CChemEqInterface Class Reference

#include <CChemEqInterface.h>

Collaboration diagram for CChemEqInterface:

Public Member Functions
void	addModifier (const std::string &name)
	CChemEqInterface (CModel *pModel)
void	clearModifiers ()
bool	createNonExistingMetabs ()
std::string	getChemEqString (bool expanded) const
const CCompartment *	getCompartment () const
const std::vector< std::string > &	getListOfDisplayNames (CFunctionParameter::Role role) const
const std::vector< C_FLOAT64 > &	getListOfMultiplicities (CFunctionParameter::Role role) const
size_t	getMolecularity (CFunctionParameter::Role role) const
bool	getReversibility () const
bool	isMulticompartment () const
std::set< std::pair < std::string, std::string > >	listOfNonExistingMetabNames () const
std::set< std::string >	listOfNonUniqueMetabNames () const
bool	loadFromChemEq (const CChemEq &ce)
void	reverse ()
bool	setChemEqString (const std::string &ces)
void	setReversibility (bool rev)
bool	writeToChemEq (CChemEq &ce) const
	~CChemEqInterface ()

Static Public Member Functions
static std::string	getChemEqString (CModel *model, const CReaction &rea, bool expanded)
static bool	isValidEq (const std::string &eq)
static void	setChemEqFromString (CModel *model, CReaction &rea, const std::string &ces)

Private Member Functions
void	buildDisplayNames ()
	CChemEqInterface ()
void	completeCompartments ()

Static Private Member Functions
static std::string	writeElement (const std::string &name, C_FLOAT64 mult, bool expanded)

Private Attributes
std::vector< std::string >	mModifierCompartments
std::vector< std::string >	mModifierDisplayNames
std::vector< C_FLOAT64 >	mModifierMult
std::vector< std::string >	mModifierNames
CModel *	mpModel
std::vector< std::string >	mProductCompartments
std::vector< std::string >	mProductDisplayNames
std::vector< C_FLOAT64 >	mProductMult
std::vector< std::string >	mProductNames
bool	mReversibility
std::vector< std::string >	mSubstrateCompartments
std::vector< std::string >	mSubstrateDisplayNames
std::vector< C_FLOAT64 >	mSubstrateMult
std::vector< std::string >	mSubstrateNames

Detailed Description

This class describes a chemical equation based on metabolite names It supports parsing and generating string representations. Note that this class handles only metab names without caring about whether these metabs exist in the model. There is however a method to create the missing metabs.

Definition at line 44 of file CChemEqInterface.h.

Constructor & Destructor Documentation

CChemEqInterface::CChemEqInterface ( )

private

Definition at line 28 of file CChemEqInterface.cpp.

                                  :
  mpModel(NULL),
  mSubstrateNames(),
  mProductNames(),
  mModifierNames(),
  mSubstrateMult(),
  mProductMult(),
  mModifierMult(),
  mSubstrateCompartments(),
  mProductCompartments(),
  mModifierCompartments(),
  mSubstrateDisplayNames(),
  mProductDisplayNames(),
  mModifierDisplayNames(),
  mReversibility(false)
{}

CChemEqInterface::CChemEqInterface

(

CModel *

pModel

)

Definition at line 45 of file CChemEqInterface.cpp.

                                                 :
  mpModel(pModel),
  mSubstrateNames(),
  mProductNames(),
  mModifierNames(),
  mSubstrateMult(),
  mProductMult(),
  mModifierMult(),
  mSubstrateCompartments(),
  mProductCompartments(),
  mModifierCompartments(),
  mSubstrateDisplayNames(),
  mProductDisplayNames(),
  mModifierDisplayNames(),
  mReversibility(false)
{}

CChemEqInterface::~CChemEqInterface

(

)

Definition at line 62 of file CChemEqInterface.cpp.

{}

Member Function Documentation

void CChemEqInterface::addModifier

(

const std::string &

name

)

add a modifier to the chemical equation. It is only added if it is not alreay in there.

Definition at line 466 of file CChemEqInterface.cpp.

References mModifierCompartments, mModifierDisplayNames, mModifierMult, mModifierNames, quote(), and CMetabNameInterface::splitDisplayName().

Referenced by CReactionInterface::updateModifiersInChemEq().

{
  std::pair< std::string, std::string > Modifier =
    CMetabNameInterface::splitDisplayName(name);

  //is the name already in the list
  std::vector< std::string >::const_iterator it, itEnd = mModifierNames.end();
  std::vector< std::string >::const_iterator itComp = mModifierCompartments.begin();

  for (it = mModifierNames.begin(); it != itEnd; ++it, ++itComp)
    if (Modifier.first == *it &&
        Modifier.second == *itComp) break;

  if (it == itEnd)
    {
      mModifierNames.push_back(Modifier.first);
      mModifierMult.push_back(1.0);
      mModifierCompartments.push_back(Modifier.second);
      mModifierDisplayNames.push_back(quote(name));
    }
}

