Interface for a type of functions using coefficients that may be changed before or after a solve. More...

#include <MutableCoefficientsFunctionInterface.h>

Inheritance diagram for MutableCoefficientsFunctionInterface:

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

virtual void	meshChanged () override

void	useCache (bool use)
	Enable/disable the cache. More...

virtual Real	value (Real time, const Point &point) const final

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

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

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

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

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

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

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

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

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

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

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. More...

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

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

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

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

virtual Real	evaluateValue (Real time, const Point &point)=0
	Used in derived classes, equivalent to Function::value() More...

void	invalidateCache ()
	Called by derived classes to invalidate the cache, perhaps due to a state change. More...

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

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

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

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

Private Attributes
std::unordered_map< hashing::HashValue, Real >	_cache
	Cached evaluations for each point. More...

Real	_current_time
	Stores the time evaluation of the cache. More...

bool	_enable_cache
	Flag for whether to cache values. More...

bool	_respect_time
	Flag for whether changes in time invalidate the cache. More...

const ConsoleStream &	_console
	MooseObject instance of `this` to provide access to `_console` More...

Detailed Description

Interface for a type of functions using coefficients that may be changed before or after a solve.

Definition at line 25 of file MutableCoefficientsFunctionInterface.h.

Constructor & Destructor Documentation

◆ MutableCoefficientsFunctionInterface()

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

Definition at line 28 of file MutableCoefficientsFunctionInterface.C.

   : MemoizedFunctionInterface(parameters),
     FunctionInterface(this),
     MutableCoefficientsInterface(moose_object, parameters)
 {
   if (isParamValid("coefficients"))
     setCoefficients(getParam<std::vector<Real>>("coefficients")), enforceSize(true);
 }

Member Function Documentation

◆ coefficientsChanged()

void MutableCoefficientsFunctionInterface::coefficientsChanged ( )

overrideprotectedvirtual

Called when the coefficients have been changed.

Reimplemented from MutableCoefficientsInterface.

Definition at line 39 of file MutableCoefficientsFunctionInterface.C.

 {
   // The coefficients have changed, which invalidates the cache
   invalidateCache();
 }

◆ enforceSize()

void MutableCoefficientsInterface::enforceSize ( bool enforce )

inherited

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().

◆ evaluateValue()

virtual Real MemoizedFunctionInterface::evaluateValue	(	Real	time,
		const Point &	point
	)

protectedpure virtualinherited

Used in derived classes, equivalent to Function::value()

Implemented in FunctionSeries.

Referenced by MemoizedFunctionInterface::value().

◆ getCharacteristics()

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

inherited

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 ( )

inherited

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

inherited

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

inherited

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

inherited

Get the size, aka number of coefficients.

Definition at line 80 of file MutableCoefficientsInterface.C.

 {
   return _coefficients.size();
 }

Referenced by MutableCoefficientsInterface::isCompatibleWith(), and operator<<().

◆ importCoefficients()

void MutableCoefficientsInterface::importCoefficients ( const MutableCoefficientsInterface & other )

inherited

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().

◆ invalidateCache()

void MemoizedFunctionInterface::invalidateCache ( )

protectedinherited

Called by derived classes to invalidate the cache, perhaps due to a state change.

Definition at line 84 of file MemoizedFunctionInterface.C.

 {
   _cache.clear();
 }

Referenced by coefficientsChanged(), MemoizedFunctionInterface::meshChanged(), MemoizedFunctionInterface::useCache(), and MemoizedFunctionInterface::value().

◆ isCompatibleWith()

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

inherited

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 MutableCoefficientsInterface::importCoefficients().

◆ isSizeEnforced()

bool MutableCoefficientsInterface::isSizeEnforced ( ) const

inherited

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

Definition at line 105 of file MutableCoefficientsInterface.C.

 {
   return _enforce_size;
 }

◆ meshChanged()

void MemoizedFunctionInterface::meshChanged ( )

overridevirtualinherited

Definition at line 40 of file MemoizedFunctionInterface.C.

 {
   // The mesh has changed, which invalidates the cache
   invalidateCache();
 }

◆ operator[]()

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

inherited

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`
	)

inherited

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().

◆ setCharacteristics()

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

inherited

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 )

inherited

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().

◆ setCoefficients() [2/2]

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

inherited

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();
 }

◆ useCache()

void MemoizedFunctionInterface::useCache ( bool use )

inherited

Enable/disable the cache.

Definition at line 75 of file MemoizedFunctionInterface.C.

 {
   _enable_cache = use;
  
   if (!_enable_cache)
     invalidateCache();
 }

Referenced by FXFluxBC::FXFluxBC(), FXValueBC::FXValueBC(), and FXValuePenaltyBC::FXValuePenaltyBC().

◆ value()

Real MemoizedFunctionInterface::value	(	Real	time,
		const Point &	point
	)		const

finalvirtualinherited

Definition at line 47 of file MemoizedFunctionInterface.C.

 {
   MemoizedFunctionInterface * ptr = const_cast<MemoizedFunctionInterface *>(this);
  
   if (_enable_cache)
   {
     // Start the cache over if we are at a new time step
     if (_respect_time && time != _current_time)
     {
       _current_time = time;
       ptr->invalidateCache();
     }
  
     // Try to insert a new value into the cache
     auto result = _cache.insert({hashing::hashCombine(time, point), 0.0});
  
     // Evaluate and apply if the insertion worked, i.e. the element didn't exist
     if (result.second)
       result.first->second = ptr->evaluateValue(time, point);
  
     // Return the cached value
     return result.first->second;
   }
  
   return ptr->evaluateValue(time, point);
 }