void CStochDirectMethod::start()
{
CTrajectoryMethod::start();
/* get configuration data */
mMaxSteps = getValue< C_INT32 >("Max Internal Steps");
mpRandomGenerator = &mpContainer->getRandomGenerator();
if (getValue< bool >("Use Random Seed"))
{
mpRandomGenerator->initialize(getValue< unsigned C_INT32 >("Random Seed"));
}
//mpCurrentState is initialized. This state is not used internally in the
//stochastic solver, but it is used for returning the result after each step.
//========Initialize Roots Related Arguments========
mNumRoot = mpContainer->getRoots().size();
mRootsFound.resize(mNumRoot);
mRootsA.resize(mNumRoot);
mRootsB.resize(mNumRoot);
mpRootValueNew = &mRootsA;
mpRootValueOld = &mRootsB;
mRootsNonZero.resize(mNumRoot);
mRootsNonZero = 0.0;
CMathObject * pRootObject = mpContainer->getMathObject(mpContainer->getRoots().array());
CMathObject * pRootObjectEnd = pRootObject + mNumRoot;
CObjectInterface::ObjectSet Requested;
for (; pRootObject != pRootObjectEnd; ++pRootObject)
{
Requested.insert(pRootObject);
}
CObjectInterface::ObjectSet Changed;
// Determine whether we have time dependent roots;
CObjectInterface * pTimeObject = mpContainer->getMathObject(mpContainerStateTime);
Changed.insert(pTimeObject);
mpContainer->getTransientDependencies().getUpdateSequence(mUpdateTimeDependentRoots, CMath::Default, Changed, Requested);
mHaveTimeDependentRoots = (mUpdateTimeDependentRoots.size() > 0);
// Build the reaction dependencies
mReactions.initialize(mpContainer->getReactions());
mNumReactions = mReactions.size();
mAmu.initialize(mpContainer->getPropensities());
mPropensityObjects.initialize(mAmu.size(), mpContainer->getMathObject(mAmu.array()));
mUpdateSequences.resize(mNumReactions);
CMathReaction * pReaction = mReactions.array();
CMathReaction * pReactionEnd = pReaction + mNumReactions;
CObjectInterface::UpdateSequence * pUpdateSequence = mUpdateSequences.array();
CMathObject * pPropensityObject = mPropensityObjects.array();
CMathObject * pPropensityObjectEnd = pPropensityObject + mPropensityObjects.size();
for (; pPropensityObject != pPropensityObjectEnd; ++pPropensityObject)
{
Requested.insert(pPropensityObject);
}
pPropensityObject = mPropensityObjects.array();
for (; pReaction != pReactionEnd; ++pReaction, ++pUpdateSequence, ++pPropensityObject)
{
Changed = pReaction->getChangedObjects();
// The time is always updated
Changed.insert(pTimeObject);
pUpdateSequence->clear();
mpContainer->getTransientDependencies().getUpdateSequence(*pUpdateSequence, CMath::Default, Changed, Requested);
}
mMaxStepsReached = false;
mTargetTime = *mpContainerStateTime;
mNextReactionTime = *mpContainerStateTime;
mNextReactionIndex = C_INVALID_INDEX;
stateChange(CMath::State);
return;
}
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;
}