www.mooseframework.org
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Static Private Member Functions | Friends | List of all members
FunctionSeries Class Reference

This class uses implementations of CompositeSeriesBasisInterface to generate a function based on convolved function series. More...

#include <FunctionSeries.h>

Inheritance diagram for FunctionSeries:
[legend]

Public Member Functions

 FunctionSeries (const InputParameters &parameters)
 
virtual Real evaluateValue (Real t, const Point &p) override
 Used in derived classes, equivalent to Function::value() More...
 
Real expand ()
 Expand the function series at the current location and with the current coefficients. More...
 
Real expand (const std::vector< Real > &coefficients)
 Expand the function using the provided coefficients at the current location. More...
 
std::size_t getNumberOfTerms () const
 Returns the number of terms (coefficients) in the underlying function series. More...
 
Real getStandardizedFunctionVolume () const
 Returns the volume of evaluation in the functional series standardized space. More...
 
const std::vector< std::size_t > & getOrders () const
 Returns a vector of the functional orders in the underlying functional series. More...
 
const std::vector< Real > & getGeneration ()
 Returns a vector of the generation-evaluated functional series at the current location. More...
 
const std::vector< Real > & getExpansion ()
 Returns a vector of the expansion-evaluated functional series at the current location. More...
 
bool isInPhysicalBounds (const Point &point) const
 Returns true if the provided point is within the set physical boundaries. More...
 
void setLocation (const Point &point)
 Set the current evaluation location. More...
 
virtual void meshChanged () override
 
void useCache (bool use)
 Enable/disable the cache. More...
 
virtual Real value (Real time, const Point &point) 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...
 

Static Public Member Functions

static FunctionSeriescheckAndConvertFunction (Function &function, const std::string &typeName, const std::string &objectName)
 Static function to cast a Function to SeriesFunction. More...
 

Protected Member Functions

virtual void coefficientsChanged () override
 Called when the coefficients have been changed. More...
 
void invalidateCache ()
 Called by derived classes to invalidate the cache, perhaps due to a state change. More...
 

Protected Attributes

const std::vector< std::size_t > _orders
 The vector holding the orders of each single series. More...
 
const std::vector< Real > _physical_bounds
 The physical bounds of the function series. More...
 
std::unique_ptr< CompositeSeriesBasisInterface_series_type
 Stores a pointer to the functional series object. More...
 
const MooseEnum & _series_type_name
 Stores the name of the current functional series type. More...
 
const MooseEnum & _x
 Stores the name of the single function series to use in the x direction. More...
 
const MooseEnum & _y
 Stores the name of the single function series to use in the y direction. More...
 
const MooseEnum & _z
 Stores the name of the single function series to use in the z direction. More...
 
const MooseEnum & _disc
 Stores the name of the single function series to use for a unit disc. More...
 
const MooseEnum & _expansion_type
 The normalization type for expansion. More...
 
const MooseEnum & _generation_type
 The normalization type for generation. More...
 
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...
 

Static Private Member Functions

static std::vector< std::size_t > convertOrders (const std::vector< unsigned int > &orders)
 Static function to convert an array of unsigned int to std::size_t. More...
 

Friends

std::ostream & operator<< (std::ostream &stream, const FunctionSeries &me)
 Returns a tabularized text stream of the currently stored coefficients. More...
 

Detailed Description

This class uses implementations of CompositeSeriesBasisInterface to generate a function based on convolved function series.

Its inheritance tree includes MutableCoefficientsInterface, which enables easy MultiApp transfers of coefficients.

Definition at line 26 of file FunctionSeries.h.

Constructor & Destructor Documentation

◆ FunctionSeries()

FunctionSeries::FunctionSeries ( const InputParameters &  parameters)

Definition at line 75 of file FunctionSeries.C.

