CModelParameter Class Reference

#include <CModelParameter.h>

Inheritance diagram for CModelParameter:

Collaboration diagram for CModelParameter:

Public Types
enum	CompareResult {   Obsolete, Missing, Modified, Conflict,   Identical }
enum	Framework { Concentration = 0, ParticleNumbers }
enum	Type {   Model, Compartment, Species, ModelValue,   ReactionParameter, Reaction, Group, Set,   unknown }

Public Member Functions
	CModelParameter (CModelParameterGroup *pParent, const CModelParameter::Type &type)
	CModelParameter (const CModelParameter &src, CModelParameterGroup *pParent)
virtual void	compile ()
virtual const CompareResult &	diff (const CModelParameter &other, const CModelParameter::Framework &framework=ParticleNumbers, const bool &createMissing=false)
virtual const CModelParameter *	getChild (const size_t &index) const
const CCopasiObjectName &	getCN () const
const CompareResult &	getCompareResult () const
size_t	getIndex () const
std::string	getInitialExpression () const
const CExpression *	getInitialExpressionPtr () const
CModel *	getModel () const
virtual std::string	getName () const
virtual size_t	getNumChildren () const
CCopasiObject *	getObject () const
CModelParameterGroup *	getParent () const
CModelParameterSet *	getSet () const
const CModelEntity::Status &	getSimulationType () const
const Type &	getType () const
const std::string	getUnit (const Framework &framework) const
virtual const double &	getValue (const Framework &framework) const
bool	isInitialExpressionValid () const
bool	isReadOnly () const
virtual bool	refreshFromModel (const bool &modifyExistence)
virtual void	setCN (const CCopasiObjectName &cn)
void	setCompareResult (const CompareResult &compareResult)
void	setInitialExpression (const std::string &initialExpression)
void	setParent (CModelParameterGroup *pParent)
bool	setSimulationType (const CModelEntity::Status &simulationType)
virtual void	setValue (const double &value, const Framework &framework)
virtual bool	updateModel ()
virtual	~CModelParameter ()

Static Public Attributes
static const char *	TypeNames []

Static Protected Member Functions
static std::string	nameFromCN (const CCopasiObjectName &cn)

Protected Attributes
CRegisteredObjectName	mCN
CompareResult	mCompareResult
bool	mIsInitialExpressionValid
CExpression *	mpInitialExpression
CCopasiObject *	mpObject
CModelParameterGroup *	mpParent
CModelEntity::Status	mSimulationType
Type	mType
double	mValue

Private Member Functions
	CModelParameter ()

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

Detailed Description

Definition at line 21 of file CModelParameter.h.

Member Enumeration Documentation

enum CModelParameter::CompareResult

Enumerator
Obsolete
Missing
Modified
Conflict
Identical

Definition at line 41 of file CModelParameter.h.

  {
    Obsolete,
    Missing,
    Modified,
    Conflict,
    Identical
  };

enum CModelParameter::Framework

Enumerator
Concentration
ParticleNumbers

Definition at line 50 of file CModelParameter.h.

  {
    Concentration = 0,
    ParticleNumbers
  };

enum CModelParameter::Type

Enumerator
Model
Compartment
Species
ModelValue
ReactionParameter
Reaction
Group
Set
unknown

Definition at line 26 of file CModelParameter.h.

  {
    Model,
    Compartment,
    Species,
    ModelValue,
    ReactionParameter,
    Reaction,
    Group,
    Set,
    unknown
  };

Constructor & Destructor Documentation

CModelParameter::CModelParameter ( )

private

The default constructor is hidden.

Referenced by CModelParameterGroup::add(), and CModelParameterGroup::copy().

CModelParameter::CModelParameter	(	CModelParameterGroup *	pParent,
		const CModelParameter::Type &	type
	)

Constructor

Definition at line 60 of file CModelParameter.cpp.

References mpParent, mType, and Set.

                                                                                                :
  mpParent(static_cast< CModelParameterGroup * >(pParent)),
  mType(type),
  mCN(),
  mSimulationType(type == CModelParameter::Model ? CModelEntity::TIME : CModelEntity::FIXED),
  mValue(std::numeric_limits< C_FLOAT64 >::quiet_NaN()),
  mpInitialExpression(NULL),
  mCompareResult(CModelParameter::Identical),
  mpObject(NULL),
  mIsInitialExpressionValid(true)
{
  assert(mType == Set || mpParent != NULL);
}

CModelParameter::CModelParameter	(	const CModelParameter &	src,
		CModelParameterGroup *	pParent
	)

