Author: jcouteau Date: 2009-04-28 13:43:11 +0000 (Tue, 28 Apr 2009) New Revision: 125 Modified: trunk/rules/TailleMin.java trunk/scripts/GravityModel.java trunk/simulators/DefaultSimulator.java Log: Fin de l'adaptation aux scripts de Stephanie Modified: trunk/rules/TailleMin.java =================================================================== --- trunk/rules/TailleMin.java 2009-04-28 13:31:17 UTC (rev 124) +++ trunk/rules/TailleMin.java 2009-04-28 13:43:11 UTC (rev 125) @@ -2,27 +2,27 @@ import static org.codelutin.i18n.I18n._; +import java.util.List; + import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.codelutin.math.matrix.MatrixIterator; +import org.codelutin.math.matrix.MatrixND; import scripts.ResultName; import scripts.SiMatrix; - -import java.io.Writer; -import java.util.List; - -import org.codelutin.math.matrix.*; - +import fr.ifremer.isisfish.entities.Metier; +import fr.ifremer.isisfish.entities.MetierSeasonInfo; +import fr.ifremer.isisfish.entities.Population; +import fr.ifremer.isisfish.entities.PopulationGroup; +import fr.ifremer.isisfish.entities.Species; +import fr.ifremer.isisfish.entities.TargetSpecies; +import fr.ifremer.isisfish.rule.AbstractRule; import fr.ifremer.isisfish.simulator.PopulationMonitor; import fr.ifremer.isisfish.simulator.SimulationContext; import fr.ifremer.isisfish.types.Date; -import fr.ifremer.isisfish.entities.*; -import fr.ifremer.isisfish.rule.AbstractRule; -import fr.ifremer.isisfish.datastore.SimulationStorage; -import fr.ifremer.isisfish.datastore.ResultStorage; +import fr.ifremer.isisfish.util.Doc; -import fr.ifremer.isisfish.util.Doc; // pour pouvoir afficher une aide contextuelle (BUG#1605) - /** * TailleMin.java * @@ -43,18 +43,18 @@ /** to use log facility, just put in your code: log.info("..."); */ static private Log log = LogFactory.getLog(TailleMin.class); - @Doc(value="do the doc of param beginDate") + @Doc(value = "do the doc of param beginDate") public Date param_beginDate = new Date(0); - @Doc(value="do the doc of param endDate") + @Doc(value = "do the doc of param endDate") public Date param_endDate = new Date(119); - @Doc(value="do the doc of param species") + @Doc(value = "do the doc of param species") public Species param_species = null; - @Doc(value="do the doc of param TailleMin") + @Doc(value = "do the doc of param TailleMin") public double param_TailleMin = 27; - @Doc(value="do the doc of param propSurvie") + @Doc(value = "do the doc of param propSurvie") public double param_propSurvie = 0; - public String [] necessaryResult = { + public String[] necessaryResult = { // put here all necessary result for this rule // example: // ResultName.MATRIX_BIOMASS, @@ -67,21 +67,24 @@ /** * Permet d'afficher a l'utilisateur une aide sur la regle. + * * @return L'aide ou la description de la regle */ public String getDescription() throws Exception { // TODO return _("TODO description rule"); } - + /** * 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 + * + * @param simulation + * La simulation pour lequel on utilise cette regle */ public void init(SimulationContext context) throws Exception { } - + /** * @param context * @param date @@ -93,16 +96,19 @@ MetierSeasonInfo info = metier.getMetierSeasonInfo(date.getMonth()); TargetSpecies target = info.getSpeciesTargetSpecies(species); boolean result = target != null; - + return result; } - + /** * La condition qui doit etre vrai pour faire les actions - * @param simulation La simulation pour lequel on utilise cette regle + * + * @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 { + public boolean condition(SimulationContext context, Date date, Metier metier) + throws Exception { log.info("Recherche si la taille Minimale s'applique"); boolean result = true; if (date.before(param_beginDate)) { @@ -110,56 +116,64 @@ } else if (date.after(param_endDate)) { result = false; } else if (isCaptureDate(date, param_species, metier) != true) { - result=false; + result = false; } log.info("fin de condition TailleMin:" + result); return result; - + // fin - + /* -writeln("Recherche si la taille Minimale s'applique (oldValue="+oldValue); -var metier=p.metier; -var result = true; -if(oldValue != undefined) - result = oldValue; -else if (Regle_libUtil.isCaptureDate(p.date,p.metapop, metier)!=true) - result=false; -else if(p.date.before(p.dateDeb)) - result = false; -else if(p.date.after(p.dateFin)) - result = false; + writeln("Recherche si la taille Minimale s'applique (oldValue="+oldValue); + var metier=p.metier; + var result = true; + if(oldValue != undefined) + result = oldValue; + else if (Regle_libUtil.isCaptureDate(p.date,p.metapop, metier)!=true) + result=false; + else if(p.date.before(p.dateDeb)) + result = false; + else if(p.date.after(p.dateFin)) + result = false; -writeln("fin de condition TailleMin:"+result); -return result; -*/ + writeln("fin de condition TailleMin:"+result); + 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 + * 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 */ - public void preAction(SimulationContext context, Date date, Metier metier) throws Exception { + public void preAction(SimulationContext context, Date date, Metier metier) + throws Exception { // nothing } - + /** - * 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 + * 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 { - log.info("*$*$*$* TailleMin.actionApres:" + date + " metapop:" + param_species + " metier:" + metier); + public void postAction(SimulationContext context, Date date, Metier metier) + throws Exception { + log.info("*$*$*$* TailleMin.actionApres:" + date + " metapop:" + + param_species + " metier:" + metier); - if(isCaptureDate(date, param_species, metier)){ - log.info("*$*$*$* ok affecte capture infÃ?rieure Ã? TailleMin au rejet"); + if (isCaptureDate(date, param_species, metier)) { + log + .info("*$*$*$* ok affecte capture infÃ?rieure Ã? TailleMin au rejet"); // ATTENTION // les captures pour cette metapop ne sont plus du qu'au metier pour qui // l'espece est secondaire: elles sont affectees aux rejets - + //pb : ne se fait pas par metier //il faut une matrice pour chaques pas de temps qui stocke les rejets //par metier, par metapop et par classes d'age (comme pour les captures) @@ -169,67 +183,69 @@ PopulationMonitor popMon = context.getPopulationMonitor(); SiMatrix siMatrix = SiMatrix.getSiMatrix(context); List<Population> pops = siMatrix.getPopulations(date); - + for (Population pop : pops) { if (pop.getSpecies().equals(param_species)) { if (popMon.getDiscard(date, pop) == null) { MatrixND discard = popMon.getCatch(pop).copy(); MatrixND eff = popMon.getN(pop); - - for (MatrixIterator i=discard.iterator(); i.next();) { - Object [] coordonnees = i.getSemanticsCoordinates(); - PopulationGroup group = (PopulationGroup)coordonnees[2]; + + for (MatrixIterator i = discard.iterator(); i.next();) { + Object[] coordonnees = i.getSemanticsCoordinates(); + PopulationGroup group = (PopulationGroup) coordonnees[2]; if (group.getLength() >= param_TailleMin) { i.setValue(0); } else if (param_propSurvie > 0) { eff.setValue(coordonnees[2], coordonnees[3], - eff.getValue(coordonnees[2], coordonnees[3]) - + i.getValue() * param_propSurvie); + eff.getValue(coordonnees[2], + coordonnees[3]) + + i.getValue() + * param_propSurvie); } } - discard.setName(ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); + discard.setName(ResultName.MATRIX_DISCARDS_PER_STR_MET); popMon.addDiscard(date, pop, discard); } } } - + log.info("fin de affecterCaptureRejetTailleMin"); - - //on a affecte une fois cette meta pop au rejet il ne faut pas le refaire + + //on a affecte une fois cette meta pop au rejet il ne faut pas le refaire } // fin - + /* -writeln("*$*$*$* TailleMin.actionApres:"+p.date+" metapop:"+p.metapop+" metier:"+p.metier); -if(Regle_libUtil.isCaptureDate(p.date,p.metapop, p.metier)){ - writeln("*$*$*$* ok affecte capture infÃ?rieure Ã? TailleMin au rejet"); - // ATTENTION - // les captures pour cette metapop ne sont plus du qu'au metier pour qui - // l'espece est secondaire: elles sont affectees aux rejets + writeln("*$*$*$* TailleMin.actionApres:"+p.date+" metapop:"+p.metapop+" metier:"+p.metier); + if(Regle_libUtil.isCaptureDate(p.date,p.metapop, p.metier)){ + writeln("*$*$*$* ok affecte capture infÃ?rieure Ã? TailleMin au rejet"); + // ATTENTION + // les captures pour cette metapop ne sont plus du qu'au metier pour qui + // l'espece est secondaire: elles sont affectees aux rejets - //pb : ne se fait pas par metier - //il faut une matrice pour chaques pas de temps qui stocke les rejets - //par metier, par metapop et par classes d'age (comme pour les captures) - ////// -writeln("deb de affecterCaptureREJETTailleMin"); -var suivi = null; + //pb : ne se fait pas par metier + //il faut une matrice pour chaques pas de temps qui stocke les rejets + //par metier, par metapop et par classes d'age (comme pour les captures) + ////// + writeln("deb de affecterCaptureREJETTailleMin"); + var suivi = null; -//recherche du suivi pour les pop qui ont une certaine meta pop -for(var i=0; i< suiviePop.size(); i++){ - if(suiviePop.get(i).getPop().getMetaPopulation().equals(metapop)){ + //recherche du suivi pour les pop qui ont une certaine meta pop + for(var i=0; i< suiviePop.size(); i++){ + if(suiviePop.get(i).getPop().getMetaPopulation().equals(metapop)){ suivi = suiviePop.get(i); var populations=suivi.getPop(); - //si on a pas deja creer le rejet on le cree et on en fait un resultat + //si on a pas deja creer le rejet on le cree et on en fait un resultat var matRejet = suivi.getRejet(date); if (matRejet==null){ var matRejetBis = MatrixFactory.create(suivi.getCapture()); var eff=suivi.getN(); -//on encapsule les objets des 4 dimensions de la matrice capture + //on encapsule les objets des 4 dimensions de la matrice capture for (var iiterateur=matRejetBis.iterator();iiterateur.next();){ var coordonnees=iiterateur.getSemanticsCoordinates(); var classe=coordonnees[2]; @@ -243,18 +259,18 @@ matRejetBis.setName("Rejet par metier"); suivi.addRejet(date,matRejetBis); } - } -} + } + } -writeln("fin de affecterCaptureRejetTailleMin"); + writeln("fin de affecterCaptureRejetTailleMin"); - //on a affecte une fois cette meta pop au rejet il ne faut pas le refaire -} + //on a affecte une fois cette meta pop au rejet il ne faut pas le refaire + } -return p.gestionMetier; -*/ + return p.gestionMetier; + */ } } Modified: trunk/scripts/GravityModel.java =================================================================== --- trunk/scripts/GravityModel.java 2009-04-28 13:31:17 UTC (rev 124) +++ trunk/scripts/GravityModel.java 2009-04-28 13:43:11 UTC (rev 125) @@ -31,7 +31,6 @@ package scripts; -import static org.codelutin.i18n.I18n._; import static org.codelutin.i18n.I18n.n_; import java.util.Collection; @@ -58,17 +57,16 @@ import fr.ifremer.isisfish.types.Month; import fr.ifremer.isisfish.types.TimeUnit; - /** * @author poussin - * + * */ public class GravityModel { /** to use log facility, just put in your code: log.info("..."); */ static private Log log = LogFactory.getLog(GravityModel.class); - + protected SimulationContext context = null; protected TopiaContext db = null; protected SiMatrix siMatrix = null; @@ -76,20 +74,24 @@ /** * Method used to get GravityModel used for simulation - * @param context context simulation + * + * @param context + * context simulation * @return GravityModel or null if no GravityModel created for simulation */ public static GravityModel getGravityModel(SimulationContext context) { - GravityModel result = (GravityModel)context.getValue(GravityModel.class.getName()); + GravityModel result = (GravityModel) context + .getValue(GravityModel.class.getName()); return result; } - - private static void setGravityModel(SimulationContext context, GravityModel gravityModel) { + + private static void setGravityModel(SimulationContext context, + GravityModel gravityModel) { context.setValue(GravityModel.class.getName(), gravityModel); } - - - public GravityModel(SimulationContext context, SiMatrix siMatrix) throws TopiaException, StorageException{ + + public GravityModel(SimulationContext context, SiMatrix siMatrix) + throws TopiaException, StorageException { this.context = context; this.db = context.getDB(); this.resultManager = context.getSimulationStorage().getResultStorage(); @@ -105,82 +107,85 @@ // MatrixFishingTimePerMonthPerVessel ////////////////////////////////////////////////////////////////////// - public MatrixND matrixFishingTimePerMonthPerVessel(Date date) throws TopiaException{ + public MatrixND matrixFishingTimePerMonthPerVessel(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); MatrixND result = MatrixFactory.getInstance().create( ResultName.MATRIX_FISHING_TIME_PER_MONTH_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); double value = fishingTimePerMonthPerVessel(str, metier, date); result.setValue(str, metier, value); } } - -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = fishingTimePerMonthPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = fishingTimePerMonthPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } + return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * FishingTimePerMonthPerVessel[str,met,month] = FishingTimePerTrip[str,met,month]NbTripsPerMonth[str,month] - + * FishingTimePerMonthPerVessel[str,met,month] = + * FishingTimePerTrip[str,met,month]NbTripsPerMonth[str,month] + * * @param str * @param metier * @param date * @return */ - private double fishingTimePerMonthPerVessel(Strategy str, Metier metier, Date date) { - Month month = date.getMonth(); - double timePerTrip = siMatrix.fishingTimePerTrip(str, metier, date); - double nbTrip = str.getStrategyMonthInfo(month).getNumberOfTrips(); - return timePerTrip * nbTrip; - } + private double fishingTimePerMonthPerVessel(Strategy str, Metier metier, + Date date) { + Month month = date.getMonth(); + double timePerTrip = siMatrix.fishingTimePerTrip(str, metier, date); + double nbTrip = str.getStrategyMonthInfo(month).getNumberOfTrips(); + return timePerTrip * nbTrip; + } - ////////////////////////////////////////////////////////////////////// // matrixFuelCostsOfTravelPerVessel ////////////////////////////////////////////////////////////////////// - public MatrixND matrixFuelCostsOfTravelPerVessel(Date date) throws TopiaException{ + public MatrixND matrixFuelCostsOfTravelPerVessel(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); MatrixND result = MatrixFactory.getInstance().create( ResultName.MATRIX_FUEL_COSTS_OF_TRAVEL_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); double value = fuelCostsOfTravelPerVessel(str, metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = fuelCostsOfTravelPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = fuelCostsOfTravelPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } @@ -188,20 +193,23 @@ /** * implant� suivant document ModifTable3PourBP25-07-2006.doc * FuelCostsOfTravelPerVessel[sov,met,month]�=�NbTripsPerMonth[str,month]*TravelTimePerTrip[sov,met,month]*UnitFuelCostsOfTravel[vt] - * + * * @param str * @param metier * @param date * @return */ - private double fuelCostsOfTravelPerVessel(Strategy str, Metier metier, Date date) { + private double fuelCostsOfTravelPerVessel(Strategy str, Metier metier, + Date date) { Month month = date.getMonth(); double nbTrip = str.getStrategyMonthInfo(month).getNumberOfTrips(); Collection<Zone> zone = metier.getMetierSeasonInfo(month).getZone(); // TODO: verifier que travelTime est bien en heure, car le unitFuelCost est l'unite par heure - double travelTime = siMatrix.travelTimePerTrip(str.getSetOfVessels(), zone); - double unitFuelCost = str.getSetOfVessels().getVesselType().getUnitFuelCostOfTravel(); + double travelTime = siMatrix.travelTimePerTrip(str.getSetOfVessels(), + zone); + double unitFuelCost = str.getSetOfVessels().getVesselType() + .getUnitFuelCostOfTravel(); return nbTrip * travelTime * unitFuelCost; } @@ -210,94 +218,101 @@ // matrixCostsOfFishingPerVessel ////////////////////////////////////////////////////////////////////// - public MatrixND matrixCostsOfFishingPerVessel(Date date) throws TopiaException{ + public MatrixND matrixCostsOfFishingPerVessel(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); MatrixND result = MatrixFactory.getInstance().create( ResultName.MATRIX_COSTS_OF_FISHING_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); double value = costsOfFishingPerVessel(str, metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = costsOfFishingPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = costsOfFishingPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * CostsOfFishingPerVessel[str,met,month]= FishingTimePerMonthPerVessel [str,met,month] {NbFishingOperationsPerDay[sov,met] UnitCostsOfFishing[sov,met] / 24} + * CostsOfFishingPerVessel[str,met,month]= FishingTimePerMonthPerVessel + * [str,met,month] {NbFishingOperationsPerDay[sov,met] + * UnitCostsOfFishing[sov,met] / 24} * * @param str * @param metier * @param date * @return */ - private double costsOfFishingPerVessel(Strategy str, Metier metier, Date date) { + private double costsOfFishingPerVessel(Strategy str, Metier metier, + Date date) { double fishingTime = fishingTimePerMonthPerVessel(str, metier, date); - EffortDescription effort = str.getSetOfVessels().getPossibleMetiers(metier); + EffortDescription effort = str.getSetOfVessels().getPossibleMetiers( + metier); int nbOperation = 0; double unitCostOfFishing = 0; - if(effort != null){ + if (effort != null) { nbOperation = effort.getFishingOperation(); unitCostOfFishing = effort.getUnitCostOfFishing(); } - return fishingTime * ( nbOperation * unitCostOfFishing / TimeUnit.HOUR_PER_DAY); + return fishingTime + * (nbOperation * unitCostOfFishing / TimeUnit.HOUR_PER_DAY); } ////////////////////////////////////////////////////////////////////// // matrixFuelCostsPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixFuelCostsPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixFuelCostsPerVessel(Date date) throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); MatrixND result = MatrixFactory.getInstance().create( ResultName.MATRIX_FUEL_COSTS_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); double value = fuelCostsPerVessel(str, metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = fuelCostsPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = fuelCostsPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * FuelCostsPerVessel[str,met,month] = FuelCostsOfTravelPerVessel [sov,met,month] + CostsOfFishingPerVessel [str,met,month] + * FuelCostsPerVessel[str,met,month] = FuelCostsOfTravelPerVessel + * [sov,met,month] + CostsOfFishingPerVessel [str,met,month] * * @param str * @param metier @@ -314,52 +329,57 @@ ////////////////////////////////////////////////////////////////////// // matrixRepairAndMaintenanceGearCostsPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixRepairAndMaintenanceGearCostsPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixRepairAndMaintenanceGearCostsPerVessel(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); MatrixND result = MatrixFactory.getInstance().create( ResultName.MATRIX_REPAIR_AND_MAINTENANCE_GEAR_COSTS_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); - double value = repairAndMaintenanceGearCostsPerVessel(str, metier, date); + double value = repairAndMaintenanceGearCostsPerVessel(str, + metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = repairAndMaintenanceGearCostsPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = repairAndMaintenanceGearCostsPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * RepairAndMaintenanceGearCostsPerVessel[str,met,month]�=�FishingTimePerMonthPerVessel[str,met,month] *RepairAndMaintenanceGearCostsPerDay[sov,met]/NbHoursPerDay + * RepairAndMaintenanceGearCostsPerVessel[str,met,month]�=�FishingTimePerMonthPerVessel[str,met,month] + * *RepairAndMaintenanceGearCostsPerDay[sov,met]/NbHoursPerDay * * @param str * @param metier * @param date * @return */ - private double repairAndMaintenanceGearCostsPerVessel(Strategy str, Metier metier, Date date) { + private double repairAndMaintenanceGearCostsPerVessel(Strategy str, + Metier metier, Date date) { double fishingTime = fishingTimePerMonthPerVessel(str, metier, date); - EffortDescription effort = str.getSetOfVessels().getPossibleMetiers(metier); + EffortDescription effort = str.getSetOfVessels().getPossibleMetiers( + metier); double repair = 0; - if(effort != null){ + if (effort != null) { repair = effort.getRepairAndMaintenanceGearCost(); } // FIXME verifier qu'il faut bien retourner 0, si pas d'effort @@ -369,52 +389,56 @@ ////////////////////////////////////////////////////////////////////// // matrixOtherRunningCostsPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixOtherRunningCostsPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixOtherRunningCostsPerVessel(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); MatrixND result = MatrixFactory.getInstance().create( ResultName.MATRIX_OTHER_RUNNING_COSTS_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); double value = otherRunningCostsPerVessel(str, metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = otherRunningCostsPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = otherRunningCostsPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * OtherRunningCostsPerVessel[str,met,month]=�FishingTimePerMonthPerVessel[str,met,month]*OtherRunningCostsPerDay[sov,met]/ NbHoursPerDay + * OtherRunningCostsPerVessel[str,met,month]=�FishingTimePerMonthPerVessel[str,met,month]*OtherRunningCostsPerDay[sov,met]/ + * NbHoursPerDay * * @param str * @param metier * @param date * @return */ - private double otherRunningCostsPerVessel(Strategy str, Metier metier, Date date) { + private double otherRunningCostsPerVessel(Strategy str, Metier metier, + Date date) { double fishingTime = fishingTimePerMonthPerVessel(str, metier, date); - EffortDescription effort = str.getSetOfVessels().getPossibleMetiers(metier); + EffortDescription effort = str.getSetOfVessels().getPossibleMetiers( + metier); double otherCosts = 0; - if(effort != null){ + if (effort != null) { otherCosts = effort.getOtherRunningCost(); } // FIXME verifier qu'il faut bien retourner 0, si pas d'effort @@ -424,156 +448,170 @@ ////////////////////////////////////////////////////////////////////// // matrixSharedNotFixedCostsPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixSharedNotFixedCostsPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixSharedNotFixedCostsPerVessel(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); MatrixND result = MatrixFactory.getInstance().create( ResultName.MATRIX_SHARED_NOT_FIXED_COSTS_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); double value = sharedNotFixedCostsPerVessel(str, metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = sharedNotFixedCostsPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = sharedNotFixedCostsPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * SharedNotFixedCostsPerVessel[str,met,month]=�FuelCostsPerVessel[str,met,month] +�OtherRunningCostsPerVessel[str,met,month] - * + * SharedNotFixedCostsPerVessel[str,met,month]=�FuelCostsPerVessel[str,met,month] + * +�OtherRunningCostsPerVessel[str,met,month] + * * @param str * @param metier * @param date * @return */ - private double sharedNotFixedCostsPerVessel(Strategy str, Metier metier, Date date) { + private double sharedNotFixedCostsPerVessel(Strategy str, Metier metier, + Date date) { double fuelCostsPerVessel = fuelCostsPerVessel(str, metier, date); - double otherRunningCostsPerVessel = otherRunningCostsPerVessel(str, metier, date); + double otherRunningCostsPerVessel = otherRunningCostsPerVessel(str, + metier, date); return fuelCostsPerVessel + otherRunningCostsPerVessel; - } + } ////////////////////////////////////////////////////////////////////// // matrixSharedFixedCostsPerVesselPerMet ////////////////////////////////////////////////////////////////////// -// Supprime avec Steph le 20070227 -// public MatrixND matrixSharedFixedCostsPerVesselPerMet(Date date) throws TopiaException{ -// List<Strategy> strategies = siMatrix.getStrategies(date); -// -// MatrixND result = MatrixFactory.getInstance().create( -// ResultName.MATRIX_SHARED_FIXED_COSTS_PER_VESSEL_PER_MET, -// new List[]{strategies}, -// new String[]{n_("Strategies")}); -// -// for (int s=0; s < strategies.size(); s++) { -// Strategy str = strategies.get(s); -// double value = sharedFixedCostsPerVesselPerMet(str, date); -// result.setValue(s, value); -// } -//// for(Strategy str : strategies){ -//// double value = sharedFixedCostsPerVesselPerMet(str, date); -//// result.setValue(str, value); -//// } -// -// return result; -// } -// -// /** -// * implant� suivant document ModifTable3PourBP25-07-2006.doc -// * SharedFixedCostsPerVesselPerMet [str,month]=FixedCostsPerMonth[sov]/NbMet[sov] -// * -// * @param str -// * @param date -// * @return -// */ -// private double sharedFixedCostsPerVesselPerMet(Strategy str, Date date) { -// SetOfVessels sov = str.getSetOfVessels(); -// double fixedCosts = sov.getFixedCosts(); -// int nbMet = sov.sizePossibleMetiers(); -// -// return fixedCosts / (double)nbMet; -// } + // Supprime avec Steph le 20070227 + // public MatrixND matrixSharedFixedCostsPerVesselPerMet(Date date) throws TopiaException{ + // List<Strategy> strategies = siMatrix.getStrategies(date); + // + // MatrixND result = MatrixFactory.getInstance().create( + // ResultName.MATRIX_SHARED_FIXED_COSTS_PER_VESSEL_PER_MET, + // new List[]{strategies}, + // new String[]{n_("Strategies")}); + // + // for (int s=0; s < strategies.size(); s++) { + // Strategy str = strategies.get(s); + // double value = sharedFixedCostsPerVesselPerMet(str, date); + // result.setValue(s, value); + // } + //// for(Strategy str : strategies){ + //// double value = sharedFixedCostsPerVesselPerMet(str, date); + //// result.setValue(str, value); + //// } + // + // return result; + // } + // + // /** + // * implant� suivant document ModifTable3PourBP25-07-2006.doc + // * SharedFixedCostsPerVesselPerMet [str,month]=FixedCostsPerMonth[sov]/NbMet[sov] + // * + // * @param str + // * @param date + // * @return + // */ + // private double sharedFixedCostsPerVesselPerMet(Strategy str, Date date) { + // SetOfVessels sov = str.getSetOfVessels(); + // double fixedCosts = sov.getFixedCosts(); + // int nbMet = sov.sizePossibleMetiers(); + // + // return fixedCosts / (double)nbMet; + // } ////////////////////////////////////////////////////////////////////// // matrixGrossValueOfLandingsPerSpeciesPerStrategyMet ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixGrossValueOfLandingsPerSpeciesPerStrategyMet(Date date) throws TopiaException{ + public MatrixND matrixGrossValueOfLandingsPerSpeciesPerStrategyMet(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); List<Population> pops = siMatrix.getPopulations(date); - MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_SPECIES_PER_STRATEGY_MET, - new List[]{strategies, metiers, pops}, - new String[]{n_("Strategies"), n_("Metiers"), n_("Populations")}); + MatrixND result = MatrixFactory + .getInstance() + .create( + ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_SPECIES_PER_STRATEGY_MET, + new List[] { strategies, metiers, pops }, + new String[] { n_("Strategies"), n_("Metiers"), + n_("Populations") }); - for (int p=0; p < pops.size(); p++) { + for (int p = 0; p < pops.size(); p++) { Population pop = pops.get(p); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); - double value = grossValueOfLandingsPerSpeciesPerStrategyMet(str, metier, pop, date); + double value = grossValueOfLandingsPerSpeciesPerStrategyMet( + str, metier, pop, date); result.setValue(str, metier, pop, value); } } } -// for(Population pop : pops){ -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = grossValueOfLandingsPerSpeciesPerStrategyMet(str, metier, pop, date); -// result.setValue(str, metier, pop, value); -// } -// } -// } + // for(Population pop : pops){ + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = grossValueOfLandingsPerSpeciesPerStrategyMet(str, metier, pop, date); + // result.setValue(str, metier, pop, value); + // } + // } + // } return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * GrossValueOfLandingsPerSpeciesPerStrategyMet[str,met,pop,month]�=�sum over classes_cl of [PricePerKg(pop,cl, t)* (CatchWeightPerStrategyMet [str,met,pop,cl,month] ?DiscardsWeightPerStrategyMet [str,met,pop,cl,mo -nth] - * GrossValueOfLandingsPerSpeciesPerStrategyMet[str,met,pop,month] = sum over classes_cl of [PricePerKg(pop,cl, t)* (CatchWeightPerStrategyMet [str,met,pop,cl,month] -DiscardsWeightPerStrategyMet [str,met,pop,cl,mo -nth])] - * + * GrossValueOfLandingsPerSpeciesPerStrategyMet[str,met,pop,month]�=�sum + * over classes_cl of [PricePerKg(pop,cl, t)* (CatchWeightPerStrategyMet + * [str,met,pop,cl,month] ?DiscardsWeightPerStrategyMet [str,met,pop,cl,mo + * nth] GrossValueOfLandingsPerSpeciesPerStrategyMet[str,met,pop,month] = + * sum over classes_cl of [PricePerKg(pop,cl, t)* (CatchWeightPerStrategyMet + * [str,met,pop,cl,month] -DiscardsWeightPerStrategyMet [str,met,pop,cl,mo + * nth])] + * * @param str * @param metier * @param pop * @param date * @return */ - private double grossValueOfLandingsPerSpeciesPerStrategyMet(Strategy str, Metier metier, Population pop, Date date) { + private double grossValueOfLandingsPerSpeciesPerStrategyMet(Strategy str, + Metier metier, Population pop, Date date) { List<PopulationGroup> groups = pop.getPopulationGroup(); double result = 0; - for(PopulationGroup group : groups){ + for (PopulationGroup group : groups) { double price = group.getPrice(); Collection<Zone> zones = pop.getPopulationZone(); - for(Zone zone : zones){ - double catchWeight = getCatchWeightPerStrMetPerZonePop(str, metier, group, zone, date); - double discardsWeight = getDiscardsWeightPerStrMet(str, metier, group, zone, date); + for (Zone zone : zones) { + double catchWeight = getCatchWeightPerStrMetPerZonePop(str, + metier, group, zone, date); + double discardsWeight = getDiscardsWeightPerStrMet(str, metier, + group, zone, date); // FIXME demander/verifier que ce le bon calcule result += price * (catchWeight - discardsWeight); } @@ -589,10 +627,12 @@ * @param date * @return */ - private double getCatchWeightPerStrMetPerZonePop(Strategy str, Metier metier, PopulationGroup group, Zone zone, Date date) { - MatrixND mat = resultManager.getMatrix(date, group.getPopulation(), ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP); - double result = 0; - if(mat != null){ + private double getCatchWeightPerStrMetPerZonePop(Strategy str, + Metier metier, PopulationGroup group, Zone zone, Date date) { + MatrixND mat = resultManager.getMatrix(date, group.getPopulation(), + ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET); + double result = 0; + if (mat != null) { result = mat.getValue(str, metier, group, zone); } return result; @@ -606,10 +646,12 @@ * @param date * @return */ - private double getDiscardsWeightPerStrMet(Strategy str, Metier metier, PopulationGroup group, Zone zone, Date date) { - MatrixND mat = resultManager.getMatrix(date, group.getPopulation(), ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET_PER_ZONE_POP); - double result = 0; - if(mat != null){ + private double getDiscardsWeightPerStrMet(Strategy str, Metier metier, + PopulationGroup group, Zone zone, Date date) { + MatrixND mat = resultManager.getMatrix(date, group.getPopulation(), + ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET); + double result = 0; + if (mat != null) { result = mat.getValue(str, metier, group, zone); } return result; @@ -618,33 +660,35 @@ ////////////////////////////////////////////////////////////////////// // matrixGrossValueOfLandingsPerStrategyMet ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixGrossValueOfLandingsPerStrategyMet(Date date) throws TopiaException{ + + public MatrixND matrixGrossValueOfLandingsPerStrategyMet(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); MatrixND result = MatrixFactory.getInstance().create( ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); - double value = grossValueOfLandingsPerStrategyMet(str, metier, date); + double value = grossValueOfLandingsPerStrategyMet(str, metier, + date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = grossValueOfLandingsPerStrategyMet(str, metier, date); -// result.setValue(str, metier, value); -// } -// } - + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = grossValueOfLandingsPerStrategyMet(str, metier, date); + // result.setValue(str, metier, value); + // } + // } + return result; } @@ -653,14 +697,16 @@ * @param metier * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double grossValueOfLandingsPerStrategyMet(Strategy str, Metier metier, Date date) throws TopiaException { + private double grossValueOfLandingsPerStrategyMet(Strategy str, + Metier metier, Date date) throws TopiaException { List<Population> pops = siMatrix.getPopulations(date); double result = 0; - for(int i=0; i<pops.size(); i++){ - Population pop = (Population)pops.get(i); - result += grossValueOfLandingsPerSpeciesPerStrategyMet(str, metier, pop, date); + for (int i = 0; i < pops.size(); i++) { + Population pop = (Population) pops.get(i); + result += grossValueOfLandingsPerSpeciesPerStrategyMet(str, metier, + pop, date); } return result; } @@ -668,87 +714,97 @@ ////////////////////////////////////////////////////////////////////// // matrixGrossValueOfLandingsPerStrategyMetPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixGrossValueOfLandingsPerStrategyMetPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixGrossValueOfLandingsPerStrategyMetPerVessel(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); - MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + MatrixND result = MatrixFactory + .getInstance() + .create( + ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET_PER_VESSEL, + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); - double value = grossValueOfLandingsPerStrategyMetPerVessel(str, metier, date); + double value = grossValueOfLandingsPerStrategyMetPerVessel(str, + metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = grossValueOfLandingsPerStrategyMetPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = grossValueOfLandingsPerStrategyMetPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * GrossValueOfLandingsPerStrategyMetPerVessel[str,met,month]�= GrossValueOfLandingsPerStrategyMet[str,met,month]�/[PropNbVessels(str,sov)*NbVesselsSetOfVessels(sov)] + * GrossValueOfLandingsPerStrategyMetPerVessel[str,met,month]�= + * GrossValueOfLandingsPerStrategyMet[str,met,month]�/[PropNbVessels(str,sov)*NbVesselsSetOfVessels(sov)] * * @param str * @param metier * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double grossValueOfLandingsPerStrategyMetPerVessel(Strategy str, Metier metier, Date date) throws TopiaException { - double grossValueOfLandingsPerStrategyMet = grossValueOfLandingsPerStrategyMet(str, metier, date); + private double grossValueOfLandingsPerStrategyMetPerVessel(Strategy str, + Metier metier, Date date) throws TopiaException { + double grossValueOfLandingsPerStrategyMet = grossValueOfLandingsPerStrategyMet( + str, metier, date); // FIXME verifier que c bien cette donn�e qu'il faut utiliser dans le doc: PropNbVessels(str, sov) double proportionSetOfVessels = str.getProportionSetOfVessels(); double numberOfVessels = str.getSetOfVessels().getNumberOfVessels(); - double grossValueOfLandingsOtherSpeciesPerStrategyMet = grossValueOfLandingsOtherSpeciesPerStrategyMet(str,metier,date); + double grossValueOfLandingsOtherSpeciesPerStrategyMet = grossValueOfLandingsOtherSpeciesPerStrategyMet( + str, metier, date); - - return (grossValueOfLandingsPerStrategyMet + grossValueOfLandingsOtherSpeciesPerStrategyMet) / (proportionSetOfVessels * numberOfVessels); + return (grossValueOfLandingsPerStrategyMet + grossValueOfLandingsOtherSpeciesPerStrategyMet) + / (proportionSetOfVessels * numberOfVessels); } ////////////////////////////////////////////////////////////////////// // matrixNetValueOfLandingsPerStrategyMet ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixNetValueOfLandingsPerStrategyMet(Date date) throws TopiaException{ + + public MatrixND matrixNetValueOfLandingsPerStrategyMet(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); MatrixND result = MatrixFactory.getInstance().create( ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); - double value = netValueOfLandingsPerStrategyMet(str, metier, date); + double value = netValueOfLandingsPerStrategyMet(str, metier, + date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = netValueOfLandingsPerStrategyMet(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = netValueOfLandingsPerStrategyMet(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } @@ -761,61 +817,70 @@ * @param metier * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double netValueOfLandingsPerStrategyMet(Strategy str, Metier metier, Date date) throws TopiaException { - double grossValue = grossValueOfLandingsPerStrategyMet(str, metier, date); - EffortDescription effort = str.getSetOfVessels().getPossibleMetiers(metier); + private double netValueOfLandingsPerStrategyMet(Strategy str, + Metier metier, Date date) throws TopiaException { + double grossValue = grossValueOfLandingsPerStrategyMet(str, metier, + date); + EffortDescription effort = str.getSetOfVessels().getPossibleMetiers( + metier); double landingCost = 1; // FIXME demander si le metier n'a pas d'effort s'il faut que landingCost soit bien a 1 - if(effort != null){ + if (effort != null) { landingCost -= effort.getLandingCosts(); } - double grossValueOfLandingsOtherSpeciesPerStrategyMet = grossValueOfLandingsOtherSpeciesPerStrategyMet(str,metier,date); - - double result = (grossValue + grossValueOfLandingsOtherSpeciesPerStrategyMet)* landingCost; + double grossValueOfLandingsOtherSpeciesPerStrategyMet = grossValueOfLandingsOtherSpeciesPerStrategyMet( + str, metier, date); + + double result = (grossValue + grossValueOfLandingsOtherSpeciesPerStrategyMet) + * landingCost; return result; - } + } - private double grossValueOfLandingsOtherSpeciesPerStrategyMet(Strategy str, Metier metier, Date date) throws TopiaException { + private double grossValueOfLandingsOtherSpeciesPerStrategyMet(Strategy str, + Metier metier, Date date) throws TopiaException { // FIXME evaluer l'equation dans suivant le doc des equations return 0; } - + ////////////////////////////////////////////////////////////////////// // matrixNetValueOfLandingsPerStrategyMetPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixNetValueOfLandingsPerStrategyMetPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixNetValueOfLandingsPerStrategyMetPerVessel(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); - MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + MatrixND result = MatrixFactory + .getInstance() + .create( + ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET_PER_VESSEL, + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); - double value = netValueOfLandingsPerStrategyMetPerVessel(str, metier, date); + double value = netValueOfLandingsPerStrategyMetPerVessel(str, + metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = netValueOfLandingsPerStrategyMetPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = netValueOfLandingsPerStrategyMetPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } - /** * implant� suivant document ModifTable3PourBP25-07-2006.doc @@ -825,104 +890,118 @@ * @param metier * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double netValueOfLandingsPerStrategyMetPerVessel(Strategy str, Metier metier, Date date) throws TopiaException { - double netValueOfLandingsPerStrategyMet = netValueOfLandingsPerStrategyMet(str, metier, date); + private double netValueOfLandingsPerStrategyMetPerVessel(Strategy str, + Metier metier, Date date) throws TopiaException { + double netValueOfLandingsPerStrategyMet = netValueOfLandingsPerStrategyMet( + str, metier, date); // FIXME verifier que c bien cette donn�e qu'il faut utiliser dans le doc: PropNbVessels(str, sov) double proportionSetOfVessels = str.getProportionSetOfVessels(); double numberOfVessels = str.getSetOfVessels().getNumberOfVessels(); - return netValueOfLandingsPerStrategyMet / (proportionSetOfVessels * numberOfVessels); + return netValueOfLandingsPerStrategyMet + / (proportionSetOfVessels * numberOfVessels); } ////////////////////////////////////////////////////////////////////// // matrixNetRenevueToSharePerStrategyMetPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixNetRenevueToSharePerStrategyMetPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixNetRenevueToSharePerStrategyMetPerVessel(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); - MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_NET_RENEVUE_TO_SHARE_PER_STRATEGY_MET_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + MatrixND result = MatrixFactory + .getInstance() + .create( + ResultName.MATRIX_NET_RENEVUE_TO_SHARE_PER_STRATEGY_MET_PER_VESSEL, + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); - double value = netRenevueToSharePerStrategyMetPerVessel(str, metier, date); + double value = netRenevueToSharePerStrategyMetPerVessel(str, + metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = netRenevueToSharePerStrategyMetPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = netRenevueToSharePerStrategyMetPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * NetRevenueToSharePerStrategyMetPerVessel[str,met,month]�=�NetValueOfLandingsPerStrategyMetPerVessel[str,met,month]�-�SharedNotFixedCostsPerVessel [str,met,month]*PropStr(str,met,month) - SharedFixedCostsPerVessel -PerMet[str,month] - * + * NetRevenueToSharePerStrategyMetPerVessel[str,met,month]�=�NetValueOfLandingsPerStrategyMetPerVessel[str,met,month]�-�SharedNotFixedCostsPerVessel + * [str,met,month]*PropStr(str,met,month) - SharedFixedCostsPerVessel + * PerMet[str,month] + * * @param str * @param metier * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double netRenevueToSharePerStrategyMetPerVessel(Strategy str, Metier metier, Date date) throws TopiaException { - double netRenevueToSharePerStrategyMetPerVessel = netValueOfLandingsPerStrategyMetPerVessel(str, metier, date); - double sharedNotFixedCostsPerVessel = sharedNotFixedCostsPerVessel(str, metier, date); - double propStr = str.getStrategyMonthInfo(date.getMonth()).getProportionMetier(metier); + private double netRenevueToSharePerStrategyMetPerVessel(Strategy str, + Metier metier, Date date) throws TopiaException { + double netRenevueToSharePerStrategyMetPerVessel = netValueOfLandingsPerStrategyMetPerVessel( + str, metier, date); + double sharedNotFixedCostsPerVessel = sharedNotFixedCostsPerVessel(str, + metier, date); + double propStr = str.getStrategyMonthInfo(date.getMonth()) + .getProportionMetier(metier); - double result = netRenevueToSharePerStrategyMetPerVessel - sharedNotFixedCostsPerVessel * propStr; + double result = netRenevueToSharePerStrategyMetPerVessel + - sharedNotFixedCostsPerVessel * propStr; return result; } ////////////////////////////////////////////////////////////////////// // matrixCrewSharePerStrategyMetPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixCrewSharePerStrategyMetPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixCrewSharePerStrategyMetPerVessel(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); MatrixND result = MatrixFactory.getInstance().create( ResultName.MATRIX_CREW_SHARE_PER_STRATEGY_MET_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); - double value = crewSharePerStrategyMetPerVessel(str, metier, date); + double value = crewSharePerStrategyMetPerVessel(str, metier, + date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = crewSharePerStrategyMetPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = crewSharePerStrategyMetPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } - /** * implant� suivant document ModifTable3PourBP25-07-2006.doc * CrewSharePerStrategyMetPerVessel[str,met,month]�=�NetRevenueToSharePerStrategyMetPerVessel[str,met,month]*CrewShareRate[sov,met] @@ -931,170 +1010,200 @@ * @param metier * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double crewSharePerStrategyMetPerVessel(Strategy str, Metier metier, Date date) throws TopiaException { - double netRenevueToShare = netRenevueToSharePerStrategyMetPerVessel(str, metier, date); + private double crewSharePerStrategyMetPerVessel(Strategy str, + Metier metier, Date date) throws TopiaException { + double netRenevueToShare = netRenevueToSharePerStrategyMetPerVessel( + str, metier, date); - EffortDescription effort = str.getSetOfVessels().getPossibleMetiers(metier); + EffortDescription effort = str.getSetOfVessels().getPossibleMetiers( + metier); double crewShareRate = 0; - if(effort != null){ + if (effort != null) { crewShareRate = effort.getCrewShareRate(); } // FIXME verifier qu'il faut bien retourner 0, si pas d'effort return netRenevueToShare * crewShareRate; - } + } ////////////////////////////////////////////////////////////////////// // matrixOwnerMarginOverVariableCostsPerStrategyMetPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixOwnerMarginOverVariableCostsPerStrategyMetPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixOwnerMarginOverVariableCostsPerStrategyMetPerVessel( + Date date) throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); - MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_MET_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + MatrixND result = MatrixFactory + .getInstance() + .create( + ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_MET_PER_VESSEL, + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); - double value = ownerMarginOverVariableCostsPerStrategyMetPerVessel(str, metier, date); + double value = ownerMarginOverVariableCostsPerStrategyMetPerVessel( + str, metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = ownerMarginOverVariableCostsPerStrategyMetPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = ownerMarginOverVariableCostsPerStrategyMetPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } - /** - * implant� suivant document ModifTable3PourBP25-07-2006.doc - * OwnerMarginOverVariableCostsPerStrategyMetPerVessel[str,met,month] = NetRevenueToSharePerStrategyMetPerVessel[str,met,month]�- CrewSharePerStrategyMetPerVessel[str,met,month]�- RepairAndMaintenanceGearCostsPerVes -sel[str,met,month]�* PropStr(str,met,month) + * implant� suivant document ModifTable3PourBP25-07-2006.doc + * OwnerMarginOverVariableCostsPerStrategyMetPerVessel[str,met,month] = + * NetRevenueToSharePerStrategyMetPerVessel[str,met,month]�- + * CrewSharePerStrategyMetPerVessel[str,met,month]�- + * RepairAndMaintenanceGearCostsPerVes sel[str,met,month]�* + * PropStr(str,met,month) * * @param str * @param metier * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double ownerMarginOverVariableCostsPerStrategyMetPerVessel(Strategy str, Metier metier, Date date) throws TopiaException { - double netRenevueToShare = netRenevueToSharePerStrategyMetPerVessel(str, metier, date); + private double ownerMarginOverVariableCostsPerStrategyMetPerVessel( + Strategy str, Metier metier, Date date) throws TopiaException { + double netRenevueToShare = netRenevueToSharePerStrategyMetPerVessel( + str, metier, date); double crewShare = crewSharePerStrategyMetPerVessel(str, metier, date); - double repair = repairAndMaintenanceGearCostsPerVessel(str, metier, date); - double propStr = str.getStrategyMonthInfo(date.getMonth()).getProportionMetier(metier); + double repair = repairAndMaintenanceGearCostsPerVessel(str, metier, + date); + double propStr = str.getStrategyMonthInfo(date.getMonth()) + .getProportionMetier(metier); return netRenevueToShare - crewShare - repair * propStr; - } + } - ////////////////////////////////////////////////////////////////////// // matrixVesselMarginOverVariableCostsPerStrategyMetPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixVesselMarginOverVariableCostsPerStrategyMetPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixVesselMarginOverVariableCostsPerStrategyMetPerVessel( + Date date) throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); List<Metier> metiers = siMatrix.getMetiers(date); - MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_MET_PER_VESSEL, - new List[]{strategies, metiers}, - new String[]{n_("Strategies"), n_("Metiers")}); + MatrixND result = MatrixFactory + .getInstance() + .create( + ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_MET_PER_VESSEL, + new List[] { strategies, metiers }, + new String[] { n_("Strategies"), n_("Metiers") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); metiers = siMatrix.getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { + for (int m = 0; m < metiers.size(); m++) { Metier metier = metiers.get(m); - double value = vesselMarginOverVariableCostsPerStrategyMetPerVessel(str, metier, date); + double value = vesselMarginOverVariableCostsPerStrategyMetPerVessel( + str, metier, date); result.setValue(str, metier, value); } } -// for(Strategy str : strategies){ -// metiers = siMatrix.getMetiers(str, date); -// for(Metier metier : metiers) { -// double value = vesselMarginOverVariableCostsPerStrategyMetPerVessel(str, metier, date); -// result.setValue(str, metier, value); -// } -// } + // for(Strategy str : strategies){ + // metiers = siMatrix.getMetiers(str, date); + // for(Metier metier : metiers) { + // double value = vesselMarginOverVariableCostsPerStrategyMetPerVessel(str, metier, date); + // result.setValue(str, metier, value); + // } + // } return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * VesselMarginOverVariableCostsPerStrategyMetPerVessel�[str,met,month]�=NetRevenueToSharePerStrategyMetPerVessel[str,met,month]- RepairAndMaintenanceGearCostsPerVessel [str,met,month]�* PropStr(str,met,month) + * VesselMarginOverVariableCostsPerStrategyMetPerVessel�[str,met,month]�=NetRevenueToSharePerStrategyMetPerVessel[str,met,month]- + * RepairAndMaintenanceGearCostsPerVessel [str,met,month]�* + * PropStr(str,met,month) * * @param str * @param metier * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double vesselMarginOverVariableCostsPerStrategyMetPerVessel(Strategy str, Metier metier, Date date) throws TopiaException { - double netRenevueToShare = netRenevueToSharePerStrategyMetPerVessel(str, metier, date); - double repair = repairAndMaintenanceGearCostsPerVessel(str, metier, date); - double propStr = str.getStrategyMonthInfo(date.getMonth()).getProportionMetier(metier); + private double vesselMarginOverVariableCostsPerStrategyMetPerVessel( + Strategy str, Metier metier, Date date) throws TopiaException { + double netRenevueToShare = netRenevueToSharePerStrategyMetPerVessel( + str, metier, date); + double repair = repairAndMaintenanceGearCostsPerVessel(str, metier, + date); + double propStr = str.getStrategyMonthInfo(date.getMonth()) + .getProportionMetier(metier); return netRenevueToShare - repair * propStr; - } - + } + ////////////////////////////////////////////////////////////////////// // matrixOwnerMarginOverVariableCostsPerStrategyPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixOwnerMarginOverVariableCostsPerStrategyPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixOwnerMarginOverVariableCostsPerStrategyPerVessel( + Date date) throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); - MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_PER_VESSEL, - new List[]{strategies}, - new String[]{n_("Strategies")}); + MatrixND result = MatrixFactory + .getInstance() + .create( + ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_PER_VESSEL, + new List[] { strategies }, + new String[] { n_("Strategies") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); - double value = ownerMarginOverVariableCostsPerStrategyPerVessel(str, date); + double value = ownerMarginOverVariableCostsPerStrategyPerVessel( + str, date); result.setValue(s, value); } -// for(Strategy str : strategies){ -// double value = ownerMarginOverVariableCostsPerStrategyPerVessel(str, date); -// result.setValue(str, value); -// } + // for(Strategy str : strategies){ + // double value = ownerMarginOverVariableCostsPerStrategyPerVessel(str, date); + // result.setValue(str, value); + // } return result; } - + /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * OwnerMarginOverVariableCostsPerStrategyPerVessel[str,month]�=�somme sur tous les m�tiers de OwnerMarginOverVariableCostsPerStrategyMetPerVessel [str,met,month] + * OwnerMarginOverVariableCostsPerStrategyPerVessel[str,month]�=�somme sur + * tous les m�tiers de OwnerMarginOverVariableCostsPerStrategyMetPerVessel + * [str,met,month] * * @param str * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double ownerMarginOverVariableCostsPerStrategyPerVessel(Strategy str, Date date) throws TopiaException { + private double ownerMarginOverVariableCostsPerStrategyPerVessel( + Strategy str, Date date) throws TopiaException { SetOfVessels sov = str.getSetOfVessels(); Collection<EffortDescription> efforts = sov.getPossibleMetiers(); float result = 0; - + for (EffortDescription effort : efforts) { Metier metier = effort.getPossibleMetiers(); - result += ownerMarginOverVariableCostsPerStrategyMetPerVessel(str, metier, date); + result += ownerMarginOverVariableCostsPerStrategyMetPerVessel(str, + metier, date); } return result; } @@ -1102,24 +1211,27 @@ ////////////////////////////////////////////////////////////////////// // matrixOwnerMarginOverVariableCostsPerStrategy ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixOwnerMarginOverVariableCostsPerStrategy(Date date) throws TopiaException{ + + public MatrixND matrixOwnerMarginOverVariableCostsPerStrategy(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); - MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY, - new List[]{strategies}, - new String[]{n_("Strategies")}); + MatrixND result = MatrixFactory + .getInstance() + .create( + ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY, + new List[] { strategies }, + new String[] { n_("Strategies") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); double value = ownerMarginOverVariableCostsPerStrategy(str, date); result.setValue(s, value); } -// for(Strategy str : strategies){ -// double value = ownerMarginOverVariableCostsPerStrategy(str, date); -// result.setValue(str, value); -// } + // for(Strategy str : strategies){ + // double value = ownerMarginOverVariableCostsPerStrategy(str, date); + // result.setValue(str, value); + // } return result; } @@ -1131,51 +1243,61 @@ * @param str * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double ownerMarginOverVariableCostsPerStrategy(Strategy str, Date date) throws TopiaException { - double ownerMarginOverVariableCostsPerStrategyPerVessel = ownerMarginOverVariableCostsPerStrategyPerVessel(str, date); + private double ownerMarginOverVariableCostsPerStrategy(Strategy str, + Date date) throws TopiaException { + double ownerMarginOverVariableCostsPerStrategyPerVessel = ownerMarginOverVariableCostsPerStrategyPerVessel( + str, date); double proportionSetOfVessels = str.getProportionSetOfVessels(); double numberOfVessels = str.getSetOfVessels().getNumberOfVessels(); - return ownerMarginOverVariableCostsPerStrategyPerVessel * (proportionSetOfVessels * numberOfVessels); - } + return ownerMarginOverVariableCostsPerStrategyPerVessel + * (proportionSetOfVessels * numberOfVessels); + } ////////////////////////////////////////////////////////////////////// // matrixVesselMarginOverVariableCostsPerStrategyPerVessel ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixVesselMarginOverVariableCostsPerStrategyPerVessel(Date date) throws TopiaException{ + + public MatrixND matrixVesselMarginOverVariableCostsPerStrategyPerVessel( + Date date) throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); - MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_PER_VESSEL, - new List[]{strategies}, - new String[]{n_("Strategies")}); + MatrixND result = MatrixFactory + .getInstance() + .create( + ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_PER_VESSEL, + new List[] { strategies }, + new String[] { n_("Strategies") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); - double value = vesselMarginOverVariableCostsPerStrategyPerVessel(str, date); + double value = vesselMarginOverVariableCostsPerStrategyPerVessel( + str, date); result.setValue(s, value); } -// for(Strategy str : strategies){ -// double value = vesselMarginOverVariableCostsPerStrategyPerVessel(str, date); -// result.setValue(str, value); -// } + // for(Strategy str : strategies){ + // double value = vesselMarginOverVariableCostsPerStrategyPerVessel(str, date); + // result.setValue(str, value); + // } return result; } - + /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * VesselMarginOverVariableCostsPerStrategyPerVessel[str,month]�= somme sur tous les m�tiers de VesselMarginOverVariableCostsPerStrategyMetPerVessel� [str,met,month] + * VesselMarginOverVariableCostsPerStrategyPerVessel[str,month]�= somme sur + * tous les m�tiers de VesselMarginOverVariableCostsPerStrategyMetPerVessel� + * [str,met,month] * * @param str * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double vesselMarginOverVariableCostsPerStrategyPerVessel(Strategy str, Date date) throws TopiaException { + private double vesselMarginOverVariableCostsPerStrategyPerVessel( + Strategy str, Date date) throws TopiaException { SetOfVessels sov = str.getSetOfVessels(); Collection<EffortDescription> efforts = sov.getPossibleMetiers(); @@ -1183,74 +1305,83 @@ for (EffortDescription effort : efforts) { Metier metier = effort.getPossibleMetiers(); - result += vesselMarginOverVariableCostsPerStrategyMetPerVessel(str, metier, date); + result += vesselMarginOverVariableCostsPerStrategyMetPerVessel(str, + metier, date); } return result; - } + } - ////////////////////////////////////////////////////////////////////// // matrixVesselMarginOverVariableCostsPerStrategy ////////////////////////////////////////////////////////////////////// - - public MatrixND matrixVesselMarginOverVariableCostsPerStrategy(Date date) throws TopiaException{ + + public MatrixND matrixVesselMarginOverVariableCostsPerStrategy(Date date) + throws TopiaException { List<Strategy> strategies = siMatrix.getStrategies(date); - MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY, - new List[]{strategies}, - new String[]{n_("Strategies")}); + MatrixND result = MatrixFactory + .getInstance() + .create( + ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY, + new List[] { strategies }, + new String[] { n_("Strategies") }); - for (int s=0; s < strategies.size(); s++) { + for (int s = 0; s < strategies.size(); s++) { Strategy str = strategies.get(s); double value = vesselMarginOverVariableCostsPerStrategy(str, date); result.setValue(s, value); } -// for(Strategy str : strategies){ -// double value = vesselMarginOverVariableCostsPerStrategy(str, date); -// result.setValue(str, value); -// } + // for(Strategy str : strategies){ + // double value = vesselMarginOverVariableCostsPerStrategy(str, date); + // result.setValue(str, value); + // } return result; } /** * implant� suivant document ModifTable3PourBP25-07-2006.doc - * VesselMarginOverVariableCostsPerStrategy[str,month]�=VesselMarginOverVariableCostsPerStrategyPerVessel�[str,month] *[PropNbVessels(str,sov)*NbVesselsSetOfVessels(sov)] + * VesselMarginOverVariableCostsPerStrategy[str,month]�=VesselMarginOverVariableCostsPerStrategyPerVessel�[str,month] + * *[PropNbVessels(str,sov)*NbVesselsSetOfVessels(sov)] * * @param str * @param date * @return - * @throws TopiaException + * @throws TopiaException */ - private double vesselMarginOverVariableCostsPerStrategy(Strategy str, Date date) throws TopiaException { - double vesselMarginOverVariableCostsPerStrategyPerVessel = vesselMarginOverVariableCostsPerStrategyPerVessel(str, date); + private double vesselMarginOverVariableCostsPerStrategy(Strategy str, + Date date) throws TopiaException { + double vesselMarginOverVariableCostsPerStrategyPerVessel = vesselMarginOverVariableCostsPerStrategyPerVessel( + str, date); double proportionSetOfVessels = str.getProportionSetOfVessels(); double numberOfVessels = str.getSetOfVessels().getNumberOfVessels(); - return vesselMarginOverVariableCostsPerStrategyPerVessel * (proportionSetOfVessels * numberOfVessels); + return vesselMarginOverVariableCostsPerStrategyPerVessel + * (proportionSetOfVessels * numberOfVessels); } - /////////////////////////////////////////////////////////////////////////// // // Methode non utilis�e directement dans GravityModel, mais dans les rules // /////////////////////////////////////////////////////////////////////////// - public double valuePerUnitFishingEffort(Strategy str, Metier metier, Date date) throws TopiaException{ - List<Population> pops = siMatrix.getPopulations(date); + public double valuePerUnitFishingEffort(Strategy str, Metier metier, + Date date) throws TopiaException { + List<Population> pops = siMatrix.getPopulations(date); - double result = 0; + double result = 0; - for(Population pop : pops){ + for (Population pop : pops) { List<PopulationGroup> groups = pop.getPopulationGroup(); Collection<Zone> zones = pop.getPopulationZone(); - for(PopulationGroup group : groups){ + for (PopulationGroup group : groups) { double price = group.getPrice(); - for(Zone zone : zones){ - double catchValue = getCatchWeightPerStrMetPerZonePop(str, metier, group, zone, date); - double discards = getDiscardsWeightPerStrMet(str, metier, group, zone, date); + for (Zone zone : zones) { + double catchValue = getCatchWeightPerStrMetPerZonePop(str, + metier, group, zone, date); + double discards = getDiscardsWeightPerStrMet(str, metier, + group, zone, date); result += price * (catchValue - discards); } } @@ -1258,7 +1389,7 @@ double effort = getEffortPerStrategyMet(str, metier, date); - if(effort == 0){ + if (effort == 0) { result = 0; } else { result = result / effort; @@ -1274,28 +1405,32 @@ * @return */ public double getEffortPerStrategyMet(Strategy str, Metier metier, Date date) { - MatrixND mat = resultManager.getMatrix(date, ResultName.MATRIX_EFFORT_PER_STRATEGY_MET); + MatrixND mat = resultManager.getMatrix(date, + ResultName.MATRIX_EFFORT_PER_STRATEGY_MET); double result = 0; - if(mat != null){ + if (mat != null) { result = mat.getValue(str, metier); } return result; } - public double landingPerUnitFishingEffort(Strategy str, Metier metier, Date date) throws TopiaException{ + public double landingPerUnitFishingEffort(Strategy str, Metier metier, + Date date) throws TopiaException { List<Population> pops = siMatrix.getPopulations(date); double effort = getEffortPerStrategyMet(str, metier, date); double result = 0; - if(effort != 0){ // s'il n'y a pas d'effort on retournera 0 - for(Population pop : pops){ + if (effort != 0) { // s'il n'y a pas d'effort on retournera 0 + for (Population pop : pops) { List<PopulationGroup> groups = pop.getPopulationGroup(); Collection<Zone> zones = pop.getPopulationZone(); - for(PopulationGroup group : groups){ - for(Zone zone : zones){ - double catchValue = getCatchWeightPerStrMetPerZonePop(str, metier, group, zone, date); - double discards = getDiscardsWeightPerStrMet(str, metier, group, zone, date); + for (PopulationGroup group : groups) { + for (Zone zone : zones) { + double catchValue = getCatchWeightPerStrMetPerZonePop( + str, metier, group, zone, date); + double discards = getDiscardsWeightPerStrMet(str, + metier, group, zone, date); result += catchValue - discards; } } @@ -1307,5 +1442,3 @@ } } - - Modified: trunk/simulators/DefaultSimulator.java =================================================================== --- trunk/simulators/DefaultSimulator.java 2009-04-28 13:31:17 UTC (rev 124) +++ trunk/simulators/DefaultSimulator.java 2009-04-28 13:43:11 UTC (rev 125) @@ -34,7 +34,6 @@ import static org.codelutin.i18n.I18n._; import static org.codelutin.i18n.I18n.n_; -import java.util.Collection; import java.util.List; import org.apache.commons.logging.Log; @@ -52,8 +51,6 @@ import fr.ifremer.isisfish.entities.Metier; import fr.ifremer.isisfish.entities.Population; import fr.ifremer.isisfish.entities.PopulationSeasonInfo; -import fr.ifremer.isisfish.entities.Strategy; -import fr.ifremer.isisfish.entities.Zone; import fr.ifremer.isisfish.rule.Rule; import fr.ifremer.isisfish.simulator.MetierMonitor; import fr.ifremer.isisfish.simulator.PopulationMonitor; @@ -68,11 +65,11 @@ /** * @author poussin - * + * */ public class DefaultSimulator implements Simulator { - + /** to use log facility, just put in your code: log.info("..."); */ static private Log log = LogFactory.getLog(DefaultSimulator.class); @@ -81,31 +78,32 @@ */ public void simulate(SimulationContext context) throws Exception { - SimulationParameter param = context.getSimulationStorage().getParameter(); + SimulationParameter param = context.getSimulationStorage() + .getParameter(); SimulationControl control = context.getSimulationControl(); int lastYear = param.getNumberOfYear(); int lastDate = lastYear * Month.NUMBER_OF_MONTH; Date date = control.getDate(); - + ResultManager resManager = context.getResultManager(); TopiaContext db = context.getDB(); - + SiMatrix siMatrix = SiMatrix.getSiMatrix(context); GravityModel gravityModel = new GravityModel(context, siMatrix); - + PopulationMonitor populationMonitor = context.getPopulationMonitor(); MetierMonitor metierMonitor = context.getMetierMonitor(); RuleMonitor ruleMonitor = context.getRuleMonitor(); - + List<Population> allpops = siMatrix.getPopulations(date); populationMonitor.init(allpops); - + for (Population pop : allpops) { MatrixND N = param.getNumberOf(pop); N.setName(ResultName.MATRIX_ABUNDANCE); populationMonitor.setN(pop, N); } - + // // Rule initialisation // @@ -113,14 +111,16 @@ control.setText("Rules initialisation:" + rules); for (Rule rule : rules) { rule.init(context); - log.info("Rule " +rule.getClass().getSimpleName()+ " initialized"); + log + .info("Rule " + rule.getClass().getSimpleName() + + " initialized"); } - + // // Commit all change done un init rules methods. // context.getDB().commitTransaction(); - + // // Simulation loop // @@ -131,14 +131,14 @@ if (control.isStopSimulationRequest()) { break; } - + control.setDate(date); control.setProgress(date.getDate()); control.setText(_("begin step " + date)); - + // raz des metiers interdits et des licences metierMonitor.clear(); - + if (date.getMonth().equals(Month.JANUARY)) { populationMonitor.clearCatch(); } @@ -147,17 +147,18 @@ if (siMatrix.getStrategies(date).size() > 0) { if (resManager.isEnabled(ResultName.MATRIX_NO_ACTIVITY)) { MatrixND mat = metierMonitor.getOrCreateNoActivity(date, - ResultName.MATRIX_NO_ACTIVITY, - siMatrix.getStrategies(date), - siMatrix.getMetiers(date)); + ResultName.MATRIX_NO_ACTIVITY, siMatrix + .getStrategies(date), siMatrix + .getMetiers(date)); resManager.addResult(date, mat); } } - + // // Rule condition evaluation // - control.setText("Evalute Rules conditions ("+rules.size()+" rules)"); + control.setText("Evalute Rules conditions (" + rules.size() + + " rules)"); for (Rule rule : rules) { for (Metier metier : siMatrix.getMetiers(date)) { boolean active = false; @@ -165,30 +166,34 @@ active = rule.condition(context, date, metier); } catch (Exception eee) { if (log.isWarnEnabled()) { - log.warn("Can't evaluate rule condition for: " + rule, eee); + log.warn("Can't evaluate rule condition for: " + + rule, eee); } } - ruleMonitor.setEvaluationCondition(date, rule, metier, active); + ruleMonitor.setEvaluationCondition(date, rule, metier, + active); if (active) { - log.info("Activate rule: " + rule.getClass().getSimpleName()); + log.info("Activate rule: " + + rule.getClass().getSimpleName()); resManager.addActiveRule(date, rule); } } } - + // // Rule pre action // control.setText("Do pre action Rules"); for (Rule rule : rules) { for (Metier metier : siMatrix.getMetiers(date)) { - boolean condition = ruleMonitor.getEvalutionCondition(date, rule, metier); + boolean condition = ruleMonitor.getEvalutionCondition(date, + rule, metier); if (condition) { rule.preAction(context, date, metier); } } } - + // // Keep modification's information done in rule // @@ -196,7 +201,7 @@ MatrixND metierZone = siMatrix.getMetierZone(date); resManager.addResult(date, metierZone); } - + // // Simulate one step for all pop // @@ -204,40 +209,45 @@ for (Population pop : siMatrix.getPopulations(date)) { computeMonth(context, siMatrix, date, pop); } - + // // Add some result not population dependante // - + // only if there are one or more strategy if (siMatrix.getStrategies(date).size() > 0) { control.setText("Add some results"); - if (resManager.isEnabled(ResultName.MATRIX_EFFORT_PER_STRATEGY_MET)) { - MatrixND effortPerStrategyMet = siMatrix.matrixEffortPerStrategyMet(date); + if (resManager + .isEnabled(ResultName.MATRIX_EFFORT_PER_STRATEGY_MET)) { + MatrixND effortPerStrategyMet = siMatrix + .matrixEffortPerStrategyMet(date); resManager.addResult(date, effortPerStrategyMet); } - - if (resManager.isEnabled(ResultName.MATRIX_STD_TRAVEL_EFFORT_PER_STRATEGY_MET)) { - MatrixND stdTravelEffortPerStrategyMet = siMatrix.matrixEffortPerStrategyMet(date); + + if (resManager + .isEnabled(ResultName.MATRIX_STD_TRAVEL_EFFORT_PER_STRATEGY_MET)) { + MatrixND stdTravelEffortPerStrategyMet = siMatrix + .matrixEffortPerStrategyMet(date); resManager.addResult(date, stdTravelEffortPerStrategyMet); } - + if (resManager.isEnabled(ResultName.MATRIX_EFFORT_PER_ZONE_POP)) { - MatrixND effortPerZonePop = siMatrix.matrixEffortPerStrategyMet(date); + MatrixND effortPerZonePop = siMatrix + .matrixEffortPerStrategyMet(date); resManager.addResult(date, effortPerZonePop); - } + } - // // Add economics results // - if (!"false".equalsIgnoreCase(param.getTagValue().get("ecoResult"))) { + if (!"false".equalsIgnoreCase(param.getTagValue().get( + "ecoResult"))) { control.setText("Add economics results"); saveGravityModel(date, resManager, gravityModel); } } - + // // Add economics results // @@ -248,8 +258,6 @@ } } - - // // Rule post action // @@ -274,18 +282,25 @@ MatrixND discard = populationMonitor.getDiscard(date, pop); if (discard != null || date.getDate() == 0) { // force discard for the first month to have discard in result if (discard == null) { - discard = MatrixFactory.getInstance().create(ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP, - new List[]{siMatrix.getStrategies(date), - siMatrix.getMetiers(date), - pop.getPopulationGroup(), - pop.getPopulationZone()}, - new String[]{n_("Strategies"), n_("Metiers"), n_("Groups"), n_("Zones")}); + discard = MatrixFactory.getInstance().create( + ResultName.MATRIX_DISCARDS_PER_STR_MET, + new List[] { siMatrix.getStrategies(date), + siMatrix.getMetiers(date), + pop.getPopulationGroup(), + pop.getPopulationZone() }, + new String[] { n_("Strategies"), + n_("Metiers"), n_("Groups"), + n_("Zones") }); } resManager.addResult(date, pop, discard); - if (resManager.isEnabled(ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET_PER_ZONE_POP)) { - MatrixND discardWeightPerStrategyMet = siMatrix.matrixDiscardWeightPerStrategyMetPerZonePop(pop, date, discard); - resManager.addResult(date, pop, discardWeightPerStrategyMet); + if (resManager + .isEnabled(ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET)) { + MatrixND discardWeightPerStrategyMet = siMatrix + .matrixDiscardWeightPerStrategyMetPerZonePop( + pop, date, discard); + resManager.addResult(date, pop, + discardWeightPerStrategyMet); } } @@ -294,7 +309,8 @@ // add landing result // if (resManager.isEnabled(ResultName.MATRIX_LANDING_PER_MET)) { - MatrixND landing = MatrixFactory.getInstance().create(populationMonitor.getCatch(pop)); + MatrixND landing = MatrixFactory.getInstance().create( + populationMonitor.getCatch(pop)); if (discard != null) { landing = landing.minus(discard); } @@ -309,14 +325,14 @@ // control.setText("Rollback rules changes"); db.rollbackTransaction(); - + // // commit result // control.setText("Commit results"); TopiaContext tx = context.getDbResult(); tx.commitTransaction(); - + // // Go next step // @@ -330,45 +346,50 @@ return result; } - protected void computeMonth(SimulationContext context, SiMatrix siMatrix, Date date, Population pop) throws IsisFishException, TopiaException { + protected void computeMonth(SimulationContext context, SiMatrix siMatrix, + Date date, Population pop) throws IsisFishException, TopiaException { // to add result - ResultStorage resManager = context.getSimulationStorage().getResultStorage(); + ResultStorage resManager = context.getSimulationStorage() + .getResultStorage(); PopulationMonitor popMon = context.getPopulationMonitor(); MatrixND N = popMon.getN(pop); - + if (log.isInfoEnabled()) { - log.info("====================== begin "+ date + " - " + pop +" =========================== " + System.currentTimeMillis()); + log.info("====================== begin " + date + " - " + pop + + " =========================== " + + System.currentTimeMillis()); log.info("N: " + N); } - + // add N and biomass result now, before computation // N is reassigned during computation - resManager.addResult(date, pop, N); + resManager.addResult(date, pop, N); if (resManager.isEnabled(ResultName.MATRIX_BIOMASS)) { MatrixND biomass = siMatrix.matrixBiomass(N, pop, date); resManager.addResult(date, pop, biomass); } - + Month month = date.getMonth(); PopulationSeasonInfo info = pop.getPopulationSeasonInfo(month); - + // group change MatrixND CA = null; if (date.getDate() == 0) { - CA = MatrixFactory.getInstance().matrixId(pop.sizePopulationGroup()*pop.sizePopulationZone()); + CA = MatrixFactory.getInstance().matrixId( + pop.sizePopulationGroup() * pop.sizePopulationZone()); } else { CA = info.getGroupChangeMatrix(month); } log.debug("CA: " + CA); - + //migration - MatrixND M = info.getMigrationMatrix(month, N); + MatrixND M = info.getMigrationMatrix(month, N); log.debug("M: " + M); //emigration - MatrixND EM = info.getEmigrationMatrix(month, N); + MatrixND EM = info.getEmigrationMatrix(month, N); log.debug("EM: " + EM); //immigration MatrixND IM = info.getImmigrationMatrix(month, N).transpose(); @@ -382,9 +403,9 @@ MatrixND tmp1 = M.minus(EM); MatrixND tmp2 = tmp0.mult(tmp1); MatrixND tmp3 = tmp2.add(IM); - + log.debug("N1D after mig: " + tmp3); - + // On reconvertie en une matrice Semantique N = pop.split2D(tmp3); @@ -393,32 +414,32 @@ //Recrutement MatrixND R = info.getReproductionMatrix(month, N); log.debug("R: " + R); - + // ajout de la matrice R dans le suivi de la pop comme etant // la reproduction pour le mois courant. popMon.setReproduction(date, pop, R); - + // recrutement MatrixND recruitment = popMon.getRecruitment(date, pop); log.debug("recruitment: " + recruitment); - + // mortalite de la reproduction popMon.applyReproductionMortality(pop); - + N = N.add(recruitment); log.debug("N after recru: " + N); - if (resManager.isEnabled(ResultName.MATRIX_ABONDANCE_BEGIN_MONTH)) { - MatrixND abondanceBM = siMatrix.matrixAbondanceBeginMonth(N, pop, date); + if (resManager.isEnabled(ResultName.MATRIX_ABUNDANCE)) { + MatrixND abondanceBM = siMatrix.matrixAbondanceBeginMonth(N, pop, + date); resManager.addResult(date, pop, abondanceBM); } - if (resManager.isEnabled(ResultName.MATRIX_BIOMASS_BEGIN_MONTH)) { + if (resManager.isEnabled(ResultName.MATRIX_BIOMASS)) { MatrixND biomassBM = siMatrix.matrixBiomassBeginMonth(N, pop, date); resManager.addResult(date, pop, biomassBM); } - MatrixND abundance = N; // compute fishing matrix only if there are one or more strategy if (siMatrix.getStrategies(date).size() > 0) { @@ -429,153 +450,193 @@ if (isEffortByCell(context)) { abundance = siMatrix.matrixAbundance(N, pop, date); - catchPerStrategyMetPerZonePop = - siMatrix.matrixCatchPerStrategyMetPerZonePop(N, pop, date); + catchPerStrategyMetPerZonePop = siMatrix + .matrixCatchPerStrategyMetPerZonePop(N, pop, date); } else { // en zone - MatrixND matrixFishingMortality = siMatrix.matrixFishingMortality(date, pop); + MatrixND matrixFishingMortality = siMatrix + .matrixFishingMortality(date, pop); resManager.addResult(date, pop, matrixFishingMortality); - - abundance = siMatrix.matrixAbundance(N, pop, date, matrixFishingMortality); + abundance = siMatrix.matrixAbundance(N, pop, date, + matrixFishingMortality); + // this matrix is necessary for matrixCatchPerStrategyMet - MatrixND catchRatePerStrategyMet = siMatrix.matrixCatchRatePerStrategyMetPerZone(pop, date, matrixFishingMortality); + MatrixND catchRatePerStrategyMet = siMatrix + .matrixCatchRatePerStrategyMetPerZone(pop, date, + matrixFishingMortality); resManager.addResult(date, pop, catchRatePerStrategyMet); - catchPerStrategyMetPerZonePop = - siMatrix.matrixCatchPerStrategyMetPerZone(N, pop, date, catchRatePerStrategyMet); + catchPerStrategyMetPerZonePop = siMatrix + .matrixCatchPerStrategyMetPerZone(N, pop, date, + catchRatePerStrategyMet); } - + popMon.holdCatch(pop, catchPerStrategyMetPerZonePop); resManager.addResult(date, pop, catchPerStrategyMetPerZonePop); - - if (resManager.isEnabled(ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP)) { - MatrixND catchWeightPerStrategyMet = - siMatrix.matrixCatchWeightPerStrategyMetPerZonePop(date, pop, - catchPerStrategyMetPerZonePop); + + if (resManager + .isEnabled(ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET)) { + MatrixND catchWeightPerStrategyMet = siMatrix + .matrixCatchWeightPerStrategyMetPerZonePop(date, pop, + catchPerStrategyMetPerZonePop); resManager.addResult(date, pop, catchWeightPerStrategyMet); } if (isEffortByCell(context)) { - MatrixND catchPerStrategyMetPerZoneMet = - siMatrix.matrixCatchPerStrategyMetPerZoneMet(N, pop, date); + MatrixND catchPerStrategyMetPerZoneMet = siMatrix + .matrixCatchPerStrategyMetPerZoneMet(N, pop, date); resManager.addResult(date, pop, catchPerStrategyMetPerZoneMet); - if (resManager.isEnabled(ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_MET)) { - MatrixND catchWeightPerStrategyMet = - siMatrix.matrixCatchWeightPerStrategyMetPerZoneMet(date, pop, - catchPerStrategyMetPerZoneMet); + if (resManager + .isEnabled(ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET)) { + MatrixND catchWeightPerStrategyMet = siMatrix + .matrixCatchWeightPerStrategyMetPerZoneMet(date, + pop, catchPerStrategyMetPerZoneMet); resManager.addResult(date, pop, catchWeightPerStrategyMet); } } - - + } else { // no strategies // compute only if fishing mortality =0 to apply Natural Mortality abundance = siMatrix.matrixAbundanceSsF(N, pop, date); } log.debug("abundance: " + abundance); - + // Keep new N popMon.setN(pop, abundance); - log.debug("====================== end " + date + " - " + pop +" ==========================="); - + log.debug("====================== end " + date + " - " + pop + + " ==========================="); + } - + /** * @param date * @param resManager - * @throws IsisFishException - * @throws TopiaException + * @throws IsisFishException + * @throws TopiaException */ - private void saveGravityModel(Date date, ResultManager resManager, GravityModel gravityModel) throws IsisFishException, TopiaException { - if (resManager.isEnabled(ResultName.MATRIX_FISHING_TIME_PER_MONTH_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixFishingTimePerMonthPerVessel(date); + private void saveGravityModel(Date date, ResultManager resManager, + GravityModel gravityModel) throws IsisFishException, TopiaException { + if (resManager + .isEnabled(ResultName.MATRIX_FISHING_TIME_PER_MONTH_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixFishingTimePerMonthPerVessel(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_FUEL_COSTS_OF_TRAVEL_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixFuelCostsOfTravelPerVessel(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_FUEL_COSTS_OF_TRAVEL_PER_VESSEL)) { + MatrixND mat = gravityModel.matrixFuelCostsOfTravelPerVessel(date); resManager.addResult(date, mat); - } + } if (resManager.isEnabled(ResultName.MATRIX_COSTS_OF_FISHING_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixCostsOfFishingPerVessel(date); + MatrixND mat = gravityModel.matrixCostsOfFishingPerVessel(date); resManager.addResult(date, mat); - } + } if (resManager.isEnabled(ResultName.MATRIX_FUEL_COSTS_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixFuelCostsOfTravelPerVessel(date); + MatrixND mat = gravityModel.matrixFuelCostsOfTravelPerVessel(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_REPAIR_AND_MAINTENANCE_GEAR_COSTS_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixRepairAndMaintenanceGearCostsPerVessel(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_REPAIR_AND_MAINTENANCE_GEAR_COSTS_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixRepairAndMaintenanceGearCostsPerVessel(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_OTHER_RUNNING_COSTS_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixOtherRunningCostsPerVessel(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_OTHER_RUNNING_COSTS_PER_VESSEL)) { + MatrixND mat = gravityModel.matrixOtherRunningCostsPerVessel(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_SHARED_NOT_FIXED_COSTS_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixSharedNotFixedCostsPerVessel(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_SHARED_NOT_FIXED_COSTS_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixSharedNotFixedCostsPerVessel(date); resManager.addResult(date, mat); - } -// if (resManager.isEnabled(ResultName.MATRIX_SHARED_FIXED_COSTS_PER_VESSEL_PER_MET)) { -// MatrixND mat = gravityModel.matrixSharedFixedCostsPerVesselPerMet(date); -// resManager.addResult(date, mat); -// } - if (resManager.isEnabled(ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_SPECIES_PER_STRATEGY_MET)) { - MatrixND mat = gravityModel.matrixGrossValueOfLandingsPerSpeciesPerStrategyMet(date); + } + // if (resManager.isEnabled(ResultName.MATRIX_SHARED_FIXED_COSTS_PER_VESSEL_PER_MET)) { + // MatrixND mat = gravityModel.matrixSharedFixedCostsPerVesselPerMet(date); + // resManager.addResult(date, mat); + // } + if (resManager + .isEnabled(ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_SPECIES_PER_STRATEGY_MET)) { + MatrixND mat = gravityModel + .matrixGrossValueOfLandingsPerSpeciesPerStrategyMet(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET)) { - MatrixND mat = gravityModel.matrixGrossValueOfLandingsPerStrategyMet(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET)) { + MatrixND mat = gravityModel + .matrixGrossValueOfLandingsPerStrategyMet(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixGrossValueOfLandingsPerStrategyMetPerVessel(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixGrossValueOfLandingsPerStrategyMetPerVessel(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET)) { - MatrixND mat = gravityModel.matrixNetValueOfLandingsPerStrategyMet(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET)) { + MatrixND mat = gravityModel + .matrixNetValueOfLandingsPerStrategyMet(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixNetValueOfLandingsPerStrategyMetPerVessel(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixNetValueOfLandingsPerStrategyMetPerVessel(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_NET_RENEVUE_TO_SHARE_PER_STRATEGY_MET_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixNetRenevueToSharePerStrategyMetPerVessel(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_NET_RENEVUE_TO_SHARE_PER_STRATEGY_MET_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixNetRenevueToSharePerStrategyMetPerVessel(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_CREW_SHARE_PER_STRATEGY_MET_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixCrewSharePerStrategyMetPerVessel(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_CREW_SHARE_PER_STRATEGY_MET_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixCrewSharePerStrategyMetPerVessel(date); resManager.addResult(date, mat); } - if (resManager.isEnabled(ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_MET_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixOwnerMarginOverVariableCostsPerStrategyMetPerVessel(date); + if (resManager + .isEnabled(ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_MET_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixOwnerMarginOverVariableCostsPerStrategyMetPerVessel(date); resManager.addResult(date, mat); } - if (resManager.isEnabled(ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_MET_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixVesselMarginOverVariableCostsPerStrategyMetPerVessel(date); + if (resManager + .isEnabled(ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_MET_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixVesselMarginOverVariableCostsPerStrategyMetPerVessel(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixOwnerMarginOverVariableCostsPerStrategyPerVessel(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixOwnerMarginOverVariableCostsPerStrategyPerVessel(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY)) { - MatrixND mat = gravityModel.matrixOwnerMarginOverVariableCostsPerStrategy(date); + } + if (resManager + .isEnabled(ResultName.MATRIX_OWNER_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY)) { + MatrixND mat = gravityModel + .matrixOwnerMarginOverVariableCostsPerStrategy(date); resManager.addResult(date, mat); - } - if (resManager.isEnabled(ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_PER_VESSEL)) { - MatrixND mat = gravityModel.matrixVesselMarginOverVariableCostsPerStrategyPerVessel(date); - resManager.addResult(date, mat); } - if (resManager.isEnabled(ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY)) { - MatrixND mat = gravityModel.matrixVesselMarginOverVariableCostsPerStrategy(date); + if (resManager + .isEnabled(ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY_PER_VESSEL)) { + MatrixND mat = gravityModel + .matrixVesselMarginOverVariableCostsPerStrategyPerVessel(date); resManager.addResult(date, mat); } + if (resManager + .isEnabled(ResultName.MATRIX_VESSEL_MARGIN_OVER_VARIABLE_COSTS_PER_STRATEGY)) { + MatrixND mat = gravityModel + .matrixVesselMarginOverVariableCostsPerStrategy(date); + resManager.addResult(date, mat); + } } } - -