[Isis-fish-data-commits] r307 - branches/4.2.2/sensitivityanalysis

7 Nov 2012

Author: echatellier
Date: 2012-11-07 15:18:20 +0100 (Wed, 07 Nov 2012)
New Revision: 307

Url: http://forge.codelutin.com/repositories/revision/isis-fish-data/307

Log:
Rename sensitivy scripts with prefix

Added:
   branches/4.2.2/sensitivityanalysis/DOptimal.java
   branches/4.2.2/sensitivityanalysis/Fast.java
   branches/4.2.2/sensitivityanalysis/Morris.java
   branches/4.2.2/sensitivityanalysis/OptimumLHS.java
   branches/4.2.2/sensitivityanalysis/RandomLHS.java
   branches/4.2.2/sensitivityanalysis/RegularExpandGrid.java
   branches/4.2.2/sensitivityanalysis/RegularFractions.java
   branches/4.2.2/sensitivityanalysis/Sobol.java
Removed:
   branches/4.2.2/sensitivityanalysis/SensitivityCalculatorJavaExpandGrid.java
   branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRDOptimal.java
   branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRExpandGrid.java
   branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRFast.java
   branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRFrF2.java
   branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRMorris.java
   branches/4.2.2/sensitivityanalysis/SensitivityCalculatorROptimumLHS.java
   branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRRandomLHS.java
   branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRSobol.java
   branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRegularFractions.java

Copied: branches/4.2.2/sensitivityanalysis/DOptimal.java (from rev 305, branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRDOptimal.java)
===================================================================

--- branches/4.2.2/sensitivityanalysis/DOptimal.java	                        (rev 0)
+++ branches/4.2.2/sensitivityanalysis/DOptimal.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -0,0 +1,405 @@
+/*
+ * #%L
+ * IsisFish data
+ * %%
+ * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
+ * %%
+ * 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 3 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-3.0.html>.
+ * #L%
+ */
+
+package sensitivityanalysis;
+
+import fr.ifremer.isisfish.datastore.SimulationStorage;
+import fr.ifremer.isisfish.export.SensitivityExport;
+import fr.ifremer.isisfish.simulator.SimulationParameter;
+import fr.ifremer.isisfish.simulator.sensitivity.*;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.DiscreteDomain;
+import fr.ifremer.isisfish.util.Doc;
+import org.apache.commons.lang.StringUtils;
+import org.nuiton.j2r.REngine;
+import org.nuiton.j2r.RException;
+import org.nuiton.j2r.RProxy;
+import org.nuiton.j2r.types.RDataFrame;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * User: couteau
+ * Date: 14 janv. 2010
+ * Time: 11:58:09
+ */
+public class DOptimal extends AbstractSensitivityAnalysis {
+
+    @Doc("True to be able to modify the code sent to R")
+    public boolean param_modifR = false;
+
+    @Doc("Order")
+    public int param_order=1;
+
+    /**
+     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
+     * continue.
+     *
+     * @return <tt>true</tt> s'il sait la gerer
+     */
+    @Override
+    public boolean canManageCardinality() {
+        return false;
+    }
+
+    @Override
+    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
+            throws SensitivityException {
+
+        SensitivityScenarios thisExperiment = new SensitivityScenarios();
+
+        setIsisFactorsR(plan, outputDirectory);
+
+        //extract the factors from the design plan
+        List<Factor> factors = plan.getFactors();
+        int factorsNb = factors.size();
+
+        try {
+            REngine engine = new RProxy();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            engine.voidEval("library(AlgDesign)");
+
+            //Create a list of the factors under the form factor1=factor1,...
+            String factorsNames = "";
+
+            //Create a list of the factors under the form factor1,factor2,...
+            String factorNames = "";
+
+            //Create a list of the factors under the form factor1+factor2+...
+            String factorPlus="";
+
+            //create the factors vectors
+            for (Factor factor : factors) {
+                //The factor values vector
+                String factorName = factor.getName().replaceAll(" ", "");
+                factorsNames += factorName + "=" + factorName + ",";
+                factorNames += factorName + ",";
+                factorPlus += factorName + "+";
+
+                String vector = factorName + "<-c(";
+
+                Domain domain = factor.getDomain();
+
+                if (domain instanceof ContinuousDomain) {
+                    ContinuousDomain contDomain = (ContinuousDomain) domain;
+                    int card = factor.getCardinality();
+                    Double min = contDomain.getCalculatorMinBound();
+                    Double max = contDomain.getCalculatorMaxBound();
+
+                    for (int i = 0; i < card; i++) {
+                        //add the ith value
+                        vector += (min + (i * (max - min) / (card - 1))) + ",";
+                    }
+                } else {
+                    Map<Object, Object> values = ((DiscreteDomain) domain).getValues();
+                    int nbValues = values.size();
+                    for (int i = 0; i < nbValues; i++) {
+                        vector += "as.integer(" + i + "),";
+                    }
+                }
+
+                vector = vector.substring(0, vector.length() - 1);
+
+                vector += ")";
+
+                engine.voidEval(vector);
+
+
+            }
+
+            factorsNames = factorsNames.substring(0,factorsNames.length()-1);
+            factorNames = factorNames.substring(0,factorNames.length()-1);
+            factorPlus = factorPlus.substring(0,factorPlus.length()-1);
+
+
+            //X<-expand.grid(vector=???,weight=???)
+            String expandGrid = "expandgrid<-expand.grid(%s)";
+
+
+
+            String rCall = String.format(expandGrid,factorsNames);
+
+            engine.voidEval(rCall);
+
+            if (param_order ==1 ){
+                rCall = "x<-optFederov(~(%s),data=expandgrid, " +
+                        "approximate =FALSE, center=F, criterion = \"D\"," +
+                        "nRepeats=10)";
+            } else {
+                rCall = "x<-optFederov(~(%s)^"+param_order+",data=expandgrid, " +
+                        "approximate =FALSE, center=F, criterion = \"D\"," +
+                        "nRepeats=10)";
+            }
+
+            rCall = String.format(rCall,factorPlus);
+
+            if (param_modifR) {
+                rCall = editRInstruction(rCall);
+            }
+
+            engine.voidEval("runif(1)");
+
+            engine.voidEval(rCall);
+
+            engine.eval("expPlan<-as.data.frame(x$design)");
+            RDataFrame dataFrame = (RDataFrame)engine.eval("expPlan");
+            dataFrame.setVariable("expPlan");
+            int nbExperiments = (Integer)engine.eval("dim(x$design)[1]");
+
+            List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
+            for (int j = 0; j < nbExperiments; j++) {
+                Scenario experimentScenario = new Scenario();
+                for (int i = 0; i < factorsNb; i++) {
+                    Factor factor = factors.get(i);
+                    factor.setValueForIdentifier(dataFrame.get(i, j));
+                    experimentScenario.addFactor(factor);
+                }
+                thisExperimentScenarios.add(experimentScenario);
+                thisExperiment.setScenarios(thisExperimentScenarios);
+            }
+
+
+            String factorDistribution = "isis.factor.distribution<-data.frame(" +
+                "NomFacteur=c(%s)," +
+                "NomDistribution=c(%s)," +
+                "ParametreDistribution=c(%s))";
+
+            String distribution = "";
+            String parameters = "";
+
+            for (int i = 0; i < factorsNb; i++) {
+                Domain domain = factors.get(i).getDomain();
+                if (i != 0) {
+                    distribution += ",";
+                    parameters += ",";
+                }
+                if (domain instanceof ContinuousDomain){
+                    ContinuousDomain contDomain = (ContinuousDomain)domain;
+                    distribution += "\"qunif\"";
+                    parameters += "\"[" + contDomain.getMinBound()
+                            + ";" + contDomain.getMaxBound()
+                            + "]\"";
+                } else {
+                    DiscreteDomain discDomain = (DiscreteDomain)domain;
+                    distribution += "\"discrete\"";
+                    parameters+="\"[";
+                    Map<Object, Object> values = discDomain.getValues();
+                    int count=0;
+                    Collection<Object> collecValues = values.values();
+                    for (Object value:collecValues){
+                        if (count!=0){
+                            parameters += ",";
+                        }
+                        parameters += StringUtils.replace(value.toString(), "\"", "\\\"") ;
+                        count++;
+                    }
+                    parameters+="]\"";
+                }
+            }
+            engine.voidEval(String.format(factorDistribution, factorNames,
+                    distribution, parameters));
+
+            engine.voidEval("call<-\"" + rCall + "\"");
+            engine.voidEval("isis.MethodExp<-list(" +
+                    "\"isis.factors\"=isis.factors," +
+                    "\"isis.factor.distribution\"=isis.factor.distribution," +
+                    "\"call\"=call)");
+            engine.voidEval("attr(isis.MethodExp," +
+                    "\"nomModel\")<-\"isis-fish-externe-R\"");
+            engine.voidEval("isis.simule<-x$design");
+            engine.voidEval("attr(isis.simule," +
+                    "\"nomModel\")<-\"isis-fish-externe-R\"");
+            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
+
+            // Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+
+        } catch (RException eee) {
+            throw new SensitivityException("Can't generate scenarios", eee);
+        }
+
+        return thisExperiment;
+    }
+
+    @Override
+    public void analyzeResult(List<SimulationStorage> simulationStorages,
+            File outputDirectory) throws SensitivityException {
+
+        try {
+
+            REngine engine = new RProxy();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            //Get back the factors number
+            int factorNumber = (Integer)engine.eval("dim(x$design)[2]");
+
+            SimulationParameter param = simulationStorages.get(0).getParameter();
+            int sensitivityNumber = param.getSensitivityExport().size();
+
+            SimulationStorage firstStorage = simulationStorages.get(0);
+
+            String firstStorageName = firstStorage.getName().replaceAll("-", "");
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                SensitivityExport sensitivityExport =
+                        param.getSensitivityExport().get(k);
+
+                String name = sensitivityExport.getExportFilename();
+
+                String rInstruction = createImportInstruction(sensitivityExport,
+                        simulationStorages);
+
+                // Send the simulation results
+                engine.voidEval(rInstruction);
+
+                //Put results in isis.simule
+                engine.voidEval("isis.simule<-data.frame(isis.simule,"
+                        + name + ")");
+
+                //Create the dataforaov data.frame
+                String dataFrame = "dataforaov<-data.frame(x$design,"
+                        + name + "=" + name + ")";
+                engine.voidEval(dataFrame);
+
+                //Call aov()
+                String aovCall = "aovresult<-aov(" + name + "~(";
+                for (int j = 0; j < factorNumber; j++) {
+                    if (j < (factorNumber - 1)) {
+                        aovCall = aovCall
+                                + engine.eval("names(x$design)[" + (j + 1) + "]")
+                                + "+";
+                    } else {
+                        aovCall = aovCall
+                                + engine.eval("names(x$design)[" + (j + 1) + "]")
+                                + ")";
+                        if(param_order>1){
+                            aovCall+="^" + param_order + ",data=dataforaov)";
+                        }else{
+                            aovCall+=",data=dataforaov)";
+                        }
+                    }
+                }
+                engine.voidEval(aovCall);
+
+                /*Export the results
+                 *Export format is csv, data separated by ','
+                 *Results Export name is sensitivityExportName_Results.csv
+                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
+                 */
+
+//Compute Sum of Squares and Sensitivity indices
+                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
+                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
+                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
+
+                //Create a data.frame to export sensitivity important results in one file.
+                engine.voidEval("exportsensitivity<-data.frame(" +
+                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
+                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
+                engine.voidEval("names(exportsensitivity)<-c(" +
+                        "\"Sum Of Squares\"," +
+                        "\"Sensitivity indices\")");
+                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
+
+
+                //Set dataforaov names
+                engine.voidEval("resultsnames<-c(names(x$design),\"Result\")");
+                engine.voidEval("names(dataforaov)<-resultsnames");
+
+
+                /*Set the export directory
+                 *Export directory is the first simulation export directory.
+                 */
+                engine.setwd(outputDirectory);
+
+                //Save the results with the scenarios.
+                engine.voidEval("write.csv(dataforaov,\""
+                        + param.getSensitivityExport().get(k)
+
+                                .getExportFilename() + "_Results.csv\")");
+
+                //Save the sensitivity indices
+                engine.voidEval("write.csv(exportsensitivity,\""
+                        + param.getSensitivityExport().get(k)
+                                .getExportFilename()
+                        + "_SensitivityIndices.csv\")");
+                //FIXME export through java to enable export when using Rserve (when distant Rserve).
+
+                //creating isis.methodAnalyse
+                engine.voidEval("isis.methodAnalyse<-list(" +
+                        "\"isis.factors\"=isis.factors," +
+                        "\"isis.factor.distribution\"=isis.factor.distribution," +
+                        "\"isis.simule\"=isis.simule," +
+                        "\"call_method\"=\"" + aovCall + "\"," +
+                        "\"analysis_result\"=list(aovresult,IndSensibilite))");
+
+                engine.voidEval("attr(isis.methodAnalyse," +
+                        "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-isis.methodAnalyse";
+                engine.voidEval(String.format(renameIsisMethodAnalyse,
+                        firstStorageName + "." + name));
+
+            }
+
+            //Rename R objects for saving purpose
+            renameObjects(engine, firstStorageName);
+
+
+            //Clean temporary R objects
+            for (String object:engine.ls()) {
+                if (!object.startsWith(firstStorageName)){
+                    engine.remove(object);
+                }
+            }
+
+            //Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+            engine.terminate();
+
+        } catch (Exception e) {
+            throw new SensitivityException("Can't evaluate results", e);
+        }
+
+    }
+
+    @Override
+    public String getDescription() {
+        return "Implementation of D optimal method method using R, needs" +
+                "AlgDesign package to work";
+    }
+}

Copied: branches/4.2.2/sensitivityanalysis/Fast.java (from rev 305, branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRFast.java)
===================================================================
--- branches/4.2.2/sensitivityanalysis/Fast.java	                        (rev 0)
+++ branches/4.2.2/sensitivityanalysis/Fast.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -0,0 +1,358 @@
+/*
+ * #%L
+ * IsisFish data
+ * %%
+ * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
+ * %%
+ * 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 3 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-3.0.html>.
+ * #L%
+ */
+
+package sensitivityanalysis;
+
+import java.io.File;
+import java.util.List;
+
+import fr.ifremer.isisfish.simulator.sensitivity.*;
+import org.nuiton.j2r.REngine;
+import org.nuiton.j2r.RException;
+import org.nuiton.j2r.RProxy;
+
+import fr.ifremer.isisfish.datastore.SimulationStorage;
+import fr.ifremer.isisfish.export.SensitivityExport;
+import fr.ifremer.isisfish.simulator.SimulationParameter;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.DiscreteDomain;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.EquationContinuousDomain;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.MatrixContinuousDomain;
+import fr.ifremer.isisfish.util.Doc;
+import org.nuiton.j2r.types.RDataFrame;
+
+/**
+ * Implementation of Fast method using R.
+ * 
+ * @author jcouteau
+ * @version $Revision: 89 $
+ * 
+ * Last update : $Date: 2009-03-25 13:45:16 +0100 (mer., 25 mars 2009) $ By :
+ * $Author: jcouteau $
+ */
+public class Fast extends AbstractSensitivityAnalysis {
+
+    @Doc("an integer giving the sample size, i.e. the length of the " +
+    "discretization of the s-space (see Cukier et al.). (default=20)")
+    public int param_n = 20;
+
+    @Doc("an integer specifying the interference parameter, i.e. the number " +
+    "of harmonics to sum in the Fourier series decomposition (see Cukier et " +
+    "al.). (default=6)")
+    public int param_M = 6;
+
+    @Doc("True to be able to modify the code sent to R")
+    public boolean param_modifR = false;
+
+    /**
+     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
+     * continue.
+     * 
+     * @return <tt>true</tt> s'il sait la gerer
+     */
+    @Override
+    public boolean canManageCardinality() {
+        return true;
+    }
+
+    @Override
+    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
+        throws SensitivityException {
+
+        setIsisFactorsR(plan, outputDirectory);
+
+        RDataFrame dataFrame;
+        int nbExperiments;
+        int factorNumber = plan.getFactors().size();
+        List<Factor> factors = plan.getFactors();
+        SensitivityScenarios thisExperiment = new SensitivityScenarios();
+        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
+
+        //Test all factors, if one is discrete, return null
+        for (int i = 0; i < factorNumber; i++) {
+            if (factors.get(i).getDomain() instanceof DiscreteDomain) {
+                throw new SensitivityException(factors.get(i).getName() +
+                    " has a discrete domain, this is not acceptable for fast " +
+                    "method.");
+            }
+        }
+        String rInstruction = "a<-fast99(" +
+                "model=NULL," +
+                "factors=%s, " +
+                "n=%s, " +
+                "M=%s, " +
+                "q = \"qunif\", " +
+                "q.arg=list(min=0,max=1))";
+        String rCall = String.format(rInstruction, factors.size(), param_n,
+                param_M);
+
+        if (param_modifR) {
+            rCall = editRInstruction(rCall);
+        }
+
+        try {
+
+            REngine engine = new RProxy();
+
+            engine.clearSession();
+            engine.loadRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            // Load sensitivity package into R (if package already loaded,
+            // nothing happens.
+            engine.voidEval("library(sensitivity)");
+
+            // Run sensitivity analysis
+            engine.voidEval(rCall);
+
+            // Creating the factors vector.
+            rInstruction = "factornames<-c(";
+            for (int i = 0; i < factorNumber; i++) {
+                String factorName = factors.get(i).getName();
+                if (i != (factorNumber - 1)) {
+                    rInstruction += "\"" + factorName + "\",";
+                } else {
+                    rInstruction += "\"" + factorName + "\"";
+                }
+            }
+
+            rInstruction += ")";
+
+            engine.voidEval(rInstruction);
+
+            // Get back experiment plan
+            dataFrame = (RDataFrame) engine.eval("a$X");
+            dataFrame.setVariable("a$X");
+
+            nbExperiments = (Integer)engine.eval("dim(a$X)[1]");
+
+            String factorDistribution = "isis.factor.distribution<-data.frame(" +
+                "NomFacteur=c(%s)," +
+                "NomDistribution=c(%s)," +
+                "ParametreDistribution=c(%s))";
+
+            // Creating the vectors.
+            String distribution = "";
+            String parameters = "";
+            String factorNames = "";
+
+            for (int i = 0; i < factorNumber; i++) {
+                Factor factor = factors.get(i);
+                ContinuousDomain domain = (ContinuousDomain) factor.getDomain();
+                if (i != 0) {
+                    distribution += ",";
+                    parameters += ",";
+                    factorNames += ",";
+                }
+
+                distribution += "\"qunif\"";
+                parameters += "\"[" + domain.getMinBound() + ";" +
+                        domain.getMaxBound() + "]\"";
+                factorNames += "\"" + factor.getName() + "\"";
+            }
+            engine.voidEval(String.format(factorDistribution, factorNames,
+                    distribution, parameters));
+            
+            engine.voidEval("call<-a$call");
+
+           
+            engine.voidEval("isis.MethodExp<-list(" +
+                "\"isis.factors\"=isis.factors," +
+                "\"isis.factor.distribution\"=isis.factor.distribution," +
+                "\"call\"=call)");
+            
+            engine.voidEval("attr(isis.MethodExp,\"nomModel\")<-" +
+                    "\"isis-fish-externe-R\"");
+
+            engine.voidEval("isis.simule<-data.frame(a$X)");
+
+            engine.voidEval("attr(isis.simule,\"nomModel\")<-" +
+                    "\"isis-fish-externe-R\"");
+
+            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
+
+            // Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+            // Setting up the scenarios.
+            for (int j = 0; j < nbExperiments; j++) {
+                Scenario experimentScenario = new Scenario();
+                for (int i = 0; i < factorNumber; i++) {
+                    Factor factor = plan.getFactors().get(i);
+                    Domain domain = factor.getDomain();
+                    if ((domain instanceof MatrixContinuousDomain)
+                            || (domain instanceof EquationContinuousDomain)) {
+                        factor.setValueForIdentifier(dataFrame.get(i,j));
+                    } else {
+                        ContinuousDomain continuousDomain = (ContinuousDomain)domain;
+                        Double min = continuousDomain.getCalculatorMinBound();
+                        Double max = continuousDomain.getCalculatorMaxBound();
+                        Double dFValue = (Double)dataFrame.get(i,j);
+                        Double value = min + (max - min) * dFValue;
+                        factor.setValueForIdentifier(value);
+                    }
+                    experimentScenario.addFactor(factor);
+                }
+                thisExperimentScenarios.add(experimentScenario);
+                thisExperiment.setScenarios(thisExperimentScenarios);
+            }
+        } catch (RException eee) {
+            throw new SensitivityException("Can't generate scenarios", eee);
+        }
+        return thisExperiment;
+
+    }
+
+    @Override
+    public void analyzeResult(List<SimulationStorage> simulationStorages,
+            File outputDirectory) throws SensitivityException {
+
+        SimulationStorage storage = simulationStorages.get(0);
+        String simulationName = storage.getName().replaceAll("-", "");
+
+        try {
+
+            REngine engine = new RProxy();
+
+            //Clear session
+            engine.clearSession();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            engine.setwd(outputDirectory);
+
+            // Call R
+            // Load sensitivity package into R (if package already loaded,
+            // nothing happens.
+            engine.voidEval("library(sensitivity)");
+
+            SimulationParameter param = simulationStorages.get(0).getParameter();
+            
+            int sensitivityNumber = param.getSensitivityExport().size();
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                SensitivityExport sensitivityExport =
+                        param.getSensitivityExport().get(k);
+
+                String rInstruction = createImportInstruction(sensitivityExport,
+                        simulationStorages);
+
+                // Send the simulation results
+                engine.voidEval(rInstruction);
+
+                //Put results in isis.simule
+                engine.voidEval("isis.simule<-data.frame(isis.simule," +
+                        sensitivityExport.getExportFilename() + ")");
+            }
+
+            //adding attribute to isis.Simule
+            engine.voidEval("attr(isis.simule,\"nomModel\")<-" +
+                    "\"isis-fish-externe-R\"");
+            engine.voidEval("attr(isis.simule,\"call\")<-isis.MethodExp$call");
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                // Creates the R expression to import results in R
+                String name = param.getSensitivityExport().get(k)
+                        .getExportFilename();
+
+                //Compute results
+                engine.voidEval("tell(a,y=" + name + ")");
+
+                engine.voidEval("names(a$V)<-factornames");
+                engine.voidEval("names(a$X)<-factornames");
+                engine.voidEval("names(a$D1)<-factornames");
+                engine.voidEval("names(a$Dt)<-factornames");
+
+                //creating isis.methodAnalyse
+                engine.voidEval("isis.methodAnalyse<-list(" +
+                    "\"isis.factors\"=isis.factors," +
+                    "\"isis.factor.distribution\"=isis.factor.distribution," +
+                    "\"isis.simule\"=isis.simule," +
+                    "call_method=\"tell(a,y=" + name + ")" + "\"," +
+                    "\"analysis_result\"=a)");
+
+                //setting isis.methodAnalyse attributes
+                engine.voidEval("attr(isis.methodAnalyse,\"nomModel\")<-" +
+                        "\"isis-fish-externe-R\")");
+
+                //Create the data.frame of scenarios and results for export purpose
+                engine.voidEval("dfresults<-data.frame(a$X,a$y)");
+
+                //Set working directory
+                engine.setwd(outputDirectory);
+
+                //Export V
+                engine.voidEval("write.csv(a$V,\"" + name + "_V.csv\")");
+
+                //Export D1
+                engine.voidEval("write.csv(a$D1,\"" + name + "_D1.csv\")");
+
+                //Export Dt
+                engine.voidEval("write.csv(a$Dt,\"" + name + "_Dt.csv\")");
+                //Set dfresults names
+                engine.voidEval("resultsnames<-c(factornames,\"Result\")");
+                engine.voidEval("names(dfresults)<-resultsnames");
+
+                //Export results
+                engine.voidEval("write.csv(dfresults,\"" + name +
+                        "_Results.csv\")");
+                //FIXME export through java to enable export when using Rserve
+
+                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse" +
+                    "<-isis.methodAnalyse";
+
+                engine.voidEval(String.format(renameIsisMethodAnalyse,
+                        simulationName + "." + name));
+
+            }
+
+            //Rename R objects for saving purpose
+            renameObjects(engine, simulationName);
+
+            //Clean temporary R objects
+            for (String object:engine.ls()) {
+                if (!object.startsWith(simulationName)){
+                    engine.remove(object);
+                }
+            }
+
+            // Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+        } catch (Exception e) {
+            throw new SensitivityException("Can't evaluate results", e);
+        }
+    }
+
+    @Override
+    public String getDescription() {
+        return "Implementation of FAST method using R (needs the sensitivity " +
+            "package to work)";
+    }
+
+}

