CModel Class Reference

#include <CModel.h>

Inheritance diagram for CModel:

Collaboration diagram for CModel:

Public Types
enum	AreaUnit {   dimensionlessArea = 0, m2, dm2, cm2,   mm2, microm2, nm2, pm2,   fm2 }
enum	DependencyType { initial = 0, transient, physical }
enum	LengthUnit {   dimensionlessLength = 0, m, dm, cm,   mm, microm, nm, pm,   fm }
enum	ModelType { deterministic = 0, stochastic }
enum	QuantityUnit {   dimensionlessQuantity = 0, Mol, mMol, microMol,   nMol, pMol, fMol, number,   OldXML }
enum	TimeUnit {   dimensionlessTime = 0, d, h, min,   s, ms, micros, ns,   ps, fs, OldMinute }
enum	VolumeUnit {   dimensionlessVolume = 0, m3, l, ml,   microl, nl, pl, fl }
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

Public Member Functions
bool	appendDependentModelObjects (const std::set< const CCopasiObject * > &candidates, std::set< const CCopasiObject * > &dependentReactions, std::set< const CCopasiObject * > &dependentMetabolites, std::set< const CCopasiObject * > &dependentCompartments, std::set< const CCopasiObject * > &dependentModelValues, std::set< const CCopasiObject * > &dependentEvents) const
bool	appendDependentReactions (std::set< const CCopasiObject * > candidates, std::set< const CCopasiObject * > &dependents) const
void	applyActiveParameterSet ()
void	applyInitialValues ()
bool	buildDependencyGraphs ()
std::vector< Refresh * >	buildInitialRefreshSequence (std::set< const CCopasiObject * > &changedObjects)
void	buildLinkZero ()
void	buildMoieties ()
void	buildRedStoi ()
void	buildStoi ()
void	calculateDerivatives (C_FLOAT64 *derivatives)
void	calculateDerivativesX (C_FLOAT64 *derivativesX)
C_FLOAT64	calculateDivergence () const
void	calculateElasticityMatrix (const C_FLOAT64 &factor, const C_FLOAT64 &resolution)
void	calculateJacobian (CMatrix< C_FLOAT64 > &jacobian, const C_FLOAT64 &derivationFactor, const C_FLOAT64 &resolution)
void	calculateJacobianX (CMatrix< C_FLOAT64 > &jacobianX, const C_FLOAT64 &derivationFactor, const C_FLOAT64 &resolution)
void	calculateRootDerivatives (CVector< C_FLOAT64 > &rootDerivatives)
	CModel (CCopasiContainer *pParent)
bool	compileIfNecessary (CProcessReport *pProcessReport)
bool	convert2NonReversible ()
CCompartment *	createCompartment (const std::string &name, const C_FLOAT64 &volume=1.0)
CEvent *	createEvent (const std::string &name)
CMetab *	createMetabolite (const std::string &name, const std::string &compartment, const C_FLOAT64 &iconc=1.0, const CModelEntity::Status &status=CModelEntity::REACTIONS)
CModelValue *	createModelValue (const std::string &name, const C_FLOAT64 &value=0.0)
CReaction *	createReaction (const std::string &name)
void	evaluateRoots (CVectorCore< C_FLOAT64 > &rootValues, const bool &ignoreDiscrete)
size_t	findMetabByName (const std::string &Target) const
size_t	findMoiety (const std::string &Target) const
bool	forceCompile (CProcessReport *pProcessReport)
CModel::AreaUnit	getAreaUnitEnum () const
std::string	getAreaUnitName () const
std::string	getAreaUnitsDisplayString () const
const C_FLOAT64 &	getAvogadro () const
virtual std::string	getChildObjectUnits (const CCopasiObject *pObject) const
CCopasiVectorNS< CCompartment > &	getCompartments ()
const CCopasiVectorNS < CCompartment > &	getCompartments () const
std::string	getConcentrationRateUnitsDisplayString () const
std::string	getConcentrationUnitsDisplayString () const
CCopasiObject *	getCorrespondingTransientObject (const CCopasiObject *pObject) const
CCopasiVectorN< CEvent > &	getEvents ()
const CCopasiVectorN< CEvent > &	getEvents () const
std::string	getFrequencyUnitsDisplayString () const
const CState &	getInitialState () const
const C_FLOAT64 &	getInitialTime () const
bool	getInitialUpdateSequence (const CMath::SimulationContextFlag &context, const CCopasiObject::DataObjectSet &changedObjects, const CCopasiObject::DataObjectSet &requestedObjects, CCopasiObject::DataUpdateSequence &updateSequence) const
const std::string &	getKey () const
const CLinkMatrixView &	getL () const
const CLinkMatrix &	getL0 () const
CModel::LengthUnit	getLengthUnitEnum () const
std::string	getLengthUnitName () const
std::string	getLengthUnitsDisplayString () const
const std::vector< Refresh * > &	getListOfConstantRefreshes () const
const std::vector< Refresh * > &	getListOfInitialRefreshes () const
const std::vector< Refresh * > &	getListOfNonSimulatedRefreshes () const
const std::vector< Refresh * > &	getListOfSimulatedRefreshes () const
const CMathModel *	getMathModel () const
CMathModel *	getMathModel ()
const CCopasiVector< CMetab > &	getMetabolites () const
CCopasiVector< CMetab > &	getMetabolites ()
const CCopasiVector< CMetab > &	getMetabolitesX () const
CCopasiVector< CMetab > &	getMetabolitesX ()
const CModelParameterSet &	getModelParameterSet () const
CModelParameterSet &	getModelParameterSet ()
const CCopasiVectorN < CModelParameterSet > &	getModelParameterSets () const
CCopasiVectorN < CModelParameterSet > &	getModelParameterSets ()
const ModelType &	getModelType () const
const CCopasiVectorN < CModelValue > &	getModelValues () const
CCopasiVectorN< CModelValue > &	getModelValues ()
const CCopasiVector< CMoiety > &	getMoieties () const
size_t	getNumAssignmentMetabs () const
const C_FLOAT64 &	getNumber2QuantityFactor () const
size_t	getNumDependentReactionMetabs () const
size_t	getNumIndependentReactionMetabs () const
size_t	getNumMetabs () const
size_t	getNumModelValues () const
size_t	getNumODEMetabs () const
size_t	getNumRoots () const
size_t	getNumVariableMetabs () const
const CVector< C_FLOAT64 > &	getParticleFlux () const
const C_FLOAT64 &	getProcessQueueExecutionTime () const
const C_FLOAT64 &	getQuantity2NumberFactor () const
std::string	getQuantityRateUnitsDisplayString () const
CModel::QuantityUnit	getQuantityUnitEnum () const
std::string	getQuantityUnitName () const
std::string	getQuantityUnitOldXMLName () const
std::string	getQuantityUnitsDisplayString () const
CCopasiVectorNS< CReaction > &	getReactions ()
const CCopasiVectorNS < CReaction > &	getReactions () const
const CMatrix< C_FLOAT64 > &	getRedStoi () const
const CVector < CMathTrigger::CRootFinder * > &	getRootFinders () const
const CState &	getState () const
const CStateTemplate &	getStateTemplate () const
CStateTemplate &	getStateTemplate ()
const CMatrix< C_FLOAT64 > &	getStoi () const
const C_FLOAT64 &	getTime () const
CModel::TimeUnit	getTimeUnitEnum () const
std::string	getTimeUnitName () const
std::string	getTimeUnitsDisplayString () const
size_t	getTotSteps () const
bool	getTransientUpdateSequence (const CMath::SimulationContextFlag &context, const CCopasiObject::DataObjectSet &changedObjects, const CCopasiObject::DataObjectSet &requestedObjects, CCopasiObject::DataUpdateSequence &updateSequence) const
std::vector< const CEvaluationTree * >	getTreesWithDiscontinuities () const
const std::set< const CCopasiObject * > &	getUptoDateObjects () const
std::string	getVolumeRateUnitsDisplayString () const
CModel::VolumeUnit	getVolumeUnitEnum () const
std::string	getVolumeUnitName () const
std::string	getVolumeUnitsDisplayString () const
bool	hasReversibleReaction () const
CVector< C_FLOAT64 >	initializeAtolVector (const C_FLOAT64 &baseTolerance, const bool &reducedModel) const
void	initializeMetabolites ()
const bool &	isAutonomous () const
bool	isStateVariable (const CCopasiObject *pObject) const
C_INT32	load (CReadConfig &configBuffer)
std::string	printParameterOverview ()
bool	processQueue (const C_FLOAT64 &time, const bool &equality, CProcessQueue::resolveSimultaneousAssignments pResolveSimultaneousAssignments)
void	processRoots (const C_FLOAT64 &time, const bool &equality, const bool &correct, const CVector< C_INT > &roots)
void	refreshActiveParameterSet ()
bool	removeCompartment (const size_t index, const bool &recursive=true)
bool	removeCompartment (const std::string &key, const bool &recursive=true)
bool	removeCompartment (const CCompartment *pCompartment, const bool &recursive=true)
void	removeDependentModelObjects (const std::set< const CCopasiObject * > &deletedObjects)
bool	removeEvent (const size_t index, const bool &recursive=true)
bool	removeEvent (const std::string &key, const bool &recursive=true)
bool	removeEvent (const CEvent *pEvent, const bool &recursive=true)
bool	removeLocalReactionParameter (const std::string &key, const bool &recursive=true)
bool	removeMetabolite (const std::string &key, const bool &recursive=true)
bool	removeMetabolite (const size_t index, const bool &recursive=true)
bool	removeMetabolite (const CMetab *pMetabolite, const bool &recursive=true)
bool	removeModelValue (const CModelValue *pModelValue, const bool &recursive=true)
bool	removeModelValue (const std::string &key, const bool &recursive=true)
bool	removeModelValue (const size_t index, const bool &recursive=true)
bool	removeReaction (const CReaction *pReaction, const bool &recursive=true)
bool	removeReaction (const std::string &key, const bool &recursive=true)
bool	removeReaction (const size_t index, const bool &recursive=true)
bool	setAreaUnit (const std::string &name)
bool	setAreaUnit (const CModel::AreaUnit &unit)
void	setAvogadro (const C_FLOAT64 &avogadro)
void	setCompileFlag (bool flag=true)
void	setInitialState (const CState &state)
void	setInitialTime (const C_FLOAT64 &time)
bool	setLengthUnit (const std::string &name)
bool	setLengthUnit (const CModel::LengthUnit &unit)
void	setModelType (const ModelType &modelType)
bool	setQuantityUnit (const std::string &name)
bool	setQuantityUnit (const CModel::QuantityUnit &unit)
void	setState (const CState &state)
void	setTime (const C_FLOAT64 &time)
bool	setTimeUnit (const std::string &name)
bool	setTimeUnit (const CModel::TimeUnit &unit)
bool	setVolumeUnit (const std::string &name)
bool	setVolumeUnit (const CModel::VolumeUnit &unit)
std::string	suitableForStochasticSimulation () const
bool	updateInitialValues ()
void	updateInitialValues (std::set< const CCopasiObject * > &changedObjects)
void	updateInitialValues (const CCopasiObject *changedObject)
void	updateNonSimulatedValues (void)
void	updateSimulatedValues (const bool &updateMoieties)
	~CModel ()
Public Member Functions inherited from CModelEntity
virtual void	calculate ()
	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)
virtual std::set< const CCopasiObject * >	getDeletedObjects () const
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
const C_FLOAT64 &	getRate () const
CCopasiObject *	getRateReference () const
const std::string &	getSBMLId () const
const CModelEntity::Status &	getStatus () const
const C_FLOAT64 &	getValue () const
virtual const CCopasiObject *	getValueObject () const
virtual void *	getValuePointer () const
CCopasiObject *	getValueReference () const
bool	isFixed () const
const bool &	isUsed () const
virtual bool	mustBeDeleted (const DataObjectSet &deletedObjects) const
virtual void	refreshInitialValue ()
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)
virtual bool	setObjectParent (const CCopasiContainer *pParent)
void	setRate (const C_FLOAT64 &rate)
void	setSBMLId (const std::string &id)
virtual void	setStatus (const CModelEntity::Status &status)
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
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
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 Attributes
static const char *	AreaUnitNames []
static const char *	LengthUnitNames []
static const char *	ModelTypeNames []
static const char *	QuantityUnitNames []
static const char *	QuantityUnitOldXMLNames []
static const char *	TimeUnitNames []
static const char *	VolumeUnitNames []
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

Private Member Functions
bool	appendDependentCompartments (std::set< const CCopasiObject * > candidates, std::set< const CCopasiObject * > &dependents) const
bool	appendDependentEvents (std::set< const CCopasiObject * > candidates, std::set< const CCopasiObject * > &dependents) const
bool	appendDependentMetabolites (std::set< const CCopasiObject * > candidates, std::set< const CCopasiObject * > &dependents) const
bool	appendDependentModelValues (std::set< const CCopasiObject * > candidates, std::set< const CCopasiObject * > &dependents) const
bool	buildApplyInitialValuesSequence ()
bool	buildInitialSequence ()
bool	buildNonSimulatedSequence ()
bool	buildSimulatedSequence ()
bool	buildStateTemplate ()
bool	buildUserOrder ()
void	clearMoieties ()
	CModel (const CModel &src)
bool	compile ()
bool	compileEvents ()
void	determineIsAutonomous ()
bool	getUpdateSequence (CMathDependencyGraph &dependencyGraph, const CMath::SimulationContextFlag &context, const CCopasiObject::DataObjectSet &changedObjects, const CCopasiObject::DataObjectSet &requestedObjects, CCopasiObject::DataUpdateSequence &updateSequence) const
bool	handleUnusedMetabolites ()
void	initObjects ()
CModel &	operator= (const CModel &src)
void	updateMatrixAnnotations ()
void	updateMoietyValues ()

Private Attributes
std::string	mActiveParameterSetKey
std::vector< Refresh * >	mApplyInitialValuesRefreshes
AreaUnit	mAreaUnit
C_FLOAT64	mAvogadro
bool	mBuildInitialSequence
CCopasiVectorNS< CCompartment >	mCompartments
bool	mCompileIsNecessary
CState	mCurrentState
CMatrix< C_FLOAT64 >	mElasticities
CCopasiVectorN< CEvent >	mEvents
CMathDependencyGraph	mInitialDependencies
std::vector< Refresh * >	mInitialRefreshes
CState	mInitialState
bool	mIsAutonomous
CVector< size_t >	mJacobianPivot
CLinkMatrix	mL
LengthUnit	mLengthUnit
CLinkMatrixView	mLView
CCopasiVector< CMetab >	mMetabolites
CCopasiVector< CMetab >	mMetabolitesX
CCopasiVector< CMoiety >	mMoieties
std::vector< Refresh * >	mNonSimulatedRefreshes
C_FLOAT64	mNumber2QuantityFactor
size_t	mNumMetabolitesAssignment
size_t	mNumMetabolitesODE
size_t	mNumMetabolitesReaction
size_t	mNumMetabolitesReactionIndependent
size_t	mNumMetabolitesUnused
CModelParameterSet	mParameterSet
CCopasiVectorN < CModelParameterSet >	mParameterSets
CVector< C_FLOAT64 >	mParticleFluxes
CProcessReport *	mpCompileHandler
CMathDependencyGraph	mPhysicalDependencies
CArrayAnnotation *	mpLinkMatrixAnnotation
CMathModel *	mpMathModel
CArrayAnnotation *	mpRedStoiAnnotation
CArrayAnnotation *	mpStoiAnnotation
C_FLOAT64	mQuantity2NumberFactor
QuantityUnit	mQuantityUnit
CMatrix< C_FLOAT64 >	mRedStoi
bool	mReorderNeeded
std::vector< Refresh * >	mSimulatedRefreshes
std::set< const CCopasiObject * >	mSimulatedUpToDateObjects
CStateTemplate	mStateTemplate
CCopasiVectorNS< CReaction >	mSteps
CMatrix< C_FLOAT64 >	mStoi
CMatrix< C_FLOAT64 >	mStoiInternal
TimeUnit	mTimeUnit
CMathDependencyGraph	mTransientDependencies
ModelType	mType
CCopasiVectorN< CModelValue >	mValues
VolumeUnit	mVolumeUnit

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 Member Functions inherited from CAnnotation
static CAnnotation *	castObject (CCopasiObject *pObject)
static const CAnnotation *	castObject (const CCopasiObject *pObject)
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 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
Static Protected Attributes inherited from CCopasiObject
static CRenameHandler *	smpRenameHandler = NULL

