Legendre Class Reference

This class provides the algorithms and properties of the Legendre polynomial series. More...

#include <Legendre.h>

Inheritance diagram for Legendre:

Public Member Functions
	Legendre ()
	Legendre (const std::vector< MooseEnum > &domain, const std::vector< std::size_t > &order, MooseEnum expansion_type, MooseEnum generation_type)
virtual Real	getStandardizedFunctionVolume () const override
	Returns the volume within the standardized function local_limits.
virtual bool	isInPhysicalBounds (const Point &point) const override
	Determines if the point provided is in within the physical bounds.
virtual std::size_t	calculatedNumberOfTermsBasedOnOrder (const std::vector< std::size_t > &order) const override
	Returns the number of terms in the single series given a value for the order.
virtual const std::vector< Real > &	getStandardizedFunctionLimits () const override
	Returns a vector of the lower and upper bounds of the standard functional space.
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.
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.
bool	isGeneration () const
	Returns true if the current evaluation is generation.
bool	isExpansion () const
	Returns true if the current evaluation is expansion.

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
void	evaluateOrthonormal ()
	Evaluates the orthonormal form of the basis functions.
void	evaluateStandard ()
	Evaluates the standard form of the basis functions.
void	evaluateSqrtMu ()
	Evaluates the 1/sqrt(mu) normalized form of the basis functions.
virtual void	checkPhysicalBounds (const std::vector< Real > &bounds) const override
	Checks the physical bounds according to the actual implementation.
virtual std::vector< Real >	getStandardizedLocation (const std::vector< Real > &location) const override
	Standardize the location according to the requirements of the underlying basis, which may actually convert the Cartesian coordinates into a more suitable system.
virtual void	evaluateGeneration () override
	Evaluate the generation form of the functional basis.
virtual void	evaluateExpansion () override
	Evaluate the expansion form of the functional basis.
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 provides the algorithms and properties of the Legendre polynomial series.

Definition at line 17 of file Legendre.h.

Constructor & Destructor Documentation

Legendre() [1/2]

Legendre::Legendre

(

)

Definition at line 19 of file Legendre.C.

: SingleSeriesBasisInterface() {}

Legendre() [2/2]

Legendre::Legendre	(	const std::vector< MooseEnum > &	domain,
		const std::vector< std::size_t > &	order,
		MooseEnum	expansion_type,
		MooseEnum	generation_type
	)

Definition at line 21 of file Legendre.C.

  : SingleSeriesBasisInterface(domain, order, calculatedNumberOfTermsBasedOnOrder(order))
{
  if (expansion_type == "orthonormal")
    _evaluateExpansionWrapper = [this]() { this->evaluateOrthonormal(); };
  else if (expansion_type == "sqrt_mu")
    _evaluateExpansionWrapper = [this]() { this->evaluateSqrtMu(); };
  else if (expansion_type == "standard")
    _evaluateExpansionWrapper = [this]() { this->evaluateStandard(); };
  else
    mooseError("The specified type of normalization for expansion does not exist");
 
  if (generation_type == "orthonormal")
    _evaluateGenerationWrapper = [this]() { this->evaluateOrthonormal(); };
  else if (generation_type == "sqrt_mu")
    _evaluateGenerationWrapper = [this]() { this->evaluateSqrtMu(); };
  else if (generation_type == "standard")
    _evaluateGenerationWrapper = [this]() { this->evaluateStandard(); };
  else
    mooseError("The specified type of normalization for generation does not exist");
}

Member Function Documentation

calculatedNumberOfTermsBasedOnOrder()

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

overridevirtual

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

Implements SingleSeriesBasisInterface.

Definition at line 47 of file Legendre.C.

{
  return order[0] + 1;
}

checkPhysicalBounds()

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

overrideprotectedvirtual

Checks the physical bounds according to the actual implementation.

Implements SingleSeriesBasisInterface.

Definition at line 53 of file Legendre.C.

{
  // Each Legendre series should have a min and max bound
  if (bounds.size() != 2)
    mooseError("Legend: Invalid number of bounds specified for single series!");
}

clearBasisEvaluation()

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

privatevirtualinherited

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 SingleSeriesBasisInterface::setOrder().

evaluateExpansion()

void SingleSeriesBasisInterface::evaluateExpansion ( )

