#include <CProcessQueue.h>

Collaboration diagram for CProcessQueue:

Classes
class	CAction

class	CKey

Public Types
typedef void(*	EventCallBack )(void *, CEvent::Type type)

typedef std::multimap< CKey, CAction >::iterator	iterator

typedef std::pair < std::multimap< CKey, CAction > ::iterator, std::multimap < CKey, CAction >::iterator >	range

typedef iterator(*	resolveSimultaneousAssignments )(const std::multimap< CKey, CAction > &, const C_FLOAT64 &, const bool &, const size_t &)

Public Member Functions
bool	addAssignment (const C_FLOAT64 &executionTime, const bool &equality, const CVector< C_FLOAT64 > &values, CMathEvent *pEvent)

bool	addCalculation (const C_FLOAT64 &executionTime, const bool &equality, CMathEvent *pEvent)

	CProcessQueue ()

	CProcessQueue (const CProcessQueue &src)

const bool &	getContinueSimultaneousEvents () const

const C_FLOAT64 &	getProcessQueueExecutionTime () const

void	initialize (CMathModel *pMathModel)

void	printDebug () const

bool	process (const C_FLOAT64 &time, const bool &priorToOutput, resolveSimultaneousAssignments pResolveSimultaneousAssignments)

void	setContinueSimultaneousEvents (const bool &continueSimultaneousEvents)

void	setEventCallBack (void *pTask, EventCallBack ecb)

	~CProcessQueue ()

Private Member Functions
void	destroyEventId (const size_t &eventId)

bool	executeAction (CProcessQueue::iterator itAction)

iterator	getAction ()

bool	rootsFound ()

Static Private Member Functions
static bool	notEmpty (const range &range)

Private Attributes
std::multimap< CKey, CAction >	mActions

size_t	mCascadingLevel

bool	mContinueSimultaneousEvents

bool	mEquality

std::set< size_t >	mEventIdSet

size_t	mExecutionCounter

size_t	mExecutionLimit

void *	mpCallbackTask

EventCallBack	mpEventCallBack

CMathModel *	mpMathModel

resolveSimultaneousAssignments	mpResolveSimultaneousAssignments

CVector< C_FLOAT64 > *	mpRootValuesAfter

CVector< C_FLOAT64 > *	mpRootValuesBefore

CVector< C_INT >	mRootsFound

CVector< C_FLOAT64 >	mRootValues1

CVector< C_FLOAT64 >	mRootValues2

bool	mSimultaneousAssignmentsFound

C_FLOAT64	mTime

Friends
std::ostream &	operator<< (std::ostream &os, const CKey &o)

std::ostream &	operator<< (std::ostream &os, const CAction &o)

std::ostream &	operator<< (std::ostream &os, const CProcessQueue &o)

Detailed Description

Definition at line 24 of file CProcessQueue.h.

Member Typedef Documentation

typedef void(* CProcessQueue::EventCallBack)(void *, CEvent::Type type)

This is the type for an event call back function

Definition at line 202 of file CProcessQueue.h.

typedef std::multimap< CKey, CAction >::iterator CProcessQueue::iterator

Definition at line 190 of file CProcessQueue.h.

typedef std::pair< std::multimap< CKey, CAction >::iterator, std::multimap< CKey, CAction >::iterator > CProcessQueue::range

Definition at line 192 of file CProcessQueue.h.

typedef iterator(* CProcessQueue::resolveSimultaneousAssignments)(const std::multimap< CKey, CAction > &, const C_FLOAT64 &, const bool &, const size_t &)

Definition at line 194 of file CProcessQueue.h.

Constructor & Destructor Documentation

CProcessQueue::CProcessQueue ( )

Default constructor

Definition at line 148 of file CProcessQueue.cpp.

                              :
   mActions(),
   mExecutionLimit(10000),
   mExecutionCounter(0),
   mTime(0.0),
   mEquality(true),
   mCascadingLevel(0),
   mSimultaneousAssignmentsFound(false),
   mEventIdSet(),
   mpMathModel(NULL),
   mRootsFound(0),
   mRootValues1(0),
   mRootValues2(0),
   mpRootValuesBefore(&mRootValues1),
   mpRootValuesAfter(&mRootValues2),
   mpResolveSimultaneousAssignments(NULL),
   mContinueSimultaneousEvents(false),
   mpCallbackTask(NULL),
   mpEventCallBack(NULL)
 {}

