- Isis-fish-community-commits - mailman.cloud.codelutin.com

r31 - trunk/rules
by loic＠users.forge.codelutin.com 02 May '13

02 May '13

Author: loic Date: 2013-05-02 18:54:16 +0200 (Thu, 02 May 2013) New Revision: 31 Url: http://forge.codelutin.com/projects/isis-fish-community/repository/revision… Log: TAC_poids_pop_3ans Added: trunk/rules/TACpoidsPop20082011.java Added: trunk/rules/TACpoidsPop20082011.java =================================================================== --- trunk/rules/TACpoidsPop20082011.java (rev 0) +++ trunk/rules/TACpoidsPop20082011.java 2013-05-02 16:54:16 UTC (rev 31) @@ -0,0 +1,363 @@ +/* + * #%L + * IsisFish data + * %% + * Copyright (C) 2006 - 2011 Ifremer, CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-2.0.html>. + * #L% + */ +package rules; + +import static org.nuiton.i18n.I18n._; + +import java.util.HashSet; +import java.util.Set; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.math.matrix.MatrixIterator; +import org.nuiton.math.matrix.MatrixND; + +import scripts.ResultName; +import scripts.RuleUtil; +import scripts.SiMatrix; +import fr.ifremer.isisfish.datastore.ResultStorage; +import fr.ifremer.isisfish.entities.EffortDescription; +import fr.ifremer.isisfish.entities.Metier; +import fr.ifremer.isisfish.entities.Population; +import fr.ifremer.isisfish.entities.Species; +import fr.ifremer.isisfish.entities.Strategy; +import fr.ifremer.isisfish.entities.StrategyMonthInfo; +import fr.ifremer.isisfish.entities.TargetSpecies; +import fr.ifremer.isisfish.rule.AbstractRule; +import fr.ifremer.isisfish.simulator.MetierMonitor; +import fr.ifremer.isisfish.simulator.PopulationMonitor; +import fr.ifremer.isisfish.simulator.SimulationContext; +import fr.ifremer.isisfish.types.TimeStep; +import fr.ifremer.isisfish.types.Month; +import fr.ifremer.isisfish.util.Doc; + +/** + * TAC peut-etre utilise pour les differents TAC, en proportion des effectifs + * et/ou avec survie ou non. + * + * <li>Pour utiliser le tac proportionnel, il faut mettre dans le parametre + * propTac une valeur > 0, le TAC sera alors recalcule a chaque mois de janvier. + * <li>Pour utiliser la survie il faut mettre dans le parametre propSurvie une + * valeur > 0, automatiquement les suvie seront ajoute aux effectifs + * + * Created: 7 septembre 2006 + * + * @author anonymous <anonymous(a)labs.libre-entreprise.org> + * @version $Revision: 1.3 $ + * + * Last update: $Date: 13/12/2012 $ + * by : $Author: Loic $ + */ +public class TACpoidsPop20082011 extends AbstractRule { + + /** to use log facility, just put in your code: log.info("..."); */ + static private Log log = LogFactory.getLog(TACpoidsPop20082011.class); + + @Doc("Affected population") + public Population param_population = null; + + @Doc("Proportion de survie") + public double param_propSurvie = 0; + + + /** TAC in tonnes */ + + @Doc("TAC in tons 2008") + public double param_tacInTons2008 = 4000; + @Doc("TAC in tons 2009") + public double param_tacInTons2009 = 3500; + @Doc("TAC in tons 2010") + public double param_tacInTons2010 = 3000; + + boolean affectation = true; + + protected String[] necessaryResult = { + // put here all necessary result for this rule + // example: + // ResultName.MATRIX_BIOMASS, + // ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET, + }; + + /** + * @return the necessaryResult + */ + @Override + public String[] getNecessaryResult() { + return this.necessaryResult; + } + + /** + * Permet d'afficher a l'utilisateur une aide sur la regle. + * + * @return L'aide ou la description de la regle + */ + @Override + public String getDescription() { + return _("TAC weight in tons.\nIf you want survival discard use propSurvie other than 0.\nIf you wish TAC computed as a proportion of the biomass use propTac other than 0."); + } + + /** + * Appele au demarrage de la simulation, cette methode permet d'initialiser + * des valeurs + * + * @param context La simulation pour lequel on utilise cette regle + */ + @Override + public void init(SimulationContext context) throws Exception { + } + + /** + * La condition qui doit etre vrai pour faire les actions. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + * @return vrai si on souhaite que les actions soit faites + */ + @Override + public boolean condition(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + log.info("test si TAC atteint"); + + //param_population = (Population) context.getDB().findByTopiaId(param_population.getTopiaId()); + + double tacInTons = 0; + boolean result = false; + if (step.getYear()>2) { + result = false; + } else { + if (step.getYear()==0) { + tacInTons = param_tacInTons2008; + } else if (step.getYear()==1) { + tacInTons = param_tacInTons2009; + } else if (step.getYear()==2) { + tacInTons = param_tacInTons2010; + context.setValue("tacInTons_" + param_population.getName() + "_2010", tacInTons); + log.info("tacInTons2010 = " + tacInTons); + log.info("param_tacInTons2010 = " + param_tacInTons2010); + } + + TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) + .getSpeciesTargetSpecies(param_population.getSpecies()); + + if (ts != null) { + double catchTons = RuleUtil.getTotalCatchTonsPop(context, param_population, step); + log.info("catchTons = " + catchTons); + log.info("[TAC] catchTons = " + catchTons + " >= tacInTons:" + tacInTons); + if (catchTons >= tacInTons) { + result = true; + } + } + log.info("tacInTons = " + tacInTons); + } + return result; + } + + /** + * Si la condition est vrai alors cette action est executee avant le pas + * de temps de la simulation. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + */ + @Override + public void preAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + //context.setValue("tacInTons2010", param_tacInTons2010); + + affectation = true; //true ? + + log.info("[TAC] preAction for: " + metier); + log.info(" TAC atteint [TAC] preAction for: " + metier); + TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) + .getSpeciesTargetSpecies(param_population.getSpecies()); + if (ts != null && ts.getPrimaryCatch()) { + // recupere tous les metiers qui ont l'espece en capture principale =>metiers vises + // aimedMetiers ne fonctionne pas je ne sais pas pourquoi ! mais au final forbiddenMetier aura le meme effet + + context.getMetierMonitor().addforbiddenMetier(metier); + + //recupere toutes les strategies pratiquant le metier et pour lesquelles la proportion !=0 + SiMatrix siMatrix = SiMatrix.getSiMatrix(context); + Set<Strategy> strs = new HashSet<Strategy>(); + for (Strategy str : siMatrix.getStrategies(step)) { + double prop = str.getStrategyMonthInfo(step.getMonth()) + .getProportionMetier(metier); + if (prop != 0) { + strs.add(str); + } + } + + for (Strategy str : strs) { + StrategyMonthInfo smi = str.getStrategyMonthInfo(step + .getMonth()); + + // 1er cas de figure: l'effort est reporte sur un metier de la + // meme strategie, n'ayant pas l'espece comme capture principale + // et pechant avec le meme engin + Set<Metier> possibleMetierCase1 = new HashSet<Metier>(); + // second cas de figure: on cherche un metier de substitution + // sans condition sur les engins, mais qui soit pratique + Set<Metier> possibleMetierCase2 = new HashSet<Metier>(); + // 3 eme cas de figure: on cherche des metiers non vises, + // sans consideration sur les engins, et pour lesquels la + // proportion peut etre nulle + Set<Metier> possibleMetierCase3 = new HashSet<Metier>(); + + for (EffortDescription effort : str.getSetOfVessels() + .getPossibleMetiers()) { + Metier newMetier = effort.getPossibleMetiers(); + if ( + /*!aimedMetiers.contains(newMetier) + &&*/!metier.getName().equalsIgnoreCase("nonActiviy") + && !metier.getName().equalsIgnoreCase("nonActivie") + && !metier.getName().equalsIgnoreCase( + "non Activite") + && !context.getMetierMonitor().getForbiddenMetier() + .contains(newMetier)) { + possibleMetierCase3.add(newMetier); + + if (smi.getProportionMetier(newMetier) != 0) { + possibleMetierCase2.add(newMetier); + + if (metier.getGear().equals(newMetier.getGear())) { + possibleMetierCase1.add(newMetier); + } + } + } + } + + Set<Metier> possibleMetier = null; + if (possibleMetierCase1.size() != 0) { + log.info("[TAC] Use case 1"); + possibleMetier = possibleMetierCase1; + } else if (possibleMetierCase2.size() != 0) { + log.info("[TAC] Use case 2"); + possibleMetier = possibleMetierCase2; + } else if (possibleMetierCase3.size() != 0) { + log.info("[TAC] Use case 3"); + possibleMetier = possibleMetierCase3; + } + + if (possibleMetier != null) { + // on repartit maintenant l'effort entre les differents metiers + // possibles dans la meme strategie si un metier possible existe + // bien la repartion est proportionnelle a l'effort deja alloue + // dans la strategie + + double somme = 0; + for (Metier met : possibleMetier) { + somme += smi.getProportionMetier(met); + } + for (Metier met : possibleMetier) { + double newProportion = smi.getProportionMetier(met) + + (smi.getProportionMetier(metier) + * smi.getProportionMetier(met) / somme); + smi.setProportionMetier(met, newProportion); + } + smi.setProportionMetier(metier, 0); //le metier vise a alors une proportion nulle + log.info("[TAC] il y a des metiers possibles"); + } else { + log.info("[TAC] Use no activity"); + + // sinon on met tout dans le metier nonActivite + MetierMonitor metierMon = context.getMetierMonitor(); + MatrixND mat = metierMon.getOrCreateNoActivity(step, + ResultName.MATRIX_NO_ACTIVITY, siMatrix + .getStrategies(step), siMatrix + .getMetiers(step)); + mat.setValue(str, metier, smi.getProportionMetier(metier)); + + smi.getProportionMetier().setValue(metier, 0); + } + } + } + } + + /** + * Si la condition est vrai alors cette action est execute apres le pas + * de temps de la simulation. + * + * @param context La simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + */ + @Override + public void postAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + log.info("[TAC] postAction for: " + metier); + + if (affectation) { // sans ! ? + // 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) + ////// + PopulationMonitor popMon = context.getPopulationMonitor(); + log.info("popMon biomass" + popMon.getBiomass(param_population)); // A priori on travaille ici sur une pop donnee car on defini le TAC sur une seule pop... Donc pas la peine de boucler sur les populations. + + //if (!param_population.getName().equals("param_population_new")) { + log.info("param_population : " + param_population.getName()); + // si on a deja une matrice rejet on le vide (elle vient + // forcement de la regle taille minimale or si le tac est + // atteint, tout va dorenavent dans les rejets et on met + // TOUTES les captures dans les rejets + MatrixND discard = popMon.getDiscard(step, param_population); + //log.info("discard : " + discard); + if (discard != null) { + discard.mults(0); + } + log.info("catch = " + popMon.getCatch(param_population)); + MatrixND discardRegle = popMon.getCatch(param_population).copy(); //nouvelle instance pour le calcul dans la regle + // ca ne doit pas pouvoir marcher car MATRIX_DISCARDS_PER_STR_MET est de dimension pop groupe str met - et discard n'a plus la dimension pop + discardRegle.setName(ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); + popMon.addDiscard(step, param_population, discardRegle); + log.info("[TAC] add discard for " + param_population + ": " + + discardRegle); + if (param_propSurvie > 0) { + MatrixND eff = popMon.getN(param_population); + //on rajoute les survivants aux effectifs + for (MatrixIterator i = discardRegle.iterator(); i + .next();) { + Object[] coord = i.getSemanticsCoordinates(); + eff.setValue(coord[2], coord[3], eff.getValue( + coord[2], coord[3]) + + i.getValue() * param_propSurvie); + } + } + //} + // on a affecte une fois cette meta pop au rejet il ne faut pas + // le refaire + affectation = false; // false ? + } + //context.setValue("tacInTons2010", param_tacInTons2010); + } +}

1 0

r30 - trunk/rules
by loic＠users.forge.codelutin.com 02 May '13

02 May '13

