CMathEventN::CTrigger Class Reference

#include <CMathEvent.h>

Collaboration diagram for CMathEventN::CTrigger:

Classes
class	CRoot

Public Member Functions
void	allocate (const CEvent *pDataEvent, const CMathContainer &container)
void	allocateDiscontinuous (const size_t &nRoots, const CMathContainer &container)
bool	compile (CEvent *pDataEvent, CMathContainer &container)
void	copy (const CTrigger &src, CMathContainer &container, const size_t &valueOffset, const size_t &objectOffset)
	CTrigger ()
const CVector< CRoot > &	getRoots () const
void	initialize (CMath::sPointers &pointers)
void	setExpression (const std::string &infix, CMathContainer &container)
	~CTrigger ()

Static Private Member Functions
static CEvaluationNode *	compile (const CEvaluationNode *pNode, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
static CEvaluationNode *	compileAND (const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
static CEvaluationNode *	compileEQ (const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
static CEvaluationNode *	compileFUNCTION (const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
static CEvaluationNode *	compileLE (const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
static CEvaluationNode *	compileNE (const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
static CEvaluationNode *	compileNOT (const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
static CEvaluationNode *	compileVARIABLE (const CEvaluationNode *pNode, const std::vector< CEvaluationNode * > &children, const CMath::Variables< CEvaluationNode * > &variables, CMathEventN::CTrigger::CRoot *&pRoot, CMathContainer &container)
static size_t	countRoots (const CEvaluationNode *pNode, const CMath::Variables< size_t > &variables)
static size_t	countRootsDefault (const std::vector< size_t > &children)
static size_t	countRootsEQ (const CEvaluationNode *pNode, const std::vector< size_t > &children)
static size_t	countRootsFUNCTION (const CEvaluationNode *pNode, const std::vector< size_t > &children)
static size_t	countRootsVARIABLE (const CEvaluationNode *pNode, const CMath::Variables< size_t > &variables)

Private Attributes
bool	mDualAction
CMathObject *	mpInitialTrigger
CMathObject *	mpTrigger
CVector< CRoot >	mRoots

Detailed Description

Definition at line 59 of file CMathEvent.h.

Constructor & Destructor Documentation

CMathEventN::CTrigger::CTrigger

(

)

Default constructor

Definition at line 153 of file CMathEvent.cpp.

                             :
  mpTrigger(NULL),
  mpInitialTrigger(NULL),
  mRoots(),
  mDualAction(false)
{}

CMathEventN::CTrigger::~CTrigger

(

)

Destructor

Definition at line 160 of file CMathEvent.cpp.

{}

Member Function Documentation

void CMathEventN::CTrigger::allocate	(	const CEvent *	pDataEvent,
		const CMathContainer &	container
	)

Definition at line 163 of file CMathEvent.cpp.

References CExpression::compile(), CEvaluationTree::compile(), CEvaluationTree::getRoot(), CEvent::getTriggerExpression(), CFunction::setInfix(), CExpression::setInfix(), and CExpression::setIsBoolean().

Referenced by CMathEventN::allocate().

{
  // Determine the number of roots.
  CMath::Variables< size_t > Variables;

  std::vector< CCopasiContainer * > Container;
  Container.push_back(const_cast< CMathContainer * >(&container));

  CExpression Trigger("EventTrigger", &container);
  Trigger.setIsBoolean(true);

  if (Trigger.setInfix(pDataEvent->getTriggerExpression()))
    {
      Trigger.compile(Container);
      mRoots.resize(countRoots(Trigger.getRoot(), Variables));
    }
  else
    {
      CFunction TriggerFunction("EventTrigger", &container);

      if (TriggerFunction.setInfix(pDataEvent->getTriggerExpression()))
        {
          TriggerFunction.compile();
          mRoots.resize(countRoots(TriggerFunction.getRoot(), Variables));
        }
    }

  return;
}

void CMathEventN::CTrigger::allocateDiscontinuous	(	const size_t &	nRoots,
		const CMathContainer &	container
	)

Definition at line 194 of file CMathEvent.cpp.

{
  mRoots.resize(nRoots);
}

bool CMathEventN::CTrigger::compile	(	CEvent *	pDataEvent,
		CMathContainer &	container
	)

Definition at line 247 of file CMathEvent.cpp.

References CExpression::compile(), CMathEventN::compile(), CEvaluationTree::getRoot(), CEvent::getTriggerExpression(), CExpression::setInfix(), and CExpression::setIsBoolean().

Referenced by CMathEventN::compile().

{
  bool success = true;

  CMath::Variables< CEvaluationNode * > Variables;

  std::vector< CCopasiContainer * > ListOfContainer;
  ListOfContainer.push_back(&container);

  CExpression DataTrigger("DataTrigger", &container);
  DataTrigger.setIsBoolean(true);

  if (pDataEvent != NULL)
    {
      DataTrigger.setInfix(pDataEvent->getTriggerExpression());
      mDualAction = false;
    }
  else
    {
      DataTrigger.setInfix(mpTrigger->getExpressionPtr()->getInfix());
    }

  success &= DataTrigger.compile();

  CEvaluationNode * pTriggerRoot = NULL;
  CRoot * pRoot = mRoots.array();

  pTriggerRoot = compile(DataTrigger.getRoot(), Variables, pRoot, container);

  assert(pRoot == mRoots.array() + mRoots.size());

  CMathExpression * pTrigger = new CMathExpression("EventTrigger", container);
  success &= static_cast< CEvaluationTree * >(pTrigger)->setRoot(pTriggerRoot);

  success &= mpTrigger->setExpressionPtr(pTrigger);

  return success;
}

CEvaluationNode * CMathEventN::CTrigger::compile ( const CEvaluationNode *  pNode, const CMath::Variables< CEvaluationNode * > &  variables, CMathEventN::CTrigger::CRoot *&  pRoot, CMathContainer &  container  )

staticprivate

Definition at line 493 of file CMathEvent.cpp.

References CEvaluationNodeConstant::_NaN, CNodeIteratorMode::After, CEvaluationNodeLogical::AND, CEvaluationNodeVariable::ANY, CNodeIteratorMode::Before, C_INVALID_INDEX, CEvaluationNode::CALL, CEvaluationNode::CONSTANT, CNodeContextIterator< Node, Context >::context(), CMathContainer::copyBranch(), CEvaluationNode::copyNode(), CNodeContextIterator< Node, Context >::end(), CEvaluationNodeLogical::EQ, CEvaluationNodeCall::EXPRESSION, CEvaluationNodeConstant::FALSE, CEvaluationNodeCall::FUNCTION, CEvaluationNode::FUNCTION, CEvaluationNodeLogical::GE, CCopasiNode< _Data >::getData(), CEvaluationNodeVariable::getIndex(), CEvaluationNode::getType(), CEvaluationNodeLogical::GT, CEvaluationNode::isBoolean(), CEvaluationNodeLogical::LE, CEvaluationNode::LOGICAL, CEvaluationNodeLogical::LT, CEvaluationNodeLogical::NE, CNodeContextIterator< Node, Context >::next(), CEvaluationNodeFunction::NOT, CEvaluationNodeLogical::OR, CNodeContextIterator< Node, Context >::parentContextPtr(), CNodeContextIterator< Node, Context >::processingMode(), CNodeContextIterator< Node, Context >::setProcessingModes(), CNodeContextIterator< Node, Context >::skipChildren(), CEvaluationNodeConstant::TRUE, CEvaluationNode::type(), CEvaluationNode::VARIABLE, and CEvaluationNodeLogical::XOR.

{
  CEvaluationNode * pNode = NULL;

  CNodeContextIterator< const CEvaluationNode, std::vector< CEvaluationNode * > > itNode(pTriggerNode);
  itNode.setProcessingModes(CNodeIteratorMode::Before | CNodeIteratorMode::After);

  while (itNode.next() != itNode.end())
    {
      if (*itNode == NULL)
        {
          continue;
        }

      switch (itNode.processingMode())
        {
          case CNodeIteratorMode::Before:

            // Variables return always false we need to dig deeper.
            if (CEvaluationNode::type(itNode->getType()) == CEvaluationNode::VARIABLE)
              {
                size_t Index =
                  static_cast< const CEvaluationNodeVariable * >(*itNode)->getIndex();

                if (Index != C_INVALID_INDEX &&
                    Index < variables.size() &&
                    variables[Index]->isBoolean())
                  {
                    continue;
                  }

                // We found a non boolean node which we simply copy.
                itNode.skipChildren();

                // Since a variable may be referred to multiple times we need to copy it.
                if (Index != C_INVALID_INDEX)
                  {
                    pNode = variables[Index]->copyBranch();
                  }
                else
                  {
                    // Variables must not appear in mathematical expressions.
                    // We create an constant node with the variable name and value NaN.
                    pNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, itNode->getData());
                  }
              }
            else if (!itNode->isBoolean())
              {
                // We found a non boolean node which we simply copy.
                itNode.skipChildren();
                pNode = container.copyBranch(*itNode, variables, true);
              }
            else
              {
                continue;
              }

            break;

          case CNodeIteratorMode::After:

            // We do not need to check whether the root is boolean as non boolean nodes are
            // already processed
            switch ((int) itNode->getType())
              {
                case(CEvaluationNode::LOGICAL | CEvaluationNodeLogical::AND):
                case(CEvaluationNode::LOGICAL | CEvaluationNodeLogical::OR):
                case(CEvaluationNode::LOGICAL | CEvaluationNodeLogical::XOR):
                  pNode = compileAND(*itNode, itNode.context(), variables, pRoot, container);
                  break;

                case(CEvaluationNode::LOGICAL | CEvaluationNodeLogical::EQ):
                  pNode = compileEQ(*itNode, itNode.context(), variables, pRoot, container);
                  break;

                case(CEvaluationNode::LOGICAL | CEvaluationNodeLogical::NE):
                  pNode = compileNE(*itNode, itNode.context(), variables, pRoot, container);
                  break;

                case(CEvaluationNode::LOGICAL | CEvaluationNodeLogical::LE):
                case(CEvaluationNode::LOGICAL | CEvaluationNodeLogical::LT):
                case(CEvaluationNode::LOGICAL | CEvaluationNodeLogical::GE):
                case(CEvaluationNode::LOGICAL | CEvaluationNodeLogical::GT):
                  pNode = compileLE(*itNode, itNode.context(), variables, pRoot, container);
                  break;

                case(CEvaluationNode::FUNCTION | CEvaluationNodeFunction::NOT):
                  pNode = compileNOT(*itNode, itNode.context(), variables, pRoot, container);
                  break;

                case(CEvaluationNode::CALL | CEvaluationNodeCall::FUNCTION):
                case(CEvaluationNode::CALL | CEvaluationNodeCall::EXPRESSION):
                  pNode = compileFUNCTION(*itNode, itNode.context(), variables, pRoot, container);
                  break;

                case(CEvaluationNode::VARIABLE | CEvaluationNodeVariable::ANY):
                  pNode = compileVARIABLE(*itNode, itNode.context(), variables, pRoot, container);
                  break;

                case(CEvaluationNode::CONSTANT | CEvaluationNodeConstant::TRUE):
                case(CEvaluationNode::CONSTANT | CEvaluationNodeConstant::FALSE):
                default:
                  pNode = itNode->copyNode(itNode.context());
                  break;
              }

            break;

          default:
            // This will never happen
            break;
        }

      if (itNode.parentContextPtr() != NULL)
        {
          itNode.parentContextPtr()->push_back(pNode);
        }
    }

  return pNode;
}

CEvaluationNode * CMathEventN::CTrigger::compileAND ( const CEvaluationNode *  pNode, const std::vector< CEvaluationNode * > &  children, const CMath::Variables< CEvaluationNode * > &  variables, CMathEventN::CTrigger::CRoot *&  pRoot, CMathContainer &  container  )

staticprivate

Definition at line 619 of file CMathEvent.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNodeLogical::AND, CEvaluationNode::getType(), CEvaluationNodeLogical::OR, CEvaluationNode::subType(), and CEvaluationNodeLogical::XOR.

{
  CEvaluationNode * pNode = NULL;

  switch ((int) CEvaluationNode::subType(pTriggerNode->getType()))
    {
      case CEvaluationNodeLogical::AND:
        pNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::AND, "AND");
        break;

      case CEvaluationNodeLogical::OR:
        pNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::OR, "OR");
        break;

      case CEvaluationNodeLogical::XOR:
        pNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::XOR, "XOR");
        break;

      default:
        break;
    }

  if (pNode != NULL)
    {
      pNode->addChild(children[0]);
      pNode->addChild(children[1]);
    }

  return pNode;
}

CEvaluationNode * CMathEventN::CTrigger::compileEQ ( const CEvaluationNode *  pNode, const std::vector< CEvaluationNode * > &  children, const CMath::Variables< CEvaluationNode * > &  variables, CMathEventN::CTrigger::CRoot *&  pRoot, CMathContainer &  container  )

staticprivate

Definition at line 655 of file CMathEvent.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNodeLogical::AND, CEvaluationNodeLogical::EQ, CEvaluationNodeLogical::GE, and CCopasiNode< _Data >::getChild().

{
  CEvaluationNode * pNode = NULL;

  // Equality can be determined between Boolean and double values.
  if (!static_cast< const CEvaluationNode * >(pTriggerNode->getChild())->isBoolean())
    {
      // We treat x EQ y as (x GE y) AND (y GE x)
      pNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::AND, "AND");

      CEvaluationNodeLogical GELeft(CEvaluationNodeLogical::GE, "GE");
      CEvaluationNode * pGELeft = compileLE(&GELeft, children, variables, pRoot, container);
      pNode->addChild(pGELeft);

      // We need to duplicate and reverse the order for the right
      std::vector< CEvaluationNode * > RightChildren;
      RightChildren.push_back(children[1]->copyBranch());
      RightChildren.push_back(children[0]->copyBranch());

      CEvaluationNodeLogical GERight(CEvaluationNodeLogical::GE, "GE");
      CEvaluationNode * pGERight = compileLE(&GERight, RightChildren, variables, pRoot, container);
      pNode->addChild(pGERight);
    }
  else
    {
      pNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::EQ, "EQ");
      pNode->addChild(children[0]);
      pNode->addChild(children[1]);
    }

  return pNode;
}

CEvaluationNode * CMathEventN::CTrigger::compileFUNCTION ( const CEvaluationNode *  pNode, const std::vector< CEvaluationNode * > &  children, const CMath::Variables< CEvaluationNode * > &  variables, CMathEventN::CTrigger::CRoot *&  pRoot, CMathContainer &  container  )

staticprivate

Definition at line 789 of file CMathEvent.cpp.

References CMathEventN::compile().

{
  const CEvaluationNode * pCalledNode =
    static_cast< const CEvaluationNodeCall * >(pTriggerNode)->getCalledTree()->getRoot();

  CEvaluationNode * pNode = compile(pCalledNode, children, pRoot, container);

  // We need to delete the children as the variables have been copied in place.
  std::vector< CEvaluationNode * >::const_iterator it = children.begin();
  std::vector< CEvaluationNode * >::const_iterator end = children.end();

  for (; it != end; ++it)
    {
      delete *it;
    }

  return pNode;
}

CEvaluationNode * CMathEventN::CTrigger::compileLE ( const CEvaluationNode *  pNode, const std::vector< CEvaluationNode * > &  children, const CMath::Variables< CEvaluationNode * > &  variables, CMathEventN::CTrigger::CRoot *&  pRoot, CMathContainer &  container  )

staticprivate

Definition at line 722 of file CMathEvent.cpp.

References CCopasiNode< _Data >::addChild(), CMathEventN::CTrigger::CRoot::compile(), CMathEventN::CTrigger::CRoot::createTriggerExpressionNode(), CEvaluationNodeLogical::GE, CEvaluationNode::getType(), CEvaluationNodeLogical::GT, CEvaluationNodeLogical::LE, CEvaluationNodeLogical::LT, CEvaluationNodeOperator::MINUS, and CEvaluationNode::subType().

{
  CEvaluationNode * pNode = NULL;

  // We need to compile the root finding structure
  // Create a root expression
  CEvaluationNode * pRootNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MINUS, "-");

  bool Equality = false;

  // We need to create a copy the left and right data nodes with the variables being replaced.
  switch ((int) CEvaluationNode::subType(pTriggerNode->getType()))
    {
      case CEvaluationNodeLogical::LE:
        pRootNode->addChild(children[1]);
        pRootNode->addChild(children[0]);
        Equality = true;
        break;

      case CEvaluationNodeLogical::LT:
        pRootNode->addChild(children[1]);
        pRootNode->addChild(children[0]);
        Equality = false;
        break;

      case CEvaluationNodeLogical::GE:
        pRootNode->addChild(children[0]);
        pRootNode->addChild(children[1]);
        Equality = true;
        break;

      case CEvaluationNodeLogical::GT:
        pRootNode->addChild(children[0]);
        pRootNode->addChild(children[1]);
        Equality = false;
        break;
    }

  pRoot->compile(pRootNode, Equality, container);
  pNode = pRoot->createTriggerExpressionNode();
  pRoot++;

  // We do not need to delete pRootNode as CRoot::compile takes car of it.

  return pNode;
}