Copied: branches/4.2.2/sensitivityanalysis/Morris.java (from rev 305, branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRMorris.java)
===================================================================
--- branches/4.2.2/sensitivityanalysis/Morris.java	                        (rev 0)
+++ branches/4.2.2/sensitivityanalysis/Morris.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -0,0 +1,357 @@
+/*
+ * #%L
+ * IsisFish data
+ * %%
+ * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
+ * %%
+ * 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 3 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-3.0.html>.
+ * #L%
+ */
+
+package sensitivityanalysis;
+
+import fr.ifremer.isisfish.datastore.SimulationStorage;
+import fr.ifremer.isisfish.export.SensitivityExport;
+import fr.ifremer.isisfish.simulator.SimulationParameter;
+import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
+import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
+import fr.ifremer.isisfish.simulator.sensitivity.Factor;
+import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
+import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
+import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
+import fr.ifremer.isisfish.util.Doc;
+import org.nuiton.j2r.REngine;
+import org.nuiton.j2r.RException;
+import org.nuiton.j2r.RProxy;
+import org.nuiton.j2r.types.RDataFrame;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * Implementation of Morris method using R.
+ *
+ * @author jcouteau
+ * @version $Revision$
+ *
+ * Last update : $Date$ By :
+ * $Author$
+ */
+public class Morris extends AbstractSensitivityAnalysis {
+
+    @Doc("Integer giving the number of repetitions of the design, i.e. the number of elementary effect computed per factor. (Default value : 4)")
+    public int param_r = 4;
+
+    @Doc("True to be able to modify the code sent to R")
+    public boolean param_modifR = false;
+
+    /**
+     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
+     * continus.
+     *
+     * @return {@code true} s'il sait la gerer
+     */
+    @Override
+    public boolean canManageCardinality() {
+        return false;
+    }
+
+    @Override
+    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
+            throws SensitivityException {
+
+        setIsisFactorsR(plan, outputDirectory);
+
+        RDataFrame dataFrame;
+        int nbExperiments;
+        int factorNumber = plan.getFactors().size();
+
+        SensitivityScenarios thisExperiment = new SensitivityScenarios();
+
+        List<Factor> factors = plan.getFactors();
+
+        if (param_r == 0) {
+            param_r = 4;
+        }
+
+        testNoDiscrete(factors);
+
+        // Creating the vectors.
+        String factorNames = "";
+        String levels = "";
+        String gridJump = "";
+        String binf = "";
+        String bsup = "";
+        for (int i = 0; i < factorNumber; i++) {
+            Factor factor = factors.get(i);
+            ContinuousDomain domain = (ContinuousDomain) factor.getDomain();
+            if (i != 0) {
+                factorNames += ",";
+                levels += ",";
+                gridJump += ",";
+                binf += ",";
+                bsup += ",";
+            }
+
+            factorNames += "\"" + factor.getName() + "\"";
+
+            levels += factor.getCardinality();
+
+            gridJump += factor.getCardinality() / 2;
+
+            binf += domain.getCalculatorMinBound();
+
+            bsup += domain.getCalculatorMaxBound();
+        }
+
+        String rInstruction = "a<-morris(model=NULL,factors=c(%s),r=%s," +
+                "design=list(type=\"oat\",levels=c(%s),grid.jump=c(%s))," +
+                "binf=c(%s),bsup=c(%s))";
+
+        String rCall = String.format(rInstruction, factorNames, param_r,
+                levels, gridJump, binf, bsup);
+
+        if (param_modifR) {
+            rCall = editRInstruction(rCall);
+        }
+
+        REngine engine = null;
+
+        try {
+            engine = new RProxy();
+
+            engine.clearSession();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+            // Load sensitivity package into R (if package already loaded,
+            // nothing happens.
+            engine.voidEval("library(sensitivity)");
+
+            // Run sensitivity analysis
+            engine.voidEval(rCall);
+
+            // Creating the factors vector.
+            rInstruction = "factornames<-c(%s)";
+            rCall = String.format(rInstruction, factorNames);
+
+            engine.voidEval(rCall);
+
+            // Set output directory
+            engine.setwd(outputDirectory);
+
+            // Get back experiment plan
+            engine.eval("expPlan<-as.data.frame(a$X)");
+            dataFrame = (RDataFrame) engine.eval("expPlan");
+            dataFrame.setVariable("expPlan");
+
+            nbExperiments = (Integer)engine.eval("dim(expPlan)[1]");
+
+            String factorDistribution = "isis.factor.distribution<-data.frame(" +
+                    "NomFacteur=c(%s)," +
+                    "NomDistribution=c(%s)," +
+                    "ParametreDistribution=c(%s))";
+
+            String distribution = "";
+            String parameters = "";
+
+            for (int i = 0; i < factorNumber; i++) {
+                Factor factor = factors.get(i);
+                ContinuousDomain domain = (ContinuousDomain) factor.getDomain();
+                if (i != 0) {
+                    distribution += ",";
+                    parameters += ",";
+                }
+
+                distribution += "\"qunif\"";
+                parameters += "\"[" + domain.getMinBound() + ";" +
+                        domain.getMaxBound() + "]\"";
+            }
+            engine.voidEval(String.format(factorDistribution, factorNames,
+                    distribution, parameters));
+
+            engine.voidEval("call<-a$call");
+            engine.voidEval("isis.MethodExp<-list(" +
+                    "\"isis.factors\"=isis.factors," +
+                    "\"isis.factor.distribution\"=isis.factor.distribution," +
+                    "\"call\"=call)");
+            engine.voidEval("attr(isis.MethodExp,\"nomModel\")<-" +
+                    "\"isis-fish-externe-R\"");
+            engine.voidEval("isis.simule<-data.frame(expPlan)");
+            engine.voidEval("attr(isis.simule,\"nomModel\")<-" +
+                    "\"isis-fish-externe-R\"");
+            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
+
+            // Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+            // Setting up the scenarios.
+            List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
+            for (int j = 0; j < nbExperiments; j++) {
+                Scenario experimentScenario = new Scenario();
+                for (int i = 0; i < factorNumber; i++) {
+                    Factor factor = factors.get(i);
+                    factor.setValueForIdentifier(dataFrame.get(i, j));
+                    experimentScenario.addFactor(factor);
+                }
+                thisExperimentScenarios.add(experimentScenario);
+                thisExperiment.setScenarios(thisExperimentScenarios);
+            }
+
+        } catch (RException eee) {
+            throw new SensitivityException("Can't generate scenarios", eee);
+        }
+
+        return thisExperiment;
+
+    }
+
+    @Override
+    public void analyzeResult(List<SimulationStorage> simulationStorages,
+                              File outputDirectory) throws SensitivityException {
+
+        SimulationStorage storage = simulationStorages.get(0);
+        String simulationName = storage.getName().replaceAll("-", "");
+
+        REngine engine = null;
+
+        try {
+            engine = new RProxy();
+
+            engine.clearSession();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+            // Call R
+            // Load sensitivity package into R (if package already loaded,
+            // nothing happens.
+            engine.voidEval("library(sensitivity)");
+
+            //Set the working directory (for exports)
+            engine.setwd(outputDirectory);
+
+            SimulationParameter param = simulationStorages.get(0)
+                    .getParameter();
+            int sensitivityNumber = param.getSensitivityExport().size();
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                SensitivityExport sensitivityExport =
+                        param.getSensitivityExport().get(k);
+
+                String rInstruction = createImportInstruction(sensitivityExport,
+                        simulationStorages);
+
+                // Send the simulation results
+                engine.voidEval(rInstruction);
+
+                //Put results in isis.simule
+                engine.voidEval("isis.simule<-data.frame(isis.simule," +
+                        sensitivityExport.getExportFilename() + ")");
+            }
+
+            //adding attribute to isis.Simule
+            engine.voidEval("attr(isis.simule,\"nomModel\")<-" +
+                    "\"isis-fish-externe-R\"");
+
+            engine.voidEval("attr(isis.simule,\"call\")<-isis.MethodExp$call");
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                // Creates the R expression to import results in R
+                String name = param.getSensitivityExport().get(k)
+                        .getExportFilename();
+
+                //Compute results
+                engine.voidEval("tell(a,y=" + name + ")");
+
+                //creating isis.methodAnalyse
+                engine.voidEval("isis.methodAnalyse<-list(" +
+                        //"\"isis.factors\"=isis.factors," +
+                        //"\"isis.factor.distribution\"=isis.factor.distribution," +
+                        "\"isis.simule\"=isis.simule," +
+                        "\"call_method\"=\"tell(a,y=" + name + ")" + "\"," +
+                        "\"analysis_result\"=a)");
+
+                //setting isis.methodAnalyse attributes
+                engine.voidEval("attr(isis.methodAnalyse,\"nomModel\")<-" +
+                        "\"isis-fish-externe-R\"");
+
+                // Get back the sensitivity results, mu, mu star and sigma.
+                engine.voidEval("mu<-apply(a$ee, 2, mean)");
+                engine.voidEval("mu.star <- apply(a$ee, 2, function(a) mean(abs(a)))");
+                engine.voidEval("sigma <- apply(a$ee, 2, sd)");
+
+                //Create the data.frame of sensitivity indices for export purpose
+                engine.voidEval("df<-data.frame(mu,mu.star,sigma)");
+                engine.voidEval("row.names(df)<-factornames");
+
+                //Create the data.frame of scenarios and results for export purpose
+                engine.voidEval("dfresults<-data.frame(a$X," + name + ")");
+
+                //Set dfresults names
+                engine.voidEval("resultsnames<-c(factornames,\"Result\")");
+                engine.voidEval("names(dfresults)<-resultsnames");
+
+                //Export sensitivity indices
+                engine.voidEval("write.csv(df," +
+                        "\"" + name + "_SensitivityIndices.csv\")");
+
+                //Export results
+                engine.voidEval("write.csv(dfresults," +
+                        "\"" + name + "_Results.csv\")");
+                //FIXME export through java to enable export when using Rserve
+
+                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-" +
+                        "isis.methodAnalyse";
+
+                engine.voidEval(String.format(renameIsisMethodAnalyse,
+                        simulationName + "." + name));
+
+            }
+
+            //Rename R objects for saving purpose
+            renameObjects(engine,simulationName);
+
+            //Clean temporary R objects
+            for (String object:engine.ls()) {
+                if (!object.startsWith(simulationName)){
+                    engine.remove(object);
+                }
+            }
+
+            // Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+        } catch (Exception e) {
+            throw new SensitivityException("Can't evaluate results", e);
+        }
+
+    }
+
+    @Override
+    public String getDescription() {
+        return "Implementation of Morris method using R (needs the sensitivity" +
+                " package to work)";
+    }
+
+}

