Reporter context for computing direct perturbation-based sensitivity coefficients. More...

#include <DirectPerturbationReporter.h>

Inheritance diagram for DirectPerturbationReporterContext< DataType >:

Public Types
enum	AutoOperation

Public Member Functions
	DirectPerturbationReporterContext (const libMesh::ParallelObject &other, const MooseObject &producer, ReporterState< std::vector< DataType > > &state, DirectPerturbationSampler &sampler, const std::vector< DataType > &data, const bool relative_sensitivity)
	Constructor.

virtual void	finalize () override

virtual std::string	type () const override

virtual void	declareClone (ReporterData &r_data, const ReporterName &r_name, const ReporterMode &mode, const MooseObject &producer) const override

virtual void	declareVectorClone (ReporterData &r_data, const ReporterName &r_name, const ReporterMode &mode, const MooseObject &producer) const override

virtual void	resize (dof_id_type local_size) final

virtual void	clear () final

virtual void	vectorSum () final

virtual std::string	contextType () const override

const ReporterName &	name () const override final

const ReporterState< T > &	state () const

virtual void	transfer (ReporterData &r_data, const ReporterName &r_name, unsigned int time_index=0) const override

virtual void	transferToVector (ReporterData &r_data, const ReporterName &r_name, dof_id_type index, unsigned int time_index=0) const override

virtual void	transferFromVector (ReporterData &r_data, const ReporterName &r_name, dof_id_type index, unsigned int time_index=0) const override

virtual void	broadcast (processor_id_type root=0) override

void	init (const ReporterMode &mode)

const MooseObject &	getProducer () const

const ReporterProducerEnum &	getProducerModeEnum () const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Protected Member Functions
virtual void	storeInfo (nlohmann::json &json) const override

virtual void	store (nlohmann::json &json) const override

virtual void	copyValuesBack () override

virtual bool	restoreState () override

void	requiresConsumerModes (const ReporterStateBase &state, const std::set< ReporterMode > &modes) const

Protected Attributes
ReporterState< T > &	_state

const MooseObject &	_producer

ReporterProducerEnum	_producer_enum

const Parallel::Communicator &	_communicator

Private Member Functions
void	addSensitivityContribution (DataType &add_to, const DataType &to_add, const DataType &reference_value, const Real interval) const
	Compute direct perturbation sensitivity, split into a separate function due to the different operators on vectors and scalars.

DataType	initializeDataType (const DataType &example_output) const
	Initialize the sensitivity container, split into a separate function due to the different constructors for scalars and vectors.

Private Attributes
DirectPerturbationSampler &	_sampler
	Reference to the direct perturbation sampler.

const std::vector< DataType > &	_data
	Data used for the statistic calculation.

const bool	_relative_sensitivity
	If relative sensitivities should be computed.

Detailed Description

template<typename DataType>
class DirectPerturbationReporterContext< DataType >

Reporter context for computing direct perturbation-based sensitivity coefficients.

Definition at line 58 of file DirectPerturbationReporter.h.

Constructor & Destructor Documentation

◆ DirectPerturbationReporterContext()

template<typename DataType >

DirectPerturbationReporterContext< DataType >::DirectPerturbationReporterContext	(	const libMesh::ParallelObject &	other,
		const MooseObject &	producer,
		ReporterState< std::vector< DataType > > &	state,
		DirectPerturbationSampler &	sampler,
		const std::vector< DataType > &	data,
		const bool	relative_sensitivity
	)

Constructor.

Parameters

other	A parallel object, usually the MooseApp
producer	The producer object for the reporter
state	A reporter state (a vector of some types in this case)
sampler	The sampler holding information on the direct perturbation paraemters
data	The data coming back from the executed models

Definition at line 95 of file DirectPerturbationReporter.C.

  : ReporterGeneralContext<std::vector<DataType>>(other, producer, state),
    _sampler(sampler),
    _data(data),
    _relative_sensitivity(relative_sensitivity)
{
  this->_state.value().resize(_sampler.getNumberOfCols());
}

Member Function Documentation

◆ addSensitivityContribution()

template<typename DataType >

void DirectPerturbationReporterContext< DataType >::addSensitivityContribution	(	DataType &	add_to,
		const DataType &	to_add,
		const DataType &	reference_value,
		const Real	interval
	)		const