CEvaluationNode * CMathEventN::CTrigger::compileNE ( const CEvaluationNode *  pNode, const std::vector< CEvaluationNode * > &  children, const CMath::Variables< CEvaluationNode * > &  variables, CMathEventN::CTrigger::CRoot *&  pRoot, CMathContainer &  container  )

staticprivate

Definition at line 693 of file CMathEvent.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNodeLogical::EQ, CEvaluationNodeFunction::NOT, and CCopasiNode< _Data >::removeChild().

{
  CEvaluationNode * pNode = NULL;

  // We treat this as NOT and EQ.
  // For this we create a modified copy of the current node.

  CEvaluationNode * pNotNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::NOT, "NOT");

  CEvaluationNodeLogical EqNode(CEvaluationNodeLogical::EQ, "EQ");

  EqNode.addChild(children[0]);
  EqNode.addChild(children[1]);

  CEvaluationNode * pEqNode = compileEQ(&EqNode, children, variables, pRoot, container);
  pNotNode->addChild(pEqNode);

  // We need to remove the children since the ownership has been transferred to pEqNode.
  EqNode.removeChild(children[0]);
  EqNode.removeChild(children[1]);

  return pNode;
}

CEvaluationNode * CMathEventN::CTrigger::compileNOT ( const CEvaluationNode *  pNode, const std::vector< CEvaluationNode * > &  children, const CMath::Variables< CEvaluationNode * > &  variables, CMathEventN::CTrigger::CRoot *&  pRoot, CMathContainer &  container  )

