#include <CCrossSectionTask.h>

Inheritance diagram for CCrossSectionTask:

Collaboration diagram for CCrossSectionTask:

Public Member Functions
	CCrossSectionTask (const CCopasiContainer *pParent=NULL)

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

void	createEvent ()

virtual CCopasiMethod *	createMethod (const int &type) const

CState *	getState ()

const CTimeSeries &	getTimeSeries () const

virtual bool	initialize (const OutputFlag &of, COutputHandler pOutputHandler, std::ostream pOstream)

virtual bool	process (const bool &useInitialValues)

void	processStart (const bool &useInitialValues)

bool	processStep (const C_FLOAT64 &nextTime)

void	removeEvent ()

virtual bool	restore ()

virtual bool	setMethodType (const int &type)

	~CCrossSectionTask ()

Public Member Functions inherited from CCopasiTask
	CCopasiTask (const std::string &name="NoName", const CCopasiContainer *pParent=NULL, const std::string &type="Task")

	CCopasiTask (const Type &taskType, const CCopasiContainer *pParent=NULL, const std::string &type="Task")

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

void	cleanup ()

CProcessReport *	getCallBack () const

const CDescription &	getDescription () const

virtual const std::string &	getKey () const

CCopasiMethod *	getMethod ()

const CCopasiMethod *	getMethod () const

COutputHandler *	getOutputHandler () const

const OutputFlag &	getOutputMode () const

CCopasiProblem *	getProblem ()

const CCopasiProblem *	getProblem () const

CReport &	getReport ()

const CResult &	getResult () const

CCopasiParameterGroup *	getSliders ()

Type	getType () const

const bool &	isScheduled () const

const bool &	isUpdateModel () const

virtual void	output (const COutputInterface::Activity &activity)

virtual void	separate (const COutputInterface::Activity &activity)

virtual bool	setCallBack (CProcessReport *pCallBack)

void	setScheduled (const bool &scheduled)

void	setType (const Type &type)

void	setUpdateModel (const bool &updateModel)

virtual bool	updateMatrices ()

virtual	~CCopasiTask ()

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

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

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

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

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

virtual const objectMap &	getObjects () const

virtual std::string	getUnits () const

virtual const CCopasiObject *	getValueObject () const

virtual bool	remove (CCopasiObject *pObject)

virtual	~CCopasiContainer ()

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

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

void	clearDirectDependencies ()

void	clearRefresh ()

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

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

virtual CCopasiObjectName	getCN () const

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

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

CCopasiDataModel *	getObjectDataModel ()

const CCopasiDataModel *	getObjectDataModel () const

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

const std::string &	getObjectName () const

CCopasiContainer *	getObjectParent () const

const std::string &	getObjectType () const

virtual const CObjectInterface::ObjectSet &	getPrerequisites () const

virtual Refresh *	getRefresh () const

UpdateMethod *	getUpdateMethod () const

virtual void *	getValuePointer () const

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

bool	hasUpdateMethod () const

bool	isArray () const

bool	isContainer () const

bool	isDataModel () const

bool	isMatrix () const

bool	isNameVector () const

bool	isNonUniqueName () const

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

bool	isReference () const

bool	isRoot () const

bool	isSeparator () const

bool	isStaticString () const

bool	isValueBool () const

bool	isValueDbl () const

bool	isValueInt () const

bool	isValueInt64 () const

bool	isValueString () const

bool	isVector () const

virtual bool	mustBeDeleted (const DataObjectSet &deletedObjects) const

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

void	removeDirectDependency (const CCopasiObject *pObject)

void	setDirectDependencies (const DataObjectSet &directDependencies)

bool	setObjectName (const std::string &name)

virtual bool	setObjectParent (const CCopasiContainer *pParent)

void	setObjectValue (const C_FLOAT64 &value)

void	setObjectValue (const C_INT32 &value)

void	setObjectValue (const bool &value)

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

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

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

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

virtual	~CCopasiObject ()

Public Member Functions inherited from CObjectInterface
	CObjectInterface ()

virtual	~CObjectInterface ()

Static Public Attributes
static const unsigned int	ValidMethods []

Static Public Attributes inherited from CCopasiTask
static const std::string	TypeName []

static const unsigned int	ValidMethods []

static const char *	XMLType []

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

Private Types
enum	STATE { TRANSIENT = 0, MAIN, FINISH }

Private Member Functions
void	cleanup ()

void	eventCallBack (CEvent::Type type)

void	finish ()

void	initObjects ()

Static Private Member Functions
static void	EventCallBack (void *pCSTask, CEvent::Type type)

static C_FLOAT64	relativeDifferenceOfStates (CState s1, CState s2)

Private Attributes
C_FLOAT64	mAverageFreq

C_FLOAT64	mAveragePeriod

C_FLOAT64	mFreq

size_t	mhProgress

C_FLOAT64	mLastFreq

C_FLOAT64	mLastPeriod

size_t	mMaxNumCrossings

size_t	mNumCrossings

size_t	mOutputStartNumCrossings

C_FLOAT64	mOutputStartTime

CCrossSectionProblem *	mpCrossSectionProblem

CState *	mpCurrentState

const C_FLOAT64 *	mpCurrentTime

C_FLOAT64	mPeriod

C_INT	mPeriodicity

CEvent *	mpEvent

C_FLOAT64	mPreviousCrossingTime

C_FLOAT64	mProgressFactor

C_FLOAT64	mProgressMax

C_FLOAT64	mProgressValue

CTrajectoryMethod *	mpTrajectoryMethod

C_FLOAT64	mStartTime

STATE	mState

std::vector< CState >	mStatesRing

size_t	mStatesRingCounter

CTimeSeries	mTimeSeries

bool	mTimeSeriesRequested

bool	mUpdateMoieties

Additional Inherited Members
Public Types inherited from CCopasiTask
enum	eOutputFlagBase { INITIALIZE = 0x01, STREAM = 0x02, FINISH = 0x04, REPORT = 0x10, PLOT = 0x20, TIME_SERIES = 0x40 }

