This class is a simple wrapper around FunctionalBasisInterface, and intended for use by any single functional series like Legendre, Zernike, etc... More...

#include <SingleSeriesBasisInterface.h>

Inheritance diagram for SingleSeriesBasisInterface:

[legend]

Public Member Functions
	SingleSeriesBasisInterface ()

	SingleSeriesBasisInterface (const std::vector< MooseEnum > &domains, const std::vector< std::size_t > &orders, const unsigned int number_of_terms)

virtual	~SingleSeriesBasisInterface ()

	SingleSeriesBasisInterface (const SingleSeriesBasisInterface &)=delete

	SingleSeriesBasisInterface (SingleSeriesBasisInterface &&)=delete

void	operator= (const SingleSeriesBasisInterface &)=delete

SingleSeriesBasisInterface &	operator= (SingleSeriesBasisInterface &&)=delete

virtual bool	isCacheInvalid () const final
	Whether the cached values correspond to the current point.

virtual void	setLocation (const Point &point) final
	Set the location that will be used by the series to compute values.

virtual void	setOrder (const std::vector< std::size_t > &orders) final
	Set the order of the series.

virtual void	setPhysicalBounds (const std::vector< Real > &bounds) final
	Sets the bounds of the series.

virtual std::size_t	calculatedNumberOfTermsBasedOnOrder (const std::vector< std::size_t > &order) const =0
	Returns the number of terms in the single series given a value for the order.

virtual std::vector< Real >	getStandardizedLocation (const std::vector< Real > &location) const =0
	Standardize the location according to the requirements of the underlying basis, which may actually convert the Cartesian coordinates into a more suitable system.

std::size_t	getOrder (std::size_t domain) const
	Returns the order of the particular domain index.

Real	operator[] (std::size_t index) const
	Returns the current evaluation at the given index.

const std::vector< Real > &	getAllGeneration ()
	Returns an array reference containing the value of each generation term.

const std::vector< Real > &	getAllExpansion ()
	Returns an array reference containing the value of each expansion term.

std::size_t	getNumberOfTerms () const
	Returns the number of terms in the series.

Real	getGeneration ()
	Gets the last term of the generation functional basis.

Real	getGenerationSeriesSum ()
	Gets the sum of all terms in the generation functional basis.

Real	getExpansion ()
	Gets the #_order-th term of the expansion functional basis.

Real	getExpansionSeriesSum ()
	Evaluates the sum of all terms in the expansion functional basis up to #_order.

virtual const std::vector< Real > &	getStandardizedFunctionLimits () const =0
	Returns a vector of the lower and upper bounds of the standard functional space.

virtual Real	getStandardizedFunctionVolume () const =0
	Returns the volume within the standardized function local_limits.

bool	isGeneration () const
	Returns true if the current evaluation is generation.

bool	isExpansion () const
	Returns true if the current evaluation is expansion.

virtual bool	isInPhysicalBounds (const Point &point) const =0
	Determines if the point provided is in within the physical bounds.

Public Attributes
const std::vector< MooseEnum >	_domains
	An ordered list of the x, y, and/or z domains needed by the functional basis to convert a point to a standardized location.

Static Public Attributes
static MooseEnum	_domain_options
	An enumeration of the domains available to each functional series.

Protected Member Functions
virtual void	evaluateGeneration () override
	Evaluate the generation form of the functional basis.

virtual void	evaluateExpansion () override
	Evaluate the expansion form of the functional basis.

virtual void	checkPhysicalBounds (const std::vector< Real > &bounds) const =0
	Checks the physical bounds according to the actual implementation.

std::vector< Real >	extractLocationFromPoint (const Point &point) const
	Convert a spatial point to a location that the series will use to determine the value at which to evaluate the series.

Real	load (std::size_t index) const
	Helper function to load a value from #_series.

void	save (std::size_t index, Real value)
	Helper function to store a value in #_series.

Protected Attributes
std::vector< std::size_t >	_orders
	The order of the series.

std::vector< Real >	_physical_bounds
	The physical bounds of the series.

std::vector< Real >	_standardized_location
	The standardized location of evaluation.

std::function< void()>	_evaluateExpansionWrapper
	The expansion evaluation wrapper.

std::function< void()>	_evaluateGenerationWrapper
	The generation evaluation wrapper.

unsigned int	_number_of_terms
	The number of terms in the series.

Private Member Functions
virtual void	clearBasisEvaluation (const unsigned int &number_of_terms)
	Set all entries of the basis evaluation to zero.

Private Attributes
bool	_are_physical_bounds_specified
	Flag for if the physical bounds are specified for this series.

std::vector< Real >	_location
	The domain locations of the current evaluation.

bool	_is_cache_invalid
	indicates if the evaluated values correspond to the current location

std::vector< Real >	_basis_evaluation
	Stores the values of the basis evaluation.