Detailed Description

Definition at line 50 of file CModel.h.

Member Enumeration Documentation

enum CModel::AreaUnit

Enum of valid area units

Enumerator
dimensionlessArea
m2
dm2
cm2
mm2
microm2
nm2
pm2
fm2

Definition at line 66 of file CModel.h.

{dimensionlessArea = 0, m2, dm2, cm2, mm2, microm2, nm2, pm2, fm2};

enum CModel::DependencyType

Enumerator
initial
transient
physical

Definition at line 119 of file CModel.h.

{initial = 0, transient, physical};

enum CModel::LengthUnit

Enum of valid length units

Enumerator
dimensionlessLength
m
dm
cm
mm
microm
nm
pm
fm

Definition at line 76 of file CModel.h.

{dimensionlessLength = 0, m, dm, cm, mm, microm, nm, pm, fm};

enum CModel::ModelType

Enum of valid model types.

Enumerator
deterministic
stochastic

Definition at line 112 of file CModel.h.

{deterministic = 0, stochastic};

enum CModel::QuantityUnit

Enum of valid quantity units

Enumerator
dimensionlessQuantity
Mol
mMol
microMol
nMol
pMol
fMol
number
OldXML

Definition at line 96 of file CModel.h.

{dimensionlessQuantity = 0, Mol, mMol, microMol, nMol, pMol, fMol, number, OldXML};

enum CModel::TimeUnit

Enum of valid time units

Enumerator
dimensionlessTime
d
h
min
s
ms
micros
ns
ps
fs
OldMinute

Definition at line 86 of file CModel.h.

{dimensionlessTime = 0, d, h, min, s, ms, micros, ns, ps, fs, OldMinute};

enum CModel::VolumeUnit

Enum of valid volume units

Enumerator
dimensionlessVolume
m3
l
ml
microl
nl
pl
fl

Definition at line 56 of file CModel.h.

{dimensionlessVolume = 0, m3, l, ml, microl, nl, pl, fl};

Constructor & Destructor Documentation

CModel::CModel ( const CModel &  src )

private

Copy constructor

Parameters

const CModel &

src

CModel::CModel

(

CCopasiContainer *

pParent

)

constructor

Definition at line 90 of file CModel.cpp.

References compile(), CONSTRUCTOR_TRACE, forceCompile(), initializeMetabolites(), initObjects(), CModelEntity::mpIValue, CModelEntity::mpValue, mQuantityUnit, mSteps, mVolumeUnit, setQuantityUnit(), CModelEntity::setStatus(), CModelEntity::setUsed(), setVolumeUnit(), CCopasiVector< T >::size(), and CModelEntity::TIME.

                                       :
  CModelEntity("New Model", pParent, "Model"),
  mInitialState(),
  mCurrentState(),
  mStateTemplate(*this, this->mInitialState, this->mCurrentState),
  mSimulatedUpToDateObjects(),
  mInitialDependencies(),
  mTransientDependencies(),
  mPhysicalDependencies(),
#ifdef USE_MATH_CONTAINER
  mpMathContainer(NULL),
#endif // USE_MATH_CONTAINER
  mVolumeUnit(ml),
  mAreaUnit(m2),
  mLengthUnit(m),
  mTimeUnit(s),
  mQuantityUnit(mMol),
  mType(deterministic),
  mCompartments("Compartments", this),
  mMetabolites("Metabolites", this),
  mMetabolitesX("Reduced Model Metabolites", this),
  mSteps("Reactions", this),
  mEvents("Events", this),
  mParticleFluxes(),
  mValues("Values", this),
  mParameterSet("Initial State", this),
  mParameterSets("ParameterSets", this),
  mActiveParameterSetKey(""),
  mMoieties("Moieties", this),
  mStoiInternal(),
  mpStoiAnnotation(NULL),
  mStoi(),
  mRedStoi(),
  mpRedStoiAnnotation(NULL),
  mNumMetabolitesUnused(0),
  mNumMetabolitesODE(0),
  mNumMetabolitesReaction(0),
  mNumMetabolitesAssignment(0),
  mNumMetabolitesReactionIndependent(0),
  mL(),
  mpLinkMatrixAnnotation(NULL),
  mLView(mL),
  mAvogadro(6.02214179e23),
  mQuantity2NumberFactor(1.0),
  mNumber2QuantityFactor(1.0),
  mpCompileHandler(NULL),
  mInitialRefreshes(),
  mSimulatedRefreshes(),
  mApplyInitialValuesRefreshes(),
  mNonSimulatedRefreshes(),
  mReorderNeeded(false),
  mIsAutonomous(true),
  mBuildInitialSequence(true),
  mpMathModel(NULL)
{
  initObjects();

  setStatus(TIME);
  setUsed(true);

  *mpIValue = 0.0;
  *mpValue = std::numeric_limits<C_FLOAT64>::quiet_NaN();

  size_t i, imax = mSteps.size();

  for (i = 0; i < imax; i++)
    mSteps[i]->compile(/*mCompartments*/);

  initializeMetabolites();

  forceCompile(NULL);

  /* This following 2 lines added by Liang Xu
  Because of the failure to initialize the parameter when creating a new models
  */
  setQuantityUnit(mQuantityUnit); // set the factors
  setVolumeUnit(mVolumeUnit); // set the factors

  CONSTRUCTOR_TRACE;
}

CModel::~CModel

(

)

Destructor

Definition at line 227 of file CModel.cpp.

References DESTRUCTOR_TRACE, CCopasiRootContainer::getKeyFactory(), CAnnotation::mKey, CModelEntity::mpIValue, mpLinkMatrixAnnotation, mpRedStoiAnnotation, mpStoiAnnotation, CModelEntity::mpValue, pdelete, and CKeyFactory::remove().

{
  mpIValue = NULL;
  mpValue = NULL;

  pdelete(mpStoiAnnotation);
  pdelete(mpRedStoiAnnotation);
  pdelete(mpLinkMatrixAnnotation);

#ifdef USE_MATH_CONTAINER
  pdelete(mpMathContainer);
#endif // USE_MATH_CONTAINER

  CCopasiRootContainer::getKeyFactory()->remove(mKey);

  DESTRUCTOR_TRACE;
}

Member Function Documentation

bool CModel::appendDependentCompartments ( std::set< const CCopasiObject * >  candidates, std::set< const CCopasiObject * > &  dependents  ) const

private

Appends pointers to compartments which are dependent on the candidates to the list.

Parameters

std::set<	const CCopasiObject * > candidates
std::set<	const CCopasiObject * > & dependents

Returns

bool objectsAppended

Definition at line 2538 of file CModel.cpp.

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

Referenced by appendDependentModelObjects(), convert2NonReversible(), and determineIsAutonomous().

{
  const_cast< CModel * >(this)->compileIfNecessary(NULL);

  size_t Size = dependents.size();

  CCopasiVectorN< CCompartment >::const_iterator it = mCompartments.begin();
  CCopasiVectorN< CCompartment >::const_iterator end = mCompartments.end();

  std::set< const CCopasiObject * >::const_iterator itSet;
  std::set< const CCopasiObject * >::const_iterator endSet;

  for (; it != end; ++it)
    {
      // Check whether the compartment is already in the list of deleted objects
      if (candidates.find(*it) == candidates.end())
        {
          if ((*it)->mustBeDeleted(candidates))
            {
              dependents.insert(*it);
            }
        }
    }

  return Size < dependents.size();
}

bool CModel::appendDependentEvents ( std::set< const CCopasiObject * >  candidates, std::set< const CCopasiObject * > &  dependents  ) const

private

Appends a pointers to events which are dependent on the candidates to the list.

Parameters

std::set<	const CCopasiObject * > candidates
std::set<	const CCopasiObject * > & dependents

Returns

bool objectsAppended

Definition at line 2593 of file CModel.cpp.

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

Referenced by appendDependentModelObjects(), convert2NonReversible(), and determineIsAutonomous().

{
  const_cast< CModel * >(this)->compileIfNecessary(NULL);

  size_t Size = dependents.size();

  CCopasiVectorN< CEvent >::const_iterator it = mEvents.begin();
  CCopasiVectorN< CEvent >::const_iterator end = mEvents.end();

  std::set< const CCopasiObject * >::const_iterator itSet;
  std::set< const CCopasiObject * >::const_iterator endSet;

  for (; it != end; ++it)

    // Check whether the model value is already in the list of deleted objects
    if (candidates.find(*it) == candidates.end())
      {
        if ((*it)->mustBeDeleted(candidates))
          {
            dependents.insert(*it);
          }
      }

  return Size < dependents.size();
}

bool CModel::appendDependentMetabolites ( std::set< const CCopasiObject * >  candidates, std::set< const CCopasiObject * > &  dependents  ) const

private

Appends pointers to metabolites which are dependent on the candidates to the list.

Parameters

std::set<	const CCopasiObject * > candidates
std::set<	const CCopasiObject * > & dependents

Returns

bool objectsAppended

Definition at line 2501 of file CModel.cpp.

References CCopasiVector< T >::begin(), CCopasiVector< CType >::begin(), compileIfNecessary(), CCopasiVector< CType >::end(), CCopasiVector< T >::end(), and mCompartments.

Referenced by appendDependentModelObjects(), convert2NonReversible(), and determineIsAutonomous().

{
  const_cast< CModel * >(this)->compileIfNecessary(NULL);

  size_t Size = dependents.size();

  CCopasiVectorN< CCompartment >::const_iterator itComp = mCompartments.begin();
  CCopasiVectorN< CCompartment >::const_iterator endComp = mCompartments.end();

  CCopasiVectorN< CMetab >::const_iterator it;
  CCopasiVectorN< CMetab >::const_iterator end;

  CCopasiObject::DataObjectSet::const_iterator itSet;
  CCopasiObject::DataObjectSet::const_iterator endSet;

  for (; itComp != endComp; ++itComp)
    {
      it = (*itComp)->getMetabolites().begin();
      end = (*itComp)->getMetabolites().end();

      for (; it != end; ++it)
        {
          // Check whether the species is already in the list of deleted objects
          if (candidates.find(*it) == candidates.end())
            {
              if ((*it)->mustBeDeleted(candidates))
                {
                  dependents.insert(*it);
                }
            }
        }
    }

  return Size < dependents.size();
}

bool CModel::appendDependentModelObjects	(	const std::set< const CCopasiObject * > &	candidates,
		std::set< const CCopasiObject * > &	dependentReactions,
		std::set< const CCopasiObject * > &	dependentMetabolites,
		std::set< const CCopasiObject * > &	dependentCompartments,
		std::set< const CCopasiObject * > &	dependentModelValues,
		std::set< const CCopasiObject * > &	dependentEvents
	)		const

Appends pointers to all model objects, which are dependent on the candidates to appropriate lists.

Parameters

const	std::set< const CCopasiObject * > & candidates
std::set<	const CCopasiObject * > & dependentReactions
std::set<	const CCopasiObject * > & dependentMetabolites
std::set<	const CCopasiObject * > & dependentCompartments
std::set<	const CCopasiObject * > & dependentModelValues
std::set<	const CCopasiObject * > & dependentEvents

Returns

bool objectsAppended

Definition at line 2364 of file CModel.cpp.

References appendDependentCompartments(), appendDependentEvents(), appendDependentMetabolites(), appendDependentModelValues(), appendDependentReactions(), CCompartment::getDeletedObjects(), CReaction::getDeletedObjects(), CModelEntity::getDeletedObjects(), and CMetab::getDeletedObjects().

Referenced by CQMessageBox::confirmDelete(), CModelExpansion::SetOfModelElements::fillDependencies(), CFunctionDB::getUsedFunctions(), FunctionWidget1::leave(), and removeDependentModelObjects().

{
  // We need a local copy since we recursively add deleted objects.
  std::set< const CCopasiObject * > DeletedObjects = deletedObjects;

  bool ObjectsAppended = false;
  bool DeleteObjects = DeletedObjects.size() > 0;

  // This is this implemented recursively. Since deleting a container may result
  // in the deletion of objects not dependent on the original set of deleted objects.

  while (DeleteObjects)
    {
      DeleteObjects = false;

      DeleteObjects |= appendDependentReactions(DeletedObjects, dependentReactions);

      if (dependentReactions.size() > 0)
        {
          std::set< const CCopasiObject * >::const_iterator it, itEnd = dependentReactions.end();

          for (it = dependentReactions.begin(); it != itEnd; ++it)
            if (DeletedObjects.find(*it) == DeletedObjects.end())
              {
                CCopasiObject::DataObjectSet AdditionalObjects =
                  static_cast< const CReaction * >(*it)->getDeletedObjects();

                std::set< const CCopasiObject * >::const_iterator itDeleted = AdditionalObjects.begin();
                std::set< const CCopasiObject * >::const_iterator endDeleted = AdditionalObjects.end();

                for (; itDeleted != endDeleted; ++itDeleted)
                  DeletedObjects.insert(*itDeleted);
              }
        }

      DeleteObjects |= appendDependentMetabolites(DeletedObjects, dependentMetabolites);

      if (dependentMetabolites.size() > 0)
        {
          std::set< const CCopasiObject * >::const_iterator it, itEnd = dependentMetabolites.end();

          for (it = dependentMetabolites.begin(); it != itEnd; ++it)
            if (DeletedObjects.find(*it) == DeletedObjects.end())
              {
                CCopasiObject::DataObjectSet AdditionalObjects =
                  static_cast< const CMetab * >(*it)->getDeletedObjects();

                std::set< const CCopasiObject * >::const_iterator itDeleted = AdditionalObjects.begin();
                std::set< const CCopasiObject * >::const_iterator endDeleted = AdditionalObjects.end();

                for (; itDeleted != endDeleted; ++itDeleted)
                  DeletedObjects.insert(*itDeleted);
              }
        }

      DeleteObjects |= appendDependentModelValues(DeletedObjects, dependentModelValues);

      if (dependentModelValues.size() > 0)
        {
          std::set< const CCopasiObject * >::const_iterator it, itEnd = dependentModelValues.end();

          for (it = dependentModelValues.begin(); it != itEnd; ++it)
            if (DeletedObjects.find(*it) == DeletedObjects.end())
              {
                CCopasiObject::DataObjectSet AdditionalObjects =
                  static_cast< const CModelValue * >(*it)->getDeletedObjects();

                std::set< const CCopasiObject * >::const_iterator itDeleted = AdditionalObjects.begin();
                std::set< const CCopasiObject * >::const_iterator endDeleted = AdditionalObjects.end();

                for (; itDeleted != endDeleted; ++itDeleted)
                  DeletedObjects.insert(*itDeleted);
              }
        }

      DeleteObjects |= appendDependentCompartments(DeletedObjects, dependentCompartments);

      if (dependentCompartments.size() > 0)
        {
          std::set< const CCopasiObject * >::const_iterator it, itEnd = dependentCompartments.end();

          for (it = dependentCompartments.begin(); it != itEnd; ++it)
            if (DeletedObjects.find(*it) == DeletedObjects.end())
              {
                CCopasiObject::DataObjectSet AdditionalObjects =
                  static_cast< const CCompartment * >(*it)->getDeletedObjects();

                std::set< const CCopasiObject * >::const_iterator itDeleted = AdditionalObjects.begin();
                std::set< const CCopasiObject * >::const_iterator endDeleted = AdditionalObjects.end();

                for (; itDeleted != endDeleted; ++itDeleted)
                  DeletedObjects.insert(*itDeleted);
              }
        }

      DeleteObjects |= appendDependentEvents(DeletedObjects, dependentEvents);

      ObjectsAppended |= DeleteObjects;
    }

  return ObjectsAppended;
}

