#include <CMathObject.h>

Inheritance diagram for CMathObject:

Collaboration diagram for CMathObject:

Public Member Functions
void	calculate ()

	CMathObject ()

bool	compile (CMathContainer &container)

void	copy (const CMathObject &src, CMathContainer &container, const size_t &valueOffset, const size_t &objectOffset)

virtual CCopasiObjectName	getCN () const

const CCopasiObject *	getDataObject () const

const CMath::EntityType &	getEntityType () const

const CMathExpression *	getExpressionPtr () const

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

virtual const CObjectInterface::ObjectSet &	getPrerequisites () const

const CMath::SimulationType &	getSimulationType () const

virtual void *	getValuePointer () const

const CMath::ValueType &	getValueType () const

const bool &	isInitialValue () const

const bool &	isIntensiveProperty () const

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

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

bool	setExpression (const std::string &infix, const bool &isBoolean, CMathContainer &container)

bool	setExpression (const CExpression &expression, CMathContainer &container)

bool	setExpressionPtr (CMathExpression *pMathExpression)

void	setSimulationType (const CMath::SimulationType &simulationType)

virtual	~CMathObject ()

Public Member Functions inherited from CObjectInterface
	CObjectInterface ()

virtual	~CObjectInterface ()

Static Public Member Functions
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)

Private Member Functions
bool	compileDependentMass (CMathContainer &container)

void	compileExpression ()

bool	compileFlux (CMathContainer &container)

bool	compileInitialValue (CMathContainer &container)

bool	compileParticleFlux (CMathContainer &container)

bool	compilePropensity (CMathContainer &container)

bool	compileRate (CMathContainer &container)

bool	compileTotalMass (CMathContainer &container)

bool	compileValue (CMathContainer &container)

bool	createConvertedExpression (const CExpression *pExpression, CMathContainer &container)

bool	createExtensiveODERateExpression (const CMetab *pSpecies, CMathContainer &container)

bool	createExtensiveReactionRateExpression (const CMetab *pSpecies, CMathContainer &container)

bool	createExtensiveValueExpression (const CMetab *pSpecies, CMathContainer &container)

bool	createIntensiveRateExpression (const CMetab *pSpecies, CMathContainer &container)

bool	createIntensiveValueExpression (const CMetab *pSpecies, CMathContainer &container)

Private Attributes
CMath::EntityType	mEntityType

bool	mIsInitialValue

bool	mIsIntensiveProperty

const CCopasiObject *	mpDataObject

CMathExpression *	mpExpression

const CMathObject *	mpIntensiveProperty

CObjectInterface::ObjectSet	mPrerequisites

C_FLOAT64 *	mpValue

CMath::SimulationType	mSimulationType

CMath::ValueType	mValueType

Static Private Attributes
static C_FLOAT64	InvalidValue = std::numeric_limits< C_FLOAT64 >::quiet_NaN()

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

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

typedef std::vector < CObjectInterface * >	UpdateSequence

Detailed Description

Definition at line 22 of file CMathObject.h.

Constructor & Destructor Documentation

CMathObject::CMathObject ( )

Default Constructor

Definition at line 44 of file CMathObject.cpp.

                         :
   CObjectInterface(),
   mpExpression(NULL),
   mpValue(&InvalidValue),
   mPrerequisites(),
   mValueType(CMath::ValueTypeUndefined),
   mEntityType(CMath::EntityTypeUndefined),
   mSimulationType(CMath::SimulationTypeUndefined),
   mIsIntensiveProperty(false),
   mIsInitialValue(false),
   mpIntensiveProperty(NULL),
   mpDataObject(NULL)
 {}

CMathObject::~CMathObject ( )

virtual

Destructor

Definition at line 59 of file CMathObject.cpp.

References mpExpression, and pdelete.

 {
   pdelete(mpExpression);
 }

Member Function Documentation

void CMathObject::calculate ( void )

Calculate the objects value

Definition at line 263 of file CMathObject.cpp.

References getCN(), mpExpression, mpValue, and CMathExpression::value().

Referenced by CMathContainer::applyUpdateSequence(), compileExpression(), and copy().

 {
   // This method should only be called if there is something to calculate, i.e.
   // mpExpression != NULL
   assert(mpExpression != NULL);
 
   *mpValue = mpExpression->value();
 
 #ifdef COPASI_DEBUG
 
   // Check for NaN
   if (isnan(*mpValue))
     {
       std::cout << "NaN Value for: " << getCN() << std::endl;
     }
 
 #endif // COPASI_DEBUG
 
   // For an extensive transient value of a dependent species we have 2
   // possible assignments depending on the context.
   //   1) Conversion from the intensive property
   //   2) Dependent mass off a moiety
   //
   // The solution is that the moiety automatically updates the value in conjunction
   // with the dependency graph omitting the value in the update sequence if the context
   // is CMath::UseMoieties.
 }

bool CMathObject::compile ( CMathContainer & container )

Compile

Parameters

CMathContainer & container

Returns: bool §success

Definition at line 380 of file CMathObject.cpp.

References compileDependentMass(), compileFlux(), compileInitialValue(), compileParticleFlux(), compilePropensity(), compileRate(), compileTotalMass(), compileValue(), CMath::DependentMass, CMath::Discontinuous, CMath::EventAssignment, CMath::EventDelay, CMath::EventPriority, CMath::EventRoot, CMath::EventRootState, CMath::EventTrigger, CMath::Flux, mIsInitialValue, mValueType, CMath::ParticleFlux, CMath::Propensity, CMath::Rate, CMath::TotalMass, CMath::Value, and CMath::ValueTypeUndefined.

Referenced by CMathContainer::compileObjects().

 {
 
   bool success = true;
 
   switch (mValueType)
     {
       case CMath::ValueTypeUndefined:
         success = false;
         break;
 
       case CMath::Value:
 
         if (mIsInitialValue)
           {
             success = compileInitialValue(container);
           }
         else
           {
             success = compileValue(container);
           }
 
         break;
 
       case CMath::Rate:
         success = compileRate(container);
         break;
 
       case CMath::ParticleFlux:
         success = compileParticleFlux(container);
         break;
 
       case CMath::Flux:
         success = compileFlux(container);
         break;
 
       case CMath::Propensity:
         success = compilePropensity(container);
         break;
 
       case CMath::TotalMass:
         success = compileTotalMass(container);
         break;
 
       case CMath::DependentMass:
         success = compileDependentMass(container);
         break;
 
       case CMath::Discontinuous:
       case CMath::EventDelay:
       case CMath::EventPriority:
       case CMath::EventAssignment:
       case CMath::EventTrigger:
       case CMath::EventRoot:
       case CMath::EventRootState:
         // These objects are compiled through the event compile,
         // which is executed after the object compile. It is therefore
         // correct to leave the object in its default state.
         break;
     }
 
   return success;
 }

bool CMathObject::compileDependentMass ( CMathContainer & container )

private

Compile the dependent mass of a moiety.

Parameters

CMathContainer & container

Returns: bool success

Definition at line 910 of file CMathObject.cpp.

