CMetab Class Reference

#include <CMetab.h>

Inheritance diagram for CMetab:

Collaboration diagram for CMetab:

Public Member Functions
virtual void	calculate ()
void	cleanup ()
	CMetab (const std::string &name="NoName", const CCopasiContainer *pParent=NULL)
	CMetab (const CMetab &src, const CCopasiContainer *pParent=NULL)
virtual bool	compile ()
bool	compileInitialValueDependencies ()
void	compileIsInitialConcentrationChangeAllowed ()
virtual std::string	getChildObjectUnits (const CCopasiObject *pObject) const
const CCompartment *	getCompartment () const
const C_FLOAT64 &	getConcentration () const
C_FLOAT64	getConcentrationRate () const
CCopasiObject *	getConcentrationRateReference () const
CConcentrationReference *	getConcentrationReference () const
virtual DataObjectSet	getDeletedObjects () const
const C_FLOAT64 &	getInitialConcentration () const
CConcentrationReference *	getInitialConcentrationReference () const
const CModel *	getModel () const
const CMoiety *	getMoiety () const
virtual std::string	getObjectDisplayName (bool regular=true, bool richtext=false) const
const C_FLOAT64 &	getTransitionTime () const
virtual const CCopasiObject *	getValueObject () const
virtual void *	getValuePointer () const
void	initCompartment (const CCompartment *pCompartment=NULL)
bool	isDependent () const
const bool &	isInitialConcentrationChangeAllowed () const
C_INT32	load (CReadConfig &configbuffer)
virtual bool	mustBeDeleted (const DataObjectSet &deletedObjects) const
CMetab &	operator= (const CMetabOld &rhs)
void	refreshConcentration ()
void	refreshConcentrationRate ()
void	refreshInitialConcentration ()
virtual void	refreshInitialValue ()
void	refreshNumber ()
void	refreshRate ()
void	refreshTransitionTime ()
void	setConcentration (const C_FLOAT64 concentration)
void	setDependentOn (const CMoiety *pMoiety)
void	setInitialConcentration (const C_FLOAT64 &initialConcentration)
virtual bool	setObjectParent (const CCopasiContainer *pParent)
virtual void	setStatus (const CModelEntity::Status &status)
void	setTransitionTime (const C_FLOAT64 &transitionTime)
	~CMetab ()
Public Member Functions inherited from CModelEntity
	CModelEntity (const std::string &name="NoName", const CCopasiContainer *pParent=NULL, const std::string &type="ModelEntity", const unsigned C_INT32 &flag=CCopasiObject::Container|CCopasiObject::ValueDbl)
	CModelEntity (const CModelEntity &src, const CCopasiContainer *pParent=NULL)
std::string	getExpression () const
const CExpression *	getExpressionPtr () const
CExpression *	getExpressionPtr ()
std::string	getInitialExpression () const
const CExpression *	getInitialExpressionPtr () const
CExpression *	getInitialExpressionPtr ()
const C_FLOAT64 &	getInitialValue () const
CCopasiObject *	getInitialValueReference () const
virtual const std::string &	getKey () const
const C_FLOAT64 &	getRate () const
CCopasiObject *	getRateReference () const
const std::string &	getSBMLId () const
const CModelEntity::Status &	getStatus () const
const C_FLOAT64 &	getValue () const
CCopasiObject *	getValueReference () const
bool	isFixed () const
const bool &	isUsed () const
bool	setExpression (const std::string &expression)
bool	setExpressionPtr (CExpression *pExpression)
bool	setInitialExpression (const std::string &expression)
bool	setInitialExpressionPtr (CExpression *pExpression)
virtual void	setInitialValue (const C_FLOAT64 &initialValue)
void	setInitialValuePtr (C_FLOAT64 *pInitialValue)
void	setRate (const C_FLOAT64 &rate)
void	setSBMLId (const std::string &id)
void	setUsed (const bool &used)
virtual void	setValue (const C_FLOAT64 &value)
void	setValuePtr (C_FLOAT64 *pValue)
	~CModelEntity ()
Public Member Functions inherited from CCopasiContainer
virtual bool	add (CCopasiObject *pObject, const bool &adopt=true)
	CCopasiContainer (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=CCopasiObject::Container)
	CCopasiContainer (const CCopasiContainer &src, const CCopasiContainer *pParent=NULL)
virtual const CObjectInterface *	getObject (const CCopasiObjectName &cn) const
virtual const objectMap &	getObjects () const
virtual std::string	getUnits () const
virtual bool	remove (CCopasiObject *pObject)
virtual	~CCopasiContainer ()
Public Member Functions inherited from CCopasiObject
void	addDirectDependency (const CCopasiObject *pObject)
	CCopasiObject (const CCopasiObject &src, const CCopasiContainer *pParent=NULL)
void	clearDirectDependencies ()
void	clearRefresh ()
bool	dependsOn (DataObjectSet candidates, const DataObjectSet &context=DataObjectSet()) const
void	getAllDependencies (DataObjectSet &dependencies, const DataObjectSet &context) const
virtual CCopasiObjectName	getCN () const
virtual const DataObjectSet &	getDirectDependencies (const DataObjectSet &context=DataObjectSet()) const
CCopasiContainer *	getObjectAncestor (const std::string &type) const
CCopasiDataModel *	getObjectDataModel ()
const CCopasiDataModel *	getObjectDataModel () const
const std::string &	getObjectName () const
CCopasiContainer *	getObjectParent () const
const std::string &	getObjectType () const
virtual const CObjectInterface::ObjectSet &	getPrerequisites () const
virtual Refresh *	getRefresh () const
UpdateMethod *	getUpdateMethod () const
bool	hasCircularDependencies (DataObjectSet &candidates, DataObjectSet &verified, const DataObjectSet &context) const
bool	hasUpdateMethod () const
bool	isArray () const
bool	isContainer () const
bool	isDataModel () const
bool	isMatrix () const
bool	isNameVector () const
bool	isNonUniqueName () const
virtual bool	isPrerequisiteForContext (const CObjectInterface *pObject, const CMath::SimulationContextFlag &context, const CObjectInterface::ObjectSet &changedObjects) const
bool	isReference () const
bool	isRoot () const
bool	isSeparator () const
bool	isStaticString () const
bool	isValueBool () const
bool	isValueDbl () const
bool	isValueInt () const
bool	isValueInt64 () const
bool	isValueString () const
bool	isVector () const
virtual void	print (std::ostream *ostream) const
void	removeDirectDependency (const CCopasiObject *pObject)
void	setDirectDependencies (const DataObjectSet &directDependencies)
bool	setObjectName (const std::string &name)
void	setObjectValue (const C_FLOAT64 &value)
void	setObjectValue (const C_INT32 &value)
void	setObjectValue (const bool &value)
template<class CType >
void	setRefresh (CType *pType, void(CType::*method)(void))
template<class CType >
void	setUpdateMethod (CType *pType, void(CType::*method)(const C_FLOAT64 &))
template<class CType >
void	setUpdateMethod (CType *pType, void(CType::*method)(const C_INT32 &))
template<class CType >
void	setUpdateMethod (CType *pType, void(CType::*method)(const bool &))
virtual	~CCopasiObject ()
Public Member Functions inherited from CObjectInterface
	CObjectInterface ()
virtual	~CObjectInterface ()
Public Member Functions inherited from CAnnotation
bool	addUnsupportedAnnotation (const std::string &name, const std::string &xml)
	CAnnotation ()
	CAnnotation (const CAnnotation &src)
const std::string &	getMiriamAnnotation () const
const std::string &	getNotes () const
UnsupportedAnnotation &	getUnsupportedAnnotations ()
const UnsupportedAnnotation &	getUnsupportedAnnotations () const
bool	operator== (const CAnnotation &rhs) const
bool	removeUnsupportedAnnotation (const std::string &name)
bool	replaceUnsupportedAnnotation (const std::string &name, const std::string &xml)
void	setMiriamAnnotation (const std::string &miriamAnnotation, const std::string &newId, const std::string &oldId)
void	setNotes (const std::string &notes)
virtual	~CAnnotation ()