76  : MutableCoefficientsFunctionInterface(this, parameters),
77  _orders(convertOrders(getParam<std::vector<unsigned int>>("orders"))),
78  _physical_bounds(getParam<std::vector<Real>>("physical_bounds")),
79  _series_type_name(getParam<MooseEnum>("series_type")),
80  _x(getParam<MooseEnum>("x")),
81  _y(getParam<MooseEnum>("y")),
82  _z(getParam<MooseEnum>("z")),
83  _disc(getParam<MooseEnum>("disc")),
84  _expansion_type(getParam<MooseEnum>("expansion_type")),
85  _generation_type(getParam<MooseEnum>("generation_type"))
86 {
87  std::vector<MooseEnum> domains;
88  std::vector<MooseEnum> types;
89 
90  if (_series_type_name == "Cartesian")
91  {
92  /*
93  * For Cartesian series, at least one of 'x', 'y', and 'z' must be specified.
94  *
95  * The individual series are always stored in x, y, z order (independent of the order in which
96  * they appear in the input file). Hence, the 'orders' and 'physical_bounds' vectors must always
97  * be specified in x, y, z order.
98  */
99  if (isParamValid("x"))
100  {
101  domains.push_back(FunctionalBasisInterface::_domain_options = "x");
102  types.push_back(_x);
103  }
104  if (isParamValid("y"))
105  {
106  domains.push_back(FunctionalBasisInterface::_domain_options = "y");
107  types.push_back(_y);
108  }
109  if (isParamValid("z"))
110  {
111  domains.push_back(FunctionalBasisInterface::_domain_options = "z");
112  types.push_back(_z);
113  }
114  if (types.size() == 0)
115  mooseError("Must specify one of 'x', 'y', or 'z' for 'Cartesian' series!");
116  _series_type = libmesh_make_unique<Cartesian>(
117  domains, _orders, types, name(), _expansion_type, _generation_type);
118  }
119  else if (_series_type_name == "CylindricalDuo")
120  {
121  /*
122  * CylindricalDuo represents a disc-axial expansion, where the disc is described by a single
123  * series, such as Zernike (as opposed to a series individually representing r and a second
124  * series independently representing theta. For CylindricalDuo series, the series are always
125  * stored in the axial, planar order, independent of which order the series appear in the input
126  * file. Therefore, the _orders and _physical_bounds vectors must always appear in axial, planar
127  * order. The first entry in _domains is interpreted as the axial direction, and the following
128  * two as the planar.
129  */
130  if (isParamValid("x"))
131  {
135  types.push_back(_x);
136  }
137  if (isParamValid("y"))
138  {
142  types.push_back(_y);
143  }
144  if (isParamValid("z"))
145  {
149  types.push_back(_z);
150  }
151 
152  if (types.size() == 0)
153  mooseError("Must specify one of 'x', 'y', or 'z' for 'CylindricalDuo' series!");
154 
155  if (types.size() > 1)
156  mooseError("Cannot specify more than one of 'x', 'y', or 'z' for 'CylindricalDuo' series!");
157 
158  types.push_back(_disc);
159  _series_type = libmesh_make_unique<CylindricalDuo>(
160  domains, _orders, types, name(), _expansion_type, _generation_type);
161  }
162  else
163  mooseError("Unknown functional series type \"", _series_type_name, "\"");
164 
165  // Set the physical bounds of each of the single series if defined
166  if (isParamValid("physical_bounds"))
167  _series_type->setPhysicalBounds(_physical_bounds);
168 
169  // Resize the coefficient array as needed
170  enforceSize(false), resize(getNumberOfTerms(), 0.0), enforceSize(true);
172 }
std::unique_ptr< CompositeSeriesBasisInterface > _series_type
Stores a pointer to the functional series object.
const MooseEnum & _x
Stores the name of the single function series to use in the x direction.
const std::vector< std::size_t > _orders
The vector holding the orders of each single series.
const MooseEnum & _generation_type
The normalization type for generation.
static MooseEnum _domain_options
An enumeration of the domains available to each functional series.
void setCharacteristics(const std::vector< std::size_t > &new_characteristics)
Sets the characteristics array.
const MooseEnum & _z
Stores the name of the single function series to use in the z direction.
const MooseEnum & _series_type_name
Stores the name of the current functional series type.
MutableCoefficientsFunctionInterface(const MooseObject *moose_object, const InputParameters &parameters)
const std::string name
Definition: Setup.h:22
std::size_t getNumberOfTerms() const
Returns the number of terms (coefficients) in the underlying function series.
const std::vector< Real > _physical_bounds
The physical bounds of the function series.
static std::vector< std::size_t > convertOrders(const std::vector< unsigned int > &orders)
Static function to convert an array of unsigned int to std::size_t.
const MooseEnum & _disc
Stores the name of the single function series to use for a unit disc.
const MooseEnum & _y
Stores the name of the single function series to use in the y direction.
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.
const MooseEnum & _expansion_type
The normalization type for expansion.
void enforceSize(bool enforce)
Toggle whether the size of the coefficient array can be changed.