enum	OutputFlag { NO_OUTPUT = 0, OUTPUT_BEFORE = INITIALIZE, OUTPUT_AFTER = FINISH, OUTPUT = REPORT \| PLOT \| STREAM, OUTPUT_SE = REPORT \| PLOT \| INITIALIZE \| STREAM \| FINISH, OUTPUT_UI = REPORT \| PLOT \| TIME_SERIES \| INITIALIZE \| STREAM \| FINISH, ONLY_TIME_SERIES = TIME_SERIES \| INITIALIZE \| STREAM \| FINISH }

enum	Type { steadyState = 0, timeCourse, scan, fluxMode, optimization, parameterFitting, mca, lyap, tssAnalysis, sens, moieties, crosssection, lna, unset }

Public Types inherited from CCopasiContainer
typedef std::multimap < std::string, CCopasiObject * >	objectMap

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

typedef std::vector< Refresh * >	DataUpdateSequence

Public Types inherited from CObjectInterface
typedef std::set< const CObjectInterface * >	ObjectSet

typedef std::vector < CObjectInterface * >	UpdateSequence

Static Public Member Functions inherited from CCopasiTask
static bool	isValidMethod (const unsigned int &method, const unsigned int *validMethods)

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

static void	setRenameHandler (CRenameHandler *rh)

Public Attributes inherited from CCopasiTask
std::string	Error

std::string	Warning

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

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

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

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

void	initObjects ()

Protected Member Functions inherited from CCopasiObject
	CCopasiObject ()

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

Protected Attributes inherited from CCopasiTask
CDescription	mDescription

OutputFlag	mDoOutput

std::string	mKey

unsigned C_INT32	mOutputCounter

CProcessReport *	mpCallBack

CState *	mpInitialState

CCopasiMethod *	mpMethod

COutputHandler *	mpOutputHandler

CCopasiProblem *	mpProblem

CCopasiParameterGroup *	mpSliders

CReport	mReport

CResult	mResult

bool	mScheduled

Type	mType

bool	mUpdateModel

Protected Attributes inherited from CCopasiContainer
objectMap	mObjects

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

Detailed Description

Definition at line 31 of file CCrossSectionTask.h.

Member Enumeration Documentation

enum CCrossSectionTask::STATE

private

describes the internal state of the calculation

Enumerator
TRANSIENT
MAIN
FINISH

Definition at line 121 of file CCrossSectionTask.h.

   {
     TRANSIENT = 0, //before the condition for starting output is met
     MAIN,          //the main part of the run, while output is generated
     FINISH         //when the conditions for finishing are met
   };

Constructor & Destructor Documentation

CCrossSectionTask::CCrossSectionTask ( const CCopasiContainer * pParent = NULL )

Default constructor

Parameters

const CCopasiContainer * pParent (default: NULL)

Definition at line 37 of file CCrossSectionTask.cpp.