Static Public Member Functions
static C_FLOAT64	convertToConcentration (const C_FLOAT64 &number, const CCompartment &compartment, const CModel &model)
static C_FLOAT64	convertToNumber (const C_FLOAT64 &concentration, const CCompartment &compartment, const CModel &model)
Static Public Member Functions inherited from CCopasiObject
static std::vector< Refresh * >	buildUpdateSequence (const DataObjectSet &objects, const DataObjectSet &uptoDateObjects, const DataObjectSet &context=DataObjectSet())
static void	setRenameHandler (CRenameHandler *rh)
Static Public Member Functions inherited from CAnnotation
static CAnnotation *	castObject (CCopasiObject *pObject)
static const CAnnotation *	castObject (const CCopasiObject *pObject)

Protected Attributes
CCopasiObjectReference < C_FLOAT64 > *	mpConcRateReference
CConcentrationReference *	mpConcReference
CConcentrationReference *	mpIConcReference
CCopasiObjectReference < C_FLOAT64 > *	mpTTReference
Protected Attributes inherited from CModelEntity
CExpression *	mpExpression
CExpression *	mpInitialExpression
C_FLOAT64 *	mpIValue
CCopasiObjectReference < C_FLOAT64 > *	mpIValueReference
CModel *	mpModel
CCopasiObjectReference < C_FLOAT64 > *	mpRateReference
C_FLOAT64 *	mpValue
CCopasiObjectReference < C_FLOAT64 > *	mpValueReference
C_FLOAT64	mRate
std::string	mSBMLId
Protected Attributes inherited from CCopasiContainer
objectMap	mObjects
Protected Attributes inherited from CAnnotation
std::string	mKey

Private Member Functions
void	initObjects ()

Private Attributes
C_FLOAT64	mConc
C_FLOAT64	mConcRate
C_FLOAT64	mIConc
bool	mIsInitialConcentrationChangeAllowed
const CCompartment *	mpCompartment
const CMoiety *	mpMoiety
std::vector< std::pair < C_FLOAT64, const C_FLOAT64 * > >	mRateVector
C_FLOAT64	mTT

Friends
void	CMoiety::add (C_FLOAT64 value, CMetab *pMetabolite)
std::ostream &	operator<< (std::ostream &os, const CMetab &d)

Additional Inherited Members
Public Types inherited from CModelEntity
enum	Status {   FIXED = 0, ASSIGNMENT, REACTIONS, ODE,   TIME }
Public Types inherited from CCopasiContainer
typedef std::multimap < std::string, CCopasiObject * >	objectMap
Public Types inherited from CCopasiObject
typedef std::set< const CCopasiObject * >	DataObjectSet
typedef std::vector< Refresh * >	DataUpdateSequence
Public Types inherited from CObjectInterface
typedef std::set< const CObjectInterface * >	ObjectSet
typedef std::vector < CObjectInterface * >	UpdateSequence
Public Types inherited from CAnnotation
typedef std::map< std::string, std::string >	UnsupportedAnnotation
Static Public Attributes inherited from CModelEntity
static const std::string	StatusName []
static const char *	XMLStatus []
Static Public Attributes inherited from CCopasiContainer
static const std::vector < CCopasiContainer * >	EmptyList
Protected Types inherited from CCopasiObject
enum	Flag {   Container = 0x1, Vector = 0x2, Matrix = 0x4, NameVector = 0x8,   Reference = 0x10, ValueBool = 0x20, ValueInt = 0x40, ValueInt64 = 0x80,   ValueDbl = 0x100, NonUniqueName = 0x200, StaticString = 0x400, ValueString = 0x800,   Separator = 0x1000, ModelEntity = 0x2000, Array = 0x4000, DataModel = 0x8000,   Root = 0x10000, Gui = 0x20000 }
Protected Member Functions inherited from CCopasiContainer
template<class CType >
CCopasiObject *	addMatrixReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)
template<class CType >
CCopasiObject *	addObjectReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)
template<class CType >
CCopasiObject *	addVectorReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)
void	initObjects ()
Protected Member Functions inherited from CCopasiObject
	CCopasiObject ()
	CCopasiObject (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=0)
Static Protected Attributes inherited from CCopasiObject
static CRenameHandler *	smpRenameHandler = NULL

Detailed Description

Definition at line 178 of file CMetab.h.

Constructor & Destructor Documentation

CMetab::CMetab	(	const std::string &	name = "NoName",
		const CCopasiContainer *	pParent = NULL
	)

Default constructor

Parameters

const	std::string & name (default: "NoName")
const	CCopasiContainer * pParent (default: NULL)

Definition at line 46 of file CMetab.cpp.

References CKeyFactory::add(), CONSTRUCTOR_TRACE, CCopasiRootContainer::getKeyFactory(), CCopasiObject::getObjectParent(), initCompartment(), initObjects(), CAnnotation::mKey, CModelEntity::REACTIONS, setConcentration(), setInitialConcentration(), and setStatus().

                                                :
  CModelEntity(name, pParent, "Metabolite",
               CCopasiObject::NonUniqueName),
  mConc(std::numeric_limits<C_FLOAT64>::quiet_NaN()),
  mIConc(0.0),
  mConcRate(0.0),
  mTT(0.0),
  mpCompartment(NULL),
  mpMoiety(NULL),
  mIsInitialConcentrationChangeAllowed(true)
{
  mKey = CCopasiRootContainer::getKeyFactory()->add("Metabolite", this);
  initObjects();

  setStatus(REACTIONS);

  if (getObjectParent())
    {
      initCompartment(NULL);

      setInitialConcentration(1.0);
      setConcentration(1.0);
    }

  CONSTRUCTOR_TRACE;
}

CMetab::CMetab	(	const CMetab &	src,
		const CCopasiContainer *	pParent = NULL
	)

Copy constructor

Parameters

const	CMetab & src
const	CCopasiContainer * pParent (default: NULL)

Definition at line 74 of file CMetab.cpp.

References CKeyFactory::add(), CONSTRUCTOR_TRACE, CCopasiRootContainer::getKeyFactory(), initCompartment(), initObjects(), CAnnotation::mKey, and mpCompartment.

                                                :
  CModelEntity(src, pParent),
  mConc(src.mConc),
  mIConc(src.mIConc),
  mConcRate(src.mConcRate),
  mTT(src.mTT),
  mpCompartment(NULL),
  mpMoiety(src.mpMoiety),
  mIsInitialConcentrationChangeAllowed(src.mIsInitialConcentrationChangeAllowed)
{
  mKey = CCopasiRootContainer::getKeyFactory()->add("Metabolite", this);

  initObjects();

  initCompartment(src.mpCompartment);
  CONSTRUCTOR_TRACE;
}

CMetab::~CMetab

(

)

Destructor.

Definition at line 111 of file CMetab.cpp.

References DESTRUCTOR_TRACE, CCopasiRootContainer::getKeyFactory(), CAnnotation::mKey, and CKeyFactory::remove().

{
  CCopasiRootContainer::getKeyFactory()->remove(mKey);
  DESTRUCTOR_TRACE;
}

Member Function Documentation

void CMetab::calculate ( void  )

virtual

Calculate the value or the rate depending whether we have an ASIGNMENT or ODE

Reimplemented from CModelEntity.

Definition at line 669 of file CMetab.cpp.

References CModelEntity::ASSIGNMENT, CExpression::calcValue(), CModelEntity::FIXED, CMoiety::getDependentNumber(), CModel::getQuantity2NumberFactor(), CModelEntity::getStatus(), CModelEntity::getValue(), isDependent(), mConc, mpCompartment, CModelEntity::mpExpression, CModelEntity::mpModel, mpMoiety, CModelEntity::mpValue, CModelEntity::mRate, CModelEntity::ODE, and CModelEntity::REACTIONS.

Referenced by compile(), and setStatus().