CProcessQueue::CProcessQueue ( const CProcessQueue & src )

Copy constructor

Definition at line 169 of file CProcessQueue.cpp.

                                                      :
   mActions(src.mActions),
   mExecutionLimit(src.mExecutionLimit),
   mExecutionCounter(src.mExecutionCounter),
   mTime(src.mTime),
   mEquality(src.mEquality),
   mCascadingLevel(src.mCascadingLevel),
   mSimultaneousAssignmentsFound(src.mSimultaneousAssignmentsFound),
   mEventIdSet(src.mEventIdSet),
   mpMathModel(src.mpMathModel),
   mRootsFound(src.mRootsFound),
   mRootValues1(src.mRootValues1),
   mRootValues2(src.mRootValues2),
   mpRootValuesBefore(&src.mRootValues1 == src.mpRootValuesBefore ? &mRootValues1 : &mRootValues2),
   mpRootValuesAfter(&src.mRootValues1 == src.mpRootValuesAfter ? &mRootValues1 : &mRootValues2),
   mpResolveSimultaneousAssignments(src.mpResolveSimultaneousAssignments),
   mContinueSimultaneousEvents(src.mContinueSimultaneousEvents),
   mpCallbackTask(src.mpCallbackTask),
   mpEventCallBack(src.mpEventCallBack)
 {}

CProcessQueue::~CProcessQueue ( )

Destructor

Definition at line 190 of file CProcessQueue.cpp.

191 {}

Member Function Documentation

bool CProcessQueue::addAssignment	(	const C_FLOAT64 &	executionTime,
		const bool &	equality,
		const CVector< C_FLOAT64 > &	values,
		CMathEvent *	pEvent
	)

Add an assignment to the process queue.

Parameters

const	C_FLOAT64 & executionTime
const	bool & equality
const	CVector< C_FLOAT64 > & values
CMathEvent	* pEvent

Returns: bool success

Definition at line 193 of file CProcessQueue.cpp.

References mActions, mCascadingLevel, and mTime.

Referenced by CMathEvent::fire().

 {
   // It is not possible to proceed backwards in time.
   if (executionTime < mTime) return false;
 
   size_t CascadingLevel = mCascadingLevel;
 
   if (executionTime > mTime)
     CascadingLevel = 0;
 
   mActions.insert(std::make_pair(CKey(executionTime, equality, CascadingLevel),
                                  CAction(values, pEvent, this)));
 
   return true;
 }

bool CProcessQueue::addCalculation	(	const C_FLOAT64 &	executionTime,
		const bool &	equality,
		CMathEvent *	pEvent
	)

Add a calculation to the process queue.

Parameters

const	C_FLOAT64 & executionTime
const	bool & equality
CMathEvent	* pEvent

Returns: bool success

Definition at line 212 of file CProcessQueue.cpp.

References mActions, mCascadingLevel, and mTime.

Referenced by CMathEvent::fire().

 {
   // It is not possible to proceed backwards in time.
   if (executionTime < mTime) return false;
 
   size_t CascadingLevel = mCascadingLevel;
 
   if (executionTime > mTime)
     CascadingLevel = 0;
 
   mActions.insert(std::make_pair(CKey(executionTime, equality, CascadingLevel),
                                  CAction(pEvent, this)));
 
   return true;
 }

void CProcessQueue::destroyEventId ( const size_t & eventId )

private

Destroy a unique eventId @param const size_t & eventId;

Definition at line 471 of file CProcessQueue.cpp.

References mEventIdSet.

 {
   mEventIdSet.erase(eventId);
 }

bool CProcessQueue::executeAction ( CProcessQueue::iterator itAction )

private

Execute the actions

Parameters

CProcessQueue::iterator itAction

Returns: bool stateChanged

Definition at line 363 of file CProcessQueue.cpp.

References mActions, and mExecutionCounter.