References CCopasiContainer::add(), createMethod(), CCopasiMethod::deterministic, initObjects(), CCopasiTask::mpMethod, and CCopasiTask::mpProblem.

                                                                     :
   CCopasiTask(CCopasiTask::crosssection, pParent),
   mTimeSeriesRequested(true),
   mTimeSeries(),
   mpCrossSectionProblem(NULL),
   mpTrajectoryMethod(NULL),
   mUpdateMoieties(false),
   mpCurrentState(NULL),
   mpCurrentTime(NULL),
   mOutputStartTime(0.0),
   mStartTime(0.0),
   mNumCrossings(0),
   mOutputStartNumCrossings(0),
   mMaxNumCrossings(std::numeric_limits< size_t >::max()),
   mhProgress(C_INVALID_INDEX),
   mProgressMax(1),
   mProgressValue(0),
   mProgressFactor(1),
   mpEvent(NULL),
   mState(CCrossSectionTask::TRANSIENT),
   mStatesRing(),
   mStatesRingCounter(0),
   mPreviousCrossingTime(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mPeriod(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mAveragePeriod(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mLastPeriod(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mPeriodicity(-1),
   mLastFreq(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mFreq(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mAverageFreq(std::numeric_limits< C_FLOAT64 >::quiet_NaN())
 {
   initObjects();
   mpProblem = new CCrossSectionProblem(this);
   mpMethod = createMethod(CCopasiMethod::deterministic);
   this->add(mpMethod, true);
 }

CCrossSectionTask::CCrossSectionTask	(	const CCrossSectionTask &	src,
		const CCopasiContainer *	pParent = `NULL`
	)

Copy constructor

Parameters

const	CCrossSectionTask & src
const	CCopasiContainer * pParent (default: NULL)

Definition at line 74 of file CCrossSectionTask.cpp.

References CCopasiContainer::add(), createMethod(), CCopasiParameterGroup::elevateChildren(), CCopasiMethod::getSubType(), initObjects(), CCopasiTask::mpMethod, and CCopasiTask::mpProblem.

                                                                       :
   CCopasiTask(src, pParent),
   mTimeSeriesRequested(src.mTimeSeriesRequested),
   mTimeSeries(),
   mpCrossSectionProblem(NULL),
   mpTrajectoryMethod(NULL),
   mUpdateMoieties(false),
   mpCurrentState(NULL),
   mpCurrentTime(NULL),
   mOutputStartTime(0.0),
   mStartTime(0.0),
   mNumCrossings(0),
   mOutputStartNumCrossings(0),
   mMaxNumCrossings(std::numeric_limits< size_t >::max()),
   mhProgress(C_INVALID_INDEX),
   mProgressMax(1),
   mProgressValue(0),
   mProgressFactor(1),
   mpEvent(NULL),
   mState(CCrossSectionTask::TRANSIENT),
   mStatesRing(),
   mStatesRingCounter(0),
   mPreviousCrossingTime(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mPeriod(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mAveragePeriod(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mLastPeriod(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mPeriodicity(-1),
   mLastFreq(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mFreq(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
   mAverageFreq(std::numeric_limits< C_FLOAT64 >::quiet_NaN())
 {
   initObjects();
   mpProblem =
     new CCrossSectionProblem(*static_cast< CCrossSectionProblem * >(src.mpProblem), this);
 
   mpMethod = createMethod(src.mpMethod->getSubType());
   * mpMethod = * src.mpMethod;
 
   mpMethod->elevateChildren();
 
   this->add(mpMethod, true);
 }

CCrossSectionTask::~CCrossSectionTask ( )

Destructor

Definition at line 118 of file CCrossSectionTask.cpp.

References cleanup().

 {
   cleanup();
 }

Member Function Documentation

void CCrossSectionTask::cleanup ( )

private

cleanup()

Definition at line 123 of file CCrossSectionTask.cpp.

References mpCurrentState, and pdelete.

Referenced by ~CCrossSectionTask().

 {
   pdelete(mpCurrentState);
 }

void CCrossSectionTask::createEvent ( )

Definition at line 194 of file CCrossSectionTask.cpp.

References C_INVALID_INDEX, CModel::compileIfNecessary(), CModel::createEvent(), CEvent::CutPlane, CModel::getEvents(), CCopasiVectorN< CType >::getIndex(), CCopasiProblem::getModel(), CCrossSectionProblem::getSingleObjectCN(), CCrossSectionProblem::getThreshold(), CCrossSectionProblem::isPositiveDirection(), mpCrossSectionProblem, mpEvent, CEvent::setTriggerExpression(), and CEvent::setType().

Referenced by initialize(), and CScanTask::process().

 {
   if (mpEvent != NULL) return;
 
   CModel* pModel = mpCrossSectionProblem->getModel();
 
   if (!mpCrossSectionProblem->getSingleObjectCN().empty())
     {
       int count = 0;
       std::string name = "__cutplane";
 
       while (pModel->getEvents().getIndex(name) != C_INVALID_INDEX)
         {
           std::stringstream str;
           str << "__cutplane" << ++count;
           name = str.str();
         }
 
       mpEvent = pModel->createEvent(name);
       mpEvent->setType(CEvent::CutPlane);
 
       std::stringstream expression;
       expression << "<" << mpCrossSectionProblem->getSingleObjectCN() << "> "
                  << (mpCrossSectionProblem->isPositiveDirection() ? std::string(" > ") : std::string(" < "))
                  << mpCrossSectionProblem->getThreshold();
 
       mpEvent ->setTriggerExpression(expression.str());
 
       pModel->compileIfNecessary(NULL);
     }
 }

CCopasiMethod * CCrossSectionTask::createMethod ( const int & type ) const

virtual

Create a method of the specified type to solve the task. It is the duty of the caller to release the CCopasiMethod.

Parameters

const CCopasiMethod::SubType & type

Returns: CCopasiMethod *

Reimplemented from CCopasiTask.

Definition at line 504 of file CCrossSectionTask.cpp.

References CTrajectoryMethod::createMethod().

Referenced by CCrossSectionTask(), and setMethodType().

 {
   CCopasiMethod::SubType Type = (CCopasiMethod::SubType) type;
 
   return CTrajectoryMethod::createMethod(Type);
 }

void CCrossSectionTask::EventCallBack	(	void *	pCSTask,
		CEvent::Type	type
	)

staticprivate

this is the static call back function that is called by the process queue when an event is executed-

Definition at line 518 of file CCrossSectionTask.cpp.

References eventCallBack().

Referenced by process().

519 {static_cast<CCrossSectionTask *>(pCSTask)->eventCallBack(type);}

CCrossSectionTask::eventCallBack

void eventCallBack(CEvent::Type type)

Definition: CCrossSectionTask.cpp:521

CCrossSectionTask

Definition: CCrossSectionTask.h:31

void CCrossSectionTask::eventCallBack ( CEvent::Type type )

private

This is the member function that is called by the static call back function It checks if an event describes the cut plane and does all the necessary analysis and output in this case

Definition at line 521 of file CCrossSectionTask.cpp.

References C_FLOAT64, CEvent::CutPlane, COutputInterface::DURING, FINISH, CCrossSectionProblem::getFlagLimitConvergence(), CCrossSectionProblem::getFlagLimitOutConvergence(), CCrossSectionProblem::getFlagLimitOutCrossings(), CCrossSectionProblem::getFlagLimitOutTime(), CCopasiProblem::getModel(), MAIN, mAverageFreq, mAveragePeriod, mFreq, mhProgress, mLastFreq, mLastPeriod, mMaxNumCrossings, mNumCrossings, mOutputStartNumCrossings, mOutputStartTime, CCopasiTask::mpCallBack, mpCrossSectionProblem, mpCurrentState, mpCurrentTime, mPeriod, mPeriodicity, CCopasiTask::mpProblem, mPreviousCrossingTime, mProgressFactor, mProgressValue, mStartTime, mState, mStatesRing, mStatesRingCounter, mUpdateMoieties, CCopasiTask::output(), CProcessReport::progressItem(), relativeDifferenceOfStates(), RING_SIZE, CModel::setState(), TRANSIENT, and CModel::updateSimulatedValues().

Referenced by EventCallBack().

 {
   //  std::cout << "event call back: " << type << std::endl;
 
   //do progress reporting
   if (mpCallBack != NULL)
     {
       mProgressValue = (*mpCurrentTime - mStartTime) * mProgressFactor;
 
       if (!mpCallBack->progressItem(mhProgress))
         {
           mState = FINISH;
         }
     }
 
   //do nothing else if the event is not representing a cut plane
   if (type != CEvent::CutPlane)
     return;
 
   mpProblem->getModel()->setState(*mpCurrentState);
   mpProblem->getModel()->updateSimulatedValues(mUpdateMoieties);
 
   // count the crossings
   ++mNumCrossings;
 
   // now check if we can transition to the main state
   if (mState == TRANSIENT)
     {
       // if output is not delayed by time and not delayed by number of crossings
       // and also not delayed by convergence
       // output is started immediately
       if (!mpCrossSectionProblem->getFlagLimitOutCrossings() &&
           !mpCrossSectionProblem->getFlagLimitOutTime() &&
           !mpCrossSectionProblem->getFlagLimitOutConvergence())
         {
           mState = MAIN;
         }
       else if (mpCrossSectionProblem->getFlagLimitOutTime() && *mpCurrentTime >= mOutputStartTime)
         {
           mState = MAIN;
         }
       else if (mpCrossSectionProblem->getFlagLimitOutCrossings() && mNumCrossings >= mOutputStartNumCrossings)
         {
           mState = MAIN;
         }
       else if (mpCrossSectionProblem->getFlagLimitOutConvergence() &&
                mStatesRingCounter > 0)
         {
           int i;
 
           for (i = mStatesRingCounter - 1; i >= 0 && i >= ((int) mStatesRingCounter) - RING_SIZE; --i)
             {
               C_FLOAT64 tmp = relativeDifferenceOfStates(&mStatesRing[i % RING_SIZE],
                               mpCurrentState);
 
               if (tmp < mpCrossSectionProblem->getConvergenceOutTolerance())
                 {
                   mPeriodicity = mStatesRingCounter - i;
                   mPeriod = *mpCurrentTime - mStatesRing[i % RING_SIZE].getTime();
                   mFreq = 1 / mPeriod;
                   mAveragePeriod = mPeriod / ((C_FLOAT64)mPeriodicity);
                   mAverageFreq = 1 / mAveragePeriod;
 
                   mState = MAIN;
                   break;
                 }
 
               //std::cout << i << "  " << tmp     << std::endl;
             }
         }
 
       if (mState == MAIN)
         {
           mStatesRingCounter = 0;
           mNumCrossings = 1;
         }
     }
 
   if (mState == MAIN)
     {
       //check for convergence (actually for the occurrence of similar states)
       if (mStatesRingCounter > 0)
         {
           int i;
 
           for (i = mStatesRingCounter - 1; i >= 0 && i >= ((int) mStatesRingCounter) - RING_SIZE; --i)
             {
               C_FLOAT64 tmp = relativeDifferenceOfStates(&mStatesRing[i % RING_SIZE],
                               mpCurrentState);
 
               if (tmp < mpCrossSectionProblem->getConvergenceTolerance())
                 {
                   mPeriodicity = mStatesRingCounter - i;
                   mPeriod = *mpCurrentTime - mStatesRing[i % RING_SIZE].getTime();
                   mFreq = 1 / mPeriod;
                   mAveragePeriod = mPeriod / ((C_FLOAT64)mPeriodicity);
                   mAverageFreq = 1 / mAveragePeriod;
 
                   if (mpCrossSectionProblem->getFlagLimitConvergence())
                     mState = FINISH;
 
                   break;
                 }
 
               //std::cout << "MAIN" << i << "  " << tmp     << std::endl;
             }
         }
 
       if (!isnan(mPreviousCrossingTime))
         {
           mLastPeriod = *mpCurrentTime - mPreviousCrossingTime;
         }
 
       mLastFreq = 1 / mLastPeriod;
 
       output(COutputInterface::DURING);
 
       //check if the conditions for stopping are met
       //we don't have to check for maximum duration, this is done elsewhere
       if (mMaxNumCrossings > 0 && mNumCrossings >= mMaxNumCrossings)
         mState = FINISH;
     }
 
   //store state in ring buffer
   mStatesRing[mStatesRingCounter % RING_SIZE] = *mpCurrentState;
   mPreviousCrossingTime = *mpCurrentTime;
   ++mStatesRingCounter;
 }

void CCrossSectionTask::finish ( )

private

should be called by all code paths that finish the task. -finishes progress reporting -finishes output -resets call back function

Definition at line 449 of file CCrossSectionTask.cpp.

References COutputInterface::AFTER, CProcessReport::finishItem(), CModel::getMathModel(), CCopasiProblem::getModel(), CMathModel::getProcessQueue(), mhProgress, CCopasiTask::mpCallBack, mpCrossSectionProblem, CCopasiTask::output(), and CProcessQueue::setEventCallBack().

Referenced by process(), and processStep().

 {
   //reset call back
   mpCrossSectionProblem->getModel()->getMathModel()->getProcessQueue().setEventCallBack(NULL, NULL);
 
   if (mpCallBack != NULL) mpCallBack->finishItem(mhProgress);
 
   output(COutputInterface::AFTER);
 }

CState * CCrossSectionTask::getState ( )

Retrieves a pointer to current state of the integration.

Returns: CState * pState

Definition at line 511 of file CCrossSectionTask.cpp.

References mpCurrentState.

512 {return mpCurrentState;}

CCrossSectionTask::mpCurrentState

CState * mpCurrentState

Definition: CCrossSectionTask.h:70

const CTimeSeries & CCrossSectionTask::getTimeSeries ( ) const

gets a reference to the time series

Returns: time series

Definition at line 514 of file CCrossSectionTask.cpp.

References mTimeSeries.

Referenced by getTimeSeriesFromTask().

515 {return mTimeSeries;}

CCrossSectionTask::mTimeSeries

CTimeSeries mTimeSeries

Definition: CCrossSectionTask.h:50

bool CCrossSectionTask::initialize	(	const OutputFlag &	of,
		COutputHandler *	pOutputHandler,
		std::ostream *	pOstream
	)

virtual

Initialize the task. If an ostream is given this ostream is used instead of the target specified in the report. This allows nested tasks to share the same output device.

Parameters

const	OutputFlag & of
COutputHandler	* pOutputHandler
std::ostream	* pOstream (default: NULL)

Returns: bool success

Reimplemented from CCopasiTask.

Definition at line 141 of file CCrossSectionTask.cpp.

References COutputHandler::addInterface(), CTimeSeries::allocate(), CTimeSeries::clear(), createEvent(), CCopasiProblem::getModel(), CCopasiParameterGroup::getParameter(), CModel::getState(), CState::getTime(), CCopasiParameter::getValue(), CCopasiTask::initialize(), CCopasiMethod::isValidProblem(), mpCrossSectionProblem, mpCurrentState, mpCurrentTime, CCopasiTask::mpMethod, CCopasiTask::mpProblem, mpTrajectoryMethod, mStatesRing, mStatesRingCounter, mTimeSeries, mTimeSeriesRequested, mUpdateMoieties, CCopasiParameter::Value::pBOOL, pdelete, RING_SIZE, CTrajectoryMethod::setProblem(), and CCopasiTask::TIME_SERIES.

 {
   assert(mpProblem && mpMethod);
 
   mpCrossSectionProblem = dynamic_cast<CCrossSectionProblem *>(mpProblem);
   assert(mpCrossSectionProblem);
 
   mpTrajectoryMethod = dynamic_cast<CTrajectoryMethod *>(mpMethod);
   assert(mpTrajectoryMethod);
 
   mpTrajectoryMethod->setProblem(mpCrossSectionProblem);
 
   bool success = mpMethod->isValidProblem(mpProblem);
 
   CCopasiParameter * pParameter = mpMethod->getParameter("Integrate Reduced Model");
 
   if (pParameter != NULL)
     mUpdateMoieties = *pParameter->getValue().pBOOL;
   else
     mUpdateMoieties = false;
 
   pdelete(mpCurrentState);
   mpCurrentState = new CState(mpCrossSectionProblem->getModel()->getState());
   mpCurrentTime = &mpCurrentState->getTime();
 
   //init the ring buffer for the states
   mStatesRing.resize(RING_SIZE);
   mStatesRingCounter = 0;
 
   // Handle the time series as a regular output.
   mTimeSeriesRequested = true;//mpCrossSectionProblem->timeSeriesRequested();
 
   if ((pOutputHandler != NULL) &&
       mTimeSeriesRequested &&
       (of & CCopasiTask::TIME_SERIES))
     {
       mTimeSeries.allocate(20);
       pOutputHandler->addInterface(&mTimeSeries);
     }
   else
     {
       mTimeSeries.clear();
     }
 
   createEvent();
 
   if (!CCopasiTask::initialize(of, pOutputHandler, pOstream)) success = false;
 
   return success;
 }

void CCrossSectionTask::initObjects ( )

private

initialize the object references

Definition at line 128 of file CCrossSectionTask.cpp.

References CCopasiContainer::addObjectReference(), mAverageFreq, mAveragePeriod, mFreq, mLastFreq, mLastPeriod, mPeriod, mPeriodicity, CCopasiObject::ValueDbl, and CCopasiObject::ValueInt.

Referenced by CCrossSectionTask().

 {
   addObjectReference("Period", mPeriod, CCopasiObject::ValueDbl);
   addObjectReference("Average Period", mAveragePeriod, CCopasiObject::ValueDbl);
   addObjectReference("Last Period", mLastPeriod, CCopasiObject::ValueDbl);
   addObjectReference("Periodicity", mPeriodicity, CCopasiObject::ValueInt);
   addObjectReference("Last Frequency", mLastFreq, CCopasiObject::ValueDbl);
   addObjectReference("Frequency", mFreq, CCopasiObject::ValueDbl);
   addObjectReference("Average Frequency", mAverageFreq, CCopasiObject::ValueDbl);
 }

bool CCrossSectionTask::process ( const bool & useInitialValues )

virtual

Process the task with or without initializing to the initial state.

Parameters

const bool & useInitialValues

Returns: bool success

Reimplemented from CCopasiTask.

Definition at line 236 of file CCrossSectionTask.cpp.

References CProcessReport::addItem(), COutputInterface::BEFORE, C_FLOAT64, EventCallBack(), CCopasiMessage::EXCEPTION, finish(), CCrossSectionProblem::getCrossingsLimit(), CTrajectoryProblem::getDuration(), CCrossSectionProblem::getFlagLimitCrossings(), CCrossSectionProblem::getFlagLimitOutCrossings(), CCrossSectionProblem::getFlagLimitOutTime(), CModel::getMathModel(), CCopasiException::getMessage(), CCopasiProblem::getModel(), CCrossSectionProblem::getOutCrossingsLimit(), CTrajectoryProblem::getOutputStartTime(), CMathModel::getProcessQueue(), mAverageFreq, mAveragePeriod, MCTrajectoryMethod, mFreq, mhProgress, min, mLastFreq, mLastPeriod, mMaxNumCrossings, mNumCrossings, mOutputStartNumCrossings, mOutputStartTime, CCopasiTask::mpCallBack, mpCrossSectionProblem, mpCurrentState, mpCurrentTime, mPeriod, mPeriodicity, mPreviousCrossingTime, mProgressFactor, mProgressMax, mProgressValue, mStartTime, mState, mStatesRingCounter, mUpdateMoieties, CCopasiTask::output(), processStart(), processStep(), CProcessQueue::setEventCallBack(), CProcessReport::setName(), CModel::setState(), TRANSIENT, and CModel::updateSimulatedValues().

 {
   processStart(useInitialValues);
 
   //this instructs the process queue to call back whenever an event is
   //executed
   mpCrossSectionProblem->getModel()->getMathModel()->getProcessQueue().setEventCallBack(this, &EventCallBack);
 
   mPreviousCrossingTime = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
   mPeriod = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
   mAveragePeriod = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
   mLastPeriod = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
   mPeriodicity = -1;
   mLastFreq = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
   mFreq = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
   mAverageFreq = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
 
   C_FLOAT64 MaxDuration = mpCrossSectionProblem->getDuration();
 
   //the output starts only after "outputStartTime" has passed
   if (mpCrossSectionProblem->getFlagLimitOutTime())
     {
       mOutputStartTime = *mpCurrentTime + mpCrossSectionProblem->getOutputStartTime();
       MaxDuration += mpCrossSectionProblem->getOutputStartTime();
     }
   else
     {
       mOutputStartTime = *mpCurrentTime;
     }
 
   const C_FLOAT64 EndTime = *mpCurrentTime + MaxDuration;
 
   mStartTime = *mpCurrentTime;
 
   // It suffices to reach the end time within machine precision
   C_FLOAT64 CompareEndTime = mOutputStartTime - 100.0 * (fabs(EndTime) * std::numeric_limits< C_FLOAT64 >::epsilon() + std::numeric_limits< C_FLOAT64 >::min());
 
   if (mpCrossSectionProblem->getFlagLimitCrossings())
     mMaxNumCrossings = mpCrossSectionProblem->getCrossingsLimit();
   else
     mMaxNumCrossings = 0;
 
   if (mpCrossSectionProblem->getFlagLimitOutCrossings())
     mOutputStartNumCrossings = mpCrossSectionProblem->getOutCrossingsLimit();
   else
     mOutputStartNumCrossings = 0;
 
   output(COutputInterface::BEFORE);
 
   bool flagProceed = true;
   mProgressFactor = 100.0 / (MaxDuration + mpCrossSectionProblem->getOutputStartTime());
   mProgressValue = 0;
 
   if (mpCallBack != NULL)
     {
       mpCallBack->setName("performing simulation...");
       mProgressMax = 100.0;
       mhProgress = mpCallBack->addItem("Completion",
                                        mProgressValue,
                                        &mProgressMax);
     }
 
   mState = TRANSIENT;
   mStatesRingCounter = 0;
 
   mNumCrossings = 0;
 
   try
     {
       do
         {
           flagProceed &= processStep(EndTime);
         }
       while ((*mpCurrentTime < CompareEndTime) && flagProceed);
     }
 
   catch (int)
     {
       mpCrossSectionProblem->getModel()->setState(*mpCurrentState);
       mpCrossSectionProblem->getModel()->updateSimulatedValues(mUpdateMoieties);
       finish();
       CCopasiMessage(CCopasiMessage::EXCEPTION, MCTrajectoryMethod + 16);
     }
 
   catch (CCopasiException & Exception)
     {
       mpCrossSectionProblem->getModel()->setState(*mpCurrentState);
       mpCrossSectionProblem->getModel()->updateSimulatedValues(mUpdateMoieties);
       finish();
       throw CCopasiException(Exception.getMessage());
     }
 
   finish();
 
   return true;
 }

void CCrossSectionTask::processStart ( const bool & useInitialValues )

Starts the process of integration by calling CTrajectoryMethod::start

Parameters

const bool & useInitialValues

Definition at line 333 of file CCrossSectionTask.cpp.

References CModel::applyInitialValues(), CCopasiProblem::getModel(), CModel::getState(), mpCrossSectionProblem, mpCurrentState, mpTrajectoryMethod, CTrajectoryMethod::setCurrentState(), and CTrajectoryMethod::start().

Referenced by process().

 {
   if (useInitialValues)
     mpCrossSectionProblem->getModel()->applyInitialValues();
 
   *mpCurrentState = mpCrossSectionProblem->getModel()->getState();
 
   mpTrajectoryMethod->setCurrentState(mpCurrentState);
   mpTrajectoryMethod->start(mpCurrentState);
 
   return;
 }

bool CCrossSectionTask::processStep ( const C_FLOAT64 & nextTime )

Integrates one step

Parameters

const C_FLOAT64 & nextTime

Returns: bool success;

Definition at line 346 of file CCrossSectionTask.cpp.

References C_FLOAT64, CCopasiMessage::EXCEPTION, CTrajectoryMethod::FAILURE, FINISH, finish(), CCopasiProblem::getModel(), CModel::getProcessQueueExecutionTime(), CTrajectoryMethod::getRoots(), CModel::getState(), MCTrajectoryMethod, min, CCopasiTask::mpCallBack, mpCrossSectionProblem, mpCurrentState, mpCurrentTime, mpTrajectoryMethod, mState, mUpdateMoieties, CTrajectoryMethod::NORMAL, CProcessReport::proceed(), CModel::processQueue(), CModel::processRoots(), CTrajectoryMethod::ROOT, CModel::setState(), CTrajectoryMethod::stateChanged(), CTrajectoryMethod::step(), and CModel::updateSimulatedValues().

Referenced by process().

 {
   CModel * pModel = mpCrossSectionProblem->getModel();
   bool StateChanged = false;
   bool proceed = true;
 
   C_FLOAT64 Tolerance = 100.0 * (fabs(endTime) * std::numeric_limits< C_FLOAT64 >::epsilon() + std::numeric_limits< C_FLOAT64 >::min());
   C_FLOAT64 NextTime = endTime;
 
   while (proceed)
     {
       // TODO Provide a call back method for resolving simultaneous assignments.
       //pModel->getMathModel()->getProcessQueue().printDebug();
 
       //execute events for inequalities
       StateChanged |= pModel->processQueue(*mpCurrentTime, false, NULL);
 
       if (StateChanged)
         {
           *mpCurrentState = pModel->getState();
           mpTrajectoryMethod->stateChanged();
           StateChanged = false;
         }
 
       // std::min suffices since events are only supported in forward integration.
       NextTime = std::min(endTime, pModel->getProcessQueueExecutionTime());
 
       switch (mpTrajectoryMethod->step(NextTime - *mpCurrentTime))
         {
           case CTrajectoryMethod::NORMAL:
             pModel->setState(*mpCurrentState);
             pModel->updateSimulatedValues(mUpdateMoieties);
 
             // TODO Provide a call back method for resolving simultaneous assignments.
 
             //execute events for equalities
             StateChanged |= pModel->processQueue(*mpCurrentTime, true, NULL);
 
             // If the state change happens to coincide with end of the step we have to return and
             // inform the integrator of eventual state changes.
             if (fabs(*mpCurrentTime - endTime) < Tolerance)
               {
                 if (StateChanged)
                   {
                     *mpCurrentState = pModel->getState();
                     mpTrajectoryMethod->stateChanged();
                     StateChanged = false;
                   }
 
                 return true;
               }
 
             break;
 
           case CTrajectoryMethod::ROOT:
             //we arrive here whenever the integrator finds a root
             //this does not necessarily mean an event fires
             pModel->setState(*mpCurrentState);
             pModel->updateSimulatedValues(mUpdateMoieties);
 
             //this checks whether equality events are triggered
             pModel->processRoots(*mpCurrentTime, true, true, mpTrajectoryMethod->getRoots());
 
             // TODO Provide a call back method for resolving simultaneous assignments.
 
             //execute scheduled events for equalities
             StateChanged |= pModel->processQueue(*mpCurrentTime, true, NULL);
 
             //this checks whether inequality events are triggered
             pModel->processRoots(*mpCurrentTime, false, true, mpTrajectoryMethod->getRoots());
 
             // If the root happens to coincide with end of the step we have to return and
             // inform the integrator of eventual state changes.
             if (fabs(*mpCurrentTime - endTime) < Tolerance)
               {
                 if (StateChanged)
                   {
                     *mpCurrentState = pModel->getState();
                     mpTrajectoryMethod->stateChanged();
                     StateChanged = false;
                   }
 
                 return true;
               }
 
             break;
 
           case CTrajectoryMethod::FAILURE:
             finish();
             CCopasiMessage(CCopasiMessage::EXCEPTION, MCTrajectoryMethod + 12);
             return false;
             break;
         }
 
       proceed = mpCallBack == NULL || mpCallBack->proceed();
 
       if (mState == FINISH)
         proceed = false;
     }
 
   return proceed;
 }

C_FLOAT64 CCrossSectionTask::relativeDifferenceOfStates	(	CState *	s1,
		CState *	s2
	)

staticprivate

Definition at line 651 of file CCrossSectionTask.cpp.

References CState::beginIndependent(), C_FLOAT64, and CState::endIndependent().

Referenced by eventCallBack().

 {
   if (!s1 || !s2)
     {
       return std::numeric_limits< C_FLOAT64 >::quiet_NaN();
     }
 
   if (s1->endIndependent() - s1->beginIndependent()
       != s2->endIndependent() - s2->beginIndependent())
     {
       return std::numeric_limits< C_FLOAT64 >::quiet_NaN();
     }
 
   C_FLOAT64 ret = 0;
 
   const C_FLOAT64 * p1 = s1->beginIndependent();
   const C_FLOAT64 * p1End = s1->endIndependent();
   const C_FLOAT64 * p2 = s2->beginIndependent();
 
   for (; p1 != p1End; ++p1, ++p2)
     {
       ret += (*p1 != *p2) ? pow((*p1 - *p2) / (fabs(*p1) + fabs(*p2)), 2) : 0.0;
     }
 
   return 2.0 * sqrt(ret);
 }

void CCrossSectionTask::removeEvent ( )

Definition at line 226 of file CCrossSectionTask.cpp.

References CCopasiProblem::getModel(), mpCrossSectionProblem, mpEvent, and CModel::removeEvent().

Referenced by CScanTask::process(), and restore().

 {
   // TODO: remove event
   if (mpEvent != NULL)
     {
       mpCrossSectionProblem->getModel()->removeEvent(mpEvent);
       mpEvent = NULL;
     }
 }

bool CCrossSectionTask::restore ( )

virtual

Perform necessary cleanup procedures

Reimplemented from CCopasiTask.

Definition at line 459 of file CCrossSectionTask.cpp.

References CModel::getMathModel(), CCopasiProblem::getModel(), CMathModel::getProcessQueue(), CModel::getState(), mpCrossSectionProblem, mpCurrentState, CCopasiTask::mpProblem, CCopasiTask::mUpdateModel, mUpdateMoieties, removeEvent(), CCopasiTask::restore(), CProcessQueue::setEventCallBack(), CModel::setInitialState(), CModel::setState(), CModel::updateInitialValues(), and CModel::updateSimulatedValues().

 {
   bool success = CCopasiTask::restore();
   CModel * pModel = mpProblem->getModel();
 
   removeEvent();
 
   if (mUpdateModel)
     {
 
       pModel->setState(*mpCurrentState);
       pModel->updateSimulatedValues(mUpdateMoieties);
       pModel->setInitialState(pModel->getState());
       pModel->updateInitialValues();
     }
 
   //reset call back
   mpCrossSectionProblem->getModel()->getMathModel()->getProcessQueue().setEventCallBack(NULL, NULL);
 
   return success;
 }

bool CCrossSectionTask::setMethodType ( const int & type )

virtual

Set the method type applied to solve the task

Parameters

const CCopasiMethod::SubType & type

Returns: bool success

Reimplemented from CCopasiTask.

Definition at line 481 of file CCrossSectionTask.cpp.

References CCopasiContainer::add(), createMethod(), CCopasiParameterGroup::getParameter(), CCopasiMethod::getSubType(), CCopasiParameter::getValue(), CCopasiTask::isValidMethod(), CCopasiTask::mpMethod, mUpdateMoieties, CCopasiParameter::Value::pBOOL, pdelete, and ValidMethods.

 {
   CCopasiMethod::SubType Type = (CCopasiMethod::SubType) type;
 
   if (!isValidMethod(Type, ValidMethods)) return false;
 
   if (mpMethod->getSubType() == Type) return true;
 
   pdelete(mpMethod);
   mpMethod = createMethod(Type);
   this->add(mpMethod, true);
 
   CCopasiParameter * pParameter = mpMethod->getParameter("Integrate Reduced Model");
 
   if (pParameter != NULL)
     mUpdateMoieties = *pParameter->getValue().pBOOL;
   else
     mUpdateMoieties = false;
 
   return true;
 }

Member Data Documentation

C_FLOAT64 CCrossSectionTask::mAverageFreq

private

Definition at line 143 of file CCrossSectionTask.h.

Referenced by eventCallBack(), initObjects(), and process().

C_FLOAT64 CCrossSectionTask::mAveragePeriod

private

Definition at line 138 of file CCrossSectionTask.h.

Referenced by eventCallBack(), initObjects(), and process().

C_FLOAT64 CCrossSectionTask::mFreq

private

Definition at line 142 of file CCrossSectionTask.h.

Referenced by eventCallBack(), initObjects(), and process().

size_t CCrossSectionTask::mhProgress

private

handle for progress reporting

Definition at line 96 of file CCrossSectionTask.h.

Referenced by eventCallBack(), finish(), and process().

C_FLOAT64 CCrossSectionTask::mLastFreq

private

Definition at line 141 of file CCrossSectionTask.h.

Referenced by eventCallBack(), initObjects(), and process().

C_FLOAT64 CCrossSectionTask::mLastPeriod

private

Definition at line 139 of file CCrossSectionTask.h.

Referenced by eventCallBack(), initObjects(), and process().

size_t CCrossSectionTask::mMaxNumCrossings

private

Definition at line 91 of file CCrossSectionTask.h.

Referenced by eventCallBack(), and process().

size_t CCrossSectionTask::mNumCrossings

private

Definition at line 87 of file CCrossSectionTask.h.

Referenced by eventCallBack(), and process().

size_t CCrossSectionTask::mOutputStartNumCrossings

private

Definition at line 89 of file CCrossSectionTask.h.

Referenced by eventCallBack(), and process().

C_FLOAT64 CCrossSectionTask::mOutputStartTime

private

time at which the output starts.

Definition at line 80 of file CCrossSectionTask.h.

Referenced by eventCallBack(), and process().

CCrossSectionProblem* CCrossSectionTask::mpCrossSectionProblem

private

A pointer to the trajectory Problem

Definition at line 55 of file CCrossSectionTask.h.

Referenced by createEvent(), eventCallBack(), finish(), initialize(), process(), processStart(), processStep(), removeEvent(), and restore().

CState* CCrossSectionTask::mpCurrentState

private

A pointer to the current state of the integration.

Definition at line 70 of file CCrossSectionTask.h.

Referenced by cleanup(), eventCallBack(), getState(), initialize(), process(), processStart(), processStep(), and restore().

const C_FLOAT64* CCrossSectionTask::mpCurrentTime

private

A pointer to the current time of the integration.

Definition at line 75 of file CCrossSectionTask.h.

Referenced by eventCallBack(), initialize(), process(), and processStep().

C_FLOAT64 CCrossSectionTask::mPeriod

private

Definition at line 137 of file CCrossSectionTask.h.

Referenced by eventCallBack(), initObjects(), and process().

C_INT CCrossSectionTask::mPeriodicity

private

Definition at line 140 of file CCrossSectionTask.h.

Referenced by eventCallBack(), initObjects(), and process().

CEvent* CCrossSectionTask::mpEvent

private

temporary event

Definition at line 116 of file CCrossSectionTask.h.

Referenced by createEvent(), and removeEvent().

C_FLOAT64 CCrossSectionTask::mPreviousCrossingTime

private

Definition at line 136 of file CCrossSectionTask.h.

Referenced by eventCallBack(), and process().

C_FLOAT64 CCrossSectionTask::mProgressFactor

private

this holds the current value for the progress reporting

Definition at line 111 of file CCrossSectionTask.h.

Referenced by eventCallBack(), and process().

C_FLOAT64 CCrossSectionTask::mProgressMax

private

this holds the max value for the progress reporting

Definition at line 101 of file CCrossSectionTask.h.

Referenced by process().

C_FLOAT64 CCrossSectionTask::mProgressValue

private

this holds the current value for the progress reporting

Definition at line 106 of file CCrossSectionTask.h.

Referenced by eventCallBack(), and process().

CTrajectoryMethod* CCrossSectionTask::mpTrajectoryMethod

private

A pointer to the trajectory method

Definition at line 60 of file CCrossSectionTask.h.

Referenced by initialize(), processStart(), and processStep().

C_FLOAT64 CCrossSectionTask::mStartTime

private

time at which the simulation starts.

Definition at line 85 of file CCrossSectionTask.h.

Referenced by eventCallBack(), and process().

STATE CCrossSectionTask::mState

private

Definition at line 128 of file CCrossSectionTask.h.

Referenced by eventCallBack(), process(), and processStep().

std::vector< CState > CCrossSectionTask::mStatesRing

private

Definition at line 130 of file CCrossSectionTask.h.

Referenced by eventCallBack(), and initialize().

size_t CCrossSectionTask::mStatesRingCounter

private

Definition at line 134 of file CCrossSectionTask.h.

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

CTimeSeries CCrossSectionTask::mTimeSeries

private

the time series (if requested)

Definition at line 50 of file CCrossSectionTask.h.

Referenced by getTimeSeries(), and initialize().

bool CCrossSectionTask::mTimeSeriesRequested

private

whether the time series should be stored in mTimeSeries

Definition at line 45 of file CCrossSectionTask.h.

Referenced by initialize().

bool CCrossSectionTask::mUpdateMoieties

private

Indicates whether we need to update moieties.

Definition at line 65 of file CCrossSectionTask.h.

Referenced by eventCallBack(), initialize(), process(), processStep(), restore(), and setMethodType().

const unsigned int CCrossSectionTask::ValidMethods

static

Initial value:

=
{
  CCopasiMethod::deterministic,
  CCopasiMethod::unset
}

The methods which can be selected for performing this task.

CCrossSectionTask class.

This class implements a cross section task.

Definition at line 38 of file CCrossSectionTask.h.

Referenced by setMethodType().

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

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation