WorkGraphPiece.h

Go to the documentation of this file.

#ifndef WORKGRAPHPIECE_H_
#define WORKGRAPHPIECE_H_
 
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/filtered_graph.hpp>
 
#include "MUQ/Modeling/WorkPiece.h"
#include "MUQ/Modeling/ConstantPiece.h"
#include "MUQ/Modeling/NodeNameFinder.h"
 
#include <deque>
 
namespace muq {
  namespace Modeling {
 
    class UpstreamPredicate {
    public:
 
      UpstreamPredicate();
 
      UpstreamPredicate(boost::graph_traits<Graph>::vertex_descriptor const& baseNode, Graph const& graph);
 
      bool operator()(const boost::graph_traits<Graph>::vertex_descriptor& node) const;
 
    private:
      std::vector<boost::graph_traits<Graph>::vertex_descriptor> doesDepend;
 
      void UpstreamNodes(const boost::graph_traits<Graph>::vertex_descriptor& baseNode, Graph const& graph);
    };
 
    class UpstreamEdgePredicate {
    public:
 
      UpstreamEdgePredicate();
 
      UpstreamEdgePredicate(UpstreamPredicate nodePred, Graph const& graph);
 
      bool operator()(const boost::graph_traits<Graph>::edge_descriptor& edge) const;
 
    private:
 
      UpstreamPredicate nodePred;
 
      const Graph* graph;
 
    };
 
    class DependentPredicate {
    public:
      DependentPredicate();
 
      DependentPredicate(boost::graph_traits<Graph>::vertex_descriptor const& baseNode, Graph const& graph);
 
      bool operator()(const boost::graph_traits<Graph>::vertex_descriptor& node) const;
 
    private:
      std::vector<boost::graph_traits<Graph>::vertex_descriptor> doesDepend;
 
      void DownstreamNodes(const boost::graph_traits<Graph>::vertex_descriptor& baseNode, Graph const& graph);
    };
 
    class DependentEdgePredicate {
    public:
      DependentEdgePredicate();
 
      DependentEdgePredicate(DependentPredicate nodePred, Graph const& graph);
 
      bool operator()(const boost::graph_traits<Graph>::edge_descriptor& edge) const;
 
    private:
      DependentPredicate nodePred;
 
      const Graph* graph;
    };
 
    typedef boost::filtered_graph<Graph, DependentEdgePredicate, DependentPredicate> FilteredGraph;
 
    class WorkGraphPiece : public WorkPiece {
    public:
 
 
      WorkGraphPiece(std::shared_ptr<WorkGraph>                          wgraph,
                     std::vector<std::shared_ptr<ConstantPiece> > const& constantPieces,
                     std::vector<std::string>                     const& inputNames,
                     std::map<unsigned int, std::string>          const& inTypes,
                     std::shared_ptr<WorkPiece>                          outputNode);
 
      virtual ~WorkGraphPiece();
 
 
      std::shared_ptr<WorkGraph> GetGraph(){return wgraph;};
 
    private:
 
 
      virtual void EvaluateImpl(ref_vector<boost::any> const& inputs) override;
 
   //    /// Compute the Jacobian for this muq::Modeling::WorkGraphPiece using the chain rule
   //    /**
     // @param[in] wrtIn We are taking the Jacobian with respect to this input
     // @param[in] wrtOut We are taking the Jacobian of this output
     // @param[in] inputs Inputs to the muq::Modeling::WorkGraphPiece
   //     */
   //    virtual void JacobianImpl(unsigned int const wrtIn, unsigned int const wrtOut, ref_vector<boost::any> const& inputs) override;
   //
   //    /// Compute the action of the Jacobian for this muq::Modeling::WorkGraphPiece using the chain rule
   //    /**
     // @param[in] wrtIn We are taking the Jacobian with respect to this input
     // @param[in] wrtOut We are taking the Jacobian of this output
     // @param[in] vec We are applying the Jacobian to this object
     // @param[in] inputs Inputs to the muq::Modeling::WorkGraphPiece
   //     */
   //    virtual void JacobianActionImpl(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any> const& inputs) override;
   //
   //    /// Compute the action of the Jacobian transpose for this muq::Modeling::WorkGraphPiece using the chain rule
   //    /**
     // @param[in] wrtIn We are taking the Jacobian with respect to this input
     // @param[in] wrtOut We are taking the Jacobian of this output
     // @param[in] vec We are applying the Jacobian transpose to this object
     // @param[in] inputs Inputs to the muq::Modeling::WorkGraphPiece
   //     */
   //    virtual void JacobianTransposeActionImpl(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any> const& inputs) override;
 
 
      std::vector<std::tuple<unsigned int, unsigned int, unsigned int> > RequiredOutputs(boost::graph_traits<FilteredGraph>::vertex_descriptor const& node, unsigned int const wrtIn, unsigned int wrtOut) const;
 
 
      std::vector<std::tuple<unsigned int, unsigned int, unsigned int> > RequiredInputs(boost::graph_traits<FilteredGraph>::vertex_descriptor const& node, unsigned int const wrtIn) const;
 
      void OutputMap();
 
 
      void SetInputs(ref_vector<boost::any> const& inputs);
 
 
      ref_vector<boost::any> Inputs(boost::graph_traits<Graph>::vertex_descriptor node) const;
 
 
      std::map<unsigned int, std::vector<std::pair<unsigned int, unsigned int> > > InputNodes(boost::graph_traits<Graph>::vertex_descriptor const& node) const;
 
      std::deque<boost::graph_traits<Graph>::vertex_descriptor> runOrder;
 
      // Run order for computing the derivatives of this muq::Modeling::WorkGraphPiece
      std::vector<std::deque<boost::graph_traits<Graph>::vertex_descriptor> > derivRunOrders;
 
      //std::shared_ptr<const Graph> graph;
      std::shared_ptr<WorkGraph> wgraph;
 
      std::vector<std::shared_ptr<FilteredGraph> > filtered_graphs;
 
      std::unordered_map<unsigned int, ref_vector<boost::any> > valMap;
 
      unsigned int outputID;
 
      std::vector<std::shared_ptr<ConstantPiece> > constantPieces;
 
    };
  } // namespace Modeling
} // namespace muq
 
#endif