Referenced by process().

 {
   bool StateChanged = itAction->second.process();
 
   if (StateChanged)
     {
       mExecutionCounter++;
     }
 
   mActions.erase(itAction);
 
   return StateChanged;
 }

CProcessQueue::iterator CProcessQueue::getAction ( )

private

Retrieve the currently pending actions

Returns: CProcessQueue::iterator itAction

Definition at line 326 of file CProcessQueue.cpp.

References CCopasiMessage::EXCEPTION, mActions, mCascadingLevel, MCMathModel, mContinueSimultaneousEvents, mEquality, mpResolveSimultaneousAssignments, mSimultaneousAssignmentsFound, mTime, and CCopasiMessage::WARNING_FILTERED.

Referenced by process().

 {
   CKey Pending(mTime, mEquality, mCascadingLevel);
   range PendingActions = mActions.equal_range(Pending);
 
   if (PendingActions.first == PendingActions.second)
     {
       return mActions.end();
     }
 
   iterator nextAction = PendingActions.first;
   ++nextAction;
 
   if (nextAction != PendingActions.second)
     {
       if (!mContinueSimultaneousEvents)
         {
 
           // The resolution of simultaneous events is algorithm dependent.
           // The simulation routine should provide a call back function.
           if (mpResolveSimultaneousAssignments == NULL)
             {
               CCopasiMessage(CCopasiMessage::EXCEPTION, MCMathModel + 1);
             }
 
           return (*mpResolveSimultaneousAssignments)(mActions, mTime, mEquality, mCascadingLevel);
         }
       else if (mSimultaneousAssignmentsFound == false)
         {
           mSimultaneousAssignmentsFound = true;
           CCopasiMessage(CCopasiMessage::WARNING_FILTERED, "CMathModel (1): Simultaneous event assignments encountered.");
         }
     }
 
   return PendingActions.first;
 }

const bool & CProcessQueue::getContinueSimultaneousEvents ( ) const

Retrieve whether to continue on simultaneous events.

Returns: const bool & continueSimultaneousEvents

Definition at line 494 of file CProcessQueue.cpp.

References mContinueSimultaneousEvents.

 {
   return mContinueSimultaneousEvents;
 }

const C_FLOAT64 & CProcessQueue::getProcessQueueExecutionTime ( ) const

Retrieve the next execution time scheduled in the process queue

Returns: const C_FLOAT64 & processQueueExecutionTime

Definition at line 476 of file CProcessQueue.cpp.

References C_FLOAT64, and mActions.

Referenced by CMathModel::getProcessQueueExecutionTime(), and process().

 {
   static C_FLOAT64 Infinity =
     std::numeric_limits< C_FLOAT64 >::infinity();
 
   if (mActions.empty())
     {
       return Infinity;
     }
 
   return mActions.begin()->first.getExecutionTime();
 }

void CProcessQueue::initialize ( CMathModel * pMathModel )

Clear the process queue.

Parameters

CMathModel * pMathModel

Definition at line 230 of file CProcessQueue.cpp.

References CMathModel::getInitialTime(), CMathModel::getNumRoots(), mActions, mEventIdSet, mpMathModel, mpRootValuesAfter, mpRootValuesBefore, mRootsFound, mRootValues1, mRootValues2, mSimultaneousAssignmentsFound, mTime, and CVector< CType >::resize().

Referenced by CMathModel::applyInitialValues().

 {
   mpMathModel = pMathModel;
   assert(mpMathModel != NULL);
 
   mTime = mpMathModel->getInitialTime();
 
   mActions.clear();
   mEventIdSet.clear();
   mSimultaneousAssignmentsFound = false;
 
   size_t NumRoots = mpMathModel->getNumRoots();
   mRootsFound.resize(NumRoots);
   mRootsFound = 0;
   mRootValues1.resize(NumRoots);
   mRootValues2.resize(NumRoots);
   mpRootValuesBefore = &mRootValues1;
   mpRootValuesAfter = &mRootValues2;
 
   return;
 }

bool CProcessQueue::notEmpty ( const range & range )

staticprivate

Check whether a range is not empty

Parameters

const range & range bool notEmpty