Author: loic Date: 2013-05-02 18:53:44 +0200 (Thu, 02 May 2013) New Revision: 30 Url: http://forge.codelutin.com/projects/isis-fish-community/repository/revision… Log: TAC_poids_pop Added: trunk/rules/TACpoidsPop.java Added: trunk/rules/TACpoidsPop.java =================================================================== --- trunk/rules/TACpoidsPop.java (rev 0) +++ trunk/rules/TACpoidsPop.java 2013-05-02 16:53:44 UTC (rev 30) @@ -0,0 +1,372 @@ +/* + * #%L + * IsisFish data + * %% + * Copyright (C) 2006 - 2011 Ifremer, CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-2.0.html>. + * #L% + */ +package rules; + +import static org.nuiton.i18n.I18n._; + +import java.util.HashSet; +import java.util.Set; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.math.matrix.MatrixIterator; +import org.nuiton.math.matrix.MatrixND; + +import scripts.ResultName; +import scripts.RuleUtil; +import scripts.SiMatrix; +import fr.ifremer.isisfish.datastore.ResultStorage; +import fr.ifremer.isisfish.entities.EffortDescription; +import fr.ifremer.isisfish.entities.Metier; +import fr.ifremer.isisfish.entities.Population; +import fr.ifremer.isisfish.entities.Species; +import fr.ifremer.isisfish.entities.Strategy; +import fr.ifremer.isisfish.entities.StrategyMonthInfo; +import fr.ifremer.isisfish.entities.TargetSpecies; +import fr.ifremer.isisfish.rule.AbstractRule; +import fr.ifremer.isisfish.simulator.MetierMonitor; +import fr.ifremer.isisfish.simulator.PopulationMonitor; +import fr.ifremer.isisfish.simulator.SimulationContext; +import fr.ifremer.isisfish.types.TimeStep; +import fr.ifremer.isisfish.types.Month; +import fr.ifremer.isisfish.util.Doc; + +/** + * TAC peut-etre utilise pour les differents TAC, en proportion des effectifs + * et/ou avec survie ou non. + * + * <li>Pour utiliser le tac proportionnel, il faut mettre dans le parametre + * propTac une valeur > 0, le TAC sera alors recalcule a chaque mois de janvier. + * <li>Pour utiliser la survie il faut mettre dans le parametre propSurvie une + * valeur > 0, automatiquement les suvie seront ajoute aux effectifs + * + * Created: + * + * @author anonymous <anonymous(a)labs.libre-entreprise.org> + * @version $Revision: 1.3 $ + * + * Last update: $Date: 010812 $ + * by : $Author: Loic $ + */ +public class TACpoidsPop extends AbstractRule { + + /** to use log facility, just put in your code: log.info("..."); */ + static private Log log = LogFactory.getLog( TACpoidsPop.class); + + // @Doc("Affected species") + //public Species param_species = null; + @Doc("Affected population") + public Population param_population = null; + @Doc("Begin date") + public TimeStep param_beginStep = new TimeStep(0); + @Doc("End date") + public TimeStep param_endStep = new TimeStep(90); + @Doc("Proportion de survie") + public double param_propSurvie = 0; + @Doc("Proportionnal TAC") + public double param_propTac = 0; + + /** TAC in tonnes */ + @Doc("TAC in tons") + public double param_tacInTons = 900; + + boolean affectation = false; + + protected String[] necessaryResult = { + // put here all necessary result for this rule + // example: + // ResultName.MATRIX_BIOMASS, + // ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET, + }; + + /** + * @return the necessaryResult + */ + @Override + public String[] getNecessaryResult() { + return this.necessaryResult; + } + + /** + * Permet d'afficher a l'utilisateur une aide sur la regle. + * + * @return L'aide ou la description de la regle + */ + @Override + public String getDescription() { + return _("TAC weight in tons per population.\nIf you want survival discard use propSurvie other than 0.\nIf you wish TAC computed as a proportion of the biomass use propTac other than 0."); + } + + /** + * Appele au demarrage de la simulation, cette methode permet d'initialiser + * des valeurs + * + * @param context La simulation pour lequel on utilise cette regle + */ + @Override + public void init(SimulationContext context) throws Exception { + } + + /** + * La condition qui doit etre vrai pour faire les actions. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + * @return vrai si on souhaite que les actions soit faites + */ + @Override + public boolean condition(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + log.info("test si TAC atteint"); + // read species in current session + //param_species = (Species) context.getDB().findByTopiaId( + //param_species.getTopiaId()); + + param_population = (Population) context.getDB().findByTopiaId( + param_population.getTopiaId()); + + // on fait le calcul du tac si necessaire + if (param_propTac > 0 && step.getMonth().equals(Month.JANUARY)) { + PopulationMonitor popMon = context.getPopulationMonitor(); + param_tacInTons = popMon.getBiomass(param_population) * param_propTac; + } + + boolean result = false; + if (step.before(param_beginStep)) { + result = false; + } else if (step.after(param_endStep)) { + result = false; + } else { + TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) + .getSpeciesTargetSpecies(param_population.getSpecies()); + if (ts != null) { + double catchTons = RuleUtil.getTotalCatchTonsPop(context, + param_population, step); + + //PopulationMonitor popMon = context.getPopulationMonitor(); + //double catchTons = popMon.getTotalHoldCatch(param_population); // Rend une matrice (dimensions ??) utiliser getTotalHoldCatch(Population pop) (qui rend un double) a la place ?? + + log.info("[TAC] catchTons = " + catchTons + + " >= param_tacInTons:" + param_tacInTons); + if (catchTons >= param_tacInTons) { + result = true; + } + } + } + return result; + } + + /** + * Si la condition est vrai alors cette action est executee avant le pas + * de temps de la simulation. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + */ + @Override + public void preAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + affectation = false; + + log.info("[TAC] preAction for: " + metier); + log.info(" TAC atteint [TAC] preAction for: " + metier); + TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) + .getSpeciesTargetSpecies(param_population.getSpecies()); + if (ts != null && ts.getPrimaryCatch()) { + // recupere tous les metiers qui ont l'espece en capture principale =>metiers vises + // aimedMetiers ne fonctionne pas je ne sais pas pourquoi ! mais au final forbiddenMetier aura le meme effet + + context.getMetierMonitor().addforbiddenMetier(metier); + + //recupere toutes les strategies pratiquant le metier et pour lesquelles la proportion !=0 + SiMatrix siMatrix = SiMatrix.getSiMatrix(context); + Set<Strategy> strs = new HashSet<Strategy>(); + for (Strategy str : siMatrix.getStrategies(step)) { + double prop = str.getStrategyMonthInfo(step.getMonth()) + .getProportionMetier(metier); + if (prop != 0) { + strs.add(str); + } + } + + for (Strategy str : strs) { + StrategyMonthInfo smi = str.getStrategyMonthInfo(step + .getMonth()); + + // 1er cas de figure: l'effort est reporte sur un metier de la + // meme strategie, n'ayant pas l'espece comme capture principale + // et pechant avec le meme engin + Set<Metier> possibleMetierCase1 = new HashSet<Metier>(); + // second cas de figure: on cherche un metier de substitution + // sans condition sur les engins, mais qui soit pratique + Set<Metier> possibleMetierCase2 = new HashSet<Metier>(); + // 3 eme cas de figure: on cherche des metiers non vises, + // sans consideration sur les engins, et pour lesquels la + // proportion peut etre nulle + Set<Metier> possibleMetierCase3 = new HashSet<Metier>(); + + for (EffortDescription effort : str.getSetOfVessels() + .getPossibleMetiers()) { + Metier newMetier = effort.getPossibleMetiers(); + if ( + /*!aimedMetiers.contains(newMetier) + &&*/!metier.getName().equalsIgnoreCase("nonActiviy") + && !metier.getName().equalsIgnoreCase("nonActivie") + && !metier.getName().equalsIgnoreCase( + "non Activite") + && !context.getMetierMonitor().getForbiddenMetier() + .contains(newMetier)) { + possibleMetierCase3.add(newMetier); + + if (smi.getProportionMetier(newMetier) != 0) { + possibleMetierCase2.add(newMetier); + + if (metier.getGear().equals(newMetier.getGear())) { + possibleMetierCase1.add(newMetier); + } + } + } + } + + Set<Metier> possibleMetier = null; + if (possibleMetierCase1.size() != 0) { + log.info("[TAC] Use case 1"); + possibleMetier = possibleMetierCase1; + } else if (possibleMetierCase2.size() != 0) { + log.info("[TAC] Use case 2"); + possibleMetier = possibleMetierCase2; + } else if (possibleMetierCase3.size() != 0) { + log.info("[TAC] Use case 3"); + possibleMetier = possibleMetierCase3; + } + + if (possibleMetier != null) { + // on repartit maintenant l'effort entre les differents metiers + // possibles dans la meme strategie si un metier possible existe + // bien la repartion est proportionnelle a l'effort deja alloue + // dans la strategie + + double somme = 0; + for (Metier met : possibleMetier) { + somme += smi.getProportionMetier(met); + } + for (Metier met : possibleMetier) { + double newProportion = smi.getProportionMetier(met) + + (smi.getProportionMetier(metier) + * smi.getProportionMetier(met) / somme); + smi.setProportionMetier(met, newProportion); + } + smi.setProportionMetier(metier, 0); //le metier vise a alors une proportion nulle + log.info("[TAC] il y a des metiers possibles"); + } else { + log.info("[TAC] Use no activity"); + + // sinon on met tout dans le metier nonActivite + MetierMonitor metierMon = context.getMetierMonitor(); + MatrixND mat = metierMon.getOrCreateNoActivity(step, + ResultName.MATRIX_NO_ACTIVITY, siMatrix + .getStrategies(step), siMatrix + .getMetiers(step)); + mat.setValue(str, metier, smi.getProportionMetier(metier)); + + smi.getProportionMetier().setValue(metier, 0); + } + } + } + } + + /** + // * Si la condition est vrai alors cette action est executee apres le pas + * de temps de la simulation. + * + * @param context La simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + */ + @Override + public void postAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + ResultStorage resultmanager = context.getSimulationStorage() + .getResultStorage(); + log.info("[TAC] postAction for: " + metier); + TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) + .getSpeciesTargetSpecies(param_population.getSpecies()); + if (ts != null) { + if (!affectation) { + // 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) + ////// + PopulationMonitor popMon = context.getPopulationMonitor(); + log.info("popMon biomass" + popMon.getBiomass(param_population)); // A priori on travaille ici sur une pop donnee car on defini le TAC sur une seule pop... Donc pas la peine de boucler sur les populations. + + if (!param_population.getName().equals("param_population_new")) { + log.info("param_population : " + param_population.getName()); + // si on a deja une matrice rejet on le vide (elle vient + // forcement de la regle taille minimale or si le tac est + // atteint, tout va dorenavent dans les rejets et on mais + // TOUTES les captures dans les rejets + MatrixND discard = popMon.getDiscard(step, param_population); + log.info("discard : " + discard); + if (discard != null) { + discard.mults(0); + } + log.info("catch = " + popMon.getCatch(param_population)); + discard = popMon.getCatch(param_population).copy(); + // ca ne doit pas pouvoir marcher car MATRIX_DISCARDS_PER_STR_MET est de dimension pop groupe str met - et discard n'a plus la dimension pop + discard.setName(ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); + popMon.addDiscard(step, param_population, discard); + log.info("[TAC] add discard for " + param_population + ": " + + discard); + // ne manquerait-il pas + resultmanager.addResult(step, param_population, discard); + if (param_propSurvie > 0) { + MatrixND eff = popMon.getN(param_population); + //on rajoute les survivants aux effectifs + for (MatrixIterator i = discard.iterator(); i + .next();) { + Object[] coord = i.getSemanticsCoordinates(); + eff.setValue(coord[2], coord[3], eff.getValue( + coord[2], coord[3]) + + i.getValue() * param_propSurvie); + } + } + + } + + // on a affecte une fois cette meta pop au rejet il ne faut pas + // le refaire + affectation = true; + } + } + } + +}

1 0

r29 - trunk/rules
by loic＠users.forge.codelutin.com 02 May '13

02 May '13

Author: loic Date: 2013-05-02 18:53:25 +0200 (Thu, 02 May 2013) New Revision: 29 Url: http://forge.codelutin.com/projects/isis-fish-community/repository/revision… Log: HCR_transition_MSY Added: trunk/rules/HCR_transition_MSY.java Added: trunk/rules/HCR_transition_MSY.java =================================================================== --- trunk/rules/HCR_transition_MSY.java (rev 0) +++ trunk/rules/HCR_transition_MSY.java 2013-05-02 16:53:25 UTC (rev 29) @@ -0,0 +1,337 @@ +/* + * #%L + * IsisFish data + * %% + * Copyright (C) 2006 - 2011 Ifremer, CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-2.0.html>. + * #L% + */ +package rules; + +import static org.nuiton.i18n.I18n._; + +import java.util.HashSet; +import java.util.Set; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.math.matrix.MatrixIterator; +import org.nuiton.math.matrix.MatrixND; + +import scripts.ResultName; +import scripts.RuleUtil; +import scripts.SiMatrix; +import fr.ifremer.isisfish.datastore.ResultStorage; +import fr.ifremer.isisfish.entities.EffortDescription; +import fr.ifremer.isisfish.entities.Metier; +import fr.ifremer.isisfish.entities.Population; +import fr.ifremer.isisfish.entities.PopulationGroup; +import fr.ifremer.isisfish.entities.Species; +import fr.ifremer.isisfish.entities.Strategy; +import fr.ifremer.isisfish.entities.StrategyMonthInfo; +import fr.ifremer.isisfish.entities.TargetSpecies; +import fr.ifremer.isisfish.entities.Zone; // ??????? +import fr.ifremer.isisfish.rule.AbstractRule; +import fr.ifremer.isisfish.simulator.MetierMonitor; +import fr.ifremer.isisfish.simulator.PopulationMonitor; +import fr.ifremer.isisfish.simulator.SimulationContext; +import fr.ifremer.isisfish.types.TimeStep; +import fr.ifremer.isisfish.types.Month; +import fr.ifremer.isisfish.util.Doc; + +/** + * Le but de cette regle est de permettre de simuler une harvest control rule, + * et plus precisemment la transition entre une gestion par approche de precaution + * et une gestion par le MSY. + * + * La premiere annee de transition est 2011 et la derniere 2014, pour une gestion + * au MSY des 2015. + * + *Ici cette regle va s'appliquer a partir de la quatrieme annee de simu (annee initiale=2008) + * et a chacune des 4 populations simulees, alors que jusqu'a 2010 on avait un TAC commun pour la plie. + * + * Created: + * + * @author anonymous <anonymous(a)labs.libre-entreprise.org> + * @version $Revision: 0.1 $ + * + * Last update: $Date: 131212 $ + * by : $Author: Loic $ + */ +public class HCR_transition_MSY extends AbstractRule { + + /** to use log facility, just put in your code: log.info("..."); */ + static private Log log = LogFactory.getLog(HCR_transition_MSY.class); + + @Doc("Affected population") + public Population param_populationHCR = null; + @Doc("Begin date") + public TimeStep param_beginStep = new TimeStep(36); + @Doc("End date") + public TimeStep param_endStep = new TimeStep(119); + @Doc("Fmsy") + public double param_fmsy = 0.29; + @Doc("Fpa") + public double param_fpa = 0.4; + @Doc("MSY Btrigger") + public double param_msyBtrigger = 8000; // Attention aux unites : kg VS t + @Doc("Duration of transition period (year)") + public double param_transitionDuration = 5; + @Doc("Proportion de survie") + public double param_propSurvieHCR = 0; + @Doc("Variation annuelle max du TAC ") + public double param_varTac = 0.15; + + public double Tac2010 = 0; + + boolean affectation = false; + + protected String[] necessaryResult = { + // put here all necessary result for this rule + // example: + // ResultName.MATRIX_BIOMASS, + // ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET, + ResultName.MATRIX_BIOMASS, + ResultName.MATRIX_TOTAL_FISHING_MORTALITY, + + }; + + /** + * @return the necessaryResult + */ + @Override + public String[] getNecessaryResult() { + return this.necessaryResult; + } + + /** + * Permet d'afficher a l'utilisateur une aide sur la regle. + * + * @return L'aide ou la description de la regle + */ + @Override + public String getDescription() { + return _("Harvest Control Rule simulatinf the transition between a precautionary approach management and a MSY management, for a given populaion"); + } + + /** + * Appele au demarrage de la simulation, cette methode permet d'initialiser + * des valeurs + * + * @param context La simulation pour lequel on utilise cette regle + */ + @Override + public void init(SimulationContext context) throws Exception { + } + + /** + * La condition qui doit etre vrai pour faire les actions. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + * @return vrai si on souhaite que les actions soit faites + */ + @Override + public boolean condition(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + boolean result = false; + + if (step.after(param_beginStep) && step.before(param_endStep) && step.getMonth() == Month.FEBRUARY){ // .previous() // JANUARY ? + result = true; + } + return result; + } + + /** + * Si la condition est vrai alors cette action est executee avant le pas + * de temps de la simulation. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + */ + @Override + public void preAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + Tac2010 = (Double) context.getValue("tacInTons_" + param_populationHCR.getName() + "_2010"); + log.info("Tac2010 = " + Tac2010); + + affectation = false; + + log.info("Mise en place de l'HCR"); + + ResultStorage matResult = context.getSimulationStorage().getResultStorage(); + + // Import de la mortalite par peche de 2010 + MatrixND MatF2010 = matResult.getMatrix(param_beginStep.previous(), param_populationHCR, ResultName.MATRIX_TOTAL_FISHING_MORTALITY); // Ne marche que si param_beginStep est Janvier 2011 + double F2010 = MatF2010.sumAll(); + log.info("F2010 = " + F2010); + + // Import de la biomasse de l'annee en cours + MatrixND MatBiom = matResult.getMatrix(step.previous(), param_populationHCR, ResultName.MATRIX_BIOMASS); // step, + MatBiom = MatBiom.reduce(); + log.info("MatBiom = " + MatBiom); + + + // Calcul de la SSB de l'annee en cours + double SSBiom = 0; + + for (MatrixIterator i=MatBiom.iterator(); i.hasNext();) { + i.next(); + Object [] sems = i.getSemanticsCoordinates(); + PopulationGroup group = (PopulationGroup)sems[0]; + + double val = i.getValue()* group.getMaturityOgive(); + + SSBiom = SSBiom + val; + } + SSBiom = SSBiom / 1000; + log.info("SSBiom = " + SSBiom); + + // Comparaison de la SSB a MSYBtrigger et calcul de fMsyHcr + double fMsyHcr = 0; + log.info("param_fmsy = " + param_fmsy); + + if ( SSBiom < param_msyBtrigger) { + double triggerMult = 1 - SSBiom / param_msyBtrigger; + fMsyHcr = param_fmsy - triggerMult * param_fmsy; + } + else { + fMsyHcr = param_fmsy; + } + log.info("fMsyHcr = " + fMsyHcr); + + // Calcul des multiplicateurs a appliquer a F2010 et fMsyHCR + double multF2010 = 1 - (step.getYear() - (param_beginStep.getYear() - 1)) * (1/param_transitionDuration); + if (multF2010 < 0){ + multF2010 = 0; + } + double multFmsy = 0 + (step.getYear() - (param_beginStep.getYear() - 1)) * (1/param_transitionDuration); + if (multFmsy > 1){ + multFmsy = 1; + } + log.info("multF2010 = " + multF2010); + log.info("multFmsy = " + multFmsy); + + // Calcul de fMsyHcrTransition + double fMsyHcrTransition = multF2010 * F2010 + multFmsy * fMsyHcr; + log.info("fMsyHcrTransition = " + fMsyHcrTransition); + + // Si fMsyHcrTransition > fpa on applique fpa + double AppliedF = 0; + log.info("param_fpa = " + param_fpa); + + if (fMsyHcrTransition < param_fpa) { + AppliedF = fMsyHcrTransition; + } + else { + AppliedF = param_fpa; + } + log.info("AppliedF = " + AppliedF); + + // Calcul du niveau de captures correspondant au F choisi + double TAC = AppliedF * SSBiom; + log.info("TAC = " + TAC); + + // Si niveau de captures inferieur de plus de 15 pcts au TAC de l'annee precedente limiter a 15 pcts + double diffTac = 0; + double TacReel = 0; + double TacPrevYr = 0; + + if (step.getYear() == param_beginStep.getYear()){ + diffTac = TAC / Tac2010 - 1; + log.info("diffTac = " + diffTac); + if (diffTac < -1 * param_varTac){ + TacReel = Tac2010 - param_varTac * Tac2010; + } + else if (diffTac >= param_varTac){ + TacReel = Tac2010 + param_varTac * Tac2010; + } + else { + TacReel = TAC; + } + } + else { + // retrouver le niveau de TAC de l'annee precedente + TacPrevYr = (Double) context.getValue("TAC_" + param_populationHCR.getName() + "_HCR"); + log.info("TacPrevYr = " + TacPrevYr); + diffTac = TAC / TacPrevYr - 1; + log.info("diffTac = " + diffTac); + if (diffTac < -1 * param_varTac){ + TacReel = TacPrevYr - param_varTac * TacPrevYr; + } + else if (diffTac >= param_varTac){ + TacReel = TacPrevYr + param_varTac * TacPrevYr; + } + else { + TacReel = TAC; + } + } + log.info("TacReel = " + TacReel); + + // Stocker le TAC dans une matrice (pour pouvoir comparer les annees entre elles) + + // Faire en sorte que le TAC soit utilise par la regle TACPoidsPop_PourHCR + context.setValue("TAC_" + param_populationHCR.getName() + "_HCR", TacReel); //TacReel + context.setValue("BeginStep_TAC_" + param_populationHCR.getName() + "_HCR", step); // Pas besoin de EndStep car on sait que c'est BeginStep+12 (mis dans regle TAC) + //context.setValue("Population_TAC_HCR", param_populationHCR); + context.setValue("PropSurvie_TAC_" + param_populationHCR.getName() + "_HCR", param_propSurvieHCR); + + } + + /** + // * Si la condition est vrai alors cette action est executee apres le pas + * de temps de la simulation. + * + * @param context La simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + */ + @Override + public void postAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + // Creation de la matrice de stockage de TAC + //ResultStorage resultmanager = context.getSimulationStorage().getResultStorage(); + // + // if (!affectation){ + // + // // Ici les TACs sont definis au niveau de la population + // public MatrixND matrixTacPop(TimeStep step, Population pop) throws TopiaException { // ResultStorage resManager ? + // + // List<Population> populations = Collections.singletonList(pop); + // + // MatrixND TacPopMatrix = MatrixFactory.getInstance().create( + // ResultName.MATRIX_TAC_PER_POP, new List[] { populations }, + // new String[] { n_("Populations") }); + // + // if (step.getMonth() == Month.JANUARY) { // Pas besoin car postAction ne s'applique que si la condition est vraie + // TacPopMatrix.setValue(param_population, TacReel); + // } + // else { + // TacPopMatrix.setValue(param_population, 0); + // } + // return TacPopMatrix; + // } + // // on a affecte une fois un TAC a une pop et il ne faut pas le refaire + // affectation = true; + // } + //} + } + +}

1 0

r28 - trunk/rules
by loic＠users.forge.codelutin.com 02 May '13

02 May '13

Author: loic Date: 2013-05-02 18:53:01 +0200 (Thu, 02 May 2013) New Revision: 28 Url: http://forge.codelutin.com/projects/isis-fish-community/repository/revision… Log: gravity_VPUE Added: trunk/rules/GraviteVPUE1_Ponderation.java Added: trunk/rules/GraviteVPUE1_Ponderation.java =================================================================== --- trunk/rules/GraviteVPUE1_Ponderation.java (rev 0) +++ trunk/rules/GraviteVPUE1_Ponderation.java 2013-05-02 16:53:01 UTC (rev 28) @@ -0,0 +1,337 @@ +/* + * #%L + * IsisFish data + * %% + * Copyright (C) 2006 - 2011 Ifremer, CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-2.0.html>. + * #L% + */ +package rules; + +import static org.nuiton.i18n.I18n._; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import scripts.ResultName; +import scripts.SiMatrix; + +import java.util.Arrays; +import java.util.List; +import java.util.Collection; + +import org.nuiton.math.matrix.*; + +import fr.ifremer.isisfish.simulator.SimulationContext; +import fr.ifremer.isisfish.types.TimeStep; +import fr.ifremer.isisfish.types.Month; +import fr.ifremer.isisfish.entities.*; +import fr.ifremer.isisfish.rule.AbstractRule; +import fr.ifremer.isisfish.datastore.ResultStorage; +import fr.ifremer.isisfish.util.Doc; + +/** + * GraviteVPUE1_Ponderation.java + * + * Created: 26 aout 2008 + * + * @author anonymous <anonymous(a)labs.libre-entreprise.org> + * @version $Revision: 257 $ + * + * Last update: $Date: 2011-07-08 15:04:29 +0200 (ven., 08 juil. 2011) $ + * by : $Author: 2SY- Sigrid+Youen+Stephanie $ + */ +public class GraviteVPUE1_Ponderation extends AbstractRule { + + /** to use log facility, just put in your code: log.info("..."); */ + static private Log log = LogFactory.getLog(GraviteVPUE1_Ponderation.class); + + ////Essai de passage de alpha en paramÃƒÂ¨tre de la rÃƒÂ¨gle. + @Doc("fishers behaviour parameter (between 0 and 1)") + public double param_alpha = 0; + + /** stocke la somme des prop initiales [str x month] */ + private MatrixND SommePropInitial = null; + /** stocke par strat*met, la derniÃƒÂ¨re attractivite pour chaque mois [str x met x month] */ + + /** permet de stocker les CPUE nominales [str x met] */ + private MatrixND valuePerUnitOfEffort = null; + + /** declare here all the parameters describing the different scenarios investigated; */ + //public double alpha; //fishers behaviour parameter; + + public String[] necessaryResult = { + // put here all necessary result for this rule + // example: + // ResultName.MATRIX_BIOMASS, + // ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET, + ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET, + //ResultName.MATRIX_EFFORT_PER_STRATEGY_MET, + ResultName.MATRIX_EFFORT_NOMINAL_PER_STRATEGY_MET, // garder la , + + }; + + @Override + public String[] getNecessaryResult() { + return this.necessaryResult; + } + + /** + * Permet d'afficher a l'utilisateur une aide sur la regle. + * @return L'aide ou la description de la regle + */ + @Override + public String getDescription() throws Exception { + return _("Calcule les proportion par metier chaque mois en fonction de la VPUE du metier l'annee precedante"); + /*"HYPOTHESES GRAVITE" + " attention cette rÃƒÂ¨gle doit toujours ÃƒÂªtre mise avant les mesures de gestion"+ + " si pour un metier Effort(metier annee-1,mois) = 0 et propinitiale (metier, mois) !=0 (ie metier potentiellement pratique), alors "+ + on remet propInitiale pour tous les metiers (premiere vue complete pour tous les metiers de la strategie - GraviteVPUE1_Ponderation-, une alternative + pourrait ÃƒÂªtre de chercher lapremiere annee avant annee -1 pour laquelle le metier, ayant une propInitiale non nulle , aurait une VPUE (metier,mois) non nulle + et recuperer la propStr (metier,mois) pour cette annee et on l'affecte annee courante - mois, les autres metiers se partageant la proportion d'effort restante + en fonction de leur VPUE - graviteVPUE2-, une alternative pourrait etre de chercher la premiere annee avant annee -1 pour laquelle tous les metiers, + ayant une propInitiale non nulle, auraient eu une propStr non nulle, (surement difficile a trouver) - - graviteVPUE3- d'autres hypothÃƒÂ¨ses pourraient etre envisagees) + "*/ + } + + /** + * function used to initialise MatrixND to NaN double + */ + private MapFunction nanFunction = new MapFunction() { + @Override + public double apply(double value) { + return Double.NaN; + } + }; + + /** + * Appele au demarrage de la simulation, cette methode permet d'initialiser + * des valeurs + * @param context La simulation pour lequel on utilise cette regle + */ + @Override + public void init(SimulationContext context) throws Exception { + TimeStep step = new TimeStep(0); + + List<Strategy> strs = SiMatrix.getSiMatrix(context).getStrategies(step); + List<Metier> metiers = SiMatrix.getSiMatrix(context).getMetiers(step); + List<Month> months = Arrays.asList(Month.MONTH); + + SommePropInitial = MatrixFactory.getInstance().create( + "SommePropInitial", new List[] { strs, months }, + new String[] { "Strategies", "Months" }); + SommePropInitial.map(nanFunction); + + valuePerUnitOfEffort = MatrixFactory.getInstance().create( + "ValuePerUnitOfEffort", new List[] { strs, metiers }, + new String[] { "Strategies", "Metiers" }); + valuePerUnitOfEffort.map(nanFunction); + + for (Strategy str : strs) { + List<Metier> strMetiers = SiMatrix.getSiMatrix(context).getMetiers( + str, step); + List<StrategyMonthInfo> infos = str.getStrategyMonthInfo(); + for (StrategyMonthInfo info : infos) { + double somme = 0; + for (Metier strMetier : strMetiers) { + somme += info.getProportionMetier(strMetier); + } + // FIXME soit on somme pour toutes les str le meme metier; donc pas de notion de str.getName dans la cle + // soit pour une str on somme tous ces metiers (mais ce doit etre 1; donc pas de notion de metier.getName dans la cle + SommePropInitial.setValue(str, info.getMonth(), somme); + } + } + + /** Setting the different scenarios parameters; */ + //fishers behavior: alpha varies between 0 (fully static) to 1 (fully dynamic); + //alpha = 0.5; + + } + + /** + * La condition qui doit etre vrai pour faire les actions. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + * @return vrai si on souhaite que les actions soit faites + */ + @Override + public boolean condition(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + // Il faut etre au moins au deuxieme pas de temps. + return step.getYear() > 0; + } + + // Booleen permettant que ne boucler que sur un seul metier dans la preaction : + boolean first = true; + + /** + * Si la condition est vrai alors cette action est executee avant le pas + * de temps de la simulation. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + */ + @Override + public void preAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + if (log.isDebugEnabled()) { + log.debug("first = " + first + "step:" + step); + } + //log.info("first = " + first + " ,on passe dans la preaction ?"); + if (first) { // on passe dans preaction pour la premiere fois + //log.info("Oui, preaction : "); + + List<Strategy> strs = SiMatrix.getSiMatrix(context).getStrategies( + step); + //List<Population> populations = SiMatrix.getSiMatrix(context) + // .getPopulations(date); + ResultStorage resultmanager = context.getSimulationStorage() + .getResultStorage(); + + ////////Initialisation des matrices qui resultent de la simulation//////////////////////////////////////////////////////////// + + //Calcul de l effort nominal par strategy met + MatrixND EffortNominalPerStrMet = null; + EffortNominalPerStrMet = resultmanager.getMatrix(step.previousYear(), + ResultName.MATRIX_EFFORT_NOMINAL_PER_STRATEGY_MET); + //System.out.println("EffortNominalPerStrMet calculee " + // + EffortNominalPerStrMet); + + //on commence par creer une matrice de valeurs (somme sur ttes les especes capturees) par strategie met + MatrixND GrossValuePerStrMet = null; + GrossValuePerStrMet = resultmanager.getMatrix(step.previousYear(), + ResultName.MATRIX_GROSS_VALUE_OF_LANDINGS_PER_STRATEGY_MET); + + //System.out.println("GrossValuePerStrMet calculee " + GrossValuePerStrMet); + + //ajouter pour tous les metiers les valeurs liees aux autres espÃƒÂ¨ces calculees par modele lineaire + + ////////////////////////////////////////////////////////////////////////////////////////////////////////// + valuePerUnitOfEffort.map(nanFunction); //reinitialisation avant calcul pour date + + for (Strategy str : strs) { + + //log.info("INFO: Boucle creation valuePerUnitEffort : " + str.getName()); + // log.info("Boucle creation catchperuniteffort : "+ str.getName()); + StrategyMonthInfo smi = str.getStrategyMonthInfo(step.getMonth()); + StrategyMonthInfo smi_1 = str.getStrategyMonthInfo(step.previousYear().getMonth()); + Collection<EffortDescription> strMet = str.getSetOfVessels().getPossibleMetiers(); + //SiMatrix.getSiMatrix(context).getMetiers(str, date); + + // boucle pour tester s'il existe un metier pour lequel effort(metier)=0 et PropInitiale(metier)=0 (Condition) + boolean testCondition = false; + double somme = 0;//initialisation de la somme des VPUE des metiers de la strategie + + for (EffortDescription ed : strMet) { + Metier strMetier = ed.getPossibleMetiers(); + //log.info("Pour str=" + str.getName() + " et metier=" + strMetier.getName()); + double effort = EffortNominalPerStrMet.getValue(str,strMetier); + // on teste effort pour le calcul des VPUE + // si effort != 0 , valeur/effort + //sinon (effort =0) , deux cas de figure : + // 1. soit propInitiale =0 pour ce metier et dans ce cas VPUE =0 et ca ne doit pas impacter le calcul de la gravite pour les autres metiers de str + // 2. soit propInitiale! =0 et dans ce cas, on mettra PropInitiale pour tous les metiers de str + if (effort > 0) {// a peche au mois, annee-1 + //on recupere la capture tot + double value = GrossValuePerStrMet.getValue(str,strMetier); + //log.debug("DEBUG: value : " + value); + //log.debug("DEBUG: effort : " + effort); + double vpue = value / effort; + valuePerUnitOfEffort.setValue(str, strMetier, vpue); + //log.info("value/effort= " + vpue); + somme += value / effort; + } else if ((effort == 0) + & (smi.getProportionMetier(strMetier) == 0)) {// n'a jamais pÃƒÂªche avec ce metier + valuePerUnitOfEffort.setValue(str, strMetier, 0); + //log.info("n'a jamais pÃƒÂªche avec ce metier"); + } else {// n'a pas peche au mois, annee -1, mais avait une prop d'effort non nul a l'annee=0 + testCondition = true;// ie somme est incomplÃƒÂ¨te mais pas grave car on mettra PropInitiale a tous les metiers + //log.info("n'a pas peche au mois, annee -1, mais avait une prop d'effort non nul a l'annee=0"); + } + } + //log.info("testCondition pour str" + str.getName() + // + ":" + testCondition); + // A partir des VPUE stockees dans valuePerUnitOfEffort, on calcule la gravite + double newProp=0.0; + double newProp2=0.0; + //log.info("A partir des VPUE stockees dans valuePerUnitOfEffort, on calcule la gravite"); + if (!testCondition) { + double SommeVPUEstrat = somme; + //System.out.println("SommeVPUEstrat=" + SommeVPUEstrat); + for (EffortDescription ed : strMet) { + Metier strMetier = ed.getPossibleMetiers(); + //System.out.println("PropStrInitiale(metier=" + // + strMetier.getName() + ")" + // + smi.getProportionMetier(strMetier)); + //System.out.println("SommePropInitial.getValue(str, date.getMonth()=" + // + SommePropInitial.getValue(str, date + // .getMonth())); + //System.out.println("valuePerUnitOfEffort.getValue(str, strMetier)" + // + valuePerUnitOfEffort.getValue(str, + // strMetier)); + // si le profit anticipe pour une strategie est negatif ou nul, on abandonne cette strategie + if (SommeVPUEstrat <= 0.0) { + newProp=0.0; + newProp2=0.0; + } else { + // VPUE du metier / VPUE de la strategie + newProp = valuePerUnitOfEffort.getValue(str,strMetier) / SommeVPUEstrat; //Ce sont bien les VPUE de l'annee precedente (step.PreviousYear() dans l'appel) + // Allocation de l'annee precedente + newProp2 = smi_1.getProportionMetier(strMetier); + } + //System.out.println("newProp(metier=" + // + strMetier.getName() + ")" + newProp); + // L'allocation de l'effort a un metier vient a hauteur de param_alpha de newProp et a hauteur de 1-param_alpha de l'allocation de l'anne precedente + smi.setProportionMetier(strMetier,param_alpha*newProp+(1-param_alpha)*newProp2); + //System.out.println("PropStrNouvelle(metier=" + // + strMetier.getName() + ")" + // + smi.getProportionMetier(strMetier)); + } + } + // else ie on met propInitiale dans PropStr(str,annee,mois) + // rien n'a faire car au debut de chaque pas de temps, PropStr + // est par defaut initialise a la valeur de la base de donnees (val initiales) + + }//fin de boucle sur strategy + + first = false; + + }// fin de first= true + + if (log.isDebugEnabled()) { + log.debug("fin Gravite CPUEAction avant"); + } + + } + + ///////////////////////////////fin Gravite CPUEAction avant//////////////////////////// + + /** + * Si la condition est vrai alors cette action est executee apres le pas + * de temps de la simulation. + * + * @param context La simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concerne + */ + @Override + public void postAction(SimulationContext context, TimeStep step, Metier metier) throws Exception { + first = true; + } +}