{
  switch (getStatus())
    {
      case FIXED:
        break;

      case ASSIGNMENT:
        mConc = mpExpression->calcValue();
        break;

      case ODE:
        mRate = mpCompartment->getValue() * mpExpression->calcValue() * mpModel->getQuantity2NumberFactor();
        break;

      case REACTIONS:

        if (isDependent())
          *mpValue = mpMoiety->getDependentNumber();

        break;

      default:
        break;
    }
}

void CMetab::cleanup

(

)

Cleanup

Definition at line 207 of file CMetab.cpp.

{}

bool CMetab::compile ( )

virtual

Compile the model value.

Returns

bool success

Reimplemented from CModelEntity.

Definition at line 385 of file CMetab.cpp.

References CModelEntity::ASSIGNMENT, CCopasiVector< T >::begin(), calculate(), CCopasiObject::clearDirectDependencies(), CCopasiObject::clearRefresh(), CExpression::compile(), compileInitialValueDependencies(), CExpression::createInitialExpression(), CCopasiVector< T >::end(), CModelEntity::FIXED, CCopasiObject::getDirectDependencies(), CCopasiObject::getObjectAncestor(), CCopasiObject::getObjectDataModel(), CModelEntity::getRateReference(), CModel::getReactions(), CModelEntity::getStatus(), CModelEntity::getValueReference(), mConcRate, CAnnotation::mKey, mpCompartment, mpConcRateReference, mpConcReference, CModelEntity::mpExpression, CModelEntity::mpInitialExpression, CModelEntity::mpModel, CModelEntity::mpRateReference, mpTTReference, CModelEntity::mpValueReference, CModelEntity::mRate, mRateVector, mTT, CModelEntity::ODE, pdelete, CModelEntity::REACTIONS, refreshConcentration(), refreshConcentrationRate(), refreshNumber(), refreshRate(), refreshTransitionTime(), CCopasiObject::setDirectDependencies(), CCopasiObject::setObjectName(), and CCopasiObject::setRefresh().

{
  bool success = true;

  // We first clear all dependencies and refreshes
  // Particle Number
  mpValueReference->clearDirectDependencies();
  mpValueReference->clearRefresh();

  // Rate (particle number rate)
  mRateVector.clear();
  mpRateReference->clearDirectDependencies();
  mpRateReference->clearRefresh();

  // Concentration
  mpConcReference->clearDirectDependencies();
  mpConcReference->clearRefresh();

  // Concentration Rate
  mpConcRateReference->clearDirectDependencies();
  mpConcRateReference->clearRefresh();

  // Transition Time
  mpTTReference->clearDirectDependencies();
  mpTTReference->clearRefresh();

  // Prepare the compilation
  std::set<const CCopasiObject *> Dependencies;
  std::vector< CCopasiContainer * > listOfContainer;
  listOfContainer.push_back(getObjectAncestor("Model"));

  CCopasiDataModel* pDataModel = NULL;
  const CCopasiObject * pVolumeReference = NULL;

  if (mpCompartment)
    pVolumeReference = mpCompartment->getValueReference();

  // Compile the value (particle number)
  Dependencies.insert(mpConcReference);

  if (pVolumeReference)
    Dependencies.insert(pVolumeReference);

  // We no longer need to distinguish the cases since the reference are now context sensitive
  mpValueReference->setDirectDependencies(Dependencies);
  mpValueReference->setRefresh(this, &CMetab::refreshNumber);

  Dependencies.clear();

  // Compiling of the rest.
  switch (getStatus())
    {
      case FIXED:
        // Concentration
        Dependencies.insert(mpValueReference);

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        mpConcReference->setDirectDependencies(Dependencies);
        mpConcReference->setRefresh(this, &CMetab::refreshConcentration);

        // Fixed values
        mRate = 0.0;
        mConcRate = 0.0;
        mTT = std::numeric_limits<C_FLOAT64>::infinity();
        break;

      case ASSIGNMENT:
        // Concentration
        success = mpExpression->compile(listOfContainer);
        mpConcReference->setDirectDependencies(mpExpression->getDirectDependencies());
        mpConcReference->setRefresh(this, &CMetab::calculate);

        // Implicit initial expression
        pdelete(mpInitialExpression);
        pDataModel = getObjectDataModel();
        mpInitialExpression = CExpression::createInitialExpression(*mpExpression, pDataModel);
        mpInitialExpression->setObjectName("InitialExpression");

        // Fixed values
        mRate = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
        mConcRate = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
        mTT = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
        break;

      case ODE:
        // Concentration
        Dependencies.insert(mpValueReference);

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        mpConcReference->setDirectDependencies(Dependencies);
        mpConcReference->setRefresh(this, &CMetab::refreshConcentration);

        // Rate (particle number rate)
        success = mpExpression->compile(listOfContainer);
        Dependencies = mpExpression->getDirectDependencies();

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        mpRateReference->setDirectDependencies(Dependencies);
        mpRateReference->setRefresh(this, &CMetab::calculate);
        Dependencies.clear();

        // Concentration Rate
        Dependencies.insert(mpRateReference);
        Dependencies.insert(mpConcReference);

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        if (mpCompartment)
          Dependencies.insert(mpCompartment->getRateReference());

        mpConcRateReference->setDirectDependencies(Dependencies);
        mpConcRateReference->setRefresh(this, &CMetab::refreshConcentrationRate);
        Dependencies.clear();

        // Transition Time
        Dependencies.insert(mpValueReference);
        Dependencies.insert(mpRateReference);
        mpTTReference->setDirectDependencies(Dependencies);
        mpTTReference->setRefresh(this, &CMetab::refreshTransitionTime);
        Dependencies.clear();
        break;

      case REACTIONS:
        // Concentration
        Dependencies.insert(mpValueReference);

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        mpConcReference->setDirectDependencies(Dependencies);
        mpConcReference->setRefresh(this, &CMetab::refreshConcentration);

        Dependencies.clear();

        // Create the rate vector
        {
          CCopasiVectorN< CReaction >::const_iterator it = mpModel->getReactions().begin();
          CCopasiVectorN< CReaction >::const_iterator end = mpModel->getReactions().end();

          for (; it != end; ++it)
            {
              const CCopasiVector< CChemEqElement > &Balances =
                (*it)->getChemEq().getBalances();
              CCopasiVector< CChemEqElement >::const_iterator itChem = Balances.begin();
              CCopasiVector< CChemEqElement >::const_iterator endChem = Balances.end();

              for (; itChem != endChem; ++itChem)
                if ((*itChem)->getMetaboliteKey() == mKey)
                  break;

              if (itChem != endChem)
                {
                  Dependencies.insert((*it)->getParticleFluxReference());

                  std::pair< C_FLOAT64, const C_FLOAT64 * > Insert;
                  Insert.first = (*itChem)->getMultiplicity();
                  Insert.second = &(*it)->getParticleFlux();

                  mRateVector.push_back(Insert);
                }
            }
        }

        // Rate (particle number rate)
        mpRateReference->setRefresh(this, &CMetab::refreshRate);
        mpRateReference->setDirectDependencies(Dependencies);

        // Transition Time
        mpTTReference->setRefresh(this, &CMetab::refreshTransitionTime);
        mpTTReference->setDirectDependencies(Dependencies);
        Dependencies.clear();

        // Concentration Rate
        Dependencies.insert(mpRateReference);
        Dependencies.insert(mpConcReference);

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        if (mpCompartment)
          Dependencies.insert(mpCompartment->getRateReference());

        mpConcRateReference->setDirectDependencies(Dependencies);
        mpConcRateReference->setRefresh(this, &CMetab::refreshConcentrationRate);
        Dependencies.clear();

        break;

      default:
        break;
    }

  // The initial values
  success &= compileInitialValueDependencies();

  return success;
}

bool CMetab::compileInitialValueDependencies

(

)

Compile the initial particle number and initial concentration dependencies.

Returns

bool success

Definition at line 590 of file CMetab.cpp.

