#include <CMathContainer.h>

Inheritance diagram for CMathContainer:

Classes
struct	sDiscontinuous

struct	sSize

Public Member Functions
CMathEvent *	addAnalysisEvent (const CEvent *pDataEvent)

CMath::Entity< CMathObject >	addAnalysisObject (const CMath::Entity< CDataObject > &dataObjects, const CMath::SimulationType &simulationType, const std::string &infix)

void	addNoiseInputObject (const CMathObject *pObject)

void	applyInitialValues ()

void	applyUpdateSequence (const CCore::CUpdateSequence &updateSequence)

bool	areObjectsConstant (const CObjectInterface::ObjectSet &objects) const

void	calculateElasticityDependencies (CMatrix< C_INT32 > &elasticityDependencies, const bool &reduced)

void	calculateJacobian (CMatrix< C_FLOAT64 > &jacobian, const C_FLOAT64 &derivationFactor, const bool &reduced, const bool &includeTime=false)

void	calculateJacobianDependencies (CMatrix< C_INT32 > &jacobianDependencies, const bool &reduced)

void	calculateRootDerivatives (CVector< C_FLOAT64 > &rootDerivatives)

	CMathContainer (CModel &model)

	CMathContainer (const CMathContainer &src)

void	compile ()

CMathContainer *	copy () const

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

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

void	deregisterUpdateSequence (CMathUpdateSequence *pUpdateSequence)

void	fetchInitialState ()

void	fetchState ()

const CCore::CUpdateSequence &	getApplyInitialValuesSequence () const

virtual CCommonName	getCN () const

CMathObject *	getCompartment (const CMathObject *pObject) const

const CVectorCore< C_FLOAT64 > &	getCompleteInitialState () const

const size_t &	getCountAssignments () const

const size_t &	getCountDependentSpecies () const

const size_t &	getCountFixed () const

const size_t &	getCountFixedEventTargets () const

size_t	getCountIndependentSpecies () const

size_t	getCountNoise () const

size_t	getCountODEs () const

CDataObject *	getDataObject (const C_FLOAT64 *pDataValue) const

const CVectorCore< C_FLOAT64 > &	getDelayLags () const

const CVectorCore< CMathEvent > &	getEvents () const

const CVectorCore< C_FLOAT64 > &	getFluxes () const

const CMathHistoryCore &	getHistory (const bool &reduced) const

const CMathDependencyGraph &	getInitialDependencies () const

CVectorCore< C_FLOAT64 > &	getInitialState ()

const CVectorCore< C_FLOAT64 > &	getInitialState () const

const CObjectInterface::ObjectSet &	getInitialStateObjects () const

CMathObject *	getInitialValueObject (const CMathObject *pObject) const

C_FLOAT64 *	getInitialValuePointer (const C_FLOAT64 *pValue) const

CMathObject *	getLargestReactionCompartment (const CMathReaction *pReaction) const

CMathObject *	getMathObject (const C_FLOAT64 *pDataValue) const

CMathObject *	getMathObject (const CCommonName &cn) const

CMathObject *	getMathObject (const CObjectInterface *pObject) const

CMathReaction *	getMathReaction (const CReaction *pReaction) const

const CModel &	getModel () const

const CVectorCore< C_FLOAT64 > &	getNoise (const bool &reduced) const

const CObjectInterface::ObjectSet &	getNoiseInputObjects () const

const CCore::CUpdateSequence &	getNoiseSequence (const bool &useMoieties) const

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

virtual const CObjectInterface *	getObjectFromCN (const CCommonName &cn) const

const CVectorCore< C_FLOAT64 > &	getParticleFluxes () const

CMathEventQueue &	getProcessQueue ()

C_FLOAT64	getProcessQueueExecutionTime () const

const CVectorCore< C_FLOAT64 > &	getPropensities () const

const C_FLOAT64 &	getQuantity2NumberFactor () const

const CObjectInterface *	getQuantity2NumberFactorObject () const

CRandom &	getRandomGenerator () const

const CDataObject *	getRandomObject () const

const CVectorCore< C_FLOAT64 > &	getRate (const bool &reduced) const

CVectorCore< CMathReaction > &	getReactions ()

const CVectorCore< CMathReaction > &	getReactions () const

const CVectorCore< bool > &	getRootIsDiscrete () const

const CVectorCore< bool > &	getRootIsTimeDependent () const

CVector< CMathEvent::CTrigger::CRootProcessor * > &	getRootProcessors ()

const CVectorCore< C_FLOAT64 > &	getRoots () const

const CObjectInterface::ObjectSet &	getSimulationUpToDateObjects () const

const CCore::CUpdateSequence &	getSimulationValuesSequence (const bool &useMoieties) const

const CVectorCore< C_FLOAT64 > &	getState (const bool &reduced) const

const CObjectInterface::ObjectSet &	getStateObjects (const bool &reduced=false) const

const CMatrix< C_FLOAT64 > &	getStoichiometry (const bool &reduced=false) const

const CCore::CUpdateSequence &	getSynchronizeInitialValuesSequence (const CCore::Framework &framework) const

const CVectorCore< C_FLOAT64 > &	getTotalMasses () const

const CCore::CUpdateSequence &	getTransientDataValueSequence () const

const CMathDependencyGraph &	getTransientDependencies () const

const CObjectInterface::ObjectSet &	getValueChangeProhibited () const

CMathObject *	getValueObject (const CMathObject *pInitialObject) const

C_FLOAT64 *	getValuePointer (const C_FLOAT64 *pInitialValue) const

CVectorCore< C_FLOAT64 > &	getValues ()

const CVectorCore< C_FLOAT64 > &	getValues () const

CVector< C_FLOAT64 >	initializeAtolVector (const C_FLOAT64 &baseTolerance, const bool &reduced) const

const bool &	isAutonomous () const

bool	isStateValid () const

bool	operator== (const CMathContainer &rhs)

CMath::StateChange	processQueue (const bool &equality)

void	processRoots (const bool &equality, const CVector< C_INT > &rootsFound)

void	processRoots (const CVector< C_INT > &rootsFound)

void	pushAllTransientValues ()

void	pushInitialState ()

void	pushState ()

void	registerUpdateSequence (CMathUpdateSequence *pUpdateSequence)

void	relocateObject (CMathObject *&pObject, const std::vector< CMath::sRelocate > &relocations) const

void	relocateObject (CObjectInterface *&pObject, const std::vector< CMath::sRelocate > &relocations) const

void	relocateObject (const CMathObject *&pObject, const std::vector< CMath::sRelocate > &relocations) const

void	relocateObject (const CObjectInterface *&pObject, const std::vector< CMath::sRelocate > &relocations) const

void	relocateObjectSet (CObjectInterface::ObjectSet &objectSet, const std::vector< CMath::sRelocate > &relocations) const

void	relocateUpdateSequence (CCore::CUpdateSequence &sequence, const std::vector< CMath::sRelocate > &relocations) const

void	relocateValue (C_FLOAT64 *&pValue, const std::vector< CMath::sRelocate > &relocations) const

void	relocateValue (const C_FLOAT64 *&pValue, const std::vector< CMath::sRelocate > &relocations) const

bool	removeAnalysisEvent (CMathEvent *&pMathEvent)

bool	removeAnalysisObject (CMath::Entity< CMathObject > &mathObjects)

void	removeDataObject (const CDataObject *pObject)

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

void	resetNoise ()

void	setCompleteInitialState (const CVectorCore< C_FLOAT64 > &initialState)

void	setHistory (const CMathHistoryCore &history)

void	setInitialState (const CVectorCore< C_FLOAT64 > &initialState)

void	setState (const CVectorCore< C_FLOAT64 > &state)

void	setValues (const CVectorCore< C_FLOAT64 > &values)

void	updateHistoryValues (const bool &useMoieties)

void	updateInitialValues (const CCore::Framework &framework)

void	updateNoiseValues (const bool &useMoieties)

void	updatePriorityValues ()

void	updateRootValues (const bool &useMoieties)

void	updateSimulatedValues (const bool &useMoieties)

void	updateTransientDataValues ()

virtual	~CMathContainer ()

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

virtual bool	appendDeletedDependentData (CUndoData &undoData) const

virtual bool	applyData (const CData &data, CUndoData::CChangeSet &changes) override

	CDataContainer (const CDataContainer &src, const CDataContainer *pParent)

	CDataContainer (const std::string &name, const CDataContainer *pParent=NO_PARENT, const std::string &type="CN", const CFlags< Flag > &flag=CFlags< Flag >::None)

virtual void	createUndoData (CUndoData &undoData, const CUndoData::Type &type, const CData &oldData=CData(), const CCore::Framework &framework=CCore::Framework::ParticleNumbers) const override

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

void	getDescendants (CDataObject::DataObjectSet &descendants, const bool &recursive=false) const

virtual size_t	getIndex (const CDataObject *pObject) const

virtual objectMap &	getObjects ()

virtual const objectMap &	getObjects () const

virtual const std::string	getUnits () const override

virtual const CDataObject *	getValueObject () const override

virtual CUndoObjectInterface *	insert (const CData &data) override

void	objectRenamed (CDataObject *pObject, const std::string &oldName)

virtual bool	remove (CDataObject *pObject)

virtual CData	toData () const override

virtual	~CDataContainer ()

Public Member Functions inherited from CDataObject
void	addIssue (const CIssue &issue)

void	addReference (const CDataContainer *pReference)

virtual void	calculateValue () override

	CDataObject (const CDataObject &src, const CDataContainer *pParent=NULL)

virtual void	destruct () override

virtual const CDataObject *	getDataObject () const override

virtual const std::string &	getKey () const

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

CDataModel *	getObjectDataModel () const

virtual std::string	getObjectDisplayName () const override

const CObjectInterface *	getObjectFromCN (const CCommonName &cn) const

const std::string &	getObjectName () const

CDataContainer *	getObjectParent () const

const std::string &	getObjectType () const

virtual const CObjectInterface::ObjectSet &	getPrerequisites () const override

virtual const CValidity &	getValidity () const override

virtual void *	getValuePointer () const override

bool	hasFlag (const Flag &flag) const

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

bool	prerequisitsContains (const DataObjectSet &objects) const

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

void	removeIssue (const CIssue &issue)

void	removeReference (const CDataContainer *pReference)

bool	setObjectName (const std::string &name)

virtual bool	setObjectParent (const CDataContainer *pParent)

void	validityChanged (const CValidity &changedValidity) override

void	validityRemoved (const CValidity &changedValidity)

virtual	~CDataObject ()

Public Member Functions inherited from CObjectInterface
	CObjectInterface ()

	CObjectInterface (const CObjectInterface &src)

virtual	~CObjectInterface ()

Public Member Functions inherited from CUndoObjectInterface
	CUndoObjectInterface ()

	CUndoObjectInterface (const CUndoObjectInterface &src)

bool	generateUuid ()

const xg::Guid &	getUuid () const

bool	setUuid (const std::string &uuid)

bool	setUuid (const xg::Guid &uuid)

virtual void	updateIndex (const size_t &index, const CUndoObjectInterface *pUndoObject)

virtual	~CUndoObjectInterface ()

Private Member Functions
void	allocate ()

void	analyzeRoots ()

void	calculateRootJacobian (CMatrix< C_FLOAT64 > &jacobian)

void	calculateRootJacobian (CMatrix< C_FLOAT64 > &jacobian, const CVector< C_FLOAT64 > &rates)

	CMathContainer ()

bool	compileDiscreteChanges ()

bool	compileEvents ()

bool	compileObjects ()

void	createApplyInitialValuesSequence ()

void	createDelays ()

void	createDependencyGraphs ()

void	createDiscontinuityDataEvent (const CEvaluationNode *pNode)

void	createDiscontinuityEvents ()

void	createDiscontinuityEvents (const CEvaluationTree pTree, const std::vector< CEvaluationNode > &variables)

std::string	createDiscontinuityTriggerInfix (const CEvaluationNode *pNode)

CEvaluationNode *	createNodeFromObject (const CObjectInterface *pMathObject)

CEvaluationNode *	createNodeFromValue (const C_FLOAT64 *pDataValue)

void	createRelocations (const sSize &size, std::vector< CMath::sRelocate > &Relocations)

void	createSynchronizeInitialValuesSequence ()

void	createUpdateAllTransientDataValuesSequence ()

void	createUpdateSequences ()

void	createUpdateSimulationValuesSequence ()

void	createValueChangeProhibited ()

void	finishResize ()

void	ignoreDiscontinuityEvent (CMathEvent *pEvent)

void	initializeDiscontinuousCreationPointer ()

void	initializeEvents (CMath::sPointers &pointers)

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

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

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

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

void	initializeObjects (CMath::sPointers &pointers)

void	initializePointers (CMath::sPointers &pointers)

void	map ()

std::vector< CMath::sRelocate >	move (sSize &size)

void	relocate (const sSize &size, const std::vector< CMath::sRelocate > &Relocations)

template<class CType >
void	relocateVector (CVectorCore< CType > &vector, size_t size, const std::vector< CMath::sRelocate > &relocations)

std::vector< CMath::sRelocate >	resize (sSize &size)

void	sanitizeDataValue2DataObject ()

Static Private Member Functions
static void	createRelocation (const size_t &oldSize, const size_t &newSize, CMath::sRelocate &relocate, std::vector< CMath::sRelocate > &relocations, const bool &modifiedAtEnd=true)

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

Private Attributes
CCore::CUpdateSequence	mApplyInitialValuesSequence

std::chrono::steady_clock::time_point	mCompileTime

CVectorCore< C_FLOAT64 >	mCompleteInitialState

sDiscontinuous	mCreateDiscontinuousPointer

std::map< const CDataObject , CMathObject >	mDataObject2MathObject

std::map< C_FLOAT64 , CDataObject >	mDataValue2DataObject

std::map< C_FLOAT64 , CMathObject >	mDataValue2MathObject

CVectorCore< C_FLOAT64 >	mDelayLags

CVectorCore< CMathDelay >	mDelays

CVectorCore< C_FLOAT64 >	mDelayValues

CVectorCore< C_FLOAT64 >	mDependentMasses

CDataVector< 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

CVectorCore< CMathEvent >	mEvents

CVectorCore< C_FLOAT64 >	mEventTriggers

CVectorCore< C_FLOAT64 >	mExtensiveNoise

CVectorCore< C_FLOAT64 >	mExtensiveRates

CVectorCore< C_FLOAT64 >	mExtensiveValues

CVectorCore< C_FLOAT64 >	mFluxes

CMathHistory	mHistory

CMathHistoryCore	mHistoryReduced

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	mInitialStateValueAll

CObjectInterface::ObjectSet	mInitialStateValueExtensive

CObjectInterface::ObjectSet	mInitialStateValueIntensive

CVectorCore< C_FLOAT64 >	mInitialTotalMasses

CVectorCore< C_FLOAT64 >	mIntensiveNoise

CVectorCore< C_FLOAT64 >	mIntensiveRates

CVectorCore< C_FLOAT64 >	mIntensiveValues

bool	mIsAutonomous

CObjectInterface::ObjectSet	mNoiseInputObjects

CVectorCore< C_FLOAT64 >	mNoiseReduced

CCore::CUpdateSequence	mNoiseSequence

CCore::CUpdateSequence	mNoiseSequenceReduced

size_t	mNumTotalRootsIgnored

CVectorCore< CMathObject >	mObjects

CVectorCore< CMathObject >	mOldObjects

CVectorCore< C_FLOAT64 >	mOldValues

CVectorCore< C_FLOAT64 >	mParticleFluxes

const CDataObject *	mpAvogadro

CModel *	mpModel

CMathObject *	mpObjectsBuffer

CMathEventQueue *	mpProcessQueue

const CDataObject *	mpQuantity2NumberFactor

CRandom *	mpRandomGenerator

CCore::CUpdateSequence	mPrioritySequence

