#include <CMathContainer.h>

Inheritance diagram for CMathContainer:

Collaboration diagram for CMathContainer:

Classes
struct	sDiscontinuous

Public Member Functions
void	applyInitialValues ()

void	applyUpdateSequence (const CObjectInterface::UpdateSequence &updateSequence)

	CMathContainer (CModel &model)

	CMathContainer (const CMathContainer &src)

CEvaluationNode *	copyBranch (const CEvaluationNode *pSrc, const bool &replaceDiscontinuousNodes)

CEvaluationNode *	copyBranch (const CEvaluationNode pSrc, const CMath::Variables< CEvaluationNode > &variables, const bool &replaceDiscontinuousNodes)

void	fetchInitialState ()

void	fetchState ()

virtual CCopasiObjectName	getCN () const

const CVectorCore< C_FLOAT64 > &	getInitialState () const

CVectorCore< C_FLOAT64 > &	getInitialState ()

C_FLOAT64 *	getInitialValuePointer (const C_FLOAT64 *pValue) const

CMathObject *	getMathObject (const CObjectInterface *pObject) const

CMathObject *	getMathObject (const C_FLOAT64 *pDataValue) const

CMathObject *	getMathObject (const CCopasiObjectName &cn) const

const CModel &	getModel () const

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

const CVectorCore< C_FLOAT64 > &	getState () const

CVectorCore< C_FLOAT64 > &	getState ()

const CVectorCore< C_FLOAT64 > &	getStateReduced () const

CVectorCore< C_FLOAT64 > &	getStateReduced ()

const CVectorCore< C_FLOAT64 > &	getValues () const

CVectorCore< C_FLOAT64 > &	getValues ()

void	pushInitialState ()

void	pushState ()

CEvaluationNode *	replaceDiscontinuousNode (const CEvaluationNode pSrc, const std::vector< CEvaluationNode > &children)

void	setInitialState (const CVectorCore< C_FLOAT64 > &initialState)

void	setState (const CVectorCore< C_FLOAT64 > &state)

void	setStateReduced (const CVectorCore< C_FLOAT64 > &stateReduced)

void	setValues (const CVectorCore< C_FLOAT64 > &values)

void	updateInitialValues (const CModelParameter::Framework &framework)

void	updateSimulatedValues (const bool &useMoieties)

virtual	~CMathContainer ()

Public Member Functions inherited from CCopasiContainer
virtual bool	add (CCopasiObject *pObject, const bool &adopt=true)

	CCopasiContainer (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=CCopasiObject::Container)

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

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

virtual const objectMap &	getObjects () const

virtual std::string	getUnits () const

virtual const CCopasiObject *	getValueObject () const

virtual bool	remove (CCopasiObject *pObject)

virtual	~CCopasiContainer ()

Public Member Functions inherited from CCopasiObject
void	addDirectDependency (const CCopasiObject *pObject)

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

void	clearDirectDependencies ()

void	clearRefresh ()

bool	dependsOn (DataObjectSet candidates, const DataObjectSet &context=DataObjectSet()) const

void	getAllDependencies (DataObjectSet &dependencies, const DataObjectSet &context) const

virtual const DataObjectSet &	getDirectDependencies (const DataObjectSet &context=DataObjectSet()) const

virtual const std::string &	getKey () const

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

CCopasiDataModel *	getObjectDataModel ()

const CCopasiDataModel *	getObjectDataModel () const

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

const std::string &	getObjectName () const

CCopasiContainer *	getObjectParent () const

const std::string &	getObjectType () const

virtual const CObjectInterface::ObjectSet &	getPrerequisites () const

virtual Refresh *	getRefresh () const

UpdateMethod *	getUpdateMethod () const

virtual void *	getValuePointer () const

bool	hasCircularDependencies (DataObjectSet &candidates, DataObjectSet &verified, const DataObjectSet &context) const

bool	hasUpdateMethod () const

bool	isArray () const

bool	isContainer () const

bool	isDataModel () const

bool	isMatrix () const

bool	isNameVector () const

bool	isNonUniqueName () const

virtual bool	isPrerequisiteForContext (const CObjectInterface *pObject, const CMath::SimulationContextFlag &context, const CObjectInterface::ObjectSet &changedObjects) const

bool	isReference () const

bool	isRoot () const

bool	isSeparator () const

bool	isStaticString () const

bool	isValueBool () const

bool	isValueDbl () const

bool	isValueInt () const

bool	isValueInt64 () const

bool	isValueString () const

bool	isVector () const

virtual bool	mustBeDeleted (const DataObjectSet &deletedObjects) const

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

void	removeDirectDependency (const CCopasiObject *pObject)

void	setDirectDependencies (const DataObjectSet &directDependencies)

bool	setObjectName (const std::string &name)

virtual bool	setObjectParent (const CCopasiContainer *pParent)

void	setObjectValue (const C_FLOAT64 &value)

void	setObjectValue (const C_INT32 &value)

void	setObjectValue (const bool &value)

template<class CType >
void	setRefresh (CType pType, void(CType::method)(void))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const C_FLOAT64 &))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const C_INT32 &))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const bool &))

virtual	~CCopasiObject ()

Public Member Functions inherited from CObjectInterface
	CObjectInterface ()

virtual	~CObjectInterface ()

Private Member Functions
void	allocate ()

	CMathContainer ()

bool	compileDiscreteChanges ()

bool	compileEvents ()

bool	compileObjects ()

void	createApplyInitialValuesSequence ()

void	createDependencyGraphs ()

void	createDiscontinuityDataEvent (const CEvaluationNode *pNode)

void	createDiscontinuityEvents ()

void	createDiscontinuityEvents (const CEvaluationTree *pTree)

std::string	createDiscontinuityTriggerInfix (const CEvaluationNode *pNode)

CEvaluationNode *	createNodeFromObject (const CObjectInterface *pMathObject)

CEvaluationNode *	createNodeFromValue (const C_FLOAT64 *pDataValue)

void	createSynchronizeInitialValuesSequence ()

void	createUpdateSimulationValuesSequence ()

void	init ()

void	initializeDiscontinuousCreationPointer ()

void	initializeEvents (CMath::sPointers &pointers)

void	initializeMathObjects (const std::vector< const CModelEntity * > &entities, const CMath::SimulationType &simulationType, CMath::sPointers &pointers)

void	initializeMathObjects (const std::vector< const CCopasiObject * > &parameters, CMath::sPointers &p)

void	initializeMathObjects (const CCopasiVector< CReaction > &reactions, CMath::sPointers &p)

void	initializeMathObjects (const CCopasiVector< CMoiety > &moieties, CMath::sPointers &p)

void	initializeObjects (CMath::sPointers &pointers)

void	initializePointers (CMath::sPointers &pointers)

void	map (CCopasiObject pDataObject, CMathObject pMathObject)

Static Private Member Functions
static CMath::EntityType	getEntityType (const CModelEntity *pEntity)

static bool	hasDependencies (const CCopasiObject *pObject)

Private Attributes
CObjectInterface::UpdateSequence	mApplyInitialValuesSequence

size_t	mAssignmentCount

sDiscontinuous	mCreateDiscontinuousPointer

std::map< CCopasiObject , CMathObject >	mDataObject2MathObject

std::map< C_FLOAT64 , CMathObject >	mDataValue2MathObject

size_t	mDependentCount

CVectorCore< C_FLOAT64 >	mDependentMasses

CCopasiVector< CEvent >	mDiscontinuityEvents

std::map< std::string, CMathObject * >	mDiscontinuityInfix2Object

CVectorCore< C_FLOAT64 >	mDiscontinuous

CVectorCore< C_FLOAT64 >	mEventAssignments

CVectorCore< C_FLOAT64 >	mEventDelays

CVectorCore< C_FLOAT64 >	mEventPriorities

CVectorCore< C_FLOAT64 >	mEventRoots

CVectorCore< C_FLOAT64 >	mEventRootStates

CVector< CMathEventN >	mEvents

size_t	mEventTargetCount

CVectorCore< C_FLOAT64 >	mEventTriggers

CVectorCore< C_FLOAT64 >	mExtensiveRates

CVectorCore< C_FLOAT64 >	mExtensiveValues

size_t	mFixedCount

CVectorCore< C_FLOAT64 >	mFluxes

size_t	mIndependentCount

CMathDependencyGraph	mInitialDependencies

CVectorCore< C_FLOAT64 >	mInitialEventTriggers

CVectorCore< C_FLOAT64 >	mInitialExtensiveRates

CVectorCore< C_FLOAT64 >	mInitialExtensiveValues

CVectorCore< C_FLOAT64 >	mInitialFluxes

CVectorCore< C_FLOAT64 >	mInitialIntensiveRates

CVectorCore< C_FLOAT64 >	mInitialIntensiveValues

CVectorCore< C_FLOAT64 >	mInitialParticleFluxes

CVectorCore< C_FLOAT64 >	mInitialState

CObjectInterface::ObjectSet	mInitialStateValueExtensive

CObjectInterface::ObjectSet	mInitialStateValueIntensive

CVectorCore< C_FLOAT64 >	mInitialTotalMasses

CVectorCore< C_FLOAT64 >	mIntensiveRates

CVectorCore< C_FLOAT64 >	mIntensiveValues

CVector< CMathObject >	mObjects

size_t	mODECount

CVectorCore< C_FLOAT64 >	mParticleFluxes

const CObjectInterface *	mpAvogadro

CModel *	mpModel

const CObjectInterface *	mpQuantity2NumberFactor

CVectorCore< C_FLOAT64 >	mPropensities

CVector< CMathReaction >	mReactions

CObjectInterface::ObjectSet	mReducedStateValues

CObjectInterface::ObjectSet	mSimulationRequiredValues

CObjectInterface::UpdateSequence	mSimulationValuesSequence

CObjectInterface::UpdateSequence	mSimulationValuesSequenceReduced

CVectorCore< C_FLOAT64 >	mState

CVectorCore< C_FLOAT64 >	mStateReduced

CObjectInterface::ObjectSet	mStateValues

CObjectInterface::UpdateSequence	mSynchronizeInitialValuesSequenceExtensive

CObjectInterface::UpdateSequence	mSynchronizeInitialValuesSequenceIntensive

CVectorCore< C_FLOAT64 >	mTotalMasses

CMathDependencyGraph	mTransientDependencies

std::map< std::string, CMathEventN * >	mTriggerInfix2Event

CVector< C_FLOAT64 >	mValues

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

Static Public Member Functions inherited from CCopasiObject
static std::vector< Refresh * >	buildUpdateSequence (const DataObjectSet &objects, const DataObjectSet &uptoDateObjects, const DataObjectSet &context=DataObjectSet())

static void	setRenameHandler (CRenameHandler *rh)

Static Public Attributes inherited from CCopasiContainer
static const std::vector < CCopasiContainer * >	EmptyList

Protected Types inherited from CCopasiObject
enum	Flag { Container = 0x1, Vector = 0x2, Matrix = 0x4, NameVector = 0x8, Reference = 0x10, ValueBool = 0x20, ValueInt = 0x40, ValueInt64 = 0x80, ValueDbl = 0x100, NonUniqueName = 0x200, StaticString = 0x400, ValueString = 0x800, Separator = 0x1000, ModelEntity = 0x2000, Array = 0x4000, DataModel = 0x8000, Root = 0x10000, Gui = 0x20000 }

Protected Member Functions inherited from CCopasiContainer
template<class CType >
CCopasiObject *	addMatrixReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

template<class CType >
CCopasiObject *	addObjectReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

template<class CType >
CCopasiObject *	addVectorReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

void	initObjects ()

Protected Member Functions inherited from CCopasiObject
	CCopasiObject ()

	CCopasiObject (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=0)

Protected Attributes inherited from CCopasiContainer
objectMap	mObjects

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

Detailed Description

Definition at line 28 of file CMathContainer.h.

Constructor & Destructor Documentation

CMathContainer::CMathContainer ( )

private

Default Constructor

Definition at line 17 of file CMathContainer.cpp.

                               :
   CCopasiContainer("Math Container", NULL, "CMathContainer"),
   mpModel(NULL),
   mpAvogadro(NULL),
   mpQuantity2NumberFactor(NULL),
   mValues(),
   mInitialExtensiveValues(),
   mInitialIntensiveValues(),
   mInitialExtensiveRates(),
   mInitialIntensiveRates(),
   mInitialParticleFluxes(),
   mInitialFluxes(),
   mInitialTotalMasses(),
   mInitialEventTriggers(),
   mExtensiveValues(),
   mIntensiveValues(),
   mExtensiveRates(),
   mIntensiveRates(),
   mParticleFluxes(),
   mFluxes(),
   mTotalMasses(),
   mEventTriggers(),
   mEventDelays(),
   mEventPriorities(),
   mEventAssignments(),
   mEventRoots(),
   mEventRootStates(),
   mPropensities(),
   mDependentMasses(),
   mDiscontinuous(),
   mFixedCount(0),
   mEventTargetCount(0),
   mODECount(0),
   mIndependentCount(0),
   mDependentCount(0),
   mAssignmentCount(0),
   mInitialState(),
   mState(),
   mStateReduced(),
   mInitialDependencies(),
   mTransientDependencies(),
   mSynchronizeInitialValuesSequenceExtensive(),
   mSynchronizeInitialValuesSequenceIntensive(),
   mApplyInitialValuesSequence(),
   mSimulationValuesSequence(),
   mSimulationValuesSequenceReduced(),
   mInitialStateValueExtensive(),
   mInitialStateValueIntensive(),
   mStateValues(),
   mReducedStateValues(),
   mSimulationRequiredValues(),
   mObjects(),
   mEvents(),
   mReactions(),
   mCreateDiscontinuousPointer(),
   mDataObject2MathObject(),
   mDataValue2MathObject(),
   mDiscontinuityEvents("Discontinuities", this),
   mDiscontinuityInfix2Object(),
   mTriggerInfix2Event()
 {}

CMathContainer::CMathContainer ( CModel & model )

Specific Constructor

Parameters

CModel & model

Definition at line 79 of file CMathContainer.cpp.

