DataFlowVisualization Class Reference

class to visualize data flow between modules. More...

#include <DataFlowVisualization.h>

Public Member Functions
	DataFlowVisualization (const DependencyMap *dependencyMap)
	Constructor.
void	visualizePath (const std::string &filename, const Path &path)
	Create graphs with datastore inputs/outputs of each module in path.

Static Public Member Functions
static void	executeModuleAndCreateIOPlot (const std::string &module)
	Create independent I/O graph for a single module (without requiring a steering file).

Private Member Functions
void	generateModulePlot (std::ofstream &file, const Module &mod, bool steeringFileFlow=false)
	Create I/O graph for a single module (written to file).
bool	checkArrayUnknown (const std::string &name, const DependencyMap::ModuleInfo &info)
	If the given array name isn't found in any of info's fields, it is added to m_unknownArrays (and true returned).

Static Private Member Functions
static void	plotPath (std::ofstream &file, const Path &path, const std::string &pathName="")
	Create a subgraph for the given Path (including conditional paths).

Private Attributes
const DependencyMap *	m_map
	Stores information on inputs/outputs of each module, as obtained by require()/createEntry();.
std::set< std::string >	m_allInputs
	set of all inputs (including optionals), for steering file visualisation.
std::set< std::string >	m_allOutputs
	set of all outputs, for steering file visualisation.
std::set< std::string >	m_unknownArrays
	set of array only being used in relations, for steering file visualisation.
std::string	m_fillcolor [DependencyMap::c_NEntryTypes]
	fill colors.
std::string	m_arrowcolor [DependencyMap::c_NEntryTypes]
	arrow colors.

Detailed Description

class to visualize data flow between modules.

Definition at line 24 of file DataFlowVisualization.h.

Constructor & Destructor Documentation

DataFlowVisualization()

DataFlowVisualization ( const DependencyMap *  dependencyMap )

explicit

Constructor.

Definition at line 26 of file DataFlowVisualization.cc.

                                                                              :
  m_map(dependencyMap)
{
  m_fillcolor[DependencyMap::c_Input] = "cornflowerblue";
  m_fillcolor[DependencyMap::c_OptionalInput] = "lightblue";
  m_fillcolor[DependencyMap::c_Output] = "orange";
 
  m_arrowcolor[DependencyMap::c_Input] = "cornflowerblue";
  m_arrowcolor[DependencyMap::c_OptionalInput] = "lightblue";
  m_arrowcolor[DependencyMap::c_Output] = "firebrick";
}

Member Function Documentation

checkArrayUnknown()

bool checkArrayUnknown ( const std::string &  name, const DependencyMap::ModuleInfo &  info  )

private

If the given array name isn't found in any of info's fields, it is added to m_unknownArrays (and true returned).

Definition at line 189 of file DataFlowVisualization.cc.

{
  for (const auto& entry : info.entries) {
    if (entry.count(name) != 0)
      return false; //found
  }
 
  //not found
  m_unknownArrays.insert(name);
  return true;
}

executeModuleAndCreateIOPlot()

void executeModuleAndCreateIOPlot ( const std::string &  module )

static

Create independent I/O graph for a single module (without requiring a steering file).

Output will be saved to ModuleName.dot.

Definition at line 165 of file DataFlowVisualization.cc.

{
  // construct given module and gearbox
  std::shared_ptr<Module> modulePtr = ModuleManager::Instance().registerModule(module);
  std::shared_ptr<Module> gearboxPtr = ModuleManager::Instance().registerModule("Gearbox");
 
  // call initialize() method
  //may throw some ERRORs, but that's OK.
  // TODO:(ignore missing inputs)
  gearboxPtr->initialize();
  DataStore::Instance().getDependencyMap().setModule(*modulePtr);
  modulePtr->initialize();
 
  // create plot
  const std::string filename = module + ".dot";
  DataFlowVisualization v(&DataStore::Instance().getDependencyMap());
  std::ofstream file(filename.c_str());
  v.generateModulePlot(file, *modulePtr, false);
 
  //clean up to avoid problems with ~TROOT
  modulePtr->terminate();
  gearboxPtr->terminate();
}

generateModulePlot()

void generateModulePlot ( std::ofstream &  file, const Module &  mod, bool  steeringFileFlow = false  )

private

Create I/O graph for a single module (written to file).

Definition at line 106 of file DataFlowVisualization.cc.

{
  const std::string& name = DependencyMap::getModuleID(mod);
  const std::string& label = mod.getName();
  if (!steeringFileFlow)
    file << "digraph \"" << name << "\" {\n";
  file << " " << name << " [label=\"" << label << "\"];\n";
 
  const auto foundInfoIter = m_map->getModuleInfoMap().find(name);
  if (foundInfoIter != m_map->getModuleInfoMap().end()) {
    const DependencyMap::ModuleInfo& moduleInfo = foundInfoIter->second;
    for (int i = 0; i < DependencyMap::c_NEntryTypes; i++) {
      const std::set<std::string>& entries = moduleInfo.entries[i];
      const std::set<std::string>& relations = moduleInfo.relations[i];
      const std::string fillcolor = m_fillcolor[i];
      const std::string arrowcolor = m_arrowcolor[i];
 
      for (const std::string& dsentry : entries) {
        if (!steeringFileFlow)
          file << "  \"" << dsentry << "\" [shape=box,style=filled,fillcolor=" << fillcolor << "];\n";
        if (i == DependencyMap::c_Output) {
          m_allOutputs.insert(dsentry);
          file << "  \"" << name << "\" -> \"" << dsentry << "\" [color=" << arrowcolor << "];\n";
        } else {
          m_allInputs.insert(dsentry);
          file << "  \"" << dsentry << "\" -> \"" << name  << "\" [color=" << arrowcolor << "];\n";
        }
      }
 
      for (const std::string& relname : relations) {
        size_t pos = relname.rfind("To");
        if (pos == std::string::npos or pos != relname.find("To")) {
          B2WARNING("generateModulePlot(): couldn't split relation name!");
          //Searching for parts in input/output lists might be helpful...
          continue;
        }
 
        const std::string from = relname.substr(0, pos);
        const std::string to = relname.substr(pos + 2);
 
        //any connected arrays that are neither input nor output?
        if (checkArrayUnknown(from, moduleInfo)) {
          if (!steeringFileFlow)
            file << "  \"" << from << "\" [shape=box,style=filled,fillcolor=" << unknownfillcolor << "];\n";
        }
        if (checkArrayUnknown(to, moduleInfo)) {
          if (!steeringFileFlow)
            file << "  \"" << to << "\" [shape=box,style=filled,fillcolor=" << unknownfillcolor << "];\n";
        }
 
        file << "  \"" << from << "\" -> \"" << to << "\" [color=" << arrowcolor << ",style=dashed];\n";
      }
    }
  }
  if (!steeringFileFlow)
    file << "}\n\n";
}

