TransitionKernel.h

Go to the documentation of this file.

#ifndef TRANSITIONKERNEL_H_
#define TRANSITIONKERNEL_H_
 
#include <iostream>
#include <map>
 
#include <boost/function.hpp>
#include <boost/property_tree/ptree.hpp>
 
#include "MUQ/config.h"
 
#if MUQ_HAS_PARCER
#include <parcer/Communicator.h>
#endif
 
#include "MUQ/Utilities/RegisterClassName.h"
 
#include "MUQ/Modeling/WorkPiece.h"
 
#include "MUQ/SamplingAlgorithms/SamplingProblem.h"
#include "MUQ/SamplingAlgorithms/SamplingState.h"
 
namespace muq {
  namespace SamplingAlgorithms {
 
    class TransitionKernel { //: public muq::Modeling::WorkPiece {
    public:
 
      TransitionKernel(boost::property_tree::ptree const& pt, std::shared_ptr<AbstractSamplingProblem> problem);
 
      virtual ~TransitionKernel() = default;
 
#if MUQ_HAS_PARCER
      virtual void SetCommunicator(std::shared_ptr<parcer::Communicator> newcomm);
#endif
 
 
      static std::shared_ptr<TransitionKernel> Construct(boost::property_tree::ptree const& pt, std::shared_ptr<AbstractSamplingProblem> problem);
      typedef boost::function<std::shared_ptr<TransitionKernel>(boost::property_tree::ptree, std::shared_ptr<AbstractSamplingProblem>)> TransitionKernelConstructor;
      typedef std::map<std::string, TransitionKernelConstructor> TransitionKernelMap;
      static std::shared_ptr<TransitionKernelMap> GetTransitionKernelMap();
 
 
      virtual inline void PreStep(unsigned int const t, std::shared_ptr<SamplingState> state) {};
 
 
      virtual inline void PostStep(unsigned int const t, std::vector<std::shared_ptr<SamplingState>> const& state) {};
 
      virtual std::vector<std::shared_ptr<SamplingState>> Step(unsigned int const t, std::shared_ptr<SamplingState> prevState) = 0;
 
      virtual inline void PrintStatus() const {PrintStatus("");};
      virtual inline void PrintStatus(std::string prefix) const {};
 
      // What block of the state does this kernel work on?
 
      virtual void SetBlockInd(int newBlockInd){blockInd = newBlockInd;};
      virtual int GetBlockInd() const{return blockInd;};
 
      virtual std::shared_ptr<AbstractSamplingProblem>  const& Problem() const{return problem;};
 
    protected:
 
      int blockInd = 0;
 
      std::shared_ptr<AbstractSamplingProblem> problem;
 
#if MUQ_HAS_PARCER
      std::shared_ptr<parcer::Communicator> comm;
#endif
 
 
      const bool reeval;
 
    private:
    };
  } // namespace SamplingAlgorithms
} // namespace muq
 
#define REGISTER_TRANSITION_KERNEL(NAME) static auto reg ##NAME     \
  = muq::SamplingAlgorithms::TransitionKernel::GetTransitionKernelMap()->insert(std::make_pair(#NAME, muq::Utilities::shared_factory<NAME>()));
 
#endif