Author: bpoussin Date: 2008-08-12 13:10:38 +0000 (Tue, 12 Aug 2008) New Revision: 47 Modified: branches/3.2/exports/CapturesNombre.java branches/3.2/exports/CapturesPoids.java branches/3.2/exports/RejetsPoids.java branches/3.2/rules/GraviteCPUE.java branches/3.2/scripts/GravityModel.java branches/3.2/scripts/ResultName.java branches/3.2/scripts/SiMatrix.java branches/3.2/simulators/DefaultSimulator.java Log: Ajout du calcul en cell pour affiner les calculs (repercussion sur les rules, exports, ... Modified: branches/3.2/exports/CapturesNombre.java =================================================================== --- branches/3.2/exports/CapturesNombre.java 2008-08-12 08:13:26 UTC (rev 46) +++ branches/3.2/exports/CapturesNombre.java 2008-08-12 13:10:38 UTC (rev 47) @@ -37,7 +37,7 @@ static private Log log = LogFactory.getLog(CapturesNombre.class); protected String [] necessaryResult = { - ResultName.MATRIX_CATCH_PER_STRATEGY_MET + ResultName.MATRIX_CATCH_PER_STRATEGY_MET_PER_ZONE_POP }; public String[] getNecessaryResult() { @@ -61,7 +61,8 @@ for (Population pop : simulation.getParameter().getPopulations()) { for (Date date = new Date(0); !date.after(lastDate); date = date.next() ) { - MatrixND mat = simulation.getResultStorage().getMatrix(date, pop, ResultName.MATRIX_CATCH_PER_STRATEGY_MET); + MatrixND mat = simulation.getResultStorage().getMatrix(date, pop, + ResultName.MATRIX_CATCH_PER_STRATEGY_MET_PER_ZONE_POP); if (mat != null) { // can be null if simulation is stopped before last year simulation mat = mat.sumOverDim(0); //sum on strategy for (MatrixIterator i=mat.iterator(); i.hasNext();) { Modified: branches/3.2/exports/CapturesPoids.java =================================================================== --- branches/3.2/exports/CapturesPoids.java 2008-08-12 08:13:26 UTC (rev 46) +++ branches/3.2/exports/CapturesPoids.java 2008-08-12 13:10:38 UTC (rev 47) @@ -37,7 +37,7 @@ static private Log log = LogFactory.getLog(CapturesPoids.class); protected String [] necessaryResult = { - ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET + ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP }; public String[] getNecessaryResult() { @@ -61,7 +61,8 @@ for (Population pop : simulation.getParameter().getPopulations()) { for (Date date = new Date(0); !date.after(lastDate); date = date.next() ) { - MatrixND mat = simulation.getResultStorage().getMatrix(date, pop, ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET); + MatrixND mat = simulation.getResultStorage().getMatrix(date, pop, + ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP); if (mat != null) { // can be null if simulation is stopped before last year simulation mat = mat.sumOverDim(0); //sum on strategy for (MatrixIterator i=mat.iterator(); i.hasNext();) { Modified: branches/3.2/exports/RejetsPoids.java =================================================================== --- branches/3.2/exports/RejetsPoids.java 2008-08-12 08:13:26 UTC (rev 46) +++ branches/3.2/exports/RejetsPoids.java 2008-08-12 13:10:38 UTC (rev 47) @@ -37,7 +37,8 @@ static private Log log = LogFactory.getLog(RejetsPoids.class); protected String [] necessaryResult = { - ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET + ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET_PER_ZONE_POP + }; public String[] getNecessaryResult() { @@ -61,7 +62,7 @@ for (Population pop : simulation.getParameter().getPopulations()) { for (Date date = new Date(0); !date.after(lastDate); date = date.next() ) { - MatrixND mat = simulation.getResultStorage().getMatrix(date, pop, ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET); + MatrixND mat = simulation.getResultStorage().getMatrix(date, pop, ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET_PER_ZONE_POP); if (mat != null) { // can be null if simulation is stopped before last year simulation mat = mat.sumOverDim(0); //sum on strategy for (MatrixIterator i=mat.iterator(); i.hasNext();) { Modified: branches/3.2/rules/GraviteCPUE.java =================================================================== --- branches/3.2/rules/GraviteCPUE.java 2008-08-12 08:13:26 UTC (rev 46) +++ branches/3.2/rules/GraviteCPUE.java 2008-08-12 13:10:38 UTC (rev 47) @@ -57,7 +57,7 @@ // example: // ResultName.MATRIX_BIOMASS, // ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET, - ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET, + ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP, ResultName.MATRIX_EFFORT_PER_STRATEGY_MET, }; @@ -186,7 +186,7 @@ MatrixND temp = resultmanager.getMatrix( date.previousYear(), pop, - ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET); + ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP); // on somme sur les zones temp=temp.sumOverDim(3); // on somme sur les groupes Modified: branches/3.2/scripts/GravityModel.java =================================================================== --- branches/3.2/scripts/GravityModel.java 2008-08-12 08:13:26 UTC (rev 46) +++ branches/3.2/scripts/GravityModel.java 2008-08-12 13:10:38 UTC (rev 47) @@ -572,7 +572,7 @@ double price = group.getPrice(); Collection<Zone> zones = pop.getPopulationZone(); for(Zone zone : zones){ - double catchWeight = getCatchWeightPerStrMet(str, metier, group, zone, date); + 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,8 +589,8 @@ * @param date * @return */ - private double getCatchWeightPerStrMet(Strategy str, Metier metier, PopulationGroup group, Zone zone, Date date) { - MatrixND mat = resultManager.getMatrix(date, group.getPopulation(), ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET); + 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){ result = mat.getValue(str, metier, group, zone); @@ -607,7 +607,7 @@ * @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); + MatrixND mat = resultManager.getMatrix(date, group.getPopulation(), ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET_PER_ZONE_POP); double result = 0; if(mat != null){ result = mat.getValue(str, metier, group, zone); @@ -1249,7 +1249,7 @@ for(PopulationGroup group : groups){ double price = group.getPrice(); for(Zone zone : zones){ - double catchValue = getCatchWeightPerStrMet(str, metier, group, zone, date); + double catchValue = getCatchWeightPerStrMetPerZonePop(str, metier, group, zone, date); double discards = getDiscardsWeightPerStrMet(str, metier, group, zone, date); result += price * (catchValue - discards); } @@ -1294,7 +1294,7 @@ Collection<Zone> zones = pop.getPopulationZone(); for(PopulationGroup group : groups){ for(Zone zone : zones){ - double catchValue = getCatchWeightPerStrMet(str, metier, group, zone, date); + double catchValue = getCatchWeightPerStrMetPerZonePop(str, metier, group, zone, date); double discards = getDiscardsWeightPerStrMet(str, metier, group, zone, date); result += catchValue - discards; } Modified: branches/3.2/scripts/ResultName.java =================================================================== --- branches/3.2/scripts/ResultName.java 2008-08-12 08:13:26 UTC (rev 46) +++ branches/3.2/scripts/ResultName.java 2008-08-12 13:10:38 UTC (rev 47) @@ -52,7 +52,7 @@ */ public class ResultName { @Doc(value = "do the doc of Result matrixDiscardsWeightPerStrMet") - static final public String MATRIX_DISCARDS_WEIGHT_PER_STR_MET = n_("matrixDiscardsWeightPerStrMet"); + static final public String MATRIX_DISCARDS_WEIGHT_PER_STR_MET_PER_ZONE_POP = n_("matrixDiscardsWeightPerStrMet"); @Doc(value = "do the doc of Result matrixDiscardsPerStrMet") static final public String MATRIX_DISCARDS_PER_STR_MET = n_("matrixDiscardsPerStrMet"); @@ -65,14 +65,14 @@ static final public String MATRIX_STD_TRAVEL_EFFORT_PER_STRATEGY_MET = n_("matrixStdTravelEffortPerStrategyMet"); @Doc(value = "do the doc of Result matrixEffortPerZonePop") static final public String MATRIX_EFFORT_PER_ZONE_POP = n_("matrixEffortPerZonePop"); - @Doc(value = "do the doc of Result matrixCatchRatePerStrategyMet") - static final public String MATRIX_CATCH_RATE_PER_STRATEGY_MET = n_("matrixCatchRatePerStrategyMet"); - @Doc(value = "do the doc of Result matrixCatchPerStrategyMet") - static final public String MATRIX_CATCH_PER_STRATEGY_MET = n_("matrixCatchPerStrategyMet"); - @Doc(value = "do the doc of Result matrixFishingMortality") - static final public String MATRIX_FISHING_MORTALITY = n_("matrixFishingMortality"); - @Doc(value = "do the doc of Result matrixCatchWeightPerStrategyMet") - static final public String MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET = n_("matrixCatchWeightPerStrategyMet"); + @Doc(value = "do the doc of Result matrixCatchPerStrategyMetPerZoneMet") + static final public String MATRIX_CATCH_PER_STRATEGY_MET_PER_ZONE_MET = n_("matrixCatchPerStrategyMetPerZoneMet"); + @Doc(value = "do the doc of Result matrixCatchPerStrategyMetPerZonePop") + static final public String MATRIX_CATCH_PER_STRATEGY_MET_PER_ZONE_POP = n_("matrixCatchPerStrategyMetPerZonePop"); + @Doc(value = "do the doc of Result matrixCatchWeightPerStrategyMetPerZoneMet") + static final public String MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_MET = n_("matrixCatchWeightPerStrategyMetPerZoneMet"); + @Doc(value = "do the doc of Result matrixCatchWeightPerStrategyMetPerZonePop") + static final public String MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP = n_("matrixCatchWeightPerStrategyMetPerZonePop"); @Doc(value = "do the doc of Result matrixAbundance") static final public String MATRIX_ABUNDANCE = n_("matrixAbundance"); @Doc(value = "do the doc of Result matrixBiomass") Modified: branches/3.2/scripts/SiMatrix.java =================================================================== --- branches/3.2/scripts/SiMatrix.java 2008-08-12 08:13:26 UTC (rev 46) +++ branches/3.2/scripts/SiMatrix.java 2008-08-12 13:10:38 UTC (rev 47) @@ -67,6 +67,7 @@ import fr.ifremer.isisfish.simulator.SimulationContext; import fr.ifremer.isisfish.types.Date; import fr.ifremer.isisfish.types.Month; +import java.util.Set; /** * @author poussin @@ -240,6 +241,94 @@ // /////////////////////////////////////////////////////////////////////////// + public MatrixND matrixCatchWeightPerStrategyMetPerZoneMet(Date date, Population pop, MatrixND matrixCatchPerStrategyMetPerZoneMet) throws TopiaException, IsisFishException { + List<PopulationGroup> groups = pop.getPopulationGroup(); + + MatrixND result = matrixCatchPerStrategyMetPerZoneMet.copy(); + result.setName(ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_MET); + + for (PopulationGroup group : groups) { + MatrixND sub = result.getSubMatrix(2, group, 1); + double meanWeight = group.getMeanWeight(); + sub.mults(meanWeight); + } + + return result; + } + + public MatrixND matrixCatchPerStrategyMetPerZoneMet(MatrixND N, Population pop, Date date) throws TopiaException, IsisFishException { + + MatrixND matrixFishingMortalityPerCell = matrixFishingMortalityPerCell(date, pop); + MatrixND matrixCatchRatePerStrategyMetPerCell = matrixCatchRatePerStrategyMetPerCell(pop, date, matrixFishingMortalityPerCell); + MatrixND matrixCatchPerStrategyMetPerCell = matrixCatchPerStrategyMetPerCell(N, pop, date, matrixCatchRatePerStrategyMetPerCell); + + List<Strategy> strategies = getStrategies(date); + List<Metier> metiers = getMetiers(date); + List<PopulationGroup> groups = matrixCatchPerStrategyMetPerCell.getSemantics(2); + List<Zone> zones = getZones(date); + + MatrixND result = MatrixFactory.getInstance().create( + ResultName.MATRIX_CATCH_PER_STRATEGY_MET_PER_ZONE_MET, + new List[]{strategies, metiers, groups, zones}, + new String[]{n_("Strategies"), n_("Metiers"), n_("Groups"), n_("Zones")}); + + // matrice temporaire ou les zones pops sont sommees + MatrixND tmp = matrixCatchPerStrategyMetPerCell.sumOverDim(3); + tmp = tmp.reduce(3); + + for (int s = 0; s < strategies.size(); s++) { + Strategy str = strategies.get(s); + for(int g = 0; g<groups.size(); g++) { + PopulationGroup group = groups.get(g); + for (int m = 0; m < metiers.size(); m++) { + Metier metier = metiers.get(m); + MetierSeasonInfo infoMet = metier.getMetierSeasonInfo(date.getMonth()); + Collection<Zone> zoneMet = infoMet.getZone(); + for (Zone z : zoneMet) { + double value = 0; + List<Cell> cells = z.getCell(); + for (int c = 0; c < cells.size(); c++) { + Cell cell = cells.get(c); + value += tmp.getValue(str, metier, group, cell); + result.setValue(str, metier, group, z, value); + } + } + } + } + } + + return result; + } + + public MatrixND matrixCatchPerStrategyMetPerZonePop(MatrixND N, Population pop, Date date) throws TopiaException, IsisFishException { + MatrixND matrixFishingMortalityPerCell = matrixFishingMortalityPerCell(date, pop); + MatrixND matrixCatchRatePerStrategyMetPerCell = matrixCatchRatePerStrategyMetPerCell(pop, date, matrixFishingMortalityPerCell); + MatrixND matrixCatchPerStrategyMetPerCell = matrixCatchPerStrategyMetPerCell(N, pop, date, matrixCatchRatePerStrategyMetPerCell); + + // on somme sur les cellules + MatrixND result = matrixCatchPerStrategyMetPerCell.sumOverDim(4); + result = result.reduce(4); + result.setName(ResultName.MATRIX_CATCH_PER_STRATEGY_MET_PER_ZONE_POP); + + return result; + } + + public MatrixND matrixCatchWeightPerStrategyMetPerZonePop(Date date, + Population pop, MatrixND matrixCatchPerStrategyMetPerZonePop) throws TopiaException, IsisFishException { + List<PopulationGroup> groups = pop.getPopulationGroup(); + + MatrixND result = matrixCatchPerStrategyMetPerZonePop.copy(); + result.setName(ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP); + + for (PopulationGroup group : groups) { + MatrixND sub = result.getSubMatrix(2, group, 1); + double meanWeight = group.getMeanWeight(); + sub.mults(meanWeight); + } + + return result; + } + /** * Matrice des captures en nombre * dim [ Strategy x Metier x Classe x zonePop ] @@ -251,21 +340,21 @@ * @throws TopiaException * @throws IsisFishException */ - public MatrixND matrixCatchPerStrategyMet(MatrixND N, Population pop, - Date date, MatrixND matrixCatchRatePerStrategyMet) throws TopiaException, IsisFishException { + private MatrixND matrixCatchPerStrategyMetPerCell(MatrixND N, Population pop, + Date date, MatrixND matrixCatchRatePerStrategyMetPerCell) throws TopiaException, IsisFishException { List<PopulationGroup> groups = pop.getPopulationGroup(); List<Zone> zones = pop.getPopulationZone(); // on le passe en argument ce qui evite de le calculer 2 fois // MatrixND matrixCatchRatePerStrategyMet = matrixCatchRatePerStrategyMet(pop, date); - MatrixND result = matrixCatchRatePerStrategyMet.copy(); - result.setName(ResultName.MATRIX_CATCH_PER_STRATEGY_MET); + MatrixND result = matrixCatchRatePerStrategyMetPerCell.copy(); + result.setName("matrixCatchPerStrategyMetPerCell"); for(PopulationGroup group : groups) { MatrixND sub = result.getSubMatrix(2, group, 1); for(Zone zone : zones){ MatrixND subsub = sub.getSubMatrix(3, zone, 1); - double val = N.getValue(group, zone); + double val = N.getValue(group, zone) / (double)zone.sizeCell(); subsub.mults(val); } } @@ -282,16 +371,17 @@ * @throws TopiaException * @throws IsisFishException */ - public MatrixND matrixCatchRatePerStrategyMet(Population pop, Date date, MatrixND matrixFishingMortality) throws TopiaException, IsisFishException { + private MatrixND matrixCatchRatePerStrategyMetPerCell(Population pop, Date date, MatrixND matrixFishingMortalityPerCell) throws TopiaException, IsisFishException { List<Strategy> strategies = getStrategies(date); List<Metier> metiers = getMetiers(date); List<PopulationGroup> groups = pop.getPopulationGroup(); List<Zone> zones = pop.getPopulationZone(); + List<Cell> cells = getCells(zones); MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_CATCH_RATE_PER_STRATEGY_MET, - new List[]{strategies, metiers, groups, zones}, - new String[]{n_("Strategies"), n_("Metiers"), n_("Groups"), n_("Zones")}); + "matrixCatchRatePerStrategyMetPerCell", + new List[]{strategies, metiers, groups, zones, cells}, + new String[]{n_("Strategies"), n_("Metiers"), n_("Groups"), n_("Zones"), n_("Cells")}); // for (int s=0; s < strategies.size(); s++) { // Strategy str = strategies.get(s); @@ -313,26 +403,38 @@ // if(log.isDebugEnabled()) {log.debug("pas de totalFishingMortality pour (" + pop + ")");} // } else { // Optimisation Hilaire - for (int s=0; s < strategies.size(); s++) { - Strategy str = strategies.get(s); - metiers = getMetiers(str, date); - for (int m=0; m < metiers.size(); m++) { - Metier metier = metiers.get(m); - for (int z=0; z < zones.size(); z++) { - Zone zone = zones.get(z); - double effort = effortPerZonePop(str,metier,date,zone); - if (effort > 0){ - for (int g=0; g < groups.size(); g++) { + + MatrixND matrixFishingMortalityPerCellSumOverGroup = matrixFishingMortalityPerCell.sumOverDim(2); + matrixFishingMortalityPerCellSumOverGroup = matrixFishingMortalityPerCellSumOverGroup.reduce(2); + + for (int s = 0; s < strategies.size(); s++) { + Strategy str = strategies.get(s); + metiers = getMetiers(str, date); + for (int m = 0; m < metiers.size(); m++) { + Metier metier = metiers.get(m); + for (int z = 0; z < zones.size(); z++) { + Zone zone = zones.get(z); + List<Cell> cellZones = zone.getCell(); + for (int c = 0; c < cellZones.size(); c++) { + Cell cell = cellZones.get(c); + double effort = matrixFishingMortalityPerCellSumOverGroup.getValue( + str, metier, zone, cell); + if (effort > 0) { + for (int g = 0; g < groups.size(); g++) { PopulationGroup group = groups.get(g); - double value = catchRatePerStrategyMet(str, metier, date, group, zone, matrixFishingMortality); - result.setValue(str, metier, group, zone, value); + double value = catchRatePerStrategyMetPerCell( + str, metier, date, group, zone, cell, + matrixFishingMortalityPerCell); + result.setValue(new Object[]{str, metier, group, + zone, cell}, value); } } } } } + } // } - + // for (Strategy str : strategies) { // List<Metier> metierStr = getMetiers(str, date); // for (Metier metier : metierStr) { @@ -380,25 +482,31 @@ // } // Optimisation Hilaire - private double catchRatePerStrategyMet(Strategy str, Metier metier, Date date, PopulationGroup group, Zone zone, MatrixND matrixFishingMortality) throws TopiaException, IsisFishException { -// double totalFishingMortality = matrixFishingMortality.sumAll(); - double totalFishingMortality = totalFishingMortality(date, matrixFishingMortality).getValue(group, zone); + private double catchRatePerStrategyMetPerCell(Strategy str, Metier metier, + Date date, PopulationGroup group, Zone zone, Cell cell, + MatrixND matrixFishingMortalityPerCell) throws TopiaException, IsisFishException { + double totalFishingMortality = totalFishingMortalityPerCell(date, + matrixFishingMortalityPerCell).getValue(group, zone); + if(totalFishingMortality == 0){ if(log.isDebugEnabled()) {log.debug("pas de totalFishingMortality pour (" + group + ", " + zone +")");} return 0; } - double fishingMortality = matrixFishingMortality.getValue(str, metier, group, zone); - double totalCatchRate = totalCatchRate(date, group, zone, totalFishingMortality); + double fishingMortalityPerCell = matrixFishingMortalityPerCell.getValue( + new Object[]{str, metier, group, zone, cell}); + double totalCatchRatePerCell = + totalCatchRatePerCell(date, group, zone, totalFishingMortality); if(log.isDebugEnabled()) { log.debug( " totalFishingMortality=" + totalFishingMortality + - " fishingMortality=" + fishingMortality + - " totalCatchRate=" + totalCatchRate); + " fishingMortality=" + fishingMortalityPerCell + + " totalCatchRate=" + totalCatchRatePerCell); } - double result = fishingMortality / totalFishingMortality * totalCatchRate; + double result = + fishingMortalityPerCell / totalFishingMortality * totalCatchRatePerCell; return result; } @@ -412,8 +520,8 @@ * @return * @throws TopiaException */ - private double totalCatchRate(Date date, PopulationGroup group, - Zone zone, double totalFishingMortality) throws TopiaException { + private double totalCatchRatePerCell(Date date, PopulationGroup group, + Zone zone, double totalFishingMortalityPerCell) throws TopiaException { double M = group.getNaturalDeathRate(zone) / Month.NUMBER_OF_MONTH; if(M == 0){ // normalement il devrait y avoir de la mortalite naturelle @@ -421,7 +529,7 @@ log.warn("Pas de mortalit� naturelle pour: " + group); } } - double F = totalFishingMortality; + double F = totalFishingMortalityPerCell; double result = 0; if( M != 0 || F != 0){ @@ -440,16 +548,18 @@ * @param zone * @return */ - private MatrixND totalFishingMortality(Date date, MatrixND matrixFishingMortality) { - MatrixND result = matrixFishingMortality.sumOverDim(0); + private MatrixND totalFishingMortalityPerCell(Date date, MatrixND matrixFishingMortalityPerCell) { + MatrixND result = matrixFishingMortalityPerCell.sumOverDim(0); result = result.sumOverDim(1); result = result.reduceDims(0, 1); return result; } + + // Nouvelle implantation suite a demande Steph et Sigrid: 20080208 (NouvellesEquationsfev2008ParCelluleAvecAlgo.odt) /** * Matrice fishing mortality - * dim [ Strategy x Metier x Classe x zonePop ] + * dim [ Strategy x Metier x Classe x zonePop x cellPop] * * @param pop * @param date @@ -457,64 +567,60 @@ * @throws TopiaException * @throws IsisFishException */ - public MatrixND matrixFishingMortality(Date date, Population pop) throws TopiaException, IsisFishException { + public MatrixND matrixFishingMortalityPerCell(Date date, Population pop) throws TopiaException, IsisFishException { List<Strategy> strategies = getStrategies(date); List<Metier> metiers = getMetiers(date); List<PopulationGroup> groups = pop.getPopulationGroup(); List<Zone> zones = pop.getPopulationZone(); + List<Cell> cells = getCells(zones); // default value in matrix is 0 MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_FISHING_MORTALITY, - new List[]{strategies, metiers, groups, zones}, - new String[]{n_("Strategies"), n_("Metiers"), n_("Groups"), n_("Zones")}); + "matrixFishingMortalityPerCell", + new List[]{strategies, metiers, groups, zones, cells}, + new String[]{n_("Strategies"), n_("Metiers"), n_("Groups"), n_("Zones"), n_("Cells")}); Month month = date.getMonth(); PopulationSeasonInfo infoPop = pop.getPopulationSeasonInfo(month); -// org.codelutin.util.CallAnalyse.activate(); - for (int g=0; g < groups.size(); g++) { - PopulationGroup group = groups.get(g); - - // getCapturability is check matrix validity and create matrix if needed and get one value in -// org.codelutin.util.CallAnalyse.enter("debug infoPop.getCapturability"); - double capturability = infoPop.getCapturability(group); -// org.codelutin.util.CallAnalyse.exit("debug infoPop.getCapturability"); - if (capturability != 0) { // check 0, this prevent next call, for default value - - for (int m=0; m < metiers.size(); m++) { - Metier metier = metiers.get(m); - -// org.codelutin.util.CallAnalyse.enter("debug infoMet.getTargetFactor"); - MetierSeasonInfo infoMet = metier.getMetierSeasonInfo(month); - // getTargetFactor seem to be simple - double ciblage = infoMet.getTargetFactor(group); -// org.codelutin.util.CallAnalyse.exit("debug infoMet.getTargetFactor"); + for (int g = 0; g < groups.size(); g++) { + PopulationGroup group = groups.get(g); - if (ciblage != 0) { // check 0, this prevent next call, for default value - -// org.codelutin.util.CallAnalyse.enter("debug gear.getPopulationSelectivity"); - Gear gear = metier.getGear(); - Selectivity selectivity = gear.getPopulationSelectivity(pop); -// org.codelutin.util.CallAnalyse.exit("debug gear.getPopulationSelectivity"); - if (selectivity != null) { + // getCapturability is check matrix validity and create matrix + // if needed and get one value in + double capturability = infoPop.getCapturability(group); + if (capturability != 0) { // check 0, this prevent next call, for default value + for (int m = 0; m < metiers.size(); m++) { + Metier metier = metiers.get(m); - // getCoefficient is equation evaluation -// org.codelutin.util.CallAnalyse.enter("debug selectivity.getCoefficient"); - double coeff = selectivity.getCoefficient(pop, group, metier); -// org.codelutin.util.CallAnalyse.exit("debug selectivity.getCoefficient"); - if (coeff != 0) { // check 0, this prevent next call, for default value - - for (int s=0; s < strategies.size(); s++) { - Strategy str = strategies.get(s); - for (int z=0; z < zones.size(); z++) { - Zone zone = zones.get(z); - double effort = effortPerZonePop(str,metier,date,zone); - if (effort > 0){ // put value only if <> 0 - double value = coeff * capturability * ciblage * effort; -// org.codelutin.util.CallAnalyse.enter("debug result.setValue"); - result.setValue(str, metier, group, zone, value); -// org.codelutin.util.CallAnalyse.exit("debug result.setValue"); + MetierSeasonInfo infoMet = metier.getMetierSeasonInfo(month); + // getTargetFactor seem to be simple + double ciblage = infoMet.getTargetFactor(group); + + if (ciblage != 0) { // check 0, this prevent next call, for default value + + Gear gear = metier.getGear(); + Selectivity selectivity = gear.getPopulationSelectivity(pop); + if (selectivity != null) { + + // getCoefficient is equation evaluation + double coeff = selectivity.getCoefficient(pop, group, metier); + if (coeff != 0) { // check 0, this prevent next call, for default value + + for (int s = 0; s < strategies.size(); s++) { + Strategy str = strategies.get(s); + // l'effort d'une cellule du metier + double effort = effortPerStrategyPerCell(str, metier, date); + if (effort > 0) { // put value only if <> 0 + for (int z = 0; z < zones.size(); z++) { + Zone zone = zones.get(z); + Set<Cell> cellPops = new HashSet<Cell>(zone.getCell()); + for (Cell cellMet : infoMet.getCells()) { + if (cellPops.contains(cellMet)) { + double value = coeff * capturability * ciblage * effort; + result.setValue(new Object[]{str, metier, group, zone, cellMet}, value); + } + } } } } @@ -524,10 +630,79 @@ } } } -// System.out.println("****DEBUG matrixFishingMortality:" + org.codelutin.util.CallAnalyse.getThreadStatistics().toString()); return result; } + // Supprimee suite a demande Steph et Sigrid: 20080208 (NouvellesEquationsfev2008ParCelluleAvecAlgo.odt) +// /** +// * Matrice fishing mortality +// * dim [ Strategy x Metier x Classe x zonePop ] +// * +// * @param pop +// * @param date +// * @return +// * @throws TopiaException +// * @throws IsisFishException +// */ +// public MatrixND matrixFishingMortalityPerCell(Date date, Population pop) throws TopiaException, IsisFishException { +// List<Strategy> strategies = getStrategies(date); +// List<Metier> metiers = getMetiers(date); +// List<PopulationGroup> groups = pop.getPopulationGroup(); +// List<Zone> zones = pop.getPopulationZone(); +// +// // default value in matrix is 0 +// MatrixND result = MatrixFactory.getInstance().create( +// ResultName.MATRIX_FISHING_MORTALITY, +// new List[]{strategies, metiers, groups, zones}, +// new String[]{n_("Strategies"), n_("Metiers"), n_("Groups"), n_("Zones")}); +// +// Month month = date.getMonth(); +// PopulationSeasonInfo infoPop = pop.getPopulationSeasonInfo(month); +// +// for (int g=0; g < groups.size(); g++) { +// PopulationGroup group = groups.get(g); +// +// // getCapturability is check matrix validity and create matrix if needed and get one value in +// double capturability = infoPop.getCapturability(group); +// if (capturability != 0) { // check 0, this prevent next call, for default value +// +// for (int m=0; m < metiers.size(); m++) { +// Metier metier = metiers.get(m); +// +// MetierSeasonInfo infoMet = metier.getMetierSeasonInfo(month); +// // getTargetFactor seem to be simple +// double ciblage = infoMet.getTargetFactor(group); +// +// if (ciblage != 0) { // check 0, this prevent next call, for default value +// +// Gear gear = metier.getGear(); +// Selectivity selectivity = gear.getPopulationSelectivity(pop); +// if (selectivity != null) { +// +// // getCoefficient is equation evaluation +// double coeff = selectivity.getCoefficient(pop, group, metier); +// if (coeff != 0) { // check 0, this prevent next call, for default value +// +// for (int s=0; s < strategies.size(); s++) { +// Strategy str = strategies.get(s); +// for (int z=0; z < zones.size(); z++) { +// Zone zone = zones.get(z); +// double effort = effortPerZonePop(str,metier,date,zone); +// if (effort > 0){ // put value only if <> 0 +// double value = coeff * capturability * ciblage * effort; +// result.setValue(str, metier, group, zone, value); +// } +// } +// } +// } +// } +// } +// } +// } +// } +// return result; +// } + // ne prendre que les metiers pratiqu� semble une bonne idee, mais en fait non, car cela oblige l'ordre des boucles // et donc ne permet pas autant d'optimisation que souhait� // public MatrixND matrixFishingMortality2(Date date, Population pop) throws TopiaException, IsisFishException { @@ -670,33 +845,34 @@ // return result; // } - /** - * @param str - * @param metier - * @param date - * @param zone - * @return - */ - private double effortPerZonePop(Strategy str, Metier metier, Date date, Zone zonePop) { - Month month = date.getMonth(); - Collection<Zone> zoneMet = metier.getMetierSeasonInfo(month).getZone(); - double inter = nbCellInter(zoneMet, zonePop); + // Supprimee suite a demande Steph et Sigrid: 20080208 (NouvellesEquationsfev2008ParCelluleAvecAlgo.odt) +// /** +// * @param str +// * @param metier +// * @param date +// * @param zone +// * @return +// */ +// private double effortPerZonePop(Strategy str, Metier metier, Date date, Zone zonePop) { +// Month month = date.getMonth(); +// Collection<Zone> zoneMet = metier.getMetierSeasonInfo(month).getZone(); +// double inter = nbCellInter(zoneMet, zonePop); +// +// double effortPerStrategyPerCell = effortPerStrategyPerCell(str, metier, date); +// +// if(log.isDebugEnabled()) { +// log.debug( +// " strategy=" + str + +// " metier=" + metier + +// " inter=" + inter + +// " effortPerStrategyPerCell=" + effortPerStrategyPerCell +// ); +// } +// +// double result = effortPerStrategyPerCell * inter; +// return result; +// } - double effortPerStrategyPerCell = effortPerStrategyPerCell(str, metier, date); - - if(log.isDebugEnabled()) { - log.debug( - " strategy=" + str + - " metier=" + metier + - " inter=" + inter + - " effortPerStrategyPerCell=" + effortPerStrategyPerCell - ); - } - - double result = effortPerStrategyPerCell * inter; - return result; - } - /** * @param str * @param metier @@ -1001,35 +1177,54 @@ * @throws IsisFishException * @throws TopiaException */ - public MatrixND matrixAbundance(MatrixND N, Population pop, Date date, MatrixND matrixFishingMortality) throws TopiaException, IsisFishException { + private MatrixND matrixAbundancePerCell(MatrixND N, Population pop, + Date date, MatrixND matrixFishingMortality) throws TopiaException, IsisFishException { + List<PopulationGroup> groups = pop.getPopulationGroup(); List<Zone> zones = pop.getPopulationZone(); MatrixND result = MatrixFactory.getInstance().create( - ResultName.MATRIX_ABUNDANCE, + ResultName.MATRIX_ABUNDANCE + "_PER_CELL", new List[]{groups, zones}, - new String[]{n_("Groups"), n_("Zones")}); + new String[]{n_("Groups"), n_("Zones"), n_("Cells")}); for (int g=0; g < groups.size(); g++) { PopulationGroup group = groups.get(g); for (int z=0; z < zones.size(); z++) { - Zone zone = zones.get(z); - double value = survivalRate(date, group, zone, matrixFishingMortality); - double n = N.getValue(g, z); - value *= n; - result.setValue(g, z, value); + Zone zone = zones.get(z); + List<Cell> cells = zone.getCell(); + for (int c=0; c<cells.size(); c++) { + Cell cell = cells.get(c); + double value = survivalRatePerCell(date, group, zone, cell, matrixFishingMortality); + double n = N.getValue(g, z) / zone.sizeCell(); + value *= n; + result.setValue(g, z, value); + } } } + + return result; + } + + /** + * @param N + * @param pop + * @param date + * @return + * @throws IsisFishException + * @throws TopiaException + */ + public MatrixND matrixAbundance(MatrixND N, Population pop, Date date) + throws TopiaException, IsisFishException { -// for(PopulationGroup group : groups){ -// for(Zone zone : zones){ -// double val = survivalRate(date, group, zone); -// val *= N.getValue(group, zone); -// result.setValue(group, zone, val); -// } -// } + MatrixND matrixFishingMortalityPerCell = matrixFishingMortalityPerCell(date, pop); - return result; + MatrixND result = matrixAbundancePerCell(N, pop, date, matrixFishingMortalityPerCell); + result = result.sumOverDim(2); + result = result.reduce(2); + result.setName(ResultName.MATRIX_ABUNDANCE); + + return result; } /** @@ -1040,8 +1235,11 @@ * @throws IsisFishException * @throws TopiaException */ - private double survivalRate(Date date, PopulationGroup group, Zone zone, MatrixND matrixFishingMortality) throws TopiaException, IsisFishException { - double F = totalFishingMortality(date, matrixFishingMortality).getValue(group, zone); //totalFishingMortality(date, group, zone); // rem perf: totalFishingMortality a deja ete calcul� + private double survivalRatePerCell(Date date, PopulationGroup group, Zone zone, + Cell cell, MatrixND matrixFishingMortalityPerCell) throws TopiaException, IsisFishException { + + double F = totalFishingMortalityPerCell(date, matrixFishingMortalityPerCell) + .getValue(group, zone, cell); //totalFishingMortality(date, group, zone); // rem perf: totalFishingMortality a deja ete calcul� double M = group.getNaturalDeathRate(zone)/(double)Month.NUMBER_OF_MONTH; double result = (double)Math.exp(-(F+M)); @@ -1138,38 +1336,40 @@ // /////////////////////////////////////////////////////////////////////////// - /** - * @param pop - * @param date - * @return - */ - public MatrixND matrixCatchWeightPerStrategyMet(Population pop, - Date date, MatrixND matrixCatchPerStrategyMet) { - List<PopulationGroup> groups = pop.getPopulationGroup(); +// /** +// * @param pop +// * @param date +// * @return +// */ +// public MatrixND matrixCatchWeightPerStrategyMet(Population pop, +// Date date, MatrixND matrixCatchPerStrategyMet) { +// List<PopulationGroup> groups = pop.getPopulationGroup(); +// +// MatrixND result = matrixCatchPerStrategyMet.copy(); +// result.setName(ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET); +// +// for(PopulationGroup group : groups){ +// MatrixND sub = result.getSubMatrix(2, group, 1); +// double meanWeight = group.getMeanWeight(); +// sub.mults(meanWeight); +// } +// +// return result; +// } - MatrixND result = matrixCatchPerStrategyMet.copy(); - result.setName(ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET); - - for(PopulationGroup group : groups){ - MatrixND sub = result.getSubMatrix(2, group, 1); - double meanWeight = group.getMeanWeight(); - sub.mults(meanWeight); - } - - return result; - } - /** + * + * * @param pop * @param date * @return */ - public MatrixND matrixDiscardWeightPerStrategyMet(Population pop, - Date date, MatrixND matrixDiscardPerStrategyMet) { + public MatrixND matrixDiscardWeightPerStrategyMetPerZonePop(Population pop, + Date date, MatrixND matrixDiscardPerStrategyMetPerZonePop) { List<PopulationGroup> groups = pop.getPopulationGroup(); - MatrixND result = matrixDiscardPerStrategyMet.copy(); - result.setName(ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET); + MatrixND result = matrixDiscardPerStrategyMetPerZonePop.copy(); + result.setName(ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET_PER_ZONE_POP); for(PopulationGroup group : groups){ MatrixND sub = result.getSubMatrix(2, group, 1); Modified: branches/3.2/simulators/DefaultSimulator.java =================================================================== --- branches/3.2/simulators/DefaultSimulator.java 2008-08-12 08:13:26 UTC (rev 46) +++ branches/3.2/simulators/DefaultSimulator.java 2008-08-12 13:10:38 UTC (rev 47) @@ -1,6 +1,6 @@ /* *##% * Copyright (C) 2006 - * Ifremer, Code Lutin, C�dric Pineau, Benjamin Poussin + * Ifremer, Code Lutin, C?dric Pineau, Benjamin Poussin * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License @@ -20,7 +20,7 @@ /* * * DefaultSimulator.java * - * Created: 21 ao�t 2006 10:57:46 + * Created: 21 ao?t 2006 10:57:46 * * @author poussin * @version $Revision: 1.19 $ @@ -98,7 +98,10 @@ MetierMonitor metierMonitor = context.getMetierMonitor(); RuleMonitor ruleMonitor = context.getRuleMonitor(); - for (Population pop : siMatrix.getPopulations(date)) { + 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); @@ -281,8 +284,8 @@ } resManager.addResult(date, pop, discard); - if (resManager.isEnabled(ResultName.MATRIX_DISCARDS_WEIGHT_PER_STR_MET)) { - MatrixND discardWeightPerStrategyMet = siMatrix.matrixDiscardWeightPerStrategyMet(pop, date, 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); } @@ -404,24 +407,43 @@ // compute fishing matrix only if there are one or more strategy if (siMatrix.getStrategies(date).size() > 0) { // compute some Matrix and add result - MatrixND matrixFishingMortality = siMatrix.matrixFishingMortality(date, pop); - resManager.addResult(date, pop, matrixFishingMortality); - abundance = siMatrix.matrixAbundance(N, pop, date, matrixFishingMortality); + // n'existe plus suite a l'implantation de calculs en cell +// MatrixND matrixFishingMortality = siMatrix.matrixFishingMortality(date, pop); +// resManager.addResult(date, pop, matrixFishingMortality); + + abundance = siMatrix.matrixAbundance(N, pop, date); + // n'existe plus suite a l'implantation de calculs en cell // this matrix is necessary for matrixCatchPerStrategyMet - MatrixND catchRatePerStrategyMet = siMatrix.matrixCatchRatePerStrategyMet(pop, date, matrixFishingMortality); - resManager.addResult(date, pop, catchRatePerStrategyMet); +// MatrixND catchRatePerStrategyMet = siMatrix.matrixCatchRatePerStrategyMet(pop, date, matrixFishingMortality); +// resManager.addResult(date, pop, catchRatePerStrategyMet); // this matrix is necessary for PopulationMonitor.holdCatch (reused in rule) - MatrixND catchPerStrategyMet = siMatrix.matrixCatchPerStrategyMet(N, pop, date, catchRatePerStrategyMet); - popMon.holdCatch(pop, catchPerStrategyMet); - resManager.addResult(date, pop, catchPerStrategyMet); + MatrixND catchPerStrategyMetPerZonePop = + siMatrix.matrixCatchPerStrategyMetPerZonePop(N, pop, date); + popMon.holdCatch(pop, catchPerStrategyMetPerZonePop); + resManager.addResult(date, pop, catchPerStrategyMetPerZonePop); - if (resManager.isEnabled(ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET)) { - MatrixND catchWeightPerStrategyMet = siMatrix.matrixCatchWeightPerStrategyMet(pop, date, catchPerStrategyMet); + if (resManager.isEnabled(ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET_PER_ZONE_POP)) { + MatrixND catchWeightPerStrategyMet = + siMatrix.matrixCatchWeightPerStrategyMetPerZonePop(date, pop, + catchPerStrategyMetPerZonePop); resManager.addResult(date, pop, catchWeightPerStrategyMet); } + + 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); + resManager.addResult(date, pop, catchWeightPerStrategyMet); + } + + } log.debug("abundance: " + abundance);