This class is designed to provide a uniform interface for any class that uses an array of coefficients for any of its operations. More...

#include <MutableCoefficientsInterface.h>

Inheritance diagram for MutableCoefficientsInterface:

[legend]

Public Member Functions
	MutableCoefficientsInterface (const MooseObject *moose_object, const InputParameters &parameters)

Real	operator[] (std::size_t index) const
	Get the value of the coefficient at the corresponding index.

const std::vector< std::size_t > &	getCharacteristics () const
	Get a reference to the characteristics array.

const std::vector< Real > &	getCoefficients () const
	Get a read-only reference to the vector of coefficients.

std::vector< Real > &	getCoefficients ()
	Get a writeable reference to the vector of coefficients.

std::string	getCoefficientsTable () const
	Get a formatted string of the coefficients.

std::size_t	getSize () const
	Get the size, aka number of coefficients.

bool	isCompatibleWith (const MutableCoefficientsInterface &other) const
	Checks to see if another instance is compatible.

bool	isSizeEnforced () const
	Returns true if the size of the coefficient array is fixed and enforced.

void	enforceSize (bool enforce)
	Toggle whether the size of the coefficient array can be changed.

void	importCoefficients (const MutableCoefficientsInterface &other)
	Import the coefficients from another instance.

void	resize (std::size_t size, Real fill=0.0, bool fill_out_to_size=true)
	Resize the array, using the value for fill if the new size is larger.

void	setCharacteristics (const std::vector< std::size_t > &new_characteristics)
	Sets the characteristics array.

void	setCoefficients (const std::vector< Real > &new_coefficients)
	Set the coefficients using a copy operation.

void	setCoefficients (std::vector< Real > &&dropin_coefficients)
	Set the coefficients using a move operation (only works with temp objects)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	coefficientsChanged ()
	Called when the coefficients have been changed.

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

Protected Attributes
std::vector< std::size_t > &	_characteristics
	An array of integer characteristics that can be used to check compatibility.

std::vector< Real > &	_coefficients
	The coefficient array.

bool	_enforce_size
	Boolean that locks or allows resizing of the coefficient array.

const bool	_print_coefficients
	Boolean to flag if the coefficients should be printed when set.

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

Private Member Functions
RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)

RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const

Private Attributes
const ConsoleStream &	_console
	MooseObject instance of `this` to provide access to `_console`

const RestartableDataMapName	_metaname

std::string	_restartable_name

Friends
std::ostream &	operator<< (std::ostream &stream, const MutableCoefficientsInterface &me)
	Friend operator to easily print out the array of coefficients.

Detailed Description

This class is designed to provide a uniform interface for any class that uses an array of coefficients for any of its operations.

In particular, the MultiAppFXTransfer mechanism transfers coefficients using this interface. Any derived class of MutableCoefficientsInterface can easily be used in any MultiAppFXTransfer-based transfer.

Definition at line 26 of file MutableCoefficientsInterface.h.

Constructor & Destructor Documentation

◆ MutableCoefficientsInterface()

MutableCoefficientsInterface::MutableCoefficientsInterface	(	const MooseObject *	moose_object,
		const InputParameters &	parameters
	)

Definition at line 30 of file MutableCoefficientsInterface.C.

  : Restartable(moose_object->getMooseApp(),
                moose_object->name() + "_coefs",
                "MutableCoefficientsInterface",
                moose_object->parameters().get<THREAD_ID>("_tid")),
    _characteristics(declareRestartableData<std::vector<std::size_t>>("characteristics")),
    _coefficients(declareRestartableData<std::vector<Real>>("coefficients")),
    _enforce_size(false),
    _print_coefficients(parameters.get<bool>("print_when_set")),
    _console(moose_object->_console)
{
}

Member Function Documentation

◆ coefficientsChanged()

virtual void MutableCoefficientsInterface::coefficientsChanged ( )

inlineprotectedvirtual

Called when the coefficients have been changed.

Reimplemented in MutableCoefficientsFunctionInterface.

Definition at line 105 of file MutableCoefficientsInterface.h.

105{}

Referenced by importCoefficients(), resize(), setCoefficients(), and setCoefficients().

◆ enforceSize()

void MutableCoefficientsInterface::enforceSize ( bool enforce )

Toggle whether the size of the coefficient array can be changed.

Definition at line 111 of file MutableCoefficientsInterface.C.

{
  _enforce_size = enforce;
}

Referenced by FunctionSeries::FunctionSeries(), and MutableCoefficientsFunctionInterface::MutableCoefficientsFunctionInterface().

◆ getCharacteristics()

const std::vector< std::size_t > & MutableCoefficientsInterface::getCharacteristics ( ) const

Get a reference to the characteristics array.

Definition at line 51 of file MutableCoefficientsInterface.C.

{
  return _characteristics;
}