References C_FLOAT64, compileExpression(), CCopasiObject::getCN(), CMoiety::getEquation(), CMathContainer::getMathObject(), CCopasiObject::getObjectParent(), CMoiety::getTotalNumberReference(), getValuePointer(), InvalidValue, mIsInitialValue, mpDataObject, mpExpression, mPrerequisites, mpValue, and CExpression::setInfix().

Referenced by compile().

 {
   bool success = true;
 
   // The default value is NaN
   *mpValue = InvalidValue;
 
   // Reset the prerequisites
   mPrerequisites.clear();
 
   const CMoiety * pMoiety = static_cast< const CMoiety *>(mpDataObject->getObjectParent());
 
   std::ostringstream Infix;
   Infix.imbue(std::locale::classic());
   Infix.precision(16);
 
   Infix << "<" << pMoiety->getTotalNumberReference()->getCN() << ">";
 
   std::vector< std::pair< C_FLOAT64, CMetab * > >::const_iterator it = pMoiety->getEquation().begin();
   std::vector< std::pair< C_FLOAT64, CMetab * > >::const_iterator end = pMoiety->getEquation().end();
   bool First = true;
 
   // The first element in the equation is always the dependent species. We can directly update
   // its value and therefore point mpValue to it.
   mpValue = (C_FLOAT64 *) container.getMathObject(it->second->getValueReference())->getValuePointer();
 
   ++it;
 
   for (; it != end; ++it)
     {
       const C_FLOAT64 & Multiplicity = it->first;
 
       if (First || Multiplicity >= 0.0)
         {
           Infix << "-" << Multiplicity;
         }
       else
         {
           Infix << "+" << fabs(Multiplicity);
         }
 
       First = false;
 
       Infix << "*<";
       Infix << it->second->getValueReference()->getCN();
       Infix << ">";
     }
 
   CExpression E("DependentMass", &container);
 
   success &= E.setInfix(Infix.str());
 
   mpExpression = new CMathExpression(E, container, !mIsInitialValue);
   compileExpression();
 
   return success;
 }

void CMathObject::compileExpression ( )

private

Common compile steps after an expression has been created.

Definition at line 968 of file CMathObject.cpp.

References calculate(), CMathExpression::convertToInitialExpression(), CMathExpression::getPrerequisites(), mIsInitialValue, mpExpression, and mPrerequisites.

Referenced by compileDependentMass(), compileFlux(), compileParticleFlux(), compilePropensity(), compileTotalMass(), createConvertedExpression(), createExtensiveODERateExpression(), createExtensiveReactionRateExpression(), createExtensiveValueExpression(), createIntensiveRateExpression(), createIntensiveValueExpression(), and setExpressionPtr().

 {
   assert(mpExpression);
 
   if (mIsInitialValue)
     {
       mpExpression->convertToInitialExpression();
     }
 
   mPrerequisites.insert(mpExpression->getPrerequisites().begin(),
                         mpExpression->getPrerequisites().end());
 
   if (mPrerequisites.empty())
     {
       calculate();
     }
 }

bool CMathObject::compileFlux ( CMathContainer & container )

private

Compile the reactions flux

Parameters

CMathContainer & container

Returns: bool success

Definition at line 730 of file CMathObject.cpp.

References compileExpression(), CReaction::getCallParameters(), CReaction::getChemEq(), CCopasiObject::getCN(), CChemEq::getCompartments(), CReaction::getFunction(), CEvaluationTree::getInfix(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), InvalidValue, mIsInitialValue, mpDataObject, mpExpression, mPrerequisites, mpValue, and pdelete.

Referenced by compile().

 {
   bool success = true;
 
   // The default value is NaN
   *mpValue = InvalidValue;
 
   // Reset the prerequisites
   mPrerequisites.clear();
 
   const CReaction * pReaction = static_cast< const CReaction * >(mpDataObject->getObjectParent());
 
   // We need to check whether this reaction is a single compartment reaction and scale it if true.
   //   mFlux = *mScalingFactor * mpFunction->calcValue(mMap.getPointers());
   //   mScalingFactor = compartment volume or 1
 
   mpExpression = new CMathExpression(*pReaction->getFunction(),
                                      pReaction->getCallParameters(),
                                      container,
                                      !mIsInitialValue);
 
   std::set< const CCompartment * > Compartments = pReaction->getChemEq().getCompartments();
 
   if (Compartments.size() == 1)
     {
       CExpression Tmp(mpExpression->getObjectName(), &container);
 
       std::string Infix = "<" + (*Compartments.begin())->getValueReference()->getCN() + ">*(" + mpExpression->getInfix() + ")";
       success &= Tmp.setInfix(Infix);
       success &= Tmp.compile();
 
       pdelete(mpExpression);
       mpExpression = new CMathExpression(Tmp, container, false);
     }
 
   compileExpression();
 
   return success;
 }

bool CMathObject::compileInitialValue ( CMathContainer & container )

private

Compile initial value objects

Parameters

CMathContainer & container

Returns: bool success

Definition at line 444 of file CMathObject.cpp.

References CMath::Assignment, C_FLOAT64, CMath::Conversion, createConvertedExpression(), createExtensiveValueExpression(), createIntensiveValueExpression(), CMath::Dependent, CMath::EventTarget, CMath::Fixed, CMetab::getInitialConcentrationReference(), CModelEntity::getInitialExpressionPtr(), CMathContainer::getMathObject(), CCopasiObject::getObjectParent(), CCopasiObject::getValuePointer(), CMath::Independent, InvalidValue, mIsIntensiveProperty, mpDataObject, mpIntensiveProperty, mPrerequisites, mpValue, mSimulationType, CMath::ODE, CMath::SimulationTypeUndefined, and CMath::Time.

Referenced by compile().

 {
   bool success = true;
 
   // The default value is NaN
   *mpValue = InvalidValue;
 
   // Initial values are taken from the data model
   if (mpDataObject != NULL)
     {
       *mpValue = * (C_FLOAT64 *) mpDataObject->getValuePointer();
     }
 
   // Reset the prerequisites
   mPrerequisites.clear();
 
   const CModelEntity * pEntity = dynamic_cast< const CModelEntity * >(mpDataObject->getObjectParent());
 
   if (mIsIntensiveProperty)
     {
       // Only species have intensive properties (concentration and concentration rate).
       const CMetab * pSpecies = static_cast< const CMetab * >(pEntity);
 
       switch (mSimulationType)
         {
           case CMath::EventTarget:
           case CMath::Fixed:
           case CMath::ODE:
           case CMath::Independent:
           case CMath::Dependent:
           case CMath::Conversion:
             success &= createIntensiveValueExpression(pSpecies, container);
             break;
 
           case CMath::Assignment:
             // Extensive Property * Conversion / Compartment Size
             success &= createConvertedExpression(pSpecies->getInitialExpressionPtr(), container);
 
             break;
 
           case CMath::Time:
           case CMath::SimulationTypeUndefined:
             success = false;
             break;
         }
     }
   else
     {
       switch (mSimulationType)
         {
           case CMath::Fixed:
             break;
 
           case CMath::Assignment:
             success &= createConvertedExpression(pEntity->getInitialExpressionPtr(), container);
             break;
 
           case CMath::Conversion:
           {
             const CMetab * pSpecies = static_cast< const CMetab * >(pEntity);
             mpIntensiveProperty = container.getMathObject(pSpecies->getInitialConcentrationReference());
             success &= createExtensiveValueExpression(pSpecies, container);
           }
           break;
 
           case CMath::SimulationTypeUndefined:
           case CMath::EventTarget:
           case CMath::Time:
           case CMath::ODE:
           case CMath::Independent:
           case CMath::Dependent:
             success = false;
             break;
         }
     }
 
   return success;
 }