References CCopasiContainer::getObject(), init(), mpAvogadro, mpModel, mpQuantity2NumberFactor, and CCopasiObject::setObjectParent().

                                             :
   CCopasiContainer("Math Container", NULL, "CMathContainer"),
   mpModel(&model),
   mpAvogadro(NULL),
   mpQuantity2NumberFactor(NULL),
   mValues(),
   mInitialExtensiveValues(),
   mInitialIntensiveValues(),
   mInitialExtensiveRates(),
   mInitialIntensiveRates(),
   mInitialParticleFluxes(),
   mInitialFluxes(),
   mInitialTotalMasses(),
   mInitialEventTriggers(),
   mExtensiveValues(),
   mIntensiveValues(),
   mExtensiveRates(),
   mIntensiveRates(),
   mParticleFluxes(),
   mFluxes(),
   mTotalMasses(),
   mEventTriggers(),
   mEventDelays(),
   mEventPriorities(),
   mEventAssignments(),
   mEventRoots(),
   mEventRootStates(),
   mPropensities(),
   mDependentMasses(),
   mDiscontinuous(),
   mFixedCount(0),
   mEventTargetCount(0),
   mODECount(0),
   mIndependentCount(0),
   mDependentCount(0),
   mAssignmentCount(0),
   mInitialState(),
   mState(),
   mStateReduced(),
   mInitialDependencies(),
   mTransientDependencies(),
   mSynchronizeInitialValuesSequenceExtensive(),
   mSynchronizeInitialValuesSequenceIntensive(),
   mApplyInitialValuesSequence(),
   mSimulationValuesSequence(),
   mSimulationValuesSequenceReduced(),
   mInitialStateValueExtensive(),
   mInitialStateValueIntensive(),
   mStateValues(),
   mReducedStateValues(),
   mSimulationRequiredValues(),
   mObjects(),
   mEvents(),
   mReactions(),
   mDataObject2MathObject(),
   mDataValue2MathObject(),
   mDiscontinuityEvents("Discontinuities", this),
   mDiscontinuityInfix2Object(),
   mTriggerInfix2Event()
 {
   // We do not want the model to know about the math container therefore we
   // do not use &model in the constructor of CCopasiContainer
   setObjectParent(mpModel);
 
   mpAvogadro = mpModel->getObject(CCopasiObjectName("Reference=Avogadro Constant"));
   mpQuantity2NumberFactor = mpModel->getObject(CCopasiObjectName("Reference=Quantity Conversion Factor"));
 
   init();
 }

CMathContainer::CMathContainer ( const CMathContainer & src )

Copy constructor

Parameters

const CMathContainer & src

Definition at line 149 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, CMathObject::copy(), CMathReaction::copy(), CMathEventN::copy(), createDependencyGraphs(), mDataObject2MathObject, mDataValue2MathObject, mDependentMasses, mDiscontinuous, mEventAssignments, mEventDelays, mEventPriorities, mEventRoots, mEventRootStates, mEvents, mEventTriggers, mExtensiveRates, mExtensiveValues, mFluxes, mInitialEventTriggers, mInitialExtensiveRates, mInitialExtensiveValues, mInitialFluxes, mInitialIntensiveRates, mInitialIntensiveValues, mInitialParticleFluxes, mInitialState, mInitialTotalMasses, mIntensiveRates, mIntensiveValues, mObjects, mParticleFluxes, mpModel, mPropensities, mReactions, mState, mStateReduced, mTotalMasses, mValues, CCopasiObject::setObjectParent(), and CVectorCore< CType >::size().

                                                         :
   CCopasiContainer(src, NULL),
   mpModel(src.mpModel),
   mpAvogadro(src.mpAvogadro),
   mpQuantity2NumberFactor(src.mpQuantity2NumberFactor),
   mValues(src.mValues),
   mInitialExtensiveValues(),
   mInitialIntensiveValues(),
   mInitialExtensiveRates(),
   mInitialIntensiveRates(),
   mInitialParticleFluxes(),
   mInitialFluxes(),
   mInitialTotalMasses(),
   mInitialEventTriggers(),
   mExtensiveValues(),
   mIntensiveValues(),
   mExtensiveRates(),
   mIntensiveRates(),
   mParticleFluxes(),
   mFluxes(),
   mTotalMasses(),
   mEventTriggers(),
   mEventDelays(),
   mEventPriorities(),
   mEventAssignments(),
   mEventRoots(),
   mEventRootStates(),
   mPropensities(),
   mDependentMasses(),
   mDiscontinuous(),
   mFixedCount(src.mFixedCount),
   mEventTargetCount(src.mEventTargetCount),
   mODECount(src.mODECount),
   mIndependentCount(src.mIndependentCount),
   mDependentCount(src.mDependentCount),
   mAssignmentCount(src.mAssignmentCount),
   mInitialState(),
   mState(),
   mStateReduced(),
   mInitialDependencies(),
   mTransientDependencies(),
   mSynchronizeInitialValuesSequenceExtensive(),
   mSynchronizeInitialValuesSequenceIntensive(),
   mApplyInitialValuesSequence(),
   mSimulationValuesSequence(),
   mSimulationValuesSequenceReduced(),
   mInitialStateValueExtensive(),
   mInitialStateValueIntensive(),
   mStateValues(),
   mReducedStateValues(),
   mSimulationRequiredValues(),
   mObjects(src.mObjects.size()),
   mEvents(src.mEvents.size()),
   mReactions(src.mReactions.size()),
   mDataObject2MathObject(),
   mDataValue2MathObject(),
   mDiscontinuityEvents("Discontinuities", this),
   mDiscontinuityInfix2Object(),
   mTriggerInfix2Event()
 {
   // We do not want the model to know about the math container therefore we
   // do not use &model in the constructor of CCopasiContainer
   setObjectParent(mpModel);
 
   // Determine the offsets
   // We have to cast all pointers to size_t to avoid pointer overflow.
   size_t ValueOffset = ((size_t) mValues.array()) - ((size_t) src.mValues.array());
   size_t ObjectOffset = ((size_t) mObjects.array()) - ((size_t) src.mObjects.array());
 
   mInitialExtensiveValues = CVectorCore< C_FLOAT64 >(src.mInitialExtensiveValues.size(),
                             (C_FLOAT64 *)((size_t) src.mInitialExtensiveValues.array() + ValueOffset));
   mInitialIntensiveValues = CVectorCore< C_FLOAT64 >(src.mInitialIntensiveValues.size(),
                             (C_FLOAT64 *)((size_t) src.mInitialIntensiveValues.array() + ValueOffset));
   mInitialExtensiveRates = CVectorCore< C_FLOAT64 >(src.mInitialExtensiveRates.size(),
                            (C_FLOAT64 *)((size_t) src.mInitialExtensiveRates.array() + ValueOffset));
   mInitialIntensiveRates = CVectorCore< C_FLOAT64 >(src.mInitialIntensiveRates.size(),
                            (C_FLOAT64 *)((size_t) src.mInitialIntensiveRates.array() + ValueOffset));
   mInitialParticleFluxes = CVectorCore< C_FLOAT64 >(src.mInitialParticleFluxes.size(),
                            (C_FLOAT64 *)((size_t) src.mInitialParticleFluxes.array() + ValueOffset));
   mInitialFluxes = CVectorCore< C_FLOAT64 >(src.mInitialFluxes.size(),
                    (C_FLOAT64 *)((size_t) src.mInitialFluxes.array() + ValueOffset));
   mInitialTotalMasses = CVectorCore< C_FLOAT64 >(src.mInitialTotalMasses.size(),
                         (C_FLOAT64 *)((size_t) src.mInitialTotalMasses.array() + ValueOffset));
   mInitialEventTriggers = CVectorCore< C_FLOAT64 >(src.mInitialEventTriggers.size(),
                           (C_FLOAT64 *)((size_t) src.mInitialEventTriggers.array() + ValueOffset));
 
   mExtensiveValues = CVectorCore< C_FLOAT64 >(src.mExtensiveValues.size(),
                      (C_FLOAT64 *)((size_t) src.mExtensiveValues.array() + ValueOffset));
   mIntensiveValues = CVectorCore< C_FLOAT64 >(src.mIntensiveValues.size(),
                      (C_FLOAT64 *)((size_t) src.mIntensiveValues.array() + ValueOffset));
   mExtensiveRates = CVectorCore< C_FLOAT64 >(src.mExtensiveRates.size(),
                     (C_FLOAT64 *)((size_t) src.mExtensiveRates.array() + ValueOffset));
   mIntensiveRates = CVectorCore< C_FLOAT64 >(src.mIntensiveRates.size(),
                     (C_FLOAT64 *)((size_t) src.mIntensiveRates.array() + ValueOffset));
   mParticleFluxes = CVectorCore< C_FLOAT64 >(src.mParticleFluxes.size(),
                     (C_FLOAT64 *)((size_t) src.mParticleFluxes.array() + ValueOffset));
   mFluxes = CVectorCore< C_FLOAT64 >(src.mFluxes.size(),
                                      (C_FLOAT64 *)((size_t) src.mFluxes.array() + ValueOffset));
   mTotalMasses = CVectorCore< C_FLOAT64 >(src.mTotalMasses.size(),
                                           (C_FLOAT64 *)((size_t) src.mTotalMasses.array() + ValueOffset));
   mEventTriggers = CVectorCore< C_FLOAT64 >(src.mEventTriggers.size(),
                    (C_FLOAT64 *)((size_t) src.mEventTriggers.array() + ValueOffset));
 
   mEventDelays = CVectorCore< C_FLOAT64 >(src.mEventDelays.size(),
                                           (C_FLOAT64 *)((size_t) src.mEventDelays.array() + ValueOffset));
   mEventPriorities = CVectorCore< C_FLOAT64 >(src.mEventPriorities.size(),
                      (C_FLOAT64 *)((size_t) src.mEventPriorities.array() + ValueOffset));
   mEventAssignments = CVectorCore< C_FLOAT64 >(src.mEventAssignments.size(),
                       (C_FLOAT64 *)((size_t) src.mEventAssignments.array() + ValueOffset));
   mEventRoots = CVectorCore< C_FLOAT64 >(src.mEventRoots.size(),
                                          (C_FLOAT64 *)((size_t) src.mEventRoots.array() + ValueOffset));
   mEventRootStates = CVectorCore< C_FLOAT64 >(src.mEventRootStates.size(),
                      (C_FLOAT64 *)((size_t) src.mEventRootStates.array() + ValueOffset));
   mPropensities = CVectorCore< C_FLOAT64 >(src.mPropensities.size(),
                   (C_FLOAT64 *)((size_t) src.mPropensities.array() + ValueOffset));
   mDependentMasses = CVectorCore< C_FLOAT64 >(src.mDependentMasses.size(),
                      (C_FLOAT64 *)((size_t) src.mDependentMasses.array() + ValueOffset));
   mDiscontinuous = CVectorCore< C_FLOAT64 >(src.mDiscontinuous.size(),
                    (C_FLOAT64 *)((size_t) src.mDiscontinuous.array() + ValueOffset));
 
   mInitialState = CVectorCore< C_FLOAT64 >(src.mInitialState.size(),
                   (C_FLOAT64 *)((size_t) src.mInitialState.array() + ValueOffset));
   mState = CVectorCore< C_FLOAT64 >(src.mState.size(),
                                     (C_FLOAT64 *)((size_t) src.mState.array() + ValueOffset));
   mStateReduced = CVectorCore< C_FLOAT64 >(src.mStateReduced.size(),
                   (C_FLOAT64 *)((size_t) src.mStateReduced.array() + ValueOffset));
 
   // Update the mappings
   std::map< CCopasiObject *, CMathObject * >::const_iterator itData = src.mDataObject2MathObject.begin();
   std::map< CCopasiObject *, CMathObject * >::const_iterator endData = src.mDataObject2MathObject.end();
 
   for (; itData != endData; ++itData)
     {
       mDataObject2MathObject[itData->first] = (CMathObject *)(((size_t) itData->second) + ObjectOffset);
     }
 
   std::map< C_FLOAT64 *, CMathObject * >::const_iterator itValue = src.mDataValue2MathObject.begin();
   std::map< C_FLOAT64 *, CMathObject * >::const_iterator endValue = src.mDataValue2MathObject.end();
 
   for (; itValue != endValue; ++itValue)
     {
       mDataValue2MathObject[itValue->first] = (CMathObject *)(((size_t) itValue->second) + ObjectOffset);
     }
 
   // Copy the objects
   CMathObject * pObject = mObjects.array();
   CMathObject * pObjectEnd = pObject + mObjects.size();
   const CMathObject * pObjectSrc = src.mObjects.array();
 
   for (; pObject != pObjectEnd; ++pObject, ++pObjectSrc)
     {
       pObject->copy(*pObjectSrc, *this, ValueOffset, ObjectOffset);
     }
 
   CMathEventN * pEvent = mEvents.array();
   CMathEventN * pEventEnd = pEvent + mEvents.size();
   const CMathEventN * pEventSrc = src.mEvents.array();
 
   for (; pEvent != pEventEnd; ++pEvent, ++pEventSrc)
     {
       pEvent->copy(*pEventSrc, *this, ValueOffset, ObjectOffset);
     }
 
   CMathReaction * pReaction = mReactions.array();
   CMathReaction * pReactionEnd = pReaction + mReactions.size();
   const CMathReaction * pReactionSrc = src.mReactions.array();
 
   for (; pReaction != pReactionEnd; ++pReaction, ++pReactionSrc)
     {
       pReaction->copy(*pReactionSrc, *this, ValueOffset, ObjectOffset);
     }
 
   createDependencyGraphs();
 }

CMathContainer::~CMathContainer ( )

virtual

Destructor

Definition at line 324 of file CMathContainer.cpp.

325 {}

Member Function Documentation

void CMathContainer::allocate ( )

private

Allocate the memory for objects and values

Definition at line 850 of file CMathContainer.cpp.

References CObjectLists::ALL_LOCAL_PARAMETER_VALUES, CMathEventN::allocate(), CVectorCore< CType >::array(), CCopasiVector< T >::begin(), C_FLOAT64, createDiscontinuityEvents(), CCopasiVector< T >::end(), CMathEventN::getAssignments(), CModel::getEvents(), CObjectLists::getListOfConstObjects(), CModel::getMoieties(), CModel::getNumMetabs(), CModel::getReactions(), CMathEventN::CTrigger::getRoots(), CModel::getStateTemplate(), CMathEventN::getTrigger(), mDependentCount, mDependentMasses, mDiscontinuityEvents, mDiscontinuous, mEventAssignments, mEventDelays, mEventPriorities, mEventRoots, mEventRootStates, mEvents, mEventTargetCount, mEventTriggers, mExtensiveRates, mExtensiveValues, mFixedCount, mFluxes, mIndependentCount, mInitialEventTriggers, mInitialExtensiveRates, mInitialExtensiveValues, mInitialFluxes, mInitialIntensiveRates, mInitialIntensiveValues, mInitialParticleFluxes, mInitialState, mInitialTotalMasses, mIntensiveRates, mIntensiveValues, mObjects, mODECount, mParticleFluxes, mpModel, mPropensities, mState, mStateReduced, mTotalMasses, mValues, CVector< CType >::resize(), CVectorCore< CType >::size(), CStateTemplate::size(), and CCopasiVector< T >::size().

