void CMetab::initCompartment(const CCompartment * pCompartment)
{
mpCompartment =
dynamic_cast< const CCompartment * >(getObjectAncestor("Compartment"));
if (!mpCompartment)
mpCompartment = pCompartment;
}
// virtual
bool CModelParameterSet::setObjectParent(const CCopasiContainer * pParent)
{
bool success = CCopasiObject::setObjectParent(pParent);
mpModel = dynamic_cast< CModel * >(getObjectAncestor("Model"));
return success;
}
bool CMetab::compileInitialValueDependencies()
{
bool success = true;
std::set<const CCopasiObject *> Dependencies;
CObjectInterface::ContainerList listOfContainer;
listOfContainer.push_back(getObjectAncestor("Model"));
// If we have an assignment or a valid initial expression we must update both
if (getStatus() == ASSIGNMENT ||
(mpInitialExpression != NULL &&
mpInitialExpression->getInfix() != ""))
{
// Initial concentration
success &= mpInitialExpression->compile(listOfContainer);
mpIConcReference->setDirectDependencies(mpInitialExpression->getDirectDependencies());
// Initial particle number
Dependencies.insert(mpIConcReference);
if (mpCompartment)
Dependencies.insert(mpCompartment->getInitialValueReference());
mpIValueReference->setDirectDependencies(Dependencies);
Dependencies.clear();
// If we have a valid initial expression, we update the initial value.
// In case the expression is constant this suffices others are updated lated again.
if (mpInitialExpression->isUsable())
mIConc = mpInitialExpression->calcValue();
return success;
}
// The context sensitivity is handle in the virtual method getDirectDependencies();
// Initial particle number
Dependencies.insert(mpIConcReference);
if (mpCompartment)
Dependencies.insert(mpCompartment->getInitialValueReference());
mpIValueReference->setDirectDependencies(Dependencies);
Dependencies.clear();
// Initial concentration
Dependencies.insert(mpIValueReference);
if (mpCompartment)
Dependencies.insert(mpCompartment->getInitialValueReference());
mpIConcReference->setDirectDependencies(Dependencies);
return success;
}
void CMoiety::initConversionFactor()
{
const CModel * pModel = dynamic_cast< const CModel * >(getObjectAncestor("Model"));
if (pModel != NULL)
{
mpConversionFactor = &pModel->getNumber2QuantityFactor();
}
else
{
mpConversionFactor = &DefaultFactor;
}
}
CEventAssignment::CEventAssignment(const std::string & targetKey,
const CCopasiContainer * pParent) :
CCopasiContainer(targetKey, pParent, "EventAssignment"),
mKey(CCopasiRootContainer::getKeyFactory()->add("EventAssignment", this)),
mpModel(static_cast<CModel *>(getObjectAncestor("Model"))),
mpTarget(NULL),
mpExpression(NULL)
{
if (mpModel != NULL)
{
mpModel->setCompileFlag(true);
}
}
CEventAssignment::CEventAssignment(const CEventAssignment & src,
const CCopasiContainer * pParent):
CCopasiContainer(src, pParent),
mKey(CCopasiRootContainer::getKeyFactory()->add("EventAssignment", this)),
mpModel(static_cast<CModel *>(getObjectAncestor("Model"))),
mpTarget(src.mpTarget),
mpExpression(NULL)
{
if (mpModel != NULL)
{
mpModel->setCompileFlag(true);
}
setExpression(src.getExpression());
}
bool CEventAssignment::setObjectParent(const CCopasiContainer * pParent)
{
if (pParent != getObjectParent() &&
mpModel != NULL)
{
mpModel->setCompileFlag(true);
}
bool success = CCopasiContainer::setObjectParent(pParent);
mpModel = static_cast<CModel *>(getObjectAncestor("Model"));
if (mpModel != NULL)
{
mpModel->setCompileFlag(true);
}
return success;
}
CEvent::CEvent(const std::string & name,
const CCopasiContainer * pParent):
CCopasiContainer(name, pParent, "Event"),
CAnnotation(),
mpModel(static_cast<CModel *>(getObjectAncestor("Model"))),
mAssignments("ListOfAssignments", this),
mDelayAssignment(true),
mFireAtInitialTime(false),
mPersistentTrigger(false),
mpTriggerExpression(NULL),
mpDelayExpression(NULL),
mpPriorityExpression(NULL),
mType(Assignment)
{
mKey = (CCopasiRootContainer::getKeyFactory()->add(getObjectType(), this));
initObjects();
}
CEvent::CEvent(const CEvent & src,
const CCopasiContainer * pParent):
CCopasiContainer(src, pParent),
CAnnotation(src),
mpModel(static_cast<CModel *>(getObjectAncestor("Model"))),
mAssignments(src.mAssignments, this),
mDelayAssignment(src.mDelayAssignment),
mFireAtInitialTime(src.mFireAtInitialTime),
mPersistentTrigger(src.mPersistentTrigger),
mpTriggerExpression(src.mpTriggerExpression != NULL ? new CExpression(*src.mpTriggerExpression, this) : NULL),
mpDelayExpression(src.mpDelayExpression != NULL ? new CExpression(*src.mpDelayExpression, this) : NULL),
mpPriorityExpression(src.mpPriorityExpression != NULL ? new CExpression(*src.mpPriorityExpression, this) : NULL),
mType(src.mType)
{
mKey = (CCopasiRootContainer::getKeyFactory()->add(getObjectType(), this));
initObjects();
setMiriamAnnotation(src.getMiriamAnnotation(), mKey, src.mKey);
}
bool CFitProblem::initialize()
{
mHaveStatistics = false;
if (!COptProblem::initialize())
{
while (CCopasiMessage::peekLastMessage().getNumber() == MCOptimization + 5 ||
CCopasiMessage::peekLastMessage().getNumber() == MCOptimization + 7)
CCopasiMessage::getLastMessage();
if (CCopasiMessage::getHighestSeverity() > CCopasiMessage::WARNING &&
CCopasiMessage::peekLastMessage().getNumber() != MCCopasiMessage + 1)
return false;
}
std::vector< CCopasiContainer * > ContainerList;
ContainerList.push_back(getObjectAncestor("Vector"));
CCopasiDataModel* pDataModel = getObjectDataModel();
assert(pDataModel != NULL);
mpSteadyState =
dynamic_cast< CSteadyStateTask * >(pDataModel->ObjectFromName(ContainerList, *mpParmSteadyStateCN));
if (mpSteadyState == NULL)
mpSteadyState =
static_cast<CSteadyStateTask *>((*pDataModel->getTaskList())["Steady-State"]);
// We only need to initialize the steady-state task if steady-state data is present.
if (mpExperimentSet->hasDataForTaskType(CCopasiTask::steadyState))
{
mpSteadyState->initialize(CCopasiTask::NO_OUTPUT, NULL, NULL);
}
mpTrajectory =
dynamic_cast< CTrajectoryTask * >(pDataModel->ObjectFromName(ContainerList, *mpParmTimeCourseCN));
if (mpTrajectory == NULL)
mpTrajectory =
static_cast<CTrajectoryTask *>((*pDataModel->getTaskList())["Time-Course"]);
// We only need to initialize the trajectory task if time course data is present.
if (mpExperimentSet->hasDataForTaskType(CCopasiTask::timeCourse))
{
mpTrajectory->initialize(CCopasiTask::NO_OUTPUT, NULL, NULL);
}
ContainerList.clear();
ContainerList.push_back(mpModel);
CFitTask * pTask = dynamic_cast<CFitTask *>(getObjectParent());
if (pTask)
{
ContainerList.push_back(pTask);
ContainerList.push_back(mpSteadyState);
ContainerList.push_back(mpTrajectory);
}
if (!mpExperimentSet->compile(ContainerList)) return false;
// Build a matrix of experiment and experiment local items.
mExperimentUpdateMethods.resize(mpExperimentSet->getExperimentCount(),
mpOptItems->size());
mExperimentUpdateMethods = NULL;
mExperimentInitialRefreshes.resize(mpExperimentSet->getExperimentCount());
std::vector< std::set< const CCopasiObject * > > ObjectSet;
ObjectSet.resize(mpExperimentSet->getExperimentCount());
std::vector<COptItem * >::iterator it = mpOptItems->begin();
std::vector<COptItem * >::iterator end = mpOptItems->end();
std::vector<COptItem * >::iterator itTmp;
CFitItem * pItem;
unsigned C_INT32 i, imax;
unsigned C_INT32 j;
unsigned C_INT32 Index;
imax = mSolutionVariables.size();
mFisher.resize(imax, imax);
mpFisherMatrix->resize();
mCorrelation.resize(imax, imax);
mpCorrelationMatrix->resize();
for (j = 0; it != end; ++it, j++)
{
pItem = static_cast<CFitItem *>(*it);
pItem->updateBounds(mpOptItems->begin());
std::string Annotation = pItem->getObjectDisplayName();
imax = pItem->getExperimentCount();
if (imax == 0)
{
for (i = 0, imax = mpExperimentSet->getExperimentCount(); i < imax; i++)
{
mExperimentUpdateMethods(i, j) = pItem->COptItem::getUpdateMethod();
ObjectSet[i].insert(pItem->getObject());
}
}
else
{
Annotation += "; {" + pItem->getExperiments() + "}";
for (i = 0; i < imax; i++)
{
if ((Index = mpExperimentSet->keyToIndex(pItem->getExperiment(i))) == C_INVALID_INDEX)
return false;
mExperimentUpdateMethods(Index, j) = pItem->COptItem::getUpdateMethod();
ObjectSet[Index].insert(pItem->getObject());
};
}
mpFisherMatrix->setAnnotationString(0, j, Annotation);
mpFisherMatrix->setAnnotationString(1, j, Annotation);
mpCorrelationMatrix->setAnnotationString(0, j, Annotation);
mpCorrelationMatrix->setAnnotationString(1, j, Annotation);
}
for (i = 0, imax = mpExperimentSet->getExperimentCount(); i < imax; i++)
mExperimentInitialRefreshes[i] = mpModel->buildInitialRefreshSequence(ObjectSet[i]);
// Build a matrix of experiment and constraint items;
mExperimentConstraints.resize(mpExperimentSet->getExperimentCount(),
mpConstraintItems->size());
mExperimentConstraints = NULL;
mExperimentConstraintRefreshes.resize(mpExperimentSet->getExperimentCount());
ObjectSet.clear();
ObjectSet.resize(mpExperimentSet->getExperimentCount());
it = mpConstraintItems->begin();
end = mpConstraintItems->end();
CFitConstraint * pConstraint;
std::set< const CCopasiObject * >::const_iterator itDepend;
std::set< const CCopasiObject * >::const_iterator endDepend;
for (j = 0; it != end; ++it, j++)
{
pConstraint = static_cast<CFitConstraint *>(*it);
itDepend = pConstraint->getDirectDependencies().begin();
endDepend = pConstraint->getDirectDependencies().end();
imax = pConstraint->getExperimentCount();
if (imax == 0)
{
for (i = 0, imax = mpExperimentSet->getExperimentCount(); i < imax; i++)
{
mExperimentConstraints(i, j) = pConstraint;
ObjectSet[i].insert(itDepend, endDepend);
}
}
else
{
for (i = 0; i < imax; i++)
{
if ((Index = mpExperimentSet->keyToIndex(pConstraint->getExperiment(i))) == C_INVALID_INDEX)
return false;
mExperimentConstraints(Index, j) = pConstraint;
ObjectSet[Index].insert(itDepend, endDepend);
};
}
}
for (i = 0, imax = mpExperimentSet->getExperimentCount(); i < imax; i++)
mExperimentConstraintRefreshes[i] = CCopasiObject::buildUpdateSequence(ObjectSet[i], mpModel->getUptoDateObjects());
mExperimentDependentValues.resize(mpExperimentSet->getDataPointCount());
if (!mpSteadyState)
{
mpSteadyState =
dynamic_cast< CSteadyStateTask * >((*pDataModel->getTaskList())["Steady-State"]);
if (mpSteadyState == NULL) fatalError();
setValue("Steady-State", mpSteadyState->getKey());
mpSteadyState->initialize(CCopasiTask::NO_OUTPUT, NULL, NULL);
ContainerList.push_back(mpSteadyState);
}
if (!mpTrajectory)
{
mpTrajectory =
dynamic_cast< CTrajectoryTask * >((*pDataModel->getTaskList())["Time-Course"]);
if (mpTrajectory == NULL) fatalError();
setValue("Time-Course", mpTrajectory->getKey());
mpTrajectory->initialize(CCopasiTask::NO_OUTPUT, NULL, NULL);
ContainerList.push_back(mpTrajectory);
}
pdelete(mpTrajectoryProblem);
mpTrajectoryProblem =
new CTrajectoryProblem(*static_cast<CTrajectoryProblem *>(mpTrajectory->getProblem()));
static_cast<CTrajectoryProblem *>(mpTrajectory->getProblem())->setStepNumber(1);
pdelete(mpInitialState);
mpInitialState = new CState(mpModel->getInitialState());
return true;
}
bool CFitProblem::elevateChildren()
{
// This call is necessary since CFitProblem is derived from COptProblem.
if (!COptProblem::elevateChildren()) return false;
// Due to a naming conflict the following parameters may have been overwritten during
// the load of a CopasiML file we replace them with default values if that was the case.
mpParmSteadyStateCN =
assertParameter("Steady-State", CCopasiParameter::CN, CCopasiObjectName(""))->getValue().pCN;
mpParmTimeCourseCN =
assertParameter("Time-Course", CCopasiParameter::CN, CCopasiObjectName(""))->getValue().pCN;
CCopasiVectorN< CCopasiTask > * pTasks = NULL;
CCopasiDataModel* pDataModel = getObjectDataModel();
if (pDataModel)
pTasks = pDataModel->getTaskList();
if (pTasks == NULL)
pTasks = dynamic_cast<CCopasiVectorN< CCopasiTask > *>(getObjectAncestor("Vector"));
if (pTasks)
{
unsigned C_INT32 i, imax = pTasks->size();
if (!mpParmSteadyStateCN->compare(0, 5 , "Task_") ||
*mpParmSteadyStateCN == "")
for (i = 0; i < imax; i++)
if ((*pTasks)[i]->getType() == CCopasiTask::steadyState)
{
*mpParmSteadyStateCN = (*pTasks)[i]->getCN();
break;
}
if (!mpParmTimeCourseCN->compare(0, 5 , "Task_") ||
*mpParmTimeCourseCN == "")
for (i = 0; i < imax; i++)
if ((*pTasks)[i]->getType() == CCopasiTask::timeCourse)
{
*mpParmTimeCourseCN = (*pTasks)[i]->getCN();
break;
}
}
std::map<std::string, std::string> ExperimentMap;
CCopasiParameterGroup * pGroup;
CExperiment * pExperiment;
std::vector<CCopasiParameter *> * pExperiments =
getGroup("Experiment Set")->CCopasiParameter::getValue().pGROUP;
std::vector<CCopasiParameter *>::iterator itExp;
std::vector<CCopasiParameter *>::iterator endExp;
for (itExp = pExperiments->begin(), endExp = pExperiments->end(); itExp != endExp; ++itExp)
if ((pGroup = dynamic_cast< CCopasiParameterGroup * >(*itExp)) != NULL &&
pGroup->getParameter("Key") != NULL)
ExperimentMap[*pGroup->getValue("Key").pKEY] = (*itExp)->getObjectName();
mpExperimentSet =
elevate<CExperimentSet, CCopasiParameterGroup>(getGroup("Experiment Set"));
if (!mpExperimentSet) return false;
std::map<std::string, std::string>::iterator itMap;
std::map<std::string, std::string>::iterator endMap;
for (itMap = ExperimentMap.begin(), endMap = ExperimentMap.end(); itMap != endMap; ++itMap)
{
pExperiment = mpExperimentSet->getExperiment(itMap->second);
itMap->second = pExperiment->CCopasiParameter::getKey();
pExperiment->setValue("Key", itMap->second);
}
std::vector<COptItem * >::iterator it = mpOptItems->begin();
std::vector<COptItem * >::iterator end = mpOptItems->end();
for (; it != end; ++it)
{
if (!((*it) = elevate<CFitItem, COptItem>(*it)))
return false;
pExperiments =
(*it)->getParameter("Affected Experiments")->getValue().pGROUP;
for (itExp = pExperiments->begin(), endExp = pExperiments->end(); itExp != endExp; ++itExp)
(*itExp)->setValue(ExperimentMap[*(*itExp)->getValue().pKEY]);
}
it = mpConstraintItems->begin();
end = mpConstraintItems->end();
for (; it != end; ++it)
{
if (!((*it) = elevate<CFitConstraint, COptItem>(*it)))
return false;
pExperiments =
(*it)->getParameter("Affected Experiments")->getValue().pGROUP;
for (itExp = pExperiments->begin(), endExp = pExperiments->end(); itExp != endExp; ++itExp)
(*itExp)->setValue(ExperimentMap[*(*itExp)->getValue().pKEY]);
}
return true;
}
bool CExperimentSet::calculateStatistics()
{
mDependentObjectiveValues.resize(mDependentObjects.size());
mDependentObjectiveValues = 0.0;
mDependentRMS.resize(mDependentObjects.size());
mDependentRMS = 0.0;
mDependentErrorMean.resize(mDependentObjects.size());
mDependentErrorMean = 0.0;
mDependentErrorMeanSD.resize(mDependentObjects.size());
mDependentErrorMeanSD = 0.0;
mDependentDataCount.resize(mDependentObjects.size());
mDependentDataCount = 0;
mValidValueCount = 0;
// calculate the per experiment and per dependent value statistics.
std::vector< CExperiment * >::iterator it = mpExperiments->begin() + mNonExperiments;
std::vector< CExperiment * >::iterator end = mpExperiments->end();
size_t i, Count;
C_FLOAT64 Tmp;
for (; it != end; ++it)
{
(*it)->calculateStatistics();
const CObjectInterface ** ppObject = mDependentObjects.array();
const CObjectInterface ** ppEnd = ppObject + mDependentObjects.size();
for (i = 0; ppObject != ppEnd; ++ppObject, ++i)
{
Count = (*it)->getColumnValidValueCount(*ppObject);
if (Count)
{
mDependentObjectiveValues[i] += (*it)->getObjectiveValue(*ppObject);
Tmp = (*it)->getRMS(*ppObject);
mDependentRMS[i] += Tmp * Tmp * Count;
mDependentErrorMean[i] += (*it)->getErrorSum(*ppObject);
mDependentDataCount[i] += Count;
mValidValueCount += Count;
}
}
}
size_t imax = mDependentObjects.size();
for (i = 0; i != imax; i++)
{
Count = mDependentDataCount[i];
if (Count)
{
mDependentRMS[i] = sqrt(mDependentRMS[i] / Count);
mDependentErrorMean[i] /= Count;
}
else
{
mDependentRMS[i] = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mDependentErrorMean[i] = std::numeric_limits<C_FLOAT64>::quiet_NaN();
}
}
it = mpExperiments->begin() + mNonExperiments;
// We need to loop again to calculate the std. deviation.
for (; it != end; ++it) //over experiments
{
const CObjectInterface ** ppObject = mDependentObjects.array();
const CObjectInterface ** ppEnd = ppObject + mDependentObjects.size();
for (i = 0; ppObject != ppEnd; ++ppObject, ++i)
{
Count = (*it)->getColumnValidValueCount(*ppObject);
if (Count)
mDependentErrorMeanSD[i] +=
(*it)->getErrorMeanSD(*ppObject, mDependentErrorMean[i]);
}
}
for (i = 0; i != imax; i++)
{
Count = mDependentDataCount[i];
if (Count)
mDependentErrorMeanSD[i] = sqrt(mDependentErrorMeanSD[i] / Count);
else
mDependentErrorMeanSD[i] = std::numeric_limits<C_FLOAT64>::quiet_NaN();
}
// This is the time to call the output handler to plot the fitted points.
for (it = mpExperiments->begin() + mNonExperiments, imax = 0; it != end; ++it)
imax = std::max(imax, (*it)->getDependentData().numRows());
CCopasiTask * pParentTask = dynamic_cast< CCopasiTask *>(getObjectAncestor("Task"));
assert(pParentTask != NULL);
for (i = 0; i < imax; i++)
{
for (it = mpExperiments->begin() + mNonExperiments; it != end; ++it)
(*it)->updateFittedPointValues(i, (*it)->getExperimentType() != CTaskEnum::Task::timeCourse); //false means without simulated data
pParentTask->output(COutputInterface::AFTER);
}
//now the extended time series
for (it = mpExperiments->begin() + mNonExperiments, imax = 0; it != end; ++it)
imax = std::max(imax, (*it)->extendedTimeSeriesSize());
for (i = 0; i < imax; i++)
{
for (it = mpExperiments->begin() + mNonExperiments; it != end; ++it)
{
if ((*it)->getExperimentType() == CTaskEnum::Task::timeCourse)
{
(*it)->updateFittedPointValuesFromExtendedTimeSeries(i);
}
}
pParentTask->output(COutputInterface::AFTER);
}
return true;
}
bool CMetab::compile()
{
bool success = true;
// We first clear all dependencies and refreshes
// Particle Number
mpValueReference->clearDirectDependencies();
// Rate (particle number rate)
mRateVector.clear();
mpRateReference->clearDirectDependencies();
// Concentration
mpConcReference->clearDirectDependencies();
// Concentration Rate
mpConcRateReference->clearDirectDependencies();
// Noise
mpNoiseReference->clearDirectDependencies();
mpIntensiveNoiseReference->clearDirectDependencies();
// Transition Time
mpTTReference->clearDirectDependencies();
// Prepare the compilation
std::set<const CCopasiObject *> Dependencies;
CObjectInterface::ContainerList listOfContainer;
listOfContainer.push_back(getObjectAncestor("Model"));
CCopasiDataModel* pDataModel = NULL;
const CCopasiObject * pVolumeReference = NULL;
if (mpCompartment)
pVolumeReference = mpCompartment->getValueReference();
// Compile the value (particle number)
Dependencies.insert(mpConcReference);
if (pVolumeReference)
Dependencies.insert(pVolumeReference);
// We no longer need to distinguish the cases since the reference are now context sensitive
mpValueReference->setDirectDependencies(Dependencies);
Dependencies.clear();
// Compiling of the rest.
switch (getStatus())
{
case FIXED:
// Concentration
Dependencies.insert(mpValueReference);
if (pVolumeReference)
Dependencies.insert(pVolumeReference);
mpConcReference->setDirectDependencies(Dependencies);
// Fixed values
mRate = 0.0;
mConcRate = 0.0;
mIntensiveNoise = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mTT = std::numeric_limits<C_FLOAT64>::infinity();
break;
case ASSIGNMENT:
// Concentration
success = mpExpression->compile(listOfContainer);
mpConcReference->setDirectDependencies(mpExpression->getDirectDependencies());
// Implicit initial expression
pdelete(mpInitialExpression);
pDataModel = getObjectDataModel();
mpInitialExpression = CExpression::createInitialExpression(*mpExpression, pDataModel);
mpInitialExpression->setObjectName("InitialExpression");
// Fixed values
mRate = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
mConcRate = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
mIntensiveNoise = std::numeric_limits<C_FLOAT64>::quiet_NaN();
mTT = std::numeric_limits< C_FLOAT64 >::quiet_NaN();
break;
case ODE:
// Concentration
Dependencies.insert(mpValueReference);
if (pVolumeReference)
Dependencies.insert(pVolumeReference);
mpConcReference->setDirectDependencies(Dependencies);
// Rate (particle number rate)
success = mpExpression->compile(listOfContainer);
Dependencies = mpExpression->getDirectDependencies();
if (pVolumeReference)
Dependencies.insert(pVolumeReference);
mpRateReference->setDirectDependencies(Dependencies);
Dependencies.clear();
// Concentration Rate
Dependencies.insert(mpRateReference);
Dependencies.insert(mpConcReference);
if (pVolumeReference)
Dependencies.insert(pVolumeReference);
if (mpCompartment)
Dependencies.insert(mpCompartment->getRateReference());
mpConcRateReference->setDirectDependencies(Dependencies);
if (mpNoiseExpression != NULL)
{
// Noise (particle number rate)
success = mpNoiseExpression->compile(listOfContainer);
Dependencies = mpNoiseExpression->getDirectDependencies();
if (pVolumeReference)
Dependencies.insert(pVolumeReference);
mpNoiseReference->setDirectDependencies(Dependencies);
Dependencies.clear();
// Intensive Noise
Dependencies.insert(mpNoiseReference);
if (pVolumeReference)
Dependencies.insert(pVolumeReference);
mpIntensiveNoiseReference->setDirectDependencies(Dependencies);
Dependencies.clear();
}
// Transition Time
Dependencies.insert(mpValueReference);
Dependencies.insert(mpRateReference);
mpTTReference->setDirectDependencies(Dependencies);
Dependencies.clear();
break;
case REACTIONS:
{
// Concentration
Dependencies.insert(mpValueReference);
if (pVolumeReference)
Dependencies.insert(pVolumeReference);
mpConcReference->setDirectDependencies(Dependencies);
Dependencies.clear();
std::set<const CCopasiObject *> NoiseDependencies;
// Create the rate vector
CCopasiVectorN< CReaction >::const_iterator it = mpModel->getReactions().begin();
CCopasiVectorN< CReaction >::const_iterator end = mpModel->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() == mKey)
break;
if (itChem != endChem)
{
Dependencies.insert(it->getParticleFluxReference());
NoiseDependencies.insert(it->getParticleNoiseReference());
std::pair< C_FLOAT64, const C_FLOAT64 * > Insert;
Insert.first = itChem->getMultiplicity();
Insert.second = &it->getParticleFlux();
mRateVector.push_back(Insert);
}
}
// Rate (particle number rate)
mpRateReference->setDirectDependencies(Dependencies);
// Transition Time
mpTTReference->setDirectDependencies(Dependencies);
Dependencies.clear();
// Concentration Rate
Dependencies.insert(mpRateReference);
Dependencies.insert(mpConcReference);
if (pVolumeReference)
Dependencies.insert(pVolumeReference);
if (mpCompartment)
Dependencies.insert(mpCompartment->getRateReference());
mpConcRateReference->setDirectDependencies(Dependencies);
Dependencies.clear();
mpNoiseReference->setDirectDependencies(NoiseDependencies);
if (pVolumeReference)
NoiseDependencies.insert(pVolumeReference);
mpIntensiveNoiseReference->setDirectDependencies(NoiseDependencies);
}
break;
default:
break;
}
// The initial values
success &= compileInitialValueDependencies();
return success;
}