Copy constructor

Definition at line 74 of file CModelParameter.cpp.

References getInitialExpression(), mpParent, mType, Set, and setInitialExpression().

                                                                                           :
  mpParent(pParent),
  mType(src.mType),
  mCN(src.mCN),
  mSimulationType(src.mSimulationType),
  mValue(src.mValue),
  mpInitialExpression(NULL),
  mCompareResult(src.mCompareResult),
  mpObject(src.mpObject),
  mIsInitialExpressionValid(src.mIsInitialExpressionValid)
{
  assert(mType == Set || mpParent != NULL);

  setInitialExpression(src.getInitialExpression());
}

CModelParameter::~CModelParameter ( )

virtual

Destructor

Definition at line 91 of file CModelParameter.cpp.

References mpParent, and CModelParameterGroup::remove().

{
  if (mpParent != NULL)
    {
      mpParent->remove(this);
    }
}

Member Function Documentation

void CModelParameter::compile ( )

virtual

Compile the parameter

Reimplemented in CModelParameterReactionParameter, CModelParameterSpecies, and CModelParameterGroup.

Definition at line 391 of file CModelParameter.cpp.

References Compartment, CExpression::compile(), getModel(), CCopasiObject::getObjectDataModel(), mCN, mIsInitialExpressionValid, Model, ModelValue, mpInitialExpression, mpObject, mType, CCopasiDataModel::ObjectFromName(), ReactionParameter, Species, and unknown.

Referenced by CModelParameterGroup::compile(), CModelParameterSpecies::compile(), and CModelParameterReactionParameter::compile().

{
  mpObject = NULL;
  mIsInitialExpressionValid = true;

  CModel * pModel = getModel();

  assert(pModel != NULL);

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

  mpObject = pModel->getObjectDataModel()->ObjectFromName(ListOfContainer, mCN);

  if (mpObject != NULL)
    {
      if (mType == unknown)
        {
          if (dynamic_cast< CModel * >(mpObject) != NULL)
            mType = Model;
          else if (dynamic_cast< CCompartment * >(mpObject) != NULL)
            mType = Compartment;
          else if (dynamic_cast< CMetab * >(mpObject) != NULL)
            mType = Species;
          else if (dynamic_cast< CModelValue * >(mpObject) != NULL)
            mType = ModelValue;
          else if (dynamic_cast< CCopasiParameter * >(mpObject) != NULL)
            mType = ReactionParameter;
        }
    }

  if (mpInitialExpression != NULL)
    {
      mIsInitialExpressionValid = mpInitialExpression->compile();
    }
}

const CModelParameter::CompareResult & CModelParameter::diff ( const CModelParameter &  other, const CModelParameter::Framework &  framework = ParticleNumbers, const bool &  createMissing = false  )

virtual

Compare the parameter to an other

Parameters

const	CModelParameter & other
const	CModelParameter::Framework & framework (default: ParticleNumbers)
const	bool & createMissing = false

Reimplemented in CModelParameterGroup.

Definition at line 428 of file CModelParameter.cpp.

References CModelEntity::ASSIGNMENT, Compartment, Conflict, getInitialExpression(), getObject(), getValue(), Identical, mCompareResult, Missing, ModelValue, Modified, mpObject, mType, Obsolete, ParticleNumbers, and Species.

{
  if (mCompareResult == Missing ||
      mCompareResult == Obsolete)
    {
      return mCompareResult;
    }

  switch (mType)
    {
      case Compartment:
      case Species:
      case ModelValue:

        if (other.getObject() != NULL &&
            mpObject != NULL &&
            static_cast< CModelEntity *>(mpObject)->getStatus() == CModelEntity::ASSIGNMENT &&
            (fabs(getValue(ParticleNumbers) - other.getValue(ParticleNumbers)) > 50 * (fabs(getValue(ParticleNumbers)) + fabs(other.getValue(ParticleNumbers))) * std::numeric_limits< C_FLOAT64 >::epsilon() ||
             getInitialExpression() != ""))
          {
            mCompareResult = Conflict;
            return mCompareResult;
          }

        break;

      default:
        break;
    }

  if (getInitialExpression() != other.getInitialExpression() ||
      fabs(getValue(framework) - other.getValue(framework)) > 50 * (fabs(getValue(framework)) + fabs(other.getValue(framework))) * std::numeric_limits< C_FLOAT64 >::epsilon())
    {
      mCompareResult = Modified;
    }
  else
    {
      mCompareResult = Identical;
    }

  return mCompareResult;
}