Referenced by init().

 {
   size_t nLocalReactionParameters =
     CObjectLists::getListOfConstObjects(CObjectLists::ALL_LOCAL_PARAMETER_VALUES, mpModel).size();
   size_t nExtensiveValues =  mpModel->getStateTemplate().size() + nLocalReactionParameters;
   size_t nIntensiveValues = mpModel->getNumMetabs();
 
   size_t nReactions = mpModel->getReactions().size();
   size_t nMoieties = mpModel->getMoieties().size();
 
   size_t nDiscontinuities = 0;
   size_t nEvents = 0;
   size_t nEventAssignments = 0;
   size_t nEventRoots = 0;
 
   // Determine the space requirements for events.
   // We need to create events for nodes which are capable of introducing
   // discontinuous changes.
   createDiscontinuityEvents();
   nDiscontinuities += mDiscontinuityEvents.size();
   nEvents += nDiscontinuities;
 
   // User defined events
   const CCopasiVector< CEvent > & Events = mpModel->getEvents();
   CCopasiVector< CEvent >::const_iterator itEvent = Events.begin();
   CCopasiVector< CEvent >::const_iterator endEvent = Events.end();
 
   nEvents += Events.size();
   mEvents.resize(nEvents);
 
   CMathEventN * pEvent = mEvents.array();
 
   for (; itEvent != endEvent; ++itEvent, ++pEvent)
     {
       CMathEventN::allocate(pEvent, *itEvent, *this);
 
       nEventRoots += pEvent->getTrigger().getRoots().size();
       nEventAssignments += pEvent->getAssignments().size();
     }
 
   itEvent = mDiscontinuityEvents.begin();
   endEvent = mDiscontinuityEvents.end();
 
   for (; itEvent != endEvent; ++itEvent, ++pEvent)
     {
       CMathEventN::allocate(pEvent, *itEvent, *this);
       nEventRoots += pEvent->getTrigger().getRoots().size();
 
       // We do not have to allocate an assignment as discontinuity object suffices
       // as target and assignment expression.
     }
 
   mValues.resize(4 * (nExtensiveValues + nIntensiveValues) +
                  5 * nReactions +
                  3 * nMoieties +
                  nDiscontinuities +
                  4 * nEvents + nEventAssignments + 2 * nEventRoots);
   mValues = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
 
   C_FLOAT64 * pArray = mValues.array();
 
   mInitialExtensiveValues = CVectorCore< C_FLOAT64 >(nExtensiveValues, pArray);
   pArray += nExtensiveValues;
   mInitialIntensiveValues = CVectorCore< C_FLOAT64 >(nIntensiveValues, pArray);
   pArray += nIntensiveValues;
   mInitialExtensiveRates = CVectorCore< C_FLOAT64 >(nExtensiveValues, pArray);
   pArray += nExtensiveValues;
   mInitialIntensiveRates = CVectorCore< C_FLOAT64 >(nIntensiveValues, pArray);
   pArray += nIntensiveValues;
   mInitialParticleFluxes = CVectorCore< C_FLOAT64 >(nReactions, pArray);
   pArray += nReactions;
   mInitialFluxes = CVectorCore< C_FLOAT64 >(nReactions, pArray);
   pArray += nReactions;
   mInitialTotalMasses = CVectorCore< C_FLOAT64 >(nMoieties, pArray);
   pArray += nMoieties;
   mInitialEventTriggers = CVectorCore< C_FLOAT64 >(nEvents, pArray);
   pArray += nEvents;
 
   mExtensiveValues = CVectorCore< C_FLOAT64 >(nExtensiveValues, pArray);
   pArray += nExtensiveValues;
   mIntensiveValues = CVectorCore< C_FLOAT64 >(nIntensiveValues, pArray);
   pArray += nIntensiveValues;
   mExtensiveRates = CVectorCore< C_FLOAT64 >(nExtensiveValues, pArray);
   pArray += nExtensiveValues;
   mIntensiveRates = CVectorCore< C_FLOAT64 >(nIntensiveValues, pArray);
   pArray += nIntensiveValues;
   mParticleFluxes = CVectorCore< C_FLOAT64 >(nReactions, pArray);
   pArray += nReactions;
   mFluxes = CVectorCore< C_FLOAT64 >(nReactions, pArray);
   pArray += nReactions;
   mTotalMasses = CVectorCore< C_FLOAT64 >(nMoieties, pArray);
   pArray += nMoieties;
   mEventTriggers = CVectorCore< C_FLOAT64 >(nEvents, pArray);
   pArray += nEvents;
 
   mEventDelays = CVectorCore< C_FLOAT64 >(nEvents, pArray);
   pArray += nEvents;
   mEventPriorities = CVectorCore< C_FLOAT64 >(nEvents, pArray);
   pArray += nEvents;
   mEventAssignments = CVectorCore< C_FLOAT64 >(nEventAssignments, pArray);
   pArray += nEventAssignments;
   mEventRoots = CVectorCore< C_FLOAT64 >(nEventRoots, pArray);
   pArray += nEventRoots;
   mEventRootStates = CVectorCore< C_FLOAT64 >(nEventRoots, pArray);
   pArray += nEventRoots;
   mPropensities = CVectorCore< C_FLOAT64 >(nReactions, pArray);
   pArray += nReactions;
   mDependentMasses = CVectorCore< C_FLOAT64 >(nMoieties, pArray);
   pArray += nMoieties;
   mDiscontinuous = CVectorCore< C_FLOAT64 >(nDiscontinuities, pArray);
   pArray += nDiscontinuities;
 
   assert(pArray == mValues.array() + mValues.size());
 
   mObjects.resize(mValues.size());
 
   mInitialState = CVectorCore< C_FLOAT64 >(mInitialExtensiveRates.array() - mValues.array(),
                   mValues.array());
   mState = CVectorCore< C_FLOAT64 >(mODECount + mIndependentCount + mDependentCount,
                                     mExtensiveValues.array() + mFixedCount + mEventTargetCount);
   mStateReduced = CVectorCore< C_FLOAT64 >(mODECount + mIndependentCount,
                   mExtensiveValues.array() + mFixedCount + mEventTargetCount);
 }

void CMathContainer::applyInitialValues ( )

Set the transient values to the initial values and calculate all dependent values. Please call updateInitialValues before calling this method to assure that all values are up to date.

Definition at line 409 of file CMathContainer.cpp.

References applyUpdateSequence(), CVectorCore< CType >::array(), C_FLOAT64, mApplyInitialValuesSequence, mExtensiveValues, and mInitialExtensiveValues.

 {
   C_FLOAT64 * pInitial = mInitialExtensiveValues.array();
   C_FLOAT64 * pTransient = mExtensiveValues.array();
 
   memcpy(pTransient, pInitial, (pTransient - pInitial) * sizeof(C_FLOAT64));
 
   applyUpdateSequence(mApplyInitialValuesSequence);
 }

void CMathContainer::applyUpdateSequence ( const CObjectInterface::UpdateSequence & updateSequence )

Apply the given update sequence to the mathematical objects in the container

Parameters

const CObjectInterface::UpdateSequence & updateSequence

Definition at line 431 of file CMathContainer.cpp.

References CMathObject::calculate().

Referenced by applyInitialValues(), updateInitialValues(), and updateSimulatedValues().

 {
   UpdateSequence::const_iterator it = updateSequence.begin();
   UpdateSequence::const_iterator end = updateSequence.end();
 
   for (; it != end; ++it)
     {
       static_cast< CMathObject * >(*it)->calculate();
     }
 }

bool CMathContainer::compileDiscreteChanges ( )

private

Convert nodes which generate discrete changes into events and compiles them.

bool CMathContainer::compileEvents ( )

private

Compile the events

Definition at line 1144 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), CCopasiVector< T >::begin(), CMathEventN::compile(), CCopasiVector< T >::end(), CModel::getEvents(), mEvents, and mpModel.

Referenced by init().

 {
   bool success = true;
 
   CMathEventN * pItEvent = mEvents.array();
   CCopasiVector< CEvent >::const_iterator itEvent = mpModel->getEvents().begin();
   CCopasiVector< CEvent >::const_iterator endEvent = mpModel->getEvents().end();
 
   for (; itEvent != endEvent; ++pItEvent, ++itEvent)
     {
       success &= pItEvent->compile(*itEvent, *this);
     }
 
   // Events representing discontinuities are already compiled.
 
   return success;
 }

bool CMathContainer::compileObjects ( )

private

Compile the objects

Definition at line 1129 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), CMathObject::compile(), mObjects, and CVectorCore< CType >::size().

Referenced by init().

 {
   bool success = true;
 
   CMathObject *pObject = mObjects.array();
   CMathObject *pObjectEnd = pObject + mObjects.size();
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       success &= pObject->compile(*this);
     }
 
   return success;
 }

CEvaluationNode * CMathContainer::copyBranch	(	const CEvaluationNode *	pSrc,
		const bool &	replaceDiscontinuousNodes
	)

Copy a node and all its children. Nodes are converted to suite the math container, i.e., objects nodes point to math object or numbers, function calls are expanded and discrete nodes are replaced by object node pointing to newly created math objects, which are and targets of automatically generated events.

Parameters

const	CEvaluationNode * pSrc
const	bool & replaceDiscontinuousNodes

Returns: CEvaluationNode * pCopy

Definition at line 657 of file CMathContainer.cpp.

Referenced by CMathExpression::CMathExpression(), CMathEventN::CTrigger::compile(), and copyBranch().

 {
   CMath::Variables< CEvaluationNode * > Variables;
 
   return copyBranch(pSrc, Variables, replaceDiscontinuousNodes);
 }

CEvaluationNode * CMathContainer::copyBranch	(	const CEvaluationNode *	pSrc,
		const CMath::Variables< CEvaluationNode * > &	variables,
		const bool &	replaceDiscontinuousNodes
	)

Copy a node and all its children. Nodes are converted to suite the math container, i.e., objects nodes point to math object or numbers, function calls are expanded and discrete nodes are replaced by object node pointing to newly created math objects, which are and targets of automatically generated events.

Parameters

const	CEvaluationNode * pSrc
const	CMath::Variables & variables
const	bool & replaceDiscontinuousNodes

Returns: CEvaluationNode * pCopy

Definition at line 665 of file CMathContainer.cpp.

References CEvaluationNodeConstant::_NaN, CEvaluationNodeVariable::ANY, C_INVALID_INDEX, CEvaluationNode::CALL, CEvaluationNodeFunction::CEIL, CEvaluationNode::CHOICE, CEvaluationNodeObject::CN, CNodeContextIterator< Node, Context >::context(), copyBranch(), CEvaluationNode::copyNode(), createNodeFromObject(), CNodeContextIterator< Node, Context >::end(), CEvaluationNodeCall::EXPRESSION, CEvaluationNodeFunction::FLOOR, CEvaluationNodeCall::FUNCTION, CEvaluationNode::FUNCTION, CEvaluationNodeCall::getCalledTree(), CCopasiNode< _Data >::getData(), CEvaluationNodeVariable::getIndex(), getMathObject(), getObject(), CEvaluationTree::getRoot(), CEvaluationNode::getType(), CEvaluationNodeChoice::IF, CEvaluationNodeOperator::MODULUS, CNodeContextIterator< Node, Context >::next(), CEvaluationNode::OBJECT, CEvaluationNode::OPERATOR, CNodeContextIterator< Node, Context >::parentContextPtr(), CEvaluationNodeObject::POINTER, replaceDiscontinuousNode(), and CEvaluationNode::VARIABLE.

 {
   CNodeContextIterator< const CEvaluationNode, std::vector< CEvaluationNode * > > itNode(pNode);
   CEvaluationNode * pCopy = NULL;
 
   while (itNode.next() != itNode.end())
     {
       if (*itNode == NULL)
         {
           continue;
         }
 
       // We need to replace variables, expand called trees, and handle discrete nodes.
       switch ((int) itNode->getType())
         {
             // Handle object nodes which are of type CN
           case (CEvaluationNode::OBJECT | CEvaluationNodeObject::CN):
           {
             // We need to map the object to a math object if possible.
             const CObjectInterface * pObject =
               getObject(static_cast< const CEvaluationNodeObject *>(*itNode)->getObjectCN());
 
             // Create a converted node
             pCopy = createNodeFromObject(pObject);
           }
           break;
 
           // Handle object nodes which are of type POINTER
           case (CEvaluationNode::OBJECT | CEvaluationNodeObject::POINTER):
           {
             const CObjectInterface * pObject =
               getMathObject(static_cast< const CEvaluationNodeObject *>(*itNode)->getObjectValuePtr());
 
             // Create a converted node
             pCopy = createNodeFromObject(pObject);
           }
           break;
 
           // Handle variables
           case (CEvaluationNode::VARIABLE | CEvaluationNodeVariable::ANY):
           {
             size_t Index =
               static_cast< const CEvaluationNodeVariable * >(*itNode)->getIndex();
 
             if (Index != C_INVALID_INDEX &&
                 Index < variables.size())
               {
                 pCopy = variables[Index]->copyBranch();
               }
             else
               {
                 pCopy = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, itNode->getData());
               }
           }
           break;
 
           // Handle call nodes
           case (CEvaluationNode::CALL | CEvaluationNodeCall::FUNCTION):
           case (CEvaluationNode::CALL | CEvaluationNodeCall::EXPRESSION):
           {
             const CEvaluationNode * pCalledNode =
               static_cast< const CEvaluationNodeCall * >(*itNode)->getCalledTree()->getRoot();
 
             pCopy = copyBranch(pCalledNode, itNode.context(), replaceDiscontinuousNodes);
 
             // The variables have been copied into place we need to delete them.
             std::vector< CEvaluationNode * >::iterator it = itNode.context().begin();
             std::vector< CEvaluationNode * >::iterator end = itNode.context().end();
 
             for (; it != end; ++it)
               {
                 delete *it;
               }
           }
           break;
 
           // Handle discrete nodes
           case (CEvaluationNode::CHOICE | CEvaluationNodeChoice::IF):
           case (CEvaluationNode::FUNCTION | CEvaluationNodeFunction::FLOOR):
           case (CEvaluationNode::FUNCTION | CEvaluationNodeFunction::CEIL):
           case (CEvaluationNode::OPERATOR | CEvaluationNodeOperator::MODULUS):
 
             if (replaceDiscontinuousNodes)
               {
                 // The node is replaced with a pointer to a math object value.
                 // The math object is calculated by an assignment with the target being the
                 // math object
                 pCopy = replaceDiscontinuousNode(*itNode, itNode.context());
               }
             else
               {
                 pCopy = itNode->copyNode(itNode.context());
               }
 
             break;
 
           default:
             pCopy = itNode->copyNode(itNode.context());
             break;
         }
 
       if (itNode.parentContextPtr() != NULL)
         {
           itNode.parentContextPtr()->push_back(pCopy);
         }
     }
 
   // assert(pCopy != NULL);
 
   return pCopy;
 }

