CModelAnalyzer Class Reference

#include <CModelAnalyzer.h>

Collaboration diagram for CModelAnalyzer:

Classes
class	ReactionResult

Public Member Functions
	CModelAnalyzer (const CModel *model)
void	writeReport (std::ostream &os, bool rt, bool verbose) const

Protected Member Functions
void	checkModel (const CModel *model)
ReactionResult	checkReaction (const CReaction *reaction)

Protected Attributes
const CModel *	mpModel
std::vector< ReactionResult >	mReactionResults

Detailed Description

Definition at line 24 of file CModelAnalyzer.h.

Constructor & Destructor Documentation

CModelAnalyzer::CModelAnalyzer

(

const CModel *

model

)

Definition at line 33 of file CModelAnalyzer.cpp.

References checkModel().

{
  checkModel(model);
}

Member Function Documentation

void CModelAnalyzer::checkModel ( const CModel *  model )

protected

Definition at line 38 of file CModelAnalyzer.cpp.

References checkReaction(), CModel::getReactions(), CModel::getTotSteps(), mpModel, and mReactionResults.

Referenced by CModelAnalyzer().

{
  if (!model) return;

  mpModel = model;

  size_t i, imax = model->getTotSteps();

  for (i = 0; i < imax; ++i)
    {
      mReactionResults.push_back(checkReaction(model->getReactions()[i]));
    }
}

CModelAnalyzer::ReactionResult CModelAnalyzer::checkReaction ( const CReaction *  reaction )

protected

Definition at line 52 of file CModelAnalyzer.cpp.