◆ getCoefficients() [1/2]

std::vector< Real > & MutableCoefficientsInterface::getCoefficients ( )

Get a writeable reference to the vector of coefficients.

Definition at line 63 of file MutableCoefficientsInterface.C.

{
  return _coefficients;
}

◆ getCoefficients() [2/2]

const std::vector< Real > & MutableCoefficientsInterface::getCoefficients ( ) const

Get a read-only reference to the vector of coefficients.

Definition at line 57 of file MutableCoefficientsInterface.C.

{
  return _coefficients;
}

◆ getCoefficientsTable()

std::string MutableCoefficientsInterface::getCoefficientsTable ( ) const

Get a formatted string of the coefficients.

Definition at line 69 of file MutableCoefficientsInterface.C.

{
  std::stringbuf string;
  std::ostream table(&string);
 
  table << *this;
 
  return string.str();
}

◆ getSize()

std::size_t MutableCoefficientsInterface::getSize ( ) const

Get the size, aka number of coefficients.

Definition at line 80 of file MutableCoefficientsInterface.C.

{
  return _coefficients.size();
}

Referenced by isCompatibleWith().

◆ importCoefficients()

void MutableCoefficientsInterface::importCoefficients ( const MutableCoefficientsInterface & other )

Import the coefficients from another instance.

Definition at line 117 of file MutableCoefficientsInterface.C.

{
  if (!isCompatibleWith(other))
    mooseError("Cannot import coefficients from incompatible MutableCoefficientsInterface");
 
  _coefficients = other._coefficients;
 
  if (_print_coefficients)
    _console << *this;
 
  coefficientsChanged();
}

Referenced by MultiAppFXTransfer::execute().

◆ isCompatibleWith()

bool MutableCoefficientsInterface::isCompatibleWith ( const MutableCoefficientsInterface & other ) const

Checks to see if another instance is compatible.

Definition at line 86 of file MutableCoefficientsInterface.C.

{
  // Check the coefficient sizes if requested
  if ((_enforce_size && other._enforce_size) && getSize() != other.getSize())
    return false;
 
  // Check the size of the characteristics array
  if (_characteristics.size() != other._characteristics.size())
    return false;
 
  // Check the values of the characteristics array
  for (std::size_t i = 0; i < _characteristics.size(); ++i)
    if (_characteristics[i] != other._characteristics[i])
      return false;
 
  return true;
}

Referenced by MultiAppFXTransfer::execute(), and importCoefficients().

◆ isSizeEnforced()

bool MutableCoefficientsInterface::isSizeEnforced ( ) const

Returns true if the size of the coefficient array is fixed and enforced.

Definition at line 105 of file MutableCoefficientsInterface.C.

{
  return _enforce_size;
}

◆ operator[]()

Real MutableCoefficientsInterface::operator[] ( std::size_t index ) const

Get the value of the coefficient at the corresponding index.

Definition at line 45 of file MutableCoefficientsInterface.C.

{
  return _coefficients[index];
}

◆ resize()

void MutableCoefficientsInterface::resize	(	std::size_t	size,
		Real	fill = `0.0`,
		bool	fill_out_to_size = `true`
	)

Resize the array, using the value for fill if the new size is larger.

Definition at line 131 of file MutableCoefficientsInterface.C.

{
  if (size != _coefficients.size())
  {
    if (_enforce_size &&
        (size > _coefficients.size() || (size < _coefficients.size() && !fill_out_to_size)))
      mooseError("Cannot resize coefficient array with size enforcement enabled.");
 
    _coefficients.resize(size, fill);
 
    if (_print_coefficients)
      _console << *this;
 
    coefficientsChanged();
  }
}

Referenced by FunctionSeries::FunctionSeries(), and FXIntegralBaseUserObject< IntegralBaseVariableUserObject >::FXIntegralBaseUserObject().

◆ setCharacteristics()

void MutableCoefficientsInterface::setCharacteristics ( const std::vector< std::size_t > & new_characteristics )

Sets the characteristics array.

Definition at line 149 of file MutableCoefficientsInterface.C.

{
  _characteristics = new_characteristics;
}

Referenced by FunctionSeries::FunctionSeries().

◆ setCoefficients() [1/2]

void MutableCoefficientsInterface::setCoefficients ( const std::vector< Real > & new_coefficients )

Set the coefficients using a copy operation.

Definition at line 156 of file MutableCoefficientsInterface.C.

{
  if (_enforce_size && new_coefficients.size() != _coefficients.size())
    mooseError("Cannon assigned a coefficient array with differing size when size enforcement is "
               "enabled.");
 
  _coefficients = new_coefficients;
 
  if (_print_coefficients)
    _console << *this;
 
  coefficientsChanged();
}

Referenced by MutableCoefficientsFunctionInterface::MutableCoefficientsFunctionInterface().

