#include <CModelMerging.h>

Collaboration diagram for CModelAdd:

Public Member Functions
	CModelAdd (CModel pModel, CModel mModel)

void	setModel (CModel pModel, CModel mModel)

void	simpleCall ()
	just a simple method to call during development More...

Protected Member Functions
bool	addCompartments (std::string name)

bool	addCompartmentsExpressions ()

bool	addEvents (std::string name)

bool	addMetabolites (std::string name)

bool	addMetabolitesExpressions ()

bool	addModelValues (std::string name)

bool	addModelValuesExpressions ()

bool	addReactions (std::string name)

bool	copyDelayExpression (const CEvent sourceEvent, CEvent newEvent)

bool	copyEventAssignmentExpression (const CEventAssignment sourceAssignment, CEventAssignment newAssignment)

bool	copyExpression (const CModelEntity sourceEntity, CModelEntity newEntity)

bool	copyInitialExpression (const CModelEntity sourceEntity, CModelEntity newEntity)

bool	copyTriggerExpression (const CEvent sourceEvent, CEvent newEvent)

Static Protected Member Functions
static bool	reactionInvolvesCompartment (const CReaction reac, const CCompartment comp)

Protected Attributes
std::map< std::string, std::string >	keyMap

CModel *	mmModel

CModel *	mpModel

std::map< std::string, std::string >	nameMap

Detailed Description

Definition at line 30 of file CModelMerging.h.

Constructor & Destructor Documentation

CModelAdd::CModelAdd	(	CModel *	pModel,
		CModel *	mModel
	)

Definition at line 28 of file CModelMerging.cpp.

     : mpModel(pModel), mmModel(mModel)
 {
 }

Member Function Documentation

bool CModelAdd::addCompartments ( std::string name )

protected

Definition at line 448 of file CModelMerging.cpp.

References CModel::createCompartment(), CModel::getCompartments(), CCompartment::getDimensionality(), CModelEntity::getInitialValue(), CModelEntity::getKey(), CCopasiObject::getObjectName(), CModelEntity::getStatus(), keyMap, mmModel, mpModel, nameMap, CCompartment::setDimensionality(), CModelEntity::setStatus(), and CCopasiVector< T >::size().

Referenced by simpleCall().

 {
 
   size_t i, imax = mmModel->getCompartments().size();
 
   for (i = 0; i < imax; ++i)
     {
       const CCompartment* sourceComp = mmModel->getCompartments()[i];
 
       if (!sourceComp) return false;
 
       //create new compartment
 
       std::string newName = sourceComp->getObjectName() + "_" + name;
 
       CCompartment* newComp = mpModel->createCompartment(newName, sourceComp->getInitialValue());
 
       if (!newComp) return false;
 
       newComp->setStatus(sourceComp->getStatus());
 
       newComp->setDimensionality(sourceComp->getDimensionality());
 
       keyMap[sourceComp->getKey()] = newComp->getKey();
       nameMap[sourceComp->getObjectName()] = newName;
     }
 
   return true;
 }

bool CModelAdd::addCompartmentsExpressions ( )

protected

Definition at line 478 of file CModelMerging.cpp.

References CModelEntity::ASSIGNMENT, copyExpression(), copyInitialExpression(), CModelEntity::FIXED, CKeyFactory::get(), CModel::getCompartments(), CModelEntity::getInitialExpression(), CModelEntity::getKey(), CCopasiRootContainer::getKeyFactory(), keyMap, mmModel, CModelEntity::ODE, and CCopasiVector< T >::size().

