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.*; import java.io.File; import java.io.FileReader; import java.io.Writer; import java.util.*; 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.types.*; 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; /** * Sensibility.java * * Created: 21 décembre 2008 * * @author HUSSEIN chirine * */ public class Sensibility implements AnalysePlan { /** to use log facility, just put in your code: log.info("..."); */ static private Log log = LogFactory.getLog(Sensibility.class); static private final String MATRIX = "matrix"; /// Le fichier est donc matrix.txt static private final String VBGF = "growth"; static private final String SELECTIVITY = "selectivity"; static private final String SELECTIVITYFiletMer = "selectivityFiletMer"; static private final String SELECTIVITYFiletEtang = "selectivityFiletEtang"; static private final String SELECTIVITYLigncote = "selectivityLignecote"; static private final String SELECTIVITYLigneemb = "selectivityLigneemb"; static private final String SELECTIVITYChalut = "selectivityChalut"; static private final String SELECTIVITYHarpon = "selectivityHarpon"; static private final String CATCHABILITY = "capturabilite"; static private final String MORTALITY = "mortalite"; static private final String STANDARDISATION = "standardisation"; //static private final String AMP = "amp"; //static private final String AMP1 = "ampRPrepro_Lignecote"; //static private final String AMP2 = "ampRPrepro_FiletMer"; ///////////* completer ici avec tous les fichiers .txt des amp public int param_parameterNumber = 5; /// ce paramètre n'est normalement pas modifié public int param_first = 0; /// on utilise ce paramètre pour indiquer à quelle ligne /// de la matrice on doit commencer à faire tourner les simulations au cas où on ait dû interompre le plan public int param_simulationNumber = 32;/// ce paramètre n'est normalement pas modifié public String param_directory = "C:/Documents and Settings/hussein/Bureau/isis-fish-3.1.3/isis-fish-3.1.3/fichier paramètres//"; /// Il s'agit du chemin vers le dossier ///contenant les fichier de matrice et paramètres, par défaut le repertoire du go.bat /// donc dans ce cas c'est le dossier Exemple_repertory qui est dans le dossier contenant le go.bat /// Déclaration de la matrice d'expérience private MatrixND matrix = null; /// Non utilisé pour ce script mais à ne pas effacer 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 { return _("réalise les expériences d'un plan complet pour 5 parametres à 2 modalités"); } /** * 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 { /// Création de la matrice d'expérience et chargement : File dir = new File(param_directory); File csvFile = new File(dir, MATRIX + ".txt"); log.info("CSV file is : " + csvFile.getAbsolutePath()); if(!csvFile.exists()) { log.warn("File doesn't exists"); } matrix = MatrixFactory.getInstance().create(new int[]{param_simulationNumber, param_parameterNumber}); matrix.importCSV(new FileReader(csvFile), new int[]{0,0}); matrix.setSemantics(1, Arrays.asList(new String[]{VBGF,CATCHABILITY,MORTALITY,SELECTIVITY, STANDARDISATION})); System.out.println(matrix); //System.out.println("amp 0 : "+ matrix.getValue(0,AMP)); /// ajout des regles qui sont modifiées par le plan //context.getParam().addExtraRules("Cantonnement","Cantonnement","Cantonnement","Cantonnement","Cantonnement","Cantonnement"); ////////////* tu dois ecrire cantonnement 11 fois si tu as 11 regles cantonnement } /// Création des méthodes qui réccupère dans la matrice la modalité du paramètre pour l'expérience en cours /// Les arguments des méthodes sont le nom du fichier et le numéro de la simulation /// (On détermine l'expérience en cours et donc la ligne de la matrice en sommant le numéro de la simulation et le param_first) /// pour un double 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")))); int ligne = simulation + param_first; int mod = (int)matrix.getValue(ligne, name); System.out.println("mod et ligne : "+ mod+" "+ligne); double result = Double.parseDouble(prop.getProperty(""+mod)); System.out.println("result : "+ result); return result; } /// pour une liste de doubles /** * @param name le nom de l'element a recuperer * @param simulation le numero de la simulation * @return */ 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 ligne = simulation + param_first; int mod = (int)matrix.getValue(ligne, name); double [] result = StringUtil.toArrayDouble(prop.getProperty(""+mod).split(";")); // ""+ ca construit une chaine de caractere return result; } /// pour une chaine de characteres (equation) /** * @param name le nom de l'element a recuperer * @param simulation le numero de la simulation * @return */ private String getString(String name,String col, 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 ligne = simulation + param_first; int mod = (int)matrix.getValue(ligne , col); String result = prop.getProperty(""+mod); return result; } /// pour les paramètres d'une règle de gestion /** * @param name le nom de l'element a recuperer * @param simulation le numero de la simulation * @return */ private Rule getRule(RegionStorage regionStorage, String name, String col, 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 ligne = simulation + param_first; int mod = (int)matrix.getValue(ligne , col); 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()+ param_first; if (simNum < param_simulationNumber+1) { /// On vérifie qu'il reste des expériences à faire /// On utilise les méthodes crées pour récupérer les valeurs des modalités pour l'expérience en cours double [] croissance = getList (VBGF , simNum); double catchability = getDouble (CATCHABILITY, simNum); double [] standardisation = getList (STANDARDISATION , simNum); String selectivity = getString (SELECTIVITY, simNum); String selectivityFiletMer = getString (SELECTIVITYFiletMer,SELECTIVITY, simNum); String selectivityFiletEtang = getString (SELECTIVITYFiletEtang,SELECTIVITY, simNum); String selectivityLignecote = getString (SELECTIVITYLignecote,SELECTIVITY, simNum); String selectivityLigneemb = getString (SELECTIVITYFLigneemb,SELECTIVITY, simNum); String selectivityChalut = getString (SELECTIVITYChalut,SELECTIVITY, simNum); String selectivityHarpon = getString (SELECTIVITYHarpon,SELECTIVITY, simNum); String mortality = getString (MORTALITY,MORTALITY, simNum); //Rule amp1 = getRule(context.getParam().getRegion(), AMP1, AMP, simNum); //Rule amp2 = getRule(context.getParam().getRegion(), AMP2, AMP, simNum); ///////////////* à completer avec le reste des amp*/ /// On peut afficher des informations dans les logs nextSimulation.getInformation().addInformation("Growth ("+context.getNumber()+")= " + croissance); nextSimulation.getInformation().addInformation("Selectivity ("+context.getNumber()+")= " + selectivity); /// Il faut maintenant modifier la valeur des paramètres dans la base de données et les paramètres des règle de la simulation /// modif les parametres des regles de gestion : // on enleve la regle de la simulation passé (elle est stoquée sous le nom LastAMP) //List paramRules = nextSimulation.getParameter().getRules(); //paramRules.remove(context.getValue("lastAMP1")); // on nomme la regle que l'on va ajouter LastAMP (pour pouvoir la retrouver a la simulation suivante) //context.setValue("lastAMP1", amp1); // on ajoute la regle à la simulation // paramRules.add(amp1); //paramRules.remove(context.getValue("lastAMP2")); //context.setValue("lastAMP2", amp2); //paramRules.add(amp2); /////////////////* à completer avec les autres amp */ /// modif les parametres dans la base de données : TopiaContext tx = nextSimulation.getStorage().beginTransaction(); /// On récupère les objets ISIS a modifier dans la base de données PopulationDAO popDAO = IsisFishDAOHelper.getPopulationDAO(tx); Population pop = popDAO.findByName("CSar"); List groups = pop.getPopulationGroup(); GearDAO gearDAO = IsisFishDAOHelper.getGearDAO(tx); List gears = gearDAO.findAll(); ///modif borne des classes de taille /// On remplace les bornes par les éléments de la liste for (PopulationGroup group : groups) { group.setMinLength(croissance[group.getId()]) ; group.setMaxLength(croissance[group.getId()+1]) ; } // modif la capturabilité /// On modifie la valeur de la base en la multipliant par la valeur contenue dans la modalité MatrixND c = pop.getCapturability(); for (MatrixIterator i = c.iterator(); i.hasNext();){ i.next(); i.setValue(catchability); } // modif la mortalité naturelle /// On modifie la valeur de la base en la remplacant par la valeur contenue dans la modalité for (PopulationGroup group : groups) { Equation eq = pop.getNaturalDeathRate(); eq.setContent(mortality); } // modif les facteurs de standardisation /// On modifie la valeur de la base en la remplacant par la valeur contenue dans la modalité for (Gear gear : gears) { if ("FiletMer".equals(gear.getName())) { gear.setStandardisationFactor(standardisation[0]); }else if("Lignecote".equals(gear.getName())) { gear.setStandardisationFactor(standardisation[1]); }else if("Harpon".equals(gear.getName())) { gear.setStandardisationFactor(standardisation[2]); }else if("chalut".equals(gear.getName())) { gear.setStandardisationFactor(standardisation[3]); }else if("Ligneemb".equals(gear.getName())) { gear.setStandardisationFactor(standardisation[4]); }else if("FiletEtang".equals(gear.getName())) { gear.setStandardisationFactor(standardisation[5]); /////////////*a completer } } /// modif selectivité /// On remplace l'equation existante par une autre equation for (Gear gear : gears) { if ("FiletMer".equals(gear.getNam())) { Selectivity sel = gear.getPopulationSelectivity(pop); Equation eq = sel.getEquation(); eq.setContent(selectivityFiletMer); } else if ("FiletEtang".equals(gear.getNam())) { Selectivity sel = gear.getPopulationSelectivity(pop); Equation eq = sel.getEquation(); eq.setContent(selectivityFiletEtang); }else if ("Lignecote".equals(gear.getNam())) { Selectivity sel = gear.getPopulationSelectivity(pop); Equation eq = sel.getEquation(); eq.setContent(selectivityLignecote); }else if ("Ligneemb".equals(gear.getNam())) { Selectivity sel = gear.getPopulationSelectivity(pop); Equation eq = sel.getEquation(); eq.setContent(selectivityLigneemb); }else if ("Chalut".equals(gear.getNam())) { Selectivity sel = gear.getPopulationSelectivity(pop); Equation eq = sel.getEquation(); eq.setContent(selectivityChalut); }else if ("Harpon".equals(gear.getNam())) { Selectivity sel = gear.getPopulationSelectivity(pop); Equation eq = sel.getEquation(); eq.setContent(selectivityHarpon); } tx.commitTransaction(); return true; } else { return false; } } /** * 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 afterSimulation(AnalysePlanContext context, SimulationStorage lastSimulation) throws Exception { return true; } }