void CMathContainer::createApplyInitialValuesSequence ( )

private

Create the update sequence used when applying the initial state

Definition at line 1312 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), CMath::Default, CMathDependencyGraph::getUpdateSequence(), mApplyInitialValuesSequence, mEventDelays, mExtensiveValues, mObjects, mTransientDependencies, mValues, and CVectorCore< CType >::size().

Referenced by createDependencyGraphs().

 {
   // Collect all the changed objects, which are all transient values
   CObjectInterface::ObjectSet Changed;
   const CMathObject * pObject = mObjects.array() + (mExtensiveValues.array() - mValues.array());
   const CMathObject * pObjectEnd = mObjects.array() + (mEventDelays.array() - mValues.array());
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       Changed.insert(pObject);
     }
 
   // Collect all the requested objects
   CObjectInterface::ObjectSet Requested;
   pObjectEnd = mObjects.array() + mObjects.size();
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       Requested.insert(pObject);
     }
 
   // Build the update sequence
   mTransientDependencies.getUpdateSequence(CMath::Default, Changed, Requested, mApplyInitialValuesSequence);
 }

void CMathContainer::createDependencyGraphs ( )

private

Create Dependency Graphs

Definition at line 1212 of file CMathContainer.cpp.

References CMathDependencyGraph::addObject(), CVectorCore< CType >::array(), createApplyInitialValuesSequence(), createSynchronizeInitialValuesSequence(), createUpdateSimulationValuesSequence(), CMathDependencyGraph::exportDOTFormat(), mExtensiveValues, mInitialDependencies, mInitialExtensiveValues, mObjects, mTransientDependencies, and CVectorCore< CType >::size().

Referenced by CMathContainer(), and init().

 {
   CMathObject *pObject = mObjects.array();
   CMathObject *pObjectEnd = pObject + (mExtensiveValues.array() - mInitialExtensiveValues.array());
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       mInitialDependencies.addObject(pObject);
     }
 
   pObjectEnd = mObjects.array() + mObjects.size();
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       mTransientDependencies.addObject(pObject);
     }
 
 #ifdef COPASI_DEBUG_TRACE
   std::ofstream InitialDependencies("InitialDependencies.dot");
   mInitialDependencies.exportDOTFormat(InitialDependencies, "InitialDependencies");
 
   std::ofstream TransientDependencies("TransientDependencies.dot");
   mTransientDependencies.exportDOTFormat(TransientDependencies, "TransientDependencies");
 #endif // COPASI_DEBUG_TRACE
 
   createSynchronizeInitialValuesSequence();
   createApplyInitialValuesSequence();
   createUpdateSimulationValuesSequence();
 
   return;
 }

void CMathContainer::createDiscontinuityDataEvent ( const CEvaluationNode * pNode )

private

Create an event of type CEvent::Discontinuity for the given node

Parameters

const CEvaluationNode * pNode

Definition at line 1863 of file CMathContainer.cpp.

References CCopasiVector< T >::add(), createDiscontinuityTriggerInfix(), CEvent::Discontinuity, mDiscontinuityEvents, CEvent::setTriggerExpression(), and CEvent::setType().

Referenced by createDiscontinuityEvents().

 {
   // We can create a data event without knowing the variables as the number
   // of roots is independent from the variable value.
   CEvent * pEvent = new CEvent();
   pEvent->setType(CEvent::Discontinuity);
   mDiscontinuityEvents.add(pEvent, true);
 
   pEvent->setTriggerExpression(createDiscontinuityTriggerInfix(pNode));
 }

void CMathContainer::createDiscontinuityEvents ( )

private

Create an event of type CEvent::Discontinuity for each discontinuity in the model

Definition at line 1808 of file CMathContainer.cpp.

References CEvaluationNodeConstant::_NaN, CModel::getTreesWithDiscontinuities(), and mpModel.

Referenced by allocate(), and createDiscontinuityEvents().

 {
   CEvaluationNodeConstant VariableNode(CEvaluationNodeConstant::_NaN, "NAN");
   //size_t i, imax;
 
   // We need to create events for nodes which are capable of introducing
   // discontinuous changes.
 
   // Retrieve expression trees which contain discontinuities.
   std::vector< const CEvaluationTree * > TreesWithDiscontinuities =  mpModel->getTreesWithDiscontinuities();
   std::vector< const CEvaluationTree * >::const_iterator it = TreesWithDiscontinuities.begin();
   std::vector< const CEvaluationTree * >::const_iterator end = TreesWithDiscontinuities.end();
 
   for (; it != end; ++it)
     {
       createDiscontinuityEvents(*it);
     }
 }

void CMathContainer::createDiscontinuityEvents ( const CEvaluationTree * pTree )

private

Create an event of type CEvent::Discontinuity for each discontinuity the tree with root pNode

Parameters

const CEvaluationTree * pTree

Definition at line 1827 of file CMathContainer.cpp.

References CEvaluationNodeConstant::_NaN, CEvaluationNode::CALL, CEvaluationNodeFunction::CEIL, CEvaluationNode::CHOICE, createDiscontinuityDataEvent(), createDiscontinuityEvents(), CEvaluationNodeCall::EXPRESSION, CEvaluationNodeFunction::FLOOR, CEvaluationNodeCall::FUNCTION, CEvaluationNode::FUNCTION, CEvaluationTree::getRoot(), CEvaluationNodeChoice::IF, CEvaluationNodeOperator::MODULUS, and CEvaluationNode::OPERATOR.

 {
   CEvaluationNodeConstant VariableNode(CEvaluationNodeConstant::_NaN, "NAN");
   CNodeIterator< const CEvaluationNode > itNode(pTree->getRoot());
 
   while (itNode.next() != itNode.end())
     {
       if (*itNode == NULL)
         {
           continue;
         }
 
       switch ((int) itNode->getType())
         {
           case (CEvaluationNode::CHOICE | CEvaluationNodeChoice::IF):
           case (CEvaluationNode::FUNCTION | CEvaluationNodeFunction::FLOOR):
           case (CEvaluationNode::FUNCTION | CEvaluationNodeFunction::CEIL):
           case (CEvaluationNode::OPERATOR | CEvaluationNodeOperator::MODULUS):
             createDiscontinuityDataEvent(*itNode);
             break;
 
             // Call nodes may include discontinuities but each called tree is handled
             // separately.
           case (CEvaluationNode::CALL | CEvaluationNodeCall::FUNCTION):
           case (CEvaluationNode::CALL | CEvaluationNodeCall::EXPRESSION):
             createDiscontinuityEvents(static_cast< const CEvaluationNodeCall * >(*itNode)->getCalledTree());
             break;
 
           default:
             break;
         }
     }
 
   return;
 }

std::string CMathContainer::createDiscontinuityTriggerInfix ( const CEvaluationNode * pNode )

private

Create the infix for trigger of the event which tracks changes in a discontinuity represented by the node.

Parameters

const CEvaluationNode * pNode

Definition at line 1874 of file CMathContainer.cpp.

References CEvaluationNodeFunction::CEIL, CEvaluationNode::CHOICE, fatalError, CEvaluationNodeFunction::FLOOR, CEvaluationNode::FUNCTION, CCopasiNode< _Data >::getChild(), CEvaluationNode::getType(), CEvaluationNodeChoice::IF, CEvaluationNodeOperator::MODULUS, and CEvaluationNode::OPERATOR.

Referenced by createDiscontinuityDataEvent(), and replaceDiscontinuousNode().

 {
   std::string TriggerInfix;
 
   // We need to define a data event for each discontinuity.
   switch ((int) pNode->getType())
     {
       case (CEvaluationNode::CHOICE | CEvaluationNodeChoice::IF):
         TriggerInfix = static_cast< const CEvaluationNode * >(pNode->getChild())->buildInfix();
         break;
 
       case (CEvaluationNode::FUNCTION | CEvaluationNodeFunction::FLOOR):
       case (CEvaluationNode::FUNCTION | CEvaluationNodeFunction::CEIL):
         TriggerInfix = "sin(PI*(" + static_cast< const CEvaluationNode * >(pNode->getChild())->buildInfix() + ")) > 0";
         break;
 
       case (CEvaluationNode::OPERATOR | CEvaluationNodeOperator::MODULUS):
         TriggerInfix = "sin(PI*(" + static_cast< const CEvaluationNode * >(pNode->getChild())->buildInfix();
         TriggerInfix += ")) > 0 || sin(PI*(" + static_cast< const CEvaluationNode * >(pNode->getChild()->getSibling())->buildInfix() + ")) > 0";
         break;
 
       default:
         fatalError();
         break;
     }
 
   return TriggerInfix;
 }

CEvaluationNode * CMathContainer::createNodeFromObject ( const CObjectInterface * pMathObject )

private

Create a node based on the given pointer to the math object

Parameters

const CObjectInterface * pMathObject

Returns: CEvaluationNode * pNode

Definition at line 1162 of file CMathContainer.cpp.

References CEvaluationNodeConstant::_NaN, C_FLOAT64, CObjectInterface::getValuePointer(), mpAvogadro, and mpQuantity2NumberFactor.

Referenced by copyBranch().

 {
   CEvaluationNode * pNode = NULL;
 
   if (pObject == NULL)
     {
       // We have an invalid value, i.e. NaN
       pNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN");
     }
   else if (pObject == mpAvogadro ||
            pObject == mpQuantity2NumberFactor)
     {
       pNode = new CEvaluationNodeNumber(*(C_FLOAT64 *) pObject->getValuePointer());
     }
   else
     {
       pNode = new CEvaluationNodeObject((C_FLOAT64 *) pObject->getValuePointer());
     }
 
   return pNode;
 }

CEvaluationNode * CMathContainer::createNodeFromValue ( const C_FLOAT64 * pDataValue )

private

Create a node based on the given pointer to a data value

Parameters

const C_FLOAT64 * pDataValue

Returns: CEvaluationNode * pNode

Definition at line 1184 of file CMathContainer.cpp.

References CEvaluationNodeConstant::_NaN, C_FLOAT64, getMathObject(), and CMathObject::getValuePointer().

 {
   CEvaluationNode * pNode = NULL;
   CMathObject * pMathObject = NULL;
 
   if (pDataValue != NULL)
     {
       pMathObject = getMathObject(pDataValue);
 
       if (pMathObject != NULL)
         {
           pNode = new CEvaluationNodeObject((C_FLOAT64 *) pMathObject->getValuePointer());
         }
       else
         {
           // We must have a constant value like the conversion factor from the model.
           pNode = new CEvaluationNodeNumber(*pDataValue);
         }
     }
   else
     {
       // We have an invalid value, i.e. NaN
       pNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN");
     }
 
   return pNode;
 }

void CMathContainer::createSynchronizeInitialValuesSequence ( )

private

Create the update sequences needed to synchronize the initial values

Definition at line 1244 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), CMathObject::getEntityType(), CMathDependencyGraph::getUpdateSequence(), CMathObject::isIntensiveProperty(), mExtensiveValues, mInitialDependencies, mInitialExtensiveRates, mInitialStateValueExtensive, mInitialStateValueIntensive, mObjects, mSynchronizeInitialValuesSequenceExtensive, mSynchronizeInitialValuesSequenceIntensive, mValues, CMath::Species, and CMath::UpdateMoieties.

Referenced by createDependencyGraphs().

 {
   // TODO CRITICAL Issue 1170: We need to add elements of the stoichiometry, reduced stoichiometry,
   // and link matrices.
 
   // Collect all the changed objects, which are all transient values
   mInitialStateValueExtensive.clear();
   mInitialStateValueIntensive.clear();
   const CMathObject * pObject = mObjects.array();
   const CMathObject * pObjectEnd = pObject + (mInitialExtensiveRates.array() - mValues.array());
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       if (pObject->getEntityType() != CMath::Species)
         {
           mInitialStateValueExtensive.insert(pObject);
           mInitialStateValueIntensive.insert(pObject);
         }
       else if (pObject->isIntensiveProperty())
         {
           mInitialStateValueIntensive.insert(pObject);
         }
       else
         {
           mInitialStateValueExtensive.insert(pObject);
         }
     }
 
   // Collect all the requested objects
   CObjectInterface::ObjectSet RequestedExtensive;
   CObjectInterface::ObjectSet RequestedIntensive;
   pObject = mObjects.array();
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       if (pObject->getEntityType() != CMath::Species)
         {
           continue;
         }
       else if (pObject->isIntensiveProperty())
         {
           RequestedExtensive.insert(pObject);
         }
       else
         {
           RequestedIntensive.insert(pObject);
         }
     }
 
   pObjectEnd = mObjects.array() + (mExtensiveValues.array() - mValues.array());
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       RequestedExtensive.insert(pObject);
       RequestedIntensive.insert(pObject);
     }
 
   // Build the update sequence
   mInitialDependencies.getUpdateSequence(CMath::UpdateMoieties,
                                          mInitialStateValueExtensive,
                                          RequestedExtensive,
                                          mSynchronizeInitialValuesSequenceExtensive);
   mInitialDependencies.getUpdateSequence(CMath::UpdateMoieties,
                                          mInitialStateValueIntensive,
                                          RequestedIntensive,
                                          mSynchronizeInitialValuesSequenceIntensive);
 }

void CMathContainer::createUpdateSimulationValuesSequence ( )

private

Create the update sequences used to calculate all values required for simulation