Member Function Documentation

◆ checkAndConvertFunction()

FunctionSeries & FunctionSeries::checkAndConvertFunction ( Function &  function,
const std::string &  typeName,
const std::string &  objectName 
)
static

Static function to cast a Function to SeriesFunction.

Definition at line 175 of file FunctionSeries.C.

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

178 {
179  FunctionSeries * test = dynamic_cast<FunctionSeries *>(&function);
180  if (!test)
181  ::mooseError("In ",
182  typeName,
183  "-type object \"",
184  objectName,
185  "\": the named Function \"",
186  function.name(),
187  "\" must be a FunctionSeries-type object.");
188 
189  return *test;
190 }
This class uses implementations of CompositeSeriesBasisInterface to generate a function based on conv...
const std::string name
Definition: Setup.h:22

◆ coefficientsChanged()

void MutableCoefficientsFunctionInterface::coefficientsChanged ( )
overrideprotectedvirtualinherited

Called when the coefficients have been changed.

Reimplemented from MutableCoefficientsInterface.

Definition at line 39 of file MutableCoefficientsFunctionInterface.C.

40 {
41  // The coefficients have changed, which invalidates the cache
43 }
void invalidateCache()
Called by derived classes to invalidate the cache, perhaps due to a state change. ...

◆ convertOrders()

std::vector< std::size_t > FunctionSeries::convertOrders ( const std::vector< unsigned int > &  orders)
staticprivate

Static function to convert an array of unsigned int to std::size_t.

The MOOSE parser has issues reading a list of integers in as std::size_t (unsigned long), so this workaround is required in order to set _orders in the constructor initializer list.

Definition at line 290 of file FunctionSeries.C.

291 {
292  return std::vector<std::size_t>(orders.begin(), orders.end());
293 }

◆ enforceSize()

void MutableCoefficientsInterface::enforceSize ( bool  enforce)
inherited

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

Definition at line 110 of file MutableCoefficientsInterface.C.

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

111 {
112  _enforce_size = enforce;
113 }
bool _enforce_size
Boolean that locks or allows resizing of the coefficient array.

◆ evaluateValue()

Real FunctionSeries::evaluateValue ( Real  time,
const Point &  point 
)
overridevirtual

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

Implements MemoizedFunctionInterface.

Definition at line 250 of file FunctionSeries.C.

251 {
252  // Check that the point is within the physical bounds of the series
253  if (!isInPhysicalBounds(point))
254  return 0.0;
255 
256  // Set the location at which to evaluate the series
257  setLocation(point);
258 
259  return expand();
260 }
void setLocation(const Point &point)
Set the current evaluation location.
Real expand()
Expand the function series at the current location and with the current coefficients.
bool isInPhysicalBounds(const Point &point) const
Returns true if the provided point is within the set physical boundaries.

◆ expand() [1/2]

Real FunctionSeries::expand ( )

Expand the function series at the current location and with the current coefficients.

Definition at line 263 of file FunctionSeries.C.

Referenced by evaluateValue().

