#include <CChemEq.h>

Inheritance diagram for CChemEq:

Collaboration diagram for CChemEq:

Public Types
enum	MetaboliteRole { PRODUCT = 0, SUBSTRATE, MODIFIER, NOROLE }

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 Member Functions
bool	addMetabolite (const std::string &key, const C_FLOAT64 multiplicity, const MetaboliteRole &role)

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

	CChemEq (const CChemEq &src, const CCopasiContainer *pParent=NULL)

void	cleanup ()

const CCopasiVector < CChemEqElement > &	getBalances () const

size_t	getCompartmentNumber () const

std::set< const CCompartment * >	getCompartments () const

const CCompartment *	getLargestCompartment () const

const CCopasiVector < CChemEqElement > &	getModifiers () const

size_t	getMolecularity (const MetaboliteRole role) const

const CCopasiVector < CChemEqElement > &	getProducts () const

const bool &	getReversibility () const

const CCopasiVector < CChemEqElement > &	getSubstrates () const

bool	setMultiplicity (const CMetab *pMetab, C_FLOAT64 newMult, MetaboliteRole role)

void	setReversibility (const bool &reversible)

virtual	~CChemEq ()

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 std::string	getChildObjectUnits (const CCopasiObject *pObject) const

virtual const CObjectInterface *	getObject (const CCopasiObjectName &cn) const

virtual const objectMap &	getObjects () const

virtual std::string	getUnits () const

virtual const CCopasiObject *	getValueObject () 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

virtual const std::string &	getKey () const

CCopasiContainer *	getObjectAncestor (const std::string &type) const

CCopasiDataModel *	getObjectDataModel ()

const CCopasiDataModel *	getObjectDataModel () const

virtual std::string	getObjectDisplayName (bool regular=true, bool richtext=false) 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

virtual void *	getValuePointer () 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 bool	mustBeDeleted (const DataObjectSet &deletedObjects) const

virtual void	print (std::ostream *ostream) const

void	removeDirectDependency (const CCopasiObject *pObject)

void	setDirectDependencies (const DataObjectSet &directDependencies)

bool	setObjectName (const std::string &name)

virtual bool	setObjectParent (const CCopasiContainer *pParent)

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 ()

Private Member Functions
void	addElement (CCopasiVector< CChemEqElement > &structure, const CChemEqElement &element, CChemEq::MetaboliteRole role=CChemEq::PRODUCT)

Private Attributes
CCopasiVector< CChemEqElement >	mBalances

CCopasiVector< CChemEqElement >	mModifiers

CCopasiVector< CChemEqElement >	mProducts

bool	mReversible

CCopasiVector< CChemEqElement >	mSubstrates

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

Additional Inherited Members
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 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)

Protected Attributes inherited from CCopasiContainer
objectMap	mObjects

Static Protected Attributes inherited from CCopasiObject
static CRenameHandler *	smpRenameHandler = NULL

Detailed Description

Definition at line 33 of file CChemEq.h.

Member Enumeration Documentation

enum CChemEq::MetaboliteRole

Enumerator
PRODUCT
SUBSTRATE
MODIFIER
NOROLE

Definition at line 36 of file CChemEq.h.

   {
     PRODUCT = 0,
     SUBSTRATE,
     MODIFIER,
     NOROLE
   };

Constructor & Destructor Documentation