Definition at line 1337 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), CMath::Default, CMath::Dependent, CMathObject::getSimulationType(), CMathDependencyGraph::getUpdateSequence(), CMath::Independent, mEventRoots, mEventRootStates, mEventTargetCount, mExtensiveRates, mExtensiveValues, mFixedCount, mIntensiveRates, mObjects, mReducedStateValues, mSimulationRequiredValues, mSimulationValuesSequence, mSimulationValuesSequenceReduced, mStateValues, mTransientDependencies, mValues, CMath::ODE, CMath::Time, and CMath::UseMoieties.

Referenced by createDependencyGraphs().

 {
   mStateValues.clear();
   mReducedStateValues.clear();
   mSimulationRequiredValues.clear();
 
   // Collect all the state objects, which are transient values of simulation type:
   //   Time, ODE, Independent, and Dependent (not for reduced model)
 
   const CMathObject * pObject = mObjects.array() + (mExtensiveValues.array() - mValues.array());
   const CMathObject * pObjectEnd = mObjects.array() + (mExtensiveRates.array() - mValues.array());
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       switch (pObject->getSimulationType())
         {
           case CMath::Time:
           case CMath::ODE:
           case CMath::Independent:
             mStateValues.insert(pObject);
             mReducedStateValues.insert(pObject);
             break;
 
           case CMath::Dependent:
             mStateValues.insert(pObject);
             break;
 
           default:
             break;
         }
     }
 
   // Collect all objects required for simulation, which are transient rates values of simulation type:
   //   ODE, Independent, and Dependent (not needed for reduced model) and EventRoots
   // The additional cost for calculating the rates for dependent species is neglected.
   pObject = mObjects.array() + (mExtensiveRates.array() - mValues.array()) + mFixedCount + mEventTargetCount + 1 /* Time */;
   pObjectEnd = mObjects.array() + (mIntensiveRates.array() - mValues.array());
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       mSimulationRequiredValues.insert(pObject);
     }
 
   pObject = mObjects.array() + (mEventRoots.array() - mValues.array());
   pObjectEnd = mObjects.array() + (mEventRootStates.array() - mValues.array());
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       mSimulationRequiredValues.insert(pObject);
     }
 
   // Build the update sequence
   mTransientDependencies.getUpdateSequence(CMath::Default, mStateValues, mSimulationRequiredValues, mSimulationValuesSequence);
   mTransientDependencies.getUpdateSequence(CMath::UseMoieties, mReducedStateValues, mSimulationRequiredValues, mSimulationValuesSequenceReduced);
 }

void CMathContainer::fetchInitialState ( )

Fetch the initial state from the associated model

Definition at line 442 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, CMathObject::getDataObject(), CCopasiObject::getValuePointer(), mInitialState, mObjects, and CVectorCore< CType >::size().

 {
   C_FLOAT64 * pValue = mInitialState.array();
   C_FLOAT64 * pValueEnd = pValue + mInitialState.size();
   CMathObject * pObject = mObjects.array();
 
   for (; pValue != pValueEnd; ++pValue, ++pObject)
     {
       const CCopasiObject * pDataObject = pObject->getDataObject();
 
       if (pDataObject != NULL)
         {
           *pValue = *(C_FLOAT64 *)pDataObject->getValuePointer();
         }
     }
 
   return;
 }

void CMathContainer::fetchState ( )

Fetch the state from the associated model

Definition at line 480 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, CMathObject::getDataObject(), CCopasiObject::getValuePointer(), mObjects, mState, and CVectorCore< CType >::size().

 {
   C_FLOAT64 * pValue = mState.array();
   C_FLOAT64 * pValueEnd = pValue + mState.size();
   CMathObject * pObject = mObjects.array();
 
   for (; pValue != pValueEnd; ++pValue, ++pObject)
     {
       const CCopasiObject * pDataObject = pObject->getDataObject();
 
       if (pDataObject != NULL)
         {
           *pValue = *(C_FLOAT64 *)pDataObject->getValuePointer();
         }
     }
 
   return;
 }

CCopasiObjectName CMathContainer::getCN ( ) const

virtual

Retrieve the CN of the math container The math container provides values for the numerical values of model objects. For the CN mechanism to work properly it has to pretend to be the model.

Returns: CCopasiObjectName

Reimplemented from CCopasiObject.

Definition at line 519 of file CMathContainer.cpp.

References CCopasiObject::getCN(), and mpModel.

 {
   return mpModel->getCN();
 }

CMath::EntityType CMathContainer::getEntityType ( const CModelEntity * pEntity )

staticprivate

Determine the entity type of an entity

Parameters

const CModelEntity * pEntity

Returns: CMath::EntityType entityType

Definition at line 1533 of file CMathContainer.cpp.

References CMath::Compartment, CMath::EntityTypeUndefined, CMath::GlobalQuantity, and CMath::Species.

Referenced by initializeMathObjects().

 {
   const CMetab * pSpecies = dynamic_cast< const CMetab * >(pEntity);
 
   if (pSpecies != NULL)
     {
       return CMath::Species;
     }
   else if (dynamic_cast< const CCompartment * >(pEntity) != NULL)
     {
       return CMath::Compartment;
     }
   else if (dynamic_cast< const CModelValue * >(pEntity) != NULL)
     {
       return CMath::GlobalQuantity;
     }
 
   return CMath::EntityTypeUndefined;
 }

const CVectorCore< C_FLOAT64 > & CMathContainer::getInitialState ( ) const

Retrieves the initial state values, i.e., all initial values of objects of simulation type Fixed, Time, ODE, Dependent, and Independent. It includes only extensive values for species.

Returns: const CVectorCore< C_FLOAT64 > & initialState

Definition at line 344 of file CMathContainer.cpp.

References mInitialState.

 {
   return mInitialState;
 }

CVectorCore< C_FLOAT64 > & CMathContainer::getInitialState ( )

Retrieves the initial state values, i.e., all initial values of objects of simulation type Fixed, Time, ODE, Dependent, and Independent. It includes only extensive values for species.

Returns: CVectorCore< C_FLOAT64 > & initialState

Definition at line 349 of file CMathContainer.cpp.

References mInitialState.

 {
   return mInitialState;
 }

C_FLOAT64 * CMathContainer::getInitialValuePointer ( const C_FLOAT64 * pValue ) const

Retrieve the pointer to the corresponding initial value

Parameters

const C_FLOAT64 * pValue

Returns: C_FLOAT64 * pInitialvalue

Definition at line 1794 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, mEventDelays, mExtensiveValues, mInitialExtensiveValues, mValues, and CVectorCore< CType >::size().

 {
   assert(mValues.array() <= pValue && pValue < mValues.array() + mValues.size());
 
   const C_FLOAT64 * pInitialValue = pValue;
 
   if (mExtensiveValues.array() <= pValue && pValue < mEventDelays.array())
     {
       pInitialValue = mInitialExtensiveValues.array() + (pValue - mExtensiveValues.array());
     }
 
   return const_cast< C_FLOAT64 * >(pInitialValue);
 }

CMathObject * CMathContainer::getMathObject ( const CObjectInterface * pObject ) const

Retrieve a pointer to corresponding the mathematical object for the given abject if it exists otherwise NULL

Parameters

const CObjectInterface * pObject

Returns: CMathObject * pMathObject

Definition at line 554 of file CMathContainer.cpp.

References mDataObject2MathObject.

Referenced by CMathEventN::CAssignment::compile(), CMathObject::compileDependentMass(), CMathObject::compileInitialValue(), CMathObject::compileValue(), copyBranch(), createNodeFromValue(), getMathObject(), getObject(), and CMathReaction::initialize().

 {
   if (pObject == NULL)
     return NULL;
 
   std::map< CCopasiObject *, CMathObject * >::const_iterator found =
     mDataObject2MathObject.find(const_cast<CCopasiObject*>(static_cast< const CCopasiObject * >(pObject)));
 
   if (found != mDataObject2MathObject.end())
     {
       return found->second;
     }
 
   return NULL;
 }

CMathObject * CMathContainer::getMathObject ( const C_FLOAT64 * pDataValue ) const

Retrieve a pointer to the mathematical object for data value pointer

Parameters

const C_FLOAT64 * pDataValue

Returns: CMathObject * pMathObject

Definition at line 570 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, mDataValue2MathObject, mObjects, mValues, and CVectorCore< CType >::size().

 {
   if (pDataValue == NULL)
     return NULL;
 
   // Check whether we point to a math value.
   const C_FLOAT64 * pValues = mValues.array();
 
   if (pValues <= pDataValue && pDataValue < pValues + mValues.size())
     {
       return const_cast< CMathObject * >(mObjects.array() + (pDataValue - pValues));
     }
 
   std::map< C_FLOAT64 *, CMathObject * >::const_iterator found =
     mDataValue2MathObject.find(const_cast< C_FLOAT64 * >(pDataValue));
 
   if (found != mDataValue2MathObject.end())
     {
       return found->second;
     }
 
   return NULL;
 }

CMathObject * CMathContainer::getMathObject ( const CCopasiObjectName & cn ) const

Retrieve a pointer to the mathematical object for the given CN

Parameters

const CCopasiObjectName & cn

Returns: CMathObject * pMathObject

Definition at line 594 of file CMathContainer.cpp.

References getMathObject(), CCopasiContainer::getObject(), and mpModel.

 {
   return getMathObject(mpModel->getObject(cn));
 }

const CModel & CMathContainer::getModel ( ) const

Retrieve the model for the container

Returns: const CModel & model

Definition at line 652 of file CMathContainer.cpp.

References mpModel.

Referenced by CMathObject::compileParticleFlux(), CMathObject::compilePropensity(), CMathObject::createExtensiveODERateExpression(), CMathObject::createExtensiveReactionRateExpression(), CMathObject::createExtensiveValueExpression(), CMathObject::createIntensiveRateExpression(), and CMathObject::createIntensiveValueExpression().

 {
   return *mpModel;
 }

const CObjectInterface * CMathContainer::getObject ( const CCopasiObjectName & cn ) const

virtual

Retrieve a descendant object by its CN.

Reimplemented from CCopasiContainer.

Definition at line 525 of file CMathContainer.cpp.

References CCopasiObject::getCN(), getMathObject(), CCopasiObject::getObjectDataModel(), CCopasiObjectName::getPrimary(), mpModel, and CCopasiDataModel::ObjectFromCN().

Referenced by copyBranch().

 {
   std::vector< CCopasiContainer * > ListOfContainer;
   ListOfContainer.push_back(mpModel);
 
   const CObjectInterface * pObject = NULL;
   CCopasiObjectName ModelCN = mpModel->getCN();
 
   if (cn.getPrimary() != ModelCN.getPrimary())
     {
       pObject = mpModel->getObjectDataModel()->ObjectFromCN(ListOfContainer, ModelCN + "," + cn);
     }
   else
     {
       pObject = mpModel->getObjectDataModel()->ObjectFromCN(ListOfContainer, cn);
     }
 
   const CMathObject * pMathObject = getMathObject(pObject);
 
   if (pMathObject != NULL)
     {
       return pMathObject;
     }
 
   std::cout << "Data Object " << cn << " (0x" << pObject << ") has no corresponding Math Object." << std::endl;
 
   return pObject;
 }

const CVectorCore< C_FLOAT64 > & CMathContainer::getState ( ) const

Retrieves the state values, i.e., all initial values of objects of simulation type Time, ODE, Dependent, and Independent. It includes only extensive values for species.

Returns: const CVectorCore< C_FLOAT64 > & state

Definition at line 361 of file CMathContainer.cpp.

References mState.

 {
   return mState;
 }

CVectorCore< C_FLOAT64 > & CMathContainer::getState ( )

Retrieves the state values, i.e., all initial values of objects of simulation type Time, ODE, Dependent, and Independent. It includes only extensive values for species.

Returns: const CVectorCore< C_FLOAT64 > & state

Definition at line 366 of file CMathContainer.cpp.

References mState.

 {
   return mState;
 }

const CVectorCore< C_FLOAT64 > & CMathContainer::getStateReduced ( ) const

Retrieves the state values, i.e., all initial values of objects of simulation type Time, ODE, and Dependent. It includes only extensive values for species.

Returns: const CVectorCore< C_FLOAT64 > & stateReduced

Definition at line 378 of file CMathContainer.cpp.

References mStateReduced.

 {
   return mStateReduced;
 }

CVectorCore< C_FLOAT64 > & CMathContainer::getStateReduced ( )

Retrieves the reduced state values, i.e., all initial values of objects of simulation type Time, ODE, and Dependent. It includes only extensive values for species.

Returns: const CVectorCore< C_FLOAT64 > & stateReduced

Definition at line 383 of file CMathContainer.cpp.

References mStateReduced.

 {
   return mStateReduced;
 }

const CVectorCore< C_FLOAT64 > & CMathContainer::getValues ( ) const

Retrieve the values of all mathematical objects

Returns: const CVectorCore< C_FLOAT64 > & values

Definition at line 327 of file CMathContainer.cpp.

References mValues.

 {
   return mValues;
 }

CVectorCore< C_FLOAT64 > & CMathContainer::getValues ( )

Retrieve the values of all mathematical objects

Returns: CVectorCore< C_FLOAT64 > & values

Definition at line 332 of file CMathContainer.cpp.

References mValues.

 {
   return mValues;
 }

bool CMathContainer::hasDependencies ( const CCopasiObject * pObject )

staticprivate

Determine whether on object has calculation dependencies.

Definition at line 1773 of file CMathContainer.cpp.

References CCopasiObject::getDirectDependencies(), and CCopasiObject::getObjectParent().

 {
   const CCopasiObject::DataObjectSet & Dependencies = pObject->getDirectDependencies();
 
   if (Dependencies.find(pObject->getObjectParent()) != Dependencies.end())
     {
       return Dependencies.size() > 1;
     }
 
   return Dependencies.size() > 0;
 }

void CMathContainer::init ( )

private

Initialize the mathematical model

Definition at line 599 of file CMathContainer.cpp.

References allocate(), CVectorCore< CType >::array(), CCopasiVector< T >::begin(), CCopasiVector< T >::clear(), compileEvents(), compileObjects(), createDependencyGraphs(), CModel::getReactions(), CMathReaction::initialize(), initializeDiscontinuousCreationPointer(), initializeEvents(), initializeObjects(), initializePointers(), mDiscontinuityEvents, mDiscontinuityInfix2Object, mObjects, mpModel, mReactions, mTriggerInfix2Event, CModelParameter::ParticleNumbers, CVector< CType >::resize(), CVectorCore< CType >::size(), CCopasiVector< T >::size(), and updateInitialValues().

