ExpensiveSamplingProblem.h

Go to the documentation of this file.

#ifndef EXPENSIVESAMPLINGPROBLEM_H_
#define EXPENSIVESAMPLINGPROBLEM_H_
 
#include "MUQ/config.h"
 
#if MUQ_HAS_PARCER
#include <parcer/Communicator.h>
#endif
 
#include "MUQ/Approximation/Regression/LocalRegression.h"
 
#include "MUQ/SamplingAlgorithms/SamplingProblem.h"
 
namespace muq {
  namespace SamplingAlgorithms {
    class ExpensiveSamplingProblem : public SamplingProblem {
    public:
 
      ExpensiveSamplingProblem(std::shared_ptr<muq::Modeling::ModPiece> const& target, std::shared_ptr<muq::Modeling::ModPiece> const& qoi, Eigen::VectorXd const& centroid, boost::property_tree::ptree pt);
 
      ExpensiveSamplingProblem(std::shared_ptr<muq::Modeling::ModPiece> const& target, std::shared_ptr<muq::Modeling::ModPiece> const& qoi, boost::property_tree::ptree pt);
 
      ExpensiveSamplingProblem(std::shared_ptr<muq::Modeling::ModPiece> const& target, boost::property_tree::ptree pt);
 
      ExpensiveSamplingProblem(std::shared_ptr<muq::Modeling::ModPiece> const& target, Eigen::VectorXd const& centroid, boost::property_tree::ptree pt);
 
#if MUQ_HAS_PARCER
      ExpensiveSamplingProblem(std::shared_ptr<muq::Modeling::ModPiece> const& target, boost::property_tree::ptree pt, std::shared_ptr<parcer::Communicator> comm);
 
      ExpensiveSamplingProblem(std::shared_ptr<muq::Modeling::ModPiece> const& target, Eigen::VectorXd const& centroid, boost::property_tree::ptree pt, std::shared_ptr<parcer::Communicator> comm);
#endif
 
      virtual ~ExpensiveSamplingProblem() = default;
 
      virtual double LogDensity(std::shared_ptr<SamplingState> const& state) override;
 
      unsigned int CacheSize() const;
 
 
      virtual void AddOptions(boost::property_tree::ptree & pt) const override;
 
      virtual std::shared_ptr<SamplingState> QOI() override;
 
    private:
 
 
      void SetUp(boost::property_tree::ptree& pt);
 
      double RefineSurrogate(
        unsigned int const step,
        std::shared_ptr<SamplingState> const& state,
        std::vector<Eigen::VectorXd>& neighbors,
        std::vector<Eigen::VectorXd>& results);
 
        double RefineSurrogate(
          std::shared_ptr<SamplingState> const& state,
          double const radius,
          std::vector<Eigen::VectorXd>& neighbors,
          std::vector<Eigen::VectorXd>& results);
 
      void RefineSurrogate(
        Eigen::VectorXd const& point,
        unsigned int const index,
        std::vector<Eigen::VectorXd>& neighbors,
        std::vector<Eigen::VectorXd>& results);
 
 
      void CheckNeighbors(
        std::shared_ptr<SamplingState> const& state,
        std::vector<Eigen::VectorXd>& neighbors,
        std::vector<Eigen::VectorXd>& results) const;
 
 
      void CheckNumNeighbors(std::shared_ptr<SamplingState> const& state);
 
 
      double ErrorThreshold(Eigen::VectorXd const& x) const;
 
 
      double LogLyapunovFunction(Eigen::VectorXd const& x) const;
 
      std::shared_ptr<muq::Approximation::LocalRegression> reg;
 
      std::shared_ptr<muq::Approximation::LocalRegression> regQoI;
 
 
      std::pair<double, double> beta;
 
 
      double tau0;
 
 
      std::pair<double, double> gamma;
 
      std::pair<double, double> lyapunovPara;
 
      const Eigen::VectorXd centroid;
 
      double eta;
 
      unsigned int level = 1;
 
      unsigned int step = 0;
public:
      unsigned int cumbeta = 0;
 
      unsigned int cumgamma = 0;
 
      unsigned int cumkappa = 0;
 
      double lastLyapunov = 0.0;
 
      double lastThreshold = 0.0;
    };
  } // namespace SamplingAlgorithms
} // namespace muq
 
#endif