264 {
265  return expand(_coefficients);
266 }
Real expand()
Expand the function series at the current location and with the current coefficients.
std::vector< Real > & _coefficients
The coefficient array.

◆ expand() [2/2]

Real FunctionSeries::expand ( const std::vector< Real > &  coefficients)

Expand the function using the provided coefficients at the current location.

Definition at line 269 of file FunctionSeries.C.

270 {
271  // Evaluate all of the terms in the series
272  const std::vector<Real> & terms = getExpansion();
273 
274  return std::inner_product(terms.begin(), terms.end(), coefficients.begin(), 0.0);
275 }
const std::vector< Real > & getExpansion()
Returns a vector of the expansion-evaluated functional series at the current location.

◆ getCharacteristics()

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

Get a reference to the characteristics array.

Definition at line 50 of file MutableCoefficientsInterface.C.

51 {
52  return _characteristics;
53 }
std::vector< std::size_t > & _characteristics
An array of integer characteristics that can be used to check compatibility.

◆ getCoefficients() [1/2]

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

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

Definition at line 56 of file MutableCoefficientsInterface.C.

57 {
58  return _coefficients;
59 }
std::vector< Real > & _coefficients
The coefficient array.

◆ getCoefficients() [2/2]

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

Get a writeable reference to the vector of coefficients.

Definition at line 62 of file MutableCoefficientsInterface.C.

63 {
64  return _coefficients;
65 }
std::vector< Real > & _coefficients
The coefficient array.

◆ getCoefficientsTable()

std::string MutableCoefficientsInterface::getCoefficientsTable ( ) const
inherited

Get a formatted string of the coefficients.

Definition at line 68 of file MutableCoefficientsInterface.C.

69 {
70  std::stringbuf string;
71  std::ostream table(&string);
72 
73  table << *this;
74 
75  return string.str();
76 }

◆ getExpansion()

const std::vector< Real > & FunctionSeries::getExpansion ( )

Returns a vector of the expansion-evaluated functional series at the current location.

Definition at line 227 of file FunctionSeries.C.

Referenced by expand().

228 {
229  return _series_type->getAllExpansion();
230 }
std::unique_ptr< CompositeSeriesBasisInterface > _series_type
Stores a pointer to the functional series object.

◆ getGeneration()

const std::vector< Real > & FunctionSeries::getGeneration ( )

Returns a vector of the generation-evaluated functional series at the current location.

Definition at line 216 of file FunctionSeries.C.

217 {
218  return _series_type->getAllGeneration();
219 }
std::unique_ptr< CompositeSeriesBasisInterface > _series_type
Stores a pointer to the functional series object.

◆ getNumberOfTerms()

std::size_t FunctionSeries::getNumberOfTerms ( ) const

Returns the number of terms (coefficients) in the underlying function series.

Definition at line 199 of file FunctionSeries.C.

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

200 {
201  return _series_type->getNumberOfTerms();
202 }
std::unique_ptr< CompositeSeriesBasisInterface > _series_type
Stores a pointer to the functional series object.

◆ getOrders()

const std::vector< size_t > & FunctionSeries::getOrders ( ) const

Returns a vector of the functional orders in the underlying functional series.

Definition at line 205 of file FunctionSeries.C.

Referenced by FXIntegralBaseUserObject< ElementIntegralVariableUserObject >::FXIntegralBaseUserObject().

206 {
207  return _orders;
208 }
const std::vector< std::size_t > _orders
The vector holding the orders of each single series.

◆ getSize()

std::size_t MutableCoefficientsInterface::getSize ( ) const
inherited

Get the size, aka number of coefficients.

Definition at line 79 of file MutableCoefficientsInterface.C.

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

80 {
81  return _coefficients.size();
82 }
std::vector< Real > & _coefficients
The coefficient array.

◆ getStandardizedFunctionVolume()

Real FunctionSeries::getStandardizedFunctionVolume ( ) const

Returns the volume of evaluation in the functional series standardized space.

Definition at line 193 of file FunctionSeries.C.

