CReactionInterface Class Reference

#include <CReactionInterface.h>

Collaboration diagram for CReactionInterface:

Public Member Functions
	CReactionInterface (CModel *pModel)
bool	createMetabolites ()
bool	createOtherObjects () const
const CChemEqInterface &	getChemEqInterface () const
std::string	getChemEqString () const
std::set< const CCopasiObject * >	getDeletedParameters () const
const CFunction *	getFunction () const
const std::string &	getFunctionDescription () const
const std::string &	getFunctionName () const
const std::vector< std::string > &	getListOfMetabs (CFunctionParameter::Role role) const
std::vector< std::string >	getListOfPossibleFunctions () const
const C_FLOAT64 &	getLocalValue (size_t index) const
const std::string &	getMapping (size_t index) const
const std::vector< std::string > &	getMappings (size_t index) const
std::string	getParameterName (size_t index) const
CFunctionParameter::Role	getUsage (size_t index) const
void	initFromReaction (const std::string &key)
void	initFromReaction (const C_INT32 index)
void	initFromReaction (const CReaction *rea)
bool	isLocalValue (size_t index) const
bool	isLocked (size_t index) const
bool	isLocked (CFunctionParameter::Role usage) const
bool	isMulticompartment () const
bool	isReversible () const
bool	isValid () const
bool	isVector (size_t index) const
void	removeMapping (size_t index, std::string mn)
void	reverse (bool rev, const std::string &newFunction)
void	setChemEqString (const std::string &eq, const std::string &newFunction)
void	setFunctionAndDoMapping (const std::string &fn)
void	setFunctionWithEmptyMapping (const std::string &fn)
void	setLocal (size_t index)
void	setLocalValue (size_t index, C_FLOAT64 value)
void	setMapping (size_t index, std::string mn)
void	setReversibility (bool rev, const std::string &newFunction)
size_t	size () const
bool	writeBackToReaction (CReaction *rea)
	~CReactionInterface ()

Private Member Functions
void	clearFunction ()
void	connectFromScratch (CFunctionParameter::Role role)
void	connectNonMetabolites ()
void	copyMapping ()
	CReactionInterface ()
void	findAndSetFunction (const std::string &newFunction)
std::vector< std::string >	getExpandedMetabList (CFunctionParameter::Role role) const
void	initMapping ()
bool	loadMappingAndValues (const CReaction &rea)
void	updateModifiersInChemEq ()

Private Attributes
std::string	emptyString
CChemEqInterface	mChemEqI
std::vector< bool >	mIsLocal
std::vector< std::vector < std::string > >	mNameMap
const CFunction *	mpFunction
CModel *	mpModel
CFunctionParameters *	mpParameters
std::string	mReactionReferenceKey
std::vector< C_FLOAT64 >	mValues

Detailed Description

This class provides an interface for dealing with reactions. For representing the parameter mappings it uses object names. A CReactionInterface allows editing a reaction while trying to keep everything consistent.

