#include <CMathDependencyNode.h>

Collaboration diagram for CMathDependencyNode:

Public Member Functions
void	addDependent (CMathDependencyNode *pNode)

void	addPrerequisite (CMathDependencyNode *pNode)

bool	buildUpdateSequence (const CMath::SimulationContextFlag &context, CObjectInterface::UpdateSequence &updateSequence)

	CMathDependencyNode (const CObjectInterface *pObject)

std::vector < CMathDependencyNode * > &	getDependents ()

const CObjectInterface *	getObject () const

std::vector < CMathDependencyNode * > &	getPrerequisites ()

const bool &	isChanged () const

const bool &	isRequested () const

void	setChanged (const bool &changed)

void	setRequested (const bool &requested)

bool	updateDependentState (const CMath::SimulationContextFlag &context, const CObjectInterface::ObjectSet &changedObjects)

bool	updatePrerequisiteState (const CMath::SimulationContextFlag &context, const CObjectInterface::ObjectSet &changedObjects)

	~CMathDependencyNode (void)

Private Member Functions
	CMathDependencyNode (void)

Private Attributes
bool	mChanged

std::vector < CMathDependencyNode * >	mDependents

const CObjectInterface *	mpObject

std::vector < CMathDependencyNode * >	mPrerequisites

bool	mRequested

Detailed Description

Definition at line 15 of file CMathDependencyNode.h.

Constructor & Destructor Documentation

CMathDependencyNode::CMathDependencyNode ( void )

private

Definition at line 14 of file CMathDependencyNode.cpp.

                                         :
   mpObject(NULL),
   mPrerequisites(),
   mDependents(),
   mChanged(false),
   mRequested(false)
 {}

CMathDependencyNode::CMathDependencyNode ( const CObjectInterface * pObject )

Specific constructor

Parameters

const CObjectInterface * pObject

Definition at line 22 of file CMathDependencyNode.cpp.

                                                                         :
   mpObject(pObject),
   mPrerequisites(),
   mDependents(),
   mChanged(false),
   mRequested(false)
 {}

CMathDependencyNode::~CMathDependencyNode ( void )

Destructor

Definition at line 30 of file CMathDependencyNode.cpp.

31 {}

Member Function Documentation

void CMathDependencyNode::addDependent ( CMathDependencyNode * pNode )

Add a dependent

Parameters

CMathDependencyNode * pNode

Definition at line 48 of file CMathDependencyNode.cpp.

References mDependents.

 {
   mDependents.push_back(pObject);
 }

void CMathDependencyNode::addPrerequisite ( CMathDependencyNode * pNode )

Add a prerequisite

Parameters

CMathDependencyNode * pNode

Definition at line 38 of file CMathDependencyNode.cpp.

References mPrerequisites.

 {
   mPrerequisites.push_back(pObject);
 }

bool CMathDependencyNode::buildUpdateSequence	(	const CMath::SimulationContextFlag &	context,
		CObjectInterface::UpdateSequence &	updateSequence
	)

Build the sequence of objects which need to be updated to calculate the object value.

Parameters

const	CMath::SimulationContextFlag & context
CObjectInterface::UpdateSequence	& updateSequence

Returns: bool success

Definition at line 142 of file CMathDependencyNode.cpp.

