comment reccuperer la table experiences ?

31 May 2007


      je disais je joints le script...
-- 
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.*;
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 CalibrationAnchois3 implements AnalysePlan {

    /** to use log facility, just put in your code: log.info("..."); */
    static private Log log = LogFactory.getLog(CalibrationAnchois3.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 = "2.42e-5;2.11e-6";// devient un parametre du plan d analyse
    public String param_M2 = "2.34e-5;2.59e-6";// devient un parametre du plan d analyse
    public String param_M3 = "2.59e-5;2.41e-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_methode2 avec simu inutiles evitées");
   }
    /**
     * 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();
	int nbTrim = nbYear * 4;
log.info("nbTrim" + nbTrim);
	int [] dimMatrix = {nbTrim,nbGroup};	
	matrixDebarquement = MatrixFactory.getInstance().create(dimMatrix);    	
	//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,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
     */
    double g1;
    double g2;
    double worst1;
    double worst2;

    public boolean beforeSimulation(AnalysePlanContext context, SimulationStorage nextSimulation) throws Exception {
   	boolean doNext = true;
    boolean doBoucle = true;
log.info("before simulation");

    	int number = context.getNumber();

if (number <3) {
log.info("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 = 1000;
			double q2 = 1000;
    		double lastCritere = experiences.getExperience(number-1).criteria;
			while (doBoucle){
			doBoucle = false;
    				if (state == State.STATE_INIT) {
doBoucle = false ;			
log.info("state init");
Collections.sort(experiences.current); 
log.info("current 0 = " + experiences.current.get(0).criteria + "current 1 = " + experiences.current.get(1).criteria  + "current 2 = " +  experiences.current.get(2).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;

    			// on fait la 4eme simulation dans tous les cas
state = State.STATE_0;

    			q1 = 2 * g1 - worst1;
    			q2 = 2 * g2 - worst2;


    				} else if (state == State.STATE_0) {
doBoucle = false;
log.info("state 0");
log.info("current 0 = " + experiences.current.get(0).criteria + "current 1 = " + experiences.current.get(1).criteria  + "current 2 = " +  experiences.current.get(2).criteria );
    			// on fait la 5eme avec des q qui dependent de la 4eme dans le dernier cas
//log.info("g1 = " + g1 + " " + "g2 = " + g2);
//log.info("worst1 = " + worst1 + " " + "worst2 = " + worst2);

    						if (lastCritere > experiences.current.get(2).criteria) {
log.info("State 0 : lastCtritere > current2");
					state = State.STATE_1;
					q1 = ((experiences.current.get(0).q1 + experiences.current.get(1).q1) / 2.0) - ( ((experiences.current.get(0).q1 + experiences.current.get(1).q1) / 2.0) - experiences.current.get(2).q1 ) / 2.0;
					q2 = ((experiences.current.get(0).q2 + experiences.current.get(1).q2) / 2.0) - ( ((experiences.current.get(0).q2 + experiences.current.get(1).q2) / 2.0) - experiences.current.get(2).q2 ) / 2.0;
log.info("Q1 = " + q1 + "Q2 = " + q2);

    						} else if (lastCritere > experiences.current.get(1).criteria) {
log.info("State 0 : lastCritere > current 1");
					state = State.STATE_2;
					q1 = ((experiences.current.get(0).q1 + experiences.current.get(1).q1) / 2.0) + ( ((experiences.current.get(0).q1 + experiences.current.get(1).q1) / 2.0) - experiences.current.get(2).q1 ) / 2.0;
					q2 = ((experiences.current.get(0).q2 + experiences.current.get(1).q2) / 2.0) + ( ((experiences.current.get(0).q2 + experiences.current.get(1).q2) / 2.0) - experiences.current.get(2).q2 ) / 2.0;
log.info("Q1 = " + q1 + "Q2 = " + q2);

    						} else if (lastCritere > experiences.current.get(0).criteria) {
log.info("State 0 : lastCritere > current0");
    				state = State.STATE_INIT;
					experiences.current.remove(2);//remove(3)avant
					doBoucle = true;
log.info("remove(2)");

    						} else { // dernier cas possible: if (lastCritere < experiences.current.get(0).critere) {
log.info("State 0 : lastCritere < current 0");
    				state = State.STATE_4;
log.info("current 3 : " + experiences.current.get(3).q1);
    				q1 = experiences.getExperience(number-1).q1 + (experiences.current.get(0).q1 + experiences.current.get(1).q1) / 2.0 - experiences.current.get(2).q1;
					q2 = experiences.getExperience(number-1).q2 + (experiences.current.get(0).q2 + experiences.current.get(1).q2) / 2.0 - experiences.current.get(2).q2;
					//q1 = experiences.current.get(3).q1 + (experiences.current.get(0).q1 + experiences.current.get(1).q1) / 2.0 - experiences.current.get(2).q1;
    				//q2 = experiences.current.get(3).q2 + (experiences.current.get(0).q2 + experiences.current.get(1).q2) / 2.0 - experiences.current.get(2).q2;
log.info("Q1 = " + q1 + "Q2 = " + q2);
    			}

    				} else if (state == State.STATE_1) {
log.info("state 1");
					experiences.current.remove(3);
					experiences.current.remove(2);
					state = State.STATE_INIT;
					doBoucle = true;


    				} else if (state == State.STATE_2) {
log.info("state 2");
					experiences.current.remove(3);
					experiences.current.remove(2);
					state = State.STATE_INIT;
					doBoucle = true;


    				} else if (state == State.STATE_4) {
log.info("state 4");
					doBoucle = true;
				if (lastCritere < experiences.current.get(3).criteria) {
log.info("remove 2 et 3");
				    experiences.current.remove(3);
					experiences.current.remove(2);
				} else {
log.info("remove 2 et 4");
					experiences.current.remove(2);
					experiences.current.remove(4);
				}

				state = State.STATE_INIT;
   				}


}//fin du while
//on remplit la table experiences
			experiences.getExperience(number).q1 = q1;
      		experiences.getExperience(number).q2 = q2;

log.info("finalement Q1 = " + q1 + " " + "Q2 = " + q2);


// on change la valeur de q dans la DB
        	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;
log.info("after simulation");
        int number = context.getNumber();
        ResultStorage result = lastSimulation.getResultStorage();
          // Pour sommer sur certaines classes les resultats :
          MatrixND L = result.getMatrix(param_Population, ResultName.MATRIX_CATCH_WEIGHT_PER_STRATEGY_MET);      
		  //MatrixND L = L2.getSubMatrix(1,1,4).copy(); //on ne prend que les 5 premieres strategies (pas live bait)
//log.info("sous matrice extraite");		
		L = L.sumOverDim(1);// sum sur les strategies
        L = L.sumOverDim(2);// sum sur les metiers
        L = L.sumOverDim(4);// sum sur les zones
log.info("somme sur les strategies, metiers zones faites");
         int [] dims = new int[]{L.getDim(0), L.getDim(1), L.getDim(2), 4, L.getDim(4)}; // matrice a 5 dimension
           MatrixND tmp = MatrixFactory.getInstance().create(L.getName(), dims);
          int [] origin = new int[5]; // on initialise l'origine a [0,0,0,0,0]

log.info("Début de la boucle while");
            while (origin[0] < dims[0]-1){ //origin commence à 0 tandis que dim[0] commence a 1
Date date = new Date(origin[0]);
MatrixND age = L.getSubMatrix(0,origin[0],1).copy();

                         if (date.getMonth().before(Month.JULY)) {  //origin[0] >= i*12 && origin[0]<= 5+i*12 ) 
		age = age.sumOverDim(3,0,5);
		age = age.sumOverDim(3,1,10);
		age = age.sumOverDim(3,2,1);
		age = age.sumOverDim(3,3,2);
                        }else if (date.getMonth().equals(Month.JULY) || date.getMonth().equals(Month.AUGUST)) { //origin[0] >= 6+i*12 && origin[0]<= 7+i*12 ){
		age = age.sumOverDim(3,0,5);
		age = age.sumOverDim(3,1,11);
		age = age.sumOverDim(3,2,1);
		age = age.sumOverDim(3,3,1);

                       } else { // apres aout  //(origin[0] >= 8+i*12 && origin[0]<= 11+i*12 )
        age = age.sumOverDim(3,0,15);
        age = age.sumOverDim(3,1,1);
        age = age.sumOverDim(3,2,1);
        age = age.sumOverDim(3,3,1);

                       }//fin du else
tmp.paste (origin, age);
origin[0]++;

}//fin du while
log.info("fin du while");


       L = tmp.sumOverDim(0,3);
	   L = L.reduce();

 log.info("calcul du critere");       
log.info("dim de L" + " " + Arrays.toString(L.getDim()));
log.info("dim de obs" + " " + Arrays.toString(matrixDebarquement.getDim()));
 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);
        }// fin du for
log.info("critere = " + crit );
        experiences.getExperience(number).criteria = crit;
       return doNext;

}// fin du after simulation

    /**

     * 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();

log.info("q1 = " + exp.q1 + ";" + "q2 = " + exp.q2 );

		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);

			}

		}//fin du for

		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;

    	}
    }
}

Sigrid LEHUTA

tags

participants (1)