const CModelParameter * CModelParameter::getChild ( const size_t &  index ) const

virtual

Reimplemented in CModelParameterGroup.

Definition at line 673 of file CModelParameter.cpp.

Referenced by applyValueToModelParameter().

{
  return NULL;
}

const CCopasiObjectName & CModelParameter::getCN

(

)

const

Retrieve the CN of the object represented by the parameter

Returns

const CCopasiObjectName & cn

Definition at line 199 of file CModelParameter.cpp.

References mCN.

Referenced by applyValueToModelParameter(), CModelParameterReactionParameter::compile(), CModelParameterSet::createFromModel(), CCopasiXML::saveModelParameter(), and CQParameterOverviewDM::setData().

{
  return mCN;
}

const CModelParameter::CompareResult & CModelParameter::getCompareResult

(

)

const

Retrieve the compare result.

Returns

const CompareResult & compareResult

Definition at line 302 of file CModelParameter.cpp.

References mCompareResult.

Referenced by CQParameterOverviewDM::diffData(), CQParameterOverviewDM::flags(), and CCopasiXML::saveModelParameter().

{
  return mCompareResult;
}

size_t CModelParameter::getIndex

(

)

const

Retrieve the index of the parameter in the vector of children in the parent

Returns

size_t index

Definition at line 307 of file CModelParameter.cpp.

References CModelParameterGroup::begin(), C_INVALID_INDEX, CModelParameterGroup::end(), and mpParent.

{
  CModelParameterGroup::const_iterator it = mpParent->begin();
  CModelParameterGroup::const_iterator end = mpParent->end();

  size_t Index = 0;

  for (; it != end; ++it, ++Index)
    {
      if (*it == this) return Index;
    }

  return C_INVALID_INDEX;
}

std::string CModelParameter::getInitialExpression

(

)

const

Retrieve the initial expression infix.

Returns

std::string initialExpression

Definition at line 287 of file CModelParameter.cpp.

References CEvaluationTree::getInfix(), and mpInitialExpression.

Referenced by CQParameterOverviewDM::assignmentData(), CModelParameter(), CModelParameterReactionParameter::compile(), diff(), isReadOnly(), operator<<(), CCopasiXML::saveModelParameter(), and updateModel().

{
  if (mpInitialExpression == NULL)
    {
      return "";
    }

  return mpInitialExpression->getInfix();
}

const CExpression * CModelParameter::getInitialExpressionPtr

(

)

const

Retrieve the actual initial expression.

Returns

const CExpression* initialExpression

Definition at line 282 of file CModelParameter.cpp.

References mpInitialExpression.

Referenced by CQParameterOverviewDM::assignmentData().

{
  return mpInitialExpression;
}

CModel * CModelParameter::getModel

(

)

const

Retrieve a pointer to the model the parameter is part of

Returns

CModel * pModel

Definition at line 363 of file CModelParameter.cpp.

References CModelParameterSet::getModel(), and getSet().

Referenced by compile(), CModelParameterReactionParameter::compile(), getUnit(), isReadOnly(), CModelParameterSpecies::setValue(), and updateModel().

{
  CModelParameterSet * pSet = getSet();

  if (pSet != NULL)
    {
      return pSet->getModel();
    }

  return NULL;
}

std::string CModelParameter::getName ( ) const

virtual

Retrieve the name of the parameter.

Returns

std::string name

Reimplemented in CModelParameterSpecies, and CModelParameterSet.

Definition at line 381 of file CModelParameter.cpp.

References CCopasiObject::getObjectName(), mCN, mpObject, and nameFromCN().

Referenced by CQParameterOverviewDM::assignmentData(), getUnit(), CQParameterOverviewDM::nameData(), refreshFromModel(), and CModelParameterSet::saveToStream().

{
  if (mpObject != NULL)
    {
      return mpObject->getObjectName();
    }

  return nameFromCN(mCN);
}

size_t CModelParameter::getNumChildren ( ) const

virtual

Reimplemented in CModelParameterGroup.

Definition at line 667 of file CModelParameter.cpp.

Referenced by applyValueToModelParameter().

{
  return 0;
}

CCopasiObject * CModelParameter::getObject

(

)

const

Retrieve the pointer to the corresponding model object

Returns

CCopasiObject * pObject

Definition at line 336 of file CModelParameter.cpp.

References mpObject.

Referenced by diff().

{
  return mpObject;
}

CModelParameterGroup * CModelParameter::getParent

(

)

const