bool CModel::appendDependentModelValues ( std::set< const CCopasiObject * >  candidates, std::set< const CCopasiObject * > &  dependents  ) const

private

Appends a pointers to model values which are dependent on the candidates to the list.

Parameters

std::set<	const CCopasiObject * > candidates
std::set<	const CCopasiObject * > & dependents

Returns

bool objectsAppended

Definition at line 2566 of file CModel.cpp.

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

Referenced by appendDependentModelObjects(), convert2NonReversible(), and determineIsAutonomous().

{
  const_cast< CModel * >(this)->compileIfNecessary(NULL);

  size_t Size = dependents.size();

  CCopasiVectorN< CModelValue >::const_iterator it = mValues.begin();
  CCopasiVectorN< CModelValue >::const_iterator end = mValues.end();

  std::set< const CCopasiObject * >::const_iterator itSet;
  std::set< const CCopasiObject * >::const_iterator endSet;

  for (; it != end; ++it)

    // Check whether the model value is already in the list of deleted objects
    if (candidates.find(*it) == candidates.end())
      {
        if ((*it)->mustBeDeleted(candidates))
          {
            dependents.insert(*it);
          }
      }

  return Size < dependents.size();
}

bool CModel::appendDependentReactions	(	std::set< const CCopasiObject * >	candidates,
		std::set< const CCopasiObject * > &	dependents
	)		const

Appends pointers to reactions which are dependent on the candidates to the list.

Parameters

std::set<	const CCopasiObject * > candidates
std::set<	const CCopasiObject * > & dependents

Returns

bool objectsAppended

Definition at line 2472 of file CModel.cpp.

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

Referenced by appendDependentModelObjects(), determineIsAutonomous(), CQSpeciesDetail::loadReactionTable(), and CQSpeciesDetail::slotSwitchToReaction().

{
  const_cast< CModel * >(this)->compileIfNecessary(NULL);

  size_t Size = dependents.size();

  CCopasiVectorN< CReaction >::const_iterator it = mSteps.begin();
  CCopasiVectorN< CReaction >::const_iterator end = mSteps.end();

  CCopasiObject::DataObjectSet::const_iterator itSet;
  CCopasiObject::DataObjectSet::const_iterator endSet;

  for (; it != end; ++it)
    if (candidates.find(*it) == candidates.end())
      {
        // Check whether the reaction is already in the list of deleted objects
        if (candidates.find(*it) == candidates.end())
          {
            if ((*it)->mustBeDeleted(candidates))
              {
                dependents.insert(*it);
              }
          }
      }

  return Size < dependents.size();
}

void CModel::applyActiveParameterSet

(

)

Update the model initial values from the active parameter set.

Definition at line 1082 of file CModel.cpp.

References CModelParameterSet::createFromModel(), CKeyFactory::get(), CModelParameterSet::getKey(), CCopasiRootContainer::getKeyFactory(), mActiveParameterSetKey, mParameterSet, and CModelParameterSet::updateModel().

{
  CModelParameterSet * pParameterSet =
    dynamic_cast< CModelParameterSet * >(CCopasiRootContainer::getKeyFactory()->get(mActiveParameterSetKey));

  if (pParameterSet != NULL)
    {
      pParameterSet->updateModel();
    }
  else
    {
      /*
      CModelParameterSet * pParameterSet = new CModelParameterSet(UTCTimeStamp());
      mParameterSets.add(pParameterSet, true);
      mActiveParameterSetKey = pParameterSet->getKey();
      pParameterSet->createFromModel();
      */
    }

  mParameterSet.createFromModel();
  mActiveParameterSetKey = mParameterSet.getKey();
}

void CModel::applyInitialValues

(

)

initialize all values of the model with their initial values

Definition at line 1236 of file CModel.cpp.

References CMathModel::applyInitialValues(), mApplyInitialValuesRefreshes, mInitialState, mpMathModel, setState(), and updateSimulatedValues().

Referenced by CSensTask::process(), CLNATask::process(), CScanTask::process(), CLyapTask::process(), CMCATask::process(), CSteadyStateTask::process(), CTSSATask::processStart(), CTrajectoryTask::processStart(), CCrossSectionTask::processStart(), and CopasiUI3Window::slotApplyInitialState().

{
  // Copy the initial state to the current state,
  setState(mInitialState);

  // Since the initial state is in itself consistent we should not need to
  // do anything further. However, for species of type ODE and ASSIGNMENT
  // the effective state variable is the concentration, i.e., we need to update
  // their concentration here.
  std::vector< Refresh * >::const_iterator itRefresh = mApplyInitialValuesRefreshes.begin();
  std::vector< Refresh * >::const_iterator endRefresh = mApplyInitialValuesRefreshes.end();

  while (itRefresh != endRefresh)
    (**itRefresh++)();

  // Update all dependent objects needed for simulation.
  updateSimulatedValues(false);

  mpMathModel->applyInitialValues();
}

bool CModel::buildApplyInitialValuesSequence ( )

private

Build the update sequence used by applyInitialValues to update values.

Returns

bool success

Definition at line 1627 of file CModel.cpp.

References CModelEntity::ASSIGNMENT, CStateTemplate::beginIndependent(), CCopasiObject::buildUpdateSequence(), CStateTemplate::endFixed(), mApplyInitialValuesRefreshes, mStateTemplate, and CModelEntity::ODE.

Referenced by buildSimulatedSequence(), and compile().

{
  bool success = true;

  mApplyInitialValuesRefreshes.clear();

  std::set< const CCopasiObject * > Objects;

  const CMetab * pMetab;

  CModelEntity ** ppEntity =  mStateTemplate.beginIndependent();
  CModelEntity ** ppEntityEnd = mStateTemplate.endFixed();

  for (; ppEntity != ppEntityEnd; ++ppEntity)
    {
      if ((*ppEntity)->getStatus() == ODE)
        {
          // TODO We need only to calculate rates which are constant since the other will
          // be updated by the simulation request.
          Objects.insert((*ppEntity)->getRateReference());
        }

      // Species of type assignment have a second pseudo state value the concentration,
      // which always can be directly calculated.
      if ((*ppEntity)->getStatus() == ASSIGNMENT &&
          (pMetab = dynamic_cast< const CMetab * >(*ppEntity)) != NULL)
        {
          mApplyInitialValuesRefreshes.push_back(pMetab->getConcentrationReference()->getApplyInitialValueRefresh());
        }
    }

  std::set< const CCopasiObject * > UpToDate;

  try
    {
      std::vector< Refresh * > RateRefreshes =
        CCopasiObject::buildUpdateSequence(Objects, UpToDate);

      mApplyInitialValuesRefreshes.insert(mApplyInitialValuesRefreshes.end(),
                                          RateRefreshes.begin(),
                                          RateRefreshes.end());
    }
  catch (...)
    {
      mApplyInitialValuesRefreshes.clear();
      success = false;
    }

  return success;
}

bool CModel::buildDependencyGraphs

(

)

Definition at line 547 of file CModel.cpp.

References CMathDependencyGraph::addObject(), CCopasiVector< T >::begin(), CStateTemplate::beginIndependent(), CMathDependencyGraph::clear(), CCopasiVector< T >::end(), CStateTemplate::endFixed(), CMathDependencyGraph::exportDOTFormat(), CMetab::getConcentrationReference(), CMetab::getInitialConcentrationReference(), mInitialDependencies, mMoieties, mPhysicalDependencies, mStateTemplate, mTransientDependencies, CModelEntity::ODE, and CModelEntity::REACTIONS.

Referenced by compile().

{
  mInitialDependencies.clear();
  mTransientDependencies.clear();
  mPhysicalDependencies.clear();

  // The initial values of the model entities
  // We need to add the time for non-autonomous models.
  CModelEntity **ppEntity = mStateTemplate.beginIndependent() - 1;
  CModelEntity **ppEntityEnd = mStateTemplate.endFixed();

  for (; ppEntity != ppEntityEnd; ++ppEntity)
    {
      CMetab * pSpecies = dynamic_cast< CMetab * >(*ppEntity);

      mInitialDependencies.addObject((*ppEntity)->getInitialValueReference());
      mTransientDependencies.addObject((*ppEntity)->getValueReference());

      if (pSpecies != NULL)
        {
          mInitialDependencies.addObject(pSpecies->getInitialConcentrationReference());
          mTransientDependencies.addObject(pSpecies->getConcentrationReference());
        }

      switch ((*ppEntity)->getStatus())
        {
          case CModelEntity::ODE:
          case CModelEntity::REACTIONS:
            mTransientDependencies.addObject((*ppEntity)->getRateReference());
            break;

          default:
            break;
        }
    }

  CCopasiVector< CMoiety >::iterator itMoiety = mMoieties.begin();
  CCopasiVector< CMoiety >::iterator endMoiety = mMoieties.end();

  for (; itMoiety != endMoiety; ++itMoiety)
    {
      mInitialDependencies.addObject((*itMoiety)->getInitialValueReference());
      mTransientDependencies.addObject((*itMoiety)->getTotalNumberReference());
      mTransientDependencies.addObject((*itMoiety)->getDependentNumberReference());
    }

#ifdef COPASI_DEBUG_TRACE
  std::ofstream File;

  File.open("InitialDependencies.dot");
  mInitialDependencies.exportDOTFormat(File, "InitialDependencies");
  File.close();

  File.open("SimulationDependencies.dot");
  mTransientDependencies.exportDOTFormat(File, "SimulationDependencies");
  File.close();
#endif //COPASI_DEBUG_TRACE
  return true;
}

std::vector< Refresh * > CModel::buildInitialRefreshSequence

(

std::set< const CCopasiObject * > &

changedObjects

)

Build the update sequence used to calculate all initial values depending on the changed objects. For metabolites the initial particle number is updated by default unless itself is in the list of changed objects. In that case the initial concentration is updated.

Parameters

std::set<

const CCopasiObject * > & changedObjects

Returns

std::vector< Refresh * > initialRefreshSequence

Definition at line 4164 of file CModel.cpp.

References CArrayAnnotation::appendElementReferences(), CModelEntity::ASSIGNMENT, CCopasiVector< T >::begin(), CStateTemplate::beginIndependent(), CCopasiVector< T >::end(), CStateTemplate::endFixed(), CCopasiMessage::EXCEPTION, CCopasiObject::getDirectDependencies(), CMetab::getInitialConcentrationReference(), CModelEntity::getInitialExpression(), CModelEntity::getInitialValueReference(), CCopasiParameterGroup::getParameter(), CModelEntity::getStatus(), CMetab::isInitialConcentrationChangeAllowed(), MCObject, mMoieties, mpLinkMatrixAnnotation, mpRedStoiAnnotation, mpStoiAnnotation, mStateTemplate, mSteps, CCopasiParameterGroup::size(), and sortObjectsByDependency().

Referenced by DataModelGUI::buildChangedObjects(), buildInitialSequence(), test000097::createModel(), CScanMethod::init(), CFitProblem::initialize(), CSensMethod::initialize(), COptProblem::initialize(), COptProblem::restoreModel(), SBMLImporter::setInitialValues(), CSlider::setSliderObject(), test000058::test_bug1025_10(), test000058::test_bug1025_6(), test000058::test_bug1025_7(), test000058::test_bug1025_8(), test000058::test_bug1025_9(), test000060::test_bug_1026(), test000059::test_unique_id_11(), test000059::test_unique_id_12(), test000059::test_unique_id_13(), test000059::test_unique_id_14(), test000059::test_unique_id_15(), test000059::test_unique_id_16(), and updateInitialValues().

