Bonjour Benjamin,
J essai de faire la calibration de l Anchois et j ai plusieurs problemes :
- Comme je te l avais expliqué Il faut sommer les resultats de simu sur
certaines classes
et ces classes sont différentes selon le mois de simulation
j ai donc modifié Calibration.java (CalibrationAnchois)
-> lorsque j essai de le faire tourner j ai le message
"Can't evaluate Analyse Plan"
- Pour vérifier le fonctionnement de mon code, j ai ecrit un nouveau
plan qui ne fait que les sommes des captures sur les classes specifiees
en fonction du mois et ecrit le resultat dans les log
(testCalibrationAnchois)
-> je peux lancer la simu mais au bout d un certain temps de blocage sur
janvier la simulation se termine sans avoir passe les autres mois et il
n y a ni resultats ni exports, en gros la simu echoue
Pourrais tu y jeter un oeil s il te plait ?
tu peux m apeler (meme numero que Stephanie) si tu veux (si c est pas
clair n hesite pas)
merci
a plus tard
Sigrid
pj : les 2 plans d analyse
- effectifs initiaux si tu veux faire tourner des simus
- debarquements observes (4 classes, 4 trimestres =1 an)
- ma base
--
Sigrid LEHUTA
stagiaire Master 2
EMH
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.util.*;
import org.codelutin.math.matrix.*;
import org.codelutin.topia.*;// pour pouvoir utiliser la methode StringUtil.toDouble()
import org.codelutin.util.*;// pour pouvoir utiliser la methode StringUtil.toDouble()
import fr.ifremer.isisfish.*;
import fr.ifremer.isisfish.types.*;
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.SimulationStorage;
import fr.ifremer.isisfish.datastore.ResultStorage;
/**
* CalibrationAnchois.java
*
* Created: 8 mars 2007
*
* @author <>
* @version $Revision: 1.1 $
*
* Last update: $Date: 2007/03/09 15:27:21 $
* by : $Author: bpoussin $
*/
public class CalibrationAnchois implements AnalysePlan {
/** to use log facility, just put in your code: log.info("..."); */
static private Log log = LogFactory.getLog(CalibrationAnchois.class);
enum State {STATE_INIT, STATE_0, STATE_1, STATE_2, STATE_3, STATE_4};
//parametres de la simu 3 points initiaux d un simplex d ordre 2
public Population param_Population = null;
public String param_M1 = "1e-5;1e-6";// devient un parametre du plan d analyse
public String param_M2 = "2e-4;2e-5";// devient un parametre du plan d analyse
public String param_M3 = "1e-4;1e-6";// devient un parametre du plan d analyse
public String param_pas = "1e-5";// devient un parametre du plan d analyse
public String param_nomfichier_debarquements = "";//nom + chemin du fichier contenant les debarquements observes par groupe pour la derniere annee
protected File debarquementsObserves;
protected MatrixND matrixDebarquement;
protected State state = State.STATE_INIT;
protected Experiences experiences = new Experiences();
public String [] necessaryResult = {
ResultName.MATRIX_CATCH_WEIGHT_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 _("Simplexe");
}
/**
* Appele au demarrage de la simulation, cette methode permet d'initialiser
* des valeurs
* @param simulation La simulation pour lequel on utilise cette regle
*/
public void init(AnalysePlanContext context) throws Exception {
if (param_nomfichier_debarquements==null || "".equals(param_nomfichier_debarquements)){
debarquementsObserves = FileUtil.getFile(".*.csv", "fichier csv séparateur ';'");
} else {
debarquementsObserves = new File(param_nomfichier_debarquements);
}
int nbYear = context.getParam().getNumberOfYear();
TopiaContext db = context.getParam().getRegion().getStorage().beginTransaction();
Population pop = (Population)db.findByTopiaId(param_Population.getTopiaId());
int nbGroup = 4 ;//pop.sizePopulationGroup();
matrixDebarquement = MatrixFactory.getInstance().create(new int[]{nbGroup});
// List<PopulationGroup> groups = pop.getPopulationGroup();
// matrixDebarquement = MatrixFactory.getInstance().create(new List[]{groups});
matrixDebarquement.importCSV(new FileReader(debarquementsObserves),new int []{0});
db.closeContext();
}
/**
* 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 {
boolean doNext = true;
int number = context.getNumber();
if (number < 3) {
String [] M1 = param_M1.split(";");
String [] M2 = param_M2.split(";");
String [] M3 = param_M3.split(";");
double [] q1 = StringUtil.toArrayDouble(M1[0], M2[0], M3[0]);
double [] q2 = StringUtil.toArrayDouble(M1[1], M2[1], M3[1]);
experiences.getExperience(number).q1 = q1[number];
experiences.getExperience(number).q2 = q2[number];
changeDB(experiences.getExperience(number), nextSimulation);
} else {
double q1 = 0;
double q2 = 0;
double lastCritere = experiences.getExperience(number-1).criteria;
double g1 = (experiences.current.get(0).q1 + experiences.current.get(1).q1) / 2.0;
double g2 = (experiences.current.get(0).q2 + experiences.current.get(1).q2) / 2.0;
double worst1 = experiences.current.get(2).q1;
double worst2 = experiences.current.get(2).q2;
if (state == State.STATE_INIT) {
// on fait la 4eme simulation dans tous les cas
state = State.STATE_0;
Collections.sort(experiences.current);
// est ce qu il va bien recchercher dans le experiences.current ordonne meme si
// g1 et g2 et worst ont ete defini avant ?
q1 = 2 * g1 - worst1;
q2 = 2 * g2 - worst2;
} else if (state == State.STATE_0) {
// on fait la 5eme avec des q qui dependent de la 4eme dans le dernier cas
if (lastCritere > experiences.current.get(2).criteria) {
state = State.STATE_1;
q1 = g1 - ( g1 - worst1 ) / 2.0;
q2 = g2 - ( g2 - worst2 ) / 2.0;
} else if (lastCritere > experiences.current.get(1).criteria) {
state = State.STATE_2;
q1 = g1 + ( g1 - worst1 ) / 2.0;
q2 = g2 + ( g2 - worst2 ) / 2.0;
} else if (lastCritere > experiences.current.get(0).criteria) {
state = State.STATE_INIT;
experiences.current.remove(3);
} else { // dernier cas possible: if (lastCritere < experiences.current.get(2).critere) {
state = State.STATE_4;
q1 = experiences.current.get(3).q1 + g1 - worst1;
q2 = experiences.current.get(3).q2 + g2 - worst2;
}
} else if (state == State.STATE_1) {
// la derniere = 5e simulation a ete faite
if (lastCritere < experiences.current.get(2).criteria) {
experiences.current.remove(3);
experiences.current.remove(2);
} else {
// FIXME on supprime les 2 derniere qui vient d'etre faite, on risque donc de boucler
experiences.current.remove(4);
experiences.current.remove(3);
doNext = false;
}
state = State.STATE_INIT;
} else if (state == State.STATE_2) {
if (lastCritere < experiences.current.get(2).criteria) {
experiences.current.remove(3);
experiences.current.remove(2);
} else {
// FIXME on supprime les 2 derniere qui vient d'etre faite, on risque donc de boucler
experiences.current.remove(4);
experiences.current.remove(3);
doNext = false;
}
state = State.STATE_INIT;
} else if (state == State.STATE_4) {
if (lastCritere < experiences.current.get(3).criteria) {
experiences.current.remove(3);
experiences.current.remove(2);
} else {
experiences.current.remove(4);
experiences.current.remove(2);
}
state = State.STATE_INIT;
}
experiences.getExperience(number).q1 = q1;
experiences.getExperience(number).q2 = q2;
changeDB(experiences.getExperience(number), nextSimulation);
}
return doNext;
}
/**
* Call after each simulation, compute criteria for last 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 {
boolean doNext = true;
int number = context.getNumber();
ResultStorage result = lastSimulation.getResultStorage();
log.fatal("sim: " + lastSimulation + " result: " + result);
MatrixND L = result.getMatrix(param_Population, ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET);
L = L.sumOverDim(1);// sum sur les strategies
L = L.sumOverDim(3);// sum sur les metiers
L = L.sumOverDim(4);// sum sur les zones
// Pour sommer sur certaines classes les resultats :
// on met 4 car il n'y a plus que 4 groupes de populations a la fin
int [] dims = new int[]{L.getDim(0), L.getDim(1), 4, L.getDim(3), L.getDim(4)}; // matrice a 5 dimension
// on cree la matrice qui contiendra les sommes
//*** MatrixND tmp = MatrixFactory.getInstance().create(L.getName(), dims);
// on fait les calculs et on met les resultats dans tmp
***/
int [] origin = new int[5]; // on initialise l'origine a [0,0,0,0,0]
int i = 0;
while (origin[0] < dims[0]){ //origin commence à 0 tandis que dim[0] commence a 1
while ( i < 1){//pour 10 ans de simu
if (origin[0] >= i*12 && origin[0]<= 11+i*12 ){
if (origin[0] >= i*12 && origin[0]<= 5+i*12 ) {
L = L.sumOverDim(2,0,5);
L = L.sumOverDim(2,5,10);
L = L.sumOverDim(2,15,1);
L = L.sumOverDim(2,16,2);
/*
MatrixND sub = L.getSubMatrix(2, 0, 5).sumOverDim(2); // on prend 5 groupes a partir du 0
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,1,0,0]
sub = L.getSubMatrix(2, 5, 10).sumOverDim(2); // on prend 11 groupes a partir du 5
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,2,0,0]
sub = L.getSubMatrix(2, 15, 1).sumOverDim(2); // on prend 1 groupe a partir du 16
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,3,0,0]
sub = L.getSubMatrix(2, 16, 2).sumOverDim(2); // on prend 1 groupe a partir du 17
tmp.paste(origin, sub);
*/
}else if (origin[0] >= 6+i*12 && origin[0]<= 7+i*12 ){
L = L.sumOverDim(2,0,5);
L = L.sumOverDim(2,5,11);
L = L.sumOverDim(2,16,1);
L = L.sumOverDim(2,17,1);
/*MatrixND sub = L.getSubMatrix(2, 0, 5).sumOverDim(2); // on prend 5 groupes a partir du 0
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,1,0,0]
sub = L.getSubMatrix(2, 5, 11).sumOverDim(2); // on prend 11 groupes a partir du 5
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,2,0,0]
sub = L.getSubMatrix(2, 16, 1).sumOverDim(2); // on prend 1 groupe a partir du 16
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,3,0,0]
sub = L.getSubMatrix(2, 17, 1).sumOverDim(2); // on prend 1 groupe a partir du 17
tmp.paste(origin, sub);
*/
}else { //(origin[0] >= 8+i*12 && origin[0]<= 11+i*12 )
L = L.sumOverDim(2,0,15);
L = L.sumOverDim(2,15,1);
L = L.sumOverDim(2,16,1);
L = L.sumOverDim(2,17,1);
/*MatrixND sub = L.getSubMatrix(2, 0, 15).sumOverDim(2);
tmp.paste(origin, sub);
origin[2]++;
sub = L.getSubMatrix(2, 15, 1).sumOverDim(2);
tmp.paste(origin, sub);
origin[2]++;
sub = L.getSubMatrix(2, 16, 1).sumOverDim(2);
tmp.paste(origin, sub);
origin[2]++;
sub = L.getSubMatrix(2, 17, 1).sumOverDim(2);
tmp.paste(origin, sub);
*/
}
}else i++ ; }
origin[0]++; }
L = L.sumOverDim(0,3);// sum sur les mois, si on ajoute le pas (12) on peut sommer sur les annees
L = L.reduce();
double crit = 0;
for ( MatrixIterator g = L.iterator(); g.hasNext();){
g.next();
int [] dim = g.getCoordinates();
double obs = matrixDebarquement.getValue(dim);
double simules = g.getValue();
crit += Math.pow(obs-simules, 2);
}
experiences.getExperience(number).criteria = -crit;
return doNext;
}
/**
* Modify nextSimulation database with q1 and q2 in exp.
* @param exp
* @param nextSimulation
* @throws Exception
*/
protected void changeDB(Experience exp, SimulationStorage nextSimulation) throws Exception {
TopiaContext db = nextSimulation.getStorage().beginTransaction();//ouvrir un context pour modifier les donnees
Population pop = (Population)db.findByTopiaId(param_Population.getTopiaId());
// autre solution moins efficace:
// PopulationDAO popDAO = IsisFishDAOHelper.getPopulationDAO(db);
// Population Nephrops = dao.findByName(param_Population.getName());
MatrixND c = pop.getCapturability();
for (MatrixIterator i = c.iterator(); i.hasNext();){
i.next();
Object [] sem = i.getSemanticsCoordinates();
PopulationGroup group = (PopulationGroup)sem[0];
PopulationSeasonInfo season = (PopulationSeasonInfo)sem[1];
if (group.getId() < 12){
i.setValue(exp.q2);
}
else {
i.setValue(exp.q1);
}
}
db.commitTransaction();
db.closeContext();
}
class Experiences {
/** contains last simplex and potentialy 2 more simulation */
protected List<Experience> current = new ArrayList<Experience>();
/** contains all experience done */
protected List<Experience> history = new ArrayList<Experience>();
/**
* return experience requested, if this experience doesn't exist
* create it.
*
* @param i simulation number
* @return experience with simulation number fixed if new experience
* is returned
*/
public Experience getExperience(int i) {
Experience result;
if (i<history.size()) {
result = history.get(i);
} else {
result = new Experience();
result.simNumber = i;
history.add(i, result);
current.add(result);
}
return result;
}
}
/**
* Use to keep q1, q2 and criteria of simulation
* @author poussin
*/
class Experience implements Comparable {
public int simNumber;
public double criteria;
public double q1;
public double q2;
/**
* Permit to order experience, first is experience with smallest criteria
*/
public int compareTo(Object arg0) {
Experience other = (Experience)arg0;
int result = Double.compare(this.criteria, other.criteria);
return result;
}
}
}
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.Writer;
import org.codelutin.math.matrix.*;
import org.codelutin.util.*;
import org.codelutin.topia.*;
import fr.ifremer.isisfish.*;
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.SimulationStorage;
import fr.ifremer.isisfish.datastore.ResultStorage;
import java.io.*;
import java.util.*;
import fr.ifremer.isisfish.types.*;
/**
* TryPlan.java
*
* Created: 26 mars 2007
*
* @author <>
* @version $Revision: 1.26 $
*
* Last update: $Date: 2007/03/09 14:10:40 $
* by : $Author: bpoussin $
*/
public class TryPlan implements AnalysePlan {
/** to use log facility, just put in your code: log.info("..."); */
static private Log log = LogFactory.getLog(TryPlan.class);
public Population param_Population = null;
public String [] necessaryResult = {
ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET
// 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 _("test_du_code_CalibrationAnchois");
}
/**
* 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 {
}
public boolean beforeSimulation(AnalysePlanContext context, SimulationStorage nextSimulation) throws Exception {
return true;
}
/**
* 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 {
int number = context.getNumber();
ResultStorage result = lastSimulation.getResultStorage();
log.fatal("sim: " + lastSimulation + " result: " + result);
MatrixND L = result.getMatrix(param_Population, ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET);
L = L.sumOverDim(1);// sum sur les strategies
L = L.sumOverDim(3);// sum sur les metiers
L = L.sumOverDim(4);// sum sur les zones
// Pour sommer sur certaines classes les resultats :
// on met 4 car il n'y a plus que 4 groupes de populations a la fin
int [] dims = new int[]{L.getDim(0), L.getDim(1), 4, L.getDim(3), L.getDim(4)}; // matrice a 5 dimension
// on cree la matrice qui contiendra les sommes
// MatrixND tmp = MatrixFactory.getInstance().create(L.getName(), dims);
// on fait les calculs et on met les resultats dans tmp
int [] origin = new int[5]; // on initialise l'origine a [0,0,0,0,0]
int i = 0;
while (origin[0] < dims[0]){ //origin commence à 0 tandis que dim[0] commence a 1
while ( i < 1){//pour 10 ans de simu
if (origin[0] >= i*12 && origin[0]<= 11+i*12 ){
if (origin[0] >= i*12 && origin[0]<= 5+i*12 ) {
L = L.sumOverDim(2,0,5);
L = L.sumOverDim(2,5,10);
L = L.sumOverDim(2,15,1);
L = L.sumOverDim(2,16,2);
/*MatrixND sub = L.getSubMatrix(2, 0, 5).sumOverDim(2); // on prend 5 groupes a partir du 0
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,1,0,0]
sub = L.getSubMatrix(2, 5, 10).sumOverDim(2); // on prend 11 groupes a partir du 5
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,2,0,0]
sub = L.getSubMatrix(2, 15, 1).sumOverDim(2); // on prend 1 groupe a partir du 16
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,3,0,0]
sub = L.getSubMatrix(2, 16, 2).sumOverDim(2); // on prend 1 groupe a partir du 17
tmp.paste(origin, sub);*/
}else if (origin[0] >= 6+i*12 && origin[0]<= 7+i*12 ){
L = L.sumOverDim(2,0,5);
L = L.sumOverDim(2,5,11);
L = L.sumOverDim(2,16,1);
L = L.sumOverDim(2,17,1);
/*MatrixND sub = L.getSubMatrix(2, 0, 5).sumOverDim(2); // on prend 5 groupes a partir du 0
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,1,0,0]
sub = L.getSubMatrix(2, 5, 11).sumOverDim(2); // on prend 11 groupes a partir du 5
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,2,0,0]
sub = L.getSubMatrix(2, 16, 1).sumOverDim(2); // on prend 1 groupe a partir du 16
tmp.paste(origin, sub);
origin[2]++; // on colle la sous matrice suivant a l'origine [0,0,3,0,0]
sub = L.getSubMatrix(2, 17, 1).sumOverDim(2); // on prend 1 groupe a partir du 17
tmp.paste(origin, sub); */
}else { //(origin[0] >= 8+i*12 && origin[0]<= 11+i*12 )
L = L.sumOverDim(2,0,15);
L = L.sumOverDim(2,15,1);
L = L.sumOverDim(2,16,1);
L = L.sumOverDim(2,17,1);
/* MatrixND sub = L.getSubMatrix(2, 0, 15).sumOverDim(2);
tmp.paste(origin, sub);
origin[2]++;
sub = L.getSubMatrix(2, 15, 1).sumOverDim(2);
tmp.paste(origin, sub);
origin[2]++;
sub = L.getSubMatrix(2, 16, 1).sumOverDim(2);
tmp.paste(origin, sub);
origin[2]++;
sub = L.getSubMatrix(2, 17, 1).sumOverDim(2);
tmp.paste(origin, sub); */
}
}else i++ ;
}i = 0;
origin[0]++;
}
L = L.sumOverDim(0);// sum sur les mois, si on ajoute le pas (12) on peut sommer sur les annees
L = L.reduce();
for (MatrixIterator m =L.iterator(); m.hasNext();) {
m.next();
Object [] sems = m.getSemanticsCoordinates();
PopulationGroup group = (PopulationGroup)sems[0];
double val = m.getValue();
log.info( group.getId() +";"+ val +"\n");
}
return true ; }
}
0;0;0;0;0;0;0
0;0;0;0;0;0;0
0;0;0;0;0;0;0
0;0;0;0;0;0;0
0;0;0;0;0;0;0
33776074.1017962;12914381.2742162;14901209.1625572;37749729.8784781;0;0;0
122014781.283067;46652710.4905843;53830050.5660588;136369461.434016;0;0;0
206409426.582071;78921251.3402038;91062982.3156198;230692888.532903;0;0;0
174586213.441545;66753552.1982383;77023329.4595057;195125767.96408;0;0;0
87793504.5915204;33568104.6967578;38732428.4962589;98122152.1905229;0;0;0
0;0;0;0;0;0;0
0;0;0;0;0;0;0
0;0;0;0;0;0;0
0;0;0;0;0;0;0
0;0;0;0;0;0;0
9163000;3503500;8354500;4851000;4851000;50050000;0
12376000;4732000;11284000;6552000;6552000;67600000;0
1309000;500500;1193500;693000;693000;7150000;0
0;94533;165027;16987
0;400076;328409;44679
3173;253149;42127;1325
48889;96761;12264;0