bool CMathObject::compileParticleFlux ( CMathContainer & container )

private

Compile the reactions particle flux

Parameters

CMathContainer & container

Returns: bool success

Definition at line 694 of file CMathObject.cpp.

References compileExpression(), CCopasiObject::getCN(), CReaction::getFluxReference(), CMathContainer::getModel(), CCopasiObject::getObjectParent(), CModel::getQuantity2NumberFactor(), InvalidValue, mIsInitialValue, mpDataObject, mpExpression, mPrerequisites, mpValue, and CExpression::setInfix().

Referenced by compile().

 {
   bool success = true;
 
   // The default value is NaN
   *mpValue = InvalidValue;
 
   // Reset the prerequisites
   mPrerequisites.clear();
 
   const CReaction * pReaction = static_cast< const CReaction * >(mpDataObject->getObjectParent());
 
   // We need to check whether this reaction is a single compartment reaction and scale
   // it if true.
   //   mParticleFlux = *mUnitScalingFactor * mFlux;
   //   mUnitScalingFactor = & pModel->getQuantity2NumberFactor();
 
   std::ostringstream Infix;
   Infix.imbue(std::locale::classic());
   Infix.precision(16);
 
   Infix << container.getModel().getQuantity2NumberFactor();
   Infix << "*<";
   Infix << pReaction->getFluxReference()->getCN();
   Infix << ">";
 
   CExpression E("ParticleExpression", &container);
 
   success &= E.setInfix(Infix.str());
 
   mpExpression = new CMathExpression(E, container, !mIsInitialValue);
   compileExpression();
 
   return success;
 }

bool CMathObject::compilePropensity ( CMathContainer & container )

private

Compile the reactions propensity

Parameters

CMathContainer & container

Returns: bool success

Definition at line 770 of file CMathObject.cpp.

References CCopasiVector< T >::begin(), C_FLOAT64, compileExpression(), CModel::deterministic, CCopasiVector< T >::end(), CReaction::getChemEq(), CCopasiObject::getCN(), CMathContainer::getModel(), CModel::getModelType(), CCopasiObject::getObjectParent(), CReaction::getParticleFluxReference(), CChemEq::getSubstrates(), InvalidValue, CReaction::isReversible(), mIsInitialValue, mpDataObject, mpExpression, mPrerequisites, mpValue, and CExpression::setInfix().

Referenced by compile().

 {
   bool success = true;
 
   // The default value is NaN
   *mpValue = InvalidValue;
 
   // Reset the prerequisites
   mPrerequisites.clear();
 
   const CReaction * pReaction = static_cast< const CReaction * >(mpDataObject->getObjectParent());
 
   std::ostringstream Infix;
   Infix.imbue(std::locale::classic());
   Infix.precision(16);
 
   // Propensity for reversible reactions must be NaN
   if (pReaction->isReversible())
     {
       Infix << "NAN";
     }
   else if (container.getModel().getModelType() == CModel::deterministic)
     {
       Infix << "<" << pReaction->getParticleFluxReference()->getCN() << ">";
 
       std::ostringstream Divisor;
       Divisor.imbue(std::locale::classic());
       Divisor.precision(16);
 
       const CCopasiVector<CChemEqElement> & Substrates = pReaction->getChemEq().getSubstrates();
       CCopasiVector< CChemEqElement >::const_iterator itSubstrate = Substrates.begin();
       CCopasiVector< CChemEqElement >::const_iterator endSubstrate = Substrates.end();
       bool first = true;
 
       for (; itSubstrate != endSubstrate; ++itSubstrate)
         {
           const std::string NumberCN = (*itSubstrate)->getMetabolite()->getValueReference()->getCN();
           C_FLOAT64 Multiplicity = (*itSubstrate)->getMultiplicity();
 
           Multiplicity -= 1.0; // Nothing to correct if the multiplicity is 1.
 
           if (Multiplicity > 2.0 - 100.0 * std::numeric_limits< C_FLOAT64 >::epsilon())
             {
               if (!first)
                 {
                   Divisor << "*";
                 }
 
               first = false;
               Divisor << "<" << NumberCN << ">^" << Multiplicity;
             }
           else if (Multiplicity > 1.0 - 100.0 * std::numeric_limits< C_FLOAT64 >::epsilon())
             {
               if (!first)
                 {
                   Divisor << "*";
                 }
 
               first = false;
               Divisor << "<" << NumberCN << ">";
             }
 
           while (Multiplicity > 1.0 - 100.0 * std::numeric_limits< C_FLOAT64 >::epsilon())
             {
               Infix << "*(<" << NumberCN << ">-" << Multiplicity << ")";
               Multiplicity -= 1.0;
             }
         }
 
       if (Divisor.str() != "")
         {
           Infix << "/(" << Divisor.str() << ")";
         }
     }
   else
     {
       // Propensity is the same as the flux.
       Infix << "<" << pReaction->getParticleFluxReference()->getCN() << ">";
     }
 
   CExpression E("PropensityExpression", &container);
 
   success &= E.setInfix(Infix.str());
 
   mpExpression = new CMathExpression(E, container, !mIsInitialValue);
   compileExpression();
 
   return success;
 }

bool CMathObject::compileRate ( CMathContainer & container )

private

Compile value rate objects

Parameters

CMathContainer & container

Returns: bool success

Definition at line 610 of file CMathObject.cpp.

References CMath::Assignment, CMath::Conversion, createConvertedExpression(), createExtensiveODERateExpression(), createExtensiveReactionRateExpression(), createIntensiveRateExpression(), CMath::Dependent, CMath::EventTarget, CMath::Fixed, CModelEntity::getExpressionPtr(), CCopasiObject::getObjectParent(), CMath::Independent, InvalidValue, mEntityType, mIsIntensiveProperty, mpDataObject, mPrerequisites, mpValue, mSimulationType, CMath::ODE, CMath::SimulationTypeUndefined, CMath::Species, and CMath::Time.

