StochasticTools::SobolCalculator< InType, OutType > Class Template Reference

Calculator for computing Sobol sensitivity indices according to the paper by Saltelli (2002) https://doi.org/10.1016/S0010-4655(02)00280-1. More...

#include <SobolCalculators.h>

Inheritance diagram for StochasticTools::SobolCalculator< InType, OutType >:

Public Member Functions
	SobolCalculator (const libMesh::ParallelObject &other, const std::string &name, bool resample)
std::vector< OutType >	compute (const std::vector< InType > &, bool)
	Evaluate the calculator on the full vector of data. More...
void	initializeCalculator ()
	Public function that must be called before updateCalculator and finalizeCalculator. More...
void	updateCalculator (const typename std::vector< InType > ::value_type &)
	Public function to update calculator with a piece of data. More...
void	finalizeCalculator (bool)
	Public function to finalize the resulting calculator value. More...
std::vector< OutType >	getValue () const
	Public function to return the calculated value _state must be FINALIZED. More...
const std::string &	name () const
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Protected Member Functions
virtual void	initialize () override
	This function is used to reset the calculator to its initial state and prepare it for another evaluation. More...
virtual void	update (const InType &data) override
virtual void	finalize (bool is_distributed) override
	This is used to compute the resulting calculator value by performing necessary arithmetic and parallel communication. More...
virtual std::vector< OutType >	get () const override
	Returns the resulting calculator value. More...
virtual void	update (const typename std::vector< InType > ::value_type &)=0
	Updating the calculator with a piece of data. More...

Protected Attributes
const Parallel::Communicator &	_communicator

Private Attributes
const bool	_resample
	Set to true if the resampling matrix exists for computing second-order indices. More...
DenseMatrix< OutType >	_amat
	Matrix containing dot products of data. More...
std::vector< OutType >	_sobol
	The returned sobol indices. More...

Detailed Description

template<typename InType, typename OutType>
class StochasticTools::SobolCalculator< InType, OutType >

Calculator for computing Sobol sensitivity indices according to the paper by Saltelli (2002) https://doi.org/10.1016/S0010-4655(02)00280-1.

The data provided is stacked vectors provided by the SobolSampler. Example use of this object is also available in the stochastic_tools unit testing.

Definition at line 24 of file SobolCalculators.h.

Constructor & Destructor Documentation

SobolCalculator()

template<typename InType , typename OutType >

StochasticTools::SobolCalculator< InType, OutType >::SobolCalculator	(	const libMesh::ParallelObject &	other,
		const std::string &	name,
		bool	resample
	)

Definition at line 14 of file SobolCalculators.C.

  : Calculator<std::vector<InType>, std::vector<OutType>>(other, name), _resample(resample)
{
}

Member Function Documentation

compute()

std::vector< OutType > StochasticTools::Calculator< std::vector< InType > , std::vector< OutType > >::compute ( const std::vector< InType > &  data, bool  is_distributed  )

inherited

Evaluate the calculator on the full vector of data.

This is basically a convenient wrapper around initializeCalculator, updateCalculator, finalizeCalculator, and getvalue.

Definition at line 288 of file Calculators.h.

Referenced by SobolStatistics::execute(), and TEST().

{
  initializeCalculator();
  for (const auto & val : data)
    updateCalculator(val);
  finalizeCalculator(is_distributed);
  return getValue();
}

finalize()

template<typename InType , typename OutType >

void StochasticTools::SobolCalculator< InType, OutType >::finalize ( bool  )

overrideprotectedvirtual

This is used to compute the resulting calculator value by performing necessary arithmetic and parallel communication.

This only called once after all the input data is entered through update.

Implements StochasticTools::Calculator< std::vector< InType >, std::vector< OutType > >.

Definition at line 47 of file SobolCalculators.C.

{
  // The size of the A matrix
  std::size_t s = _amat.n();

  if (is_distributed)
  {
    this->_communicator.max(s);
    if (_amat.n() == 0)
      _amat.resize(s, s);
    mooseAssert(_amat.n() == s, "Size of data updating SobolCalculator has changed.");
    this->_communicator.sum(_amat.get_values());
  }

  // Number of independent parameters
  const std::size_t n = (s - 2) / (_resample ? 2 : 1);

  // The data to output
  DenseMatrix<OutType> S(n, n);
  std::vector<OutType> ST(n);

  // First order
  {
    auto E = _amat(0, s - 1);
    auto V = _amat(s - 1, s - 1) - E;
    for (std::size_t i = 0; i < n; ++i)
    {
      auto U0 = _amat(i + 1, s - 1);
      if (_resample)
      {
        auto U1 = _amat(0, i + n + 1);
        S(i, i) = (((U0 + U1) / 2) - E) / V;
      }
      else
        S(i, i) = (U0 - E) / V;
    }
  }

  // Total-effect
  {
    auto E = _amat(0, s - 1);
    auto V = _amat(0, 0) - E;
    for (std::size_t i = 0; i < n; ++i)
    {
      auto U0 = _amat(0, i + 1);
      if (_resample)
      {
        auto U1 = _amat(i + n + 1, s - 1);
        ST[i] = 1 - (((U0 + U1) / 2) - E) / V;
      }
      else
        ST[i] = 1 - (U0 - E) / V;
    }
  }

  // Second-order
  if (_resample)
  {
    for (std::size_t i = 0; i < n; ++i)
    {
      auto E = _amat(i + 1, i + n + 1);
      for (std::size_t j = 0; j < i; ++j)
      {
        auto V = _amat(j + n + 1, j + n + 1) - E;
        auto U0 = _amat(i + 1, j + n + 1);
        auto U1 = _amat(j + 1, i + n + 1);
        auto Sc = (((U0 + U1) / 2) - E) / V;
        auto S2 = Sc - S(i, i) - S(j, j);
        S(j, i) = S2;
      }
    }
  }

  // Output the data
  _sobol.clear();
  if (_resample)
    _sobol.reserve(n * (n + 3) / 2);
  else
    _sobol.reserve(2 * n);

  // First-order
  for (std::size_t i = 0; i < n; ++i)
    _sobol.push_back(S(i, i));

  // Total-effect
  for (std::size_t i = 0; i < n; ++i)
    _sobol.push_back(ST[i]);

  // Second-order
  if (_resample)
  {
    for (std::size_t i = 0; i < n; ++i)
      for (std::size_t j = i + 1; j < n; ++j)
        _sobol.push_back(S(i, j));
  }
}