194 {
195  return _series_type->getStandardizedFunctionVolume();
196 }
std::unique_ptr< CompositeSeriesBasisInterface > _series_type
Stores a pointer to the functional series object.

◆ importCoefficients()

void MutableCoefficientsInterface::importCoefficients ( const MutableCoefficientsInterface other)
inherited

Import the coefficients from another instance.

Definition at line 116 of file MutableCoefficientsInterface.C.

Referenced by MultiAppFXTransfer::execute().

117 {
118  if (!isCompatibleWith(other))
119  mooseError("Cannot import coefficients from incompatible MutableCoefficientsInterface");
120 
122 
124  _console << *this;
125 
127 }
virtual void coefficientsChanged()
Called when the coefficients have been changed.
const bool _print_coefficients
Boolean to flag if the coefficients should be printed when set.
bool isCompatibleWith(const MutableCoefficientsInterface &other) const
Checks to see if another instance is compatible.
std::vector< Real > & _coefficients
The coefficient array.
const ConsoleStream & _console
MooseObject instance of this to provide access to _console

◆ invalidateCache()

void MemoizedFunctionInterface::invalidateCache ( )
protectedinherited

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

Definition at line 82 of file MemoizedFunctionInterface.C.

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

83 {
84  _cache.clear();
85 }
std::unordered_map< hashing::HashValue, Real > _cache
Cached evaluations for each point.

◆ isCompatibleWith()

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

Checks to see if another instance is compatible.

Definition at line 85 of file MutableCoefficientsInterface.C.

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

86 {
87  // Check the coefficient sizes if requested
88  if ((_enforce_size && other._enforce_size) && getSize() != other.getSize())
89  return false;
90 
91  // Check the size of the characteristics array
92  if (_characteristics.size() != other._characteristics.size())
93  return false;
94 
95  // Check the values of the characteristics array
96  for (std::size_t i = 0; i < _characteristics.size(); ++i)
97  if (_characteristics[i] != other._characteristics[i])
98  return false;
99 
100  return true;
101 }
bool _enforce_size
Boolean that locks or allows resizing of the coefficient array.
std::vector< std::size_t > & _characteristics
An array of integer characteristics that can be used to check compatibility.
std::size_t getSize() const
Get the size, aka number of coefficients.

◆ isInPhysicalBounds()

bool FunctionSeries::isInPhysicalBounds ( const Point &  point) const

Returns true if the provided point is within the set physical boundaries.

Definition at line 238 of file FunctionSeries.C.

Referenced by evaluateValue().

239 {
240  return _series_type->isInPhysicalBounds(point);
241 }
std::unique_ptr< CompositeSeriesBasisInterface > _series_type
Stores a pointer to the functional series object.

◆ isSizeEnforced()

bool MutableCoefficientsInterface::isSizeEnforced ( ) const
inherited

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

Definition at line 104 of file MutableCoefficientsInterface.C.

105 {
106  return _enforce_size;
107 }
bool _enforce_size
Boolean that locks or allows resizing of the coefficient array.

◆ meshChanged()

void MemoizedFunctionInterface::meshChanged ( )
overridevirtualinherited

Definition at line 40 of file MemoizedFunctionInterface.C.

41 {
42  // The mesh has changed, which invalidates the cache
44 }
void invalidateCache()
Called by derived classes to invalidate the cache, perhaps due to a state change. ...

◆ operator[]()

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

Get the value of the coefficient at the corresponding index.

Definition at line 44 of file MutableCoefficientsInterface.C.

45 {
46  return _coefficients[index];
47 }
std::vector< Real > & _coefficients
The coefficient array.

◆ 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 130 of file MutableCoefficientsInterface.C.

Referenced by FunctionSeries().

