PMCMCDecision.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "GeneralReporter.h"
#include "PMCMCBase.h"
#include "LikelihoodFunctionBase.h"
#include "LikelihoodInterface.h"
#include "Distribution.h"
 
class PMCMCDecision : public GeneralReporter, public LikelihoodInterface
{
public:
  static InputParameters validParams();
  PMCMCDecision(const InputParameters & parameters);
  virtual void initialize() override;
  virtual void finalize() override {}
  virtual void execute() override;
 
protected:
  virtual void computeEvidence(std::vector<Real> & evidence,
                               const DenseMatrix<Real> & input_matrix);
 
  virtual void computeTransitionVector(std::vector<Real> & tv, const std::vector<Real> & evidence);
 
  virtual void nextSamples(std::vector<Real> & req_inputs,
                           DenseMatrix<Real> & input_matrix,
                           const std::vector<Real> & tv,
                           const unsigned int & parallel_index);
 
  virtual void nextSeeds() {}
 
  virtual bool usingGP() const { return false; }
 
  std::vector<std::vector<Real>> & _inputs;
 
  std::vector<Real> & _tpm;
 
  std::vector<Real> & _variance;
 
  Real & _noise;
 
  std::vector<const LikelihoodFunctionBase *> _likelihoods;
 
  Sampler & _sampler;
 
  const PMCMCBase * const _pmcmc;
 
  dof_id_type _props;
 
  const std::vector<Real> & _rnd_vec;
 
  const std::vector<Real> & _new_var_samples;
 
  const std::vector<const Distribution *> _priors;
 
  const Distribution * _var_prior;
 
  std::vector<Real> * _outputs_required;
 
  dof_id_type _num_confg_values;
 
  dof_id_type _num_confg_params;
 
  DenseMatrix<Real> _data_prev;
 
  std::vector<Real> _var_prev;
 
  std::vector<Real> _outputs_prev;
 
  const std::vector<Real> * _output_value;
 
  libMesh::Parallel::Communicator & _local_comm;
 
  int _check_step;
};