Retrieve the parent, i.e., containing group, of the parameter.

Returns

CModelParameterGroup * pParent

Definition at line 104 of file CModelParameter.cpp.

References mpParent.

Referenced by CQParameterOverviewDM::getRow(), getSet(), CQParameterOverviewDM::index(), and CQParameterOverviewDM::parent().

{
  return mpParent;
}

CModelParameterSet * CModelParameter::getSet

(

)

const

Retrieve a pointer to the parameter set the parameter belongs to

Returns

CModelParameterSet * set

Definition at line 341 of file CModelParameter.cpp.

References getParent(), getType(), mpParent, mType, and Set.

Referenced by CQParameterOverviewDM::assignmentData(), CModelParameterSpecies::compile(), CModelParameterReactionParameter::compile(), getModel(), CModelParameterSpecies::getName(), refreshFromModel(), CQParameterOverviewDM::setData(), setInitialExpression(), and setValue().

{
  if (mType == Set)
    {
      return static_cast< CModelParameterSet * >(const_cast< CModelParameter * >(this));
    }

  CModelParameterGroup * pParent = mpParent;

  while (pParent != NULL)
    {
      if (pParent->getType() == Set)
        {
          return static_cast< CModelParameterSet * >(pParent);
        }

      pParent = pParent->getParent();
    }

  return NULL;
}

const CModelEntity::Status & CModelParameter::getSimulationType

(

)

const

Retrieve the role the parameters object plays in the simulation

Returns

const CModelEntity::Status & simulationType

Definition at line 242 of file CModelParameter.cpp.

References mSimulationType.

Referenced by CCopasiXML::saveModelParameter(), and CQParameterOverviewDM::typeData().

{
  return mSimulationType;
}

const CModelParameter::Type & CModelParameter::getType

(

)

const

Retrieve the type of the parameter

Returns

const Type & type

Definition at line 109 of file CModelParameter.cpp.

References mType.

Referenced by CQParameterOverviewDM::assignmentData(), CModelParameterGroup::copy(), CModelParameterGroup::diff(), CQParameterOverviewDM::diffData(), CQParameterOverviewDM::flags(), getSet(), CQParameterOverviewDM::rowCount(), CCopasiXML::saveModelParameter(), CModelParameterSet::saveToStream(), CQParameterOverviewDM::typeData(), and CQParameterOverviewDM::valueData().

{
  return mType;
}

const std::string CModelParameter::getUnit

(

const Framework &

framework

)

const

Retrieve the unit of the parameter based on the current framework

Parameters

const

Framework & framework (default: ParticleNumbers)

Returns

const std::string unit

Definition at line 114 of file CModelParameter.cpp.

References Compartment, Concentration, CModel::dimensionlessArea, CModel::dimensionlessLength, CModel::dimensionlessQuantity, CModel::dimensionlessTime, CModel::dimensionlessVolume, CModel::getAreaUnitEnum(), CReaction::getChemEq(), CCompartment::getChildObjectUnits(), CMetab::getChildObjectUnits(), CReaction::getCompartmentNumber(), CReaction::getFunction(), CMetab::getInitialConcentrationReference(), CModelEntity::getInitialValueReference(), CModel::getLengthUnitEnum(), getModel(), getName(), CReaction::getParameterIndex(), CModel::getQuantityUnitEnum(), CModel::getTimeUnitEnum(), CModel::getTimeUnitsDisplayString(), CModel::getVolumeUnitEnum(), Model, ModelValue, mpObject, mType, ReactionParameter, CFindDimensions::setUseHeuristics(), and Species.

Referenced by CModelParameterSet::saveToStream(), and CQParameterOverviewDM::unitData().