Referenced by compile().

 {
   bool success = true;
 
   // The default value is NaN
   *mpValue = InvalidValue;
 
   // Reset the prerequisites
   mPrerequisites.clear();
 
   if (mIsIntensiveProperty)
     {
       // Only species have intensive properties.
       const CMetab * pSpecies = static_cast< const CMetab * >(mpDataObject->getObjectParent());
 
       switch (mSimulationType)
         {
           case CMath::Assignment:
             success &= createIntensiveRateExpression(pSpecies, container);
             break;
 
           case CMath::SimulationTypeUndefined:
           case CMath::Fixed:
           case CMath::EventTarget:
           case CMath::Time:
           case CMath::ODE:
           case CMath::Independent:
           case CMath::Dependent:
           case CMath::Conversion:
             success = false;
             break;
         }
     }
   else
     {
 
       switch (mSimulationType)
         {
           case CMath::Fixed:
             *mpValue = 0;
             break;
 
           case CMath::Time:
             *mpValue = 1;
             break;
 
           case CMath::ODE:
 
             if (mEntityType == CMath::Species)
               {
                 const CMetab * pSpecies = static_cast< const CMetab * >(mpDataObject->getObjectParent());
                 success &= createExtensiveODERateExpression(pSpecies, container);
               }
             else
               {
                 const CModelEntity * pEntity = static_cast< const CModelEntity * >(mpDataObject->getObjectParent());
                 success &= createConvertedExpression(pEntity->getExpressionPtr(), container);
               }
 
             break;
 
           case CMath::Independent:
           case CMath::Dependent:
           {
             const CMetab * pSpecies = static_cast< const CMetab * >(mpDataObject->getObjectParent());
             success &= createExtensiveReactionRateExpression(pSpecies, container);
           }
           break;
 
           case CMath::Assignment:
             // TODO When we have symbolic differentiation we can deal with this.
             break;
 
           case CMath::SimulationTypeUndefined:
           case CMath::EventTarget:
           case CMath::Conversion:
             success = false;
             break;
         }
     }
 
   return success;
 }

bool CMathObject::compileTotalMass ( CMathContainer & container )

private

Compile the total mass of a moiety.

Parameters

CMathContainer & container

Returns: bool success

Definition at line 860 of file CMathObject.cpp.

References C_FLOAT64, compileExpression(), CMoiety::getEquation(), CCopasiObject::getObjectParent(), InvalidValue, mIsInitialValue, mpDataObject, mpExpression, mPrerequisites, mpValue, and CExpression::setInfix().

Referenced by compile().

 {
   bool success = true;
 
   // The default value is NaN
   *mpValue = InvalidValue;
 
   // Reset the prerequisites
   mPrerequisites.clear();
 
   const CMoiety * pMoiety = static_cast< const CMoiety *>(mpDataObject->getObjectParent());
 
   std::ostringstream Infix;
   Infix.imbue(std::locale::classic());
   Infix.precision(16);
 
   std::vector< std::pair< C_FLOAT64, CMetab * > >::const_iterator it = pMoiety->getEquation().begin();
   std::vector< std::pair< C_FLOAT64, CMetab * > >::const_iterator end = pMoiety->getEquation().end();
   bool First = true;
 
   for (; it != end; ++it)
     {
       const C_FLOAT64 & Multiplicity = it->first;
 
       if (First || Multiplicity < 0.0)
         {
           Infix << Multiplicity;
         }
       else
         {
           Infix << "+" << Multiplicity;
         }
 
       First = false;
 
       Infix << "*<";
       Infix << it->second->getValueReference()->getCN();
       Infix << ">";
     }
 
   CExpression E("TotalMass", &container);
 
   success &= E.setInfix(Infix.str());
 
   mpExpression = new CMathExpression(E, container, !mIsInitialValue);
   compileExpression();
 
   return success;
 }

bool CMathObject::compileValue ( CMathContainer & container )

private

Compile value objects

Parameters

CMathContainer & container

Returns: bool success

Definition at line 523 of file CMathObject.cpp.

References CMath::Assignment, CMath::Conversion, createConvertedExpression(), createExtensiveValueExpression(), createIntensiveValueExpression(), CMath::Dependent, CMath::EventTarget, CMath::Fixed, CMetab::getConcentrationReference(), CMoiety::getDependentNumberReference(), CModelEntity::getExpressionPtr(), CMathContainer::getMathObject(), CMetab::getMoiety(), CCopasiObject::getObjectParent(), CMath::Independent, InvalidValue, mEntityType, mIsIntensiveProperty, mpDataObject, mpIntensiveProperty, mPrerequisites, mpValue, mSimulationType, CMath::ODE, CMath::SimulationTypeUndefined, CMath::Species, and CMath::Time.

Referenced by compile().

 {
   bool success = true;
 
   // The default value is NaN
   *mpValue = InvalidValue;
 
   // Reset the prerequisites
   mPrerequisites.clear();
 
   if (mIsIntensiveProperty)
     {
       // Only species have intensive properties.
       const CMetab * pSpecies = static_cast< const CMetab * >(mpDataObject->getObjectParent());
 
       switch (mSimulationType)
         {
           case CMath::Assignment:
             success &= createConvertedExpression(pSpecies->getExpressionPtr(), container);
             break;
 
           case CMath::EventTarget:
           case CMath::Conversion:
             success &= createIntensiveValueExpression(pSpecies, container);
             break;
 
           case CMath::SimulationTypeUndefined:
           case CMath::Fixed:
           case CMath::Time:
           case CMath::ODE:
           case CMath::Independent:
           case CMath::Dependent:
             success = false;
             break;
         }
     }
   else
     {
       // Species need an additional conversion since the event targets the
       // intensive property.
       const CMetab * pSpecies = NULL;
 
       if (mEntityType == CMath::Species)
         {
           pSpecies = static_cast< const CMetab * >(mpDataObject->getObjectParent());
           mpIntensiveProperty = container.getMathObject(pSpecies->getConcentrationReference());
           success &= createExtensiveValueExpression(pSpecies, container);
         }
 
       switch (mSimulationType)
         {
           case CMath::Fixed:
           case CMath::EventTarget:
           case CMath::Time:
           case CMath::ODE:
           case CMath::Independent:
           case CMath::Conversion:
             break;
 
           case CMath::Dependent:
           {
             // We need to add the dependent number of the moiety as a possible
             // prerequisite.
             const CMoiety * pMoiety = pSpecies->getMoiety();
             const CMathObject * pDependentNumber =
               container.getMathObject(pMoiety->getDependentNumberReference());
 
             mPrerequisites.insert(pDependentNumber);
           }
           break;
 
           case CMath::Assignment:
           {
             const CModelEntity * pEntity = static_cast< const CModelEntity * >(mpDataObject->getObjectParent());
             success &= createConvertedExpression(pEntity->getExpressionPtr(), container);
           }
           break;
 
           case CMath::SimulationTypeUndefined:
             success = false;
             break;
         }
     }
 
   return success;
 }

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

Copy an existing object

Parameters

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

Definition at line 64 of file CMathObject.cpp.

References C_FLOAT64, calculate(), CMathExpression::copy(), getPrerequisites(), mEntityType, mIsInitialValue, mIsIntensiveProperty, mpDataObject, mpExpression, mpIntensiveProperty, mPrerequisites, mpValue, mSimulationType, and mValueType.

