/**
* Creates the simulations for SEDML.
*/
std::string CSEDMLExporter::createTimeCourseTask(CCopasiDataModel& dataModel, const std::string & modelId)
{
mpTimecourse = this->mpSEDMLDocument->createUniformTimeCourse();
mpTimecourse->setId(SEDMLUtils::getNextId("sim", mpSEDMLDocument->getNumSimulations()));
//presently SEDML only supports time course
CCopasiTask* pTask = (*dataModel.getTaskList())["Time-Course"];
CTrajectoryProblem* tProblem = static_cast<CTrajectoryProblem*>(pTask->getProblem());
mpTimecourse->setInitialTime(0.0);
mpTimecourse->setOutputStartTime(tProblem->getOutputStartTime());
mpTimecourse->setOutputEndTime(tProblem->getStepNumber()*tProblem->getStepSize());
mpTimecourse->setNumberOfPoints(tProblem->getStepNumber());
// set the correct KISAO Term
SedAlgorithm* alg = mpTimecourse->createAlgorithm();
if (pTask->getMethod()->getObjectName().find("Stochastic") != std::string::npos)
alg->setKisaoID("KISAO:0000241");
else
alg->setKisaoID("KISAO:0000019");
mpTimecourseTask = this->mpSEDMLDocument->createTask();
std::string taskId = SEDMLUtils::getNextId("task", mpSEDMLDocument->getNumTasks());
mpTimecourseTask->setId(taskId);
mpTimecourseTask->setSimulationReference(mpTimecourse->getId());
mpTimecourseTask->setModelReference(modelId);
return taskId;
}
bool CQTrajectoryWidget::loadTask()
{
CTrajectoryTask * pTask =
dynamic_cast< CTrajectoryTask * >(mpTask);
if (!pTask) return false;
loadCommon();
loadMethod();
showUnits();
CTrajectoryProblem* trajectoryproblem =
dynamic_cast<CTrajectoryProblem *>(pTask->getProblem());
assert(trajectoryproblem);
pdelete(mpTrajectoryProblem);
mpTrajectoryProblem = new CTrajectoryProblem(*trajectoryproblem);
//numbers
mpEditIntervalSize->setText(QString::number(trajectoryproblem->getStepSize()));
mpEditIntervals->setText(QString::number(trajectoryproblem->getStepNumber()));
mpEditDuration->setText(QString::number(trajectoryproblem->getDuration()));
assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
C_FLOAT64 InitialTime = (*CCopasiRootContainer::getDatamodelList())[0]->getModel()->getInitialTime();
bool Delayed;
if (trajectoryproblem->getStepSize() > 0.0)
Delayed = (trajectoryproblem->getOutputStartTime() - InitialTime) > std::numeric_limits< C_FLOAT64 >::min();
else
Delayed = (InitialTime - trajectoryproblem->getOutputStartTime()) > std::numeric_limits< C_FLOAT64 >::min();
mpCheckDelay->setChecked(Delayed);
mpEditDelay->setEnabled(Delayed);
mpEditDelay->setText(QString::number(trajectoryproblem->getOutputStartTime()));
mpCheckOutputEvent->setChecked(trajectoryproblem->getOutputEvent());
//store time series checkbox
mpCheckSave->setChecked(trajectoryproblem->timeSeriesRequested());
checkTimeSeries();
updateIntervals();
mpValidatorDuration->saved();
mpValidatorIntervalSize->saved();
mpValidatorIntervals->saved();
mpValidatorDelay->saved();
return true;
}
bool CQTrajectoryWidget::saveTask()
{
CTrajectoryTask * pTask =
dynamic_cast< CTrajectoryTask * >(mpTask);
if (!pTask) return false;
saveCommon();
saveMethod();
CTrajectoryProblem* trajectoryproblem =
dynamic_cast<CTrajectoryProblem *>(pTask->getProblem());
assert(trajectoryproblem);
//numbers
if (mpEditIntervalSize->hasAcceptableInput() &&
trajectoryproblem->getStepSize() != mpEditIntervalSize->text().toDouble())
{
trajectoryproblem->setStepSize(mpEditIntervalSize->text().toDouble());
mChanged = true;
}
else if (mpEditIntervals->hasAcceptableInput() &&
trajectoryproblem->getStepNumber() != mpEditIntervals->text().toULong())
{
trajectoryproblem->setStepNumber(mpEditIntervals->text().toLong());
mChanged = true;
}
if (mpEditDuration->hasAcceptableInput() &&
trajectoryproblem->getDuration() != mpEditDuration->text().toDouble())
{
trajectoryproblem->setDuration(mpEditDuration->text().toDouble());
mChanged = true;
}
C_FLOAT64 StartTime = mpEditDelay->text().toDouble();
if (mpCheckDelay->isChecked())
{
if (mpEditDelay->hasAcceptableInput() &&
StartTime != trajectoryproblem->getOutputStartTime())
{
trajectoryproblem->setOutputStartTime(StartTime);
mChanged = true;
}
}
else
{
assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
C_FLOAT64 InitialTime =
(*CCopasiRootContainer::getDatamodelList())[0]->getModel()->getInitialTime();
if (trajectoryproblem->getStepSize() > 0.0)
{
if (StartTime > InitialTime)
{
trajectoryproblem->setOutputStartTime(InitialTime);
mChanged = true;
}
}
else
{
if (StartTime < InitialTime)
{
trajectoryproblem->setOutputStartTime(InitialTime);
mChanged = true;
}
}
}
if (trajectoryproblem->timeSeriesRequested() != mpCheckSave->isChecked())
{
trajectoryproblem->setTimeSeriesRequested(mpCheckSave->isChecked());
mChanged = true;
}
mpValidatorDuration->saved();
mpValidatorIntervalSize->saved();
mpValidatorIntervals->saved();
mpValidatorDelay->saved();
return true;
}
int main(int argc, char *argv[])
{
// Parse the commandline options
// first argument is the SBML filename
// second argument is the endtime
// third argument is the step number
// fourth argument is the filename where the results are to be written
// fifth argument is the tmp directory (this is not needed)
// the rest of the arguments are species names for the result
try
{
// Create the root container.
CCopasiRootContainer::init(0, NULL, false);
}
catch (copasi::autoexcept &e)
{}
catch (copasi::option_error &e)
{}
if (argc < 5)
{
std::cout << "Usage: semantic-test-suite SBMLFILENAME ENDTIME STEPNUMBER OUTFILENAME TMPDIR SPECIESID1 SPECIESID2 ..." << std::endl;
exit(1);
}
char* pSBMLFilename = argv[1];
const char* pEndTime = argv[2];
const char* pStepNumber = argv[3];
char* pOutputFilename = argv[4];
//char* pTmpDirectory=argv[5];
char** pSBMLSpeciesIds = new char * [argc - 6];
unsigned int i, iMax = argc;
CTrajectoryTask* pTrajectoryTask = NULL;
std::string CWD = COptions::getPWD();
double endTime = strToDouble(pEndTime, &pEndTime);
double stepNumber = strToDouble(pStepNumber, &pStepNumber);
if (endTime == 0.0)
{
std::cerr << "Invalid endtime " << pEndTime << std::endl;
exit(1);
}
if (stepNumber == 0.0)
{
std::cerr << "Invalid step number " << pStepNumber << std::endl;
exit(1);
}
for (i = 6; i < iMax; ++i)
{
pSBMLSpeciesIds[i - 6] = argv[i];
//std::cout << "Copying pointer to " << argv[i] << "." << std::endl;
}
try
{
// Create the global data model.
CCopasiDataModel* pDataModel = CCopasiRootContainer::addDatamodel();
// Import the SBML File
pDataModel->importSBML(pSBMLFilename);
//pDataModel->getModel()->forceCompile();
// create a report with the correct filename and all the species against
// time.
CReportDefinitionVector* pReports = pDataModel->getReportDefinitionList();
CReportDefinition* pReport = pReports->createReportDefinition("Report", "Output for SBML testsuite run");
pReport->setTaskType(CCopasiTask::timeCourse);
pReport->setIsTable(true);
std::vector<CRegisteredObjectName>* pTable = pReport->getTableAddr();
pTable->push_back(CCopasiObjectName(pDataModel->getModel()->getCN() + ",Reference=Time"));
iMax = iMax - 6;
const CCopasiVector<CMetab>& metabolites = pDataModel->getModel()->getMetabolites();
for (i = 0; i < iMax; ++i)
{
unsigned int j, jMax = metabolites.size();
for (j = 0; j < jMax; ++j)
{
if (metabolites[j]->getSBMLId() == pSBMLSpeciesIds[i])
{
pTable->push_back(metabolites[j]->getObject(CCopasiObjectName("Reference=Concentration"))->getCN());
//std::cout << "adding metabolite " << metabolites[j]->getObjectName() << " to report." << std::endl;
break;
}
}
if (j == jMax)
{
std::cerr << "Could not find a metabolite for the SBML id " << pSBMLSpeciesIds[i] << std::endl;
exit(1);
}
}
// create a trajectory task
pTrajectoryTask = new CTrajectoryTask();
pTrajectoryTask->getProblem()->setModel(pDataModel->getModel());
pTrajectoryTask->setScheduled(true);
pTrajectoryTask->getReport().setReportDefinition(pReport);
pTrajectoryTask->getReport().setTarget(CWD + "/" + pOutputFilename);
pTrajectoryTask->getReport().setAppend(false);
CTrajectoryProblem* pProblem = dynamic_cast<CTrajectoryProblem*>(pTrajectoryTask->getProblem());
pProblem->setStepNumber((const unsigned C_INT32)stepNumber);
pProblem->setDuration((const C_FLOAT64)endTime);
pProblem->setTimeSeriesRequested(true);
//pProblem->setInitialState(pDataModel->getModel()->getInitialState());
CTrajectoryMethod* pMethod = dynamic_cast<CTrajectoryMethod*>(pTrajectoryTask->getMethod());
pMethod->getParameter("Absolute Tolerance")->setValue(1.0e-20);
CCopasiVectorN< CCopasiTask > & TaskList = * pDataModel->getTaskList();
TaskList.remove("Time-Course");
TaskList.add(pTrajectoryTask, true);
// save the file for control purposes
std::string saveFilename = pSBMLFilename;
saveFilename = saveFilename.substr(0, saveFilename.length() - 4) + ".cps";
pDataModel->saveModel(saveFilename, NULL, true);
// Run the trajectory task
pTrajectoryTask->initialize(CCopasiTask::OUTPUT_UI, pDataModel, NULL);
pTrajectoryTask->process(true);
pTrajectoryTask->restore();
// create another report that will write to the directory where the input file came from
// this can be used for debugging
// create a trajectory task
pTrajectoryTask->getReport().setTarget(pOutputFilename);
pTrajectoryTask->initialize(CCopasiTask::OUTPUT_UI, pDataModel, NULL);
pTrajectoryTask->process(true);
pTrajectoryTask->restore();
}
catch (CCopasiException Exception)
{
std::cerr << Exception.getMessage().getText() << std::endl;
}
CCopasiRootContainer::destroy();
return 0;
}
void test000087::test_simulate_reaction_flux_reference_1()
{
try
{
bool result = pCOPASIDATAMODEL->importSBMLFromString(test000087::MODEL_STRING5);
CPPUNIT_ASSERT(result = true);
}
catch (...)
{
// there should be no exception
CPPUNIT_ASSERT(false);
}
CModel* pModel = pCOPASIDATAMODEL->getModel();
CPPUNIT_ASSERT(pModel != NULL);
CPPUNIT_ASSERT(pModel->getCompartments().size() == 1);
CPPUNIT_ASSERT(pModel->getMetabolites().size() == 2);
CPPUNIT_ASSERT(pModel->getModelValues().size() == 2);
CPPUNIT_ASSERT(pModel->getReactions().size() == 1);
const CReaction* pReaction = pModel->getReactions()[0];
CPPUNIT_ASSERT(pReaction != NULL);
CModelValue* pConstParameter = NULL;
CModelValue* pNonConstParameter = NULL;
unsigned int i, iMax = pModel->getModelValues().size();
for (i = 0; i < iMax; ++i)
{
if (pModel->getModelValues()[i]->getStatus() == CModelEntity::FIXED)
{
pConstParameter = pModel->getModelValues()[i];
}
if (pModel->getModelValues()[i]->getStatus() == CModelEntity::ASSIGNMENT)
{
pNonConstParameter = pModel->getModelValues()[i];
}
}
CPPUNIT_ASSERT(pConstParameter != NULL);
CPPUNIT_ASSERT(pNonConstParameter != NULL);
// check if the kinetic law is mass action with const global parameter as the kinetic constant
CPPUNIT_ASSERT(pReaction->getChemEq().getSubstrates().size() == 1);
CPPUNIT_ASSERT(pReaction->getChemEq().getProducts().size() == 1);
CPPUNIT_ASSERT(pReaction->getChemEq().getModifiers().size() == 0);
CPPUNIT_ASSERT(pReaction->isReversible() == false);
const CFunction* pKineticLaw = pReaction->getFunction();
CPPUNIT_ASSERT(pKineticLaw != NULL);
CPPUNIT_ASSERT(pKineticLaw->getType() == CEvaluationTree::MassAction);
const std::vector< std::vector<std::string> > & parameterMappings = pReaction->getParameterMappings();
CPPUNIT_ASSERT(parameterMappings.size() == 2);
CPPUNIT_ASSERT(parameterMappings[0].size() == 1);
CPPUNIT_ASSERT(parameterMappings[0][0] == pConstParameter->getKey());
CPPUNIT_ASSERT(parameterMappings[1].size() == 1);
std::string substrateKey = parameterMappings[1][0];
const CCopasiObject* pTempObject = CCopasiRootContainer::getKeyFactory()->get(substrateKey);
CPPUNIT_ASSERT(pTempObject != NULL);
const CMetab* pSubstrate = dynamic_cast<const CMetab*>(pTempObject);
CPPUNIT_ASSERT(pSubstrate != NULL);
// check that the assignment consists of only one object node that is a reference to the reaction flux
const CExpression* pExpression = pNonConstParameter->getExpressionPtr();
CPPUNIT_ASSERT(pExpression != NULL);
const CEvaluationNode* pRoot = pExpression->getRoot();
CPPUNIT_ASSERT(pRoot != NULL);
CPPUNIT_ASSERT(CEvaluationNode::type(pRoot->getType()) == CEvaluationNode::OBJECT);
const CEvaluationNodeObject* pObjectNode = dynamic_cast<const CEvaluationNodeObject*>(pRoot);
CPPUNIT_ASSERT(pObjectNode != NULL);
const CRegisteredObjectName cn = pObjectNode->getObjectCN();
std::vector<CCopasiContainer*> listOfContainers;
listOfContainers.push_back(pCOPASIDATAMODEL->getModel());
const CCopasiObject* pObject = pCOPASIDATAMODEL->ObjectFromName(listOfContainers, cn);
CPPUNIT_ASSERT(pObject != NULL);
CPPUNIT_ASSERT(pObject->isReference() == true);
CPPUNIT_ASSERT(pObject->getObjectName() == "Flux");
CPPUNIT_ASSERT(pObject->getObjectParent() == pReaction);
// Simulate the model (5 steps, stepsize 1 and check that at each step, the value of the variable parameter
// is the same as the flux through the reaction.
std::ostringstream result;
// create a report with the correct filename and all the species against
// time.
CReportDefinitionVector* pReports = pCOPASIDATAMODEL->getReportDefinitionList();
CReportDefinition* pReport = pReports->createReportDefinition("Report", "Output for simulation");
pReport->setTaskType(CCopasiTask::timeCourse);
pReport->setIsTable(false);
pReport->setSeparator(CCopasiReportSeparator(", "));
std::vector<CRegisteredObjectName>* pHeader = pReport->getHeaderAddr();
std::vector<CRegisteredObjectName>* pBody = pReport->getBodyAddr();
pHeader->push_back(CCopasiStaticString("time").getCN());
pHeader->push_back(pReport->getSeparator().getCN());
pHeader->push_back(CCopasiStaticString("substrate").getCN());
pHeader->push_back(pReport->getSeparator().getCN());
pHeader->push_back(CCopasiStaticString("reaction flux").getCN());
pHeader->push_back(pReport->getSeparator().getCN());
pHeader->push_back(CCopasiStaticString("variable model value").getCN());
pBody->push_back(CCopasiObjectName(pCOPASIDATAMODEL->getModel()->getCN() + ",Reference=Time"));
pBody->push_back(CRegisteredObjectName(pReport->getSeparator().getCN()));
pBody->push_back(CCopasiObjectName(pSubstrate->getCN() + ",Reference=Concentration"));
pBody->push_back(CRegisteredObjectName(pReport->getSeparator().getCN()));
pBody->push_back(CCopasiObjectName(pReaction->getCN() + ",Reference=Flux"));
pBody->push_back(CRegisteredObjectName(pReport->getSeparator().getCN()));
pBody->push_back(CCopasiObjectName(pNonConstParameter->getCN() + ",Reference=Value"));
//
// create a trajectory task
CTrajectoryTask* pTrajectoryTask = new CTrajectoryTask();
// use LSODAR from now on since we will have events pretty soon
pTrajectoryTask->setMethodType(CCopasiMethod::LSODAR);
pTrajectoryTask->getProblem()->setModel(pCOPASIDATAMODEL->getModel());
pTrajectoryTask->setScheduled(true);
pTrajectoryTask->getReport().setReportDefinition(pReport);
// the target needs to be set in order to get output on the stream
// object passed to the task in the call to initialize below
pTrajectoryTask->getReport().setTarget("test.tmp");
CTrajectoryProblem* pProblem = dynamic_cast<CTrajectoryProblem*>(pTrajectoryTask->getProblem());
pProblem->setStepNumber((const unsigned C_INT32)30);
pCOPASIDATAMODEL->getModel()->setInitialTime((const C_FLOAT64)0.0);
pProblem->setDuration((const C_FLOAT64)30);
pProblem->setTimeSeriesRequested(true);
CTrajectoryMethod* pMethod = dynamic_cast<CTrajectoryMethod*>(pTrajectoryTask->getMethod());
pMethod->getParameter("Absolute Tolerance")->setValue(1.0e-12);
CCopasiVectorN< CCopasiTask > & TaskList = * pCOPASIDATAMODEL->getTaskList();
TaskList.remove("Time-Course");
TaskList.add(pTrajectoryTask, true);
try
{
pTrajectoryTask->initialize(CCopasiTask::OUTPUT_UI, pCOPASIDATAMODEL, &result);
pTrajectoryTask->process(true);
pTrajectoryTask->restore();
}
catch (...)
{
// there should be no exception
CPPUNIT_ASSERT(false);
}
// analyse the result
CPPUNIT_ASSERT(!result.str().empty());
std::string result_string = result.str();
std::string delimiter = "\n";
std::string delimiter2 = ",";
std::size_t lastPos = result_string.find_first_not_of(delimiter);
std::size_t pos;
std::string line, number_string;
unsigned int index = 0;
unsigned int index2;
std::size_t lastPos2;
std::size_t pos2;
double last = std::numeric_limits<double>::max(), current = std::numeric_limits<double>::max();
while (lastPos != std::string::npos)
{
pos = result_string.find_first_of(delimiter, lastPos);
line = result_string.substr(lastPos, pos - lastPos);
lastPos = result_string.find_first_not_of(delimiter, pos);
lastPos2 = line.find_first_not_of(delimiter2);
// skip the header line
if (index != 0)
{
index2 = 0;
while (lastPos2 != std::string::npos)
{
pos2 = line.find_first_of(delimiter2, lastPos2);
number_string = line.substr(lastPos2, pos2 - lastPos2);
lastPos2 = line.find_first_not_of(delimiter2, pos2);
// skip the time column
if (index2 != 0)
{
//check that all values in the row (besides the time)
// are always the same
if (index2 == 1)
{
last = strToDouble(number_string.c_str(), NULL);
if (index == 1)
{
// just make sure that we don't compare all zeros
// The initial value of the substrate hould be higher than 1
CPPUNIT_ASSERT(fabs(pSubstrate->getInitialValue()) > 1);
// the first rwo should correspond the the initial value of the substrate
// We check this to make sure that the whole timeseries does not consist of zeros
CPPUNIT_ASSERT(fabs((last - pSubstrate->getInitialConcentration()) / pSubstrate->getInitialConcentration()) < 1e-20);
}
}
else
{
current = strToDouble(number_string.c_str(), NULL);
CPPUNIT_ASSERT(fabs((current - last) / last) < 1e-20);
last = current;
}
}
++index2;
}
}
++index;
}
// make sure there actually were datapoints
CPPUNIT_ASSERT(index > 1);
// the simulation is set to run until all substrate is depleted, so in the end
// last should be below the absolute tolerance for the simulation
CPPUNIT_ASSERT(last < *pMethod->getParameter("Absolute Tolerance")->getValue().pDOUBLE);
}
int main(int argc, char *argv[])
{
// Parse the commandline options
// first argument is the SBML filename
// second argument is the endtime
// third argument is the step number
// fourth argument is the filename where the results are to be written
// fifth argument is the tmp directory (this is not needed)
// the rest of the arguments are species names for the result
try
{
// Create the root container.
CCopasiRootContainer::init(0, NULL, false);
}
catch (copasi::autoexcept &e)
{}
catch (copasi::option_error &e)
{}
if (argc < 5)
{
std::cout << "Usage: stochastic-testsuite METHOD SBMLFILENAME ENDTIME STEPNUMBER REPEATS OUTFILENAME SPECIESID1 SPECIESID2 ..." << std::endl;
exit(1);
}
const char* pMethodType = argv[1];
const char* pSBMLFilename = argv[2];
const char* pEndTime = argv[3];
const char* pStepNumber = argv[4];
const char* pRepeats = argv[5];
const char* pOutputFilename = argv[6];
unsigned int NUMARGS = 7;
/*
std::cout << "Input : " << pSBMLFilename << std::endl;
std::cout << "Endtime : " << pEndTime << std::endl;
std::cout << "Stepnumber: " << pStepNumber << std::endl;
std::cout << "Repeats : " << pRepeats << std::endl;
std::cout << "Output file: " << pOutputFilename << std::endl;
*/
char** pSBMLSpeciesIds = new char * [argc - NUMARGS];
unsigned int i, iMax = argc;
CTrajectoryTask* pTrajectoryTask = NULL;
CScanTask* pScanTask = NULL;
std::string CWD = COptions::getPWD();
double endTime = strToDouble(pEndTime, &pEndTime);
double stepNumber = strToDouble(pStepNumber, &pStepNumber);
char** pTmpP = (char**)(&pRepeats);
long int repeats = strtol(pRepeats, pTmpP , 10);
CCopasiMethod::SubType MethodType;
if (!strcmp(pMethodType, "stochastic"))
{
MethodType = CCopasiMethod::stochastic;
}
else if (!strcmp(pMethodType, "directMethod"))
{
MethodType = CCopasiMethod::directMethod;
}
else if (!strcmp(pMethodType, "tauLeap"))
{
MethodType = CCopasiMethod::tauLeap;
}
else if (!strcmp(pMethodType, "adaptiveSA"))
{
MethodType = CCopasiMethod::adaptiveSA;
}
else if (!strcmp(pMethodType, "LSODA"))
{
MethodType = CCopasiMethod::deterministic;
}
else
{
std::cerr << "Invalid method type. Valid options are:" << std::endl;
std::cerr << " stochastic" << std::endl;
std::cerr << " directMethod" << std::endl;
std::cerr << " tauLeap" << std::endl;
}
if (endTime == 0.0)
{
std::cerr << "Invalid endtime " << pEndTime << std::endl;
exit(1);
}
if (stepNumber == 0.0)
{
std::cerr << "Invalid step number " << pStepNumber << std::endl;
exit(1);
}
for (i = NUMARGS; i < iMax; ++i)
{
pSBMLSpeciesIds[i - NUMARGS] = argv[i];
//std::cout << "Copying pointer to " << argv[i] << "." << std::endl;
}
try
{
// Create the global data model.
CCopasiDataModel* pDataModel = CCopasiRootContainer::addDatamodel();
// Import the SBML File
pDataModel->importSBML(pSBMLFilename);
//pDataModel->getModel()->forceCompile();
// create a report with the correct filename and all the species against
// time.
CReportDefinitionVector* pReports = pDataModel->getReportDefinitionList();
CReportDefinition* pReport = pReports->createReportDefinition("Report", "Output for stochastic testsuite run");
pReport->setTaskType(CCopasiTask::timeCourse);
pReport->setIsTable(false);
CCopasiReportSeparator Separator(std::string(","));
pReport->setSeparator(Separator);
std::vector<CRegisteredObjectName> * pHeader = pReport->getHeaderAddr();
std::vector<CRegisteredObjectName> * pBody = pReport->getBodyAddr();
// Add time column
pHeader->push_back(CCopasiStaticString("time").getCN());
pBody->push_back(CCopasiObjectName(pDataModel->getModel()->getCN() + ",Reference=Time"));
iMax = iMax - NUMARGS;
const CCopasiVector<CMetab>& metabolites = pDataModel->getModel()->getMetabolites();
for (i = 0; i < iMax; ++i)
{
pHeader->push_back(Separator.getCN());
pBody->push_back(Separator.getCN());
unsigned int j, jMax = metabolites.size();
std::string SBMLId = unQuote(pSBMLSpeciesIds[i]);
for (j = 0; j < jMax; ++j)
{
if (metabolites[j]->getSBMLId() == SBMLId)
{
break;
}
}
if (j == jMax)
{
std::cerr << "Could not find a metabolite for the SBML id \"" << pSBMLSpeciesIds[i] << "\"" << std::endl;
exit(1);
}
pHeader->push_back(CCopasiStaticString(SBMLId).getCN());
pBody->push_back(metabolites[j]->getObject(CCopasiObjectName("Reference=ParticleNumber"))->getCN());
}
// create a trajectory task
pTrajectoryTask = new CTrajectoryTask();
pTrajectoryTask->setMethodType(MethodType);
pTrajectoryTask->getProblem()->setModel(pDataModel->getModel());
pTrajectoryTask->setScheduled(false);
//pTrajectoryTask->getReport().setReportDefinition(pReport);
//pTrajectoryTask->getReport().setTarget(CWD + "/" + pOutputFilename);
//pTrajectoryTask->getReport().setAppend(false);
CTrajectoryProblem* pProblem = dynamic_cast<CTrajectoryProblem*>(pTrajectoryTask->getProblem());
pProblem->setStepNumber((const unsigned C_INT32)stepNumber);
pProblem->setDuration((const C_FLOAT64)endTime);
pProblem->setTimeSeriesRequested(true);
pProblem->setTimeSeriesRequested(false);
//pProblem->setInitialState(pDataModel->getModel()->getInitialState());
CCopasiVectorN< CCopasiTask > & TaskList = * pDataModel->getTaskList();
TaskList.remove("Time-Course");
TaskList.add(pTrajectoryTask, true);
// create a scan task
pScanTask = new CScanTask(pDataModel);
CScanProblem* pScanProblem = dynamic_cast<CScanProblem*>(pScanTask->getProblem());
pScanProblem->setModel(pDataModel->getModel());
pScanTask->setScheduled(true);
pScanTask->getReport().setReportDefinition(pReport);
pScanTask->getReport().setTarget(CWD + "/" + pOutputFilename);
pScanTask->getReport().setAppend(false);
pScanProblem->setSubtask(CCopasiTask::timeCourse);
pScanProblem->createScanItem(CScanProblem::SCAN_REPEAT, repeats);
pScanProblem->setOutputInSubtask(true);
pScanProblem->setContinueFromCurrentState(false);
TaskList.remove("Scan");
TaskList.add(pScanTask, true);
// save the file for control purposes
std::string saveFilename = pSBMLFilename;
saveFilename = saveFilename.substr(0, saveFilename.length() - 4) + ".cps";
pDataModel->saveModel(saveFilename, NULL, true);
// Run the trajectory task
pScanTask->initialize(CCopasiTask::OUTPUT_SE, pDataModel, NULL);
pScanTask->process(true);
pScanTask->restore();
// create another report that will write to the directory where the input file came from
// this can be used for debugging
// create a trajectory task
// pScanTask->getReport().setTarget(pOutputFilename);
// pScanTask->initialize(CCopasiTask::OUTPUT_SE, pDataModel, NULL);
// pScanTask->process(true);
// pScanTask->restore();
}
catch (CCopasiException Exception)
{
std::cerr << Exception.getMessage().getText() << std::endl;
}
CCopasiRootContainer::destroy();
return 0;
}
int main(int argc, char** argv)
{
// initialize the backend library
CCopasiRootContainer::init(argc, argv);
assert(CCopasiRootContainer::getRoot() != NULL);
// create a new datamodel
CCopasiDataModel* pDataModel = CCopasiRootContainer::addDatamodel();
assert(CCopasiRootContainer::getDatamodelList()->size() == 1);
// the only argument to the main routine should be the name of an SBML file
if (argc == 2)
{
std::string filename = argv[1];
try
{
// load the model without progress report
pDataModel->importSBML(filename, NULL);
}
catch (...)
{
std::cerr << "Error while importing the model from file named \"" << filename << "\"." << std::endl;
CCopasiRootContainer::destroy();
return 1;
}
CModel* pModel = pDataModel->getModel();
assert(pModel != NULL);
// create a report with the correct filename and all the species against
// time.
CReportDefinitionVector* pReports = pDataModel->getReportDefinitionList();
// create a new report definition object
CReportDefinition* pReport = pReports->createReportDefinition("Report", "Output for timecourse");
// set the task type for the report definition to timecourse
pReport->setTaskType(CTaskEnum::timeCourse);
// we don't want a table
pReport->setIsTable(false);
// the entries in the output should be seperated by a ", "
pReport->setSeparator(", ");
// 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
std::vector<CRegisteredObjectName>* pHeader = pReport->getHeaderAddr();
std::vector<CRegisteredObjectName>* pBody = pReport->getBodyAddr();
pBody->push_back(CCopasiObjectName(pDataModel->getModel()->getCN() + ",Reference=Time"));
pBody->push_back(CRegisteredObjectName(pReport->getSeparator().getCN()));
pHeader->push_back(CCopasiStaticString("time").getCN());
pHeader->push_back(pReport->getSeparator().getCN());
size_t i, iMax = pModel->getMetabolites().size();
for (i = 0; i < iMax; ++i)
{
CMetab* pMetab = &pModel->getMetabolites()[i];
assert(pMetab != NULL);
// we don't want output for FIXED metabolites right now
if (pMetab->getStatus() != CModelEntity::FIXED)
{
// we want the concentration oin the output
// alternatively, we could use "Reference=Amount" to get the
// particle number
pBody->push_back(pMetab->getObject(CCopasiObjectName("Reference=Concentration"))->getCN());
// after each entry, we need a seperator
pBody->push_back(pReport->getSeparator().getCN());
// add the corresponding id to the header
pHeader->push_back(CCopasiStaticString(pMetab->getSBMLId()).getCN());
// and a seperator
pHeader->push_back(pReport->getSeparator().getCN());
}
}
if (iMax > 0)
{
// delete the last separator
// since we don't need one after the last element on each line
if ((*pBody->rbegin()) == pReport->getSeparator().getCN())
{
pBody->erase(--pBody->end());
}
if ((*pHeader->rbegin()) == pReport->getSeparator().getCN())
{
pHeader->erase(--pHeader->end());
}
}
// get the task list
CCopasiVectorN< CCopasiTask > & TaskList = * pDataModel->getTaskList();
// get the trajectory task object
CTrajectoryTask* pTrajectoryTask = dynamic_cast<CTrajectoryTask*>(&TaskList["Time-Course"]);
// if there isn't one
if (pTrajectoryTask == NULL)
{
// remove any existing trajectory task just to be sure since in
// theory only the cast might have failed above
TaskList.remove("Time-Course");
// create a new one
pTrajectoryTask = new CTrajectoryTask(& TaskList);
// add the new time course task to the task list
TaskList.add(pTrajectoryTask, true);
}
// run a deterministic time course
pTrajectoryTask->setMethodType(CTaskEnum::deterministic);
// Activate the task so that it will be run when the model is saved
// and passed to CopasiSE
pTrajectoryTask->setScheduled(true);
// set the report for the task
pTrajectoryTask->getReport().setReportDefinition(pReport);
// set the output filename
pTrajectoryTask->getReport().setTarget("example3.txt");
// don't append output if the file exists, but overwrite the file
pTrajectoryTask->getReport().setAppend(false);
// get the problem for the task to set some parameters
CTrajectoryProblem* pProblem = dynamic_cast<CTrajectoryProblem*>(pTrajectoryTask->getProblem());
// simulate 100 steps
pProblem->setStepNumber(100);
// start at time 0
pDataModel->getModel()->setInitialTime(0.0);
// simulate a duration of 10 time units
pProblem->setDuration(10);
// tell the problem to actually generate time series data
pProblem->setTimeSeriesRequested(true);
// set some parameters for the LSODA method through the method
CTrajectoryMethod* pMethod = dynamic_cast<CTrajectoryMethod*>(pTrajectoryTask->getMethod());
CCopasiParameter* pParameter = pMethod->getParameter("Absolute Tolerance");
assert(pParameter != NULL);
pParameter->setValue(1.0e-12);
try
{
// initialize the trajectory task
// we want complete output (HEADER, BODY and FOOTER)
//
// The output has to be set to OUTPUT_UI, otherwise the time series will not be
// kept in memory and some of the assert further down will fail
// If it is OK that the output is only written to file, the output type can
// be set to OUTPUT_SE
pTrajectoryTask->initialize(CCopasiTask::OUTPUT_UI, pDataModel, NULL);
// now we run the actual trajectory
pTrajectoryTask->process(true);
}
catch (...)
{
std::cerr << "Error. Running the time course simulation failed." << std::endl;
// check if there are additional error messages
if (CCopasiMessage::size() > 0)
{
// print the messages in chronological order
std::cerr << CCopasiMessage::getAllMessageText(true);
}
CCopasiRootContainer::destroy();
return 1;
}
// restore the state of the trajectory
pTrajectoryTask->restore();
// look at the timeseries
const CTimeSeries* pTimeSeries = &pTrajectoryTask->getTimeSeries();
// we simulated 100 steps, including the initial state, this should be
// 101 step in the timeseries
assert(pTimeSeries->getRecordedSteps() == 101);
std::cout << "The time series consists of " << pTimeSeries->getRecordedSteps() << "." << std::endl;
std::cout << "Each step contains " << pTimeSeries->getNumVariables() << " variables." << std::endl;
std::cout << "The final state is: " << std::endl;
iMax = pTimeSeries->getNumVariables();
size_t lastIndex = pTimeSeries->getRecordedSteps() - 1;
for (i = 0; i < iMax; ++i)
{
// here we get the particle number (at least for the species)
// the unit of the other variables may not be particle numbers
// the concentration data can be acquired with getConcentrationData
std::cout << pTimeSeries->getTitle(i) << ": " << pTimeSeries->getData(lastIndex, i) << std::endl;
}
}
else
{
std::cerr << "Usage: example3 SBMLFILE" << std::endl;
CCopasiRootContainer::destroy();
return 1;
}
// clean up the library
CCopasiRootContainer::destroy();
}
bool CQTrajectoryWidget::loadTask()
{
CTrajectoryTask * pTask =
dynamic_cast< CTrajectoryTask * >(mpTask);
if (!pTask) return false;
loadCommon();
loadMethod();
showUnits();
CTrajectoryProblem* TrajectoryProblem =
dynamic_cast<CTrajectoryProblem *>(pTask->getProblem());
assert(TrajectoryProblem);
pdelete(mpTrajectoryProblem);
mpTrajectoryProblem = new CTrajectoryProblem(*TrajectoryProblem, NO_PARENT);
//numbers
mpEditIntervalSize->setText(QString::number(TrajectoryProblem->getStepSize()));
mpEditIntervals->setText(QString::number(TrajectoryProblem->getStepNumber()));
mpEditDuration->setText(QString::number(TrajectoryProblem->getDuration()));
mpCheckAutomaticInterval->setChecked(TrajectoryProblem->getAutomaticStepSize());
assert(mpDataModel != NULL);
C_FLOAT64 InitialTime = mpDataModel->getModel()->getInitialTime();
bool Delayed;
if (TrajectoryProblem->getStepSize() > 0.0)
Delayed = (TrajectoryProblem->getOutputStartTime() - InitialTime) > std::numeric_limits< C_FLOAT64 >::min();
else
Delayed = (InitialTime - TrajectoryProblem->getOutputStartTime()) > std::numeric_limits< C_FLOAT64 >::min();
mpCheckDelay->setChecked(Delayed);
mpEditDelay->setEnabled(Delayed);
mpEditDelay->setText(QString::number(TrajectoryProblem->getOutputStartTime()));
mpCheckOutputEvent->setChecked(TrajectoryProblem->getOutputEvent());
mpCheckStartInSteadyState->setChecked(TrajectoryProblem->getStartInSteadyState());
//store time series checkbox
mpCheckSave->setChecked(TrajectoryProblem->timeSeriesRequested());
checkTimeSeries();
updateIntervals();
mpValidatorDuration->saved();
mpValidatorIntervalSize->saved();
mpValidatorIntervals->saved();
mpValidatorDelay->saved();
return true;
}