{
  std::string Unit;

  switch (mType)
    {
      case Model:
        return getModel()->getTimeUnitsDisplayString();
        break;

      case Compartment:
      {
        const CCompartment * pCompartment = static_cast< const CCompartment * >(mpObject);

        if (pCompartment == NULL)
          {
            return "";
          }

        return pCompartment->getChildObjectUnits(pCompartment->getInitialValueReference());
      }
      break;

      case Species:
      {
        const CMetab * pSpecies = static_cast< const CMetab * >(mpObject);

        if (pSpecies == NULL)
          {
            return "";
          }

        if (framework == Concentration)
          {
            return pSpecies->getChildObjectUnits(pSpecies->getInitialConcentrationReference());
          }

        return pSpecies->getChildObjectUnits(pSpecies->getInitialValueReference());
      }
      break;

      case ModelValue:
        break;

      case ReactionParameter:
      {
        const CReaction * pReaction = static_cast< const CModelParameterReactionParameter * >(this)->getReaction();

        if (pReaction == NULL)
          {
            return "";
          }

        const CModel * pModel = getModel();

        CFindDimensions Units(pReaction->getFunction(),
                              pModel->getQuantityUnitEnum() == CModel::dimensionlessQuantity,
                              pModel->getVolumeUnitEnum() == CModel::dimensionlessVolume,
                              pModel->getTimeUnitEnum() == CModel::dimensionlessTime,
                              pModel->getAreaUnitEnum() == CModel::dimensionlessArea,
                              pModel->getLengthUnitEnum() == CModel::dimensionlessLength);

        Units.setUseHeuristics(true);

        Units.setChemicalEquation(&pReaction->getChemEq());

        Units.findDimensions(pReaction->getCompartmentNumber() > 1);

        return Units.getDimensions()[pReaction->getParameterIndex(getName())].getDisplayString(pModel);
      }
      break;

      default:
        break;
    }

  return "";
}

const C_FLOAT64 & CModelParameter::getValue ( const Framework &  framework ) const

virtual

Retrieve the value of the parameter based on the current framework

Parameters

const

Framework & framework

Returns

const double & value

Reimplemented in CModelParameterSpecies.

Definition at line 261 of file CModelParameter.cpp.

References mValue.

Referenced by CModelParameterReactionParameter::compile(), diff(), refreshFromModel(), CCopasiXML::saveModelParameter(), CModelParameterSet::saveToStream(), CModelParameterSpecies::setValue(), and CQParameterOverviewDM::valueData().

{
  return mValue;
}

bool CModelParameter::isInitialExpressionValid

(

)

const

Check whether the initial expression is valid, i.e., it compiled

Returns

bool isInitialExpressionValid

Definition at line 375 of file CModelParameter.cpp.

References mIsInitialExpressionValid.

{
  return mIsInitialExpressionValid;
}

bool CModelParameter::isReadOnly

(

)

const

Check whether the value is read only.

Returns

bool isReadOnly

Definition at line 322 of file CModelParameter.cpp.

References getInitialExpression(), getModel(), Group, mIsInitialExpressionValid, Model, mType, Reaction, and Set.

Referenced by CQParameterOverviewDM::flags().

{
  if (mType == Reaction ||
      mType == Group ||
      mType == Set ||
      (mType == Model && getModel()->isAutonomous()) ||
      (mIsInitialExpressionValid && getInitialExpression() != ""))
    {
      return true;
    }

  return false;
}

std::string CModelParameter::nameFromCN ( const CCopasiObjectName &  cn )

staticprotected

Determine the parameter name based on the CN of the corresponding object

Parameters

const

CCopasiObjectName & cn

Returns

std::string name

Definition at line 39 of file CModelParameter.cpp.

References CCopasiObjectName::getElementName(), CCopasiObjectName::getObjectName(), CCopasiObjectName::getPrimary(), and CCopasiObjectName::getRemainder().

Referenced by getName(), and CModelParameterSpecies::getName().

{
  CCopasiObjectName Primary = cn.getPrimary();
  CCopasiObjectName Remainder = cn.getRemainder();

  while (Remainder != "")
    {
      Primary = Remainder.getPrimary();
      Remainder = Remainder.getRemainder();
    }

  std::string Name = Primary.getElementName(0);

  if (Name != "")
    {
      return Name;
    }

  return Primary.getObjectName();
}

bool CModelParameter::refreshFromModel ( const bool &  modifyExistence )

virtual

Refresh the parameter from the corresponding model object

Parameters

const

bool & modifyExistence

Reimplemented in CModelParameterGroup.

Definition at line 561 of file CModelParameter.cpp.

References CModelEntity::ASSIGNMENT, Compartment, CModelEntity::FIXED, CKeyFactory::get(), CModelEntity::getInitialValue(), CCopasiRootContainer::getKeyFactory(), CModelParameterGroup::getModelParameter(), getName(), CReaction::getParameterMapping(), getSet(), getValue(), CCopasiParameter::getValue(), Identical, CModel::isAutonomous(), CReaction::isLocalParameter(), mCompareResult, Missing, Model, ModelValue, mpObject, mSimulationType, mType, mValue, Obsolete, ParticleNumbers, CCopasiParameter::Value::pDOUBLE, ReactionParameter, and Species.

Referenced by CQParameterOverviewWidget::slotResolve().