Referenced by CMathContainer::CMathContainer().

 {
   mpValue = (C_FLOAT64 *)((size_t) src.mpValue + valueOffset);
   mValueType = src.mValueType;
   mEntityType = src.mEntityType;
   mSimulationType = src.mSimulationType;
   mIsIntensiveProperty = src.mIsIntensiveProperty;
   mIsInitialValue = src.mIsInitialValue;
   mpDataObject = src.mpDataObject;
 
   if (src.mpIntensiveProperty != NULL)
     {
       mpIntensiveProperty = (CMathObject *)((size_t) src.mpIntensiveProperty + objectOffset);
     }
   else
     {
       mpIntensiveProperty = NULL;
     }
 
   if (src.mpExpression != NULL)
     {
       mpExpression = CMathExpression::copy(*src.mpExpression, container, valueOffset, objectOffset);
     }
   else
     {
       mpExpression = NULL;
     }
 
   ObjectSet::const_iterator it = src.getPrerequisites().begin();
   ObjectSet::const_iterator end = src.getPrerequisites().end();
 
   for (; it != end; ++it)
     {
       mPrerequisites.insert((CMathObject *)((size_t) *it + objectOffset));
     }
 
   if (mpExpression != NULL &&
       mPrerequisites.empty())
     {
       calculate();
     }
 }

bool CMathObject::createConvertedExpression	(	const CExpression *	pExpression,
		CMathContainer &	container
	)

private

Create and compile an expression based on the given expression.

Parameters

const	CExpression * pExpression
CMathContainer	& container

Returns: bool success

Definition at line 986 of file CMathObject.cpp.

References compileExpression(), CMath::Discontinuous, CMath::EventAssignment, mIsInitialValue, mpExpression, and mValueType.

Referenced by compileInitialValue(), compileRate(), compileValue(), and setExpression().

 {
   assert(pExpression != NULL);
 
   bool success = true;
 
   bool ReplaceDiscontinousNodes =
     !mIsInitialValue &&
     mValueType != CMath::Discontinuous &&
     mValueType != CMath::EventAssignment;
 
   mpExpression = new CMathExpression(*pExpression, container, ReplaceDiscontinousNodes);
   compileExpression();
 
   return success;
 }

bool CMathObject::createExtensiveODERateExpression	(	const CMetab *	pSpecies,
		CMathContainer &	container
	)

private

Create and compile an expression for an extensive rate of a species determined by an ODE.

Parameters

const	CMetab * pSpecies
CMathContainer	& container

Returns: bool success

Definition at line 1124 of file CMathObject.cpp.

References compileExpression(), CCopasiObject::getCN(), CMetab::getCompartment(), CModelEntity::getExpression(), CMathContainer::getModel(), CModel::getQuantity2NumberFactor(), CModelEntity::getValueReference(), mIsInitialValue, mpExpression, and CExpression::setInfix().

Referenced by compileRate().

 {
   bool success = true;
 
   /*
     mRate = mpModel->getQuantity2NumberFactor() *
       mpCompartment->getValue() * mpExpression->calcValue();
    */
 
   std::ostringstream Infix;
   Infix.imbue(std::locale::classic());
   Infix.precision(16);
 
   Infix << container.getModel().getQuantity2NumberFactor();
   Infix << "*<";
   Infix << pSpecies->getCompartment()->getValueReference()->getCN();
   Infix << ">*";
   Infix << pSpecies->getExpression();
 
   CExpression E("ExtensiveODERateExpression", &container);
 
   success &= E.setInfix(Infix.str());
 
   mpExpression = new CMathExpression(E, container, !mIsInitialValue);
   compileExpression();
 
   return success;
 }

bool CMathObject::createExtensiveReactionRateExpression	(	const CMetab *	pSpecies,
		CMathContainer &	container
	)

private

Create and compile an expression for an extensive rate of a species determined by reactions

Parameters

const	CMetab * pSpecies
CMathContainer	& container

Returns: bool success

Definition at line 1154 of file CMathObject.cpp.

References CCopasiVector< T >::begin(), C_FLOAT64, compileExpression(), CCopasiVector< T >::end(), CModelEntity::getKey(), CMathContainer::getModel(), CModel::getReactions(), mIsInitialValue, mpExpression, and CExpression::setInfix().

Referenced by compileRate().

 {
   bool success = true;
 
   std::ostringstream Infix;
   Infix.imbue(std::locale::classic());
   Infix.precision(16);
 
   std::string Key = pSpecies->getKey();
   bool First = true;
 
   CCopasiVectorN< CReaction >::const_iterator it = container.getModel().getReactions().begin();
   CCopasiVectorN< CReaction >::const_iterator end = container.getModel().getReactions().end();
 
   for (; it != end; ++it)
     {
       const CCopasiVector< CChemEqElement > &Balances =
         (*it)->getChemEq().getBalances();
       CCopasiVector< CChemEqElement >::const_iterator itChem = Balances.begin();
       CCopasiVector< CChemEqElement >::const_iterator endChem = Balances.end();
 
       for (; itChem != endChem; ++itChem)
         if ((*itChem)->getMetaboliteKey() == Key)
           break;
 
       if (itChem != endChem)
         {
           const C_FLOAT64 & Multiplicity = (*itChem)->getMultiplicity();
 
           if (First || Multiplicity < 0.0)
             {
               if (Multiplicity == std::numeric_limits< C_FLOAT64 >::infinity())
                 {
                   Infix << "infinity";
                 }
               else if (Multiplicity == -std::numeric_limits< C_FLOAT64 >::infinity())
                 {
                   Infix << "-infinity";
                 }
               else
                 {
                   Infix << Multiplicity;
                 }
             }
           else
             {
               if (Multiplicity == std::numeric_limits< C_FLOAT64 >::infinity())
                 {
                   Infix << "+infinity";
                 }
               else
                 {
                   Infix << "+" << Multiplicity;
                 }
             }
 
           First = false;
 
           Infix << "*<";
           Infix << (*it)->getParticleFluxReference()->getCN();
           Infix << ">";
         }
     }
 
   CExpression E("ExtensiveReactionExpression", &container);
 
   success &= E.setInfix(Infix.str());
 
   mpExpression = new CMathExpression(E, container, !mIsInitialValue);
   compileExpression();
 
   return success;
 }

bool CMathObject::createExtensiveValueExpression	(	const CMetab *	pSpecies,
		CMathContainer &	container
	)

private

Create and compile an expression for an extensive value of a species.

Parameters

const	CMetab * pSpecies
CMathContainer	& container

Returns: bool success

Definition at line 1045 of file CMathObject.cpp.

References compileExpression(), CObjectInterface::getCN(), CMetab::getCompartment(), CMetab::getConcentrationReference(), CMetab::getInitialConcentrationReference(), CModelEntity::getInitialValueReference(), CMathContainer::getModel(), CModel::getQuantity2NumberFactor(), CModelEntity::getValueReference(), mIsInitialValue, mpExpression, and CExpression::setInfix().

