41 const size_t & objectOffset)
43 mpTarget = src.
mpTarget + objectOffset;
56 if (mpTarget != NULL &&
62 std::vector< CCopasiContainer * > ListOfContainer;
65 CExpression AssignmentExpression(
"AssignmentExpression", &container);
67 success &= AssignmentExpression.
compile(ListOfContainer);
68 success &= mpAssignment->setExpression(AssignmentExpression, container);
80 mpAssignment = pExpression;
113 const size_t & objectOffset)
115 mpRoot = src.
mpRoot + objectOffset;
122 const bool & equality,
125 mEquality = equality;
127 std::vector< CCopasiContainer * > ListOfContainer;
128 ListOfContainer.push_back(const_cast< CMathContainer * >(&container));
131 bool success =
static_cast< CEvaluationTree *
>(pExpression)->setRoot(pRootNode);
132 success &= mpRoot->setExpressionPtr(pExpression);
141 success &=
static_cast< CEvaluationTree *
>(pStateExpression)->setRoot(pStateExpressionNode);
142 success &= mpRootState->setExpressionPtr(pStateExpression);
169 std::vector< CCopasiContainer * > Container;
170 Container.push_back(const_cast< CMathContainer * >(&container));
178 mRoots.resize(countRoots(Trigger.
getRoot(), Variables));
182 CFunction TriggerFunction(
"EventTrigger", &container);
187 mRoots.resize(countRoots(TriggerFunction.
getRoot(), Variables));
197 mRoots.resize(nRoots);
217 CRoot * pRoot = mRoots.array();
218 CRoot * pRootEnd = pRoot + mRoots.size();
220 for (; pRoot != pRootEnd; ++pRoot)
228 const size_t & valueOffset,
229 const size_t & objectOffset)
231 mpTrigger = src.
mpTrigger + objectOffset;
234 mRoots.resize(src.
mRoots.size());
235 CRoot * pRoot = mRoots.array();
236 CRoot * pRootEnd = pRoot + mRoots.size();
239 for (; pRoot != pRootEnd; ++pRoot, ++pRootSrc)
241 pRoot->
copy(*pRootSrc, container, valueOffset, objectOffset);
254 std::vector< CCopasiContainer * > ListOfContainer;
255 ListOfContainer.push_back(&container);
257 CExpression DataTrigger(
"DataTrigger", &container);
260 if (pDataEvent != NULL)
267 DataTrigger.
setInfix(mpTrigger->getExpressionPtr()->getInfix());
270 success &= DataTrigger.
compile();
273 CRoot * pRoot = mRoots.array();
275 pTriggerRoot =
compile(DataTrigger.
getRoot(), Variables, pRoot, container);
277 assert(pRoot == mRoots.array() + mRoots.size());
280 success &=
static_cast< CEvaluationTree *
>(pTrigger)->setRoot(pTriggerRoot);
282 success &= mpTrigger->setExpressionPtr(pTrigger);
295 assert(mpTrigger != NULL);
297 mpTrigger->setExpression(infix,
true, container);
301 std::cout << *mpTrigger;
302 std::cout << *mpInitialTrigger;
304 CRoot * pRoot = mRoots.array();
305 CRoot * pRootEnd = pRoot + mRoots.size();
307 for (; pRoot != pRootEnd; ++pRoot)
309 std::cout << *pRoot->
mpRoot;
318 size_t RootCount = 0;
324 while (itNode.
next() != itNode.
end())
362 RootCount = countRootsEQ(*itNode, itNode.
context());
373 RootCount = countRootsDefault(itNode.
context());
385 RootCount = countRootsFUNCTION(*itNode, itNode.
context());
389 RootCount = countRootsDefault(itNode.
context());
400 RootCount = countRootsVARIABLE(*itNode, variables);
404 RootCount = countRootsDefault(itNode.
context());
411 RootCount = countRootsDefault(itNode.
context());
433 size_t RootCount = 0;
435 std::vector< size_t >::const_iterator it = children.begin();
436 std::vector< size_t >::const_iterator end = children.end();
438 for (; it != end; ++it)
448 const std::vector< size_t > & children)
450 size_t nRoots = children[0] + children[1];
453 if (static_cast<const CEvaluationNode *>(pNode->
getChild())->isBoolean())
455 nRoots = children[0] + children[1];
467 const std::vector< size_t > & children)
472 size_t nRoots = countRoots(pTreeRoot, children);
489 return variables[Index];
503 while (itNode.
next() != itNode.
end())
521 Index < variables.size() &&
522 variables[Index]->isBoolean())
533 pNode = variables[Index]->copyBranch();
546 pNode = container.
copyBranch(*itNode, variables,
true);
559 switch ((
int) itNode->
getType())
564 pNode = compileAND(*itNode, itNode.
context(), variables, pRoot, container);
568 pNode = compileEQ(*itNode, itNode.
context(), variables, pRoot, container);
572 pNode = compileNE(*itNode, itNode.
context(), variables, pRoot, container);
579 pNode = compileLE(*itNode, itNode.
context(), variables, pRoot, container);
583 pNode = compileNOT(*itNode, itNode.
context(), variables, pRoot, container);
588 pNode = compileFUNCTION(*itNode, itNode.
context(), variables, pRoot, container);
592 pNode = compileVARIABLE(*itNode, itNode.
context(), variables, pRoot, container);
620 const std::vector< CEvaluationNode * > & children,
656 const std::vector< CEvaluationNode * > & children,
664 if (!static_cast< const CEvaluationNode * >(pTriggerNode->
getChild())->isBoolean())
670 CEvaluationNode * pGELeft = compileLE(&GELeft, children, variables, pRoot, container);
674 std::vector< CEvaluationNode * > RightChildren;
675 RightChildren.push_back(children[1]->copyBranch());
676 RightChildren.push_back(children[0]->copyBranch());
679 CEvaluationNode * pGERight = compileLE(&GERight, RightChildren, variables, pRoot, container);
694 const std::vector< CEvaluationNode * > & children,
711 CEvaluationNode * pEqNode = compileEQ(&EqNode, children, variables, pRoot, container);
723 const std::vector< CEvaluationNode * > & children,
734 bool Equality =
false;
764 pRoot->
compile(pRootNode, Equality, container);
775 const std::vector< CEvaluationNode * > & children,
790 const std::vector< CEvaluationNode * > & children,
801 std::vector< CEvaluationNode * >::const_iterator it = children.begin();
802 std::vector< CEvaluationNode * >::const_iterator end = children.end();
804 for (; it != end; ++it)
814 const std::vector< CEvaluationNode * > & ,
824 Index < variables.size())
827 return variables[Index]->copyBranch();
839 const CEvent * pDataEvent,
876 for (; pAssignment != pAssignmentEnd; ++pAssignment)
904 for (; pAssignment != pAssignmentEnd; ++pAssignment, ++pAssignmentSrc)
906 pAssignment->
copy(*pAssignmentSrc, container, valueOffset, objectOffset);
933 for (; pAssignment != pAssignmentEnd; ++pAssignment, ++itAssignment)
935 success &= pAssignment->
compile(*itAssignment, container);
938 std::vector< CCopasiContainer * > ListOfContainer;
942 CExpression DelayExpression(
"DelayExpression", &container);
944 success &= DelayExpression.
compile(ListOfContainer);
948 CExpression PriorityExpression(
"PriorityExpression", &container);
950 success &= PriorityExpression.
compile(ListOfContainer);
1009 mExpression(
"Expression", this)
1015 mpTarget(src.mpTarget),
1016 mExpression(src.mExpression, this)
1023 std::vector< CCopasiContainer * > listOfContainer)
1025 if (pAssignment == NULL)
1028 bool success =
true;
1037 if (mpTarget == NULL)
1040 success &= mExpression.setInfix(pAssignment->
getExpression());
1041 success &= mExpression.compile(listOfContainer);
1053 mDelay(
"DelayExpression", this),
1065 mTrigger(src.mTrigger, this),
1067 mHaveDelay(src.mHaveDelay),
1068 mDelay(src.mDelay, this),
1069 mDelayAssignment(src.mDelayAssignment),
1070 mAssignments(src.mAssignments, this),
1071 mDelayValueRefreshes(src.mDelayValueRefreshes),
1072 mAssignmentValueRefreshes(src.mAssignmentValueRefreshes),
1073 mDependentValueRefreshes(src.mDependentValueRefreshes),
1081 std::vector< CCopasiContainer * > listOfContainer)
1086 if (pMathModel == NULL)
1089 bool success =
true;
1112 std::set< const CCopasiObject * > Assignments;
1113 std::set< const CCopasiObject * > Targets;
1115 for (; it != end; ++it)
1120 success &= pAssignment->
compile(*it, listOfContainer);
1122 Assignments.insert(pAssignment);
1123 Targets.insert((*it)->getTargetObject());
1138 const bool & equality,
1160 for (; itAssignment != endAssignment; ++itAssignment, ++pValue)
1162 *pValue = (*itAssignment)->mExpression.calcValue();
1170 bool StateChanged =
false;
1176 for (; itAssignment != endAssignment; ++itAssignment, ++pValue)
1178 if (*(*itAssignment)->mpTarget != *pValue)
1180 StateChanged =
true;
1181 *(*itAssignment)->mpTarget = *pValue;
1190 return StateChanged;
1203 while (itRefresh != endRefresh)
1214 while (itRefresh != endRefresh)
1225 while (itRefresh != endRefresh)
1280 if (DelayedTime - currentTime < 0.0)
1284 (fabs(DelayedTime) + fabs(currentTime)) * 50.0 * std::numeric_limits< C_FLOAT64 >::epsilon();
1289 DelayedTime = currentTime;
1292 else if (fabs(DelayedTime - currentTime) < Scale)
1294 DelayedTime = currentTime;
void setExpression(const std::string &infix, CMathContainer &container)
static CEvaluationNode * compileVARIABLE(const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
CCopasiContainer * getObjectAncestor(const std::string &type) const
const size_t & getOrder() const
bool compile(CEventAssignment *pDataAssignment, CMathContainer &container)
CMathObject * pEventRootsObject
static size_t countRoots(const CEvaluationNode *pNode, const CMath::Variables< size_t > &variables)
std::vector< Refresh * > mDependentValueRefreshes
void setSimulationType(const CMath::SimulationType &simulationType)
const CCopasiVectorN< CEventAssignment > & getAssignments() const
void setExpression(CMathObject *pExpression)
virtual bool setInfix(const std::string &infix)
const bool & getDelayAssignment() const
static size_t countRootsVARIABLE(const CEvaluationNode *pNode, const CMath::Variables< size_t > &variables)
bool compile(CEvent *pDataEvent, CMathContainer &container)
const CVector< CRoot > & getRoots() const
CMathObject * getMathObject(const CObjectInterface *pObject) const
void copy(const CMathEventN &src, CMathContainer &container, const size_t &valueOffset, const size_t &objectOffset)
void setTriggerExpression(const std::string &infix, CMathContainer &container)
bool compile(const CEvent *pEvent, std::vector< CCopasiContainer * > listOfContainer)
CEvaluationNode * copyNode(CEvaluationNode *child1, CEvaluationNode *child2) const
static CEvaluationNode * compileNE(const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
virtual size_t size() const
CMathObject * mpAssignment
void applyValueRefreshes()
C_FLOAT64 * pEventRootStates
const bool & delayAssignment() const
bool compile(CEvent *pDataEvent, CMathContainer &container)
void setDelayExpression(const std::string &infix, CMathContainer &container)
bool setTargetValues(const CVector< C_FLOAT64 > &targetValues)
std::vector< Refresh * > buildRequiredRefreshList(const std::set< const CCopasiObject * > &requiredObjects) const
void initialize(CMath::sPointers &pointers)
const Type & getType() const
void fire(const C_FLOAT64 &time, const bool &equality, CProcessQueue &processQueue)
void setDirectDependencies(const DataObjectSet &directDependencies)
static CEvaluationNode * compileAND(const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
std::vector< Refresh * > mDelayValueRefreshes
bool addAssignment(const C_FLOAT64 &executionTime, const bool &equality, const CVector< C_FLOAT64 > &values, CMathEvent *pEvent)
std::string getTriggerExpression() const
static CEvaluationNode * compileEQ(const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
CMathObject * pEventRootStatesObject
virtual bool compile(std::vector< CCopasiContainer * > listOfContainer=CCopasiContainer::EmptyList)
CEvaluationNode * copyBranch(const CEvaluationNode *pSrc, const bool &replaceDiscontinuousNodes)
std::vector< Refresh * > buildDependendRefreshList(const std::set< const CCopasiObject * > &changedObjects) const
const CNodeIteratorMode::State & next()
void setIsBoolean(const bool &booleanRequired)
static size_t countRootsFUNCTION(const CEvaluationNode *pNode, const std::vector< size_t > &children)
const CEvent::Type & getType() const
void setPriorityExpression(const std::string &infix, CMathContainer &container)
virtual bool setInfix(const std::string &infix)
void copy(const CTrigger &src, CMathContainer &container, const size_t &valueOffset, const size_t &objectOffset)
const Type & getType() const
void addAssignment(CMathObject *pTarget, CMathObject *pExpression)
CMathObject * mpInitialTrigger
C_FLOAT64 * pInitialEventTriggers
void setTarget(CMathObject *pTarget)
const bool & getPersistentTrigger() const
static Type type(const Type &type)
CMathTrigger & getMathTrigger()
virtual const C_FLOAT64 & calcValue()
C_FLOAT64 * pEventPriorities
virtual bool addChild(CCopasiNode< Data > *pChild, CCopasiNode< Data > *pAfter=NULL)
void initialize(CMath::sPointers &pointers)
void initialize(CMath::sPointers &pointers)
CVector< C_FLOAT64 > getTargetValues()
const CNodeIteratorMode::State & skipChildren()
Context * parentContextPtr()
C_FLOAT64 getAssignmentTime(const C_FLOAT64 ¤tTime)
C_FLOAT64 * pEventAssignments
bool setExpression(const std::string &infix, const bool &isBoolean, CMathContainer &container)
static CEvaluationNode * compileLE(const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
void allocateDiscontinuous(const size_t &nRoots, const CMathContainer &container)
bool compile(CEvaluationNode *pRootNode, const bool &equality, CMathContainer &container)
CMathObject * pEventTriggersObject
static size_t countRootsDefault(const std::vector< size_t > &children)
std::string getDelayExpression() const
static CEvaluationNode * compileFUNCTION(const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
CMathObject * pInitialEventTriggersObject
const CVector< CAssignment > & getAssignments() const
CAssignment(const CCopasiContainer *pParent=NULL)
CMathObject * pEventAssignmentsObject
CVector< CAssignment > mAssignments
virtual const DataObjectSet & getDirectDependencies(const DataObjectSet &context=DataObjectSet()) const
CMathObject * mpRootState
static Type subType(const Type &type)
const CExpression * getTriggerExpressionPtr() const
void setProcessingModes(const CNodeIteratorMode::Flag &processingModes)
void allocate(const CEvent *pDataEvent, const CMathContainer &container)
C_FLOAT64 getCalculationTime(const C_FLOAT64 ¤tTime)
CMathObject * pEventDelaysObject
CEvaluationNode * createTriggerExpressionNode() const
static void initialize(CMathObject *&pObject, C_FLOAT64 *&pValue, const CMath::ValueType &valueType, const CMath::EntityType &entityType, const CMath::SimulationType &simulationType, const bool &isIntensiveProperty, const bool &isInitialValue, const CCopasiObject *pDataObject)
void applyDelayRefreshes()
virtual bool isBoolean() const
bool compile(const CEventAssignment *pAssignment, std::vector< CCopasiContainer * > listOfContainer)
static size_t countRootsEQ(const CEvaluationNode *pNode, const std::vector< size_t > &children)
bool addCalculation(const C_FLOAT64 &executionTime, const bool &equality, CMathEvent *pEvent)
const CNodeIteratorMode::State & processingMode() const
CCopasiVector< CAssignment > mAssignments
std::vector< CType * >::iterator iterator
std::vector< Refresh * > mAssignmentValueRefreshes
The class for handling a chemical kinetic function.
static void allocate(CMathEventN *pEvent, const CEvent *pDataEvent, const CMathContainer &container)
C_FLOAT64 calculateDelayedTime(const C_FLOAT64 ¤tTime)
void copy(const CRoot &src, CMathContainer &container, const size_t &valueOffset, const size_t &objectOffset)
CMathEvent(const CCopasiContainer *pParent=NULL)
virtual void * getValuePointer() const
const CTrigger & getTrigger() const
virtual bool removeChild(CCopasiNode< Data > *pChild)
const bool & getFireAtInitialTime() const
Header file of class CEvent.
CMathObject * pEventPrioritiesObject
C_FLOAT64 * pEventTriggers
virtual const Data & getData() const
CNodeIteratorMode::State end() const
static CEvaluationNode * compileNOT(const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
const CCopasiObject * getTargetObject() const
CCopasiNode< Data > * getChild()
std::string getPriorityExpression() const
void applyDependentRefreshes()
void initialize(CMath::sPointers &pointers)
CEvaluationNode * getRoot()
const std::string & getInfix() const
bool compile(const CExpression *pTriggerExpression, std::vector< CCopasiContainer * > listOfContainer)
std::string getExpression() const
void copy(const CAssignment &src, CMathContainer &container, const size_t &valueOffset, const size_t &objectOffset)