[Isis-fish-devel] sensibilité pour le ciblage

7 Jun 2007

      Salut Benjamin,
je crois que tu n aurais pas du venir bosser aujourd hui parce que j ai 
pas fini de t embeter :-(
je reconnait que demander que le ciblage soit une equation n etait pas 
la meilleure idee que j ai eu l an dernier...

en effet je voudrait changer les valeurs du ciblage en multipliant la 
valeur actuelle par 0.8 ou 1.2
or le ciblage est une equation "return 0.56;" par exemple
et j ai pas envie de rentrer les deux valeurs pour chacun des metiers d 
autant que ca necessite de connaitre leur ordre d apparition dans la liste

est ce que un truc du genre

Equation target = 
season.getSpeciesTargetSpecies(pop.getSpecies()).getTargetFactorEquation();

String [] target2 = target.split("return ");
double valActuelle = target2[1].split(";")[0];
//ou alors avec substring mais ca parait risqué...

season.getSpeciesTargetSpecies(pop.getSpecies()).setTargetFactorEquation("return 
"+ valActuelle*0.8 + ";");

c est possible ??
merci
sigrid

ci joint le script "fini" mais du coup je sais pas si ca tourne

-- 
Sigrid LEHUTA
stagiaire Master 2

Ecologie et Modèles pour l'Halieutique
IFREMer, rue de l'ile d'Yeu BP 21105
44311 Nantes Cedex 03

package analyseplans;

import static org.codelutin.i18n.I18n._;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import scripts.ResultName;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.Writer;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.codelutin.math.matrix.*;
import org.codelutin.util.*;
import org.codelutin.topia.*;

import fr.ifremer.isisfish.*;
import fr.ifremer.isisfish.rule.Rule;
import fr.ifremer.isisfish.rule.RuleHelper;
import fr.ifremer.isisfish.simulator.SimulationContext;
import fr.ifremer.isisfish.types.Date;
import fr.ifremer.isisfish.entities.*;
import fr.ifremer.isisfish.simulator.AnalysePlan;
import fr.ifremer.isisfish.simulator.AnalysePlanContext;
import fr.ifremer.isisfish.simulator.SimulationParameter;
import fr.ifremer.isisfish.datastore.RegionStorage;
import fr.ifremer.isisfish.datastore.RuleStorage;
import fr.ifremer.isisfish.datastore.SimulationStorage;
import fr.ifremer.isisfish.datastore.ResultStorage;

/*
 * SAAnchois.java
 *
 * Created: 6 juin 2007
 *
 * @author bpoussin <bpoussin@labs.libre-entreprise.org>
 * @version $Revision: 1.27 $
 *
 * Last update: $Date: 2007/05/24 09:29:18 $
 * by : $Author: bpoussin $
 */

/**
 * Le principe est d'avoir dans un repertoire un fichier matrix.txt et un 
 * fichier par parametre. Si le parametre s'appelle tac, le fichier sera tac.txt
 * 
 * Les fichiers pour les parametres de type double sont de la forme
 * <pre>
 * -1=0.8
 * 1=1.2
 * </pre> 
 * 
 * Les fichiers pour les parametres de type String sont de la forme
 * <pre>
 * -1=L'equation ecrite sur une seul ligne
 * 1=une autre equation toujours sur une ligne
 * </pre> 
 * 
 * Les fichiers pour les parametres de type Rule sont de la forme
 * <pre>
-1=Cantonnement
rule.-1.parameter.gear=fr.ifremer.isisfish.entities.Gear\#11690286646709\#0.5814158398678262 
rule.-1.parameter.zone=fr.ifremer.isisfish.entities.Zone\#11690286645767\#0.37798185123822536
rule.-1.parameter.beginDate=0                                                                
rule.-1.parameter.endDate=119
rule.-1.parameter.enginSelectivite=false
rule.-1.parameter.beginMonth=8          
rule.-1.parameter.endMonth=11
1=Cantonnement
rule.1.parameter.gear=fr.ifremer.isisfish.entities.Gear\#11690286646709\#0.5814158398678262 
rule.1.parameter.zone=fr.ifremer.isisfish.entities.Zone\#11690286645767\#0.37798185123822536
rule.1.parameter.beginDate=0                                                                
rule.1.parameter.endDate=119
rule.1.parameter.enginSelectivite=false
rule.1.parameter.beginMonth=3          
rule.1.parameter.endMonth=11
 * </pre> 
 */
public class SAAnchois implements AnalysePlan {

    /** to use log facility, just put in your code: log.info("..."); */
    static private Log log = LogFactory.getLog(SAAnchois.class);

    static private final String MATRIX = "matrix";

    static private final String VBGF = "growth";
    static private final String FECONDITY = "fecondity";
    static private final String SPAWNINGF = "spawningFract";
    static private final String MORTALITYA = "Madult";
    static private final String MORTALITYJ = "Mjuv";
    static private final String CATCHABILITY = "capturabilite";
    static private final String FSTD = "facteurStd";
    static private final String SELECTIVITY = "selectivity";
    static private final String TARGET = "targetFact";
    static private final String EFFORT = "effort";

    static private final String TAC = "tac";
    static private final String APM = "apm";

    // FIXME en fait ca ne sert a rien de mettre 13 en parametre, le plan
    // est trop specifique pour pouvoir jouer sur le nombre de parametre
    public int param_parameterNumber = 12;
    public int param_first = 0;
    public int param_simulationNumber = 256;
    public String param_directory = "";

    private MatrixND matrix = null;

    public String [] necessaryResult = {
    // put here all necessary result for this rule
    // example: 
    // ResultName.MATRIX_BIOMASS,
    // ResultName.MATRIX_NET_VALUE_OF_LANDINGS_PER_STRATEGY_MET,
    };

    public String[] getNecessaryResult() {
        return this.necessaryResult;
    }

    /**
     * Permet d'afficher a l'utilisateur une aide sur le plan.
     * @return L'aide ou la description du plan
     */
    public String getDescription() throws Exception {
        // TODO
        return _("réalise les expériences d'un FFD de resolution V pour 12 parametres");
    }

    /**
     * Appelé au démarrage de la simulation, cette méthode permet d'initialiser
     * des valeurs
     * @param simulation La simulation pour lequel on utilise cette regle
     */
    public void init(AnalysePlanContext context) throws Exception {
        File dir = new File(param_directory);

        matrix = MatrixFactory.getInstance().create(new int[]{param_simulationNumber, param_parameterNumber});
        matrix.importCSV(new FileReader(new File(dir, MATRIX + ".txt")), new int[]{0,0});
        matrix.setSemantics(1, Arrays.asList(new String[]{VBGF,FECONDITY,SPAWNINGF,MORTALITYA,MORTALITYJ,CATCHABILITY,FSTD, SELECTIVITY, TARGET,EFFORT,TAC, APM}));

        log.info("Matrix: " + matrix);
    }

    /**
     * @param name le nom de l'element a recuperer
     * @param simulation le numero de la simulation
     * @return
     */
    private double getDouble(String name, int simulation) throws Exception {
        File dir = new File(param_directory);
        Properties prop = new Properties();
        prop.load(new BufferedReader(new FileReader(new File(dir, name + ".txt"))));

// va chercher dans matrix si c est la modalité 1 ou -1 du facteur
        int mod = (int)matrix.getValue(simulation, name);
        double result = Double.parseDouble(prop.getProperty(""+mod));
        return result;
    }

  private double [] getList(String name, int simulation) throws Exception {
        File dir = new File(param_directory);
        Properties prop = new Properties();
        prop.load(new BufferedReader(new FileReader(new File(dir, name + ".txt"))));
          int mod = (int)matrix.getValue(simulation, name);
        double [] result = StringUtil.toArrayDouble(prop.getProperty(""+mod).split(";"));
        return result;
    }

    /**
     * @param name le nom de l'element a recuperer
     * @param simulation le numero de la simulation
     * @return
     */
    private String getString(String name, int simulation) throws Exception {
        File dir = new File(param_directory);
        Properties prop = new Properties();
        prop.load(new BufferedReader(new FileReader(new File(dir, name + ".txt"))));

        int mod = (int)matrix.getValue(simulation, name);
        String result = prop.getProperty(""+mod);
        return result;
    }

    private Rule getRule(RegionStorage regionStorage, String name, int simulation) throws Exception {
        File dir = new File(param_directory);
        Properties prop = new Properties();
        prop.load(new BufferedReader(new FileReader(new File(dir, name+".txt"))));

        int mod = (int)matrix.getValue(simulation, name);

        String ruleName = prop.getProperty(""+mod);
        RuleStorage ruleStorage = RuleStorage.getRule(ruleName);
        Rule rule = ruleStorage.getNewRuleInstance();
        RuleHelper.populateRule(mod, regionStorage, rule, prop);

        return rule;
    }

    /**
     * Call before each simulation
     * @param context plan context
     * @param nextSimulation storage used for next simulation
     * @return true if we must do next simulation, false to stop plan
     * @throws Exception
     */
    public boolean beforeSimulation(AnalysePlanContext context, SimulationStorage nextSimulation) throws Exception {
        int simNum = context.getNumber(); 
        if (simNum < param_simulationNumber) {

            double [] croissance    = getList (VBGF , simNum);
            double reproductionRate = getDouble (FECONDITY, simNum);
            double spawningFraction = getDouble (SPAWNINGF, simNum);
            String adultMortality   = getString (MORTALITYA, simNum);
            String juvMortality     = getString (MORTALITYJ, simNum);
            double catchability     = getDouble (CATCHABILITY, simNum);
            double standardisation  = getDouble (FSTD, simNum);
            String selectivityEquation = getString(SELECTIVITY, simNum);
            double targetFactor     = getDouble (TARGET, simNum);
            double effort           = getDouble (EFFORT, simNum);

            Rule tac = getRule(context.getParam().getRegion(), TAC, simNum);
            Rule apm = getRule(context.getParam().getRegion(), APM, simNum);

            log.info("Fecondites ("+simNum+")= " + reproductionRate);
            log.info("Selectivites ("+simNum+")= " + selectivityEquation);
            log.info("spawningFraction ("+simNum+")= " + spawningFraction);
            log.info("catchability ("+simNum+")= " + catchability);
            log.info("Fstd ("+simNum+")= " + standardisation);
            log.info("Ftarget("+simNum+")= " + targetFactor);
            log.info("effort ("+simNum+")= " + effort);
            log.info("croissance ("+simNum+")= " + croissance[0] + " ; " + croissance[6]);
            nextSimulation.getInformation().addInformation("Fecondites ("+context.getNumber()+")= " + reproductionRate);
            nextSimulation.getInformation().addInformation("Selectivites ("+context.getNumber()+")= " + selectivityEquation);

        // modif les parametres des regles de gestion
             /* attention il faut avoir charger les regles dans le lanceur de
             simu avec des param qui font qu elles ne s'appliquent pas*/
            // on enleve les regles de la simulation passé
            List<Rule> paramRules = context.getParam().getRules();
            paramRules.remove(context.getValue("lastTac"));
            paramRules.remove(context.getValue("lastAPM"));
            // on retient les regles que l'on va ajouter
            context.setValue("lastTac", tac);
            context.setValue("lastAPM", apm);
            // on ajoute les regles
            paramRules.add(tac);
            paramRules.add(apm);

            TopiaContext tx = nextSimulation.getStorage().beginTransaction();
            PopulationDAO popDAO = IsisFishDAOHelper.getPopulationDAO(tx);
            // il n'y a qu'une population, et elle nous interesse
            Population pop = popDAO.findAll().get(0);
            List<PopulationGroup> groups = pop.getPopulationGroup();

        //modif fecondité et borne des classes de taille
            for (PopulationGroup group : groups) {
                group.setReproductionRate(group.getReproductionRate() * reproductionRate);

                group.setMinLength(croissance[group.getId()]) ;
                group.setMaxLength(croissance[group.getId()+18]) ;
            }

        // modif frequence de ponte
            List<PopulationSeasonInfo> popSea = pop.getPopulationSeasonInfo();
			for(PopulationSeasonInfo season : popSea){            
			MatrixND sfract = season.getReproductionDistribution();
            for (MatrixIterator i = sfract.iterator(); i.hasNext();){
            i.next();
            i.setValue(i.getValue()*spawningFraction);
			}
            }

       // modif l equation de mortalité
            String mortality = juvMortality + adultMortality;
            Equation eqm = pop.getNaturalDeathRate();
            eqm.setContent(mortality);
      log.info("eq mortalité ("+simNum+")= " + mortality);

       // modif la capturabilité
		        MatrixND c = pop.getCapturability();
		        for (MatrixIterator i = c.iterator(); i.hasNext();){
			      i.next();
        		i.setValue(i.getValue()* catchability);
            }

       // modif selectivité et facteur de standardisation
            GearDAO gearDAO = IsisFishDAOHelper.getGearDAO(tx);
            List<Gear> gears = gearDAO.findAll();
            for (Gear gear : gears) {
                if (!"senne appat vivant".equals(gear.getName())){
                Selectivity selectivity = gear.getPopulationSelectivity(pop);
                Equation eq = selectivity.getEquation();
                eq.setContent(selectivityEquation);

                gear.setStandardisationFactor(gear.getStandardisationFactor()*standardisation);
            }   }

       // modif le coeff de ciblage
            MetierDAO metierDAO = IsisFishDAOHelper.getMetierDAO(tx);
            List<Metier> metiers = metierDAO.findAll();
            for(Metier metier : metiers){
              List<MetierSeasonInfo> seasons = metier.getMetierSeasonInfo();
              for(MetierSeasonInfo season : seasons){
			  Equation eqt = season.getSpeciesTargetSpecies(pop.getSpecies()).getTargetFactorEquation();     
              season.getSpeciesTargetSpecies(pop.getSpecies()).setTargetFactorEquation();
			}  
            }

       // modif le nb de jours d inactivité
            StrategyDAO strategyDAO = IsisFishDAOHelper.getStrategyDAO(tx) ;
            List<Strategy> strategies = strategyDAO.findAll();
            for (Strategy strategy : strategies) {
            List <StrategyMonthInfo>  monthInfos = strategy.getStrategyMonthInfo();
              for (StrategyMonthInfo month : monthInfos) {
			  int days = Math.round(month.getMinInactivityDays()*effort);
              month.setMinInactivityDays(days);
			  }               
            }

            tx.commitTransaction();
            return true;
        } else {
            return false;
        }
    }

    /**
     * Call after each simulation
     * @param context plan context
     * @param nextSimulation storage used for next simulation
     * @return true if we must do next simulation, false to stop plan
     * @throws Exception
     */
    public boolean afterSimulation(AnalysePlanContext context, SimulationStorage lastSimulation) throws Exception {
        return true;
    }

}