CVectorCore< C_FLOAT64 >	mPropensities

C_FLOAT64 *	mpValuesBuffer

CDataObjectReference< C_FLOAT64 >	mRandom

CVectorCore< C_FLOAT64 >	mRate

CVectorCore< C_FLOAT64 >	mRateReduced

CVectorCore< C_FLOAT64 >	mReactionNoise

CVectorCore< C_FLOAT64 >	mReactionParticleNoise

CVectorCore< CMathReaction >	mReactions

CObjectInterface::ObjectSet	mReducedStateValues

std::multimap< size_t, size_t >	mRootCount2Events

CVector< C_FLOAT64 >	mRootDerivatives

CVector< C_FLOAT64 >	mRootDerivativesState

CVector< bool >	mRootIsDiscrete

CVector< bool >	mRootIsTimeDependent

CVector< CMathEvent::CTrigger::CRootProcessor * >	mRootProcessors

CCore::CUpdateSequence	mRootSequence

CCore::CUpdateSequence	mRootSequenceReduced

CObjectInterface::ObjectSet	mSimulationRequiredValues

CCore::CUpdateSequence	mSimulationValuesSequence

CCore::CUpdateSequence	mSimulationValuesSequenceReduced

sSize	mSize

CVectorCore< C_FLOAT64 >	mState

CVectorCore< C_FLOAT64 >	mStateReduced

CObjectInterface::ObjectSet	mStateValues

CCore::CUpdateSequence	mSynchronizeInitialValuesSequenceExtensive

CCore::CUpdateSequence	mSynchronizeInitialValuesSequenceIntensive

CVectorCore< C_FLOAT64 >	mTotalMasses

CCore::CUpdateSequence	mTransientDataObjectSequence

CMathDependencyGraph	mTransientDependencies

CVectorCore< C_FLOAT64 >	mTransitionTimes

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

std::set< CMathUpdateSequence * >	mUpdateSequences

CObjectInterface::ObjectSet	mValueChangeProhibited

CVectorCore< C_FLOAT64 >	mValues

Additional Inherited Members
Public Types inherited from CDataContainer
typedef CDataObjectMap	objectMap

Public Types inherited from CDataObject
typedef std::set< const CDataObject * >	DataObjectSet

enum	Flag { Container , Vector , Matrix , NameVector , Reference , ValueBool , ValueInt , ValueInt64 , ValueDbl , NonUniqueName , StaticString , ValueString , Separator , DisplayName , ModelEntity , Array , DataModel , Root , Gui , __SIZE }

Public Types inherited from CObjectInterface
typedef std::vector< const CDataContainer * >	ContainerList

typedef std::set< const CObjectInterface * >	ObjectSet

Static Public Member Functions inherited from CDataContainer
static CDataContainer *	fromData (const CData &data, CUndoObjectInterface *pParent)

Static Public Member Functions inherited from CDataObject
static CDataObject *	fromData (const CData &data, CUndoObjectInterface *pParent)

static void	sanitizeObjectName (std::string &name)

Static Public Member Functions inherited from CObjectInterface
static const CDataObject *	DataObject (const CObjectInterface *pInterface)

static CObjectInterface *	GetObjectFromCN (const ContainerList &listOfContainer, const CCommonName &objName)

Static Public Member Functions inherited from CUndoObjectInterface
template<class CType >
static CType *	fromData (const CData &, CUndoObjectInterface *)

Static Public Attributes inherited from CDataContainer
static const CObjectInterface::ContainerList	EmptyList

Protected Member Functions inherited from CDataContainer
template<class CType >
CDataMatrixReference< CType > *	addMatrixReference (const std::string &name, CType &reference, const CFlags< Flag > &flag=CFlags< Flag >::None)

template<class CType >
CDataObjectReference< CType > *	addObjectReference (const std::string &name, CType &reference, const CFlags< Flag > &flag=CFlags< Flag >::None)

template<class CType >
CDataVectorReference< CType > *	addVectorReference (const std::string &name, CType &reference, const CFlags< Flag > &flag=CFlags< Flag >::None)

	CDataContainer (const CDataContainer &src)

void	initObjects ()

Protected Member Functions inherited from CDataObject
	CDataObject ()

	CDataObject (const std::string &name, const CDataContainer pParent=static_cast< CDataContainer >((void *) 0), const std::string &type="CN", const CFlags< Flag > &flag=CFlags< Flag >::None)

Protected Attributes inherited from CDataContainer
objectMap	mObjects

Protected Attributes inherited from CDataObject
ObjectSet	mPrerequisits

std::set< CDataContainer * >	mReferences

Protected Attributes inherited from CObjectInterface
CValidity	mValidity

Constructor & Destructor Documentation

◆ CMathContainer() [1/3]

CMathContainer::CMathContainer ( )

private

Default Constructor

Referenced by copy().

◆ CMathContainer() [2/3]

CMathContainer::CMathContainer ( CModel & model )

Specific Constructor

Parameters

CModel & model

◆ CMathContainer() [3/3]

CMathContainer::CMathContainer ( const CMathContainer & src )

Copy constructor

Parameters

const CMathContainer & src

◆ ~CMathContainer()

CMathContainer::~CMathContainer ( )

virtual

Destructor

References CVectorCore< CType >::array(), deregisterUpdateSequence(), mDelays, mEvents, mpObjectsBuffer, mpProcessQueue, mpRandomGenerator, mpValuesBuffer, mReactions, mUpdateSequences, pdelete, pdeletev, and CDataObject::setObjectParent().

Member Function Documentation

◆ addAnalysisEvent()

CMathEvent * CMathContainer::addAnalysisEvent ( const CEvent * pDataEvent )

Add an event to the container. The dataEvent must remain in memory while in the math container.

Parameters

const CEvent * pDataEvent

Returns: const CMathEvent * pMathEvent

Referenced by CAnalyticsTask::createEvent(), and CCrossSectionTask::createEvent().

◆ addAnalysisObject()

CMath::Entity< CMathObject > CMathContainer::addAnalysisObject	(	const CMath::Entity< CDataObject > &	dataObjects,
		const CMath::SimulationType &	simulationType,
		const std::string &	infix
	)

Add an entity to the container const const CMath::Entity< CDataObject > & dataObjects const const CMath::SimulationType & simulationType const const std::string & infix

Returns: CMath::Entity< CMathObject > mathObjects

References CMath::__SIZE, CMathDependencyGraph::addObject(), CMath::Analysis, CVectorCore< CType >::array(), CMath::Assignment, C_FLOAT64, CMathObject::compile(), CMath::Conversion, CMathExpression::convertToInitialExpression(), copyBranch(), createUpdateSequences(), CMath::Dependent, CMath::EventTarget, fatalError, finishResize(), CMath::Fixed, CMathObject::getEntityType(), CEvaluationTree::getRoot(), CMathObject::getSimulationType(), CMathObject::getValuePointer(), CMathObject::getValueType(), CMath::Independent, CMathObject::initialize(), CMath::Entity< CType >::InitialRate, CMath::Entity< CType >::InitialValue, map(), mInitialDependencies, mObjects, mSize, CMathContainer::sSize::nAssignment, CMathContainer::sSize::nFixed, CMathContainer::sSize::nODE, CMath::ODE, CMath::Entity< CType >::Rate, CMath::Rate, resize(), CMathObject::setExpressionPtr(), CExpression::setInfix(), CVectorCore< CType >::size(), CMath::Time, CMath::Undefined, CMath::Entity< CType >::Value, and CMath::Value.

◆ addNoiseInputObject()

void CMathContainer::addNoiseInputObject ( const CMathObject * pObject )

Add a noise input object

Parameters

const CMathObject * pObject

References mNoiseInputObjects.

Referenced by CMathObject::compileNoise(), and CMathObject::compileReactionParticleNoise().

◆ allocate()

void CMathContainer::allocate ( )

private

Allocate the memory for objects and values

Referenced by compile().

◆ analyzeRoots()

void CMathContainer::analyzeRoots ( )

private

Analyze the number and type of roots, i.e., which roots are only changed during discrete event processing.

References CVectorCore< CType >::array(), C_FLOAT64, CCore::Default, CMathUpdateSequence::empty(), CMathObject::getExpressionPtr(), getMathObject(), CMathEvent::CTrigger::getRoots(), CMathEvent::getTrigger(), CMathDependencyGraph::getUpdateSequence(), CVectorCore< CType >::initialize(), CMathEvent::isDisabled(), mEventRoots, mEventRootStates, mEvents, CMathEvent::CTrigger::CRootProcessor::mpRoot, mRootDerivatives, mRootDerivativesState, mRootIsDiscrete, mRootIsTimeDependent, mRootProcessors, mSize, mState, mTransientDependencies, CMathContainer::sSize::nFixedEventTargets, CVector< CType >::resize(), and CVectorCore< CType >::size().

Referenced by addAnalysisEvent(), compile(), and removeAnalysisEvent().

◆ applyInitialValues()

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.

References applyUpdateSequence(), CVectorCore< CType >::array(), C_FLOAT64, C_INT, calculateRootDerivatives(), CMathObject::calculateValue(), CMathEvent::fire(), CMathEvent::fireAtInitialTime(), getMathObject(), mApplyInitialValuesSequence, mEventRoots, mEvents, mEventTriggers, mExtensiveValues, mInitialExtensiveValues, mpProcessQueue, mRootDerivatives, mRootDerivativesState, mRootProcessors, mState, mValues, processRoots(), CMathEvent::removePendingAction(), CVectorCore< CType >::size(), and CMathEventQueue::start().

Referenced by CModel::applyInitialValues(), CSensMethod::do_target_calculation(), CLyapTask::process(), CScanTask::process(), CSensTask::process(), CLNATask::process(), CMCATask::process(), CSteadyStateTask::process(), CTimeSensTask::processStart(), CTrajectoryTask::processStart(), and CTSSATask::processStart().

◆ applyUpdateSequence()

void CMathContainer::applyUpdateSequence ( const CCore::CUpdateSequence & updateSequence )

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

Parameters

const CCore::CUpdateSequence & updateSequence

References CMathUpdateSequence::begin(), CObjectInterface::calculateValue(), and CMathUpdateSequence::end().

Referenced by COptProblem::adjustStartValue(), applyInitialValues(), ResultData::applyToModelStateFromOptTask(), COptProblem::calculate(), CScanMethod::calculate(), CFitProblem::calculate(), CTimeSensMethod::calculate_dAssignments_dPar(), CTimeSensMethod::calculate_dAssignments_dState(), CTimeSensMethod::calculate_dRate_dPar(), CFitProblem::calculateCrossValidation(), CMathDelay::calculateDelayValues(), COptProblem::calculateStatistics(), COptProblem::checkFunctionalConstraints(), COptProblem::checkIntervals(), CFitProblem::createParameterSets(), CSensMethod::do_target_calculation(), CTrajAdaptiveSA::doSingleSSAStep(), CStochDirectMethod::doSingleStep(), CStochNextReactionMethod::doSingleStep(), CHybridMethodODE45::evalF(), COptProblem::evalMinimizeIntervals(), CStochasticRungeKuttaRI5::evalNoise(), CTrajectoryMethodDsaLsodar::fireReaction(), CMathEvent::getCalculationTime(), CMathEvent::getExecutionTime(), CMathEvent::getTargetValues(), COptProblem::restore(), CFitProblem::restore(), CStochDirectMethod::rootValue(), CMathEvent::setTargetValues(), CExperiment::storeExtendedTimeSeriesData(), CExperiment::sumOfSquares(), CExperiment::sumOfSquaresStore(), CNewtonMethod::targetFunction(), updateInitialValues(), CModel::updateInitialValues(), CExperiment::updateModelWithIndependentData(), updateNoiseValues(), CHybridMethod::updatePriorityQueue(), updatePriorityValues(), updateRootValues(), updateSimulatedValues(), and updateTransientDataValues().

◆ areObjectsConstant()

bool CMathContainer::areObjectsConstant ( const CObjectInterface::ObjectSet & objects ) const

Check whether all objects are constant, i.e., do never change during simulation

Parameters

const CObjectInterface::ObjectSet & objects

Returns: bool areObjectsConstant

References CMathUpdateSequence::empty(), CCore::EventHandling, CMathDependencyGraph::getUpdateSequence(), mStateValues, mTransientDependencies, and CCore::UpdateMoieties.

Referenced by CEvaluationNodeOperator::getUnit().

◆ calculateElasticityDependencies()

void CMathContainer::calculateElasticityDependencies	(	CMatrix< C_INT32 > &	elasticityDependencies,
		const bool &	reduced
	)

Calculates whether matrix elements in the elasticity matrix are identical to zero or not and stored it in the provided matrix. needs to be called before.

Parameters

CMatrix<	C_FLOAT64 > & elasticityDependencies
const	bool & reduced

References CVectorCore< CType >::array(), CMathUpdateSequence::begin(), CCore::Default, CMathUpdateSequence::end(), getMathObject(), getState(), CMathDependencyGraph::getUpdateSequence(), CMathUpdateSequence::insert(), mFluxes, mSize, mState, mTransientDependencies, CMathContainer::sSize::nFixedEventTargets, CMathContainer::sSize::nReactions, CMathContainer::sSize::nTime, CMatrix< CType >::resize(), CVectorCore< CType >::size(), and CCore::UseMoieties.

Referenced by CMCAMethod::calculateUnscaledElasticities().

◆ calculateJacobian()

void CMathContainer::calculateJacobian	(	CMatrix< C_FLOAT64 > &	jacobian,
		const C_FLOAT64 &	derivationFactor,
		const bool &	reduced,
		const bool &	includeTime = `false`
	)

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

Parameters

CMatrix<	C_FLOAT64 > & Jacobian
const	C_FLOAT64 & derivationFactor,
const	bool & reduced
const	bool & includeTime (default: false)

References CMatrix< CType >::array(), CVectorCore< CType >::array(), C_FLOAT64, getState(), max, mRate, mSize, mState, CMathContainer::sSize::nFixedEventTargets, CMatrix< CType >::resize(), CMatrix< CType >::size(), CVectorCore< CType >::size(), and updateSimulatedValues().

Referenced by CLNAMethod::calculateCovarianceMatrixReduced(), CSteadyStateMethod::calculateJacobian(), CSteadyStateMethod::doJacobian(), CLyapWolfMethod::evalF(), CTimeSensLsodaMethod::evalF(), CCSPMethod::step(), CILDMMethod::step(), CILDMModifiedMethod::step(), and CNewtonMethod::targetFunctionDistance().

◆ calculateJacobianDependencies()

void CMathContainer::calculateJacobianDependencies	(	CMatrix< C_INT32 > &	jacobianDependencies,
		const bool &	reduced
	)

Calculates whether matrix elements in the Jacobian are identical to zero or not and stored it in the provided matrix. needs to be called before.

Parameters

CMatrix<	C_FLOAT64 > & jacobianDependencies
const	bool & reduced

References CVectorCore< CType >::array(), CMathUpdateSequence::begin(), CCore::Default, CMathUpdateSequence::end(), getMathObject(), getState(), CMathDependencyGraph::getUpdateSequence(), CMathUpdateSequence::insert(), mRate, mSize, mState, mTransientDependencies, CMathContainer::sSize::nFixedEventTargets, CMathContainer::sSize::nTime, CMatrix< CType >::resize(), CVectorCore< CType >::size(), and CCore::UseMoieties.

◆ calculateRootDerivatives()

void CMathContainer::calculateRootDerivatives ( CVector< C_FLOAT64 > & rootDerivatives )

Calculate the time derivative of all roots

Parameters

CVector< C_FLOAT64 > & rootDerivatives

References CVectorCore< CType >::array(), calculateRootJacobian(), dgemm::eval(), mRate, mSize, CMathContainer::sSize::nFixedEventTargets, CMatrix< CType >::numCols(), and updateRootValues().

