COPASI API  4.16.103
Classes | Public Types | Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | Friends | List of all members
CProcessQueue Class Reference

#include <CProcessQueue.h>

Collaboration diagram for CProcessQueue:
Collaboration graph
[legend]

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_FLOAT64getProcessQueueExecutionTime () 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, CActionmActions
 
size_t mCascadingLevel
 
bool mContinueSimultaneousEvents
 
bool mEquality
 
std::set< size_t > mEventIdSet
 
size_t mExecutionCounter
 
size_t mExecutionLimit
 
voidmpCallbackTask
 
EventCallBack mpEventCallBack
 
CMathModelmpMathModel
 
resolveSimultaneousAssignments mpResolveSimultaneousAssignments
 
CVector< C_FLOAT64 > * mpRootValuesAfter
 
CVector< C_FLOAT64 > * mpRootValuesBefore
 
CVector< C_INTmRootsFound
 
CVector< C_FLOAT64mRootValues1
 
CVector< C_FLOAT64mRootValues2
 
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.

148  :
149  mActions(),
150  mExecutionLimit(10000),
152  mTime(0.0),
153  mEquality(true),
154  mCascadingLevel(0),
156  mEventIdSet(),
157  mpMathModel(NULL),
158  mRootsFound(0),
159  mRootValues1(0),
160  mRootValues2(0),
165  mpCallbackTask(NULL),
166  mpEventCallBack(NULL)
167 {}
C_FLOAT64 mTime
CVector< C_FLOAT64 > * mpRootValuesAfter
CVector< C_FLOAT64 > mRootValues1
size_t mExecutionLimit
std::set< size_t > mEventIdSet
size_t mCascadingLevel
EventCallBack mpEventCallBack
CMathModel * mpMathModel
CVector< C_INT > mRootsFound
CVector< C_FLOAT64 > mRootValues2
CVector< C_FLOAT64 > * mpRootValuesBefore
bool mContinueSimultaneousEvents
void * mpCallbackTask
size_t mExecutionCounter
bool mSimultaneousAssignmentsFound
resolveSimultaneousAssignments mpResolveSimultaneousAssignments
std::multimap< CKey, CAction > mActions
CProcessQueue::CProcessQueue ( const CProcessQueue src)

Copy constructor

Definition at line 169 of file CProcessQueue.cpp.

169  :
170  mActions(src.mActions),
173  mTime(src.mTime),
174  mEquality(src.mEquality),
188 {}
C_FLOAT64 mTime
CVector< C_FLOAT64 > * mpRootValuesAfter
CVector< C_FLOAT64 > mRootValues1
size_t mExecutionLimit
std::set< size_t > mEventIdSet
size_t mCascadingLevel
EventCallBack mpEventCallBack
CMathModel * mpMathModel
CVector< C_INT > mRootsFound
CVector< C_FLOAT64 > mRootValues2
CVector< C_FLOAT64 > * mpRootValuesBefore
bool mContinueSimultaneousEvents
void * mpCallbackTask
size_t mExecutionCounter
bool mSimultaneousAssignmentsFound
resolveSimultaneousAssignments mpResolveSimultaneousAssignments
std::multimap< CKey, CAction > mActions
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
constC_FLOAT64 & executionTime
constbool & equality
constCVector< 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().

197 {
198  // It is not possible to proceed backwards in time.
199  if (executionTime < mTime) return false;
200 
201  size_t CascadingLevel = mCascadingLevel;
202 
203  if (executionTime > mTime)
204  CascadingLevel = 0;
205 
206  mActions.insert(std::make_pair(CKey(executionTime, equality, CascadingLevel),
207  CAction(values, pEvent, this)));
208 
209  return true;
210 }
C_FLOAT64 mTime
size_t mCascadingLevel
std::multimap< CKey, CAction > mActions
bool CProcessQueue::addCalculation ( const C_FLOAT64 executionTime,
const bool &  equality,
CMathEvent pEvent 
)

Add a calculation to the process queue.

