// virtual bool CConcentrationReference::isPrerequisiteForContext(const CObjectInterface * pObject, const CMath::SimulationContextFlag & /* context */, const CObjectInterface::ObjectSet & changedObjects) const { // If the value is in the context, it does not depend on the object. if (changedObjects.find(this) != changedObjects.end()) return false; // Densities which are not in the context have to be recalculated. return true; }
// virtual bool CParticleReference::isPrerequisiteForContext(const CObjectInterface * pObject, const CMath::SimulationContextFlag & context , const CObjectInterface::ObjectSet & changedObjects) const { const CMetab * pSpecies = static_cast< const CMetab * >(getObjectParent()); if ((context & CMath::UseMoieties) && pSpecies->isDependent()) { return true; } // If the value is changed it must not be recalculated, i.e., it does not depend on the object. if (changedObjects.find(this) != changedObjects.end()) return false; // Amounts which are determine by assignment need to be recalculated. if (pSpecies->getStatus() == CModelEntity::ASSIGNMENT) return true; const CConcentrationReference * pConcentrationReference = NULL; if (getObjectName() != "ParticleNumber") { pConcentrationReference = pSpecies->getInitialConcentrationReference(); } else { pConcentrationReference = pSpecies->getConcentrationReference(); } // If the concentration was changed in the context we need to recalculate. if (changedObjects.find(pConcentrationReference) != changedObjects.end()) return true; return false; }
bool CCopasiObject::isPrerequisiteForContext(const CObjectInterface * pObject, const CMath::SimulationContextFlag & /* context */, const CObjectInterface::ObjectSet & changedObjects) const { // If the object is among the changed objects it does not depend on anything else. if (changedObjects.find(this) != changedObjects.end()) return false; #ifdef COPASI_DEBUG const CObjectInterface::ObjectSet & Prerequisites = getPrerequisites(); // This method should only be called for objects which are prerequisites. // We check for this only in debug mode. assert(Prerequisites.find(pObject) != Prerequisites.end()); #endif // COPASI_DEBUG return true; }
// virtual bool CMathObject::isPrerequisiteForContext(const CObjectInterface * pObject, const CMath::SimulationContextFlag & context, const CObjectInterface::ObjectSet & changedObjects) const { // This method should only be called for objects which are prerequisites. // We check for this only in debug mode. assert(mPrerequisites.find(pObject) != mPrerequisites.end()); switch (mEntityType) { case CMath::Moiety: if ((context & CMath::UpdateMoieties) && mValueType == CMath::TotalMass) { return true; } if ((context & CMath::UseMoieties) && mValueType == CMath::DependentMass) { return true; } return false; break; case CMath::Species: // For species we need to account for the duality of the intensive and extensive value if (mValueType != CMath::Value) return true; if ((context & CMath::UseMoieties) && mSimulationType == CMath::Dependent && !mIsIntensiveProperty) { if (mpCorrespondingProperty != pObject) { return true; } return false; } // If the value is in the context, it does not depend on the object. if (changedObjects.find(this) != changedObjects.end()) return false; if (mIsIntensiveProperty) { // Densities which are not in the context have to be recalculated. return true; } else { // Amount which are determine by assignment need to be recalculated. if (mSimulationType == CMath::Assignment) return true; // If the concentration was changed in the context we need to recalculate. if (changedObjects.find(mpCorrespondingProperty) != changedObjects.end()) return true; // If the concentration is calculated by an assignment we need to recalculate. if (mpCorrespondingProperty->getSimulationType() == CMath::Assignment) return true; return false; } break; case CMath::Event: if ((context & CMath::EventHandling) && mValueType == CMath::Discontinuous) { switch ((int) mpExpression->getRoot()->getType()) { case (CEvaluationNode::CHOICE | CEvaluationNodeChoice::IF): { const CMathObject * pMathObject = dynamic_cast< const CMathObject * >(pObject); if (pMathObject != NULL && pMathObject->mValueType == CMath::EventTrigger) { return false; } return true; } break; case (CEvaluationNode::FUNCTION | CEvaluationNodeFunction::FLOOR): return false; break; case (CEvaluationNode::FUNCTION | CEvaluationNodeFunction::CEIL): return false; break; default: return true; } } return true; break; case CMath::Delay: if (context & CMath::EventHandling) { return true; } return (mValueType == CMath::DelayLag); break; default: return true; } // This should never be reached. return true; }
bool CExperimentSet::compile(const CMathContainer * pMathContainer) { bool success = true; // First we need to sort the experiments so that we can make use of continued // file reading. sort(); CObjectInterface::ObjectSet DependentObjects; std::ifstream in; std::string CurrentFileName(""); size_t CurrentLineNumber = 1; std::vector< CExperiment * >::iterator it = mpExperiments->begin() + mNonExperiments; std::vector< CExperiment * >::iterator end = mpExperiments->end(); for (; it != end; ++it) { if (CurrentFileName != (*it)->getFileName()) { CurrentFileName = (*it)->getFileName(); CurrentLineNumber = 1; if (in.is_open()) { in.close(); in.clear(); } in.open(CLocaleString::fromUtf8(CurrentFileName).c_str(), std::ios::binary); if (in.fail()) { CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 8, CurrentFileName.c_str()); return false; // File can not be opened. } } if (!(*it)->read(in, CurrentLineNumber)) { return false; } if (!(*it)->compile(pMathContainer)) { return false; } const std::map< const CObjectInterface *, size_t > & ExpDependentObjects = (*it)->getDependentObjectsMap(); std::map< const CObjectInterface *, size_t >::const_iterator itObject = ExpDependentObjects.begin(); std::map< const CObjectInterface *, size_t >::const_iterator endObject = ExpDependentObjects.end(); for (; itObject != endObject; ++itObject) { DependentObjects.insert(itObject->first); } } mDependentObjects.resize(DependentObjects.size()); const CObjectInterface ** ppInsert = mDependentObjects.array(); CObjectInterface::ObjectSet::const_iterator itObject = DependentObjects.begin(); CObjectInterface::ObjectSet::const_iterator endObject = DependentObjects.end(); for (; itObject != endObject; ++itObject, ++ppInsert) *ppInsert = *itObject; // Allocation and initialization of statistical information mDependentObjectiveValues.resize(mDependentObjects.size()); mDependentObjectiveValues = std::numeric_limits<C_FLOAT64>::quiet_NaN(); mDependentRMS.resize(mDependentObjects.size()); mDependentRMS = std::numeric_limits<C_FLOAT64>::quiet_NaN(); mDependentErrorMean.resize(mDependentObjects.size()); mDependentErrorMean = std::numeric_limits<C_FLOAT64>::quiet_NaN(); mDependentErrorMeanSD.resize(mDependentObjects.size()); mDependentErrorMeanSD = std::numeric_limits<C_FLOAT64>::quiet_NaN(); mDependentDataCount.resize(mDependentObjects.size()); mDependentDataCount = std::numeric_limits<size_t>::quiet_NaN(); return success; }
bool CMathDependencyGraph::getUpdateSequence(const CMath::SimulationContextFlag & context, const CObjectInterface::ObjectSet & changedObjects, const CObjectInterface::ObjectSet & requestedObjects, CObjectInterface::UpdateSequence & updateSequence) { bool success = true; iterator found; iterator notFound = mObjects2Nodes.end(); updateSequence.clear(); CObjectInterface::ObjectSet::const_iterator it = changedObjects.begin(); CObjectInterface::ObjectSet::const_iterator end = changedObjects.end(); const_iterator itCheck = mObjects2Nodes.begin(); const_iterator endCheck = mObjects2Nodes.end(); // Mark all nodes which are changed or need to be calculated for (; it != end && success; ++it) { found = mObjects2Nodes.find(*it); if (found != notFound) { success &= found->second->updateDependentState(context, changedObjects); continue; } success = false; } if (!success) goto finish; it = requestedObjects.begin(); end = requestedObjects.end(); // Mark all nodes which are requested and its prerequisites. for (; it != end && success; ++it) { found = mObjects2Nodes.find(*it); if (found != notFound) { found->second->setRequested(true); success &= found->second->updatePrerequisiteState(context, changedObjects); continue; } success = false; } #ifdef COPASI_DEBUG_TRACE { std::ofstream GetUpdateSequence("GetUpdateSequence.dot"); exportDOTFormat(GetUpdateSequence, "GetUpdateSequence"); GetUpdateSequence.close(); } #endif //COPASI_DEBUG_TRACE if (!success) goto finish; it = requestedObjects.begin(); end = requestedObjects.end(); for (; it != end && success; ++it) { found = mObjects2Nodes.find(*it); if (found != notFound) { success &= found->second->buildUpdateSequence(context, updateSequence); continue; } success = false; } if (!success) goto finish; for (; itCheck != endCheck; ++itCheck) { // Reset the dependency nodes for the next call. itCheck->second->setChanged(false); itCheck->second->setRequested(false); } finish: if (!success) { updateSequence.clear(); CCopasiMessage(CCopasiMessage::ERROR, MCMathModel + 3, (*it)->getCN().c_str()); } #ifdef XXXX CObjectInterface::UpdateSequence::const_iterator itSeq = updateSequence.begin(); CObjectInterface::UpdateSequence::const_iterator endSeq = updateSequence.end(); std::cout << std::endl << "Start" << std::endl; for (; itSeq != endSeq; ++itSeq) { if (dynamic_cast< const CMathObject * >(*itSeq)) { std::cout << *static_cast< const CMathObject * >(*itSeq); } else { std::cout << (*itSeq)->getCN() << std::endl; } } std::cout << "End" << std::endl; #endif // return success; }