void CChemEqInterface::buildDisplayNames ( )

private

Definition at line 356 of file CChemEqInterface.cpp.

References CMetabNameInterface::getDisplayName(), mModifierCompartments, mModifierDisplayNames, mModifierNames, mpModel, mProductCompartments, mProductDisplayNames, mProductNames, mSubstrateCompartments, mSubstrateDisplayNames, and mSubstrateNames.

Referenced by createNonExistingMetabs(), loadFromChemEq(), and setChemEqString().

{
  std::vector< std::string >::const_iterator itName, itCompartment;
  std::vector< std::string >::iterator it, end;

  // We need to build the list of display names for the substrates;
  mSubstrateDisplayNames.resize(mSubstrateNames.size());

  for (itName = mSubstrateNames.begin(),
       itCompartment = mSubstrateCompartments.begin(),
       it = mSubstrateDisplayNames.begin(),
       end = mSubstrateDisplayNames.end();
       it != end;
       ++itName, ++itCompartment, ++it)
    *it = CMetabNameInterface::getDisplayName(mpModel, *itName, *itCompartment, true);

  // We need to build the list of display names for the products;
  mProductDisplayNames.resize(mProductNames.size());

  for (itName = mProductNames.begin(),
       itCompartment = mProductCompartments.begin(),
       it = mProductDisplayNames.begin(),
       end = mProductDisplayNames.end();
       it != end;
       ++itName, ++itCompartment, ++it)
    *it = CMetabNameInterface::getDisplayName(mpModel, *itName, *itCompartment, true);

  // We need to build the list of display names for the modifiers;
  mModifierDisplayNames.resize(mModifierNames.size());

  for (itName = mModifierNames.begin(),
       itCompartment = mModifierCompartments.begin(),
       it = mModifierDisplayNames.begin(),
       end = mModifierDisplayNames.end();
       it != end;
       ++itName, ++itCompartment, ++it)
    *it = CMetabNameInterface::getDisplayName(mpModel, *itName, *itCompartment, true);

  return;
}

void CChemEqInterface::clearModifiers

(

)

Definition at line 488 of file CChemEqInterface.cpp.

References mModifierCompartments, mModifierDisplayNames, mModifierMult, and mModifierNames.

Referenced by CReactionInterface::updateModifiersInChemEq().

{
  mModifierNames.clear();
  mModifierMult.clear();
  mModifierCompartments.clear();
  mModifierDisplayNames.clear();
}

void CChemEqInterface::completeCompartments ( )

private

Definition at line 141 of file CChemEqInterface.cpp.

References CMetab::getCompartment(), CModel::getCompartments(), CMetabNameInterface::getMetabolite(), CCopasiObject::getObjectName(), CMetabNameInterface::isUnique(), mModifierCompartments, mModifierNames, mpModel, mProductCompartments, mProductNames, mSubstrateCompartments, mSubstrateNames, and CCopasiVector< T >::size().

Referenced by setChemEqString().