References CModelEntity::ASSIGNMENT, CExpression::calcValue(), CExpression::compile(), CCopasiObject::getDirectDependencies(), CEvaluationTree::getInfix(), CModelEntity::getInitialValueReference(), CCopasiObject::getObjectAncestor(), CModelEntity::getStatus(), CEvaluationTree::isUsable(), mIConc, mpCompartment, mpIConcReference, CModelEntity::mpInitialExpression, CModelEntity::mpIValueReference, and CCopasiObject::setDirectDependencies().

Referenced by compile().

{
  bool success = true;
  std::set<const CCopasiObject *> Dependencies;
  std::vector< CCopasiContainer * > listOfContainer;
  listOfContainer.push_back(getObjectAncestor("Model"));

  // If we have an assignment or a valid initial expression we must update both
  if (getStatus() == ASSIGNMENT ||
      (mpInitialExpression != NULL &&
       mpInitialExpression->getInfix() != ""))
    {
      // Initial concentration
      success &= mpInitialExpression->compile(listOfContainer);
      mpIConcReference->setDirectDependencies(mpInitialExpression->getDirectDependencies());

      // Initial particle number
      Dependencies.insert(mpIConcReference);

      if (mpCompartment)
        Dependencies.insert(mpCompartment->getInitialValueReference());

      mpIValueReference->setDirectDependencies(Dependencies);
      Dependencies.clear();

      // If we have a valid initial expression, we update the initial value.
      // In case the expression is constant this suffices others are updated lated again.
      if (mpInitialExpression->isUsable())
        mIConc = mpInitialExpression->calcValue();

      return success;
    }

  // The context sensitivity is handle in the virtual method getDirectDependencies();

  // Initial particle number
  Dependencies.insert(mpIConcReference);

  if (mpCompartment)
    Dependencies.insert(mpCompartment->getInitialValueReference());

  mpIValueReference->setDirectDependencies(Dependencies);
  Dependencies.clear();

  // Initial concentration
  Dependencies.insert(mpIValueReference);

  if (mpCompartment)
    Dependencies.insert(mpCompartment->getInitialValueReference());

  mpIConcReference->setDirectDependencies(Dependencies);
  return success;
}

void CMetab::compileIsInitialConcentrationChangeAllowed

(

)

Determine whether changing the initial concentration is allowed

Definition at line 644 of file CMetab.cpp.

References CCopasiObject::hasCircularDependencies(), mIsInitialConcentrationChangeAllowed, mpIConcReference, and CModelEntity::mpIValueReference.

{
  // We check whether changing the initial concentration will lead to circular
  // dependencies in the system.

  // These circular dependencies must always involve the initial particle number, i.e.,
  // it suffices to check whether the initial particle number has circular dependencies when the
  // concentration is changes.

  CCopasiObject::DataObjectSet Candidates;
  CCopasiObject::DataObjectSet Verified;
  CCopasiObject::DataObjectSet Context;

  Context.insert(this->mpIConcReference);

  mIsInitialConcentrationChangeAllowed = !mpIValueReference->hasCircularDependencies(Candidates, Verified, Context);

  return;
}

C_FLOAT64 CMetab::convertToConcentration ( const C_FLOAT64 &  number, const CCompartment &  compartment, const CModel &  model  )

static

Converts the number to concentration

Parameters

const	C_FLOAT64 & number
const	CCompartment & compartment
const	CModel & model

Returns

C_FLOAT64 concentration

Definition at line 41 of file CMetab.cpp.

References CModelEntity::getInitialValue(), and CModel::getNumber2QuantityFactor().

Referenced by CQSpecieDM::setData(), and CQSpeciesDetail::slotInitialValueLostFocus().

{return number / compartment.getInitialValue() * model.getNumber2QuantityFactor();}

C_FLOAT64 CMetab::convertToNumber ( const C_FLOAT64 &  concentration, const CCompartment &  compartment, const CModel &  model  )

static

Converts the concentration to number

Parameters

const	C_FLOAT64 & concentration
const	CCompartment & compartment
const	CModel & model

Returns

C_FLOAT64 number

Definition at line 35 of file CMetab.cpp.

References CModelEntity::getInitialValue(), and CModel::getQuantity2NumberFactor().

Referenced by operator=(), CQSpecieDM::setData(), and CQSpeciesDetail::slotInitialValueLostFocus().

{return concentration * compartment.getInitialValue() * model.getQuantity2NumberFactor();}

std::string CMetab::getChildObjectUnits ( const CCopasiObject *  pObject ) const

virtual

Retrieve the units of the child object.

Returns

std::string units

Reimplemented from CCopasiContainer.

Definition at line 118 of file CMetab.cpp.

References CCompartment::getChildObjectUnits(), CModel::getFrequencyUnitsDisplayString(), CModelEntity::getInitialValueReference(), CModel::getQuantityUnitsDisplayString(), CModel::getTimeUnitsDisplayString(), mpCompartment, mpConcRateReference, mpConcReference, mpIConcReference, CModelEntity::mpIValueReference, CModelEntity::mpModel, CModelEntity::mpRateReference, mpTTReference, and CModelEntity::mpValueReference.

Referenced by CModelParameter::getUnit().

{
  if (mpModel == NULL) return "";

  if (pObject == mpIValueReference ||
      pObject == mpValueReference)
    {
      return "";
    }
  else if (pObject == mpRateReference)
    {
      return mpModel->getFrequencyUnitsDisplayString();
    }
  else if (pObject == mpTTReference)
    {
      return mpModel->getTimeUnitsDisplayString();
    }
  else if (mpCompartment != NULL)
    {
      std::string Unit = mpModel->getQuantityUnitsDisplayString();
      std::string CompartmentUnit = mpCompartment->getChildObjectUnits(mpCompartment->getInitialValueReference());
      std::string TimeUnit = mpModel->getTimeUnitsDisplayString();

      if (pObject == mpIConcReference ||
          pObject == mpConcReference)
        {
          if (Unit == "")
            {
              if (CompartmentUnit == "")
                {
                  return "";
                }

              return "1/" + CompartmentUnit;
            }

          if (CompartmentUnit == "")
            {
              return Unit;
            }

          return Unit + "/" + CompartmentUnit;
        }
      else if (pObject == this->mpConcRateReference)
        {
          if (Unit == "")
            {
              if (CompartmentUnit == "")
                {
                  if (TimeUnit == "")
                    {
                      return "";
                    }

                  return "1/" + TimeUnit;
                }

              if (TimeUnit == "")
                {
                  return "1/" + CompartmentUnit;
                }

              return "1/(" + CompartmentUnit + "*" + TimeUnit + ")";
            }
          else
            {
              if (CompartmentUnit == "")
                {
                  if (TimeUnit == "")
                    {
                      return Unit;
                    }

                  return Unit + "/" + TimeUnit;
                }

              if (TimeUnit == "")
                {
                  return Unit + "/" + CompartmentUnit;
                }

              return Unit + "/(" + CompartmentUnit + "*" + TimeUnit + ")";
            }
        }
    }

  return "";
}

const CCompartment * CMetab::getCompartment

(

)

const

Definition at line 222 of file CMetab.cpp.

References mpCompartment.

Referenced by CModelAdd::addMetabolites(), CModel::calculateElasticityMatrix(), CTimeSeries::compile(), CChemEqInterface::completeCompartments(), CQSpeciesDetail::copy(), CMathObject::createExtensiveODERateExpression(), CMathObject::createExtensiveValueExpression(), CSBMLExporter::createInitialAssignment(), CMathObject::createIntensiveRateExpression(), CMathObject::createIntensiveValueExpression(), CCopasiSpringLayout::createLayout(), CModelExpansion::createLinearArray(), CSBMLExporter::createMetabolite(), CModelExpansion::createRectangularArray(), CSBMLExporter::createRule(), CCSPMethod::cspstep(), CQSpecieDM::data(), CModelExpansion::duplicateMetab(), CSBMLExporter::exportEventAssignments(), CODEExporter::exportMetabolites(), CODEExporter::exportModelEntityExpression(), CChemEqInterface::getCompartment(), CMetabNameInterface::getDisplayName(), SBMLImporter::importEvent(), SBMLImporter::importInitialAssignments(), CCopasiSpringLayout::initFromLayout(), CTSSAMethod::initializeAtol(), CModel::initializeAtolVector(), CQSpeciesDetail::load(), CQSimpleSelectionTree::populateTree(), CCopasiSpringLayout::randomize(), CModelExpansion::replaceInMetab(), CSBMLExporter::replaceSpeciesReferences(), CQSpeciesDetail::save(), CCopasiXML::saveModel(), CQSpecieDM::setData(), CReaction::setScalingFactor(), CNewtonMethod::solveJacobianXeqB(), CNewtonMethod::targetFunction(), and CMMLOutput::writeRHS().