References CMathDependencyNodeIterator::After, CMathDependencyNodeIterator::Before, CMath::Dependent, CMathDependencyNodeIterator::End, getObject(), CCopasiObject::getObjectParent(), CMathObject::getSimulationType(), CMathObject::getValueType(), isChanged(), isRequested(), mChanged, mRequested, CMathDependencyNodeIterator::next(), CMathDependencyNodeIterator::Prerequisites, setChanged(), CMathDependencyNodeIterator::setProcessingModes(), CMathDependencyNodeIterator::skipChildren(), CMathDependencyNodeIterator::state(), CMath::UseMoieties, and CMath::Value.

 {
   if (!mChanged || !mRequested)
     return true;
 
   CMathDependencyNodeIterator itNode(this, CMathDependencyNodeIterator::Prerequisites);
   itNode.setProcessingModes(CMathDependencyNodeIterator::Before | CMathDependencyNodeIterator::After);
 
   while (itNode.next())
     {
       switch (itNode.state())
         {
           case CMathDependencyNodeIterator::Before:
 
             if (!itNode->isChanged() || !itNode->isRequested())
               {
                 itNode.skipChildren();
               }
 
             break;
 
           case CMathDependencyNodeIterator::After:
 
             // This check is not needed as unchanged or unrequested nodes
             // are skipped in Before processing.
             if (itNode->isChanged() && itNode->isRequested())
               {
                 const CObjectInterface * pObject = itNode->getObject();
                 const CMathObject * pMathObject = NULL;
                 const CParticleReference * pParticleNumber = NULL;
 
                 // For an extensive transient value of a dependent species we have 2
                 // possible assignments depending on the context.
                 //   1) Conversion from the intensive property
                 //   2) Dependent mass off a moiety
                 //
                 // The solution is that the moiety automatically updates the value in conjunction
                 // with the dependency graph omitting the value in the update sequence if the context
                 // is CMath::UseMoieties.
 
                 if (!(context & CMath::UseMoieties) ||
                     ((pMathObject = dynamic_cast< const CMathObject *>(pObject)) == NULL &&
                      (pParticleNumber = dynamic_cast< const CParticleReference *>(pObject)) == NULL) ||
                     (pMathObject != NULL &&
                      (pMathObject->getSimulationType() != CMath::Dependent ||
                       pMathObject->getValueType() != CMath::Value)) ||
                     (pParticleNumber != NULL &&
                      !static_cast< const CMetab * >(pParticleNumber->getObjectParent())->isDependent()))
                   {
                     updateSequence.push_back(const_cast< CObjectInterface * >(itNode->getObject()));
                     itNode->setChanged(false);
                   }
               }
 
             break;
 
           default:
             break;
         }
     }
 
   mChanged = false;
 
   return itNode.state() == CMathDependencyNodeIterator::End;
 }

std::vector< CMathDependencyNode * > & CMathDependencyNode::getDependents ( )

Retrieve the dependents

Returns: std::vector< CMathDependencyNode * > dependents

Definition at line 53 of file CMathDependencyNode.cpp.

References mDependents.

Referenced by CMathDependencyNodeIterator::CStackElement::CStackElement().

 {
   return mDependents;
 }

const CObjectInterface * CMathDependencyNode::getObject ( ) const

Retrieve a pointer to the object the node is representing

Returns: const CObjectInterface * pObject

Definition at line 33 of file CMathDependencyNode.cpp.

References mpObject.

Referenced by buildUpdateSequence(), updateDependentState(), and updatePrerequisiteState().

 {
   return mpObject;
 }

std::vector< CMathDependencyNode * > & CMathDependencyNode::getPrerequisites ( )

Retrieve the prerequisites

Returns: std::vector< CMathDependencyNode * > prerequisites

Definition at line 43 of file CMathDependencyNode.cpp.

References mPrerequisites.

Referenced by CMathDependencyNodeIterator::CStackElement::CStackElement().

 {
   return mPrerequisites;
 }

const bool & CMathDependencyNode::isChanged ( ) const

Check whether the current nodes value is changed

Returns: const bool & isChanged

Definition at line 214 of file CMathDependencyNode.cpp.

References mChanged.

Referenced by buildUpdateSequence(), and updateDependentState().

 {
   return mChanged;
 }

const bool & CMathDependencyNode::isRequested ( ) const

Check whether the current node's value is requested

Parameters

const bool & isRequested

Definition at line 224 of file CMathDependencyNode.cpp.

References mRequested.

Referenced by buildUpdateSequence(), and updatePrerequisiteState().

 {
   return mRequested;
 }

void CMathDependencyNode::setChanged ( const bool & changed )

Set whether the current node has changed its value

Parameters

const bool & changed

Definition at line 209 of file CMathDependencyNode.cpp.

References mChanged.

Referenced by buildUpdateSequence(), and updateDependentState().

 {
   mChanged = changed;
 }

void CMathDependencyNode::setRequested ( const bool & requested )

Set whether the current node's value is requested

Parameters

const bool & requested

Definition at line 219 of file CMathDependencyNode.cpp.

References mRequested.

