//=======================================================================
template<typename Traits>
void PHX::EvaluatorManager<Traits>::
writeGraphvizFile(const std::string filename,
		  bool writeEvaluatedFields,
		  bool writeDependentFields,
		  bool debugRegisteredEvaluators) const
{
#if defined(BOOST_VERSION)&&(BOOST_VERSION>=104200)

  using std::string;
  using std::vector;
  using std::map;
  using std::pair;
  using Teuchos::RCP;
  using PHX::FieldTag;

  TEST_FOR_EXCEPTION(!sorting_called_ && !debugRegisteredEvaluators, std::logic_error, "Error sorting of evaluators must be done before writing graphviz file.");

  // Create the Graph object and attribute vectors
  typedef boost::GraphvizDigraph Graph;
  Graph g_dot;

  boost::property_map<Graph,boost::vertex_attribute_t>::type
    vertex_attr_map = get(boost::vertex_attribute, g_dot);
  
  boost::property_map<Graph,boost::edge_attribute_t>::type
    edge_attr_map = get(boost::edge_attribute, g_dot);

  typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
  typedef typename boost::graph_traits<Graph>::edge_descriptor edge_t;

  // link fields to their evaluators
  std::vector< Teuchos::RCP<PHX::Evaluator<Traits> > > evaluators;
  if (!debugRegisteredEvaluators) {
    for (vector<int>::const_iterator index = providerEvalOrderIndex.begin(); 
	 index != providerEvalOrderIndex.end(); ++index)
      evaluators.push_back(varProviders[*index]);
  }
  else{
    evaluators = varProviders;
  }

  map<string,vertex_t> field_to_evaluator_index;
  vertex_t index = 0;
  for (typename vector< RCP<PHX::Evaluator<Traits> > >::const_iterator 
	 evaluator = evaluators.begin(); evaluator != evaluators.end(); 
       ++evaluator, ++index) {

    const vector< RCP<FieldTag> >& eval_fields = 
      (*evaluator)->evaluatedFields();

    for (vector< RCP<FieldTag> >::const_iterator tag = 
	   eval_fields.begin(); tag != eval_fields.end(); ++tag) {
      
      field_to_evaluator_index[(*tag)->identifier()] = index;

    }
  }

  // Create an edgelist with unique edges (by insterting into a map)
  map<string,pair<vertex_t,vertex_t> > graph_edges;
  for (map<string,std::size_t>::const_iterator field = 
	 field_to_evaluator_index.begin(); 
       field != field_to_evaluator_index.end(); ++field) {

    const vector< RCP<FieldTag> >& dep_fields = 
      (evaluators[field->second])->dependentFields();

    for (vector< RCP<FieldTag> >::const_iterator dep_field = 
	   dep_fields.begin(); dep_field != dep_fields.end(); ++dep_field) {

      // Only add the edge of the out node exists
      map<string,vertex_t>::const_iterator search = 
	field_to_evaluator_index.find((*dep_field)->identifier());
      if (search != field_to_evaluator_index.end()) {

	std::ostringstream edge_name;
	edge_name << field->second << ":" 
		  << field_to_evaluator_index[(*dep_field)->identifier()];
	
	graph_edges[edge_name.str()] = std::pair<vertex_t,vertex_t>
	  (field->second, field_to_evaluator_index[(*dep_field)->identifier()]);
      }
    }
  }


  // Create edge graph between evaluators
  for (map<string,pair<vertex_t,vertex_t> >::const_iterator edge = 
	 graph_edges.begin(); edge != graph_edges.end(); ++edge) {

    std::pair<edge_t, bool> boost_edge = 
      boost::add_edge(edge->second.first, edge->second.second, g_dot);
    //boost::add_edge(0, 1, g_dot);

    edge_attr_map[boost_edge.first]["label"] = edge->first;
  }

  boost::graph_traits<boost::GraphvizDigraph>::vertex_iterator vi, vi_end;
  for (boost::tie(vi, vi_end) = vertices(g_dot); vi != vi_end; ++vi) {
    
    string label = evaluators[*vi]->getName();

    if (writeEvaluatedFields) {
    
      const vector< RCP<FieldTag> >& eval_fields = 
	(evaluators[*vi])->evaluatedFields();
      
      label += "\\n   Evaluates:";
      if (eval_fields.size() > 0) {
	for (vector< RCP<FieldTag> >::const_iterator field = 
	       eval_fields.begin(); field != eval_fields.end(); ++field) {
	  label += "\\n     ";
	  label += (*field)->name()  
	    + " : " + (*field)->dataLayout().identifier()
	    + " : " + Teuchos::demangleName((*field)->dataTypeInfo().name());
	}
      }
      else 
	label += " None!";
    
    }

    if (writeDependentFields) {
      const vector< RCP<FieldTag> >& dep_fields = 
	(evaluators[*vi])->dependentFields();

      label += "\\n   Dependencies:";
      if (dep_fields.size() > 0) {
	for (vector< RCP<FieldTag> >::const_iterator field = 
	       dep_fields.begin(); field != dep_fields.end(); ++field) {

	  // Mark any broken evaluators in red
	  bool found = true;
	  if (debugRegisteredEvaluators) {

	    map<string,vertex_t>::const_iterator testing = 
	      field_to_evaluator_index.find((*field)->identifier());
	    if (testing == field_to_evaluator_index.end()) {
	      found = false;
	      vertex_attr_map[*vi]["fontcolor"] = "red";
	    }

	  }
	  
	  if (found)
	    label += "\\n     ";
	  else
	    label += "\\n     *****MISSING**** ";
	    
	  label += (*field)->name() 
	    + " : " + (*field)->dataLayout().identifier()
	    + " : " + Teuchos::demangleName((*field)->dataTypeInfo().name());
	}
      }
      else 
	label += " None!";

    }

    vertex_attr_map[*vi]["label"] = label;
  }

  std::ofstream outfile;
  outfile.open (filename.c_str());
  boost::write_graphviz(outfile, g_dot);
  outfile.close();

#else

  std::cout << "WARNING: writeGraphvizFile() was called, but this requires a boost library version 1.42 or higher.  \nPlease rebuild Trilinos with a more recent version of boost." << std::endl; 

#endif // defined(BOOST_VERSION)&&(BOOST_VERSION>=104200)
}