private

Compute direct perturbation sensitivity, split into a separate function due to the different operators on vectors and scalars.

Parameters

add_to	The data structure which will be extended
to_add	The data structure which will be added to the other one
reference_value	The reference values in case we are computing relative sensitivities
interval	The interval scaling coefficient vector

Definition at line 179 of file DirectPerturbationReporter.C.

{
  // DataType is a numeric type that we can sum (excluding bool)
  if constexpr (std::is_arithmetic<DataType>::value && !std::is_same<DataType, bool>::value)
  {
    add_to += to_add / (_relative_sensitivity ? interval * reference_value : interval);
    return;
  }
  // DataType is a vector type
  else if constexpr (is_std_vector<DataType>::value)
  {
    // It can still be anything in the vector elements, so we will check this later
    using VectorValueType = typename DataType::value_type;
 
    mooseAssert(add_to.size() == to_add.size(), "The vectors for summation have different sizes!");
 
    // Check if the vector elements are of a numeric type
    if constexpr (std::is_arithmetic<VectorValueType>::value &&
                  !std::is_same<VectorValueType, bool>::value)
    {
      for (const auto index : index_range(add_to))
        add_to[index] +=
            to_add[index] / (_relative_sensitivity ? interval * reference_value[index] : interval);
      return;
    }
    // Check if the vector elements are also vectors
    else if constexpr (is_std_vector<VectorValueType>::value)
    {
      // This is as deep as we will go for now
      using InnerValueType = typename VectorValueType::value_type;
 
      // Check if the inner vector elements are of a numeric type
      if constexpr (std::is_arithmetic<InnerValueType>::value &&
                    !std::is_same<InnerValueType, bool>::value)
      {
        // Iterate over each inner vector in the outer vector
        for (auto & inner_index : index_range(add_to))
        {
          mooseAssert(add_to[inner_index].size() == to_add[inner_index].size(),
                      "The vectors for summation have different sizes!");
          for (const auto index : index_range(add_to[inner_index]))
            add_to[inner_index][index] +=
                to_add[inner_index][index] /
                (_relative_sensitivity ? interval * reference_value[inner_index][index] : interval);
        }
        return;
      }
      else
        static_assert(Moose::always_false<DataType>,
                      "Sensitivity coefficient computation is not implemented for the given type!");
    }
  }
  else
    static_assert(Moose::always_false<DataType>,
                  "Sensitivity coefficient computation is not implemented for the given type!");
}

◆ finalize()

template<typename DataType >

void DirectPerturbationReporterContext< DataType >::finalize ( )

overridevirtual

Reimplemented from ReporterGeneralContext< std::vector< DataType > >.

Definition at line 112 of file DirectPerturbationReporter.C.

{
  const dof_id_type offset = _sampler.getLocalRowBegin();
  const dof_id_type num_columns = _sampler.getNumberOfCols();
 
  // If we are computing the relative sensitivity, we will need
  // the reference value. So the process that has that will communicate it
  // to everybody. We reuse the initialization function for the reference
  // value as well
  // _data can be empty on a rank with zero local rows.
  auto reference_value = _data.empty() ? DataType() : initializeDataType(_data[0]);
  if (_relative_sensitivity)
  {
    // The reference point is sampler row 0, which is always local to rank 0.
    if (this->processor_id() == 0)
      reference_value = _data[0];
    this->comm().broadcast(reference_value);
  }
 
  for (const auto param_i : make_range(num_columns))
  {
    // If we need relative coefficients we need to normalize the difference
    const auto interval = _relative_sensitivity ? _sampler.getRelativeInterval(param_i)
                                                : _sampler.getAbsoluteInterval(param_i);
 
    dof_id_type left_i;
    dof_id_type right_i;
    // Depending on which method we use, the indices will change
    if (_sampler.perturbationMethod() == "central_difference")
    {
      left_i = 2 * param_i + 1;
      right_i = 2 * param_i + 2;
    }
    else
    {
      left_i = param_i + 1;
      right_i = 0;
    }
 
    const bool left_i_in_owned_range =
        _sampler.getLocalRowBegin() <= left_i && left_i < _sampler.getLocalRowEnd();
    const bool right_i_in_owned_range =
        _sampler.getLocalRowBegin() <= right_i && right_i < _sampler.getLocalRowEnd();
 
    if (left_i_in_owned_range || right_i_in_owned_range)
    {
      const dof_id_type copy_i = left_i_in_owned_range ? left_i - offset : right_i - offset;
      this->_state.value()[param_i] = initializeDataType(_data[copy_i]);
    }
 
    // We add the contribution from one side
    if (left_i_in_owned_range)
      addSensitivityContribution(
          this->_state.value()[param_i], _data[left_i - offset], reference_value, interval);
 
    // We add the contribution from the other side
    if (right_i_in_owned_range)
      addSensitivityContribution(
          this->_state.value()[param_i], _data[right_i - offset], reference_value, -interval);
  }
 
  // We gather the contributions across all processors
  this->vectorSum();
}