overrideprotectedvirtualinherited

Evaluate the expansion form of the functional basis.

Implements FunctionalBasisInterface.

Definition at line 57 of file SingleSeriesBasisInterface.C.

{
  _evaluateExpansionWrapper();
}

evaluateGeneration()

void SingleSeriesBasisInterface::evaluateGeneration ( )

overrideprotectedvirtualinherited

Evaluate the generation form of the functional basis.

Implements FunctionalBasisInterface.

Definition at line 51 of file SingleSeriesBasisInterface.C.

{
  _evaluateGenerationWrapper();
}

evaluateOrthonormal()

void Legendre::evaluateOrthonormal ( )

protected

Evaluates the orthonormal form of the basis functions.

Definition at line 61 of file Legendre.C.

{
  std::size_t k;
  const Real & x = _standardized_location[0];
  const Real x2 = x * x;
 
  /*
   * Use direct formula to efficiently evaluate the polynomials for n <= 12
   *
   * The performance benefit diminishes for higher n. It is expected that the cost of the direct
   * calculation nears that of the recurrence relation in the neighborhood of n == 15, although this
   * theory is untested due to only implementing the direct calculations up to n == 12.
   *
   * If you want to calculate the higher-order Legendre Coefficients and code them in then be my
   * guest.
   */
  // clang-format off
  switch (_orders[0])
  {
    default:
    case MAX_DIRECT_CALCULATION_LEGENDRE:  /* 12 */
      save(12, ((((((676039 * x2 - 1939938) * x2 + 2078505) * x2 - 1021020) * x2 + 225225) * x2 - 18018) * x2 + 231) / 1024
               * 12.5);
      libmesh_fallthrough();
 
    case 11:
      save(11, (((((88179 * x2 - 230945) * x2 + 218790) * x2 - 90090) * x2 + 15015) * x2 - 693) * x / 256
               * 11.5);
      libmesh_fallthrough();
 
    case 10:
      save(10, (((((46189 * x2 - 109395) * x2 + 90090) * x2 - 30030) * x2 + 3465) * x2 - 63) / 256
               * 10.5);
      libmesh_fallthrough();
 
    case 9:
      save(9, ((((12155 * x2 - 25740) * x2 + 18018) * x2 - 4620) * x2 + 315) * x / 128
              * 9.5);
      libmesh_fallthrough();
 
    case 8:
      save(8, ((((6435 * x2 - 12012) * x2 + 6930) * x2 - 1260) * x2 + 35) / 128
              * 8.5);
      libmesh_fallthrough();
 
    case 7:
      save(7, (((429 * x2 - 693) * x2 + 315) * x2 - 35) * x / 16
              * 7.5);
      libmesh_fallthrough();
 
    case 6:
      save(6, (((231 * x2 - 315) * x2 + 105) * x2 - 5) / 16
              * 6.5);
      libmesh_fallthrough();
 
    case 5:
      save(5, ((63 * x2 - 70) * x2 + 15) * x / 8
              * 5.5);
      libmesh_fallthrough();
 
    case 4:
      save(4, ((35 * x2 - 30) * x2 + 3) / 8
              * 4.5);
      libmesh_fallthrough();
 
    case 3:
      save(3, (5 * x2 - 3) * x / 2
              * 3.5);
      libmesh_fallthrough();
 
    case 2:
      save(2, (3 * x2 - 1) / 2
              * 2.5);
      libmesh_fallthrough();
 
    case 1:
      save(1, x
              * 1.5);
      libmesh_fallthrough();
 
    case 0:
      save(0, 1
              * 0.5);
  }
  // clang-format on
 
  /*
   * Evaluate any remaining polynomials.
   *
   * The original recurrence relation is:
   *       (2 * k - 1) * x * L_(k-1) - (k - 1) * L_(k-2)
   * L_k = ---------------------------------------------
   *                        k
   *
   * However, for FXs we are using a the orthonormalized version of the polynomials, so each
   * polynomial L_k is multiplied by:
   *    (2 * k + 1)
   *    -----------      essentially:    k + 0.5
   *         2
   * Reversing this in the previous polynomials and implementing for the current polynomial results
   * in the orthonormalized recurrence:
   *       (2 * k + 1)   /                 (k - 1)             \
   * L_k = ----------- * | x * L_(k-1) - ----------- * L_(k-2) |
   *            k        \               (2 * k - 3)           /
   *
   * The options are 1) to use this form, or 2) to not apply the orthonormalization at first, and
   * then loop through all the values in a second loop and then apply the orthonormalization.
   */
  for (k = MAX_DIRECT_CALCULATION_LEGENDRE + 1; k <= _orders[0]; ++k)
    save(k, ((k + k + 1) / Real(k)) * (x * load(k - 1) - ((k - 1) / (k + k - 3.0)) * load(k - 2)));
}