Note: Many of the methods need to be provided with a model. While handling of the metabolites is completely independent of the model (they are handled by name, and they don't need to exist), the mapping of Compartments and global parameters is done with the entities that exist in the model. This may seem inconsistent, but the idea is that metabolites can be created from the gui by entering them into the reaction equation. Compartments and global parameters can only be chosen from the list of existing objects.

Definition at line 52 of file CReactionInterface.h.

Constructor & Destructor Documentation

CReactionInterface::CReactionInterface ( )

private

CReactionInterface::CReactionInterface

(

CModel *

pModel

)

Definition at line 27 of file CReactionInterface.cpp.

References emptyString, and mpModel.

                                                     :
  mpModel(pModel),
  mChemEqI(pModel),
  mpFunction(NULL),
  mpParameters(NULL)
{
  assert(mpModel != NULL);
  emptyString = "";
}

CReactionInterface::~CReactionInterface

(

)

Definition at line 37 of file CReactionInterface.cpp.

References mpParameters, and pdelete.

{
  pdelete(mpParameters);
  //pdelete(mpChemEq);
}

Member Function Documentation

void CReactionInterface::clearFunction ( )

private

Definition at line 315 of file CReactionInterface.cpp.

References mNameMap, mpFunction, mpParameters, mValues, and pdelete.

Referenced by setFunctionAndDoMapping(), and setFunctionWithEmptyMapping().

{
  mpFunction = NULL;
  pdelete(mpParameters);
  //mValid = false;

  mValues.clear();
  mNameMap.clear();
}

void CReactionInterface::connectFromScratch ( CFunctionParameter::Role  role )

private

guesses how to connect metabs with parameters for a specific usage

Definition at line 444 of file CReactionInterface.cpp.

References fatalError, CFunctionParameter::FLOAT64, getExpandedMetabList(), CFunctionParameters::getNumberOfParametersByUsage(), CFunctionParameters::getParameterByUsage(), CFunctionParameter::getType(), mNameMap, mpParameters, and CFunctionParameter::VFLOAT64.

Referenced by setFunctionAndDoMapping().

{
  size_t i, imax = mpParameters->getNumberOfParametersByUsage(role);

  if (!imax) return;

  // get the list of chem eq elements
  std::vector<std::string> el = getExpandedMetabList(role);

  // get the first parameter with the respective role
  CFunctionParameter::DataType Type;
  size_t pos = 0;
  Type = mpParameters->getParameterByUsage(role, pos)->getType();

  if (Type == CFunctionParameter::VFLOAT64)
    {
      mNameMap[pos - 1] = el;
    }
  else if (Type == CFunctionParameter::FLOAT64)
    {
      if (el.size() > 0)
        mNameMap[pos - 1][0] = el[0];
      else
        {mNameMap[pos - 1][0] = "unknown"; /*mValid = false;*/}

      for (i = 1; i < imax; ++i)
        {
          Type = mpParameters->getParameterByUsage(role, pos)->getType();

          if (Type != CFunctionParameter::FLOAT64) fatalError();

          if (el.size() > i)
            mNameMap[pos - 1][0] = el[i];
          else
            {mNameMap[pos - 1][0] = "unknown"; /*mValid = false;*/}
        }
    }
  else fatalError();
}

void CReactionInterface::connectNonMetabolites ( )

private

tries to determine the mapping for PARAMETER, VOLUME, TIME only if the current mapping is "unknown". Is typically called after initMapping() and copyMapping()

Definition at line 682 of file CReactionInterface.cpp.

References CChemEqInterface::getCompartment(), CModel::getModelValues(), CCopasiObject::getObjectName(), getUsage(), isLocalValue(), mChemEqI, mNameMap, CFunctionParameter::MODIFIER, mpModel, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, size(), CCopasiVector< T >::size(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, and CFunctionParameter::VOLUME.

Referenced by setFunctionAndDoMapping().

{
  size_t i, imax = size();

  for (i = 0; i < imax; ++i)
    {
      //only do something if the current mapping is "unknown"
      if (mNameMap[i].size())
        if (mNameMap[i][0] != "unknown")
          continue;

      if (isLocalValue(i))
        continue;

      switch (getUsage(i))
        {
          case CFunctionParameter::SUBSTRATE:
          case CFunctionParameter::PRODUCT:
          case CFunctionParameter::MODIFIER:
            break;

          case CFunctionParameter::PARAMETER:

            if (mpModel->getModelValues().size() == 1)
              mNameMap[i][0] = mpModel->getModelValues()[0]->getObjectName();

            break;

          case CFunctionParameter::VOLUME:
            //if (mpModel->getCompartments().size()==1)
            //  mNameMap[i][0] = mpModel->getCompartments()[0]->getObjectName();
          {
            const CCompartment* comp = mChemEqI.getCompartment();

            if (comp)
              mNameMap[i][0] = comp->getObjectName();
          }
          break;

          case CFunctionParameter::TIME:
            mNameMap[i][0] = mpModel->getObjectName();
            break;

          default:
            break;
        }
    }
}

void CReactionInterface::copyMapping ( )

private

create new mapping, try to keep as much information from the current mapping. Calls initMapping().

Definition at line 614 of file CReactionInterface.cpp.

References getParameterName(), getUsage(), initMapping(), isVector(), mIsLocal, mNameMap, CFunctionParameter::MODIFIER, mpParameters, mValues, CFunctionParameter::PARAMETER, pdelete, CFunctionParameter::PRODUCT, CFunctionParameters::size(), size(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, CFunctionParameter::VFLOAT64, and CFunctionParameter::VOLUME.

Referenced by setFunctionAndDoMapping().

{
  if (!mpParameters) //nothing to copy
    {
      initMapping();
      return;
    }

  // save the old information
  CFunctionParameters *oldParameters = mpParameters;
  std::vector<std::vector<std::string> > oldMap = mNameMap;
  std::vector<C_FLOAT64> oldValues = mValues;
  std::vector<bool> oldIsLocal = mIsLocal;

  //create new mapping
  initMapping();

  //try to preserve as much information from the old mapping as possible
  size_t j, jmax = oldParameters->size();
  size_t i, imax = size();

  for (i = 0; i < imax; ++i)
    {
      //find parameter with same name in old parameters
      for (j = 0; j < jmax; ++j)
        if ((*oldParameters)[j]->getObjectName() == getParameterName(i)) break;

      if (j == jmax) continue;

      //see if usage matches
      if (getUsage(i) != (*oldParameters)[j]->getUsage()) continue;

      //see if vector property matches
      if (isVector(i) != ((*oldParameters)[j]->getType() == CFunctionParameter::VFLOAT64))
        continue;

      mIsLocal[i] = oldIsLocal[j];
      mValues[i] = oldValues[j];

      switch (getUsage(i))
        {
          case CFunctionParameter::SUBSTRATE:
          case CFunctionParameter::PRODUCT:
            //TODO: check with chemeq
            mNameMap[i] = oldMap[j];
            break;

          case CFunctionParameter::MODIFIER:
            //TODO: check existence?
            mNameMap[i] = oldMap[j];
            //TODO: add to chemeq
            break;

          case CFunctionParameter::PARAMETER:
          case CFunctionParameter::VOLUME:
          case CFunctionParameter::TIME:
            //TODO: check existence?
            mNameMap[i] = oldMap[j];
            break;

          default:
            break;
        }
    }

  pdelete(oldParameters);
}

bool CReactionInterface::createMetabolites

(

)

create all metabolites that are needed by the reaction but do not exist in the model yet.

Definition at line 877 of file CReactionInterface.cpp.

References CChemEqInterface::createNonExistingMetabs(), getFunctionName(), mChemEqI, and setFunctionAndDoMapping().

Referenced by ReactionsWidget1::saveToReaction(), and CQReactionDM::setEquation().

{
  bool created = mChemEqI.createNonExistingMetabs();

  // Update the parameter mapping to assure that the new names match.
  if (created)
    setFunctionAndDoMapping(getFunctionName());

  return created;
}

bool CReactionInterface::createOtherObjects

(

)

const

create all other objects that are needed by the reaction but do not exist in the model yet.

Definition at line 888 of file CReactionInterface.cpp.

References CModel::createCompartment(), CModel::createModelValue(), getUsage(), isLocalValue(), mNameMap, mpModel, CFunctionParameter::PARAMETER, size(), and CFunctionParameter::VOLUME.

Referenced by ReactionsWidget1::saveToReaction(), and CQReactionDM::setEquation().

{
  bool ret = false;

  size_t i, imax = size();

  for (i = 0; i < imax; ++i)
    {
      switch (getUsage(i))
        {
          case CFunctionParameter::VOLUME:

            if (mNameMap[i][0] == "unknown" || mNameMap[i][0] == "") break;

            if (mpModel->createCompartment(mNameMap[i][0], 1.0))
              ret = true;

            break;

          case CFunctionParameter::PARAMETER:

            if (mNameMap[i][0] == "unknown" || mNameMap[i][0] == "") break;

            if (!isLocalValue(i))
              if (mpModel->createModelValue(mNameMap[i][0], 1.0))
                ret = true;

            break;

          default:
            break;
        }
    }

  return ret;
}

void CReactionInterface::findAndSetFunction ( const std::string &  newFunction )

private

checks if newFunction is an valid function for the reaction. If it is not or if newFunction="" another function is chosen.

Definition at line 344 of file CReactionInterface.cpp.

References C_FLOAT64, fl(), getFunctionName(), CChemEqInterface::getListOfDisplayNames(), getListOfPossibleFunctions(), getLocalValue(), CChemEqInterface::getReversibility(), mChemEqI, CFunctionParameter::PRODUCT, setFunctionAndDoMapping(), and setLocalValue().

Referenced by reverse(), setChemEqString(), and setReversibility().

{
  std::vector<std::string> fl = getListOfPossibleFunctions();
  size_t i, imax = fl.size();

  //no valid function?
  if (imax == 0)
    {
      setFunctionAndDoMapping("");
      return;
    }

  //first try the function provided as argument
  if (newFunction != "")
    {
      for (i = 0; i < imax; ++i)
        if (fl[i] == newFunction)
          {
            setFunctionAndDoMapping(fl[i]);
            return;
          }
    }

  //next try if the current function works
  std::string currentFunctionName = getFunctionName();

  if ("" != currentFunctionName)
    {
      for (i = 0; i < imax; ++i)
        if (fl[i] == currentFunctionName)
          {
            setFunctionAndDoMapping(fl[i]);
            return;
          }
    }

  // if not found then see if there is a best match in the list (i.e. a corresponding rev/irrev function).
  //if there is a current function try to find a related new function
  std::string s;

  if (currentFunctionName != "")
    {
      s = currentFunctionName.substr(0, currentFunctionName.find('(') - 1);

      //'-1' so as to strip off the white space before '('
      //This is purely heuristics
      for (i = 0; i < imax; i++)
        {
          if (fl[i].find(s) != std::string::npos)    // if find succeeds, the return value is likely to be 0
            //if (fl[i].find(s) >= 0) - for some reason this doesn't work
            {
              setFunctionAndDoMapping(fl[i]);
              return;
            }
        }
    }

  //try mass action next
  s = "Mass action";

  for (i = 0; i < imax; i++)
    {
      if (fl[i].find(s) != std::string::npos)    // if find succeeds, the return value is likely to be 0
        //if (fl[i].find(s) >= 0) - for some reason this doesn't work
        {
          setFunctionAndDoMapping(fl[i]);
          return;
        }
    }

  //try constant flux next
  s = "Constant flux";

  for (i = 0; i < imax; i++)
    {
      if (fl[i].find(s) != std::string::npos)    // if find succeeds, the return value is likely to be 0
        //if (fl[i].find(s) >= 0) - for some reason this doesn't work
        {
          setFunctionAndDoMapping(fl[i]);

          // If we have a reaction of the type X + Y = and the function
          // is Constant flux (reversible) we need to set the parameter v to
          // be negative to avoid negative concentrations during time course simulations.
          // Note, this fix is only done when we are assigning a default rate law.
          if (mChemEqI.getReversibility() == true &&
              mChemEqI.getListOfDisplayNames(CFunctionParameter::PRODUCT).size() == 0)
            {
              C_FLOAT64 v = - fabs(getLocalValue(0));
              setLocalValue(0, v);
            }

          return;
        }
    }

  //if everything else fails just take the first function from the list
  //this should not be reached since constant flux is a valid kinetic function for every reaction
  setFunctionAndDoMapping(fl[0]);
}

const CChemEqInterface& CReactionInterface::getChemEqInterface ( ) const

inline

Definition at line 110 of file CReactionInterface.h.

References mChemEqI.

Referenced by CQCompartment::copy(), and ParameterTable::updateTable().

{return mChemEqI;};

std::string CReactionInterface::getChemEqString ( ) const

inline

Definition at line 108 of file CReactionInterface.h.

References CChemEqInterface::getChemEqString(), and mChemEqI.

Referenced by ReactionsWidget1::FillWidgetFromRI(), and CQReactionDM::setEquation().

{return mChemEqI.getChemEqString(false);};

std::set< const CCopasiObject * > CReactionInterface::getDeletedParameters

(

)

const

Retrieve the list of parameters which will be deleted

Returns

std::set< const CCopasiObject * > DeletedParameters

Definition at line 539 of file CReactionInterface.cpp.

References CKeyFactory::get(), CReaction::getFunction(), CCopasiRootContainer::getKeyFactory(), CCopasiObject::getObjectName(), CCopasiParameterGroup::getParameter(), getParameterName(), CReaction::getParameters(), CFunctionParameter::getUsage(), CFunction::getVariables(), CReaction::isLocalParameter(), mIsLocal, mReactionReferenceKey, CFunctionParameter::PARAMETER, CFunctionParameters::size(), and size().

Referenced by ReactionsWidget1::saveToReaction(), and CQReactionDM::setEquation().

{
  std::set< const CCopasiObject * > ToBeDeleted;

  // We need to compare the current visible local parameter with the one stored
  // in the reaction.
  const CReaction * pReaction
    = dynamic_cast< CReaction *>(CCopasiRootContainer::getKeyFactory()->get(mReactionReferenceKey));

  if (pReaction == NULL)
    return ToBeDeleted;

  if (pReaction->getFunction() == NULL)
    return ToBeDeleted;

  const CFunctionParameters & OriginalParameters
    = pReaction->getFunction()->getVariables();

  size_t j, jmax = size();
  size_t i, imax = OriginalParameters.size();
  const CFunctionParameter * pParameter;

  for (i = 0; i < imax; ++i)
    {
      pParameter = OriginalParameters[i];

      if (pParameter->getUsage() == CFunctionParameter::PARAMETER &&
          pReaction->isLocalParameter(i))
        {
          const std::string & Name = pParameter->getObjectName();

          //find parameter with same name in current parameters
          for (j = 0; j < jmax; ++j)
            if (Name == getParameterName(j)) break;

          if (j < jmax && mIsLocal[j])
            continue;

          // The old parameter is either not found or is no longer local, i.e., it needs to
          // be added to values to be deleted.
          ToBeDeleted.insert(pReaction->getParameters().getParameter(Name));
        }
    }

  return ToBeDeleted;
}

std::vector< std::string > CReactionInterface::getExpandedMetabList ( CFunctionParameter::Role  role ) const

private

returns a list of metabolites (from the chemical equation). Species can occur several times according to theit multiplicity

Definition at line 838 of file CReactionInterface.cpp.

References C_FLOAT64, CChemEqInterface::getListOfDisplayNames(), CChemEqInterface::getListOfMultiplicities(), mChemEqI, and CFunctionParameter::MODIFIER.

Referenced by connectFromScratch().

{
  const std::vector<std::string> & names = mChemEqI.getListOfDisplayNames(role);
  const std::vector<C_FLOAT64> & mults = mChemEqI.getListOfMultiplicities(role);

  size_t j, jmax;
  size_t i, imax = names.size();

  std::vector<std::string> ret;

  for (i = 0; i < imax; ++i)
    {
      if (role == CFunctionParameter::MODIFIER)
        {
          jmax = 1;
        }
      else
        {
          C_FLOAT64 Multiplicity = mults[i];

          if (Multiplicity == floor(Multiplicity + 0.5))
            {
              jmax = (size_t) Multiplicity;
            }
          else
            {
              jmax = 1;
            }
        }

      for (j = 0; j < jmax; ++j)
        {
          ret.push_back(names[i]);
        }
    }

  return ret;
}

const CFunction* CReactionInterface::getFunction ( ) const

inline

Definition at line 159 of file CReactionInterface.h.

References mpFunction.

Referenced by ParameterTable::updateTable().

  {return mpFunction;}

const std::string& CReactionInterface::getFunctionDescription ( ) const

inline

Definition at line 156 of file CReactionInterface.h.

References emptyString, CEvaluationTree::getInfix(), and mpFunction.

Referenced by ReactionsWidget1::FillWidgetFromRI().

  {if (mpFunction) return mpFunction->getInfix(); else return emptyString;};

const std::string& CReactionInterface::getFunctionName ( ) const

inline

Definition at line 153 of file CReactionInterface.h.

References emptyString, CCopasiObject::getObjectName(), and mpFunction.

Referenced by createMetabolites(), ReactionsWidget1::FillWidgetFromRI(), and findAndSetFunction().

  {if (mpFunction) return mpFunction->getObjectName(); else return emptyString;};

const std::vector< std::string > & CReactionInterface::getListOfMetabs

(

CFunctionParameter::Role

role

)

const

This produces a list of metab names (from the chem eq) for use in the combo boxes. The role must be given like a usage, e.g. "SUBSTRATE".

Definition at line 43 of file CReactionInterface.cpp.

References CChemEqInterface::getListOfDisplayNames(), and mChemEqI.

Referenced by ParameterTable::getListOfAllMetabNames(), setMapping(), and ParameterTable::updateTable().

{
  return mChemEqI.getListOfDisplayNames(role);
}

std::vector< std::string > CReactionInterface::getListOfPossibleFunctions

(

)

const

Definition at line 48 of file CReactionInterface.cpp.

References CCopasiRootContainer::getFunctionList(), CChemEqInterface::getMolecularity(), isReversible(), mChemEqI, CFunctionParameter::PRODUCT, CFunctionParameter::SUBSTRATE, CFunctionDB::suitableFunctions(), TriFalse, and TriTrue.

Referenced by ReactionsWidget1::FillWidgetFromRI(), and findAndSetFunction().

{
  TriLogic reversible;

  if (isReversible() == false)
    reversible = TriFalse;
  else
    reversible = TriTrue;

  std::vector<CFunction*> functionVector =
    CCopasiRootContainer::getFunctionList()->suitableFunctions(
      mChemEqI.getMolecularity(CFunctionParameter::SUBSTRATE),
      mChemEqI.getMolecularity(CFunctionParameter::PRODUCT),
      reversible);

  std::vector<std::string> ret;
  size_t i, imax = functionVector.size();

  for (i = 0; i < imax; ++i)
    ret.push_back(functionVector[i]->getObjectName());

  return ret;
}

const C_FLOAT64& CReactionInterface::getLocalValue ( size_t  index ) const

inline

Definition at line 213 of file CReactionInterface.h.

References mValues.

Referenced by findAndSetFunction(), and ParameterTable::updateTable().

{return mValues[index];}

const std::string& CReactionInterface::getMapping ( size_t  index ) const

inline

Definition at line 196 of file CReactionInterface.h.

References isVector(), and mNameMap.

Referenced by updateModifiersInChemEq(), and ParameterTable::updateTable().

  {
    assert(!isVector(index));
    return mNameMap[index][0];
  }

const std::vector< std::string >& CReactionInterface::getMappings ( size_t  index ) const

inline

Definition at line 193 of file CReactionInterface.h.

References mNameMap.

Referenced by ParameterTable::updateTable().

  {return mNameMap[index];}

std::string CReactionInterface::getParameterName ( size_t  index ) const

inline

Definition at line 181 of file CReactionInterface.h.

References emptyString, mpFunction, and mpParameters.

Referenced by copyMapping(), getDeletedParameters(), loadMappingAndValues(), ParameterTable::updateTable(), and writeBackToReaction().

  {
    if (mpFunction) return (*mpParameters)[index]->getObjectName();
    else return emptyString;
  }

CFunctionParameter::Role CReactionInterface::getUsage ( size_t  index ) const

inline

Definition at line 175 of file CReactionInterface.h.

References mpFunction, mpParameters, and CFunctionParameter::VARIABLE.

Referenced by connectNonMetabolites(), copyMapping(), createOtherObjects(), initMapping(), isLocked(), loadMappingAndValues(), setMapping(), ReactionsWidget1::slotTableChanged(), updateModifiersInChemEq(), ParameterTable::updateTable(), and writeBackToReaction().

  {
    if (mpFunction) return (*mpParameters)[index]->getUsage();
    else return CFunctionParameter::VARIABLE;
  }

void CReactionInterface::initFromReaction

(

const std::string &

key

)

associate the function parameter referenced by "index" with the global parameter named pn. Only valid if the role for this function parameter is "PARAMETER". returns success

Definition at line 72 of file CReactionInterface.cpp.

References CKeyFactory::get(), CCopasiRootContainer::getKeyFactory(), and mReactionReferenceKey.

Referenced by CQCompartment::copy(), initFromReaction(), ReactionsWidget1::loadFromReaction(), and CQReactionDM::setEquation().

{
  mReactionReferenceKey = key;

  const CReaction *rea;
  rea = dynamic_cast< CReaction *>(CCopasiRootContainer::getKeyFactory()->get(key));
  assert(rea);
  initFromReaction(rea);
}

void CReactionInterface::initFromReaction

(

const C_INT32

index

)

Definition at line 82 of file CReactionInterface.cpp.

References CReaction::getKey(), CModel::getReactions(), initFromReaction(), mpModel, and mReactionReferenceKey.

{
  const CReaction *rea = mpModel->getReactions()[index];

  mReactionReferenceKey = rea->getKey();
  assert(rea);
  initFromReaction(rea);
}

void CReactionInterface::initFromReaction

(

const CReaction *

rea

)

Definition at line 91 of file CReactionInterface.cpp.

References CReaction::getChemEq(), CReaction::getFunction(), CCopasiRootContainer::getUndefinedFunction(), CFunction::getVariables(), CChemEqInterface::loadFromChemEq(), loadMappingAndValues(), mChemEqI, mpFunction, mpParameters, pdelete, and setFunctionWithEmptyMapping().

{
  //chemical equation
  mChemEqI.loadFromChemEq(rea->getChemEq());

  if (rea->getFunction() && (rea->getFunction() != CCopasiRootContainer::getUndefinedFunction()))
    {
      //function
      mpFunction = rea->getFunction();
      pdelete(mpParameters)
      mpParameters = new CFunctionParameters(mpFunction->getVariables());

      //mapping
      loadMappingAndValues(*rea);
    }
  else
    {
      setFunctionWithEmptyMapping("");
    }
}

void CReactionInterface::initMapping ( )

private

initialize mapping (resize vectors and set names to "unknown"). Also initializes mpParameters but doesn't delete the old mpParameters.

Definition at line 586 of file CReactionInterface.cpp.

References getUsage(), CFunction::getVariables(), isVector(), mIsLocal, mNameMap, mpFunction, mpParameters, mValues, CFunctionParameter::PARAMETER, and size().

Referenced by copyMapping(), and setFunctionWithEmptyMapping().

{
  mpParameters = new CFunctionParameters(mpFunction->getVariables());
  //make sure mpParameters is deleted! (e.g. in copyMapping())
  mNameMap.resize(size());
  mValues.resize(size());
  mIsLocal.resize(size());
  size_t i, imax = size();

  for (i = 0; i < imax; ++i)
    {
      if (isVector(i))
        mNameMap[i].resize(0);
      else
        {
          mNameMap[i].resize(1);
          mNameMap[i][0] = "unknown";
        }

      if (getUsage(i) == CFunctionParameter::PARAMETER)
        mIsLocal[i] = true;
      else
        mIsLocal[i] = false;

      mValues[i] = 0.1;
    }
}

bool CReactionInterface::isLocalValue ( size_t  index ) const

inline

Definition at line 215 of file CReactionInterface.h.

References mIsLocal.

Referenced by connectNonMetabolites(), createOtherObjects(), ReactionsWidget1::slotTableChanged(), and ParameterTable::updateTable().

{return mIsLocal[index];};

bool CReactionInterface::isLocked

(

size_t

index

)

const

Is the mapping of this parameter locked? The bahaviour of this method is different for different roles: SUBSTRATE, PRODUCT: according to the chemical equation MODIFIER: always unlocked TIME: always locked VOLUME, PARAMETER: according to the model

The idea is that in the reaction GUI new species can be entered in the chemical equation that are then created automatically. Compartments and global parameters can only be chosen from those existing in the model.

Definition at line 484 of file CReactionInterface.cpp.

References getUsage().

Referenced by ParameterTable::updateTable().

{return isLocked(getUsage(index));}

bool CReactionInterface::isLocked

(

CFunctionParameter::Role

usage

)

const

Definition at line 487 of file CReactionInterface.cpp.

References CModel::getCompartments(), CChemEqInterface::getListOfDisplayNames(), CModel::getModelValues(), CFunctionParameters::getNumberOfParametersByUsage(), CFunctionParameters::getParameterByUsage(), isVector(), mChemEqI, CFunctionParameter::MODIFIER, mpModel, mpParameters, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, CCopasiVector< T >::size(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, and CFunctionParameter::VOLUME.

{
  switch (usage)
    {
      case CFunctionParameter::MODIFIER:
        return false;
        break;

      case CFunctionParameter::TIME:
        return true;
        break;

      case CFunctionParameter::SUBSTRATE:
      case CFunctionParameter::PRODUCT:
      {
        // get number of parameters
        size_t paramSize = mpParameters->getNumberOfParametersByUsage(usage);

        if (paramSize == 0)
          return true;

        // get index of first parameter
        size_t pos = 0;
        mpParameters->getParameterByUsage(usage, pos); --pos;

        if (isVector(pos))
          {
            assert(paramSize == 1);
            return true;
          }
        else
          {
            return (mChemEqI.getListOfDisplayNames(usage).size() == 1);
          }
      }
      break;

      case CFunctionParameter::PARAMETER:
        return mpModel->getModelValues().size() <= 1;
        break;

      case CFunctionParameter::VOLUME:
        return mpModel->getCompartments().size() <= 1;
        break;

      default:
        break;
    }

  return false;
}

bool CReactionInterface::isMulticompartment

(

)

const

this method tries to find out if the REACTION involves several compartments 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 925 of file CReactionInterface.cpp.

References CChemEqInterface::isMulticompartment(), and mChemEqI.

Referenced by CQCompartment::copy(), ReactionsWidget1::FillWidgetFromRI(), and ParameterTable::updateTable().

{
  return mChemEqI.isMulticompartment();
}

bool CReactionInterface::isReversible ( ) const

inline

Definition at line 112 of file CReactionInterface.h.

References CChemEqInterface::getReversibility(), and mChemEqI.

Referenced by ReactionsWidget1::FillWidgetFromRI(), and getListOfPossibleFunctions().

{return mChemEqI.getReversibility();};

bool CReactionInterface::isValid

(

)

const

Definition at line 930 of file CReactionInterface.cpp.

References mIsLocal, mNameMap, and size().

Referenced by ReactionsWidget1::saveToReaction(), ReactionsWidget1::slotTableChanged(), and writeBackToReaction().

{
  //A reaction is invalid if it has a metab, a global parameter, or a compartment "unknown"
  size_t j, jmax = size();

  for (j = 0; j < jmax; ++j)
    if ((mNameMap[j][0] == "unknown") && (!mIsLocal[j]))
      return false;

  return true;
}

bool CReactionInterface::isVector ( size_t  index ) const

inline

Definition at line 169 of file CReactionInterface.h.

References mpFunction, mpParameters, and CFunctionParameter::VFLOAT64.

Referenced by copyMapping(), getMapping(), initMapping(), isLocked(), loadMappingAndValues(), setMapping(), ParameterTable::updateTable(), and writeBackToReaction().

  {
    if (mpFunction) return ((*mpParameters)[index]->getType() == CFunctionParameter::VFLOAT64);
    else return (false);
  }

bool CReactionInterface::loadMappingAndValues ( const CReaction &  rea )

private

Definition at line 112 of file CReactionInterface.cpp.

References CKeyFactory::get(), CMetabNameInterface::getDisplayName(), CModelEntity::getInitialValue(), CCopasiRootContainer::getKeyFactory(), CCopasiObject::getObjectName(), CCopasiParameterGroup::getParameter(), CReaction::getParameterMappings(), getParameterName(), CReaction::getParameters(), getUsage(), CCopasiParameter::getValue(), CReaction::isLocalParameter(), isVector(), mIsLocal, mNameMap, CFunctionParameter::MODIFIER, mpModel, mValues, CFunctionParameter::PARAMETER, CCopasiParameter::Value::pDOUBLE, CFunctionParameter::PRODUCT, size(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, and CFunctionParameter::VOLUME.

Referenced by initFromReaction().

{
  bool success = true;
  std::vector< std::vector<std::string> >::const_iterator it;
  std::vector< std::vector<std::string> >::const_iterator iEnd;
  std::vector<std::string>::const_iterator jt;
  std::vector<std::string>::const_iterator jEnd;
  size_t i;

  std::string metabName;
  const CModelEntity* pObj;

  std::vector<std::string> SubList;
  SubList.resize(1);
  SubList[0] = "unknown";

  mNameMap.resize(size());

  for (i = 0; i != size(); ++i)
    {
      mNameMap[i] = SubList;
    }

  mValues.resize(size(), 0.1);
  mIsLocal.resize(size(), false);

  it = rea.getParameterMappings().begin();
  iEnd = rea.getParameterMappings().end();

  for (i = 0; it != iEnd; ++it, ++i)
    {

      if (isVector(i))
        {
          assert((getUsage(i) == CFunctionParameter::SUBSTRATE)
                 || (getUsage(i) == CFunctionParameter::PRODUCT)
                 || (getUsage(i) == CFunctionParameter::MODIFIER));

          SubList.clear();

          for (jt = it->begin(), jEnd = it->end(); jt != jEnd; ++jt)
            {
              metabName = CMetabNameInterface::getDisplayName(mpModel, *jt, true);
              assert(metabName != "");
              SubList.push_back(metabName);
            }
        }
      else
        {
          assert(it->size() == 1);
          SubList.resize(1); SubList[0] = "unknown";

          switch (getUsage(i))
            {
              case CFunctionParameter::SUBSTRATE:
              case CFunctionParameter::PRODUCT:
              case CFunctionParameter::MODIFIER:
                metabName = CMetabNameInterface::getDisplayName(mpModel, *(it->begin()), true);
                // assert(metabName != "");
                SubList[0] = metabName;
                //TODO: check if the metabolite is in the chemical equation with the correct rule
                break;

              case CFunctionParameter::VOLUME:
                pObj = dynamic_cast<const CCompartment*>(CCopasiRootContainer::getKeyFactory()->get(*(it->begin())));
                assert(pObj);
                SubList[0] = pObj->getObjectName();
                break;

              case CFunctionParameter::TIME:
                pObj = dynamic_cast<const CModel*>(CCopasiRootContainer::getKeyFactory()->get(*(it->begin())));
                assert(pObj);
                SubList[0] = pObj->getObjectName();
                break;

              case CFunctionParameter::PARAMETER:
              {
                const CCopasiParameter * pParameter = rea.getParameters().getParameter(getParameterName(i));

                if (pParameter != NULL)
                  {
                    mValues[i] = * pParameter->getValue().pDOUBLE;
                  }
                else
                  {
                    mValues[i] = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
                  }

                mIsLocal[i] = rea.isLocalParameter(i);

                if (!mIsLocal[i])
                  {
                    pObj = dynamic_cast<const CModelValue*>(CCopasiRootContainer::getKeyFactory()->get(*(it->begin())));

                    if (pObj)
                      {
                        SubList[0] = pObj->getObjectName();
                        mValues[i] = pObj->getInitialValue();
                      }
                  }
              }
              break;

              default:
                break;
            }
        }

      mNameMap[i] = SubList;
    }

  return success;
}

void CReactionInterface::removeMapping	(	size_t	index,
		std::string	mn
	)

void CReactionInterface::reverse	(	bool	rev,
		const std::string &	newFunction
	)

reverse the reaction and set the reversibility. newFunction suggests a new kinetic function which is only used if adequate.

Definition at line 337 of file CReactionInterface.cpp.

References findAndSetFunction(), mChemEqI, CChemEqInterface::reverse(), and CChemEqInterface::setReversibility().

{
  mChemEqI.setReversibility(rev);
  mChemEqI.reverse();
  findAndSetFunction(newFunction);
}

void CReactionInterface::setChemEqString	(	const std::string &	eq,
		const std::string &	newFunction
	)

set a new chemical equation. newFunction suggests a new kinetic function which is only used if adequate.

Definition at line 325 of file CReactionInterface.cpp.

References findAndSetFunction(), mChemEqI, and CChemEqInterface::setChemEqString().

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

{
  mChemEqI.setChemEqString(eq);
  findAndSetFunction(newFunction);
}

void CReactionInterface::setFunctionAndDoMapping

(

const std::string &

fn

)

set the function. a new mapping is created that tries to preserve as much information as possible from the old mapping. Then a default mapping is set from the chemical equation and the model (if possible).

Definition at line 746 of file CReactionInterface.cpp.

References clearFunction(), connectFromScratch(), connectNonMetabolites(), copyMapping(), fatalError, CFunctionDB::findLoadFunction(), CCopasiRootContainer::getFunctionList(), CFunctionParameter::MODIFIER, mpFunction, CFunctionParameter::PRODUCT, and CFunctionParameter::SUBSTRATE.

Referenced by createMetabolites(), findAndSetFunction(), and ReactionsWidget1::slotComboBoxSelectionChanged().

{
  if ((fn == "") || (fn == "undefined"))
    {clearFunction(); return;}

  //get the function
  mpFunction = dynamic_cast<CFunction *>
               (CCopasiRootContainer::getFunctionList()->findLoadFunction(fn));

  if (!mpFunction) fatalError();

  copyMapping();
  connectNonMetabolites();

  //guess initial connections between metabs and function parameters
  connectFromScratch(CFunctionParameter::SUBSTRATE);
  connectFromScratch(CFunctionParameter::PRODUCT);
  connectFromScratch(CFunctionParameter::MODIFIER); // we can not be pedantic about modifiers
  // because modifiers are not taken into acount
  // when looking for suitable functions
}

void CReactionInterface::setFunctionWithEmptyMapping

(

const std::string &

fn

)

set the function. an empty mapping is created

Definition at line 731 of file CReactionInterface.cpp.

References clearFunction(), fatalError, CFunctionDB::findLoadFunction(), CCopasiRootContainer::getFunctionList(), initMapping(), mpFunction, mpParameters, and pdelete.

Referenced by initFromReaction(), ReactionsWidget1::saveToReaction(), CQReactionDM::setEquation(), and ReactionsWidget1::slotBtnDelete().

{
  if ((fn == "") || (fn == "undefined"))
    {clearFunction(); return;}

  //get the function
  mpFunction = dynamic_cast<CFunction *>
               (CCopasiRootContainer::getFunctionList()->findLoadFunction(fn));

  if (!mpFunction) fatalError();

  pdelete(mpParameters);
  initMapping(); //empty mapping
}

void CReactionInterface::setLocal ( size_t  index )

inline

Definition at line 208 of file CReactionInterface.h.

References mIsLocal.

Referenced by ReactionsWidget1::slotParameterStatusChanged().

  {
    mIsLocal[index] = true;
  }

void CReactionInterface::setLocalValue ( size_t  index, C_FLOAT64  value  )

inline

Definition at line 202 of file CReactionInterface.h.

References mIsLocal, and mValues.

Referenced by findAndSetFunction(), and ReactionsWidget1::slotTableChanged().

  {
    mValues[index] = value;
    mIsLocal[index] = true;
  }

void CReactionInterface::setMapping	(	size_t	index,
		std::string	mn
	)

Definition at line 779 of file CReactionInterface.cpp.

References CChemEqInterface::getListOfDisplayNames(), getListOfMetabs(), CFunctionParameters::getNumberOfParametersByUsage(), CFunctionParameters::getParameterByUsage(), getUsage(), isVector(), mChemEqI, mIsLocal, mNameMap, CFunctionParameter::MODIFIER, mpParameters, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, updateModifiersInChemEq(), and CFunctionParameter::VOLUME.

Referenced by ReactionsWidget1::slotParameterStatusChanged(), and ReactionsWidget1::slotTableChanged().

{
  mIsLocal[index] = false;

  switch (getUsage(index))
    {
      case CFunctionParameter::VOLUME:
      case CFunctionParameter::PARAMETER:
      case CFunctionParameter::TIME:
        assert(!isVector(index));
        mNameMap[index][0] = mn;
        break;

      case CFunctionParameter::SUBSTRATE:
      case CFunctionParameter::PRODUCT:

        if (isVector(index))
          mNameMap[index].push_back(mn);
        else
          {
            mNameMap[index][0] = mn;

            //TODO: check the following
            // if we have two parameters of this usage change the other one.
            size_t listSize = mChemEqI.getListOfDisplayNames(getUsage(index)).size();

            if ((listSize == 2) && (mpParameters->getNumberOfParametersByUsage(getUsage(index)) == 2))
              {
                // get index of other parameter
                size_t pos = 0;
                mpParameters->getParameterByUsage(getUsage(index), pos);

                if ((pos - 1) == index) mpParameters->getParameterByUsage(getUsage(index), pos);

                --pos;

                // get name if other metab
                std::vector<std::string> ml = getListOfMetabs(getUsage(index));
                std::string otherMetab;
                if (ml[0] == mn) otherMetab = ml[1]; else otherMetab = ml[0];

                // set other parameter
                mNameMap[pos][0] = otherMetab;
              }
          }

        break;

      case CFunctionParameter::MODIFIER:
        assert(!isVector(index));
        mNameMap[index][0] = mn;
        updateModifiersInChemEq();
        break;

      default:
        break;
    }
}

void CReactionInterface::setReversibility	(	bool	rev,
		const std::string &	newFunction
	)

set the reversibility. newFunction suggests a new kinetic function which is only used if adequate.

Definition at line 331 of file CReactionInterface.cpp.

References findAndSetFunction(), mChemEqI, and CChemEqInterface::setReversibility().

Referenced by ReactionsWidget1::slotCheckBoxClicked().

{
  mChemEqI.setReversibility(rev);
  findAndSetFunction(newFunction);
}

size_t CReactionInterface::size ( ) const

inline

Definition at line 166 of file CReactionInterface.h.

References mpFunction, mpParameters, and CFunctionParameters::size().

Referenced by connectNonMetabolites(), copyMapping(), createOtherObjects(), getDeletedParameters(), initMapping(), isValid(), loadMappingAndValues(), updateModifiersInChemEq(), ParameterTable::updateTable(), and writeBackToReaction().

  {if (mpFunction) return mpParameters->size(); else return 0;};

void CReactionInterface::updateModifiersInChemEq ( )

private

updates the modifiers in the chemical equation according to the parameter mapping

Definition at line 768 of file CReactionInterface.cpp.

References CChemEqInterface::addModifier(), CChemEqInterface::clearModifiers(), getMapping(), getUsage(), mChemEqI, CFunctionParameter::MODIFIER, and size().

Referenced by setMapping().

{
  mChemEqI.clearModifiers();
  size_t j, jmax = size();

  for (j = 0; j < jmax; ++j)
    if (getUsage(j) == CFunctionParameter::MODIFIER) //all the modifiers in the table
      if (getMapping(j) != "unknown")
        mChemEqI.addModifier(getMapping(j));
}

bool CReactionInterface::writeBackToReaction

(

CReaction *

rea

)

writes the information back to a CReaction. createMetabolites() and createOtherObjects() should be called before.

Definition at line 226 of file CReactionInterface.cpp.

References CReaction::addParameterMapping(), CReaction::clearParameterMapping(), CReaction::compile(), CKeyFactory::get(), CReaction::getChemEq(), CModel::getCompartments(), CModel::getKey(), CCopasiObject::getKey(), CCopasiRootContainer::getKeyFactory(), CMetabNameInterface::getMetaboliteKey(), CModel::getModelValues(), CCopasiObject::getObjectName(), getParameterName(), getUsage(), CFunction::getVariables(), isValid(), isVector(), mChemEqI, mIsLocal, mNameMap, CFunctionParameter::MODIFIER, mpFunction, mpModel, mpParameters, mReactionReferenceKey, mValues, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, CModel::setCompileFlag(), CReaction::setFunction(), CReaction::setParameterMapping(), CReaction::setParameterValue(), size(), CMetabNameInterface::splitDisplayName(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, CFunctionParameter::VOLUME, and CChemEqInterface::writeToChemEq().

Referenced by ReactionsWidget1::saveToReaction(), and CQReactionDM::setEquation().

{
  bool success = true;

  //CReaction *rea;
  if (rea == NULL)
    rea = dynamic_cast< CReaction *>(CCopasiRootContainer::getKeyFactory()->get(mReactionReferenceKey));

  if (rea == NULL) return false;

  // Now we can safely write to the equation as we are sure that only unique metabolites
  // may have the empty string as compartments
  mChemEqI.writeToChemEq(rea->getChemEq());

  if (!isValid()) return false; // do nothing

  if (mpFunction == NULL) return false;

  if (mpFunction->getObjectName() == "undefined") return false;

  if (mpParameters == NULL) return false;

  if (!(*mpParameters == mpFunction->getVariables())) return false; // do nothing

  // TODO. check if function has changed since it was set in the R.I.
  rea->setFunction(mpFunction->getObjectName());

  size_t j, jmax;
  size_t i, imax = size();
  std::pair< std::string, std::string > Names;

  for (i = 0; i < imax; ++i)
    {
      switch (getUsage(i))
        {
          case CFunctionParameter::PARAMETER:

            if (mIsLocal[i])
              rea->setParameterValue(getParameterName(i), mValues[i]);
            else
              {
                rea->setParameterValue(getParameterName(i), mValues[i], false);
                rea->setParameterMapping(i, mpModel->getModelValues()[mNameMap[i][0]]->getKey());
              }

            break;

          case CFunctionParameter::VOLUME:
            rea->setParameterMapping(i, mpModel->getCompartments()[mNameMap[i][0]]->getKey());
            break;

          case CFunctionParameter::TIME:
            rea->setParameterMapping(i, mpModel->getKey()); //time is the value of the model
            break;

          case CFunctionParameter::SUBSTRATE:
          case CFunctionParameter::PRODUCT:
          case CFunctionParameter::MODIFIER:

            if (isVector(i))
              {
                rea->clearParameterMapping(i);
                jmax = mNameMap[i].size();

                for (j = 0; j < jmax; ++j)
                  {
                    Names = CMetabNameInterface::splitDisplayName(mNameMap[i][j]);
                    rea->addParameterMapping(i, CMetabNameInterface::getMetaboliteKey(mpModel, Names.first, Names.second));
                  }
              }
            else
              {
                Names = CMetabNameInterface::splitDisplayName(mNameMap[i][0]);
                rea->setParameterMapping(i, CMetabNameInterface::getMetaboliteKey(mpModel, Names.first, Names.second));
              }

            break;

          default:
            break;
        }
    }

  rea->compile();
  mpModel->setCompileFlag(); //TODO: check if really necessary

  return success;
}

Member Data Documentation

std::string CReactionInterface::emptyString

private

Definition at line 57 of file CReactionInterface.h.

Referenced by CReactionInterface(), getFunctionDescription(), getFunctionName(), and getParameterName().

CChemEqInterface CReactionInterface::mChemEqI

private

A copy of the chemical equation of the reaction

Definition at line 67 of file CReactionInterface.h.

Referenced by connectNonMetabolites(), createMetabolites(), findAndSetFunction(), getChemEqInterface(), getChemEqString(), getExpandedMetabList(), getListOfMetabs(), getListOfPossibleFunctions(), initFromReaction(), isLocked(), isMulticompartment(), isReversible(), reverse(), setChemEqString(), setMapping(), setReversibility(), updateModifiersInChemEq(), and writeBackToReaction().

std::vector<bool> CReactionInterface::mIsLocal

private

values of the kinetic parameters

Definition at line 92 of file CReactionInterface.h.

Referenced by copyMapping(), getDeletedParameters(), initMapping(), isLocalValue(), isValid(), loadMappingAndValues(), setLocal(), setLocalValue(), setMapping(), and writeBackToReaction().

std::vector< std::vector< std::string > > CReactionInterface::mNameMap

private

what metabolite for what function parameter

Definition at line 82 of file CReactionInterface.h.

Referenced by clearFunction(), connectFromScratch(), connectNonMetabolites(), copyMapping(), createOtherObjects(), getMapping(), getMappings(), initMapping(), isValid(), loadMappingAndValues(), setMapping(), and writeBackToReaction().

const CFunction* CReactionInterface::mpFunction

private

A pointer to the kinetic function of the reaction

Definition at line 72 of file CReactionInterface.h.

Referenced by clearFunction(), getFunction(), getFunctionDescription(), getFunctionName(), getParameterName(), getUsage(), initFromReaction(), initMapping(), isVector(), setFunctionAndDoMapping(), setFunctionWithEmptyMapping(), size(), and writeBackToReaction().

CModel* CReactionInterface::mpModel

private

Definition at line 55 of file CReactionInterface.h.

Referenced by connectNonMetabolites(), CReactionInterface(), createOtherObjects(), initFromReaction(), isLocked(), loadMappingAndValues(), and writeBackToReaction().

CFunctionParameters* CReactionInterface::mpParameters

private

A copy of the function parameters

Definition at line 77 of file CReactionInterface.h.

Referenced by clearFunction(), connectFromScratch(), copyMapping(), getParameterName(), getUsage(), initFromReaction(), initMapping(), isLocked(), isVector(), setFunctionWithEmptyMapping(), setMapping(), size(), writeBackToReaction(), and ~CReactionInterface().

std::string CReactionInterface::mReactionReferenceKey

private

This is the key that identifies the Reaction that is beeing edited

Definition at line 62 of file CReactionInterface.h.

Referenced by getDeletedParameters(), initFromReaction(), and writeBackToReaction().

std::vector< C_FLOAT64 > CReactionInterface::mValues

private

values of the kinetic parameters

Definition at line 87 of file CReactionInterface.h.

Referenced by clearFunction(), copyMapping(), getLocalValue(), initMapping(), loadMappingAndValues(), setLocalValue(), and writeBackToReaction().

---

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

• CReactionInterface.h
• CReactionInterface.cpp