Referenced by CMathContainer().

 {
   allocate();
 
   CMath::sPointers Pointers;
   initializePointers(Pointers);
 #ifdef COPASI_DEBUG
   printPointers(Pointers);
 #endif
 
   initializeDiscontinuousCreationPointer();
 
   initializeObjects(Pointers);
   initializeEvents(Pointers);
 
   compileObjects();
   compileEvents();
 
   // These are only used during initialization for setting up the tracking of
   // discontinuities and are cleared afterwards.
   mDiscontinuityEvents.clear();
   mDiscontinuityInfix2Object.clear();
   mTriggerInfix2Event.clear();
 
   // TODO We may have unused event triggers and roots due to optimization
   // in the discontinuities.
   createDependencyGraphs();
 
   mReactions.resize(mpModel->getReactions().size());
   CMathReaction * pReaction = mReactions.array();
   CMathReaction * pReactionEnd = pReaction + mReactions.size();
   CCopasiVector< CReaction >::const_iterator itReaction = mpModel->getReactions().begin();
 
   for (; pReaction != pReactionEnd; ++itReaction, ++pReaction)
     {
       pReaction->initialize(*itReaction, *this);
     }
 
   updateInitialValues(CModelParameter::ParticleNumbers);
 
 #ifdef COPASI_DEBUG
   CMathObject *pObject = mObjects.array();
   CMathObject *pObjectEnd = pObject + mObjects.size();
 
   for (; pObject != pObjectEnd; ++pObject)
     {
       std::cout << *pObject;
     }
 
   std::cout << std::endl;
 #endif // COPASI_DEBUG
 }

void CMathContainer::initializeDiscontinuousCreationPointer ( )

private

Initialize the pointers used for the conversion of discontinuous nodes.

Definition at line 1512 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, mCreateDiscontinuousPointer, mDiscontinuous, mEvents, mObjects, mValues, CMathContainer::sDiscontinuous::pDiscontinuous, CMathContainer::sDiscontinuous::pEvent, and CVectorCore< CType >::size().

Referenced by init().

 {
   C_FLOAT64 * pValues = mValues.array();
   CMathObject * pObjects = mObjects.array();
 
   size_t nDiscontinuous = mDiscontinuous.size();
   size_t nEvents = mEvents.size() - nDiscontinuous;
 
   mCreateDiscontinuousPointer.pEvent = mEvents.array() + nEvents;
   mCreateDiscontinuousPointer.pDiscontinuous = pObjects + (mDiscontinuous.array() - pValues);
 
   /*
   mCreateDiscontinuousPointer.pEventDelay = pObjects + (mEventDelays.array() - pValues) + nEvents;
   mCreateDiscontinuousPointer.pEventPriority = pObjects + (mEventPriorities.array() - pValues) + nEvents;
   mCreateDiscontinuousPointer.pEventAssignment = pObjects + (mEventAssignments.array() - pValues) + nEventAssignments;
   mCreateDiscontinuousPointer.pEventTrigger = pObjects + (mEventTriggers.array() - pValues) + nEvents;
   mCreateDiscontinuousPointer.pEventRoot = pObjects + (mEventRoots.array() - pValues) + nEventRoots;
   */
 }

void CMathContainer::initializeEvents ( CMath::sPointers & pointers )

private

Initialize the events

Parameters

sPointers & pointers

Definition at line 1115 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), CMathEventN::initialize(), mEvents, and CVectorCore< CType >::size().

Referenced by init().

 {
   // Initialize events.
   CMathEventN * pEvent = mEvents.array();
   CMathEventN * pEventEnd = pEvent + mEvents.size();
 
   for (; pEvent != pEventEnd; ++pEvent)
     {
       pEvent->initialize(p);
     }
 
   return;
 }

void CMathContainer::initializeMathObjects	(	const std::vector< const CModelEntity * > &	entities,
		const CMath::SimulationType &	simulationType,
		CMath::sPointers &	pointers
	)

private

Initialize several mathematical objects of a common simulation type and advance relevant pointers

Parameters

const	std::vector<const CModelEntity*> & entities
const	CMath::SimulationType & simulationType
sPointers	& pointers

Definition at line 1553 of file CMathContainer.cpp.

Referenced by initializeObjects().

 {
   // Process entities.
   std::vector<const CModelEntity*>::const_iterator it = entities.begin();
   std::vector<const CModelEntity*>::const_iterator end = entities.end();
 
   CMath::EntityType EntityType;
 
   for (; it != end; ++it)
     {
       EntityType = getEntityType(*it);
 
       // Extensive Initial Value
 
       // The simulation type for initial values is either CMath::Assignment or CMath::Fixed
       // We must check whether the initial value must be calculated, i.e., whether it has
       // dependencies or not. In case of species it always possible that is must be calculated.
 
       CMath::SimulationType SimulationType = CMath::Fixed;
       CCopasiObject * pObject = (*it)->getInitialValueReference();
 
       if (EntityType == CMath::Species)
         {
           SimulationType = CMath::Conversion;
         }
       else if ((simulationType == CMath::Assignment && (*it)->getExpression() != "") ||
                (*it)->getInitialExpression() != "")
         {
           SimulationType = CMath::Assignment;
         }
 
       map(pObject, p.pInitialExtensiveValuesObject);
       CMathObject::initialize(p.pInitialExtensiveValuesObject, p.pInitialExtensiveValues,
                               CMath::Value, EntityType, SimulationType, false, true,
                               pObject);
 
       // Extensive Value
       SimulationType = simulationType;
 
       if (EntityType == CMath::Species &&
           (simulationType == CMath::EventTarget ||
            simulationType == CMath::Assignment))
         {
           SimulationType = CMath::Conversion;
         }
 
       map((*it)->getValueReference(), p.pExtensiveValuesObject);
       CMathObject::initialize(p.pExtensiveValuesObject, p.pExtensiveValues,
                               CMath::Value, EntityType, SimulationType, false, false,
                               (*it)->getValueReference());
 
       // Initial Extensive Rate
       SimulationType = simulationType;
 
       if (simulationType == CMath::EventTarget)
         {
           SimulationType = CMath::Fixed;
         }
 
       CMathObject::initialize(p.pInitialExtensiveRatesObject, p.pInitialExtensiveRates,
                               CMath::Rate, EntityType, SimulationType, false, true,
                               (*it)->getRateReference());
 
       // Extensive Rate
       map((*it)->getRateReference(), p.pExtensiveRatesObject);
       CMathObject::initialize(p.pExtensiveRatesObject, p.pExtensiveRates,
                               CMath::Rate, EntityType, SimulationType, false, false,
                               (*it)->getRateReference());
 
       // Species have intensive values in addition to the extensive  ones.
       if (EntityType == CMath::Species)
         {
           const CMetab *pSpecies = static_cast<const CMetab*>(*it);
 
           // Intensive Initial Value
 
           // The simulation type for initial values is either CMath::Assignment or CMath::Conversion
           // In case of species it always possible that is must be calculated.
           SimulationType = CMath::Conversion;
 
           if (simulationType == CMath::Assignment)
             {
               SimulationType = CMath::Assignment;
             }
 
           map(pSpecies->getInitialConcentrationReference(), p.pInitialIntensiveValuesObject);
           CMathObject::initialize(p.pInitialIntensiveValuesObject, p.pInitialIntensiveValues,
                                   CMath::Value, CMath::Species, SimulationType, true, true,
                                   pSpecies->getInitialConcentrationReference());
 
           // Intensive Value
           SimulationType = CMath::Conversion;
 
           if (simulationType == CMath::EventTarget ||
               simulationType == CMath::Assignment)
             {
               SimulationType = simulationType;
             }
 
           map(pSpecies->getConcentrationReference(), p.pIntensiveValuesObject);
           CMathObject::initialize(p.pIntensiveValuesObject, p.pIntensiveValues,
                                   CMath::Value, CMath::Species, SimulationType, true, false,
                                   pSpecies->getConcentrationReference());
 
           // Initial Intensive Rate
           CMathObject::initialize(p.pInitialIntensiveRatesObject, p.pInitialIntensiveRates,
                                   CMath::Rate, CMath::Species, CMath::Assignment, true, true,
                                   pSpecies->getConcentrationRateReference());
 
           // Intensive Rate
           map(pSpecies->getConcentrationRateReference(), p.pIntensiveRatesObject);
           CMathObject::initialize(p.pIntensiveRatesObject, p.pIntensiveRates,
                                   CMath::Rate, CMath::Species, CMath::Assignment, true, false,
                                   pSpecies->getConcentrationRateReference());
         }
     }
 }

void CMathContainer::initializeMathObjects	(	const std::vector< const CCopasiObject * > &	parameters,
		CMath::sPointers &	p
	)

private

Initialize several mathematical objects for local reaction parameters and advance relevant pointers

Parameters

const	std::vector<const CCopasiObject *> & parameters
CMathContainer::sPointers	& p

Definition at line 1673 of file CMathContainer.cpp.

References CMath::Fixed, CMathObject::initialize(), CMath::LocalReactionParameter, map(), CMath::sPointers::pExtensiveRates, CMath::sPointers::pExtensiveRatesObject, CMath::sPointers::pExtensiveValues, CMath::sPointers::pExtensiveValuesObject, CMath::sPointers::pInitialExtensiveRates, CMath::sPointers::pInitialExtensiveRatesObject, CMath::sPointers::pInitialExtensiveValues, CMath::sPointers::pInitialExtensiveValuesObject, CMath::Rate, and CMath::Value.

 {
   // Process parameters.
   std::vector<const CCopasiObject *>::const_iterator it = parameters.begin();
   std::vector<const CCopasiObject *>::const_iterator end = parameters.end();
 
   for (; it != end; ++it)
     {
       // Extensive Initial Value
       map(const_cast< CCopasiObject * >(*it), p.pInitialExtensiveValuesObject);
       CMathObject::initialize(p.pInitialExtensiveValuesObject, p.pInitialExtensiveValues,
                               CMath::Value, CMath::LocalReactionParameter, CMath::Fixed, false, true,
                               *it);
 
       // Extensive Value
       CMathObject::initialize(p.pExtensiveValuesObject, p.pExtensiveValues,
                               CMath::Value, CMath::LocalReactionParameter, CMath::Fixed, false, false,
                               NULL);
 
       // Initial Extensive Rate
       CMathObject::initialize(p.pInitialExtensiveRatesObject, p.pInitialExtensiveRates,
                               CMath::Rate, CMath::LocalReactionParameter, CMath::Fixed, false, true,
                               NULL);
 
       // Extensive Rate
       CMathObject::initialize(p.pExtensiveRatesObject, p.pExtensiveRates,
                               CMath::Rate, CMath::LocalReactionParameter, CMath::Fixed, false, false,
                               NULL);
     }
 }

void CMathContainer::initializeMathObjects	(	const CCopasiVector< CReaction > &	reactions,
		CMath::sPointers &	p
	)

private

Initialize several mathematical objects for local reaction parameters and advance relevant pointers

Parameters

const	CCopasiVector< CReaction > & reactions
CMathContainer::sPointers	& p

Definition at line 1705 of file CMathContainer.cpp.

References CCopasiVector< T >::begin(), CCopasiVector< T >::end(), CMath::Flux, CMathObject::initialize(), map(), CMath::ParticleFlux, CMath::sPointers::pFluxes, CMath::sPointers::pFluxesObject, CMath::sPointers::pInitialFluxes, CMath::sPointers::pInitialFluxesObject, CMath::sPointers::pInitialParticleFluxes, CMath::sPointers::pInitialParticleFluxesObject, CMath::sPointers::pParticleFluxes, CMath::sPointers::pParticleFluxesObject, CMath::sPointers::pPropensities, CMath::sPointers::pPropensitiesObject, CMath::Propensity, CMath::Reaction, and CMath::SimulationTypeUndefined.

 {
   // Process reactions.
   CCopasiVector< CReaction >::const_iterator it = reactions.begin();
   CCopasiVector< CReaction >::const_iterator end = reactions.end();
 
   for (; it != end; ++it)
     {
       // Initial Particle Flux
       CMathObject::initialize(p.pInitialParticleFluxesObject, p.pInitialParticleFluxes,
                               CMath::ParticleFlux, CMath::Reaction, CMath::SimulationTypeUndefined, false, true,
                               (*it)->getParticleFluxReference());
 
       // Particle Flux
       map((*it)->getParticleFluxReference(), p.pParticleFluxesObject);
       CMathObject::initialize(p.pParticleFluxesObject, p.pParticleFluxes,
                               CMath::ParticleFlux, CMath::Reaction, CMath::SimulationTypeUndefined, false, false,
                               (*it)->getParticleFluxReference());
 
       // Initial Flux
       CMathObject::initialize(p.pInitialFluxesObject, p.pInitialFluxes,
                               CMath::Flux, CMath::Reaction, CMath::SimulationTypeUndefined, false, true,
                               (*it)->getFluxReference());
 
       // Flux
       map((*it)->getFluxReference(), p.pFluxesObject);
       CMathObject::initialize(p.pFluxesObject, p.pFluxes,
                               CMath::Flux, CMath::Reaction, CMath::SimulationTypeUndefined, false, false,
                               (*it)->getFluxReference());
 
       // Propensity
       map((*it)->getPropensityReference(), p.pPropensitiesObject);
       CMathObject::initialize(p.pPropensitiesObject, p.pPropensities,
                               CMath::Propensity, CMath::Reaction, CMath::SimulationTypeUndefined, false, false,
                               (*it)->getPropensityReference());
     }
 }

void CMathContainer::initializeMathObjects	(	const CCopasiVector< CMoiety > &	moieties,
		CMath::sPointers &	p
	)

private

Initialize several mathematical objects for local reaction parameters and advance relevant pointers

Parameters

const	CCopasiVector< CMoiety > & moieties
CMathContainer::sPointers	& p

Definition at line 1744 of file CMathContainer.cpp.