Referenced by Legendre().

evaluateSqrtMu()

void Legendre::evaluateSqrtMu ( )

protected

Evaluates the 1/sqrt(mu) normalized form of the basis functions.

Definition at line 259 of file Legendre.C.

{
  evaluateStandard();
  for (size_t i = 0; i < getNumberOfTerms(); ++i)
    save(i, load(i) * std::sqrt(i + 0.5));
}

Referenced by Legendre().

evaluateStandard()

void Legendre::evaluateStandard ( )

protected

Evaluates the standard form of the basis functions.

Definition at line 174 of file Legendre.C.

{
  std::size_t k;
  const Real x = _standardized_location[0];
  const Real x2 = x * x;
 
  /*
   * Use direct formula to efficiently evaluate the polynomials for n <= 12
   *
   * The performance benefit diminishes for higher n. It is expected that the cost of the direct
   * calculation nears that of the recurrence relation in the neighborhood of n == 15, although this
   * theory is untested due to only implementing the direct calculations up to n == 12.
   *
   * If you want to calculate the higher-order Legendre Coefficients and
   * code them in then be my guest.
   */
  // clang-format off
  switch (_orders[0])
  {
    default:
    case MAX_DIRECT_CALCULATION_LEGENDRE:  /* 12 */
      save(12, ((((((676039 * x2 - 1939938) * x2 + 2078505) * x2 - 1021020) * x2 + 225225) * x2 - 18018) * x2 + 231) / 1024);
      libmesh_fallthrough();
 
    case 11:
      save(11, (((((88179 * x2 - 230945) * x2 + 218790) * x2 - 90090) * x2 + 15015) * x2 - 693) * x / 256);
      libmesh_fallthrough();
 
    case 10:
      save(10, (((((46189 * x2 - 109395) * x2 + 90090) * x2 - 30030) * x2 + 3465) * x2 - 63) / 256);
      libmesh_fallthrough();
 
    case 9:
      save(9, ((((12155 * x2 - 25740) * x2 + 18018) * x2 - 4620) * x2 + 315) * x / 128);
      libmesh_fallthrough();
 
    case 8:
      save(8, ((((6435 * x2 - 12012) * x2 + 6930) * x2 - 1260) * x2 + 35) / 128);
      libmesh_fallthrough();
 
    case 7:
      save(7, (((429 * x2 - 693) * x2 + 315) * x2 - 35) * x / 16);
      libmesh_fallthrough();
 
    case 6:
      save(6, (((231 * x2 - 315) * x2 + 105) * x2 - 5) / 16);
      libmesh_fallthrough();
 
    case 5:
      save(5, ((63 * x2 - 70) * x2 + 15) * x / 8);
      libmesh_fallthrough();
 
    case 4:
      save(4, ((35 * x2 - 30) * x2 + 3) / 8);
      libmesh_fallthrough();
 
    case 3:
      save(3, (5 * x2 - 3) * x / 2);
      libmesh_fallthrough();
 
    case 2:
      save(2, (3 * x2 - 1) / 2);
      libmesh_fallthrough();
 
    case 1:
      save(1, x);
      libmesh_fallthrough();
 
    case 0:
      save(0, 1);
  }
  // clang-format on
 
  /*
   * Evaluate any remaining polynomials.
   * The recurrence relation is:
   *       (2 * k - 1) * x * L_(k-1) - (k - 1) * L_(k-2)
   * L_k = ---------------------------------------------
   *                        k
   */
  for (k = MAX_DIRECT_CALCULATION_LEGENDRE + 1; k <= _orders[0]; ++k)
    save(k, (((2 * k - 1) * x * load(k - 1)) - ((k - 1) * load(k - 2))) / Real(k));
}