{
  std::string DefaultCompartment;

  if (mpModel->getCompartments().size() == 0)
    DefaultCompartment = "compartment";
  else
    DefaultCompartment = mpModel->getCompartments()[0]->getObjectName();

  // We try to find a reaction compartment. Note, it is not possible to use
  // getCompartment as writeToChemEq may fail;
  std::string ReactionCompartment = "";
  bool first = true;
  bool HaveReactionCompartment = true;

  std::vector< std::string >::iterator itCompartment, endCompartment;

  itCompartment = mSubstrateCompartments.begin();
  endCompartment = mSubstrateCompartments.end();

  for (; itCompartment != endCompartment && HaveReactionCompartment; ++itCompartment)
    {
      if (*itCompartment == "") continue;

      if (first)
        {
          ReactionCompartment = *itCompartment;
          first = false;
        }
      else if (ReactionCompartment != *itCompartment)
        HaveReactionCompartment = false;
    }

  itCompartment = mProductCompartments.begin();
  endCompartment = mProductCompartments.end();

  for (; itCompartment != endCompartment && HaveReactionCompartment; ++itCompartment)
    {
      if (*itCompartment == "") continue;

      if (first)
        {
          ReactionCompartment = *itCompartment;
          first = false;
        }
      else if (ReactionCompartment != *itCompartment)
        HaveReactionCompartment = false;
    }

  itCompartment = mModifierCompartments.begin();
  endCompartment = mModifierCompartments.end();

  for (; itCompartment != endCompartment && HaveReactionCompartment; ++itCompartment)
    {
      if (*itCompartment == "") continue;

      if (first)
        {
          ReactionCompartment = *itCompartment;
          first = false;
        }
      else if (ReactionCompartment != *itCompartment)
        HaveReactionCompartment = false;
    }

  if (first)
    ReactionCompartment = DefaultCompartment;

  CMetab * pMetab;

  std::vector< std::string >::iterator itMetab;

  itMetab = mSubstrateNames.begin();
  itCompartment = mSubstrateCompartments.begin();
  endCompartment = mSubstrateCompartments.end();

  for (; itCompartment != endCompartment; ++itCompartment, ++itMetab)
    if (*itCompartment == "")
      {
        pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, "");

        if (pMetab == NULL)
          *itCompartment = ReactionCompartment;
        else if (CMetabNameInterface::isUnique(mpModel, *itMetab))
          *itCompartment = pMetab->getCompartment()->getObjectName();
        else // Multiple metabolites with the given name exist.
          {
            // 1. Metabolite in the reaction compartment
            pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, ReactionCompartment);

            // 2. Metabolite in the default compartment if different from reaction compartment
            if (pMetab == NULL && ReactionCompartment != DefaultCompartment)
              pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, DefaultCompartment);

            // 3. The first metabolite found
            if (pMetab == NULL)
              pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, "");

            *itCompartment = pMetab->getCompartment()->getObjectName();
          }
      }

  itMetab = mProductNames.begin();
  itCompartment = mProductCompartments.begin();
  endCompartment = mProductCompartments.end();

  for (; itCompartment != endCompartment; ++itCompartment, ++itMetab)
    if (*itCompartment == "")
      {
        pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, "");

        if (pMetab == NULL)
          *itCompartment = ReactionCompartment;
        else if (CMetabNameInterface::isUnique(mpModel, *itMetab))
          *itCompartment = pMetab->getCompartment()->getObjectName();
        else // Multiple metabolites with the given name exist.
          {
            // 1. Metabolite in the reaction compartment
            pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, ReactionCompartment);

            // 2. Metabolite in the default compartment if different from reaction compartment
            if (pMetab == NULL && ReactionCompartment != DefaultCompartment)
              pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, DefaultCompartment);

            // 3. The first metabolite found
            if (pMetab == NULL)
              pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, "");

            *itCompartment = pMetab->getCompartment()->getObjectName();
          }
      }

  itMetab = mModifierNames.begin();
  itCompartment = mModifierCompartments.begin();
  endCompartment = mModifierCompartments.end();

  for (; itCompartment != endCompartment; ++itCompartment, ++itMetab)
    if (*itCompartment == "")
      {
        pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, "");

        if (pMetab == NULL)
          *itCompartment = ReactionCompartment;
        else if (CMetabNameInterface::isUnique(mpModel, *itMetab))
          *itCompartment = pMetab->getCompartment()->getObjectName();
        else // Multiple metabolites with the given name exist.
          {
            // 1. Metabolite in the reaction compartment
            pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, ReactionCompartment);

            // 2. Metabolite in the default compartment if different from reaction compartment
            if (pMetab == NULL && ReactionCompartment != DefaultCompartment)
              pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, DefaultCompartment);

            // 3. The first metabolite found
            if (pMetab == NULL)
              pMetab = CMetabNameInterface::getMetabolite(mpModel, *itMetab, "");

            *itCompartment = pMetab->getCompartment()->getObjectName();
          }
      }
}

bool CChemEqInterface::createNonExistingMetabs

(

)

Definition at line 649 of file CChemEqInterface.cpp.

References buildDisplayNames(), C_INVALID_INDEX, CModel::createCompartment(), CModel::createMetabolite(), CModel::getCompartments(), CCopasiVectorN< CType >::getIndex(), listOfNonExistingMetabNames(), mpModel, and CModelEntity::REACTIONS.

Referenced by CReactionInterface::createMetabolites().

{
  std::set< std::pair< std::string, std::string > > metabs = listOfNonExistingMetabNames();
  bool ret;
  if (metabs.size() == 0) ret = false; else ret = true;

  std::set< std::pair< std::string, std::string > >::const_iterator it, itEnd;

  itEnd = metabs.end();

  for (it = metabs.begin(); it != itEnd; ++it)
    {
      if (mpModel->getCompartments().getIndex(it->second) == C_INVALID_INDEX)
        mpModel->createCompartment(it->second, 1);

      mpModel->createMetabolite(it->first,
                                it->second,
                                1.0, CModelEntity::REACTIONS);
    }

  // Due to the creation of metabolites the display names may have changed.
  buildDisplayNames();

  return ret;
}

std::string CChemEqInterface::getChemEqString

(

bool

expanded

)

const

Definition at line 65 of file CChemEqInterface.cpp.

References mModifierDisplayNames, mModifierNames, mProductDisplayNames, mProductMult, mProductNames, mReversibility, mSubstrateDisplayNames, mSubstrateMult, mSubstrateNames, and writeElement().