staticprivate

Definition at line 774 of file CMathEvent.cpp.

References CCopasiNode< _Data >::addChild(), and CEvaluationNodeFunction::NOT.

{
  CEvaluationNode * pNode = NULL;

  pNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::NOT, "NOT");
  pNode->addChild(children[0]);

  return pNode;
}

CEvaluationNode * CMathEventN::CTrigger::compileVARIABLE ( const CEvaluationNode *  pNode, const std::vector< CEvaluationNode * > &  children, const CMath::Variables< CEvaluationNode * > &  variables, CMathEventN::CTrigger::CRoot *&  pRoot, CMathContainer &  container  )

staticprivate

Definition at line 813 of file CMathEvent.cpp.

References CEvaluationNodeConstant::_NaN, C_INVALID_INDEX, and CCopasiNode< _Data >::getData().

{
  // We need to mimic the process in CMathContainer::copyBranch;
  size_t Index =
    static_cast< const CEvaluationNodeVariable * >(pTriggerNode)->getIndex();

  if (Index != C_INVALID_INDEX &&
      Index < variables.size())
    {
      // Since a variable may be referred to multiple times we need to copy it.
      return variables[Index]->copyBranch();
    }
  else
    {
      // Variables must not appear in mathematical expressions.
      // We create a constant node with the variable name and value NaN.
      return new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, pTriggerNode->getData());
    }
}