{
  bool success = true;

  if (modifyExistence)
    {
      if (mCompareResult == CModelParameter::Obsolete)
        {
          delete this;

          return true;
        }

      if (mCompareResult == CModelParameter::Missing)
        {
          mCompareResult = CModelParameter::Identical;
        }

      if (mType != ReactionParameter &&
          mpObject != NULL)
        {
          mSimulationType = static_cast< CModelEntity * >(mpObject)->getStatus();
        }
    }

  if (mpObject != NULL)
    {
      switch (mType)
        {
          case Model:
          {
            CModel * pModel = static_cast< CModel * >(mpObject);

            if (!pModel->isAutonomous())
              {
                mValue = pModel->getInitialValue();
              }
            else
              {
                mValue = 0.0;
              }
          }
          break;

          case Compartment:
          case Species:
          case ModelValue:
          {
            CModelEntity * pEntity = static_cast< CModelEntity * >(mpObject);

            mValue = pEntity->getInitialValue();
          }
          break;

          case ReactionParameter:
          {
            CCopasiParameter * pParameter = static_cast< CCopasiParameter * >(mpObject);
            mValue = * pParameter->getValue().pDOUBLE;

            // We need to update the mapping
            // Check whether this refers to a global quantity.
            const CReaction * pReaction = static_cast< CModelParameterReactionParameter * >(this)->getReaction();

            if (pReaction != NULL)
              {
                if (pReaction->isLocalParameter(getName()))
                  {
                    mSimulationType = CModelEntity::FIXED;
                    static_cast< CModelParameterReactionParameter * >(this)->setGlobalQuantityCN("");
                  }
                else
                  {
                    mSimulationType = CModelEntity::ASSIGNMENT;
                    const std::vector<std::string> ModelValue = pReaction->getParameterMapping(getName());

                    assert(ModelValue.size() == 1);

                    CModelValue * pModelValue = static_cast< CModelValue * >(CCopasiRootContainer::getKeyFactory()->get(ModelValue[0]));
                    static_cast< CModelParameterReactionParameter * >(this)->setGlobalQuantityCN(pModelValue->getInitialValueReference()->getCN());
                  }
              }

            CCopasiObjectName GlobalQuantityCN = static_cast< CModelParameterReactionParameter * >(this)->getGlobalQuantityCN();

            if (GlobalQuantityCN != "")
              {
                CModelParameter * pGlobalQuantity = getSet()->getModelParameter(GlobalQuantityCN);

                if (pGlobalQuantity != NULL)
                  {
                    mValue = pGlobalQuantity->getValue(ParticleNumbers);
                  }
              }
          }
          break;

          default:
            success = false;
            break;
        }
    }

  return success;
}

void CModelParameter::setCN ( const CCopasiObjectName &  cn )

virtual

Set the CN of the object represented by the parameter

Parameters

const

CCopasiObjectName & cn

Reimplemented in CModelParameterSpecies.

Definition at line 194 of file CModelParameter.cpp.

References mCN.

Referenced by CModelParameterSet::createFromModel(), CModelParameterSpecies::setCN(), CCopasiXMLParser::ModelParameterElement::start(), and CCopasiXMLParser::ModelParameterGroupElement::start().

{
  mCN = cn;
}

void CModelParameter::setCompareResult

(

const CompareResult &

compareResult

)

The the compare result.

Parameters

const

CompareResult & compareResult

Definition at line 297 of file CModelParameter.cpp.

References mCompareResult.

Referenced by CModelParameterGroup::diff().

{
  mCompareResult = compareResult;
}

void CModelParameter::setInitialExpression

(

const std::string &

initialExpression

)

Set the initial expression infix.

Parameters

const

std::string & initialExpression

Definition at line 266 of file CModelParameter.cpp.

References getSet(), mpInitialExpression, pdelete, and CExpression::setInfix().

Referenced by CModelParameter(), CModelParameterSet::createFromModel(), CCopasiXMLParser::ModelParameterElement::end(), and CModelParameterReactionParameter::setGlobalQuantityCN().

{
  if (initialExpression == "")
    {
      pdelete(mpInitialExpression);
      return;
    }

  if (mpInitialExpression == NULL)
    {
      mpInitialExpression = new CExpression("InitialExpression", getSet());
    }

  mpInitialExpression->setInfix(initialExpression);
}

void CModelParameter::setParent

(

CModelParameterGroup *

pParent

)

Set the parent, i.e., containing group, of the parameter. Note, it is the responsibility of the user to remove the parameter from the old part.

Parameters