bool	_is_generation
	Indicates whether the current evaluation is expansion or generation.

Detailed Description

This class is a simple wrapper around FunctionalBasisInterface, and intended for use by any single functional series like Legendre, Zernike, etc...

Definition at line 19 of file SingleSeriesBasisInterface.h.

Constructor & Destructor Documentation

◆ SingleSeriesBasisInterface() [1/4]

SingleSeriesBasisInterface::SingleSeriesBasisInterface ( )

Definition at line 20 of file SingleSeriesBasisInterface.C.

  : FunctionalBasisInterface(1),
    _domains({_domain_options = "x"}),
    _orders({0}),
    _physical_bounds(2, 0.0),
    _standardized_location({0.0}),
    _are_physical_bounds_specified(false),
    _location(_domains.size(), 0.0)
{
}

◆ SingleSeriesBasisInterface() [2/4]

SingleSeriesBasisInterface::SingleSeriesBasisInterface	(	const std::vector< MooseEnum > &	domains,
		const std::vector< std::size_t > &	orders,
		const unsigned int	number_of_terms
	)

Definition at line 31 of file SingleSeriesBasisInterface.C.

  : FunctionalBasisInterface(number_of_terms),
    _domains(domains),
    _orders(orders),
    _physical_bounds(2, 0.0),
    _standardized_location(1, 0.0),
    _are_physical_bounds_specified(false),
    _location(_domains.size(), 0.0)
{
}

◆ ~SingleSeriesBasisInterface()

SingleSeriesBasisInterface::~SingleSeriesBasisInterface ( )

virtual

Definition at line 138 of file SingleSeriesBasisInterface.C.

138{}

◆ SingleSeriesBasisInterface() [3/4]

SingleSeriesBasisInterface::SingleSeriesBasisInterface ( const SingleSeriesBasisInterface & )

delete

◆ SingleSeriesBasisInterface() [4/4]

SingleSeriesBasisInterface::SingleSeriesBasisInterface ( SingleSeriesBasisInterface && )

delete

Member Function Documentation

◆ calculatedNumberOfTermsBasedOnOrder()

virtual std::size_t SingleSeriesBasisInterface::calculatedNumberOfTermsBasedOnOrder ( const std::vector< std::size_t > & order ) const

pure virtual

Returns the number of terms in the single series given a value for the order.

Implemented in Legendre, and Zernike.

Referenced by setOrder().

◆ checkPhysicalBounds()

virtual void SingleSeriesBasisInterface::checkPhysicalBounds ( const std::vector< Real > & bounds ) const

protectedpure virtual

Checks the physical bounds according to the actual implementation.

Implemented in Legendre, and Zernike.

Referenced by setPhysicalBounds().

◆ clearBasisEvaluation()

void FunctionalBasisInterface::clearBasisEvaluation ( const unsigned int & number_of_terms )

privatevirtual

Set all entries of the basis evaluation to zero.

Reimplemented from FunctionalBasisInterface.

Definition at line 120 of file FunctionalBasisInterface.C.

{
  _basis_evaluation.assign(number_of_terms, 0.0);
  _basis_evaluation.shrink_to_fit();
}

Referenced by setOrder().

◆ evaluateExpansion()

void SingleSeriesBasisInterface::evaluateExpansion ( )

overrideprotectedvirtual

Evaluate the expansion form of the functional basis.

Implements FunctionalBasisInterface.

Definition at line 57 of file SingleSeriesBasisInterface.C.

{
  _evaluateExpansionWrapper();
}

◆ evaluateGeneration()

void SingleSeriesBasisInterface::evaluateGeneration ( )

overrideprotectedvirtual

Evaluate the generation form of the functional basis.

Implements FunctionalBasisInterface.

Definition at line 51 of file SingleSeriesBasisInterface.C.

{
  _evaluateGenerationWrapper();
}

◆ extractLocationFromPoint()

std::vector< Real > SingleSeriesBasisInterface::extractLocationFromPoint ( const Point & point ) const

protected

Convert a spatial point to a location that the series will use to determine the value at which to evaluate the series.

Definition at line 122 of file SingleSeriesBasisInterface.C.

{
  std::vector<Real> location(_domains.size());
 
  // Update the locations as specified by _domain
  for (std::size_t index = 0; index < _domains.size(); ++index)
    location[index] = point(_domains[index]);
  return location;
}

Referenced by Legendre::isInPhysicalBounds(), Zernike::isInPhysicalBounds(), and setLocation().

◆ getAllExpansion()

const std::vector< Real > & FunctionalBasisInterface::getAllExpansion ( )

inherited

Returns an array reference containing the value of each expansion term.

Definition at line 73 of file FunctionalBasisInterface.C.