Referenced by evaluateSqrtMu(), and Legendre().

extractLocationFromPoint()

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

protectedinherited

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 isInPhysicalBounds(), Zernike::isInPhysicalBounds(), and SingleSeriesBasisInterface::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 evaluateSqrtMu(), TEST(), TEST(), TEST(), and TEST().

getOrder()

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

inherited

Returns the order of the particular domain index.

Definition at line 133 of file SingleSeriesBasisInterface.C.

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

getStandardizedFunctionLimits()

const std::vector< Real > & Legendre::getStandardizedFunctionLimits ( ) const

overridevirtual

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

Implements FunctionalBasisInterface.

Definition at line 267 of file Legendre.C.

{
  // Lazily instantiate the function limits array
  static const std::vector<Real> standardizedFunctionLimits = {-1, 1};
 
  return standardizedFunctionLimits;
}

getStandardizedFunctionVolume()

Real Legendre::getStandardizedFunctionVolume ( ) const

overridevirtual

Returns the volume within the standardized function local_limits.

Implements FunctionalBasisInterface.

Definition at line 276 of file Legendre.C.

{
  return 2.0; // Span of [-1, 1]
}

getStandardizedLocation()

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

overrideprotectedvirtual

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.

Implements SingleSeriesBasisInterface.

Definition at line 282 of file Legendre.C.

{
  const Real difference = location[0] - _physical_bounds[0];
  const Real span = _physical_bounds[1] - _physical_bounds[0];
 
  // Convert to [0, 1] (assuming that location[0] is within _physical_bounds)
  const Real ratio = difference / span;
 
  // Legendre space is [-1, 1]
  return {ratio * 2 - 1};
}

isCacheInvalid()

bool SingleSeriesBasisInterface::isCacheInvalid ( ) const

finalvirtualinherited

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

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

overridevirtual

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

Implements FunctionalBasisInterface.

Definition at line 295 of file Legendre.C.

{
  std::vector<Real> location = extractLocationFromPoint(point);
 
  if (location[0] < _physical_bounds[0] || _physical_bounds[1] < location[0])
    return false;
  else
    return true;
}

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 evaluateOrthonormal(), Zernike::evaluateOrthonormal(), evaluateSqrtMu(), Zernike::evaluateSqrtMu(), evaluateStandard(), Zernike::evaluateStandard(), and Zernike::fillOutNegativeRankAndApplyAzimuthalComponent().

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 evaluateOrthonormal(), Zernike::evaluateOrthonormal(), CompositeSeriesBasisInterface::evaluateSeries(), evaluateSqrtMu(), Zernike::evaluateSqrtMu(), evaluateStandard(), Zernike::evaluateStandard(), and Zernike::fillOutNegativeRankAndApplyAzimuthalComponent().

setLocation()

void SingleSeriesBasisInterface::setLocation ( const Point &  point )

finalvirtualinherited

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 )

finalvirtualinherited

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 )

finalvirtualinherited

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

Member Data Documentation

_are_physical_bounds_specified

bool SingleSeriesBasisInterface::_are_physical_bounds_specified

privateinherited

Flag for if the physical bounds are specified for this series.

Definition at line 95 of file SingleSeriesBasisInterface.h.

Referenced by SingleSeriesBasisInterface::setLocation(), and SingleSeriesBasisInterface::setPhysicalBounds().

_basis_evaluation

std::vector<Real> FunctionalBasisInterface::_basis_evaluation

privateinherited

Stores the values of the basis evaluation.

Definition at line 150 of file FunctionalBasisInterface.h.

Referenced by FunctionalBasisInterface::clearBasisEvaluation(), FunctionalBasisInterface::FunctionalBasisInterface(), FunctionalBasisInterface::getAllExpansion(), FunctionalBasisInterface::getAllGeneration(), FunctionalBasisInterface::load(), FunctionalBasisInterface::operator[](), and FunctionalBasisInterface::save().

_domain_options

MooseEnum FunctionalBasisInterface::_domain_options

staticinherited

An enumeration of the domains available to each functional series.

Definition at line 114 of file FunctionalBasisInterface.h.