References CCopasiVector< T >::begin(), CMath::DependentMass, CCopasiVector< T >::end(), CMathObject::initialize(), map(), CMath::Moiety, CMath::sPointers::pDependentMasses, CMath::sPointers::pDependentMassesObject, CMath::sPointers::pInitialTotalMasses, CMath::sPointers::pInitialTotalMassesObject, CMath::sPointers::pTotalMasses, CMath::sPointers::pTotalMassesObject, CMath::SimulationTypeUndefined, and CMath::TotalMass.

 {
   // Process reactions.
   CCopasiVector< CMoiety >::const_iterator it = moieties.begin();
   CCopasiVector< CMoiety >::const_iterator end = moieties.end();
 
   for (; it != end; ++it)
     {
       // Initial Total Mass
       CMathObject::initialize(p.pInitialTotalMassesObject, p.pInitialTotalMasses,
                               CMath::TotalMass, CMath::Moiety, CMath::SimulationTypeUndefined, false, true,
                               (*it)->getTotalNumberReference());
 
       // Total Mass
       map((*it)->getTotalNumberReference(), p.pTotalMassesObject);
       CMathObject::initialize(p.pTotalMassesObject, p.pTotalMasses,
                               CMath::TotalMass, CMath::Moiety, CMath::SimulationTypeUndefined, false, false,
                               (*it)->getTotalNumberReference());
 
       // Dependent
       map((*it)->getDependentNumberReference(), p.pDependentMassesObject);
       CMathObject::initialize(p.pDependentMassesObject, p.pDependentMasses,
                               CMath::DependentMass, CMath::Moiety, CMath::SimulationTypeUndefined, false, false,
                               (*it)->getDependentNumberReference());
     }
 }

void CMathContainer::initializeObjects ( CMath::sPointers & pointers )

private

Initialize the objects

Parameters

sPointers & pointers

Definition at line 974 of file CMathContainer.cpp.

Referenced by init().

 {
   std::set< const CModelEntity * > EventTargets = CObjectLists::getEventTargets(mpModel);
 
   std::vector< const CModelEntity * > FixedEntities;
   std::vector< const CModelEntity * > FixedEventTargetEntities;
 
   const CStateTemplate & StateTemplate = mpModel->getStateTemplate();
 
   // Determine which fixed entities are modified by events and which not.
   CModelEntity *const* ppEntities = StateTemplate.beginFixed();
   CModelEntity *const* ppEntitiesEnd = StateTemplate.endFixed();
 
   for (; ppEntities != ppEntitiesEnd; ++ppEntities)
     {
       if ((*ppEntities)->getStatus() == CModelEntity::ASSIGNMENT)
         continue;
 
       if (EventTargets.find(*ppEntities) == EventTargets.end())
         {
           FixedEntities.push_back(*ppEntities);
         }
       else
         {
           FixedEventTargetEntities.push_back(*ppEntities);
         }
     }
 
   // Process fixed entities which are not event targets.
   initializeMathObjects(FixedEntities, CMath::Fixed, p);
   mFixedCount = FixedEntities.size();
 
   // Process local reaction parameters
   std::vector<const CCopasiObject*> LocalReactionParameter =
     CObjectLists::getListOfConstObjects(CObjectLists::ALL_LOCAL_PARAMETER_VALUES, mpModel);
   initializeMathObjects(LocalReactionParameter, p);
   mFixedCount += LocalReactionParameter.size();
 
   // Process fixed entities which are event targets.
   initializeMathObjects(FixedEventTargetEntities, CMath::EventTarget, p);
   mEventTargetCount = FixedEventTargetEntities.size();
 
   // The simulation time
   // Extensive Initial Value
   map(mpModel->getInitialValueReference(), p.pInitialExtensiveValuesObject);
   CMathObject::initialize(p.pInitialExtensiveValuesObject, p.pInitialExtensiveValues,
                           CMath::Value, CMath::Model, CMath::Time, false, true,
                           mpModel->getInitialValueReference());
 
   // Extensive Value
   map(mpModel->getValueReference(), p.pExtensiveValuesObject);
   CMathObject::initialize(p.pExtensiveValuesObject, p.pExtensiveValues,
                           CMath::Value, CMath::Model, CMath::Time, false, false,
                           mpModel->getValueReference());
 
   // Initial Extensive Rate
   CMathObject::initialize(p.pInitialExtensiveRatesObject, p.pInitialExtensiveRates,
                           CMath::Rate, CMath::Model, CMath::Time, false, true,
                           mpModel->getRateReference());
   // Extensive Rate
   map(mpModel->getRateReference(), p.pExtensiveRatesObject);
   CMathObject::initialize(p.pExtensiveRatesObject, p.pExtensiveRates,
                           CMath::Rate, CMath::Model, CMath::Time, false, false,
                           mpModel->getRateReference());
 
   // Process entities which are determined by ODEs
   std::vector< const CModelEntity * > ODEEntities;
 
   ppEntities = StateTemplate.beginIndependent();
   ppEntitiesEnd = StateTemplate.endIndependent();
 
   for (; ppEntities != ppEntitiesEnd && (*ppEntities)->getStatus() == CModelEntity::ODE; ++ppEntities)
     {
       ODEEntities.push_back(*ppEntities);
     }
 
   initializeMathObjects(ODEEntities, CMath::ODE, p);
   mODECount = ODEEntities.size();
 
   // Process independent species
   std::vector< const CModelEntity * > IndependentSpecies;
 
   ppEntities = StateTemplate.beginIndependent();
   ppEntitiesEnd = StateTemplate.endIndependent();
 
   for (; ppEntities != ppEntitiesEnd; ++ppEntities)
     {
       if ((*ppEntities)->getStatus() != CModelEntity::REACTIONS)
         continue;
 
       IndependentSpecies.push_back(*ppEntities);
     }
 
   initializeMathObjects(IndependentSpecies, CMath::Independent, p);
   mIndependentCount = IndependentSpecies.size();
 
   // Process dependent species
   std::vector< const CModelEntity * > DependentSpecies;
 
   ppEntities = StateTemplate.beginDependent();
   ppEntitiesEnd = StateTemplate.endDependent();
 
   for (; ppEntities != ppEntitiesEnd && (*ppEntities)->getStatus() == CModelEntity::REACTIONS; ++ppEntities)
     {
       DependentSpecies.push_back(*ppEntities);
     }
 
   initializeMathObjects(DependentSpecies, CMath::Dependent, p);
   mDependentCount = DependentSpecies.size();
 
   // Process entities which are determined by assignments
   std::vector< const CModelEntity * > AssignmentEntities;
 
   // We continue with the pointer ppEntities
   ppEntitiesEnd = StateTemplate.endFixed();
 
   for (; ppEntities != ppEntitiesEnd && (*ppEntities)->getStatus() == CModelEntity::ASSIGNMENT; ++ppEntities)
     {
       AssignmentEntities.push_back(*ppEntities);
     }
 
   initializeMathObjects(AssignmentEntities, CMath::Assignment, p);
   mAssignmentCount = AssignmentEntities.size();
 
   // Process Reactions
   initializeMathObjects(mpModel->getReactions(), p);
 
   // Process Moieties
   initializeMathObjects(mpModel->getMoieties(), p);
 
   // Process Discontinuous Objects
   size_t n, nDiscontinuous = mDiscontinuous.size();
 
   for (n = 0; n != nDiscontinuous; ++n)
     {
       CMathObject::initialize(p.pDiscontinuousObject, p.pDiscontinuous,
                               CMath::Discontinuous, CMath::Event, CMath::SimulationTypeUndefined,
                               false, false, NULL);
     }
 }

void CMathContainer::initializePointers ( CMath::sPointers & pointers )

private

Initialize the pointers

Parameters

sPointers & pointers

Definition at line 1393 of file CMathContainer.cpp.

Referenced by init().

 {
   p.pInitialExtensiveValues = mInitialExtensiveValues.array();
   p.pInitialIntensiveValues = mInitialIntensiveValues.array();
   p.pInitialExtensiveRates = mInitialExtensiveRates.array();
   p.pInitialIntensiveRates = mInitialIntensiveRates.array();
   p.pInitialParticleFluxes = mInitialParticleFluxes.array();
   p.pInitialFluxes = mInitialFluxes.array();
   p.pInitialTotalMasses = mInitialTotalMasses.array();
   p.pInitialEventTriggers = mInitialEventTriggers.array();
 
   p.pExtensiveValues = mExtensiveValues.array();
   p.pIntensiveValues = mIntensiveValues.array();
   p.pExtensiveRates = mExtensiveRates.array();
   p.pIntensiveRates = mIntensiveRates.array();
   p.pParticleFluxes = mParticleFluxes.array();
   p.pFluxes = mFluxes.array();
   p.pTotalMasses = mTotalMasses.array();
   p.pEventTriggers = mEventTriggers.array();
 
   p.pEventDelays = mEventDelays.array();
   p.pEventPriorities = mEventPriorities.array();
   p.pEventAssignments = mEventAssignments.array();
   p.pEventRoots = mEventRoots.array();
   p.pEventRootStates = mEventRootStates.array();
   p.pPropensities = mPropensities.array();
   p.pDependentMasses = mDependentMasses.array();
   p.pDiscontinuous = mDiscontinuous.array();
 
   C_FLOAT64 * pValues = mValues.array();
   CMathObject * pObjects = mObjects.array();
 
   p.pInitialExtensiveValuesObject = pObjects + (p.pInitialExtensiveValues - pValues);
   p.pInitialIntensiveValuesObject = pObjects + (p.pInitialIntensiveValues - pValues);
   p.pInitialExtensiveRatesObject = pObjects + (p.pInitialExtensiveRates - pValues);
   p.pInitialIntensiveRatesObject = pObjects + (p.pInitialIntensiveRates - pValues);
   p.pInitialParticleFluxesObject = pObjects + (p.pInitialParticleFluxes - pValues);
   p.pInitialFluxesObject = pObjects + (p.pInitialFluxes - pValues);
   p.pInitialTotalMassesObject = pObjects + (p.pInitialTotalMasses - pValues);
   p.pInitialEventTriggersObject = pObjects + (p.pInitialEventTriggers - pValues);
 
   p.pExtensiveValuesObject = pObjects + (p.pExtensiveValues - pValues);
   p.pIntensiveValuesObject = pObjects + (p.pIntensiveValues - pValues);
   p.pExtensiveRatesObject = pObjects + (p.pExtensiveRates - pValues);
   p.pIntensiveRatesObject = pObjects + (p.pIntensiveRates - pValues);
   p.pParticleFluxesObject = pObjects + (p.pParticleFluxes - pValues);
   p.pFluxesObject = pObjects + (p.pFluxes - pValues);
   p.pTotalMassesObject = pObjects + (p.pTotalMasses - pValues);
   p.pEventTriggersObject = pObjects + (p.pEventTriggers - pValues);
 
   p.pEventDelaysObject = pObjects + (p.pEventDelays - pValues);
   p.pEventPrioritiesObject = pObjects + (p.pEventPriorities - pValues);
   p.pEventAssignmentsObject = pObjects + (p.pEventAssignments - pValues);
   p.pEventRootsObject = pObjects + (p.pEventRoots - pValues);
   p.pEventRootStatesObject = pObjects + (p.pEventRootStates - pValues);
   p.pPropensitiesObject = pObjects + (p.pPropensities - pValues);
   p.pDependentMassesObject = pObjects + (p.pDependentMasses - pValues);
   p.pDiscontinuousObject = pObjects + (p.pDiscontinuous - pValues);
 }

void CMathContainer::map	(	CCopasiObject *	pDataObject,
		CMathObject *	pMathObject
	)

private

Map the data object to the math object

Parameters

CCopasiObject	* pDataObject
CMathObject	* pMathObject

Definition at line 1785 of file CMathContainer.cpp.

References C_FLOAT64, CCopasiObject::getValuePointer(), mDataObject2MathObject, and mDataValue2MathObject.

Referenced by initializeMathObjects(), and initializeObjects().

 {
   if (pDataObject != NULL)
     {
       mDataObject2MathObject[pDataObject] = pMathObject;
       mDataValue2MathObject[(C_FLOAT64 *) pDataObject->getValuePointer()] = pMathObject;
     }
 }

void CMathContainer::pushInitialState ( )

Push the initial state to the associated model

Definition at line 461 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, CMathObject::getDataObject(), CCopasiObject::getValuePointer(), mInitialState, mObjects, and CVectorCore< CType >::size().

 {
   C_FLOAT64 * pValue = mInitialState.array();
   C_FLOAT64 * pValueEnd = pValue + mInitialState.size();
   CMathObject * pObject = mObjects.array();
 
   for (; pValue != pValueEnd; ++pValue, ++pObject)
     {
       const CCopasiObject * pDataObject = pObject->getDataObject();
 
       if (pDataObject != NULL)
         {
           *(C_FLOAT64 *)pDataObject->getValuePointer() = *pValue;
         }
     }
 
   return;
 }

void CMathContainer::pushState ( )

Push the state to the associated model

Definition at line 499 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, CMathObject::getDataObject(), CCopasiObject::getValuePointer(), mObjects, mState, and CVectorCore< CType >::size().

 {
   C_FLOAT64 * pValue = mState.array();
   C_FLOAT64 * pValueEnd = pValue + mState.size();
   CMathObject * pObject = mObjects.array();
 
   for (; pValue != pValueEnd; ++pValue, ++pObject)
     {
       const CCopasiObject * pDataObject = pObject->getDataObject();
 
       if (pDataObject != NULL)
         {
           *(C_FLOAT64 *)pDataObject->getValuePointer() = *pValue;
         }
     }
 
   return;
 }

CEvaluationNode * CMathContainer::replaceDiscontinuousNode	(	const CEvaluationNode *	pSrc,
		const std::vector< CEvaluationNode * > &	children
	)

Replace a discontinuous node by an object node pointing to newly created math objects, which are targets of automatically generated events.

Parameters

const	CEvaluationNode * pSrc
const	std::vector< CEvaluationNode * > & children

Returns: CEvaluationNode * pCopy

Definition at line 780 of file CMathContainer.cpp.

References CMathEventN::addAssignment(), CEvaluationNode::buildInfix(), C_FLOAT64, CEvaluationNode::copyNode(), createDiscontinuityTriggerInfix(), CMathObject::getValuePointer(), mCreateDiscontinuousPointer, mDiscontinuityInfix2Object, mTriggerInfix2Event, pdelete, CMathContainer::sDiscontinuous::pDiscontinuous, CMathContainer::sDiscontinuous::pEvent, CMathObject::setExpressionPtr(), and CMathEventN::setTriggerExpression().

