#include <CMathDependencyGraph.h>

Collaboration diagram for CMathDependencyGraph:

Public Types
typedef NodeMap::const_iterator	const_iterator

typedef NodeMap::iterator	iterator

typedef std::map< const CObjectInterface , CMathDependencyNode >	NodeMap

Public Member Functions
iterator	addObject (const CObjectInterface *pObject)

void	clear ()

	CMathDependencyGraph ()

void	exportDOTFormat (std::ostream &os, const std::string &name) const

bool	getUpdateSequence (const CMath::SimulationContextFlag &context, const CObjectInterface::ObjectSet &changedObjects, const CObjectInterface::ObjectSet &requestedObjects, CObjectInterface::UpdateSequence &updateSequence)

	~CMathDependencyGraph ()

Private Member Functions
std::string	getDOTNodeId (const CObjectInterface *pObject) const

Private Attributes
std::map< const CObjectInterface *, size_t >	mObject2Index

NodeMap	mObjects2Nodes

Detailed Description

Definition at line 18 of file CMathDependencyGraph.h.

Member Typedef Documentation

typedef NodeMap::const_iterator CMathDependencyGraph::const_iterator

Definition at line 23 of file CMathDependencyGraph.h.

typedef NodeMap::iterator CMathDependencyGraph::iterator

Definition at line 22 of file CMathDependencyGraph.h.

typedef std::map< const CObjectInterface *, CMathDependencyNode * > CMathDependencyGraph::NodeMap

Definition at line 21 of file CMathDependencyGraph.h.

Constructor & Destructor Documentation

CMathDependencyGraph::CMathDependencyGraph ( )

Constructor

Definition at line 18 of file CMathDependencyGraph.cpp.

                                           :
   mObjects2Nodes(),
   mObject2Index()
 {}

CMathDependencyGraph::~CMathDependencyGraph ( )

Destructor

Definition at line 23 of file CMathDependencyGraph.cpp.

References clear().

 {
   clear();
 }

Member Function Documentation

CMathDependencyGraph::iterator CMathDependencyGraph::addObject ( const CObjectInterface * pObject )

Add an object and all its prerequisites to the tree

Parameters

const CObjectInterface * pObject

Returns: std::map< const CObjectInterface *, CMathDependencyNode * >::iterator itObject

Definition at line 41 of file CMathDependencyGraph.cpp.

References CObjectInterface::getPrerequisites(), and mObjects2Nodes.

Referenced by CModel::buildDependencyGraphs(), and CMathContainer::createDependencyGraphs().

 {
   iterator found = mObjects2Nodes.find(pObject);
 
   if (found == mObjects2Nodes.end())
     {
       found = mObjects2Nodes.insert(std::make_pair(pObject, new CMathDependencyNode(pObject))).first;
 
       const CObjectInterface::ObjectSet & Prerequisites = pObject->getPrerequisites();
       CObjectInterface::ObjectSet::const_iterator it = Prerequisites.begin();
       CObjectInterface::ObjectSet::const_iterator end = Prerequisites.end();
 
       for (; it != end; ++it)
         {
           iterator foundPrerequisite = mObjects2Nodes.find(*it);
 
           if (foundPrerequisite == mObjects2Nodes.end())
             {
               foundPrerequisite = addObject(*it);
             }
 
           foundPrerequisite->second->addDependent(found->second);
           found->second->addPrerequisite(foundPrerequisite->second);
         }
     }
 
   return found;
 }

void CMathDependencyGraph::clear ( )

Clear the whole dependency tree

Definition at line 28 of file CMathDependencyGraph.cpp.

References mObjects2Nodes.

Referenced by CModel::buildDependencyGraphs(), and ~CMathDependencyGraph().

 {
   iterator it = mObjects2Nodes.begin();
   iterator end = mObjects2Nodes.end();
 
   for (; it != end; ++it)
     {
       delete(it->second);
     }
 
   mObjects2Nodes.clear();
 }

void CMathDependencyGraph::exportDOTFormat	(	std::ostream &	os,
		const std::string &	name
	)		const

Definition at line 191 of file CMathDependencyGraph.cpp.

References getDOTNodeId(), CObjectInterface::getObject(), mObject2Index, and mObjects2Nodes.