Referenced by applyInitialValues(), CTimeSensLsodaMethod::createRootMask(), CHybridMethodODE45::createRootMask(), CLsodaMethod::createRootMask(), CLsodaMethod2::createRootMask(), CRadau5Method::createRootMask(), and CStochasticRungeKuttaRI5::createRootMask().

◆ calculateRootJacobian() [1/2]

void CMathContainer::calculateRootJacobian ( CMatrix< C_FLOAT64 > & jacobian )

private

Calculate the partial derivative of the root values with respect to the continuous state variables

Parameters

CMatrix< C_FLOAT64 > & jacobian

References CMatrix< CType >::array(), CVectorCore< CType >::array(), C_FLOAT64, mEventRoots, min, mRate, mSize, mState, CMathContainer::sSize::nFixedEventTargets, CMathContainer::sSize::nODE, CMathContainer::sSize::nODESpecies, CMathContainer::sSize::nReactionSpecies, CMathContainer::sSize::nTime, CMatrix< CType >::resize(), CMatrix< CType >::size(), CVectorCore< CType >::size(), and updateRootValues().

Referenced by calculateRootDerivatives().

◆ calculateRootJacobian() [2/2]

void CMathContainer::calculateRootJacobian	(	CMatrix< C_FLOAT64 > &	jacobian,
		const CVector< C_FLOAT64 > &	rates
	)

private

Calculate the Jacobian for the roots.

Parameters

CMatrix<	C_FLOAT64 > & jacobian
const	CVector< C_FLOAT64 > & rates

◆ compile()

void CMathContainer::compile ( )

Compile the mathematical model

References allocate(), analyzeRoots(), CVectorCore< CType >::array(), CDataVector< CType >::begin(), CDataVector< CType >::clear(), compileEvents(), compileObjects(), createDelays(), createDependencyGraphs(), createUpdateSequences(), CMathDelay::createUpdateSequences(), createValueChangeProhibited(), CCore::DelayValues, CMathUpdateSequence::empty(), CDataVector< CType >::end(), fatalError, getMathObject(), CModel::getReactions(), CMathDependencyGraph::getUpdateSequence(), CMathReaction::initialize(), initializeDiscontinuousCreationPointer(), initializeEvents(), initializeObjects(), initializePointers(), map(), mCompileTime, mDelays, mDelayValues, mDiscontinuityEvents, mDiscontinuityInfix2Object, mObjects, mpModel, mReactions, mRootCount2Events, mTransientDependencies, mTriggerInfix2Event, CCore::ParticleNumbers, CVectorCore< CType >::size(), and updateInitialValues().

Referenced by CModel::compile().

◆ compileDiscreteChanges()

bool CMathContainer::compileDiscreteChanges ( )

private

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

◆ compileEvents()

bool CMathContainer::compileEvents ( )

private

Compile the events

References CVectorCore< CType >::array(), CDataVector< CType >::begin(), CMathEvent::compile(), CDataVector< CType >::end(), CModel::getEvents(), ignoreDiscontinuityEvent(), mCreateDiscontinuousPointer, mDiscontinuityEvents, mEvents, mNumTotalRootsIgnored, mpModel, mRootCount2Events, and CMathContainer::sDiscontinuous::pEvent.

Referenced by compile().

◆ compileObjects()

bool CMathContainer::compileObjects ( )

private

Compile the objects

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

Referenced by compile().

◆ copy()

CMathContainer * CMathContainer::copy ( ) const

References CMathContainer().

Referenced by CMathContext::sync().

◆ copyBranch() [1/2]

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

Referenced by addAnalysisObject(), CMathExpression::CMathExpression(), CMathEvent::CTrigger::compile(), copyBranch(), and createDiscontinuityEvents().

◆ copyBranch() [2/2]

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

References CEvaluationNode::AVOGADRO, C_INVALID_INDEX, CEvaluationNode::CALL, CEvaluationNode::CEIL, CEvaluationNode::CHOICE, CEvaluationNode::CN, CNodeContextIterator< Node, Context >::context(), copyBranch(), CEvaluationNode::copyNode(), createNodeFromObject(), CObjectInterface::DataObject(), CEvaluationNode::DEFAULT, CNodeContextIterator< Node, Context >::end(), CEvaluationNode::EXPRESSION, CEvaluationNode::FLOOR, CEvaluationNode::FUNCTION, CEvaluationNodeCall::getCalledTree(), CEvaluationNodeVariable::getIndex(), getMathObject(), getObject(), CEvaluationNodeObject::getObjectCN(), CEvaluationNodeObject::getObjectInterfacePtr(), CEvaluationNodeObject::getObjectValuePtr(), CEvaluationTree::getRoot(), CEvaluationNode::IF, CEvaluationNode::MODULUS, mpAvogadro, CEvaluationNode::NaN, CNodeContextIterator< Node, Context >::next(), CEvaluationNode::OBJECT, CEvaluationNode::OPERATOR, CNodeContextIterator< Node, Context >::parentContextPtr(), CEvaluationNode::POINTER, CEvaluationNode::REMAINDER, replaceDiscontinuousNode(), and CEvaluationNode::VARIABLE.

◆ createApplyInitialValuesSequence()

void CMathContainer::createApplyInitialValuesSequence ( )

private

◆ createDelays()

void CMathContainer::createDelays ( )

private

◆ createDependencyGraphs()

void CMathContainer::createDependencyGraphs ( )

private

Create Dependency Graphs

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

Referenced by compile().

◆ createDiscontinuityDataEvent()

void CMathContainer::createDiscontinuityDataEvent ( const CEvaluationNode * pNode )

private

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

Parameters

const CEvaluationNode * pNode

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

Referenced by createDiscontinuityEvents().

◆ createDiscontinuityEvents() [1/2]

void CMathContainer::createDiscontinuityEvents ( )

private

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

References CModel::getTreesWithDiscontinuities(), mpModel, and CEvaluationNode::NaN.

Referenced by allocate().

◆ createDiscontinuityEvents() [2/2]

void CMathContainer::createDiscontinuityEvents	(	const CEvaluationTree *	pTree,
		const std::vector< CEvaluationNode * > &	variables
	)

private

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

Parameters

const	CEvaluationTree * pTree
const	std::vector< CEvaluationNode * > & variables

References CEvaluationNode::CALL, CEvaluationNode::CEIL, CEvaluationNode::CHOICE, copyBranch(), createDiscontinuityDataEvent(), CEvaluationNode::DEFAULT, CNodeContextIterator< Node, Context >::end(), CEvaluationNode::EXPRESSION, fatalError, CEvaluationNode::FLOOR, CEvaluationNode::FUNCTION, CEvaluationTree::getRoot(), CEvaluationNode::IF, CEvaluationNode::MODULUS, CNodeContextIterator< Node, Context >::next(), CEvaluationNode::OPERATOR, pdelete, CEvaluationNode::REMAINDER, and CEvaluationNode::VARIABLE.

◆ createDiscontinuityTriggerInfix()

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

References CEvaluationNode::CEIL, CEvaluationNode::CHOICE, fatalError, CEvaluationNode::FLOOR, CEvaluationNode::FUNCTION, CCopasiNode< _Data >::getChild(), CEvaluationNode::IF, CEvaluationNode::mainType(), CEvaluationNode::MODULUS, CEvaluationNode::OPERATOR, CEvaluationNode::REMAINDER, and CEvaluationNode::subType().

Referenced by createDiscontinuityDataEvent(), and replaceDiscontinuousNode().

◆ createNodeFromObject()

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

References C_FLOAT64, CObjectInterface::getDataObject(), CObjectInterface::getValuePointer(), mDataValue2DataObject, and CEvaluationNode::NaN.

Referenced by copyBranch().

◆ createNodeFromValue()

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

References C_FLOAT64, getMathObject(), CMathObject::getValuePointer(), and CEvaluationNode::NaN.

◆ createRelocation()

void CMathContainer::createRelocation	(	const size_t &	oldSize,
		const size_t &	newSize,
		CMath::sRelocate &	relocate,
		std::vector< CMath::sRelocate > &	relocations,
		const bool &	modifiedAtEnd = `true`
	)

staticprivate

Modify the current relocation information based on old and new sizes. If appropriate append the relocation information to the vector of relocations. The size modification can appear at the beginning or the end of the current section.

Parameters

const	size_t & oldSize
const	size_t & newSize
CMath::sRelocate	& currentRelocation
std::vector<	CMath::sRelocate > & relocations
const	bool & modifiedAtEnd (Default: true)

References min, CMath::sRelocate::offset, CMath::sRelocate::pObjectEnd, CMath::sRelocate::pObjectStart, CMath::sRelocate::pValueEnd, and CMath::sRelocate::pValueStart.

Referenced by createRelocations(), and ignoreDiscontinuityEvent().

◆ createRelocations()

void CMathContainer::createRelocations	(	const sSize &	size,
		std::vector< CMath::sRelocate > &	Relocations
	)

private

Create relocation information

Parameters

const	sSize & size
std::vector<	CMath::sRelocate > & Relocations

Referenced by move().

◆ createSynchronizeInitialValuesSequence()

void CMathContainer::createSynchronizeInitialValuesSequence ( )

private

Create the update sequences needed to synchronize the initial values

References CMath::__SIZE, CVectorCore< CType >::array(), CMath::Assignment, CMath::Conversion, CMath::Dependent, CMath::EventTarget, CMath::Fixed, CMathObject::getCorrespondingProperty(), CMathObject::getEntityType(), getMathObject(), CMathObject::getPrerequisites(), CMathObject::getSimulationType(), CMathDependencyGraph::getUpdateSequence(), CMathObject::getValueType(), CMath::Independent, CMathObject::isIntensiveProperty(), mDataValue2DataObject, mExtensiveValues, mInitialDependencies, mInitialStateValueAll, mInitialStateValueExtensive, mInitialStateValueIntensive, mObjects, mpAvogadro, mpQuantity2NumberFactor, mSynchronizeInitialValuesSequenceExtensive, mSynchronizeInitialValuesSequenceIntensive, mValueChangeProhibited, CMath::ODE, CMath::Species, CMath::Time, CCore::UpdateMoieties, and CMath::Value.

Referenced by createUpdateSequences().

◆ createUpdateAllTransientDataValuesSequence()

void CMathContainer::createUpdateAllTransientDataValuesSequence ( )

private

Create the update sequences used to calculate all transient data values

References CVectorCore< CType >::array(), CCore::Default, CMathObject::getDataObject(), CMathDependencyGraph::getUpdateSequence(), mExtensiveValues, mObjects, mSimulationRequiredValues, mStateValues, mTransientDataObjectSequence, mTransientDependencies, mValues, and CVectorCore< CType >::size().

Referenced by createUpdateSequences().

◆ createUpdateSequences()

void CMathContainer::createUpdateSequences ( )

private

Create Update Sequences

References CVectorCore< CType >::array(), createApplyInitialValuesSequence(), createSynchronizeInitialValuesSequence(), createUpdateAllTransientDataValuesSequence(), CMathEvent::createUpdateSequences(), createUpdateSimulationValuesSequence(), mEvents, sanitizeDataValue2DataObject(), and CVectorCore< CType >::size().

Referenced by addAnalysisEvent(), addAnalysisObject(), compile(), removeAnalysisEvent(), and removeAnalysisObject().

◆ createUpdateSimulationValuesSequence()

void CMathContainer::createUpdateSimulationValuesSequence ( )

private

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

References CMathDependencyGraph::appendAllDependents(), CVectorCore< CType >::array(), CCore::Default, CMath::Dependent, CMath::EventTarget, getMathObject(), CMathObject::getSimulationType(), CMathDependencyGraph::getUpdateSequence(), CMath::Independent, mDelayLags, mEventDelays, mEventPriorities, mEventRoots, mEventRootStates, mExtensiveNoise, mExtensiveRates, mExtensiveValues, mIsAutonomous, mNoiseSequence, mNoiseSequenceReduced, mObjects, mPrioritySequence, mReducedStateValues, mRootSequence, mRootSequenceReduced, mSimulationRequiredValues, mSimulationValuesSequence, mSimulationValuesSequenceReduced, mSize, mState, mStateValues, mTransientDependencies, mValueChangeProhibited, mValues, CMathContainer::sSize::nFixed, CMathContainer::sSize::nFixedEventTargets, CMathContainer::sSize::nODE, CMathContainer::sSize::nODESpecies, CMathContainer::sSize::nReactionSpecies, CMathContainer::sSize::nTime, CMath::ODE, CVectorCore< CType >::size(), CMath::Time, and CCore::UseMoieties.

Referenced by createUpdateSequences().

◆ createValueChangeProhibited()

void CMathContainer::createValueChangeProhibited ( )

private

Create the set of object for which the initial value change is prohibited

References CVectorCore< CType >::array(), CDataVector< CType >::begin(), CCore::Default, CDataVector< CType >::end(), CModel::getCompartments(), CMathObject::getCompartmentValue(), CMathObject::getCorrespondingProperty(), CMathObject::getEntityType(), getMathObject(), CMathObject::getValueType(), CMathDependencyGraph::hasCircularDependencies(), mExtensiveRates, mExtensiveValues, mInitialDependencies, mInitialExtensiveRates, mObjects, mpModel, mTransientDependencies, mValueChangeProhibited, CMathDependencyGraph::removePrerequisite(), CMath::Species, CCore::UpdateMoieties, and CMath::Value.

Referenced by compile().

◆ deregisterUpdateSequence()

void CMathContainer::deregisterUpdateSequence ( CMathUpdateSequence * pUpdateSequence )

Deregister and update sequence.

Parameters

CMathUpdateSequence * pUpdateSeqeunce

References mUpdateSequences, and CMathUpdateSequence::setMathContainer().

Referenced by CMathUpdateSequence::setMathContainer(), ~CMathContainer(), and CMathUpdateSequence::~CMathUpdateSequence().

◆ fetchInitialState()

void CMathContainer::fetchInitialState ( )

Fetch the initial state from the associated model

References CVectorCore< CType >::array(), CMath::Assignment, C_FLOAT64, CMathObject::getDataObject(), CMathObject::getSimulationType(), CDataObject::getValuePointer(), mInitialState, mObjects, and CVectorCore< CType >::size().

Referenced by CModel::applyInitialValues(), CModel::compile(), and CModel::updateInitialValues().

◆ fetchState()

void CMathContainer::fetchState ( )

Fetch the state from the associated model

References CVectorCore< CType >::begin(), C_FLOAT64, CVectorCore< CType >::end(), CMathObject::getDataObject(), getMathObject(), CDataObject::getValuePointer(), and mState.

Referenced by CModel::stateToIntialState().

◆ finishResize()

void CMathContainer::finishResize ( )

private

Complete resize and release temporary objects

References CVectorCore< CType >::array(), CVectorCore< CType >::initialize(), mObjects, mOldObjects, mOldValues, and mValues.

Referenced by addAnalysisEvent(), addAnalysisObject(), allocate(), createDelays(), removeAnalysisEvent(), and removeAnalysisObject().

◆ getApplyInitialValuesSequence()

const CCore::CUpdateSequence & CMathContainer::getApplyInitialValuesSequence ( ) const

Retrieve the sequence for applying the initial values to the transient values.

Returns: CCore::CUpdateSequence & applyInitialValuesSequence

References mApplyInitialValuesSequence.

◆ getCN()

CCommonName 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: CCommonName

Reimplemented from CDataObject.

References CDataObject::getCN(), and mpModel.

◆ getCompartment()

CMathObject * CMathContainer::getCompartment ( const CMathObject * pObject ) const

Retrieve the pointer to the compartment of a species related object otherwise NULL

Parameters

const CMathObject * pObject CMathObject * pCompartment

References CMetab::getCompartment(), CMathObject::getDataObject(), CMathObject::getEntityType(), getMathObject(), CDataObject::getObjectParent(), CModelEntity::getValueReference(), and CMath::Species.