Referenced by compileInitialValue(), and compileValue().

 {
   bool success = true;
 
   // mConc * mpCompartment->getValue() * mpModel->getQuantity2NumberFactor();
 
   CObjectInterface * pDensity = NULL;
   CObjectInterface * pCompartment = NULL;
 
   if (mIsInitialValue)
     {
       pDensity = pSpecies->getInitialConcentrationReference();
       pCompartment = pSpecies->getCompartment()->getInitialValueReference();
     }
   else
     {
       pDensity = pSpecies->getConcentrationReference();
       pCompartment = pSpecies->getCompartment()->getValueReference();
     }
 
   std::ostringstream Infix;
   Infix.imbue(std::locale::classic());
   Infix.precision(16);
 
   Infix << container.getModel().getQuantity2NumberFactor();
   Infix << "*<";
   Infix << pDensity->getCN();
   Infix << ">*<";
   Infix << pCompartment->getCN();
   Infix << ">";
 
   CExpression E("ExtensiveValueExpression", &container);
 
   success &= E.setInfix(Infix.str());
 
   mpExpression = new CMathExpression(E, container, !mIsInitialValue);
   compileExpression();
 
   return success;
 }

bool CMathObject::createIntensiveRateExpression	(	const CMetab *	pSpecies,
		CMathContainer &	container
	)

private

Create and compile an expression for an intensive rate of a species.

Parameters

const	CMetab * pSpecies
CMathContainer	& container

Returns: bool success

Definition at line 1087 of file CMathObject.cpp.

References compileExpression(), CCopasiObject::getCN(), CMetab::getCompartment(), CMathContainer::getModel(), CModel::getNumber2QuantityFactor(), CModelEntity::getRateReference(), CModelEntity::getValueReference(), mIsInitialValue, mpExpression, and CExpression::setInfix().

Referenced by compileRate().

 {
   bool success = true;
 
   /*
     mConcRate =
       (mRate * mpModel->getNumber2QuantityFactor() - mConc * mpCompartment->getRate())
       / mpCompartment->getValue();
    */
 
   std::ostringstream Infix;
   Infix.imbue(std::locale::classic());
   Infix.precision(16);
 
   Infix << "(<";
   Infix << pSpecies->getRateReference()->getCN();
   Infix << ">*";
   Infix << container.getModel().getNumber2QuantityFactor();
   Infix << "-<";
   Infix << pSpecies->getCompartment()->getValueReference()->getCN();
   Infix << ">*<";
   Infix << pSpecies->getCompartment()->getRateReference()->getCN();
   Infix << ">)/<";
   Infix << pSpecies->getCompartment()->getValueReference()->getCN();
   Infix << ">";
 
   CExpression E("IntensiveRateExpression", &container);
 
   success &= E.setInfix(Infix.str());
 
   mpExpression = new CMathExpression(E, container, !mIsInitialValue);
   compileExpression();
 
   return success;
 }

bool CMathObject::createIntensiveValueExpression	(	const CMetab *	pSpecies,
		CMathContainer &	container
	)

private

Create and compile an expression for an intensive value of a species.

Parameters

const	CMetab * pSpecies
CMathContainer	& container

Returns: bool success

Definition at line 1004 of file CMathObject.cpp.

References compileExpression(), CObjectInterface::getCN(), CMetab::getCompartment(), CModelEntity::getInitialValueReference(), CMathContainer::getModel(), CModel::getNumber2QuantityFactor(), CModelEntity::getValueReference(), mIsInitialValue, mpExpression, and CExpression::setInfix().

Referenced by compileInitialValue(), and compileValue().

 {
   bool success = true;
 
   // mConc = *mpValue / mpCompartment->getValue() * mpModel->getNumber2QuantityFactor();
   CObjectInterface * pNumber = NULL;
   CObjectInterface * pCompartment = NULL;
 
   if (mIsInitialValue)
     {
       pNumber = pSpecies->getInitialValueReference();
       pCompartment = pSpecies->getCompartment()->getInitialValueReference();
     }
   else
     {
       pNumber = pSpecies->getValueReference();
       pCompartment = pSpecies->getCompartment()->getValueReference();
     }
 
   std::ostringstream Infix;
   Infix.imbue(std::locale::classic());
   Infix.precision(16);
 
   Infix << container.getModel().getNumber2QuantityFactor();
   Infix << "*<";
   Infix << pNumber->getCN();
   Infix << ">/<";
   Infix << pCompartment->getCN();
   Infix << ">";
 
   CExpression E("IntensiveValueExpression", &container);
 
   success &= E.setInfix(Infix.str());
 
   mpExpression = new CMathExpression(E, container, !mIsInitialValue);
   compileExpression();
 
   return success;
 }

CCopasiObjectName CMathObject::getCN ( ) const

virtual

Retrieve the CN of the object

Returns: CCopasiObjectName

Implements CObjectInterface.

Definition at line 108 of file CMathObject.cpp.

References CCopasiObject::getCN(), and mpDataObject.

Referenced by calculate(), and operator<<().

 {
   if (mpDataObject == NULL)
     return CCopasiObjectName("");
 
   return mpDataObject->getCN();
 }

const CCopasiObject * CMathObject::getDataObject ( ) const

Retrieve the pointer to the data object

Returns: const CCopasiObject * pDataObject

Definition at line 291 of file CMathObject.cpp.

References mpDataObject.

Referenced by CEvaluationTree::compileNodes(), CMathContainer::fetchInitialState(), CMathContainer::fetchState(), CMathDependencyGraph::getDOTNodeId(), CEvaluationNodeObject::getMMLString(), CMathContainer::pushInitialState(), and CMathContainer::pushState().

 {
   return mpDataObject;
 }

const CMath::EntityType & CMathObject::getEntityType ( ) const

Retrieve the entity type

Returns: const CMath::EntityType & entityType

Definition at line 301 of file CMathObject.cpp.

References mEntityType.

Referenced by CMathContainer::createSynchronizeInitialValuesSequence().

 {
   return mEntityType;
 }

const CMathExpression * CMathObject::getExpressionPtr ( ) const

Retrieve a pointer to the math expression.

Returns: const CMathExpression * pExpression

Definition at line 375 of file CMathObject.cpp.

References mpExpression.

 {
   return mpExpression;
 }

const CObjectInterface * CMathObject::getObject ( const CCopasiObjectName & cn ) const

virtual

Retrieve a descendant object by its CN.

Parameters

const CCopasiObjectName & cn

Returns: const CObjectInterface * pObject

Implements CObjectInterface.

Definition at line 117 of file CMathObject.cpp.

References CCopasiObject::getObject(), and mpDataObject.

 {
   if (mpDataObject == NULL)
     return NULL;
 
   const CObjectInterface * pObject = mpDataObject->getObject(cn);
 
   if (pObject != mpDataObject)
     return pObject;
 
   return this;
 }

const CObjectInterface::ObjectSet & CMathObject::getPrerequisites ( ) const

virtual

Retrieve the prerequisites, i.e., the objects which need to be evaluated before this.

Returns: const CObjectInterface::ObjectSet & prerequisites

Implements CObjectInterface.

Definition at line 131 of file CMathObject.cpp.

References mPrerequisites.