Referenced by simpleCall().

 {
 
   bool info = false;
 
   size_t i, imax = mmModel->getCompartments().size();
 
   for (i = 0; i < imax; ++i)
     {
       const CCompartment* sourceComp = mmModel->getCompartments()[i];
 
       if (!sourceComp) return info;
 
       std::string newKey = keyMap[sourceComp->getKey()];
 
       CCopasiObject*  pObject = (CCopasiRootContainer::getKeyFactory()->get(newKey));
 
       CCompartment*  newComp = dynamic_cast< CCompartment * >(pObject);
 
       if (!newComp) return info;
 
       switch (newComp ->getStatus())
         {
           case CModelEntity::FIXED:
 
             break;
           case CModelEntity::ASSIGNMENT:
 
             if (!copyExpression(sourceComp, newComp)) return info;
 
             break;
 
           case CModelEntity::ODE:
 
             if (!copyExpression(sourceComp, newComp)) return info;
 
             if (sourceComp->getInitialExpression() != "")
               if (!copyInitialExpression(sourceComp, newComp)) return info;
 
             break;
 
           default:
 
             return info;
 
             break;
         }
     }
 
   return true;
 }

bool CModelAdd::addEvents ( std::string name )

protected

Definition at line 75 of file CModelMerging.cpp.

References CCopasiVectorN< CType >::add(), C_INVALID_INDEX, copyDelayExpression(), copyEventAssignmentExpression(), copyTriggerExpression(), CModel::createEvent(), CEvent::getAssignments(), CEvent::getDelayAssignment(), CEvent::getDelayExpressionPtr(), CModel::getEvents(), CEventAssignment::getExpressionPtr(), CCopasiVectorN< CType >::getIndex(), CCopasiObject::getObjectName(), CEventAssignment::getTargetKey(), CEvent::getTriggerExpressionPtr(), keyMap, mmModel, mpModel, CEvent::setDelayAssignment(), CEventAssignment::setTargetKey(), and CCopasiVector< T >::size().

Referenced by simpleCall().

 {
 
   bool info = false;
 
   size_t i, imax = mmModel->getEvents().size();
 
   for (i = 0; i < imax; ++i)
     {
       const CEvent* sourceEvent = mmModel->getEvents()[i];
 
       if (!sourceEvent) return info;
 
       //create new event
 
       std::string eventName;
 
       eventName = sourceEvent->getObjectName();
 
       std::string appendix = "";
 #if 0
       unsigned int counter = 2;
       std::ostringstream numberStream;
 
       while (mpModel->getEvents().getIndex(eventName + appendix) != C_INVALID_INDEX)
         {
           numberStream.str("");
           numberStream << "_" << counter;
           counter++;
           appendix = numberStream.str();
         }
 
 #else
       appendix = "_" + name;
 #endif
 
       CEvent* newEvent = mpModel->createEvent(eventName + appendix);
 
       if (newEvent == NULL) return info;
 
       /* copy trigger expression */
 
       if (sourceEvent->getTriggerExpressionPtr() != NULL)
         {
           if (!copyTriggerExpression(sourceEvent, newEvent))
             return info;
         }
       else
         {
           return info;
         }
 
       /* set whether the calculation or the assignment shall be delayed */
 
       newEvent->setDelayAssignment(sourceEvent->getDelayAssignment());
 
       /* copy the delay expression */
 
       if (sourceEvent->getDelayExpressionPtr() != NULL)
         if (!copyDelayExpression(sourceEvent, newEvent)) return info;
 
       /* copy the assignments */
 
       size_t j, jmax = sourceEvent->getAssignments().size();
 
       for (j = 0; j < jmax; ++j)
         {
           const CEventAssignment* sourceAssignment = sourceEvent->getAssignments()[j];
 
           if (!sourceAssignment) return info;
 
           std::string key = sourceAssignment->getTargetKey();
 
           CEventAssignment* newAssignment = new CEventAssignment;
 
           newEvent->getAssignments().add(newAssignment, true);
 
           newAssignment->setTargetKey(keyMap[key]);
 
           if (sourceAssignment->getExpressionPtr() != NULL)
             {
               if (!copyEventAssignmentExpression(sourceAssignment, newAssignment))
                 return info;
             }
           else
             {
               return info;
             }
         }
     }
 
   return true;
 }