{
  // First we remove all objects which are of type assignment from the changed objects
  // since this may not be changed as they are under control of the assignment.
  std::set< const CCopasiObject * >::iterator itSet;
  std::set< const CCopasiObject * >::iterator endSet;
  std::set< const CCopasiObject * > Objects;

  CModelEntity **ppEntity;
  CModelEntity **ppEntityEnd = mStateTemplate.endFixed();

  const CModelEntity * pEntity;
  CMetab * pMetab;

  // If the changed objects are empty we assume that all changeable objects have been changed
  if (changedObjects.size() == 0)
    {
      // The objects which are changed are all initial values of of all model entities including
      // fixed and unused once. Additionally, all kinetic parameters are possibly changed.
      // This is basically all the parameters in the parameter overview whose value is editable.

      // :TODO: Theoretically, it is possible that also task parameters influence the initial
      // state of a model but that is currently not handled.

      // The initial values of the model entities
      ppEntity = mStateTemplate.beginIndependent() - 1; // Offset for time

      for (; ppEntity != ppEntityEnd; ++ppEntity)
        {
          // If we have an initial expression we have no initial values
          if (((*ppEntity)->getInitialExpression() != "" ||
               (*ppEntity)->getStatus() == ASSIGNMENT) &&
              (*ppEntity)->getInitialValueReference()->getDirectDependencies().size() > 0)
            continue;

          // Metabolites have two initial values
          if ((pMetab = dynamic_cast< CMetab * >(*ppEntity)) != NULL)
            {
              // The concentration is assumed to be fix accept when this would lead to circular dependencies,
              // for the parent's compartment's initial volume.
              if (pMetab->isInitialConcentrationChangeAllowed())
                changedObjects.insert(pMetab->getInitialConcentrationReference());
              else
                changedObjects.insert(pMetab->getInitialValueReference());
            }
          else
            changedObjects.insert((*ppEntity)->getInitialValueReference());
        }

      // The reaction parameters
      CCopasiVector< CReaction >::const_iterator itReaction = mSteps.begin();
      CCopasiVector< CReaction >::const_iterator endReaction = mSteps.end();
      size_t i, imax;

      for (; itReaction != endReaction; ++itReaction)
        {
          const CCopasiParameterGroup & Group = (*itReaction)->getParameters();

          for (i = 0, imax = Group.size(); i < imax; i++)
            changedObjects.insert(Group.getParameter(i));
        }

      // Fix for Issue 1170: We need to add elements of the stoichiometry, reduced stoichiometry,
      // and link matrices.
      if (mpStoiAnnotation != NULL)
        mpStoiAnnotation->appendElementReferences(changedObjects);

      if (mpRedStoiAnnotation != NULL)
        mpRedStoiAnnotation->appendElementReferences(changedObjects);

      if (mpLinkMatrixAnnotation != NULL)
        mpLinkMatrixAnnotation->appendElementReferences(changedObjects);
    }
  else
    {
      // Remove all objects with initial assignments
      itSet = changedObjects.begin();
      endSet = changedObjects.end();

      for (; itSet != endSet; ++itSet)
        {
          if ((pEntity = dynamic_cast< const CModelEntity * >((*itSet)->getObjectParent())) != NULL &&
              (pEntity->getInitialExpression() != "" ||
               pEntity->getStatus() == ASSIGNMENT) &&
              pEntity->getInitialValueReference()->getDirectDependencies().size() > 0)
            Objects.insert(*itSet);
        }

      for (itSet = Objects.begin(), endSet = Objects.end(); itSet != endSet; ++itSet)
        changedObjects.erase(*itSet);
    }

  // We need to add all initial values which are dynamically calculated.
  // These are initial assignments and either a metabolite's initial particle number
  // or concentration.
  ppEntity = mStateTemplate.beginIndependent() - 1; // Offset for time
  Objects.clear();

  for (; ppEntity != ppEntityEnd; ++ppEntity)
    {
      if (((*ppEntity)->getInitialExpression() != "" ||
           (*ppEntity)->getStatus() == ASSIGNMENT))
        {
          Objects.insert((*ppEntity)->getInitialValueReference());
          continue;
        }

      // For metabolites we need to add the initial concentration or the initial
      // particle number..
      if ((pMetab = dynamic_cast< CMetab * >(*ppEntity)) != NULL)
        {
          if (changedObjects.count(pMetab->getInitialConcentrationReference()) != 0)
            {
              Objects.insert(pMetab->getInitialValueReference());
            }
          else
            {
              Objects.insert(pMetab->getInitialConcentrationReference());
            }
        }
    }

  // We need to add the total particle number of moieties.
  CCopasiVector< CMoiety >::iterator itMoiety = mMoieties.begin();
  CCopasiVector< CMoiety >::iterator endMoiety = mMoieties.end();

  for (; itMoiety != endMoiety; ++itMoiety)
    Objects.insert((*itMoiety)->getInitialValueReference());

  std::set< const CCopasiObject * > DependencySet;
  std::set< const CCopasiObject * > VerifiedSet;
  std::pair<std::set< const CCopasiObject * >::iterator, bool> InsertedObject;

  assert(Objects.count(NULL) == 0);

  // Check whether we have any circular dependencies
  for (itSet = Objects.begin(), endSet = Objects.end(); itSet != endSet; ++itSet)
    if ((*itSet)->hasCircularDependencies(DependencySet, VerifiedSet, changedObjects))
      CCopasiMessage(CCopasiMessage::EXCEPTION, MCObject + 1, (*itSet)->getCN().c_str());

  // Build the complete set of dependencies
  for (itSet = Objects.begin(); itSet != endSet; ++itSet)
    {
      // At least the object itself needs to be up to date.
      InsertedObject = DependencySet.insert(*itSet);

      // Add all its dependencies
      if (InsertedObject.second)
        (*itSet)->getAllDependencies(DependencySet, changedObjects);
    }

  // Remove all objects which do not depend on the changed objects, or do not have a
  // refresh method.
  Objects.clear();

  // We now check which objects we need to refresh
  for (itSet = DependencySet.begin(), endSet = DependencySet.end(); itSet != endSet; ++itSet)
    {
      // No refresh method
      if ((*itSet)->getRefresh() == NULL)
        Objects.insert(*itSet);
      // Is a changed object
      else if (changedObjects.count(*itSet) != 0)
        Objects.insert(*itSet);
      // Not dependent on the changed objects.
      else if (!(*itSet)->dependsOn(changedObjects, changedObjects))
        Objects.insert(*itSet);
    }

  for (itSet = Objects.begin(), endSet = Objects.end(); itSet != endSet; ++itSet)
    DependencySet.erase(*itSet);

  // Create a properly sorted list.
  std::list< const CCopasiObject * > SortedList =
    sortObjectsByDependency(DependencySet.begin(), DependencySet.end(), changedObjects);

  std::list< const CCopasiObject * >::iterator itList;
  std::list< const CCopasiObject * >::iterator endList;

  // Build the vector of pointers to refresh methods
  Refresh * pRefresh;

  std::vector< Refresh * > UpdateVector;
  std::vector< Refresh * >::const_iterator itUpdate;
  std::vector< Refresh * >::const_iterator endUpdate;

  itList = SortedList.begin();
  endList = SortedList.end();

  for (; itList != endList; ++itList)
    {
      pRefresh = (*itList)->getRefresh();
      itUpdate = UpdateVector.begin();
      endUpdate = UpdateVector.end();

      while (itUpdate != endUpdate && !(*itUpdate)->isEqual(pRefresh)) ++itUpdate;

      if (itUpdate == endUpdate)
        UpdateVector.push_back(pRefresh);
    }

  return UpdateVector;
}

bool CModel::buildInitialSequence ( )

private

Build the update sequence used by updateInitialValues to update all initial values.

Returns

bool success

Definition at line 1395 of file CModel.cpp.

References CArrayAnnotation::appendElementReferences(), CModelEntity::ASSIGNMENT, CCopasiVector< T >::begin(), CStateTemplate::beginIndependent(), buildInitialRefreshSequence(), CCopasiVector< T >::end(), CStateTemplate::endFixed(), CCopasiContainer::getObject(), CCopasiParameterGroup::getParameter(), CCopasiParameter::getValueReference(), mBuildInitialSequence, mInitialRefreshes, mpLinkMatrixAnnotation, mpRedStoiAnnotation, mpStoiAnnotation, mStateTemplate, mSteps, and CCopasiParameterGroup::size().

Referenced by buildSimulatedSequence(), compile(), and updateInitialValues().

{
  bool success = true;

  // The objects which are changed are all initial values of of all model entities including
  // fixed and unused once. Additionally, all kinetic parameters are possibly changed.
  // This is basically all the parameters in the parameter overview whose value is editable.

  // Issue 1170: We need to add elements of the stoichiometry, reduced stoichiometry,
  // and link matrix.

  CCopasiObject::DataObjectSet Objects;

  Objects.insert(static_cast< const CCopasiObject * >(getObject(CCopasiObjectName("Reference=Avogadro Constant"))));

  // The initial values of the model entities
  CModelEntity **ppEntity = mStateTemplate.beginIndependent() - 1; // Offset for time
  CModelEntity **ppEntityEnd = mStateTemplate.endFixed();

  for (; ppEntity != ppEntityEnd; ++ppEntity)
    {
      // Assignments have no initial values
      if ((*ppEntity)->getStatus() != ASSIGNMENT ||
          (*ppEntity)->getInitialValueReference()->getDirectDependencies().size() == 0)
        Objects.insert((*ppEntity)->getInitialValueReference());
    }

  // The reaction parameters
  CCopasiVector< CReaction >::const_iterator itReaction = mSteps.begin();
  CCopasiVector< CReaction >::const_iterator endReaction = mSteps.end();
  size_t i, imax;

  for (; itReaction != endReaction; ++itReaction)
    {
      const CCopasiParameterGroup & Group = (*itReaction)->getParameters();

      for (i = 0, imax = Group.size(); i < imax; i++)
        Objects.insert(Group.getParameter(i)->getValueReference());
    }

  // Fix for Issue 1170: We need to add elements of the stoichiometry, reduced stoichiometry,
  // and link matrices.
  if (mpStoiAnnotation != NULL)
    mpStoiAnnotation->appendElementReferences(Objects);

  if (mpRedStoiAnnotation != NULL)
    mpRedStoiAnnotation->appendElementReferences(Objects);

  if (mpLinkMatrixAnnotation != NULL)
    mpLinkMatrixAnnotation->appendElementReferences(Objects);

  try
    {
      mInitialRefreshes = buildInitialRefreshSequence(Objects);
    }
  catch (...)
    {
      mInitialRefreshes.clear();
      success = false;
    }

  mBuildInitialSequence = false;

  return success;
}

void CModel::buildLinkZero

(

)

Build the core of the link matrix L

Parameters

const

CMatrix< C_FLOAT64 > & LU

Definition at line 3946 of file CModel.cpp.

References CLinkMatrix::build(), CLinkMatrix::doRowPivot(), CLinkMatrix::getNumIndependent(), mL, mNumMetabolitesReactionIndependent, mStoi, and mStoiInternal.

Referenced by compile().

{
  mL.build(mStoiInternal);
  mNumMetabolitesReactionIndependent = mL.getNumIndependent();
  mStoi = mStoiInternal;
  mL.doRowPivot(mStoi);

  return;
}

void CModel::buildMoieties

(

)

Build the moieties based on the LU decomposition

Definition at line 905 of file CModel.cpp.

References CMoiety::add(), CCopasiVector< T >::add(), CMatrix< CType >::array(), CCopasiVector< T >::begin(), C_FLOAT64, CCopasiVector< T >::cleanup(), mL, mMetabolitesX, mMoieties, mNumMetabolitesODE, MNumMetabolitesReactionDependent, mNumMetabolitesReactionIndependent, and updateMoietyValues().

Referenced by compile().

{
  // Independent metabs
  CCopasiVector< CMetab >::iterator itIndependent = mMetabolitesX.begin() + mNumMetabolitesODE;
  CCopasiVector< CMetab >::iterator endIndependent = itIndependent + mNumMetabolitesReactionIndependent;

  // Dependent metabs
  CCopasiVector< CMetab >::iterator itDependent = endIndependent;
  CCopasiVector< CMetab >::iterator endDependent = itDependent + MNumMetabolitesReactionDependent;

  C_FLOAT64 * pFactor = mL.array();

  CMoiety *pMoiety;
  mMoieties.cleanup();

  for (; itDependent != endDependent; ++itDependent)
    {
      pMoiety = new CMoiety((*itDependent)->getObjectName());
      pMoiety->add(1.0, *itDependent);

      if (pFactor != NULL)
        {
          for (itIndependent = mMetabolitesX.begin() + mNumMetabolitesODE; itIndependent != endIndependent; ++itIndependent, ++pFactor)
            if (fabs(*pFactor) > std::numeric_limits< C_FLOAT64 >::epsilon())
              pMoiety->add(- *pFactor, *itIndependent);
        }

      mMoieties.add(pMoiety, true);
    }

  updateMoietyValues();
  return;
}

bool CModel::buildNonSimulatedSequence ( )

private

Build the update sequence used by updateNonSimulatedValues.

Returns

bool success

Definition at line 1678 of file CModel.cpp.

References CCopasiVector< T >::begin(), CCopasiObject::buildUpdateSequence(), CCopasiVector< T >::end(), mCompartments, mMetabolites, mNonSimulatedRefreshes, mSimulatedUpToDateObjects, mSteps, mValues, CModelEntity::ODE, and CModelEntity::REACTIONS.

Referenced by compile().

{
  bool success = true;

  CCopasiObject::DataObjectSet Objects;

  // Compartments
  CCopasiVector< CCompartment >::iterator itComp = mCompartments.begin();
  CCopasiVector< CCompartment >::iterator endComp = mCompartments.end();

  for (; itComp != endComp; ++itComp)
    {
      Objects.insert((*itComp)->getValueReference());

      switch ((*itComp)->getStatus())
        {
          case ODE:
            Objects.insert((*itComp)->getRateReference());
            break;

          default:
            break;
        }
    }

  // Metabolites
  CCopasiVector< CMetab >::iterator itMetab = mMetabolites.begin();
  CCopasiVector< CMetab >::iterator endMetab = mMetabolites.end();

  for (; itMetab != endMetab; ++itMetab)
    {
      Objects.insert((*itMetab)->getConcentrationReference());
      Objects.insert((*itMetab)->getValueReference());

      switch ((*itMetab)->getStatus())
        {
          case REACTIONS:
          case ODE:
            Objects.insert(static_cast< const CCopasiObject *>((*itMetab)->getObject(CCopasiObjectName("Reference=TransitionTime"))));
            Objects.insert((*itMetab)->getConcentrationRateReference());
            Objects.insert((*itMetab)->getRateReference());
            break;

          default:
            break;
        }
    }

  // Reactions
  CCopasiVector< CReaction >::iterator itStep = mSteps.begin();
  CCopasiVector< CReaction >::iterator endStep = mSteps.end();

  for (; itStep != endStep; ++itStep)
    {
      Objects.insert(static_cast< const CCopasiObject * >((*itStep)->getObject(CCopasiObjectName("Reference=Flux"))));
      Objects.insert((*itStep)->getParticleFluxReference());
    }

  // Model Values
  CCopasiVector< CModelValue >::iterator itValue = mValues.begin();
  CCopasiVector< CModelValue >::iterator endValue = mValues.end();

  for (; itValue != endValue; ++itValue)
    {
      Objects.insert((*itValue)->getValueReference());

      switch ((*itValue)->getStatus())
        {
          case ODE:
            Objects.insert((*itValue)->getRateReference());
            break;

          default:
            break;
        }
    }

  try
    {
      mNonSimulatedRefreshes = CCopasiObject::buildUpdateSequence(Objects, mSimulatedUpToDateObjects);
    }
  catch (...)
    {
      mNonSimulatedRefreshes.clear();
      success = false;
    }

  return success;
}

void CModel::buildRedStoi

(

)

Build the core of the link matrix L

Parameters

const

CMatrix< C_FLOAT64 > & LU Build the Reduced Stoichiometry Matrix from the LU decomposition

Definition at line 829 of file CModel.cpp.

References CLinkMatrix::applyRowPivot(), CVectorCore< CType >::array(), CCopasiVector< T >::begin(), mL, mMetabolitesX, mNumMetabolitesODE, mNumMetabolitesReaction, mNumMetabolitesReactionIndependent, mRedStoi, mStoi, CMatrix< CType >::numCols(), and CMatrix< CType >::resize().

Referenced by compile().

{
  mRedStoi = mStoi;
  mRedStoi.resize(mNumMetabolitesReactionIndependent, mRedStoi.numCols(), true);

  // The first metabolites are determined by ODEs we therefore cannot simply
  // apply the pivot.

  // Create a temporary copy of metabolites determined by reactions.
  CVector< CMetab * > ReactionMetabolites(mNumMetabolitesReaction);
  CMetab ** ppMetab = ReactionMetabolites.array();
  CMetab ** ppMetabEnd = ppMetab + mNumMetabolitesReaction;
  CCopasiVector< CMetab >::iterator itMetabX = mMetabolitesX.begin() + mNumMetabolitesODE;

  for (; ppMetab != ppMetabEnd; ++ppMetab, ++itMetabX)
    {
      *ppMetab = *itMetabX;
    }

  // Apply the pivot on the temporary copy
  mL.applyRowPivot(ReactionMetabolites);

  // Map the result on the actual metabolites
  ppMetab = ReactionMetabolites.array();
  itMetabX = mMetabolitesX.begin() + mNumMetabolitesODE;

  for (; ppMetab != ppMetabEnd; ++ppMetab, ++itMetabX)
    {
      *itMetabX = *ppMetab;
    }

  return;
}

bool CModel::buildSimulatedSequence ( )

private

Build the update sequence used by updateSimulatedValues.

Returns

bool success

Definition at line 1483 of file CModel.cpp.

References CModelEntity::ASSIGNMENT, CCopasiVector< T >::begin(), CStateTemplate::beginDependent(), CStateTemplate::beginIndependent(), buildApplyInitialValuesSequence(), buildInitialSequence(), CCopasiObject::buildUpdateSequence(), CModelEntity::compile(), CCopasiObject::dependsOn(), CCopasiVector< T >::end(), CStateTemplate::endDependent(), CStateTemplate::endFixed(), CStateTemplate::endIndependent(), CMetab::getConcentrationReference(), MNumMetabolitesReactionDependent, mNumMetabolitesReactionIndependent, mReorderNeeded, mSimulatedRefreshes, mSimulatedUpToDateObjects, mStateTemplate, mSteps, CStateTemplate::reorder(), and CStateTemplate::size().

Referenced by compile().