◆ initializeDataType()

template<typename DataType >

DataType DirectPerturbationReporterContext< DataType >::initializeDataType ( const DataType & example_output ) const

private

Initialize the sensitivity container, split into a separate function due to the different constructors for scalars and vectors.

Parameters

example_output A structure which supplies the dimensions for the allocation

Definition at line 242 of file DirectPerturbationReporter.C.

{
  // DataType is a numeric type so we just return 0
  if constexpr (std::is_arithmetic<DataType>::value && !std::is_same<DataType, bool>::value)
    return 0.0;
  // DataType is a vector type
  else if constexpr (is_std_vector<DataType>::value)
  {
    // It can still be anything in the vector elements, so we will check this later
    using VectorValueType = typename DataType::value_type;
 
    // Check if the vector elements are of a numeric type
    if constexpr (std::is_arithmetic<VectorValueType>::value &&
                  !std::is_same<VectorValueType, bool>::value)
      return std::vector<VectorValueType>(example_output.size(), 0);
    // Check if the vector elements are also vectors
    else if constexpr (is_std_vector<VectorValueType>::value)
    {
      // This is as deep as we will go for now
      using InnerValueType = typename VectorValueType::value_type;
 
      // Check if the inner vector elements are of a numeric type
      if constexpr (std::is_arithmetic<InnerValueType>::value &&
                    !std::is_same<InnerValueType, bool>::value)
      {
        auto return_vector = std::vector<VectorValueType>(example_output.size());
        // Iterate over each inner vector in the outer vector
        for (auto & inner_index : index_range(example_output))
          return_vector[inner_index].resize(example_output.size(), 0.0);
        return return_vector;
      }
    }
    else
      static_assert(Moose::always_false<DataType>,
                    "Sensitivity coefficient computation is not implemented for the given type!");
  }
  else
    static_assert(Moose::always_false<DataType>,
                  "Sensitivity coefficient initialization is not implemented for the given type!");
}

◆ type()

template<typename DataType >

virtual std::string DirectPerturbationReporterContext< DataType >::type ( ) const

inlineoverridevirtual

Reimplemented from ReporterGeneralContext< std::vector< DataType > >.

Definition at line 77 of file DirectPerturbationReporter.h.

  {
    return "DirectPerturbationSensitivity<" + MooseUtils::prettyCppType<DataType>() + ">";
  }

Member Data Documentation

◆ _data

template<typename DataType >

const std::vector<DataType>& DirectPerturbationReporterContext< DataType >::_data

private

Data used for the statistic calculation.

Definition at line 103 of file DirectPerturbationReporter.h.

◆ _relative_sensitivity

template<typename DataType >

const bool DirectPerturbationReporterContext< DataType >::_relative_sensitivity

private

If relative sensitivities should be computed.

Definition at line 106 of file DirectPerturbationReporter.h.

◆ _sampler

template<typename DataType >

DirectPerturbationSampler& DirectPerturbationReporterContext< DataType >::_sampler

private

Reference to the direct perturbation sampler.

Definition at line 100 of file DirectPerturbationReporter.h.

Referenced by DirectPerturbationReporterContext< DataType >::DirectPerturbationReporterContext().

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

stochastic_tools/include/reporters/DirectPerturbationReporter.h
stochastic_tools/src/reporters/DirectPerturbationReporter.C

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DirectPerturbationReporterContext()

Member Function Documentation

◆ addSensitivityContribution()

◆ finalize()

◆ initializeDataType()

◆ type()

Member Data Documentation

◆ _data

◆ _relative_sensitivity

◆ _sampler