ModGraphPiece.h

Go to the documentation of this file.

#ifndef MODGRAPHPIECE_H_
#define MODGRAPHPIECE_H_
 
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/filtered_graph.hpp>
 
#include <map>
 
#include "MUQ/Modeling/ModPiece.h"
#include "MUQ/Modeling/WorkGraphPiece.h"
#include "MUQ/Modeling/ModGraphPiece.h"
#include "MUQ/Modeling/ConstantVector.h"
#include "MUQ/Modeling/NodeNameFinder.h"
#include "MUQ/Modeling/WorkGraph.h"
 
namespace muq {
  namespace Modeling {
 
    typedef boost::filtered_graph<Graph, DependentEdgePredicate, DependentPredicate> FilteredGraph;
 
    class ModGraphPiece : public ModPiece {
    public:
 
 
      ModGraphPiece(std::shared_ptr<WorkGraph>                           graph,
                    std::vector<std::shared_ptr<ConstantVector> > const& constantPieces,
                    std::vector<std::string>                      const& inputNames,
                    std::shared_ptr<ModPiece>                            outputNode);
 
      virtual ~ModGraphPiece() = default;
 
      std::shared_ptr<WorkGraph> GetGraph(){return wgraph;};
 
      std::vector<std::shared_ptr<ConstantVector> > GetConstantPieces(){return constantPieces;};
 
      std::shared_ptr<ModGraphPiece> GetSubModel(std::string const& nodeName) const;
 
      std::vector<int> MatchInputs(std::shared_ptr<ModGraphPiece> otherPiece) const;
 
      std::shared_ptr<ModGraphPiece> GradientGraph(unsigned int                const  outputDimWrt,
                                                   unsigned int                const  inputDimWrt);
 
      std::shared_ptr<ModGraphPiece> JacobianGraph(unsigned int                const  outputDimWrt,
                                                   unsigned int                const  inputDimWrt);
 
      std::string GetOutputName() const{return wgraph->GetName(outputPiece);};
 
      std::shared_ptr<ModPiece> GetOutputPiece() const{return outputPiece;};
 
      //virtual void SetWarnLevel(unsigned int newLevel) override{};
 
    private:
 
      // Indices are [outWrt][inWrt]
      std::map<std::pair<unsigned int, unsigned int>, std::shared_ptr<ModGraphPiece>> gradientPieces;
      std::map<std::pair<unsigned int, unsigned int>, std::shared_ptr<ModGraphPiece>> jacobianPieces;
      std::map<std::tuple<unsigned int, unsigned int, unsigned int>, std::shared_ptr<ModGraphPiece>> hessianPieces;
 
      int GetInputIndex(std::shared_ptr<WorkPiece> const& piece) const;
 
      static Eigen::VectorXi ConstructInputSizes(std::vector<std::shared_ptr<ConstantVector> > const& constantPiecesIn);
 
 
      virtual void EvaluateImpl(ref_vector<Eigen::VectorXd> const& inputs) override;
 
 
      virtual void GradientImpl(unsigned int                const  outputDimWrt,
                                unsigned int                const  inputDimWrt,
                                ref_vector<Eigen::VectorXd> const& input,
                                Eigen::VectorXd             const& sensitivity) override;
 
 
      virtual void JacobianImpl(unsigned int                const  outputDimWrt,
                                unsigned int                const  inputDimWrt,
                                ref_vector<Eigen::VectorXd> const& input) override;
 
 
      virtual void ApplyJacobianImpl(unsigned int                const  outputDimWrt,
                                     unsigned int                const  inputDimWrt,
                                     ref_vector<Eigen::VectorXd> const& input,
                                     Eigen::VectorXd             const& vec) override;
 
 
     virtual void ApplyHessianImpl(unsigned int                const  outWrt,
                                   unsigned int                const  inWrt1,
                                   unsigned int                const  inWrt2,
                                   ref_vector<Eigen::VectorXd> const& input,
                                   Eigen::VectorXd             const& sens,
                                   Eigen::VectorXd             const& vec) 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 FillOutputMap();
 
 
      void SetInputs(ref_vector<Eigen::VectorXd> const& inputs);
 
 
      ref_vector<Eigen::VectorXd> GetNodeInputs(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> > adjointRunOrders;
 
      std::shared_ptr<WorkGraph> wgraph;
 
      std::vector<std::shared_ptr<FilteredGraph> > filtered_graphs;
 
      std::unordered_map<unsigned int, ref_vector<Eigen::VectorXd> > valMap;
 
      unsigned int outputID;
 
      std::shared_ptr<ModPiece> outputPiece;
 
      std::vector<std::shared_ptr<ConstantVector> > constantPieces;
 
    };
  } // namespace Modeling
} // namespace muq
 
#endif