bool CModelAdd::addMetabolites ( std::string name )

protected

Definition at line 530 of file CModelMerging.cpp.

References CModel::createMetabolite(), CMetab::getCompartment(), CMetab::getInitialConcentration(), CModelEntity::getKey(), CModel::getMetabolites(), CCopasiObject::getObjectName(), CModelEntity::getStatus(), keyMap, mmModel, mpModel, nameMap, CMetab::setStatus(), and CCopasiVector< T >::size().

Referenced by simpleCall().

 {
   bool info = false;
 
   size_t i, imax = mmModel->getMetabolites().size();
 
   for (i = 0; i < imax; ++i)
     {
       const CMetab* sourceMetab = mmModel->getMetabolites()[i];
       const CCompartment* sourceComp =  sourceMetab->getCompartment();
 
       if (!sourceMetab) return info;
 
       if (!sourceComp) return info;
 
       //create new metabolite
 
       std::string newName = sourceMetab->getObjectName() + "_" + name;
 
       CMetab* newMetab = mpModel->createMetabolite(sourceMetab->getObjectName(), nameMap[sourceComp->getObjectName()], sourceMetab->getInitialConcentration());
 
       if (!newMetab) return info;
 
       newMetab->setStatus(sourceMetab->getStatus());
 
       keyMap[sourceMetab->getKey()] = newMetab->getKey();
       nameMap[sourceMetab->getObjectName()] = newName;
     }
 
   return true;
 }

bool CModelAdd::addMetabolitesExpressions ( )

protected

Definition at line 562 of file CModelMerging.cpp.

References CModelEntity::ASSIGNMENT, copyExpression(), copyInitialExpression(), CModelEntity::FIXED, CKeyFactory::get(), CModelEntity::getInitialExpression(), CModelEntity::getKey(), CCopasiRootContainer::getKeyFactory(), CModel::getMetabolites(), keyMap, mmModel, CModelEntity::ODE, CModelEntity::REACTIONS, and CCopasiVector< T >::size().

Referenced by simpleCall().

 {
   bool info = false;
 
   size_t i, imax = mmModel->getMetabolites().size();
 
   for (i = 0; i < imax; ++i)
     {
       const CMetab* sourceMetab = mmModel->getMetabolites()[i];
 
       if (!sourceMetab) return info;
 
       std::string newKey = keyMap[sourceMetab->getKey()];
 
       CCopasiObject*  pObject = (CCopasiRootContainer::getKeyFactory()->get(newKey));
 
       CMetab*  newMetab = dynamic_cast< CMetab * >(pObject);
 
       if (!newMetab) return info;
 
       switch (newMetab ->getStatus())
         {
           case CModelEntity::FIXED:
 
             break;
           case CModelEntity::ASSIGNMENT:
 
             if (!copyExpression(sourceMetab, newMetab)) return info;
 
             break;
 
           case CModelEntity::ODE:
 
             if (!copyExpression(sourceMetab, newMetab)) return info;
 
             if (sourceMetab->getInitialExpression() != "")
               if (!copyInitialExpression(sourceMetab, newMetab)) return info;
 
             break;
 
           case CModelEntity::REACTIONS:
 
             break;
           default:
 
             return info;
 
             break;
         }
     }
 
   return true;
 }

bool CModelAdd::addModelValues ( std::string name )

protected

Definition at line 616 of file CModelMerging.cpp.

References CModel::createModelValue(), CModelEntity::getInitialValue(), CModelEntity::getKey(), CModel::getModelValues(), CCopasiObject::getObjectName(), CModelEntity::getStatus(), keyMap, mmModel, mpModel, nameMap, CModelEntity::setStatus(), and CCopasiVector< T >::size().