Referenced by getLargestReactionCompartment(), CNewtonMethod::initialize(), and CMCAMethod::scaleMCA().

◆ getCompleteInitialState()

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

Retrieves the complete initial state values, i.e., all initial values including all internal values.

Returns: const CVectorCore< C_FLOAT64 > & initialState

References mCompleteInitialState.

Referenced by COptProblem::adjustStartValuesForIntervals(), CFitProblem::calculate(), CFitProblem::calculateCrossValidation(), CFitProblem::createParameterSets(), CFitProblem::initialize(), and CFitProblem::updateInitialState().

◆ getCountAssignments()

const size_t & CMathContainer::getCountAssignments ( ) const

Retrieve the count of assignments

Returns: const size_t & countDependentSpecies

References mSize, and CMathContainer::sSize::nAssignment.

Referenced by CTimeSeries::compile().

◆ getCountDependentSpecies()

const size_t & CMathContainer::getCountDependentSpecies ( ) const

Retrieve the count of dependent species

Returns: const size_t & countDependentSpecies

References mSize, and CMathContainer::sSize::nMoieties.

Referenced by CLNAMethod::calculateCovarianceMatrixFull(), CMCAMethod::calculateUnscaledElasticities(), CTimeSeries::compile(), CNewtonMethod::initialize(), CTrajectoryMethodDsaLsodar::CPartition::intialize(), CLNAMethod::resizeAllMatrices(), CMCAMethod::resizeAllMatrices(), CMCAMethod::scaleMCA(), CHybridMethod::start(), CHybridMethodODE45::start(), CStochMethod::start(), CTauLeapMethod::start(), CTrajAdaptiveSA::start(), CTrajectoryMethodDsaLsodar::start(), CCSPMethod::start(), and CStochDirectMethod::stateChange().

◆ getCountFixed()

const size_t & CMathContainer::getCountFixed ( ) const

Retrieve the count of fixed values, i.e., parameters

Returns: const size_t & countDependentSpecies

References mSize, and CMathContainer::sSize::nFixed.

Referenced by CTimeSensMethod::calculate_dInitialState_dPar(), CTimeSeries::compile(), CFitProblem::initialize(), and CCopasiTask::restore().

◆ getCountFixedEventTargets()

const size_t & CMathContainer::getCountFixedEventTargets ( ) const

Retrieve the count of fixed values which are changed through events

Returns: const size_t & countFixedEventTargets

References mSize, and CMathContainer::sSize::nFixedEventTargets.

Referenced by CSteadyStateMethod::allPositive(), CTimeSensMethod::calculate_dAssignments_dState(), CTimeSensMethod::calculate_dInitialState_dPar(), CTimeSensMethod::calculate_dRate_dPar(), CLNAMethod::calculateCovarianceMatrixReduced(), CMCAMethod::calculateUnscaledElasticities(), CTimeSeries::compile(), CMathEvent::compile(), CAnalyticsTask::eventCallBack(), CCrossSectionTask::eventCallBack(), CTimeSensLsodaMethod::hasStateChanged(), CLsodaMethod::hasStateChanged(), CRadau5Method::hasStateChanged(), CFitProblem::initialize(), CNewtonMethod::initialize(), CSteadyStateMethod::initialize(), CTSSATask::initialize(), CTimeSensMethod::initResult(), CTrajectoryMethodDsaLsodar::CPartition::intialize(), CLyapTask::process(), CSteadyStateTask::process(), CTimeSensTask::processStart(), CTrajectoryTask::processStart(), CAnalyticsTask::relativeDifferenceOfStates(), CCrossSectionTask::relativeDifferenceOfStates(), CCopasiTask::restore(), CMCAMethod::scaleMCA(), CTimeSensMethod::signalMathContainerChanged(), CTimeSensTask::signalMathContainerChanged(), CTrajectoryMethod::signalMathContainerChanged(), CTrajectoryTask::signalMathContainerChanged(), CLyapWolfMethod::start(), CMathEventQueue::start(), CTimeSensLsodaMethod::start(), CHybridMethod::start(), CHybridMethodODE45::start(), CLsodaMethod::start(), CLsodaMethod2::start(), CRadau5Method::start(), CStochasticRungeKuttaRI5::start(), CStochMethod::start(), CTauLeapMethod::start(), CTrajAdaptiveSA::start(), CTrajectoryMethod::start(), CTrajectoryMethodDsaLsodar::start(), CTSSAMethod::start(), CTimeSensLsodaMethod::stateChange(), CLsodaMethod::stateChange(), CLsodaMethod2::stateChange(), CRadau5Method::stateChange(), CStochDirectMethod::stateChange(), CTimeSensLsodaMethod::step(), CLsodaMethod::step(), CRadau5Method::step(), and CSteadyStateTask::updateMatrices().

◆ getCountIndependentSpecies()

size_t CMathContainer::getCountIndependentSpecies ( ) const

Retrieve the count of independent species

Returns: size_t countIndependentSpecies

References mSize, CMathContainer::sSize::nMoieties, and CMathContainer::sSize::nReactionSpecies.

Referenced by CLNAMethod::calculateCovarianceMatrixFull(), CLNAMethod::calculateCovarianceMatrixReduced(), CMCAMethod::calculateUnscaledElasticities(), CTimeSeries::compile(), CTrajectoryMethodDsaLsodar::CPartition::intialize(), CLyapMethod::isValidProblem(), CLNAMethod::resizeAllMatrices(), CMCAMethod::resizeAllMatrices(), CMCAMethod::scaleMCA(), CHybridMethod::start(), CHybridMethodODE45::start(), CStochMethod::start(), CTauLeapMethod::start(), CTrajAdaptiveSA::start(), CTrajectoryMethodDsaLsodar::start(), CTSSAMethod::start(), and CStochDirectMethod::stateChange().

◆ getCountNoise()

size_t CMathContainer::getCountNoise ( ) const

Retrieve the count of noise added to the system

Returns: size_t countNoise

References mNoiseInputObjects.

Referenced by CStochasticRungeKuttaRI5::start().

◆ getCountODEs()

size_t CMathContainer::getCountODEs ( ) const

◆ getDataObject()

CDataObject * CMathContainer::getDataObject ( const C_FLOAT64 * pDataValue ) const

Retrieve a pointer to the data object for a data value pointer

Parameters

const C_FLOAT64 * pDataValue

Returns: CDataObject * pDataObject

References C_FLOAT64, and mDataValue2DataObject.

Referenced by CEvaluationNodeObject::compile().

◆ getDelayLags()

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

Retrieve the vector of delay lags

Returns: const CVectorCore< C_FLOAT64 > & delayLags

References mDelayLags.

◆ getEntityType()

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

staticprivate

Determine the entity type of an entity

Parameters

const CModelEntity * pEntity

Returns: CMath::EntityType entityType

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

Referenced by initializeMathObjects().

◆ getEvents()

const CVectorCore< CMathEvent > & CMathContainer::getEvents ( ) const

Retrieve the events

Returns: const CVector< CMathEventN > & events

References mEvents.

Referenced by CHybridMethod::isValidProblem(), CStochMethod::isValidProblem(), CTauLeapMethod::isValidProblem(), CTrajAdaptiveSA::isValidProblem(), CTrajectoryMethodDsaLsodar::isValidProblem(), CCopasiMethod::isValidProblem(), and CRadau5Method::start().

◆ getFluxes()

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

Retrieve reaction fluxes.

Returns: const CVectorCore< C_FLOAT64 > & fluxes

References mFluxes.

Referenced by CHybridMethodODE45::partitionSystem(), and CMCAMethod::scaleMCA().

◆ getHistory()

const CMathHistoryCore & CMathContainer::getHistory ( const bool & reduced ) const

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

Parameters

const bool & reduced

Returns: const CMathHistoryCore & history

References mHistory, and mHistoryReduced.

◆ getInitialDependencies()

const CMathDependencyGraph & CMathContainer::getInitialDependencies ( ) const

Retrieve the initial dependencies

Returns: CMathDependencyGraph & getTransientDependencies

References mInitialDependencies.

Referenced by CModel::appendAllDependents(), CModel::appendDirectDependents(), ResultData::applyToModelStateFromOptTask(), CModel::buildInitialRefreshSequence(), CExperiment::compile(), CScanMethod::init(), COptProblem::initialize(), CFitProblem::initialize(), and CSensMethod::initialize().

◆ getInitialState() [1/2]

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

References mInitialState.

◆ getInitialState() [2/2]

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

References mInitialState.

Referenced by CScanMethod::calculate(), CTimeSensMethod::calculate_dInitialState_dPar(), CFitProblem::createParameterSets(), CScanMethod::init(), CFitProblem::initialize(), CCopasiTask::initialize(), and CCopasiTask::restore().

◆ getInitialStateObjects()

const CObjectInterface::ObjectSet & CMathContainer::getInitialStateObjects ( ) const

Retrieve the objects which represent the initial state.

Returns: CObjectInterface::ObjectSet & stateObjects

References mInitialStateValueAll.

Referenced by ResultData::applyToModelStateFromOptTask(), CModel::buildInitialRefreshSequence(), CExperiment::compile(), CScanMethod::init(), COptProblem::initialize(), CFitProblem::initialize(), and CSensMethod::initialize().

◆ getInitialValueObject()

CMathObject * CMathContainer::getInitialValueObject ( const CMathObject * pObject ) const

Retrieve the pointer to the corresponding initial value

Parameters

const CMathObject * pObject

Returns: CMathObject * pInitialValueObject

References getInitialValuePointer(), getMathObject(), and CMathObject::getValue().

Referenced by CModel::appendAllDependents(), CMathObject::compileParticleFlux(), and removeDataObject().

◆ getInitialValuePointer()

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

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

Referenced by CMathObject::compile(), CMathObject::compileDependentMass(), CMathObject::compileTotalMass(), CMathObject::createExtensiveReactionNoiseExpression(), CMathObject::createExtensiveReactionRateExpression(), and getInitialValueObject().

◆ getLargestReactionCompartment()

CMathObject * CMathContainer::getLargestReactionCompartment ( const CMathReaction * pReaction ) const

Retrieve the size of the largest compartment of the species changed in the reaction

Parameters

const CMathReaction * pReaction

Returns: CMathObject * pLargestCompartment

References C_FLOAT64, getCompartment(), CMathReaction::getObjectBalance(), and CMathObject::getValuePointer().

Referenced by CMCAMethod::scaleMCA().

◆ getMathObject() [1/3]

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

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

◆ getMathObject() [2/3]

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

Retrieve a pointer to the mathematical object for the given CN

Parameters

const CCommonName & cn

Returns: CMathObject * pMathObject

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

◆ getMathObject() [3/3]

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

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

Parameters

const CObjectInterface * pObject

Returns: CMathObject * pMathObject

References mDataObject2MathObject.

◆ getMathReaction()

CMathReaction * CMathContainer::getMathReaction ( const CReaction * pReaction ) const

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

Parameters

const CObjectInterface * pObject

Returns: CMathReaction * pMathReaction

References CVectorCore< CType >::array(), C_FLOAT64, CReaction::getFluxReference(), getMathObject(), CMathObject::getValuePointer(), mFluxes, and mReactions.

Referenced by CHybridMethodODE45::partitionSystem().

◆ getModel()

const CModel & CMathContainer::getModel ( ) const

Retrieve the model for the container

Returns: const CModel & model

References mpModel.

◆ getNoise()

const CVectorCore< C_FLOAT64 > & CMathContainer::getNoise ( const bool & reduced ) const

Retrieve the noise simulation type EventTarget, Time, ODE, Dependent, (and Independent).

Parameters

const bool & reduced

Returns: const CVectorCore< C_FLOAT64 > & noise

References mExtensiveNoise, and mNoiseReduced.

Referenced by CStochasticRungeKuttaRI5::start().

◆ getNoiseInputObjects()

const CObjectInterface::ObjectSet & CMathContainer::getNoiseInputObjects ( ) const

ARetrieve the set of noise input objects

Returns: const CObjectInterface::ObjectSet & noiseInputObjects

References mNoiseInputObjects.

Referenced by CStochasticRungeKuttaRI5::start().

◆ getNoiseSequence()

const CCore::CUpdateSequence & CMathContainer::getNoiseSequence ( const bool & useMoieties ) const

Retrieve the sequence for calculating all noise values.

Parameters

const bool & useMoieties

Returns: CCore::CUpdateSequence & synchronizeInitialValuesSequence

References mNoiseSequence, and mNoiseSequenceReduced.

◆ getObject()

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

virtual

Retrieve a descendant object by its partial CN.

Parameters

const CCommonName & cn

Returns: const CObjectInterface * pObject

Reimplemented from CDataContainer.

References CDataObject::getCN(), getMathObject(), CDataContainer::getObject(), CDataObject::getObjectDataModel(), CObjectInterface::GetObjectFromCN(), CCommonName::getPrimary(), and mpModel.

Referenced by copyBranch(), CModelParameterGroup::getObjectUnit(), CTimeSensMethod::initializeDerivativesCalculations(), and CTimeSensMethod::initResult().

◆ getObjectFromCN()

const CObjectInterface * CMathContainer::getObjectFromCN ( const CCommonName & cn ) const

virtual

Retrieve a object by its full CN.

Parameters

const CCommonName & cn

Returns: const CObjectInterface * pObject

References CDataObject::getObjectDataModel(), CObjectInterface::GetObjectFromCN(), and mpModel.

◆ getParticleFluxes()

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

Retrieve reaction particle fluxes.

Returns: const CVectorCore< C_FLOAT64 > & particleFluxes

References mParticleFluxes.

Referenced by CLNAMethod::calculateCovarianceMatrixReduced(), CMCAMethod::calculateUnscaledElasticities(), CCSPMethod::CSPImportanceIndex(), CCSPMethod::CSPParticipationIndex(), and CMCAMethod::scaleMCA().

◆ getProcessQueue()

CMathEventQueue & CMathContainer::getProcessQueue ( )

Retrieve the event processing queue.

Returns: CMathEventQueue & eventQueue

References mpProcessQueue.

Referenced by CMathEvent::fire().

◆ getProcessQueueExecutionTime()

C_FLOAT64 CMathContainer::getProcessQueueExecutionTime ( ) const

Retrieve the next execution time scheduled in the process queue

Returns: C_FLOAT64 processQueueExecutionTime

References CMathEventQueue::getProcessQueueExecutionTime(), and mpProcessQueue.

Referenced by CTimeSensTask::processStep(), and CTrajectoryTask::processStep().

◆ getPropensities()

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

Retrieve reaction propensities.

Returns: const CVectorCore< C_FLOAT64 > & propensities

References mPropensities.

Referenced by CStochDirectMethod::start(), CStochMethod::start(), CTauLeapMethod::start(), CTrajAdaptiveSA::start(), and CTrajectoryMethodDsaLsodar::start().

◆ getQuantity2NumberFactor()

const C_FLOAT64 & CMathContainer::getQuantity2NumberFactor ( ) const

Retrieve the Quantity to Number conversion factor

Returns: C_FLOAT64 & quantity2NumberFactor

References C_FLOAT64, CDataObject::getValuePointer(), and mpQuantity2NumberFactor.

Referenced by CMathEvent::CAssignment::compile(), CNewtonMethod::targetFunctionDistance(), and CNewtonMethod::targetFunctionRate().

◆ getQuantity2NumberFactorObject()

const CObjectInterface * CMathContainer::getQuantity2NumberFactorObject ( ) const

Retrieve the Quantity to Number conversion factor

Returns: const CObjectInterface * quantity2NumberFactorObject

References mpQuantity2NumberFactor.

Referenced by CMathObject::compile().

◆ getRandomGenerator()

CRandom & CMathContainer::getRandomGenerator ( ) const

Retrieve the random number generator.

References mpRandomGenerator.