Parameters
constC_FLOAT64 & executionTime
constbool & equality
CMathEvent* pEvent
Returns
bool success

Definition at line 212 of file CProcessQueue.cpp.

References mActions, mCascadingLevel, and mTime.

Referenced by CMathEvent::fire().

215 {
216  // It is not possible to proceed backwards in time.
217  if (executionTime < mTime) return false;
218 
219  size_t CascadingLevel = mCascadingLevel;
220 
221  if (executionTime > mTime)
222  CascadingLevel = 0;
223 
224  mActions.insert(std::make_pair(CKey(executionTime, equality, CascadingLevel),
225  CAction(pEvent, this)));
226 
227  return true;
228 }
C_FLOAT64 mTime
size_t mCascadingLevel
std::multimap< CKey, CAction > mActions
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.

472 {
473  mEventIdSet.erase(eventId);
474 }
std::set< size_t > mEventIdSet
bool CProcessQueue::executeAction ( CProcessQueue::iterator  itAction)
private

Execute the actions

Parameters
CProcessQueue::iteratoritAction
Returns
bool stateChanged

Definition at line 363 of file CProcessQueue.cpp.

References mActions, and mExecutionCounter.

Referenced by process().

364 {
365  bool StateChanged = itAction->second.process();
366 
367  if (StateChanged)
368  {
370  }
371 
372  mActions.erase(itAction);
373 
374  return StateChanged;
375 }
size_t mExecutionCounter
std::multimap< CKey, CAction > mActions
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().

327 {
328  CKey Pending(mTime, mEquality, mCascadingLevel);
329  range PendingActions = mActions.equal_range(Pending);
330 
331  if (PendingActions.first == PendingActions.second)
332  {
333  return mActions.end();
334  }
335 
336  iterator nextAction = PendingActions.first;
337  ++nextAction;
338 
339  if (nextAction != PendingActions.second)
340  {
342  {
343 
344  // The resolution of simultaneous events is algorithm dependent.
345  // The simulation routine should provide a call back function.
347  {
349  }
350 
352  }
353  else if (mSimultaneousAssignmentsFound == false)
354  {
356  CCopasiMessage(CCopasiMessage::WARNING_FILTERED, "CMathModel (1): Simultaneous event assignments encountered.");
357  }
358  }
359 
360  return PendingActions.first;
361 }
C_FLOAT64 mTime
std::pair< std::multimap< CKey, CAction >::iterator, std::multimap< CKey, CAction >::iterator > range
size_t mCascadingLevel
#define MCMathModel
bool mContinueSimultaneousEvents
bool mSimultaneousAssignmentsFound
resolveSimultaneousAssignments mpResolveSimultaneousAssignments
std::multimap< CKey, CAction > mActions
std::multimap< CKey, CAction >::iterator iterator
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.

495 {
497 }
bool 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().

477 {
478  static C_FLOAT64 Infinity =
479  std::numeric_limits< C_FLOAT64 >::infinity();
480 
481  if (mActions.empty())
482  {
483  return Infinity;
484  }
485 
486  return mActions.begin()->first.getExecutionTime();
487 }
#define C_FLOAT64
Definition: copasi.h:92
std::multimap< CKey, CAction > mActions
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().

231 {
232  mpMathModel = pMathModel;
233  assert(mpMathModel != NULL);
234 
236 
237  mActions.clear();
238  mEventIdSet.clear();
240 
241  size_t NumRoots = mpMathModel->getNumRoots();
242  mRootsFound.resize(NumRoots);
243  mRootsFound = 0;
244  mRootValues1.resize(NumRoots);
245  mRootValues2.resize(NumRoots);
248 
249  return;
250 }
C_FLOAT64 mTime
CVector< C_FLOAT64 > * mpRootValuesAfter
CVector< C_FLOAT64 > mRootValues1
void resize(size_t size, const bool &copy=false)
Definition: CVector.h:301
std::set< size_t > mEventIdSet
const C_FLOAT64 & getInitialTime() const
Definition: CMathModel.cpp:206
CMathModel * mpMathModel
CVector< C_INT > mRootsFound
CVector< C_FLOAT64 > mRootValues2
CVector< C_FLOAT64 > * mpRootValuesBefore
bool mSimultaneousAssignmentsFound
size_t getNumRoots() const
Definition: CMathModel.cpp:412
std::multimap< CKey, CAction > mActions
bool CProcessQueue::notEmpty ( const range range)
staticprivate

