UMBridgeModPiece.h

Go to the documentation of this file.

#ifndef UMBRIDGEMODPIECE
#define UMBRIDGEMODPIECE
#include "MUQ/Modeling/ModPiece.h"
#include "umbridge.h"
 
namespace muq {
  namespace Modeling {
 
    class UMBridgeModPiece : public muq::Modeling::ModPiece {
    public:
 
      UMBridgeModPiece(const std::string host, std::string name, json config = json(), httplib::Headers headers = httplib::Headers());
 
      static const std::vector<double> EigenvectordToStdVector(const Eigen::VectorXd& vector) {
        const std::vector<double> vec(vector.data(), vector.data() + vector.rows());
        return vec;
      }
      static Eigen::VectorXd StdVectorToEigenvectord(std::vector<double>& vector) {
        double* ptr_data = &vector[0];
        Eigen::VectorXd vec = Eigen::Map<Eigen::VectorXd, Eigen::Unaligned>(ptr_data, vector.size());
        return vec;
      }
      static const Eigen::VectorXd StdVectorToEigenvectord(const std::vector<double>& vector) {
        const double* ptr_data = &vector[0];
        const Eigen::VectorXd vec = Eigen::Map<const Eigen::VectorXd, Eigen::Unaligned>(ptr_data, vector.size());
        return vec;
      }
 
      static std::vector<std::vector<double>> EigenvectordsToStdVectors(std::vector<Eigen::VectorXd> const& inputs) {
        std::vector<std::vector<double>> vecs(inputs.size());
        for (int i = 0; i < inputs.size(); i++)
          vecs[i] = EigenvectordToStdVector(inputs[i]);
        return vecs;
      }
      static std::vector<std::vector<double>> EigenvectordsToStdVectors(muq::Modeling::ref_vector<Eigen::VectorXd> const& inputs) {
        std::vector<std::vector<double>> vecs(inputs.size());
        for (int i = 0; i < inputs.size(); i++)
          vecs[i] = EigenvectordToStdVector(inputs[i]);
        return vecs;
      }
      static std::vector<Eigen::VectorXd> StdVectorsToEigenvectords(std::vector<std::vector<double>> vector) {
        std::vector<Eigen::VectorXd> vec(vector.size());
        for (int i = 0; i < vector.size(); i++) {
          vec[i] = StdVectorToEigenvectord(vector[i]);
        }
        return vec;
      }
 
      static std::vector<std::size_t> EigenvectoriToStdVector(const Eigen::VectorXi& vector) {
        std::vector<std::size_t> vec(vector.data(), vector.data() + vector.rows());
        return vec;
      }
      static Eigen::VectorXi StdVectorToEigenvectori(const std::vector<std::size_t>& vector) {
        Eigen::VectorXi vec(vector.size());
        for (int i = 0; i < vector.size(); i++)
          vec[i] = vector[i];
        return vec;
      }
 
    private:
 
      Eigen::VectorXi read_input_size(const std::string host, std::string name, const httplib::Headers& headers);
 
      Eigen::VectorXi read_output_size(const std::string host, std::string name, const httplib::Headers& headers);
 
      void EvaluateImpl(muq::Modeling::ref_vector<Eigen::VectorXd> const& inputs) override;
 
      void GradientImpl(unsigned int outWrt,
                        unsigned int inWrt,
                        muq::Modeling::ref_vector<Eigen::VectorXd> const& inputs,
                        Eigen::VectorXd const& sens) override;
 
      void ApplyJacobianImpl(unsigned int outWrt,
                             unsigned int inWrt,
                             muq::Modeling::ref_vector<Eigen::VectorXd> const& inputs,
                             Eigen::VectorXd const& vec) override;
 
      void ApplyHessianImpl(unsigned int outWrt,
                            unsigned int inWrt1,
                            unsigned int inWrt2,
                            muq::Modeling::ref_vector<Eigen::VectorXd> const& inputs,
                            Eigen::VectorXd const& sens,
                            Eigen::VectorXd const& vec) override;
 
      json config;
      umbridge::HTTPModel client;
    };
 
  }
}
 
#endif