Referenced by simpleCall().

 {
   bool info = false;
 
   size_t i, imax = mmModel->getModelValues().size();
 
   for (i = 0; i < imax; ++i)
     {
       const CModelValue* sourceModVal = mmModel->getModelValues()[i];
 
       if (!sourceModVal) return info;
 
       //create new model value
 
       std::string newName = sourceModVal->getObjectName() + "_" + name;
 
       CModelValue* newModVal = mpModel->createModelValue(newName, sourceModVal->getInitialValue());
 
       if (!newModVal) return info;
 
       newModVal->setStatus(sourceModVal->getStatus());
 
       keyMap[sourceModVal->getKey()] = newModVal->getKey();
       nameMap[sourceModVal->getObjectName()] = newName;
     }
 
   return true;
 }

bool CModelAdd::addModelValuesExpressions ( )

protected

Definition at line 645 of file CModelMerging.cpp.

References CModelEntity::ASSIGNMENT, copyExpression(), copyInitialExpression(), CModelEntity::FIXED, CKeyFactory::get(), CModelEntity::getInitialExpression(), CModelEntity::getKey(), CCopasiRootContainer::getKeyFactory(), CModel::getModelValues(), keyMap, mmModel, CModelEntity::ODE, and CCopasiVector< T >::size().

Referenced by simpleCall().

 {
   bool info = false;
 
   size_t i, imax = mmModel->getModelValues().size();
 
   for (i = 0; i < imax; ++i)
     {
       const CModelValue* sourceModVal = mmModel->getModelValues()[i];
 
       if (!sourceModVal) return info;
 
       std::string newKey = keyMap[sourceModVal->getKey()];
 
       CCopasiObject*  pObject = (CCopasiRootContainer::getKeyFactory()->get(newKey));
 
       CModelValue*  newModVal = dynamic_cast<CModelValue * >(pObject);
 
       if (!newModVal) return info;
 
       switch (newModVal ->getStatus())
         {
           case CModelEntity::FIXED:
 
             break;
           case CModelEntity::ASSIGNMENT:
 
             if (!copyExpression(sourceModVal, newModVal)) return info;
 
             break;
 
           case CModelEntity::ODE:
 
             if (!copyExpression(sourceModVal, newModVal)) return info;
 
             if (sourceModVal->getInitialExpression() != "")
               if (!copyInitialExpression(sourceModVal, newModVal)) return info;
 
             break;
 
           default:
 
             return info;
 
             break;
         }
     }
 
   return true;
 }

bool CModelAdd::addReactions ( std::string name )

protected

Definition at line 696 of file CModelMerging.cpp.