void CMathEventN::CTrigger::copy	(	const CTrigger &	src,
		CMathContainer &	container,
		const size_t &	valueOffset,
		const size_t &	objectOffset
	)

Copy an existing object

Parameters

const	CTrigger & src
CMathContainer	& container
const	size_t & valueOffset
const	size_t & objectOffset

Definition at line 226 of file CMathEvent.cpp.

References CMathEventN::CTrigger::CRoot::copy(), mDualAction, mpInitialTrigger, mpTrigger, and mRoots.

Referenced by CMathEventN::copy().

{
  mpTrigger = src.mpTrigger + objectOffset;
  mpInitialTrigger = src.mpInitialTrigger + objectOffset;

  mRoots.resize(src.mRoots.size());
  CRoot * pRoot = mRoots.array();
  CRoot * pRootEnd = pRoot + mRoots.size();
  const CRoot * pRootSrc = src.mRoots.array();

  for (; pRoot != pRootEnd; ++pRoot, ++pRootSrc)
    {
      pRoot->copy(*pRootSrc, container, valueOffset, objectOffset);
    }

  mDualAction = src.mDualAction;
}

size_t CMathEventN::CTrigger::countRoots ( const CEvaluationNode *  pNode, const CMath::Variables< size_t > &  variables  )

staticprivate