◆ setCoefficients() [2/2]

void MutableCoefficientsInterface::setCoefficients ( std::vector< Real > && dropin_coefficients )

Set the coefficients using a move operation (only works with temp objects)

Definition at line 171 of file MutableCoefficientsInterface.C.

{
  if (_enforce_size && dropin_coefficients.size() != _coefficients.size())
    mooseError("Cannon assigned a coefficient array with differing size when size enforcement is "
               "enabled.");
 
  _coefficients = dropin_coefficients;
 
  if (_print_coefficients)
    _console << *this;
 
  coefficientsChanged();
}

◆ validParams()

InputParameters MutableCoefficientsInterface::validParams ( )

static

Definition at line 18 of file MutableCoefficientsInterface.C.

{
  InputParameters params = emptyInputParameters();
 
  params.addClassDescription("This interface universalizes the communication standards for "
                             "array-based coefficient transfers.");
 
  params.addParam<bool>("print_when_set", false, "Print the array of coefficients when set");
 
  return params;
}

Referenced by MutableCoefficientsFunctionInterface::validParams(), and FXIntegralBaseUserObject< IntegralBaseVariableUserObject >::validParams().

Friends And Related Symbol Documentation

◆ operator<<

std::ostream & operator<<	(	std::ostream &	stream,
		const MutableCoefficientsInterface &	me
	)

friend

Friend operator to easily print out the array of coefficients.

Definition at line 185 of file MutableCoefficientsInterface.C.

{
  const MooseObject * myself_again = dynamic_cast<const MooseObject *>(&me);
  stream << "\n\n"
         << "MutableCoefficientsInterface: " << (myself_again ? myself_again->name() : "Unknown")
         << "\n"
         << "      Number of Coefficients: " << me.getSize() << "\n";
 
  for (std::size_t i = 0; i < me.getSize(); ++i)
    stream << std::setw(4) << i << ": " << std::setw(12) << me[i] << ((i % 6 == 5) ? "\n" : "    ");
 
  stream << "\n\n" << std::flush;
 
  return stream;
}

Member Data Documentation

◆ _characteristics

std::vector<std::size_t>& MutableCoefficientsInterface::_characteristics

protected

An array of integer characteristics that can be used to check compatibility.

Definition at line 108 of file MutableCoefficientsInterface.h.

Referenced by FXIntegralBaseUserObject< IntegralBaseVariableUserObject >::FXIntegralBaseUserObject(), getCharacteristics(), isCompatibleWith(), and setCharacteristics().

◆ _coefficients

std::vector<Real>& MutableCoefficientsInterface::_coefficients

protected

The coefficient array.

Definition at line 111 of file MutableCoefficientsInterface.h.

Referenced by FunctionSeries::expand(), FXIntegralBaseUserObject< IntegralBaseVariableUserObject >::FXIntegralBaseUserObject(), getCoefficients(), getCoefficients(), getSize(), importCoefficients(), operator[](), resize(), setCoefficients(), and setCoefficients().

◆ _console

const ConsoleStream& MutableCoefficientsInterface::_console

private

MooseObject instance of this to provide access to _console

Definition at line 121 of file MutableCoefficientsInterface.h.

Referenced by importCoefficients(), resize(), setCoefficients(), and setCoefficients().

◆ _enforce_size

bool MutableCoefficientsInterface::_enforce_size

protected

Boolean that locks or allows resizing of the coefficient array.

Definition at line 114 of file MutableCoefficientsInterface.h.

Referenced by enforceSize(), isCompatibleWith(), isSizeEnforced(), resize(), setCoefficients(), and setCoefficients().

◆ _print_coefficients

const bool MutableCoefficientsInterface::_print_coefficients

protected

Boolean to flag if the coefficients should be printed when set.

Definition at line 117 of file MutableCoefficientsInterface.h.

Referenced by importCoefficients(), resize(), setCoefficients(), and setCoefficients().

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

functional_expansion_tools/include/coefficients/MutableCoefficientsInterface.h
functional_expansion_tools/src/coefficients/MutableCoefficientsInterface.C

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ MutableCoefficientsInterface()

Member Function Documentation

◆ coefficientsChanged()

◆ enforceSize()

◆ getCharacteristics()

◆ getCoefficients() [1/2]

◆ getCoefficients() [2/2]

◆ getCoefficientsTable()

◆ getSize()

◆ importCoefficients()

◆ isCompatibleWith()

◆ isSizeEnforced()

◆ operator[]()

◆ resize()

◆ setCharacteristics()

◆ setCoefficients() [1/2]

◆ setCoefficients() [2/2]

◆ validParams()

Friends And Related Symbol Documentation

◆ operator<<

Member Data Documentation

◆ _characteristics

◆ _coefficients

◆ _console

◆ _enforce_size

◆ _print_coefficients