Definition at line 466 of file CProcessQueue.cpp.

 {
   return range.first != range.second;
 }

void CProcessQueue::printDebug ( ) const

inline

This prints debugging info to stdout

Definition at line 295 of file CProcessQueue.h.

295 {std::cout << *this; };

bool CProcessQueue::process	(	const C_FLOAT64 &	time,
		const bool &	priorToOutput,
		resolveSimultaneousAssignments	pResolveSimultaneousAssignments
	)

Process the queue.

Parameters

const	C_FLOAT64 & time
const	bool & priorToOutput
resolveSimultaneousAssignments	pResolveSimultaneousAssignments

Returns: bool stateChanged

Definition at line 252 of file CProcessQueue.cpp.

References CMathModel::evaluateRoots(), executeAction(), getAction(), getProcessQueueExecutionTime(), mActions, max, mCascadingLevel, mEquality, mExecutionCounter, mpMathModel, mpResolveSimultaneousAssignments, mpRootValuesBefore, mRootsFound, mTime, CMathModel::processRoots(), and rootsFound().

Referenced by CMathModel::processQueue().

 {
   if (getProcessQueueExecutionTime() > time)
     return false;
 
   mTime = time;
   mEquality = priorToOutput;
   mpResolveSimultaneousAssignments = pResolveSimultaneousAssignments;
   mExecutionCounter = 0;
   mCascadingLevel = 0;
 
   bool success = true;
   bool stateChanged = false;
 
   mpMathModel->evaluateRoots(*mpRootValuesBefore, false);
 
   iterator itAction = getAction();
 
   // The algorithm below will work properly for user ordered events
   // as the queue enforces the proper ordering.
   while (success &&
          itAction != mActions.end() &&
          mCascadingLevel != std::numeric_limits<size_t>::max())
     {
       if (!executeAction(itAction))
         {
           itAction = getAction();
           continue;
         }
 
       stateChanged = true;
 
       // We switch to the next cascading level so that events triggered by the
       // execution of assignments are properly scheduled.
       mCascadingLevel++;
 
       // We need to compare the roots before the execution and after
       // to determine which roots need to be charged.
       if (rootsFound())
         {
           // We have to deal with both types of found roots.
           mpMathModel->processRoots(mTime, mRootsFound);
         }
 
       // Note, applying the events may have added new events to the queue.
       // The setting of the equality flag for these events may be either true
       // or false.
 
       // Independent from the setting priorToOutput we must only consider equality
       mEquality = true;
 
       // Retrieve the pending calculations.
       itAction = getAction();
 
       while (itAction == mActions.end() &&
              mCascadingLevel > 0)
         {
           // If we are here we have no more actions for this level.
           mCascadingLevel--;
 
           if (mCascadingLevel == 0)
             {
               mEquality = priorToOutput;
             }
 
           itAction = getAction();
         }
     }
 
   return stateChanged;
 }

bool CProcessQueue::rootsFound ( )

private

Check whether the executions of assignment lead to newly found roots

Returns: bool rootsFound

Definition at line 377 of file CProcessQueue.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, C_INT, CMathModel::evaluateRoots(), CMathModel::getRootFinders(), mpMathModel, mpRootValuesAfter, mpRootValuesBefore, mRootsFound, and CVectorCore< CType >::size().

