Sampler.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 "Shuffle.h"
#include "DenseMatrix.h"
#include "MooseObject.h"
#include "MooseRandom.h"
#include "SetupInterface.h"
#include "DistributionInterface.h"
#include "PerfGraphInterface.h"
#include "SamplerInterface.h"
#include "MultiApp.h"
#include "VectorPostprocessorInterface.h"
#include "ReporterInterface.h"
#include "MooseRandomStateless.h"
 
class Sampler : public MooseObject,
                public SetupInterface,
                public DistributionInterface,
                public PerfGraphInterface,
                public SamplerInterface,
                public VectorPostprocessorInterface,
                public ReporterInterface
{
public:
  enum class SampleMode
  {
    GLOBAL = 0,
    LOCAL = 1
  };
 
  static InputParameters validParams();
  Sampler(const InputParameters & parameters);
 
  // The public members define the API that is exposed to application developers that are using
  // Sampler objects to perform calculations, so be very careful when adding items here since
  // they are exposed to any other object via the SamplerInterface.
  //
  // It is also important to point out that when Sampler objects, when used, are not const. This is
  // due to the fact that calling the various get methods below must store various pieces of data as
  // well as control the state of the random number generators.
 
 
  DenseMatrix<Real> getGlobalSamples();
  DenseMatrix<Real> getLocalSamples();
 
  std::vector<Real> getNextLocalRow();
 
  dof_id_type getNumberOfRows() const;
  dof_id_type getNumberOfCols() const;
  dof_id_type getNumberOfLocalRows() const;
 
 
  dof_id_type getLocalRowBegin() const;
  dof_id_type getLocalRowEnd() const;
 
  const LocalRankConfig & getRankConfig(bool batch_mode) const
  {
    return batch_mode ? _rank_config.second : _rank_config.first;
  }
 
  virtual bool isAdaptiveSamplingCompleted() const
  {
    mooseError("This method should be overridden in adaptive sampling classes.");
    return false;
  }
 
  libMesh::Parallel::Communicator & getLocalComm() { return _local_comm; }
 
protected:
  // The following methods are the basic methods that should be utilized my most application
  // developers that are creating a custom Sampler.
 
 
  void setNumberOfRows(dof_id_type n_rows);
  void setNumberOfCols(dof_id_type n_cols);
 
  void setNumberOfRandomSeeds(std::size_t number);
 
  Real getRand(std::size_t n, unsigned int index = 0) const;
 
  unsigned int
  getRandl(std::size_t n, unsigned int lower, unsigned int upper, unsigned int index = 0) const;
 
  virtual Real computeSample(dof_id_type row_index, dof_id_type col_index) = 0;
 
  // The following methods are advanced methods that should not be needed by application developers,
  // but exist for special cases.
 
 
  virtual void computeSampleMatrix(DenseMatrix<Real> & matrix);
  virtual void computeLocalSampleMatrix(DenseMatrix<Real> & matrix);
 
 
  virtual void computeSampleRow(dof_id_type i, std::vector<Real> & data);
 
  virtual void advanceGenerators(const dof_id_type count);
  virtual void advanceGenerator(const unsigned int seed_index, const dof_id_type count);
  void setAutoAdvanceGenerators(const bool state);
 
 
  virtual void executeSetUp() {}
  virtual void executeTearDown() {}
 
  virtual LocalRankConfig constructRankConfig(bool batch_mode) const;
 
  const dof_id_type _min_procs_per_row;
  const dof_id_type _max_procs_per_row;
 
  libMesh::Parallel::Communicator _local_comm;
 
private:
 
  void init();   // sets up MooseRandom
  void reinit(); // partitions sampler output
  friend void FEProblemBase::addSampler(const std::string & type,
                                        const std::string & name,
                                        InputParameters & parameters);
  void execute();
  friend void FEProblemBase::objectExecuteHelper<Sampler>(const std::vector<Sampler *> & objects);
 
  void checkReinitStatus() const;
 
  void advanceGeneratorsInternal(const dof_id_type count);
 
  std::vector<std::unique_ptr<MooseRandomStateless>> _generators;
 
  dof_id_type _n_local_rows;
 
  dof_id_type _local_row_begin;
 
  dof_id_type _local_row_end;
 
  dof_id_type _n_rows;
 
  dof_id_type _n_cols;
 
  std::size_t _n_seeds;
 
  dof_id_type _next_local_row;
 
  bool _next_local_row_requires_state_restore;
 
  bool _initialized;
 
  bool _needs_reinit;
 
  bool _has_executed;
 
  const dof_id_type _limit_get_global_samples;
 
  const dof_id_type _limit_get_local_samples;
 
  const dof_id_type _limit_get_next_local_row;
 
  std::pair<LocalRankConfig, LocalRankConfig> _rank_config;
 
  bool _auto_advance_generators;
};