Referenced by copy().

 {
   return mPrerequisites;
 }

const CMath::SimulationType & CMathObject::getSimulationType ( ) const

Retrieve the simulation type

Returns: const CMath::SimulationType & simulationType

Definition at line 306 of file CMathObject.cpp.

References mSimulationType.

Referenced by CMathDependencyNode::buildUpdateSequence(), and CMathContainer::createUpdateSimulationValuesSequence().

 {
   return mSimulationType;
 }

void * CMathObject::getValuePointer ( ) const

virtual

Retrieve a pointer to the value of the object

Implements CObjectInterface.

Definition at line 258 of file CMathObject.cpp.

References mpValue.

Referenced by compileDependentMass(), CMathExpression::createNodeFromValue(), CMathContainer::createNodeFromValue(), CMathReaction::initialize(), and CMathContainer::replaceDiscontinuousNode().

 {
   return mpValue;
 }

const CMath::ValueType & CMathObject::getValueType ( ) const

Retrieve the value type

Returns: const CMath::ValueType & valueType

Definition at line 296 of file CMathObject.cpp.

References mValueType.

Referenced by CMathDependencyNode::buildUpdateSequence(), and CMathDependencyGraph::getDOTNodeId().

 {
   return mValueType;
 }

void CMathObject::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
	)

static

Initialize a single mathematical object and advance relevant pointers

Parameters

CMathObject	*& pObject
C_FLOAT64	*& pValue
const	CMath::Value & valueType
const	CMath::EntityType & entityType
const	CMath::SimulationType & simulationType
const	bool & isIntensiveProperty
const	bool & isInitialValue
const	CCopasiObject * pDataObject

Definition at line 23 of file CMathObject.cpp.

References isInitialValue(), isIntensiveProperty(), mEntityType, mIsInitialValue, mIsIntensiveProperty, mpDataObject, mpValue, mSimulationType, and mValueType.

Referenced by CMathEventN::CAssignment::initialize(), CMathEventN::CTrigger::CRoot::initialize(), CMathEventN::CTrigger::initialize(), CMathEventN::initialize(), CMathContainer::initializeMathObjects(), and CMathContainer::initializeObjects().

 {
   pObject->mpValue = pValue;
   pObject->mValueType = valueType;
   pObject->mEntityType = entityType;
   pObject->mSimulationType = simulationType;
   pObject->mIsIntensiveProperty = isIntensiveProperty;
   pObject->mIsInitialValue = isInitialValue;
   pObject->mpDataObject = pDataObject;
 
   pObject++;
   pValue++;
 }

const bool & CMathObject::isInitialValue ( ) const

Check whether the object is an initial value

Returns: const bool & isInitialValue

Definition at line 321 of file CMathObject.cpp.

References mIsInitialValue.

Referenced by initialize().

 {
   return mIsInitialValue;
 }

const bool & CMathObject::isIntensiveProperty ( ) const

Check whether the object is an intensive property

Returns: const bool & isIntensiveProperty

Definition at line 316 of file CMathObject.cpp.

References mIsIntensiveProperty.

Referenced by CMathContainer::createSynchronizeInitialValuesSequence(), and initialize().

 {
   return mIsIntensiveProperty;
 }

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

virtual

Check whether a given object is a prerequisite for a context.

Parameters

const	CObjectInterface * pObject
const	CMath::SimulationContextFlag & context
const	CObjectInterface::ObjectSet & changedObjects

Returns: bool isPrerequisiteForContext

Implements CObjectInterface.

Definition at line 137 of file CMathObject.cpp.

References CMath::Assignment, CEvaluationNodeFunction::CEIL, CEvaluationNode::CHOICE, CMath::Dependent, CMath::DependentMass, CMath::Discontinuous, CMath::Event, CMath::EventHandling, CMath::EventTrigger, CEvaluationNodeFunction::FLOOR, CEvaluationNode::FUNCTION, CEvaluationTree::getRoot(), CEvaluationNode::getType(), CEvaluationNodeChoice::IF, mEntityType, mIsIntensiveProperty, CMath::Moiety, mpExpression, mpIntensiveProperty, mPrerequisites, mSimulationType, mValueType, CMath::Species, CMath::TotalMass, CMath::UpdateMoieties, CMath::UseMoieties, and CMath::Value.

 {
   // This method should only be called for objects which are prerequisites.
   // We check for this only in debug mode.
   assert(mPrerequisites.find(pObject) != mPrerequisites.end());
 
   switch (mEntityType)
     {
       case CMath::Moiety:
 
         if ((context & CMath::UpdateMoieties) &&
             mValueType == CMath::TotalMass)
           {
             return true;
           }
 
         if ((context & CMath::UseMoieties) &&
             mValueType == CMath::DependentMass)
           {
             return true;
           }
 
         return false;
         break;
 
       case CMath::Species:
 
         // For species we need to account for the duality of the intensive and extensive value
         if (mValueType != CMath::Value)
           return true;
 
         if ((context & CMath::UseMoieties) &&
             mSimulationType == CMath::Dependent &&
             !mIsIntensiveProperty)
           {
             if (mpIntensiveProperty != pObject)
               {
                 return true;
               }
 
             return false;
           }
 
         // If the value is in the context, it does not depend on the object.
         if (changedObjects.find(this) != changedObjects.end())
           return false;
 
         if (mIsIntensiveProperty)
           {
             // Densities which are not in the context have to be recalculated.
             return true;
           }
         else
           {
             // Amount which are determine by assignment need to be recalculated.
             if (mSimulationType == CMath::Assignment)
               return true;
 
             // If the concentration was changed in the context we need to recalculate.
             if (changedObjects.find(mpIntensiveProperty) != changedObjects.end())
               return true;
 
             return false;
           }
 
         break;
 
       case CMath::Event:
 
         if ((context & CMath::EventHandling) &&
             mValueType == CMath::Discontinuous)
           {
             switch ((int) mpExpression->getRoot()->getType())
               {
                 case(CEvaluationNode::CHOICE | CEvaluationNodeChoice::IF):
                 {
                   const CMathObject * pMathObject = dynamic_cast< const CMathObject * >(pObject);
 
                   if (pMathObject != NULL &&
                       pMathObject->mValueType == CMath::EventTrigger)
                     {
                       return false;
                     }
 
                   return true;
                 }
                 break;
 
                 case(CEvaluationNode::FUNCTION | CEvaluationNodeFunction::FLOOR):
                   return false;
                   break;
 
                 case(CEvaluationNode::FUNCTION | CEvaluationNodeFunction::CEIL):
                   return false;
                   break;
 
                 default:
                   return true;
               }
           }
 
         return true;
         break;
 
       default:
         return true;
     }
 
   // This should never be reached.
   return true;
 }

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

virtual

This is the output method for any object. The default implementation provided with CCopasiObject uses the ostream operator<< of the object to print the object.To override this default behavior one needs to reimplement the virtual print function.

Parameters

std::ostream * ostream

Implements CObjectInterface.

Definition at line 252 of file CMathObject.cpp.

References mpValue.

 {
   (*ostream) << *mpValue;
 }