References CReaction::getChemEq(), CModel::getCompartments(), CReaction::getFunction(), CReaction::getFunctionParameters(), CCopasiParameter::getKey(), CModel::getKey(), CCopasiObject::getKey(), CCopasiRootContainer::getKeyFactory(), CModel::getModelValues(), CChemEq::getModifiers(), CCopasiObject::getObjectName(), CCopasiParameterGroup::getParameter(), CReaction::getParameterMappings(), CReaction::getParameters(), CChemEq::getProducts(), CChemEq::getSubstrates(), CFunction::isReversible(), CReaction::isReversible(), CModelAnalyzer::ReactionResult::mChemEqMods, CModelAnalyzer::ReactionResult::mChemEqProds, CModelAnalyzer::ReactionResult::mChemEqSubs, CModelAnalyzer::ReactionResult::mFunctionParametersMods, CModelAnalyzer::ReactionResult::mFunctionParametersParams, CModelAnalyzer::ReactionResult::mFunctionParametersProds, CModelAnalyzer::ReactionResult::mFunctionParametersSubs, CModelAnalyzer::ReactionResult::mFunctionParametersTime, CModelAnalyzer::ReactionResult::mFunctionParametersVar, CModelAnalyzer::ReactionResult::mFunctionParametersVol, CModelAnalyzer::ReactionResult::mFunctionResult, CModelAnalyzer::ReactionResult::mKineticUnspecifiedReversibility, CModelAnalyzer::ReactionResult::mNotMetabolite, CFunctionParameter::MODIFIER, mpModel, CModelAnalyzer::ReactionResult::mReactionName, CModelAnalyzer::ReactionResult::mReversibilityMismatch, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, CFunctionParameters::size(), CCopasiVector< T >::size(), CCopasiParameterGroup::size(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TEMPORARY, CFunctionParameter::TIME, TriFalse, TriTrue, TriUnspecified, CFunctionParameter::VARIABLE, and CFunctionParameter::VOLUME.

Referenced by checkModel().

{
  ReactionResult ret;

  if (!reaction) return ret;

  ret.mReactionName = reaction->getObjectName();

  //reversibility
  if (reaction->getFunction()->isReversible() == TriUnspecified)
    {
      //warning
      // Kinetics is of unspecified reversibility.
      ret.mKineticUnspecifiedReversibility = true;
    }
  else if (((reaction->getFunction()->isReversible() == TriTrue) && !reaction->isReversible())
           || ((reaction->getFunction()->isReversible() == TriFalse) && reaction->isReversible()))
    {
      //error; or COPASI error?
      // Reversibility of function and kinetics does not match.
      ret.mReversibilityMismatch = true;
    }
  else
    {
      //OK.
    }

  if (dynamic_cast<const CMassAction*>(reaction->getFunction())) return ret;

  //TODO special case mass action

  //********* mapping **********************

  size_t i, imax;
  imax = reaction->getChemEq().getSubstrates().size();

  for (i = 0; i < imax; ++i)
    {
      //each substrate of the reaction needs to be mapped to a function parameter with role SUBSTRATE
      std::string tmpkey = reaction->getChemEq().getSubstrates()[i]->getMetaboliteKey();

      size_t j, jmax = reaction->getFunctionParameters().size();

      for (j = 0; j < jmax; ++j)
        {
          if ((reaction->getFunctionParameters()[j]->getUsage() == CFunctionParameter::SUBSTRATE)
              && reaction->getParameterMappings()[j][0] == tmpkey)
            break;
        }

      if (j == jmax)
        {
          //warning/error?
          // A substrate of this reaction is not mapped to a corresponding function parameter.
          const CMetab * pM = reaction->getChemEq().getSubstrates()[i]->getMetabolite();

          if (pM)
            ret.mChemEqSubs.push_back(pM->getObjectName());
        }
    }

  //for reversible reactions each product of the reaction needs to be mapped to a function parameter with role PRODUCT
  if (reaction->getFunction()->isReversible() == TriTrue)
    {
      imax = reaction->getChemEq().getProducts().size();

      for (i = 0; i < imax; ++i)
        {
          std::string tmpkey = reaction->getChemEq().getProducts()[i]->getMetaboliteKey();

          size_t j, jmax = reaction->getFunctionParameters().size();

          for (j = 0; j < jmax; ++j)
            {
              if ((reaction->getFunctionParameters()[j]->getUsage() == CFunctionParameter::PRODUCT)
                  && reaction->getParameterMappings()[j][0] == tmpkey)
                break;
            }

          if (j == jmax)
            {
              //warning/error?
              // A product of this reaction is not mapped to a corresponding function parameter.
              const CMetab * pM = reaction->getChemEq().getProducts()[i]->getMetabolite();

              if (pM)
                ret.mChemEqProds.push_back(pM->getObjectName());
            }
        }
    }

  imax = reaction->getChemEq().getModifiers().size();

  for (i = 0; i < imax; ++i)
    {
      //each modifier of the reaction should be mapped to a function parameter with role MODIFIER
      std::string tmpkey = reaction->getChemEq().getModifiers()[i]->getMetaboliteKey();

      size_t j, jmax = reaction->getFunctionParameters().size();

      for (j = 0; j < jmax; ++j)
        {
          if ((reaction->getFunctionParameters()[j]->getUsage() == CFunctionParameter::MODIFIER)
              && reaction->getParameterMappings()[j][0] == tmpkey)
            break;
        }

      if (j == jmax)
        {
          //warning
          // A modifier of this reaction is not mapped to a corresponding function parameter.
          const CMetab * pM = reaction->getChemEq().getModifiers()[i]->getMetabolite();

          if (pM)
            ret.mChemEqMods.push_back(pM->getObjectName());
        }
    }

  size_t j, jmax;

  //loop over all function parameters
  imax = reaction->getFunctionParameters().size();

  for (i = 0; i < imax; ++i)
    {
      CFunctionParameter::Role role = reaction->getFunctionParameters()[i]->getUsage();

      // substr., product, modifier must be matched to a metab (COPASI bug!)
      if (role == CFunctionParameter::SUBSTRATE
          || role == CFunctionParameter::PRODUCT
          || role == CFunctionParameter::MODIFIER)
        {
          if (!dynamic_cast<CMetab*>(CCopasiRootContainer::getKeyFactory()->get(reaction->getParameterMappings()[i][0])))
            {
              //COPASI bug!
              // COPASI bug! Something that is not a metabolite is mapped to a (subs/prod/mod) function parameter.
              ret.mNotMetabolite.push_back(reaction->getFunctionParameters()[i]->getObjectName());
            }
        }

      switch (role)
        {
            //substrate must be matched to a substr. of the reaction (COPASI bug?)
          case CFunctionParameter::SUBSTRATE:
            jmax = reaction->getChemEq().getSubstrates().size();

            for (j = 0; j < jmax; ++j)
              {
                if (reaction->getParameterMappings()[i][0]
                    == reaction->getChemEq().getSubstrates()[j]->getMetaboliteKey())
                  break;
              }

            if (j == jmax)
              {
                //COPASI error?
                // A SUBSTRATE function parameter is not mapped to a substrate of the reaction.
                ret.mFunctionParametersSubs.push_back(reaction->getFunctionParameters()[i]->getObjectName());
              }

            break;

            //Product must be matched to a product of the reaction (COPASI bug?)
          case CFunctionParameter::PRODUCT:
            jmax = reaction->getChemEq().getProducts().size();

            for (j = 0; j < jmax; ++j)
              {
                if (reaction->getParameterMappings()[i][0]
                    == reaction->getChemEq().getProducts()[j]->getMetaboliteKey())
                  break;
              }

            if (j == jmax)
              {
                //COPASI error?
                // A PRODUCT function parameter is not mapped to a product of the reaction." << std::endl;
                ret.mFunctionParametersProds.push_back(reaction->getFunctionParameters()[i]->getObjectName());
              }

            break;

            //modifier should be matched to a modifier in the chemeq
          case CFunctionParameter::MODIFIER:
            jmax = reaction->getChemEq().getModifiers().size();

            for (j = 0; j < jmax; ++j)
              {
                if (reaction->getParameterMappings()[i][0]
                    == reaction->getChemEq().getModifiers()[j]->getMetaboliteKey())
                  break;
              }

            if (j == jmax)
              {
                //COPASI error?
                // A MODIFIER function parameter is not mapped to a modifier of the reaction.
                ret.mFunctionParametersMods.push_back(reaction->getFunctionParameters()[i]->getObjectName());
                //this is not a user error. The modifier should have been added to the chemeq automatically.
              }

            break;

            //parameter must be matched to a local or global parameter (COPASI bug)
          case CFunctionParameter::PARAMETER:
            //first search in local parameters list
            jmax = reaction->getParameters().size();

            for (j = 0; j < jmax; ++j)
              {
                if (reaction->getParameterMappings()[i][0]
                    == reaction->getParameters().getParameter(j)->getKey())
                  break;
              }

            if (j == jmax) //not a local parameter
              {
                //now search in global value list
                jmax = mpModel->getModelValues().size();

                for (j = 0; j < jmax; ++j)
                  {
                    if (reaction->getParameterMappings()[i][0]
                        == mpModel->getModelValues()[j]->getKey())
                      break;
                  }

                if (j == jmax) //not a global parameter
                  {
                    //COPASI bug
                    // A PARAMETER function parameter is mapped neither to a local parameter nor a global value.
                    ret.mFunctionParametersParams.push_back(reaction->getFunctionParameters()[i]->getObjectName());
                  }
              }

            break;

          case CFunctionParameter::VOLUME:
            jmax = mpModel->getCompartments().size();

            for (j = 0; j < jmax; ++j)
              {
                if (reaction->getParameterMappings()[i][0]
                    == mpModel->getCompartments()[j]->getKey())
                  break;
              }

            if (j == jmax)
              {
                //COPASI bug
                // A VOLUME function parameter is not mapped to a compartment.
                ret.mFunctionParametersVol.push_back(reaction->getFunctionParameters()[i]->getObjectName());
              }

            break;

          case CFunctionParameter::TIME:

            if (reaction->getParameterMappings()[i][0] != mpModel->getKey())
              {
                //COPASI bug
                // Internal Copasi bug: TIME parameter not mapped correctly.
                ret.mFunctionParametersTime.push_back(reaction->getFunctionParameters()[i]->getObjectName());
              }

            break;

          case CFunctionParameter::VARIABLE:
          case CFunctionParameter::TEMPORARY:
          {
            //COPASI bug
            // Don't know what to do with a VARIABLE parameter here..."
            ret.mFunctionParametersVar.push_back(reaction->getFunctionParameters()[i]->getObjectName());
          }
          break;
        }
    }

  //check function:
  // irrev: no products should occur
  // irrev: if substr=0 -> kinetics=0
  CFunctionAnalyzer fa(reaction->getFunction() , reaction);
  ret.mFunctionResult = fa.getResult();

  return ret;
}

void CModelAnalyzer::writeReport	(	std::ostream &	os,
		bool	rt,
		bool	verbose
	)		const

Definition at line 478 of file CModelAnalyzer.cpp.

References mReactionResults.

Referenced by CopasiUI3Window::slotCheckModel().

{

  //reaction results
  size_t i, imax = mReactionResults.size();

  for (i = 0; i < imax; ++i)
    {
      //std::ostringstream tmpss;
      mReactionResults[i].writeResult(os, rt, verbose);
    }
}

Member Data Documentation

const CModel* CModelAnalyzer::mpModel

protected

Definition at line 72 of file CModelAnalyzer.h.

Referenced by checkModel(), and checkReaction().

std::vector<ReactionResult> CModelAnalyzer::mReactionResults

protected

Definition at line 74 of file CModelAnalyzer.h.

Referenced by checkModel(), and writeReport().

---

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

• CModelAnalyzer.h
• CModelAnalyzer.cpp