{
  if (isGeneration() || isCacheInvalid())
  {
    clearBasisEvaluation(_number_of_terms);
 
    evaluateExpansion();
 
    _is_generation = false;
    _is_cache_invalid = false;
  }
 
  return _basis_evaluation;
}

Referenced by FunctionalBasisInterface::getExpansion(), and FunctionalBasisInterface::getExpansionSeriesSum().

◆ getAllGeneration()

const std::vector< Real > & FunctionalBasisInterface::getAllGeneration ( )

inherited

Returns an array reference containing the value of each generation term.

Definition at line 57 of file FunctionalBasisInterface.C.

{
  if (isExpansion() || isCacheInvalid())
  {
    clearBasisEvaluation(_number_of_terms);
 
    evaluateGeneration();
 
    _is_generation = true;
    _is_cache_invalid = false;
  }
 
  return _basis_evaluation;
}

Referenced by FunctionalBasisInterface::getGeneration(), and FunctionalBasisInterface::getGenerationSeriesSum().

◆ getExpansion()

Real FunctionalBasisInterface::getExpansion ( )

inherited

Gets the #_order-th term of the expansion functional basis.

Definition at line 114 of file FunctionalBasisInterface.C.

{
  // Use getAllExpansion() which will lazily evaluate the series as needed
  return getAllExpansion().back();
}

◆ getExpansionSeriesSum()

Real FunctionalBasisInterface::getExpansionSeriesSum ( )

inherited

Evaluates the sum of all terms in the expansion functional basis up to #_order.

Definition at line 121 of file FunctionalBasisInterface.C.

{
  Real sum = 0.0;
 
  // Use getAllExpansion() which will lazily evaluate the series as needed
  for (auto term : getAllExpansion())
    sum += term;
 
  return sum;
}

Referenced by TEST(), and TEST().

◆ getGeneration()

Real FunctionalBasisInterface::getGeneration ( )

inherited

Gets the last term of the generation functional basis.

Definition at line 95 of file FunctionalBasisInterface.C.

{
  // Use getAllGeneration() which will lazily evaluate the series as needed
  return getAllGeneration().back();
}

◆ getGenerationSeriesSum()

Real FunctionalBasisInterface::getGenerationSeriesSum ( )

inherited

Gets the sum of all terms in the generation functional basis.

Definition at line 102 of file FunctionalBasisInterface.C.

{
  Real sum = 0.0;
 
  // Use getAllGeneration() which will lazily evaluate the series as needed
  for (auto term : getAllGeneration())
    sum += term;
 
  return sum;
}

Referenced by TEST(), and TEST().

◆ getNumberOfTerms()

std::size_t FunctionalBasisInterface::getNumberOfTerms ( ) const

inherited

Returns the number of terms in the series.

Definition at line 89 of file FunctionalBasisInterface.C.

{
  return _number_of_terms;
}

Referenced by Legendre::evaluateSqrtMu(), TEST(), TEST(), TEST(), and TEST().

◆ getOrder()

std::size_t SingleSeriesBasisInterface::getOrder ( std::size_t domain ) const

Returns the order of the particular domain index.

Definition at line 133 of file SingleSeriesBasisInterface.C.

{
  return domain < _orders.size() ? _orders[domain] : -1;
}

◆ getStandardizedFunctionLimits()

virtual const std::vector< Real > & FunctionalBasisInterface::getStandardizedFunctionLimits ( ) const

pure virtualinherited

Returns a vector of the lower and upper bounds of the standard functional space.

Implemented in CompositeSeriesBasisInterface, Legendre, and Zernike.

◆ getStandardizedFunctionVolume()

virtual Real FunctionalBasisInterface::getStandardizedFunctionVolume ( ) const

pure virtualinherited

Returns the volume within the standardized function local_limits.

Implemented in CompositeSeriesBasisInterface, Legendre, and Zernike.

◆ getStandardizedLocation()

virtual std::vector< Real > SingleSeriesBasisInterface::getStandardizedLocation ( const std::vector< Real > & location ) const

pure virtual

Standardize the location according to the requirements of the underlying basis, which may actually convert the Cartesian coordinates into a more suitable system.

The second version exists simply to return the value.

Implemented in Legendre, and Zernike.

Referenced by setLocation().

◆ isCacheInvalid()

bool SingleSeriesBasisInterface::isCacheInvalid ( ) const

finalvirtual

Whether the cached values correspond to the current point.

Implements FunctionalBasisInterface.

Definition at line 45 of file SingleSeriesBasisInterface.C.

{
  return _is_cache_invalid;
}

◆ isExpansion()

bool FunctionalBasisInterface::isExpansion ( ) const

inherited

Returns true if the current evaluation is expansion.

Definition at line 51 of file FunctionalBasisInterface.C.

{
  return !_is_generation;
}

Referenced by FunctionalBasisInterface::getAllGeneration().