Referenced by FunctionSeries::FunctionSeries(), SingleSeriesBasisInterface::SingleSeriesBasisInterface(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

_domains

const std::vector<MooseEnum> SingleSeriesBasisInterface::_domains

inherited

An ordered list of the x, y, and/or z domains needed by the functional basis to convert a point to a standardized location.

Definition at line 60 of file SingleSeriesBasisInterface.h.

Referenced by SingleSeriesBasisInterface::extractLocationFromPoint().

_evaluateExpansionWrapper

std::function<void()> SingleSeriesBasisInterface::_evaluateExpansionWrapper

protectedinherited

The expansion evaluation wrapper.

Definition at line 88 of file SingleSeriesBasisInterface.h.

Referenced by SingleSeriesBasisInterface::evaluateExpansion(), Legendre(), and Zernike::Zernike().

_evaluateGenerationWrapper

std::function<void()> SingleSeriesBasisInterface::_evaluateGenerationWrapper

protectedinherited

The generation evaluation wrapper.

Definition at line 91 of file SingleSeriesBasisInterface.h.

Referenced by SingleSeriesBasisInterface::evaluateGeneration(), Legendre(), and Zernike::Zernike().

_is_cache_invalid

bool FunctionalBasisInterface::_is_cache_invalid

privateinherited

indicates if the evaluated values correspond to the current location

Definition at line 146 of file FunctionalBasisInterface.h.

Referenced by SingleSeriesBasisInterface::isCacheInvalid(), SingleSeriesBasisInterface::setLocation(), SingleSeriesBasisInterface::setOrder(), and SingleSeriesBasisInterface::setPhysicalBounds().

_is_generation

bool FunctionalBasisInterface::_is_generation

privateinherited

Indicates whether the current evaluation is expansion or generation.

Definition at line 153 of file FunctionalBasisInterface.h.

Referenced by FunctionalBasisInterface::getAllExpansion(), FunctionalBasisInterface::getAllGeneration(), FunctionalBasisInterface::isExpansion(), and FunctionalBasisInterface::isGeneration().

_location

std::vector<Real> SingleSeriesBasisInterface::_location

privateinherited

The domain locations of the current evaluation.

This is private so that derived classes will be required to use _standardized_location, essentially forcing location-awareness compliance

Definition at line 99 of file SingleSeriesBasisInterface.h.

Referenced by SingleSeriesBasisInterface::setLocation().

_number_of_terms

unsigned int FunctionalBasisInterface::_number_of_terms

protectedinherited

The number of terms in the series.

Definition at line 143 of file FunctionalBasisInterface.h.

Referenced by FunctionalBasisInterface::getAllExpansion(), FunctionalBasisInterface::getAllGeneration(), FunctionalBasisInterface::getNumberOfTerms(), CompositeSeriesBasisInterface::setNumberOfTerms(), and SingleSeriesBasisInterface::setOrder().

_orders

std::vector<std::size_t> SingleSeriesBasisInterface::_orders

protectedinherited

The order of the series.

Definition at line 79 of file SingleSeriesBasisInterface.h.

Referenced by evaluateOrthonormal(), Zernike::evaluateOrthonormal(), Zernike::evaluateSqrtMu(), evaluateStandard(), Zernike::evaluateStandard(), Zernike::fillOutNegativeRankAndApplyAzimuthalComponent(), SingleSeriesBasisInterface::getOrder(), and SingleSeriesBasisInterface::setOrder().

_physical_bounds

std::vector<Real> SingleSeriesBasisInterface::_physical_bounds

protectedinherited

The physical bounds of the series.

Definition at line 82 of file SingleSeriesBasisInterface.h.

Referenced by getStandardizedLocation(), Zernike::getStandardizedLocation(), isInPhysicalBounds(), and SingleSeriesBasisInterface::setPhysicalBounds().

_standardized_location

std::vector<Real> SingleSeriesBasisInterface::_standardized_location

protectedinherited

The standardized location of evaluation.

Definition at line 85 of file SingleSeriesBasisInterface.h.

Referenced by evaluateOrthonormal(), Zernike::evaluateOrthonormal(), evaluateStandard(), Zernike::evaluateStandard(), Zernike::fillOutNegativeRankAndApplyAzimuthalComponent(), and SingleSeriesBasisInterface::setLocation().

---

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

• functional_expansion_tools/include/series/Legendre.h
• functional_expansion_tools/src/series/Legendre.C