Referenced by CModel::buildDependencyGraphs(), CMathContainer::createDependencyGraphs(), and getUpdateSequence().

 {
   os << "digraph " << name << " {" << std::endl;
   os << "rankdir=LR;" << std::endl;
 
   mObject2Index.clear();
 
   const_iterator it = mObjects2Nodes.begin();
   const_iterator end = mObjects2Nodes.end();
 
   for (; it != end; ++it)
     {
       const CObjectInterface * pObject = it->second->getObject();
 
       const std::vector< CMathDependencyNode * > & Dependents = it->second->getDependents();
       std::vector< CMathDependencyNode * >::const_iterator itDep = Dependents.begin();
       std::vector< CMathDependencyNode * >::const_iterator endDep = Dependents.end();
 
       for (; itDep != endDep; ++itDep)
         {
           os << "\"";
           os << getDOTNodeId(pObject);
           os << ((it->second->isChanged()) ? "\\nC" : "\\no");
           os << ((it->second->isRequested()) ? "R" : "o");
           os << "\"";
           os << " -> ";
           os << "\"";
           os << getDOTNodeId((*itDep)->getObject());
           os << (((*itDep)->isChanged()) ? "\\nC" : "\\no");
           os << (((*itDep)->isRequested()) ? "R" : "o");
           os << "\"";
           os << ";" << std::endl;
         }
     }
 
   os << "}" << std::endl;
 }

std::string CMathDependencyGraph::getDOTNodeId ( const CObjectInterface * pObject ) const

private

Definition at line 230 of file CMathDependencyGraph.cpp.

References CMath::DependentMass, CMath::Discontinuous, CMath::EventAssignment, CMath::EventDelay, CMath::EventPriority, CMath::EventRoot, CMath::EventRootState, CMath::EventTrigger, CMath::Flux, CMathObject::getDataObject(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CMathObject::getValueType(), mObject2Index, CMath::ParticleFlux, CMath::Propensity, CMath::Rate, CMath::TotalMass, CMath::Value, and CMath::ValueTypeUndefined.

Referenced by exportDOTFormat().

 {
   const CCopasiObject * pDataObject = dynamic_cast< const CCopasiObject * >(pObject);
   const CMathObject * pMathObject = dynamic_cast< const CMathObject * >(pObject);
 
   if (pDataObject == NULL && pMathObject == NULL)
     {
       return "Invalid Node";
     }
 
   if (pDataObject == NULL)
     {
       pDataObject = pMathObject->getDataObject();
     }
 
   if (pDataObject == NULL)
     {
       std::ostringstream os;
 
       switch (pMathObject->getValueType())
         {
           case CMath::ValueTypeUndefined:
             os << "ValueTypeUndefined";
             break;
 
           case CMath::Value:
             os << "Value";
             break;
 
           case CMath::Rate:
             os << "ValueRate";
             break;
 
           case CMath::ParticleFlux:
             os << "ParticleFlux";
             break;
 
           case CMath::Flux:
             os << "Flux";
             break;
 
           case CMath::Propensity:
             os << "Propensity";
             break;
 
           case CMath::TotalMass:
             os << "TotalMass";
             break;
 
           case CMath::DependentMass:
             os << "DependentMass";
             break;
 
           case CMath::Discontinuous:
             os << "Discontinuous";
             break;
 
           case CMath::EventDelay:
             os << "EventDelay";
             break;
 
           case CMath::EventPriority:
             os << "EventPriority";
             break;
 
           case CMath::EventAssignment:
             os << "EventAssignment";
             break;
 
           case CMath::EventTrigger:
             os << "EventTrigger";
             break;
 
           case CMath::EventRoot:
             os << "EventRoot";
             break;
 
           case CMath::EventRootState:
             os << "EventRootState";
             break;
         }
 
       std::map< const CObjectInterface *, size_t >::const_iterator found = mObject2Index.find(pMathObject);
 
       if (found != mObject2Index.end())
         {
           os << "::"  << found->second;
         }
       else
         {
           os << "::"  << mObject2Index.size();
           mObject2Index[pMathObject] = mObject2Index.size();
         }
 
       return os.str();
     }
 
   return pDataObject->getObjectParent()->getObjectName() + "::" + pDataObject->getObjectName();
 }

bool CMathDependencyGraph::getUpdateSequence	(	const CMath::SimulationContextFlag &	context,
		const CObjectInterface::ObjectSet &	changedObjects,
		const CObjectInterface::ObjectSet &	requestedObjects,
		CObjectInterface::UpdateSequence &	updateSequence
	)

Construct a update sequence for the given context

Parameters

const	CMath::SimulationContextFlag & context
const	CObjectInterface::ObjectSet & changedObjects
const	CObjectInterface::ObjectSet & requestedObjects
CObjectInterface::UpdateSequence	& updateSequence)

Returns: bool success

Definition at line 70 of file CMathDependencyGraph.cpp.

References CCopasiMessage::ERROR, exportDOTFormat(), MCMathModel, and mObjects2Nodes.

Referenced by CMathContainer::createApplyInitialValuesSequence(), CMathContainer::createSynchronizeInitialValuesSequence(), CMathContainer::createUpdateSimulationValuesSequence(), and CModel::getUpdateSequence().

 {
 
   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;
 }