bool CMathObject::setExpression	(	const std::string &	infix,
		const bool &	isBoolean,
		CMathContainer &	container
	)

Set the expression's infix and compile the object.

Parameters

const	std::string & infix,
const	bool & isBoolean,
CMathContainer	& container

Returns: bool success

Definition at line 326 of file CMathObject.cpp.

References CExpression::compile(), CExpression::setInfix(), and CExpression::setIsBoolean().

Referenced by CMathEventN::compile(), CMathEventN::setDelayExpression(), and CMathEventN::setPriorityExpression().

 {
   bool success = true;
   CExpression Expression;
   Expression.setIsBoolean(isBoolean);
 
   success &= Expression.setInfix(infix);
   std::vector< CCopasiContainer * > ListOfContainer;
   ListOfContainer.push_back(&container);
   success &= Expression.compile(ListOfContainer);
   success &= setExpression(Expression, container);
 
   return success;
 }

bool CMathObject::setExpression	(	const CExpression &	expression,
		CMathContainer &	container
	)

Set the expression and compile the object.

Parameters

const	CExpression & expression,
CMathContainer	& container

Returns: bool success

Definition at line 343 of file CMathObject.cpp.

References createConvertedExpression().

 {
   bool success = true;
 
   success &= createConvertedExpression(&expression, container);
 
   return success;
 }

bool CMathObject::setExpressionPtr ( CMathExpression * pMathExpression )

Set the expression and compile the object.

Parameters

CMathExpression * pMathExpression,

Returns: bool success

Definition at line 353 of file CMathObject.cpp.

References CMathExpression::compile(), compileExpression(), mpExpression, mPrerequisites, and pdelete.

Referenced by CMathContainer::replaceDiscontinuousNode().

 {
   bool success = true;
 
   pdelete(mpExpression);
   mPrerequisites.clear();
 
   mpExpression = pMathExpression;
 
   if (mpExpression != NULL)
     {
       success &= mpExpression->compile();
       compileExpression();
     }
   else
     {
       success = false;
     }
 
   return success;
 }

void CMathObject::setSimulationType ( const CMath::SimulationType & simulationType )

Set the simulation type

Parameters

const CMath::SimulationType & simulationType

Definition at line 311 of file CMathObject.cpp.

References mSimulationType.

Referenced by CMathEventN::CAssignment::compile().

 {
   mSimulationType = simulationType;
 }

Friends And Related Function Documentation

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

friend

Definition at line 1229 of file CMathObject.cpp.

 {
   if (o.mpDataObject != NULL)
     {
       os << o.mpDataObject->getCN() << std::endl;
     }
   else
     {
       os << "Data Object = NULL" << std::endl;
     }
 
   os << "  Pointer:               " << &o << std::endl;
   os << "  Value Type:            ";
 
   switch (o.mValueType)
     {
       case CMath::ValueTypeUndefined:
         os << "ValueTypeUndefined" << std::endl;
         break;
 
       case CMath::Value:
         os << "Value" << std::endl;
         break;
 
       case CMath::Rate:
         os << "ValueRate" << std::endl;
         break;
 
       case CMath::ParticleFlux:
         os << "ParticleFlux" << std::endl;
         break;
 
       case CMath::Flux:
         os << "Flux" << std::endl;
         break;
 
       case CMath::Propensity:
         os << "Propensity" << std::endl;
         break;
 
       case CMath::TotalMass:
         os << "TotalMass" << std::endl;
         break;
 
       case CMath::DependentMass:
         os << "DependentMass" << std::endl;
         break;
 
       case CMath::Discontinuous:
         os << "Discontinuous" << std::endl;
         break;
 
       case CMath::EventDelay:
         os << "EventDelay" << std::endl;
         break;
 
       case CMath::EventPriority:
         os << "EventPriority" << std::endl;
         break;
 
       case CMath::EventAssignment:
         os << "EventAssignment" << std::endl;
         break;
 
       case CMath::EventTrigger:
         os << "EventTrigger" << std::endl;
         break;
 
       case CMath::EventRoot:
         os << "EventRoot" << std::endl;
         break;
 
       case CMath::EventRootState:
         os << "EventRootState" << std::endl;
         break;
     }
 
   os << "  Simulation Type:       ";
 
   switch (o.mSimulationType)
     {
       case CMath::SimulationTypeUndefined:
         os << "SimulationTypeUndefined" << std::endl;
         break;
 
       case CMath::Fixed:
         os << "Fixed" << std::endl;
         break;
 
       case CMath::EventTarget:
         os << "EventTarget" << std::endl;
         break;
 
       case CMath::Time:
         os << "Time" << std::endl;
         break;
 
       case CMath::ODE:
         os << "ODE" << std::endl;
         break;
 
       case CMath::Independent:
         os << "Independent" << std::endl;
         break;
 
       case CMath::Dependent:
         os << "Dependent" << std::endl;
         break;
 
       case CMath::Assignment:
         os << "Assignment" << std::endl;
         break;
 
       case CMath::Conversion:
         os << "Conversion" << std::endl;
         break;
     };
 
   os << "  Entity Type:           ";
 
   switch (o.mEntityType)
     {
       case CMath::EntityTypeUndefined:
         os << "EntityTypeUndefined" << std::endl;
         break;
 
       case CMath::Model:
         os << "Model" << std::endl;
         break;
 
       case CMath::Analysis:
         os << "Analysis" << std::endl;
         break;
 
       case CMath::GlobalQuantity:
         os << "GlobalQuantity" << std::endl;
         break;
 
       case CMath::Compartment:
         os << "Compartment" << std::endl;
         break;
 
       case CMath::Species:
         os << "Species" << std::endl;
         break;
 
       case CMath::LocalReactionParameter:
         os << "LocalReactionParameter" << std::endl;
         break;
 
       case CMath::StoichiometricCoefficients:
         os << "StoichiometricCoefficients" << std::endl;
         break;
 
       case CMath::Reaction:
         os << "Reaction" << std::endl;
         break;
 
       case CMath::Moiety:
         os << "Moiety" << std::endl;
         break;
 
       case CMath::Event:
         os << "Event" << std::endl;
         break;
     };
 
   os << "  Is Intensive Property: " << (o.mIsIntensiveProperty ? "true" : "false") << std::endl;
 
   os << "  Is Initial Value:      " << (o.mIsInitialValue ? "true" : "false") << std::endl;
 
   os << "  Intensive Property:    ";
 
   if (o.mpIntensiveProperty != NULL)
     {
       os << o.mpIntensiveProperty->getCN() << std::endl;
     }
   else
     {
       os << "NULL" << std::endl;
     }
 
   os << "  Value:                 " << *o.mpValue << " (" << o.mpValue << ")" << std::endl;
 
   os << "  Expression:            ";
 
   if (o.mpExpression != NULL)
     {
       os << o.mpExpression->getRoot()->buildInfix() << std::endl;
     }
   else
     {
       os << "NULL" << std::endl;
     }
 
   // CObjectInterface::ObjectSet mPrerequisites;
 
   return os;
 }