Sampler.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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"

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:
  enum CommMethod
  {
    NONE = 0,
    LOCAL = 1,
    SEMI_LOCAL = 2
  };

  // 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(unsigned int index = 0);

  uint32_t getRandl(unsigned int index, uint32_t lower, uint32_t upper);

  virtual Real computeSample(dof_id_type row_index, dof_id_type col_index) = 0;


  virtual void sampleSetUp(const SampleMode /*mode*/) {}
  virtual void sampleTearDown(const SampleMode /*mode*/) {}

  // 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);

  template <typename T>
  void shuffle(std::vector<T> & data,
               const std::size_t seed_index = 0,
               const CommMethod method = CommMethod::LOCAL);


  virtual void executeSetUp() {}
  virtual void executeTearDown() {}


  void saveGeneratorState() { _generator.saveState(); }
  void restoreGeneratorState() { _generator.restoreState(); }

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

  MooseRandom _generator;

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

template <typename T>
void
Sampler::shuffle(std::vector<T> & data, const std::size_t seed_index, const CommMethod method)
{
  if (method == CommMethod::NONE)
    MooseUtils::shuffle<T>(data, _generator, seed_index, nullptr);
  else if (method == CommMethod::LOCAL)
    MooseUtils::shuffle<T>(data, _generator, seed_index, &_communicator);
  else if (method == CommMethod::SEMI_LOCAL)
    MooseUtils::shuffle<T>(data, _generator, seed_index, &_local_comm);
}