CModelParameterGroup

* pParent

Definition at line 99 of file CModelParameter.cpp.

References mpParent.

{
  mpParent = pParent;
}

bool CModelParameter::setSimulationType

(

const CModelEntity::Status &

simulationType

)

Set the role the parameters object plays in the simulation. Note, REACTION is only valid for species.

Parameters

const

CModelEntity::Status & simulationType

Returns

bool success

Definition at line 204 of file CModelParameter.cpp.

References CModelEntity::ASSIGNMENT, Compartment, CModelEntity::FIXED, Model, ModelValue, mSimulationType, mType, ReactionParameter, CModelEntity::REACTIONS, Species, and CModelEntity::TIME.

Referenced by CModelParameterReactionParameter::compile(), CModelParameterSet::createFromModel(), and CCopasiXMLParser::ModelParameterElement::start().

{
  bool success = true;

  switch (mType)
    {
      case Model:
        success = (simulationType == CModelEntity::TIME);
        break;

      case Species:
        success = (simulationType != CModelEntity::TIME);
        break;

      case ReactionParameter:
        success = (simulationType == CModelEntity::FIXED ||
                   simulationType == CModelEntity::ASSIGNMENT);
        break;

      case ModelValue:
      case Compartment:
        success = (simulationType != CModelEntity::TIME &&
                   simulationType != CModelEntity::REACTIONS);
        break;

      default:
        success = (simulationType == CModelEntity::FIXED);
        break;
    }

  if (success)
    {
      mSimulationType = simulationType;
    }

  return success;
}

void CModelParameter::setValue ( const double &  value, const Framework &  framework  )

virtual

Set the value of the parameter based on the current framework

Parameters

const	double & value
const	Framework & framework

Definition at line 248 of file CModelParameter.cpp.

References getSet(), CModelParameterSet::isActive(), mValue, and updateModel().

Referenced by applyValueToModelParameter(), CModelParameterSet::createFromModel(), CQParameterOverviewDM::setData(), and CCopasiXMLParser::ModelParameterElement::start().

{
  mValue = value;

  CModelParameterSet * pSet = getSet();

  if (pSet->isActive())
    {
      updateModel();
    }
}

bool CModelParameter::updateModel ( )

virtual

Update the corresponding model object with the current parameter settings

Reimplemented in CModelParameterGroup, and CModelParameterSet.

Definition at line 474 of file CModelParameter.cpp.

