CModelMerging Class Reference

#include <CModelMerging.h>

Collaboration diagram for CModelMerging:

Public Types
enum	Type { ignore = 0, merge }

Public Member Functions
	CModelMerging (CModel *pModel)
void	setModel (CModel *pModel)
void	simpleCall (std::vector< std::string > &toKey, std::vector< std::string > &objectKey)
	just a simple method to call during development More...

Static Public Attributes
static const std::string	TypeName []

Protected Member Functions
bool	mergeInExpression (std::string toKey, std::string key, CExpression *pExpression)
bool	mergeMetabolites (std::string toKey, std::string key)

Protected Attributes
CModel *	mpModel

Detailed Description

Definition at line 72 of file CModelMerging.h.

Member Enumeration Documentation

enum CModelMerging::Type

Enumeration of the types of columns known to COPASI.

Enumerator
ignore
merge

Definition at line 85 of file CModelMerging.h.

  {
    ignore = 0,
    merge
  };

Constructor & Destructor Documentation

CModelMerging::CModelMerging

(

CModel *

pModel

)

Definition at line 932 of file CModelMerging.cpp.

    : mpModel(pModel)
{
}

Member Function Documentation

bool CModelMerging::mergeInExpression ( std::string  toKey, std::string  key, CExpression *  pExpression  )

protected

Definition at line 1219 of file CModelMerging.cpp.

References CKeyFactory::get(), CCopasiObject::getCN(), CCopasiObject::getKey(), CCopasiRootContainer::getKeyFactory(), CEvaluationTree::getNodeList(), CCopasiContainer::getObject(), CEvaluationNodeObject::getObjectCN(), CCopasiObject::getObjectDataModel(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CCopasiObject::isReference(), mpModel, CEvaluationNode::OBJECT, CEvaluationNodeObject::setData(), CEvaluationNode::type(), and CEvaluationTree::updateTree().

Referenced by mergeMetabolites().

{

  bool info = false;

  if (pExpression == NULL) return info;

  const std::vector<CEvaluationNode*>& objectNodes = pExpression->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 * >(mpModel->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;

          CCopasiObject* pObject;

          std::string ikey = (dynamic_cast<const CModelEntity * >(mObject))->getKey();

          if (ikey == key)
            {
              pObject = (CCopasiRootContainer::getKeyFactory()->get(toKey));

              cn = pObject->getCN() + host;

              pObjectNode->setData("<" + cn + ">");
            }
        }
    }

  pExpression->updateTree();

  return true;
}

bool CModelMerging::mergeMetabolites ( std::string  toKey, std::string  key  )

protected

Definition at line 989 of file CModelMerging.cpp.