finalizeCalculator()

void StochasticTools::Calculator< std::vector< InType > , std::vector< OutType > >::finalizeCalculator ( bool  is_distributed )

inherited

Public function to finalize the resulting calculator value.

_state must be INITLIALIZED Sets _state to FINALIZED

Definition at line 315 of file Calculators.h.

{
  if (_state != CalculatorState::INITIALIZED)
    ::mooseError("Calculator is in wrong state.");
  finalize(is_distributed);
  _state = CalculatorState::FINALIZED;
}

get()

template<typename InType, typename OutType>

virtual std::vector<OutType> StochasticTools::SobolCalculator< InType, OutType >::get ( ) const

inlineoverrideprotectedvirtual

Returns the resulting calculator value.

It is important to not modify member data here so the calculator can retain its state.

Implements StochasticTools::Calculator< std::vector< InType >, std::vector< OutType > >.

Definition at line 33 of file SobolCalculators.h.

{ return _sobol; }

getValue()

std::vector< OutType > StochasticTools::Calculator< std::vector< InType > , std::vector< OutType > >::getValue ( ) const

inherited

Public function to return the calculated value _state must be FINALIZED.

Definition at line 325 of file Calculators.h.

{
  if (_state != CalculatorState::FINALIZED)
    ::mooseError("Calculator is in wrong state.");
  return get();
}

initialize()

template<typename InType , typename OutType >

void StochasticTools::SobolCalculator< InType, OutType >::initialize ( )

overrideprotectedvirtual

This function is used to reset the calculator to its initial state and prepare it for another evaluation.

This usually involves clearing class members.

Implements StochasticTools::Calculator< std::vector< InType >, std::vector< OutType > >.

Definition at line 23 of file SobolCalculators.C.

{
  _amat.resize(0, 0);
}

initializeCalculator()

void StochasticTools::Calculator< std::vector< InType > , std::vector< OutType > >::initializeCalculator ( )

inherited

Public function that must be called before updateCalculator and finalizeCalculator.

Sets _state to INITIALIZED

Definition at line 299 of file Calculators.h.

{
  initialize();
  _state = CalculatorState::INITIALIZED;
}

name()

const std::string& StochasticTools::Calculator< std::vector< InType > , std::vector< OutType > >::name ( ) const

inlineinherited

Definition at line 99 of file Calculators.h.

{ return _name; }

update() [1/2]

template<typename InType , typename OutType >

void StochasticTools::SobolCalculator< InType, OutType >::update ( const InType &  data )

overrideprotectedvirtual

Definition at line 30 of file SobolCalculators.C.

{
  if (_amat.n() == 0)
  {
    _amat.resize(data.size(), data.size());
    if (_amat.n() < 2 || (_resample && _amat.n() % 2 != 0))
      mooseError("Size of input data is inconsistent with Sobol resampling scheme.");
  }
  mooseAssert(_amat.n() == data.size(), "Size of data updating SobolCalculator has changed.");

  for (const auto & c : index_range(data))
    for (const auto & r : make_range(c + 1))
      _amat(r, c) += data[r] * data[c];
}

update() [2/2]

virtual void StochasticTools::Calculator< std::vector< InType > , std::vector< OutType > >::update ( const typename std::vector< InType > ::value_type &  )

protectedpure virtualinherited

Updating the calculator with a piece of data.

Sometimes some clever arithmetic is required to avoid storing data.

updateCalculator()

void StochasticTools::Calculator< std::vector< InType > , std::vector< OutType > >::updateCalculator ( const typename std::vector< InType > ::value_type &  val )

inherited

Public function to update calculator with a piece of data.

_state mush be INITIALIZED

Definition at line 307 of file Calculators.h.

{
  mooseAssert(_state == CalculatorState::INITIALIZED, "Calculator is in wrong state.");
  update(val);
}

Member Data Documentation

_amat

template<typename InType, typename OutType>

DenseMatrix<OutType> StochasticTools::SobolCalculator< InType, OutType >::_amat

private

Matrix containing dot products of data.

Definition at line 39 of file SobolCalculators.h.

_resample

template<typename InType, typename OutType>

const bool StochasticTools::SobolCalculator< InType, OutType >::_resample

private

Set to true if the resampling matrix exists for computing second-order indices.

Definition at line 37 of file SobolCalculators.h.

_sobol

template<typename InType, typename OutType>

std::vector<OutType> StochasticTools::SobolCalculator< InType, OutType >::_sobol

private

The returned sobol indices.

Definition at line 41 of file SobolCalculators.h.

Referenced by StochasticTools::SobolCalculator< InType, OutType >::get().

---

The documentation for this class was generated from the following files:

• stochastic_tools/include/utils/SobolCalculators.h
• stochastic_tools/src/utils/SobolCalculators.C