Referenced by CQReactionDM::data(), CQMergingData::fillTree(), CReactionInterface::getChemEqString(), getChemEqString(), CEFMTask::getReactionEquation(), StateSubwidget::loadReactions(), and CQSpeciesDetail::loadReactionTable().

{
  std::string ChemicalEquation;
  size_t j;

  if ((mSubstrateNames.size() == 0) && (mProductNames.size() == 0) && (mModifierNames.size() == 0))
    return "";

  for (j = 0; j < mSubstrateNames.size(); j++)
    {
      if (j)
        ChemicalEquation += " + ";

      ChemicalEquation += writeElement(mSubstrateDisplayNames[j], mSubstrateMult[j], expanded);
    }

  if (mReversibility)
    ChemicalEquation += " = ";
  else
    ChemicalEquation += " -> ";

  for (j = 0; j < mProductNames.size(); j++)
    {
      if (j)
        ChemicalEquation += " + ";

      ChemicalEquation += writeElement(mProductDisplayNames[j], mProductMult[j], expanded);
    }

  if (mModifierNames.size())
    {
      ChemicalEquation += "; ";

      for (j = 0; j < mModifierNames.size(); j++)
        {
          ChemicalEquation += " ";

          ChemicalEquation += mModifierDisplayNames[j];
        }
    }

  return ChemicalEquation;
}

std::string CChemEqInterface::getChemEqString ( CModel *  model, const CReaction &  rea, bool  expanded  )

static

Definition at line 740 of file CChemEqInterface.cpp.

References CReaction::getChemEq(), getChemEqString(), and loadFromChemEq().

{
  CChemEqInterface cei(model);
  cei.loadFromChemEq(rea.getChemEq());
  return cei.getChemEqString(expanded);
}

const CCompartment * CChemEqInterface::getCompartment

(

)

const

convenience method. If the reaction is single compartment the compartment is returned, else NULL.

Definition at line 716 of file CChemEqInterface.cpp.

References CMetab::getCompartment(), CChemEq::getCompartmentNumber(), CChemEq::getProducts(), CChemEq::getSubstrates(), CCopasiVector< T >::size(), and writeToChemEq().

Referenced by CReactionInterface::connectNonMetabolites(), and CQCompartment::copy().

{
  CChemEq ce;
  writeToChemEq(ce);

  if (ce.getCompartmentNumber() > 1)
    return NULL;
  else
    {
      const CMetab * metab = NULL;

      if (ce.getSubstrates().size())
        metab = ce.getSubstrates()[0]->getMetabolite();
      else if (ce.getProducts().size())
        metab = ce.getProducts()[0]->getMetabolite();

      if (metab)
        return metab->getCompartment();
      else
        return NULL;
    }
}

const std::vector< std::string > & CChemEqInterface::getListOfDisplayNames

(

CFunctionParameter::Role

role

)

const

Definition at line 456 of file CChemEqInterface.cpp.

References fatalError, mModifierDisplayNames, CFunctionParameter::MODIFIER, mProductDisplayNames, mSubstrateDisplayNames, CFunctionParameter::PRODUCT, and CFunctionParameter::SUBSTRATE.

Referenced by CReactionInterface::findAndSetFunction(), CReactionInterface::getExpandedMetabList(), CReactionInterface::getListOfMetabs(), CReactionInterface::isLocked(), and CReactionInterface::setMapping().

{
  if (role == CFunctionParameter::SUBSTRATE) return mSubstrateDisplayNames;
  else if (role == CFunctionParameter::PRODUCT) return mProductDisplayNames;
  else if (role == CFunctionParameter::MODIFIER) return mModifierDisplayNames;
  else fatalError();

  return mSubstrateDisplayNames; //never reached
}

const std::vector< C_FLOAT64 > & CChemEqInterface::getListOfMultiplicities

(

CFunctionParameter::Role

role

)

const

Definition at line 446 of file CChemEqInterface.cpp.

References fatalError, mModifierMult, CFunctionParameter::MODIFIER, mProductMult, mSubstrateMult, CFunctionParameter::PRODUCT, and CFunctionParameter::SUBSTRATE.

Referenced by CReactionInterface::getExpandedMetabList().

{
  if (role == CFunctionParameter::SUBSTRATE) return mSubstrateMult;
  else if (role == CFunctionParameter::PRODUCT) return mProductMult;
  else if (role == CFunctionParameter::MODIFIER) return mModifierMult;
  else fatalError();

  return mSubstrateMult; //never reached
}

size_t CChemEqInterface::getMolecularity

(

CFunctionParameter::Role

role

)

const

Definition at line 537 of file CChemEqInterface.cpp.