References CModelEntity::ASSIGNMENT, CModelEntity::FIXED, CReaction::getChemEq(), CModel::getCompartments(), CModel::getEvents(), CEventAssignment::getExpressionPtr(), CModelEntity::getExpressionPtr(), CReaction::getFunctionParameters(), CModelEntity::getInitialExpression(), CModelEntity::getInitialExpressionPtr(), CModelEntity::getKey(), CChemEqElement::getMetabolite(), CModel::getMetabolites(), CModel::getModelValues(), CChemEq::getModifiers(), CReaction::getParameterMappings(), CChemEq::getProducts(), CModel::getReactions(), CModelEntity::getStatus(), CChemEq::getSubstrates(), CEventAssignment::getTargetKey(), mergeInExpression(), CFunctionParameter::MODIFIER, mpModel, CModelEntity::ODE, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, CModelEntity::REACTIONS, CChemEqElement::setMetabolite(), CEventAssignment::setTargetKey(), CFunctionParameters::size(), CCopasiVector< T >::size(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, and CFunctionParameter::VOLUME.

Referenced by simpleCall().

{

  bool info = false;

  //merge in  the relevant reactions

  size_t i, imax = mpModel->getReactions().size();
  size_t j, jmax;

  for (i = 0; i < imax; ++i)
    {
      CReaction * reac = mpModel->getReactions()[i];

      jmax = reac->getChemEq().getSubstrates().size();

      for (j = 0; j < jmax; ++j)
        {
          CChemEqElement * subst = reac->getChemEq().getSubstrates()[j];

          if (subst->getMetabolite()->getKey() == key)
            subst->setMetabolite(toKey);
        }

      jmax = reac->getChemEq().getProducts().size();

      for (j = 0; j < jmax; ++j)
        {
          CChemEqElement * prod = reac->getChemEq().getProducts()[j];

          if (prod->getMetabolite()->getKey() == key)
            prod->setMetabolite(toKey);
        }

      jmax = reac->getChemEq().getModifiers().size();

      for (j = 0; j < jmax; ++j)
        {
          CChemEqElement * modif = reac->getChemEq().getModifiers()[j];

          if (modif->getMetabolite()->getKey() == key)
            modif->setMetabolite(toKey);
        }

      //change parameters of  the kinetic function

      for (j = 0; j < reac->getFunctionParameters().size(); ++j)
        {
          switch (reac->getFunctionParameters()[j]->getUsage())
            {
              case CFunctionParameter::SUBSTRATE:
              case CFunctionParameter::PRODUCT:
              case CFunctionParameter::MODIFIER:
                //translate the metab keys
              {

                //we assume that only SUBSTRATE, PRODUCT, MODIFIER can be vectors

                size_t k, kmax = reac->getParameterMappings()[j].size();

                for (k = 0; k < kmax; ++k)
                  if (reac->getParameterMappings()[j][k] == key)
                    reac->getParameterMappings()[j][k] = toKey;
              }
              break;

              case CFunctionParameter::TIME:
                break;

              case CFunctionParameter::VOLUME:
                // ??? TODO : have to ask
                break;

              case CFunctionParameter::PARAMETER:
                break;

              default:
                return info;
                break;
            }
        }
    }

  imax = mpModel->getEvents().size();

  for (i = 0; i < imax; ++i)
    {
      CEvent* event = mpModel->getEvents()[i];

      if (!event) return info;

      /* merge in  trigger expressions */
      CExpression* pExpression = event->getTriggerExpressionPtr();

      if (pExpression == NULL) return info;

      if (!mergeInExpression(toKey, key, pExpression))  return info;

      pExpression = event->getDelayExpressionPtr();

      if (pExpression)
        if (!mergeInExpression(toKey, key, pExpression))
          return info;

      jmax = event->getAssignments().size();

      for (j = 0; j < jmax; ++j)
        {
          CEventAssignment* assignment = event->getAssignments()[j];

          if (!assignment) return info;

          std::string assignmentKey = assignment->getTargetKey();

          if (assignmentKey == key) assignment->setTargetKey(toKey);

          pExpression = assignment->getExpressionPtr();

          if (pExpression == NULL) return info;

          if (!mergeInExpression(toKey, key, pExpression))    return info;
        }
    }

  imax = mpModel->getMetabolites().size();

  for (i = 0; i < imax; ++i)
    {
      CMetab* metab = mpModel->getMetabolites()[i];

      if (!metab) return info;

      switch (metab->getStatus())
        {
          case CModelEntity::FIXED:
          case CModelEntity::REACTIONS:

            break;
          case CModelEntity::ASSIGNMENT:

            if (!mergeInExpression(toKey, key, metab->getExpressionPtr())) return info;

            break;

          case CModelEntity::ODE:

            if (!mergeInExpression(toKey, key, metab->getExpressionPtr())) return info;

            if (metab->getInitialExpression() != "")
              if (!mergeInExpression(toKey, key, metab->getInitialExpressionPtr())) return info;

            break;

          default:
            return info;
            break;
        }
    }

  imax = mpModel->getCompartments().size();

  for (i = 0; i < imax; ++i)
    {
      CCompartment* comp = mpModel->getCompartments()[i];

      if (!comp) return info;

      switch (comp ->getStatus())
        {
          case CModelEntity::FIXED:

            break;
          case CModelEntity::ASSIGNMENT:

            if (!mergeInExpression(toKey, key, comp->getExpressionPtr())) return info;

            break;

          case CModelEntity::ODE:

            if (!mergeInExpression(toKey, key, comp->getExpressionPtr())) return info;

            if (comp->getInitialExpression() != "")
              if (!mergeInExpression(toKey, key, comp->getInitialExpressionPtr())) return info;

            break;

          default:
            return info;
            break;
        }
    }

  imax = mpModel->getModelValues().size();

  for (i = 0; i < imax; ++i)
    {
      CModelValue* modval = mpModel->getModelValues()[i];

      if (!modval) return info;

      switch (modval ->getStatus())
        {
          case CModelEntity::FIXED:

            break;
          case CModelEntity::ASSIGNMENT:

            if (!mergeInExpression(toKey, key, modval->getExpressionPtr())) return info;

            break;

          case CModelEntity::ODE:

            if (!mergeInExpression(toKey, key, modval->getExpressionPtr())) return info;

            if (modval->getInitialExpression() != "")
              if (!mergeInExpression(toKey, key, modval->getInitialExpressionPtr())) return info;

            break;

          default:
            return info;
            break;
        }
    }

  return true;
}

void CModelMerging::setModel

(

CModel *

pModel

)

Definition at line 937 of file CModelMerging.cpp.

References mpModel.

{
  mpModel = pModel;
}

void CModelMerging::simpleCall	(	std::vector< std::string > &	toKey,
		std::vector< std::string > &	objectKey
	)

just a simple method to call during development

Definition at line 942 of file CModelMerging.cpp.

References CModel::compileIfNecessary(), CCopasiMessage::ERROR, fatalError, CModelEntity::getKey(), CModel::getMetabolites(), CCopasiObject::getObjectName(), MCModelMerging, mergeMetabolites(), mpModel, CModel::removeMetabolite(), and CCopasiVector< T >::size().

{
  if (!mpModel)
    {
      fatalError();
    }

  size_t i, j, imax = mpModel->getMetabolites().size();

  CMetab * metab;
  CMetab * metab1;
  CMetab* tmp;
  std::string empty = "";

  for (i = 0; i < imax; ++i)
    {
      metab = mpModel->getMetabolites()[i];

      for (j = 0; j < imax; ++j)
        {
          if (objectKey[i] != "")
            {
              tmp = mpModel->getMetabolites()[j];

              if (tmp->getKey() == objectKey[i])
                {
                  metab1 = tmp;
                }
            }
        }

      if (! mergeMetabolites(metab->getKey(), objectKey[i]))
        {
          CCopasiMessage(CCopasiMessage::ERROR, MCModelMerging + 2,
                         metab1->getObjectName().c_str(), metab->getObjectName().c_str());
          return;
        }
    }

  for (i = 0; i < imax; ++i)
    {
      if (objectKey[i] != empty) mpModel->removeMetabolite(objectKey[i] , false);
    }

  mpModel->compileIfNecessary(NULL);
}

Member Data Documentation

CModel* CModelMerging::mpModel

protected

Definition at line 102 of file CModelMerging.h.

Referenced by mergeInExpression(), mergeMetabolites(), setModel(), and simpleCall().

const std::string CModelMerging::TypeName

static

Initial value:

=
{
  "ignore",
  "merge",
  ""
}

String literals for the GUI to display type names of columns known to COPASI.

Definition at line 95 of file CModelMerging.h.

---

The documentation for this class was generated from the following files:

• CModelMerging.h
• CModelMerging.cpp