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 >:

[legend]

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.

void	initializeCalculator ()
	Public function that must be called before updateCalculator and finalizeCalculator.

void	updateCalculator (const typename InType::value_type &)
	Public function to update calculator with a piece of data.

void	finalizeCalculator (bool)
	Public function to finalize the resulting calculator value.

std::vector< OutType >	getValue () const
	Public function to return the calculated value _state must be FINALIZED.

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.

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.

virtual std::vector< OutType >	get () const override
	Returns the resulting calculator value.

virtual void	update (const typename InType::value_type &)=0
	Updating the calculator with a piece of data.

Protected Attributes
const Parallel::Communicator &	_communicator

Private Types
enum	CalculatorState

Private Attributes
const bool	_resample
	Set to true if the resampling matrix exists for computing second-order indices.

DenseMatrix< OutType >	_amat
	Matrix containing dot products of data.

std::vector< OutType >	_sobol
	The returned sobol indices.

const std::string	_name

CalculatorState	_state

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 25 of file SobolCalculators.h.

Member Enumeration Documentation

◆ CalculatorState

enum StochasticTools::Calculator::CalculatorState

privateinherited

Definition at line 125 of file Calculators.h.

  {
    NONE,
    INITIALIZED,
    FINALIZED
  };

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 75 of file Calculators.h.

{
  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 92 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 34 of file SobolCalculators.h.

34{ 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 97 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 81 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.

99{ return _name; }

StochasticTools::Calculator< std::vector< InType >, std::vector< OutType > >::_name

const std::string _name

Definition Calculators.h:132

◆ 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 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 InType::value_type & val )

inherited

Public function to update calculator with a piece of data.

_state mush be INITIALIZED

Definition at line 86 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 40 of file SobolCalculators.h.

◆ _name

const std::string StochasticTools::Calculator< std::vector< InType > , std::vector< OutType > >::_name

privateinherited

Definition at line 132 of file Calculators.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 38 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 42 of file SobolCalculators.h.

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

◆ _state

CalculatorState StochasticTools::Calculator< std::vector< InType > , std::vector< OutType > >::_state

privateinherited

Definition at line 133 of file Calculators.h.

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ CalculatorState

Constructor & Destructor Documentation

◆ SobolCalculator()

Member Function Documentation

◆ compute()

◆ finalize()

◆ finalizeCalculator()

◆ get()

◆ getValue()

◆ initialize()

◆ initializeCalculator()

◆ name()

◆ update() [1/2]

◆ update() [2/2]

◆ updateCalculator()

Member Data Documentation

◆ _amat

◆ _name

◆ _resample

◆ _sobol

◆ _state