static void Main()
{
Debug.Assert(CCopasiRootContainer.getRoot() != null);
// create a new datamodel
CCopasiDataModel dataModel = CCopasiRootContainer.addDatamodel();
Debug.Assert(CCopasiRootContainer.getDatamodelList().size() == 1);
// get the model from the datamodel
CModel model = dataModel.getModel();
Debug.Assert(model != null);
model.setVolumeUnit(CUnit.fl);
model.setTimeUnit(CUnit.s);
model.setQuantityUnit(CUnit.fMol);
CModelValue fixedModelValue = model.createModelValue("F");
Debug.Assert(fixedModelValue != null);
fixedModelValue.setStatus(CModelEntity.FIXED);
fixedModelValue.setInitialValue(3.0);
CModelValue variableModelValue = model.createModelValue("V");
Debug.Assert(variableModelValue != null);
variableModelValue.setStatus(CModelEntity.ASSIGNMENT);
// we create a very simple assignment that is easy on the optimization
// a parabole with the minimum at x=6 should do just fine
string s = fixedModelValue.getValueReference().getCN().getString();
s = "(<" + s + "> - 6.0)^2";
variableModelValue.setExpression(s);
// now we compile the model and tell COPASI which values have changed so
// that COPASI can update the values that depend on those
model.compileIfNecessary();
ObjectStdVector changedObjects = new ObjectStdVector();
changedObjects.Add(fixedModelValue.getInitialValueReference());
changedObjects.Add(variableModelValue.getInitialValueReference());
model.updateInitialValues(changedObjects);
// now we set up the optimization
// we want to do an optimization for the time course
// so we have to set up the time course task first
CTrajectoryTask timeCourseTask = (CTrajectoryTask)dataModel.getTask("Time-Course");
Debug.Assert(timeCourseTask != null);
// since for this example it really doesn't matter how long we run the time course
// we run for 1 second and calculate 10 steps
// run a deterministic time course
timeCourseTask.setMethodType(CTaskEnum.deterministic);
// pass a pointer of the model to the problem
timeCourseTask.getProblem().setModel(dataModel.getModel());
// get the problem for the task to set some parameters
CTrajectoryProblem problem = (CTrajectoryProblem)timeCourseTask.getProblem();
Debug.Assert(problem != null);
// simulate 10 steps
problem.setStepNumber(10);
// start at time 0
dataModel.getModel().setInitialTime(0.0);
// simulate a duration of 1 time units
problem.setDuration(1);
// tell the problem to actually generate time series data
problem.setTimeSeriesRequested(true);
// get the optimization task
COptTask optTask = (COptTask)dataModel.getTask("Optimization");
Debug.Assert(optTask != null);
// we want to use Levenberg-Marquardt as the optimization method
optTask.setMethodType(CTaskEnum.LevenbergMarquardt);
// next we need to set subtask type on the problem
COptProblem optProblem = (COptProblem)optTask.getProblem();
Debug.Assert(optProblem != null);
optProblem.setSubtaskType(CTaskEnum.timeCourse);
// we create the objective function
// we want to minimize the value of the variable model value at the end of
// the simulation
// the objective function is normally minimized
string objectiveFunction = variableModelValue.getObject(new CCopasiObjectName("Reference=Value")).getCN().getString();
// we need to put the angled brackets around the common name of the object
objectiveFunction = "<" + objectiveFunction + ">";
// now we set the objective function in the problem
optProblem.setObjectiveFunction(objectiveFunction);
// now we create the optimization items
// i.e. the model elements that have to be changed during the optimization
// in order to get to the optimal solution
COptItem optItem = optProblem.addOptItem(new CCopasiObjectName(fixedModelValue.getObject(new CCopasiObjectName("Reference=InitialValue")).getCN()));
// we want to change the fixed model value from -100 to +100 with a start
// value of 50
optItem.setStartValue(50.0);
optItem.setLowerBound(new CCopasiObjectName("-100"));
optItem.setUpperBound(new CCopasiObjectName("100"));
// now we set some parameters on the method
// these parameters are specific to the method type we set above
// (in this case Levenberg-Marquardt)
COptMethod optMethod = (COptMethod)optTask.getMethod();
Debug.Assert(optMethod != null);
// now we set some method parameters for the optimization method
// iteration limit
CCopasiParameter parameter = optMethod.getParameter("Iteration Limit");
Debug.Assert(parameter != null);
parameter.setIntValue(2000);
// tolerance
parameter = optMethod.getParameter("Tolerance");
Debug.Assert(parameter != null);
parameter.setDblValue(1.0e-5);
// create a report with the correct filename and all the species against
// time.
CReportDefinitionVector reports = dataModel.getReportDefinitionList();
// create a new report definition object
CReportDefinition report = reports.createReportDefinition("Report", "Output for optimization");
// set the task type for the report definition to timecourse
report.setTaskType(CTaskEnum.optimization);
// we don't want a table
report.setIsTable(false);
// the entries in the output should be seperated by a ", "
report.setSeparator(new CCopasiReportSeparator(", "));
// we need a handle to the header and the body
// the header will display the ids of the metabolites and "time" for
// the first column
// the body will contain the actual timecourse data
ReportItemVector header = report.getHeaderAddr();
ReportItemVector body = report.getBodyAddr();
// in the report header we write two strings and a separator
header.Add(new CRegisteredObjectName(new CCopasiStaticString("best value of objective function").getCN().getString()));
header.Add(new CRegisteredObjectName(report.getSeparator().getCN().getString()));
header.Add(new CRegisteredObjectName(new CCopasiStaticString("initial value of F").getCN().getString()));
// in the report body we write the best value of the objective function and
// the initial value of the fixed parameter separated by a komma
body.Add(new CRegisteredObjectName(optProblem.getObject(new CCopasiObjectName("Reference=Best Value")).getCN().getString()));
body.Add(new CRegisteredObjectName(report.getSeparator().getCN().getString()));
body.Add(new CRegisteredObjectName(fixedModelValue.getObject(new CCopasiObjectName("Reference=InitialValue")).getCN().getString()));
// set the report for the task
optTask.getReport().setReportDefinition(report);
// set the output filename
optTask.getReport().setTarget("example5.txt");
// don't append output if the file exists, but overwrite the file
optTask.getReport().setAppend(false);
bool result = false;
try
{
result = optTask.processWithOutputFlags(true, (int)CCopasiTask.ONLY_TIME_SERIES);
}
catch (System.ApplicationException e)
{
System.Console.Error.WriteLine("ERROR: " + e.Message);
String lastErrors = optTask.getProcessError();
// check if there are additional error messages
if (!string.IsNullOrEmpty(lastErrors))
{
// print the messages in chronological order
System.Console.Error.WriteLine(lastErrors);
}
System.Environment.Exit(1);
}
if (!result)
{
System.Console.Error.WriteLine("Running the optimization failed.");
String lastErrors = optTask.getProcessError();
// check if there are additional error messages
if (!string.IsNullOrEmpty(lastErrors))
{
// print the messages in chronological order
System.Console.Error.WriteLine(lastErrors);
}
System.Environment.Exit(1);
}
// now we check if the optimization actually got the correct result
// the best value it should have is 0 and the best parameter value for
// that result should be 6 for the initial value of the fixed parameter
double bestValue = optProblem.getSolutionValue();
Debug.Assert(System.Math.Abs(bestValue) < 1e-3);
// we should only have one solution variable since we only have one
// optimization item
Debug.Assert(optProblem.getSolutionVariables().size() == 1);
double solution = optProblem.getSolutionVariables().get(0);
Debug.Assert(System.Math.Abs((solution - 6.0) / 6.0) < 1e-3);
}
static void Main(string[] args)
{
Debug.Assert(CRootContainer.getRoot() != null);
// create a new datamodel
CDataModel dataModel = CRootContainer.addDatamodel();
Debug.Assert(CRootContainer.getDatamodelList().size() == 1);
// first we load a simple model
try
{
// load the model
dataModel.importSBMLFromString(MODEL_STRING);
}
catch
{
System.Console.Error.WriteLine("Error while importing the model.");
System.Environment.Exit(1);
}
// now we need to run some time course simulation to get data to fit
// against
// get the trajectory task object
CTrajectoryTask trajectoryTask = (CTrajectoryTask)dataModel.getTask("Time-Course");
// run a deterministic time course
trajectoryTask.setMethodType(CTaskEnum.Method_deterministic);
// pass a pointer of the model to the problem
trajectoryTask.getProblem().setModel(dataModel.getModel());
// activate the task so that it will be run when the model is saved
// and passed to CopasiSE
trajectoryTask.setScheduled(true);
// get the problem for the task to set some parameters
CTrajectoryProblem problem = (CTrajectoryProblem)trajectoryTask.getProblem();
// simulate 4000 steps
problem.setStepNumber(4000);
// start at time 0
dataModel.getModel().setInitialTime(0.0);
// simulate a duration of 400 time units
problem.setDuration(400);
// tell the problem to actually generate time series data
problem.setTimeSeriesRequested(true);
// set some parameters for the LSODA method through the method
// Currently we don't use the method to set anything
//CTrajectoryMethod method = (CTrajectoryMethod)trajectoryTask.getMethod();
bool result = true;
try
{
// now we run the actual trajectory
result = trajectoryTask.processWithOutputFlags(true, (int)CCopasiTask.ONLY_TIME_SERIES);
}
catch
{
System.Console.Error.WriteLine("Error. Running the time course simulation failed.");
String lastErrors = trajectoryTask.getProcessError();
// check if there are additional error messages
if (!string.IsNullOrEmpty(lastErrors))
{
// print the messages in chronological order
System.Console.Error.WriteLine(lastErrors);
}
System.Environment.Exit(1);
}
if (result == false)
{
System.Console.Error.WriteLine("An error occured while running the time course simulation.");
String lastErrors = trajectoryTask.getProcessError();
// check if there are additional error messages
if (!string.IsNullOrEmpty(lastErrors))
{
// print the messages in chronological order
System.Console.Error.WriteLine(lastErrors);
}
System.Environment.Exit(1);
}
// we write the data to a file and add some noise to it
// This is necessary since COPASI can only read experimental data from
// file.
CTimeSeries timeSeries = trajectoryTask.getTimeSeries();
// we simulated 100 steps, including the initial state, this should be
// 101 step in the timeseries
Debug.Assert(timeSeries.getRecordedSteps() == 4001);
uint i;
uint iMax = (uint)timeSeries.getNumVariables();
// there should be four variables, the three metabolites and time
Debug.Assert(iMax == 5);
uint lastIndex = (uint)timeSeries.getRecordedSteps() - 1;
// open the file
// we need to remember in which order the variables are written to file
// since we need to specify this later in the parameter fitting task
List <uint> indexSet = new List <uint>();
List <CMetab> metabVector = new List <CMetab>();
// write the header
// the first variable in a time series is a always time, for the rest
// of the variables, we use the SBML id in the header
double random = 0.0;
System.Random rand_gen = new System.Random();
try
{
System.IO.StreamWriter os = new System.IO.StreamWriter("fakedata_example6.txt");
os.Write("# time ");
CKeyFactory keyFactory = CRootContainer.getKeyFactory();
Debug.Assert(keyFactory != null);
for (i = 1; i < iMax; ++i)
{
string key = timeSeries.getKey(i);
CDataObject obj = keyFactory.get(key);
Debug.Assert(obj != null);
// only write header data or metabolites
System.Type type = obj.GetType();
if (type.FullName.Equals("org.COPASI.CMetab"))
{
os.Write(", ");
os.Write(timeSeries.getSBMLId(i, dataModel));
CMetab m = (CMetab)obj;
indexSet.Add(i);
metabVector.Add(m);
}
}
os.Write("\n");
double data = 0.0;
for (i = 0; i < lastIndex; ++i)
{
uint j;
string s = "";
for (j = 0; j < iMax; ++j)
{
// we only want to write the data for metabolites
// the compartment does not interest us here
if (j == 0 || indexSet.Contains(j))
{
// write the data with some noise (+-5% max)
random = rand_gen.NextDouble();
data = timeSeries.getConcentrationData(i, j);
// don't add noise to the time
if (j != 0)
{
data += data * (random * 0.1 - 0.05);
}
s = s + (System.Convert.ToString(data));
s = s + ", ";
}
}
// remove the last two characters again
os.Write(s.Substring(0, s.Length - 2));
os.Write("\n");
}
os.Close();
}
catch (System.ApplicationException e)
{
System.Console.Error.WriteLine("Error. Could not write time course data to file.");
System.Console.WriteLine(e.Message);
System.Environment.Exit(1);
}
// now we change the parameter values to see if the parameter fitting
// can really find the original values
random = rand_gen.NextDouble() * 10;
CReaction reaction = dataModel.getModel().getReaction(0);
// we know that it is an irreversible mass action, so there is one
// parameter
Debug.Assert(reaction.getParameters().size() == 1);
Debug.Assert(reaction.isLocalParameter(0));
// the parameter of a irreversible mass action is called k1
reaction.setParameterValue("k1", random);
reaction = dataModel.getModel().getReaction(1);
// we know that it is an irreversible mass action, so there is one
// parameter
Debug.Assert(reaction.getParameters().size() == 1);
Debug.Assert(reaction.isLocalParameter(0));
reaction.setParameterValue("k1", random);
CFitTask fitTask = (CFitTask)dataModel.addTask(CTaskEnum.Task_parameterFitting);
Debug.Assert(fitTask != null);
// the method in a fit task is an instance of COptMethod or a subclass of
// it.
COptMethod fitMethod = (COptMethod)fitTask.getMethod();
Debug.Assert(fitMethod != null);
// the object must be an instance of COptMethod or a subclass thereof
// (CFitMethod)
CFitProblem fitProblem = (CFitProblem)fitTask.getProblem();
Debug.Assert(fitProblem != null);
CExperimentSet experimentSet = (CExperimentSet)fitProblem.getParameter("Experiment Set");
Debug.Assert(experimentSet != null);
// first experiment (we only have one here)
CExperiment experiment = new CExperiment(dataModel);
Debug.Assert(experiment != null);
// tell COPASI where to find the data
// reading data from string is not possible with the current C++ API
experiment.setFileName("fakedata_example6.txt");
// we have to tell COPASI that the data for the experiment is a komma
// separated list (the default is TAB separated)
experiment.setSeparator(",");
// the data start in row 1 and goes to row 4001
experiment.setFirstRow(1);
Debug.Assert(experiment.getFirstRow() == 1);
experiment.setLastRow(4001);
Debug.Assert(experiment.getLastRow() == 4001);
experiment.setHeaderRow(1);
Debug.Assert(experiment.getHeaderRow() == 1);
experiment.setExperimentType(CTaskEnum.Task_timeCourse);
Debug.Assert(experiment.getExperimentType() == CTaskEnum.Task_timeCourse);
experiment.setNumColumns(4);
Debug.Assert(experiment.getNumColumns() == 4);
CExperimentObjectMap objectMap = experiment.getObjectMap();
Debug.Assert(objectMap != null);
result = objectMap.setNumCols(4);
Debug.Assert(result == true);
result = objectMap.setRole(0, CExperiment.time);
Debug.Assert(result == true);
Debug.Assert(objectMap.getRole(0) == CExperiment.time);
CModel model = dataModel.getModel();
Debug.Assert(model != null);
CDataObject timeReference = model.getValueReference();
Debug.Assert(timeReference != null);
objectMap.setObjectCN(0, timeReference.getCN().getString());
// now we tell COPASI which column contain the concentrations of
// metabolites and belong to dependent variables
objectMap.setRole(1, CExperiment.dependent);
CMetab metab = metabVector[0];
Debug.Assert(metab != null);
CDataObject particleReference = metab.getConcentrationReference();
Debug.Assert(particleReference != null);
objectMap.setObjectCN(1, particleReference.getCN().getString());
objectMap.setRole(2, CExperiment.dependent);
metab = metabVector[1];
Debug.Assert(metab != null);
particleReference = metab.getConcentrationReference();
Debug.Assert(particleReference != null);
objectMap.setObjectCN(2, particleReference.getCN().getString());
objectMap.setRole(3, CExperiment.dependent);
metab = metabVector[2];
Debug.Assert(metab != null);
particleReference = metab.getConcentrationReference();
Debug.Assert(particleReference != null);
objectMap.setObjectCN(3, particleReference.getCN().getString());
experimentSet.addExperiment(experiment);
Debug.Assert(experimentSet.getExperimentCount() == 1);
// addExperiment makes a copy, so we need to get the added experiment
// again
experiment = experimentSet.getExperiment(0);
Debug.Assert(experiment != null);
// now we have to define the two fit items for the two local parameters
// of the two reactions
reaction = model.getReaction(0);
Debug.Assert(reaction != null);
Debug.Assert(reaction.isLocalParameter(0) == true);
CCopasiParameter parameter = reaction.getParameters().getParameter(0);
Debug.Assert(parameter != null);
// define a CFitItem
CDataObject parameterReference = parameter.getValueReference();
Debug.Assert(parameterReference != null);
CFitItem fitItem1 = new CFitItem(dataModel);
Debug.Assert(fitItem1 != null);
fitItem1.setObjectCN(parameterReference.getCN());
fitItem1.setStartValue(4.0);
fitItem1.setLowerBound(new CCommonName("0.00001"));
fitItem1.setUpperBound(new CCommonName("10"));
// add the fit item to the correct parameter group
CCopasiParameterGroup optimizationItemGroup = (CCopasiParameterGroup)fitProblem.getParameter("OptimizationItemList");
Debug.Assert(optimizationItemGroup != null);
optimizationItemGroup.addParameter(fitItem1);
reaction = model.getReaction(1);
Debug.Assert(reaction != null);
Debug.Assert(reaction.isLocalParameter(0) == true);
parameter = reaction.getParameters().getParameter(0);
Debug.Assert(parameter != null);
// define a CFitItem
parameterReference = parameter.getValueReference();
Debug.Assert(parameterReference != null);
CFitItem fitItem2 = new CFitItem(dataModel);
Debug.Assert(fitItem2 != null);
fitItem2.setObjectCN(parameterReference.getCN());
fitItem2.setStartValue(4.0);
fitItem2.setLowerBound(new CCommonName("0.00001"));
fitItem2.setUpperBound(new CCommonName("10"));
// add the fit item to the correct parameter group
optimizationItemGroup.addParameter(fitItem2);
result = true;
try
{
// running the task for this example will probably take some time
System.Console.WriteLine("This can take some time...");
result = fitTask.processWithOutputFlags(true, (int)CCopasiTask.ONLY_TIME_SERIES);
}
catch
{
System.Console.Error.WriteLine("Error. Parameter fitting failed.");
String lastErrors = fitTask.getProcessError();
// check if there are additional error messages
if (!string.IsNullOrEmpty(lastErrors))
{
// print the messages in chronological order
System.Console.Error.WriteLine(lastErrors);
}
System.Environment.Exit(1);
}
Debug.Assert(result == true);
// assert that there are two optimization items
Debug.Assert(fitProblem.getOptItemList().Count == 2);
// the order should be the order in whih we added the items above
COptItem optItem1 = fitProblem.getOptItemList()[0];
COptItem optItem2 = fitProblem.getOptItemList()[1];
// the actual results are stored in the fit problem
Debug.Assert(fitProblem.getSolutionVariables().size() == 2);
System.Console.WriteLine("value for " + optItem1.getObject().getCN().getString() + ": " + fitProblem.getSolutionVariables().get(0));
System.Console.WriteLine("value for " + optItem2.getObject().getCN().getString() + ": " + fitProblem.getSolutionVariables().get(1));
// depending on the noise, the fit can be quite bad, so we are a litle
// relaxed here (we should be within 3% of the original values)
Debug.Assert((System.Math.Abs(fitProblem.getSolutionVariables().get(0) - 0.03) / 0.03) < 3e-2);
Debug.Assert((System.Math.Abs(fitProblem.getSolutionVariables().get(1) - 0.004) / 0.004) < 3e-2);
}