Referenced by CMathEventQueue::getAction(), COptProblem::randomizeStartValues(), CHybridMethod::start(), CHybridMethodODE45::start(), CStochasticRungeKuttaRI5::start(), CStochDirectMethod::start(), CStochMethod::start(), CTauLeapMethod::start(), and CTrajAdaptiveSA::start().

◆ getRandomObject()

const CDataObject * CMathContainer::getRandomObject ( ) const

Retrieve the object which triggers recalculation of random functions

References mRandom.

Referenced by CMathDependencyGraph::getUpdateSequence().

◆ getRate()

const CVectorCore< C_FLOAT64 > & CMathContainer::getRate ( const bool & reduced ) const

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

Parameters

const bool & reduced

Returns: const CVectorCore< C_FLOAT64 > & rate

References mRate, and mRateReduced.

Referenced by CTimeSensMethod::calculate_dRate_dPar(), CAnalyticsTask::createEvent(), CLsodaMethod::evalF(), CLsodaMethod2::evalF(), CRadau5Method::evalF(), CTrajectoryMethodDsaLsodar::evalF(), CNewtonMethod::initialize(), CLyapWolfMethod::start(), CTimeSensLsodaMethod::start(), CHybridMethod::start(), CHybridMethodODE45::start(), CLsodaMethod::start(), CLsodaMethod2::start(), CRadau5Method::start(), CStochasticRungeKuttaRI5::start(), and CTSSAMethod::start().

◆ getReactions() [1/2]

CVectorCore< CMathReaction > & CMathContainer::getReactions ( )

Retrieve the reactions

Returns: CVectorCore< CMathReaction > & reactions

References mReactions.

Referenced by CLNAMethod::calculateCovarianceMatrixReduced(), CCSPMethod::CSPImportanceIndex(), CCSPMethod::CSPParticipationIndex(), CCSPMethod::CSPradicalPointer(), CCSPMethod::cspstep(), CTrajectoryMethodDsaLsodar::CPartition::intialize(), CSteadyStateMethod::isEquilibrium(), CHybridMethod::isValidProblem(), CTauLeapMethod::isValidProblem(), CTrajAdaptiveSA::isValidProblem(), CHybridMethodODE45::partitionSystem(), CMCAMethod::resizeAllMatrices(), CMCAMethod::scaleMCA(), CILDMMethod::setAnnotationM(), CCSPMethod::setVectors(), CILDMMethod::setVectors(), CCSPMethod::setVectorsToNaN(), CHybridMethod::start(), CStochDirectMethod::start(), CStochMethod::start(), CTauLeapMethod::start(), CTrajAdaptiveSA::start(), CTrajectoryMethodDsaLsodar::start(), CCSPMethod::start(), and CILDMMethod::step().

◆ getReactions() [2/2]

const CVectorCore< CMathReaction > & CMathContainer::getReactions ( ) const

Retrieve the reactions

Returns: const CVectorCore< CMathReaction > & reactions

References mReactions.

◆ getRootIsDiscrete()

const CVectorCore< bool > & CMathContainer::getRootIsDiscrete ( ) const

Retrieve a vector of Boolean values indicating whether a root is changing continuously or only during discrete event processing

References mRootIsDiscrete.

Referenced by CHybridMethodODE45::checkRoots(), CStochDirectMethod::checkRoots(), CTimeSensLsodaMethod::createRootMask(), CLsodaMethod::createRootMask(), CLsodaMethod2::createRootMask(), CRadau5Method::createRootMask(), CStochasticRungeKuttaRI5::createRootMask(), CTimeSensLsodaMethod::setRootMaskType(), CLsodaMethod::setRootMaskType(), CRadau5Method::setRootMaskType(), CTimeSensLsodaMethod::start(), CHybridMethodODE45::start(), CLsodaMethod::start(), CLsodaMethod2::start(), CRadau5Method::start(), and CStochasticRungeKuttaRI5::start().

◆ getRootIsTimeDependent()

const CVectorCore< bool > & CMathContainer::getRootIsTimeDependent ( ) const

Retrieve a vector of Boolean values indicating whether a root time dependent

References mRootIsTimeDependent.

Referenced by CHybridMethodODE45::checkRoots(), and CStochDirectMethod::checkRoots().

◆ getRootProcessors()

CVector< CMathEvent::CTrigger::CRootProcessor * > & CMathContainer::getRootProcessors ( )

Retrieve a vector of pointers to root processors

References mRootProcessors.

Referenced by CMathEventQueue::rootsFound().

◆ getRoots()

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

Retrieve root values.

Returns: const CVectorCore< C_FLOAT64 > & roots

References mEventRoots.

Referenced by CStochDirectMethod::checkRoots(), CTimeSensLsodaMethod::createRootMask(), CHybridMethodODE45::createRootMask(), CLsodaMethod::createRootMask(), CRadau5Method::createRootMask(), CMathEvent::createUpdateSequences(), CStochDirectMethod::doSingleStep(), CTimeSensLsodaMethod::evalR(), CLsodaMethod::evalR(), CRadau5Method::evalR(), CHybridMethodODE45::evalR(), CLsodaMethod2::evalRoot(), CTimeSensLsodaMethod::peekAhead(), CLsodaMethod::peekAhead(), CLsodaMethod2::peekAhead(), CRadau5Method::peekAhead(), CMathEventQueue::process(), CMathEventQueue::rootsFound(), CStochDirectMethod::rootValue(), CTimeSensLsodaMethod::setRootMaskType(), CLsodaMethod::setRootMaskType(), CRadau5Method::setRootMaskType(), CMathEventQueue::start(), CTimeSensLsodaMethod::start(), CHybridMethodODE45::start(), CLsodaMethod::start(), CLsodaMethod2::start(), CRadau5Method::start(), CStochasticRungeKuttaRI5::start(), CStochDirectMethod::start(), CStochDirectMethod::stateChange(), and CLsodaMethod::step().

◆ getSimulationUpToDateObjects()

const CObjectInterface::ObjectSet & CMathContainer::getSimulationUpToDateObjects ( ) const

Retrieve the objects which are up to date after a call to updateSimulatedValues.

Returns: CObjectInterface::ObjectSet & imulationUpToDateObjects

References mSimulationRequiredValues.

Referenced by CExperiment::compile(), COutputHandler::compileUpdateSequence(), CMathEvent::createUpdateSequences(), CScanMethod::init(), COptProblem::initialize(), CFitProblem::initialize(), CNewtonMethod::initialize(), CTimeSensMethod::initializeDerivativesCalculations(), and CHybridMethodODE45::partitionSystem().

◆ getSimulationValuesSequence()

const CCore::CUpdateSequence & CMathContainer::getSimulationValuesSequence ( const bool & useMoieties ) const

Retrieve the sequence for calculating all values needed for the simulation.

Parameters

const bool & useMoieties

Returns: CCore::CUpdateSequence & synchronizeInitialValuesSequence

References mSimulationValuesSequence, and mSimulationValuesSequenceReduced.

Referenced by CODEExporter::exportObjectNodesFromModel().

◆ getState()

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

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

Parameters

const bool & reduced

Returns: const CVectorCore< C_FLOAT64 > & state

References mState, and mStateReduced.

Referenced by CTimeSensMethod::calculate_dAssignments_dState(), CLNAMethod::calculateCovarianceMatrixReduced(), calculateElasticityDependencies(), calculateJacobian(), calculateJacobianDependencies(), CMCAMethod::calculateUnscaledElasticities(), CTimeSeries::compile(), CMathEvent::compile(), CAnalyticsTask::createEvent(), CTrajAdaptiveSA::doSingleTauLeapStep(), CLsodaMethod::evalF(), CLsodaMethod2::evalF(), CRadau5Method::evalF(), CTimeSensLsodaMethod::evalR(), CLsodaMethod::evalR(), CRadau5Method::evalR(), CAnalyticsTask::eventCallBack(), CAnalyticsTask::finish(), CScanMethod::init(), CSteadyStateMethod::initialize(), CTSSATask::initialize(), CSteadyStateTask::initialize(), initializeAtolVector(), CTimeSensMethod::initResult(), CTrajectoryMethodDsaLsodar::CPartition::intialize(), CMathEventQueue::process(), CLyapTask::process(), CTimeSensTask::process(), CAnalyticsTask::process(), CSteadyStateTask::process(), CTimeSensTask::processStart(), CTrajectoryTask::processStart(), CTSSATask::processStart(), CTimeSensTask::processStep(), CTrajectoryTask::processStep(), CTrajectoryTask::processTrajectory(), CTrajectoryTask::processValues(), CCopasiTask::restore(), CSteadyStateTask::restore(), CSteadyStateMethod::returnProcess(), CMCAMethod::scaleMCA(), CTimeSensMethod::signalMathContainerChanged(), CTimeSensTask::signalMathContainerChanged(), CTrajectoryMethod::signalMathContainerChanged(), CTrajectoryTask::signalMathContainerChanged(), CLyapWolfMethod::start(), CMathEventQueue::start(), CHybridMethod::start(), CTrajectoryMethod::start(), CTSSAMethod::start(), CModel::stateToIntialState(), CLsodaMethod2::step(), CTimeSensLsodaMethod::step(), CLsodaMethod::step(), CRadau5Method::step(), and CSteadyStateTask::updateMatrices().

◆ getStateObjects()

const CObjectInterface::ObjectSet & CMathContainer::getStateObjects ( const bool & reduced = false ) const

Retrieve the objects which represent the state or reduced state.

Parameters

const bool & reduced (default: false)

Returns: CObjectInterface::ObjectSet & stateObjects

References mReducedStateValues, and mStateValues.

Referenced by CExperiment::compile(), COutputHandler::compileUpdateSequence(), CMathDelay::createUpdateSequences(), CMathEvent::createUpdateSequences(), COptProblem::initialize(), CFitProblem::initialize(), CNewtonMethod::initialize(), CSensMethod::initialize(), CTimeSensMethod::initializeDerivativesCalculations(), CMCAMethod::isValidProblem(), and CStochasticRungeKuttaRI5::start().

◆ getStoichiometry()

const CMatrix< C_FLOAT64 > & CMathContainer::getStoichiometry ( const bool & reduced = false ) const

Retrieve the stoichiometry matrix

Parameters

const bool & reduced (default: false)

Returns: const CMatrix< C_FLOAT64 > & stoichiometry

References CModel::getRedStoi(), CModel::getStoi(), and mpModel.

Referenced by CCSPMethod::CSPImportanceIndex(), CCSPMethod::CSPParticipationIndex(), and CCSPMethod::CSPradicalPointer().

◆ getSynchronizeInitialValuesSequence()

const CCore::CUpdateSequence & CMathContainer::getSynchronizeInitialValuesSequence ( const CCore::Framework & framework ) const

Retrieve the sequence for synchronizing all transient values for the given framework.

Parameters

const CCore::Framework & framework

Returns: CCore::CUpdateSequence & synchronizeInitialValuesSequence

References CCore::__SIZE, CCore::Concentration, mSynchronizeInitialValuesSequenceExtensive, mSynchronizeInitialValuesSequenceIntensive, and CCore::ParticleNumbers.

◆ getTotalMasses()

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

Retrieve the total masses of the moieties.

Returns: const CVectorCore< C_FLOAT64 > & totalMasses

References mTotalMasses.

Referenced by CMathEvent::createUpdateSequences().

◆ getTransientDataValueSequence()

const CCore::CUpdateSequence & CMathContainer::getTransientDataValueSequence ( ) const

Retrieve the sequence for updating all transient values.

Returns: CCore::CUpdateSequence & transientDataValueSequence

References mTransientDataObjectSequence.

◆ getTransientDependencies()

const CMathDependencyGraph & CMathContainer::getTransientDependencies ( ) const

Retrieve the transient dependencies

Returns: CMathDependencyGraph & getTransientDependencies

References mTransientDependencies.

Referenced by CModel::appendAllDependents(), CModel::appendDirectDependents(), CMCAMethod::calculateUnscaledElasticities(), CExperiment::compile(), COutputHandler::compileUpdateSequence(), CMathDelay::createUpdateSequences(), CMathEvent::createUpdateSequences(), CScanMethod::init(), COptProblem::initialize(), CFitProblem::initialize(), CNewtonMethod::initialize(), CSensMethod::initialize(), CTimeSensMethod::initializeDerivativesCalculations(), CMCAMethod::isValidProblem(), CHybridMethodODE45::partitionSystem(), CHybridMethod::setupDependencyGraph(), CStochasticRungeKuttaRI5::start(), CStochDirectMethod::start(), CStochMethod::start(), CTrajAdaptiveSA::start(), and CTrajectoryMethodDsaLsodar::start().

◆ getValueChangeProhibited()

const CObjectInterface::ObjectSet & CMathContainer::getValueChangeProhibited ( ) const

Retrieve the objects for which the intial value change is prohibitied.

Returns: CObjectInterface::ObjectSet & initialValueChangeProhibited

References mValueChangeProhibited.

◆ getValueObject()

CMathObject * CMathContainer::getValueObject ( const CMathObject * pInitialObject ) const

Retrieve the pointer to the corresponding value object

Parameters

const CMathObject * pInitialObject

Returns: CMathObject * pValueObject

References getMathObject(), CMathObject::getValue(), and CDataObject::getValuePointer().

◆ getValuePointer()

C_FLOAT64 * CMathContainer::getValuePointer ( const C_FLOAT64 * pInitialValue ) const

Retrieve the pointer to the corresponding value

Parameters

const C_FLOAT64 * pInitialValue

Returns: C_FLOAT64 * pvalue

References CVectorCore< CType >::begin(), C_FLOAT64, CVectorCore< CType >::end(), CDataObject::getDataObject(), mExtensiveValues, and mValues.

◆ getValues() [1/2]

CVectorCore< C_FLOAT64 > & CMathContainer::getValues ( )

Retrieve the values of all mathematical objects

Returns: CVectorCore< C_FLOAT64 > & values

References mValues.

◆ getValues() [2/2]

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

Retrieve the values of all mathematical objects

Returns: const CVectorCore< C_FLOAT64 > & values

References mValues.

Referenced by CScanMethod::calculate(), CTSSAMethod::calculateDerivatives(), and CMathDerive::initOneVar().

◆ ignoreDiscontinuityEvent()

void CMathContainer::ignoreDiscontinuityEvent ( CMathEvent * pEvent )

private

Ignore the discontinuity event

Parameters

CMathEvent * pEvent

Referenced by compileEvents().

◆ initializeAtolVector()

CVector< C_FLOAT64 > CMathContainer::initializeAtolVector	(	const C_FLOAT64 &	baseTolerance,
		const bool &	reduced
	)		const

Initialize a vector of individual absolute tolerances

Parameters

const	C_FLOAT64 & baseTolerance
const	bool & reduced

Returns: CVector< C_FLOAT64 > absoluteTolerances

References CVectorCore< CType >::array(), C_FLOAT64, CMath::Compartment, CMetab::getCompartment(), CMathObject::getDataObject(), CMathObject::getEntityType(), CModelEntity::getInitialValueReference(), getMathObject(), CDataObject::getObjectParent(), getState(), CDataObject::getValuePointer(), CMath::GlobalQuantity, max, mDataObject2MathObject, min, mInitialState, CMath::Model, mpQuantity2NumberFactor, mSize, CMathContainer::sSize::nFixed, CVector< CType >::resize(), CVectorCore< CType >::size(), and CMath::Species.

Referenced by CSteadyStateMethod::initialize(), CLyapWolfMethod::start(), CTimeSensLsodaMethod::start(), CLsodaMethod::start(), CLsodaMethod2::start(), CRadau5Method::start(), and CStochasticRungeKuttaRI5::start().

◆ initializeDiscontinuousCreationPointer()

void CMathContainer::initializeDiscontinuousCreationPointer ( )

private

Initialize the pointers used for the conversion of discontinuous nodes.

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

Referenced by compile().

◆ initializeEvents()

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

private

