int main()
{
// initialize the backend library
// since we are not interested in the arguments
// that are passed to main, we pass 0 and NULL to
// init
CCopasiRootContainer::init(0, NULL);
assert(CCopasiRootContainer::getRoot() != NULL);
// create a new datamodel
CCopasiDataModel* pDataModel = CCopasiRootContainer::addDatamodel();
assert(CCopasiRootContainer::getDatamodelList()->size() == 1);
// get the model from the datamodel
CModel* pModel = pDataModel->getModel();
assert(pModel != NULL);
// set the units for the model
// we want seconds as the time unit
// microliter as the volume units
// and nanomole as the substance units
pModel->setTimeUnit(CModel::s);
pModel->setVolumeUnit(CModel::microl);
pModel->setQuantityUnit(CModel::nMol);
// we have to keep a set of all the initial values that are changed during
// the model building process
// They are needed after the model has been built to make sure all initial
// values are set to the correct initial value
std::set<const CCopasiObject*> changedObjects;
// create a compartment with the name cell and an initial volume of 5.0
// microliter
CCompartment* pCompartment = pModel->createCompartment("cell", 5.0);
const CCopasiObject* pObject = pCompartment->getValueReference();
assert(pObject != NULL);
changedObjects.insert(pObject);
assert(pCompartment != NULL);
assert(pModel->getCompartments().size() == 1);
// create a new metabolite with the name S and an inital
// concentration of 10 nanomol
// the metabolite belongs to the compartment we created and is is to be
// fixed
CMetab* pS = pModel->createMetabolite("S", pCompartment->getObjectName(), 10.0, CMetab::FIXED);
pObject = pS->getInitialConcentrationReference();
assert(pObject != NULL);
changedObjects.insert(pObject);
assert(pCompartment != NULL);
assert(pS != NULL);
assert(pModel->getMetabolites().size() == 1);
// create a second metabolite called P with an initial
// concentration of 0. This metabolite is to be changed by reactions
CMetab* pP = pModel->createMetabolite("P", pCompartment->getObjectName(), 0.0, CMetab::REACTIONS);
assert(pP != NULL);
pObject = pP->getInitialConcentrationReference();
assert(pObject != NULL);
changedObjects.insert(pObject);
assert(pModel->getMetabolites().size() == 2);
// now we create a reaction
CReaction* pReaction = pModel->createReaction("reaction");
assert(pReaction != NULL);
assert(pModel->getReactions().size() == 1);
// reaction converts S to P
// we can set these on the chemical equation of the reaction
CChemEq* pChemEq = &pReaction->getChemEq();
// S is a substrate with stoichiometry 1
pChemEq->addMetabolite(pS->getKey(), 1.0, CChemEq::SUBSTRATE);
// P is a product with stoichiometry 1
pChemEq->addMetabolite(pP->getKey(), 1.0, CChemEq::PRODUCT);
assert(pChemEq->getSubstrates().size() == 1);
assert(pChemEq->getProducts().size() == 1);
// this reaction is to be irreversible
pReaction->setReversible(false);
assert(pReaction->isReversible() == false);
CModelValue* pMV = pModel->createModelValue("K", 42.0);
// set the status to FIXED
pMV->setStatus(CModelValue::FIXED);
assert(pMV != NULL);
pObject = pMV->getInitialValueReference();
assert(pObject != NULL);
changedObjects.insert(pObject);
assert(pModel->getModelValues().size() == 1);
// now we ned to set a kinetic law on the reaction
// for this we create a user defined function
CFunctionDB* pFunDB = CCopasiRootContainer::getFunctionList();
assert(pFunDB != NULL);
CKinFunction* pFunction = new CKinFunction("My Rate Law");
pFunDB->add(pFunction, true);
CFunction* pRateLaw = dynamic_cast<CFunction*>(pFunDB->findFunction("My Rate Law"));
assert(pRateLaw != NULL);
// now we create the formula for the function and set it on the function
std::string formula = "(1-0.4/(EXPONENTIALE^(temp-37)))*0.00001448471257*1.4^(temp-37)*substrate";
bool result = pFunction->setInfix(formula);
assert(result == true);
// make the function irreversible
pFunction->setReversible(TriFalse);
// the formula string should have been parsed now
// and COPASI should have determined that the formula string contained 2 parameters (temp and substrate)
CFunctionParameters& variables = pFunction->getVariables();
// per default the usage of those parameters will be set to VARIABLE
size_t index = pFunction->getVariableIndex("temp");
assert(index != C_INVALID_INDEX);
CFunctionParameter* pParam = variables[index];
assert(pParam->getUsage() == CFunctionParameter::VARIABLE);
// This is correct for temp, but substrate should get the usage SUBSTRATE in order
// for us to use the function with the reaction created above
// So we need to set the usage for "substrate" manually
index = pFunction->getVariableIndex("substrate");
assert(index != C_INVALID_INDEX);
pParam = variables[index];
pParam->setUsage(CFunctionParameter::SUBSTRATE);
// set the rate law for the reaction
pReaction->setFunction(pFunction);
assert(pReaction->getFunction() != NULL);
// COPASI also needs to know what object it has to assocuiate with the individual function parameters
// In our case we need to tell COPASI that substrate is to be replaced by the substrate of the reaction
// and temp is to be replaced by the global parameter K
pReaction->setParameterMapping("substrate", pS->getKey());
pReaction->setParameterMapping("temp", pMV->getKey());
// finally compile the model
// compile needs to be done before updating all initial values for
// the model with the refresh sequence
pModel->compileIfNecessary(NULL);
// now that we are done building the model, we have to make sure all
// initial values are updated according to their dependencies
std::vector<Refresh*> refreshes = pModel->buildInitialRefreshSequence(changedObjects);
std::vector<Refresh*>::iterator it2 = refreshes.begin(), endit2 = refreshes.end();
while (it2 != endit2)
{
// call each refresh
(**it2)();
++it2;
}
// save the model to a COPASI file
// we save to a file named example1.cps, we don't want a progress report
// and we want to overwrite any existing file with the same name
// Default tasks are automatically generated and will always appear in cps
// file unless they are explicitley deleted before saving.
pDataModel->saveModel("example7.cps", NULL, true);
// export the model to an SBML file
// we save to a file named example1.xml, we want to overwrite any
// existing file with the same name and we want SBML L2V3
pDataModel->exportSBML("example7.xml", true, 2, 3);
// destroy the root container once we are done
CCopasiRootContainer::destroy();
}
void test_compare_utilities::test_copasi_function_expansion()
{
CCopasiDataModel* pDataModel = pCOPASIDATAMODEL;;
std::istringstream iss(test_compare_utilities::MODEL_STRING1);
CPPUNIT_ASSERT(load_cps_model_from_stream(iss, *pDataModel) == true);
CFunctionDB* pFunctionDB = CCopasiRootContainer::getFunctionList();
// function_5
CEvaluationTree* pTree = pFunctionDB->findFunction("function_4");
CPPUNIT_ASSERT(pTree != NULL);
// generate a call node
CFunction* pFunction = dynamic_cast<CFunction*>(pTree);
CPPUNIT_ASSERT(pFunction != NULL);
CEvaluationNodeCall* pCallNode = new CEvaluationNodeCall(CEvaluationNode::S_FUNCTION, pFunction->getObjectName());
CPPUNIT_ASSERT(pCallNode != NULL);
CFunctionParameters* pFunctionParameters = &pFunction->getVariables();
unsigned int i = 0, iMax = pFunctionParameters->size();
while (i < iMax)
{
CFunctionParameter* pParameter = (*pFunctionParameters)[i];
CPPUNIT_ASSERT(pParameter != NULL);
CEvaluationNodeVariable* pVariableNode = new CEvaluationNodeVariable(CEvaluationNode::S_DEFAULT, pParameter->getObjectName());
pCallNode->addChild(pVariableNode);
++i;
}
CEvaluationNode* pExpanded = expand_function_calls(pCallNode, pFunctionDB);
delete pCallNode;
CPPUNIT_ASSERT(pExpanded != NULL);
CPPUNIT_ASSERT(pExpanded->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pExpanded->subType() == CEvaluationNode::S_DIVIDE);
CEvaluationNode* pChild = dynamic_cast<CEvaluationNode*>(pExpanded->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_PLUS);
pChild = dynamic_cast<CEvaluationNode*>(pChild->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_VARIABLE);
CPPUNIT_ASSERT(pChild->getData() == std::string("y"));
pChild = dynamic_cast<CEvaluationNode*>(pChild->getSibling());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_VARIABLE);
CPPUNIT_ASSERT(pChild->getData() == std::string("x"));
CPPUNIT_ASSERT(pChild->getSibling() == NULL);
pChild = dynamic_cast<CEvaluationNode*>(pExpanded->getChild()->getSibling());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_NUMBER);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_DOUBLE);
CPPUNIT_ASSERT((fabs(pChild->getValue() - 2.0) / 2.0) < 1e-6);
CPPUNIT_ASSERT(pChild->getSibling() == NULL);
delete pExpanded;
// function_5
pTree = pFunctionDB->findFunction("function_5");
CPPUNIT_ASSERT(pTree != NULL);
// generate a call node
pFunction = dynamic_cast<CFunction*>(pTree);
CPPUNIT_ASSERT(pFunction != NULL);
pCallNode = new CEvaluationNodeCall(CEvaluationNode::S_FUNCTION, pFunction->getObjectName());
CPPUNIT_ASSERT(pCallNode != NULL);
pFunctionParameters = &pFunction->getVariables();
i = 0, iMax = pFunctionParameters->size();
while (i < iMax)
{
CFunctionParameter* pParameter = (*pFunctionParameters)[i];
CPPUNIT_ASSERT(pParameter != NULL);
CEvaluationNodeVariable* pVariableNode = new CEvaluationNodeVariable(CEvaluationNode::S_DEFAULT, pParameter->getObjectName());
pCallNode->addChild(pVariableNode);
++i;
}
pExpanded = expand_function_calls(pCallNode, pFunctionDB);
delete pCallNode;
CPPUNIT_ASSERT(pExpanded != NULL);
CPPUNIT_ASSERT(pExpanded->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pExpanded->subType() == CEvaluationNode::S_PLUS);
pChild = dynamic_cast<CEvaluationNode*>(pExpanded->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_MINUS);
pChild = dynamic_cast<CEvaluationNode*>(pChild->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_VARIABLE);
CPPUNIT_ASSERT(pChild->getData() == std::string("a"));
pChild = dynamic_cast<CEvaluationNode*>(pChild->getSibling());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_MULTIPLY);
CPPUNIT_ASSERT(pChild->getSibling() == NULL);
pChild = dynamic_cast<CEvaluationNode*>(pChild->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_VARIABLE);
CPPUNIT_ASSERT(pChild->getData() == std::string("c"));
pChild = dynamic_cast<CEvaluationNode*>(pChild->getSibling());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_NUMBER);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_DOUBLE);
CPPUNIT_ASSERT((fabs(pChild->getValue() - 1.3) / 1.3) < 1e-6);
CPPUNIT_ASSERT(pChild->getSibling() == NULL);
// (3*b)-5.23
pChild = dynamic_cast<CEvaluationNode*>(pExpanded->getChild()->getSibling());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_MINUS);
// 3*b
pChild = dynamic_cast<CEvaluationNode*>(pChild->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_MULTIPLY);
pChild = dynamic_cast<CEvaluationNode*>(pChild->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_NUMBER);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_DOUBLE);
CPPUNIT_ASSERT((fabs(pChild->getValue() - 3.0) / 3.0) < 1e-6);
pChild = dynamic_cast<CEvaluationNode*>(pChild->getSibling());
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_VARIABLE);
CPPUNIT_ASSERT(pChild->getData() == std::string("b"));
CPPUNIT_ASSERT(pChild->getSibling() == NULL);
// 5.23
pChild = dynamic_cast<CEvaluationNode*>(pExpanded->getChild()->getSibling()->getChild()->getSibling());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_NUMBER);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_DOUBLE);
CPPUNIT_ASSERT((fabs(pChild->getValue() - 5.23) / 5.23) < 1e-6);
CPPUNIT_ASSERT(pChild->getSibling() == NULL);
delete pExpanded;
// function_6
pTree = pFunctionDB->findFunction("function_6");
CPPUNIT_ASSERT(pTree != NULL);
// generate a call node
pFunction = dynamic_cast<CFunction*>(pTree);
CPPUNIT_ASSERT(pFunction != NULL);
pCallNode = new CEvaluationNodeCall(CEvaluationNode::S_FUNCTION, pFunction->getObjectName());
CPPUNIT_ASSERT(pCallNode != NULL);
pFunctionParameters = &pFunction->getVariables();
i = 0, iMax = pFunctionParameters->size();
while (i < iMax)
{
CFunctionParameter* pParameter = (*pFunctionParameters)[i];
CPPUNIT_ASSERT(pParameter != NULL);
CEvaluationNodeVariable* pVariableNode = new CEvaluationNodeVariable(CEvaluationNode::S_DEFAULT, pParameter->getObjectName());
pCallNode->addChild(pVariableNode);
++i;
}
pExpanded = expand_function_calls(pCallNode, pFunctionDB);
delete pCallNode;
CPPUNIT_ASSERT(pExpanded != NULL);
// (k1-k3*1.3)+((3*k2)-5.23)
CPPUNIT_ASSERT(pExpanded->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pExpanded->subType() == CEvaluationNode::S_PLUS);
pChild = dynamic_cast<CEvaluationNode*>(pExpanded->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_MINUS);
pChild = dynamic_cast<CEvaluationNode*>(pChild->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_VARIABLE);
CPPUNIT_ASSERT(pChild->getData() == std::string("k1"));
pChild = dynamic_cast<CEvaluationNode*>(pChild->getSibling());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_MULTIPLY);
CPPUNIT_ASSERT(pChild->getSibling() == NULL);
pChild = dynamic_cast<CEvaluationNode*>(pChild->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_VARIABLE);
CPPUNIT_ASSERT(pChild->getData() == std::string("k3"));
pChild = dynamic_cast<CEvaluationNode*>(pChild->getSibling());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_NUMBER);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_DOUBLE);
CPPUNIT_ASSERT((fabs(pChild->getValue() - 1.3) / 1.3) < 1e-6);
CPPUNIT_ASSERT(pChild->getSibling() == NULL);
// (3*b)-5.23
pChild = dynamic_cast<CEvaluationNode*>(pExpanded->getChild()->getSibling());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_MINUS);
// 3*b
pChild = dynamic_cast<CEvaluationNode*>(pChild->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_OPERATOR);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_MULTIPLY);
pChild = dynamic_cast<CEvaluationNode*>(pChild->getChild());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_NUMBER);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_DOUBLE);
CPPUNIT_ASSERT((fabs(pChild->getValue() - 3.0) / 3.0) < 1e-6);
pChild = dynamic_cast<CEvaluationNode*>(pChild->getSibling());
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_VARIABLE);
CPPUNIT_ASSERT(pChild->getData() == std::string("k2"));
CPPUNIT_ASSERT(pChild->getSibling() == NULL);
// 5.23
pChild = dynamic_cast<CEvaluationNode*>(pExpanded->getChild()->getSibling()->getChild()->getSibling());
CPPUNIT_ASSERT(pChild != NULL);
CPPUNIT_ASSERT(pChild->mainType() == CEvaluationNode::T_NUMBER);
CPPUNIT_ASSERT(pChild->subType() == CEvaluationNode::S_DOUBLE);
CPPUNIT_ASSERT((fabs(pChild->getValue() - 5.23) / 5.23) < 1e-6);
CPPUNIT_ASSERT(pChild->getSibling() == NULL);
delete pExpanded;
}
// This is only used when reading Gepasi Files
void CKinFunction::createParameters()
{
CCopasiVectorN < CFunctionParameter > Substrates;
CCopasiVectorN < CFunctionParameter > Products;
CCopasiVectorN < CFunctionParameter > Modifiers;
CCopasiVectorN < CFunctionParameter > Parameters;
CCopasiVectorN < CFunctionParameter > Volumes;
size_t i, imax = mNodes.size();
CFunctionParameter *pParameter;
for (i = 0; i < imax; i++)
{
if (mNodes[i]->getType() == N_IDENTIFIER)
{
// We need to check that we have no reserved name.
const char *Reserved[] =
{"pi", "exponentiale", "true", "false", "infinity", "nan",
"PI", "EXPONENTIALE", "TRUE", "FALSE", "INFINITY", "NAN"
};
std::string Name = mNodes[i]->getName();
size_t j, jmax = 12;
for (j = 0; j < jmax; j++)
if (Name == Reserved[j]) break;
if (j != jmax)
{
// It is save to prepend the identifyer with '_' since this is not allowed in
// Gepasi but within COPASI.
std::string OldName = Name;
Name = "_" + Name;
// We have to replace the corresponding CEvaluationNodes to reflect the change.
std::vector< CEvaluationNode * >::iterator it = mpNodeList->begin();
std::vector< CEvaluationNode * >::iterator end = mpNodeList->end();
for (; it != end; ++it)
if (((*it)->getType() & 0xFF000000) == CEvaluationNode::CONSTANT &&
(*it)->getData() == OldName)
(*it)->setData(Name);
// The Infix has changed we need to update it.
setInfix(mpRoot->buildInfix());
}
pParameter = new CFunctionParameter(Name);
pParameter->setType(CFunctionParameter::FLOAT64);
switch (mNodes[i]->getSubtype())
{
case N_SUBSTRATE:
pParameter->setUsage(CFunctionParameter::SUBSTRATE);
if (Substrates.getIndex(pParameter->getObjectName()) == C_INVALID_INDEX)
Substrates.add(pParameter, false);
else
pdelete(pParameter);
break;
case N_PRODUCT:
pParameter->setUsage(CFunctionParameter::PRODUCT);
if (Products.getIndex(pParameter->getObjectName()) == C_INVALID_INDEX)
Products.add(pParameter, false);
else
pdelete(pParameter);
break;
case N_MODIFIER:
pParameter->setUsage(CFunctionParameter::MODIFIER);
if (Modifiers.getIndex(pParameter->getObjectName()) == C_INVALID_INDEX)
Modifiers.add(pParameter, false);
else
pdelete(pParameter);
break;
case N_KCONSTANT:
case N_NOP:
pParameter->setUsage(CFunctionParameter::PARAMETER);
if (Parameters.getIndex(pParameter->getObjectName()) == C_INVALID_INDEX)
Parameters.add(pParameter, false);
else
pdelete(pParameter);
break;
case N_VOLUME:
pParameter->setUsage(CFunctionParameter::VOLUME);
if (Volumes.getIndex(pParameter->getObjectName()) == C_INVALID_INDEX)
Volumes.add(pParameter, false);
else
pdelete(pParameter);
break;
default:
pdelete(pParameter);
fatalError();
}
}
}
getVariables().cleanup();
imax = Substrates.size();
for (i = 0; i < imax; i++)
getVariables().add(Substrates[i], true);
Substrates.cleanup();
imax = Products.size();
for (i = 0; i < imax; i++)
getVariables().add(Products[i], true);
Products.cleanup();
imax = Modifiers.size();
for (i = 0; i < imax; i++)
getVariables().add(Modifiers[i], true);
Modifiers.cleanup();
imax = Parameters.size();
for (i = 0; i < imax; i++)
getVariables().add(Parameters[i], true);
Parameters.cleanup();
imax = Volumes.size();
for (i = 0; i < imax; i++)
getVariables().add(Volumes[i], true);
Volumes.cleanup();
}