plotPath()

void plotPath ( std::ofstream &  file, const Path &  path, const std::string &  pathName = ""  )

staticprivate

Create a subgraph for the given Path (including conditional paths).

Definition at line 71 of file DataFlowVisualization.cc.

{
  //graph name must begin with cluster for fancy graphics!
  const std::string graphname = pathName.empty() ? "clusterMain" : ("cluster" + pathName);
  file << "  subgraph \"" << graphname << "\" {\n";
  if (pathName.empty()) {
    file << "    rank=min;\n";
  } else {
    file << "    rank=same;\n";
  }
  file << "    style=solid;\n";
  file << "    color=grey;\n";
  file << "    \"" << graphname  << "_inv\" [shape=point,style=invis];\n";
  std::string lastModule("");
  //connect modules in right order...
  for (const ModulePtr& mod : path.getModules()) {
    const std::string& module = DependencyMap::getModuleID(*mod);
    file << "    \"" << module << "\";\n";
    if (!lastModule.empty()) {
      file << "    \"" << lastModule << "\" -> \"" << module << "\" [color=black];\n";
    }
    if (mod->hasCondition()) {
      for (const auto& condition : mod->getAllConditions()) {
        const std::string& conditionName = condition.getString();
        plotPath(file, *condition.getPath(), conditionName);
        file << "    \"" << module << "\" -> \"cluster" << conditionName << "_inv\" " <<
             "[color=grey,lhead=\"cluster" << conditionName << "\",label=\"" << conditionName << "\",fontcolor=grey];\n";
      }
    }
 
    lastModule = module;
  }
  file << "  }\n";
}

visualizePath()

void visualizePath	(	const std::string &	filename,
		const Path &	path
	)

Create graphs with datastore inputs/outputs of each module in path.

Parameters

filename	file saved to (in DOT format).
path	Path to visualize.

Definition at line 38 of file DataFlowVisualization.cc.

{
  std::ofstream file(filename.c_str());
  file << "digraph allModules {\n";
  file << "  rankdir=LR;\n"; //left -> right
  file << "  compound=true;\n"; //allow edges to subgraphs
 
  //for steering file data flow graph, we may get multiple definitions of each node
  //graphviz merges these into the last one, so we'll go through module list in reverse (all boxes should be coloured as outputs)
  const bool steeringFileFlow = true;
  for (const ModulePtr& mod : path.buildModulePathList())
    generateModulePlot(file, *mod, steeringFileFlow);
 
  plotPath(file, path);
 
  //add nodes
  for (const std::string& name : m_allOutputs) {
    file << "  \"" << name << "\" [shape=box,style=filled,fillcolor=" << m_fillcolor[DependencyMap::c_Output] << "];\n";
  }
  for (const std::string& name : m_allInputs) {
    if (m_allOutputs.count(name) == 0)
      file << "  \"" << name << "\" [shape=box,style=filled,fillcolor=" << m_fillcolor[DependencyMap::c_Input] << "];\n";
  }
  for (const std::string& name : m_unknownArrays) {
    if (m_allOutputs.count(name) == 0 && m_allInputs.count(name) == 0)
      file << "  \"" << name << "\" [shape=box,style=filled,fillcolor=" << unknownfillcolor << "];\n";
  }
 
  file << "}\n\n";
 
  B2INFO("Data flow diagram created. You can use 'dot dataflow.dot -Tps -o dataflow.ps' to create a PostScript file from it.");
}

Member Data Documentation

m_allInputs

std::set<std::string> m_allInputs

private

set of all inputs (including optionals), for steering file visualisation.

Definition at line 54 of file DataFlowVisualization.h.

m_allOutputs

std::set<std::string> m_allOutputs

private

set of all outputs, for steering file visualisation.

Definition at line 55 of file DataFlowVisualization.h.

m_arrowcolor

std::string m_arrowcolor[DependencyMap::c_NEntryTypes]

private

arrow colors.

Definition at line 59 of file DataFlowVisualization.h.

m_fillcolor

std::string m_fillcolor[DependencyMap::c_NEntryTypes]

private

fill colors.

Definition at line 58 of file DataFlowVisualization.h.

m_map

const DependencyMap* m_map

private

Stores information on inputs/outputs of each module, as obtained by require()/createEntry();.

Definition at line 52 of file DataFlowVisualization.h.

m_unknownArrays

std::set<std::string> m_unknownArrays

private

set of array only being used in relations, for steering file visualisation.

Definition at line 56 of file DataFlowVisualization.h.

---

The documentation for this class was generated from the following files:

• framework/core/include/DataFlowVisualization.h
• framework/core/src/DataFlowVisualization.cc