Definition at line 315 of file CMathEvent.cpp.

References CNodeIteratorMode::After, CEvaluationNodeVariable::ANY, CNodeIteratorMode::Before, CEvaluationNode::CALL, CNodeContextIterator< Node, Context >::context(), CNodeContextIterator< Node, Context >::end(), CEvaluationNodeLogical::EQ, CEvaluationNodeCall::EXPRESSION, CEvaluationNodeCall::FUNCTION, CEvaluationNodeLogical::GE, CEvaluationNode::getType(), CEvaluationNodeLogical::GT, CEvaluationNode::isBoolean(), CEvaluationNodeLogical::LE, CEvaluationNode::LOGICAL, CEvaluationNodeLogical::LT, CEvaluationNodeLogical::NE, CNodeContextIterator< Node, Context >::next(), CNodeContextIterator< Node, Context >::parentContextPtr(), CNodeContextIterator< Node, Context >::processingMode(), CNodeContextIterator< Node, Context >::setProcessingModes(), CNodeContextIterator< Node, Context >::skipChildren(), CEvaluationNode::subType(), CEvaluationNode::type(), and CEvaluationNode::VARIABLE.

{
  size_t RootCount = 0;

  // TODO CRITICAL We only need to count in boolean functions see compile for details.
  CNodeContextIterator< const CEvaluationNode, std::vector< size_t > > itNode(pNode);
  itNode.setProcessingModes(CNodeIteratorMode::Before | CNodeIteratorMode::After);

  while (itNode.next() != itNode.end())
    {
      if (*itNode == NULL)
        {
          continue;
        }

      switch (itNode.processingMode())
        {
          case CNodeIteratorMode::Before:

            // Variables return always false we need to dig deeper.
            if (CEvaluationNode::type(itNode->getType()) == CEvaluationNode::VARIABLE ||
                itNode->isBoolean())
              {
                continue;
              }

            // We found a non boolean node which does not create a root.
            itNode.skipChildren();
            RootCount = 0;

            break;

          case CNodeIteratorMode::After:
          {
            // We do not need to check whether the root is boolean as non boolean nodes are
            // already processed
            const CEvaluationNode::Type & Type = itNode->getType();

            switch (CEvaluationNode::type(Type))
              {
                case CEvaluationNode::LOGICAL:

                  switch ((int) CEvaluationNode::subType(Type))
                    {
                      case CEvaluationNodeLogical::EQ:
                      case CEvaluationNodeLogical::NE:
                        RootCount = countRootsEQ(*itNode, itNode.context());
                        break;

                      case CEvaluationNodeLogical::LE:
                      case CEvaluationNodeLogical::LT:
                      case CEvaluationNodeLogical::GE:
                      case CEvaluationNodeLogical::GT:
                        RootCount = 1;
                        break;

                      default:
                        RootCount = countRootsDefault(itNode.context());
                        break;
                    }

                  break;

                case CEvaluationNode::CALL:

                  switch ((int) CEvaluationNode::subType(Type))
                    {
                      case CEvaluationNodeCall::FUNCTION:
                      case CEvaluationNodeCall::EXPRESSION:
                        RootCount = countRootsFUNCTION(*itNode, itNode.context());
                        break;

                      default:
                        RootCount = countRootsDefault(itNode.context());
                        break;
                    }

                  break;

                case CEvaluationNode::VARIABLE:

                  switch ((int) CEvaluationNode::subType(Type))
                    {
                      case CEvaluationNodeVariable::ANY:
                        RootCount = countRootsVARIABLE(*itNode, variables);
                        break;

                      default:
                        RootCount = countRootsDefault(itNode.context());
                        break;
                    }

                  break;

                default:
                  RootCount = countRootsDefault(itNode.context());
                  break;
              }
          }
          break;

          default:
            break;
        }

      if (itNode.parentContextPtr() != NULL)
        {
          itNode.parentContextPtr()->push_back(RootCount);
        }
    }

  return RootCount;
}