1 0

r27 - trunk/exports
by loic＠users.forge.codelutin.com 02 May '13

02 May '13

Author: loic Date: 2013-05-02 18:52:28 +0200 (Thu, 02 May 2013) New Revision: 27 Url: http://forge.codelutin.com/projects/isis-fish-community/repository/revision… Log: export_biomasse_feconde Added: trunk/exports/BiomasseFeconde.java Added: trunk/exports/BiomasseFeconde.java =================================================================== --- trunk/exports/BiomasseFeconde.java (rev 0) +++ trunk/exports/BiomasseFeconde.java 2013-05-02 16:52:28 UTC (rev 27) @@ -0,0 +1,96 @@ +/* + * #%L + * IsisFish data + * %% + * Copyright (C) 2006 - 2011 Ifremer, CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-2.0.html>. + * #L% + */ +package exports; + +import static org.nuiton.i18n.I18n._; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.io.Writer; + +import org.nuiton.math.matrix.*; + +import scripts.ResultName; + +import fr.ifremer.isisfish.entities.*; +import fr.ifremer.isisfish.export.Export; +import fr.ifremer.isisfish.types.TimeStep; +import fr.ifremer.isisfish.datastore.SimulationStorage; + +/** + * Biomasses.java + * + * Created: 23 novembre 2006 + * + * @author anonymous <anonymous(a)labs.libre-entreprise.org> + * @version $Revision: $ + * + * Last update: $Date: 28/08/2012$ + * by : $Author:lgasche $ + */ +public class BiomasseFeconde implements Export { + + /** to use log facility, just put in your code: log.info("..."); */ + static private Log log = LogFactory.getLog(BiomasseFeconde.class); + + protected String [] necessaryResult = { + ResultName.MATRIX_BIOMASS + }; + + @Override + public String[] getNecessaryResult() { + return this.necessaryResult; + } + + @Override + public String getExportFilename() { + return "BiomasseFeconde"; + } + + @Override + public String getExtensionFilename() { + return ".csv"; + } + + @Override + public String getDescription() { + return _("Exporte les biomasses fecondes, tableau avec des lignes pop;id;zone;date;nombre"); + } + + @Override + public void export(SimulationStorage simulation, Writer out) throws Exception { + for (Population pop : simulation.getParameter().getPopulations()) { + MatrixND mat = simulation.getResultStorage().getMatrix(pop, ResultName.MATRIX_BIOMASS); + for (MatrixIterator i=mat.iterator(); i.hasNext();) { + i.next(); + Object [] sems = i.getSemanticsCoordinates(); + TimeStep step = (TimeStep)sems[0]; + PopulationGroup group = (PopulationGroup)sems[1]; + Zone zone = (Zone)sems[2]; + + double val = i.getValue()* group.getMaturityOgive(); + out.write(pop.getName() +";"+ group.getId() +";"+ zone.getName() +";"+ step.getStep() +";"+ val +"\n"); + } + } + } +}

1 0

r26 - trunk/exports
by echatellier＠users.forge.codelutin.com 02 May '13

02 May '13

Author: echatellier Date: 2013-05-02 16:59:39 +0200 (Thu, 02 May 2013) New Revision: 26 Url: http://forge.codelutin.com/projects/isis-fish-community/repository/revision… Log: Mise ?\195?\160 jour de la date de copyright Modified: trunk/exports/MortalitePecheGroupe.java Modified: trunk/exports/MortalitePecheGroupe.java =================================================================== --- trunk/exports/MortalitePecheGroupe.java 2012-12-20 11:01:12 UTC (rev 25) +++ trunk/exports/MortalitePecheGroupe.java 2013-05-02 14:59:39 UTC (rev 26) @@ -1,107 +1,107 @@ -/* - * #%L - * IsisFish data - * %% - * Copyright (C) 2006 - 2011 Ifremer, CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 2 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/gpl-2.0.html>. - * #L% - */ -package exports; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -import java.io.Writer; - -import static org.nuiton.i18n.I18n._; -import org.nuiton.math.matrix.*; - -import scripts.ResultName; - -import fr.ifremer.isisfish.entities.*; -import fr.ifremer.isisfish.export.Export; -import fr.ifremer.isisfish.types.TimeStep; -import fr.ifremer.isisfish.datastore.SimulationStorage; - -/** - * FishingMortality.java - * - * Created: 19 Avril 2012 - * - * @author anonymous <anonymous(a)labs.libre-entreprise.org> - * @version $Revision: 0.1 $ - * - * Last update: $Date: 0000-00-00 00:00:00 $ by : $Author: $ - */ -public class MortalitePecheGroupe implements Export { - - /** to use log facility, just put in your code: log.info("..."); */ - static private Log log = LogFactory.getLog(MortalitePecheGroupe.class); - - protected String[] necessaryResult = { ResultName.MATRIX_FISHING_MORTALITY_PER_GROUP, - ResultName.MATRIX_CATCH_PER_STRATEGY_MET_PER_ZONE_POP, - ResultName.MATRIX_ABUNDANCE, - }; - - @Override - public String[] getNecessaryResult() { - return this.necessaryResult; - } - - @Override - public String getExportFilename() { - return "MortalitePecheGroupe"; - } - - @Override - public String getExtensionFilename() { - return ".csv"; - } - - @Override - public String getDescription() { - return _("Exporte la mortalite par peche par groupe et par population de la simulation (Fgroup par an calcule en decembre)"); - } - - @Override - public void export(SimulationStorage simulation, Writer out) - throws Exception { - TimeStep lastStep = simulation.getResultStorage().getLastStep(); - - for (Population pop : simulation.getParameter().getPopulations()) { -// for (PopulationGroup group : pop.getPopulationGroup()) { // Rajouter une boucle sur les groupes ?? - for (TimeStep step = new TimeStep(0); !step.after(lastStep); step = step.next()) { - - MatrixND mat = simulation.getResultStorage().getMatrix(step, - pop, ResultName.MATRIX_FISHING_MORTALITY_PER_GROUP); // group - - if (mat != null) { // can be null if simulation is stopped before last year simulation - for (MatrixIterator i = mat.iterator(); i.hasNext();) { - i.next(); - Object[] sems = i.getSemanticsCoordinates(); - PopulationGroup group = (PopulationGroup)sems[1]; - double val = i.getValue(); - - out.write(pop.getName() + ";" + step.getStep() + ";" + group.getAge() + ";" + val + "\n"); // + ";" + group.getAge() - } - } - } - //} - } - } - } - - +/* + * #%L + * IsisFish data + * %% + * Copyright (C) 2006 - 2013 Ifremer, CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-2.0.html>. + * #L% + */ +package exports; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.io.Writer; + +import static org.nuiton.i18n.I18n._; +import org.nuiton.math.matrix.*; + +import scripts.ResultName; + +import fr.ifremer.isisfish.entities.*; +import fr.ifremer.isisfish.export.Export; +import fr.ifremer.isisfish.types.TimeStep; +import fr.ifremer.isisfish.datastore.SimulationStorage; + +/** + * FishingMortality.java + * + * Created: 19 Avril 2012 + * + * @author anonymous <anonymous(a)labs.libre-entreprise.org> + * @version $Revision: 0.1 $ + * + * Last update: $Date: 0000-00-00 00:00:00 $ by : $Author: $ + */ +public class MortalitePecheGroupe implements Export { + + /** to use log facility, just put in your code: log.info("..."); */ + static private Log log = LogFactory.getLog(MortalitePecheGroupe.class); + + protected String[] necessaryResult = { ResultName.MATRIX_FISHING_MORTALITY_PER_GROUP, + ResultName.MATRIX_CATCH_PER_STRATEGY_MET_PER_ZONE_POP, + ResultName.MATRIX_ABUNDANCE, + }; + + @Override + public String[] getNecessaryResult() { + return this.necessaryResult; + } + + @Override + public String getExportFilename() { + return "MortalitePecheGroupe"; + } + + @Override + public String getExtensionFilename() { + return ".csv"; + } + + @Override + public String getDescription() { + return _("Exporte la mortalite par peche par groupe et par population de la simulation (Fgroup par an calcule en decembre)"); + } + + @Override + public void export(SimulationStorage simulation, Writer out) + throws Exception { + TimeStep lastStep = simulation.getResultStorage().getLastStep(); + + for (Population pop : simulation.getParameter().getPopulations()) { +// for (PopulationGroup group : pop.getPopulationGroup()) { // Rajouter une boucle sur les groupes ?? + for (TimeStep step = new TimeStep(0); !step.after(lastStep); step = step.next()) { + + MatrixND mat = simulation.getResultStorage().getMatrix(step, + pop, ResultName.MATRIX_FISHING_MORTALITY_PER_GROUP); // group + + if (mat != null) { // can be null if simulation is stopped before last year simulation + for (MatrixIterator i = mat.iterator(); i.hasNext();) { + i.next(); + Object[] sems = i.getSemanticsCoordinates(); + PopulationGroup group = (PopulationGroup)sems[1]; + double val = i.getValue(); + + out.write(pop.getName() + ";" + step.getStep() + ";" + group.getAge() + ";" + val + "\n"); // + ";" + group.getAge() + } + } + } + //} + } + } + } + +

1 0

r25 - trunk/rules
by echatellier＠users.forge.codelutin.com 20 Dec '12

20 Dec '12

Author: echatellier Date: 2012-12-20 12:01:12 +0100 (Thu, 20 Dec 2012) New Revision: 25 Url: http://forge.codelutin.com/projects/isis-fish-community/repository/revision… Log: Modification du copyright Modified: trunk/rules/TACpoids20012011TailleMin.java Modified: trunk/rules/TACpoids20012011TailleMin.java =================================================================== --- trunk/rules/TACpoids20012011TailleMin.java 2012-12-20 11:01:02 UTC (rev 24) +++ trunk/rules/TACpoids20012011TailleMin.java 2012-12-20 11:01:12 UTC (rev 25) @@ -2,7 +2,7 @@ * #%L * IsisFish data * %% - * Copyright (C) 2006 - 2011 Ifremer, CodeLutin + * Copyright (C) 2006 - 2012 Ifremer, CodeLutin * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as

1 0

r24 - trunk/rules
by smahevas＠users.forge.codelutin.com 20 Dec '12

20 Dec '12

Author: smahevas Date: 2012-12-20 12:01:02 +0100 (Thu, 20 Dec 2012) New Revision: 24 Url: http://forge.codelutin.com/projects/isis-fish-community/repository/revision… Log: tacAtteint initialise a chaque pas de temps Modified: trunk/rules/TACpoids20012011OgiveTriMerlu.java Modified: trunk/rules/TACpoids20012011OgiveTriMerlu.java =================================================================== --- trunk/rules/TACpoids20012011OgiveTriMerlu.java 2012-12-20 11:00:31 UTC (rev 23) +++ trunk/rules/TACpoids20012011OgiveTriMerlu.java 2012-12-20 11:01:02 UTC (rev 24) @@ -1,468 +1,470 @@ -/* - * #%L - * IsisFish data - * %% - * Copyright (C) 2006 - 2012 Ifremer, CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 2 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/gpl-2.0.html>. - * #L% - */ -package rules; - -import static org.nuiton.i18n.I18n._; - -import java.util.HashSet; -import java.util.Set; -import java.util.List; -import java.util.ArrayList; -import java.util.Iterator; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.nuiton.math.matrix.MatrixIterator; -import org.nuiton.math.matrix.MatrixND; - -import scripts.ResultName; -import scripts.RuleUtil; -import scripts.SiMatrix; -import fr.ifremer.isisfish.datastore.ResultStorage; -import fr.ifremer.isisfish.entities.EffortDescription; -import fr.ifremer.isisfish.entities.Metier; -import fr.ifremer.isisfish.entities.Population; -import fr.ifremer.isisfish.entities.Species; -import fr.ifremer.isisfish.entities.Strategy; -import fr.ifremer.isisfish.entities.StrategyMonthInfo; -import fr.ifremer.isisfish.entities.TargetSpecies; -import fr.ifremer.isisfish.entities.MetierSeasonInfo; -import fr.ifremer.isisfish.entities.PopulationGroup; -import fr.ifremer.isisfish.entities.*; -import fr.ifremer.isisfish.rule.AbstractRule; -import fr.ifremer.isisfish.simulator.MetierMonitor; -import fr.ifremer.isisfish.simulator.PopulationMonitor; -import fr.ifremer.isisfish.simulator.SimulationContext; -import fr.ifremer.isisfish.types.TimeStep; -import fr.ifremer.isisfish.types.Month; -import fr.ifremer.isisfish.util.Doc; - -/** - * TAC peut-etre utilise pour les differents TAC, en proportion des effectifs - * et/ou avec survie ou non. - * - * <li>Pour utiliser le tac proportionnel, il faut mettre dans le parametre - * propTac une valeur > 0, le TAC sera alors recalcule a chaque mois de janvier. - * <li>Pour utiliser la survie il faut mettre dans le parametre propSurvie une - * valeur > 0, automatiquement les suvie seront ajoute aux effectifs - * - * Created: 7 septembre 2006 - * - * @author anonymous <anonymous(a)labs.libre-entreprise.org> - * @version $Revision: 1.3 $ - * - * Last update: $Date: 30 aout 2012 $ - * by : $Author: Stephanie Mahevas$ - */ -public class TACpoids20012011OgiveTriMerlu extends AbstractRule { - - /** to use log facility, just put in your code: log.info("..."); */ - static private Log log = LogFactory.getLog(TACpoids20012011OgiveTriMerlu.class); - - @Doc("Affected species") - public Species param_species = null; - - @Doc("Proportion de survie") - public double param_propSurvie = 0.45; - @Doc(value = "param_Retention_L50") - public double param_Retention_L50 = 29.4307; - - @Doc(value = "param_Retention_slope") - public double param_Retention_slope = 2.02485; - - @Doc(value = "param_TailleMin") - public double param_TailleMin = 27.0; - /** TAC in tonnes */ - @Doc("TAC in tons 2001") - public double param_tacInTons2001 =8452; - @Doc("TAC in tons 2002") - public double param_tacInTons2002 = 10098; - @Doc("TAC in tons 2003") - public double param_tacInTons2003 = 11220; - @Doc("TAC in tons 2004") - public double param_tacInTons2004 = 14623; - @Doc("TAC in tons 2005") - public double param_tacInTons2005 = 15932; - @Doc("TAC in tons 2006") - public double param_tacInTons2006 = 16412; - @Doc("TAC in tons 2007") - public double param_tacInTons2007 = 19701; - @Doc("TAC in tons 2008") - public double param_tacInTons2008 = 20196; - @Doc("TAC in tons 2009") - public double param_tacInTons2009 = 19261; - @Doc("TAC in tons 2010") - public double param_tacInTons2010 = 20609; - @Doc("TAC in tons 2011") - public double param_tacInTons2011 = 20609; - - - boolean affectation = true; // pour ne passer qu'une seule fois dans afterSimulation (pour le premier metier) - boolean tacAtteint = false; // pour ne passer dans beforeSimulation que si le tac est atteint - - - protected String[] necessaryResult = { - // put here all necessary result for this rule - // example: - // ResultName.MATRIX_BIOMASS, - // ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET, - }; - - /** - * @return the necessaryResult - */ - @Override - public String[] getNecessaryResult() { - return this.necessaryResult; - } - - /** - * Permet d'afficher a l'utilisateur une aide sur la regle. - * - * @return L'aide ou la description de la regle - */ - @Override - public String getDescription() { - return _("Combinaison de la regle tac poids sur 2001-2011 avec ogive de tri + prop de survie des rejets."); - } - - /** - * Appele au demarrage de la simulation, cette methode permet d'initialiser - * des valeurs - * - * @param context La simulation pour lequel on utilise cette regle - */ - @Override - public void init(SimulationContext context) throws Exception { - - } - - /** - * La condition qui doit etre vrai pour faire les actions. - * - * @param context la simulation pour lequel on utilise cette regle - * @param step le pas de temps courant - * @param metier le metier concern - * @return vrai si on souhaite que les actions soit faites - */ - @Override - public boolean condition(SimulationContext context, TimeStep step, Metier metier) - throws Exception { - - log.info("test si TAC atteint"); - // read species in current session : plus necessaire bug resolu - //param_species = (Species) context.getDB().findByTopiaId( - // param_species.getTopiaId()); - TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) - .getSpeciesTargetSpecies(param_species); - boolean result = false; - if (ts != null) { // on n'applique la regle que si espece captur - double param_tacInTons = 0; - - if (step.getYear()>10) { //si on est apres 2011 - result = false; - } else { - result = true; // au moins ogive tri s'applique - if (step.getYear()==0) { - param_tacInTons = param_tacInTons2001; - } else if (step.getYear()==1) { - param_tacInTons = param_tacInTons2002; - } else if (step.getYear()==2) { - param_tacInTons = param_tacInTons2003; - } else if (step.getYear()==3) { - param_tacInTons = param_tacInTons2004; - } else if (step.getYear()==4) { - param_tacInTons = param_tacInTons2005; - } else if (step.getYear()==5) { - param_tacInTons = param_tacInTons2006; - } else if (step.getYear()==6) { - param_tacInTons = param_tacInTons2007; - } else if (step.getYear()==7) { - param_tacInTons = param_tacInTons2008; - } else if (step.getYear()==8) { - param_tacInTons = param_tacInTons2009; - } else if (step.getYear()==9) { - param_tacInTons = param_tacInTons2010; - } else if (step.getYear()==10) { - param_tacInTons = param_tacInTons2011; - } - // test si Tac atteint - double catchTons = RuleUtil.getTotalCatchTons(context, - param_species, step); - log.info("[TAC] catchTons = " + catchTons - + " >= param_tacInTons:" + param_tacInTons); - if (catchTons >= param_tacInTons) { - tacAtteint = true; - } - } - } - return result; - } - - /** - * Si la condition est vrai alors cette action est executee avant le pas - * de temps de la simulation. - * - * @param context la simulation pour lequel on utilise cette regle - * @param step le pas de temps courant - * @param metier le metier concern */ - @Override - public void preAction(SimulationContext context, TimeStep step, Metier metier) - throws Exception { - - // la preaction ne tourne que si le TAC est atteint - affectation = true; - - if (tacAtteint) { - - log.info("[TAC] preAction for: " + metier); - log.info(" TAC atteint [TAC] preAction for: " + metier); - TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) - .getSpeciesTargetSpecies(param_species); - if (ts != null && ts.getPrimaryCatch()) { - // recupere tous les metiers qui ont l'espece en capture principale =>metiers vises - // aimedMetiers ne fonctionne pas je ne sais pas pourquoi ! mais au final forbiddenMetier aura le meme effet - - context.getMetierMonitor().addforbiddenMetier(metier); - - //recupere toutes les strategies pratiquant le metier et pour lesquelles la proportion !=0 - SiMatrix siMatrix = SiMatrix.getSiMatrix(context); - Set<Strategy> strs = new HashSet<Strategy>(); - for (Strategy str : siMatrix.getStrategies(step)) { - double prop = str.getStrategyMonthInfo(step.getMonth()) - .getProportionMetier(metier); - if (prop != 0) { - strs.add(str); - } - } - - for (Strategy str : strs) { - StrategyMonthInfo smi = str.getStrategyMonthInfo(step - .getMonth()); - - // 1er cas de figure: l'effort est reporte sur un metier de la - // meme strategie, n'ayant pas l'espece comme capture principale - // et pechant avec le meme engin - Set<Metier> possibleMetierCase1 = new HashSet<Metier>(); - // second cas de figure: on cherche un metier de substitution - // sans condition sur les engins, mais qui soit pratique - Set<Metier> possibleMetierCase2 = new HashSet<Metier>(); - // 3 eme cas de figure: on cherche des metiers non vises, - // sans consideration sur les engins, et pour lesquels la - // proportion peut etre nulle - Set<Metier> possibleMetierCase3 = new HashSet<Metier>(); - - for (EffortDescription effort : str.getSetOfVessels() - .getPossibleMetiers()) { - Metier newMetier = effort.getPossibleMetiers(); - if ( - /*!aimedMetiers.contains(newMetier) - &&*/!newMetier.getName().equalsIgnoreCase("nonActivity") - && !newMetier.getName().equalsIgnoreCase("nonActivite") - && !newMetier.getName().equalsIgnoreCase("non Activite") - && !context.getMetierMonitor().getForbiddenMetier() - .contains(newMetier)) { - possibleMetierCase3.add(newMetier); - - if (smi.getProportionMetier(newMetier) != 0) { - possibleMetierCase2.add(newMetier); - - if (metier.getGear().equals(newMetier.getGear())) { - possibleMetierCase1.add(newMetier); - } - } - } - } - - Set<Metier> possibleMetier = null; - if (possibleMetierCase1.size() != 0) { - log.info("[TAC] Use case 1"); - possibleMetier = possibleMetierCase1; - } else if (possibleMetierCase2.size() != 0) { - log.info("[TAC] Use case 2"); - possibleMetier = possibleMetierCase2; - } else if (possibleMetierCase3.size() != 0) { - log.info("[TAC] Use case 3"); - possibleMetier = possibleMetierCase3; - } - - if (possibleMetier != null) { - // on repartit maintenant l'effort entre les differents metiers - // possibles dans la meme strategie si un metier possible existe - // bien la repartion est proportionnelle a l'effort deja alloue - // dans la strategie - - double somme = 0; - for (Metier met : possibleMetier) { - somme += smi.getProportionMetier(met); - } - for (Metier met : possibleMetier) { - double newProportion; - if (somme == 0) { - // cas ou aucun autre metier n'est pratique - // on répartit quand meme l'effort equitablement - // sur tous les autres metier - newProportion = smi.getProportionMetier(metier) / possibleMetier.size(); - } else { - newProportion = smi.getProportionMetier(met) - + (smi.getProportionMetier(metier) - * smi.getProportionMetier(met) / somme); - } - smi.setProportionMetier(met, newProportion); - - log.info("[TAC] set new proportion to " + newProportion + " for " + met.getName()); - } - smi.setProportionMetier(metier, 0); //le metier vise a alors une proportion nulle - log.info("[TAC] il y a des metiers possibles"); - } else { - log.info("[TAC] Use no activity"); - - // sinon on met tout dans le metier nonActivite - MetierMonitor metierMon = context.getMetierMonitor(); - MatrixND mat = metierMon.getOrCreateNoActivity(step, - ResultName.MATRIX_NO_ACTIVITY, siMatrix - .getStrategies(step), siMatrix - .getMetiers(step)); - mat.setValue(str, metier, smi.getProportionMetier(metier)); - - smi.getProportionMetier().setValue(metier, 0); - } - } - } - - - } - - } - - /** - * Si la condition est vrai alors cette action est execute apres le pas - * de temps de la simulation. - * - * @param context La simulation pour lequel on utilise cette regle - * @param step le pas de temps courant - * @param metier le metier concern */ - @Override - public void postAction(SimulationContext context, TimeStep step, Metier metier) - throws Exception { - - - - if (affectation) { - // Application des rejets si Tac atteint et tailleMin sinon sur les captures - // la matrice de captures a une dimension metier - donc a cette etape, toutes - // les captures de tous les metiers sont connues - // Ne doit pas s'appliquer pour chaque metier de la boucle mais une seule fois! - // affectation est mis - // la preaction ne tourne que si le TAC est atteint - - if (tacAtteint) { //postAction de la regle TAC dans ce cas TailleMin ne s'applique pas - log.info("[TAC] postAction for: " + metier); - - PopulationMonitor popMon = context.getPopulationMonitor(); - log.info("popMon biomass" + popMon.getBiomass(param_species)); - for (Population pop : param_species.getPopulation()) { - - log.info("pop : " + pop.getName()); - // si on a deja une matrice rejet on le vide (elle vient - // forcement de la regle taille minimale or si le tac est - // atteint, tout va dorenavent dans les rejets et on mais - // TOUTES les captures dans les rejets - MatrixND discard = popMon.getDiscard(step, pop); - //log.info("discard : " + discard); - if (discard != null) { - discard.mults(0); - } - log.info("catch = " + popMon.getCatch(pop)); - MatrixND discardRegle = popMon.getCatch(pop).copy(); //nouvelle instance pour le calcul dans la regle - // ca ne doit pas pouvoir marcher car MATRIX_DISCARDS_PER_STR_MET est de dimension pop groupe str met - et discard n'a plus la dimension pop - discardRegle.setName(ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); - popMon.addDiscard(step, pop, discardRegle); - log.info("[TAC] add discard for " + pop + ": " - + discardRegle); - if (param_propSurvie > 0) { - MatrixND eff = popMon.getN(pop); - //on re - for (MatrixIterator i = discardRegle.iterator(); i - .next();) { - Object[] coord = i.getSemanticsCoordinates(); - eff.setValue(coord[2], coord[3], eff.getValue( - coord[2], coord[3]) - + i.getValue() * param_propSurvie); - } - } - } - - } else { - log.info("deb de affecterCaptureRejetSelonOgive"); - - PopulationMonitor popMon = context.getPopulationMonitor(); - for (Population pop : param_species.getPopulation()) { - 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]; - Metier met = (Metier) coordonnees[1]; - if (met.getName().equals("metier lang simp Sud")||met.getName().equals("metier lang simp Nord")||met.getName().equals("metier lang simple")||met.getName().equals("metier lang jum Nord")||met.getName().equals("metier lang jum Sud")||met.getName().equals("metier lang jum")) { - - double propTrie = 1 / (1 + Math.exp(-(group.getLength() - param_Retention_L50)/ param_Retention_slope)); - double propRejet = 1 - propTrie; - //log.info("REJETS" + propRejet); - double value = i.getValue() * propRejet; - //log.info("VALUE" + value); - i.setValue(value); - if (param_propSurvie >0) { - //ajout de la survie aux effectifs - eff.setValue(coordonnees[2], coordonnees[3], - eff.getValue(coordonnees[2], - coordonnees[3]) + i.getValue() * - param_propSurvie); - } - - }else if (group.getLength() >= param_TailleMin) { - i.setValue(0); // initialise discard si pas de rejet (ie taille>=TailleMin et pas metierLangoustine) - - } else { //si group.getLength() < param_TailleMin - if (param_propSurvie >0) { - //ajout de la survie aux effectifs - eff.setValue(coordonnees[2], coordonnees[3], - eff.getValue(coordonnees[2], - coordonnees[3]) + i.getValue() *param_propSurvie); - } - - } - } - discard.setName(ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); - popMon.addDiscard(step, pop, discard); - } - - } - // on a affecte une fois cette meta pop au rejet il ne faut pas - // le refaire - affectation = false; - } - - } - -} +/* + * #%L + * IsisFish data + * %% + * Copyright (C) 2006 - 2012 Ifremer, CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-2.0.html>. + * #L% + */ +package rules; + +import static org.nuiton.i18n.I18n._; + +import java.util.HashSet; +import java.util.Set; +import java.util.List; +import java.util.ArrayList; +import java.util.Iterator; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.math.matrix.MatrixIterator; +import org.nuiton.math.matrix.MatrixND; + +import scripts.ResultName; +import scripts.RuleUtil; +import scripts.SiMatrix; +import fr.ifremer.isisfish.datastore.ResultStorage; +import fr.ifremer.isisfish.entities.EffortDescription; +import fr.ifremer.isisfish.entities.Metier; +import fr.ifremer.isisfish.entities.Population; +import fr.ifremer.isisfish.entities.Species; +import fr.ifremer.isisfish.entities.Strategy; +import fr.ifremer.isisfish.entities.StrategyMonthInfo; +import fr.ifremer.isisfish.entities.TargetSpecies; +import fr.ifremer.isisfish.entities.MetierSeasonInfo; +import fr.ifremer.isisfish.entities.PopulationGroup; +import fr.ifremer.isisfish.entities.*; +import fr.ifremer.isisfish.rule.AbstractRule; +import fr.ifremer.isisfish.simulator.MetierMonitor; +import fr.ifremer.isisfish.simulator.PopulationMonitor; +import fr.ifremer.isisfish.simulator.SimulationContext; +import fr.ifremer.isisfish.types.TimeStep; +import fr.ifremer.isisfish.types.Month; +import fr.ifremer.isisfish.util.Doc; + +/** + * TAC peut-etre utilise pour les differents TAC, en proportion des effectifs + * et/ou avec survie ou non. + * + * <li>Pour utiliser le tac proportionnel, il faut mettre dans le parametre + * propTac une valeur > 0, le TAC sera alors recalcule a chaque mois de janvier. + * <li>Pour utiliser la survie il faut mettre dans le parametre propSurvie une + * valeur > 0, automatiquement les suvie seront ajoute aux effectifs + * + * Created: 7 septembre 2006 + * + * @author anonymous <anonymous(a)labs.libre-entreprise.org> + * @version $Revision: 1.3 $ + * + * Last update: $Date: 30 aout 2012 $ + * by : $Author: Stephanie Mahevas$ + */ +public class TACpoids20012011OgiveTriMerlu extends AbstractRule { + + /** to use log facility, just put in your code: log.info("..."); */ + static private Log log = LogFactory.getLog(TACpoids20012011OgiveTriMerlu.class); + + @Doc("Affected species") + public Species param_species = null; + + @Doc("Proportion de survie") + public double param_propSurvie = 0.45; + @Doc(value = "param_Retention_L50") + public double param_Retention_L50 = 29.4307; + + @Doc(value = "param_Retention_slope") + public double param_Retention_slope = 2.02485; + + @Doc(value = "param_TailleMin") + public double param_TailleMin = 27.0; + /** TAC in tonnes */ + @Doc("TAC in tons 2001") + public double param_tacInTons2001 =8452; + @Doc("TAC in tons 2002") + public double param_tacInTons2002 = 10098; + @Doc("TAC in tons 2003") + public double param_tacInTons2003 = 11220; + @Doc("TAC in tons 2004") + public double param_tacInTons2004 = 14623; + @Doc("TAC in tons 2005") + public double param_tacInTons2005 = 15932; + @Doc("TAC in tons 2006") + public double param_tacInTons2006 = 16412; + @Doc("TAC in tons 2007") + public double param_tacInTons2007 = 19701; + @Doc("TAC in tons 2008") + public double param_tacInTons2008 = 20196; + @Doc("TAC in tons 2009") + public double param_tacInTons2009 = 19261; + @Doc("TAC in tons 2010") + public double param_tacInTons2010 = 20609; + @Doc("TAC in tons 2011") + public double param_tacInTons2011 = 20609; + + + boolean affectation = true; // pour ne passer qu'une seule fois dans afterSimulation (pour le premier metier) + boolean tacAtteint = false; // pour ne passer dans beforeSimulation que si le tac est atteint + + + protected String[] necessaryResult = { + // put here all necessary result for this rule + // example: + // ResultName.MATRIX_BIOMASS, + // ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET, + }; + + /** + * @return the necessaryResult + */ + @Override + public String[] getNecessaryResult() { + return this.necessaryResult; + } + + /** + * Permet d'afficher a l'utilisateur une aide sur la regle. + * + * @return L'aide ou la description de la regle + */ + @Override + public String getDescription() { + return _("Combinaison de la regle tac poids sur 2001-2011 avec ogive de tri + prop de survie des rejets."); + } + + /** + * Appele au demarrage de la simulation, cette methode permet d'initialiser + * des valeurs + * + * @param context La simulation pour lequel on utilise cette regle + */ + @Override + public void init(SimulationContext context) throws Exception { + + } + + /** + * La condition qui doit etre vrai pour faire les actions. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concern + * @return vrai si on souhaite que les actions soit faites + */ + @Override + public boolean condition(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + log.info("test si TAC atteint"); + // read species in current session : plus necessaire bug resolu + //param_species = (Species) context.getDB().findByTopiaId( + // param_species.getTopiaId()); + TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) + .getSpeciesTargetSpecies(param_species); + boolean result = false; + tacAtteint = false; // sinon une fois le tac atteint pendant la simu cette variable reste ÃƒÂ vrai et on passe toujours dans preAction et postAction + + if (ts != null) { // on n'applique la regle que si espece captur + double param_tacInTons = 0; + + if (step.getYear()>10) { //si on est apres 2011 + result = false; + } else { + result = true; // au moins ogive tri s'applique + if (step.getYear()==0) { + param_tacInTons = param_tacInTons2001; + } else if (step.getYear()==1) { + param_tacInTons = param_tacInTons2002; + } else if (step.getYear()==2) { + param_tacInTons = param_tacInTons2003; + } else if (step.getYear()==3) { + param_tacInTons = param_tacInTons2004; + } else if (step.getYear()==4) { + param_tacInTons = param_tacInTons2005; + } else if (step.getYear()==5) { + param_tacInTons = param_tacInTons2006; + } else if (step.getYear()==6) { + param_tacInTons = param_tacInTons2007; + } else if (step.getYear()==7) { + param_tacInTons = param_tacInTons2008; + } else if (step.getYear()==8) { + param_tacInTons = param_tacInTons2009; + } else if (step.getYear()==9) { + param_tacInTons = param_tacInTons2010; + } else if (step.getYear()==10) { + param_tacInTons = param_tacInTons2011; + } + // test si Tac atteint + double catchTons = RuleUtil.getTotalCatchTons(context, + param_species, step); + log.info("[TAC] catchTons = " + catchTons + + " >= param_tacInTons:" + param_tacInTons); + if (catchTons >= param_tacInTons) { + tacAtteint = true; + } + } + } + return result; + } + + /** + * Si la condition est vrai alors cette action est executee avant le pas + * de temps de la simulation. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concern */ + @Override + public void preAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + // la preaction ne tourne que si le TAC est atteint + affectation = true; + + if (tacAtteint) { + + log.info("[TAC] preAction for: " + metier); + log.info(" TAC atteint [TAC] preAction for: " + metier); + TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) + .getSpeciesTargetSpecies(param_species); + if (ts != null && ts.getPrimaryCatch()) { + // recupere tous les metiers qui ont l'espece en capture principale =>metiers vises + // aimedMetiers ne fonctionne pas je ne sais pas pourquoi ! mais au final forbiddenMetier aura le meme effet + + context.getMetierMonitor().addforbiddenMetier(metier); + + //recupere toutes les strategies pratiquant le metier et pour lesquelles la proportion !=0 + SiMatrix siMatrix = SiMatrix.getSiMatrix(context); + Set<Strategy> strs = new HashSet<Strategy>(); + for (Strategy str : siMatrix.getStrategies(step)) { + double prop = str.getStrategyMonthInfo(step.getMonth()) + .getProportionMetier(metier); + if (prop != 0) { + strs.add(str); + } + } + + for (Strategy str : strs) { + StrategyMonthInfo smi = str.getStrategyMonthInfo(step + .getMonth()); + + // 1er cas de figure: l'effort est reporte sur un metier de la + // meme strategie, n'ayant pas l'espece comme capture principale + // et pechant avec le meme engin + Set<Metier> possibleMetierCase1 = new HashSet<Metier>(); + // second cas de figure: on cherche un metier de substitution + // sans condition sur les engins, mais qui soit pratique + Set<Metier> possibleMetierCase2 = new HashSet<Metier>(); + // 3 eme cas de figure: on cherche des metiers non vises, + // sans consideration sur les engins, et pour lesquels la + // proportion peut etre nulle + Set<Metier> possibleMetierCase3 = new HashSet<Metier>(); + + for (EffortDescription effort : str.getSetOfVessels() + .getPossibleMetiers()) { + Metier newMetier = effort.getPossibleMetiers(); + if ( + /*!aimedMetiers.contains(newMetier) + &&*/!newMetier.getName().equalsIgnoreCase("nonActivity") + && !newMetier.getName().equalsIgnoreCase("nonActivite") + && !newMetier.getName().equalsIgnoreCase("non Activite") + && !context.getMetierMonitor().getForbiddenMetier() + .contains(newMetier)) { + possibleMetierCase3.add(newMetier); + + if (smi.getProportionMetier(newMetier) != 0) { + possibleMetierCase2.add(newMetier); + + if (metier.getGear().equals(newMetier.getGear())) { + possibleMetierCase1.add(newMetier); + } + } + } + } + + Set<Metier> possibleMetier = null; + if (possibleMetierCase1.size() != 0) { + log.info("[TAC] Use case 1"); + possibleMetier = possibleMetierCase1; + } else if (possibleMetierCase2.size() != 0) { + log.info("[TAC] Use case 2"); + possibleMetier = possibleMetierCase2; + } else if (possibleMetierCase3.size() != 0) { + log.info("[TAC] Use case 3"); + possibleMetier = possibleMetierCase3; + } + + if (possibleMetier != null) { + // on repartit maintenant l'effort entre les differents metiers + // possibles dans la meme strategie si un metier possible existe + // bien la repartion est proportionnelle a l'effort deja alloue + // dans la strategie + + double somme = 0; + for (Metier met : possibleMetier) { + somme += smi.getProportionMetier(met); + } + for (Metier met : possibleMetier) { + double newProportion; + if (somme == 0) { + // cas ou aucun autre metier n'est pratique + // on rÃƒÂ©partit quand meme l'effort equitablement + // sur tous les autres metier + newProportion = smi.getProportionMetier(metier) / possibleMetier.size(); + } else { + newProportion = smi.getProportionMetier(met) + + (smi.getProportionMetier(metier) + * smi.getProportionMetier(met) / somme); + } + smi.setProportionMetier(met, newProportion); + + log.info("[TAC] set new proportion to " + newProportion + " for " + met.getName()); + } + smi.setProportionMetier(metier, 0); //le metier vise a alors une proportion nulle + log.info("[TAC] il y a des metiers possibles"); + } else { + log.info("[TAC] Use no activity"); + + // sinon on met tout dans le metier nonActivite + MetierMonitor metierMon = context.getMetierMonitor(); + MatrixND mat = metierMon.getOrCreateNoActivity(step, + ResultName.MATRIX_NO_ACTIVITY, siMatrix + .getStrategies(step), siMatrix + .getMetiers(step)); + mat.setValue(str, metier, smi.getProportionMetier(metier)); + + smi.getProportionMetier().setValue(metier, 0); + } + } + } + + + } + + } + + /** + * Si la condition est vrai alors cette action est execute apres le pas + * de temps de la simulation. + * + * @param context La simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concern */ + @Override + public void postAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + + + if (affectation) { + // Application des rejets si Tac atteint et tailleMin sinon sur les captures + // la matrice de captures a une dimension metier - donc a cette etape, toutes + // les captures de tous les metiers sont connues + // Ne doit pas s'appliquer pour chaque metier de la boucle mais une seule fois! + // affectation est mis + // la preaction ne tourne que si le TAC est atteint + + if (tacAtteint) { //postAction de la regle TAC dans ce cas TailleMin ne s'applique pas + log.info("[TAC] postAction for: " + metier); + + PopulationMonitor popMon = context.getPopulationMonitor(); + log.info("popMon biomass" + popMon.getBiomass(param_species)); + for (Population pop : param_species.getPopulation()) { + + log.info("pop : " + pop.getName()); + // si on a deja une matrice rejet on le vide (elle vient + // forcement de la regle taille minimale or si le tac est + // atteint, tout va dorenavent dans les rejets et on mais + // TOUTES les captures dans les rejets + MatrixND discard = popMon.getDiscard(step, pop); + //log.info("discard : " + discard); + if (discard != null) { + discard.mults(0); + } + log.info("catch = " + popMon.getCatch(pop)); + MatrixND discardRegle = popMon.getCatch(pop).copy(); //nouvelle instance pour le calcul dans la regle + // ca ne doit pas pouvoir marcher car MATRIX_DISCARDS_PER_STR_MET est de dimension pop groupe str met - et discard n'a plus la dimension pop + discardRegle.setName(ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); + popMon.addDiscard(step, pop, discardRegle); + log.info("[TAC] add discard for " + pop + ": " + + discardRegle); + if (param_propSurvie > 0) { + MatrixND eff = popMon.getN(pop); + //on re + for (MatrixIterator i = discardRegle.iterator(); i + .next();) { + Object[] coord = i.getSemanticsCoordinates(); + eff.setValue(coord[2], coord[3], eff.getValue( + coord[2], coord[3]) + + i.getValue() * param_propSurvie); + } + } + } + + } else { + log.info("deb de affecterCaptureRejetSelonOgive"); + + PopulationMonitor popMon = context.getPopulationMonitor(); + for (Population pop : param_species.getPopulation()) { + 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]; + Metier met = (Metier) coordonnees[1]; + if (met.getName().equals("metier lang simp Sud")||met.getName().equals("metier lang simp Nord")||met.getName().equals("metier lang simple")||met.getName().equals("metier lang jum Nord")||met.getName().equals("metier lang jum Sud")||met.getName().equals("metier lang jum")) { + + double propTrie = 1 / (1 + Math.exp(-(group.getLength() - param_Retention_L50)/ param_Retention_slope)); + double propRejet = 1 - propTrie; + //log.info("REJETS" + propRejet); + double value = i.getValue() * propRejet; + //log.info("VALUE" + value); + i.setValue(value); + if (param_propSurvie >0) { + //ajout de la survie aux effectifs + eff.setValue(coordonnees[2], coordonnees[3], + eff.getValue(coordonnees[2], + coordonnees[3]) + i.getValue() * + param_propSurvie); + } + + }else if (group.getLength() >= param_TailleMin) { + i.setValue(0); // initialise discard si pas de rejet (ie taille>=TailleMin et pas metierLangoustine) + + } else { //si group.getLength() < param_TailleMin + if (param_propSurvie >0) { + //ajout de la survie aux effectifs + eff.setValue(coordonnees[2], coordonnees[3], + eff.getValue(coordonnees[2], + coordonnees[3]) + i.getValue() *param_propSurvie); + } + + } + } + discard.setName(ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); + popMon.addDiscard(step, pop, discard); + } + + } + // on a affecte une fois cette meta pop au rejet il ne faut pas + // le refaire + affectation = false; + } + + } + +}

1 0

r23 - trunk/rules
by smahevas＠users.forge.codelutin.com 20 Dec '12

20 Dec '12

Author: smahevas Date: 2012-12-20 12:00:31 +0100 (Thu, 20 Dec 2012) New Revision: 23 Url: http://forge.codelutin.com/projects/isis-fish-community/repository/revision… Log: tacatteint initialise a chaque pas de temps Modified: trunk/rules/TACpoids20012011TailleMin.java Modified: trunk/rules/TACpoids20012011TailleMin.java =================================================================== --- trunk/rules/TACpoids20012011TailleMin.java 2012-12-05 11:35:18 UTC (rev 22) +++ trunk/rules/TACpoids20012011TailleMin.java 2012-12-20 11:00:31 UTC (rev 23) @@ -1,452 +1,454 @@ -/* - * #%L - * IsisFish data - * %% - * Copyright (C) 2006 - 2011 Ifremer, CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 2 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/gpl-2.0.html>. - * #L% - */ -package rules; - -import static org.nuiton.i18n.I18n._; - -import java.util.HashSet; -import java.util.Set; -import java.util.List; -import java.util.ArrayList; -import java.util.Iterator; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.nuiton.math.matrix.MatrixIterator; -import org.nuiton.math.matrix.MatrixND; - -import scripts.ResultName; -import scripts.RuleUtil; -import scripts.SiMatrix; -import fr.ifremer.isisfish.datastore.ResultStorage; -import fr.ifremer.isisfish.entities.EffortDescription; -import fr.ifremer.isisfish.entities.Metier; -import fr.ifremer.isisfish.entities.Population; -import fr.ifremer.isisfish.entities.Species; -import fr.ifremer.isisfish.entities.Strategy; -import fr.ifremer.isisfish.entities.StrategyMonthInfo; -import fr.ifremer.isisfish.entities.TargetSpecies; -import fr.ifremer.isisfish.entities.MetierSeasonInfo; -import fr.ifremer.isisfish.entities.PopulationGroup; -import fr.ifremer.isisfish.entities.*; -import fr.ifremer.isisfish.rule.AbstractRule; -import fr.ifremer.isisfish.simulator.MetierMonitor; -import fr.ifremer.isisfish.simulator.PopulationMonitor; -import fr.ifremer.isisfish.simulator.SimulationContext; -import fr.ifremer.isisfish.types.TimeStep; -import fr.ifremer.isisfish.types.Month; -import fr.ifremer.isisfish.util.Doc; - -/** - * TAC peut-etre utilise pour les differents TAC, en proportion des effectifs - * et/ou avec survie ou non. - * - * <li>Pour utiliser le tac proportionnel, il faut mettre dans le parametre - * propTac une valeur > 0, le TAC sera alors recalcule a chaque mois de janvier. - * <li>Pour utiliser la survie il faut mettre dans le parametre propSurvie une - * valeur > 0, automatiquement les suvie seront ajoute aux effectifs - * - * Created: 7 septembre 2006 - * - * @author anonymous <anonymous(a)labs.libre-entreprise.org> - * @version $Revision: 1.3 $ - * - * Last update: $Date: 30 aout 2012 $ - * by : $Author: Stephanie Mahevas$ - */ -public class TACpoids20012011TailleMin extends AbstractRule { - - /** to use log facility, just put in your code: log.info("..."); */ - static private Log log = LogFactory.getLog(TACpoids20012011TailleMin.class); - - @Doc("Affected species") - public Species param_species = null; - - @Doc("Proportion de survie") - public double param_propSurvie = 0.45; - - - /** TAC in tonnes */ - @Doc("TAC in tons 2001") - public double param_tacInTons2001 = 4000.0; - @Doc("TAC in tons 2002") - public double param_tacInTons2002 = 3200.0; - @Doc("TAC in tons 2003") - public double param_tacInTons2003 = 3000.0; - @Doc("TAC in tons 2004") - public double param_tacInTons2004 = 3150.0; - @Doc("TAC in tons 2005") - public double param_tacInTons2005 = 3100.0; - @Doc("TAC in tons 2006") - public double param_tacInTons2006 = 4000.0; - @Doc("TAC in tons 2007") - public double param_tacInTons2007 = 4320.0; - @Doc("TAC in tons 2008") - public double param_tacInTons2008 = 4320.0; - @Doc("TAC in tons 2009") - public double param_tacInTons2009 = 4100.0; - @Doc("TAC in tons 2010") - public double param_tacInTons2010 = 3900.0; - @Doc("TAC in tons 2011") - public double param_tacInTons2011 = 3900.0; - - @Doc(value = "param_TailleMin") - public double param_TailleMin = 85.0; - - - - boolean affectation = true; // pour ne passer qu'une seule fois dans afterSimulation (pour le premier metier) - boolean tacAtteint = false; // pour ne passer dans beforeSimulation que si le tac est atteint - - - - protected String[] necessaryResult = { - // put here all necessary result for this rule - // example: - // ResultName.MATRIX_BIOMASS, - // ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET, - }; - - /** - * @return the necessaryResult - */ - @Override - public String[] getNecessaryResult() { - return this.necessaryResult; - } - - /** - * Permet d'afficher a l'utilisateur une aide sur la regle. - * - * @return L'aide ou la description de la regle - */ - @Override - public String getDescription() { - return _("Combinaison de la regle tac poids sur 2001-2011 avec tailleMin + prop de survie des rejets."); - } - - /** - * Appele au demarrage de la simulation, cette methode permet d'initialiser - * des valeurs - * - * @param context La simulation pour lequel on utilise cette regle - */ - @Override - public void init(SimulationContext context) throws Exception { - - } - - /** - * La condition qui doit etre vrai pour faire les actions. - * - * @param context la simulation pour lequel on utilise cette regle - * @param step le pas de temps courant - * @param metier le metier concern - * @return vrai si on souhaite que les actions soit faites - */ - @Override - public boolean condition(SimulationContext context, TimeStep step, Metier metier) - throws Exception { - - log.info("test si TAC atteint"); - // read species in current session : plus necessaire bug resolu - //param_species = (Species) context.getDB().findByTopiaId( - // param_species.getTopiaId()); - TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) - .getSpeciesTargetSpecies(param_species); - boolean result = false; - if (ts != null) { // on n'applique la regle que si espece capturÃƒÆ’Ã‚Â©e par ce metier - double param_tacInTons = 0; - - if (step.getYear()>10) { //si on est apres 2011 - result = false; - } else { - result = true; // au moins tailleMin s'applique - if (step.getYear()==0) { - param_tacInTons = param_tacInTons2001; - } else if (step.getYear()==1) { - param_tacInTons = param_tacInTons2002; - } else if (step.getYear()==2) { - param_tacInTons = param_tacInTons2003; - } else if (step.getYear()==3) { - param_tacInTons = param_tacInTons2004; - } else if (step.getYear()==4) { - param_tacInTons = param_tacInTons2005; - } else if (step.getYear()==5) { - param_tacInTons = param_tacInTons2006; - } else if (step.getYear()==6) { - param_tacInTons = param_tacInTons2007; - } else if (step.getYear()==7) { - param_tacInTons = param_tacInTons2008; - } else if (step.getYear()==8) { - param_tacInTons = param_tacInTons2009; - } else if (step.getYear()==9) { - param_tacInTons = param_tacInTons2010; - } else if (step.getYear()==10) { - param_tacInTons = param_tacInTons2011; - } - // test si Tac atteint - double catchTons = RuleUtil.getTotalCatchTons(context, - param_species, step); - log.info("[TAC] catchTons = " + catchTons - + " >= param_tacInTons:" + param_tacInTons); - if (catchTons >= param_tacInTons) { - tacAtteint = true; - } - } - } - return result; - } - - /** - * Si la condition est vrai alors cette action est executee avant le pas - * de temps de la simulation. - * - * @param context la simulation pour lequel on utilise cette regle - * @param step le pas de temps courant - * @param metier le metier concern */ - @Override - public void preAction(SimulationContext context, TimeStep step, Metier metier) - throws Exception { - - // la preaction ne tourne que si le TAC est atteint - affectation = true; - - if (tacAtteint) { - - log.info("[TAC] preAction for: " + metier); - log.info(" TAC atteint [TAC] preAction for: " + metier); - TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) - .getSpeciesTargetSpecies(param_species); - if (ts != null && ts.getPrimaryCatch()) { - // recupere tous les metiers qui ont l'espece en capture principale =>metiers vises - // aimedMetiers ne fonctionne pas je ne sais pas pourquoi ! mais au final forbiddenMetier aura le meme effet - - context.getMetierMonitor().addforbiddenMetier(metier); - - //recupere toutes les strategies pratiquant le metier et pour lesquelles la proportion !=0 - SiMatrix siMatrix = SiMatrix.getSiMatrix(context); - Set<Strategy> strs = new HashSet<Strategy>(); - for (Strategy str : siMatrix.getStrategies(step)) { - double prop = str.getStrategyMonthInfo(step.getMonth()) - .getProportionMetier(metier); - if (prop != 0) { - strs.add(str); - } - } - - for (Strategy str : strs) { - StrategyMonthInfo smi = str.getStrategyMonthInfo(step - .getMonth()); - - // 1er cas de figure: l'effort est reporte sur un metier de la - // meme strategie, n'ayant pas l'espece comme capture principale - // et pechant avec le meme engin - Set<Metier> possibleMetierCase1 = new HashSet<Metier>(); - // second cas de figure: on cherche un metier de substitution - // sans condition sur les engins, mais qui soit pratique - Set<Metier> possibleMetierCase2 = new HashSet<Metier>(); - // 3 eme cas de figure: on cherche des metiers non vises, - // sans consideration sur les engins, et pour lesquels la - // proportion peut etre nulle - Set<Metier> possibleMetierCase3 = new HashSet<Metier>(); - - for (EffortDescription effort : str.getSetOfVessels() - .getPossibleMetiers()) { - Metier newMetier = effort.getPossibleMetiers(); - if ( - /*!aimedMetiers.contains(newMetier) - &&*/!newMetier.getName().equalsIgnoreCase("nonActivity") - && !newMetier.getName().equalsIgnoreCase("nonActivite") - && !newMetier.getName().equalsIgnoreCase("non Activite") - && !context.getMetierMonitor().getForbiddenMetier() - .contains(newMetier)) { - possibleMetierCase3.add(newMetier); - - if (smi.getProportionMetier(newMetier) != 0) { - possibleMetierCase2.add(newMetier); - - if (metier.getGear().equals(newMetier.getGear())) { - possibleMetierCase1.add(newMetier); - } - } - } - } - - Set<Metier> possibleMetier = null; - if (possibleMetierCase1.size() != 0) { - log.info("[TAC] Use case 1"); - possibleMetier = possibleMetierCase1; - } else if (possibleMetierCase2.size() != 0) { - log.info("[TAC] Use case 2"); - possibleMetier = possibleMetierCase2; - } else if (possibleMetierCase3.size() != 0) { - log.info("[TAC] Use case 3"); - possibleMetier = possibleMetierCase3; - } - - if (possibleMetier != null) { - // on repartit maintenant l'effort entre les differents metiers - // possibles dans la meme strategie si un metier possible existe - // bien la repartion est proportionnelle a l'effort deja alloue - // dans la strategie - - double somme = 0; - for (Metier met : possibleMetier) { - somme += smi.getProportionMetier(met); - } - for (Metier met : possibleMetier) { - double newProportion; - if (somme == 0) { - // cas ou aucun autre metier n'est pratique - // on répartit quand meme l'effort equitablement - // sur tous les autres metier - newProportion = smi.getProportionMetier(metier) / possibleMetier.size(); - } else { - newProportion = smi.getProportionMetier(met) - + (smi.getProportionMetier(metier) - * smi.getProportionMetier(met) / somme); - } - smi.setProportionMetier(met, newProportion); - } - smi.setProportionMetier(metier, 0); //le metier vise a alors une proportion nulle - log.info("[TAC] il y a des metiers possibles"); - } else { - log.info("[TAC] Use no activity"); - - // sinon on met tout dans le metier nonActivite - MetierMonitor metierMon = context.getMetierMonitor(); - MatrixND mat = metierMon.getOrCreateNoActivity(step, - ResultName.MATRIX_NO_ACTIVITY, siMatrix - .getStrategies(step), siMatrix - .getMetiers(step)); - mat.setValue(str, metier, smi.getProportionMetier(metier)); - - smi.getProportionMetier().setValue(metier, 0); - } - } - } - - - } - - } - - /** - * Si la condition est vrai alors cette action est execute apres le pas - * de temps de la simulation. - * - * @param context La simulation pour lequel on utilise cette regle - * @param step le pas de temps courant - * @param metier le metier concern */ - @Override - public void postAction(SimulationContext context, TimeStep step, Metier metier) - throws Exception { - - - - if (affectation) { - // Application des rejets si Tac atteint et tailleMin sinon sur les captures - // la matrice de captures a une dimension metier - donc a cette etape, toutes - // les captures de tous les metiers sont connues - // Ne doit pas s'appliquer pour chaque metier de la boucle mais une seule fois! - // affectation est mis ÃƒÆ’Ã‚Â true ÃƒÆ’Ã‚Â la fin de la boucle sur les pop - // la preaction ne tourne que si le TAC est atteint - - if (tacAtteint) { //postAction de la regle TAC dans ce cas TailleMin ne s'applique pas - log.info("[TAC] postAction for: " + metier); - - PopulationMonitor popMon = context.getPopulationMonitor(); - log.info("popMon biomass" + popMon.getBiomass(param_species)); - for (Population pop : param_species.getPopulation()) { - - log.info("pop : " + pop.getName()); - // si on a deja une matrice rejet on le vide (elle vient - // forcement de la regle taille minimale or si le tac est - // atteint, tout va dorenavent dans les rejets et on mais - // TOUTES les captures dans les rejets - MatrixND discard = popMon.getDiscard(step, pop); - //log.info("discard : " + discard); - if (discard != null) { - discard.mults(0); - } - log.info("catch = " + popMon.getCatch(pop)); - MatrixND discardRegle = popMon.getCatch(pop).copy(); //nouvelle instance pour le calcul dans la regle - // ca ne doit pas pouvoir marcher car MATRIX_DISCARDS_PER_STR_MET est de dimension pop groupe str met - et discard n'a plus la dimension pop - discardRegle.setName(ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); - popMon.addDiscard(step, pop, discardRegle); - log.info("[TAC] add discard for " + pop + ": " - + discardRegle); - if (param_propSurvie > 0) { - MatrixND eff = popMon.getN(pop); - //on rÃƒÆ’Ã†â€™Ãƒâ€ Ã¢â‚¬â„¢ÃƒÆ’Ã¢â‚¬Å¡Ãƒâ€šÃ‚Â©ajoute les survivants aux effectifs - for (MatrixIterator i = discardRegle.iterator(); i - .next();) { - Object[] coord = i.getSemanticsCoordinates(); - eff.setValue(coord[2], coord[3], eff.getValue( - coord[2], coord[3]) - + i.getValue() * param_propSurvie); - } - } - } - - } else { - //on applique TailleMin uniquement si tac pas atteint - log.info(" TailleMin.actionApres:" + step + " metapop:" + - param_species + " metier:" + metier); - log.info("deb de affecterCaptureREJETTailleMin"); - - PopulationMonitor popMon = context.getPopulationMonitor(); - - for (Population pop : param_species.getPopulation()) { - //if (popMon.getDiscard(step, 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]; - 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); - } - } - discard.setName( - ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); - popMon.addDiscard(step, pop, discard); - //} - } - - } - // on a affecte une fois cette meta pop au rejet il ne faut pas - // le refaire - affectation = false; - } - - } - -} +/* + * #%L + * IsisFish data + * %% + * Copyright (C) 2006 - 2011 Ifremer, CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-2.0.html>. + * #L% + */ +package rules; + +import static org.nuiton.i18n.I18n._; + +import java.util.HashSet; +import java.util.Set; +import java.util.List; +import java.util.ArrayList; +import java.util.Iterator; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.math.matrix.MatrixIterator; +import org.nuiton.math.matrix.MatrixND; + +import scripts.ResultName; +import scripts.RuleUtil; +import scripts.SiMatrix; +import fr.ifremer.isisfish.datastore.ResultStorage; +import fr.ifremer.isisfish.entities.EffortDescription; +import fr.ifremer.isisfish.entities.Metier; +import fr.ifremer.isisfish.entities.Population; +import fr.ifremer.isisfish.entities.Species; +import fr.ifremer.isisfish.entities.Strategy; +import fr.ifremer.isisfish.entities.StrategyMonthInfo; +import fr.ifremer.isisfish.entities.TargetSpecies; +import fr.ifremer.isisfish.entities.MetierSeasonInfo; +import fr.ifremer.isisfish.entities.PopulationGroup; +import fr.ifremer.isisfish.entities.*; +import fr.ifremer.isisfish.rule.AbstractRule; +import fr.ifremer.isisfish.simulator.MetierMonitor; +import fr.ifremer.isisfish.simulator.PopulationMonitor; +import fr.ifremer.isisfish.simulator.SimulationContext; +import fr.ifremer.isisfish.types.TimeStep; +import fr.ifremer.isisfish.types.Month; +import fr.ifremer.isisfish.util.Doc; + +/** + * TAC peut-etre utilise pour les differents TAC, en proportion des effectifs + * et/ou avec survie ou non. + * + * <li>Pour utiliser le tac proportionnel, il faut mettre dans le parametre + * propTac une valeur > 0, le TAC sera alors recalcule a chaque mois de janvier. + * <li>Pour utiliser la survie il faut mettre dans le parametre propSurvie une + * valeur > 0, automatiquement les suvie seront ajoute aux effectifs + * + * Created: 7 septembre 2006 + * + * @author anonymous <anonymous(a)labs.libre-entreprise.org> + * @version $Revision: 1.3 $ + * + * Last update: $Date: 30 aout 2012 $ + * by : $Author: Stephanie Mahevas$ + */ +public class TACpoids20012011TailleMin extends AbstractRule { + + /** to use log facility, just put in your code: log.info("..."); */ + static private Log log = LogFactory.getLog(TACpoids20012011TailleMin.class); + + @Doc("Affected species") + public Species param_species = null; + + @Doc("Proportion de survie") + public double param_propSurvie = 0.45; + + + /** TAC in tonnes */ + @Doc("TAC in tons 2001") + public double param_tacInTons2001 = 4000.0; + @Doc("TAC in tons 2002") + public double param_tacInTons2002 = 3200.0; + @Doc("TAC in tons 2003") + public double param_tacInTons2003 = 3000.0; + @Doc("TAC in tons 2004") + public double param_tacInTons2004 = 3150.0; + @Doc("TAC in tons 2005") + public double param_tacInTons2005 = 3100.0; + @Doc("TAC in tons 2006") + public double param_tacInTons2006 = 4000.0; + @Doc("TAC in tons 2007") + public double param_tacInTons2007 = 4320.0; + @Doc("TAC in tons 2008") + public double param_tacInTons2008 = 4320.0; + @Doc("TAC in tons 2009") + public double param_tacInTons2009 = 4100.0; + @Doc("TAC in tons 2010") + public double param_tacInTons2010 = 3900.0; + @Doc("TAC in tons 2011") + public double param_tacInTons2011 = 3900.0; + + @Doc(value = "param_TailleMin") + public double param_TailleMin = 85.0; + + + + boolean affectation = true; // pour ne passer qu'une seule fois dans afterSimulation (pour le premier metier) + boolean tacAtteint = false; // pour ne passer dans beforeSimulation que si le tac est atteint + + + + protected String[] necessaryResult = { + // put here all necessary result for this rule + // example: + // ResultName.MATRIX_BIOMASS, + // ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET, + }; + + /** + * @return the necessaryResult + */ + @Override + public String[] getNecessaryResult() { + return this.necessaryResult; + } + + /** + * Permet d'afficher a l'utilisateur une aide sur la regle. + * + * @return L'aide ou la description de la regle + */ + @Override + public String getDescription() { + return _("Combinaison de la regle tac poids sur 2001-2011 avec tailleMin + prop de survie des rejets."); + } + + /** + * Appele au demarrage de la simulation, cette methode permet d'initialiser + * des valeurs + * + * @param context La simulation pour lequel on utilise cette regle + */ + @Override + public void init(SimulationContext context) throws Exception { + + } + + /** + * La condition qui doit etre vrai pour faire les actions. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concern + * @return vrai si on souhaite que les actions soit faites + */ + @Override + public boolean condition(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + log.info("test si TAC atteint"); + // read species in current session : plus necessaire bug resolu + //param_species = (Species) context.getDB().findByTopiaId( + // param_species.getTopiaId()); + TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) + .getSpeciesTargetSpecies(param_species); + boolean result = false; + tacAtteint = false; // sinon une fois le tac atteint pendant la simu cette variable reste Ã vrai et on passe toujours dans preAction et postAction + + if (ts != null) { // on n'applique la regle que si espece capturÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â©e par ce metier + double param_tacInTons = 0; + + if (step.getYear()>10) { //si on est apres 2011 + result = false; + } else { + result = true; // au moins tailleMin s'applique + if (step.getYear()==0) { + param_tacInTons = param_tacInTons2001; + } else if (step.getYear()==1) { + param_tacInTons = param_tacInTons2002; + } else if (step.getYear()==2) { + param_tacInTons = param_tacInTons2003; + } else if (step.getYear()==3) { + param_tacInTons = param_tacInTons2004; + } else if (step.getYear()==4) { + param_tacInTons = param_tacInTons2005; + } else if (step.getYear()==5) { + param_tacInTons = param_tacInTons2006; + } else if (step.getYear()==6) { + param_tacInTons = param_tacInTons2007; + } else if (step.getYear()==7) { + param_tacInTons = param_tacInTons2008; + } else if (step.getYear()==8) { + param_tacInTons = param_tacInTons2009; + } else if (step.getYear()==9) { + param_tacInTons = param_tacInTons2010; + } else if (step.getYear()==10) { + param_tacInTons = param_tacInTons2011; + } + // test si Tac atteint + double catchTons = RuleUtil.getTotalCatchTons(context, + param_species, step); + log.info("[TAC] catchTons = " + catchTons + + " >= param_tacInTons:" + param_tacInTons); + if (catchTons >= param_tacInTons) { + tacAtteint = true; + } + } + } + return result; + } + + /** + * Si la condition est vrai alors cette action est executee avant le pas + * de temps de la simulation. + * + * @param context la simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concern */ + @Override + public void preAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + // la preaction ne tourne que si le TAC est atteint + affectation = true; + + if (tacAtteint) { + + log.info("[TAC] preAction for: " + metier); + log.info(" TAC atteint [TAC] preAction for: " + metier); + TargetSpecies ts = metier.getMetierSeasonInfo(step.getMonth()) + .getSpeciesTargetSpecies(param_species); + if (ts != null && ts.getPrimaryCatch()) { + // recupere tous les metiers qui ont l'espece en capture principale =>metiers vises + // aimedMetiers ne fonctionne pas je ne sais pas pourquoi ! mais au final forbiddenMetier aura le meme effet + + context.getMetierMonitor().addforbiddenMetier(metier); + + //recupere toutes les strategies pratiquant le metier et pour lesquelles la proportion !=0 + SiMatrix siMatrix = SiMatrix.getSiMatrix(context); + Set<Strategy> strs = new HashSet<Strategy>(); + for (Strategy str : siMatrix.getStrategies(step)) { + double prop = str.getStrategyMonthInfo(step.getMonth()) + .getProportionMetier(metier); + if (prop != 0) { + strs.add(str); + } + } + + for (Strategy str : strs) { + StrategyMonthInfo smi = str.getStrategyMonthInfo(step + .getMonth()); + + // 1er cas de figure: l'effort est reporte sur un metier de la + // meme strategie, n'ayant pas l'espece comme capture principale + // et pechant avec le meme engin + Set<Metier> possibleMetierCase1 = new HashSet<Metier>(); + // second cas de figure: on cherche un metier de substitution + // sans condition sur les engins, mais qui soit pratique + Set<Metier> possibleMetierCase2 = new HashSet<Metier>(); + // 3 eme cas de figure: on cherche des metiers non vises, + // sans consideration sur les engins, et pour lesquels la + // proportion peut etre nulle + Set<Metier> possibleMetierCase3 = new HashSet<Metier>(); + + for (EffortDescription effort : str.getSetOfVessels() + .getPossibleMetiers()) { + Metier newMetier = effort.getPossibleMetiers(); + if ( + /*!aimedMetiers.contains(newMetier) + &&*/!newMetier.getName().equalsIgnoreCase("nonActivity") + && !newMetier.getName().equalsIgnoreCase("nonActivite") + && !newMetier.getName().equalsIgnoreCase("non Activite") + && !context.getMetierMonitor().getForbiddenMetier() + .contains(newMetier)) { + possibleMetierCase3.add(newMetier); + + if (smi.getProportionMetier(newMetier) != 0) { + possibleMetierCase2.add(newMetier); + + if (metier.getGear().equals(newMetier.getGear())) { + possibleMetierCase1.add(newMetier); + } + } + } + } + + Set<Metier> possibleMetier = null; + if (possibleMetierCase1.size() != 0) { + log.info("[TAC] Use case 1"); + possibleMetier = possibleMetierCase1; + } else if (possibleMetierCase2.size() != 0) { + log.info("[TAC] Use case 2"); + possibleMetier = possibleMetierCase2; + } else if (possibleMetierCase3.size() != 0) { + log.info("[TAC] Use case 3"); + possibleMetier = possibleMetierCase3; + } + + if (possibleMetier != null) { + // on repartit maintenant l'effort entre les differents metiers + // possibles dans la meme strategie si un metier possible existe + // bien la repartion est proportionnelle a l'effort deja alloue + // dans la strategie + + double somme = 0; + for (Metier met : possibleMetier) { + somme += smi.getProportionMetier(met); + } + for (Metier met : possibleMetier) { + double newProportion; + if (somme == 0) { + // cas ou aucun autre metier n'est pratique + // on rÃ©partit quand meme l'effort equitablement + // sur tous les autres metier + newProportion = smi.getProportionMetier(metier) / possibleMetier.size(); + } else { + newProportion = smi.getProportionMetier(met) + + (smi.getProportionMetier(metier) + * smi.getProportionMetier(met) / somme); + } + smi.setProportionMetier(met, newProportion); + } + smi.setProportionMetier(metier, 0); //le metier vise a alors une proportion nulle + log.info("[TAC] il y a des metiers possibles"); + } else { + log.info("[TAC] Use no activity"); + + // sinon on met tout dans le metier nonActivite + MetierMonitor metierMon = context.getMetierMonitor(); + MatrixND mat = metierMon.getOrCreateNoActivity(step, + ResultName.MATRIX_NO_ACTIVITY, siMatrix + .getStrategies(step), siMatrix + .getMetiers(step)); + mat.setValue(str, metier, smi.getProportionMetier(metier)); + + smi.getProportionMetier().setValue(metier, 0); + } + } + } + + + } + + } + + /** + * Si la condition est vrai alors cette action est execute apres le pas + * de temps de la simulation. + * + * @param context La simulation pour lequel on utilise cette regle + * @param step le pas de temps courant + * @param metier le metier concern */ + @Override + public void postAction(SimulationContext context, TimeStep step, Metier metier) + throws Exception { + + + + if (affectation) { + // Application des rejets si Tac atteint et tailleMin sinon sur les captures + // la matrice de captures a une dimension metier - donc a cette etape, toutes + // les captures de tous les metiers sont connues + // Ne doit pas s'appliquer pour chaque metier de la boucle mais une seule fois! + // affectation est mis ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â true ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â la fin de la boucle sur les pop + // la preaction ne tourne que si le TAC est atteint + + if (tacAtteint) { //postAction de la regle TAC dans ce cas TailleMin ne s'applique pas + log.info("[TAC] postAction for: " + metier); + + PopulationMonitor popMon = context.getPopulationMonitor(); + log.info("popMon biomass" + popMon.getBiomass(param_species)); + for (Population pop : param_species.getPopulation()) { + + log.info("pop : " + pop.getName()); + // si on a deja une matrice rejet on le vide (elle vient + // forcement de la regle taille minimale or si le tac est + // atteint, tout va dorenavent dans les rejets et on mais + // TOUTES les captures dans les rejets + MatrixND discard = popMon.getDiscard(step, pop); + //log.info("discard : " + discard); + if (discard != null) { + discard.mults(0); + } + log.info("catch = " + popMon.getCatch(pop)); + MatrixND discardRegle = popMon.getCatch(pop).copy(); //nouvelle instance pour le calcul dans la regle + // ca ne doit pas pouvoir marcher car MATRIX_DISCARDS_PER_STR_MET est de dimension pop groupe str met - et discard n'a plus la dimension pop + discardRegle.setName(ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); + popMon.addDiscard(step, pop, discardRegle); + log.info("[TAC] add discard for " + pop + ": " + + discardRegle); + if (param_propSurvie > 0) { + MatrixND eff = popMon.getN(pop); + //on rÃƒÆ’Ã†â€™Ãƒâ€ Ã¢â‚¬â„¢ÃƒÆ’Ã¢â‚¬Â ÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢ÃƒÆ’Ã†â€™ÃƒÂ¢Ã¢â€šÂ¬Ã…Â¡ÃƒÆ’Ã¢â‚¬Å¡Ãƒâ€šÃ‚Â©ajoute les survivants aux effectifs + for (MatrixIterator i = discardRegle.iterator(); i + .next();) { + Object[] coord = i.getSemanticsCoordinates(); + eff.setValue(coord[2], coord[3], eff.getValue( + coord[2], coord[3]) + + i.getValue() * param_propSurvie); + } + } + } + + } else { + //on applique TailleMin uniquement si tac pas atteint + log.info(" TailleMin.actionApres:" + step + " metapop:" + + param_species + " metier:" + metier); + log.info("deb de affecterCaptureREJETTailleMin"); + + PopulationMonitor popMon = context.getPopulationMonitor(); + + for (Population pop : param_species.getPopulation()) { + //if (popMon.getDiscard(step, 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]; + 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); + } + } + discard.setName( + ResultName.MATRIX_DISCARDS_PER_STR_MET_PER_ZONE_POP); + popMon.addDiscard(step, pop, discard); + //} + } + + } + // on a affecte une fois cette meta pop au rejet il ne faut pas + // le refaire + affectation = false; + } + + } + +}

1 0

r22 - trunk/rules
by echatellier＠users.forge.codelutin.com 05 Dec '12

05 Dec '12

Author: echatellier Date: 2012-12-05 12:35:18 +0100 (Wed, 05 Dec 2012) New Revision: 22 Url: http://forge.codelutin.com/projects/isis-fish-community/repository/revision… Log: Correction concernant le metier "nonActivite" Modified: trunk/rules/TACpoids20012011OgiveTriMerlu.java trunk/rules/TACpoids20012011TailleMin.java Modified: trunk/rules/TACpoids20012011OgiveTriMerlu.java =================================================================== --- trunk/rules/TACpoids20012011OgiveTriMerlu.java 2012-12-05 11:04:54 UTC (rev 21) +++ trunk/rules/TACpoids20012011OgiveTriMerlu.java 2012-12-05 11:35:18 UTC (rev 22) @@ -276,9 +276,9 @@ Metier newMetier = effort.getPossibleMetiers(); if ( /*!aimedMetiers.contains(newMetier) - &&*/!metier.getName().equalsIgnoreCase("nonActiviy") - && !metier.getName().equalsIgnoreCase("nonActivite") - && !metier.getName().equalsIgnoreCase("non Activite") + &&*/!newMetier.getName().equalsIgnoreCase("nonActivity") + && !newMetier.getName().equalsIgnoreCase("nonActivite") + && !newMetier.getName().equalsIgnoreCase("non Activite") && !context.getMetierMonitor().getForbiddenMetier() .contains(newMetier)) { possibleMetierCase3.add(newMetier); Modified: trunk/rules/TACpoids20012011TailleMin.java =================================================================== --- trunk/rules/TACpoids20012011TailleMin.java 2012-12-05 11:04:54 UTC (rev 21) +++ trunk/rules/TACpoids20012011TailleMin.java 2012-12-05 11:35:18 UTC (rev 22) @@ -275,9 +275,9 @@ Metier newMetier = effort.getPossibleMetiers(); if ( /*!aimedMetiers.contains(newMetier) - &&*/!metier.getName().equalsIgnoreCase("nonActiviy") - && !metier.getName().equalsIgnoreCase("nonActivite") - && !metier.getName().equalsIgnoreCase("non Activite") + &&*/!newMetier.getName().equalsIgnoreCase("nonActivity") + && !newMetier.getName().equalsIgnoreCase("nonActivite") + && !newMetier.getName().equalsIgnoreCase("non Activite") && !context.getMetierMonitor().getForbiddenMetier() .contains(newMetier)) { possibleMetierCase3.add(newMetier);

1 0