StochasticTools Namespace Reference

Enum for batch type in stochastic tools MultiApp. More...

Classes
class	BiasCorrectedAccelerated
class	BiasCorrectedAccelerated< std::vector< InType >, std::vector< OutType > >
class	BootstrapCalculator
	Base class for computing bootstrap confidence level intervals. More...
struct	BootstrapCalculatorBuilder
struct	BootstrapCalculatorBuilder< std::vector< InType >, std::vector< OutType > >
struct	BootstrapCalculatorBuilder< std::vector< std::vector< InType > >, std::vector< std::vector< OutType > > >
class	Calculator
struct	CalculatorBuilder
struct	CalculatorBuilder< std::vector< InType >, std::vector< OutType > >
struct	canDefaultGather
	Custom type trait that has a value of true for types that can be gathered. More...
struct	canDefaultGather< std::vector< T > >
struct	canStochasticGather
struct	canStochasticGather< std::vector< T > >
class	CartesianProduct
class	DistributedData
	Templated class that specifies a distributed storage of a vector of given objects. More...
class	GaussianProcess
	Utility class dedicated to hold structures and functions commont to Gaussian Processes. More...
class	L2Norm
class	Max
class	Mean
class	MeanAbsoluteValue
class	Median
class	Min
class	MultiDimPolynomialGenerator
	Class containing functionalitties to generate the degress of the 1D Polynomials within every term of a multi-dimensional polynomial. More...
class	Percentile
class	Percentile< std::vector< InType >, std::vector< OutType > >
class	Percentile< std::vector< std::vector< InType > >, std::vector< std::vector< OutType > > >
class	POD
	Class which computes a Proper Orthogonal Decomposition (POD) for snapshots stored in ParallelSolutionStorage. More...
class	Ratio
class	SobolCalculator
	Calculator for computing Sobol sensitivity indices according to the paper by Saltelli (2002) https://doi.org/10.1016/S0010-4655(02)00280-1. More...
class	SobolCalculator< std::vector< InType >, std::vector< OutType > >
class	Standardizer
	Class for standardizing data (centering and scaling) More...
class	StdDev
class	StdErr
class	Sum
class	VectorCalculator
class	WeightedCartesianProduct

Enumerations
enum class	MultiAppMode { NORMAL = 0 , BATCH_RESET = 1 , BATCH_RESTORE = 2 }

Functions
MooseEnum	makeBootstrapCalculatorEnum ()
template<typename InType , typename OutType >
std::unique_ptr< BootstrapCalculator< InType, OutType > >	makeBootstrapCalculator (const MooseEnum &, const libMesh::ParallelObject &, const std::vector< Real > &, unsigned int, unsigned int, StochasticTools::Calculator< InType, OutType > &)
MultiMooseEnum	makeCalculatorEnum ()
template<typename InType = std::vector<Real>, typename OutType = Real>
std::unique_ptr< Calculator< InType, OutType > >	makeCalculator (const MooseEnumItem &item, const libMesh::ParallelObject &other)
template<typename T >
void	stochasticGather (const libMesh::Parallel::Communicator &, processor_id_type, T &)
template<typename T , typename std::enable_if< canDefaultGather< std::vector< T > >::value, int >::type = 0>
void	stochasticGather (const libMesh::Parallel::Communicator &comm, processor_id_type root_id, std::vector< T > &val)
template<typename T , typename std::enable_if< canStochasticGather< std::vector< std::vector< T > > >::value, int >::type = 0>
void	stochasticGather (const libMesh::Parallel::Communicator &comm, processor_id_type root_id, std::vector< std::vector< T > > &val)
template<typename T >
void	stochasticGather (const libMesh::Parallel::Communicator &comm, processor_id_type root_id, std::vector< std::basic_string< T > > &val)
template<typename A >
void	stochasticGather (const libMesh::Parallel::Communicator &comm, processor_id_type root_id, std::vector< bool, A > &val)
template<typename T >
void	stochasticAllGather (const libMesh::Parallel::Communicator &, T &)
template<typename T , typename std::enable_if< canDefaultGather< std::vector< T > >::value, int >::type = 0>
void	stochasticAllGather (const libMesh::Parallel::Communicator &comm, std::vector< T > &val)
template<typename T , typename std::enable_if< canStochasticGather< std::vector< std::vector< T > > >::value, int >::type = 0>
void	stochasticAllGather (const libMesh::Parallel::Communicator &comm, std::vector< std::vector< T > > &val)
template<typename T >
void	stochasticAllGather (const libMesh::Parallel::Communicator &comm, std::vector< std::basic_string< T > > &val)
template<typename A >
void	stochasticAllGather (const libMesh::Parallel::Communicator &comm, std::vector< bool, A > &val)
template<typename T >
void	inplaceSort (std::vector< T > &values)
template<typename T >
void	inplaceSort (std::vector< std::vector< T > > &values)
template<typename T >
std::vector< std::vector< T > >	reshapeVector (const std::vector< T > &vec, std::size_t n, bool row_major)
	Reshape a vector into matrix-like vector of vectors.
	createBootstrapCalculators (std::vector< Real >, Real)
	createBootstrapCalculators (std::vector< int >, Real)
	createCalculators (std::vector< Real >, Real)
	createCalculators (std::vector< int >, Real)
	createVectorCalculators (std::vector< Real >, Real)
	createVectorOfVectorCalculators (std::vector< Real >, Real)