References CModelEntity::ASSIGNMENT, C_FLOAT64, Compartment, getInitialExpression(), CCopasiParameter::getKey(), CCopasiObject::getKey(), getModel(), CCopasiObject::getObjectAncestor(), CCopasiObject::getObjectDataModel(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CEvaluationTree::getRoot(), CModelEntity::getStatus(), CCopasiObject::getValuePointer(), CModel::isAutonomous(), mIsInitialExpressionValid, Model, ModelValue, mpInitialExpression, mpObject, mpParent, mType, mValue, CCopasiDataModel::ObjectFromName(), ReactionParameter, CModelEntity::setInitialExpression(), CModelEntity::setInitialValue(), CReaction::setParameterMapping(), CCopasiParameter::setValue(), and Species.

Referenced by setValue().

{
  bool success = true;

  if (mpObject != NULL)
    {
      switch (mType)
        {
          case Model:
          {
            CModel * pModel = static_cast< CModel * >(mpObject);

            if (!pModel->isAutonomous())
              {
                pModel->setInitialValue(mValue);
              }
            else
              {
                pModel->setInitialValue(0.0);
              }
          }
          break;

          case Compartment:
          case Species:
          case ModelValue:
          {
            CModelEntity * pEntity = static_cast< CModelEntity * >(mpObject);

            if (pEntity->getStatus() != CModelEntity::ASSIGNMENT)
              {
                pEntity->setInitialValue(mValue);

                if (mIsInitialExpressionValid)
                  {
                    pEntity->setInitialExpression(getInitialExpression());
                  }
              }
          }
          break;

          case ReactionParameter:
          {
            CCopasiParameter * pParameter = static_cast< CCopasiParameter * >(mpObject);
            CReaction * pReaction = static_cast< CReaction * >(mpObject->getObjectAncestor("Reaction"));

            if (mIsInitialExpressionValid &&
                getInitialExpression() != "")
              {
                CModel * pModel = mpParent->getModel();

                assert(pModel != NULL);

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

                CCopasiObjectName CN = static_cast< CEvaluationNodeObject * >(mpInitialExpression->getRoot())->getObjectCN();
                CCopasiObject * pObject = pModel->getObjectDataModel()->ObjectFromName(ListOfContainer, CN);

                assert(pObject != NULL);

                // We assign the object value
                pParameter->setValue(* (C_FLOAT64 *) pObject->getValuePointer());

                // We map the parameter to the global quantity
                pReaction->setParameterMapping(pParameter->getObjectName(), pObject->getObjectParent()->getKey());
              }
            else
              {
                pParameter->setValue(mValue);

                // We need to remove the existing mapping to a global quantity1.
                pReaction->setParameterMapping(pParameter->getObjectName(), pParameter->getKey());
              }
          }
          break;

          default:
            success = false;
            break;
        }
    }

  return success;
}

Friends And Related Function Documentation

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

friend

Definition at line 862 of file CModelParameter.cpp.

{
  os << "Model Parameter:" << std::endl;
  os << "  Type:       " << CModelParameter::TypeNames[o.mType] << std::endl;
  os << "  CN:         " << o.mCN << std::endl;
  os << "  Value:      " << o.mValue << std::endl;
  os << "  Expression: " << o.getInitialExpression() << std::endl;
  os << "  Diff:       " << o.mCompareResult << std::endl;

  return os;
}

Member Data Documentation

CRegisteredObjectName CModelParameter::mCN

protected

The CN of the corresponding model object

Definition at line 274 of file CModelParameter.h.

Referenced by compile(), getCN(), getName(), CModelParameterSpecies::getName(), operator<<(), setCN(), and CModelParameterSpecies::setCN().

CompareResult CModelParameter::mCompareResult

protected

The result of the last compare

Definition at line 294 of file CModelParameter.h.

Referenced by CModelParameterGroup::diff(), diff(), getCompareResult(), operator<<(), CModelParameterGroup::refreshFromModel(), refreshFromModel(), and setCompareResult().

bool CModelParameter::mIsInitialExpressionValid

protected

The result of the last compile of the initial expression. Note an empty or missing expression is valid.

Definition at line 305 of file CModelParameter.h.

Referenced by compile(), isInitialExpressionValid(), isReadOnly(), and updateModel().

CExpression* CModelParameter::mpInitialExpression

protected

A pointer to the initial expression

Definition at line 289 of file CModelParameter.h.

Referenced by compile(), getInitialExpression(), getInitialExpressionPtr(), setInitialExpression(), and updateModel().

CCopasiObject* CModelParameter::mpObject

protected

A pointer to the corresponding model object. NULL if no object exists.

Definition at line 299 of file CModelParameter.h.

Referenced by compile(), diff(), getName(), CModelParameterSpecies::getName(), getObject(), getUnit(), refreshFromModel(), and updateModel().

CModelParameterGroup* CModelParameter::mpParent

protected

The parent group

Definition at line 264 of file CModelParameter.h.

Referenced by CModelParameter(), CModelParameterReactionParameter::compile(), getIndex(), getParent(), getSet(), setParent(), updateModel(), and ~CModelParameter().

CModelEntity::Status CModelParameter::mSimulationType

protected

The role the parameter object is used in the simulation.

Definition at line 279 of file CModelParameter.h.

Referenced by getSimulationType(), refreshFromModel(), and setSimulationType().

Type CModelParameter::mType

protected

The type

Definition at line 269 of file CModelParameter.h.

Referenced by CModelParameter(), compile(), diff(), getSet(), getType(), getUnit(), isReadOnly(), operator<<(), refreshFromModel(), setSimulationType(), and updateModel().

double CModelParameter::mValue

protected

The value of the parameter

Definition at line 284 of file CModelParameter.h.

Referenced by CModelParameterSpecies::compile(), CModelParameterReactionParameter::compile(), getValue(), CModelParameterSpecies::getValue(), operator<<(), refreshFromModel(), setValue(), CModelParameterCompartment::setValue(), CModelParameterSpecies::setValue(), and updateModel().

const char * CModelParameter::TypeNames

static

Initial value:

=
{
  "Model",
  "Compartment",
  "Species",
  "ModelValue",
  "ReactionParameter",
  "Reaction",
  "Group",
  "Set",
  "unknown",
  NULL
}

Definition at line 39 of file CModelParameter.h.

Referenced by operator<<(), CCopasiXML::saveModelParameter(), CCopasiXMLParser::ModelParameterElement::start(), and CCopasiXMLParser::ModelParameterGroupElement::start().

---

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

• CModelParameter.h
• CModelParameter.cpp