CFixLocalReactionParameters Class Reference

#include <CFixLocalReactionParameters.h>

Collaboration diagram for CFixLocalReactionParameters:

Public Member Functions
	CFixLocalReactionParameters ()
void	fixModel (CModel *pModel)
	~CFixLocalReactionParameters ()

Private Member Functions
void	changeModel ()
void	checkModel ()

Private Attributes
std::multimap < CCopasiParameter *, CExpression * >	mChanges
CModel *	mpModel

Detailed Description

Definition at line 23 of file CFixLocalReactionParameters.h.

Constructor & Destructor Documentation

CFixLocalReactionParameters::CFixLocalReactionParameters

(

)

Constructor

Definition at line 23 of file CFixLocalReactionParameters.cpp.

                                                        :
    mpModel(NULL),
    mChanges()
{}

CFixLocalReactionParameters::~CFixLocalReactionParameters

(

)

Constructor

Definition at line 28 of file CFixLocalReactionParameters.cpp.

{}

Member Function Documentation

void CFixLocalReactionParameters::changeModel ( )

private

Change the model

Definition at line 81 of file CFixLocalReactionParameters.cpp.

References C_INT32, CModel::createModelValue(), CCopasiParameter::getCN(), CCopasiObject::getCN(), CModelEntity::getKey(), CCopasiObject::getObjectAncestor(), CCopasiObject::getObjectName(), CCopasiParameter::getValue(), CReaction::isLocalParameter(), mChanges, MCXML, mpModel, CCopasiParameter::Value::pDOUBLE, CReaction::setParameterMapping(), and CCopasiMessage::WARNING.

Referenced by fixModel().

{
  CCopasiParameter * pParameter = NULL;
  CModelValue * pModelValue = NULL;
  CReaction * pReaction = NULL;

  std::stringstream NameStream;
  std::stringstream Message;

  std::string OldCN;
  std::string NewCNBase;
  std::string NewCN;
  std::string Infix;

  std::string::size_type Start;

  // Loop through all changes.
  std::multimap< CCopasiParameter *, CExpression * >::const_iterator itChanges = mChanges.begin();
  std::multimap< CCopasiParameter *, CExpression * >::const_iterator endChanges = mChanges.end();

  for (; itChanges != endChanges; ++itChanges)
    {
      if (pParameter != itChanges->first)
        {
          // We have a new parameter
          pParameter = itChanges->first;
          OldCN = "<" + pParameter->getCN() + ",Reference=";

          // Create a global quantity of type FIXED.
          std::string Name = pParameter->getObjectName();
          pReaction = static_cast< CReaction * >(pParameter->getObjectAncestor("Reaction"));
          Name += "{" + pReaction->getObjectName() + "}";

          pModelValue = mpModel->createModelValue(Name,
                                                  *pParameter->getValue().pDOUBLE);

          // In case the created name is not unique we append _n with increasing n
          // until we succeed;
          C_INT32 index = 0;
          while (pModelValue == NULL)
            {
              NameStream.str("");
              NameStream << Name << "_" << index++;
              pModelValue = mpModel->createModelValue(NameStream.str(),
                                                      *pParameter->getValue().pDOUBLE);
            }
          NewCNBase = "<" + pModelValue->getCN() + ",Reference=";

          // If the parameter is actually used in the reaction
          // it is changed to the global quantity.
          if (pReaction->isLocalParameter(pParameter->getObjectName()))
            pReaction->setParameterMapping(pParameter->getObjectName(), pModelValue->getKey());

          Message << "  " << pParameter->getObjectName() << " in " << pReaction->getObjectName()
          << " is replaced by " << pModelValue->getObjectName() << std::endl;
        }

      // We need to distinguish between initial and other expressions.
      if (itChanges->second->getObjectName().compare(0, 7, "Initial") == 0)
        NewCN = NewCNBase + "Initial";
      else
        NewCN = NewCNBase;

      // Replace the OldCN of the parameter with the NewCN of global quantity in all expressions.
      Infix = itChanges->second->getInfix();

      // There may be more than one occurrence.
      Start = 0;
      while ((Start = Infix.find(OldCN), Start) != std::string::npos)
        Infix.replace(Start, OldCN.length(), NewCN);

      itChanges->second->setInfix(Infix);
    }

  CCopasiMessage(CCopasiMessage::WARNING, MCXML + 14, Message.str().c_str());
}

void CFixLocalReactionParameters::checkModel ( )

private

Checks whether the model needs to be fixed and builds the listed of needed changes

Definition at line 43 of file CFixLocalReactionParameters.cpp.

References CCopasiVector< T >::begin(), CCopasiVector< T >::end(), CStateTemplate::getEntities(), CModel::getReactions(), CModel::getStateTemplate(), mChanges, mpModel, and CStateTemplate::size().

Referenced by fixModel().

{
  // Clear recorded changes
  mChanges.clear();

  // Check for all reactions
  CCopasiVector< CReaction >::const_iterator itReaction = mpModel->getReactions().begin();
  CCopasiVector< CReaction >::const_iterator endReaction = mpModel->getReactions().end();

  for (; itReaction != endReaction; ++itReaction)
    {
      // Check for all local parameters
      CCopasiParameterGroup::index_iterator itParameter = (*itReaction)->getParameters().beginIndex();
      CCopasiParameterGroup::index_iterator endParameter = (*itReaction)->getParameters().endIndex();

      for (; itParameter != endParameter; ++itParameter)
        {
          // Check for all entities' expressions and initial expressions
          // whether the CN of the parameter appears in the infix.
          // Note '>' is already properly escaped in the CN
          std::string CN = "<" + (*itParameter)->getCN() + ",Reference=Value>";

          CModelEntity *const*ppEntity = mpModel->getStateTemplate().getEntities();
          CModelEntity *const*ppEntityEnd = ppEntity + mpModel->getStateTemplate().size();
          for (; ppEntity != ppEntityEnd; ++ppEntity)
            {
              if ((*ppEntity)->getExpression().find(CN) != std::string::npos)
                mChanges.insert
                (std::pair< CCopasiParameter * const, CExpression * >(*itParameter, (*ppEntity)->getExpressionPtr()));

              if ((*ppEntity)->getInitialExpression().find(CN) != std::string::npos)
                mChanges.insert
                (std::pair< CCopasiParameter * const, CExpression * >(*itParameter, (*ppEntity)->getInitialExpressionPtr()));
            }
        }
    }
}

void CFixLocalReactionParameters::fixModel

(

CModel *

pModel

)

Check and fix the given model if needed

Parameters

CModel

* pModel

Definition at line 31 of file CFixLocalReactionParameters.cpp.

References changeModel(), checkModel(), mChanges, and mpModel.

{
  if (pModel == NULL) return;

  mpModel = pModel;
  checkModel();

  if (mChanges.size() == 0) return;

  changeModel();
}

Member Data Documentation

std::multimap< CCopasiParameter *, CExpression * > CFixLocalReactionParameters::mChanges

private

Definition at line 65 of file CFixLocalReactionParameters.h.

Referenced by changeModel(), checkModel(), and fixModel().

CModel* CFixLocalReactionParameters::mpModel

private

The model which needs to be fixed.

Definition at line 60 of file CFixLocalReactionParameters.h.

Referenced by changeModel(), checkModel(), and fixModel().

---

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

• CFixLocalReactionParameters.h
• CFixLocalReactionParameters.cpp