Initialize the events

Parameters

sPointers & pointers

References CMathEvent::allocate(), CVectorCore< CType >::array(), CDataVector< CType >::begin(), CDataVector< CType >::end(), CModel::getEvents(), CMathEvent::initialize(), mDiscontinuityEvents, mEvents, and mpModel.

Referenced by compile().

◆ initializeMathObjects() [1/4]

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

private

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

Parameters

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

References CDataVector< CType >::begin(), CMath::DependentMass, CDataVector< CType >::end(), CMathObject::initialize(), CMath::Moiety, CMath::sPointers::pDependentMasses, CMath::sPointers::pDependentMassesObject, CMath::sPointers::pInitialTotalMasses, CMath::sPointers::pInitialTotalMassesObject, CMath::sPointers::pTotalMasses, CMath::sPointers::pTotalMassesObject, CMath::TotalMass, and CMath::Undefined.

◆ initializeMathObjects() [2/4]

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

private

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

Parameters

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

◆ initializeMathObjects() [3/4]

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

private

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

Parameters

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

References CMath::Fixed, CMathObject::initialize(), CMath::LocalReactionParameter, 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.

◆ initializeMathObjects() [4/4]

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

Referenced by initializeObjects().

◆ initializeObjects()

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

private

Initialize the objects

Parameters

sPointers & pointers

Referenced by compile().

◆ initializePointers()

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

private

Initialize the pointers

Parameters

sPointers & pointers

Referenced by addAnalysisEvent(), compile(), and removeAnalysisEvent().

◆ isAutonomous()

const bool & CMathContainer::isAutonomous ( ) const

Check whether the model is autonomous

Returns: const bool &isAutonomous

References mIsAutonomous.

Referenced by CModel::compile(), CNewtonMethod::isValidProblem(), CSteadyStateTask::process(), CCopasiTask::restore(), and CNewtonMethod::targetFunctionDistance().

◆ isStateValid()

bool CMathContainer::isStateValid ( ) const

Check whether the current state is valid.

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

Referenced by CNewtonMethod::containsNaN(), CStochasticRungeKuttaRI5::internalStep(), CSteadyStateTask::process(), CCopasiTask::restore(), CSteadyStateTask::restore(), CLsodaMethod2::step(), CTimeSensLsodaMethod::step(), CLsodaMethod::step(), and CRadau5Method::step().

◆ map()

void CMathContainer::map ( )

private

Determine whether on object has calculation dependencies. Map the data object to the math object

References CVectorCore< CType >::begin(), C_FLOAT64, CVectorCore< CType >::end(), CMathObject::getDataObject(), CDataObject::getValuePointer(), mDataObject2MathObject, mDataValue2MathObject, and mObjects.

Referenced by addAnalysisEvent(), addAnalysisObject(), compile(), createDelays(), removeAnalysisEvent(), and removeAnalysisObject().

◆ move()

std::vector< CMath::sRelocate > CMathContainer::move ( CMathContainer::sSize & size )

private

Move the container data the container

Parameters

CMathContainer::sSize & size

Returns: std::vector< CMath::sRelocate > relocations

Referenced by resize().

◆ operator==()

bool CMathContainer::operator== ( const CMathContainer & rhs )

Check whether 2 container would genereate equivalent results

References mCompileTime, and mpModel.

◆ processQueue()

CMath::StateChange CMathContainer::processQueue ( const bool & equality )

Process events scheduled at the given which a are checked for equality or not

Parameters

const bool & equality

Returns: CMath::StateChange stateChange

References mpProcessQueue, and CMathEventQueue::process().

Referenced by CTimeSensTask::process(), CTimeSensTask::processStep(), CTrajectoryTask::processStep(), CTrajectoryTask::processTrajectory(), and CTrajectoryTask::processValues().

◆ processRoots() [1/2]

void CMathContainer::processRoots	(	const bool &	equality,
		const CVector< C_INT > &	rootsFound
	)

Check whether the roots which have value 1 lead to firing of events and schedule them if needed.

Parameters

const	bool & equality
const	CVector< C_INT > & rootsFound

References CVectorCore< CType >::array(), C_FLOAT64, C_INT, CMathObject::calculateValue(), CMathEvent::fire(), getMathObject(), mEvents, mEventTriggers, mRootProcessors, mSize, mState, CMathContainer::sSize::nFixedEventTargets, CMath::NoToggle, CVectorCore< CType >::size(), CMath::ToggleBoth, CMath::ToggleEquality, and CMath::ToggleInequality.

Referenced by applyInitialValues(), CMathEventQueue::process(), CTimeSensTask::processStep(), and CTrajectoryTask::processStep().

◆ processRoots() [2/2]

void CMathContainer::processRoots ( const CVector< C_INT > & rootsFound )

Check whether the roots which have value 1 lead to firing of events and schedule them if needed.

Parameters

const CVector< C_INT > & rootsFound

References CVectorCore< CType >::array(), C_FLOAT64, C_INT, CMathObject::calculateValue(), CMathEvent::fire(), getMathObject(), mEvents, mEventTriggers, mRootProcessors, mSize, mState, CMathContainer::sSize::nFixedEventTargets, and CVectorCore< CType >::size().

◆ pushAllTransientValues()

void CMathContainer::pushAllTransientValues ( )

Push all transient values to the associated model.

References CVectorCore< CType >::array(), C_FLOAT64, CMathObject::getDataObject(), getMathObject(), CDataObject::getValuePointer(), mExtensiveValues, mValues, and CVectorCore< CType >::size().

Referenced by CModel::applyInitialValues(), CTimeSensTask::process(), CAnalyticsTask::process(), CCrossSectionTask::process(), CSteadyStateTask::process(), CTrajectoryTask::processTrajectory(), CTrajectoryTask::processValues(), and CCopasiTask::restore().

◆ pushInitialState()

void CMathContainer::pushInitialState ( )

Push the initial state to the associated model

References CVectorCore< CType >::begin(), C_FLOAT64, CVectorCore< CType >::end(), CMathObject::getDataObject(), getMathObject(), CDataObject::getValuePointer(), mInitialExtensiveValues, mInitialIntensiveValues, and mInitialTotalMasses.

Referenced by ResultData::applyToModelStateFromOptTask(), CModel::compile(), CFitProblem::createParameterSets(), COptProblem::restore(), CFitProblem::restore(), CCopasiTask::restore(), CSteadyStateTask::restore(), CModel::stateToIntialState(), and CModel::updateInitialValues().

◆ pushState()

void CMathContainer::pushState ( )

Push the state to the associated model

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

◆ registerUpdateSequence()

void CMathContainer::registerUpdateSequence ( CMathUpdateSequence * pUpdateSequence )

Register and update sequence.

Parameters

CMathUpdateSequence * pUpdateSequence

References mUpdateSequences, and CMathUpdateSequence::setMathContainer().

Referenced by CMathUpdateSequence::setMathContainer().

◆ relocate()

void CMathContainer::relocate	(	const sSize &	size,
		const std::vector< CMath::sRelocate > &	Relocations
	)

private

Relocate the objects. This works only if you relocate objects down in the existing location or out of space.

Parameters

const	sSize & size
const	std::vector< CMath::sRelocate > & Relocations

Referenced by addAnalysisEvent(), ignoreDiscontinuityEvent(), move(), and removeAnalysisEvent().

◆ relocateObject() [1/4]

void CMathContainer::relocateObject	(	CMathObject *&	pObject,
		const std::vector< CMath::sRelocate > &	relocations
	)		const

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

◆ relocateObject() [2/4]

void CMathContainer::relocateObject	(	CObjectInterface *&	pObject,
		const std::vector< CMath::sRelocate > &	relocations
	)		const

References CObjectInterface::getDataObject().

Referenced by createDelays(), CMathObject::relocate(), CMathDelay::relocate(), CMathDependencyGraph::relocate(), CMathDependencyNode::relocate(), CMathEvent::CAssignment::relocate(), CMathEvent::CTrigger::CRootProcessor::relocate(), CMathEvent::CTrigger::relocate(), CMathEvent::relocate(), CMathReaction::relocate(), relocate(), relocateObject(), relocateObjectSet(), and relocateUpdateSequence().

◆ relocateObject() [3/4]

void CMathContainer::relocateObject	(	const CMathObject *&	pObject,
		const std::vector< CMath::sRelocate > &	relocations
	)		const

References relocateObject().

◆ relocateObject() [4/4]

void CMathContainer::relocateObject	(	const CObjectInterface *&	pObject,
		const std::vector< CMath::sRelocate > &	relocations
	)		const

References relocateObject().

◆ relocateObjectSet()

void CMathContainer::relocateObjectSet	(	CObjectInterface::ObjectSet &	objectSet,
		const std::vector< CMath::sRelocate > &	relocations
	)		const

References relocateObject().

Referenced by CMathObject::relocate(), CMathExpression::relocate(), CMathReaction::relocate(), and relocate().

◆ relocateUpdateSequence()

void CMathContainer::relocateUpdateSequence	(	CCore::CUpdateSequence &	sequence,
		const std::vector< CMath::sRelocate > &	relocations
	)		const

References CVectorCore< CType >::array(), CMathUpdateSequence::begin(), CMathUpdateSequence::end(), mObjects, mOldObjects, and relocateObject().

Referenced by relocate().

◆ relocateValue() [1/2]

void CMathContainer::relocateValue	(	C_FLOAT64 *&	pValue,
		const std::vector< CMath::sRelocate > &	relocations
	)		const

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

Referenced by CMathObject::relocate(), CMathEvent::CTrigger::CRootProcessor::relocate(), CMathEvent::relocate(), CMathExpression::relocate(), CMathReaction::relocate(), relocate(), and relocateValue().

◆ relocateValue() [2/2]

void CMathContainer::relocateValue	(	const C_FLOAT64 *&	pValue,
		const std::vector< CMath::sRelocate > &	relocations
	)		const

References C_FLOAT64, and relocateValue().

◆ relocateVector()

template<class CType >

void CMathContainer::relocateVector	(	CVectorCore< CType > &	vector,
		size_t	size,
		const std::vector< CMath::sRelocate > &	relocations
	)

inlineprivate

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

Referenced by relocate().

◆ removeAnalysisEvent()

bool CMathContainer::removeAnalysisEvent ( CMathEvent *& pMathEvent )

Remove the event from the container

Parameters

CMathEvent *& pMathEvent

Returns: bool success

References analyzeRoots(), CVectorCore< CType >::array(), createUpdateSequences(), finishResize(), CMathEvent::getAssignments(), getMathObject(), CMathEvent::CTrigger::getRoots(), CMathEvent::CAssignment::getTarget(), CMathEvent::getTrigger(), initializePointers(), map(), mEvents, mExtensiveRates, mExtensiveValues, mInitialDependencies, mInitialExtensiveRates, mInitialExtensiveValues, mSize, mTransientDependencies, CMathContainer::sSize::nAssignment, CMathContainer::sSize::nEventAssignments, CMathContainer::sSize::nEventRoots, CMathContainer::sSize::nEvents, CMathContainer::sSize::nFixed, CMathContainer::sSize::nFixedEventTargets, CMath::sRelocate::offset, CMath::sPointers::pEventAssignmentsObject, CMath::sPointers::pEventDelaysObject, CMath::sPointers::pEventPrioritiesObject, CMath::sPointers::pEventRootsObject, CMath::sPointers::pEventRootStatesObject, CMath::sPointers::pEventTriggersObject, CMath::sPointers::pInitialEventTriggersObject, CMath::sRelocate::pNewObject, CMath::sRelocate::pNewValue, CMath::sRelocate::pObjectEnd, CMath::sRelocate::pObjectStart, CMath::sRelocate::pOldObject, CMath::sRelocate::pOldValue, CMath::sRelocate::pValueEnd, CMath::sRelocate::pValueStart, relocate(), CMathDependencyGraph::removeObject(), resize(), and CVectorCore< CType >::size().

Referenced by CAnalyticsTask::removeEvent(), and CCrossSectionTask::removeEvent().

◆ removeAnalysisObject()

bool CMathContainer::removeAnalysisObject ( CMath::Entity< CMathObject > & mathObjects )

Remove the event from the container

Parameters

CMath::Entity< CMathObject > & mathObjects

Returns: bool success

References CMath::__SIZE, CMath::Assignment, C_INVALID_INDEX, CMath::Conversion, createUpdateSequences(), CMath::Dependent, CMath::EventTarget, fatalError, finishResize(), CMath::Fixed, CMath::Independent, CMath::Entity< CType >::InitialRate, CMath::Entity< CType >::InitialValue, map(), mInitialDependencies, mObjects, mSize, mTransientDependencies, CMathContainer::sSize::nAssignment, CMathContainer::sSize::nFixed, CMathContainer::sSize::nFixedEventTargets, CMathContainer::sSize::nODE, CMathContainer::sSize::nODESpecies, CMathContainer::sSize::nReactionSpecies, CMathContainer::sSize::nTime, CMath::ODE, CMath::Entity< CType >::Rate, CMathDependencyGraph::removeObject(), resize(), CMath::Time, CMath::Undefined, and CMath::Entity< CType >::Value.

◆ removeDataObject()

void CMathContainer::removeDataObject ( const CDataObject * pObject )

Remove a data object from the math container

Parameters

const CDataObject * pObject;

References CDataContainer::getDescendants(), getInitialValueObject(), getMathObject(), CDataObject::hasFlag(), mInitialDependencies, mTransientDependencies, CMathDependencyGraph::removeObject(), and CMathObject::setDataObject().

Referenced by CModel::removeDataObject().

◆ replaceDiscontinuousNode()

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

References CMathEvent::addAssignment(), CMathEvent::allocate(), CEvaluationNode::buildInfix(), C_FLOAT64, CEvaluationNode::copyNode(), createDiscontinuityTriggerInfix(), CEvent::Discontinuity, fatalError, CMathEvent::CTrigger::getRoots(), CMathEvent::getTrigger(), CMathObject::getValuePointer(), mCreateDiscontinuousPointer, mDiscontinuityInfix2Object, mRootCount2Events, mTriggerInfix2Event, pdelete, CMathContainer::sDiscontinuous::pDiscontinuous, CMathContainer::sDiscontinuous::pEvent, CMathObject::setExpressionPtr(), CEvent::setTriggerExpression(), CMathEvent::setTriggerExpression(), CEvent::setType(), CMathObject::setValueType(), and CMath::Undefined.

Referenced by copyBranch().

◆ resetNoise()

void CMathContainer::resetNoise ( )

Reset all niose values to zero

References CVectorCore< CType >::array(), C_FLOAT64, mExtensiveNoise, mIntensiveNoise, mReactionNoise, mReactionParticleNoise, and CVectorCore< CType >::size().

Referenced by CStochasticRungeKuttaRI5::evalNoise().

◆ resize()

std::vector< CMath::sRelocate > CMathContainer::resize ( CMathContainer::sSize & size )

private

Resize the container

Parameters

CMathContainer::sSize & size

Returns: std::vector< CMath::sRelocate > relocations

Referenced by addAnalysisEvent(), addAnalysisObject(), allocate(), createDelays(), removeAnalysisEvent(), and removeAnalysisObject().

◆ sanitizeDataValue2DataObject()

void CMathContainer::sanitizeDataValue2DataObject ( )

private

Remove data objects which have a representation in the math container

References getMathObject(), and mDataValue2DataObject.

Referenced by createUpdateSequences().

◆ setCompleteInitialState()

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

Set the complete initial state values, i.e., all initial values including all internal values.

Parameters

const CVectorCore< C_FLOAT64 > & initialState

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

Referenced by COptProblem::adjustStartValuesForIntervals(), CFitProblem::calculate(), CFitProblem::calculateCrossValidation(), and CFitProblem::createParameterSets().

◆ setHistory()

void CMathContainer::setHistory ( const CMathHistoryCore & history )

Set all the history values needed for calculation.