size_t CMathEventN::CTrigger::countRootsDefault ( const std::vector< size_t > &  children )

staticprivate

Definition at line 431 of file CMathEvent.cpp.

{
  size_t RootCount = 0;

  std::vector< size_t >::const_iterator it = children.begin();
  std::vector< size_t >::const_iterator end = children.end();

  for (; it != end; ++it)
    {
      RootCount += *it;
    }

  return RootCount;
}

size_t CMathEventN::CTrigger::countRootsEQ ( const CEvaluationNode *  pNode, const std::vector< size_t > &  children  )

staticprivate

Definition at line 447 of file CMathEvent.cpp.

References CCopasiNode< _Data >::getChild().

{
  size_t nRoots = children[0] + children[1];

  // Equality can be determined between Boolean and double values.
  if (static_cast<const CEvaluationNode *>(pNode->getChild())->isBoolean())
    {
      nRoots = children[0] + children[1];
    }
  else
    {
      nRoots = 2;
    }

  return nRoots;
}

size_t CMathEventN::CTrigger::countRootsFUNCTION ( const CEvaluationNode *  pNode, const std::vector< size_t > &  children  )

staticprivate

Definition at line 466 of file CMathEvent.cpp.

{
  const CEvaluationNode * pTreeRoot =
    static_cast< const CEvaluationNodeCall * >(pNode)->getCalledTree()->getRoot();

  size_t nRoots = countRoots(pTreeRoot, children);

  return nRoots;
}

