Isis-fish-data-commits

Download

isis-fish-data-commits@list.isis-fish.org

November 2012

1 participants
2 discussions

r307 - branches/4.2.2/sensitivityanalysis
by echatellier＠users.forge.codelutin.com Nov. 7, 2012

Nov. 7, 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)"; + } +}

1 0

r306 - in branches/4.2.2: . simulationplans
by echatellier＠users.forge.codelutin.com Nov. 6, 2012

Nov. 6, 2012

Author: echatellier Date: 2012-11-06 11:23:44 +0100 (Tue, 06 Nov 2012) New Revision: 306 Url: http://forge.codelutin.com/repositories/revision/isis-fish-data/306 Log: Migrate methods removed from FileUtil Modified: branches/4.2.2/pom.xml branches/4.2.2/simulationplans/CalibrationSimplexePasVariable2Capturabilite.java Modified: branches/4.2.2/pom.xml =================================================================== --- branches/4.2.2/pom.xml 2012-10-31 11:35:50 UTC (rev 305) +++ branches/4.2.2/pom.xml 2012-11-06 10:23:44 UTC (rev 306) @@ -14,7 +14,7 @@ <packaging>jar</packaging>  - <version>4.2.1</version> + <version>4.2.2</version>  <description>Data for Isis-fish</description> @@ -74,7 +74,7 @@ <dependency> <groupId>fr.ifremer</groupId> <artifactId>isis-fish</artifactId> - <version>4.2.1.0</version> + <version>4.2.2.0-SNAPSHOT</version> <scope>compile</scope> </dependency> </dependencies> Modified: branches/4.2.2/simulationplans/CalibrationSimplexePasVariable2Capturabilite.java =================================================================== --- branches/4.2.2/simulationplans/CalibrationSimplexePasVariable2Capturabilite.java 2012-10-31 11:35:50 UTC (rev 305) +++ branches/4.2.2/simulationplans/CalibrationSimplexePasVariable2Capturabilite.java 2012-11-06 10:23:44 UTC (rev 306) @@ -37,16 +37,16 @@ import org.nuiton.util.FileUtil; import org.nuiton.util.StringUtil; +import scripts.ResultName; import fr.ifremer.isisfish.datastore.ResultStorage; import fr.ifremer.isisfish.datastore.SimulationStorage; import fr.ifremer.isisfish.entities.Population; import fr.ifremer.isisfish.entities.PopulationGroup; +import fr.ifremer.isisfish.simulator.SimulationPlan; import fr.ifremer.isisfish.simulator.SimulationPlanContext; -import fr.ifremer.isisfish.simulator.SimulationPlan; import fr.ifremer.isisfish.util.Doc; +import fr.ifremer.isisfish.util.ScriptUtil; -import scripts.ResultName; - /** * CalibrationSimplexePasVariable2Capturabilite. * @@ -385,7 +385,7 @@ exportHisto += experiences.getExperience(number).q1 + ";" + experiences.getExperience(number).q2 + ";" + experiences.getExperience(number).criteria + "\n"; - org.nuiton.util.FileUtil.writeString(exportHistoric, exportHisto); + ScriptUtil.writeString(exportHistoric, exportHisto); return doNext; }// fin du after simulation

1 0