{return mpCompartment;}

const C_FLOAT64 & CMetab::getConcentration

(

)

const

Definition at line 218 of file CMetab.cpp.

References mConc.

Referenced by CModel::calculateElasticityMatrix(), CQSpecieDM::data(), operator<<(), and CQSpeciesDetail::setFramework().

{return mConc;}

C_FLOAT64 CMetab::getConcentrationRate

(

)

const

Return rate of production of this metaboLite

Definition at line 870 of file CMetab.cpp.

References mConcRate, and refreshConcentrationRate().

Referenced by CQSpecieDM::data(), operator<<(), and CQSpeciesDetail::setFramework().

{
  const_cast<CMetab *>(this)->refreshConcentrationRate();
  return mConcRate;
}

CCopasiObject * CMetab::getConcentrationRateReference

(

)

const

Retrieve object referencing the concentration

Returns

CCopasiObject * concentrationRateReference

Definition at line 867 of file CMetab.cpp.

References mpConcRateReference.

Referenced by findObjectByDisplayName(), CMathContainer::initializeMathObjects(), and CQSimpleSelectionTree::populateTree().

{return mpConcRateReference;}

CConcentrationReference * CMetab::getConcentrationReference

(

)

const

Retrieve object referencing the concentration

Returns

CConcentrationReference * concentrationReference

Definition at line 864 of file CMetab.cpp.

References mpConcReference.

Referenced by CModel::buildDependencyGraphs(), CModel::buildSimulatedSequence(), CMathObject::compileValue(), CMathObject::createExtensiveValueExpression(), CExpression::createInitialExpression(), findObjectByDisplayName(), CModel::getCorrespondingTransientObject(), CParticleReference::getDirectDependencies(), CMathContainer::initializeMathObjects(), CParticleReference::isPrerequisiteForContext(), and CQSimpleSelectionTree::populateTree().

{return mpConcReference;}

CCopasiObject::DataObjectSet CMetab::getDeletedObjects ( ) const

virtual

Retrieve the list of deleted numeric child objects;

Returns

CCopasiObject::DataObjectSet deletedObjects

Reimplemented from CModelEntity.

Definition at line 806 of file CMetab.cpp.

References CModelEntity::getDeletedObjects(), mpConcRateReference, mpConcReference, mpIConcReference, and mpTTReference.

Referenced by CModel::appendDependentModelObjects(), CQSpeciesDetail::loadReactionTable(), mustBeDeleted(), CModel::removeMetabolite(), CQSpecieDM::removeRows(), CQSpeciesDetail::slotBtnDelete(), and CQSpeciesDetail::slotSwitchToReaction().

{
  CCopasiObject::DataObjectSet Deleted = CModelEntity::getDeletedObjects();

  Deleted.insert(mpIConcReference);
  Deleted.insert(mpConcReference);
  Deleted.insert(mpConcRateReference);
  Deleted.insert(mpTTReference);

  return Deleted;
}

const C_FLOAT64 & CMetab::getInitialConcentration

(

)

const

Definition at line 220 of file CMetab.cpp.

References mIConc.

Referenced by CModelAdd::addMetabolites(), DataModelGUI::buildChangedObjects(), CSBMLExporter::createMetabolite(), CQSpecieDM::data(), CModelExpansion::duplicateMetab(), CODEExporter::exportExpression(), CODEExporter::exportMetabolites(), CQSpeciesDetail::load(), CQSpeciesDetail::save(), and test000087::test_simulate_reaction_flux_reference_1().

{return mIConc;}

CConcentrationReference * CMetab::getInitialConcentrationReference

(

)

const

Retrieve object referencing the initial concentration

Returns

CConcentrationReference * initialConcentrationReference

Definition at line 861 of file CMetab.cpp.

References mpIConcReference.

Referenced by DataModelGUI::buildChangedObjects(), CModel::buildDependencyGraphs(), CModel::buildInitialRefreshSequence(), CMathObject::compileInitialValue(), CMathObject::createExtensiveValueExpression(), CExpression::createInitialExpression(), SliderDialog::determineCorrectObjectForSlider(), findObjectByDisplayName(), CModel::getCorrespondingTransientObject(), CParticleReference::getDirectDependencies(), getInitialCNForSBase(), CModelParameter::getUnit(), CMathContainer::initializeMathObjects(), CParticleReference::isPrerequisiteForContext(), CQSimpleSelectionTree::populateTree(), test000058::test_bug1025_3(), test000058::test_bug1025_8(), test000059::test_unique_id_11(), test000059::test_unique_id_2(), and test000059::test_unique_id_5().

{return mpIConcReference;}

const CModel * CMetab::getModel

(

)

const

Definition at line 224 of file CMetab.cpp.

References CModelEntity::mpModel.

Referenced by CQSpeciesDetail::load(), CQSpeciesDetail::loadReactionTable(), CQSpeciesDetail::save(), CQSpeciesDetail::setFramework(), CQSpeciesDetail::slotBtnDelete(), CQSpeciesDetail::slotCompartmentChanged(), CQSpeciesDetail::slotInitialValueLostFocus(), and CQSpeciesDetail::slotSwitchToReaction().

{return mpModel;}

const CMoiety * CMetab::getMoiety

(

)

const

Retrieve a pointer to the moiety the species depends on

Returns

const CMoiety * pMoiety;

Definition at line 992 of file CMetab.cpp.

References mpMoiety.

Referenced by CMathObject::compileValue().

{return mpMoiety;}

std::string CMetab::getObjectDisplayName ( bool  regular = true, bool  richtext = false  ) const

virtual

Reimplemented from CCopasiObject.

Definition at line 974 of file CMetab.cpp.

References CMetabNameInterface::getDisplayName(), CCopasiObject::getObjectAncestor(), and CCopasiObject::getObjectDisplayName().

Referenced by CSBMLExporter::createMetabolite(), CQSelectionWizardPage::fillTree(), findObjectByDisplayName(), and CQSideCompoundWizardPage::alphaSorter::operator()().

{
  CModel* tmp = dynamic_cast<CModel*>(this->getObjectAncestor("Model"));

  if (tmp)
    {
      return CMetabNameInterface::getDisplayName(tmp, *this, false);
    }

  return CCopasiObject::getObjectDisplayName(regular, richtext);
}

const C_FLOAT64 & CMetab::getTransitionTime

(

)

const

Retrieves the transition time

Returns

"const C_FLOAT64 &" transitionTime

Definition at line 229 of file CMetab.cpp.

References mTT.

Referenced by CQSpeciesDetail::load(), and operator<<().

{return mTT;}

const CCopasiObject * CMetab::getValueObject ( ) const

virtual

Retrieve the object representing the value;

Reimplemented from CModelEntity.

Definition at line 889 of file CMetab.cpp.

References mpConcReference.

{
  return mpConcReference;
}

void * CMetab::getValuePointer ( ) const

virtual

Retrieve a pointer to the value;

Reimplemented from CModelEntity.

Definition at line 895 of file CMetab.cpp.

References C_FLOAT64, and mConc.

{
  return const_cast<C_FLOAT64 *>(&mConc);
}

void CMetab::initCompartment

(

const CCompartment *

pCompartment = NULL

)

Definition at line 209 of file CMetab.cpp.

References CCopasiObject::getObjectAncestor(), and mpCompartment.