Parameters

const CMathHistoryCore & history

References CMathHistoryCore::cols(), mHistory, mHistoryReduced, CMathHistoryCore::rows(), and CMathHistoryCore::size().

◆ setInitialState()

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

References CVectorCore< CType >::array(), C_FLOAT64, mInitialState, mSize, mState, CMathContainer::sSize::nFixed, and CVectorCore< CType >::size().

Referenced by CScanMethod::calculate(), CFitProblem::createParameterSets(), CCopasiTask::restore(), CSteadyStateTask::restore(), and CModel::stateToIntialState().

◆ setState()

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

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

Referenced by CSteadyStateMethod::calculateJacobian(), CAnalyticsTask::computeSelectedStatistics(), CNewtonMethod::doIntegration(), CSteadyStateMethod::doJacobian(), CTrajAdaptiveSA::doSingleTauLeapStep(), CAnalyticsTask::eventCallBack(), CCrossSectionTask::eventCallBack(), CTimeSensMethod::output(), CTrajectoryMethod::output(), CTimeSensTask::process(), CAnalyticsTask::process(), CCrossSectionTask::process(), CSteadyStateTask::process(), CTimeSensTask::processStep(), CTrajectoryTask::processStep(), CTrajectoryTask::processTrajectory(), CTrajectoryTask::processValues(), CSteadyStateTask::restore(), and updateHistoryValues().

◆ setValues()

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

Set the values of all mathematical objects

Parameters

const CVectorCore< C_FLOAT64 > & values

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

Referenced by CTSSAMethod::calculateDerivatives().

◆ updateHistoryValues()

void CMathContainer::updateHistoryValues ( const bool & useMoieties )

Calculate all historic values required for delayed differential equations

Parameters

const bool & useMoieties

References CVectorCore< CType >::array(), CMathDelay::calculateDelayValues(), CMathHistoryCore::getRow(), mDelays, mHistory, mHistoryReduced, setState(), and CVectorCore< CType >::size().

◆ updateInitialValues()

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

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

Parameters

const CCore::Framework & framework

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

Referenced by CModel::applyInitialValues(), CTimeSensMethod::calculate_dInitialState_dPar(), compile(), CModel::compile(), CCopasiTask::restore(), CSteadyStateTask::restore(), CModel::stateToIntialState(), and CModel::updateInitialValues().

◆ updateNoiseValues()

void CMathContainer::updateNoiseValues ( const bool & useMoieties )

Calculate all noise valuse based on the current state

Parameters

const bool & useMoieties

References applyUpdateSequence(), mNoiseSequence, and mNoiseSequenceReduced.

◆ updatePriorityValues()

void CMathContainer::updatePriorityValues ( )

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

References applyUpdateSequence(), and mPrioritySequence.

Referenced by CMathEventQueue::process().

◆ updateRootValues()

void CMathContainer::updateRootValues ( const bool & useMoieties )

Calculate all roots based on the current state

Parameters

const bool & useMoieties

References applyUpdateSequence(), mRootSequence, and mRootSequenceReduced.

Referenced by calculateRootDerivatives(), calculateRootJacobian(), CTimeSensLsodaMethod::createRootMask(), CHybridMethodODE45::createRootMask(), CLsodaMethod::createRootMask(), CRadau5Method::createRootMask(), CTimeSensLsodaMethod::evalR(), CLsodaMethod::evalR(), CRadau5Method::evalR(), CHybridMethodODE45::evalR(), CStochasticRungeKuttaRI5::evalRoot(), CHybridMethodODE45::fireReaction(), CTimeSensTask::processStep(), CTrajectoryTask::processStep(), CTimeSensLsodaMethod::setRootMaskType(), CLsodaMethod::setRootMaskType(), CRadau5Method::setRootMaskType(), and CMathEvent::setTargetValues().

◆ updateSimulatedValues()

void CMathContainer::updateSimulatedValues ( const bool & useMoieties )

Calculate all values required for simulation based on the current state

Parameters

const bool & useMoieties

References applyUpdateSequence(), mSimulationValuesSequence, and mSimulationValuesSequenceReduced.

Referenced by CSteadyStateMethod::allPositive(), CModel::applyInitialValues(), CLyapWolfMethod::calculate(), CHybridMethod::calculateDerivative(), CTSSAMethod::calculateDerivatives(), CNewtonMethod::calculateDerivativesX(), calculateJacobian(), CMCAMethod::calculateUnscaledElasticities(), CLsodaMethod2::createRootMask(), CStochasticRungeKuttaRI5::createRootMask(), CLsodaMethod2::destroyRootMask(), CStochasticRungeKuttaRI5::destroyRootMask(), CILDMMethod::deuflhard(), CTrajAdaptiveSA::doSingleTauLeapStep(), CLyapWolfMethod::evalF(), CTimeSensLsodaMethod::evalF(), CHybridMethodODE45::evalF(), CLsodaMethod::evalF(), CLsodaMethod2::evalF(), CRadau5Method::evalF(), CTrajectoryMethodDsaLsodar::evalF(), CStochasticRungeKuttaRI5::evalRate(), CLsodaMethod2::evalRoot(), CAnalyticsTask::eventCallBack(), CCrossSectionTask::eventCallBack(), CHybridMethodODE45::fireReaction(), CHybridMethodODE45::integrateDeterministicPart(), CHybridNextReactionRKMethod::integrateDeterministicPart(), CTrajectoryMethodDsaLsodar::integrateDeterministicPart(), CTimeSensMethod::output(), CTrajectoryMethod::output(), CLyapTask::process(), CTimeSensTask::process(), CTSSATask::process(), CAnalyticsTask::process(), CCrossSectionTask::process(), CSteadyStateTask::process(), CTSSATask::processStep(), CTimeSensTask::processStep(), CTrajectoryTask::processStep(), CTrajectoryTask::processTrajectory(), CTrajectoryTask::processValues(), CCopasiTask::restore(), CSteadyStateTask::restore(), CMathEvent::setTargetValues(), CStochMethod::start(), CTauLeapMethod::start(), CTrajAdaptiveSA::start(), CTrajectoryMethodDsaLsodar::start(), CCSPMethod::start(), CTimeSensLsodaMethod::stateChange(), CLsodaMethod::stateChange(), CRadau5Method::stateChange(), CStochDirectMethod::stateChange(), CCSPMethod::step(), CILDMMethod::step(), CILDMModifiedMethod::step(), CTimeSensLsodaMethod::step(), CHybridMethod::step(), CLsodaMethod::step(), CTauLeapMethod::step(), CNewtonMethod::targetFunction(), and CHybridMethod::updatePriorityQueue().

◆ updateTransientDataValues()

void CMathContainer::updateTransientDataValues ( )

Calculate all transient data values. The simulated values need to be calculated beforehand.

References applyUpdateSequence(), and mTransientDataObjectSequence.

Referenced by CModel::applyInitialValues(), CSteadyStateMethod::isEquilibrium(), CTimeSensTask::process(), CAnalyticsTask::process(), CCrossSectionTask::process(), CSteadyStateTask::process(), CTrajectoryTask::processTrajectory(), CTrajectoryTask::processValues(), CCopasiTask::restore(), and CMCAMethod::scaleMCA().

Member Data Documentation

◆ mApplyInitialValuesSequence

CCore::CUpdateSequence CMathContainer::mApplyInitialValuesSequence

private

The sequence of updates needed to apply the initial values

Referenced by allocate(), applyInitialValues(), createApplyInitialValuesSequence(), and getApplyInitialValuesSequence().

◆ mCompileTime

std::chrono::steady_clock::time_point CMathContainer::mCompileTime

private

The compile time of the container needed to indicate whther copies are out sync.

Referenced by compile(), and operator==().

◆ mCompleteInitialState

CVectorCore< C_FLOAT64 > CMathContainer::mCompleteInitialState

private

The initial state contains additionally all computed internal values

Referenced by getCompleteInitialState(), relocate(), and setCompleteInitialState().

◆ mCreateDiscontinuousPointer

sDiscontinuous CMathContainer::mCreateDiscontinuousPointer

private

Structure of pointers used for creating discontinuities.

Referenced by compileEvents(), initializeDiscontinuousCreationPointer(), and replaceDiscontinuousNode().

◆ mDataObject2MathObject

std::map< const CDataObject *, CMathObject * > CMathContainer::mDataObject2MathObject

private

A map from data objects to math objects

Referenced by allocate(), getMathObject(), initializeAtolVector(), map(), and move().

◆ mDataValue2DataObject

std::map< C_FLOAT64 *, CDataObject * > CMathContainer::mDataValue2DataObject

private

A map from data objects values to math objects

Referenced by allocate(), createNodeFromObject(), createSynchronizeInitialValuesSequence(), getDataObject(), and sanitizeDataValue2DataObject().

◆ mDataValue2MathObject

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

private

A map from data objects values to math objects

Referenced by allocate(), getMathObject(), map(), and move().

◆ mDelayLags

CVectorCore< C_FLOAT64 > CMathContainer::mDelayLags

private

Referenced by createDelays(), createUpdateSimulationValuesSequence(), getDelayLags(), initializePointers(), and relocate().

◆ mDelays

CVectorCore< CMathDelay > CMathContainer::mDelays

private

A vector of delays

Referenced by allocate(), compile(), createDelays(), relocate(), updateHistoryValues(), and ~CMathContainer().

◆ mDelayValues

CVectorCore< C_FLOAT64 > CMathContainer::mDelayValues

private

Referenced by compile(), createDelays(), initializePointers(), and relocate().

◆ mDependentMasses

CVectorCore< C_FLOAT64 > CMathContainer::mDependentMasses

private

Referenced by initializePointers(), and relocate().

◆ mDiscontinuityEvents

CDataVector< CEvent > CMathContainer::mDiscontinuityEvents

private

A vector of data events for discontinuities

Referenced by allocate(), compile(), compileEvents(), createDiscontinuityDataEvent(), and initializeEvents().

◆ mDiscontinuityInfix2Object

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

private

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

Referenced by compile(), and replaceDiscontinuousNode().

◆ mDiscontinuous

CVectorCore< C_FLOAT64 > CMathContainer::mDiscontinuous

private

Referenced by createApplyInitialValuesSequence(), initializeDiscontinuousCreationPointer(), initializeObjects(), initializePointers(), and relocate().

◆ mEventAssignments

CVectorCore< C_FLOAT64 > CMathContainer::mEventAssignments

private

Referenced by initializePointers(), and relocate().

◆ mEventDelays

CVectorCore< C_FLOAT64 > CMathContainer::mEventDelays

private

Referenced by createUpdateSimulationValuesSequence(), ignoreDiscontinuityEvent(), initializePointers(), and relocate().

◆ mEventPriorities

CVectorCore< C_FLOAT64 > CMathContainer::mEventPriorities

private

Referenced by createUpdateSimulationValuesSequence(), initializePointers(), and relocate().

◆ mEventRoots

CVectorCore< C_FLOAT64 > CMathContainer::mEventRoots

private

Referenced by analyzeRoots(), applyInitialValues(), calculateRootJacobian(), createUpdateSimulationValuesSequence(), getRoots(), ignoreDiscontinuityEvent(), initializePointers(), and relocate().

◆ mEventRootStates

CVectorCore< C_FLOAT64 > CMathContainer::mEventRootStates

private

Referenced by analyzeRoots(), createUpdateSimulationValuesSequence(), ignoreDiscontinuityEvent(), initializePointers(), and relocate().

◆ mEvents

CVectorCore< CMathEvent > CMathContainer::mEvents

private

A vector containing all math events.

Referenced by addAnalysisEvent(), allocate(), analyzeRoots(), applyInitialValues(), compileEvents(), createUpdateSequences(), getEvents(), ignoreDiscontinuityEvent(), initializeDiscontinuousCreationPointer(), initializeEvents(), processRoots(), relocate(), removeAnalysisEvent(), and ~CMathContainer().

◆ mEventTriggers

CVectorCore< C_FLOAT64 > CMathContainer::mEventTriggers

private

Referenced by applyInitialValues(), ignoreDiscontinuityEvent(), initializePointers(), processRoots(), and relocate().

◆ mExtensiveNoise

CVectorCore< C_FLOAT64 > CMathContainer::mExtensiveNoise

private

Referenced by createUpdateSimulationValuesSequence(), getInitialValuePointer(), getNoise(), ignoreDiscontinuityEvent(), initializePointers(), relocate(), and resetNoise().

◆ mExtensiveRates

CVectorCore< C_FLOAT64 > CMathContainer::mExtensiveRates

private

Referenced by addAnalysisEvent(), createUpdateSimulationValuesSequence(), createValueChangeProhibited(), initializePointers(), relocate(), and removeAnalysisEvent().

◆ mExtensiveValues

CVectorCore< C_FLOAT64 > CMathContainer::mExtensiveValues

private

Referenced by addAnalysisEvent(), applyInitialValues(), createApplyInitialValuesSequence(), createDelays(), createDependencyGraphs(), createSynchronizeInitialValuesSequence(), createUpdateAllTransientDataValuesSequence(), createUpdateSimulationValuesSequence(), createValueChangeProhibited(), getInitialValuePointer(), getValuePointer(), ignoreDiscontinuityEvent(), initializePointers(), pushAllTransientValues(), relocate(), and removeAnalysisEvent().

◆ mFluxes

CVectorCore< C_FLOAT64 > CMathContainer::mFluxes

private

Referenced by calculateElasticityDependencies(), getFluxes(), getMathReaction(), initializePointers(), and relocate().

◆ mHistory

CMathHistory CMathContainer::mHistory

private

The full history needed for the calculation of delayed differential equations

Referenced by createDelays(), getHistory(), relocate(), setHistory(), and updateHistoryValues().

◆ mHistoryReduced

CMathHistoryCore CMathContainer::mHistoryReduced

private

The reduced history needed for the calculation of delayed differential equations

Referenced by getHistory(), relocate(), setHistory(), and updateHistoryValues().

◆ mInitialDependencies

CMathDependencyGraph CMathContainer::mInitialDependencies

private

Dependency graph for initial value calculations

Referenced by addAnalysisEvent(), addAnalysisObject(), allocate(), createDependencyGraphs(), createSynchronizeInitialValuesSequence(), createValueChangeProhibited(), getInitialDependencies(), relocate(), removeAnalysisEvent(), removeAnalysisObject(), and removeDataObject().

◆ mInitialEventTriggers

CVectorCore< C_FLOAT64 > CMathContainer::mInitialEventTriggers

private

Referenced by ignoreDiscontinuityEvent(), initializePointers(), and relocate().

◆ mInitialExtensiveRates

CVectorCore< C_FLOAT64 > CMathContainer::mInitialExtensiveRates

private

Referenced by addAnalysisEvent(), createValueChangeProhibited(), initializePointers(), relocate(), and removeAnalysisEvent().

◆ mInitialExtensiveValues

CVectorCore< C_FLOAT64 > CMathContainer::mInitialExtensiveValues

private

Referenced by addAnalysisEvent(), applyInitialValues(), createDependencyGraphs(), getInitialValuePointer(), initializePointers(), pushInitialState(), relocate(), and removeAnalysisEvent().

◆ mInitialFluxes

CVectorCore< C_FLOAT64 > CMathContainer::mInitialFluxes

private

Referenced by initializePointers(), and relocate().

◆ mInitialIntensiveRates

CVectorCore< C_FLOAT64 > CMathContainer::mInitialIntensiveRates

private

Referenced by initializePointers(), and relocate().

◆ mInitialIntensiveValues

CVectorCore< C_FLOAT64 > CMathContainer::mInitialIntensiveValues

private

Referenced by initializePointers(), pushInitialState(), and relocate().

◆ mInitialParticleFluxes

CVectorCore< C_FLOAT64 > CMathContainer::mInitialParticleFluxes

private

Referenced by initializePointers(), and relocate().

◆ mInitialState