◆ isGeneration()

bool FunctionalBasisInterface::isGeneration ( ) const

inherited

Returns true if the current evaluation is generation.

Definition at line 45 of file FunctionalBasisInterface.C.

{
  return _is_generation;
}

Referenced by FunctionalBasisInterface::getAllExpansion().

◆ isInPhysicalBounds()

virtual bool FunctionalBasisInterface::isInPhysicalBounds ( const Point & point ) const

pure virtualinherited

Determines if the point provided is in within the physical bounds.

Implemented in CompositeSeriesBasisInterface, Legendre, and Zernike.

◆ load()

Real FunctionalBasisInterface::load ( std::size_t index ) const

protectedinherited

Helper function to load a value from #_series.

Definition at line 133 of file FunctionalBasisInterface.C.

{
  return _basis_evaluation[index];
}

Referenced by Legendre::evaluateOrthonormal(), Zernike::evaluateOrthonormal(), Legendre::evaluateSqrtMu(), Zernike::evaluateSqrtMu(), Legendre::evaluateStandard(), Zernike::evaluateStandard(), and Zernike::fillOutNegativeRankAndApplyAzimuthalComponent().

◆ operator=() [1/2]

void SingleSeriesBasisInterface::operator= ( const SingleSeriesBasisInterface & )

delete

◆ operator=() [2/2]

SingleSeriesBasisInterface & SingleSeriesBasisInterface::operator= ( SingleSeriesBasisInterface && )

delete

◆ operator[]()

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

inherited

Returns the current evaluation at the given index.

Definition at line 39 of file FunctionalBasisInterface.C.

{
  return (index > _basis_evaluation.size() ? 0.0 : _basis_evaluation[index]);
}

◆ save()

void FunctionalBasisInterface::save	(	std::size_t	index,
		Real	value
	)

protectedinherited

Helper function to store a value in #_series.

Definition at line 139 of file FunctionalBasisInterface.C.

{
  _basis_evaluation[index] = value;
}

Referenced by Legendre::evaluateOrthonormal(), Zernike::evaluateOrthonormal(), CompositeSeriesBasisInterface::evaluateSeries(), Legendre::evaluateSqrtMu(), Zernike::evaluateSqrtMu(), Legendre::evaluateStandard(), Zernike::evaluateStandard(), and Zernike::fillOutNegativeRankAndApplyAzimuthalComponent().

◆ setLocation()

void SingleSeriesBasisInterface::setLocation ( const Point & point )

finalvirtual

Set the location that will be used by the series to compute values.

Implements FunctionalBasisInterface.

Definition at line 102 of file SingleSeriesBasisInterface.C.

{
  std::vector<Real> oldLocation(_location);
 
  // Update the physical-space location
  _location = extractLocationFromPoint(point);
 
  // Standardize the location if standardized bounds exist
  if (_are_physical_bounds_specified)
    _standardized_location = getStandardizedLocation(_location);
  else
    _standardized_location = _location;
 
  // Once the location is changed, the cached values correspond to an old location
  for (std::size_t i = 0; !_is_cache_invalid && (i < _location.size()); ++i)
    if (oldLocation[i] != _location[i])
      _is_cache_invalid = true;
}

Referenced by TEST(), TEST(), TEST(), TEST(), and TEST().

◆ setOrder()

void SingleSeriesBasisInterface::setOrder ( const std::vector< std::size_t > & orders )

finalvirtual

Set the order of the series.

Implements FunctionalBasisInterface.

Definition at line 63 of file SingleSeriesBasisInterface.C.

{
  if (orders.size() != _orders.size())
    mooseError("SSBI: Invalid 'orders' use in setOrder()!");
 
  /*
   * Do nothing if the order isn't changed. Note that this only compares the first value - it is
   * assumed that a single series only needs to be described using a single order.
   */
  if (orders[0] == _orders[0])
    return;
 
  _orders = orders;
 
  // Set the new number of terms in the single series
  _number_of_terms = calculatedNumberOfTermsBasedOnOrder(_orders);
 
  // Zero the basis evaluation
  clearBasisEvaluation(_number_of_terms);
  _is_cache_invalid = true;
}

◆ setPhysicalBounds()

void SingleSeriesBasisInterface::setPhysicalBounds ( const std::vector< Real > & bounds )

finalvirtual

Sets the bounds of the series.

Implements FunctionalBasisInterface.

Definition at line 86 of file SingleSeriesBasisInterface.C.

{
  // Use the concrete implementation to check the validity of the bounds
  checkPhysicalBounds(bounds);
 
  _physical_bounds = bounds;
  _are_physical_bounds_specified = true;
 
  /*
   * Once the physical bounds have been changed, the normalization of a point will change, so the
   * cached values will also be incorrect
   */
  _is_cache_invalid = true;
}