References C_INVALID_INDEX, fatalError, mModifierMult, CFunctionParameter::MODIFIER, mProductMult, mSubstrateMult, CFunctionParameter::PRODUCT, and CFunctionParameter::SUBSTRATE.

Referenced by CReactionInterface::getListOfPossibleFunctions(), and ParameterTable::updateTable().

{
  const std::vector<C_FLOAT64> * tmpVector = NULL;

  if (role == CFunctionParameter::SUBSTRATE)
    tmpVector = &mSubstrateMult;
  else if (role == CFunctionParameter::PRODUCT)
    tmpVector = &mProductMult;
  else if (role == CFunctionParameter::MODIFIER)
    tmpVector = &mModifierMult;
  else fatalError();

  size_t ccc, i, imax = tmpVector->size();
  ccc = 0;

  for (i = 0; i < imax; ++i)
    {
      if ((*tmpVector)[i] != floor((*tmpVector)[i] + 0.5))
        return C_INVALID_INDEX;

      ccc += (size_t) floor((*tmpVector)[i]);
    }

  return ccc;
}

bool CChemEqInterface::getReversibility ( ) const

inline

Definition at line 90 of file CChemEqInterface.h.

References mReversibility.

Referenced by CReactionInterface::findAndSetFunction(), and CReactionInterface::isReversible().

{return mReversibility;};

bool CChemEqInterface::isMulticompartment

(

)

const

this method tries to find out if the chemical equation involves several compartments in a given model. It only takes into account the metabs that actually exist in the model. A non existing metabolite is assumed not to be in a different compartment

Definition at line 675 of file CChemEqInterface.cpp.

References mModifierCompartments, mProductCompartments, and mSubstrateCompartments.

Referenced by CReactionInterface::isMulticompartment().

{
  bool Initialize = true;
  std::string Compartment = "";

  std::vector< std::string >::const_iterator it;
  std::vector< std::string >::const_iterator end;

  for (it = mSubstrateCompartments.begin(), end = mSubstrateCompartments.end();
       it != end; ++it)
    if (Initialize)
      {
        Compartment = *it;
        Initialize = false;
      }
    else if (Compartment != *it)
      return true;

  for (it = mProductCompartments.begin(), end = mProductCompartments.end();
       it != end; ++it)
    if (Initialize)
      {
        Compartment = *it;
        Initialize = false;
      }
    else if (Compartment != *it)
      return true;

  for (it = mModifierCompartments.begin(), end = mModifierCompartments.end();
       it != end; ++it)
    if (Initialize)
      {
        Compartment = *it;
        Initialize = false;
      }
    else if (Compartment != *it)
      return true;

  return false;
}

bool CChemEqInterface::isValidEq ( const std::string &  eq )

static

Definition at line 756 of file CChemEqInterface.cpp.

References CChemEqParserBase::yyparse().

Referenced by CQReactionDM::setEquation(), ReactionsWidget1::slotLineEditChanged(), and ChemEqValidator::validate().

{
  if (eq.empty()) return false;

  // parse the description into a linked node tree
  std::istringstream buffer(eq);
  CChemEqParser Parser(&buffer);

  return (Parser.yyparse() == 0);
}

std::set< std::pair< std::string, std::string > > CChemEqInterface::listOfNonExistingMetabNames

(

)

const

Definition at line 609 of file CChemEqInterface.cpp.

References CMetabNameInterface::doesExist(), mModifierCompartments, mModifierNames, mpModel, mProductCompartments, mProductNames, mSubstrateCompartments, and mSubstrateNames.

Referenced by createNonExistingMetabs().

{
  std::set< std::pair< std::string, std::string > > ret;
  std::pair< std::string, std::string > Insert;

  std::vector<std::string>::const_iterator it, itComp, itEnd;

  itEnd = mSubstrateNames.end();

  for (it = mSubstrateNames.begin(), itComp = mSubstrateCompartments.begin(); it != itEnd; ++it, ++itComp)
    if (!CMetabNameInterface::doesExist(mpModel, *it, *itComp))
      {
        Insert.first = *it;
        Insert.second = *itComp;
        ret.insert(Insert);
      }

  itEnd = mProductNames.end();

  for (it = mProductNames.begin(), itComp = mProductCompartments.begin(); it != itEnd; ++it, ++itComp)
    if (!CMetabNameInterface::doesExist(mpModel, *it, *itComp))
      {
        Insert.first = *it;
        Insert.second = *itComp;
        ret.insert(Insert);
      }

  itEnd = mModifierNames.end();

  for (it = mModifierNames.begin(), itComp = mModifierCompartments.begin(); it != itEnd; ++it, ++itComp)
    if (!CMetabNameInterface::doesExist(mpModel, *it, *itComp))
      {
        Insert.first = *it;
        Insert.second = *itComp;
        ret.insert(Insert);
      }

  return ret;
}