CChemEq::CChemEq	(	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 30 of file CChemEq.cpp.

References CONSTRUCTOR_TRACE.

                                                   :
   CCopasiContainer(name, pParent, "Chemical Equation"),
   mReversible(false),
   mSubstrates("Substrates", this),
   mProducts("Products", this),
   mModifiers("Modifiers", this),
   mBalances("Balances", this)
 {CONSTRUCTOR_TRACE;}

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

Copy constructor

Parameters

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

Definition at line 40 of file CChemEq.cpp.

References CONSTRUCTOR_TRACE.

                                                   :
   CCopasiContainer(src, pParent),
   mReversible(src.mReversible),
   mSubstrates(src.mSubstrates, this),
   mProducts(src.mProducts, this),
   mModifiers(src.mModifiers, this),
   mBalances(src.mBalances, this)
 {CONSTRUCTOR_TRACE;}

CChemEq::~CChemEq ( )

virtual

Destructor

Definition at line 50 of file CChemEq.cpp.

References cleanup(), and DESTRUCTOR_TRACE.

50 {cleanup(); DESTRUCTOR_TRACE;}

DESTRUCTOR_TRACE

#define DESTRUCTOR_TRACE

Definition: copasi.h:206

CChemEq::cleanup

void cleanup()

Definition: CChemEq.cpp:52

Member Function Documentation

void CChemEq::addElement	(	CCopasiVector< CChemEqElement > &	structure,
		const CChemEqElement &	element,
		CChemEq::MetaboliteRole	role = `CChemEq::PRODUCT`
	)

private

Adds an element to the vector given by structure. The element is either SUBSTRATE or PRODUCT.

Parameters

CCopasiVector < CChemEqElement > &	structure
const CChemEqElement &	element
CChemEq::MetaboliteRole	role (

Definition at line 180 of file CChemEq.cpp.

References CCopasiVector< T >::add(), CChemEqElement::getMetaboliteKey(), CChemEqElement::getMultiplicity(), CChemEqElement::setMultiplicity(), CCopasiVector< T >::size(), and SUBSTRATE.

Referenced by addMetabolite(), and setMultiplicity().

 {
   size_t i;
 
   std::string key = element.getMetaboliteKey();
 
   if (key == "")
     return; // don�t add empty element
 
   for (i = 0; i < structure.size(); i++)
     if (key == structure[i]->getMetaboliteKey())
       break;
 
   if (i >= structure.size())
     {
       CChemEqElement * Element = new CChemEqElement(element);
 
       if (role == CChemEq::SUBSTRATE)
         Element->setMultiplicity(- Element->getMultiplicity());
 
       structure.add(Element, true);
     }
   else if (role == CChemEq::SUBSTRATE)
     structure[i]->addToMultiplicity(- element.getMultiplicity());
   else
     structure[i]->addToMultiplicity(element.getMultiplicity());
 }

bool CChemEq::addMetabolite	(	const std::string &	key,
		const C_FLOAT64	multiplicity,
		const MetaboliteRole &	role
	)

Add a species to the equation

Parameters

const	std::string & speciesKey
const	C_FLOAT64 & multiplicity
const	MetaboliteRole & role

Returns: bool success

Definition at line 80 of file CChemEq.cpp.

References addElement(), fatalError, mBalances, mModifiers, MODIFIER, mProducts, mSubstrates, PRODUCT, CChemEqElement::setMetabolite(), CChemEqElement::setMultiplicity(), and SUBSTRATE.

Referenced by CReaction::addModifier(), CReaction::addProduct(), CReaction::addSubstrate(), SBMLImporter::applyStoichiometricExpressions(), SBMLImporter::isMassActionExpression(), CReaction::loadOneRole(), and CChemEqInterface::writeToChemEq().

 {
   CChemEqElement element;
   element.setMetabolite(key);
   element.setMultiplicity(multiplicity);
 
   switch (role)
     {
       case CChemEq::SUBSTRATE:
         addElement(mSubstrates, element);
         addElement(mBalances, element, CChemEq::SUBSTRATE);
         break;
 
       case CChemEq::PRODUCT:
         addElement(mProducts, element);
         addElement(mBalances, element);
         break;
 
       case CChemEq::MODIFIER:
         addElement(mModifiers, element);
         break;
 
       default:
         fatalError();
         break;
     }
 
   return true;
 }

void CChemEq::cleanup ( )

Cleanup

Definition at line 52 of file CChemEq.cpp.

References CCopasiVector< T >::cleanup(), mBalances, mModifiers, mProducts, and mSubstrates.

Referenced by CChemEqInterface::writeToChemEq(), and ~CChemEq().

 {
   mSubstrates.cleanup();
   mProducts.cleanup();
   mModifiers.cleanup();
   mBalances.cleanup();
 }

const CCopasiVector< CChemEqElement > & CChemEq::getBalances ( ) const

Retrieves the vector of metabolites and their total balance in the chemical reaction.

Returns: "vector < CChemEqElement * > &" balances

Definition at line 69 of file CChemEq.cpp.

References mBalances.

Referenced by CMathReaction::initialize(), and CMMLOutput::writeRHS().

70 {return mBalances;}

CChemEq::mBalances

CCopasiVector< CChemEqElement > mBalances

Definition: CChemEq.h:216

size_t CChemEq::getCompartmentNumber ( ) const

Returns the number of compartments the chemical equation is associated with.

Definition at line 110 of file CChemEq.cpp.

References getCompartments().

 {
   return getCompartments().size();
 }

std::set< const CCompartment * > CChemEq::getCompartments ( ) const

Retrieves a set of the compartments.

Definition at line 115 of file CChemEq.cpp.

References CCopasiVector< T >::begin(), CCopasiVector< T >::end(), and mBalances.

Referenced by CMathObject::compileFlux(), and getCompartmentNumber().

 {
   const CCompartment * pCompartment = NULL;
   std::set< const CCompartment * > Compartments;
 
   CCopasiVector < CChemEqElement >::const_iterator it = mBalances.begin();
   CCopasiVector < CChemEqElement >::const_iterator end = mBalances.end();
 
   for (; it != end; ++it)
     {
       if ((*it)->getMetabolite() == NULL)
         continue;
 
       if ((pCompartment = (*it)->getMetabolite()->getCompartment()) != NULL)
         {
           Compartments.insert(pCompartment);
         }
     }
 
   return Compartments;
 }

const CCompartment * CChemEq::getLargestCompartment ( ) const

Retrieve the largest compartment that the reaction touches. This is time dependent it can only be called after update initial values has been called. Note for an empty reaction a NULL pointer is returned.

Returns: const CCompartment * pCompartment

Definition at line 137 of file CChemEq.cpp.

References C_FLOAT64, C_INVALID_INDEX, mProducts, mSubstrates, and CCopasiVector< T >::size().

Referenced by CReaction::getLargestCompartment().

 {
   size_t indexSubstrates = C_INVALID_INDEX;
   size_t indexProducts = C_INVALID_INDEX;
   size_t i, imax;
 
   C_FLOAT64 tmp, maxVol = -1.0;
 
   for (i = 0, imax = mSubstrates.size(); i < imax; i++)
     {
       if (!mSubstrates[i]->getMetabolite()) continue;
 
       tmp = mSubstrates[i]->getMetabolite()->getCompartment()->getValue();
 
       if (tmp > maxVol)
         {
           maxVol = tmp;
           indexSubstrates = i;
         }
     }
 
   for (i = 0, imax = mProducts.size(); i < imax; i++)
     {
       if (!mProducts[i]->getMetabolite()) continue;
 
       tmp = mProducts[i]->getMetabolite()->getCompartment()->getValue();
 
       if (tmp > maxVol)
         {
           maxVol = tmp;
           indexProducts = i;
         }
     }
 
   if (indexProducts != C_INVALID_INDEX)
     return mProducts[indexProducts]->getMetabolite()->getCompartment();
 
   if (indexSubstrates != C_INVALID_INDEX)
     return mSubstrates[indexSubstrates]->getMetabolite()->getCompartment();
 
   return NULL;
 }

const CCopasiVector< CChemEqElement > & CChemEq::getModifiers ( ) const

Retrieves the vector of Modifiers and their multiplicity

Definition at line 66 of file CChemEq.cpp.

References mModifiers.

67 {return mModifiers;}

CChemEq::mModifiers

CCopasiVector< CChemEqElement > mModifiers

Definition: CChemEq.h:209

size_t CChemEq::getMolecularity ( const MetaboliteRole role ) const

Checks if it is possible to figure out a compartment from the information in the chemical equation. If there are substrates and if all the substrates are in the same compartment this compartment will be returned. If there are no substrates and there are Products and all Products are in the same compartment this compartment will be returned, else an exception will be thrown. This returns the sum of the multiplicities

Definition at line 210 of file CChemEq.cpp.

References fatalError, mModifiers, MODIFIER, mProducts, mSubstrates, PRODUCT, CCopasiVector< T >::size(), and SUBSTRATE.

Referenced by CFindDimensions::setChemicalEquation().

 {
   const CCopasiVector<CChemEqElement> * tmpVector = NULL;
 
   switch (role)
     {
       case CChemEq::SUBSTRATE:
         tmpVector = &mSubstrates;
         break;
 
       case CChemEq::PRODUCT:
         tmpVector = &mProducts;
         break;
 
       case CChemEq::MODIFIER:
         tmpVector = &mModifiers;
         break;
 
       default:
         fatalError();
         break;
     }
 
   size_t ccc, i, imax = tmpVector->size();
   ccc = 0;
 
   for (i = 0; i < imax; ++i)
     ccc += (size_t) floor((*tmpVector)[i]->getMultiplicity());
 
   return ccc;
 }

const CCopasiVector< CChemEqElement > & CChemEq::getProducts ( ) const

Retrieves the vector of products and their multiplicity in the chemical reaction.

Returns: "vector < CChemEqElement * > &" products

Definition at line 63 of file CChemEq.cpp.

References mProducts.

64 {return mProducts;}

CChemEq::mProducts

CCopasiVector< CChemEqElement > mProducts

Definition: CChemEq.h:204

const bool & CChemEq::getReversibility ( ) const

Retrieve the reversibility of the equation

Returns: const bool & reversible

Definition at line 77 of file CChemEq.cpp.

References mReversible.

Referenced by SBMLImporter::doMapping(), is_mass_action(), SBMLImporter::isMassActionExpression(), CReaction::isReversible(), and CChemEqInterface::loadFromChemEq().

78 {return mReversible;}

CChemEq::mReversible

bool mReversible

Definition: CChemEq.h:190

const CCopasiVector< CChemEqElement > & CChemEq::getSubstrates ( ) const

Retrieves the vector of substrates and their multiplicity in the chemical reaction.

Returns: "vector < CChemEqElement * > &" substrates

Definition at line 60 of file CChemEq.cpp.

References mSubstrates.

61 {return mSubstrates;}

CChemEq::mSubstrates

CCopasiVector< CChemEqElement > mSubstrates

Definition: CChemEq.h:197

bool CChemEq::setMultiplicity	(	const CMetab *	pMetab,
		C_FLOAT64	newMult,
		MetaboliteRole	role
	)

Sets the stoichiometry of the chemical element that corresponds to the given metabolite and role to the new value. The role has to be either CChemEqElement::SUBSTRATE or CChemEqElement::PRODUCT. If the role is invalid, the multiplicity is negative or zero or if the element for the metabolite and role can not be found in the chemical equation, false is returned and nothing is changed.

Sets the stoichiometry of the chemical element that corresponds to the given metabolite and role to the new value. The role has to be either CChemEqElement::SUBSTRATE or CChemEqElement::PRODUCT. If the role is invalid, the multiplicity if negative or if the element for the metabolite and role can not be found in the chemical equation, false is returned and nothing is changed.

Definition at line 268 of file CChemEq.cpp.

References addElement(), CCopasiVector< T >::begin(), C_FLOAT64, CCopasiVector< T >::end(), CModelEntity::getKey(), mBalances, mProducts, mSubstrates, PRODUCT, CChemEqElement::setMultiplicity(), and SUBSTRATE.

 {
   bool result = true;
 
   // check if the multiplicity and the role are valid
   if (pMetab == NULL || newMult <= 0 || !(role == CChemEq::SUBSTRATE || role == CChemEq::PRODUCT))
     {
       result = false;
     }
   else
     {
       // find the corresponding chemical element
       std::string key = pMetab->getKey();
       CCopasiVector<CChemEqElement>::iterator it, endit;
 
       if (role == CChemEq::SUBSTRATE)
         {
           it = this->mSubstrates.begin();
           endit = this->mSubstrates.end();
         }
       else
         {
           it = this->mProducts.begin();
           endit = this->mProducts.end();
         }
 
       while (it != endit)
         {
           if ((*it)->getMetaboliteKey() == key)
             {
               break;
             }
 
           ++it;
         }
 
       if (it == endit)
         {
           result = false;
         }
       else
         {
           // set the new multiplicity and update the balances
           C_FLOAT64 diff = newMult - (*it)->getMultiplicity();
 
           // we only make changes if there actually is a difference
           if (fabs(diff) > 1e-9)
             {
               // we have to add the difference between the new and the old
               // multiplicity to the balances
               (*it)->setMultiplicity(newMult);
               // copy the element
               CChemEqElement tmp(**it);
               // set the difference of the multiplicities
               // as the multiplicity of the copy
               tmp.setMultiplicity(diff);
               // update the balances
               this->addElement(this->mBalances, tmp, role);
             }
         }
     }
 
   return result;
 }

void CChemEq::setReversibility ( const bool & reversible )

Set the reversibility of the of the equation

Parameters

const bool & const bool & reversible

Definition at line 72 of file CChemEq.cpp.

References mReversible.

Referenced by CReaction::load(), CReaction::setReversible(), and CChemEqInterface::writeToChemEq().

 {
   mReversible = reversible;
 }

Friends And Related Function Documentation

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

friend

Friend declaration for ostream operator

Parameters

std::ostream	& os
const	CChemEq & d

Returns: std::ostream & os

Definition at line 242 of file CChemEq.cpp.

 {
   os << "CChemEq:" << std::endl;
   //os << "   mChemicalEquation:          " << d.getChemicalEquation() << std::endl;
   //os << "   mChemicalEquationConverted: " << d.getChemicalEquationConverted() << std::endl;
 
   os << "   mSubstrates:" << std::endl;
   os << d.mSubstrates;
   os << "   mProducts:" << std::endl;
   os << d.mProducts;
   os << "   mBalances:" << std::endl;
   os << d.mBalances;
 
   os << "----CChemEq" << std::endl;
   return os;
 }