Check whether a range is not empty

Parameters
constrange & range bool notEmpty

Definition at line 466 of file CProcessQueue.cpp.

467 {
468  return range.first != range.second;
469 }
std::pair< std::multimap< CKey, CAction >::iterator, std::multimap< CKey, CAction >::iterator > range
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
constC_FLOAT64 & time
constbool & priorToOutput
resolveSimultaneousAssignmentspResolveSimultaneousAssignments
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().

255 {
256  if (getProcessQueueExecutionTime() > time)
257  return false;
258 
259  mTime = time;
260  mEquality = priorToOutput;
261  mpResolveSimultaneousAssignments = pResolveSimultaneousAssignments;
262  mExecutionCounter = 0;
263  mCascadingLevel = 0;
264 
265  bool success = true;
266  bool stateChanged = false;
267 
269 
270  iterator itAction = getAction();
271 
272  // The algorithm below will work properly for user ordered events
273  // as the queue enforces the proper ordering.
274  while (success &&
275  itAction != mActions.end() &&
277  {
278  if (!executeAction(itAction))
279  {
280  itAction = getAction();
281  continue;
282  }
283 
284  stateChanged = true;
285 
286  // We switch to the next cascading level so that events triggered by the
287  // execution of assignments are properly scheduled.
288  mCascadingLevel++;
289 
290  // We need to compare the roots before the execution and after
291  // to determine which roots need to be charged.
292  if (rootsFound())
293  {
294  // We have to deal with both types of found roots.
296  }
297 
298  // Note, applying the events may have added new events to the queue.
299  // The setting of the equality flag for these events may be either true
300  // or false.
301 
302  // Independent from the setting priorToOutput we must only consider equality
303  mEquality = true;
304 
305  // Retrieve the pending calculations.
306  itAction = getAction();
307 
308  while (itAction == mActions.end() &&
309  mCascadingLevel > 0)
310  {
311  // If we are here we have no more actions for this level.
312  mCascadingLevel--;
313 
314  if (mCascadingLevel == 0)
315  {
316  mEquality = priorToOutput;
317  }
318 
319  itAction = getAction();
320  }
321  }
322 
323  return stateChanged;
324 }
C_FLOAT64 mTime
iterator getAction()
const C_FLOAT64 & getProcessQueueExecutionTime() const
void evaluateRoots(CVectorCore< C_FLOAT64 > &rootValues, const bool &ignoreDiscrete)
Definition: CMathModel.cpp:169
size_t mCascadingLevel
CMathModel * mpMathModel
CVector< C_INT > mRootsFound
bool executeAction(CProcessQueue::iterator itAction)
CVector< C_FLOAT64 > * mpRootValuesBefore
size_t mExecutionCounter
resolveSimultaneousAssignments mpResolveSimultaneousAssignments
std::multimap< CKey, CAction > mActions
void processRoots(const C_FLOAT64 &time, const bool &equality, const bool &correct, const CVector< C_INT > &roots)
Definition: CMathModel.cpp:218
std::multimap< CKey, CAction >::iterator iterator
#define max(a, b)
Definition: f2c.h:176
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().

378 {
379  bool rootsFound = false;
380 
381  // Calculate the current root values
383 
384  // Compare the root values before and after;
385  C_INT * pRootFound = mRootsFound.array();
386  C_INT * pRootEnd = pRootFound + mRootsFound.size();
387  C_FLOAT64 * pValueBefore = mpRootValuesBefore->array();
388  C_FLOAT64 * pValueAfter = mpRootValuesAfter->array();
389  CMathTrigger::CRootFinder *const* ppRootFinder = mpMathModel->getRootFinders().array();
390 
391  for (; pRootFound != pRootEnd; ++pRootFound, ++pValueBefore, ++pValueAfter, ++ppRootFinder)
392  {
393  // Root values which did not change are not found
394  if (*pValueBefore == *pValueAfter)
395  {
396  *pRootFound = 0;
397  continue;
398  }
399 
400  // Handle equality
401  if ((*ppRootFinder)->isEquality())
402  {
403  if ((*ppRootFinder)->isTrue())
404  {
405  if (*pValueAfter >= 0.0 || *pValueAfter > *pValueBefore)
406  {
407  *pRootFound = 0;
408  }
409  else
410  {
411  *pRootFound = 1;
412  rootsFound = true;
413  }
414  }
415  else
416  {
417  if (*pValueAfter < 0.0 || *pValueAfter < *pValueBefore)
418  {
419  *pRootFound = 0;
420  }
421  else
422  {
423  *pRootFound = 1;
424  rootsFound = true;
425  }
426  }
427  }
428  else
429  {
430  if ((*ppRootFinder)->isTrue())
431  {
432  if (*pValueAfter > 0.0 || *pValueAfter > *pValueBefore)
433  {
434  *pRootFound = 0;
435  }
436  else
437  {
438  *pRootFound = 1;
439  rootsFound = true;
440  }
441  }
442  else
443  {
444  if (*pValueAfter <= 0.0 || *pValueAfter < *pValueBefore)
445  {
446  *pRootFound = 0;
447  }
448  else
449  {
450  *pRootFound = 1;
451  rootsFound = true;
452  }
453  }
454  }
455  }
456 
457  // Swap before and after.
460  mpRootValuesAfter = pTmp;
461 
462  return rootsFound;
463 }
#define C_INT
Definition: copasi.h:115
CVector< C_FLOAT64 > * mpRootValuesAfter
void evaluateRoots(CVectorCore< C_FLOAT64 > &rootValues, const bool &ignoreDiscrete)
Definition: CMathModel.cpp:169
CMathModel * mpMathModel
CVector< C_INT > mRootsFound
CVector< C_FLOAT64 > * mpRootValuesBefore
size_t size() const
Definition: CVector.h:100
#define C_FLOAT64
Definition: copasi.h:92
CType * array()
Definition: CVector.h:139
const CVector< CMathTrigger::CRootFinder * > & getRootFinders() const
Definition: CMathModel.cpp:447
void CProcessQueue::setContinueSimultaneousEvents ( const bool &  continueSimultaneousEvents)

Set whether to continue on simultaneous events

Parameters
constbool & continueSimultaneousEvents

Definition at line 489 of file CProcessQueue.cpp.

References mContinueSimultaneousEvents.

Referenced by CTrajectoryTask::initialize().

490 {
491  mContinueSimultaneousEvents = continueSimultaneousEvents;
492 }
bool mContinueSimultaneousEvents
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().

500 {
502  mpEventCallBack = ecb;
503 }
EventCallBack mpEventCallBack
CTSSATask * pTask
void * mpCallbackTask

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.

506 {
507  os << "Process Queue" << std::endl;
508  std::multimap< CProcessQueue::CKey, CProcessQueue::CAction >::const_iterator it;
509 
510  if (o.mActions.size()) os << " Actions:" << std::endl;
511 
512  for (it = o.mActions.begin(); it != o.mActions.end(); ++it)
513  {
514  os << "exec time " << it->first.mExecutionTime
515  << ", cascading lvl " << it->first.mCascadingLevel
516  << ", " << (it->first.mEquality ? "equality, " : "inequality");
517 
518  os << std::endl;
519 
520  CMathEvent * pEvent = it->second.mpEvent;
521 
522  os << "pEvent: 0x" << pEvent << ", Action: ";
523 
524  switch (it->second.mType)
525  {
527 
528  if (pEvent->delayAssignment())
529  {
530  os << "Calculation";
531  }
532  else
533  {
534  os << "Calculation & Assignment";
535  }
536 
537  break;
538 
540  os << "Assignment";
541  break;
542 
544  os << "Callback";
545  break;
546  }
547 
548  os << std::endl << std::endl;
549  }
550 
551  return os;
552 }
std::multimap< CKey, CAction > mActions

Member Data Documentation

std::multimap< CKey, CAction > CProcessQueue::mActions
private

An ordered list of calculations in the queue.

Definition at line 337 of file CProcessQueue.h.

Referenced by addAssignment(), addCalculation(), executeAction(), getAction(), getProcessQueueExecutionTime(), initialize(), operator<<(), and process().

size_t CProcessQueue::mCascadingLevel
private

The cascading level of events

Definition at line 362 of file CProcessQueue.h.

Referenced by addAssignment(), addCalculation(), getAction(), CProcessQueue::CKey::operator<(), and process().

bool CProcessQueue::mContinueSimultaneousEvents
private

A flag indicating to continue when simultaneous events are encountered.

Definition at line 412 of file CProcessQueue.h.

Referenced by getAction(), getContinueSimultaneousEvents(), and setContinueSimultaneousEvents().

bool CProcessQueue::mEquality
private

Indicate whether we processing equality or inequality

Definition at line 357 of file CProcessQueue.h.

Referenced by getAction(), CProcessQueue::CKey::operator<(), and process().

std::set< size_t > CProcessQueue::mEventIdSet
private

A set of currently active event ids

Definition at line 372 of file CProcessQueue.h.

Referenced by destroyEventId(), and initialize().

size_t CProcessQueue::mExecutionCounter
private

A counter of the execution steps for the current process

Definition at line 347 of file CProcessQueue.h.

Referenced by executeAction(), and process().

size_t CProcessQueue::mExecutionLimit
private

The limit of execution steps allowed for call to process

Definition at line 342 of file CProcessQueue.h.

void* CProcessQueue::mpCallbackTask
private

the object to which the call back function belongs

Definition at line 417 of file CProcessQueue.h.

Referenced by setEventCallBack().

EventCallBack CProcessQueue::mpEventCallBack
private

the pointer to the call back function

Definition at line 422 of file CProcessQueue.h.

Referenced by setEventCallBack().

CMathModel* CProcessQueue::mpMathModel
private

A pointer to the math model the process queue belongs to.

Definition at line 377 of file CProcessQueue.h.

Referenced by initialize(), process(), and rootsFound().

resolveSimultaneousAssignments CProcessQueue::mpResolveSimultaneousAssignments
private

A pointer to a call back method for resolving simultaneous event assignments

Definition at line 407 of file CProcessQueue.h.

Referenced by getAction(), and process().

CVector< C_FLOAT64 >* CProcessQueue::mpRootValuesAfter
private

Definition at line 402 of file CProcessQueue.h.

Referenced by initialize(), and rootsFound().

CVector< C_FLOAT64 >* CProcessQueue::mpRootValuesBefore
private

Definition at line 397 of file CProcessQueue.h.

Referenced by initialize(), process(), and rootsFound().

CVector< C_INT > CProcessQueue::mRootsFound
private

Definition at line 382 of file CProcessQueue.h.

Referenced by initialize(), process(), and rootsFound().

CVector< C_FLOAT64 > CProcessQueue::mRootValues1
private

Definition at line 387 of file CProcessQueue.h.

Referenced by initialize().

CVector< C_FLOAT64 > CProcessQueue::mRootValues2
private

Definition at line 392 of file CProcessQueue.h.

Referenced by initialize().

bool CProcessQueue::mSimultaneousAssignmentsFound
private

A flag indicating that simultaneous assignments have been found.

Definition at line 367 of file CProcessQueue.h.

Referenced by getAction(), and initialize().

C_FLOAT64 CProcessQueue::mTime
private

The current time

Definition at line 352 of file CProcessQueue.h.

Referenced by addAssignment(), addCalculation(), getAction(), initialize(), and process().


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