std::set< std::string > CChemEqInterface::listOfNonUniqueMetabNames

(

)

const

Definition at line 582 of file CChemEqInterface.cpp.

References CMetabNameInterface::isUnique(), mModifierNames, mpModel, mProductNames, and mSubstrateNames.

{
  std::set<std::string> ret;

  std::vector<std::string>::const_iterator it, itEnd;

  itEnd = mSubstrateNames.end();

  for (it = mSubstrateNames.begin(); it != itEnd; ++it)
    if (!CMetabNameInterface::isUnique(mpModel, *it))
      ret.insert(*it);

  itEnd = mProductNames.end();

  for (it = mProductNames.begin(); it != itEnd; ++it)
    if (!CMetabNameInterface::isUnique(mpModel, *it))
      ret.insert(*it);

  itEnd = mModifierNames.end();

  for (it = mModifierNames.begin(); it != itEnd; ++it)
    if (!CMetabNameInterface::isUnique(mpModel, *it))
      ret.insert(*it);

  return ret;
}

bool CChemEqInterface::loadFromChemEq

(

const CChemEq &

ce

)

Definition at line 304 of file CChemEqInterface.cpp.

References buildDisplayNames(), CChemEq::getModifiers(), CChemEq::getProducts(), CChemEq::getReversibility(), CChemEq::getSubstrates(), mModifierCompartments, mModifierMult, mModifierNames, mProductCompartments, mProductMult, mProductNames, mReversibility, mSubstrateCompartments, mSubstrateMult, mSubstrateNames, and CCopasiVector< T >::size().

Referenced by getChemEqString(), and CReactionInterface::initFromReaction().

{
  bool ret = true;
  const CCopasiVector<CChemEqElement> * elements;
  size_t i, imax;

  elements = &ce.getSubstrates();
  imax = elements->size();
  mSubstrateNames.resize(imax);
  mSubstrateMult.resize(imax);
  mSubstrateCompartments.resize(imax);

  for (i = 0; i < imax; ++i)
    {
      mSubstrateNames[i] = (*elements)[i]->getMetabolite()->getObjectName();
      mSubstrateMult[i] = (*elements)[i]->getMultiplicity();
      mSubstrateCompartments[i] = (*elements)[i]->getMetabolite()->getCompartment()->getObjectName();
    }

  elements = &ce.getProducts();
  imax = elements->size();
  mProductNames.resize(imax);
  mProductMult.resize(imax);
  mProductCompartments.resize(imax);

  for (i = 0; i < imax; ++i)
    {
      mProductNames[i] = (*elements)[i]->getMetabolite()->getObjectName();
      mProductMult[i] = (*elements)[i]->getMultiplicity();
      mProductCompartments[i] = (*elements)[i]->getMetabolite()->getCompartment()->getObjectName();
    }

  elements = &ce.getModifiers();
  imax = elements->size();
  mModifierNames.resize(imax);
  mModifierMult.resize(imax);
  mModifierCompartments.resize(imax);

  for (i = 0; i < imax; ++i)
    {
      mModifierNames[i] = (*elements)[i]->getMetabolite()->getObjectName();
      mModifierMult[i] = (*elements)[i]->getMultiplicity();
      mModifierCompartments[i] = (*elements)[i]->getMetabolite()->getCompartment()->getObjectName();
    }

  mReversibility = ce.getReversibility();

  buildDisplayNames();

  return ret;
}

void CChemEqInterface::reverse

(

)

Definition at line 563 of file CChemEqInterface.cpp.

References mProductCompartments, mProductMult, mProductNames, mSubstrateCompartments, mSubstrateMult, and mSubstrateNames.

Referenced by CReactionInterface::reverse().

{
  std::vector<std::string> dummyNames;
  std::vector<C_FLOAT64> dummyMults;
  std::vector<std::string> dummyCompartments;

  dummyNames = mSubstrateNames;
  dummyMults = mSubstrateMult;
  dummyCompartments = mSubstrateCompartments;

  mSubstrateNames = mProductNames;
  mSubstrateMult = mProductMult;
  mSubstrateCompartments = mProductCompartments;

  mProductNames = dummyNames;
  mProductMult = dummyMults;
  mProductCompartments = dummyCompartments;
}

void CChemEqInterface::setChemEqFromString ( CModel *  model, CReaction &  rea, const std::string &  ces  )

static

Definition at line 748 of file CChemEqInterface.cpp.

References CReaction::getChemEq(), setChemEqString(), and writeToChemEq().

Referenced by CReaction::load().

{
  CChemEqInterface cei(model);
  cei.setChemEqString(ces);
  cei.writeToChemEq(rea.getChemEq());
}

bool CChemEqInterface::setChemEqString

(

const std::string &

ces

)