Detailed Description

Enum for batch type in stochastic tools MultiApp.

Polynomials and quadratures based on defined distributions for Polynomial Chaos.

Enumeration Type Documentation

MultiAppMode

enum class StochasticTools::MultiAppMode

strong

Enumerator
NORMAL
BATCH_RESET
BATCH_RESTORE

Definition at line 15 of file StochasticToolsTypes.h.

{
  NORMAL = 0,
  BATCH_RESET = 1,
  BATCH_RESTORE = 2
};

Function Documentation

createBootstrapCalculators() [1/2]

StochasticTools::createBootstrapCalculators	(	std::vector< int >	,
		Real
	)

createBootstrapCalculators() [2/2]

StochasticTools::createBootstrapCalculators	(	std::vector< Real >	,
		Real
	)

createCalculators() [1/2]

StochasticTools::createCalculators	(	std::vector< int >	,
		Real
	)

createCalculators() [2/2]

StochasticTools::createCalculators	(	std::vector< Real >	,
		Real
	)

createVectorCalculators()

StochasticTools::createVectorCalculators	(	std::vector< Real >	,
		Real
	)

createVectorOfVectorCalculators()

StochasticTools::createVectorOfVectorCalculators	(	std::vector< Real >	,
		Real
	)

inplaceSort() [1/2]

template<typename T >

void StochasticTools::inplaceSort

(

std::vector< std::vector< T > > &

values

)

Definition at line 224 of file StochasticToolsUtils.h.

{
  if (values.empty())
    return;
 
  const std::size_t sz = values[0].size();
  mooseAssert(std::find_if(values.begin(),
                           values.end(),
                           [&sz](const std::vector<T> & val)
                           { return val.size() != sz; }) == values.end(),
              "All vectors must be same size to sort.");
 
  std::vector<T> vals(values.size());
  for (const auto & i : make_range(sz))
  {
    for (const auto & k : index_range(values))
      vals[k] = values[k][i];
    inplaceSort(vals);
    for (const auto & k : index_range(values))
      values[k][i] = std::move(vals[k]);
  }
}

inplaceSort() [2/2]

template<typename T >

void StochasticTools::inplaceSort

(

std::vector< T > &

values

)

Definition at line 218 of file StochasticToolsUtils.h.

{
  std::sort(values.begin(), values.end());
}

Referenced by StochasticTools::BootstrapCalculator< InType, OutType >::computeBootstrapEstimates(), and inplaceSort().

makeBootstrapCalculator()

template<typename InType , typename OutType >

std::unique_ptr< BootstrapCalculator< InType, OutType > > StochasticTools::makeBootstrapCalculator	(	const MooseEnum &	item,
		const libMesh::ParallelObject &	other,
		const std::vector< Real > &	levels,
		unsigned int	replicates,
		unsigned int	seed,
		StochasticTools::Calculator< InType, OutType > &	calc
	)

Definition at line 183 of file BootstrapCalculators.h.

{
  return BootstrapCalculatorBuilder<InType, OutType>::build(
      item, other, levels, replicates, seed, calc);
}

Referenced by TEST(), TEST(), and TEST().

makeBootstrapCalculatorEnum()

MooseEnum StochasticTools::makeBootstrapCalculatorEnum

(

)

Definition at line 17 of file BootstrapCalculators.C.

{
  return MooseEnum("percentile=0 bca=1");
}

Referenced by StatisticsReporter::validParams(), and Statistics::validParams().

makeCalculator()

template<typename InType = std::vector<Real>, typename OutType = Real>

std::unique_ptr< Calculator< InType, OutType > > StochasticTools::makeCalculator	(	const MooseEnumItem &	item,
		const libMesh::ParallelObject &	other
	)