131 {
132  if (size != _coefficients.size())
133  {
134  if (_enforce_size &&
135  (size > _coefficients.size() || (size < _coefficients.size() && !fill_out_to_size)))
136  mooseError("Cannot resize coefficient array with size enforcement enabled.");
137 
138  _coefficients.resize(size, fill);
139 
141  _console << *this;
142 
144  }
145 }
virtual void coefficientsChanged()
Called when the coefficients have been changed.
const bool _print_coefficients
Boolean to flag if the coefficients should be printed when set.
bool _enforce_size
Boolean that locks or allows resizing of the coefficient array.
std::vector< Real > & _coefficients
The coefficient array.
const ConsoleStream & _console
MooseObject instance of this to provide access to _console

◆ setCharacteristics()

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

Sets the characteristics array.

Definition at line 148 of file MutableCoefficientsInterface.C.

Referenced by FunctionSeries().

150 {
151  _characteristics = new_characteristics;
152 }
std::vector< std::size_t > & _characteristics
An array of integer characteristics that can be used to check compatibility.

◆ setCoefficients() [1/2]

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

Set the coefficients using a copy operation.

Definition at line 155 of file MutableCoefficientsInterface.C.

Referenced by MutableCoefficientsFunctionInterface::MutableCoefficientsFunctionInterface().

156 {
157  if (_enforce_size && new_coefficients.size() != _coefficients.size())
158  mooseError("Cannon assigned a coefficient array with differing size when size enforcement is "
159  "enabled.");
160 
161  _coefficients = new_coefficients;
162 
164  _console << *this;
165 
167 }
virtual void coefficientsChanged()
Called when the coefficients have been changed.
const bool _print_coefficients
Boolean to flag if the coefficients should be printed when set.
bool _enforce_size
Boolean that locks or allows resizing of the coefficient array.
std::vector< Real > & _coefficients
The coefficient array.
const ConsoleStream & _console
MooseObject instance of this to provide access to _console

◆ 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 170 of file MutableCoefficientsInterface.C.

171 {
172  if (_enforce_size && dropin_coefficients.size() != _coefficients.size())
173  mooseError("Cannon assigned a coefficient array with differing size when size enforcement is "
174  "enabled.");
175 
176  _coefficients = dropin_coefficients;
177 
179  _console << *this;
180 
182 }
virtual void coefficientsChanged()
Called when the coefficients have been changed.
const bool _print_coefficients
Boolean to flag if the coefficients should be printed when set.
bool _enforce_size
Boolean that locks or allows resizing of the coefficient array.
std::vector< Real > & _coefficients
The coefficient array.
const ConsoleStream & _console
MooseObject instance of this to provide access to _console

◆ setLocation()

void FunctionSeries::setLocation ( const Point &  point)

Set the current evaluation location.

Definition at line 244 of file FunctionSeries.C.

Referenced by evaluateValue().

245 {
246  _series_type->setLocation(point);
247 }
std::unique_ptr< CompositeSeriesBasisInterface > _series_type
Stores a pointer to the functional series object.

◆ useCache()

void MemoizedFunctionInterface::useCache ( bool  use)
inherited

Enable/disable the cache.

Definition at line 73 of file MemoizedFunctionInterface.C.

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

74 {
75  _enable_cache = use;
76 
77  if (!_enable_cache)
79 }
void invalidateCache()
Called by derived classes to invalidate the cache, perhaps due to a state change. ...
bool _enable_cache
Flag for whether to cache values.

◆ value()

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

Definition at line 47 of file MemoizedFunctionInterface.C.

48 {
49  if (_enable_cache)
50  {
51  // Start the cache over if we are at a new time step
52  if (_respect_time && time != _current_time)
53  {
54  _current_time = time;
56  }
57 
58  // Try to insert a new value into the cache
59  auto result = _cache.insert({hashing::hashCombine(time, point), 0.0});
60 
61  // Evaluate and apply if the insertion worked, i.e. the element didn't exist
62  if (result.second)
63  result.first->second = evaluateValue(time, point);
64 
65  // Return the cached value
66  return result.first->second;
67  }
68 
69  return evaluateValue(time, point);
70 }
void invalidateCache()
Called by derived classes to invalidate the cache, perhaps due to a state change. ...
bool _enable_cache
Flag for whether to cache values.
Real _current_time
Stores the time evaluation of the cache.
void hashCombine(HashValue &)
Final iteration of the variadic template with no additional arguments.
Definition: Hashing.h:27
bool _respect_time
Flag for whether changes in time invalidate the cache.
std::unordered_map< hashing::HashValue, Real > _cache
Cached evaluations for each point.
virtual Real evaluateValue(Real time, const Point &point)=0
Used in derived classes, equivalent to Function::value()