Referenced by process().

 {
   bool rootsFound = false;
 
   // Calculate the current root values
   mpMathModel->evaluateRoots(*mpRootValuesAfter, false);
 
   // Compare the root values before and after;
   C_INT * pRootFound = mRootsFound.array();
   C_INT * pRootEnd = pRootFound + mRootsFound.size();
   C_FLOAT64 * pValueBefore = mpRootValuesBefore->array();
   C_FLOAT64 * pValueAfter = mpRootValuesAfter->array();
   CMathTrigger::CRootFinder *const* ppRootFinder = mpMathModel->getRootFinders().array();
 
   for (; pRootFound != pRootEnd; ++pRootFound, ++pValueBefore, ++pValueAfter, ++ppRootFinder)
     {
       // Root values which did not change are not found
       if (*pValueBefore == *pValueAfter)
         {
           *pRootFound = 0;
           continue;
         }
 
       // Handle equality
       if ((*ppRootFinder)->isEquality())
         {
           if ((*ppRootFinder)->isTrue())
             {
               if (*pValueAfter >= 0.0 || *pValueAfter > *pValueBefore)
                 {
                   *pRootFound = 0;
                 }
               else
                 {
                   *pRootFound = 1;
                   rootsFound = true;
                 }
             }
           else
             {
               if (*pValueAfter < 0.0 || *pValueAfter < *pValueBefore)
                 {
                   *pRootFound = 0;
                 }
               else
                 {
                   *pRootFound = 1;
                   rootsFound = true;
                 }
             }
         }
       else
         {
           if ((*ppRootFinder)->isTrue())
             {
               if (*pValueAfter > 0.0 || *pValueAfter > *pValueBefore)
                 {
                   *pRootFound = 0;
                 }
               else
                 {
                   *pRootFound = 1;
                   rootsFound = true;
                 }
             }
           else
             {
               if (*pValueAfter <= 0.0 || *pValueAfter < *pValueBefore)
                 {
                   *pRootFound = 0;
                 }
               else
                 {
                   *pRootFound = 1;
                   rootsFound = true;
                 }
             }
         }
     }
 
   // Swap before and after.
   CVector< C_FLOAT64 > * pTmp = mpRootValuesBefore;
   mpRootValuesBefore = mpRootValuesAfter;
   mpRootValuesAfter = pTmp;
 
   return rootsFound;
 }

void CProcessQueue::setContinueSimultaneousEvents ( const bool & continueSimultaneousEvents )

Set whether to continue on simultaneous events

Parameters

const bool & continueSimultaneousEvents

Definition at line 489 of file CProcessQueue.cpp.

References mContinueSimultaneousEvents.

Referenced by CTrajectoryTask::initialize().

 {
   mContinueSimultaneousEvents = continueSimultaneousEvents;
 }

void CProcessQueue::setEventCallBack	(	void *	pTask,
		EventCallBack	ecb
	)

Sets an event call back. The call back function must be a static function that receives a "this" pointer as first argument. The function is called when the actual assignment takes place, or when the assignment would take place in case the event has no assignment. The function is called with an integer argument: 1: An assignment has happened 2: A cut plane was crossed

Definition at line 499 of file CProcessQueue.cpp.

References mpCallbackTask, mpEventCallBack, and pTask.

Referenced by CCrossSectionTask::finish(), CCrossSectionTask::process(), and CCrossSectionTask::restore().

 {
   mpCallbackTask = pTask;
   mpEventCallBack = ecb;
 }

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		const CKey &	o
	)

friend

std::ostream& operator<<	(	std::ostream &	os,
		const CAction &	o
	)

friend

std::ostream& operator<<	(	std::ostream &	os,
		const CProcessQueue &	o
	)

friend

Definition at line 505 of file CProcessQueue.cpp.

 {
   os << "Process Queue" << std::endl;
   std::multimap< CProcessQueue::CKey, CProcessQueue::CAction >::const_iterator it;
 
   if (o.mActions.size()) os << " Actions:" << std::endl;
 
   for (it = o.mActions.begin(); it != o.mActions.end(); ++it)
     {
       os << "exec time " << it->first.mExecutionTime
          << ", cascading lvl " << it->first.mCascadingLevel
          << ", " << (it->first.mEquality ? "equality, " : "inequality");
 
       os << std::endl;
 
       CMathEvent * pEvent = it->second.mpEvent;
 
       os << "pEvent: 0x" << pEvent << ", Action: ";
 
       switch (it->second.mType)
         {
           case CProcessQueue::CAction::Calculation:
 
             if (pEvent->delayAssignment())
               {
                 os << "Calculation";
               }
             else
               {
                 os << "Calculation & Assignment";
               }
 
             break;
 
           case CProcessQueue::CAction::Assignment:
             os << "Assignment";
             break;
 
           case CProcessQueue::CAction::Callback:
             os << "Callback";
             break;
         }
 
       os << std::endl << std::endl;
     }
 
   return os;
 }