Definition at line 335 of file Calculators.h.

{
  return CalculatorBuilder<InType, OutType>::build(item, other);
}

Referenced by Statistics::execute(), PolynomialChaosTrainer::PolynomialChaosTrainer(), PolynomialRegressionTrainer::PolynomialRegressionTrainer(), TEST(), and TEST().

makeCalculatorEnum()

MultiMooseEnum StochasticTools::makeCalculatorEnum

(

)

Definition at line 16 of file Calculators.C.

{
  return MultiMooseEnum(
      "min=0 max=1 sum=2 mean=3 stddev=4 norm2=5 ratio=6 stderr=7 median=8 meanabs=9");
}

Referenced by ParameterStudyAction::validParams(), StatisticsReporter::validParams(), and Statistics::validParams().

reshapeVector()

template<typename T >

std::vector< std::vector< T > > StochasticTools::reshapeVector	(	const std::vector< T > &	vec,
		std::size_t	n,
		bool	row_major
	)

Reshape a vector into matrix-like vector of vectors.

Parameters

vec	Input vector to reshape
n	Leading dimension size, number of columns if row-major, number of rows if column-major
row_major	True if
vec	is in row-major format see https://en.wikipedia.org/wiki/Row-_and_column-major_order

Returns

vector of vectors representing reshaped vector ([row][col])

Definition at line 259 of file StochasticToolsUtils.h.

{
  const auto nelem = vec.size();
  const auto nrow = row_major ? nelem / n : n;
  const auto ncol = row_major ? n : nelem / n;
  if (nelem % n != 0)
    ::mooseError(
        "Reshaping dimensions (", nrow, ", ", ncol, ") does not match vector size (", nelem, ").");
 
  std::vector<std::vector<T>> mat(nrow, std::vector<T>(ncol));
  for (const auto & i : make_range(nrow))
    for (const auto & j : make_range(ncol))
    {
      const auto k = row_major ? (i * ncol + j) : (j * nrow + i);
      mat[i][j] = vec[k];
    }
  return mat;
}

Referenced by AdaptiveMonteCarloDecision::execute(), SobolStatistics::execute(), SobolReporterContext< InType, OutType >::finalize(), and sobolidx().

stochasticAllGather() [1/5]

template<typename T >

void StochasticTools::stochasticAllGather	(	const libMesh::Parallel::Communicator &	,
		T &
	)

Definition at line 141 of file StochasticToolsUtils.h.

{
  ::mooseError("Cannot gather values of type ", MooseUtils::prettyCppType<T>());
}

Referenced by StochasticReporterContext< T >::finalize(), and stochasticAllGather().

stochasticAllGather() [2/5]

template<typename A >

void StochasticTools::stochasticAllGather	(	const libMesh::Parallel::Communicator &	comm,
		std::vector< bool, A > &	val
	)

Definition at line 201 of file StochasticToolsUtils.h.

{
  std::vector<unsigned short int> temp(val.size());
  for (std::size_t i = 0; i < val.size(); ++i)
    temp[i] = val[i] ? 1 : 0;
  comm.allgather(temp);
  val.resize(temp.size());
  for (std::size_t i = 0; i < temp.size(); ++i)
    val[i] = temp[i] == 1;
}

stochasticAllGather() [3/5]

template<typename T >

void StochasticTools::stochasticAllGather	(	const libMesh::Parallel::Communicator &	comm,
		std::vector< std::basic_string< T > > &	val
	)

Definition at line 193 of file StochasticToolsUtils.h.

{
  comm.allgather(val);
}

stochasticAllGather() [4/5]

template<typename T , typename std::enable_if< canStochasticGather< std::vector< std::vector< T > > >::value, int >::type = 0>

void StochasticTools::stochasticAllGather	(	const libMesh::Parallel::Communicator &	comm,
		std::vector< std::vector< T > > &	val
	)

Definition at line 156 of file StochasticToolsUtils.h.

{
  // Get local vector sizes
  std::size_t num_local_vecs = val.size();
  std::vector<std::size_t> val_sizes;
  val_sizes.reserve(num_local_vecs);
  std::size_t num_local_vals = 0;
  for (const auto & v : val)
  {
    val_sizes.push_back(v.size());
    num_local_vals += v.size();
  }
 
  // Flatten the local vector of vectors
  std::vector<T> val_exp;
  val_exp.reserve(num_local_vals);
  for (auto & v : val)
    std::copy(v.begin(), v.end(), std::back_inserter(val_exp));
 
  // Gather the vector sizes and the flattened vector
  comm.allgather(val_sizes);
  stochasticAllGather(comm, val_exp);
 
  // Build the vector of vectors from the gathered flatten vector
  val.resize(val_sizes.size());
  std::size_t ind = 0;
  for (std::size_t i = 0; i < val_sizes.size(); ++i)
  {
    val[i].resize(val_sizes[i]);
    std::move(val_exp.begin() + ind, val_exp.begin() + ind + val_sizes[i], val[i].begin());
    ind += val_sizes[i];
  }
}