Referenced by CMetab(), and setObjectParent().

{
  mpCompartment =
    dynamic_cast< const CCompartment * >(getObjectAncestor("Compartment"));

  if (!mpCompartment)
    mpCompartment = pCompartment;
}

void CMetab::initObjects ( )

private

Initialize the contained CCopasiObjects

Definition at line 777 of file CMetab.cpp.

References CCopasiContainer::addObjectReference(), C_FLOAT64, CCopasiObjectReference< CType >::getValuePointer(), mConc, mConcRate, mIConc, mpConcRateReference, mpConcReference, mpIConcReference, CModelEntity::mpIValueReference, CModelEntity::mpRateReference, mpTTReference, CModelEntity::mpValueReference, mTT, pdelete, refreshInitialConcentration(), refreshInitialValue(), CCopasiObject::setObjectName(), CCopasiObject::setRefresh(), and CCopasiObject::ValueDbl.

Referenced by CMetab().

{
  // We need to have mpIValueRefernce point to a CParticleReference object.
  C_FLOAT64 * pValue = static_cast< C_FLOAT64 * >(mpValueReference->getValuePointer());
  assert(pValue != NULL);
  pdelete(mpIValueReference);
  mpIValueReference = new CParticleReference("InitialParticleNumber", this, *pValue);
  mpIValueReference->setRefresh(this, &CMetab::refreshInitialValue);

  // We need to have mpValueRefernce point to a CParticleReference object.
  pValue = static_cast< C_FLOAT64 * >(mpValueReference->getValuePointer());
  assert(pValue != NULL);
  pdelete(mpValueReference);
  mpValueReference = new CParticleReference("ParticleNumber", this, *pValue);

  mpRateReference->setObjectName("ParticleNumberRate");

  mpIConcReference = new CConcentrationReference("InitialConcentration", this, mIConc);
  mpIConcReference->setRefresh(this, &CMetab::refreshInitialConcentration);

  mpConcReference = new CConcentrationReference("Concentration", this, mConc);

  mpConcRateReference =
    static_cast<CCopasiObjectReference<C_FLOAT64> *>(addObjectReference("Rate", mConcRate, CCopasiObject::ValueDbl));

  mpTTReference =
    static_cast<CCopasiObjectReference<C_FLOAT64> *>(addObjectReference("TransitionTime", mTT, CCopasiObject::ValueDbl));
}

bool CMetab::isDependent

(

)

const

Retrieve whether the metabolite dependent

Returns

bool dependent

Definition at line 989 of file CMetab.cpp.

References mpMoiety.

Referenced by calculate(), CLNAMethod::calculateCovarianceMatrixReduced(), CODEExporter::exportExpression(), CODEExporter::exportMetabolites(), CODEExporter::exportODEs(), CODEExporterBM::exportSingleMetabolite(), CODEExporterXPPAUT::exportSingleMetabolite(), CODEExporterC::exportSingleMetabolite(), CODEExporter::isModelEntityExpressionODEExporterCompatible(), CParticleReference::isPrerequisiteForContext(), CODEExporterC::preprocess(), and CODEExporter::preprocess().

{return mpMoiety != NULL;}

const bool & CMetab::isInitialConcentrationChangeAllowed

(

)

const

Check whether changing the initial concentration is allowed

Returns

const bool & allowed

Definition at line 664 of file CMetab.cpp.

References mIsInitialConcentrationChangeAllowed.

Referenced by DataModelGUI::buildChangedObjects(), CModel::buildInitialRefreshSequence(), SliderDialog::determineCorrectObjectForSlider(), CQSpecieDM::flags(), and CQSpeciesDetail::setFramework().

{
  return mIsInitialConcentrationChangeAllowed;
}

C_INT32 CMetab::load

(

CReadConfig &

configbuffer

)

Loads an object with data coming from a CReadConfig object. (CReadConfig object reads an input stream)

Parameters

pconfigbuffer

reference to a CReadConfig object.

Returns

Fail

Definition at line 922 of file CMetab.cpp.

References C_INT32, CCopasiObject::getObjectName(), CReadConfig::getVariable(), METAB_MOIETY, mIConc, CModelEntity::REACTIONS, CReadConfig::SEARCH, setConcentration(), setInitialConcentration(), CCopasiObject::setObjectName(), setStatus(), and CCopasiMessage::WARNING.

{
  C_INT32 Fail = 0;

  std::string tmp;
  Fail = configbuffer.getVariable("Metabolite", "string",
                                  (void *) & tmp,
                                  CReadConfig::SEARCH);

  if (Fail)
    return Fail;

  setObjectName(tmp);

  Fail = configbuffer.getVariable("InitialConcentration", "C_FLOAT64",
                                  (void *) & mIConc);

  setInitialConcentration(mIConc);
  setConcentration(mIConc);

  Status GepasiStatus;
  Fail = configbuffer.getVariable("Type", "C_INT16",
                                  (void *) & GepasiStatus);

  if (Fail)
    return Fail;

  setStatus(GepasiStatus);

  // sanity check
  if ((GepasiStatus < 0) || (GepasiStatus > 7))
    {
      CCopasiMessage(CCopasiMessage::WARNING,
                     "The file specifies a non-existing type "
                     "for '%s'.\nReset to internal species.",
                     getObjectName().c_str());
      setStatus(REACTIONS);
    }

  // sanity check
  if ((GepasiStatus != METAB_MOIETY) && (mIConc < 0.0))
    {
      CCopasiMessage(CCopasiMessage::WARNING,
                     "The file specifies a negative concentration "
                     "for '%s'.\nReset to default.",
                     getObjectName().c_str());
      mIConc = 1.0;
    }

  return Fail;
}

bool CMetab::mustBeDeleted ( const DataObjectSet &  deletedObjects ) const

virtual

Check whether an object must be deleted because its prerequisites can no longer be fulfilled due to the given deleted objects

Parameters

const

DataObjectSet & deletedObjects

Returns

bool mustBeDeleted

Reimplemented from CModelEntity.

Definition at line 819 of file CMetab.cpp.

References getDeletedObjects(), CModelEntity::getStatus(), mpConcRateReference, CModelEntity::mpRateReference, mpTTReference, and CModelEntity::REACTIONS.

{
  bool MustBeDeleted = false;

  DataObjectSet ChildObjects = getDeletedObjects();

  DataObjectSet::const_iterator it = ChildObjects.begin();
  DataObjectSet::const_iterator end = ChildObjects.end();

  for (; it != end; ++it)
    {
      if (*it == this)
        {
          if ((*it)->CCopasiObject::mustBeDeleted(deletedObjects))
            {
              MustBeDeleted = true;
              break;
            }

          continue;
        }

      // The following objects are automatically corrected, i.e., they
      // are no reasons for being deleted.
      if (getStatus() == REACTIONS &&
          (*it == this->mpConcRateReference ||
           *it == this->mpRateReference ||
           *it == this->mpTTReference))
        {
          continue;
        }

      if ((*it)->mustBeDeleted(deletedObjects))
        {
          MustBeDeleted = true;
          break;
        }
    }

  return MustBeDeleted;
}

CMetab & CMetab::operator=

(

const CMetabOld &

rhs

)

Assignment operator.

Definition at line 93 of file CMetab.cpp.

References C_FLOAT64, convertToNumber(), CCopasiObject::getObjectName(), mConcRate, CMetabOld::mIConc, mpCompartment, CModelEntity::mpModel, CModelEntity::mRate, CMetabOld::mStatus, mTT, CModelEntity::setInitialValue(), CCopasiObject::setObjectName(), and setStatus().

{
  setObjectName(RHS.getObjectName());

  setStatus(RHS.mStatus);

  // We need to set the initial particle number since that is the expected for the initial state
  C_FLOAT64 InitialParticleNumber =
    CMetab::convertToNumber(RHS.mIConc, *mpCompartment, *mpModel);
  setInitialValue(InitialParticleNumber);

  mRate = 0.0;
  mConcRate = 0.0;
  mTT = 0.0;

  return *this;  // Assignment operator returns left side.
}