Definition at line 109 of file CChemEqInterface.cpp.

References buildDisplayNames(), completeCompartments(), CChemEqParserBase::getModifierCompartments(), CChemEqParserBase::getModifierMulitplicities(), CChemEqParserBase::getModifierNames(), CChemEqParserBase::getProductCompartments(), CChemEqParserBase::getProductMulitplicities(), CChemEqParserBase::getProductNames(), CChemEqParserBase::getSubstrateCompartments(), CChemEqParserBase::getSubstrateMulitplicities(), CChemEqParserBase::getSubstrateNames(), CChemEqParserBase::isReversible(), mModifierCompartments, mModifierMult, mModifierNames, mProductCompartments, mProductMult, mProductNames, mReversibility, mSubstrateCompartments, mSubstrateMult, mSubstrateNames, and CChemEqParserBase::yyparse().

Referenced by setChemEqFromString(), and CReactionInterface::setChemEqString().

{
  // parse the description into a linked node tree
  std::istringstream buffer(ces);
  CChemEqParser Parser(&buffer);

  bool success = (Parser.yyparse() == 0);

  if (success)
    {
      mReversibility = Parser.isReversible();

      mSubstrateNames = Parser.getSubstrateNames();
      mSubstrateMult = Parser.getSubstrateMulitplicities();
      mSubstrateCompartments = Parser.getSubstrateCompartments();

      mProductNames = Parser.getProductNames();
      mProductMult = Parser.getProductMulitplicities();
      mProductCompartments = Parser.getProductCompartments();

      mModifierNames = Parser.getModifierNames();
      mModifierMult = Parser.getModifierMulitplicities();
      mModifierCompartments = Parser.getModifierCompartments();
    }

  completeCompartments();

  buildDisplayNames();

  return success;
}

void CChemEqInterface::setReversibility ( bool  rev )

inline

Definition at line 91 of file CChemEqInterface.h.

References mReversibility.

Referenced by CReactionInterface::reverse(), and CReactionInterface::setReversibility().

{mReversibility = rev;};

std::string CChemEqInterface::writeElement ( const std::string &  name, C_FLOAT64  mult, bool  expanded  )

staticprivate

Definition at line 496 of file CChemEqInterface.cpp.

References C_INT32, and isNumber().

Referenced by getChemEqString().

{
  std::ostringstream Element;
  Element.imbue(std::locale::classic());
  Element.precision(6);

  std::string Metabolite = name;

  // The last character must not be a ';' in a reaction.
  if (Metabolite[Metabolite.length() - 1] == ';')
    Metabolite = "\"" + Metabolite + "\"";

  if (isNumber(Metabolite))
    Metabolite = "\"" + Metabolite + "\"";

  if (expanded)
    {
      C_INT32 i, imax = (C_INT32) mult;

      for (i = 0; i < imax; ++i)
        {
          if (i) Element << " + ";

          Element << Metabolite;
        }
    }
  else
    {
      if (mult == 1.0)
        {
          Element << Metabolite;
        }
      else
        {
          Element << mult << " * " << Metabolite;
        }
    }

  return Element.str();
}

bool CChemEqInterface::writeToChemEq

(

CChemEq &

ce

)

const

Definition at line 397 of file CChemEqInterface.cpp.

References CChemEq::addMetabolite(), CChemEq::cleanup(), CMetabNameInterface::getMetaboliteKey(), mModifierCompartments, mModifierMult, mModifierNames, CChemEq::MODIFIER, mpModel, mProductCompartments, mProductMult, mProductNames, mReversibility, mSubstrateCompartments, mSubstrateMult, mSubstrateNames, CChemEq::PRODUCT, CChemEq::setReversibility(), and CChemEq::SUBSTRATE.

Referenced by getCompartment(), setChemEqFromString(), and CReactionInterface::writeBackToReaction().

{
  bool ret = true;
  std::string metabkey;
  size_t i, imax;

  ce.cleanup();

  imax = mSubstrateNames.size();

  for (i = 0; i < imax; ++i)
    {
      metabkey = CMetabNameInterface::getMetaboliteKey(mpModel, mSubstrateNames[i], mSubstrateCompartments[i]);

      if (metabkey.empty())
        ret = false;
      else
        ce.addMetabolite(metabkey, mSubstrateMult[i], CChemEq::SUBSTRATE);
    }

  imax = mProductNames.size();

  for (i = 0; i < imax; ++i)
    {
      metabkey = CMetabNameInterface::getMetaboliteKey(mpModel, mProductNames[i], mProductCompartments[i]);

      if (metabkey.empty())
        ret = false;
      else
        ce.addMetabolite(metabkey, mProductMult[i], CChemEq::PRODUCT);
    }

  imax = mModifierNames.size();

  for (i = 0; i < imax; ++i)
    {
      metabkey = CMetabNameInterface::getMetaboliteKey(mpModel, mModifierNames[i], mModifierCompartments[i]);

      if (metabkey.empty())
        ret = false;
      else
        ce.addMetabolite(metabkey, mModifierMult[i], CChemEq::MODIFIER);
    }

  ce.setReversibility(mReversibility);

  return ret; //TODO: really check
}