stochasticAllGather() [5/5]

template<typename T , typename std::enable_if< canDefaultGather< std::vector< T > >::value, int >::type = 0>

void StochasticTools::stochasticAllGather	(	const libMesh::Parallel::Communicator &	comm,
		std::vector< T > &	val
	)

Definition at line 148 of file StochasticToolsUtils.h.

{
  comm.allgather(val);
}

stochasticGather() [1/5]

template<typename T >

void StochasticTools::stochasticGather	(	const libMesh::Parallel::Communicator &	,
		processor_id_type	,
		T &
	)

Definition at line 49 of file StochasticToolsUtils.h.

{
  ::mooseError("Cannot gather values of type ", MooseUtils::prettyCppType<T>());
}

Referenced by StochasticReporterContext< T >::finalize(), and stochasticGather().

stochasticGather() [2/5]

template<typename A >

void StochasticTools::stochasticGather	(	const libMesh::Parallel::Communicator &	comm,
		processor_id_type	root_id,
		std::vector< bool, A > &	val
	)

Definition at line 120 of file StochasticToolsUtils.h.

{
  std::vector<unsigned short int> temp(val.size());
  for (std::size_t i = 0; i < val.size(); ++i)
    temp[i] = val[i] ? 1 : 0;
  comm.gather(root_id, temp);
  if (comm.rank() == root_id)
  {
    val.resize(temp.size());
    for (std::size_t i = 0; i < temp.size(); ++i)
      val[i] = temp[i] == 1;
  }
}

stochasticGather() [3/5]

template<typename T >

void StochasticTools::stochasticGather	(	const libMesh::Parallel::Communicator &	comm,
		processor_id_type	root_id,
		std::vector< std::basic_string< T > > &	val
	)

Definition at line 108 of file StochasticToolsUtils.h.

{
  std::vector<std::basic_string<T>> val_gath = val;
  comm.allgather(val_gath);
  if (comm.rank() == root_id)
    val = std::move(val_gath);
}

stochasticGather() [4/5]

template<typename T , typename std::enable_if< canStochasticGather< std::vector< std::vector< T > > >::value, int >::type = 0>

void StochasticTools::stochasticGather	(	const libMesh::Parallel::Communicator &	comm,
		processor_id_type	root_id,
		std::vector< std::vector< T > > &	val
	)

Definition at line 66 of file StochasticToolsUtils.h.

{
  // Get local vector sizes
  std::size_t num_local_vecs = val.size();
  std::vector<std::size_t> val_sizes;
  val_sizes.reserve(num_local_vecs);
  std::size_t num_local_vals = 0;
  for (const auto & v : val)
  {
    val_sizes.push_back(v.size());
    num_local_vals += v.size();
  }
 
  // Flatten the local vector of vectors
  std::vector<T> val_exp;
  val_exp.reserve(num_local_vals);
  for (auto & v : val)
    std::copy(v.begin(), v.end(), std::back_inserter(val_exp));
 
  // Gather the vector sizes and the flattened vector
  comm.gather(root_id, val_sizes);
  stochasticGather(comm, root_id, val_exp);
 
  // Build the vector of vectors from the gathered flatten vector
  if (comm.rank() == root_id)
  {
    val.resize(val_sizes.size());
    std::size_t ind = num_local_vals;
    for (std::size_t i = num_local_vecs; i < val_sizes.size(); ++i)
    {
      val[i].resize(val_sizes[i]);
      std::move(val_exp.begin() + ind, val_exp.begin() + ind + val_sizes[i], val[i].begin());
      ind += val_sizes[i];
    }
  }
}

stochasticGather() [5/5]

template<typename T , typename std::enable_if< canDefaultGather< std::vector< T > >::value, int >::type = 0>

void StochasticTools::stochasticGather	(	const libMesh::Parallel::Communicator &	comm,
		processor_id_type	root_id,
		std::vector< T > &	val
	)

Definition at line 56 of file StochasticToolsUtils.h.

{
  comm.gather(root_id, val);
}