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;
};