{
  bool success = true;

  // We need to add each used model entity to the objects which need to be updated.
  mSimulatedUpToDateObjects.clear();

  // For CModelValues and CCompartment ODEs we need to add the Rate
  // For CMetab ODEs we need to add the Particle Rate
  CModelEntity **ppEntity = mStateTemplate.beginIndependent();
  CModelEntity **ppEntityEnd = mStateTemplate.endIndependent() - mNumMetabolitesReactionIndependent;

  for (; ppEntity != ppEntityEnd; ++ppEntity) //loop over all entities with ODEs
    mSimulatedUpToDateObjects.insert((*ppEntity)->getRateReference());

  // We do not add the rates for metabolites of type REACTION. These are automatically calculated
  // with dgemm in calculate derivatives based on the reaction fluxes added below.
  // In the case that other simulated values depend on such a rate this is taken care by
  // calculating all dependencies.
  // This mechanism may lead occasionally to multiple calculations of rates of metabolites when used
  // in assignments or ODEs. However this is acceptable and more than compensated by the performance
  // gains of dgemm.

  // Furthermore all reaction fluxes have to be calculated too (see CMetab REACTION above)
  CCopasiVector< CReaction >::iterator itReaction = mSteps.begin();
  CCopasiVector< CReaction >::iterator endReaction = mSteps.end();

  for (; itReaction != endReaction; ++itReaction)
    mSimulatedUpToDateObjects.insert((*itReaction)->getParticleFluxReference());

  // We now detect unused assignments, i.e., the result of an assignment is not
  // used during updateSimulatedValues except for itself or another unused assignment.
  bool UnusedFound = true;

  std::set<const CCopasiObject * > Candidate;
  std::set< const CCopasiObject * >::iterator it;
  std::set< const CCopasiObject * >::iterator end = mSimulatedUpToDateObjects.end();
  CCopasiObject * pObject;
  CMetab * pMetab;
  ppEntityEnd = mStateTemplate.endDependent();

  while (UnusedFound)
    {
      UnusedFound = false;
      ppEntity = mStateTemplate.beginDependent() + MNumMetabolitesReactionDependent;
      //now points to the first entity with assignment

      for (; ppEntity != ppEntityEnd; ++ppEntity) //over all entities with assignments
        if ((*ppEntity)->isUsed())
          {
            if ((*ppEntity)->getStatus() != ASSIGNMENT)
              pObject = *ppEntity;
            else if ((pMetab = dynamic_cast< CMetab *>(*ppEntity)) != NULL)
              pObject = pMetab->getConcentrationReference();
            else
              pObject = (*ppEntity)->getValueReference();

            Candidate.insert(pObject);

            for (it = mSimulatedUpToDateObjects.begin(), end = mSimulatedUpToDateObjects.end(); it != end; ++it)
              if (*it != pObject &&
                  (*it)->dependsOn(Candidate))
                break;

            if (it == end)
              {
                UnusedFound = true;
                mReorderNeeded = true;
                (*ppEntity)->setUsed(false);
              }

            Candidate.erase(pObject);
          }
    }

  if (mReorderNeeded)
    {
      CVector< CModelEntity * > Reorder(mStateTemplate.size() - 1);
      CModelEntity ** ppReorder = Reorder.array();

      ppEntity = mStateTemplate.beginIndependent();
      ppEntityEnd = mStateTemplate.beginDependent() + MNumMetabolitesReactionDependent;

      //range is for all entities with ODEs + all metabs dependent on Reactions
      for (; ppEntity != ppEntityEnd; ++ppEntity, ++ppReorder)
        *ppReorder = *ppEntity;

      // :TODO: This must be enhanced as the mMetaboliteX and the state template may get out of sync
      // when we use assignments for metabolites.

      // the entities with assignments are reordered according to the isUsed() flag
      ppEntityEnd = mStateTemplate.endDependent();

      for (; ppEntity != ppEntityEnd; ++ppEntity) //over all entities with assignments
        if ((*ppEntity)->isUsed())
          *ppReorder++ = *ppEntity;

      ppEntity = mStateTemplate.beginDependent() + MNumMetabolitesReactionDependent;

      for (; ppEntity != ppEntityEnd; ++ppEntity) //again over all entities with assignments
        if (!(*ppEntity)->isUsed())
          *ppReorder++ = *ppEntity;

      ppEntityEnd = mStateTemplate.endFixed();

      for (; ppEntity != ppEntityEnd; ++ppEntity, ++ppReorder) //over all fixed entities
        *ppReorder = *ppEntity;

      mStateTemplate.reorder(Reorder);
      mReorderNeeded = false;

      // We need to recompile as pointers to values may have changed
      ppEntity = mStateTemplate.beginIndependent();
      ppEntityEnd = mStateTemplate.endFixed();

      for (; ppEntity != ppEntityEnd; ++ppEntity)
        (*ppEntity)->compile();

      itReaction = mSteps.begin();
      endReaction = mSteps.end();

      for (; itReaction != endReaction; ++itReaction)
        (*itReaction)->compile();

      // The compile might have broken some refresh pointers we need to rebuild the constant sequence
      buildInitialSequence();
      buildApplyInitialValuesSequence();
    }

  std::set< const CCopasiObject * > UpToDate;

  try
    {
      mSimulatedRefreshes = CCopasiObject::buildUpdateSequence(mSimulatedUpToDateObjects, UpToDate);
    }
  catch (...)
    {
      mSimulatedRefreshes.clear();
      success = false;
    }

  return success;
}

bool CModel::buildStateTemplate ( )

private

Build the state template for the model.

Returns

bool success

Definition at line 1262 of file CModel.cpp.

References CModelEntity::ASSIGNMENT, CCopasiVector< T >::begin(), CStateTemplate::beginIndependent(), CModelEntity::compile(), CCopasiVector< T >::end(), CStateTemplate::endFixed(), mCompartments, mMetabolitesX, mReorderNeeded, mStateTemplate, mSteps, mValues, CModelEntity::ODE, CStateTemplate::reorder(), CModelEntity::setUsed(), and CCopasiVector< T >::size().

Referenced by compile().

{
  CVector<CModelEntity *> Entities(mMetabolitesX.size() + mCompartments.size() + mValues.size());
  CModelEntity ** ppEntity = Entities.array();

  CCopasiVector< CModelValue >::iterator itValue = mValues.begin();
  CCopasiVector< CModelValue >::iterator endValue = mValues.end();

  for (; itValue != endValue; ++itValue)
    if ((*itValue)->getStatus() == ODE)
      {
        *ppEntity = *itValue;
        (*ppEntity++)->setUsed(true);
      }

  CCopasiVector< CCompartment >::iterator itCompartment = mCompartments.begin();
  CCopasiVector< CCompartment >::iterator endCompartment = mCompartments.end();

  for (; itCompartment != endCompartment; ++itCompartment)
    if ((*itCompartment)->getStatus() == ODE)
      {
        *ppEntity = *itCompartment;
        (*ppEntity++)->setUsed(true);
      }

  CCopasiVector< CMetab >::iterator itMetab = mMetabolitesX.begin();
  CCopasiVector< CMetab >::iterator endMetab = mMetabolitesX.end();

  for (; itMetab != endMetab; ++itMetab)
    {
      if (!(*itMetab)->isUsed()) break;

      *ppEntity++ = *itMetab;
    }

  itCompartment = mCompartments.begin();

  for (; itCompartment != endCompartment; ++itCompartment)
    if ((*itCompartment)->getStatus() == ASSIGNMENT)
      {
        *ppEntity = *itCompartment;
        (*ppEntity++)->setUsed(true);
      }

  itValue = mValues.begin();

  for (; itValue != endValue; ++itValue)
    if ((*itValue)->getStatus() == ASSIGNMENT)
      {
        *ppEntity = *itValue;
        (*ppEntity++)->setUsed(true);
      }

  for (; itMetab != endMetab; ++itMetab)
    *ppEntity++ = *itMetab;

  itCompartment = mCompartments.begin();

  for (; itCompartment != endCompartment; ++itCompartment)
    if ((*itCompartment)->isFixed())
      *ppEntity++ = *itCompartment;

  itValue = mValues.begin();

  for (; itValue != endValue; ++itValue)
    if ((*itValue)->isFixed())
      *ppEntity++ = *itValue;

  mStateTemplate.reorder(Entities);
  mReorderNeeded = false;

  // Now all entities and reactions can be compiled
  ppEntity = mStateTemplate.beginIndependent();
  CModelEntity ** ppEntityEnd = mStateTemplate.endFixed();

  for (; ppEntity != ppEntityEnd; ++ppEntity)
    (*ppEntity)->compile();

  CCopasiVector< CReaction >::iterator itReaction = mSteps.begin();
  CCopasiVector< CReaction >::iterator endReaction = mSteps.end();

  for (; itReaction != endReaction; ++itReaction)
    (*itReaction)->compile();

  return true;
}

void CModel::buildStoi

(

)

Build the Stoichiometry Matrix from the chemical equations of the steps

Definition at line 642 of file CModel.cpp.

References CProcessReport::addItem(), CMatrix< CType >::array(), CCopasiVector< T >::begin(), C_FLOAT64, C_INT32, CCopasiVector< T >::end(), CCopasiMessage::ERROR, CProcessReport::finishItem(), handleUnusedMetabolites(), initializeMetabolites(), MCReaction, mMetabolitesX, mNumMetabolitesODE, mNumMetabolitesReaction, mParticleFluxes, mpCompileHandler, mSteps, mStoiInternal, CProcessReport::progressItem(), CMatrix< CType >::resize(), CVector< CType >::resize(), and CCopasiVector< T >::size().

Referenced by compile().

{
  unsigned C_INT32 i, numCols;

  initializeMetabolites();

  size_t numRows;
  numRows = mNumMetabolitesReaction;
  numCols = (unsigned C_INT32) mSteps.size();

  mParticleFluxes.resize(numCols);
  mStoiInternal.resize(numRows, numCols);
  mStoiInternal = 0.0;

  size_t hProcess;

  if (mpCompileHandler)
    {
      i = 0;
      hProcess = mpCompileHandler->addItem("Building Stoichiometry",
                                           i,
                                           &numCols);
    }

  C_FLOAT64 * pCol, *pColEnd;
  pCol = mStoiInternal.array();
  pColEnd = mStoiInternal.array() + numCols;

  C_FLOAT64 * pRow, *pRowEnd;
  pRowEnd = mStoiInternal.array() + numRows * numCols;

  CCopasiVector< CReaction >::iterator itStep = mSteps.begin();
  CCopasiVector< CMetab >::const_iterator itMetab;

  for (; pCol < pColEnd; ++pCol, ++itStep)
    {
      if (mpCompileHandler && !mpCompileHandler->progressItem(hProcess)) return;

      // Since we are stepping through the reactions we can check whether
      // the kinetic functions are usable.
      if (!(*itStep)->getFunction()->isUsable())
        CCopasiMessage(CCopasiMessage::ERROR, MCReaction + 11,
                       (*itStep)->getObjectName().c_str(),
                       (*itStep)->getFunction()->getObjectName().c_str());

      const CCopasiVector< CChemEqElement > & Balance =
        (*itStep)->getChemEq().getBalances();
      CCopasiVector< CChemEqElement >::const_iterator itBalance = Balance.begin();
      CCopasiVector< CChemEqElement >::const_iterator endBalance = Balance.end();

      for (; itBalance != endBalance; ++itBalance)
        {
          const std::string & key = (*itBalance)->getMetaboliteKey();

          for (pRow = pCol, itMetab = mMetabolitesX.begin() + mNumMetabolitesODE;
               pRow < pRowEnd;
               pRow += numCols, ++itMetab)
            if ((*itMetab)->getKey() == key)
              {
                *pRow = (*itBalance)->getMultiplicity();
                break;
              }
        }
    }

  // We need to have all unused and fixed metabolites at the end of mMetabolites.
  // However we can only detect unused metabolites after building the
  // stoichiometry matrix.
  handleUnusedMetabolites();

#ifdef DEBUG_MATRIX
  DebugFile << "Stoichiometry Matrix" << std::endl;
  DebugFile << mStoiInternal << std::endl;
#endif

  if (mpCompileHandler)
    mpCompileHandler->finishItem(hProcess);

  return;
}

bool CModel::buildUserOrder ( )

private

Build the user order for the state template

Returns

bool success

Definition at line 1349 of file CModel.cpp.

References CVectorCore< CType >::array(), CCopasiVector< T >::begin(), CCopasiVector< T >::end(), CStateTemplate::getEntities(), CStateTemplate::getNumIndependent(), CStateTemplate::getUserOrder(), CModelEntity::isUsed(), mCompartments, mJacobianPivot, mMetabolites, MNumMetabolitesReactionDependent, mStateTemplate, mValues, CModelEntity::ODE, CModelEntity::REACTIONS, CVector< CType >::resize(), CStateTemplate::setUserOrder(), CVectorCore< CType >::size(), and CCopasiVector< T >::size().

Referenced by compile().

{
  CVector<CModelEntity *> Entities(mMetabolites.size() + mCompartments.size() + mValues.size());
  CModelEntity ** ppEntity = Entities.array();

  CCopasiVector< CMetab >::iterator itMetab = mMetabolites.begin();
  CCopasiVector< CMetab >::iterator endMetab = mMetabolites.end();

  for (; itMetab != endMetab; ++itMetab)
    *ppEntity++ = *itMetab;;

  CCopasiVector< CCompartment >::iterator itCompartment = mCompartments.begin();
  CCopasiVector< CCompartment >::iterator endCompartment = mCompartments.end();

  for (; itCompartment != endCompartment; ++itCompartment)
    *ppEntity++ = *itCompartment;

  CCopasiVector< CModelValue >::iterator itValue = mValues.begin();
  CCopasiVector< CModelValue >::iterator endValue = mValues.end();

  for (; itValue != endValue; ++itValue)
    *ppEntity++ = *itValue;

  mStateTemplate.setUserOrder(Entities);

  mJacobianPivot.resize(mStateTemplate.getNumIndependent() + MNumMetabolitesReactionDependent);
  //now sized to the number of entities with ODEs + all metabolites dependent on reactions

  const size_t * pUserOrder = mStateTemplate.getUserOrder().array();
  const size_t * pUserOrderEnd = pUserOrder + mStateTemplate.getUserOrder().size();
  ppEntity = mStateTemplate.getEntities();

  size_t i;

  for (i = 0; pUserOrder != pUserOrderEnd; ++pUserOrder)
    {
      const Status & Status = ppEntity[*pUserOrder]->getStatus();

      if (Status == ODE ||
          (Status == REACTIONS && ppEntity[*pUserOrder]->isUsed()))
        mJacobianPivot[i++] = *pUserOrder - 1;
    }

  return true;
}

void CModel::calculateDerivatives

(

C_FLOAT64 *

derivatives

)

Calculate the changes of all model quantities determined by ODEs for the model in the current state. The parameter derivatives must at least provide space for state->getVariableNumberSize() double &param C_FLOAT64 * derivatives (output)

Definition at line 1903 of file CModel.cpp.

References CVectorCore< CType >::array(), CMatrix< CType >::array(), C_FLOAT64, C_INT, dgemm_(), CStateTemplate::getEntities(), CStateTemplate::getNumIndependent(), K, mNumMetabolitesReaction, mNumMetabolitesReactionIndependent, mParticleFluxes, mStateTemplate, mSteps, mStoi, and CCopasiVector< T >::size().

Referenced by CTSSAMethod::calculateDerivatives(), calculateJacobian(), CMathModel::calculateRootDerivatives(), CLyapWolfMethod::evalF(), CLsodaMethod::evalF(), CTrajectoryMethodDsaLsodar::evalF(), CTSSAMethod::evalF(), and CCSPMethod::step().

{
  C_FLOAT64 * pTmp = derivatives;

  // First retrieve derivatives of quantities determined by ODE
  // The offset 1 is for the model time which is always the first
  // state variable.
  CModelEntity ** ppIt = mStateTemplate.getEntities() + 1;
  CModelEntity ** ppEnd =
    ppIt + mStateTemplate.getNumIndependent() - mNumMetabolitesReactionIndependent;

  for (; ppIt != ppEnd; ++ppIt, ++pTmp)
    {
      *pTmp = (*ppIt)->getRate();

#ifdef COPASI_DEBUG

      if (isnan(*pTmp))
        {
          std::cout << "Entity[" <<   ppIt - (mStateTemplate.getEntities() + 1) << "] is NaN" << std::endl;
        }

#endif // COPASI_DEBUG
    }

  // Now calculate derivatives of all metabolites determined by reactions
  char T = 'N';
  C_INT M = 1;
  C_INT N = (C_INT) mNumMetabolitesReaction;
  C_INT K = (C_INT) mSteps.size();
  C_FLOAT64 Alpha = 1.0;
  C_FLOAT64 Beta = 0.0;

  if (K != 0)
    dgemm_(&T, &T, &M, &N, &K, &Alpha, mParticleFluxes.array(), &M,
           mStoi.array(), &K, &Beta, pTmp, &M);
}

