C_FLOAT64 CExperimentObjectMap::CDataColumn::getDefaultScale() const
{
if (mpObjectCN == NULL)
return std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiParameterGroup *pGroup =
dynamic_cast< CCopasiParameterGroup * >(getObjectParent());
if (pGroup == NULL)
return std::numeric_limits<C_FLOAT64>::quiet_NaN();
const CExperiment *pExperiment =
dynamic_cast<const CExperiment * >(pGroup->getObjectParent());
if (pExperiment == NULL)
return std::numeric_limits<C_FLOAT64>::quiet_NaN();
const CCopasiDataModel* pDataModel = getObjectDataModel();
assert(pDataModel != NULL);
const CCopasiObject * pObject = pDataModel->getDataObject(*mpObjectCN);
if (pObject == NULL)
return std::numeric_limits<C_FLOAT64>::quiet_NaN();
return pExperiment->getDefaultScale(pObject);
}
C_FLOAT64 CExperimentObjectMap::CDataColumn::getDefaultScale() const
{
if (mpObjectCN == NULL)
return std::numeric_limits<C_FLOAT64>::quiet_NaN();
CCopasiParameterGroup *pGroup =
dynamic_cast< CCopasiParameterGroup * >(getObjectParent());
if (pGroup == NULL)
return std::numeric_limits<C_FLOAT64>::quiet_NaN();
const CExperiment *pExperiment =
dynamic_cast<const CExperiment * >(pGroup->getObjectParent());
if (pExperiment == NULL)
return std::numeric_limits<C_FLOAT64>::quiet_NaN();
CObjectInterface::ContainerList ListOfContainer;
ListOfContainer.push_back(getObjectDataModel());
const CCopasiObject * pObject = CObjectInterface::DataObject(CObjectInterface::GetObjectFromCN(ListOfContainer, *mpObjectCN));
if (pObject == NULL)
return std::numeric_limits<C_FLOAT64>::quiet_NaN();
return pExperiment->getDefaultScale(pObject);
}
bool CReportDefinition::preCompileTable(const std::vector< CCopasiContainer * > & listOfContainer)
{
bool success = true;
mHeaderVector.clear();
mBodyVector.clear();
mFooterVector.clear();
std::vector<CRegisteredObjectName>::const_iterator it = mTableVector.begin();
std::vector<CRegisteredObjectName>::const_iterator end = mTableVector.end();
CCopasiDataModel* pDataModel = getObjectDataModel();
CCopasiObject * pObject;
for (; it != end; ++it)
{
pObject = pDataModel->ObjectFromName(listOfContainer, *it);
if (pObject != NULL)
{
addTableElement(pObject);
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCCopasiTask + 6, it->c_str());
}
}
return success;
}
bool CSlider::compile(const std::vector< CCopasiContainer * > & listOfContainer)
{
//setSliderObject(CCopasiContainer::ObjectFromName(listOfContainer, getObjectName()));
setSliderObject(getObjectDataModel()->ObjectFromName(listOfContainer, mCN));
if (this->mSync) this->sync();
return (mpSliderObject != NULL);
}
/**
* Set whether the steady state analysis is requested.
* @param bool * steadyStateRequested
*/
void CLNAProblem::setSteadyStateRequested(const bool & steadyStateRequested)
{
CSteadyStateTask * pSubTask = NULL;
CDataModel* pDataModel = getObjectDataModel();
if (pDataModel && pDataModel->getTaskList())
pSubTask = dynamic_cast<CSteadyStateTask *>(&pDataModel->getTaskList()->operator[]("Steady-State"));
if (steadyStateRequested && pSubTask)
setValue("Steady-State", pSubTask->getKey());
else
setValue("Steady-State", std::string(""));
}
/**
* Set whether the steady state analysis is requested.
* @param bool * steadyStateRequested
*/
void CLNAProblem::setSteadyStateRequested(const bool & steadyStateRequested)
{
CSteadyStateTask * pSubTask = NULL;
CCopasiDataModel* pDataModel = getObjectDataModel();
assert(pDataModel != NULL);
if (pDataModel && pDataModel->getTaskList())
pSubTask = dynamic_cast<CSteadyStateTask *>((*pDataModel->getTaskList())["Steady-State"]);
if (steadyStateRequested && pSubTask)
setValue("Steady-State", pSubTask->getKey());
else
setValue("Steady-State", std::string(""));
}
bool CSlider::setSliderObject(CCopasiObject * pObject)
{
mpSliderObject = pObject;
if (!pObject)
{
mInitialRefreshes.clear();
return false;
}
mCN = pObject->getCN();
std::set< const CCopasiObject * > ChangedObjects;
ChangedObjects.insert(pObject);
CCopasiDataModel* pDataModel = getObjectDataModel();
assert(pDataModel != NULL);
mInitialRefreshes = pDataModel->getModel()->buildInitialRefreshSequence(ChangedObjects);
if (mpSliderObject->isValueInt())
{
this->setSliderType(Integer);
}
else if (mpSliderObject->isValueDbl())
{
this->setSliderType(Float);
}
else
{
this->setSliderType(Undefined);
}
if (this->mSync) this->sync();
C_FLOAT64 value = this->getSliderValue();
this->mOriginalValue = value;
if (this->mMinValue > value)
{
this->mMinValue = value;
}
if (this->mMaxValue < value)
{
this->mMaxValue = value;
}
return true;
}
void CCopasiTask::initObjects()
{
addObjectReference("Output counter", mOutputCounter, CCopasiObject::ValueInt);
new CCopasiTimer(CCopasiTimer::WALL, this);
new CCopasiTimer(CCopasiTimer::PROCESS, this);
CCopasiDataModel *pDataModel = getObjectDataModel();
if (pDataModel != NULL)
{
if (pDataModel->getModel() != NULL)
{
setMathContainer(&pDataModel->getModel()->getMathContainer());
}
}
}
void CTSSAProblem::printResult(std::ostream * ostream) const
{
std::ostream & os = *ostream;
const CCopasiDataModel* pDataModel = getObjectDataModel();
assert(pDataModel != NULL);
const CCopasiTask* mpTask =
dynamic_cast<const CTSSATask *>((*const_cast<CCopasiDataModel*>(pDataModel)->getTaskList())["Time Scale Separation Analysis"]);
if (!mpTask) return;
const CCopasiMethod* mpMethod = mpTask->getMethod();
this->print(&os);
mpMethod->printResult(&os);
}
/**
* Load a trajectory problem
* @param "CReadConfig &" configBuffer
*/
void CTrajectoryProblem::load(CReadConfig & configBuffer,
CReadConfig::Mode C_UNUSED(mode))
{
if (configBuffer.getVersion() < "4.0")
{
CCopasiDataModel* pDataModel = getObjectDataModel();
assert(pDataModel != NULL);
mpModel = pDataModel->getModel();
configBuffer.getVariable("EndTime", "C_FLOAT64",
mpDuration,
CReadConfig::LOOP);
configBuffer.getVariable("Points", "C_INT32",
mpStepNumber);
mStepNumberSetLast = true;
sync();
}
}
bool CExperimentObjectMap::compile(const std::vector< CCopasiContainer * > listOfContainer)
{
size_t i, imax = size();
size_t Column;
// We need to find out the size of the object map
if (imax == 0)
mLastColumn = C_INVALID_INDEX;
else
{
mLastColumn = strtoul(getName(0).c_str(), NULL, 0);
for (i = 1; i < imax; i++)
{
Column = strtoul(getName(i).c_str(), NULL, 0);
if (mLastColumn < Column)
mLastColumn = Column;
}
}
mObjects.resize(mLastColumn + 1);
mObjects = NULL;
CCopasiObject * pObject = NULL;
std::string CN;
for (i = 0; i < imax; i++)
{
if ((CN = getObjectCN(i)) == "") continue;
if ((pObject =
getObjectDataModel()->ObjectFromName(listOfContainer, CN)) != NULL &&
pObject->isValueDbl())
{
Column = strtoul(getName(i).c_str(), NULL, 0);
mObjects[Column] = pObject;
}
else
return false;
}
return true;
}
bool CScanTask::initialize(const OutputFlag & of,
COutputHandler * pOutputHandler,
std::ostream * pOstream)
{
assert(mpProblem && mpMethod);
bool success = mpMethod->isValidProblem(mpProblem);
if ((of & REPORT) &&
pOutputHandler != NULL)
{
if (mReport.open(getObjectDataModel(), pOstream))
pOutputHandler->addInterface(&mReport);
else
CCopasiMessage(CCopasiMessage::COMMANDLINE, MCCopasiTask + 5, getObjectName().c_str());
}
success &= initSubtask(of, pOutputHandler, mReport.getStream());
success &= CCopasiTask::initialize(of, pOutputHandler, mReport.getStream());
return success;
}
void CLsodaMethod::initializeParameter()
{
CCopasiParameter *pParm;
mpReducedModel =
assertParameter("Integrate Reduced Model", CCopasiParameter::BOOL, (bool) false)->getValue().pBOOL;
mpRelativeTolerance =
assertParameter("Relative Tolerance", CCopasiParameter::UDOUBLE, (C_FLOAT64) 1.0e-6)->getValue().pUDOUBLE;
mpAbsoluteTolerance =
assertParameter("Absolute Tolerance", CCopasiParameter::UDOUBLE, (C_FLOAT64) 1.0e-12)->getValue().pUDOUBLE;
mpMaxInternalSteps =
assertParameter("Max Internal Steps", CCopasiParameter::UINT, (unsigned C_INT32) 10000)->getValue().pUINT;
// Check whether we have a method with the old parameter names
if ((pParm = getParameter("LSODA.RelativeTolerance")) != NULL)
{
*mpRelativeTolerance = *pParm->getValue().pUDOUBLE;
removeParameter("LSODA.RelativeTolerance");
if ((pParm = getParameter("LSODA.AbsoluteTolerance")) != NULL)
{
*mpAbsoluteTolerance = *pParm->getValue().pUDOUBLE;
removeParameter("LSODA.AbsoluteTolerance");
}
if ((pParm = getParameter("LSODA.AdamsMaxOrder")) != NULL)
{
removeParameter("LSODA.AdamsMaxOrder");
}
if ((pParm = getParameter("LSODA.BDFMaxOrder")) != NULL)
{
removeParameter("LSODA.BDFMaxOrder");
}
if ((pParm = getParameter("LSODA.MaxStepsInternal")) != NULL)
{
*mpMaxInternalSteps = *pParm->getValue().pUINT;
removeParameter("LSODA.MaxStepsInternal");
}
}
// Check whether we have a method with "Use Default Absolute Tolerance"
if ((pParm = getParameter("Use Default Absolute Tolerance")) != NULL)
{
C_FLOAT64 NewValue;
if (*pParm->getValue().pBOOL)
{
// The default
NewValue = 1.e-12;
}
else
{
C_FLOAT64 OldValue = *mpAbsoluteTolerance;
CCopasiDataModel* pDataModel = getObjectDataModel();
assert(pDataModel != NULL);
CModel * pModel = pDataModel->getModel();
if (pModel == NULL)
// The default
NewValue = 1.e-12;
else
{
const CCopasiVectorNS< CCompartment > & Compartment = pModel->getCompartments();
unsigned C_INT32 i, imax;
C_FLOAT64 Volume = DBL_MAX;
for (i = 0, imax = Compartment.size(); i < imax; i++)
if (Compartment[i]->getValue() < Volume)
Volume = Compartment[i]->getValue();
if (Volume == DBL_MAX)
// The default
NewValue = 1.e-12;
else
// Invert the scaling as best as we can
NewValue = OldValue / (Volume * pModel->getQuantity2NumberFactor());
}
}
*mpAbsoluteTolerance = NewValue;
removeParameter("Use Default Absolute Tolerance");
}
// These parameters are no longer supported.
removeParameter("Adams Max Order");
removeParameter("BDF Max Order");
}
bool CScanTask::initSubtask(const OutputFlag & /* of */,
COutputHandler * pOutputHandler,
std::ostream * pOstream)
{
if (!mpProblem) fatalError();
CScanProblem * pProblem = dynamic_cast<CScanProblem *>(mpProblem);
if (!pProblem) fatalError();
//get the parameters from the problem
CCopasiTask::Type type = *(CCopasiTask::Type*) pProblem->getValue("Subtask").pUINT;
CCopasiDataModel* pDataModel = getObjectDataModel();
assert(pDataModel != NULL);
switch (type)
{
case CCopasiTask::steadyState:
mpSubtask = dynamic_cast<CCopasiTask*>
((*pDataModel->getTaskList())["Steady-State"]);
break;
case CCopasiTask::timeCourse:
mpSubtask = dynamic_cast<CCopasiTask*>
((*pDataModel->getTaskList())["Time-Course"]);
break;
case CCopasiTask::mca:
mpSubtask = dynamic_cast<CCopasiTask*>
((*pDataModel->getTaskList())["Metabolic Control Analysis"]);
break;
case CCopasiTask::lyap:
mpSubtask = dynamic_cast<CCopasiTask*>
((*pDataModel->getTaskList())["Lyapunov Exponents"]);
break;
case CCopasiTask::optimization:
mpSubtask = dynamic_cast<CCopasiTask*>
((*pDataModel->getTaskList())["Optimization"]);
break;
case CCopasiTask::parameterFitting:
mpSubtask = dynamic_cast<CCopasiTask*>
((*pDataModel->getTaskList())["Parameter Estimation"]);
break;
case CCopasiTask::sens:
mpSubtask = dynamic_cast<CCopasiTask*>
((*pDataModel->getTaskList())["Sensitivities"]);
break;
case CCopasiTask::lna:
mpSubtask = dynamic_cast<CCopasiTask*>
((*pDataModel->getTaskList())["Linear Noise Approximation"]);
break;
case CCopasiTask::tssAnalysis :
mpSubtask = dynamic_cast<CCopasiTask*>
((*pDataModel->getTaskList())[CCopasiTask::TypeName[tssAnalysis]]);
break;
case CCopasiTask::crosssection:
mpSubtask = dynamic_cast<CCopasiTask*>
((*pDataModel->getTaskList())["Cross Section"]);
break;
default:
mpSubtask = NULL;
}
mOutputInSubtask = * pProblem->getValue("Output in subtask").pBOOL;
mUseInitialValues = !pProblem->getContinueFromCurrentState();
if (!mpSubtask) return false;
mpSubtask->getProblem()->setModel(pDataModel->getModel()); //TODO
mpSubtask->setCallBack(NULL);
if (mOutputInSubtask)
return mpSubtask->initialize(OUTPUT, pOutputHandler, pOstream);
else
return mpSubtask->initialize(NO_OUTPUT, pOutputHandler, pOstream);
return true;
}
void CILDMModifiedMethod::printResult(std::ostream * ostream) const
{
std::ostream & os = *ostream;
double timeScale;
C_INT i, j, istep = 0;
this->print(&os);
C_INT32 stepNumber;
assert(getObjectDataModel() != NULL);
//stepNumber = pProblem->getStepNumber();
stepNumber = mVec_SlowModes.size();
for (istep = 0; istep < stepNumber; istep++)
{
os << std::endl;
os << "**************** Time step " << istep + 1 << " ************************** " << std::endl;
os << std::endl;
os << "Contribution of species to modes" << std::endl;
os << "Rows : contribution to mode (TS - corresponding timescale)" << std::endl;
os << "Columns: species ";
for (j = 0; j < mData.dim; j++)
{
os << mpModel->getMetabolitesX()[j]->getObjectName() << " ";
}
os << std::endl;
for (i = 0; i < mData.dim; i++)
{
timeScale = mVec_TimeScale[istep][i];
if (i < mVec_SlowModes[istep])
os << "Slow (";
else
os << "Fast (";
os << timeScale << "): ";
for (j = 0; j < mData.dim; j++)
os << mVec_mVslow[istep][i][j] << " ";
os << std::endl;
}
os << std::endl;
os << "Modes distribution for species" << std::endl;
os << "Rows : Mode distribution for each species" << std::endl;
os << "Columns: Modes (TS - corresponding timescale) ";
os << std::endl;
for (i = 0; i < mData.dim; i++)
{
timeScale = mVec_TimeScale[istep][i];
if (i < mVec_SlowModes[istep])
os << "Slow (";
else
os << "Fast (";
os << timeScale << ") ";
}
os << std::endl;
for (j = 0; j < mData.dim; j++)
{
os << mpModel->getMetabolitesX()[j]->getObjectName() << " ";
for (i = 0; i < mData.dim; i++)
os << mVec_mVslowMetab[istep][j][i] << " ";
os << std::endl;
}
os << std::endl;
os << "Slow space" << std::endl;
os << "Rows : Species" << std::endl;
os << "Column: Contribution to slow space ";
os << std::endl;
os << mVec_SlowModes[istep];
os << " slow; ";
os << mData.dim - mVec_SlowModes[istep];
os << " fast";
os << std::endl;
for (j = 0; j < mData.dim; j++)
{
os << mpModel->getMetabolitesX()[j]->getObjectName() << " ";
os << mVec_mVslowSpace[istep][j] << " ";
os << std::endl;
}
os << std::endl;
os << "Fast space" << std::endl;
os << "Rows : Species" << std::endl;
os << "Column: Contribution to fast space ";
os << std::endl;
os << mVec_SlowModes[istep];
os << " slow; ";
os << mData.dim - mVec_SlowModes[istep];
os << " fast";
os << std::endl;
for (j = 0; j < mData.dim; j++)
{
os << mpModel->getMetabolitesX()[j]->getObjectName() << " ";
os << mVec_mVfastSpace[istep][j] << " ";
os << std::endl;
}
os << std::endl;
}
return;
}
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 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;
}
bool CCopasiTask::initialize(const OutputFlag & of,
COutputHandler * pOutputHandler,
std::ostream * pOstream)
{
bool success = true;
if (!mpProblem)
{
CCopasiMessage(CCopasiMessage::ERROR, MCCopasiTask + 1, getObjectName().c_str());
return false;
}
if (!mpProblem->getModel())
{
CCopasiMessage(CCopasiMessage::ERROR, MCCopasiTask + 2, getObjectName().c_str());
return false;
}
if (!mpMethod)
{
CCopasiMessage(CCopasiMessage::ERROR, MCCopasiTask + 3, getObjectName().c_str());
return false;
}
if (!mpProblem->getModel()->compileIfNecessary(mpCallBack))
{
CCopasiMessage(CCopasiMessage::ERROR, MCCopasiTask + 4, mpProblem->getModel()->getObjectName().c_str());
return false;
}
pdelete(mpInitialState);
mpInitialState = new CState(mpProblem->getModel()->getInitialState());
mDoOutput = of;
mpOutputHandler = pOutputHandler;
if (mDoOutput == NO_OUTPUT ||
mpOutputHandler == NULL) return true;
mOutputCounter = 0;
if (mDoOutput & REPORT)
{
if (mReport.open(getObjectDataModel(), pOstream) &&
mReport.getTarget() != "")
mpOutputHandler->addInterface(&mReport);
else if (pOstream == NULL)
CCopasiMessage(CCopasiMessage::COMMANDLINE, MCCopasiTask + 5, getObjectName().c_str());
}
std::vector< CCopasiContainer * > ListOfContainer;
ListOfContainer.push_back(this);
CCopasiDataModel* pDataModel = getObjectDataModel();
assert(pDataModel != NULL);
if (!mpOutputHandler->compile(ListOfContainer, pDataModel))
{
// Warning
CCopasiMessage(CCopasiMessage::WARNING, MCCopasiTask + 7);
success = false;
}
return success;
}
bool CScanTask::initSubtask(const OutputFlag & /* of */,
COutputHandler * pOutputHandler,
std::ostream * pOstream)
{
if (!mpProblem) fatalError();
CScanProblem * pProblem = dynamic_cast<CScanProblem *>(mpProblem);
if (!pProblem) fatalError();
//get the parameters from the problem
CTaskEnum::Task type = (CTaskEnum::Task) pProblem->getValue< unsigned C_INT32 >("Subtask");
CDataModel* pDataModel = getObjectDataModel();
assert(pDataModel != NULL);
switch (type)
{
case CTaskEnum::Task::steadyState:
mpSubtask = dynamic_cast<CCopasiTask*>
(&pDataModel->getTaskList()->operator[]("Steady-State"));
break;
case CTaskEnum::Task::timeCourse:
mpSubtask = dynamic_cast<CCopasiTask*>
(&pDataModel->getTaskList()->operator[]("Time-Course"));
break;
case CTaskEnum::Task::mca:
mpSubtask = dynamic_cast<CCopasiTask*>
(&pDataModel->getTaskList()->operator[]("Metabolic Control Analysis"));
break;
case CTaskEnum::Task::lyap:
mpSubtask = dynamic_cast<CCopasiTask*>
(&pDataModel->getTaskList()->operator[]("Lyapunov Exponents"));
break;
case CTaskEnum::Task::optimization:
mpSubtask = dynamic_cast<CCopasiTask*>
(&pDataModel->getTaskList()->operator[]("Optimization"));
break;
case CTaskEnum::Task::parameterFitting:
mpSubtask = dynamic_cast<CCopasiTask*>
(&pDataModel->getTaskList()->operator[]("Parameter Estimation"));
break;
case CTaskEnum::Task::sens:
mpSubtask = dynamic_cast<CCopasiTask*>
(&pDataModel->getTaskList()->operator[]("Sensitivities"));
break;
case CTaskEnum::Task::lna:
mpSubtask = dynamic_cast<CCopasiTask*>
(&pDataModel->getTaskList()->operator[]("Linear Noise Approximation"));
break;
case CTaskEnum::Task::tssAnalysis :
mpSubtask = dynamic_cast<CCopasiTask*>
(&pDataModel->getTaskList()->operator[](CTaskEnum::TaskName[CTaskEnum::Task::tssAnalysis]));
break;
case CTaskEnum::Task::crosssection:
mpSubtask = dynamic_cast<CCopasiTask*>
(&pDataModel->getTaskList()->operator[]("Cross Section"));
break;
default:
mpSubtask = NULL;
}
mOutputInSubtask = pProblem->getValue< bool >("Output in subtask");
mUseInitialValues = !pProblem->getContinueFromCurrentState();
if (!mpSubtask) return false;
mpSubtask->setMathContainer(mpContainer); //TODO
mpSubtask->setCallBack(NULL);
if (mOutputInSubtask)
return mpSubtask->initialize(OUTPUT, pOutputHandler, pOstream);
else
return mpSubtask->initialize(NO_OUTPUT, pOutputHandler, pOstream);
return true;
}
bool CCopasiTask::initialize(const OutputFlag & of,
COutputHandler * pOutputHandler,
std::ostream * pOstream)
{
bool success = true;
if (mpProblem == NULL)
{
CCopasiMessage(CCopasiMessage::ERROR, MCCopasiTask + 1, getObjectName().c_str());
return false;
}
if (mpContainer == NULL)
{
CCopasiMessage(CCopasiMessage::ERROR, MCCopasiTask + 2, getObjectName().c_str());
return false;
}
if (mpMethod == NULL)
{
CCopasiMessage(CCopasiMessage::ERROR, MCCopasiTask + 3, getObjectName().c_str());
return false;
}
if (mpContainer != NULL)
{
mInitialState = mpContainer->getInitialState();
}
else
{
mInitialState.resize(0);
}
mDoOutput = of;
mpOutputHandler = pOutputHandler;
if (mDoOutput == NO_OUTPUT ||
mpOutputHandler == NULL) return true;
mOutputCounter = 0;
if (mDoOutput & REPORT)
{
if (mReport.open(getObjectDataModel(), pOstream) &&
mReport.getTarget() != "")
mpOutputHandler->addInterface(&mReport);
else if (pOstream == NULL)
CCopasiMessage(CCopasiMessage::COMMANDLINE, MCCopasiTask + 5, getObjectName().c_str());
}
CObjectInterface::ContainerList ListOfContainer;
ListOfContainer.push_back(this);
if (mpContainer != NULL)
{
ListOfContainer.push_back(mpContainer);
}
if (!mpOutputHandler->compile(ListOfContainer))
{
// Warning
CCopasiMessage(CCopasiMessage::WARNING, MCCopasiTask + 7);
success = false;
}
return success;
}