CVectorCore< C_FLOAT64 > CMathContainer::mInitialState

private

The initial state contains also all fixed values

Referenced by fetchInitialState(), getInitialState(), initializeAtolVector(), relocate(), and setInitialState().

◆ mInitialStateValueAll

CObjectInterface::ObjectSet CMathContainer::mInitialStateValueAll

private

All initial state values (intensive and extensive)

Referenced by allocate(), createSynchronizeInitialValuesSequence(), getInitialStateObjects(), and relocate().

◆ mInitialStateValueExtensive

CObjectInterface::ObjectSet CMathContainer::mInitialStateValueExtensive

private

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

Referenced by allocate(), createApplyInitialValuesSequence(), createSynchronizeInitialValuesSequence(), and relocate().

◆ mInitialStateValueIntensive

CObjectInterface::ObjectSet CMathContainer::mInitialStateValueIntensive

private

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

Referenced by allocate(), createSynchronizeInitialValuesSequence(), and relocate().

◆ mInitialTotalMasses

CVectorCore< C_FLOAT64 > CMathContainer::mInitialTotalMasses

private

Referenced by initializePointers(), pushInitialState(), and relocate().

◆ mIntensiveNoise

CVectorCore< C_FLOAT64 > CMathContainer::mIntensiveNoise

private

Referenced by initializePointers(), relocate(), and resetNoise().

◆ mIntensiveRates

CVectorCore< C_FLOAT64 > CMathContainer::mIntensiveRates

private

Referenced by initializePointers(), and relocate().

◆ mIntensiveValues

CVectorCore< C_FLOAT64 > CMathContainer::mIntensiveValues

private

Referenced by initializePointers(), and relocate().

◆ mIsAutonomous

bool CMathContainer::mIsAutonomous

private

A flag indicating whether the model is autonomous.

Referenced by createUpdateSimulationValuesSequence(), and isAutonomous().

◆ mNoiseInputObjects

CObjectInterface::ObjectSet CMathContainer::mNoiseInputObjects

private

The objects from which the noise originates

Referenced by addNoiseInputObject(), compileObjects(), getCountNoise(), getNoiseInputObjects(), and relocate().

◆ mNoiseReduced

CVectorCore< C_FLOAT64 > CMathContainer::mNoiseReduced

private

The noise contains the mean values for entities of type ODE, Independent

Referenced by getNoise(), and relocate().

◆ mNoiseSequence

CCore::CUpdateSequence CMathContainer::mNoiseSequence

private

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

Referenced by allocate(), createUpdateSimulationValuesSequence(), getNoiseSequence(), and updateNoiseValues().

◆ mNoiseSequenceReduced

CCore::CUpdateSequence CMathContainer::mNoiseSequenceReduced

private

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

Referenced by allocate(), createUpdateSimulationValuesSequence(), getNoiseSequence(), and updateNoiseValues().

◆ mNumTotalRootsIgnored

size_t CMathContainer::mNumTotalRootsIgnored

private

The total number of ignored event roots.

Referenced by compileEvents(), and ignoreDiscontinuityEvent().

◆ mObjects

CVectorCore< CMathObject > CMathContainer::mObjects

private

◆ mOldObjects

CVectorCore< CMathObject > CMathContainer::mOldObjects

private

Referenced by finishResize(), relocate(), relocateObject(), and relocateUpdateSequence().

◆ mOldValues

CVectorCore< C_FLOAT64 > CMathContainer::mOldValues

private

Referenced by finishResize(), relocate(), and relocateValue().

◆ mParticleFluxes

CVectorCore< C_FLOAT64 > CMathContainer::mParticleFluxes

private

Referenced by getParticleFluxes(), initializePointers(), and relocate().

◆ mpAvogadro

const CDataObject* CMathContainer::mpAvogadro

private

Referenced by copyBranch(), and createSynchronizeInitialValuesSequence().

◆ mpModel

CModel* CMathContainer::mpModel

private

A pointer to the data model which mathematics are contained

Referenced by allocate(), compile(), compileEvents(), createDiscontinuityEvents(), createValueChangeProhibited(), getCN(), getMathObject(), getModel(), getObject(), getObjectFromCN(), getStoichiometry(), initializeEvents(), initializeObjects(), and operator==().

◆ mpObjectsBuffer

CMathObject* CMathContainer::mpObjectsBuffer

private

Referenced by move(), and ~CMathContainer().

◆ mpProcessQueue

CMathEventQueue* CMathContainer::mpProcessQueue

private

Referenced by applyInitialValues(), getProcessQueue(), getProcessQueueExecutionTime(), processQueue(), relocate(), and ~CMathContainer().

◆ mpQuantity2NumberFactor

const CDataObject* CMathContainer::mpQuantity2NumberFactor

private

Referenced by createSynchronizeInitialValuesSequence(), getQuantity2NumberFactor(), getQuantity2NumberFactorObject(), and initializeAtolVector().

◆ mpRandomGenerator

CRandom* CMathContainer::mpRandomGenerator

private

Referenced by getRandomGenerator(), and ~CMathContainer().

◆ mPrioritySequence

CCore::CUpdateSequence CMathContainer::mPrioritySequence

private

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

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

◆ mPropensities

CVectorCore< C_FLOAT64 > CMathContainer::mPropensities

private

Referenced by getPropensities(), initializePointers(), and relocate().

◆ mpValuesBuffer

C_FLOAT64* CMathContainer::mpValuesBuffer

private

Referenced by move(), and ~CMathContainer().

◆ mRandom

CDataObjectReference< C_FLOAT64 > CMathContainer::mRandom

private

Referenced by getRandomObject().

◆ mRate

CVectorCore< C_FLOAT64 > CMathContainer::mRate

private

The rate contains derivatives for values of type EventTarget, Time, ODE, Independent, and Dependent

Referenced by calculateJacobian(), calculateJacobianDependencies(), calculateRootDerivatives(), calculateRootJacobian(), getRate(), and relocate().

◆ mRateReduced

CVectorCore< C_FLOAT64 > CMathContainer::mRateReduced

private

The reduced rate derivatives for contains values of type EventTarget, Time, ODE, Independent

Referenced by getRate(), and relocate().

◆ mReactionNoise

CVectorCore< C_FLOAT64 > CMathContainer::mReactionNoise

private

Referenced by initializePointers(), relocate(), and resetNoise().

◆ mReactionParticleNoise

CVectorCore< C_FLOAT64 > CMathContainer::mReactionParticleNoise

private

Referenced by initializePointers(), relocate(), and resetNoise().

◆ mReactions

CVectorCore< CMathReaction > CMathContainer::mReactions

private

A vector containing all math reactions.

Referenced by allocate(), compile(), getMathReaction(), getReactions(), relocate(), and ~CMathContainer().

◆ mReducedStateValues

CObjectInterface::ObjectSet CMathContainer::mReducedStateValues

private

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

Referenced by allocate(), createUpdateSimulationValuesSequence(), getStateObjects(), and relocate().

◆ mRootCount2Events

std::multimap< size_t, size_t > CMathContainer::mRootCount2Events

private

A map of root counts to math events.

Referenced by allocate(), compile(), compileEvents(), and replaceDiscontinuousNode().

◆ mRootDerivatives

CVector< C_FLOAT64 > CMathContainer::mRootDerivatives

private

The root derivatives calculated for mRootDerivativesState

Referenced by analyzeRoots(), and applyInitialValues().

◆ mRootDerivativesState

CVector< C_FLOAT64 > CMathContainer::mRootDerivativesState

private

The state for which the root derivatives are calculated

Referenced by analyzeRoots(), and applyInitialValues().

◆ mRootIsDiscrete

CVector< bool > CMathContainer::mRootIsDiscrete

private

A vector of Boolean values indicating whether a root is changing continuously or only during discrete event processing.

Referenced by analyzeRoots(), getRootIsDiscrete(), ignoreDiscontinuityEvent(), and relocate().

◆ mRootIsTimeDependent

CVector< bool > CMathContainer::mRootIsTimeDependent

private

A vector of Boolean values indicating whether a root is non time dependent.

Referenced by analyzeRoots(), getRootIsTimeDependent(), ignoreDiscontinuityEvent(), and relocate().

◆ mRootProcessors

CVector< CMathEvent::CTrigger::CRootProcessor * > CMathContainer::mRootProcessors

private

A vector of pointers to all objects values CMathEventN::CTrigger::CRootProcessor

Referenced by analyzeRoots(), applyInitialValues(), getRootProcessors(), ignoreDiscontinuityEvent(), processRoots(), and relocate().

◆ mRootSequence

CCore::CUpdateSequence CMathContainer::mRootSequence

private

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

Referenced by createUpdateSimulationValuesSequence(), and updateRootValues().

◆ mRootSequenceReduced

CCore::CUpdateSequence CMathContainer::mRootSequenceReduced

private

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

Referenced by createUpdateSimulationValuesSequence(), and updateRootValues().

◆ mSimulationRequiredValues

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.

Referenced by allocate(), createUpdateAllTransientDataValuesSequence(), createUpdateSimulationValuesSequence(), getSimulationUpToDateObjects(), and relocate().

◆ mSimulationValuesSequence

CCore::CUpdateSequence 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

Referenced by allocate(), createUpdateSimulationValuesSequence(), getSimulationValuesSequence(), and updateSimulatedValues().

◆ mSimulationValuesSequenceReduced

CCore::CUpdateSequence 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

Referenced by allocate(), createUpdateSimulationValuesSequence(), getSimulationValuesSequence(), and updateSimulatedValues().

◆ mSize

sSize CMathContainer::mSize

private

◆ mState

CVectorCore< C_FLOAT64 > CMathContainer::mState

private

The state contains values of type EventTarget, Time, ODE, Independent, and Dependent

Referenced by analyzeRoots(), applyInitialValues(), calculateElasticityDependencies(), calculateJacobian(), calculateJacobianDependencies(), calculateRootJacobian(), createUpdateSimulationValuesSequence(), fetchState(), getState(), isStateValid(), processRoots(), pushState(), relocate(), setInitialState(), and setState().

◆ mStateReduced

CVectorCore< C_FLOAT64 > CMathContainer::mStateReduced

private

The reduced state contains values of type EventTarget, Time, ODE, Independent

Referenced by getState(), and relocate().

◆ mStateValues

CObjectInterface::ObjectSet CMathContainer::mStateValues

private

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

Referenced by allocate(), areObjectsConstant(), createUpdateAllTransientDataValuesSequence(), createUpdateSimulationValuesSequence(), getStateObjects(), and relocate().

◆ mSynchronizeInitialValuesSequenceExtensive

CCore::CUpdateSequence CMathContainer::mSynchronizeInitialValuesSequenceExtensive

private

The sequence of updates needed to synchronize the initial values based on extensive values, i.e., species amounts

Referenced by allocate(), createSynchronizeInitialValuesSequence(), getSynchronizeInitialValuesSequence(), and updateInitialValues().

◆ mSynchronizeInitialValuesSequenceIntensive

CCore::CUpdateSequence CMathContainer::mSynchronizeInitialValuesSequenceIntensive

private

The sequence of updates needed to synchronize the initial values based on intensive values, i.e., species concentrations.

Referenced by allocate(), createSynchronizeInitialValuesSequence(), getSynchronizeInitialValuesSequence(), and updateInitialValues().

◆ mTotalMasses

CVectorCore< C_FLOAT64 > CMathContainer::mTotalMasses

private

Referenced by getTotalMasses(), initializePointers(), and relocate().

◆ mTransientDataObjectSequence

CCore::CUpdateSequence CMathContainer::mTransientDataObjectSequence

private

The sequence of updates needed to calculate all objects which have data object associated on the assumption that all state values may have changed

Referenced by allocate(), createUpdateAllTransientDataValuesSequence(), getTransientDataValueSequence(), and updateTransientDataValues().

◆ mTransientDependencies

CMathDependencyGraph CMathContainer::mTransientDependencies

private

Dependency graph for transient value calculations

Referenced by addAnalysisEvent(), allocate(), analyzeRoots(), areObjectsConstant(), calculateElasticityDependencies(), calculateJacobianDependencies(), compile(), createApplyInitialValuesSequence(), createDependencyGraphs(), createUpdateAllTransientDataValuesSequence(), createUpdateSimulationValuesSequence(), createValueChangeProhibited(), getTransientDependencies(), relocate(), removeAnalysisEvent(), removeAnalysisObject(), and removeDataObject().

◆ mTransitionTimes

CVectorCore< C_FLOAT64 > CMathContainer::mTransitionTimes

private

Referenced by initializePointers(), and relocate().

◆ mTriggerInfix2Event

std::map< std::string, CMathEvent * > CMathContainer::mTriggerInfix2Event

private

A map from the discontinuity trigger infix of to event representing it.

Referenced by compile(), and replaceDiscontinuousNode().

◆ mUpdateSequences

std::set< CMathUpdateSequence * > CMathContainer::mUpdateSequences

private

Pointers to all update sequences associated with this container;

Referenced by allocate(), deregisterUpdateSequence(), registerUpdateSequence(), relocate(), and ~CMathContainer().

◆ mValueChangeProhibited

CObjectInterface::ObjectSet CMathContainer::mValueChangeProhibited

private

A set of object for which changing the initial value is prohibeted;

Referenced by createSynchronizeInitialValuesSequence(), createUpdateSimulationValuesSequence(), createValueChangeProhibited(), getValueChangeProhibited(), and relocate().

◆ mValues

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

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ CMathContainer() [1/3]

◆ CMathContainer() [2/3]

◆ CMathContainer() [3/3]

◆ ~CMathContainer()

Member Function Documentation

◆ addAnalysisEvent()

◆ addAnalysisObject()

◆ addNoiseInputObject()

◆ allocate()

◆ analyzeRoots()

◆ applyInitialValues()

◆ applyUpdateSequence()

◆ areObjectsConstant()

◆ calculateElasticityDependencies()

◆ calculateJacobian()

◆ calculateJacobianDependencies()

◆ calculateRootDerivatives()

◆ calculateRootJacobian() [1/2]

◆ calculateRootJacobian() [2/2]

◆ compile()

◆ compileDiscreteChanges()

◆ compileEvents()

◆ compileObjects()

◆ copy()

◆ copyBranch() [1/2]

◆ copyBranch() [2/2]

◆ createApplyInitialValuesSequence()

◆ createDelays()

◆ createDependencyGraphs()

◆ createDiscontinuityDataEvent()

◆ createDiscontinuityEvents() [1/2]

◆ createDiscontinuityEvents() [2/2]

◆ createDiscontinuityTriggerInfix()

◆ createNodeFromObject()

◆ createNodeFromValue()

◆ createRelocation()

◆ createRelocations()

◆ createSynchronizeInitialValuesSequence()

◆ createUpdateAllTransientDataValuesSequence()

◆ createUpdateSequences()

◆ createUpdateSimulationValuesSequence()

◆ createValueChangeProhibited()

◆ deregisterUpdateSequence()

◆ fetchInitialState()

◆ fetchState()

◆ finishResize()

◆ getApplyInitialValuesSequence()

◆ getCN()

◆ getCompartment()

◆ getCompleteInitialState()

◆ getCountAssignments()

◆ getCountDependentSpecies()

◆ getCountFixed()

◆ getCountFixedEventTargets()

◆ getCountIndependentSpecies()

◆ getCountNoise()

◆ getCountODEs()

◆ getDataObject()

◆ getDelayLags()

◆ getEntityType()

◆ getEvents()

◆ getFluxes()

◆ getHistory()

◆ getInitialDependencies()

◆ getInitialState() [1/2]

◆ getInitialState() [2/2]

◆ getInitialStateObjects()

◆ getInitialValueObject()

◆ getInitialValuePointer()

◆ getLargestReactionCompartment()

◆ getMathObject() [1/3]

◆ getMathObject() [2/3]

◆ getMathObject() [3/3]