void CMetab::refreshConcentration

(

)

Definition at line 281 of file CMetab.cpp.

References CModel::getNumber2QuantityFactor(), CModelEntity::getValue(), mConc, mpCompartment, CModelEntity::mpModel, and CModelEntity::mpValue.

Referenced by CConcentrationReference::CConcentrationReference(), compile(), CHybridMethod::fireReaction(), CHybridMethodLSODA::fireReaction(), CHybridMethodODE45::fireReaction(), setStatus(), and CStochMethod::updateSystemState().

{
  mConc = *mpValue / mpCompartment->getValue() * mpModel->getNumber2QuantityFactor();
}

void CMetab::refreshConcentrationRate

(

)

Calculate the concentration rate.

Definition at line 876 of file CMetab.cpp.

References CModel::getNumber2QuantityFactor(), CModelEntity::getRate(), CModelEntity::getValue(), mConc, mConcRate, mpCompartment, CModelEntity::mpModel, and CModelEntity::mRate.

Referenced by compile(), getConcentrationRate(), and setStatus().

{
  // d(Particle Number*conversion/Volume)/dt
  // = (Rate / Volume - Particle Number / Volume^2 * Volume Rate) * conversion
  // = (Rate - Particle Number / Volume * Volume Rate) / Volume * conversion
  // = (Rate  * conversion - Concentration * Volume Rate) / Volume

  mConcRate =
    (mRate * mpModel->getNumber2QuantityFactor() - mConc * mpCompartment->getRate())
    / mpCompartment->getValue();
}

void CMetab::refreshInitialConcentration

(

)

Definition at line 269 of file CMetab.cpp.

References CExpression::calcValue(), CEvaluationTree::getInfix(), CModelEntity::getInitialValue(), CModel::getNumber2QuantityFactor(), CModelEntity::isFixed(), mConc, mIConc, mpCompartment, CModelEntity::mpInitialExpression, CModelEntity::mpIValue, and CModelEntity::mpModel.

Referenced by initObjects().

{
  if (mpInitialExpression != NULL &&
      mpInitialExpression->getInfix() != "")
    mIConc = mpInitialExpression->calcValue();
  else
    mIConc =
      *mpIValue / mpCompartment->getInitialValue() * mpModel->getNumber2QuantityFactor();

  if (isFixed()) mConc = mIConc;
}

void CMetab::refreshInitialValue ( )

virtual

Refresh the initial value

Reimplemented from CModelEntity.

Definition at line 264 of file CMetab.cpp.

References CModelEntity::getInitialValue(), CModel::getQuantity2NumberFactor(), mIConc, mpCompartment, CModelEntity::mpIValue, and CModelEntity::mpModel.

Referenced by CModel::createMetabolite(), and initObjects().

{
  *mpIValue = mIConc * mpCompartment->getInitialValue() * mpModel->getQuantity2NumberFactor();
}

void CMetab::refreshNumber

(

)

Definition at line 286 of file CMetab.cpp.

References CModel::getQuantity2NumberFactor(), CModelEntity::getValue(), mConc, mpCompartment, CModelEntity::mpModel, and CModelEntity::mpValue.

Referenced by compile(), setStatus(), and CSensMethod::setValue().

{
  *mpValue = mConc * mpCompartment->getValue() * mpModel->getQuantity2NumberFactor();
}

void CMetab::refreshRate

(

)

Calculate the particle rate.

Definition at line 696 of file CMetab.cpp.

References CModelEntity::ASSIGNMENT, CModelEntity::FIXED, CModelEntity::getStatus(), CModelEntity::mRate, mRateVector, CModelEntity::ODE, and CModelEntity::REACTIONS.

Referenced by compile(), and setStatus().

{
  switch (getStatus())
    {
      case FIXED:
        break;

      case ASSIGNMENT:
        break;

      case ODE:
        break;

      case REACTIONS:
      {
        mRate = 0.0;

        std::vector< std::pair< C_FLOAT64, const C_FLOAT64 * > >::const_iterator it =
          mRateVector.begin();
        std::vector< std::pair< C_FLOAT64, const C_FLOAT64 * > >::const_iterator end =
          mRateVector.end();

        for (; it != end; ++it)
          mRate += it->first * *it->second;
      }
      break;

      default:
        break;
    }
}

void CMetab::refreshTransitionTime

(

)

Calculate the transition time.

Definition at line 728 of file CMetab.cpp.

References CModelEntity::ASSIGNMENT, C_FLOAT64, CModelEntity::FIXED, CModelEntity::getStatus(), min, CModelEntity::mpValue, CModelEntity::mRate, mRateVector, mTT, CModelEntity::ODE, and CModelEntity::REACTIONS.

Referenced by compile().

{
  switch (getStatus())
    {
      case FIXED:
        break;

      case ASSIGNMENT:
        break;

      case ODE:
        mTT = *mpValue / fabs(mRate);
        break;

      case REACTIONS:
      {
        C_FLOAT64 PositiveFlux = 0;
        C_FLOAT64 NegativeFlux = 0;
        C_FLOAT64 Flux;

        std::vector< std::pair< C_FLOAT64, const C_FLOAT64 * > >::const_iterator it =
          mRateVector.begin();
        std::vector< std::pair< C_FLOAT64, const C_FLOAT64 * > >::const_iterator end =
          mRateVector.end();

        for (; it != end; ++it)
          {
            Flux = it->first * *it->second;

            if (Flux > 0.0)
              PositiveFlux += Flux;
            else
              NegativeFlux -= Flux;
          }

        Flux = std::min(PositiveFlux, NegativeFlux);

        if (Flux == 0.0)
          mTT = std::numeric_limits<C_FLOAT64>::infinity();
        else
          mTT = *mpValue / Flux;
      }
      break;

      default:
        break;
    }
}

void CMetab::setConcentration

(

const C_FLOAT64

concentration

)

Definition at line 250 of file CMetab.cpp.

References CModelEntity::isFixed(), and mConc.

Referenced by CMetab(), load(), and CSensMethod::setValue().

{
  if (isFixed()) return;

  mConc = concentration;
}

void CMetab::setDependentOn

(

const CMoiety *

pMoiety

)

Set whether the metabolite is dependent, i.e., calculated by a moiety

Parameters

const

CMoiety * pMoiety

Definition at line 986 of file CMetab.cpp.

References mpMoiety.

Referenced by CMoiety::add().

{mpMoiety = pMoiety;}

void CMetab::setInitialConcentration

(

const C_FLOAT64 &

initialConcentration

)

Definition at line 257 of file CMetab.cpp.

References mIConc.

Referenced by CMetab(), CModel::createMetabolite(), load(), CQSpeciesDetail::save(), CQSpecieDM::setData(), and CQSpeciesDetail::slotBtnNew().

{
  mIConc = initialConcentration;

  return;
}

bool CMetab::setObjectParent ( const CCopasiContainer *  pParent )

virtual

Sets the parent of the metabolite;

Parameters

const

CCopasiContainer * pParent

Returns

bool success

Reimplemented from CModelEntity.

Definition at line 231 of file CMetab.cpp.

References CModelEntity::FIXED, CModelEntity::getStatus(), initCompartment(), CModelEntity::REACTIONS, CModelEntity::setObjectParent(), and setStatus().

{
  CModelEntity::setObjectParent(pParent);
  initCompartment(NULL);

  Status CurrentStatus = getStatus();

  if (CurrentStatus != FIXED)
    setStatus(FIXED);
  else
    setStatus(REACTIONS);

  setStatus(CurrentStatus);

  return true;
}

void CMetab::setStatus ( const CModelEntity::Status &  status )

virtual

Set the status

Parameters

const

CModelEntity::Status & status

Reimplemented from CModelEntity.

Definition at line 291 of file CMetab.cpp.

