voilà la règle erreur null pointeur exception ligne 576 l idee c est que soit j ai un plan d analyse qui tourne et je recupere la liste fuelprice dans le context, soit je ne suis pas dans un plan d analyse et je recupere un double param_fuelprice en param de la regle que je mets comme premier et unique element de la liste. mais apparement ca marche pas... :-( merci ! -- Sigrid LEHUTA ~ ><> ~ Doctorante Département Ecologie et Modèles pour l'Halieutique IFREMER, rue de l'ile d'Yeu BP 21105 44311 Nantes Cedex 03 Tél : +33 (0)2 40 37 41 23 (interne : 8123) package rules; import java.util.HashSet; import java.util.HashMap; import java.util.Map; import java.util.List; import java.util.ArrayList; import java.util.Arrays; import java.util.Set; import java.io.File; import java.io.Writer; import java.io.FileWriter; import java.io.BufferedWriter; import java.io.FileReader; import java.util.Collection; import java.util.Collections; import org.codelutin.util.StringUtil; import static org.codelutin.i18n.I18n._; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.codelutin.math.matrix.*; import org.codelutin.util.FileUtil; import scripts.ResultName; import scripts.RuleUtil; import scripts.SiMatrix; import fr.ifremer.isisfish.entities.EffortDescription; import fr.ifremer.isisfish.entities.Metier; import fr.ifremer.isisfish.entities.Population; import fr.ifremer.isisfish.entities.Species; import fr.ifremer.isisfish.entities.Strategy; import fr.ifremer.isisfish.entities.StrategyMonthInfo; import fr.ifremer.isisfish.entities.TargetSpecies; import fr.ifremer.isisfish.rule.AbstractRule; import fr.ifremer.isisfish.simulator.MetierMonitor; import fr.ifremer.isisfish.simulator.PopulationMonitor; import fr.ifremer.isisfish.simulator.SimulationContext; import fr.ifremer.isisfish.types.Date; import fr.ifremer.isisfish.types.Month; import fr.ifremer.isisfish.simulator.SimulationParameter; import fr.ifremer.isisfish.datastore.SimulationStorage; import fr.ifremer.isisfish.datastore.ResultStorage; /** *RUM_multinomial_Costs.java *a partir de RUM_multinomial * Created: 10/09/09 * * @author sigrid * @version $Revision: $ * * Last update: $Date: $ * by : $Author: sigrid $ */ /** * RUM utilise les RUM pour predire a chaque mois la proportion de chaque metier realisé par les pecheurs *en fonction des abondance par zone, de la biomasse totale et des VPUE realisees sur les metiers le mois *precedant et l annee precedante * ATTENTION ce code est valable si un metier n est pratiqué que dans une et une seule strategie */ public class RUM_multinomial_Costs_Anchois extends AbstractRule { /** to use log facility, just put in your code: log.info("..."); */ static private Log log = LogFactory.getLog(RUM_multinomial_Costs_Anchois.class); public Population param_pop = null; public Double param_fuelprice = 0.3411; static final protected String VPUE_O = "LandingsValueOther"; static final protected String VPUE_A = "LandingsValueAnchovy"; static final protected String INTERCEPT = "Intercept"; static final protected String EFFORT_PY = "EffortPY"; static final protected String EFFORT_PM = "EffortPM"; static final protected String EFFORT = "Effort"; static final protected String LVALUE_O = "LandingsValueOther"; static final protected String LVALUE_A = "LandingsValueAnchovy"; static final protected String BETA_O = "BetaOthers"; static final protected String BETA_A = "BetaAnchovy"; static final protected String ALPHA_O = "AlphaOthers"; static final protected String ALPHA_A = "AlphaAnchovy"; static final protected String COST = "Cost"; // To keep and export %effort / metier date File exportEffort = new File ("Effort.csv");//yv //File exportEffort = new File ("C:/these/ISIS-RUM/Simulation/Effort.csv");//yv //Load matrix of coefficients of rum //public String param_nomfichier_coeffRUM = "C:/SIGRID/work/CouplageISIS-RUM/Simulation/CoeffRum.csv";//yv public String param_nomfichier_coeffRUM0 = "Inputs_Anchois/CoeffRumMultiCost/CoeffRum0.csv"; public String param_nomfichier_coeffRUM1 = "Inputs_Anchois/CoeffRumMultiCost/CoeffRum1.csv";//yv public String param_nomfichier_coeffRUM2 = "Inputs_Anchois/CoeffRumMultiCost/CoeffRum2.csv";//yv public String param_nomfichier_coeffRUM3 = "Inputs_Anchois/CoeffRumMultiCost/CoeffRum3.csv";//yv //public String param_nomfichier_coeff = "C:/SIGRID/work/ISIS-FISH/simu/RUM/Coeff.csv"; //Load matrix of coefficients of relations Effort - Value others met other et anchovy et anchovy met other public String param_nomfichier_coeffOthers0 = "Inputs_Anchois/CoeffOthers_ssIntercept/CoeffOthers0.csv"; public String param_nomfichier_coeffOthers1 = "Inputs_Anchois/CoeffOthers_ssIntercept/CoeffOthers1.csv"; public String param_nomfichier_coeffOthers2 = "Inputs_Anchois/CoeffOthers_ssIntercept/CoeffOthers2.csv"; public String param_nomfichier_coeffOthers3 = "Inputs_Anchois/CoeffOthers_ssIntercept/CoeffOthers3.csv"; //public String param_nomfichier_coeffOthers0 = "C:/SIGRID/work/CouplageISIS-RUM/Simulation/CoeffOthers0.csv";//yv //public String param_nomfichier_coeffOthers1 = "C:/SIGRID/work/CouplageISIS-RUM/Simulation/CoeffOthers1.csv";//yv //public String param_nomfichier_coeffOthers2 = "C:/SIGRID/work/CouplageISIS-RUM/Simulation/CoeffOthers2.csv";//yv //public String param_nomfichier_coeffOthers3 = "C:/SIGRID/work/CouplageISIS-RUM/Simulation/CoeffOthers3.csv";//yv //public String param_nomfichier_coeff = "C:/SIGRID/work/ISIS-FISH/simu/RUM/CoeffOthers.csv"; public String param_nomfichier_distances0 = "Inputs_Anchois/CoeffRumMultiCost/Distances0.csv"; public String param_nomfichier_distances1 = "Inputs_Anchois/CoeffRumMultiCost/Distances1.csv"; public String param_nomfichier_distances2 = "Inputs_Anchois/CoeffRumMultiCost/Distances2.csv"; public String param_nomfichier_distances3 = "Inputs_Anchois/CoeffRumMultiCost/Distances3.csv"; protected File CoeffRum0; protected File CoeffRum1; protected File CoeffRum2; protected File CoeffRum3; protected File CoeffOthers0; protected File CoeffOthers1; protected File CoeffOthers2; protected File CoeffOthers3; protected File Distances0; protected File Distances1; protected File Distances2; protected File Distances3; protected MatrixND matrixCoeffRUM; protected MatrixND matrixCoeffOthers; protected MatrixND matrixVar; protected List<Metier> metiers; protected MatrixND matrixDistances; // interdit de faire des set sur les strategies de la map, il faut recuperer les strategies de la date courante protected Map<String , Strategy> mesStrategies; protected String [] necessaryResult = { ResultName.MATRIX_BIOMASS, ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET, ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP, ResultName.MATRIX_EFFORT_PER_STRATEGY_MET, ResultName.MATRIX_EFFORT_NOMINAL_PER_STRATEGY_MET, }; /** * @return the necessaryResult */ public String[] getNecessaryResult() { return this.necessaryResult; } /** * Permet d'afficher a l'utilisateur une aide sur la regle. * @return L'aide ou la description de la regle */ public String getDescription() { return _("calcul le temps passe sur chaque metier possible a l aide des RUM / "+ "necessite au moins 2 années de simulation / "+ "attend une matrice de coefficients du RUM / "+ "une matrice de coeff pour le calcul des valeurs des especes non décrites / "+ "exporte les pourcentages et valeurs calculés chaque mois"); } /** * Appelé au démarrage de la simulation, cette méthode permet d'initialiser * des valeurs * @param simulation La simulation pour lequel on utilise cette regle */ public void init(SimulationContext context) throws Exception { // load coefficients of rum file in a matrix if (param_nomfichier_coeffRUM0==null || "".equals(param_nomfichier_coeffRUM0)){ CoeffRum0 = FileUtil.getFile(".*.csv", "fichierRum 0 csv séparateur ';'"); CoeffRum1 = FileUtil.getFile(".*.csv", "fichierRum 1 csv séparateur ';'"); CoeffRum2 = FileUtil.getFile(".*.csv", "fichierRum 2 csv séparateur ';'"); CoeffRum3 = FileUtil.getFile(".*.csv", "fichierRum 3 csv séparateur ';'"); } else { CoeffRum0 = new File(param_nomfichier_coeffRUM0); CoeffRum1 = new File(param_nomfichier_coeffRUM1); CoeffRum2 = new File(param_nomfichier_coeffRUM2); CoeffRum3 = new File(param_nomfichier_coeffRUM3); } // load coefficients of relation others file in a matrix if (param_nomfichier_coeffOthers0==null || "".equals(param_nomfichier_coeffOthers0)){ CoeffOthers0 = FileUtil.getFile(".*.csv", "fichierOthers 0 csv séparateur ';'"); CoeffOthers1 = FileUtil.getFile(".*.csv", "fichierOthers 1 csv séparateur ';'"); CoeffOthers2 = FileUtil.getFile(".*.csv", "fichierOthers 2 csv séparateur ';'"); CoeffOthers3 = FileUtil.getFile(".*.csv", "fichierOthers 3 csv séparateur ';'"); } else { CoeffOthers0 = new File(param_nomfichier_coeffOthers0); CoeffOthers1 = new File(param_nomfichier_coeffOthers1); CoeffOthers2 = new File(param_nomfichier_coeffOthers2); CoeffOthers3 = new File(param_nomfichier_coeffOthers3); } //Load file of distances Distances0 = new File(param_nomfichier_distances0); Distances1 = new File(param_nomfichier_distances1); Distances2 = new File(param_nomfichier_distances2); Distances3 = new File(param_nomfichier_distances3); // reccuperation des metiers et strategies SiMatrix siMatrix = SiMatrix.getSiMatrix(context); metiers = siMatrix.getMetiers(new Date(0)); List<Strategy> allStrategies = siMatrix.getStrategies(new Date(0)); List <String> coeffs = Arrays.asList(new String[]{ALPHA_O,BETA_O,ALPHA_A,BETA_A}); List <String> coeffRum = Arrays.asList(new String[]{INTERCEPT, EFFORT_PY, EFFORT_PM, VPUE_O ,VPUE_A, COST}); List<Month> months = Arrays.asList(Month.MONTH); // creation de mes strategies qui ne contient pas les espagnols mesStrategies = new HashMap<String, Strategy>(); for(Strategy str : allStrategies) { mesStrategies.put(str.getName(), str); } mesStrategies.remove("Espagnols"); /*List <Strategy> mStr = new ArrayList(mesStrategies.values()); for(Strategy str : mStr){ System.out.println(str.getName());} //mesStrategies = new ArrayList(strategies.entrySet());*/ //// import des fichiers de coeff des rum [1 par strategie, metier*coeff] MatrixND matCoeffRum0 = MatrixFactory.getInstance().create( "matCoeffRum0", new List[]{ metiers,coeffRum}, new String[]{"Metiers","Coeff"}); MatrixND matCoeffRum1 = MatrixFactory.getInstance().create( "matCoeffRum1", new List[]{ metiers,coeffRum}, new String[]{"Metiers","Coeff"}); MatrixND matCoeffRum2 = MatrixFactory.getInstance().create( "matCoeffORum2", new List[]{metiers,coeffRum}, new String[]{"Metiers","Coeff"}); MatrixND matCoeffRum3 = MatrixFactory.getInstance().create( "matCoeffRum3", new List[]{metiers,coeffRum}, new String[]{"Metiers","Coeff"}); matCoeffRum0.importCSV(new FileReader(CoeffRum0),new int []{0,0}); matCoeffRum1.importCSV(new FileReader(CoeffRum1),new int []{0,0}); matCoeffRum2.importCSV(new FileReader(CoeffRum2),new int []{0,0}); matCoeffRum3.importCSV(new FileReader(CoeffRum3),new int []{0,0}); //// import des fichiers de coeff pour le calcul des valeurs non simulees [1 par strategie, metier*coeff] MatrixND matCoeffOthers0 = MatrixFactory.getInstance().create( "matCoeffOthers0", new List[]{metiers,coeffs}, new String[]{"Metiers","Coeff"}); MatrixND matCoeffOthers1 = MatrixFactory.getInstance().create( "matCoeffOthers1", new List[]{ metiers,coeffs}, new String[]{"Metiers","Coeff"}); MatrixND matCoeffOthers2 = MatrixFactory.getInstance().create( "matCoeffOthers2", new List[]{metiers,coeffs}, new String[]{"Metiers","Coeff"}); MatrixND matCoeffOthers3 = MatrixFactory.getInstance().create( "matCoeffOthers3", new List[]{metiers,coeffs}, new String[]{"Metiers","Coeff"}); matCoeffOthers0.importCSV(new FileReader(CoeffOthers0),new int []{0,0}); matCoeffOthers1.importCSV(new FileReader(CoeffOthers1),new int []{0,0}); matCoeffOthers2.importCSV(new FileReader(CoeffOthers2),new int []{0,0}); matCoeffOthers3.importCSV(new FileReader(CoeffOthers3),new int []{0,0}); //// import des distances parcourues MatrixND matDistances0 = MatrixFactory.getInstance().create( "matDistances0", new List[]{metiers,months}, new String[]{"Metiers","Month"}); MatrixND matDistances1 = MatrixFactory.getInstance().create( "matDistances1", new List[]{metiers,months}, new String[]{"Metiers","Month"}); MatrixND matDistances2 = MatrixFactory.getInstance().create( "matDistances2", new List[]{metiers,months}, new String[]{"Metiers","Month"}); MatrixND matDistances3 = MatrixFactory.getInstance().create( "matDistances3", new List[]{metiers,months}, new String[]{"Metiers","Month"}); matDistances0.importCSV(new FileReader(Distances0),new int []{0,0}); matDistances1.importCSV(new FileReader(Distances1),new int []{0,0}); matDistances2.importCSV(new FileReader(Distances2),new int []{0,0}); matDistances3.importCSV(new FileReader(Distances3),new int []{0,0}); //creation et import des matrices des coeff // RUM matrixCoeffRUM = MatrixFactory.getInstance().create( "matrixCoeffRUM", new List[]{new ArrayList(mesStrategies.values()), metiers, coeffRum}, new String[]{"Strategies","Metiers","Coeff"}); MatrixND matImportRum = MatrixFactory.getInstance().create(new int[]{14,2}); for(Strategy str : mesStrategies.values()){ for(Metier met : metiers){ for(String coeff : coeffRum){ if ("BolBasques".equals(str.getName())) { matImportRum = matCoeffRum0; }else if ("BolBretons".equals(str.getName())) { matImportRum = matCoeffRum1; }else if ("PelProfil1".equals(str.getName())) { matImportRum = matCoeffRum2; }else if ("PelProfil2".equals(str.getName())) { matImportRum = matCoeffRum3;} matrixCoeffRUM.setValue(str,met, coeff, matImportRum.getValue(met,coeff)); }// fin de for coeff }// fin de for met }// fin de for strategy // captures non simulees matrixCoeffOthers = MatrixFactory.getInstance().create( "matrixCoeffOthers", new List[]{new ArrayList(mesStrategies.values()), metiers, coeffs}, new String[]{"Strategies","Metiers","Coeff"}); MatrixND matImport = MatrixFactory.getInstance().create(new int[]{14,2}); for(Strategy str : mesStrategies.values()){ for(Metier met : metiers){ for(String coeff : coeffs){ if ("BolBasques".equals(str.getName())) { matImport = matCoeffOthers0; }else if ("BolBretons".equals(str.getName())) { matImport = matCoeffOthers1; }else if ("PelProfil1".equals(str.getName())) { matImport = matCoeffOthers2; }else if ("PelProfil2".equals(str.getName())) { matImport = matCoeffOthers3;} matrixCoeffOthers.setValue(str, met, coeff, matImport.getValue(met,coeff)); }// fin de for coeff }// fin de for met }// fin de for strategy System.out.println("matrixCoeffOthers : "+matrixCoeffOthers); System.out.println("coeff RUM: " + matrixCoeffRUM); //// Matrice des distances parcourues matrixDistances = MatrixFactory.getInstance().create( "matrixDistances", new List[]{metiers,new ArrayList(mesStrategies.values()),months}, new String[]{"Metiers","Strategies","Month"}); MatrixND matImportDist = MatrixFactory.getInstance().create(new int[]{14,12}); for(Strategy str : mesStrategies.values()){ for(Metier met : metiers){ for(Month mois : months){ if ("BolBasques".equals(str.getName())) { matImportDist = matDistances0; }else if ("BolBretons".equals(str.getName())) { matImportDist = matDistances1; }else if ("PelProfil1".equals(str.getName())) { matImportDist = matDistances2; }else if ("PelProfil2".equals(str.getName())) { matImportDist = matDistances3;} matrixDistances.setValue(met, str, mois, matImportDist.getValue(met,mois)); }// fin de for months }// fin de for met }// fin de for strategy /*for(MatrixIterator i = matrixDistances.iterator(); i.hasNext();) { i.next(); Object[] sem = i.getSemanticsCoordinates(); Strategy str = (Strategy) sem[1]; int metNum = i.getCoordinates()[0]; if("BolBasques".equals(str.getName())){ i.setValue(matDistancesprovi.getValue(metNum,0)); } else if("BolBretons".equals(str.getName())){ i.setValue(matDistancesprovi.getValue(metNum,1)); } else if("PelProfil1".equals(str.getName())){ i.setValue(matDistancesprovi.getValue(metNum,2)); } else if("PelProfil2".equals(str.getName())){ i.setValue(matDistancesprovi.getValue(metNum,3)); } }*/ }// fin de init protected Map<Date, MatrixND> allMatrixVar = new HashMap<Date, MatrixND>(); protected MatrixND getMatrixVar(Date askedDate) { MatrixND result = allMatrixVar.get(askedDate); // si on demande on matrice qui n existe pas encore : on la cree if (result == null) { MatrixND matrixVar = createMatrixVar(); allMatrixVar.put(askedDate, matrixVar); result = matrixVar; } return result; } protected MatrixND createMatrixVar (){ // Creation d'une nouvelle matrix qui n'existe pas encore ... MatrixND matrixVar = MatrixFactory.getInstance().create( "matrixVar", new List[]{new ArrayList(mesStrategies.values()), metiers, Arrays.asList(new String[]{EFFORT, LVALUE_O, LVALUE_A})}, new String[]{"Strategies","Metiers","Variables"}); return matrixVar ; } /** * ajoute a file le contenu de la matrice pour la date donnee */ protected void exportEffort(File file, Date date) throws Exception { if(date.getDate() > 0){ MatrixND mat = allMatrixVar.get(date.previous()); //mat = mat.getSubMatrix(2, EFFORT); //mat = mat.reduceDims(2); BufferedWriter out = new BufferedWriter(new FileWriter(file, true)); int d = date.previous().getDate(); /*for (MatrixIterator i = mat.iterator(); i.hasNext();) { i.next(); Object str = i.getSemanticsCoordinates()[0]; Object met = i.getSemanticsCoordinates()[1]; Object var = i.getSemanticsCoordinates()[2]; double value = i.getValue(); out.write(d + ";" + str + ";" + met + ";"+ var +";" + value); out.newLine(); }*/ List <Strategy> str = mat.getSemantics()[0]; List <Metier> met = mat.getSemantics()[1]; for(Strategy s : str){ for(Metier m : met){ double val1 = mat.getValue(s,m,0); double val2 = mat.getValue(s,m,1); double val3 = mat.getValue(s,m,2); out.write(d + ";" + s + ";" + m + ";" + val1 +";" + val2 + ";" + val3); out.newLine(); } } out.close(); } } /** * La condition qui doit etre vrai pour faire les actions * @param simulation La simulation pour lequel on utilise cette regle * @return vrai si on souhaite que les actions soit faites */ public boolean condition(SimulationContext context, Date date, Metier metier) throws Exception { boolean result = true ; return result; } /** * Si la condition est vrai alors cette action est executée avant le pas * de temps de la simulation. * @param simulation La simulation pour lequel on utilise cette regle */ boolean first = true ; public void preAction(SimulationContext context, Date date, Metier metier) throws Exception { // la préaction n est realisee qu une seule fois pour tous les metiers if (first == true){ first = false ; SiMatrix siMatrix = SiMatrix.getSiMatrix(context); ResultStorage Result = context.getSimulationStorage().getResultStorage(); MatrixND currentMatrixVar = getMatrixVar(date); List<Strategy> strategies = currentMatrixVar.getSemantics(0); List<Metier> metiers = currentMatrixVar.getSemantics(1); // 1) reccupere les landings values en anchois des metiers anchois le mois precedent if (date.getDate() != 0) { MatrixND valueMat = Result.getMatrix(date.previous(), ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET); MatrixND valuePerMet = valueMat.getSubMatrix(0, new ArrayList(mesStrategies.values()).toArray()); for(Strategy strIndex : strategies){ for(Metier metIndex : metiers){ getMatrixVar(date.previous()).setValue(strIndex,metIndex,LVALUE_A,valuePerMet.getValue(strIndex,metIndex)); } } System.out.print("MatrixVar "+ getMatrixVar(date.previous())); } MatrixND EffortNominalPerStrMet_pm = null; if (date.getDate() != 0){ //reccupere de l effort nominal par strategy met du pas de temps precedant EffortNominalPerStrMet_pm = Result.getMatrix( date.previous(), ResultName.MATRIX_EFFORT_NOMINAL_PER_STRATEGY_MET); System.out.println("EffortNominalPerStrMet_pm "+EffortNominalPerStrMet_pm); } // Boucle sur les strategies int comp = 0 ; for(Strategy strIndex : strategies){ comp += 1; System.out.println("boucle strategie "+comp); // interdit de faire des set sur les strategies de la semantique de la matrice, il faut recuperer les strategies de la date courante Strategy str = (Strategy)context.getDB().findByTopiaId(strIndex.getTopiaId()); StrategyMonthInfo smi = str.getStrategyMonthInfo(date.getMonth()); Collection<EffortDescription> strMet = str.getSetOfVessels().getPossibleMetiers() ; double effortTotStr = 0 ; if (date.getDate() != 0){ effortTotStr = EffortNominalPerStrMet_pm.getSubMatrix(0,str,1).sumOverDim(1).reduce().getValue(0); } System.out.println("effort total strategie"+ str.getName() + effortTotStr); //2) calcul les valeurs non simulees du mois précédant et des proportions d effort // liste des hypotheses... if (date.getDate() != 0){ for (EffortDescription effort : strMet){ Metier met = effort.getPossibleMetiers() ; System.out.println("Boucle metier 1, metier possible: "+met.getName()); double eff = EffortNominalPerStrMet_pm.getValue(str,met); if(effortTotStr != 0){ getMatrixVar(date.previous()).setValue(str,met,EFFORT,eff / effortTotStr); } else { getMatrixVar(date.previous()).setValue(str,met,EFFORT,0); } System.out.println("effort str"+str.getName()+met.getName()+" : "+eff); System.out.println("effortTotStr = "+ effortTotStr); System.out.println("propMet = "+ getMatrixVar(date.previous()).getValue(str,met,EFFORT)); double valOtherMetOther = 0; //yv double valAnchovyMetOther = 0; //yv double valOtherMetAnchovy = 0;//yv if ("Autre".equals(met.getName())){ if (eff != 0) { valOtherMetOther = matrixCoeffOthers.getValue(str,met,ALPHA_O) + matrixCoeffOthers.getValue(str,met,BETA_O)*eff; valAnchovyMetOther = matrixCoeffOthers.getValue(str,met,ALPHA_A) + matrixCoeffOthers.getValue(str,met,BETA_A)*eff; } getMatrixVar(date.previous()).setValue(str,met,LVALUE_O,valOtherMetOther); getMatrixVar(date.previous()).setValue(str,met,LVALUE_A,valAnchovyMetOther); System.out.println("LVALUE_O, metOther :"+getMatrixVar(date.previous()).getValue(str,met,LVALUE_O)); System.out.println("LVALUE_A, metOther :"+getMatrixVar(date.previous()).getValue(str,met,LVALUE_A)); }else { if (eff != 0) { valOtherMetAnchovy = matrixCoeffOthers.getValue(str,met,ALPHA_O) + matrixCoeffOthers.getValue(str,met,BETA_O)*eff; } getMatrixVar(date.previous()).setValue(str,met,LVALUE_O,valOtherMetAnchovy); System.out.println("LVALUE_O, metAnchovy :"+getMatrixVar(date.previous()).getValue(str,met,LVALUE_O)); } } } // 3) calcul des pourcentages d effort // a) %Effort pour la premiere année : reccuperation des pourcentages d effort du pas de temps dans la database if (date.getDate() > 11){ /*// boucle sur les met de la str for (EffortDescription effort : strMet){ Metier met = effort.getPossibleMetiers() ; System.out.println("Boucle metier 2, metier possible: "+met.getName()); getMatrixVar(date).setValue(str, met, EFFORT, smi.getProportionMetier(met)); } // b) calcul avec les RUM des pourcentages d effort du pas de temps }else{*/ // map temporaire de stoquage des valeurs de sum cum calculees pour les met de la strategie. Map<Metier, Double> tmp = new HashMap<Metier, Double>(); double tot = 0; List<Double> fuelprice ; fuelprice = (List<Double>)context.getValue("fuelPrice"); System.out.println("fuelprice avant:"+fuelprice); if (fuelprice == null){ System.out.println("oui null"+param_fuelprice); fuelprice.set(0,param_fuelprice); System.out.println("fuelprice apres:"+fuelprice); } // boucle sur les met de la str for (EffortDescription effort : strMet){ Metier met = effort.getPossibleMetiers() ; System.out.println("Boucle metier 3, metier possible: "+met.getName()); Date previousDate = date.previous(); Date previousYear = date.previousYear(); MatrixND matrixVarPreviousMonth = getMatrixVar(previousDate); MatrixND matrixVarPreviousYear = getMatrixVar(previousYear) ; double FuelPrice; if(fuelprice.size() == 0){ FuelPrice = fuelprice.get(0); }else { FuelPrice = fuelprice.get(date.getYear()); } double peff_pm = matrixVarPreviousMonth.getValue(str,met,EFFORT); double peff_py = matrixVarPreviousYear.getValue(str,met,EFFORT); double val_O = matrixVarPreviousMonth.getValue(str,met,LVALUE_O); double val_A = matrixVarPreviousMonth.getValue(str,met,LVALUE_A); double eff_pm = EffortNominalPerStrMet_pm.getValue(str,met); double Vpue_O = 0; double Vpue_A = 0; if(eff_pm != 0){ Vpue_O = val_O / eff_pm; System.out.println("vpue o :"+Vpue_O); Vpue_A = val_A / eff_pm; System.out.println("vpue a:"+ Vpue_A); } double sumCum = matrixCoeffRUM.getValue(str,met,INTERCEPT) + peff_pm * matrixCoeffRUM.getValue(str,met,EFFORT_PM)*100 + peff_py * matrixCoeffRUM.getValue(str,met,EFFORT_PY)*100 + Vpue_O * matrixCoeffRUM.getValue(str,met,VPUE_O) + Vpue_A * matrixCoeffRUM.getValue(str,met,VPUE_A) + FuelPrice * matrixDistances.getValue(met,str,date.getMonth())* matrixCoeffRUM.getValue(str,met,COST); System.out.println("tout pour le calcul peff_pm : " + peff_pm + "peff_py : "+peff_py); System.out.println("tout pour le calcul coeffs : intercept " + matrixCoeffRUM.getValue(str,met,INTERCEPT) + "pm : "+matrixCoeffRUM.getValue(str,met,EFFORT_PM) + "py : "+matrixCoeffRUM.getValue(str,met,EFFORT_PY) + "VPUEO : "+matrixCoeffRUM.getValue(str,met,VPUE_O) + "VPUEA : "+matrixCoeffRUM.getValue(str,met,VPUE_A)); System.out.println("sumCum :"+sumCum); tot += Math.exp(sumCum); tmp.put(met,Math.exp(sumCum)); } for (EffortDescription effort : strMet){ Metier met = effort.getPossibleMetiers() ; System.out.println("Boucle metier 4, metier possible: "+met.getName()); double percent = 0; if(tot != 0){ percent = tmp.get(met)/tot; } System.out.println("tmp.get(met):"+tmp.get(met)+" tot : "+tot); //getMatrixVar(date).setValue(str, met, EFFORT, percent); // attribution de la nouvelle prop pour le mois if (!context.getMetierMonitor().getForbiddenMetier().contains(met)) { smi.setProportionMetier(met,percent); System.out.println("smi set " + smi.getProportionMetier(met)); } } } } exportEffort(exportEffort, date); } } /** * Si la condition est vrai alors cette action est executée apres le pas * de temps de la simulation. * @param simulation La simulation pour lequel on utilise cette regle */ public void postAction(SimulationContext context, Date date, Metier metier) throws Exception { first = true ; } } _______________________________________________ Isis-fish-users mailing list Isis-fish-users@list.isis-fish.org http://list.isis-fish.org/cgi-bin/mailman/listinfo/isis-fish-users