size_t CMathEventN::CTrigger::countRootsVARIABLE ( const CEvaluationNode *  pNode, const CMath::Variables< size_t > &  variables  )

staticprivate

Definition at line 478 of file CMathEvent.cpp.

References C_INVALID_INDEX.

{
  size_t Index =
    static_cast< const CEvaluationNodeVariable * >(pNode)->getIndex();

  if (Index == C_INVALID_INDEX)
    {
      return 0;
    }

  return variables[Index];
}

const CVector< CMathEventN::CTrigger::CRoot > & CMathEventN::CTrigger::getRoots

(

)

const

Definition at line 287 of file CMathEvent.cpp.

Referenced by CMathContainer::allocate().

{
  return mRoots;
}

void CMathEventN::CTrigger::initialize

(

CMath::sPointers &

pointers

)

Definition at line 200 of file CMathEvent.cpp.

References CMath::Event, CMath::EventTrigger, CMathEventN::CTrigger::CRoot::initialize(), CMathObject::initialize(), CMath::sPointers::pEventTriggers, CMath::sPointers::pEventTriggersObject, CMath::sPointers::pInitialEventTriggers, CMath::sPointers::pInitialEventTriggersObject, and CMath::SimulationTypeUndefined.

Referenced by CMathEventN::initialize().