void CModel::calculateDerivativesX

(

C_FLOAT64 *

derivativesX

)

Calculate the changes of all model quantities determined by ODEs for the reduced model in the current state. The parameter derivatives must at least provide space for state->getDependentNumberSize() double &param C_FLOAT64 * derivatives (output)

Definition at line 1941 of file CModel.cpp.

References CVectorCore< CType >::array(), CMatrix< CType >::array(), C_FLOAT64, C_INT, dgemm_(), CStateTemplate::getEntities(), CStateTemplate::getNumIndependent(), K, mNumMetabolitesReactionIndependent, mParticleFluxes, mRedStoi, mStateTemplate, mSteps, and CCopasiVector< T >::size().

Referenced by CNewtonMethod::calculateDerivativesX(), CTSSAMethod::calculateDerivativesX(), calculateJacobianX(), CLyapWolfMethod::evalF(), CLsodaMethod::evalF(), CTrajectoryMethodDsaLsodar::evalF(), CTSSAMethod::evalF(), and CCSPMethod::step().

{
  C_FLOAT64 * pTmp = derivativesX;

  // First retrieve derivatives of quantities determined by ODE
  // The offset 1 is for the model time which is always the first
  // state variable.
  CModelEntity ** ppIt = mStateTemplate.getEntities() + 1;
  CModelEntity ** ppEnd =
    ppIt + mStateTemplate.getNumIndependent() - mNumMetabolitesReactionIndependent;

  for (; ppIt != ppEnd; ++ppIt, ++pTmp)
    *pTmp = (*ppIt)->getRate();

  // Now calculate derivatives of the independent metabolites determined by reactions
  char T = 'N';
  C_INT M = 1;
  C_INT N = (C_INT) mNumMetabolitesReactionIndependent;
  C_INT K = (C_INT) mSteps.size();
  C_FLOAT64 Alpha = 1.0;
  C_FLOAT64 Beta = 0.0;

  if (K != 0)
    dgemm_(&T, &T, &M, &N, &K, &Alpha, mParticleFluxes.array(), &M,
           mRedStoi.array(), &K, &Beta, pTmp, &M);
}

C_FLOAT64 CModel::calculateDivergence

(

)

const

Calculates the divergence for the current state. calculateElasticityMatrix() needs to be called before. It makes only sense to use this method if the Jacobian is not also calculated. In this case it would be more efficient to use the trace of the Jacobian

Definition at line 2153 of file CModel.cpp.

References fatalError.

{
  fatalError(); //not yet implemented
  return 0.0;
}

void CModel::calculateElasticityMatrix	(	const C_FLOAT64 &	factor,
		const C_FLOAT64 &	resolution
	)

Calculates the elasticity matrix of the model for the current state and stores it in the provided matrix.

Parameters

CMatrix<	C_FLOAT64 > & elasticityMatrix
const	C_FLOAT64 & factor,
const	C_FLOAT64 & resolution

Definition at line 1968 of file CModel.cpp.

References CMatrix< CType >::array(), CCopasiVector< T >::begin(), CStateTemplate::beginIndependent(), C_FLOAT64, CCopasiVector< T >::end(), CStateTemplate::endDependent(), CMetab::getCompartment(), CMetab::getConcentration(), CModelEntity::getValue(), mElasticities, mStateTemplate, mSteps, and CMatrix< CType >::numCols().

{
  size_t Col;
  size_t nCol = mElasticities.numCols();

  C_FLOAT64 * itE;
  C_FLOAT64 * beginE = mElasticities.array();

  CCopasiVector< CReaction >::const_iterator itReaction;
  CCopasiVector< CReaction >::const_iterator beginReaction = mSteps.begin();
  CCopasiVector< CReaction >::const_iterator endReaction = mSteps.end();

  CModelEntity ** itEntity;
  CModelEntity ** beginEntity = mStateTemplate.beginIndependent();
  CModelEntity ** endEntity = mStateTemplate.endDependent();

  for (itEntity = beginEntity, Col = 0; itEntity != endEntity; ++itEntity, ++Col)
    {
      // :TODO: This only works for entities of type metabolites.
      //        The scaling factor for other entities should be 1.
      const C_FLOAT64 invVolume =
        1.0 / static_cast<CMetab *>(*itEntity)->getCompartment()->getValue();
      C_FLOAT64 * pX =
        const_cast<C_FLOAT64 *>(&static_cast<CMetab *>(*itEntity)->getConcentration());

      for (itReaction = beginReaction, itE = beginE + Col;
           itReaction != endReaction;
           ++itReaction, itE += nCol)
        * itE = invVolume * (*itReaction)->calculatePartialDerivative(pX, factor, resolution);
    }

  // DebugFile << "CModel::calculateElasticityMatrix()" << std::endl;
  // DebugFile << mElasticities << std::endl;

  return;
}

void CModel::calculateJacobian	(	CMatrix< C_FLOAT64 > &	jacobian,
		const C_FLOAT64 &	derivationFactor,
		const C_FLOAT64 &	resolution
	)

Calculates the jacobian of the full model for the current state and stores it in the provided matrix. calculateElasticityMatrix() needs to be called before.

Parameters

CMatrix<	C_FLOAT64 > & jacobian
const	C_FLOAT64 & derivationFactor,
const	C_FLOAT64 & resolution

Definition at line 2006 of file CModel.cpp.

References CVectorCore< CType >::array(), CMatrix< CType >::array(), CState::beginIndependent(), C_FLOAT64, calculateDerivatives(), CState::getNumIndependent(), max, mCurrentState, MNumMetabolitesReactionDependent, CMatrix< CType >::resize(), and updateSimulatedValues().

Referenced by CSteadyStateMethod::doJacobian(), and CCSPMethod::step().

{
  C_FLOAT64 DerivationFactor = std::max(derivationFactor, 100.0 * std::numeric_limits< C_FLOAT64 >::epsilon());

  size_t Dim =
    mCurrentState.getNumIndependent() + MNumMetabolitesReactionDependent;
  //Dim now contains the number of entities with ODEs + number of metabs depending on reactions.

  size_t Col;

  jacobian.resize(Dim, Dim);

  C_FLOAT64 Store;
  C_FLOAT64 X1;
  C_FLOAT64 X2;
  C_FLOAT64 InvDelta;

  CVector< C_FLOAT64 > Y1(Dim);
  CVector< C_FLOAT64 > Y2(Dim);

  C_FLOAT64 * pY1;
  C_FLOAT64 * pY2;

  C_FLOAT64 * pX = mCurrentState.beginIndependent();
  C_FLOAT64 * pXEnd = pX + Dim;

  C_FLOAT64 * pJacobian;
  C_FLOAT64 * pJacobianEnd = jacobian.array() + Dim * Dim;

  for (Col = 0; pX != pXEnd; ++pX, ++Col)
    {
      Store = *pX;

      // We only need to make sure that we do not have an underflow problem
      if (fabs(Store) < DerivationFactor)
        {
          X1 = 0.0;

          if (Store < 0.0)
            X2 = -2.0 * DerivationFactor;
          else
            X2 = 2.0 * DerivationFactor;
        }
      else
        {
          X1 = Store * (1.0 + DerivationFactor);
          X2 = Store * (1.0 - DerivationFactor);
        }

      InvDelta = 1.0 / (X2 - X1);

      *pX = X1;
      updateSimulatedValues(false);
      calculateDerivatives(Y1.array());

      *pX = X2;
      updateSimulatedValues(false);
      calculateDerivatives(Y2.array());

      *pX = Store;

      pJacobian = jacobian.array() + Col;
      pY1 = Y1.array();
      pY2 = Y2.array();

      for (; pJacobian < pJacobianEnd; pJacobian += Dim, ++pY1, ++pY2)
        * pJacobian = (*pY2 - *pY1) * InvDelta;
    }

  updateSimulatedValues(false);

  return;
}

void CModel::calculateJacobianX	(	CMatrix< C_FLOAT64 > &	jacobianX,
		const C_FLOAT64 &	derivationFactor,
		const C_FLOAT64 &	resolution
	)

Calculates the Jacobian of the reduced model for the current state and stores it in the provided matrix. calculateElasticityMatrix() needs to be called before.

Parameters

const	C_FLOAT64 & derivationFactor,
const	C_FLOAT64 & resolution
CMatrix<	C_FLOAT64 > & jacobianX

Definition at line 2082 of file CModel.cpp.

References CVectorCore< CType >::array(), CMatrix< CType >::array(), CState::beginIndependent(), C_FLOAT64, calculateDerivativesX(), CState::getNumIndependent(), max, mCurrentState, CMatrix< CType >::resize(), and updateSimulatedValues().

Referenced by CLNAMethod::calculateCovarianceMatrixReduced(), CSteadyStateMethod::calculateJacobianX(), CSteadyStateMethod::doJacobian(), CLyapWolfMethod::evalF(), CILDMMethod::step(), CILDMModifiedMethod::step(), and CCSPMethod::step().

{
  C_FLOAT64 DerivationFactor = std::max(derivationFactor, 100.0 * std::numeric_limits< C_FLOAT64 >::epsilon());

  size_t Dim = mCurrentState.getNumIndependent();
  size_t Col;

  jacobianX.resize(Dim, Dim);

  C_FLOAT64 Store;
  C_FLOAT64 X1;
  C_FLOAT64 X2;
  C_FLOAT64 InvDelta;

  CVector< C_FLOAT64 > Y1(Dim);
  CVector< C_FLOAT64 > Y2(Dim);

  C_FLOAT64 * pY1;
  C_FLOAT64 * pY2;

  C_FLOAT64 * pX = mCurrentState.beginIndependent();
  C_FLOAT64 * pXEnd = pX + Dim;

  C_FLOAT64 * pJacobian;
  C_FLOAT64 * pJacobianEnd = jacobianX.array() + Dim * Dim;

  for (Col = 0; pX != pXEnd; ++pX, ++Col)
    {
      Store = *pX;

      // We only need to make sure that we do not have an underflow problem
      if (fabs(Store) < DerivationFactor)
        {
          X1 = 0.0;

          if (Store < 0.0)
            X2 = -2.0 * DerivationFactor;
          else
            X2 = 2.0 * DerivationFactor;;
        }
      else
        {
          X1 = Store * (1.0 + DerivationFactor);
          X2 = Store * (1.0 - DerivationFactor);
        }

      InvDelta = 1.0 / (X2 - X1);

      *pX = X1;
      updateSimulatedValues(true);
      calculateDerivativesX(Y1.array());

      *pX = X2;
      updateSimulatedValues(true);
      calculateDerivativesX(Y2.array());

      *pX = Store;

      pJacobian = jacobianX.array() + Col;
      pY1 = Y1.array();
      pY2 = Y2.array();

      for (; pJacobian < pJacobianEnd; pJacobian += Dim, ++pY1, ++pY2)
        * pJacobian = (*pY2 - *pY1) * InvDelta;
    }

  updateSimulatedValues(true);
}

void CModel::calculateRootDerivatives

(

CVector< C_FLOAT64 > &

rootDerivatives

)

Calculate the time derivative of all roots

Parameters

CVector<

C_FLOAT64 > & rootDerivatives

Definition at line 4712 of file CModel.cpp.

References CMathModel::calculateRootDerivatives(), and mpMathModel.

Referenced by CLsodaMethod::createRootMask().

{
  return mpMathModel->calculateRootDerivatives(rootDerivatives);
}

void CModel::clearMoieties ( )

private

Clear all references to moieties

Definition at line 1257 of file CModel.cpp.

References CCopasiVector< T >::clear(), and mMoieties.

Referenced by removeEvent(), removeMetabolite(), and removeReaction().

{
  mMoieties.clear();
}

bool CModel::compile ( )

privatevirtual

Compile the model value. This is only needed for status ASIGNMENT and ODE.

Returns

bool success

Reimplemented from CModelEntity.

Definition at line 381 of file CModel.cpp.

References CCopasiObject::addDirectDependency(), CProcessReport::addItem(), CCopasiVector< T >::begin(), buildApplyInitialValuesSequence(), buildDependencyGraphs(), buildInitialSequence(), buildLinkZero(), buildMoieties(), buildNonSimulatedSequence(), buildRedStoi(), buildSimulatedSequence(), buildStateTemplate(), buildStoi(), buildUserOrder(), C_INT32, CLinkMatrix::clearPivoting(), CMathModel::compile(), compileEvents(), CModelParameterSet::createFromModel(), determineIsAutonomous(), CCopasiVector< T >::end(), CProcessReport::finishItem(), mApplyInitialValuesRefreshes, mCompileIsNecessary, mInitialRefreshes, mIsAutonomous, mL, mMetabolitesX, mNonSimulatedRefreshes, mParameterSet, mpCompileHandler, mpMathModel, CModelEntity::mpValueReference, mSimulatedRefreshes, pdelete, CProcessReport::progressItem(), CRenameHandler::setEnabled(), CProcessReport::setName(), CCopasiObject::smpRenameHandler, and updateMatrixAnnotations().

Referenced by CModel(), compileIfNecessary(), and load().

{
  bool success = true;

  if (CCopasiObject::smpRenameHandler != NULL)
    {
      CCopasiObject::smpRenameHandler->setEnabled(false);
    }

  mpValueReference->addDirectDependency(this);

  CMatrix< C_FLOAT64 > LU;

  unsigned C_INT32 CompileStep = 0;
  size_t hCompileStep;

  if (mpCompileHandler)
    {
      mpCompileHandler->setName("Compiling model...");
      unsigned C_INT32 totalSteps = 7;
      hCompileStep = mpCompileHandler->addItem("Compile Process",
                     CompileStep,
                     &totalSteps);
    }

  // To assure that we do not produce access violations we clear the refresh sequences
  // first
  mInitialRefreshes.clear();
  mSimulatedRefreshes.clear();
  mApplyInitialValuesRefreshes.clear();
  mNonSimulatedRefreshes.clear();

  CompileStep = 0;

  if (mpCompileHandler && !mpCompileHandler->progressItem(hCompileStep))
    {
      success = false;
      goto finish;
    }

  buildStoi();
  CompileStep = 1;

  if (mpCompileHandler && !mpCompileHandler->progressItem(hCompileStep))
    {
      success = false;
      goto finish;
    }

  buildLinkZero();
  CompileStep = 2;

  if (mpCompileHandler && !mpCompileHandler->progressItem(hCompileStep))
    {
      success = false;
      goto finish;
    }

  buildRedStoi();
  CompileStep = 3;

  if (mpCompileHandler && !mpCompileHandler->progressItem(hCompileStep))
    {
      success = false;
      goto finish;
    }

  buildMoieties();
  CompileStep = 4;

  if (mpCompileHandler && !mpCompileHandler->progressItem(hCompileStep))
    {
      success = false;
      goto finish;
    }

  buildStateTemplate();
  CompileStep = 5;

  if (mpCompileHandler && !mpCompileHandler->progressItem(hCompileStep))
    {
      success = false;
      goto finish;
    }

  try
    {
      success &= buildInitialSequence();
      success &= buildApplyInitialValuesSequence();
      success &= buildSimulatedSequence();
      success &= buildNonSimulatedSequence();
    }
  catch (...)
    {
      success = false;
    }

  CompileStep = 6;

  if (mpCompileHandler && !mpCompileHandler->progressItem(hCompileStep))
    {
      success = false;
      goto finish;
    }

  buildUserOrder();

  if (mpCompileHandler) mpCompileHandler->finishItem(hCompileStep);

  {
    CCopasiVector< CMetab >::iterator itSpecies = mMetabolitesX.begin();
    CCopasiVector< CMetab >::iterator endSpecies = mMetabolitesX.end();

    for (; itSpecies != endSpecies; ++itSpecies)
      {
        (*itSpecies)->compileIsInitialConcentrationChangeAllowed();
      }
  }

  //update annotations
  updateMatrixAnnotations();

  success &= compileEvents();
  success &= mpMathModel->compile(this);

  if (!success)
    {
      mIsAutonomous = false;
    }
  else
    {
      mCompileIsNecessary = false;
      determineIsAutonomous();
    }

  //writeDependenciesToDotFile();

  buildDependencyGraphs();

#ifdef USE_MATH_CONTAINER
  pdelete(mpMathContainer);
  mpMathContainer = new CMathContainer(*this);

  // CMathContainer CopyModel(MathModel);
#endif // USE_MATH_CONTAINER

  // Update the parameter set
  mParameterSet.createFromModel();

finish:

  // Since we have applied the pivot to the stoichiometry matrix and the species
  // we do not need them any longer. In fact it is detrimental if other functions rely
  // on consistency between the stoichiometry matrix, reduced stoichiometry matrix and the Link matrix..
  mL.clearPivoting();

  if (CCopasiObject::smpRenameHandler != NULL)
    {
      CCopasiObject::smpRenameHandler->setEnabled(true);
    }

  mCompileIsNecessary = !success;

  return success;
}

bool CModel::compileEvents ( )

private

Compile the events

Returns

bool success

Definition at line 4116 of file CModel.cpp.

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

Referenced by compile().

{
  bool success = true;

  std::vector< CCopasiContainer * > ListOfContainer;

  CCopasiVectorN< CEvent >::iterator it = mEvents.begin();
  CCopasiVectorN< CEvent >::iterator end = mEvents.end();

  for (; it != end; ++ it)
    {
      success &= (*it)->compile(ListOfContainer);
    }

  return success;
}

bool CModel::compileIfNecessary

(

CProcessReport *

pProcessReport

)

Compile the model if necessary

Parameters

CProcessReport*

pProcessReport

Returns

bool success

Definition at line 612 of file CModel.cpp.

References compile(), mCompileIsNecessary, and mpCompileHandler.

Referenced by appendDependentCompartments(), appendDependentEvents(), appendDependentMetabolites(), appendDependentModelValues(), appendDependentReactions(), DataModelGUI::buildChangedObjects(), CCopasiDataModel::commonAfterLoad(), CModelExpansion::copyCompleteModel(), CCrossSectionTask::createEvent(), CModelExpansion::createLinearArray(), test000097::createModel(), CModelExpansion::createRectangularArray(), CCopasiDataModel::exportMathModel(), CCopasiDataModel::exportMathModelToString(), CCopasiDataModel::exportSBML(), CCopasiDataModel::exportSBMLToString(), forceCompile(), COscillationProblem::initialize(), CLNATask::initialize(), COptProblem::initialize(), CMCATask::initialize(), CCopasiTask::initialize(), CQUpdatesWidget::loadWidget(), CCopasiDataModel::saveModel(), SBMLImporter::setInitialValues(), CModelAdd::simpleCall(), CModelMerging::simpleCall(), CModelExpansion::simpleCall(), CopasiUI3Window::slotApplyInitialState(), CopasiUI3Window::slotUpdateInitialState(), CQSteadyStateResult::slotUpdateModel(), test000058::test_bug1025_10(), test000058::test_bug1025_6(), test000058::test_bug1025_7(), test000058::test_bug1025_8(), test000058::test_bug1025_9(), test000059::test_unique_id_11(), test000059::test_unique_id_12(), test000059::test_unique_id_13(), test000059::test_unique_id_14(), test000059::test_unique_id_15(), test000059::test_unique_id_16(), updateInitialValues(), and CSensTask::updateMatrices().

{
  bool success = true;

  if (mCompileIsNecessary)
    {
      mpCompileHandler = pProcessReport;

      try
        {
          success &= compile();
        }

      catch (...)
        {
          success = false;
        }

      mpCompileHandler = NULL;
    }

  return success;
}

bool CModel::convert2NonReversible

(

)

Converts the set of reactions to a set of reactions where all reactions are irreversible.

Definition at line 3205 of file CModel.cpp.

References CFunctionDB::addAndAdaptName(), CReaction::addModifier(), CReaction::addProduct(), CReaction::addSubstrate(), appendDependentCompartments(), appendDependentEvents(), appendDependentMetabolites(), appendDependentModelValues(), CModelEntity::ASSIGNMENT, CCopasiVector< T >::begin(), CReaction::compile(), createReaction(), CCopasiVector< T >::end(), CCopasiMessage::ERROR, findFunction(), CFunctionParameter::FLOAT64, CEvent::getAssignments(), CReaction::getChemEq(), CCopasiObject::getCN(), CEvent::getDelayExpression(), CCopasiObject::getDirectDependencies(), CModelEntity::getExpression(), CReaction::getFluxReference(), CReaction::getFunction(), CCopasiRootContainer::getFunctionList(), CReaction::getFunctionParameters(), CModelEntity::getInitialExpression(), CCopasiObject::getObjectName(), CCopasiParameterGroup::getParameter(), CReaction::getParameterMapping(), CReaction::getParameters(), CReaction::getParameterValue(), CReaction::getParticleFluxReference(), CEvent::getPriorityExpression(), CChemEq::getProducts(), getReactions(), CModelEntity::getStatus(), CChemEq::getSubstrates(), CEvent::getTriggerExpression(), CFunctionParameter::getType(), CFunctionParameter::getUsage(), CCopasiParameter::getValueReference(), CReaction::isLocalParameter(), mCompartments, MCReaction, mEvents, mMetabolitesX, CFunctionParameter::MODIFIER, mValues, CFunctionParameter::PARAMETER, pdelete, CFunctionParameter::PRODUCT, setCompileFlag(), CEvent::setDelayExpression(), CModelEntity::setExpression(), CReaction::setFunction(), CModelEntity::setInitialExpression(), CReaction::setParameterMapping(), CReaction::setParameterMappingVector(), CReaction::setParameterValue(), CEvent::setPriorityExpression(), CReaction::setReversible(), CEvent::setTriggerExpression(), CFunctionParameters::size(), CCopasiVector< T >::size(), CFunction::splitFunction(), stringReplace(), and CFunctionParameter::SUBSTRATE.

Referenced by CopasiUI3Window::slotConvertToIrreversible().

{
  // TODO check if there are any reversible reactions
  // TODO warn the user
  // TODO tell the GUI about changes -> not from here
  // TODO generate report ?
  // TODO check if newly generated reaction names are valid
  // TODO map, so that the same function is split only once

  bool success = true;

  std::vector< CReaction * > reactionsToDelete;

  CReaction *reac0, *reac1, *reac2;
  std::string fn, rn1, rn2;

  //CModel* model = dynamic_cast< CModel * >(CCopasiRootContainer::getKeyFactory()->get(objKey));
  //if (!model) return false;

  CCopasiVectorN< CReaction > & steps = this->getReactions();

  size_t i, imax = steps.size();

  for (i = 0; i < imax; ++i)
    if (steps[i]->isReversible())
      {
        std::vector< std::pair< const CCopasiObject * , const CCopasiObject * > > ParameterMap;

        reac0 = steps[i];
        rn1 = reac0->getObjectName() + " (forward)";
        rn2 = reac0->getObjectName() + " (backward)";

        fn = reac0->getFunction()->getObjectName();

        const CFunction* pFunc = reac0->getFunction();

        bool massaction = (fn == "Mass action (reversible)");

        std::pair<CFunction *, CFunction *> tmp;

        if (massaction)
          {
            //set functions to mass action (irrev)
            tmp.first = dynamic_cast<CFunction*>
                        (CCopasiRootContainer::getFunctionList()-> findFunction("Mass action (irreversible)"));
            assert(tmp.first);
            tmp.second = tmp.first;
          }
        else //not mass action
          {
            //try splitting
            tmp = pFunc->splitFunction(NULL, pFunc->getObjectName() + " (forward part)",
                                       pFunc->getObjectName() + " (backward part)");

            if ((tmp.first == NULL) || (tmp.second == NULL))
              {
                // Create a message that the conversion for this reaction failed.
                CCopasiMessage(CCopasiMessage::ERROR, MCReaction + 12,
                               reac0->getObjectName().c_str(), fn.c_str());
                success = false;

                pdelete(tmp.first);
                pdelete(tmp.second);
                continue;
              }

            tmp.first = CCopasiRootContainer::getFunctionList()->addAndAdaptName(tmp.first);

            tmp.second = CCopasiRootContainer::getFunctionList()->addAndAdaptName(tmp.second);
          }

        size_t i, imax;

        //**** create 1st reaction.
        reac1 = createReaction(rn1);
        reac1->setReversible(false);
        //substrates
        imax = reac0->getChemEq().getSubstrates().size();

        for (i = 0; i < imax; ++i)
          reac1->addSubstrate(reac0->getChemEq().getSubstrates()[i]->getMetaboliteKey(),
                              reac0->getChemEq().getSubstrates()[i]->getMultiplicity());

        //products
        imax = reac0->getChemEq().getProducts().size();

        for (i = 0; i < imax; ++i)
          reac1->addProduct(reac0->getChemEq().getProducts()[i]->getMetaboliteKey(),
                            reac0->getChemEq().getProducts()[i]->getMultiplicity());

        //function
        reac1->setFunction(tmp.first);

        //**** create 2nd reaction.
        reac2 = createReaction(rn2);
        reac2->setReversible(false);
        //substrates -> products
        imax = reac0->getChemEq().getSubstrates().size();

        for (i = 0; i < imax; ++i)
          reac2->addProduct(reac0->getChemEq().getSubstrates()[i]->getMetaboliteKey(),
                            reac0->getChemEq().getSubstrates()[i]->getMultiplicity());

        //products -> substrates
        imax = reac0->getChemEq().getProducts().size();

        for (i = 0; i < imax; ++i)
          reac2->addSubstrate(reac0->getChemEq().getProducts()[i]->getMetaboliteKey(),
                              reac0->getChemEq().getProducts()[i]->getMultiplicity());

        //function
        reac2->setFunction(tmp.second);

        //mapping for both reactions
        if (massaction)
          {
            // the parameter names of the massaction kinetics are hardcoded here.
            if (reac0->isLocalParameter("k1"))
              reac1->setParameterValue("k1", reac0->getParameterValue("k1"));
            else
              reac1->setParameterMapping("k1", reac0->getParameterMapping("k1")[0]);

            reac1->setParameterMappingVector("substrate", reac0->getParameterMapping("substrate"));

            if (reac0->isLocalParameter("k2"))
              reac2->setParameterValue("k1", reac0->getParameterValue("k2"));
            else
              reac2->setParameterMapping("k1", reac0->getParameterMapping("k2")[0]);

            reac2->setParameterMappingVector("substrate", reac0->getParameterMapping("product"));

            // Bug 2143: We need to replace any occurrence of the reaction parameter of the
            // reversible reaction with its replacement in the forward or backwards reaction
            ParameterMap.push_back(std::make_pair(reac0->getParameters().getParameter("k1")->getValueReference(),
                                                  reac1->getParameters().getParameter("k1")->getValueReference()));
            ParameterMap.push_back(std::make_pair(reac0->getParameters().getParameter("k2")->getValueReference(),
                                                  reac2->getParameters().getParameter("k1")->getValueReference()));
          }
        else //not mass action
          {
            const CFunctionParameters & fps = reac0->getFunctionParameters();
            imax = fps.size();

            for (i = 0; i < imax; ++i)
              {
                const CFunctionParameter * fp = fps[i];
                assert(fp);
                assert(fp->getType() == CFunctionParameter::FLOAT64);

                switch (fp->getUsage())
                  {
                    case CFunctionParameter::SUBSTRATE:
                      reac1->setParameterMapping(fp->getObjectName(),
                                                 reac0->getParameterMapping(fp->getObjectName())[0]);

                      // It is possible (see Bug 1830) that the split function may have additional modifier.
                      // This will happen e.g. if the product is referenced in the forward part of the reaction.
                      if (reac2->setParameterMapping(fp->getObjectName(),
                                                     reac0->getParameterMapping(fp->getObjectName())[0]))
                        {
                          reac2->addModifier(reac0->getParameterMapping(fp->getObjectName())[0]);
                        }

                      break;

                    case CFunctionParameter::PRODUCT:

                      // It is possible (see Bug 1830) that the split function may have additional modifier.
                      // This will happen e.g. if the product is referenced in the forward part of the reaction.
                      if (reac1->setParameterMapping(fp->getObjectName(),
                                                     reac0->getParameterMapping(fp->getObjectName())[0]))
                        {
                          reac1->addModifier(reac0->getParameterMapping(fp->getObjectName())[0]);
                        }

                      reac2->setParameterMapping(fp->getObjectName(),
                                                 reac0->getParameterMapping(fp->getObjectName())[0]);
                      break;

                    case CFunctionParameter::MODIFIER:

                      if (reac1->setParameterMapping(fp->getObjectName(),
                                                     reac0->getParameterMapping(fp->getObjectName())[0]))
                        {
                          // Add the modifier
                          reac1->addModifier(reac0->getParameterMapping(fp->getObjectName())[0]);
                        }

                      if (reac2->setParameterMapping(fp->getObjectName(),
                                                     reac0->getParameterMapping(fp->getObjectName())[0]))
                        {
                          // Add the modifier
                          reac2->addModifier(reac0->getParameterMapping(fp->getObjectName())[0]);
                        }

                      break;

                    case CFunctionParameter::PARAMETER:

                      if (reac0->isLocalParameter(fp->getObjectName()))
                        {

                          reac1->setParameterValue(fp->getObjectName(),
                                                   reac0->getParameterValue(fp->getObjectName()));
                          reac2->setParameterValue(fp->getObjectName(),
                                                   reac0->getParameterValue(fp->getObjectName()));
                        }
                      else
                        {
                          reac1->setParameterMapping(fp->getObjectName(),
                                                     reac0->getParameterMapping(fp->getObjectName())[0]);
                          reac2->setParameterMapping(fp->getObjectName(),
                                                     reac0->getParameterMapping(fp->getObjectName())[0]);
                        }

                      // Bug 2143: We need to replace any occurrence of the reaction parameter of the
                      // reversible reaction with its replacement in the forward or backwards reaction
                      {
                        CCopasiParameter * pOldParameter = reac0->getParameters().getParameter(fp->getObjectName());
                        CCopasiParameter * pNewParameter = reac1->getParameters().getParameter(fp->getObjectName());

                        if (pNewParameter == NULL)
                          {
                            pNewParameter = reac2->getParameters().getParameter(fp->getObjectName());
                          }

                        ParameterMap.push_back(std::make_pair(pOldParameter->getValueReference(), pNewParameter->getValueReference()));
                      }

                      break;

                    default:
                      reac1->setParameterMapping(fp->getObjectName(),
                                                 reac0->getParameterMapping(fp->getObjectName())[0]);
                      reac2->setParameterMapping(fp->getObjectName(),
                                                 reac0->getParameterMapping(fp->getObjectName())[0]);
                      break;
                  }
              }
          }

        reac1->compile();
        reac2->compile();

        std::string Old;
        std::string New;
        std::string Infix;

        // Bug 2143: We need to replace any occurrence of the reaction parameter of the
        // reversible reaction with its replacement in the forward or backwards reaction
        std::vector< std::pair< const CCopasiObject *, const CCopasiObject * > >::const_iterator itParameter = ParameterMap.begin();
        std::vector< std::pair< const CCopasiObject *, const CCopasiObject * > >::const_iterator endParameter = ParameterMap.end();

        for (; itParameter != endParameter; ++itParameter)
          {
            Old = "<" + itParameter->first->getCN() + ">";
            New = "<" + itParameter->second->getCN() + ">";

            // We need to find all expressions which reference the old parameter (first value of the itParameter)
            // Compartments (expression, initial expression)
            CCopasiVector< CCompartment >::iterator itComp = mCompartments.begin();
            CCopasiVector< CCompartment >::iterator endComp = mCompartments.end();

            for (; itComp != endComp; ++itComp)
              {
                const CExpression * pExpression = (*itComp)->getExpressionPtr();

                if (pExpression != NULL)
                  {
                    const CCopasiObject::DataObjectSet & Dependencies = pExpression->getDirectDependencies();

                    if (Dependencies.find(itParameter->first) != Dependencies.end())
                      {
                        Infix = (*itComp)->getExpression();
                        stringReplace(Infix, Old, New);
                        (*itComp)->setExpression(Infix);
                      }
                  }

                pExpression = (*itComp)->getInitialExpressionPtr();

                if (pExpression != NULL)
                  {
                    const CCopasiObject::DataObjectSet & Dependencies = pExpression->getDirectDependencies();

                    if (Dependencies.find(itParameter->first) != Dependencies.end())
                      {
                        Infix = (*itComp)->getInitialExpression();
                        stringReplace(Infix, Old, New);
                        (*itComp)->setInitialExpression(Infix);
                      }
                  }
              }

            // Species (expression, initial expression)
            CCopasiVector< CMetab >::iterator itMetab = mMetabolitesX.begin();
            CCopasiVector< CMetab >::iterator endMetab = mMetabolitesX.end();

            for (; itMetab != endMetab; ++itMetab)
              {
                const CExpression * pExpression = (*itMetab)->getExpressionPtr();

                if (pExpression != NULL)
                  {
                    const CCopasiObject::DataObjectSet & Dependencies = pExpression->getDirectDependencies();

                    if (Dependencies.find(itParameter->first) != Dependencies.end())
                      {
                        Infix = (*itMetab)->getExpression();
                        stringReplace(Infix, Old, New);
                        (*itMetab)->setExpression(Infix);
                      }
                  }

                pExpression = (*itMetab)->getInitialExpressionPtr();

                if (pExpression != NULL)
                  {
                    const CCopasiObject::DataObjectSet & Dependencies = pExpression->getDirectDependencies();

                    if (Dependencies.find(itParameter->first) != Dependencies.end())
                      {
                        Infix = (*itMetab)->getInitialExpression();
                        stringReplace(Infix, Old, New);
                        (*itMetab)->setInitialExpression(Infix);
                      }
                  }
              }

            // Model Quantities (expression, initial expression)
            CCopasiVector< CModelValue >::iterator itValue = mValues.begin();
            CCopasiVector< CModelValue >::iterator endValue = mValues.end();

            for (; itValue != endValue; ++itValue)
              {
                const CExpression * pExpression = (*itValue)->getExpressionPtr();

                if (pExpression != NULL)
                  {
                    const CCopasiObject::DataObjectSet & Dependencies = pExpression->getDirectDependencies();

                    if (Dependencies.find(itParameter->first) != Dependencies.end())
                      {
                        Infix = (*itValue)->getExpression();
                        stringReplace(Infix, Old, New);
                        (*itValue)->setExpression(Infix);
                      }
                  }

                pExpression = (*itValue)->getInitialExpressionPtr();

                if (pExpression != NULL)
                  {
                    const CCopasiObject::DataObjectSet & Dependencies = pExpression->getDirectDependencies();

                    if (Dependencies.find(itParameter->first) != Dependencies.end())
                      {
                        Infix = (*itValue)->getInitialExpression();
                        stringReplace(Infix, Old, New);
                        (*itValue)->setInitialExpression(Infix);
                      }
                  }
              }

            // Events (trigger, delay, assignments)
            CCopasiVector< CEvent >::iterator itEvent = mEvents.begin();
            CCopasiVector< CEvent >::iterator endEvent = mEvents.end();

            for (; itEvent != endEvent; ++itEvent)
              {
                const CExpression * pExpression = (*itEvent)->getTriggerExpressionPtr();

                if (pExpression != NULL)
                  {
                    const CCopasiObject::DataObjectSet & Dependencies = pExpression->getDirectDependencies();

                    if (Dependencies.find(itParameter->first) != Dependencies.end())
                      {
                        Infix = (*itEvent)->getTriggerExpression();
                        stringReplace(Infix, Old, New);
                        (*itEvent)->setTriggerExpression(Infix);
                      }
                  }

                pExpression = (*itEvent)->getDelayExpressionPtr();

                if (pExpression != NULL)
                  {
                    const CCopasiObject::DataObjectSet & Dependencies = pExpression->getDirectDependencies();

                    if (Dependencies.find(itParameter->first) != Dependencies.end())
                      {
                        Infix = (*itEvent)->getDelayExpression();
                        stringReplace(Infix, Old, New);
                        (*itEvent)->setDelayExpression(Infix);
                      }
                  }

                CCopasiVector< CEventAssignment >::iterator itAssignment = (*itEvent)->getAssignments().begin();
                CCopasiVector< CEventAssignment >::iterator endAssignment = (*itEvent)->getAssignments().end();

                for (; itAssignment != endAssignment; ++itAssignment)
                  {
                    pExpression = (*itAssignment)->getExpressionPtr();

                    if (pExpression != NULL)
                      {
                        const CCopasiObject::DataObjectSet & Dependencies = pExpression->getDirectDependencies();

                        if (Dependencies.find(itParameter->first) != Dependencies.end())
                          {
                            Infix = (*itAssignment)->getExpression();
                            stringReplace(Infix, Old, New);
                            (*itAssignment)->setExpression(Infix);
                          }
                      }
                  }
              }
          }

        // BUG 1848. We need to replace all references to the flux and particle flux
        // with the difference of the forward and backward reaction fluxes and particle fluxes, i.e,
        // flux = forward.flux - backward.flux

        Old = "<" + reac0->getFluxReference()->getCN() + ">";
        New = "(<" + reac1->getFluxReference()->getCN() + "> - <" + reac2->getFluxReference()->getCN() + ">)";

        // Find all objects which directly depend on the flux or particle flux.
        std::set< const CCopasiObject * > Flux;
        Flux.insert(reac0->getFluxReference());
        std::set< const CCopasiObject * > FluxDependents;

        // Initial Expression and Expression
        appendDependentCompartments(Flux, FluxDependents);
        appendDependentModelValues(Flux, FluxDependents);
        appendDependentMetabolites(Flux, FluxDependents);

        std::set< const CCopasiObject * >::iterator it = FluxDependents.begin();
        std::set< const CCopasiObject * >::iterator end = FluxDependents.end();

        for (; it != end; ++it)
          {
            CModelEntity * pEntity = static_cast< CModelEntity * >(const_cast< CCopasiObject * >(*it));

            // Expression
            Infix = pEntity->getExpression();

            if (stringReplace(Infix, Old, New))
              {
                pEntity->setExpression(Infix);
              }

            // Initial Expression
            if (pEntity->getStatus() != CModelEntity::ASSIGNMENT)
              {
                Infix = pEntity->getInitialExpression();

                if (stringReplace(Infix, Old, New))
                  {
                    pEntity->setInitialExpression(Infix);
                  }
              }
          }

        FluxDependents.clear();

        // Trigger and Assignments
        appendDependentEvents(Flux, FluxDependents);

        it = FluxDependents.begin();
        end = FluxDependents.end();

        for (; it != end; ++it)
          {
            CEvent * pEvent = static_cast< CEvent * >(const_cast< CCopasiObject * >(*it));

            // Trigger Expression
            Infix = pEvent->getTriggerExpression();

            if (stringReplace(Infix, Old, New))
              {
                pEvent->setTriggerExpression(Infix);
              }

            // Delay Expression
            Infix = pEvent->getDelayExpression();

            if (stringReplace(Infix, Old, New))
              {
                pEvent->setDelayExpression(Infix);
              }

            // Priority Expression
            Infix = pEvent->getPriorityExpression();

            if (stringReplace(Infix, Old, New))
              {
                pEvent->setPriorityExpression(Infix);
              }

            // Assignments
            CCopasiVector< CEventAssignment >::iterator itAssignment = pEvent->getAssignments().begin();
            CCopasiVector< CEventAssignment >::iterator endAssignment = pEvent->getAssignments().end();

            for (; itAssignment != endAssignment; ++itAssignment)
              {
                Infix = (*itAssignment)->getExpression();

                if (stringReplace(Infix, Old, New))
                  {
                    (*itAssignment)->setExpression(Infix);
                  }
              }
          }

        FluxDependents.clear();
        Flux.clear();

        // particleFlux = forward.particleFlux - backward.particleFlux
        Old = "<" + reac0->getParticleFluxReference()->getCN() + ">";
        New = "(<" + reac1->getParticleFluxReference()->getCN() + "> - <" + reac2->getParticleFluxReference()->getCN() + ">)";

        Flux.insert(reac0->getParticleFluxReference());

        // Initial Expression and Expression
        appendDependentCompartments(Flux, FluxDependents);
        appendDependentModelValues(Flux, FluxDependents);
        appendDependentMetabolites(Flux, FluxDependents);

        it = FluxDependents.begin();
        end = FluxDependents.end();

        for (; it != end; ++it)
          {
            CModelEntity * pEntity = static_cast< CModelEntity * >(const_cast< CCopasiObject * >(*it));

            // Expression
            Infix = pEntity->getExpression();

            if (stringReplace(Infix, Old, New))
              {
                pEntity->setExpression(Infix);
              }

            // Initial Expression
            if (pEntity->getStatus() != CModelEntity::ASSIGNMENT)
              {
                Infix = pEntity->getInitialExpression();

                if (stringReplace(Infix, Old, New))
                  {
                    pEntity->setInitialExpression(Infix);
                  }
              }
          }

        FluxDependents.clear();

        // Trigger and Assignments
        appendDependentEvents(Flux, FluxDependents);

        it = FluxDependents.begin();
        end = FluxDependents.end();

        for (; it != end; ++it)
          {
            CEvent * pEvent = static_cast< CEvent * >(const_cast< CCopasiObject * >(*it));

            // Trigger Expression
            Infix = pEvent->getTriggerExpression();

            if (stringReplace(Infix, Old, New))
              {
                pEvent->setTriggerExpression(Infix);
              }

            // Delay Expression
            Infix = pEvent->getDelayExpression();

            if (stringReplace(Infix, Old, New))
              {
                pEvent->setDelayExpression(Infix);
              }

            // Priority Expression
            Infix = pEvent->getPriorityExpression();

            if (stringReplace(Infix, Old, New))
              {
                pEvent->setPriorityExpression(Infix);
              }

            // Assignments
            CCopasiVector< CEventAssignment >::iterator itAssignment = pEvent->getAssignments().begin();
            CCopasiVector< CEventAssignment >::iterator endAssignment = pEvent->getAssignments().end();

            for (; itAssignment != endAssignment; ++itAssignment)
              {
                Infix = (*itAssignment)->getExpression();

                if (stringReplace(Infix, Old, New))
                  {
                    (*itAssignment)->setExpression(Infix);
                  }
              }
          }

        // Schedule the old reaction for removal.
        reactionsToDelete.push_back(reac0);
      }

  imax = reactionsToDelete.size();

  for (i = 0; i < imax; ++i)
    {
      delete reactionsToDelete[i];
    }

  if (imax != 0)
    {
      setCompileFlag(true);
    }

  return success;
}

CCompartment * CModel::createCompartment	(	const std::string &	name,
		const C_FLOAT64 &	volume = 1.0
	)

Add a compartment to the model

Parameters

const	std::string &name
const	C_FLOAT64 & volume (default 1.0)

Returns

bool success (false if failed)

Definition at line 2698 of file CModel.cpp.

References CCopasiVectorN< CType >::add(), C_INVALID_INDEX, CCopasiVectorN< CType >::getIndex(), mCompartments, mCompileIsNecessary, and CModelEntity::setInitialValue().

Referenced by CModelAdd::addCompartments(), SBMLImporter::createCCompartmentFromCompartment(), test000097::createModel(), CChemEqInterface::createNonExistingMetabs(), CReactionInterface::createOtherObjects(), CModelExpansion::duplicateCompartment(), CQSpecieDM::insertRows(), CQSpeciesDetail::slotBtnNew(), and test000058::test_bug1025_7().

{
  // check if there is already a volume with this name
  if (mCompartments.getIndex(name) != C_INVALID_INDEX)
    return NULL;

  CCompartment * cpt = new CCompartment(name);

  cpt->setInitialValue(volume);
  //cpt->setVolume(volume);

  if (!mCompartments.add(cpt, true))
    {
      delete cpt;
      return NULL;
    }

  mCompileIsNecessary = true;
  return cpt;
}

CEvent * CModel::createEvent

(

const std::string &

name

)

Add a new event to the model

Parameters

const

std::string &name

Returns

bool success (false if failed)

Definition at line 2928 of file CModel.cpp.

References CCopasiVectorN< CType >::add(), C_INVALID_INDEX, CCopasiVectorN< CType >::getIndex(), mCompileIsNecessary, and mEvents.

Referenced by CModelAdd::addEvents(), CCrossSectionTask::createEvent(), CModelExpansion::duplicateEvent(), and SBMLImporter::importEvent().

{
  if (mEvents.getIndex(name) != C_INVALID_INDEX)
    return NULL;

  CEvent * pEvent = new CEvent(name, this);

  if (!mEvents.add(pEvent, true))
    {
      delete pEvent;
      return NULL;
    }

  mCompileIsNecessary = true;
  return pEvent;
}

CMetab * CModel::createMetabolite	(	const std::string &	name,
		const std::string &	compartment,
		const C_FLOAT64 &	iconc = 1.0,
		const CModelEntity::Status &	status = CModelEntity::REACTIONS
	)

Add a metabolite to the model

Parameters

const	std::string & name
const	std::string & compartment
const	C_FLOAT64 & iconc (default 1.0)
const	CMetab::Status & status (default CMetab::METAB_VARIABL)

Returns

bool success (false if failed)

See Also

CMetab for more information

Definition at line 2622 of file CModel.cpp.

References CCopasiVector< T >::add(), C_INVALID_INDEX, CCopasiVector< T >::getIndex(), CCopasiVectorN< CType >::getIndex(), getMetabolites(), mCompartments, mCompileIsNecessary, mMetabolites, CMetab::refreshInitialValue(), CMetab::setInitialConcentration(), CMetab::setStatus(), and CCopasiVector< T >::size().

Referenced by CModelAdd::addMetabolites(), SBMLImporter::createCMetabFromSpecies(), CChemEqInterface::createNonExistingMetabs(), CModelExpansion::duplicateMetab(), CQSpecieDM::insertRows(), CQSpeciesDetail::slotBtnNew(), test000058::test_bug1025_8(), and test000059::test_unique_id_11().

{
  size_t Index;

  if (mCompartments.size() == 0)
    return NULL;

  if (compartment == "")
    Index = 0;
  else if ((Index = mCompartments.getIndex(compartment)) == C_INVALID_INDEX)
    return NULL;

  if (mCompartments[Index]->getMetabolites().getIndex(name) != C_INVALID_INDEX)
    return NULL;

  CMetab * pMetab = new CMetab(name);

  if (!mCompartments[Index]->addMetabolite(pMetab))
    {
      delete pMetab;
      return NULL;
    }

  pMetab->setStatus(status);
  pMetab->setInitialConcentration(iconc);
  pMetab->refreshInitialValue();

  if (!mMetabolites.add(pMetab))
    return NULL;

  mCompileIsNecessary = true;

  return pMetab;
}