References CModelEntity::ASSIGNMENT, calculate(), CCopasiObject::clearRefresh(), CModelEntity::FIXED, CCopasiObject::getDirectDependencies(), CModelEntity::getStatus(), CModelEntity::getValueReference(), mpCompartment, mpConcRateReference, mpConcReference, CModelEntity::mpExpression, CModelEntity::mpModel, CModelEntity::mpRateReference, CModelEntity::mpValueReference, CModelEntity::ODE, CModelEntity::REACTIONS, refreshConcentration(), refreshConcentrationRate(), refreshNumber(), refreshRate(), CCopasiObject::setDirectDependencies(), CCopasiObject::setRefresh(), and CModelEntity::setStatus().

Referenced by CModelAdd::addMetabolites(), CMetab(), SBMLImporter::createCMetabFromSpecies(), CModel::createMetabolite(), load(), operator=(), CQSpeciesDetail::save(), CQSpecieDM::setData(), and setObjectParent().

{
  Status OldStatus = getStatus();

  CModelEntity::setStatus(status);

  if (status == OldStatus) return;

  CCopasiObject::DataObjectSet Dependencies;

  const CCopasiObject * pVolumeReference = NULL;

  if (mpCompartment)
    pVolumeReference = mpCompartment->getValueReference();

  switch (getStatus())
    {
      case FIXED:
        break;

      case ASSIGNMENT:
        Dependencies.insert(mpConcReference);

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        mpValueReference->setDirectDependencies(Dependencies);
        mpValueReference->setRefresh(this, &CMetab::refreshNumber);

        mpConcReference->setDirectDependencies(mpExpression->getDirectDependencies());
        mpConcReference->setRefresh(this, &CMetab::calculate);

        // The dependencies and refresh of the rate are correct (see CModelEntity::setStatus).

        mpConcRateReference->setDirectDependencies(mpRateReference->getDirectDependencies());
        mpConcRateReference->clearRefresh();
        break;

      case ODE:
        mpValueReference->setDirectDependencies(Dependencies);
        mpValueReference->clearRefresh();

        Dependencies.insert(mpValueReference);

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        mpConcReference->setDirectDependencies(Dependencies);
        mpConcReference->setRefresh(this, &CMetab::refreshConcentration);

        Dependencies.clear();
        Dependencies.insert(mpConcRateReference);

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        mpRateReference->setDirectDependencies(Dependencies);
        mpRateReference->setRefresh(this, &CMetab::refreshRate);

        mpConcRateReference->setDirectDependencies(mpExpression->getDirectDependencies());
        mpConcRateReference->setRefresh(this, &CMetab::calculate);

        break;

      case REACTIONS:
        mpValueReference->setDirectDependencies(Dependencies);
        mpValueReference->clearRefresh();

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        Dependencies.insert(mpValueReference);
        mpConcReference->setDirectDependencies(Dependencies);
        mpConcReference->setRefresh(this, &CMetab::refreshConcentration);

        mpRateReference->setRefresh(this, &CMetab::refreshRate);

        Dependencies.clear();

        if (pVolumeReference)
          Dependencies.insert(pVolumeReference);

        Dependencies.insert(mpRateReference);
        mpConcRateReference->setDirectDependencies(Dependencies);
        mpConcRateReference->setRefresh(this, &CMetab::refreshConcentrationRate);
        break;

      default:
        break;
    }

  if (mpModel && mpCompartment) refreshConcentration();
}

void CMetab::setTransitionTime

(

const C_FLOAT64 &

transitionTime

)

Set transition time

Parameters

const C_FLOAT64 &

transitionTime

Definition at line 226 of file CMetab.cpp.

References mTT.

{mTT = transitionTime;}

Friends And Related Function Documentation

void CMoiety::add ( C_FLOAT64  value, CMetab *  pMetabolite  )

friend

std::ostream& operator<< ( std::ostream &  os, const CMetab &  d  )

friend

ostream operator

Definition at line 900 of file CMetab.cpp.

{
  os << "    ++++CMetab: " << d.getObjectName() << std::endl;
  os << "        mConc " << d.mConc << " mIConc " << d.mIConc << std::endl;
  os << "        mValue (particle number) " << *d.mpValue << " mIValue " << *d.mpIValue << std::endl;
  os << "        mRate " << d.mRate << " mTT " << d.mTT << " mStatus " << d.getStatus() << std::endl;

  if (d.mpCompartment)
    os << "        mpCompartment == " << d.mpCompartment << std::endl;
  else
    os << "        mpCompartment == 0 " << std::endl;

  if (d.mpModel)
    os << "        mpModel == " << d.mpModel << std::endl;
  else
    os << "        mpModel == 0 " << std::endl;

  os << "    ----CMetab " << std::endl;

  return os;
}

Member Data Documentation

C_FLOAT64 CMetab::mConc

private

Concentration of the metabolite as double.

Definition at line 211 of file CMetab.h.

Referenced by calculate(), getConcentration(), getValuePointer(), initObjects(), operator<<(), refreshConcentration(), refreshConcentrationRate(), refreshInitialConcentration(), refreshNumber(), and setConcentration().

C_FLOAT64 CMetab::mConcRate

private

The rate of concentration change

Definition at line 221 of file CMetab.h.

Referenced by compile(), getConcentrationRate(), initObjects(), operator=(), and refreshConcentrationRate().

C_FLOAT64 CMetab::mIConc

private

Initial concentration of the metabolite as double

Definition at line 216 of file CMetab.h.

Referenced by compileInitialValueDependencies(), getInitialConcentration(), initObjects(), load(), operator<<(), refreshInitialConcentration(), refreshInitialValue(), and setInitialConcentration().

bool CMetab::mIsInitialConcentrationChangeAllowed

private

Definition at line 241 of file CMetab.h.

Referenced by compileIsInitialConcentrationChangeAllowed(), and isInitialConcentrationChangeAllowed().

const CCompartment* CMetab::mpCompartment

private

pointer to the compartment the metabolite is located in. The metab needs to know about volumes.

Definition at line 232 of file CMetab.h.

Referenced by calculate(), CMetab(), compile(), compileInitialValueDependencies(), getChildObjectUnits(), getCompartment(), initCompartment(), operator<<(), operator=(), refreshConcentration(), refreshConcentrationRate(), refreshInitialConcentration(), refreshInitialValue(), refreshNumber(), and setStatus().

CCopasiObjectReference<C_FLOAT64>* CMetab::mpConcRateReference

protected

Definition at line 246 of file CMetab.h.

Referenced by compile(), getChildObjectUnits(), getConcentrationRateReference(), getDeletedObjects(), initObjects(), mustBeDeleted(), and setStatus().

CConcentrationReference* CMetab::mpConcReference

protected

Definition at line 245 of file CMetab.h.

Referenced by compile(), getChildObjectUnits(), getConcentrationReference(), getDeletedObjects(), getValueObject(), initObjects(), and setStatus().

CConcentrationReference* CMetab::mpIConcReference

protected

Definition at line 244 of file CMetab.h.

Referenced by compileInitialValueDependencies(), compileIsInitialConcentrationChangeAllowed(), getChildObjectUnits(), getDeletedObjects(), getInitialConcentrationReference(), and initObjects().

const CMoiety* CMetab::mpMoiety

private

If dependent the moiety the metabolite is calculated from

Definition at line 237 of file CMetab.h.

Referenced by calculate(), getMoiety(), isDependent(), and setDependentOn().

CCopasiObjectReference<C_FLOAT64>* CMetab::mpTTReference

protected

Definition at line 247 of file CMetab.h.

Referenced by compile(), getChildObjectUnits(), getDeletedObjects(), initObjects(), and mustBeDeleted().

std::vector< std::pair< C_FLOAT64, const C_FLOAT64 * > > CMetab::mRateVector

private

Definition at line 239 of file CMetab.h.

Referenced by compile(), refreshRate(), and refreshTransitionTime().

C_FLOAT64 CMetab::mTT

private

Transition time of the metabolite

Definition at line 226 of file CMetab.h.

Referenced by compile(), getTransitionTime(), initObjects(), operator<<(), operator=(), refreshTransitionTime(), and setTransitionTime().

---

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

• CMetab.h
• CMetab.cpp