References CReaction::addModifier(), CReaction::addParameterMapping(), CReaction::addProduct(), CReaction::addSubstrate(), CReaction::clearParameterMapping(), CModel::createReaction(), CReaction::getChemEq(), CModel::getCompartments(), CReaction::getFunction(), CReaction::getFunctionParameters(), CModelEntity::getKey(), CChemEqElement::getMetaboliteKey(), CChemEq::getModifiers(), CChemEqElement::getMultiplicity(), CCopasiObject::getObjectName(), CReaction::getParameterMappings(), CReaction::getParameterValue(), CChemEq::getProducts(), CModel::getReactions(), CChemEq::getSubstrates(), CReaction::isLocalParameter(), CReaction::isReversible(), keyMap, mmModel, CFunctionParameter::MODIFIER, mpModel, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, reactionInvolvesCompartment(), CReaction::setFunction(), CReaction::setParameterMapping(), CReaction::setParameterValue(), CReaction::setReversible(), CFunctionParameters::size(), CCopasiVector< T >::size(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, CFunctionParameter::VFLOAT64, and CFunctionParameter::VOLUME.

Referenced by simpleCall().

 {
 
   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;
 }

bool CModelAdd::copyDelayExpression	(	const CEvent *	sourceEvent,
		CEvent *	newEvent
	)

protected

Definition at line 224 of file CModelMerging.cpp.

References CKeyFactory::get(), CCopasiObject::getCN(), CEvent::getDelayExpressionPtr(), CEvaluationTree::getInfix(), CCopasiRootContainer::getKeyFactory(), CEvaluationTree::getNodeList(), CCopasiContainer::getObject(), CEvaluationNodeObject::getObjectCN(), CCopasiObject::getObjectDataModel(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CCopasiObject::isReference(), keyMap, mmModel, CEvaluationNode::OBJECT, CEvaluationNodeObject::setData(), CEvent::setDelayExpression(), CEvaluationNode::type(), and CEvaluationTree::updateTree().

Referenced by addEvents().

 {
 
   bool info = false;
 
   const CExpression* pExpression = sourceEvent->getDelayExpressionPtr();
 
   if (pExpression == NULL) return info;
 
   CExpression* tmp;
   tmp = new CExpression(*pExpression, mmModel);
 
   const std::vector<CEvaluationNode*>& objectNodes = tmp->getNodeList();
   size_t j, jmax = objectNodes.size();
 
   for (j = 0; j < jmax; ++j)
     {
       if (CEvaluationNode::type(objectNodes[j]->getType()) == CEvaluationNode::OBJECT)
         {
           CEvaluationNodeObject* pObjectNode = dynamic_cast<CEvaluationNodeObject*>(objectNodes[j]);
 
           if (pObjectNode == NULL) return info;
 
           CCopasiObjectName cn = pObjectNode->getObjectCN();
 
           const CCopasiObject* mObject =
             static_cast< const CCopasiObject * >(mmModel->getObjectDataModel()->getObject(cn));
 
           if (mObject == NULL) return info;
 
           std::string host = "";
 
           if (mObject->isReference())
             {
               host = ",Reference=" + mObject->getObjectName();
               mObject = mObject->getObjectParent();
             }
 
           if (mObject == NULL) return info;
 
           std::string key = keyMap[(dynamic_cast<const CModelEntity * >(mObject))->getKey()];
           CCopasiObject*  pObject = (CCopasiRootContainer::getKeyFactory()->get(key));
 
           cn = pObject->getCN() + host;
 
           pObjectNode->setData("<" + cn + ">");
         }
     }
 
   tmp->updateTree();
 
   newEvent->setDelayExpression(tmp->getInfix().c_str());
 
   return true;
 }

bool CModelAdd::copyEventAssignmentExpression	(	const CEventAssignment *	sourceAssignment,
		CEventAssignment *	newAssignment
	)

protected

Definition at line 168 of file CModelMerging.cpp.

References CKeyFactory::get(), CCopasiObject::getCN(), CEventAssignment::getExpressionPtr(), CEvaluationTree::getInfix(), CCopasiRootContainer::getKeyFactory(), CEvaluationTree::getNodeList(), CCopasiContainer::getObject(), CEvaluationNodeObject::getObjectCN(), CCopasiObject::getObjectDataModel(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CCopasiObject::isReference(), keyMap, mmModel, CEvaluationNode::OBJECT, CEvaluationNodeObject::setData(), CEventAssignment::setExpression(), CEvaluationNode::type(), and CEvaluationTree::updateTree().

Referenced by addEvents().

 {
 
   bool info = false;
 
   const CExpression* pExpression = sourceAssignment->getExpressionPtr();
 
   if (pExpression == NULL) return info;
 
   CExpression* tmp;
   tmp = new CExpression(*pExpression, mmModel);
 
   const std::vector<CEvaluationNode*>& objectNodes = tmp->getNodeList();
   size_t j, jmax = objectNodes.size();
 
   for (j = 0; j < jmax; ++j)
     {
       if (CEvaluationNode::type(objectNodes[j]->getType()) == CEvaluationNode::OBJECT)
         {
           CEvaluationNodeObject* pObjectNode = dynamic_cast<CEvaluationNodeObject*>(objectNodes[j]);
 
           if (pObjectNode == NULL) return info;
 
           CCopasiObjectName cn = pObjectNode->getObjectCN();
 
           const CCopasiObject* mObject =
             static_cast< const CCopasiObject * >(mmModel->getObjectDataModel()->getObject(cn));
 
           if (mObject == NULL) return info;
 
           std::string host = "";
 
           if (mObject->isReference())
             {
               host = ",Reference=" + mObject->getObjectName();
               mObject = mObject->getObjectParent();
             }
 
           if (mObject == NULL) return info;
 
           std::string key = keyMap[(dynamic_cast<const CModelEntity * >(mObject))->getKey()];
           CCopasiObject*  pObject = (CCopasiRootContainer::getKeyFactory()->get(key));
 
           cn = pObject->getCN() + host;
 
           pObjectNode->setData("<" + cn + ">");
         }
     }
 
   tmp->updateTree();
 
   newAssignment->setExpression(tmp->getInfix().c_str());
 
   return true;
 }

bool CModelAdd::copyExpression	(	const CModelEntity *	sourceEntity,
		CModelEntity *	newEntity
	)

protected

Definition at line 336 of file CModelMerging.cpp.

References CKeyFactory::get(), CCopasiObject::getCN(), CModelEntity::getExpressionPtr(), CEvaluationTree::getInfix(), CCopasiRootContainer::getKeyFactory(), CEvaluationTree::getNodeList(), CCopasiContainer::getObject(), CEvaluationNodeObject::getObjectCN(), CCopasiObject::getObjectDataModel(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CCopasiObject::isReference(), keyMap, mmModel, CEvaluationNode::OBJECT, CEvaluationNodeObject::setData(), CModelEntity::setExpression(), CEvaluationNode::type(), and CEvaluationTree::updateTree().

Referenced by addCompartmentsExpressions(), addMetabolitesExpressions(), and addModelValuesExpressions().

 {
 
   bool info = false;
 
   const CExpression* pExpression = sourceEntity->getExpressionPtr();
 
   if (pExpression == NULL) return info;
 
   CExpression* tmp;
   tmp = new CExpression(*pExpression, mmModel);
 
   const std::vector<CEvaluationNode*>& objectNodes = tmp->getNodeList();
   size_t j, jmax = objectNodes.size();
 
   for (j = 0; j < jmax; ++j)
     {
       if (CEvaluationNode::type(objectNodes[j]->getType()) == CEvaluationNode::OBJECT)
         {
           CEvaluationNodeObject* pObjectNode = dynamic_cast<CEvaluationNodeObject*>(objectNodes[j]);
 
           if (pObjectNode == NULL) return info;
 
           CCopasiObjectName cn = pObjectNode->getObjectCN();
 
           const CCopasiObject* mObject =
             static_cast< const CCopasiObject * >(mmModel->getObjectDataModel()->getObject(cn));
 
           if (mObject == NULL) return info;
 
           std::string host = "";
 
           if (mObject->isReference())
             {
               host = ",Reference=" + mObject->getObjectName();
               mObject = mObject->getObjectParent();
             }
 
           if (mObject == NULL) return info;
 
           std::string key = keyMap[(dynamic_cast<const CModelEntity * >(mObject))->getKey()];
           CCopasiObject*  pObject = (CCopasiRootContainer::getKeyFactory()->get(key));
 
           cn = pObject->getCN() + host;
 
           pObjectNode->setData("<" + cn + ">");
         }
     }
 
   tmp->updateTree();
 
   newEntity->setExpression(tmp->getInfix().c_str());
 
   return true;
 }

bool CModelAdd::copyInitialExpression	(	const CModelEntity *	sourceEntity,
		CModelEntity *	newEntity
	)

protected

Definition at line 392 of file CModelMerging.cpp.

References CKeyFactory::get(), CCopasiObject::getCN(), CEvaluationTree::getInfix(), CModelEntity::getInitialExpressionPtr(), CCopasiRootContainer::getKeyFactory(), CEvaluationTree::getNodeList(), CCopasiContainer::getObject(), CEvaluationNodeObject::getObjectCN(), CCopasiObject::getObjectDataModel(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CCopasiObject::isReference(), keyMap, mmModel, CEvaluationNode::OBJECT, CEvaluationNodeObject::setData(), CModelEntity::setInitialExpression(), CEvaluationNode::type(), and CEvaluationTree::updateTree().

Referenced by addCompartmentsExpressions(), addMetabolitesExpressions(), and addModelValuesExpressions().

 {
 
   bool info = false;
 
   const CExpression* pExpression = sourceEntity->getInitialExpressionPtr();
 
   if (pExpression == NULL) return info;
 
   CExpression* tmp;
   tmp = new CExpression(*pExpression, mmModel);
 
   const std::vector<CEvaluationNode*>& objectNodes = tmp->getNodeList();
   size_t j, jmax = objectNodes.size();
 
   for (j = 0; j < jmax; ++j)
     {
       if (CEvaluationNode::type(objectNodes[j]->getType()) == CEvaluationNode::OBJECT)
         {
           CEvaluationNodeObject* pObjectNode = dynamic_cast<CEvaluationNodeObject*>(objectNodes[j]);
 
           if (pObjectNode == NULL) return info;
 
           CCopasiObjectName cn = pObjectNode->getObjectCN();
 
           const CCopasiObject* mObject =
             static_cast< const CCopasiObject * >(mmModel->getObjectDataModel()->getObject(cn));
 
           if (mObject == NULL) return info;
 
           std::string host = "";
 
           if (mObject->isReference())
             {
               host = ",Reference=" + mObject->getObjectName();
               mObject = mObject->getObjectParent();
             }
 
           if (mObject == NULL) return info;
 
           std::string key = keyMap[(dynamic_cast<const CModelEntity * >(mObject))->getKey()];
           CCopasiObject*  pObject = (CCopasiRootContainer::getKeyFactory()->get(key));
 
           cn = pObject->getCN() + host;
 
           pObjectNode->setData("<" + cn + ">");
         }
     }
 
   tmp->updateTree();
 
   newEntity->setInitialExpression(tmp->getInfix().c_str());
 
   return info;
 }

bool CModelAdd::copyTriggerExpression	(	const CEvent *	sourceEvent,
		CEvent *	newEvent
	)

protected

Definition at line 280 of file CModelMerging.cpp.

References CKeyFactory::get(), CCopasiObject::getCN(), CEvaluationTree::getInfix(), CCopasiRootContainer::getKeyFactory(), CEvaluationTree::getNodeList(), CCopasiContainer::getObject(), CEvaluationNodeObject::getObjectCN(), CCopasiObject::getObjectDataModel(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CEvent::getTriggerExpressionPtr(), CCopasiObject::isReference(), keyMap, mmModel, CEvaluationNode::OBJECT, CEvaluationNodeObject::setData(), CEvent::setTriggerExpression(), CEvaluationNode::type(), and CEvaluationTree::updateTree().

Referenced by addEvents().

 {
 
   bool info = false;
 
   const CExpression* pExpression = sourceEvent->getTriggerExpressionPtr();
 
   if (pExpression == NULL) return info;
 
   CExpression* tmp;
   tmp = new CExpression(*pExpression, mmModel);
 
   const std::vector<CEvaluationNode*>& objectNodes = tmp->getNodeList();
   size_t j, jmax = objectNodes.size();
 
   for (j = 0; j < jmax; ++j)
     {
       if (CEvaluationNode::type(objectNodes[j]->getType()) == CEvaluationNode::OBJECT)
         {
           CEvaluationNodeObject* pObjectNode = dynamic_cast<CEvaluationNodeObject*>(objectNodes[j]);
 
           if (pObjectNode == NULL) return info;
 
           CCopasiObjectName cn = pObjectNode->getObjectCN();
 
           const CCopasiObject* mObject =
             static_cast< const CCopasiObject * >(mmModel->getObjectDataModel()->getObject(cn));
 
           if (mObject == NULL) return info;
 
           std::string host = "";
 
           if (mObject->isReference())
             {
               host = ",Reference=" + mObject->getObjectName();
               mObject = mObject->getObjectParent();
             }
 
           if (mObject == NULL) return info;
 
           std::string key = keyMap[(dynamic_cast<const CModelEntity * >(mObject))->getKey()];
           CCopasiObject*  pObject = (CCopasiRootContainer::getKeyFactory()->get(key));
 
           cn = pObject->getCN() + host;
 
           pObjectNode->setData("<" + cn + ">");
         }
     }
 
   tmp->updateTree();
 
   newEvent->setTriggerExpression(tmp->getInfix().c_str());
 
   return true;
 }

bool CModelAdd::reactionInvolvesCompartment	(	const CReaction *	reac,
		const CCompartment *	comp
	)

staticprotected

determine whether the one of the substrate, products, or modifiers of the reaction is located in the given compartment

Definition at line 898 of file CModelMerging.cpp.

References CReaction::getChemEq(), CChemEq::getModifiers(), CChemEq::getProducts(), CChemEq::getSubstrates(), and CCopasiVector< T >::size().

Referenced by addReactions().

 {
   if (!reac) return false;
 
   if (!comp) return false;
 
   size_t i, imax = reac->getChemEq().getSubstrates().size();
 
   for (i = 0; i < imax; ++i)
     if (reac->getChemEq().getSubstrates()[i]->getMetabolite()->getCompartment() == comp)
       return true;
 
   imax = reac->getChemEq().getProducts().size();
 
   for (i = 0; i < imax; ++i)
     if (reac->getChemEq().getProducts()[i]->getMetabolite()->getCompartment() == comp)
       return true;
 
   imax = reac->getChemEq().getModifiers().size();
 
   for (i = 0; i < imax; ++i)
     if (reac->getChemEq().getModifiers()[i]->getMetabolite()->getCompartment() == comp)
       return true;
 
   return false;
 }

void CModelAdd::setModel	(	CModel *	pModel,
		CModel *	mModel
	)

Definition at line 33 of file CModelMerging.cpp.

References mmModel, and mpModel.

 {
   mpModel = pModel;
   mmModel = mModel;
 }

void CModelAdd::simpleCall ( )

just a simple method to call during development

Definition at line 39 of file CModelMerging.cpp.

References addCompartments(), addCompartmentsExpressions(), addEvents(), addMetabolites(), addMetabolitesExpressions(), addModelValues(), addModelValuesExpressions(), addReactions(), CModel::compileIfNecessary(), CCopasiMessage::ERROR, fatalError, CModel::getKey(), keyMap, MCModelMerging, mmModel, and mpModel.

 {
   if (!mpModel)
     {
       fatalError();
     }
 
   if (!mmModel)
     {
       fatalError();
     }
 
   keyMap[mmModel->getKey()] = mpModel->getKey();
 
   std::string name = "model_2"; // temporary we do not take care about naming conflicts.
   // : "model_2" is the appendix for the names  of compartments and reactions,
   // comming form the second model
 
   bool  progress  =      addCompartments(name)
                          &&  addMetabolites(name)
                          &&  addModelValues(name)
                          &&  addCompartmentsExpressions()
                          &&  addMetabolitesExpressions()
                          &&  addModelValuesExpressions()
                          &&  addReactions(name)
                          &&  addEvents(name);
 
   if (!progress)
     {
       CCopasiMessage(CCopasiMessage::ERROR, MCModelMerging + 1);
       return;
     }
 
   mpModel->compileIfNecessary(NULL);
 }