Copied: branches/4.2.2/sensitivityanalysis/OptimumLHS.java (from rev 305, branches/4.2.2/sensitivityanalysis/SensitivityCalculatorROptimumLHS.java)
===================================================================
--- branches/4.2.2/sensitivityanalysis/OptimumLHS.java	                        (rev 0)
+++ branches/4.2.2/sensitivityanalysis/OptimumLHS.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -0,0 +1,404 @@
+/*
+ * #%L
+ * IsisFish data
+ * %%
+ * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
+ * %%
+ * 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 3 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-3.0.html>.
+ * #L%
+ */
+
+package sensitivityanalysis;
+
+import java.io.File;
+import java.util.List;
+
+import org.nuiton.j2r.REngine;
+import org.nuiton.j2r.RProxy;
+
+import fr.ifremer.isisfish.datastore.SimulationStorage;
+import fr.ifremer.isisfish.export.SensitivityExport;
+import fr.ifremer.isisfish.simulator.SimulationParameter;
+import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
+import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
+import fr.ifremer.isisfish.simulator.sensitivity.Factor;
+import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
+import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
+import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
+import fr.ifremer.isisfish.util.Doc;
+import org.nuiton.j2r.types.RDataFrame;
+
+/**
+ * Implementation of Optimum Latin Hypercube method using R.
+ * 
+ * @author jcouteau
+ * @version $Revision: 1.0 $
+ */
+public class OptimumLHS extends AbstractSensitivityAnalysis {
+
+    @Doc("Number of simulations (default=10)")
+    public int param_simulationNumber = 10;
+    @Doc("The maximum number of times the Columnwise Pairwise algorithm is applied to all the columns(default=2).")
+    public int param_MaxSweeps = 2;
+    @Doc("The optimal stopping criterion (between 0 and 1) (default=0.1).")
+    public double param_eps = 0.1;
+    @Doc("True to be able to modify the code sent to R")
+    public boolean param_modifR = false;
+
+    /**
+     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
+     * continue.
+     * 
+     * @return <tt>true</tt> s'il sait la gerer
+     */
+    @Override
+    public boolean canManageCardinality() {
+        return true;
+    }
+
+    @Override
+    public SensitivityScenarios compute(DesignPlan plan, File outputdirectory)
+            throws SensitivityException {
+
+        setIsisFactorsR(plan, outputdirectory);
+
+        int factorNumber = plan.getFactors().size();
+        List<Factor> factors = plan.getFactors();
+        RDataFrame dataFrame;
+        SensitivityScenarios thisExperiment = new SensitivityScenarios();
+        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
+
+        //Test all factors, if one is discrete, return null
+        testNoDiscrete(factors);
+
+        try {
+            REngine engine = new RProxy();
+
+            //Clear session
+            engine.clearSession();
+
+            //Set working directory to get Isis R session
+            engine.loadRData(outputdirectory.getParentFile(),
+                outputdirectory.getName());
+
+            //Load the lhs library
+            engine.voidEval("library(lhs)");
+
+            String rInstruction = "x<-optimumLHS(n=%s,k=%s,maxSweeps=%s,eps=%s)";
+
+            String rCall = String.format(rInstruction, param_simulationNumber,
+                    factorNumber, param_MaxSweeps, param_eps);
+
+            if (param_modifR) {
+                rCall = editRInstruction(rCall);
+            }
+
+            //Create the scenarios
+            engine.voidEval(rCall);
+
+            // Get back experiment plan
+            engine.eval("expPlan<-as.data.frame(x)");
+            dataFrame = (RDataFrame)engine.eval("expPlan");
+            dataFrame.setVariable("expPlan");
+
+            // Setting up the scenarios.
+            for (int j = 0; j < param_simulationNumber; j++) {
+                Scenario experimentScenario = new Scenario();
+                for (int i = 0; i < factorNumber; i++) {
+                    Factor factor = plan.getFactors().get(i);
+                    factor.setValueForIdentifier(dataFrame.get(i, j));
+                    experimentScenario.addFactor(factor);
+                }
+                thisExperimentScenarios.add(experimentScenario);
+                thisExperiment.setScenarios(thisExperimentScenarios);
+            }
+
+            String isisFactorDistribution = "isis.factor.distribution<-" +
+                "data.frame(" +
+                "NomFacteur=c(%s)," +
+                "NomDistribution=c(%s)," +
+                "ParametreDistribution=c(%s))";
+
+            String distribution = "";
+            String parameters = "";
+            String factorNames = "";
+
+            for (int i = 0; i < factors.size(); i++) {
+                Factor tempFactor = factors.get(i);
+                ContinuousDomain domain = (ContinuousDomain) tempFactor.getDomain();
+                if (i != 0) {
+                    distribution += ",";
+                    factorNames += ",";
+                    parameters += ",";
+                }
+
+                factorNames += "\"" + factors.get(i).getName() + "\"";
+                distribution += "\"qunif\"";
+                //add [min;max] to parameters
+                parameters += "\"[" + domain.getMinBound() + ";" +
+                    domain.getMaxBound() + "]\"";
+            }
+
+            engine.voidEval(String.format(isisFactorDistribution, factorNames,
+                    distribution, parameters));
+            
+            engine.voidEval("call<-" + "\"x<-optimumLHS("
+                + "n=" + param_simulationNumber
+                + ",k=" + factorNumber
+                + ",maxSweeps=" + param_MaxSweeps
+                + ",eps=" + param_eps + ")\"");
+
+            engine.voidEval("isis.MethodExp<-list(" +
+                "\"isis.factors\"=isis.factors," +
+                "\"isis.factor.distribution\"=isis.factor.distribution," +
+                "\"call\"=call)");
+
+            engine.voidEval("attr(isis.MethodExp," +
+                "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+            engine.voidEval("isis.simule<-data.frame(x)");
+
+            engine.voidEval("attr(isis.simule," +
+                "\"nomModel\")<-\"isis-fish-externe-R\"");
+            
+            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
+
+            String data = "data<-data.frame(";
+
+            //Create the factors vectors and the dataFrame instruction
+            for (int j = 0; j < factors.size(); j++) {
+                //The factor values vector
+                String vector;
+                //Get back the factor
+                Scenario scenario = thisExperimentScenarios.get(0);
+                Factor factor = scenario.getFactors().get(j);
+                String factorName = factor.getName().replaceAll(" ", "");
+
+                vector = factorName + "<-c(";
+                for (int i = 0; i < param_simulationNumber; i++) {
+                    //Get back the displayed value the factor
+                    Scenario tempScenario = thisExperimentScenarios.get(i);
+                    Factor tempFactor = tempScenario.getFactors().get(j);
+                    Object value = tempFactor.getDisplayedValue();
+
+                    if (i < (param_simulationNumber - 1)) {
+                        vector = vector + value + ",";
+                    } else {
+                        vector += value;
+                    }
+
+                }
+                vector += ")";
+                engine.voidEval(vector);
+
+                if (j < factors.size() - 1) {
+                    data += factorName + "=factor(" + factorName + "),";
+                } else {
+                    data += factorName + "=factor(" + factorName + "))";
+                }
+            }
+            engine.voidEval(data);
+
+            // Creating the factors vector.
+            rInstruction = "factornames<-c(";
+            for (int i = 0; i < factorNumber; i++) {
+                if (i != (factorNumber - 1)) {
+                    rInstruction = rInstruction + "\""
+                            + factors.get(i).getName() + "\",";
+                } else {
+                    rInstruction = rInstruction + "\""
+                            + factors.get(i).getName() + "\"";
+                }
+            }
+
+            rInstruction += ")";
+
+            engine.voidEval(rInstruction);
+
+            // Save Isis R session
+            engine.saveRData(outputdirectory.getParentFile(),
+                outputdirectory.getName());
+
+            engine.terminate();
+
+        } catch (Exception e) {
+            throw new SensitivityException("Can't generate scenarios", e);
+        }
+
+        return thisExperiment;
+    }
+
+    @Override
+    public void analyzeResult(List<SimulationStorage> simulationStorages,
+            File outputDirectory) throws SensitivityException {
+
+        //The first storage to get the name and parameters all along the method
+        SimulationStorage storage = simulationStorages.get(0);
+
+        String simulationName = storage.getName().replaceAll("-", "");
+
+        try {
+
+            REngine engine = new RProxy();
+
+            //Clear session
+            engine.clearSession();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            engine.voidEval("factors<-data.frame(x)");
+            engine.voidEval("names(factors)<-factornames");
+
+            //Get back the factors number
+            int factorNumber = (Integer) engine.eval("length(factors[1,])");
+            //Get back the simulation number
+            param_simulationNumber = (Integer) (engine.eval("length(factors[,1])"));
+
+            SimulationParameter param = storage.getParameter();
+            int sensitivityNumber = param.getSensitivityExport().size();
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                SensitivityExport sensitivityExport =
+                        param.getSensitivityExport().get(k);
+
+                String rInstruction = createImportInstruction(sensitivityExport,
+                        simulationStorages);
+
+                // Send the simulation results
+                engine.voidEval(rInstruction);
+
+                //Put results in isis.simule
+                engine.voidEval("isis.simule<-data.frame(isis.simule," +
+                        sensitivityExport.getExportFilename() + ")");
+            }
+
+            //adding attribute to isis.Simule
+            engine.voidEval("attr(isis.simule," +
+                "\"nomModel\")<-\"isis-fish-externe-R\"");
+            engine.voidEval("attr(isis.simule,\"call\")<-isis.MethodExp$call");
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                // Creates the R expression to import results in R
+                SensitivityExport export = param.getSensitivityExport().get(k);
+                String name = export.getExportFilename();
+
+                //Create the dataforaov data.frame
+                String dataframe = "dataforaov<-data.frame(factors," +
+                    name + "=" + name + ")";
+                engine.voidEval(dataframe);
+
+                //Call aov()
+                String aovCall = "aovresult<-aov(" + name + "~";
+                for (int j = 0; j < factorNumber; j++) {
+
+                    String factorName = (String) engine.eval("names(factors)[" + (j + 1) + "]");
+                    factorName = factorName.replaceAll(" ", ".");
+
+                    if (j < (factorNumber - 1)) {
+                        aovCall += factorName +
+                            "+";
+                    } else {
+                        aovCall += factorName + ",data=dataforaov)";
+                    }
+                }
+                engine.voidEval(aovCall);
+
+                /*Export the results
+                 *Export format is csv, data separated by ','
+                 *Results Export name is sensitivityExportName_Results.csv
+                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
+                 */
+
+                //Compute Sum of Squares and Sensitivity indices
+                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
+                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
+                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
+
+                //Create a data.frame to export sensitivity important results in one file.
+                engine.voidEval("exportsensitivity<-data.frame(" +
+                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
+                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
+                engine.voidEval("names(exportsensitivity)<-c(" +
+                        "\"Sum Of Squares\"," +
+                        "\"Sensitivity indices\")");
+                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
+
+
+                //Set dataforaov names
+                engine.voidEval("names(dataforaov)<-c(factornames,\"Result\")");
+
+                /*Set the export directory
+                 *Export directory is the first simulation export directory. 
+                 */
+                engine.setwd(outputDirectory);
+
+                //Save the results with the scenarios.
+                engine.voidEval("write.csv(dataforaov,\"" +
+                        name + "_Results.csv\")");
+
+                //Save the sensitivity indices
+                engine.voidEval("write.csv(exportsensitivity,\"" +
+                        name + "_SensitivityIndices.csv\")");
+                //FIXME export through java to enable export when using Rserve (when distant Rserve).
+
+                //creating isis.methodAnalyse
+                engine.voidEval("isis.methodAnalyse<-list(" +
+                    "\"isis.factors\"=isis.factors," +
+                    "\"isis.factor.distribution\"=isis.factor.distribution," +
+                    "\"isis.simule\"=isis.simule," +
+                    "call_method=\"" + aovCall + "\""+
+                    ",\"analysis_result\"=list(aovresult,IndSensibilite))");
+
+                engine.voidEval("attr(isis.methodAnalyse," +
+                    "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-" +
+                    "isis.methodAnalyse";
+
+                engine.voidEval(String.format(renameIsisMethodAnalyse,
+                    simulationName + "." + name));
+
+            }
+
+            //Rename R objects for saving purpose
+            renameObjects(engine, simulationName);
+
+            //Clean temporary R objects
+            for (String object:engine.ls()) {
+                if (!object.startsWith(simulationName)){
+                    engine.remove(object);
+                }
+            }
+
+            engine.terminate();
+
+        } catch (Exception e) {
+            throw new SensitivityException("Can't evaluate results", e);
+        }
+
+    }
+
+    @Override
+    public String getDescription() {
+        return "Implementation of Random Latin Hypercube method method " +
+            "using R (needs 'lhs' package to work)";
+    }
+
+}

Copied: branches/4.2.2/sensitivityanalysis/RandomLHS.java (from rev 305, branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRRandomLHS.java)
===================================================================
--- branches/4.2.2/sensitivityanalysis/RandomLHS.java	                        (rev 0)
+++ branches/4.2.2/sensitivityanalysis/RandomLHS.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -0,0 +1,402 @@
+/*
+ * #%L
+ * IsisFish data
+ * %%
+ * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
+ * %%
+ * 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 3 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-3.0.html>.
+ * #L%
+ */
+
+package sensitivityanalysis;
+
+import java.io.File;
+import java.lang.String;
+import java.util.List;
+
+import fr.ifremer.isisfish.export.SensitivityExport;
+import org.nuiton.j2r.REngine;
+import org.nuiton.j2r.RProxy;
+import org.nuiton.j2r.types.RDataFrame;
+
+import fr.ifremer.isisfish.datastore.SimulationStorage;
+import fr.ifremer.isisfish.simulator.SimulationParameter;
+import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
+import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
+import fr.ifremer.isisfish.simulator.sensitivity.Factor;
+import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
+import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
+import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
+import fr.ifremer.isisfish.util.Doc;
+
+/**
+ * Implementation of Random Latin Hypercube method using R.
+ * 
+ * @author jcouteau
+ * @version $Revision: 1.0 $
+ */
+public class RandomLHS extends AbstractSensitivityAnalysis {
+
+    @Doc("Simulation number (default=10)")
+    public int param_simulationNumber = 10;
+    @Doc("True to be able to modify the code sent to R")
+    public boolean param_modifR = false;
+
+    /**
+     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
+     * continue.
+     * 
+     * @return <tt>true</tt> s'il sait la gerer
+     */
+    @Override
+    public boolean canManageCardinality() {
+        return true;
+    }
+
+    @Override
+    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
+            throws SensitivityException {
+
+        setIsisFactorsR(plan, outputDirectory);
+
+        int factorNumber = plan.getFactors().size();
+        RDataFrame dataFrame; //The dataframe to get back the scenarios from R
+        SensitivityScenarios thisExperiment = new SensitivityScenarios(); //The experiment we will build
+        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios(); //The list of scenarios
+        List<Factor> factors = plan.getFactors(); //The factors
+
+        testNoDiscrete(factors);
+
+        try {
+
+            REngine engine = new RProxy(); //The R engine
+
+            //Clear session
+            engine.clearSession();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            //Load the lhs library
+            engine.voidEval("library(lhs)");
+
+            //Create the scenarios
+            String rInstruction = "x<-randomLHS(%s,%s)";
+            String rCall = String.format(rInstruction, param_simulationNumber,
+                    factorNumber);
+
+            if (param_modifR) {
+                rCall = editRInstruction(rCall);
+            }
+
+            engine.voidEval(rCall);
+
+            // Get back experiment plan
+            engine.eval("expPlan<-as.data.frame(x)");
+            dataFrame = (RDataFrame)engine.eval("expPlan");
+            dataFrame.setVariable("expPlan");
+
+            // Setting up the scenarios.
+            for (int j = 0; j < param_simulationNumber; j++) {
+                Scenario experimentScenario = new Scenario();
+                for (int i = 0; i < factorNumber; i++) {
+                    Factor factor = plan.getFactors().get(i); //The factor we are setting
+                    factor.setValueForIdentifier(dataFrame.get(i,j));
+                    experimentScenario.addFactor(factor);
+                }
+                thisExperimentScenarios.add(experimentScenario);
+                thisExperiment.setScenarios(thisExperimentScenarios);
+            }
+
+            String isisFactorDistribution = "isis.factor.distribution<-" +
+                "data.frame(" +
+                "NomFacteur=c(%s)," +
+                "NomDistribution=c(%s)," +
+                "ParametreDistribution=c(%s))";
+
+            String distribution = "";
+            String parameters = "";
+            String factorNames = "";
+
+
+            //Create the strings for the isis.MethodExp instruction
+            for (int i = 0; i < factors.size(); i++) {
+                ContinuousDomain domain = (ContinuousDomain)factors.get(i).getDomain();
+                if (i != 0) {
+                    distribution += ","; //the distribution
+                    factorNames += ","; //the factor names
+                    parameters += ","; //the parameters
+                }
+
+                factorNames += "\"" + factors.get(i).getName() + "\"";
+                distribution += "\"qunif\""; //all distributions are qunif
+                double min = domain.getCalculatorMinBound();
+                double max = domain.getCalculatorMaxBound();
+                parameters += "\"[" + min + ";" + max + "]\"";
+            }
+            engine.voidEval(String.format(isisFactorDistribution, factorNames,
+                    distribution, parameters));
+
+            engine.voidEval("call<-" + "\"x<-randomLHS("
+                    + param_simulationNumber + "," + factorNumber + ")\"");
+
+            engine.voidEval("isis.MethodExp<-list(" +
+                "\"isis.factors\"=isis.factors," +
+                "\"isis.factor.distribution\"=isis.factor.distribution," +
+                "\"call\"=call)");
+
+            engine.voidEval("attr(isis.MethodExp," +
+                "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+            engine.voidEval("isis.simule<-data.frame(x)");
+            engine.voidEval("attr(isis.simule," +
+                "\"nomModel\")<-\"isis-fish-externe-R\"");
+            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
+
+            String data = "data<-data.frame(";
+
+            //Create the factors vectors and the dataFrame instruction
+            for (int j = 0; j < factors.size(); j++) {
+                Scenario firstScenario = thisExperimentScenarios.get(0);
+                Factor factor = firstScenario.getFactors().get(j);
+                String factorName = factor.getName().replaceAll(" ", "");
+
+                //the vector of the factor values
+                //read all the values one by one from the already created
+                //scenarios.
+                String vector = factorName + "<-c(";
+                for (int i = 0; i < param_simulationNumber; i++) {
+                    Scenario scenario = thisExperimentScenarios.get(i);
+                    List<Factor> factorList = scenario.getFactors();
+                    Factor factor1 = factorList.get(j);
+                    if (i < (param_simulationNumber - 1)) {
+                        vector += factor1.getDisplayedValue() + ",";
+                    } else {
+                        vector += factor1.getDisplayedValue();
+                    }
+
+                }
+                vector = vector + ")";
+                engine.voidEval(vector);
+
+                //add factor1=factor(factor1) for each factor...
+                if (j < factors.size() - 1) {
+                    data += factorName + "=factor(" + factorName + "),";
+                } else {
+                    data += factorName + "=factor(" + factorName + "))";
+                }
+
+            }
+            engine.voidEval(data);
+
+            // Creating the factors vector.
+            rInstruction = "factornames<-c(";
+            for (int i = 0; i < factorNumber; i++) {
+                if (i != (factorNumber - 1)) {
+                    rInstruction = rInstruction + "\""
+                            + factors.get(i).getName() + "\",";
+                } else {
+                    rInstruction = rInstruction + "\""
+                            + factors.get(i).getName() + "\"";
+                }
+            }
+            rInstruction += ")";
+            engine.voidEval(rInstruction);
+            
+            // Clean RData
+            for (Factor factor:factors) {
+                engine.remove(factor.getName().replaceAll(" ", ""));
+            }
+
+            // Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            engine.terminate();
+
+        } catch (Exception e) {
+            throw new SensitivityException("Can't generate scenarios", e);
+        }
+
+        return thisExperiment;
+    }
+
+    @Override
+    public void analyzeResult(List<SimulationStorage> simulationStorages,
+            File outputDirectory) throws SensitivityException {
+
+        SimulationStorage simulationStorage1 = simulationStorages.get(0);
+        String simName = simulationStorage1.getName();
+        String simulationName = simName.replaceAll("-", "");
+        SimulationParameter param = simulationStorage1.getParameter();
+        int sensitivityNumber = param.getSensitivityExport().size();
+        //List<SensitivityExport> export = param.getSensitivityExport();
+
+        try {
+            REngine engine = new RProxy();
+
+            //Clear session
+            engine.clearSession();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            engine.voidEval("factors<-data.frame(x)");
+
+            //Get back the factors number
+            int factorNumber = (Integer) engine.eval("length(factors)");
+
+            //Get back the simulation number
+            param_simulationNumber = (Integer) (engine.eval("length(factors[,1])"));
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                SensitivityExport sensitivityExport =
+                        param.getSensitivityExport().get(k);
+
+                String rInstruction = createImportInstruction(sensitivityExport,
+                        simulationStorages);
+
+                // Send the simulation results
+                engine.voidEval(rInstruction);
+
+                //Put results in isis.simule
+                engine.voidEval("isis.simule<-data.frame(isis.simule," +
+                        sensitivityExport.getExportFilename() + ")");
+            }
+
+            //adding attribute to isis.Simule
+            engine.voidEval("attr(isis.simule," +
+                "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+            engine.voidEval("attr(isis.simule,\"call\")<-isis.MethodExp$call");
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                // Creates the R expression to import results in R
+                String name = param.getSensitivityExport().get(k)
+                        .getExportFilename();
+
+                //Create the dataforaov data.frame
+                String dataframe = "dataforaov<-data.frame(factors," + name
+                        + "=" + name + ")";
+                engine.voidEval(dataframe);
+
+                //Call aov()
+                String aovCall = "aovresult<-aov(" + name + "~";
+                for (int j = 0; j < factorNumber; j++) {
+
+                    if (j < (factorNumber - 1)) {
+                        aovCall += engine.eval("names(factors)[" + (j + 1) + "]")
+                                + "+";
+                    } else {
+                        aovCall += engine.eval("names(factors)[" + (j + 1) + "]")
+                                + ",data=dataforaov)";
+                    }
+                }
+                engine.voidEval(aovCall);
+
+                /*Export the results
+                 *Export format is csv, data separated by ','
+                 *Results Export name is sensitivityExportName_Results.csv
+                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
+                 */
+
+                //Compute Sum of Squares and Sensitivity indices
+                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
+                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
+                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
+
+                //Create a data.frame to export sensitivity important results in one file.
+                engine.voidEval("exportsensitivity<-data.frame(" +
+                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
+                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
+                engine.voidEval("names(exportsensitivity)<-c(" +
+                        "\"Sum Of Squares\"," +
+                        "\"Sensitivity indices\")");
+                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
+
+
+                //Set dataforaov names
+                engine.voidEval("resultsnames<-c(factornames,\"Result\")");
+                engine.voidEval("names(dataforaov)<-resultsnames");
+
+                /*Set the export directory
+                 *Export directory is the first simulation export directory.
+                 */
+                engine.setwd(outputDirectory);
+
+                //Save the results with the scenarios.
+                engine.voidEval("write.csv(dataforaov,\"" +
+                    param.getSensitivityExport().get(k).getExportFilename() +
+                    "_Results.csv\")");
+
+                //Save the sensitivity indices
+                engine.voidEval("write.csv(exportsensitivity,\"" +
+                    param.getSensitivityExport().get(k).getExportFilename() +
+                    "_SensitivityIndices.csv\")");
+                //FIXME export through java to enable export when using Rserve (when distant Rserve).
+
+                //creating isis.methodAnalyse
+                engine.voidEval("isis.methodAnalyse<-list(" +
+                    "\"isis.factors\"=isis.factors," +
+                    "\"isis.factor.distribution\"=isis.factor.distribution," +
+                    "\"isis.simule\"=isis.simule," +
+                    "call_method=\"" + aovCall + "\"," +
+                    "\"analysis_result\"=list(aovresult,IndSensibilite))");
+
+                engine.voidEval("attr(isis.methodAnalyse," +
+                    "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-" +
+                    "isis.methodAnalyse";
+                engine.voidEval(String.format(renameIsisMethodAnalyse,
+                        simulationName + "." + name));
+
+            }
+
+            //Rename R objects for saving purpose
+            renameObjects(engine, simulationName);
+
+            //Clean temporary R objects
+            for (String object:engine.ls()) {
+                if (!object.startsWith(simulationName)){
+                    engine.remove(object);
+                }
+            }
+
+
+            // Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            engine.terminate();
+
+        } catch (Exception e) {
+            throw new SensitivityException("Can't evaluate results", e);
+        }
+
+    }
+
+    @Override
+    public String getDescription() {
+        return "Implementation of Random Latin Hypercube method method using" +
+            " R needs the 'lhs' package to work)";
+    }
+
+}

Copied: branches/4.2.2/sensitivityanalysis/RegularExpandGrid.java (from rev 305, branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRExpandGrid.java)
===================================================================
--- branches/4.2.2/sensitivityanalysis/RegularExpandGrid.java	                        (rev 0)
+++ branches/4.2.2/sensitivityanalysis/RegularExpandGrid.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -0,0 +1,374 @@
+/*
+ * #%L
+ * IsisFish data
+ * %%
+ * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
+ * %%
+ * 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 3 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-3.0.html>.
+ * #L%
+ */
+
+package sensitivityanalysis;
+
+import fr.ifremer.isisfish.datastore.SimulationStorage;
+import fr.ifremer.isisfish.export.SensitivityExport;
+import fr.ifremer.isisfish.simulator.SimulationParameter;
+import fr.ifremer.isisfish.simulator.sensitivity.*;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.DiscreteDomain;
+import fr.ifremer.isisfish.util.Doc;
+import org.apache.commons.lang.StringUtils;
+import org.nuiton.j2r.REngine;
+import org.nuiton.j2r.RException;
+import org.nuiton.j2r.RProxy;
+import org.nuiton.j2r.types.RDataFrame;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * User: couteau
+ * Date: 6 janv. 2010
+ * Time: 14:31:09
+ */
+public class RegularExpandGrid extends AbstractSensitivityAnalysis {
+
+    @Doc("Interaction order")
+    public int param_order = 2;
+
+    @Doc("True to be able to modify the code sent to R")
+    public boolean param_modifR = false;
+
+    /**
+     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
+     * continue.
+     *
+     * @return <tt>true</tt> s'il sait la gerer
+     */
+    @Override
+    public boolean canManageCardinality() {
+        return false;
+    }
+
+    @Override
+    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
+            throws SensitivityException {
+
+        SensitivityScenarios thisExperiment = new SensitivityScenarios();
+
+        setIsisFactorsR(plan, outputDirectory);
+
+        //extract the factors from the design plan
+        List<Factor> factors = plan.getFactors();
+        int factorsNb = factors.size();
+
+        try {
+            REngine engine = new RProxy();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            //Create a list of the factors under the form factor1=factor1,...
+            String factorsNames = "";
+
+            //Create a list of the factors under the form factor1,factor2,...
+            String factorNames = "";
+
+            //create the factors vectors
+            for (Factor factor : factors) {
+                //The factor values vector
+                String factorName = factor.getName().replaceAll(" ", "");
+                factorsNames += factorName + "=" + factorName + ",";
+                factorNames += factorName + ",";
+                String vector = factorName + "<-c(";
+
+                Domain domain = factor.getDomain();
+
+                if (domain instanceof ContinuousDomain) {
+                    ContinuousDomain contDomain = (ContinuousDomain) domain;
+                    int card = factor.getCardinality();
+                    Double min = contDomain.getCalculatorMinBound();
+                    Double max = contDomain.getCalculatorMaxBound();
+
+                    for (int i = 0; i < card; i++) {
+                        //add the ith value
+                        vector += (min + (i * (max - min) / (card - 1))) + ",";
+                    }
+                }
+
+                if (domain instanceof DiscreteDomain) {
+                    Map<Object, Object> values = ((DiscreteDomain) domain).getValues();
+                    int nbValues = values.size();
+                    for (int i = 0; i < nbValues; i++) {
+                        vector += "as.integer(" + i + "),";
+                    }
+                }
+
+                vector = vector.substring(0, vector.length() - 1);
+
+                vector += ")";
+
+                engine.voidEval(vector);
+
+
+            }
+
+            factorsNames = factorsNames.substring(0,factorsNames.length()-1);
+            factorNames = factorNames.substring(0,factorNames.length()-1);
+
+
+            //X<-expand.grid(vector=???,weight=???)
+            String expandGrid = "x<-expand.grid(%s)";
+
+            String rCall = String.format(expandGrid,factorsNames);
+
+            if (param_modifR) {
+                rCall = editRInstruction(rCall);
+            }
+
+            engine.voidEval(rCall);
+
+            engine.eval("expPlan<-as.data.frame(x)");
+            RDataFrame dataFrame = (RDataFrame)engine.eval("expPlan");
+            dataFrame.setVariable("expPlan");
+            int nbExperiments = (Integer)engine.eval("dim(x)[1]");
+
+            List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
+            for (int j = 0; j < nbExperiments; j++) {
+                Scenario experimentScenario = new Scenario();
+                for (int i = 0; i < factorsNb; i++) {
+                    Factor factor = factors.get(i);
+                    factor.setValueForIdentifier(dataFrame.get(i, j));
+                    experimentScenario.addFactor(factor);
+                }
+                thisExperimentScenarios.add(experimentScenario);
+                thisExperiment.setScenarios(thisExperimentScenarios);
+            }
+
+
+            String factorDistribution = "isis.factor.distribution<-data.frame(" +
+                "NomFacteur=c(%s)," +
+                "NomDistribution=c(%s)," +
+                "ParametreDistribution=c(%s))";
+
+            String distribution = "";
+            String parameters = "";
+
+            for (int i = 0; i < factorsNb; i++) {
+                Domain domain = factors.get(i).getDomain();
+                if (i != 0) {
+                    distribution += ",";
+                    parameters += ",";
+                }
+                if (domain instanceof ContinuousDomain){
+                    ContinuousDomain contDomain = (ContinuousDomain)domain;
+                    distribution += "\"qunif\"";
+                    parameters += "\"[" + contDomain.getMinBound()
+                            + ";" + contDomain.getMaxBound()
+                            + "]\"";
+                } else {
+                    DiscreteDomain discDomain = (DiscreteDomain)domain;
+                    distribution += "\"discrete\"";
+                    parameters+="\"[";
+                    Map<Object, Object> values = discDomain.getValues();
+                    int count=0;
+                    Collection<Object> collecValues = values.values();
+                    for (Object value:collecValues){
+                        if (count!=0){
+                            parameters += ",";
+                        }
+                        parameters += StringUtils.replace(value.toString(), "\"", "\\\"") ;
+                        count++;
+                    }
+                    parameters+="]\"";
+                }
+            }
+            engine.voidEval(String.format(factorDistribution, factorNames,
+                    distribution, parameters));
+
+            engine.voidEval("call<-\"" +
+                    String.format(expandGrid,factorsNames) + "\"");
+            engine.voidEval("isis.MethodExp<-list(" +
+                    "\"isis.factors\"=isis.factors," +
+                    "\"isis.factor.distribution\"=isis.factor.distribution," +
+                    "\"call\"=call)");
+            engine.voidEval("attr(isis.MethodExp," +
+                    "\"nomModel\")<-\"isis-fish-externe-R\"");
+            engine.voidEval("isis.simule<-x");
+            engine.voidEval("attr(isis.simule," +
+                    "\"nomModel\")<-\"isis-fish-externe-R\"");
+            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
+
+                // Save Isis R session
+                engine.saveRData(outputDirectory.getParentFile(),
+                        outputDirectory.getName());
+
+
+        } catch (RException eee) {
+            throw new SensitivityException("Can't generate scenarios", eee);
+        }
+
+        return thisExperiment;
+    }
+
+    @Override
+    public void analyzeResult(List<SimulationStorage> simulationStorages,
+            File outputDirectory) throws SensitivityException {
+
+        try {
+
+            REngine engine = new RProxy();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            //Get back the factors number
+            int factorNumber = (Integer)engine.eval("dim(x)[2]");
+
+            SimulationParameter param = simulationStorages.get(0).getParameter();
+            int sensitivityNumber = param.getSensitivityExport().size();
+
+            SimulationStorage firstStorage = simulationStorages.get(0);
+
+            String firstStorageName = firstStorage.getName().replaceAll("-", "");
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                SensitivityExport sensitivityExport =
+                        param.getSensitivityExport().get(k);
+
+                String name = sensitivityExport.getExportFilename();
+
+                String rInstruction = createImportInstruction(sensitivityExport,
+                        simulationStorages);
+
+                // Send the simulation results
+                engine.voidEval(rInstruction);
+
+                //Put results in isis.simule
+                engine.voidEval("isis.simule<-data.frame(isis.simule,"
+                        + name + ")");
+
+                //Create the dataforaov data.frame
+                String dataFrame = "dataforaov<-data.frame(x,"
+                        + name + "=" + name + ")";
+                engine.voidEval(dataFrame);
+
+                //Call aov()
+                String aovCall = "aovresult<-aov(" + name + "~(";
+                for (int j = 0; j < factorNumber; j++) {
+                    if (j < (factorNumber - 1)) {
+                        aovCall = aovCall
+                                + engine.eval("names(x)[" + (j + 1) + "]")
+                                + "+";
+                    } else {
+                        aovCall = aovCall
+                                + engine.eval("names(x)[" + (j + 1) + "]")
+                                + ")";
+                        if(param_order>1){
+                            aovCall+="^" + param_order + ",data=dataforaov)";
+                        }else{
+                            aovCall+=",data=dataforaov)";
+                        }
+                    }
+                }
+                engine.voidEval(aovCall);
+
+                /*Export the results
+                 *Export format is csv, data separated by ','
+                 *Results Export name is sensitivityExportName_Results.csv
+                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
+                 */
+
+                //Compute Sum of Squares and Sensitivity indices
+                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
+                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
+                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
+
+                //Create a data.frame to export sensitivity important results in one file.
+                engine.voidEval("exportsensitivity<-data.frame(" +
+                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
+                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
+                engine.voidEval("names(exportsensitivity)<-c(" +
+                        "\"Sum Of Squares\"," +
+                        "\"Sensitivity indices\")");
+                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
+
+                /*Set the export directory
+                 *Export directory is the first simulation export directory.
+                 */
+                engine.setwd(outputDirectory);
+
+                //Save the results with the scenarios.
+                engine.voidEval("write.csv(dataforaov,\""
+                        + param.getSensitivityExport().get(k)
+                        
+                                .getExportFilename() + "_Results.csv\")");
+
+                //Save the sensitivity indices
+                engine.voidEval("write.csv(exportsensitivity,\""
+                        + param.getSensitivityExport().get(k)
+                                .getExportFilename()
+                        + "_SensitivityIndices.csv\")");
+                //FIXME export through java to enable export when using Rserve (when distant Rserve).
+
+                //creating isis.methodAnalyse
+                engine.voidEval("isis.methodAnalyse<-list(" +
+                        "\"isis.factors\"=isis.factors," +
+                        "\"isis.factor.distribution\"=isis.factor.distribution," +
+                        "\"isis.simule\"=isis.simule," +
+                        "\"call_method\"=\"" + aovCall + "\"," +
+                        "\"analysis_result\"=list(aovresult,IndSensibilite))");
+
+                engine.voidEval("attr(isis.methodAnalyse," +
+                        "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-isis.methodAnalyse";
+                engine.voidEval(String.format(renameIsisMethodAnalyse,
+                        firstStorageName + "." + name));
+
+            }
+
+            //Rename R objects for saving purpose
+            renameObjects(engine, firstStorageName);
+
+            //Clean temporary R objects
+            for (String object:engine.ls()) {
+                if (!object.startsWith(firstStorageName)){
+                    engine.remove(object);
+                }
+            }
+
+            //Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+            engine.terminate();
+
+        } catch (Exception e) {
+            throw new SensitivityException("Can't evaluate results", e);
+        }
+
+    }
+
+    @Override
+    public String getDescription() {
+        return "Implementation of Expand Grid method using R";
+    }
+}

Copied: branches/4.2.2/sensitivityanalysis/RegularFractions.java (from rev 305, branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRegularFractions.java)
===================================================================
--- branches/4.2.2/sensitivityanalysis/RegularFractions.java	                        (rev 0)
+++ branches/4.2.2/sensitivityanalysis/RegularFractions.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -0,0 +1,398 @@
+/*
+ * #%L
+ * IsisFish data
+ * %%
+ * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
+ * %%
+ * 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 3 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-3.0.html>.
+ * #L%
+ */
+
+package sensitivityanalysis;
+
+import java.io.File;
+import java.util.List;
+
+import fr.ifremer.isisfish.export.SensitivityExport;
+import org.nuiton.j2r.REngine;
+import org.nuiton.j2r.RException;
+import org.nuiton.j2r.RProxy;
+import org.nuiton.j2r.types.RDataFrame;
+
+import fr.ifremer.isisfish.datastore.SimulationStorage;
+import fr.ifremer.isisfish.simulator.SimulationParameter;
+import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
+import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
+import fr.ifremer.isisfish.simulator.sensitivity.Domain;
+import fr.ifremer.isisfish.simulator.sensitivity.Factor;
+import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
+import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
+import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.DiscreteDomain;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.EquationContinuousDomain;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.MatrixContinuousDomain;
+import fr.ifremer.isisfish.util.Doc;
+
+public class RegularFractions extends AbstractSensitivityAnalysis {
+
+    @Doc("the path of the directory where the R function is stored (do not indicate the RegularFractions.R file name)")
+    public String param_pathToFunction = "";
+
+    @Doc("unique prime number of levels of all input and unit factors")
+    public int param_p = 2;
+
+    @Doc("number of unit factors (so that there are N=p^r units)")
+    public int param_r = 2;
+
+    @Doc("resolution of the fraction")
+    public int param_resolution = 2;
+
+    @Doc("True to be able to modify the code sent to R")
+    public boolean param_modifR = false;
+
+    /**
+     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
+     * continue.
+     * 
+     * @return <tt>true</tt> s'il sait la gerer
+     */
+    @Override
+    public boolean canManageCardinality() {
+        return true;
+    }
+
+    @Override
+    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
+        throws SensitivityException {
+
+        setIsisFactorsR(plan, outputDirectory);
+
+        RDataFrame dataFrame;
+        int factorNumber = plan.getFactors().size();
+        List<Factor> factors = plan.getFactors();
+        SensitivityScenarios thisExperiment = new SensitivityScenarios();
+        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
+
+        String factorNames = "";
+
+        //Test all factors, if one is discrete, return null
+        //Create a string with all factors names
+        for (int i = 0; i < factorNumber; i++) {
+            Domain domain = factors.get(i).getDomain();
+            if (i != 0) {
+                factorNames += ",";
+            }
+
+            factorNames += "\"" + factors.get(i).getName() + "\"";
+
+            if (domain instanceof DiscreteDomain) {
+                throw new SensitivityException(factors.get(i).getName() +
+                        " has a discrete domain, this is not acceptable for " +
+                        "this method.");
+            }
+        }
+
+        try {
+
+            REngine engine = new RProxy();
+
+            //Clear session
+            engine.clearSession();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+            //Set the working directory (to import the R function)
+            engine.setwd(new File(param_pathToFunction));
+
+            //Import the function
+            engine.voidEval("source(\"regularfractions.R\")");
+
+            //Create the instruction
+            String rInstruction = "x<-regular.fraction(%s,%s,%s,%s)";
+            String rCall = String.format(rInstruction, factors.size(), param_p,
+                    param_r, param_resolution);
+
+            if (param_modifR) {
+                rCall = editRInstruction(rCall);
+            }
+
+            // Run function
+            engine.voidEval(rCall);
+
+            // Run function
+            engine.voidEval("call<-\"" + rCall + "\"");
+
+            // Creating the factors vector.
+            rInstruction = "factornames<-c(%s)";
+            rCall = String.format(rInstruction, factorNames);
+
+            engine.voidEval(rCall);
+
+
+            // Get back experiment plan
+            engine.eval("expPlan<-as.data.frame(x[[1]])");
+            dataFrame = (RDataFrame)engine.eval("expPlan");
+            dataFrame.setVariable("expPlan");
+            
+            //Get back the simulation number
+            int simulationNumber = (Integer) engine.eval("length(x[[1]][,1])");
+
+            // Setting up the scenarios.
+            for (int j = 0; j < simulationNumber; j++) {
+                Scenario experimentScenario = new Scenario();
+                for (int i = 0; i < factors.size(); i++) {
+                    Factor factor = plan.getFactors().get(i);
+                    Domain domain = factor.getDomain();
+                    Double dFValue = (Double)dataFrame.get(i,j);
+                    if ((domain instanceof MatrixContinuousDomain)
+                            || (domain instanceof EquationContinuousDomain)) {
+                        factor.setValueForIdentifier(dFValue);
+                    } else {
+                        ContinuousDomain contDomain = (ContinuousDomain)domain;
+                        Double max = contDomain.getCalculatorMaxBound();
+                        Double min = contDomain.getCalculatorMinBound();
+                        Double value = min + (max - min) * dFValue / (param_p - 1);
+                        factor.setValueForIdentifier(value);
+                    }
+                    experimentScenario.addFactor(factor);
+                }
+                thisExperimentScenarios.add(experimentScenario);
+                thisExperiment.setScenarios(thisExperimentScenarios);
+            }
+
+            String dataframe = "data<-data.frame(";
+
+            //Create the factors vectors and the dataframe instruction
+            for (int j = 0; j < factorNumber; j++) {
+                Factor factor = factors.get(j);
+                String factorName = factor.getName().replaceAll(" ", "");
+
+                String vector = factorName + "<-c(";
+                for (int i = 0; i < simulationNumber; i++) {
+                    Scenario scenario = thisExperimentScenarios.get(i);
+                    List<Factor> newFactors = scenario.getFactors();
+                    Factor factor1 = newFactors.get(j);
+
+                    if (i < (simulationNumber - 1)) {
+                        vector += factor1.getDisplayedValue() + ",";
+                    } else {
+                        vector += factor1.getDisplayedValue();
+                    }
+
+                }
+                vector = vector + ")";
+                engine.voidEval(vector);
+
+                if (j < factorNumber - 1) {
+                    dataframe += factorName + "=factor(" + factorName + "),";
+                } else {
+                    dataframe += factorName + "=factor(" + factorName + "))";
+                }
+
+            }
+            engine.voidEval(dataframe);
+
+            engine.voidEval("isis.factor.distribution<-c(0.0)");
+
+            engine.voidEval("isis.MethodExp<-list(" +
+                    "\"isis.factors\"=isis.factors," +
+                    "\"isis.factor.distribution\"=isis.factor.distribution," +
+                    "\"call\"=call)");
+
+            engine.voidEval("attr(isis.MethodExp," +
+                    "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+            //Create isis.Simule
+            engine.voidEval("isis.simule<-data.frame(data)");
+
+            engine.voidEval("attr(isis.simule," +
+                    "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
+
+            // Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+            engine.terminate();
+
+        } catch (RException eee) {
+            throw new SensitivityException("Can't generate scenarios", eee);
+        }
+
+        return thisExperiment;
+
+    }
+
+    @Override
+    public void analyzeResult(List<SimulationStorage> simulationStorages,
+            File outputDirectory) throws SensitivityException {
+
+        SimulationStorage firstStorage = simulationStorages.get(0);
+        SimulationParameter param = firstStorage.getParameter();
+        List<SensitivityExport> exports = param.getSensitivityExport();
+        int sensitivityNumber = exports.size();
+        String simulationName = firstStorage.getName().replaceAll("-", "");
+
+        try {
+
+            REngine engine = new RProxy();
+
+            //Clear session
+            engine.clearSession();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+            //Get back the factors number
+            int factorNumber = (Integer) engine.eval("dim(data)[2]");
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                SensitivityExport sensitivityExport =
+                        param.getSensitivityExport().get(k);
+
+                String rInstruction = createImportInstruction(sensitivityExport,
+                        simulationStorages);
+
+                // Send the simulation results
+                engine.voidEval(rInstruction);
+
+                //Put results in isis.simule
+                engine.voidEval("isis.simule<-data.frame(isis.simule," +
+                        sensitivityExport.getExportFilename() + ")");
+            }
+
+            //adding attribute to isis.Simule
+            engine.voidEval("attr(isis.simule," +
+                    "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+            for (SensitivityExport export : exports) {
+
+                String name = export.getExportFilename();
+
+                //Create the dataforaov data.frame
+                String dataFrame = "dataforaov<-data.frame(data," +
+                        name + "=" + name + ")";
+                engine.voidEval(dataFrame);
+
+                //Call aov()
+                String aovCall = "aovresult<-aov(" + name + "~(";
+                for (int j = 0; j < factorNumber; j++) {
+
+                    if (j < (factorNumber - 1)) {
+                        aovCall = aovCall
+                                + engine.eval("names(data)[" + (j + 1) + "]")
+                                + "+";
+                    } else {
+                        aovCall = aovCall
+                                + engine.eval("names(data)[" + (j + 1) + "]")
+                                + ")";
+                        if (param_resolution <= 4) {
+                            aovCall += ",data=dataforaov)";
+                        } else {
+                            aovCall += "^2,data=dataforaov)";
+                        }
+                    }
+                }
+                engine.voidEval(aovCall);
+
+                /*Export the results
+                 *Export format is csv, data separated by ','
+                 *Results Export name is sensitivityExportName_Results.csv
+                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
+                 */
+
+                //Compute Sum of Squares and Sensitivity indices
+                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
+                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
+                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
+
+                //Create a data.frame to export sensitivity important results in one file.
+                engine.voidEval("exportsensitivity<-data.frame(" +
+                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
+                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
+                engine.voidEval("names(exportsensitivity)<-c(" +
+                        "\"Sum Of Squares\"," +
+                        "\"Sensitivity indices\")");
+                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
+
+                //Set dataforaov names
+                engine.voidEval("resultsnames<-c(factornames,\"Result\")");
+                engine.voidEval("names(dataforaov)<-resultsnames");
+
+                /*Set the export directory
+                 *Export directory is the first simulation export directory. 
+                 */
+                engine.setwd(outputDirectory);
+
+                //Save the results with the scenarios.
+                engine.voidEval("write.csv(dataforaov,\"" + name +
+                        "_Results.csv\")");
+
+                //Save the sensitivity indices
+                engine.voidEval("write.csv(exportsensitivity,\"" + name +
+                        "_SensitivityIndices.csv\")");
+                //FIXME export through java to enable export when using Rserve (when distant Rserve).
+
+                //creating isis.methodAnalyse
+                engine.voidEval("isis.methodAnalyse<-list(" +
+                        "\"isis.factors\"=isis.factors," +
+                        "\"isis.factor.distribution\"=isis.factor.distribution," +
+                        "\"isis.simule\"=isis.simule," +
+                        "\"call_method\"=\"" + aovCall + "\"," +
+                        "\"analysis_result\"=list(aovresult,IndSensibilite))");
+
+                engine.voidEval("attr(isis.methodAnalyse," +
+                        "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-isis.methodAnalyse";
+                engine.voidEval(String.format(renameIsisMethodAnalyse,
+                        simulationName + "." + name));
+
+            }
+
+            //Rename R objects for saving purpose
+            renameObjects(engine,simulationName);
+
+            //Clean temporary R objects
+            for (String object:engine.ls()) {
+                if (!object.startsWith(simulationName)){
+                    engine.remove(object);
+                }
+            }
+
+            // Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                    outputDirectory.getName());
+
+            engine.terminate();
+
+        } catch (Exception eee) {
+            throw new SensitivityException("Can't evaluate results", eee);
+        }
+
+    }
+
+    @Override
+    public String getDescription() {
+        return "Implementation of Regular fractions method using R";
+    }
+
+}

Deleted: branches/4.2.2/sensitivityanalysis/SensitivityCalculatorJavaExpandGrid.java
===================================================================
--- branches/4.2.2/sensitivityanalysis/SensitivityCalculatorJavaExpandGrid.java	2012-11-06 10:23:44 UTC (rev 306)
+++ branches/4.2.2/sensitivityanalysis/SensitivityCalculatorJavaExpandGrid.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -1,393 +0,0 @@
-/*
- * #%L
- * IsisFish data
- * %%
- * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
- * %%
- * 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 3 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-3.0.html>.
- * #L%
- */
-
-package sensitivityanalysis;
-
-import java.io.File;
-import java.util.List;
-
-import fr.ifremer.isisfish.export.SensitivityExport;
-import fr.ifremer.isisfish.simulator.sensitivity.*;
-import org.nuiton.j2r.REngine;
-import org.nuiton.j2r.RProxy;
-
-import fr.ifremer.isisfish.datastore.SimulationStorage;
-import fr.ifremer.isisfish.simulator.SimulationParameter;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.DiscreteDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.EquationContinuousDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.MatrixContinuousDomain;
-import fr.ifremer.isisfish.util.Doc;
-
-/**
- * Implementation of ExpandGrid method using Java
- * 
- * @author jcouteau
- * @version $Revision: 1.0 $
- * 
- */
-public class SensitivityCalculatorJavaExpandGrid extends
-        AbstractSensitivityAnalysis {
-
-    @Doc("Interaction order")
-    public int param_order = 2;
-
-    /**
-     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
-     * continue.
-     * 
-     * @return <tt>true</tt> s'il sait la gerer
-     */
-    @Override
-    public boolean canManageCardinality() {
-        return false;
-    }
-
-    @Override
-    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
-            throws SensitivityException {
-
-        setIsisFactorsR(plan, outputDirectory);
-
-        int k = 1; //number of sensitivity scenarios (initialization)
-        int factorNumber = plan.getFactors().size(); //number of factors
-        List<Factor> factors = plan.getFactors(); //list of factors
-
-        for (int i = 0; i < factorNumber; i++) {
-            Factor factor = factors.get(i);
-            Domain domain = factor.getDomain();
-
-            //calculate the number of scenarios
-            if (domain instanceof ContinuousDomain) {
-                if (factor.getCardinality() != 0) {
-                    k = k * factor.getCardinality();
-                }
-            } else if (domain instanceof DiscreteDomain) {
-                DiscreteDomain discreteDomain = (DiscreteDomain)domain;
-                if (discreteDomain.getValues().size() != 0) {
-                    k = k * discreteDomain.getValues().size();
-                }
-            }
-        }
-
-        SensitivityScenarios thisExperiment = new SensitivityScenarios();
-        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
-
-        for (int i = 0; i < k; i++) {
-            int result = 0; //used for the euclidian division
-            int rest = i; //used for the euclidian division
-            Scenario experimentScenario = new Scenario();
-            for (int j = 0; j < factorNumber; j++) {
-                Factor factor = factors.get(j);
-                Domain domain = factor.getDomain();
-                if (domain instanceof ContinuousDomain) {
-                    ContinuousDomain continuousDomain = (ContinuousDomain)domain;
-                    Double max = continuousDomain.getCalculatorMaxBound();
-                    Double min = continuousDomain.getCalculatorMinBound();
-                    int card = factor.getCardinality();
-
-                    //Do the euclidian division
-                    result = (int) Math.floor(rest / card);
-                    rest = rest - (card * result);
-
-                    //Calculate the value of the factor
-                    Double value = min + ((max - min) / (card - 1) * rest);
-                    if ((domain instanceof MatrixContinuousDomain)
-                            || (domain instanceof EquationContinuousDomain)) {
-                        factor.setValueForIdentifier(value);
-                    } else {
-                        factor.setValueForIdentifier(value);
-                    }
-                }
-                if (factor.getDomain() instanceof DiscreteDomain) {
-                    DiscreteDomain discreteDomain = (DiscreteDomain)domain;
-                    int card = discreteDomain.getValues().size();
-
-                    //Do the euclidian division
-                    result = (int) Math.floor(rest / card);
-                    rest = rest - (card * result);
-
-                    //Select the value of the factor
-                    factor.setValueForIdentifier(rest);
-                }
-                rest = result;
-                experimentScenario.addFactor(factor);
-            }
-            thisExperimentScenarios.add(experimentScenario);
-
-        }
-        thisExperiment.setScenarios(thisExperimentScenarios);
-
-        thisExperimentScenarios = thisExperiment.getScenarios();
-
-        /*
-         * Call R to save the data for result analysis
-         */
-        int scenariosNumber = thisExperimentScenarios.size();
-
-        try {
-
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            String dataframe = "data<-data.frame(";
-
-            //Create the factors vectors and the dataframe instruction
-            for (int j = 0; j < factorNumber; j++) {
-
-                Factor factor = factors.get(j);
-                String factorName = factor.getName().replaceAll(" ", "");
-
-                //String vector = "factor" + j + "<-c(";
-                String vector = factorName + "<-c(";
-                for (int i = 0; i < scenariosNumber; i++) {
-                    Scenario scenario = thisExperimentScenarios.get(i);
-                    List<Factor> newFactors = scenario.getFactors();
-                    Factor factor1 = newFactors.get(j);
-
-                    if (i < (scenariosNumber - 1)) {
-                        vector += factor1.getDisplayedValue() + ",";
-                    } else {
-                        vector += factor1.getDisplayedValue();
-                    }
-
-                }
-                vector = vector + ")";
-                engine.voidEval(vector);
-
-                if (j < factorNumber - 1) {
-                    dataframe += factorName + "=factor(" + factorName + "),";
-                } else {
-                    dataframe += factorName + "=factor(" + factorName + "))";
-                }
-
-            }
-            engine.voidEval(dataframe);
-
-            // Creating the factors vector.
-            String rInstruction = "factornames<-c(";
-            for (int i = 0; i < factorNumber; i++) {
-                if (i != (factorNumber - 1)) {
-                    rInstruction = rInstruction + "\""
-                            + factors.get(i).getName() + "\",";
-                } else {
-                    rInstruction = rInstruction + "\""
-                            + factors.get(i).getName() + "\"";
-                }
-            }
-
-            rInstruction += ")";
-
-            engine.voidEval(rInstruction);
-
-            //Create the isis.factor.distribution
-            engine.voidEval("isis.factor.distribution<-c(0.0)");
-
-            //Create isis.MethodExp
-            engine.voidEval("isis.MethodExp<-list(" +
-                    "isis.factors," +
-                    "isis.factor.distribution," +
-                    "call_method=\"isis-fish-externeR\")");
-
-            engine.voidEval("attr(isis.MethodExp," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            //Create isis.Simule
-            engine.voidEval("isis.simule<-data.frame(data)");
-
-            engine.voidEval("attr(isis.simule," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            engine.terminate();
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't generate scenarios", e);
-        }
-
-        return thisExperiment;
-    }
-
-    @Override
-    public void analyzeResult(List<SimulationStorage> simulationStorages,
-            File outputdirectory) throws SensitivityException {
-
-        SimulationStorage firstStorage = simulationStorages.get(0);
-        String simulationName = firstStorage.getName().replaceAll("-", "");
-        SimulationParameter param = firstStorage.getParameter();
-        int sensitivityNumber = param.getSensitivityExport().size();
-
-        try {
-
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputdirectory.getParentFile(),
-                    outputdirectory.getName());
-
-            //Get back the factors number
-            int factorNumber = (Integer)engine.eval("dim(data)[2]");
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                SensitivityExport sensitivityExport =
-                        param.getSensitivityExport().get(k);
-
-                String name = sensitivityExport.getExportFilename();
-
-                String rInstruction = createImportInstruction(sensitivityExport,
-                        simulationStorages);
-
-                // Send the simulation results
-                engine.voidEval(rInstruction);
-
-                //Put results in isis.simule
-                engine.voidEval("isis.simule<-data.frame(isis.simule,"
-                        + name + ")");
-
-                //Create the dataforaov data.frame
-                String dataframe = "dataforaov<-data.frame(data," +
-                        name + "=" + name + ")";
-                engine.voidEval(dataframe);
-
-                //Call aov()
-                String aovCall = "aovresult<-aov(" + name + "~(";
-                for (int j = 0; j < factorNumber; j++) {
-                    if (j < (factorNumber - 1)) {
-                        aovCall = aovCall +
-                                engine.eval("names(data)[" + (j + 1) + "]") +
-                                "+";
-                    } else {
-                        aovCall = aovCall +
-                                engine.eval("names(data)[" + (j + 1) + "]") +
-                                ")";
-                        if(param_order>1){
-                            aovCall+="^" + param_order + ",data=dataforaov)";
-                        }else{
-                            aovCall+=",data=dataforaov)";
-                        }
-                    }
-                }
-                engine.voidEval(aovCall);
-
-                /*Export the results
-                 *Export format is csv, data separated by ','
-                 *Results Export name is sensitivityExportName_Results.csv
-                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
-                 */
-
-                //Compute Sum of Squares and Sensitivity indices
-                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
-                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
-                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
-
-                //Create a data.frame to export sensitivity important results in one file.
-                engine.voidEval("exportsensitivity<-data.frame(" +
-                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
-                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
-                engine.voidEval("names(exportsensitivity)<-c(" +
-                        "\"Sum Of Squares\"," +
-                        "\"Sensitivity indices\")");
-                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
-
-
-                //Set dataforaov names
-                engine.voidEval("resultsnames<-c(" +
-                        "factornames," +
-                        "\"Result\")");
-                engine.voidEval("names(dataforaov)<-resultsnames");
-
-                /*Set the export directory
-                 *Export directory is the first simulation export directory. 
-                 */
-                engine.setwd(outputdirectory);
-
-                //Save the results with the scenarios.
-                engine.voidEval("write.csv(dataforaov,\""
-                        + param.getSensitivityExport().get(k).getExportFilename() + "_Results.csv\")");
-
-                //Save the sensitivity indices
-                engine.voidEval("write.csv(exportsensitivity,\""
-                        + param.getSensitivityExport().get(k).getExportFilename()
-                        + "_SensitivityIndices.csv\")");
-                //FIXME export through java to enable export when using Rserve (when distant Rserve).
-
-                //creating isis.methodAnalyse
-                engine.voidEval("isis.methodAnalyse<-list(" +
-                        "\"isis.factors\"=isis.factors," +
-                        "\"isis.factor.distribution\"=isis.factor.distribution," +
-                        "\"isis.simule\"=isis.simule," +
-                        "call_method=\"" + aovCall + "\"," +
-                        "\"analysis_result\"=list(aovresult,IndSensibilite))");
-
-                engine.voidEval("attr(isis.methodAnalyse," +
-                        "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-" +
-                        "isis.methodAnalyse";
-                engine.voidEval(String.format(renameIsisMethodAnalyse,
-                        simulationName + "." + name));
-
-            }
-
-            //Rename R objects for saving purpose
-            renameObjects(engine,simulationName);
-
-            //Clean temporary R objects
-            for (String object:engine.ls()) {
-                if (!object.startsWith(simulationName)){
-                    engine.remove(object);
-                }
-            }
-
-            // Save Isis R session
-            engine.saveRData(outputdirectory.getParentFile(),
-                    outputdirectory.getName());
-
-            engine.terminate();
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't evaluate results", e);
-        }
-
-    }
-
-    @Override
-    public String getDescription() {
-        return "Implementation of Expand Grid method using Java";
-    }
-
-}

Deleted: branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRDOptimal.java
===================================================================
--- branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRDOptimal.java	2012-11-06 10:23:44 UTC (rev 306)
+++ branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRDOptimal.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -1,406 +0,0 @@
-/*
- * #%L
- * IsisFish data
- * %%
- * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
- * %%
- * 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 3 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-3.0.html>.
- * #L%
- */
-
-package sensitivityanalysis;
-
-import fr.ifremer.isisfish.datastore.SimulationStorage;
-import fr.ifremer.isisfish.export.SensitivityExport;
-import fr.ifremer.isisfish.simulator.SimulationParameter;
-import fr.ifremer.isisfish.simulator.sensitivity.*;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.DiscreteDomain;
-import fr.ifremer.isisfish.util.Doc;
-import org.apache.commons.lang.StringUtils;
-import org.nuiton.j2r.REngine;
-import org.nuiton.j2r.RException;
-import org.nuiton.j2r.RProxy;
-import org.nuiton.j2r.types.RDataFrame;
-
-import java.io.File;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
-/**
- * User: couteau
- * Date: 14 janv. 2010
- * Time: 11:58:09
- */
-public class SensitivityCalculatorRDOptimal
-        extends AbstractSensitivityAnalysis {
-
-    @Doc("True to be able to modify the code sent to R")
-    public boolean param_modifR = false;
-
-    @Doc("Order")
-    public int param_order=1;
-
-    /**
-     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
-     * continue.
-     *
-     * @return <tt>true</tt> s'il sait la gerer
-     */
-    @Override
-    public boolean canManageCardinality() {
-        return false;
-    }
-
-    @Override
-    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
-            throws SensitivityException {
-
-        SensitivityScenarios thisExperiment = new SensitivityScenarios();
-
-        setIsisFactorsR(plan, outputDirectory);
-
-        //extract the factors from the design plan
-        List<Factor> factors = plan.getFactors();
-        int factorsNb = factors.size();
-
-        try {
-            REngine engine = new RProxy();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            engine.voidEval("library(AlgDesign)");
-
-            //Create a list of the factors under the form factor1=factor1,...
-            String factorsNames = "";
-
-            //Create a list of the factors under the form factor1,factor2,...
-            String factorNames = "";
-
-            //Create a list of the factors under the form factor1+factor2+...
-            String factorPlus="";
-
-            //create the factors vectors
-            for (Factor factor : factors) {
-                //The factor values vector
-                String factorName = factor.getName().replaceAll(" ", "");
-                factorsNames += factorName + "=" + factorName + ",";
-                factorNames += factorName + ",";
-                factorPlus += factorName + "+";
-
-                String vector = factorName + "<-c(";
-
-                Domain domain = factor.getDomain();
-
-                if (domain instanceof ContinuousDomain) {
-                    ContinuousDomain contDomain = (ContinuousDomain) domain;
-                    int card = factor.getCardinality();
-                    Double min = contDomain.getCalculatorMinBound();
-                    Double max = contDomain.getCalculatorMaxBound();
-
-                    for (int i = 0; i < card; i++) {
-                        //add the ith value
-                        vector += (min + (i * (max - min) / (card - 1))) + ",";
-                    }
-                } else {
-                    Map<Object, Object> values = ((DiscreteDomain) domain).getValues();
-                    int nbValues = values.size();
-                    for (int i = 0; i < nbValues; i++) {
-                        vector += "as.integer(" + i + "),";
-                    }
-                }
-
-                vector = vector.substring(0, vector.length() - 1);
-
-                vector += ")";
-
-                engine.voidEval(vector);
-
-
-            }
-
-            factorsNames = factorsNames.substring(0,factorsNames.length()-1);
-            factorNames = factorNames.substring(0,factorNames.length()-1);
-            factorPlus = factorPlus.substring(0,factorPlus.length()-1);
-
-
-            //X<-expand.grid(vector=???,weight=???)
-            String expandGrid = "expandgrid<-expand.grid(%s)";
-
-
-
-            String rCall = String.format(expandGrid,factorsNames);
-
-            engine.voidEval(rCall);
-
-            if (param_order ==1 ){
-                rCall = "x<-optFederov(~(%s),data=expandgrid, " +
-                        "approximate =FALSE, center=F, criterion = \"D\"," +
-                        "nRepeats=10)";
-            } else {
-                rCall = "x<-optFederov(~(%s)^"+param_order+",data=expandgrid, " +
-                        "approximate =FALSE, center=F, criterion = \"D\"," +
-                        "nRepeats=10)";
-            }
-
-            rCall = String.format(rCall,factorPlus);
-
-            if (param_modifR) {
-                rCall = editRInstruction(rCall);
-            }
-
-            engine.voidEval("runif(1)");
-
-            engine.voidEval(rCall);
-
-            engine.eval("expPlan<-as.data.frame(x$design)");
-            RDataFrame dataFrame = (RDataFrame)engine.eval("expPlan");
-            dataFrame.setVariable("expPlan");
-            int nbExperiments = (Integer)engine.eval("dim(x$design)[1]");
-
-            List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
-            for (int j = 0; j < nbExperiments; j++) {
-                Scenario experimentScenario = new Scenario();
-                for (int i = 0; i < factorsNb; i++) {
-                    Factor factor = factors.get(i);
-                    factor.setValueForIdentifier(dataFrame.get(i, j));
-                    experimentScenario.addFactor(factor);
-                }
-                thisExperimentScenarios.add(experimentScenario);
-                thisExperiment.setScenarios(thisExperimentScenarios);
-            }
-
-
-            String factorDistribution = "isis.factor.distribution<-data.frame(" +
-                "NomFacteur=c(%s)," +
-                "NomDistribution=c(%s)," +
-                "ParametreDistribution=c(%s))";
-
-            String distribution = "";
-            String parameters = "";
-
-            for (int i = 0; i < factorsNb; i++) {
-                Domain domain = factors.get(i).getDomain();
-                if (i != 0) {
-                    distribution += ",";
-                    parameters += ",";
-                }
-                if (domain instanceof ContinuousDomain){
-                    ContinuousDomain contDomain = (ContinuousDomain)domain;
-                    distribution += "\"qunif\"";
-                    parameters += "\"[" + contDomain.getMinBound()
-                            + ";" + contDomain.getMaxBound()
-                            + "]\"";
-                } else {
-                    DiscreteDomain discDomain = (DiscreteDomain)domain;
-                    distribution += "\"discrete\"";
-                    parameters+="\"[";
-                    Map<Object, Object> values = discDomain.getValues();
-                    int count=0;
-                    Collection<Object> collecValues = values.values();
-                    for (Object value:collecValues){
-                        if (count!=0){
-                            parameters += ",";
-                        }
-                        parameters += StringUtils.replace(value.toString(), "\"", "\\\"") ;
-                        count++;
-                    }
-                    parameters+="]\"";
-                }
-            }
-            engine.voidEval(String.format(factorDistribution, factorNames,
-                    distribution, parameters));
-
-            engine.voidEval("call<-\"" + rCall + "\"");
-            engine.voidEval("isis.MethodExp<-list(" +
-                    "\"isis.factors\"=isis.factors," +
-                    "\"isis.factor.distribution\"=isis.factor.distribution," +
-                    "\"call\"=call)");
-            engine.voidEval("attr(isis.MethodExp," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-            engine.voidEval("isis.simule<-x$design");
-            engine.voidEval("attr(isis.simule," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-
-        } catch (RException eee) {
-            throw new SensitivityException("Can't generate scenarios", eee);
-        }
-
-        return thisExperiment;
-    }
-
-    @Override
-    public void analyzeResult(List<SimulationStorage> simulationStorages,
-            File outputDirectory) throws SensitivityException {
-
-        try {
-
-            REngine engine = new RProxy();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            //Get back the factors number
-            int factorNumber = (Integer)engine.eval("dim(x$design)[2]");
-
-            SimulationParameter param = simulationStorages.get(0).getParameter();
-            int sensitivityNumber = param.getSensitivityExport().size();
-
-            SimulationStorage firstStorage = simulationStorages.get(0);
-
-            String firstStorageName = firstStorage.getName().replaceAll("-", "");
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                SensitivityExport sensitivityExport =
-                        param.getSensitivityExport().get(k);
-
-                String name = sensitivityExport.getExportFilename();
-
-                String rInstruction = createImportInstruction(sensitivityExport,
-                        simulationStorages);
-
-                // Send the simulation results
-                engine.voidEval(rInstruction);
-
-                //Put results in isis.simule
-                engine.voidEval("isis.simule<-data.frame(isis.simule,"
-                        + name + ")");
-
-                //Create the dataforaov data.frame
-                String dataFrame = "dataforaov<-data.frame(x$design,"
-                        + name + "=" + name + ")";
-                engine.voidEval(dataFrame);
-
-                //Call aov()
-                String aovCall = "aovresult<-aov(" + name + "~(";
-                for (int j = 0; j < factorNumber; j++) {
-                    if (j < (factorNumber - 1)) {
-                        aovCall = aovCall
-                                + engine.eval("names(x$design)[" + (j + 1) + "]")
-                                + "+";
-                    } else {
-                        aovCall = aovCall
-                                + engine.eval("names(x$design)[" + (j + 1) + "]")
-                                + ")";
-                        if(param_order>1){
-                            aovCall+="^" + param_order + ",data=dataforaov)";
-                        }else{
-                            aovCall+=",data=dataforaov)";
-                        }
-                    }
-                }
-                engine.voidEval(aovCall);
-
-                /*Export the results
-                 *Export format is csv, data separated by ','
-                 *Results Export name is sensitivityExportName_Results.csv
-                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
-                 */
-
-//Compute Sum of Squares and Sensitivity indices
-                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
-                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
-                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
-
-                //Create a data.frame to export sensitivity important results in one file.
-                engine.voidEval("exportsensitivity<-data.frame(" +
-                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
-                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
-                engine.voidEval("names(exportsensitivity)<-c(" +
-                        "\"Sum Of Squares\"," +
-                        "\"Sensitivity indices\")");
-                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
-
-
-                //Set dataforaov names
-                engine.voidEval("resultsnames<-c(names(x$design),\"Result\")");
-                engine.voidEval("names(dataforaov)<-resultsnames");
-
-
-                /*Set the export directory
-                 *Export directory is the first simulation export directory.
-                 */
-                engine.setwd(outputDirectory);
-
-                //Save the results with the scenarios.
-                engine.voidEval("write.csv(dataforaov,\""
-                        + param.getSensitivityExport().get(k)
-
-                                .getExportFilename() + "_Results.csv\")");
-
-                //Save the sensitivity indices
-                engine.voidEval("write.csv(exportsensitivity,\""
-                        + param.getSensitivityExport().get(k)
-                                .getExportFilename()
-                        + "_SensitivityIndices.csv\")");
-                //FIXME export through java to enable export when using Rserve (when distant Rserve).
-
-                //creating isis.methodAnalyse
-                engine.voidEval("isis.methodAnalyse<-list(" +
-                        "\"isis.factors\"=isis.factors," +
-                        "\"isis.factor.distribution\"=isis.factor.distribution," +
-                        "\"isis.simule\"=isis.simule," +
-                        "\"call_method\"=\"" + aovCall + "\"," +
-                        "\"analysis_result\"=list(aovresult,IndSensibilite))");
-
-                engine.voidEval("attr(isis.methodAnalyse," +
-                        "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-isis.methodAnalyse";
-                engine.voidEval(String.format(renameIsisMethodAnalyse,
-                        firstStorageName + "." + name));
-
-            }
-
-            //Rename R objects for saving purpose
-            renameObjects(engine, firstStorageName);
-
-
-            //Clean temporary R objects
-            for (String object:engine.ls()) {
-                if (!object.startsWith(firstStorageName)){
-                    engine.remove(object);
-                }
-            }
-
-            //Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            engine.terminate();
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't evaluate results", e);
-        }
-
-    }
-
-    @Override
-    public String getDescription() {
-        return "Implementation of D optimal method method using R, needs" +
-                "AlgDesign package to work";
-    }
-}

Deleted: branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRExpandGrid.java
===================================================================
--- branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRExpandGrid.java	2012-11-06 10:23:44 UTC (rev 306)
+++ branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRExpandGrid.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -1,375 +0,0 @@
-/*
- * #%L
- * IsisFish data
- * %%
- * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
- * %%
- * 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 3 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-3.0.html>.
- * #L%
- */
-
-package sensitivityanalysis;
-
-import fr.ifremer.isisfish.datastore.SimulationStorage;
-import fr.ifremer.isisfish.export.SensitivityExport;
-import fr.ifremer.isisfish.simulator.SimulationParameter;
-import fr.ifremer.isisfish.simulator.sensitivity.*;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.DiscreteDomain;
-import fr.ifremer.isisfish.util.Doc;
-import org.apache.commons.lang.StringUtils;
-import org.nuiton.j2r.REngine;
-import org.nuiton.j2r.RException;
-import org.nuiton.j2r.RProxy;
-import org.nuiton.j2r.types.RDataFrame;
-
-import java.io.File;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
-/**
- * User: couteau
- * Date: 6 janv. 2010
- * Time: 14:31:09
- */
-public class SensitivityCalculatorRExpandGrid
-        extends AbstractSensitivityAnalysis {
-
-    @Doc("Interaction order")
-    public int param_order = 2;
-
-    @Doc("True to be able to modify the code sent to R")
-    public boolean param_modifR = false;
-
-    /**
-     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
-     * continue.
-     *
-     * @return <tt>true</tt> s'il sait la gerer
-     */
-    @Override
-    public boolean canManageCardinality() {
-        return false;
-    }
-
-    @Override
-    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
-            throws SensitivityException {
-
-        SensitivityScenarios thisExperiment = new SensitivityScenarios();
-
-        setIsisFactorsR(plan, outputDirectory);
-
-        //extract the factors from the design plan
-        List<Factor> factors = plan.getFactors();
-        int factorsNb = factors.size();
-
-        try {
-            REngine engine = new RProxy();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            //Create a list of the factors under the form factor1=factor1,...
-            String factorsNames = "";
-
-            //Create a list of the factors under the form factor1,factor2,...
-            String factorNames = "";
-
-            //create the factors vectors
-            for (Factor factor : factors) {
-                //The factor values vector
-                String factorName = factor.getName().replaceAll(" ", "");
-                factorsNames += factorName + "=" + factorName + ",";
-                factorNames += factorName + ",";
-                String vector = factorName + "<-c(";
-
-                Domain domain = factor.getDomain();
-
-                if (domain instanceof ContinuousDomain) {
-                    ContinuousDomain contDomain = (ContinuousDomain) domain;
-                    int card = factor.getCardinality();
-                    Double min = contDomain.getCalculatorMinBound();
-                    Double max = contDomain.getCalculatorMaxBound();
-
-                    for (int i = 0; i < card; i++) {
-                        //add the ith value
-                        vector += (min + (i * (max - min) / (card - 1))) + ",";
-                    }
-                }
-
-                if (domain instanceof DiscreteDomain) {
-                    Map<Object, Object> values = ((DiscreteDomain) domain).getValues();
-                    int nbValues = values.size();
-                    for (int i = 0; i < nbValues; i++) {
-                        vector += "as.integer(" + i + "),";
-                    }
-                }
-
-                vector = vector.substring(0, vector.length() - 1);
-
-                vector += ")";
-
-                engine.voidEval(vector);
-
-
-            }
-
-            factorsNames = factorsNames.substring(0,factorsNames.length()-1);
-            factorNames = factorNames.substring(0,factorNames.length()-1);
-
-
-            //X<-expand.grid(vector=???,weight=???)
-            String expandGrid = "x<-expand.grid(%s)";
-
-            String rCall = String.format(expandGrid,factorsNames);
-
-            if (param_modifR) {
-                rCall = editRInstruction(rCall);
-            }
-
-            engine.voidEval(rCall);
-
-            engine.eval("expPlan<-as.data.frame(x)");
-            RDataFrame dataFrame = (RDataFrame)engine.eval("expPlan");
-            dataFrame.setVariable("expPlan");
-            int nbExperiments = (Integer)engine.eval("dim(x)[1]");
-
-            List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
-            for (int j = 0; j < nbExperiments; j++) {
-                Scenario experimentScenario = new Scenario();
-                for (int i = 0; i < factorsNb; i++) {
-                    Factor factor = factors.get(i);
-                    factor.setValueForIdentifier(dataFrame.get(i, j));
-                    experimentScenario.addFactor(factor);
-                }
-                thisExperimentScenarios.add(experimentScenario);
-                thisExperiment.setScenarios(thisExperimentScenarios);
-            }
-
-
-            String factorDistribution = "isis.factor.distribution<-data.frame(" +
-                "NomFacteur=c(%s)," +
-                "NomDistribution=c(%s)," +
-                "ParametreDistribution=c(%s))";
-
-            String distribution = "";
-            String parameters = "";
-
-            for (int i = 0; i < factorsNb; i++) {
-                Domain domain = factors.get(i).getDomain();
-                if (i != 0) {
-                    distribution += ",";
-                    parameters += ",";
-                }
-                if (domain instanceof ContinuousDomain){
-                    ContinuousDomain contDomain = (ContinuousDomain)domain;
-                    distribution += "\"qunif\"";
-                    parameters += "\"[" + contDomain.getMinBound()
-                            + ";" + contDomain.getMaxBound()
-                            + "]\"";
-                } else {
-                    DiscreteDomain discDomain = (DiscreteDomain)domain;
-                    distribution += "\"discrete\"";
-                    parameters+="\"[";
-                    Map<Object, Object> values = discDomain.getValues();
-                    int count=0;
-                    Collection<Object> collecValues = values.values();
-                    for (Object value:collecValues){
-                        if (count!=0){
-                            parameters += ",";
-                        }
-                        parameters += StringUtils.replace(value.toString(), "\"", "\\\"") ;
-                        count++;
-                    }
-                    parameters+="]\"";
-                }
-            }
-            engine.voidEval(String.format(factorDistribution, factorNames,
-                    distribution, parameters));
-
-            engine.voidEval("call<-\"" +
-                    String.format(expandGrid,factorsNames) + "\"");
-            engine.voidEval("isis.MethodExp<-list(" +
-                    "\"isis.factors\"=isis.factors," +
-                    "\"isis.factor.distribution\"=isis.factor.distribution," +
-                    "\"call\"=call)");
-            engine.voidEval("attr(isis.MethodExp," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-            engine.voidEval("isis.simule<-x");
-            engine.voidEval("attr(isis.simule," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
-
-                // Save Isis R session
-                engine.saveRData(outputDirectory.getParentFile(),
-                        outputDirectory.getName());
-
-
-        } catch (RException eee) {
-            throw new SensitivityException("Can't generate scenarios", eee);
-        }
-
-        return thisExperiment;
-    }
-
-    @Override
-    public void analyzeResult(List<SimulationStorage> simulationStorages,
-            File outputDirectory) throws SensitivityException {
-
-        try {
-
-            REngine engine = new RProxy();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            //Get back the factors number
-            int factorNumber = (Integer)engine.eval("dim(x)[2]");
-
-            SimulationParameter param = simulationStorages.get(0).getParameter();
-            int sensitivityNumber = param.getSensitivityExport().size();
-
-            SimulationStorage firstStorage = simulationStorages.get(0);
-
-            String firstStorageName = firstStorage.getName().replaceAll("-", "");
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                SensitivityExport sensitivityExport =
-                        param.getSensitivityExport().get(k);
-
-                String name = sensitivityExport.getExportFilename();
-
-                String rInstruction = createImportInstruction(sensitivityExport,
-                        simulationStorages);
-
-                // Send the simulation results
-                engine.voidEval(rInstruction);
-
-                //Put results in isis.simule
-                engine.voidEval("isis.simule<-data.frame(isis.simule,"
-                        + name + ")");
-
-                //Create the dataforaov data.frame
-                String dataFrame = "dataforaov<-data.frame(x,"
-                        + name + "=" + name + ")";
-                engine.voidEval(dataFrame);
-
-                //Call aov()
-                String aovCall = "aovresult<-aov(" + name + "~(";
-                for (int j = 0; j < factorNumber; j++) {
-                    if (j < (factorNumber - 1)) {
-                        aovCall = aovCall
-                                + engine.eval("names(x)[" + (j + 1) + "]")
-                                + "+";
-                    } else {
-                        aovCall = aovCall
-                                + engine.eval("names(x)[" + (j + 1) + "]")
-                                + ")";
-                        if(param_order>1){
-                            aovCall+="^" + param_order + ",data=dataforaov)";
-                        }else{
-                            aovCall+=",data=dataforaov)";
-                        }
-                    }
-                }
-                engine.voidEval(aovCall);
-
-                /*Export the results
-                 *Export format is csv, data separated by ','
-                 *Results Export name is sensitivityExportName_Results.csv
-                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
-                 */
-
-                //Compute Sum of Squares and Sensitivity indices
-                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
-                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
-                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
-
-                //Create a data.frame to export sensitivity important results in one file.
-                engine.voidEval("exportsensitivity<-data.frame(" +
-                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
-                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
-                engine.voidEval("names(exportsensitivity)<-c(" +
-                        "\"Sum Of Squares\"," +
-                        "\"Sensitivity indices\")");
-                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
-
-                /*Set the export directory
-                 *Export directory is the first simulation export directory.
-                 */
-                engine.setwd(outputDirectory);
-
-                //Save the results with the scenarios.
-                engine.voidEval("write.csv(dataforaov,\""
-                        + param.getSensitivityExport().get(k)
-                        
-                                .getExportFilename() + "_Results.csv\")");
-
-                //Save the sensitivity indices
-                engine.voidEval("write.csv(exportsensitivity,\""
-                        + param.getSensitivityExport().get(k)
-                                .getExportFilename()
-                        + "_SensitivityIndices.csv\")");
-                //FIXME export through java to enable export when using Rserve (when distant Rserve).
-
-                //creating isis.methodAnalyse
-                engine.voidEval("isis.methodAnalyse<-list(" +
-                        "\"isis.factors\"=isis.factors," +
-                        "\"isis.factor.distribution\"=isis.factor.distribution," +
-                        "\"isis.simule\"=isis.simule," +
-                        "\"call_method\"=\"" + aovCall + "\"," +
-                        "\"analysis_result\"=list(aovresult,IndSensibilite))");
-
-                engine.voidEval("attr(isis.methodAnalyse," +
-                        "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-isis.methodAnalyse";
-                engine.voidEval(String.format(renameIsisMethodAnalyse,
-                        firstStorageName + "." + name));
-
-            }
-
-            //Rename R objects for saving purpose
-            renameObjects(engine, firstStorageName);
-
-            //Clean temporary R objects
-            for (String object:engine.ls()) {
-                if (!object.startsWith(firstStorageName)){
-                    engine.remove(object);
-                }
-            }
-
-            //Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            engine.terminate();
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't evaluate results", e);
-        }
-
-    }
-
-    @Override
-    public String getDescription() {
-        return "Implementation of Expand Grid method using R";
-    }
-}

Deleted: branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRFast.java
===================================================================
--- branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRFast.java	2012-11-06 10:23:44 UTC (rev 306)
+++ branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRFast.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -1,358 +0,0 @@
-/*
- * #%L
- * IsisFish data
- * %%
- * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
- * %%
- * 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 3 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-3.0.html>.
- * #L%
- */
-
-package sensitivityanalysis;
-
-import java.io.File;
-import java.util.List;
-
-import fr.ifremer.isisfish.simulator.sensitivity.*;
-import org.nuiton.j2r.REngine;
-import org.nuiton.j2r.RException;
-import org.nuiton.j2r.RProxy;
-
-import fr.ifremer.isisfish.datastore.SimulationStorage;
-import fr.ifremer.isisfish.export.SensitivityExport;
-import fr.ifremer.isisfish.simulator.SimulationParameter;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.DiscreteDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.EquationContinuousDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.MatrixContinuousDomain;
-import fr.ifremer.isisfish.util.Doc;
-import org.nuiton.j2r.types.RDataFrame;
-
-/**
- * Implementation of Fast method using R.
- * 
- * @author jcouteau
- * @version $Revision: 89 $
- * 
- * Last update : $Date: 2009-03-25 13:45:16 +0100 (mer., 25 mars 2009) $ By :
- * $Author: jcouteau $
- */
-public class SensitivityCalculatorRFast extends AbstractSensitivityAnalysis {
-
-    @Doc("an integer giving the sample size, i.e. the length of the " +
-    "discretization of the s-space (see Cukier et al.). (default=20)")
-    public int param_n = 20;
-
-    @Doc("an integer specifying the interference parameter, i.e. the number " +
-    "of harmonics to sum in the Fourier series decomposition (see Cukier et " +
-    "al.). (default=6)")
-    public int param_M = 6;
-
-    @Doc("True to be able to modify the code sent to R")
-    public boolean param_modifR = false;
-
-    /**
-     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
-     * continue.
-     * 
-     * @return <tt>true</tt> s'il sait la gerer
-     */
-    @Override
-    public boolean canManageCardinality() {
-        return true;
-    }
-
-    @Override
-    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
-        throws SensitivityException {
-
-        setIsisFactorsR(plan, outputDirectory);
-
-        RDataFrame dataFrame;
-        int nbExperiments;
-        int factorNumber = plan.getFactors().size();
-        List<Factor> factors = plan.getFactors();
-        SensitivityScenarios thisExperiment = new SensitivityScenarios();
-        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
-
-        //Test all factors, if one is discrete, return null
-        for (int i = 0; i < factorNumber; i++) {
-            if (factors.get(i).getDomain() instanceof DiscreteDomain) {
-                throw new SensitivityException(factors.get(i).getName() +
-                    " has a discrete domain, this is not acceptable for fast " +
-                    "method.");
-            }
-        }
-        String rInstruction = "a<-fast99(" +
-                "model=NULL," +
-                "factors=%s, " +
-                "n=%s, " +
-                "M=%s, " +
-                "q = \"qunif\", " +
-                "q.arg=list(min=0,max=1))";
-        String rCall = String.format(rInstruction, factors.size(), param_n,
-                param_M);
-
-        if (param_modifR) {
-            rCall = editRInstruction(rCall);
-        }
-
-        try {
-
-            REngine engine = new RProxy();
-
-            engine.clearSession();
-            engine.loadRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            // Load sensitivity package into R (if package already loaded,
-            // nothing happens.
-            engine.voidEval("library(sensitivity)");
-
-            // Run sensitivity analysis
-            engine.voidEval(rCall);
-
-            // Creating the factors vector.
-            rInstruction = "factornames<-c(";
-            for (int i = 0; i < factorNumber; i++) {
-                String factorName = factors.get(i).getName();
-                if (i != (factorNumber - 1)) {
-                    rInstruction += "\"" + factorName + "\",";
-                } else {
-                    rInstruction += "\"" + factorName + "\"";
-                }
-            }
-
-            rInstruction += ")";
-
-            engine.voidEval(rInstruction);
-
-            // Get back experiment plan
-            dataFrame = (RDataFrame) engine.eval("a$X");
-            dataFrame.setVariable("a$X");
-
-            nbExperiments = (Integer)engine.eval("dim(a$X)[1]");
-
-            String factorDistribution = "isis.factor.distribution<-data.frame(" +
-                "NomFacteur=c(%s)," +
-                "NomDistribution=c(%s)," +
-                "ParametreDistribution=c(%s))";
-
-            // Creating the vectors.
-            String distribution = "";
-            String parameters = "";
-            String factorNames = "";
-
-            for (int i = 0; i < factorNumber; i++) {
-                Factor factor = factors.get(i);
-                ContinuousDomain domain = (ContinuousDomain) factor.getDomain();
-                if (i != 0) {
-                    distribution += ",";
-                    parameters += ",";
-                    factorNames += ",";
-                }
-
-                distribution += "\"qunif\"";
-                parameters += "\"[" + domain.getMinBound() + ";" +
-                        domain.getMaxBound() + "]\"";
-                factorNames += "\"" + factor.getName() + "\"";
-            }
-            engine.voidEval(String.format(factorDistribution, factorNames,
-                    distribution, parameters));
-            
-            engine.voidEval("call<-a$call");
-
-           
-            engine.voidEval("isis.MethodExp<-list(" +
-                "\"isis.factors\"=isis.factors," +
-                "\"isis.factor.distribution\"=isis.factor.distribution," +
-                "\"call\"=call)");
-            
-            engine.voidEval("attr(isis.MethodExp,\"nomModel\")<-" +
-                    "\"isis-fish-externe-R\"");
-
-            engine.voidEval("isis.simule<-data.frame(a$X)");
-
-            engine.voidEval("attr(isis.simule,\"nomModel\")<-" +
-                    "\"isis-fish-externe-R\"");
-
-            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            // Setting up the scenarios.
-            for (int j = 0; j < nbExperiments; j++) {
-                Scenario experimentScenario = new Scenario();
-                for (int i = 0; i < factorNumber; i++) {
-                    Factor factor = plan.getFactors().get(i);
-                    Domain domain = factor.getDomain();
-                    if ((domain instanceof MatrixContinuousDomain)
-                            || (domain instanceof EquationContinuousDomain)) {
-                        factor.setValueForIdentifier(dataFrame.get(i,j));
-                    } else {
-                        ContinuousDomain continuousDomain = (ContinuousDomain)domain;
-                        Double min = continuousDomain.getCalculatorMinBound();
-                        Double max = continuousDomain.getCalculatorMaxBound();
-                        Double dFValue = (Double)dataFrame.get(i,j);
-                        Double value = min + (max - min) * dFValue;
-                        factor.setValueForIdentifier(value);
-                    }
-                    experimentScenario.addFactor(factor);
-                }
-                thisExperimentScenarios.add(experimentScenario);
-                thisExperiment.setScenarios(thisExperimentScenarios);
-            }
-        } catch (RException eee) {
-            throw new SensitivityException("Can't generate scenarios", eee);
-        }
-        return thisExperiment;
-
-    }
-
-    @Override
-    public void analyzeResult(List<SimulationStorage> simulationStorages,
-            File outputDirectory) throws SensitivityException {
-
-        SimulationStorage storage = simulationStorages.get(0);
-        String simulationName = storage.getName().replaceAll("-", "");
-
-        try {
-
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            engine.setwd(outputDirectory);
-
-            // Call R
-            // Load sensitivity package into R (if package already loaded,
-            // nothing happens.
-            engine.voidEval("library(sensitivity)");
-
-            SimulationParameter param = simulationStorages.get(0).getParameter();
-            
-            int sensitivityNumber = param.getSensitivityExport().size();
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                SensitivityExport sensitivityExport =
-                        param.getSensitivityExport().get(k);
-
-                String rInstruction = createImportInstruction(sensitivityExport,
-                        simulationStorages);
-
-                // Send the simulation results
-                engine.voidEval(rInstruction);
-
-                //Put results in isis.simule
-                engine.voidEval("isis.simule<-data.frame(isis.simule," +
-                        sensitivityExport.getExportFilename() + ")");
-            }
-
-            //adding attribute to isis.Simule
-            engine.voidEval("attr(isis.simule,\"nomModel\")<-" +
-                    "\"isis-fish-externe-R\"");
-            engine.voidEval("attr(isis.simule,\"call\")<-isis.MethodExp$call");
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                // Creates the R expression to import results in R
-                String name = param.getSensitivityExport().get(k)
-                        .getExportFilename();
-
-                //Compute results
-                engine.voidEval("tell(a,y=" + name + ")");
-
-                engine.voidEval("names(a$V)<-factornames");
-                engine.voidEval("names(a$X)<-factornames");
-                engine.voidEval("names(a$D1)<-factornames");
-                engine.voidEval("names(a$Dt)<-factornames");
-
-                //creating isis.methodAnalyse
-                engine.voidEval("isis.methodAnalyse<-list(" +
-                    "\"isis.factors\"=isis.factors," +
-                    "\"isis.factor.distribution\"=isis.factor.distribution," +
-                    "\"isis.simule\"=isis.simule," +
-                    "call_method=\"tell(a,y=" + name + ")" + "\"," +
-                    "\"analysis_result\"=a)");
-
-                //setting isis.methodAnalyse attributes
-                engine.voidEval("attr(isis.methodAnalyse,\"nomModel\")<-" +
-                        "\"isis-fish-externe-R\")");
-
-                //Create the data.frame of scenarios and results for export purpose
-                engine.voidEval("dfresults<-data.frame(a$X,a$y)");
-
-                //Set working directory
-                engine.setwd(outputDirectory);
-
-                //Export V
-                engine.voidEval("write.csv(a$V,\"" + name + "_V.csv\")");
-
-                //Export D1
-                engine.voidEval("write.csv(a$D1,\"" + name + "_D1.csv\")");
-
-                //Export Dt
-                engine.voidEval("write.csv(a$Dt,\"" + name + "_Dt.csv\")");
-                //Set dfresults names
-                engine.voidEval("resultsnames<-c(factornames,\"Result\")");
-                engine.voidEval("names(dfresults)<-resultsnames");
-
-                //Export results
-                engine.voidEval("write.csv(dfresults,\"" + name +
-                        "_Results.csv\")");
-                //FIXME export through java to enable export when using Rserve
-
-                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse" +
-                    "<-isis.methodAnalyse";
-
-                engine.voidEval(String.format(renameIsisMethodAnalyse,
-                        simulationName + "." + name));
-
-            }
-
-            //Rename R objects for saving purpose
-            renameObjects(engine, simulationName);
-
-            //Clean temporary R objects
-            for (String object:engine.ls()) {
-                if (!object.startsWith(simulationName)){
-                    engine.remove(object);
-                }
-            }
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't evaluate results", e);
-        }
-    }
-
-    @Override
-    public String getDescription() {
-        return "Implementation of FAST method using R (needs the sensitivity " +
-            "package to work)";
-    }
-
-}

Deleted: branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRFrF2.java
===================================================================
--- branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRFrF2.java	2012-11-06 10:23:44 UTC (rev 306)
+++ branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRFrF2.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -1,389 +0,0 @@
-/*
- * #%L
- * IsisFish data
- * %%
- * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
- * %%
- * 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 3 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-3.0.html>.
- * #L%
- */
-
-package sensitivityanalysis;
-
-import java.io.File;
-import java.util.List;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.nuiton.j2r.REngine;
-import org.nuiton.j2r.RException;
-import org.nuiton.j2r.RProxy;
-import org.nuiton.math.matrix.MatrixFactory;
-import org.nuiton.math.matrix.MatrixND;
-import org.nuiton.util.FileUtil;
-
-import fr.ifremer.isisfish.datastore.SimulationStorage;
-import fr.ifremer.isisfish.simulator.SimulationParameter;
-import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
-import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
-import fr.ifremer.isisfish.simulator.sensitivity.Factor;
-import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
-import fr.ifremer.isisfish.util.Doc;
-
-/**
- * Implementation of FrF2 method using R.
- * 
- * @author jcouteau
- * @version $Revision: 94 $
- * 
- * Last update : $Date: 2009-04-03 13:13:35 +0200 (ven., 03 avr. 2009) $ By :
- * $Author: chatellier $
- */
-public class SensitivityCalculatorRFrF2 extends AbstractSensitivityAnalysis {
-
-    //TODO jcouteau 20110607 need to use new ethods on REngine instead of coding R sentences by hand.
-
-    /** to use log facility, just put in your code: log.info("..."); */
-    private static Log log = LogFactory
-            .getLog(SensitivityCalculatorRFrF2.class);
-
-    @Doc("is the arabic numeral for the requested resolution of the design( 3 <= resolution <= 5). (if resolution=3, model = sum(Xi), if resolution = 4 or 5, model = sum(Xi)+sum(XiXj)")
-    public int param_resolution;
-
-    /**
-     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
-     * continue.
-     * 
-     * @return <tt>true</tt> s'il sait la gerer
-     */
-    @Override
-    public boolean canManageCardinality() {
-        return true;
-    }
-
-    @Override
-    public SensitivityScenarios compute(DesignPlan plan, File outputdirectory)
-        throws SensitivityException {
-
-        double[] dataframe;
-        int nbExperiments;
-        int factorNumber = plan.getFactors().size();
-        List<Factor> factors = plan.getFactors();
-        SensitivityScenarios thisExperiment = new SensitivityScenarios();
-        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
-
-        testNoDiscrete(factors);
-
-        try {
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.voidEval("rm(list=ls())");
-
-            engine.voidEval("library(FrF2)");
-
-            //Set the working directory (for import and exports)
-            engine.voidEval("setwd(\""
-                    + outputdirectory.getAbsolutePath().replaceAll("\\\\", "/")
-                    + "\")");
-
-            String rInstruction = "a<-FrF2(nfactors=" + factorNumber
-                    + ",resolution=" + param_resolution + ")";
-
-            engine.voidEval(rInstruction);
-
-            // Export the FrF2 object for the second run in a .FrF2 file
-            engine.voidEval("dput(a,file=\".FrF2\")");
-
-            // Get back experiment plan
-            dataframe = (double[]) engine.eval("a$desnum");
-
-            // Creating the factors vector.
-            rInstruction = "factornames<-c(";
-            for (int i = 0; i < factorNumber; i++) {
-                if (i != (factorNumber - 1)) {
-                    rInstruction = rInstruction + "\""
-                            + factors.get(i).getName() + "\",";
-                } else {
-                    rInstruction = rInstruction + "\""
-                            + factors.get(i).getName() + "\"";
-                }
-            }
-
-            rInstruction += ")";
-
-            engine.voidEval(rInstruction);
-
-            // Export the factornames object for the second run in a .factornames file
-            engine.voidEval("dput(factornames,file=\".factornames\")");
-
-
-            nbExperiments = dataframe.length / factorNumber;
-    
-            // Transform the result from R in a matrix
-            MatrixND frf2 = MatrixFactory.getInstance().create(dataframe,
-                    new int[] { factorNumber, nbExperiments });
-    
-            // Setting up the scenarios.
-            for (int j = 0; j < nbExperiments; j++) {
-                Scenario experimentScenario = new Scenario();
-                for (int i = 0; i < factorNumber; i++) {
-                    Factor factor = plan.getFactors().get(i);
-
-                    if (frf2.getValue(new int[]{i, j}) == -1) {
-                        factor.setValueForIdentifier(0);
-                    } else if (frf2.getValue(new int[]{i, j}) == 1) {
-                        factor.setValueForIdentifier(1);
-                    }
-
-                    experimentScenario.addFactor(factor);
-                }
-                thisExperimentScenarios.add(experimentScenario);
-                thisExperiment.setScenarios(thisExperimentScenarios);
-            }
-
-            //Create the factors vectors
-            for (int j = 0; j < factorNumber; j++) {
-                Factor factor = thisExperimentScenarios.get(0).getFactors()
-                        .get(j);
-
-                String vector = "factor" + j + "<-c(";
-                for (int i = 0; i < nbExperiments; i++) {
-                    if (i < (nbExperiments - 1)) {
-                        vector = vector + factor.getDisplayedValue() + ",";
-                    } else {
-                        vector = vector + factor.getDisplayedValue();
-                    }
-
-                }
-                vector = vector + ")";
-                engine.voidEval(vector);
-            }
-
-            //Create the data data.frame from the factors
-            String data = "data<-data.frame(";
-            for (int j = 0; j < factorNumber; j++) {
-                if (j < factorNumber - 1) {
-                    data = data + "factor" + j + "=factor(factor" + j + "),";
-                } else {
-                    data = data + "factor" + j + "=factor(factor" + j + "))";
-                }
-
-            }
-            engine.voidEval(data);
-
-            // Set output directory
-            engine.voidEval("setwd(\""
-                    + outputdirectory.getAbsolutePath().replaceAll("\\\\", "/")
-                    + "\")");
-
-            // Export the scenario matrix for the second run in a .FrF2.csv file
-            engine.voidEval("write.csv(data,file=\".FrF2.csv\")");
-
-            engine.terminate();
-
-        } catch (RException e) {
-            throw new SensitivityException("Can't generate scenarios", e);
-        }
-        return thisExperiment;
-
-    }
-
-    @Override
-    public void analyzeResult(List<SimulationStorage> simulationStorages,
-            File outputdirectory) throws SensitivityException {
-
-        try {
-
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.voidEval("rm(list=ls())");
-
-            SimulationParameter param = simulationStorages.get(0)
-                    .getParameter();
-            int sensitivityNumber = param.getSensitivityExport().size();
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                engine.voidEval("library(FrF2)");
-
-                // Set output directory
-                engine.voidEval("setwd(\""
-                        + outputdirectory.getAbsolutePath().replaceAll("\\\\",
-                        "/") + "\")");
-
-                //Get back the FrF2 object
-                engine.voidEval("a<-dget(\".FrF2\")");
-
-                //Get back the scenarios
-                engine.voidEval("factors<-read.csv(\".FrF2.csv\")");
-
-                // Get the factornames object in the .factornames file
-                engine.voidEval("factornames<-dget(\".factornames\")");
-
-                //Get back the factors number
-                int factorNumber = ((Double) engine.eval("length(factors)-1"))
-                        .intValue();
-
-                // Creates the R expression to import results in R
-                String name = param.getSensitivityExport().get(k)
-                        .getExportFilename();
-                String rInstruction = name + "<-c(";
-                for (int l = 0; l < simulationStorages.size(); l++) {
-                    File importFile = new File(simulationStorages.get(l)
-                            .getDirectory().toString()
-                            + File.separator
-                            + SimulationStorage.RESULT_EXPORT_DIRECTORY, param
-                            .getSensitivityExport().get(k).getExportFilename()
-                            + param.getSensitivityExport().get(k)
-                                    .getExtensionFilename());
-                    String simulResult = FileUtil.readAsString(importFile);
-                    double simulationResult = Double.valueOf(simulResult);
-                    if (l < simulationStorages.size() - 1) {
-                        rInstruction = rInstruction + simulationResult + ",";
-                    } else {
-                        rInstruction = rInstruction + simulationResult;
-                    }
-                }
-                rInstruction = rInstruction + ")";
-
-                // Send the simulation results
-                engine.voidEval(rInstruction);
-
-                //Create the dataforaov data.frame
-                String dataframe = "dataforaov<-data.frame(factors,result=result)";
-                engine.voidEval(dataframe);
-
-                //get back the resolution
-                int resolution = (Integer) engine.eval("res.catlg(a$catentry)");
-
-                String aovCall;
-
-                switch (resolution) {
-                case 3:
-                    //Call aov()
-                    aovCall = "aovresult<-aov(result~";
-                    for (int j = 0; j < factorNumber; j++) {
-                        if (j < (factorNumber - 1)) {
-                            aovCall = aovCall + "factor" + j + "+";
-                        } else {
-                            aovCall = aovCall + "factor" + j
-                                    + ",data=dataforaov)";
-                        }
-                    }
-                    engine.voidEval(aovCall);
-                    break;
-                case 4:
-                    aovCall = "aovresult<-aov(result~";
-                    for (int j = 0; j < factorNumber; j++) {
-                        aovCall = aovCall + "factor" + j + "+";
-                    }
-                    for (int i = 0; i < factorNumber; i++) {
-                        for (int j = 0; j < factorNumber; j++) {
-                            if (i < j) {
-                                aovCall = aovCall + "factor" + i + "*factor"
-                                        + j + "+";
-                            }
-                        }
-                    }
-                    aovCall = aovCall.substring(0, aovCall.length() - 1);
-                    aovCall = aovCall + ",data=dataforaov)";
-                    engine.voidEval(aovCall);
-                    break;
-                case 5:
-                    aovCall = "aovresult<-aov(result~";
-                    for (int j = 0; j < factorNumber; j++) {
-                        aovCall = aovCall + "factor" + j + "+";
-                    }
-                    for (int i = 0; i < factorNumber; i++) {
-                        for (int j = 0; j < factorNumber; j++) {
-                            if (i < j) {
-                                aovCall = aovCall + "factor" + i + "*factor"
-                                        + j + "+";
-                            }
-                        }
-                    }
-                    aovCall = aovCall.substring(0, aovCall.length() - 1);
-                    aovCall = aovCall + ",data=dataforaov)";
-                    engine.voidEval(aovCall);
-                    break;
-                default:
-                    log.info("This resolution is not managed");
-                    break;
-                }
-
-                /*Export the results
-                 *Export format is csv, data separated by ','
-                 *Results Export name is sensitivityExportName_Results.csv
-                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
-                 */
-
-                //Compute Sum of Squares and Sensitivity indices
-                engine.voidEval("SoS<-summary(aovresult)[[1]][1:"
-                        + factorNumber + ",2]");
-                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:"
-                                + factorNumber + "]");
-                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
-
-                //Create a data.frame to export sensitivity important results in one file.
-                engine.voidEval("exportsensitivity=data.frame(SoS[1:"
-                        + factorNumber + "],IndSensibilite[1:" + factorNumber
-                        + "])");
-                engine.voidEval("names(exportsensitivity)<-c(" +
-                        "\"Sum Of Squares\",\"Sensitivity indices\")");
-
-                engine.voidEval("row.names(exportsensitivity)<-factornames");
-
-                /*Set the export directory
-                 *Export directory is the first simulation export directory. 
-                 */
-                engine.voidEval("setwd(\""
-                        + outputdirectory.getAbsolutePath().replaceAll("\\\\",
-                                "/") + "\")");
-
-                //Set dataforaov names
-                engine.voidEval("resultsnames<-c(\"Simulation\"," +
-                        "factornames,\"Result\")");
-                engine.voidEval("names(dataforaov)<-resultsnames");
-
-                //Save the results with the scenarios.
-                engine.voidEval("write.csv(dataforaov,\""
-                        + param.getSensitivityExport().get(k)
-                                .getExportFilename() + "_Results.csv\")");
-
-                //Save the sensitivity indices
-                engine.voidEval("write.csv(exportsensitivity,\""
-                        + param.getSensitivityExport().get(k)
-                                .getExportFilename()
-                        + "_SensitivityIndices.csv\")");
-
-                //FIXME export through java to enable export when using Rserve (when distant Rserve).
-                engine.terminate();
-            }
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't evaluate results", e);
-        }
-
-    }
-
-    @Override
-    public String getDescription() {
-        return "Implementation of FrF2 method method using R, at least 4 factors need to be declared (nneds the 'sensitivity' package to work)";
-    }
-}

Deleted: branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRMorris.java
===================================================================
--- branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRMorris.java	2012-11-06 10:23:44 UTC (rev 306)
+++ branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRMorris.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -1,358 +0,0 @@
-/*
- * #%L
- * IsisFish data
- * %%
- * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
- * %%
- * 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 3 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-3.0.html>.
- * #L%
- */
-
-package sensitivityanalysis;
-
-import fr.ifremer.isisfish.datastore.SimulationStorage;
-import fr.ifremer.isisfish.export.SensitivityExport;
-import fr.ifremer.isisfish.simulator.SimulationParameter;
-import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
-import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
-import fr.ifremer.isisfish.simulator.sensitivity.Factor;
-import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
-import fr.ifremer.isisfish.util.Doc;
-import org.nuiton.j2r.REngine;
-import org.nuiton.j2r.RException;
-import org.nuiton.j2r.RProxy;
-import org.nuiton.j2r.types.RDataFrame;
-
-import java.io.File;
-import java.util.List;
-
-/**
- * Implementation of Morris method using R.
- *
- * @author jcouteau
- * @version $Revision$
- *
- * Last update : $Date$ By :
- * $Author$
- */
-public class SensitivityCalculatorRMorris
-        extends AbstractSensitivityAnalysis {
-
-    @Doc("Integer giving the number of repetitions of the design, i.e. the number of elementary effect computed per factor. (Default value : 4)")
-    public int param_r = 4;
-
-    @Doc("True to be able to modify the code sent to R")
-    public boolean param_modifR = false;
-
-    /**
-     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
-     * continus.
-     *
-     * @return <tt>true</tt> s'il sait la gerer
-     */
-    @Override
-    public boolean canManageCardinality() {
-        return false;
-    }
-
-    @Override
-    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
-            throws SensitivityException {
-
-        setIsisFactorsR(plan, outputDirectory);
-
-        RDataFrame dataFrame;
-        int nbExperiments;
-        int factorNumber = plan.getFactors().size();
-
-        SensitivityScenarios thisExperiment = new SensitivityScenarios();
-
-        List<Factor> factors = plan.getFactors();
-
-        if (param_r == 0) {
-            param_r = 4;
-        }
-
-        testNoDiscrete(factors);
-
-        // Creating the vectors.
-        String factorNames = "";
-        String levels = "";
-        String gridJump = "";
-        String binf = "";
-        String bsup = "";
-        for (int i = 0; i < factorNumber; i++) {
-            Factor factor = factors.get(i);
-            ContinuousDomain domain = (ContinuousDomain) factor.getDomain();
-            if (i != 0) {
-                factorNames += ",";
-                levels += ",";
-                gridJump += ",";
-                binf += ",";
-                bsup += ",";
-            }
-
-            factorNames += "\"" + factor.getName() + "\"";
-
-            levels += factor.getCardinality();
-
-            gridJump += factor.getCardinality() / 2;
-
-            binf += domain.getCalculatorMinBound();
-
-            bsup += domain.getCalculatorMaxBound();
-        }
-
-        String rInstruction = "a<-morris(model=NULL,factors=c(%s),r=%s," +
-                "design=list(type=\"oat\",levels=c(%s),grid.jump=c(%s))," +
-                "binf=c(%s),bsup=c(%s))";
-
-        String rCall = String.format(rInstruction, factorNames, param_r,
-                levels, gridJump, binf, bsup);
-
-        if (param_modifR) {
-            rCall = editRInstruction(rCall);
-        }
-
-        REngine engine = null;
-
-        try {
-            engine = new RProxy();
-
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            // Load sensitivity package into R (if package already loaded,
-            // nothing happens.
-            engine.voidEval("library(sensitivity)");
-
-            // Run sensitivity analysis
-            engine.voidEval(rCall);
-
-            // Creating the factors vector.
-            rInstruction = "factornames<-c(%s)";
-            rCall = String.format(rInstruction, factorNames);
-
-            engine.voidEval(rCall);
-
-            // Set output directory
-            engine.setwd(outputDirectory);
-
-            // Get back experiment plan
-            engine.eval("expPlan<-as.data.frame(a$X)");
-            dataFrame = (RDataFrame) engine.eval("expPlan");
-            dataFrame.setVariable("expPlan");
-
-            nbExperiments = (Integer)engine.eval("dim(expPlan)[1]");
-
-            String factorDistribution = "isis.factor.distribution<-data.frame(" +
-                    "NomFacteur=c(%s)," +
-                    "NomDistribution=c(%s)," +
-                    "ParametreDistribution=c(%s))";
-
-            String distribution = "";
-            String parameters = "";
-
-            for (int i = 0; i < factorNumber; i++) {
-                Factor factor = factors.get(i);
-                ContinuousDomain domain = (ContinuousDomain) factor.getDomain();
-                if (i != 0) {
-                    distribution += ",";
-                    parameters += ",";
-                }
-
-                distribution += "\"qunif\"";
-                parameters += "\"[" + domain.getMinBound() + ";" +
-                        domain.getMaxBound() + "]\"";
-            }
-            engine.voidEval(String.format(factorDistribution, factorNames,
-                    distribution, parameters));
-
-            engine.voidEval("call<-a$call");
-            engine.voidEval("isis.MethodExp<-list(" +
-                    "\"isis.factors\"=isis.factors," +
-                    "\"isis.factor.distribution\"=isis.factor.distribution," +
-                    "\"call\"=call)");
-            engine.voidEval("attr(isis.MethodExp,\"nomModel\")<-" +
-                    "\"isis-fish-externe-R\"");
-            engine.voidEval("isis.simule<-data.frame(expPlan)");
-            engine.voidEval("attr(isis.simule,\"nomModel\")<-" +
-                    "\"isis-fish-externe-R\"");
-            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            // Setting up the scenarios.
-            List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
-            for (int j = 0; j < nbExperiments; j++) {
-                Scenario experimentScenario = new Scenario();
-                for (int i = 0; i < factorNumber; i++) {
-                    Factor factor = factors.get(i);
-                    factor.setValueForIdentifier(dataFrame.get(i, j));
-                    experimentScenario.addFactor(factor);
-                }
-                thisExperimentScenarios.add(experimentScenario);
-                thisExperiment.setScenarios(thisExperimentScenarios);
-            }
-
-        } catch (RException eee) {
-            throw new SensitivityException("Can't generate scenarios", eee);
-        }
-
-        return thisExperiment;
-
-    }
-
-    @Override
-    public void analyzeResult(List<SimulationStorage> simulationStorages,
-                              File outputDirectory) throws SensitivityException {
-
-        SimulationStorage storage = simulationStorages.get(0);
-        String simulationName = storage.getName().replaceAll("-", "");
-
-        REngine engine = null;
-
-        try {
-            engine = new RProxy();
-
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            // Call R
-            // Load sensitivity package into R (if package already loaded,
-            // nothing happens.
-            engine.voidEval("library(sensitivity)");
-
-            //Set the working directory (for exports)
-            engine.setwd(outputDirectory);
-
-            SimulationParameter param = simulationStorages.get(0)
-                    .getParameter();
-            int sensitivityNumber = param.getSensitivityExport().size();
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                SensitivityExport sensitivityExport =
-                        param.getSensitivityExport().get(k);
-
-                String rInstruction = createImportInstruction(sensitivityExport,
-                        simulationStorages);
-
-                // Send the simulation results
-                engine.voidEval(rInstruction);
-
-                //Put results in isis.simule
-                engine.voidEval("isis.simule<-data.frame(isis.simule," +
-                        sensitivityExport.getExportFilename() + ")");
-            }
-
-            //adding attribute to isis.Simule
-            engine.voidEval("attr(isis.simule,\"nomModel\")<-" +
-                    "\"isis-fish-externe-R\"");
-
-            engine.voidEval("attr(isis.simule,\"call\")<-isis.MethodExp$call");
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                // Creates the R expression to import results in R
-                String name = param.getSensitivityExport().get(k)
-                        .getExportFilename();
-
-                //Compute results
-                engine.voidEval("tell(a,y=" + name + ")");
-
-                //creating isis.methodAnalyse
-                engine.voidEval("isis.methodAnalyse<-list(" +
-                        //"\"isis.factors\"=isis.factors," +
-                        //"\"isis.factor.distribution\"=isis.factor.distribution," +
-                        "\"isis.simule\"=isis.simule," +
-                        "\"call_method\"=\"tell(a,y=" + name + ")" + "\"," +
-                        "\"analysis_result\"=a)");
-
-                //setting isis.methodAnalyse attributes
-                engine.voidEval("attr(isis.methodAnalyse,\"nomModel\")<-" +
-                        "\"isis-fish-externe-R\"");
-
-                // Get back the sensitivity results, mu, mu star and sigma.
-                engine.voidEval("mu<-apply(a$ee, 2, mean)");
-                engine.voidEval("mu.star <- apply(a$ee, 2, function(a) mean(abs(a)))");
-                engine.voidEval("sigma <- apply(a$ee, 2, sd)");
-
-                //Create the data.frame of sensitivity indices for export purpose
-                engine.voidEval("df<-data.frame(mu,mu.star,sigma)");
-                engine.voidEval("row.names(df)<-factornames");
-
-                //Create the data.frame of scenarios and results for export purpose
-                engine.voidEval("dfresults<-data.frame(a$X," + name + ")");
-
-                //Set dfresults names
-                engine.voidEval("resultsnames<-c(factornames,\"Result\")");
-                engine.voidEval("names(dfresults)<-resultsnames");
-
-                //Export sensitivity indices
-                engine.voidEval("write.csv(df," +
-                        "\"" + name + "_SensitivityIndices.csv\")");
-
-                //Export results
-                engine.voidEval("write.csv(dfresults," +
-                        "\"" + name + "_Results.csv\")");
-                //FIXME export through java to enable export when using Rserve
-
-                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-" +
-                        "isis.methodAnalyse";
-
-                engine.voidEval(String.format(renameIsisMethodAnalyse,
-                        simulationName + "." + name));
-
-            }
-
-            //Rename R objects for saving purpose
-            renameObjects(engine,simulationName);
-
-            //Clean temporary R objects
-            for (String object:engine.ls()) {
-                if (!object.startsWith(simulationName)){
-                    engine.remove(object);
-                }
-            }
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't evaluate results", e);
-        }
-
-    }
-
-    @Override
-    public String getDescription() {
-        return "Implementation of Morris method using R (needs the sensitivity" +
-                " package to work)";
-    }
-
-}

Deleted: branches/4.2.2/sensitivityanalysis/SensitivityCalculatorROptimumLHS.java
===================================================================
--- branches/4.2.2/sensitivityanalysis/SensitivityCalculatorROptimumLHS.java	2012-11-06 10:23:44 UTC (rev 306)
+++ branches/4.2.2/sensitivityanalysis/SensitivityCalculatorROptimumLHS.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -1,405 +0,0 @@
-/*
- * #%L
- * IsisFish data
- * %%
- * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
- * %%
- * 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 3 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-3.0.html>.
- * #L%
- */
-
-package sensitivityanalysis;
-
-import java.io.File;
-import java.util.List;
-
-import org.nuiton.j2r.REngine;
-import org.nuiton.j2r.RProxy;
-
-import fr.ifremer.isisfish.datastore.SimulationStorage;
-import fr.ifremer.isisfish.export.SensitivityExport;
-import fr.ifremer.isisfish.simulator.SimulationParameter;
-import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
-import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
-import fr.ifremer.isisfish.simulator.sensitivity.Factor;
-import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
-import fr.ifremer.isisfish.util.Doc;
-import org.nuiton.j2r.types.RDataFrame;
-
-/**
- * Implementation of Optimum Latin Hypercube method using R.
- * 
- * @author jcouteau
- * @version $Revision: 1.0 $
- */
-public class SensitivityCalculatorROptimumLHS extends
-        AbstractSensitivityAnalysis {
-
-    @Doc("Number of simulations (default=10)")
-    public int param_simulationNumber = 10;
-    @Doc("The maximum number of times the Columnwise Pairwise algorithm is applied to all the columns(default=2).")
-    public int param_MaxSweeps = 2;
-    @Doc("The optimal stopping criterion (between 0 and 1) (default=0.1).")
-    public double param_eps = 0.1;
-    @Doc("True to be able to modify the code sent to R")
-    public boolean param_modifR = false;
-
-    /**
-     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
-     * continue.
-     * 
-     * @return <tt>true</tt> s'il sait la gerer
-     */
-    @Override
-    public boolean canManageCardinality() {
-        return true;
-    }
-
-    @Override
-    public SensitivityScenarios compute(DesignPlan plan, File outputdirectory)
-            throws SensitivityException {
-
-        setIsisFactorsR(plan, outputdirectory);
-
-        int factorNumber = plan.getFactors().size();
-        List<Factor> factors = plan.getFactors();
-        RDataFrame dataFrame;
-        SensitivityScenarios thisExperiment = new SensitivityScenarios();
-        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
-
-        //Test all factors, if one is discrete, return null
-        testNoDiscrete(factors);
-
-        try {
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.clearSession();
-
-            //Set working directory to get Isis R session
-            engine.loadRData(outputdirectory.getParentFile(),
-                outputdirectory.getName());
-
-            //Load the lhs library
-            engine.voidEval("library(lhs)");
-
-            String rInstruction = "x<-optimumLHS(n=%s,k=%s,maxSweeps=%s,eps=%s)";
-
-            String rCall = String.format(rInstruction, param_simulationNumber,
-                    factorNumber, param_MaxSweeps, param_eps);
-
-            if (param_modifR) {
-                rCall = editRInstruction(rCall);
-            }
-
-            //Create the scenarios
-            engine.voidEval(rCall);
-
-            // Get back experiment plan
-            engine.eval("expPlan<-as.data.frame(x)");
-            dataFrame = (RDataFrame)engine.eval("expPlan");
-            dataFrame.setVariable("expPlan");
-
-            // Setting up the scenarios.
-            for (int j = 0; j < param_simulationNumber; j++) {
-                Scenario experimentScenario = new Scenario();
-                for (int i = 0; i < factorNumber; i++) {
-                    Factor factor = plan.getFactors().get(i);
-                    factor.setValueForIdentifier(dataFrame.get(i, j));
-                    experimentScenario.addFactor(factor);
-                }
-                thisExperimentScenarios.add(experimentScenario);
-                thisExperiment.setScenarios(thisExperimentScenarios);
-            }
-
-            String isisFactorDistribution = "isis.factor.distribution<-" +
-                "data.frame(" +
-                "NomFacteur=c(%s)," +
-                "NomDistribution=c(%s)," +
-                "ParametreDistribution=c(%s))";
-
-            String distribution = "";
-            String parameters = "";
-            String factorNames = "";
-
-            for (int i = 0; i < factors.size(); i++) {
-                Factor tempFactor = factors.get(i);
-                ContinuousDomain domain = (ContinuousDomain) tempFactor.getDomain();
-                if (i != 0) {
-                    distribution += ",";
-                    factorNames += ",";
-                    parameters += ",";
-                }
-
-                factorNames += "\"" + factors.get(i).getName() + "\"";
-                distribution += "\"qunif\"";
-                //add [min;max] to parameters
-                parameters += "\"[" + domain.getMinBound() + ";" +
-                    domain.getMaxBound() + "]\"";
-            }
-
-            engine.voidEval(String.format(isisFactorDistribution, factorNames,
-                    distribution, parameters));
-            
-            engine.voidEval("call<-" + "\"x<-optimumLHS("
-                + "n=" + param_simulationNumber
-                + ",k=" + factorNumber
-                + ",maxSweeps=" + param_MaxSweeps
-                + ",eps=" + param_eps + ")\"");
-
-            engine.voidEval("isis.MethodExp<-list(" +
-                "\"isis.factors\"=isis.factors," +
-                "\"isis.factor.distribution\"=isis.factor.distribution," +
-                "\"call\"=call)");
-
-            engine.voidEval("attr(isis.MethodExp," +
-                "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            engine.voidEval("isis.simule<-data.frame(x)");
-
-            engine.voidEval("attr(isis.simule," +
-                "\"nomModel\")<-\"isis-fish-externe-R\"");
-            
-            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
-
-            String data = "data<-data.frame(";
-
-            //Create the factors vectors and the dataFrame instruction
-            for (int j = 0; j < factors.size(); j++) {
-                //The factor values vector
-                String vector;
-                //Get back the factor
-                Scenario scenario = thisExperimentScenarios.get(0);
-                Factor factor = scenario.getFactors().get(j);
-                String factorName = factor.getName().replaceAll(" ", "");
-
-                vector = factorName + "<-c(";
-                for (int i = 0; i < param_simulationNumber; i++) {
-                    //Get back the displayed value the factor
-                    Scenario tempScenario = thisExperimentScenarios.get(i);
-                    Factor tempFactor = tempScenario.getFactors().get(j);
-                    Object value = tempFactor.getDisplayedValue();
-
-                    if (i < (param_simulationNumber - 1)) {
-                        vector = vector + value + ",";
-                    } else {
-                        vector += value;
-                    }
-
-                }
-                vector += ")";
-                engine.voidEval(vector);
-
-                if (j < factors.size() - 1) {
-                    data += factorName + "=factor(" + factorName + "),";
-                } else {
-                    data += factorName + "=factor(" + factorName + "))";
-                }
-            }
-            engine.voidEval(data);
-
-            // Creating the factors vector.
-            rInstruction = "factornames<-c(";
-            for (int i = 0; i < factorNumber; i++) {
-                if (i != (factorNumber - 1)) {
-                    rInstruction = rInstruction + "\""
-                            + factors.get(i).getName() + "\",";
-                } else {
-                    rInstruction = rInstruction + "\""
-                            + factors.get(i).getName() + "\"";
-                }
-            }
-
-            rInstruction += ")";
-
-            engine.voidEval(rInstruction);
-
-            // Save Isis R session
-            engine.saveRData(outputdirectory.getParentFile(),
-                outputdirectory.getName());
-
-            engine.terminate();
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't generate scenarios", e);
-        }
-
-        return thisExperiment;
-    }
-
-    @Override
-    public void analyzeResult(List<SimulationStorage> simulationStorages,
-            File outputDirectory) throws SensitivityException {
-
-        //The first storage to get the name and parameters all along the method
-        SimulationStorage storage = simulationStorages.get(0);
-
-        String simulationName = storage.getName().replaceAll("-", "");
-
-        try {
-
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            engine.voidEval("factors<-data.frame(x)");
-            engine.voidEval("names(factors)<-factornames");
-
-            //Get back the factors number
-            int factorNumber = (Integer) engine.eval("length(factors[1,])");
-            //Get back the simulation number
-            param_simulationNumber = (Integer) (engine.eval("length(factors[,1])"));
-
-            SimulationParameter param = storage.getParameter();
-            int sensitivityNumber = param.getSensitivityExport().size();
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                SensitivityExport sensitivityExport =
-                        param.getSensitivityExport().get(k);
-
-                String rInstruction = createImportInstruction(sensitivityExport,
-                        simulationStorages);
-
-                // Send the simulation results
-                engine.voidEval(rInstruction);
-
-                //Put results in isis.simule
-                engine.voidEval("isis.simule<-data.frame(isis.simule," +
-                        sensitivityExport.getExportFilename() + ")");
-            }
-
-            //adding attribute to isis.Simule
-            engine.voidEval("attr(isis.simule," +
-                "\"nomModel\")<-\"isis-fish-externe-R\"");
-            engine.voidEval("attr(isis.simule,\"call\")<-isis.MethodExp$call");
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                // Creates the R expression to import results in R
-                SensitivityExport export = param.getSensitivityExport().get(k);
-                String name = export.getExportFilename();
-
-                //Create the dataforaov data.frame
-                String dataframe = "dataforaov<-data.frame(factors," +
-                    name + "=" + name + ")";
-                engine.voidEval(dataframe);
-
-                //Call aov()
-                String aovCall = "aovresult<-aov(" + name + "~";
-                for (int j = 0; j < factorNumber; j++) {
-
-                    String factorName = (String) engine.eval("names(factors)[" + (j + 1) + "]");
-                    factorName = factorName.replaceAll(" ", ".");
-
-                    if (j < (factorNumber - 1)) {
-                        aovCall += factorName +
-                            "+";
-                    } else {
-                        aovCall += factorName + ",data=dataforaov)";
-                    }
-                }
-                engine.voidEval(aovCall);
-
-                /*Export the results
-                 *Export format is csv, data separated by ','
-                 *Results Export name is sensitivityExportName_Results.csv
-                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
-                 */
-
-                //Compute Sum of Squares and Sensitivity indices
-                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
-                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
-                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
-
-                //Create a data.frame to export sensitivity important results in one file.
-                engine.voidEval("exportsensitivity<-data.frame(" +
-                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
-                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
-                engine.voidEval("names(exportsensitivity)<-c(" +
-                        "\"Sum Of Squares\"," +
-                        "\"Sensitivity indices\")");
-                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
-
-
-                //Set dataforaov names
-                engine.voidEval("names(dataforaov)<-c(factornames,\"Result\")");
-
-                /*Set the export directory
-                 *Export directory is the first simulation export directory. 
-                 */
-                engine.setwd(outputDirectory);
-
-                //Save the results with the scenarios.
-                engine.voidEval("write.csv(dataforaov,\"" +
-                        name + "_Results.csv\")");
-
-                //Save the sensitivity indices
-                engine.voidEval("write.csv(exportsensitivity,\"" +
-                        name + "_SensitivityIndices.csv\")");
-                //FIXME export through java to enable export when using Rserve (when distant Rserve).
-
-                //creating isis.methodAnalyse
-                engine.voidEval("isis.methodAnalyse<-list(" +
-                    "\"isis.factors\"=isis.factors," +
-                    "\"isis.factor.distribution\"=isis.factor.distribution," +
-                    "\"isis.simule\"=isis.simule," +
-                    "call_method=\"" + aovCall + "\""+
-                    ",\"analysis_result\"=list(aovresult,IndSensibilite))");
-
-                engine.voidEval("attr(isis.methodAnalyse," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-" +
-                    "isis.methodAnalyse";
-
-                engine.voidEval(String.format(renameIsisMethodAnalyse,
-                    simulationName + "." + name));
-
-            }
-
-            //Rename R objects for saving purpose
-            renameObjects(engine, simulationName);
-
-            //Clean temporary R objects
-            for (String object:engine.ls()) {
-                if (!object.startsWith(simulationName)){
-                    engine.remove(object);
-                }
-            }
-
-            engine.terminate();
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't evaluate results", e);
-        }
-
-    }
-
-    @Override
-    public String getDescription() {
-        return "Implementation of Random Latin Hypercube method method " +
-            "using R (needs 'lhs' package to work)";
-    }
-
-}

Deleted: branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRRandomLHS.java
===================================================================
--- branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRRandomLHS.java	2012-11-06 10:23:44 UTC (rev 306)
+++ branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRRandomLHS.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -1,403 +0,0 @@
-/*
- * #%L
- * IsisFish data
- * %%
- * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
- * %%
- * 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 3 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-3.0.html>.
- * #L%
- */
-
-package sensitivityanalysis;
-
-import java.io.File;
-import java.lang.String;
-import java.util.List;
-
-import fr.ifremer.isisfish.export.SensitivityExport;
-import org.nuiton.j2r.REngine;
-import org.nuiton.j2r.RProxy;
-import org.nuiton.j2r.types.RDataFrame;
-
-import fr.ifremer.isisfish.datastore.SimulationStorage;
-import fr.ifremer.isisfish.simulator.SimulationParameter;
-import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
-import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
-import fr.ifremer.isisfish.simulator.sensitivity.Factor;
-import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
-import fr.ifremer.isisfish.util.Doc;
-
-/**
- * Implementation of Random Latin Hypercube method using R.
- * 
- * @author jcouteau
- * @version $Revision: 1.0 $
- */
-public class SensitivityCalculatorRRandomLHS extends
-        AbstractSensitivityAnalysis {
-
-    @Doc("Simulation number (default=10)")
-    public int param_simulationNumber = 10;
-    @Doc("True to be able to modify the code sent to R")
-    public boolean param_modifR = false;
-
-    /**
-     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
-     * continue.
-     * 
-     * @return <tt>true</tt> s'il sait la gerer
-     */
-    @Override
-    public boolean canManageCardinality() {
-        return true;
-    }
-
-    @Override
-    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
-            throws SensitivityException {
-
-        setIsisFactorsR(plan, outputDirectory);
-
-        int factorNumber = plan.getFactors().size();
-        RDataFrame dataFrame; //The dataframe to get back the scenarios from R
-        SensitivityScenarios thisExperiment = new SensitivityScenarios(); //The experiment we will build
-        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios(); //The list of scenarios
-        List<Factor> factors = plan.getFactors(); //The factors
-
-        testNoDiscrete(factors);
-
-        try {
-
-            REngine engine = new RProxy(); //The R engine
-
-            //Clear session
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            //Load the lhs library
-            engine.voidEval("library(lhs)");
-
-            //Create the scenarios
-            String rInstruction = "x<-randomLHS(%s,%s)";
-            String rCall = String.format(rInstruction, param_simulationNumber,
-                    factorNumber);
-
-            if (param_modifR) {
-                rCall = editRInstruction(rCall);
-            }
-
-            engine.voidEval(rCall);
-
-            // Get back experiment plan
-            engine.eval("expPlan<-as.data.frame(x)");
-            dataFrame = (RDataFrame)engine.eval("expPlan");
-            dataFrame.setVariable("expPlan");
-
-            // Setting up the scenarios.
-            for (int j = 0; j < param_simulationNumber; j++) {
-                Scenario experimentScenario = new Scenario();
-                for (int i = 0; i < factorNumber; i++) {
-                    Factor factor = plan.getFactors().get(i); //The factor we are setting
-                    factor.setValueForIdentifier(dataFrame.get(i,j));
-                    experimentScenario.addFactor(factor);
-                }
-                thisExperimentScenarios.add(experimentScenario);
-                thisExperiment.setScenarios(thisExperimentScenarios);
-            }
-
-            String isisFactorDistribution = "isis.factor.distribution<-" +
-                "data.frame(" +
-                "NomFacteur=c(%s)," +
-                "NomDistribution=c(%s)," +
-                "ParametreDistribution=c(%s))";
-
-            String distribution = "";
-            String parameters = "";
-            String factorNames = "";
-
-
-            //Create the strings for the isis.MethodExp instruction
-            for (int i = 0; i < factors.size(); i++) {
-                ContinuousDomain domain = (ContinuousDomain)factors.get(i).getDomain();
-                if (i != 0) {
-                    distribution += ","; //the distribution
-                    factorNames += ","; //the factor names
-                    parameters += ","; //the parameters
-                }
-
-                factorNames += "\"" + factors.get(i).getName() + "\"";
-                distribution += "\"qunif\""; //all distributions are qunif
-                double min = domain.getCalculatorMinBound();
-                double max = domain.getCalculatorMaxBound();
-                parameters += "\"[" + min + ";" + max + "]\"";
-            }
-            engine.voidEval(String.format(isisFactorDistribution, factorNames,
-                    distribution, parameters));
-
-            engine.voidEval("call<-" + "\"x<-randomLHS("
-                    + param_simulationNumber + "," + factorNumber + ")\"");
-
-            engine.voidEval("isis.MethodExp<-list(" +
-                "\"isis.factors\"=isis.factors," +
-                "\"isis.factor.distribution\"=isis.factor.distribution," +
-                "\"call\"=call)");
-
-            engine.voidEval("attr(isis.MethodExp," +
-                "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            engine.voidEval("isis.simule<-data.frame(x)");
-            engine.voidEval("attr(isis.simule," +
-                "\"nomModel\")<-\"isis-fish-externe-R\"");
-            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
-
-            String data = "data<-data.frame(";
-
-            //Create the factors vectors and the dataFrame instruction
-            for (int j = 0; j < factors.size(); j++) {
-                Scenario firstScenario = thisExperimentScenarios.get(0);
-                Factor factor = firstScenario.getFactors().get(j);
-                String factorName = factor.getName().replaceAll(" ", "");
-
-                //the vector of the factor values
-                //read all the values one by one from the already created
-                //scenarios.
-                String vector = factorName + "<-c(";
-                for (int i = 0; i < param_simulationNumber; i++) {
-                    Scenario scenario = thisExperimentScenarios.get(i);
-                    List<Factor> factorList = scenario.getFactors();
-                    Factor factor1 = factorList.get(j);
-                    if (i < (param_simulationNumber - 1)) {
-                        vector += factor1.getDisplayedValue() + ",";
-                    } else {
-                        vector += factor1.getDisplayedValue();
-                    }
-
-                }
-                vector = vector + ")";
-                engine.voidEval(vector);
-
-                //add factor1=factor(factor1) for each factor...
-                if (j < factors.size() - 1) {
-                    data += factorName + "=factor(" + factorName + "),";
-                } else {
-                    data += factorName + "=factor(" + factorName + "))";
-                }
-
-            }
-            engine.voidEval(data);
-
-            // Creating the factors vector.
-            rInstruction = "factornames<-c(";
-            for (int i = 0; i < factorNumber; i++) {
-                if (i != (factorNumber - 1)) {
-                    rInstruction = rInstruction + "\""
-                            + factors.get(i).getName() + "\",";
-                } else {
-                    rInstruction = rInstruction + "\""
-                            + factors.get(i).getName() + "\"";
-                }
-            }
-            rInstruction += ")";
-            engine.voidEval(rInstruction);
-            
-            // Clean RData
-            for (Factor factor:factors) {
-                engine.remove(factor.getName().replaceAll(" ", ""));
-            }
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            engine.terminate();
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't generate scenarios", e);
-        }
-
-        return thisExperiment;
-    }
-
-    @Override
-    public void analyzeResult(List<SimulationStorage> simulationStorages,
-            File outputDirectory) throws SensitivityException {
-
-        SimulationStorage simulationStorage1 = simulationStorages.get(0);
-        String simName = simulationStorage1.getName();
-        String simulationName = simName.replaceAll("-", "");
-        SimulationParameter param = simulationStorage1.getParameter();
-        int sensitivityNumber = param.getSensitivityExport().size();
-        //List<SensitivityExport> export = param.getSensitivityExport();
-
-        try {
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            engine.voidEval("factors<-data.frame(x)");
-
-            //Get back the factors number
-            int factorNumber = (Integer) engine.eval("length(factors)");
-
-            //Get back the simulation number
-            param_simulationNumber = (Integer) (engine.eval("length(factors[,1])"));
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                SensitivityExport sensitivityExport =
-                        param.getSensitivityExport().get(k);
-
-                String rInstruction = createImportInstruction(sensitivityExport,
-                        simulationStorages);
-
-                // Send the simulation results
-                engine.voidEval(rInstruction);
-
-                //Put results in isis.simule
-                engine.voidEval("isis.simule<-data.frame(isis.simule," +
-                        sensitivityExport.getExportFilename() + ")");
-            }
-
-            //adding attribute to isis.Simule
-            engine.voidEval("attr(isis.simule," +
-                "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            engine.voidEval("attr(isis.simule,\"call\")<-isis.MethodExp$call");
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                // Creates the R expression to import results in R
-                String name = param.getSensitivityExport().get(k)
-                        .getExportFilename();
-
-                //Create the dataforaov data.frame
-                String dataframe = "dataforaov<-data.frame(factors," + name
-                        + "=" + name + ")";
-                engine.voidEval(dataframe);
-
-                //Call aov()
-                String aovCall = "aovresult<-aov(" + name + "~";
-                for (int j = 0; j < factorNumber; j++) {
-
-                    if (j < (factorNumber - 1)) {
-                        aovCall += engine.eval("names(factors)[" + (j + 1) + "]")
-                                + "+";
-                    } else {
-                        aovCall += engine.eval("names(factors)[" + (j + 1) + "]")
-                                + ",data=dataforaov)";
-                    }
-                }
-                engine.voidEval(aovCall);
-
-                /*Export the results
-                 *Export format is csv, data separated by ','
-                 *Results Export name is sensitivityExportName_Results.csv
-                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
-                 */
-
-                //Compute Sum of Squares and Sensitivity indices
-                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
-                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
-                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
-
-                //Create a data.frame to export sensitivity important results in one file.
-                engine.voidEval("exportsensitivity<-data.frame(" +
-                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
-                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
-                engine.voidEval("names(exportsensitivity)<-c(" +
-                        "\"Sum Of Squares\"," +
-                        "\"Sensitivity indices\")");
-                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
-
-
-                //Set dataforaov names
-                engine.voidEval("resultsnames<-c(factornames,\"Result\")");
-                engine.voidEval("names(dataforaov)<-resultsnames");
-
-                /*Set the export directory
-                 *Export directory is the first simulation export directory.
-                 */
-                engine.setwd(outputDirectory);
-
-                //Save the results with the scenarios.
-                engine.voidEval("write.csv(dataforaov,\"" +
-                    param.getSensitivityExport().get(k).getExportFilename() +
-                    "_Results.csv\")");
-
-                //Save the sensitivity indices
-                engine.voidEval("write.csv(exportsensitivity,\"" +
-                    param.getSensitivityExport().get(k).getExportFilename() +
-                    "_SensitivityIndices.csv\")");
-                //FIXME export through java to enable export when using Rserve (when distant Rserve).
-
-                //creating isis.methodAnalyse
-                engine.voidEval("isis.methodAnalyse<-list(" +
-                    "\"isis.factors\"=isis.factors," +
-                    "\"isis.factor.distribution\"=isis.factor.distribution," +
-                    "\"isis.simule\"=isis.simule," +
-                    "call_method=\"" + aovCall + "\"," +
-                    "\"analysis_result\"=list(aovresult,IndSensibilite))");
-
-                engine.voidEval("attr(isis.methodAnalyse," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-" +
-                    "isis.methodAnalyse";
-                engine.voidEval(String.format(renameIsisMethodAnalyse,
-                        simulationName + "." + name));
-
-            }
-
-            //Rename R objects for saving purpose
-            renameObjects(engine, simulationName);
-
-            //Clean temporary R objects
-            for (String object:engine.ls()) {
-                if (!object.startsWith(simulationName)){
-                    engine.remove(object);
-                }
-            }
-
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            engine.terminate();
-
-        } catch (Exception e) {
-            throw new SensitivityException("Can't evaluate results", e);
-        }
-
-    }
-
-    @Override
-    public String getDescription() {
-        return "Implementation of Random Latin Hypercube method method using" +
-            " R needs the 'lhs' package to work)";
-    }
-
-}

Deleted: branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRSobol.java
===================================================================
--- branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRSobol.java	2012-11-06 10:23:44 UTC (rev 306)
+++ branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRSobol.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -1,343 +0,0 @@
-/*
- * #%L
- * IsisFish data
- * %%
- * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
- * %%
- * 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 3 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-3.0.html>.
- * #L%
- */
-
-package sensitivityanalysis;
-
-import java.io.File;
-import java.util.List;
-
-import fr.ifremer.isisfish.export.SensitivityExport;
-import org.nuiton.j2r.REngine;
-import org.nuiton.j2r.RProxy;
-
-import fr.ifremer.isisfish.datastore.SimulationStorage;
-import fr.ifremer.isisfish.simulator.SimulationParameter;
-import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
-import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
-import fr.ifremer.isisfish.simulator.sensitivity.Domain;
-import fr.ifremer.isisfish.simulator.sensitivity.Factor;
-import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
-import fr.ifremer.isisfish.util.Doc;
-import org.nuiton.j2r.types.RDataFrame;
-
-/**
- * Implementation of Sobol method using R.
- * 
- * @author jcouteau
- * @version $Revision: 89 $
- * 
- * Last update : $Date: 2009-03-25 13:45:16 +0100 (mer., 25 mars 2009) $ By :
- * $Author: jcouteau $
- */
-public class SensitivityCalculatorRSobol extends AbstractSensitivityAnalysis {
-
-    @Doc("the size of the 2 random samples")
-    public int param_n = 20;
-
-    @Doc("the number of bootstrap replicates.")
-    public int param_nboot = 20;
-
-    @Doc("True to be able to modify the code sent to R")
-    public boolean param_modifR = false;
-
-    /**
-     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
-     * continue.
-     * 
-     * @return <tt>true</tt> s'il sait la gerer
-     */
-    @Override
-    public boolean canManageCardinality() {
-        return true;
-    }
-
-    @Override
-    public SensitivityScenarios compute(DesignPlan plan, File outputdirectory)
-        throws SensitivityException {
-
-        setIsisFactorsR(plan, outputdirectory);
-
-        RDataFrame dataFrame;
-        int nbExperiments;
-        int factorNumber = plan.getFactors().size();
-        List<Factor> factors = plan.getFactors();
-        SensitivityScenarios thisExperiment = new SensitivityScenarios();
-        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
-
-        testNoDiscrete(factors);
-
-        String rInstruction = "a<-sobol2002(model=NULL,X1=X1,X2=X2,nboot=%s)";
-        String rCall = String.format(rInstruction, param_nboot);
-
-        if (param_modifR) {
-            rCall = editRInstruction(rCall);
-        }
-
-        try {
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputdirectory.getParentFile(),
-                outputdirectory.getName());
-
-            engine.voidEval("library(sensitivity)");
-
-            engine.voidEval("X1<-data.frame(matrix(runif(" + factorNumber + "*"
-                    + param_n + "),nrow=" + param_n + "))");
-            engine.voidEval("X2<-data.frame(matrix(runif(" + factorNumber + "*"
-                    + param_n + "),nrow=" + param_n + "))");
-
-            engine.voidEval(rCall);
-
-            // Creating the factors vector.
-            rInstruction = "factornames<-c(";
-            for (int i = 0; i < factorNumber; i++) {
-                String factorName = factors.get(i).getName();
-                if (i != (factorNumber - 1)) {
-                    rInstruction += "\"" + factorName + "\",";
-                } else {
-                    rInstruction += "\"" + factorName + "\"";
-                }
-            }
-
-            rInstruction += ")";
-
-            engine.voidEval(rInstruction);
-
-            // Get back experiment plan
-            dataFrame = (RDataFrame) engine.eval("a$X");
-            dataFrame.setVariable("a$X");
-
-            nbExperiments = dataFrame.dim()[0];
-
-            String isisFactorDistribution = "isis.factor.distribution<-" +
-                "data.frame(NomFacteur=c(%s)," +
-                "NomDistribution=c(%s)," +
-                "ParametreDistribution=c(%s))";
-
-            // Creating the vectors.
-            String distribution = "";
-            String parameters = "";
-            String factorNames = "";
-
-            for (int i = 0; i < factorNumber; i++) {
-                Factor factor = factors.get(i);
-                Domain domain = factor.getDomain();
-                if (i != 0) {
-                    distribution += ",";
-                    parameters += ",";
-                    factorNames += ",";
-                }
-
-                distribution += "\"qunif\"";
-                ContinuousDomain continuousDomain = (ContinuousDomain) domain;
-                double min = continuousDomain.getCalculatorMinBound();
-                double max = continuousDomain.getCalculatorMaxBound();
-                parameters += "\"[" + min + ";" + max + "]\"";
-                factorNames += "\"" + factor.getName() + "\"";
-            }
-
-            engine.voidEval(String.format(isisFactorDistribution, factorNames,
-                    distribution, parameters));
-
-            engine.voidEval("call<-a$call");
-
-            engine.voidEval("isis.MethodExp<-list(" +
-                "\"isis.factors\"=isis.factors," +
-                "\"isis.factor.distribution\"=isis.factor.distribution," +
-                "\"call\"=call)");
-
-            engine.voidEval("attr(isis.MethodExp," +
-                "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            engine.voidEval("isis.simule<-data.frame(a$X)");
-
-            engine.voidEval("attr(isis.simule," +
-                "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
-
-            // Save Isis R session
-            engine.saveRData(outputdirectory.getParentFile(),
-                outputdirectory.getName());
-
-                // Setting up the scenarios.
-            for (int j = 0; j < nbExperiments; j++) {
-                Scenario experimentScenario = new Scenario();
-                for (int i = 0; i < factorNumber; i++) {
-                    Factor factor = plan.getFactors().get(i);
-                    Double dFValue = (Double) dataFrame.get(i, j);
-                    factor.setValueForIdentifier(dFValue);
-                    experimentScenario.addFactor(factor);
-                }
-                thisExperimentScenarios.add(experimentScenario);
-            }
-
-        } catch (Exception e) {
-        throw new SensitivityException("Can't generate scenarios", e);}
-
-
-        thisExperiment.setScenarios(thisExperimentScenarios);
-        return thisExperiment;
-
-    }
-
-    @Override
-    public void analyzeResult(List<SimulationStorage> simulationStorages,
-            File outputDirectory) throws SensitivityException {
-
-        SimulationStorage firstStorage = simulationStorages.get(0);
-        SimulationParameter param = firstStorage.getParameter();
-        int sensitivityNumber = param.getSensitivityExport().size();
-        String simulationName = firstStorage.getName().replaceAll("-", "");
-
-        try {
-
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-
-            // Call R
-            // Load sensitivity package into R (if package already loaded,
-            // nothing happens.
-            engine.voidEval("library(sensitivity)");
-
-            //Set X1 names
-            engine.voidEval("names(X1)<-factornames");
-            //Set X2 names
-            engine.voidEval("names(X2)<-factornames");
-
-            //Set a$X names
-            engine.voidEval("names(a$X)<-factornames");
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                SensitivityExport sensitivityExport =
-                        param.getSensitivityExport().get(k);
-
-                String rInstruction = createImportInstruction(sensitivityExport,
-                        simulationStorages);
-
-                // Send the simulation results
-                engine.voidEval(rInstruction);
-
-                //Put results in isis.simule
-                engine.voidEval("isis.simule<-data.frame(isis.simule," +
-                        sensitivityExport.getExportFilename() + ")");
-            }
-
-            //adding attribute to isis.Simule
-            engine.voidEval("attr(isis.simule," +
-                "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            engine.voidEval("attr(isis.simule,\"call\")<-isis.MethodExp$call");
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                SensitivityExport sensitivityExport = param.getSensitivityExport().get(k);
-                String name = sensitivityExport.getExportFilename();
-
-                //Compute results
-                engine.voidEval("tell(a,y=" + name + ")");
-
-                engine.voidEval("row.names(a$S)<-names(a$X)");
-                engine.voidEval("row.names(a$T)<-names(a$X)");
-                engine.voidEval("row.names(a$V)<-c(\"global\"," +
-                    "names(a$X),paste(\"-\",names(a$X),sep=\"\"))");
-
-                //creating isis.methodAnalyse
-                engine.voidEval("isis.methodAnalyse<-list(" +
-                    "\"isis.factors\"=isis.factors," +
-                    "\"isis.factor.distribution\"=isis.factor.distribution," +
-                    "\"isis.simule\"=isis.simule," +
-                    "call_method=\"tell(a,y=" + name + ")" + "\"," +
-                    "\"analysis_result\"=a)");
-
-                //setting isis.methodAnalyse attributes
-                engine.voidEval("attr(isis.methodAnalyse," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\")");
-
-                //Create the data.frame of scenarios and results for export purpose
-                engine.voidEval("dfresults<-data.frame(a$X,a$y)");
-
-                //Set working directory
-                engine.setwd(outputDirectory);
-
-                //Export V
-                engine.voidEval("write.csv(a$V,\""
-                        + name
-                        + "_SensitivityIndices.csv\")");
-                //Export DD
-                engine.voidEval("write.csv(a$D,\""
-                        + name + "_D.csv\")");
-
-                //Export S
-                engine.voidEval("write.csv(a$S,\""
-                        + name + "_S.csv\")");
-
-                //Export results
-                engine.voidEval("write.csv(dfresults,\""
-                        + name + "_Results.csv\")");
-                //FIXME export through java to enable export when using Rserve
-
-                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-" +
-                    "isis.methodAnalyse";
-                engine.voidEval(String.format(renameIsisMethodAnalyse,
-                        simulationName + "." + name));
-
-            }
-
-            //Rename R objects for saving purpose
-            renameObjects(engine, simulationName);
-
-            //Clean temporary R objects
-            for (String object:engine.ls()) {
-                if (!object.startsWith(simulationName)){
-                    engine.remove(object);
-                }
-            }
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                outputDirectory.getName());
-        } catch (Exception e) {
-            throw new SensitivityException("Can't evaluate results", e);
-        }
-    }
-
-    @Override
-    public String getDescription() {
-        return "Implementation of Sobol method using R (use of the R " +
-            "sobol2002 method, needs the 'sensitivity' package to work)";
-    }
-}

Deleted: branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRegularFractions.java
===================================================================
--- branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRegularFractions.java	2012-11-06 10:23:44 UTC (rev 306)
+++ branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRegularFractions.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -1,399 +0,0 @@
-/*
- * #%L
- * IsisFish data
- * %%
- * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
- * %%
- * 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 3 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-3.0.html>.
- * #L%
- */
-
-package sensitivityanalysis;
-
-import java.io.File;
-import java.util.List;
-
-import fr.ifremer.isisfish.export.SensitivityExport;
-import org.nuiton.j2r.REngine;
-import org.nuiton.j2r.RException;
-import org.nuiton.j2r.RProxy;
-import org.nuiton.j2r.types.RDataFrame;
-
-import fr.ifremer.isisfish.datastore.SimulationStorage;
-import fr.ifremer.isisfish.simulator.SimulationParameter;
-import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
-import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
-import fr.ifremer.isisfish.simulator.sensitivity.Domain;
-import fr.ifremer.isisfish.simulator.sensitivity.Factor;
-import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
-import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.DiscreteDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.EquationContinuousDomain;
-import fr.ifremer.isisfish.simulator.sensitivity.domain.MatrixContinuousDomain;
-import fr.ifremer.isisfish.util.Doc;
-
-public class SensitivityCalculatorRegularFractions extends
-        AbstractSensitivityAnalysis {
-
-    @Doc("the path of the directory where the R function is stored (do not indicate the RegularFractions.R file name)")
-    public String param_pathToFunction = "";
-
-    @Doc("unique prime number of levels of all input and unit factors")
-    public int param_p = 2;
-
-    @Doc("number of unit factors (so that there are N=p^r units)")
-    public int param_r = 2;
-
-    @Doc("resolution of the fraction")
-    public int param_resolution = 2;
-
-    @Doc("True to be able to modify the code sent to R")
-    public boolean param_modifR = false;
-
-    /**
-     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
-     * continue.
-     * 
-     * @return <tt>true</tt> s'il sait la gerer
-     */
-    @Override
-    public boolean canManageCardinality() {
-        return true;
-    }
-
-    @Override
-    public SensitivityScenarios compute(DesignPlan plan, File outputDirectory)
-        throws SensitivityException {
-
-        setIsisFactorsR(plan, outputDirectory);
-
-        RDataFrame dataFrame;
-        int factorNumber = plan.getFactors().size();
-        List<Factor> factors = plan.getFactors();
-        SensitivityScenarios thisExperiment = new SensitivityScenarios();
-        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
-
-        String factorNames = "";
-
-        //Test all factors, if one is discrete, return null
-        //Create a string with all factors names
-        for (int i = 0; i < factorNumber; i++) {
-            Domain domain = factors.get(i).getDomain();
-            if (i != 0) {
-                factorNames += ",";
-            }
-
-            factorNames += "\"" + factors.get(i).getName() + "\"";
-
-            if (domain instanceof DiscreteDomain) {
-                throw new SensitivityException(factors.get(i).getName() +
-                        " has a discrete domain, this is not acceptable for " +
-                        "this method.");
-            }
-        }
-
-        try {
-
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            //Set the working directory (to import the R function)
-            engine.setwd(new File(param_pathToFunction));
-
-            //Import the function
-            engine.voidEval("source(\"regularfractions.R\")");
-
-            //Create the instruction
-            String rInstruction = "x<-regular.fraction(%s,%s,%s,%s)";
-            String rCall = String.format(rInstruction, factors.size(), param_p,
-                    param_r, param_resolution);
-
-            if (param_modifR) {
-                rCall = editRInstruction(rCall);
-            }
-
-            // Run function
-            engine.voidEval(rCall);
-
-            // Run function
-            engine.voidEval("call<-\"" + rCall + "\"");
-
-            // Creating the factors vector.
-            rInstruction = "factornames<-c(%s)";
-            rCall = String.format(rInstruction, factorNames);
-
-            engine.voidEval(rCall);
-
-
-            // Get back experiment plan
-            engine.eval("expPlan<-as.data.frame(x[[1]])");
-            dataFrame = (RDataFrame)engine.eval("expPlan");
-            dataFrame.setVariable("expPlan");
-            
-            //Get back the simulation number
-            int simulationNumber = (Integer) engine.eval("length(x[[1]][,1])");
-
-            // Setting up the scenarios.
-            for (int j = 0; j < simulationNumber; j++) {
-                Scenario experimentScenario = new Scenario();
-                for (int i = 0; i < factors.size(); i++) {
-                    Factor factor = plan.getFactors().get(i);
-                    Domain domain = factor.getDomain();
-                    Double dFValue = (Double)dataFrame.get(i,j);
-                    if ((domain instanceof MatrixContinuousDomain)
-                            || (domain instanceof EquationContinuousDomain)) {
-                        factor.setValueForIdentifier(dFValue);
-                    } else {
-                        ContinuousDomain contDomain = (ContinuousDomain)domain;
-                        Double max = contDomain.getCalculatorMaxBound();
-                        Double min = contDomain.getCalculatorMinBound();
-                        Double value = min + (max - min) * dFValue / (param_p - 1);
-                        factor.setValueForIdentifier(value);
-                    }
-                    experimentScenario.addFactor(factor);
-                }
-                thisExperimentScenarios.add(experimentScenario);
-                thisExperiment.setScenarios(thisExperimentScenarios);
-            }
-
-            String dataframe = "data<-data.frame(";
-
-            //Create the factors vectors and the dataframe instruction
-            for (int j = 0; j < factorNumber; j++) {
-                Factor factor = factors.get(j);
-                String factorName = factor.getName().replaceAll(" ", "");
-
-                String vector = factorName + "<-c(";
-                for (int i = 0; i < simulationNumber; i++) {
-                    Scenario scenario = thisExperimentScenarios.get(i);
-                    List<Factor> newFactors = scenario.getFactors();
-                    Factor factor1 = newFactors.get(j);
-
-                    if (i < (simulationNumber - 1)) {
-                        vector += factor1.getDisplayedValue() + ",";
-                    } else {
-                        vector += factor1.getDisplayedValue();
-                    }
-
-                }
-                vector = vector + ")";
-                engine.voidEval(vector);
-
-                if (j < factorNumber - 1) {
-                    dataframe += factorName + "=factor(" + factorName + "),";
-                } else {
-                    dataframe += factorName + "=factor(" + factorName + "))";
-                }
-
-            }
-            engine.voidEval(dataframe);
-
-            engine.voidEval("isis.factor.distribution<-c(0.0)");
-
-            engine.voidEval("isis.MethodExp<-list(" +
-                    "\"isis.factors\"=isis.factors," +
-                    "\"isis.factor.distribution\"=isis.factor.distribution," +
-                    "\"call\"=call)");
-
-            engine.voidEval("attr(isis.MethodExp," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            //Create isis.Simule
-            engine.voidEval("isis.simule<-data.frame(data)");
-
-            engine.voidEval("attr(isis.simule," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            engine.terminate();
-
-        } catch (RException eee) {
-            throw new SensitivityException("Can't generate scenarios", eee);
-        }
-
-        return thisExperiment;
-
-    }
-
-    @Override
-    public void analyzeResult(List<SimulationStorage> simulationStorages,
-            File outputDirectory) throws SensitivityException {
-
-        SimulationStorage firstStorage = simulationStorages.get(0);
-        SimulationParameter param = firstStorage.getParameter();
-        List<SensitivityExport> exports = param.getSensitivityExport();
-        int sensitivityNumber = exports.size();
-        String simulationName = firstStorage.getName().replaceAll("-", "");
-
-        try {
-
-            REngine engine = new RProxy();
-
-            //Clear session
-            engine.clearSession();
-
-            //Get Isis R session
-            engine.loadRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            //Get back the factors number
-            int factorNumber = (Integer) engine.eval("dim(data)[2]");
-
-            for (int k = 0; k < sensitivityNumber; k++) {
-
-                SensitivityExport sensitivityExport =
-                        param.getSensitivityExport().get(k);
-
-                String rInstruction = createImportInstruction(sensitivityExport,
-                        simulationStorages);
-
-                // Send the simulation results
-                engine.voidEval(rInstruction);
-
-                //Put results in isis.simule
-                engine.voidEval("isis.simule<-data.frame(isis.simule," +
-                        sensitivityExport.getExportFilename() + ")");
-            }
-
-            //adding attribute to isis.Simule
-            engine.voidEval("attr(isis.simule," +
-                    "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-            for (SensitivityExport export : exports) {
-
-                String name = export.getExportFilename();
-
-                //Create the dataforaov data.frame
-                String dataFrame = "dataforaov<-data.frame(data," +
-                        name + "=" + name + ")";
-                engine.voidEval(dataFrame);
-
-                //Call aov()
-                String aovCall = "aovresult<-aov(" + name + "~(";
-                for (int j = 0; j < factorNumber; j++) {
-
-                    if (j < (factorNumber - 1)) {
-                        aovCall = aovCall
-                                + engine.eval("names(data)[" + (j + 1) + "]")
-                                + "+";
-                    } else {
-                        aovCall = aovCall
-                                + engine.eval("names(data)[" + (j + 1) + "]")
-                                + ")";
-                        if (param_resolution <= 4) {
-                            aovCall += ",data=dataforaov)";
-                        } else {
-                            aovCall += "^2,data=dataforaov)";
-                        }
-                    }
-                }
-                engine.voidEval(aovCall);
-
-                /*Export the results
-                 *Export format is csv, data separated by ','
-                 *Results Export name is sensitivityExportName_Results.csv
-                 *Sensitivity Indices export name is sensitivityExportName_SensitivityIndices.csv
-                 */
-
-                //Compute Sum of Squares and Sensitivity indices
-                engine.voidEval("SoS<-summary(aovresult)[[1]][1:dim(summary(aovresult)[[1]])[1],2]");
-                engine.voidEval("names(SoS)<-dimnames(summary(aovresult)[[1]])[[1]][1:dim(summary(aovresult)[[1]])[1]]");
-                engine.voidEval("IndSensibilite<-SoS/sum(SoS)");
-
-                //Create a data.frame to export sensitivity important results in one file.
-                engine.voidEval("exportsensitivity<-data.frame(" +
-                        "SoS[1:dim(summary(aovresult)[[1]])[1]]," +
-                        "IndSensibilite[1:dim(summary(aovresult)[[1]])[1]])");
-                engine.voidEval("names(exportsensitivity)<-c(" +
-                        "\"Sum Of Squares\"," +
-                        "\"Sensitivity indices\")");
-                engine.voidEval("row.names(exportsensitivity)<-dimnames(summary(aovresult)[[1]])[1][[1]][1:dim(summary(aovresult)[[1]])[1]]");
-
-                //Set dataforaov names
-                engine.voidEval("resultsnames<-c(factornames,\"Result\")");
-                engine.voidEval("names(dataforaov)<-resultsnames");
-
-                /*Set the export directory
-                 *Export directory is the first simulation export directory. 
-                 */
-                engine.setwd(outputDirectory);
-
-                //Save the results with the scenarios.
-                engine.voidEval("write.csv(dataforaov,\"" + name +
-                        "_Results.csv\")");
-
-                //Save the sensitivity indices
-                engine.voidEval("write.csv(exportsensitivity,\"" + name +
-                        "_SensitivityIndices.csv\")");
-                //FIXME export through java to enable export when using Rserve (when distant Rserve).
-
-                //creating isis.methodAnalyse
-                engine.voidEval("isis.methodAnalyse<-list(" +
-                        "\"isis.factors\"=isis.factors," +
-                        "\"isis.factor.distribution\"=isis.factor.distribution," +
-                        "\"isis.simule\"=isis.simule," +
-                        "\"call_method\"=\"" + aovCall + "\"," +
-                        "\"analysis_result\"=list(aovresult,IndSensibilite))");
-
-                engine.voidEval("attr(isis.methodAnalyse," +
-                        "\"nomModel\")<-\"isis-fish-externe-R\"");
-
-                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-isis.methodAnalyse";
-                engine.voidEval(String.format(renameIsisMethodAnalyse,
-                        simulationName + "." + name));
-
-            }
-
-            //Rename R objects for saving purpose
-            renameObjects(engine,simulationName);
-
-            //Clean temporary R objects
-            for (String object:engine.ls()) {
-                if (!object.startsWith(simulationName)){
-                    engine.remove(object);
-                }
-            }
-
-            // Save Isis R session
-            engine.saveRData(outputDirectory.getParentFile(),
-                    outputDirectory.getName());
-
-            engine.terminate();
-
-        } catch (Exception eee) {
-            throw new SensitivityException("Can't evaluate results", eee);
-        }
-
-    }
-
-    @Override
-    public String getDescription() {
-        return "Implementation of Regular fractions method using R";
-    }
-
-}

Copied: branches/4.2.2/sensitivityanalysis/Sobol.java (from rev 305, branches/4.2.2/sensitivityanalysis/SensitivityCalculatorRSobol.java)
===================================================================
--- branches/4.2.2/sensitivityanalysis/Sobol.java	                        (rev 0)
+++ branches/4.2.2/sensitivityanalysis/Sobol.java	2012-11-07 14:18:20 UTC (rev 307)
@@ -0,0 +1,343 @@
+/*
+ * #%L
+ * IsisFish data
+ * %%
+ * Copyright (C) 2009 - 2012 Ifremer, Code Lutin, Jean Couteau
+ * %%
+ * 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 3 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-3.0.html>.
+ * #L%
+ */
+
+package sensitivityanalysis;
+
+import java.io.File;
+import java.util.List;
+
+import fr.ifremer.isisfish.export.SensitivityExport;
+import org.nuiton.j2r.REngine;
+import org.nuiton.j2r.RProxy;
+
+import fr.ifremer.isisfish.datastore.SimulationStorage;
+import fr.ifremer.isisfish.simulator.SimulationParameter;
+import fr.ifremer.isisfish.simulator.sensitivity.AbstractSensitivityAnalysis;
+import fr.ifremer.isisfish.simulator.sensitivity.DesignPlan;
+import fr.ifremer.isisfish.simulator.sensitivity.Domain;
+import fr.ifremer.isisfish.simulator.sensitivity.Factor;
+import fr.ifremer.isisfish.simulator.sensitivity.Scenario;
+import fr.ifremer.isisfish.simulator.sensitivity.SensitivityException;
+import fr.ifremer.isisfish.simulator.sensitivity.SensitivityScenarios;
+import fr.ifremer.isisfish.simulator.sensitivity.domain.ContinuousDomain;
+import fr.ifremer.isisfish.util.Doc;
+import org.nuiton.j2r.types.RDataFrame;
+
+/**
+ * Implementation of Sobol method using R.
+ * 
+ * @author jcouteau
+ * @version $Revision: 89 $
+ * 
+ * Last update : $Date: 2009-03-25 13:45:16 +0100 (mer., 25 mars 2009) $ By :
+ * $Author: jcouteau $
+ */
+public class Sobol extends AbstractSensitivityAnalysis {
+
+    @Doc("the size of the 2 random samples")
+    public int param_n = 20;
+
+    @Doc("the number of bootstrap replicates.")
+    public int param_nboot = 20;
+
+    @Doc("True to be able to modify the code sent to R")
+    public boolean param_modifR = false;
+
+    /**
+     * Retourne vrai si le calculateur sait gerer la cardinalité des facteurs
+     * continue.
+     * 
+     * @return <tt>true</tt> s'il sait la gerer
+     */
+    @Override
+    public boolean canManageCardinality() {
+        return true;
+    }
+
+    @Override
+    public SensitivityScenarios compute(DesignPlan plan, File outputdirectory)
+        throws SensitivityException {
+
+        setIsisFactorsR(plan, outputdirectory);
+
+        RDataFrame dataFrame;
+        int nbExperiments;
+        int factorNumber = plan.getFactors().size();
+        List<Factor> factors = plan.getFactors();
+        SensitivityScenarios thisExperiment = new SensitivityScenarios();
+        List<Scenario> thisExperimentScenarios = thisExperiment.getScenarios();
+
+        testNoDiscrete(factors);
+
+        String rInstruction = "a<-sobol2002(model=NULL,X1=X1,X2=X2,nboot=%s)";
+        String rCall = String.format(rInstruction, param_nboot);
+
+        if (param_modifR) {
+            rCall = editRInstruction(rCall);
+        }
+
+        try {
+            REngine engine = new RProxy();
+
+            //Clear session
+            engine.clearSession();
+
+            //Get Isis R session
+            engine.loadRData(outputdirectory.getParentFile(),
+                outputdirectory.getName());
+
+            engine.voidEval("library(sensitivity)");
+
+            engine.voidEval("X1<-data.frame(matrix(runif(" + factorNumber + "*"
+                    + param_n + "),nrow=" + param_n + "))");
+            engine.voidEval("X2<-data.frame(matrix(runif(" + factorNumber + "*"
+                    + param_n + "),nrow=" + param_n + "))");
+
+            engine.voidEval(rCall);
+
+            // Creating the factors vector.
+            rInstruction = "factornames<-c(";
+            for (int i = 0; i < factorNumber; i++) {
+                String factorName = factors.get(i).getName();
+                if (i != (factorNumber - 1)) {
+                    rInstruction += "\"" + factorName + "\",";
+                } else {
+                    rInstruction += "\"" + factorName + "\"";
+                }
+            }
+
+            rInstruction += ")";
+
+            engine.voidEval(rInstruction);
+
+            // Get back experiment plan
+            dataFrame = (RDataFrame) engine.eval("a$X");
+            dataFrame.setVariable("a$X");
+
+            nbExperiments = dataFrame.dim()[0];
+
+            String isisFactorDistribution = "isis.factor.distribution<-" +
+                "data.frame(NomFacteur=c(%s)," +
+                "NomDistribution=c(%s)," +
+                "ParametreDistribution=c(%s))";
+
+            // Creating the vectors.
+            String distribution = "";
+            String parameters = "";
+            String factorNames = "";
+
+            for (int i = 0; i < factorNumber; i++) {
+                Factor factor = factors.get(i);
+                Domain domain = factor.getDomain();
+                if (i != 0) {
+                    distribution += ",";
+                    parameters += ",";
+                    factorNames += ",";
+                }
+
+                distribution += "\"qunif\"";
+                ContinuousDomain continuousDomain = (ContinuousDomain) domain;
+                double min = continuousDomain.getCalculatorMinBound();
+                double max = continuousDomain.getCalculatorMaxBound();
+                parameters += "\"[" + min + ";" + max + "]\"";
+                factorNames += "\"" + factor.getName() + "\"";
+            }
+
+            engine.voidEval(String.format(isisFactorDistribution, factorNames,
+                    distribution, parameters));
+
+            engine.voidEval("call<-a$call");
+
+            engine.voidEval("isis.MethodExp<-list(" +
+                "\"isis.factors\"=isis.factors," +
+                "\"isis.factor.distribution\"=isis.factor.distribution," +
+                "\"call\"=call)");
+
+            engine.voidEval("attr(isis.MethodExp," +
+                "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+            engine.voidEval("isis.simule<-data.frame(a$X)");
+
+            engine.voidEval("attr(isis.simule," +
+                "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+            engine.voidEval("names(isis.simule)<-isis.factors[[1]]");
+
+            // Save Isis R session
+            engine.saveRData(outputdirectory.getParentFile(),
+                outputdirectory.getName());
+
+                // Setting up the scenarios.
+            for (int j = 0; j < nbExperiments; j++) {
+                Scenario experimentScenario = new Scenario();
+                for (int i = 0; i < factorNumber; i++) {
+                    Factor factor = plan.getFactors().get(i);
+                    Double dFValue = (Double) dataFrame.get(i, j);
+                    factor.setValueForIdentifier(dFValue);
+                    experimentScenario.addFactor(factor);
+                }
+                thisExperimentScenarios.add(experimentScenario);
+            }
+
+        } catch (Exception e) {
+        throw new SensitivityException("Can't generate scenarios", e);}
+
+
+        thisExperiment.setScenarios(thisExperimentScenarios);
+        return thisExperiment;
+
+    }
+
+    @Override
+    public void analyzeResult(List<SimulationStorage> simulationStorages,
+            File outputDirectory) throws SensitivityException {
+
+        SimulationStorage firstStorage = simulationStorages.get(0);
+        SimulationParameter param = firstStorage.getParameter();
+        int sensitivityNumber = param.getSensitivityExport().size();
+        String simulationName = firstStorage.getName().replaceAll("-", "");
+
+        try {
+
+            REngine engine = new RProxy();
+
+            //Clear session
+            engine.clearSession();
+
+            //Get Isis R session
+            engine.loadRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+
+            // Call R
+            // Load sensitivity package into R (if package already loaded,
+            // nothing happens.
+            engine.voidEval("library(sensitivity)");
+
+            //Set X1 names
+            engine.voidEval("names(X1)<-factornames");
+            //Set X2 names
+            engine.voidEval("names(X2)<-factornames");
+
+            //Set a$X names
+            engine.voidEval("names(a$X)<-factornames");
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                SensitivityExport sensitivityExport =
+                        param.getSensitivityExport().get(k);
+
+                String rInstruction = createImportInstruction(sensitivityExport,
+                        simulationStorages);
+
+                // Send the simulation results
+                engine.voidEval(rInstruction);
+
+                //Put results in isis.simule
+                engine.voidEval("isis.simule<-data.frame(isis.simule," +
+                        sensitivityExport.getExportFilename() + ")");
+            }
+
+            //adding attribute to isis.Simule
+            engine.voidEval("attr(isis.simule," +
+                "\"nomModel\")<-\"isis-fish-externe-R\"");
+
+            engine.voidEval("attr(isis.simule,\"call\")<-isis.MethodExp$call");
+
+            for (int k = 0; k < sensitivityNumber; k++) {
+
+                SensitivityExport sensitivityExport = param.getSensitivityExport().get(k);
+                String name = sensitivityExport.getExportFilename();
+
+                //Compute results
+                engine.voidEval("tell(a,y=" + name + ")");
+
+                engine.voidEval("row.names(a$S)<-names(a$X)");
+                engine.voidEval("row.names(a$T)<-names(a$X)");
+                engine.voidEval("row.names(a$V)<-c(\"global\"," +
+                    "names(a$X),paste(\"-\",names(a$X),sep=\"\"))");
+
+                //creating isis.methodAnalyse
+                engine.voidEval("isis.methodAnalyse<-list(" +
+                    "\"isis.factors\"=isis.factors," +
+                    "\"isis.factor.distribution\"=isis.factor.distribution," +
+                    "\"isis.simule\"=isis.simule," +
+                    "call_method=\"tell(a,y=" + name + ")" + "\"," +
+                    "\"analysis_result\"=a)");
+
+                //setting isis.methodAnalyse attributes
+                engine.voidEval("attr(isis.methodAnalyse," +
+                    "\"nomModel\")<-\"isis-fish-externe-R\")");
+
+                //Create the data.frame of scenarios and results for export purpose
+                engine.voidEval("dfresults<-data.frame(a$X,a$y)");
+
+                //Set working directory
+                engine.setwd(outputDirectory);
+
+                //Export V
+                engine.voidEval("write.csv(a$V,\""
+                        + name
+                        + "_SensitivityIndices.csv\")");
+                //Export DD
+                engine.voidEval("write.csv(a$D,\""
+                        + name + "_D.csv\")");
+
+                //Export S
+                engine.voidEval("write.csv(a$S,\""
+                        + name + "_S.csv\")");
+
+                //Export results
+                engine.voidEval("write.csv(dfresults,\""
+                        + name + "_Results.csv\")");
+                //FIXME export through java to enable export when using Rserve
+
+                String renameIsisMethodAnalyse = "%s.isis.methodAnalyse<-" +
+                    "isis.methodAnalyse";
+                engine.voidEval(String.format(renameIsisMethodAnalyse,
+                        simulationName + "." + name));
+
+            }
+
+            //Rename R objects for saving purpose
+            renameObjects(engine, simulationName);
+
+            //Clean temporary R objects
+            for (String object:engine.ls()) {
+                if (!object.startsWith(simulationName)){
+                    engine.remove(object);
+                }
+            }
+
+            // Save Isis R session
+            engine.saveRData(outputDirectory.getParentFile(),
+                outputDirectory.getName());
+        } catch (Exception e) {
+            throw new SensitivityException("Can't evaluate results", e);
+        }
+    }
+
+    @Override
+    public String getDescription() {
+        return "Implementation of Sobol method using R (use of the R " +
+            "sobol2002 method, needs the 'sensitivity' package to work)";
+    }
+}

    

[Isis-fish-data-commits] r307 - branches/4.2.2/sensitivityanalysis

echatellier＠users.forge.codelutin.com