Friends And Related Function Documentation

◆ operator<<

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

Returns a tabularized text stream of the currently stored coefficients.

Definition at line 278 of file FunctionSeries.C.

279 {
280  stream << "\n\n"
281  << "FunctionSeries: " << me.name() << "\n"
282  << " Terms: " << me.getNumberOfTerms() << "\n";
283  me._series_type->formatCoefficients(stream, me._coefficients);
284  stream << "\n\n";
285 
286  return stream;
287 }
std::unique_ptr< CompositeSeriesBasisInterface > _series_type
Stores a pointer to the functional series object.
std::vector< Real > & _coefficients
The coefficient array.
std::size_t getNumberOfTerms() const
Returns the number of terms (coefficients) in the underlying function series.

Member Data Documentation

◆ _characteristics

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

◆ _coefficients

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

◆ _disc

const MooseEnum& FunctionSeries::_disc
protected

Stores the name of the single function series to use for a unit disc.

Definition at line 115 of file FunctionSeries.h.

Referenced by FunctionSeries().

◆ _enforce_size

bool MutableCoefficientsInterface::_enforce_size
protectedinherited

◆ _expansion_type

const MooseEnum& FunctionSeries::_expansion_type
protected

The normalization type for expansion.

Definition at line 117 of file FunctionSeries.h.

Referenced by FunctionSeries().

◆ _generation_type

const MooseEnum& FunctionSeries::_generation_type
protected

The normalization type for generation.

Definition at line 119 of file FunctionSeries.h.

Referenced by FunctionSeries().

◆ _orders

const std::vector<std::size_t> FunctionSeries::_orders
protected

The vector holding the orders of each single series.

Definition at line 93 of file FunctionSeries.h.

Referenced by FunctionSeries(), and getOrders().

◆ _physical_bounds

const std::vector<Real> FunctionSeries::_physical_bounds
protected

The physical bounds of the function series.

Definition at line 96 of file FunctionSeries.h.

Referenced by FunctionSeries().

◆ _print_coefficients

const bool MutableCoefficientsInterface::_print_coefficients
protectedinherited

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

Definition at line 120 of file MutableCoefficientsInterface.h.

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

◆ _series_type

std::unique_ptr<CompositeSeriesBasisInterface> FunctionSeries::_series_type
protected

Stores a pointer to the functional series object.

Definition at line 99 of file FunctionSeries.h.

Referenced by FunctionSeries(), getExpansion(), getGeneration(), getNumberOfTerms(), getStandardizedFunctionVolume(), isInPhysicalBounds(), operator<<(), and setLocation().

◆ _series_type_name

const MooseEnum& FunctionSeries::_series_type_name
protected

Stores the name of the current functional series type.

Definition at line 102 of file FunctionSeries.h.

Referenced by FunctionSeries().

◆ _x

const MooseEnum& FunctionSeries::_x
protected

Stores the name of the single function series to use in the x direction.

Definition at line 109 of file FunctionSeries.h.

Referenced by FunctionSeries().

◆ _y

const MooseEnum& FunctionSeries::_y
protected

Stores the name of the single function series to use in the y direction.

Definition at line 111 of file FunctionSeries.h.

Referenced by FunctionSeries().

◆ _z

const MooseEnum& FunctionSeries::_z
protected

Stores the name of the single function series to use in the z direction.

Definition at line 113 of file FunctionSeries.h.

Referenced by FunctionSeries().


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