Referenced by updatePrerequisiteState().

 {
   mRequested = requested;
 }

bool CMathDependencyNode::updateDependentState	(	const CMath::SimulationContextFlag &	context,
		const CObjectInterface::ObjectSet &	changedObjects
	)

Update the state of all dependents (and dependents thereof) to changed,

Parameters

const	CMath::SimulationContextFlag & context
const	CObjectInterface::ObjectSet & changedObjects

Returns: bool success

Definition at line 58 of file CMathDependencyNode.cpp.

References CMathDependencyNodeIterator::Before, CMathDependencyNodeIterator::Dependents, CMathDependencyNodeIterator::End, getObject(), isChanged(), CObjectInterface::isPrerequisiteForContext(), CMathDependencyNodeIterator::next(), CMathDependencyNodeIterator::parent(), CMathDependencyNodeIterator::Recursive, setChanged(), CMathDependencyNodeIterator::setProcessingModes(), CMathDependencyNodeIterator::skipChildren(), and CMathDependencyNodeIterator::state().

 {
   CMathDependencyNodeIterator itNode(this, CMathDependencyNodeIterator::Dependents);
   itNode.setProcessingModes(CMathDependencyNodeIterator::Before);
 
   while (itNode.next())
     {
       // If we have a recursive dependency we need make sure that this is due to
       // an intensive/extensive value pair
       if (itNode.state() == CMathDependencyNodeIterator::Recursive)
         {
           if (itNode->getObject()->isPrerequisiteForContext(itNode.parent()->getObject(), context, changedObjects))
             {
               return false;
             }
 
           continue;
         }
 
       // The node itself is not modified.
       if (*itNode == this)
         {
           continue;
         }
 
       // We are guaranteed that the current node has a parent as the only node without is this,
       // which is handled above.
       if (!itNode->isChanged() &&
           itNode->getObject()->isPrerequisiteForContext(itNode.parent()->getObject(), context, changedObjects))
         {
           itNode->setChanged(true);
         }
       else
         {
           itNode.skipChildren();
         }
     }
 
   return itNode.state() == CMathDependencyNodeIterator::End;
 }

bool CMathDependencyNode::updatePrerequisiteState	(	const CMath::SimulationContextFlag &	context,
		const CObjectInterface::ObjectSet &	changedObjects
	)

Update the state of all prerequisites (and prerequisites thereof) to requested.

Parameters

const	CMath::SimulationContextFlag & context
const	CObjectInterface::ObjectSet & changedObjects

Returns: bool success

Definition at line 100 of file CMathDependencyNode.cpp.

References CMathDependencyNodeIterator::Before, CMathDependencyNodeIterator::End, getObject(), CObjectInterface::isPrerequisiteForContext(), isRequested(), CMathDependencyNodeIterator::next(), CMathDependencyNodeIterator::parent(), CMathDependencyNodeIterator::Prerequisites, CMathDependencyNodeIterator::Recursive, CMathDependencyNodeIterator::setProcessingModes(), setRequested(), CMathDependencyNodeIterator::skipChildren(), and CMathDependencyNodeIterator::state().

 {
   CMathDependencyNodeIterator itNode(this, CMathDependencyNodeIterator::Prerequisites);
   itNode.setProcessingModes(CMathDependencyNodeIterator::Before);
 
   while (itNode.next())
     {
       // If we have a recursive dependency we need make sure that this is due to
       // an intensive/extensive value pair
       if (itNode.state() == CMathDependencyNodeIterator::Recursive)
         {
           if (itNode.parent()->getObject()->isPrerequisiteForContext(itNode->getObject(), context, changedObjects))
             {
               return false;
             }
 
           continue;
         }
 
       // The node itself is not modified.
       if (*itNode == this)
         {
           continue;
         }
 
       // We are guaranteed that the current node has a parent as the only node without is this,
       // which is handled above.
       if (!itNode->isRequested() &&
           itNode.parent()->getObject()->isPrerequisiteForContext(itNode->getObject(), context, changedObjects))
         {
           itNode->setRequested(true);
         }
       else
         {
           itNode.skipChildren();
         }
     }
 
   return itNode.state() == CMathDependencyNodeIterator::End;
 }