{
  // Initialize trigger object.
  mpTrigger = pointers.pEventTriggersObject;
  *pointers.pEventTriggers = 1.0;
  CMathObject::initialize(pointers.pEventTriggersObject, pointers.pEventTriggers,
                          CMath::EventTrigger, CMath::Event, CMath::SimulationTypeUndefined,
                          false, false, NULL);

  // Initialize initial trigger object.
  mpInitialTrigger = pointers.pInitialEventTriggersObject;
  *pointers.pInitialEventTriggers = 1.0;
  CMathObject::initialize(pointers.pInitialEventTriggersObject, pointers.pInitialEventTriggers,
                          CMath::EventTrigger, CMath::Event, CMath::SimulationTypeUndefined,
                          false, true, NULL);

  // Initialize root object.
  CRoot * pRoot = mRoots.array();
  CRoot * pRootEnd = pRoot + mRoots.size();

  for (; pRoot != pRootEnd; ++pRoot)
    {
      pRoot->initialize(pointers);
    }
}

void CMathEventN::CTrigger::setExpression	(	const std::string &	infix,
		CMathContainer &	container
	)

Set the trigger expression

Parameters

const	std::string & infix
CMathContainer	& container

Definition at line 292 of file CMathEvent.cpp.

References CMathEventN::compile(), CMathEventN::CTrigger::CRoot::mpRoot, and CMathEventN::CTrigger::CRoot::mpRootState.

Referenced by CMathEventN::setTriggerExpression().

{
  assert(mpTrigger != NULL);

  mpTrigger->setExpression(infix, true, container);

  compile(NULL, container);

  std::cout << *mpTrigger;
  std::cout << *mpInitialTrigger;

  CRoot * pRoot = mRoots.array();
  CRoot * pRootEnd = pRoot + mRoots.size();

  for (; pRoot != pRootEnd; ++pRoot)
    {
      std::cout << *pRoot->mpRoot;
      std::cout << *pRoot->mpRootState;
    }
}

Member Data Documentation

bool CMathEventN::CTrigger::mDualAction

private

Definition at line 203 of file CMathEvent.h.

Referenced by copy().

CMathObject* CMathEventN::CTrigger::mpInitialTrigger

private

Definition at line 201 of file CMathEvent.h.

Referenced by copy().

CMathObject* CMathEventN::CTrigger::mpTrigger

private

Definition at line 200 of file CMathEvent.h.

Referenced by copy().

CVector< CRoot > CMathEventN::CTrigger::mRoots

private

Definition at line 202 of file CMathEvent.h.

Referenced by copy().

---

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

• CMathEvent.h
• CMathEvent.cpp