Referenced by copyBranch().

 {
   bool success = true;
 
   CEvaluationNode * pNode = pSrc->copyNode(children);
   std::string DiscontinuityInfix = pNode->buildInfix();
 
   // Check whether we have the discontinuous node already created. This can happen if the
   // discontinuity was part of an expression for a variable in a function call.
   std::map< std::string, CMathObject * >::iterator itObject = mDiscontinuityInfix2Object.find(DiscontinuityInfix);
 
   if (itObject != mDiscontinuityInfix2Object.end())
     {
       // No need to copy we have already on object
       CMathObject * pDiscontinuity = itObject->second;
 
       // We need to advance both creation pointer to assure that we have the correct allocation
       mCreateDiscontinuousPointer.pDiscontinuous += 1;
       mCreateDiscontinuousPointer.pEvent += 1;
 
       pdelete(pNode);
 
       // Return a pointer to a node pointing to the value of discontinuous object.
       return new CEvaluationNodeObject((C_FLOAT64 *) pDiscontinuity->getValuePointer());
     }
 
   // We have a new discontinuity
   CMathObject * pDiscontinuity = mCreateDiscontinuousPointer.pDiscontinuous;
   mCreateDiscontinuousPointer.pDiscontinuous += 1;
 
   // Map the discontinuity infix to the discontinuous object.
   mDiscontinuityInfix2Object[DiscontinuityInfix] = pDiscontinuity;
 
   // Create the expression to calculate the discontinuous object
   CMathExpression * pExpression = new CMathExpression("DiscontinuousExpression", *this);
   success &= static_cast< CEvaluationTree * >(pExpression)->setRoot(pNode);
   success &= pDiscontinuity->setExpressionPtr(pExpression);
 
   CMathEventN * pEvent = NULL;
 
   // Check whether we have already an event with the current trigger
   std::string TriggerInfix = createDiscontinuityTriggerInfix(pNode);
   std::map< std::string, CMathEventN * >::iterator itEvent = mTriggerInfix2Event.find(TriggerInfix);
 
   // We need to create an event.
   if (itEvent == mTriggerInfix2Event.end())
     {
       pEvent = mCreateDiscontinuousPointer.pEvent;
 
       // Set the trigger
       pEvent->setTriggerExpression(TriggerInfix, *this);
 
       // Map the trigger infix to the event.
       mTriggerInfix2Event[TriggerInfix] = pEvent;
     }
   else
     {
       pEvent = itEvent->second;
     }
 
   mCreateDiscontinuousPointer.pEvent += 1;
 
   // Add the current discontinuity as an assignment.
   pEvent->addAssignment(pDiscontinuity, pDiscontinuity);
 
   // Return a pointer to a node pointing to the value of discontinuous object.
   return new CEvaluationNodeObject((C_FLOAT64 *) pDiscontinuity->getValuePointer());
 }

void CMathContainer::setInitialState ( const CVectorCore< C_FLOAT64 > & initialState )

Set the initial state values, i.e., all initial values of objects of simulation type Fixed, Time, ODE, Dependent, and Independent. It includes only extensive values for species.

Parameters

const CVectorCore< C_FLOAT64 > & initialState

Definition at line 354 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, mInitialState, and CVectorCore< CType >::size().

 {
   assert(mInitialState.size() == initialState.size());
 
   memcpy(mInitialState.array(), initialState.array(), mInitialState.size() * sizeof(C_FLOAT64));
 }

void CMathContainer::setState ( const CVectorCore< C_FLOAT64 > & state )

Set the state values, i.e., all initial values of objects of simulation type Time, ODE, Dependent, and Independent. It includes only extensive values for species.

Parameters

const CVectorCore< C_FLOAT64 > & state

Definition at line 371 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, mState, and CVectorCore< CType >::size().

 {
   assert(mState.size() == state.size());
 
   memcpy(mState.array(), state.array(), mState.size() * sizeof(C_FLOAT64));
 }

void CMathContainer::setStateReduced ( const CVectorCore< C_FLOAT64 > & stateReduced )

Set the reduced state values, i.e., all initial values of objects of simulation type Time, ODE, Dependent, and Independent. It includes only extensive values for species.

Parameters

const CVectorCore< C_FLOAT64 > & stateReduced

Definition at line 388 of file CMathContainer.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, mStateReduced, and CVectorCore< CType >::size().

 {
   assert(mStateReduced.size() == stateReduced.size());
 
   memcpy(mStateReduced.array(), stateReduced.array(), mStateReduced.size() * sizeof(C_FLOAT64));
 }

void CMathContainer::setValues ( const CVectorCore< C_FLOAT64 > & values )

Set the values of all mathematical objects

Parameters

const CVectorCore< C_FLOAT64 > & values

Definition at line 337 of file CMathContainer.cpp.

References mValues, and CVectorCore< CType >::size().

 {
   assert(mValues.size() == values.size());
 
   mValues = values;
 }

void CMathContainer::updateInitialValues ( const CModelParameter::Framework & framework )

Calculate all dependent initial values based on initial extensive or intensive values

Parameters

const CModelParameter::Framework & framework

Definition at line 395 of file CMathContainer.cpp.

References applyUpdateSequence(), CModelParameter::Concentration, mSynchronizeInitialValuesSequenceExtensive, mSynchronizeInitialValuesSequenceIntensive, and CModelParameter::ParticleNumbers.

Referenced by init().

 {
   switch (framework)
     {
       case CModelParameter::Concentration:
         applyUpdateSequence(mSynchronizeInitialValuesSequenceIntensive);
         break;
 
       case CModelParameter::ParticleNumbers:
         applyUpdateSequence(mSynchronizeInitialValuesSequenceExtensive);
         break;
     }
 }

void CMathContainer::updateSimulatedValues ( const bool & useMoieties )

Calculate all values required for simulation based on the current state

Parameters

const bool & useMoieties

Definition at line 419 of file CMathContainer.cpp.

References applyUpdateSequence(), mSimulationValuesSequence, and mSimulationValuesSequenceReduced.

 {
   if (useMoieties)
     {
       applyUpdateSequence(mSimulationValuesSequenceReduced);
     }
   else
     {
       applyUpdateSequence(mSimulationValuesSequence);
     }
 }

Member Data Documentation

CObjectInterface::UpdateSequence CMathContainer::mApplyInitialValuesSequence

private

The sequence of updates needed to apply the initial values

Definition at line 542 of file CMathContainer.h.

Referenced by applyInitialValues(), and createApplyInitialValuesSequence().

size_t CMathContainer::mAssignmentCount

private

Definition at line 500 of file CMathContainer.h.

Referenced by initializeObjects().

sDiscontinuous CMathContainer::mCreateDiscontinuousPointer

private

Structure of pointers used for creating discontinuities.

Definition at line 610 of file CMathContainer.h.

Referenced by initializeDiscontinuousCreationPointer(), and replaceDiscontinuousNode().

std::map< CCopasiObject *, CMathObject * > CMathContainer::mDataObject2MathObject

private

A map from data objects to math objects

Definition at line 615 of file CMathContainer.h.

Referenced by CMathContainer(), getMathObject(), and map().

std::map< C_FLOAT64 *, CMathObject * > CMathContainer::mDataValue2MathObject

private

A map from data objects values to math objects

Definition at line 620 of file CMathContainer.h.

Referenced by CMathContainer(), getMathObject(), and map().

size_t CMathContainer::mDependentCount

private

Definition at line 499 of file CMathContainer.h.

Referenced by allocate(), and initializeObjects().

CVectorCore< C_FLOAT64 > CMathContainer::mDependentMasses

private

Definition at line 492 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CCopasiVector< CEvent > CMathContainer::mDiscontinuityEvents

private

A vector of data events for discontinuities

Definition at line 625 of file CMathContainer.h.

Referenced by allocate(), createDiscontinuityDataEvent(), and init().

std::map< std::string, CMathObject * > CMathContainer::mDiscontinuityInfix2Object

private

A map from the infix of the expression of a discontinuity to the object representing it.

Definition at line 631 of file CMathContainer.h.

Referenced by init(), and replaceDiscontinuousNode().

CVectorCore< C_FLOAT64 > CMathContainer::mDiscontinuous

private

Definition at line 493 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), initializeDiscontinuousCreationPointer(), initializeObjects(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mEventAssignments

private

Definition at line 488 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mEventDelays

private

Definition at line 486 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), createApplyInitialValuesSequence(), getInitialValuePointer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mEventPriorities

private

Definition at line 487 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mEventRoots

private

Definition at line 489 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), createUpdateSimulationValuesSequence(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mEventRootStates

private

Definition at line 490 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), createUpdateSimulationValuesSequence(), and initializePointers().

CVector< CMathEventN > CMathContainer::mEvents

private

A vector containing all math events.

Definition at line 600 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), compileEvents(), initializeDiscontinuousCreationPointer(), and initializeEvents().

size_t CMathContainer::mEventTargetCount

private

Definition at line 496 of file CMathContainer.h.

Referenced by allocate(), createUpdateSimulationValuesSequence(), and initializeObjects().

CVectorCore< C_FLOAT64 > CMathContainer::mEventTriggers

private

Definition at line 484 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mExtensiveRates

private

Definition at line 479 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), createUpdateSimulationValuesSequence(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mExtensiveValues

private

Definition at line 477 of file CMathContainer.h.

Referenced by allocate(), applyInitialValues(), CMathContainer(), createApplyInitialValuesSequence(), createDependencyGraphs(), createSynchronizeInitialValuesSequence(), createUpdateSimulationValuesSequence(), getInitialValuePointer(), and initializePointers().

size_t CMathContainer::mFixedCount

private

Definition at line 495 of file CMathContainer.h.

Referenced by allocate(), createUpdateSimulationValuesSequence(), and initializeObjects().

CVectorCore< C_FLOAT64 > CMathContainer::mFluxes

private

Definition at line 482 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

size_t CMathContainer::mIndependentCount

private

Definition at line 498 of file CMathContainer.h.

Referenced by allocate(), and initializeObjects().

CMathDependencyGraph CMathContainer::mInitialDependencies

private

Dependency graph for initial value calculations

Definition at line 520 of file CMathContainer.h.

Referenced by createDependencyGraphs(), and createSynchronizeInitialValuesSequence().

CVectorCore< C_FLOAT64 > CMathContainer::mInitialEventTriggers

private

Definition at line 475 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mInitialExtensiveRates

private

Definition at line 470 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), createSynchronizeInitialValuesSequence(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mInitialExtensiveValues

private

Definition at line 468 of file CMathContainer.h.

Referenced by allocate(), applyInitialValues(), CMathContainer(), createDependencyGraphs(), getInitialValuePointer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mInitialFluxes

private

Definition at line 473 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mInitialIntensiveRates

private

Definition at line 471 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mInitialIntensiveValues

private

Definition at line 469 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mInitialParticleFluxes

private

Definition at line 472 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mInitialState

private

The initial state contains also all fixed values

Definition at line 505 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), fetchInitialState(), getInitialState(), pushInitialState(), and setInitialState().

CObjectInterface::ObjectSet CMathContainer::mInitialStateValueExtensive

private

The set of objects which determine the initial state of the model based on extensive values

Definition at line 560 of file CMathContainer.h.

Referenced by createSynchronizeInitialValuesSequence().

CObjectInterface::ObjectSet CMathContainer::mInitialStateValueIntensive

private

The set of objects which determine the initial state of the model based on intensive values

Definition at line 566 of file CMathContainer.h.

Referenced by createSynchronizeInitialValuesSequence().

CVectorCore< C_FLOAT64 > CMathContainer::mInitialTotalMasses

private

Definition at line 474 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mIntensiveRates

private

Definition at line 480 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), createUpdateSimulationValuesSequence(), and initializePointers().

CVectorCore< C_FLOAT64 > CMathContainer::mIntensiveValues

private

Definition at line 478 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVector< CMathObject > CMathContainer::mObjects

private

The objects which are required to be up to date for simulation of the reduced model, i.e., the right hand side of ODEs, rates of independent species determined by reaction, and event roots. A vector containing all math objects.

Definition at line 595 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), compileObjects(), createApplyInitialValuesSequence(), createDependencyGraphs(), createSynchronizeInitialValuesSequence(), createUpdateSimulationValuesSequence(), fetchInitialState(), fetchState(), getMathObject(), init(), initializeDiscontinuousCreationPointer(), initializePointers(), pushInitialState(), and pushState().

size_t CMathContainer::mODECount

private

Definition at line 497 of file CMathContainer.h.

Referenced by allocate(), and initializeObjects().

CVectorCore< C_FLOAT64 > CMathContainer::mParticleFluxes

private

Definition at line 481 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

const CObjectInterface* CMathContainer::mpAvogadro

private

Definition at line 463 of file CMathContainer.h.

Referenced by CMathContainer(), and createNodeFromObject().

CModel* CMathContainer::mpModel

private

A pointer to the data model which mathematics are contained

Definition at line 462 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), compileEvents(), createDiscontinuityEvents(), getCN(), getMathObject(), getModel(), getObject(), init(), and initializeObjects().

const CObjectInterface* CMathContainer::mpQuantity2NumberFactor

private

Definition at line 464 of file CMathContainer.h.

Referenced by CMathContainer(), and createNodeFromObject().

CVectorCore< C_FLOAT64 > CMathContainer::mPropensities

private

Definition at line 491 of file CMathContainer.h.

Referenced by allocate(), CMathContainer(), and initializePointers().

CVector< CMathReaction > CMathContainer::mReactions

private

A vector containing all math reactions.

Definition at line 605 of file CMathContainer.h.

Referenced by CMathContainer(), and init().

CObjectInterface::ObjectSet CMathContainer::mReducedStateValues

private

The set of objects which determine the transient state of the reduced model

Definition at line 576 of file CMathContainer.h.

Referenced by createUpdateSimulationValuesSequence().

CObjectInterface::ObjectSet CMathContainer::mSimulationRequiredValues

private

The objects which are required to be up to date for simulation of the full model, i.e., the right hand side of ODEs, rates of species determined by reaction, and event roots.

Definition at line 583 of file CMathContainer.h.

Referenced by createUpdateSimulationValuesSequence().

CObjectInterface::UpdateSequence CMathContainer::mSimulationValuesSequence

private

The sequence of updates needed to calculate all simulation required values based on the assumption that all state values may have changed

Definition at line 548 of file CMathContainer.h.

Referenced by createUpdateSimulationValuesSequence(), and updateSimulatedValues().

CObjectInterface::UpdateSequence CMathContainer::mSimulationValuesSequenceReduced

private

The sequence of updates needed to calculate all simulation required values based on the assumption that all state values may have changed

Definition at line 554 of file CMathContainer.h.

Referenced by createUpdateSimulationValuesSequence(), and updateSimulatedValues().