Member Data Documentation

std::vector< std::string > CChemEqInterface::mModifierCompartments

private

Definition at line 59 of file CChemEqInterface.h.

Referenced by addModifier(), buildDisplayNames(), clearModifiers(), completeCompartments(), isMulticompartment(), listOfNonExistingMetabNames(), loadFromChemEq(), setChemEqString(), and writeToChemEq().

std::vector< std::string > CChemEqInterface::mModifierDisplayNames

private

Definition at line 63 of file CChemEqInterface.h.

Referenced by addModifier(), buildDisplayNames(), clearModifiers(), getChemEqString(), and getListOfDisplayNames().

std::vector< C_FLOAT64 > CChemEqInterface::mModifierMult

private

Definition at line 55 of file CChemEqInterface.h.

Referenced by addModifier(), clearModifiers(), getListOfMultiplicities(), getMolecularity(), loadFromChemEq(), setChemEqString(), and writeToChemEq().

std::vector< std::string > CChemEqInterface::mModifierNames

private

Definition at line 51 of file CChemEqInterface.h.

Referenced by addModifier(), buildDisplayNames(), clearModifiers(), completeCompartments(), getChemEqString(), listOfNonExistingMetabNames(), listOfNonUniqueMetabNames(), loadFromChemEq(), setChemEqString(), and writeToChemEq().

CModel* CChemEqInterface::mpModel

private

Definition at line 47 of file CChemEqInterface.h.

Referenced by buildDisplayNames(), completeCompartments(), createNonExistingMetabs(), listOfNonExistingMetabNames(), listOfNonUniqueMetabNames(), and writeToChemEq().

std::vector< std::string > CChemEqInterface::mProductCompartments

private

Definition at line 58 of file CChemEqInterface.h.

Referenced by buildDisplayNames(), completeCompartments(), isMulticompartment(), listOfNonExistingMetabNames(), loadFromChemEq(), reverse(), setChemEqString(), and writeToChemEq().

std::vector< std::string > CChemEqInterface::mProductDisplayNames

private

Definition at line 62 of file CChemEqInterface.h.

Referenced by buildDisplayNames(), getChemEqString(), and getListOfDisplayNames().

std::vector< C_FLOAT64 > CChemEqInterface::mProductMult

private

Definition at line 54 of file CChemEqInterface.h.

Referenced by getChemEqString(), getListOfMultiplicities(), getMolecularity(), loadFromChemEq(), reverse(), setChemEqString(), and writeToChemEq().

std::vector< std::string > CChemEqInterface::mProductNames

private

Definition at line 50 of file CChemEqInterface.h.

Referenced by buildDisplayNames(), completeCompartments(), getChemEqString(), listOfNonExistingMetabNames(), listOfNonUniqueMetabNames(), loadFromChemEq(), reverse(), setChemEqString(), and writeToChemEq().

bool CChemEqInterface::mReversibility

private

Definition at line 65 of file CChemEqInterface.h.

Referenced by getChemEqString(), getReversibility(), loadFromChemEq(), setChemEqString(), setReversibility(), and writeToChemEq().

std::vector< std::string > CChemEqInterface::mSubstrateCompartments

private

Definition at line 57 of file CChemEqInterface.h.

Referenced by buildDisplayNames(), completeCompartments(), isMulticompartment(), listOfNonExistingMetabNames(), loadFromChemEq(), reverse(), setChemEqString(), and writeToChemEq().

std::vector< std::string > CChemEqInterface::mSubstrateDisplayNames

private

Definition at line 61 of file CChemEqInterface.h.

Referenced by buildDisplayNames(), getChemEqString(), and getListOfDisplayNames().

std::vector< C_FLOAT64 > CChemEqInterface::mSubstrateMult

private

Definition at line 53 of file CChemEqInterface.h.

Referenced by getChemEqString(), getListOfMultiplicities(), getMolecularity(), loadFromChemEq(), reverse(), setChemEqString(), and writeToChemEq().

std::vector< std::string > CChemEqInterface::mSubstrateNames

private

Definition at line 49 of file CChemEqInterface.h.

Referenced by buildDisplayNames(), completeCompartments(), getChemEqString(), listOfNonExistingMetabNames(), listOfNonUniqueMetabNames(), loadFromChemEq(), reverse(), setChemEqString(), and writeToChemEq().

---

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

• CChemEqInterface.h
• CChemEqInterface.cpp