void IGenerator::updateSimulations(CExperiment &experiment) const
{
CSimulationsList sims;
foreach(const CGeneratorInput &input, createInputs(experiment.getConditions()))
sims.push_back(createSimulation(input));
experiment.setSimulations(sims);
}
void CQExperimentData::slotOK()
{
mpBtnOK->setFocus();
// Force the save all current changes.
slotExperimentChanged(NULL, NULL);
CExperiment * pExperiment;
size_t i = mpExperimentSet->getExperimentCount() - 1;
for (; i != C_INVALID_INDEX; i--)
{
pExperiment =
dynamic_cast<CExperiment *>(CCopasiRootContainer::getKeyFactory()->get(mKeyMap[mpExperimentSet->getExperiment(i)->CCopasiParameter::getKey()]));
if (pExperiment)
{
*mpExperimentSet->getExperiment(i) = *pExperiment;
mpExperimentSetCopy->removeParameter(pExperiment->getObjectName());
}
else
mpExperimentSet->removeExperiment(i);
}
emit experimentChanged();
for (i = 0; i < mpExperimentSetCopy->getExperimentCount(); i++)
mpExperimentSet->addExperiment(*mpExperimentSetCopy->getExperiment(i));
#ifdef COPASI_CROSSVALIDATION
if (mCrossValidation)
{
CCrossValidationSet * pSet = static_cast< CCrossValidationSet * >(mpExperimentSet);
if (QString::number(pSet->getWeight()) != mpEditWeight->text())
{
pSet->setWeight(mpEditWeight->text().toDouble());
}
if (QString::number(pSet->getThreshold()) != mpEditThreshold->text())
{
pSet->setThreshold(mpEditThreshold->text().toUInt());
}
}
#endif // COPASI_CROSSVALIDATION
pdelete(mpExperimentSetCopy);
accept();
}
void CQExperimentData::slotExperimentAdd()
{
mShowError = false;
CExperiment Experiment(mpDataModel);
CExperiment * pExperiment = mpExperimentSetCopy->addExperiment(Experiment);
size_t First, Last;
mpFileInfo->getFirstUnusedSection(First, Last);
pExperiment->setFirstRow((unsigned C_INT32) First);
pExperiment->setLastRow((unsigned C_INT32) Last);
pExperiment->setHeaderRow((unsigned C_INT32) First);
pExperiment->setFileName(mpFileInfo->getFileName());
pExperiment->setNumColumns((unsigned C_INT32) pExperiment->guessColumnNumber());
mpFileInfo->sync();
mpBoxExperiment->addItem(FROM_UTF8(pExperiment->getObjectName()));
mpBoxExperiment->setCurrentRow(mpBoxExperiment->count() - 1);
syncExperiments();
mpBtnExperimentAdd->setEnabled(mpFileInfo->getFirstUnusedSection(First, Last));
mShowError = true;
}
void CQExperimentData::slotCheckTo(bool checked)
{
mpCheckTo->setFocus();
if (!checked || !mpExperiment) return;
size_t Next =
mpExperimentSetCopy->keyToIndex(mpExperiment->CCopasiParameter::getKey()) + 1;
if (Next < mpExperimentSetCopy->getExperimentCount())
{
CExperiment * pNext = mpExperimentSetCopy->getExperiment(Next);
unsigned C_INT32 OldWeightMethod = mOldWeightMethod;
mOldWeightMethod = pNext->getWeightMethod();
saveExperiment(mpExperimentSetCopy->getExperiment(Next), false);
mOldWeightMethod = OldWeightMethod;
}
}
CExperiment * CExperimentSet::addExperiment(const CExperiment & experiment)
{
// We need to make sure that the experiment name is unique.
std::string name = experiment.getObjectName();
int i = 0;
while (getParameter(name))
{
i++;
name = StringPrint("%s_%d", experiment.getObjectName().c_str(), i);
}
CExperiment * pExperiment = new CExperiment(experiment, NO_PARENT);
pExperiment->setObjectName(name);
addParameter(pExperiment);
sort();
return pExperiment;
}
bool CQExperimentData::isLikePreviousExperiment(CExperiment * pExperiment)
{
if (!pExperiment) return false;
size_t Previous =
mpExperimentSetCopy->keyToIndex(pExperiment->CCopasiParameter::getKey()) - 1;
if (Previous == C_INVALID_INDEX) return false;
CExperiment * pPrevious = mpExperimentSetCopy->getExperiment(Previous);
if (pExperiment->getSeparator() != pPrevious->getSeparator()) return false;
if (pExperiment->getHeaderRow() != pPrevious->getHeaderRow()) return false;
if (pExperiment->getExperimentType() != pPrevious->getExperimentType()) return false;
if (mpExperiment != pExperiment)
{
if (pExperiment->getWeightMethod() != (CExperiment::WeightMethod) mOldWeightMethod) return false;
}
else
{
if ((CExperiment::WeightMethod) mOldWeightMethod != pPrevious->getWeightMethod()) return false;
}
if (!(pExperiment->getObjectMap() == pPrevious->getObjectMap())) return false;
return true;
}
void CQExperimentData::slotWeightMethod(int weightMethod)
{
if (mpExperiment == NULL) return;
if ((CExperiment::WeightMethod) weightMethod ==
mpExperiment->getWeightMethod()) return;
switch ((CExperiment::WeightMethod) weightMethod)
{
case CExperiment::VALUE_SCALING:
mpTable->horizontalHeaderItem(COL_SCALE)->setText("Epsilon");
break;
default:
mpTable->horizontalHeaderItem(COL_SCALE)->setText("Weight");
break;
}
size_t Current =
mpExperimentSetCopy->keyToIndex(mpExperiment->CCopasiParameter::getKey());
size_t Next = Current + 1;
// Find all experiments which are like this.
while (Next < mpExperimentSetCopy->getExperimentCount() && mpCheckTo->isChecked())
{
CExperiment * pNext = mpExperimentSetCopy->getExperiment(Next);
if (!isLikePreviousExperiment(pNext)) break;
Next++;
}
// Update each of them.
while (true)
{
Next--;
CExperiment * pNext = mpExperimentSetCopy->getExperiment(Next);
bool Changed = saveTable(pNext);
if (Changed)
{
std::ifstream File;
File.open(CLocaleString::fromUtf8(pNext->getFileName()).c_str());
size_t CurrentLine = 1;
pNext->read(File, CurrentLine);
pNext->compile();
}
pNext->setWeightMethod((CExperiment::WeightMethod) weightMethod);
pNext->calculateWeights();
if (Next == Current) break;
}
loadTable(mpExperiment, false);
}
bool IGenerator::isExperimentValid(const CExperiment &experiment, bool checkSimulations /*= true*/) const
{
if (experiment.getPluginName() != m_pluginName)
return false;
if (!isBoundaryConditionsValid(experiment.getConditions()))
return false;
if (!isSettingsValid(experiment.getSettings()))
return false;
if (!checkSimulations)
return true;
auto I = experiment.getSimulationsRef().constBegin();
auto E = experiment.getSimulationsRef().constEnd();
for (; I != E; ++I)
{
if (!isInputValid(I->getGeneratorInput()))
return false;
}
return true;
}
void IGenerator::updatePlots(CExperiment &experiment) const
{
experiment.setPlots(createPlots(experiment.getSimulationsRef()));
}
void CFitProblem::printResult(std::ostream * ostream) const
{
std::ostream & os = *ostream;
if (mSolutionVariables.size() == 0)
{
return;
}
os << "Objective Function Value:\t" << mSolutionValue << std::endl;
os << "Standard Deviation:\t" << mSD << std::endl;
CCopasiTimeVariable CPUTime = const_cast<CFitProblem *>(this)->mCPUTime.getElapsedTime();
os << "Function Evaluations:\t" << mCounter << std::endl;
os << "CPU Time [s]:\t"
<< CCopasiTimeVariable::LL2String(CPUTime.getSeconds(), 1) << "."
<< CCopasiTimeVariable::LL2String(CPUTime.getMilliSeconds(true), 3) << std::endl;
os << "Evaluations/Second [1/s]:\t" << mCounter / (C_FLOAT64)(CPUTime.getMilliSeconds() / 1e3) << std::endl;
os << std::endl;
std::vector< COptItem * >::const_iterator itItem =
mpOptItems->begin();
std::vector< COptItem * >::const_iterator endItem =
mpOptItems->end();
CFitItem * pFitItem;
CExperiment * pExperiment;
unsigned C_INT32 i, j;
os << "\tParameter\tValue\tGradient\tStandard Deviation" << std::endl;
for (i = 0; itItem != endItem; ++itItem, i++)
{
os << "\t" << (*itItem)->getObjectDisplayName();
pFitItem = static_cast<CFitItem *>(*itItem);
if (pFitItem->getExperimentCount() != 0)
{
os << " (";
for (j = 0; j < pFitItem->getExperimentCount(); j++)
{
if (j) os << ", ";
pExperiment =
dynamic_cast< CExperiment * >(CCopasiRootContainer::getKeyFactory()->get(pFitItem->getExperiment(j)));
if (pExperiment)
os << pExperiment->getObjectName();
}
os << ")";
}
if (mHaveStatistics)
{
os << ":\t" << mSolutionVariables[i];
os << "\t" << mGradient[i];
os << "\t" << mParameterSD[i];
}
else
{
os << ":\t" << std::numeric_limits<C_FLOAT64>::quiet_NaN();
os << "\t" << std::numeric_limits<C_FLOAT64>::quiet_NaN();
os << "\t" << std::numeric_limits<C_FLOAT64>::quiet_NaN();
}
os << std::endl;
}
os << std::endl;
if (mHaveStatistics)
{
os << "Parameter Interdependence:" << std::endl;
os << " " << mFisher << std::endl;
unsigned C_INT32 k, kmax = mpExperimentSet->getExperimentCount();
for (k = 0; k < kmax; k++)
{
mpExperimentSet->getExperiment(k)->printResult(ostream);
os << std::endl;
}
}
}
bool CFitProblem::calculate()
{
mCounter += 1;
bool Continue = true;
unsigned i, imax = mpExperimentSet->getExperimentCount();
unsigned j;
unsigned kmax;
mCalculateValue = 0.0;
CExperiment * pExp = NULL;
C_FLOAT64 * Residuals = mResiduals.array();
C_FLOAT64 * DependentValues = mExperimentDependentValues.array();
UpdateMethod ** pUpdate = mExperimentUpdateMethods.array();
std::vector<COptItem *>::iterator itItem;
std::vector<COptItem *>::iterator endItem = mpOptItems->end();
std::vector<COptItem *>::iterator itConstraint;
std::vector<COptItem *>::iterator endConstraint = mpConstraintItems->end();
std::vector< Refresh *>::const_iterator itRefresh;
std::vector< Refresh *>::const_iterator endRefresh;
// Reset the constraints memory
for (itConstraint = mpConstraintItems->begin(); itConstraint != endConstraint; ++itConstraint)
static_cast<CFitConstraint *>(*itConstraint)->resetConstraintViolation();
CFitConstraint **ppConstraint = mExperimentConstraints.array();
CFitConstraint **ppConstraintEnd;
try
{
for (i = 0; i < imax && Continue; i++) // For each experiment
{
pExp = mpExperimentSet->getExperiment(i);
mpModel->setInitialState(*mpInitialState);
mpModel->updateInitialValues();
// set the global and experiment local fit item values.
for (itItem = mpOptItems->begin(); itItem != endItem; itItem++, pUpdate++)
if (*pUpdate)
(**pUpdate)(static_cast<CFitItem *>(*itItem)->getLocalValue());
// Update initial values which changed due to the fit item values.
itRefresh = mExperimentInitialRefreshes[i].begin();
endRefresh = mExperimentInitialRefreshes[i].end();
while (itRefresh != endRefresh)
(**itRefresh++)();
kmax = pExp->getNumDataRows();
switch (pExp->getExperimentType())
{
case CCopasiTask::steadyState:
// set independent data
for (j = 0; j < kmax && Continue; j++) // For each data row;
{
pExp->updateModelWithIndependentData(j);
Continue = mpSteadyState->process(true);
if (!Continue)
{
mFailedCounter++;
mCalculateValue = mInfinity;
break;
}
// We check after each simulation whether the constraints are violated.
// Make sure the constraint values are up to date.
itRefresh = mExperimentConstraintRefreshes[i].begin();
endRefresh = mExperimentConstraintRefreshes[i].end();
for (; itRefresh != endRefresh; ++itRefresh)
(**itRefresh)();
ppConstraint = mExperimentConstraints[i];
ppConstraintEnd = ppConstraint + mExperimentConstraints.numCols();
for (; ppConstraint != ppConstraintEnd; ++ppConstraint)
if (*ppConstraint)(*ppConstraint)->calculateConstraintViolation();
if (mStoreResults)
mCalculateValue += pExp->sumOfSquaresStore(j, DependentValues);
else
mCalculateValue += pExp->sumOfSquares(j, Residuals);
}
break;
case CCopasiTask::timeCourse:
for (j = 0; j < kmax && Continue; j++) // For each data row;
{
if (j)
{
mpTrajectory->processStep(pExp->getTimeData()[j]);
}
else
{
// set independent data
pExp->updateModelWithIndependentData(j);
mpTrajectory->processStart(true);
if (pExp->getTimeData()[0] != mpModel->getInitialTime())
{
mpTrajectory->processStep(pExp->getTimeData()[0]);
}
}
// We check after each simulation step whether the constraints are violated.
// Make sure the constraint values are up to date.
itRefresh = mExperimentConstraintRefreshes[i].begin();
endRefresh = mExperimentConstraintRefreshes[i].end();
for (; itRefresh != endRefresh; ++itRefresh)
(**itRefresh)();
ppConstraint = mExperimentConstraints[i];
ppConstraintEnd = ppConstraint + mExperimentConstraints.numCols();
for (; ppConstraint != ppConstraintEnd; ++ppConstraint)
if (*ppConstraint)(*ppConstraint)->calculateConstraintViolation();
if (mStoreResults)
mCalculateValue += pExp->sumOfSquaresStore(j, DependentValues);
else
mCalculateValue += pExp->sumOfSquares(j, Residuals);
}
break;
default:
break;
}
// restore independent data
pExp->restoreModelIndependentData();
}
}
catch (CCopasiException)
{
// We do not want to clog the message cue.
CCopasiMessage::getLastMessage();
mFailedCounter++;
mCalculateValue = mInfinity;
if (pExp) pExp->restoreModelIndependentData();
}
catch (...)
{
mFailedCounter++;
mCalculateValue = mInfinity;
if (pExp) pExp->restoreModelIndependentData();
}
if (isnan(mCalculateValue))
mCalculateValue = mInfinity;
if (mpCallBack) return mpCallBack->progressItem(mhCounter);
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 CQFittingWidget::saveTask()
{
CFitTask * pTask =
dynamic_cast< CFitTask * >(mpTask);
if (!pTask) return false;
saveCommon();
saveMethod();
CFitProblem * pProblem =
dynamic_cast<CFitProblem *>(mpTask->getProblem());
if (!pProblem) return false;
std::map<std::string, std::string> ExperimentMap;
std::map<std::string, std::string> CrossValidationMap;
// Save experiment set
CExperimentSet * pExperimentSet =
dynamic_cast<CExperimentSet *>(pProblem->getGroup("Experiment Set"));
std::string Name;
CExperiment * pExperiment;
size_t i, imax;
std::set<CExperiment *> DealtWith;
for (i = pExperimentSet->getExperimentCount() - 1; i != C_INVALID_INDEX; i--)
{
pExperiment =
dynamic_cast<CExperiment *>(CCopasiRootContainer::getKeyFactory()->get(mExperimentKeyMap[pExperimentSet->getExperiment(i)->CCopasiParameter::getKey()]));
if (pExperiment && pExperiment == mpExperimentSet->getExperiment(pExperiment->getObjectName()))
{
if (!(*pExperimentSet->getExperiment(i) == *pExperiment))
{
*pExperimentSet->getExperiment(i) = *pExperiment;
mChanged = true;
}
DealtWith.insert(pExperiment);
}
else
{
mExperimentKeyMap.erase(pExperimentSet->getExperiment(i)->CCopasiParameter::getKey());
pExperimentSet->removeExperiment(i);
mChanged = true;
}
}
for (i = 0, imax = mpExperimentSet->getExperimentCount(); i < imax; i++)
{
pExperiment = mpExperimentSet->getExperiment(i);
if (DealtWith.count(pExperiment)) continue;
pExperiment = pExperimentSet->addExperiment(*pExperiment);
mExperimentKeyMap[pExperiment->CCopasiParameter::getKey()] =
mpExperimentSet->getExperiment(i)->CCopasiParameter::getKey();
mChanged = true;
}
// We need to invert the key map for saving!
std::map<std::string, std::string>::iterator it = mExperimentKeyMap.begin();
std::map<std::string, std::string>::iterator end = mExperimentKeyMap.end();
for (; it != end; ++it)
ExperimentMap[it->second] = it->first;
// Save cross validation experiment set
CCrossValidationSet * pCrossValidationSet =
dynamic_cast<CCrossValidationSet *>(pProblem->getGroup("Validation Set"));
if (pCrossValidationSet->getWeight() != mpCrossValidationSet->getWeight())
{
pCrossValidationSet->setWeight(mpCrossValidationSet->getWeight());
mChanged = true;
}
if (pCrossValidationSet->getThreshold() != mpCrossValidationSet->getThreshold())
{
pCrossValidationSet->setThreshold(mpCrossValidationSet->getThreshold());
mChanged = true;
}
DealtWith.clear();
for (i = pCrossValidationSet->getExperimentCount() - 1; i != C_INVALID_INDEX; i--)
{
pExperiment =
dynamic_cast<CExperiment *>(CCopasiRootContainer::getKeyFactory()->get(mCrossValidationKeyMap[pCrossValidationSet->getExperiment(i)->CCopasiParameter::getKey()]));
if (pExperiment && pExperiment == mpCrossValidationSet->getExperiment(pExperiment->getObjectName()))
{
if (!(*pCrossValidationSet->getExperiment(i) == *pExperiment))
{
*pCrossValidationSet->getExperiment(i) = *pExperiment;
mChanged = true;
}
DealtWith.insert(pExperiment);
}
else
{
mCrossValidationKeyMap.erase(pCrossValidationSet->getExperiment(i)->CCopasiParameter::getKey());
pCrossValidationSet->removeExperiment(i);
mChanged = true;
}
}
for (i = 0, imax = mpCrossValidationSet->getExperimentCount(); i < imax; i++)
{
pExperiment = mpCrossValidationSet->getExperiment(i);
if (DealtWith.count(pExperiment)) continue;
pExperiment = pCrossValidationSet->addExperiment(*pExperiment);
mCrossValidationKeyMap[pExperiment->CCopasiParameter::getKey()] =
mpCrossValidationSet->getExperiment(i)->CCopasiParameter::getKey();
mChanged = true;
}
// We need to invert the key map for saving!
it = mCrossValidationKeyMap.begin();
end = mCrossValidationKeyMap.end();
for (; it != end; ++it)
CrossValidationMap[it->second] = it->first;
if (mpCheckRandomize->isChecked() != pProblem->getRandomizeStartValues())
{
mChanged = true;
pProblem->setRandomizeStartValues(mpCheckRandomize->isChecked());
}
if (mpCreateParameterSets->isChecked() != pProblem->getCreateParameterSets())
{
mChanged = true;
pProblem->setCreateParameterSets(mpCreateParameterSets->isChecked());
}
if (mpCheckStatistics->isChecked() != pProblem->getCalculateStatistics())
{
mChanged = true;
pProblem->setCalculateStatistics(mpCheckStatistics->isChecked());
}
mChanged |= mpParameters->save(&ExperimentMap, &CrossValidationMap);
mChanged |= mpConstraints->save(&ExperimentMap, &CrossValidationMap);
assert(mpDataModel != NULL);
if (mChanged) mpDataModel->changed();
mChanged = false;
return true;
}
