void CModelExpansion::createDiffusionReaction(const std::string & name,
const std::string & metabkey1, const std::string & metabkey2,
const std::string & parameterkey)
{
//try creating the object until we find a name that is not yet used
CReaction* newObj;
std::ostringstream name_;
name_ << name;
do
{
newObj = mpModel->createReaction(name_.str());
name_ << "_";
}
while (!newObj);
newObj->setReversible(true);
newObj->addSubstrate(metabkey1, 1);
newObj->addProduct(metabkey2, 1);
newObj->setFunction("Mass action (reversible)");
newObj->addParameterMapping("substrate", metabkey1);
newObj->addParameterMapping("product", metabkey2);
newObj->setParameterMapping(0, parameterkey);
newObj->setParameterMapping(2, parameterkey);
}
void CModelExpansion::duplicateReaction(const CReaction* source, const std::string & index, const SetOfModelElements & sourceSet, ElementsMap & emap)
{
//if the source object has already been duplicated: do nothing
if (emap.exists(source))
return;
//try creating the object until we find a name that is not yet used
CReaction* newObj;
std::ostringstream infix;
do
{
std::ostringstream name;
name << source->getObjectName() << infix.str() << index;
newObj = mpModel->createReaction(name.str());
infix << "_";
}
while (!newObj);
//add duplicated object to the map
emap.add(source, newObj);
//now copy the chemical equation
size_t i;
for (i = 0; i < source->getChemEq().getSubstrates().size(); ++i)
{
const CChemEqElement * sourceElement = source->getChemEq().getSubstrates()[i];
const CMetab* pMetab = NULL;
if (sourceSet.contains(sourceElement->getMetabolite()))
{
if (!emap.exists(sourceElement->getMetabolite()))
duplicateMetab(sourceElement->getMetabolite(), index, sourceSet, emap);
pMetab = dynamic_cast<const CMetab*>(emap.getDuplicatePtr(sourceElement->getMetabolite()));
}
else //add the original metab
{
pMetab = sourceElement->getMetabolite();
}
if (pMetab)
newObj->addSubstrate(pMetab->getKey(), sourceElement->getMultiplicity());
}
for (i = 0; i < source->getChemEq().getProducts().size(); ++i)
{
const CChemEqElement * sourceElement = source->getChemEq().getProducts()[i];
const CMetab* pMetab = NULL;
if (sourceSet.contains(sourceElement->getMetabolite()))
{
if (!emap.exists(sourceElement->getMetabolite()))
duplicateMetab(sourceElement->getMetabolite(), index, sourceSet, emap);
pMetab = dynamic_cast<const CMetab*>(emap.getDuplicatePtr(sourceElement->getMetabolite()));
}
else //add the original metab
{
pMetab = sourceElement->getMetabolite();
}
if (pMetab)
newObj->addProduct(pMetab->getKey(), sourceElement->getMultiplicity());
}
for (i = 0; i < source->getChemEq().getModifiers().size(); ++i)
{
const CChemEqElement * sourceElement = source->getChemEq().getModifiers()[i];
const CMetab* pMetab = NULL;
if (sourceSet.contains(sourceElement->getMetabolite()))
{
if (!emap.exists(sourceElement->getMetabolite()))
duplicateMetab(sourceElement->getMetabolite(), index, sourceSet, emap);
pMetab = dynamic_cast<const CMetab*>(emap.getDuplicatePtr(sourceElement->getMetabolite()));
}
else //add the original metab
{
pMetab = sourceElement->getMetabolite();
}
if (pMetab)
newObj->addModifier(pMetab->getKey());
}
newObj->setReversible(source->isReversible());
//set the kinetic function
newObj->setFunction(const_cast<CFunction*>(source->getFunction()));
//mapping and local parameters
for (i = 0; i < newObj->getFunctionParameters().size(); ++i)
{
switch (newObj->getFunctionParameters()[i]->getUsage())
{
case CFunctionParameter::SUBSTRATE:
case CFunctionParameter::PRODUCT:
case CFunctionParameter::MODIFIER:
{
bool isVector = (newObj->getFunctionParameters()[i]->getType() == CFunctionParameter::VFLOAT64);
if (isVector)
newObj->clearParameterMapping(i);
size_t k;
for (k = 0; k < source->getParameterMappings()[i].size(); ++k)
{
//we assume that by now the metab was copied if necessary.
//therefore we only need to check the map.
std::string targetKey;
if (emap.exists(source->getParameterMappings()[i][k]))
targetKey = emap.getDuplicateKey(source->getParameterMappings()[i][k]);
else
targetKey = source->getParameterMappings()[i][k];
if (isVector)
newObj->addParameterMapping(i, targetKey);
else
newObj->setParameterMapping(i, targetKey);
}
}
break;
case CFunctionParameter::TIME:
newObj->setParameterMapping(i, source->getParameterMappings()[i][0]);
break;
case CFunctionParameter::VOLUME:
if (sourceSet.contains(source->getParameterMappings()[i][0]))
{
if (!emap.exists(source->getParameterMappings()[i][0]))
{
const CCompartment* pSource = dynamic_cast<const CCompartment*>(
(CCopasiRootContainer::getKeyFactory()->get(source->getParameterMappings()[i][0])));
duplicateCompartment(pSource, index, sourceSet, emap);
}
newObj->setParameterMapping(i, emap.getDuplicateKey(source->getParameterMappings()[i][0]));
}
else //add the original metab
{
newObj->setParameterMapping(i, source->getParameterMappings()[i][0]);
}
break;
case CFunctionParameter::PARAMETER:
if (newObj->isLocalParameter(i))
{
//just copy the value
newObj->setParameterValue(newObj->getFunctionParameters()[i]->getObjectName(),
source->getParameterValue(newObj->getFunctionParameters()[i]->getObjectName()));
}
else
{
if (sourceSet.contains(source->getParameterMappings()[i][0]))
{
if (!emap.exists(source->getParameterMappings()[i][0]))
{
const CModelValue* pSource = dynamic_cast<const CModelValue*>(
(CCopasiRootContainer::getKeyFactory()->get(source->getParameterMappings()[i][0])));
duplicateGlobalQuantity(pSource, index, sourceSet, emap);
}
newObj->setParameterMapping(i, emap.getDuplicateKey(source->getParameterMappings()[i][0]));
}
else //add the original global quantity
{
newObj->setParameterMapping(i, source->getParameterMappings()[i][0]);
}
}
break;
default:
break;
}
}
newObj->setNotes(source->getNotes());
newObj->setMiriamAnnotation(source->getMiriamAnnotation(), newObj->getKey(), source->getKey());
}
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();
}
bool CModelAdd::addReactions(std::string name)
{
bool info = false;
//create copies of the relevant reactions
size_t i, imax = mmModel->getReactions().size();
size_t ic, icmax = mmModel->getCompartments().size();
for (ic = 0; ic < icmax; ++ic)
{
const CCompartment* sourceComp = &mmModel->getCompartments()[ic];
if (!sourceComp) return info;
for (i = 0; i < imax; ++i)
{
CReaction * sourceReac = &mmModel->getReactions()[i];
if (reactionInvolvesCompartment(sourceReac, sourceComp))
{
std::string newName = sourceReac->getObjectName() + "_" + name;
CReaction* newReac = mpModel->createReaction(newName);
if (!newReac) return info;
//copy the chemical equation. If the involved metabs are among those that
//were copied with the compartment, replace them. Otherwise keep the original metab
newReac->setReversible(sourceReac->isReversible());
std::map<std::string, std::string>::const_iterator mapIt;
std::string targetKey;
size_t j, jmax = sourceReac->getChemEq().getSubstrates().size();
for (j = 0; j < jmax; ++j)
{
const CChemEqElement * sourceElement = &sourceReac->getChemEq().getSubstrates()[j];
//check if the metab is in the map. If yes, translate it, otherwise not.
mapIt = keyMap.find(sourceElement->getMetaboliteKey());
if (mapIt == keyMap.end())
{
targetKey = sourceElement->getMetaboliteKey();
}
else
targetKey = mapIt->second;
newReac->addSubstrate(targetKey, sourceElement->getMultiplicity());
}
jmax = sourceReac->getChemEq().getProducts().size();
for (j = 0; j < jmax; ++j)
{
const CChemEqElement * sourceElement = &sourceReac->getChemEq().getProducts()[j];
//check if the metab is in the map. If yes, translate it, otherwise not.
mapIt = keyMap.find(sourceElement->getMetaboliteKey());
if (mapIt == keyMap.end())
{
targetKey = sourceElement->getMetaboliteKey();
}
else
targetKey = mapIt->second;
newReac->addProduct(targetKey, sourceElement->getMultiplicity());
}
jmax = sourceReac->getChemEq().getModifiers().size();
for (j = 0; j < jmax; ++j)
{
const CChemEqElement * sourceElement = &sourceReac->getChemEq().getModifiers()[j];
//check if the metab is in the map. If yes, translate it, otherwise not.
mapIt = keyMap.find(sourceElement->getMetaboliteKey());
if (mapIt == keyMap.end())
{
targetKey = sourceElement->getMetaboliteKey();
}
else
targetKey = mapIt->second;
newReac->addModifier(targetKey);
}
//set the kinetic function
newReac->setFunction(const_cast<CFunction*>(sourceReac->getFunction()));
//mapping and local parameters
for (j = 0; j < newReac->getFunctionParameters().size(); ++j)
{
switch (newReac->getFunctionParameters()[j]->getUsage())
{
case CFunctionParameter::SUBSTRATE:
case CFunctionParameter::PRODUCT:
case CFunctionParameter::MODIFIER:
//translate the metab keys
{
bool isVector = (newReac->getFunctionParameters()[j]->getType() == CFunctionParameter::VFLOAT64);
//we assume that only SUBSTRATE, PRODUCT, MODIFIER can be vectors
if (isVector)
newReac->clearParameterMapping(j);
size_t k;
for (k = 0; k < sourceReac->getParameterMappings()[j].size(); ++k)
{
mapIt = keyMap.find(sourceReac->getParameterMappings()[j][k]);
if (mapIt == keyMap.end())
{
targetKey = sourceReac->getParameterMappings()[j][k];
}
else
targetKey = mapIt->second;
if (isVector)
newReac->addParameterMapping(j, targetKey);
else
newReac->setParameterMapping(j, targetKey);
}
}
break;
case CFunctionParameter::TIME:
//just copy the key
{
mapIt = keyMap.find(sourceReac->getParameterMappings()[j][0]);
if (mapIt == keyMap.end())
{
targetKey = sourceReac->getParameterMappings()[j][0];
}
else
targetKey = mapIt->second;
newReac->setParameterMapping(j, targetKey);
}
break;
case CFunctionParameter::VOLUME:
//translate the compartment key if necessary
if (sourceReac->getParameterMappings()[j][0] == sourceComp->getKey())
newReac->setParameterMapping(j, keyMap[sourceComp->getKey()]);
else
{
mapIt = keyMap.find(sourceReac->getParameterMappings()[j][0]);
if (mapIt == keyMap.end())
{
targetKey = sourceReac->getParameterMappings()[j][0];
}
else
targetKey = mapIt->second;
newReac->setParameterMapping(j, targetKey);
}
//TODO: this needs to be adapted when sets of compartments will be copied
break;
case CFunctionParameter::PARAMETER:
if (sourceReac->isLocalParameter(j))
newReac->setParameterValue(newReac->getFunctionParameters()[j]->getObjectName(),
sourceReac->getParameterValue(newReac->getFunctionParameters()[j]->getObjectName()));
else
{
mapIt = keyMap.find(sourceReac->getParameterMappings()[j][0]);
if (mapIt == keyMap.end())
{
targetKey = sourceReac->getParameterMappings()[j][0];
}
else
targetKey = mapIt->second;
newReac->setParameterMapping(j, targetKey);
}
break;
default:
return info;
break;
}
}
}
}
}
return true;
}
