Zernike Class Reference

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

#include <Zernike.h>

Inheritance diagram for Zernike:

Public Member Functions
	Zernike ()
	Zernike (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
virtual void	evaluateOrthonormal ()
	Evaluates the orthonormal form of the basis functions.
virtual void	evaluateStandard ()
	Evaluates the standard form of the basis functions.
virtual 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.
void	fillOutNegativeRankAndApplyAzimuthalComponent ()
	Helper function used by evaluateGeneration() and evaluateExpansion().
std::size_t	simpleDoubleToSingle (std::size_t n, long m) const
	Maps the double order/rank idices to a single linear index.
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< Real >	_negative_azimuthal_components
	Stores the recurrence evaluations for the negative rank azimuthal terms.
std::vector< Real >	_positive_azimuthal_components
	Stores the recurrence evaluations for the positive rank azimuthal terms.
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 Zernike polynomial series.

Definition at line 17 of file Zernike.h.

Constructor & Destructor Documentation

Zernike() [1/2]

Zernike::Zernike

(

)

Definition at line 20 of file Zernike.C.

: SingleSeriesBasisInterface() {}

Zernike() [2/2]

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

Definition at line 22 of file Zernike.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 Zernike::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 48 of file Zernike.C.

{
  return ((order[0] + 1) * (order[0] + 2)) / 2;
}

checkPhysicalBounds()

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

overrideprotectedvirtual

Checks the physical bounds according to the actual implementation.

Implements SingleSeriesBasisInterface.

Definition at line 54 of file Zernike.C.

{
  /*
   * Each single series is assumed to be a function of a single coordinate, which should only have
   * two bounds.
   */
  if (bounds.size() != 3)
    mooseError("Zernike: 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 Zernike::evaluateOrthonormal ( )

protectedvirtual

Evaluates the orthonormal form of the basis functions.

Definition at line 66 of file Zernike.C.

{
  std::size_t n;
  long j, q;
  Real H1, H2, H3;
  const Real & rho = _standardized_location[0];
  const Real rho2 = rho * rho;
  const Real rho4 = rho2 * rho2;
 
  if (MooseUtils::absoluteFuzzyEqual(rho, 0.0))
  {
    for (n = 0; n <= _orders[0]; n += 2)
    {
      j = simpleDoubleToSingle(n, 0);
 
      if ((n / 2) % 2 != 0)
        save(j, -1 * (n + 1) / M_PI);
      else
        save(j, 1 * (n + 1) / M_PI);
    }
 
    return;
  }
 
  switch (_orders[0])
  {
    default:
    case MAX_DIRECT_CALCULATION_ZERNIKE:  /* 10 */
      save(65, rho4 * rho4 * rho2
               * 22 / M_PI);
      save(64, (10 * rho2 - 9) * rho4 * rho4
               * 22 / M_PI);
      save(63, ((45 * rho2 - 72) * rho2 + 28) * rho4 * rho2
               * 22 / M_PI);
      save(62, (((120 * rho2 - 252) * rho2 + 168) * rho2- 35) * rho4
               * 22 / M_PI);
      save(61, ((((210 * rho2 - 504) * rho2 + 420) * rho2 - 140) * rho2 + 15) * rho2
               * 22 / M_PI);
      save(60, (((((252 * rho2 - 630) * rho2 + 560) * rho2 - 210) * rho2 + 30) * rho2 - 1)
               * 11 / M_PI);
      libmesh_fallthrough();
 
    case 9:
      save(54, rho4 * rho4 * rho
               * 20 / M_PI);
      save(53, (9 * rho2 - 8) * rho4 * rho2 * rho
               * 20 / M_PI);
      save(52, ((36 * rho2 - 56) * rho2 + 21) * rho4 * rho
               * 20 / M_PI);
      save(51, (((84 * rho2 - 168) * rho2 + 105) * rho2 - 20) * rho2 * rho
               * 20 / M_PI);
      save(50, ((((126 * rho2 - 280) * rho2 + 210) * rho2 - 60) * rho2 + 5) * rho
               * 20 / M_PI);
      libmesh_fallthrough();
 
    case 8:
      save(44, rho4 * rho4
               * 18 / M_PI);
      save(43, (8 * rho2 - 7) * rho4 * rho2
               * 18 / M_PI);
      save(42, ((28 * rho2 - 42) * rho2 + 15) * rho4
               * 18 / M_PI);
      save(41, (((56 * rho2 - 105) * rho2 + 60) * rho2 - 10) * rho2
               * 18 / M_PI);
      save(40, ((((70 * rho2 - 140) * rho2 + 90) * rho2 - 20) * rho2 + 1)
               * 9 / M_PI);
      libmesh_fallthrough();
 
    case 7:
      save(35, rho4 * rho2 * rho
               * 16 / M_PI);
      save(34, (7 * rho2 - 6) * rho4 * rho
               * 16 / M_PI);
      save(33, ((21 * rho2 - 30) * rho2 + 10) * rho2 * rho
               * 16 / M_PI);
      save(32, (((35 * rho2 - 60) * rho2 + 30) * rho2 - 4) * rho
               * 16 / M_PI);
      libmesh_fallthrough();
 
    case 6:
      save(27, rho4 * rho2
               * 14 / M_PI);
      save(26, (6 * rho2 - 5) * rho4
               * 14 / M_PI);
      save(25, ((15 * rho2 - 20) * rho2 + 6) * rho2
               * 14 / M_PI);
      save(24, (((20 * rho2 - 30) * rho2 + 12) * rho2 - 1)
               * 7 / M_PI);
      libmesh_fallthrough();
 
    case 5:
      save(20, rho4 * rho
               * 12 / M_PI);
      save(19, (5 * rho2 - 4) * rho2 * rho
               * 12 / M_PI);
      save(18, ((10 * rho2 - 12) * rho2 + 3) * rho
               * 12 / M_PI);
      libmesh_fallthrough();
 
    case 4:
      save(14, rho4
               * 10 / M_PI);
      save(13, (4 * rho2 - 3) * rho2
               * 10 / M_PI);
      save(12, ((6 * rho2 - 6) * rho2 + 1)
               * 5 / M_PI);
      libmesh_fallthrough();
 
    case 3:
      save(9, rho2 * rho
              * 8 / M_PI);
      save(8, (3 * rho2 - 2) * rho
              * 8 / M_PI);
      libmesh_fallthrough();
 
    case 2:
      save(5, rho2
              * 6 / M_PI);
      save(4, (2 * rho2 - 1)
              * 3 / M_PI);
      libmesh_fallthrough();
 
    case 1:
      save(2, rho
              * 4 / M_PI);
      libmesh_fallthrough();
 
    case 0:
      save(0, 1
              * 1 / M_PI);
  }
 
  for (n = MAX_DIRECT_CALCULATION_ZERNIKE + 1; n <= _orders[0]; ++n)
  {
    j = simpleDoubleToSingle(n, n);
    save(j, pow(rho, n)
            * (n + n + 2) / M_PI);
 
    j--;
    save(j, n * load(j + 1) - (n + 1) * load(j - (n + n)));
 
    for (q = n; q >= 4; q -= 2)
    {
      H3 = (-4 * (q - 2) * (q - 3)) / ((n + q - 2) * (n - q + 4.0));
      H2 = (H3 * (n + q) * (n - q + 2)) / (4.0 * (q - 1)) + (q - 2);
      H1 = q * (q - 1) / 2 - q * H2 + (H3 * (n + q + 2) * (n - q)) / 8.0;
      j--;
      if (q == 4)
        save(j, (H1 * load(j + 2) + (H2 + H3 / rho2) * load(j + 1))
                * 0.5);
      else
        save(j, H1 * load(j + 2) + (H2 + H3 / rho2) * load(j + 1));
    }
  }
 
  fillOutNegativeRankAndApplyAzimuthalComponent();
}

Referenced by Zernike().

evaluateSqrtMu()

void Zernike::evaluateSqrtMu ( )

protectedvirtual

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

Definition at line 226 of file Zernike.C.

{
  evaluateStandard();
  save(0, load(0) / std::sqrt(M_PI));
  size_t j = 1;
  for (size_t n = 1; n < _orders[0] + 1; ++n)
  {
    for (size_t m = 0; m < n + 1; ++m)
    {
      if (m != 0 && n / m == 2 && n % m == 0)
        save(j, load(j) * std::sqrt((n + 1) / M_PI));
      else
        save(j, load(j) * std::sqrt((2 * n + 2) / M_PI));
      ++j;
    }
  }
}

Referenced by Zernike().

evaluateStandard()

void Zernike::evaluateStandard ( )

protectedvirtual

Evaluates the standard form of the basis functions.

Definition at line 245 of file Zernike.C.

{
  std::size_t n;
  long j, q;
  Real H1, H2, H3;
  const Real & rho = _standardized_location[0];
  const Real rho2 = rho * rho;
  const Real rho4 = rho2 * rho2;
 
  if (MooseUtils::absoluteFuzzyLessEqual(rho, 0))
  {
    for (n = 0; n <= _orders[0]; n += 2)
    {
      j = simpleDoubleToSingle(n, 0);
 
      if ((n / 2) % 2 != 0)
        save(j, -1);
      else
        save(j, 1);
    }
 
    return;
  }
 
  switch (_orders[0])
  {
    default:
    case MAX_DIRECT_CALCULATION_ZERNIKE: /* 10 */
      save(65, rho4 * rho4 * rho2);
      save(64, (10 * rho2 - 9) * rho4 * rho4);
      save(63, ((45 * rho2 - 72) * rho2 + 28) * rho4 * rho2);
      save(62, (((120 * rho2 - 252) * rho2 + 168) * rho2 - 35) * rho4);
      save(61, ((((210 * rho2 - 504) * rho2 + 420) * rho2 - 140) * rho2 + 15) * rho2);
      save(60, ((((252 * rho2 - 630) * rho2 + 560) * rho2 - 210) * rho2 + 30) * rho2 - 1);
      libmesh_fallthrough();
 
    case 9:
      save(54, rho4 * rho4 * rho);
      save(53, (9 * rho2 - 8) * rho4 * rho2 * rho);
      save(52, ((36 * rho2 - 56) * rho2 + 21) * rho4 * rho);
      save(51, (((84 * rho2 - 168) * rho2 + 105) * rho2 - 20) * rho2 * rho);
      save(50, ((((126 * rho2 - 280) * rho2 + 210) * rho2 - 60) * rho2 + 5) * rho);
      libmesh_fallthrough();
 
    case 8:
      save(44, rho4 * rho4);
      save(43, (8 * rho2 - 7) * rho4 * rho2);
      save(42, ((28 * rho2 - 42) * rho2 + 15) * rho4);
      save(41, (((56 * rho2 - 105) * rho2 + 60) * rho2 - 10) * rho2);
      save(40, (((70 * rho2 - 140) * rho2 + 90) * rho2 - 20) * rho2 + 1);
      libmesh_fallthrough();
 
    case 7:
      save(35, rho4 * rho2 * rho);
      save(34, (7 * rho2 - 6) * rho4 * rho);
      save(33, ((21 * rho2 - 30) * rho2 + 10) * rho2 * rho);
      save(32, (((35 * rho2 - 60) * rho2 + 30) * rho2 - 4) * rho);
      libmesh_fallthrough();
 
    case 6:
      save(27, rho4 * rho2);
      save(26, (6 * rho2 - 5) * rho4);
      save(25, ((15 * rho2 - 20) * rho2 + 6) * rho2);
      save(24, ((20 * rho2 - 30) * rho2 + 12) * rho2 - 1);
      libmesh_fallthrough();
 
    case 5:
      save(20, rho4 * rho);
      save(19, (5 * rho2 - 4) * rho2 * rho);
      save(18, ((10 * rho2 - 12) * rho2 + 3) * rho);
      libmesh_fallthrough();
 
    case 4:
      save(14, rho4);
      save(13, (4 * rho2 - 3) * rho2);
      save(12, (6 * rho2 - 6) * rho2 + 1);
      libmesh_fallthrough();
 
    case 3:
      save(9, rho2 * rho);
      save(8, (3 * rho2 - 2) * rho);
      libmesh_fallthrough();
 
    case 2:
      save(5, rho2);
      save(4, 2 * rho2 - 1);
      libmesh_fallthrough();
 
    case 1:
      save(2, rho);
      libmesh_fallthrough();
 
    case 0:
      save(0, 1);
  }
 
  for (n = MAX_DIRECT_CALCULATION_ZERNIKE + 1; n <= _orders[0]; ++n)
  {
    j = simpleDoubleToSingle(n, n);
    save(j, pow(rho, n));
 
    j--;
    save(j, n * load(j + 1) - (n - 1) * load(j - (n + n)));
 
    for (q = n; q >= 4; q -= 2)
    {
      H3 = (-4 * (q - 2) * (q - 3)) / ((n + q - 2) * (n - q + 4.0));
      H2 = (H3 * (n + q) * (n - q + 2)) / (4.0 * (q - 1)) + (q - 2);
      H1 = q * (q - 1) / 2 - q * H2 + (H3 * (n + q + 2) * (n - q)) / 8.0;
      j--;
      save(j, H1 * load(j + 2) + (H2 + H3 / rho2) * load(j + 1));
    }
  }
 
  fillOutNegativeRankAndApplyAzimuthalComponent();
}

Referenced by evaluateSqrtMu(), and Zernike().

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 Legendre::isInPhysicalBounds(), isInPhysicalBounds(), and SingleSeriesBasisInterface::setLocation().

fillOutNegativeRankAndApplyAzimuthalComponent()

void Zernike::fillOutNegativeRankAndApplyAzimuthalComponent ( )

protected

Helper function used by evaluateGeneration() and evaluateExpansion().

It uses the evaluated value array of the zero and positive rank terms to: 1) fill out the negative rank terms 2) apply the azimuthal components to all terms

Definition at line 363 of file Zernike.C.

{
  std::size_t n;
  long j, m, q, a;
  const Real & phi = _standardized_location[1];
 
  j = 0;
  for (n = 1; n <= _orders[0]; ++n)
  {
    j += n;
    for (m = 0, q = a = n; m < q; ++m, --q, a -= 2)
    {
      save(j + m, load(j + q) * sin(a * phi));
      save(j + q, load(j + q) * cos(a * phi));
    }
  }
}

Referenced by evaluateOrthonormal(), and evaluateStandard().

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

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 > & Zernike::getStandardizedFunctionLimits ( ) const

overridevirtual

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

Implements FunctionalBasisInterface.

Definition at line 382 of file Zernike.C.

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

getStandardizedFunctionVolume()

Real Zernike::getStandardizedFunctionVolume ( ) const

overridevirtual

Returns the volume within the standardized function local_limits.

Implements FunctionalBasisInterface.

Definition at line 391 of file Zernike.C.

{
  return M_PI; // The area of a unit disc is pi
}

getStandardizedLocation()

std::vector< Real > Zernike::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 397 of file Zernike.C.

{
  // Get the offset corresponding to the 'x' direction
  const Real offset1 = location[0] - _physical_bounds[0];
  // Get the offset corresponding to the 'y' direction
  const Real offset2 = location[1] - _physical_bounds[1];
  // Get the user-provided radius bound
  const Real & radius = _physical_bounds[2];
  // Covert to a radis and normalize
  const Real standardizedRadius = sqrt(offset1 * offset1 + offset2 * offset2) / radius;
  // Get the angle
  const Real theta = atan2(offset2, offset1);
 
  return {standardizedRadius, theta};
}

Referenced by isInPhysicalBounds().

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 Zernike::isInPhysicalBounds ( const Point &  point ) const

overridevirtual

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

Implements FunctionalBasisInterface.

Definition at line 414 of file Zernike.C.

{
  /*
   * Because Zernike polynomials live in RZ space, the easiest approach to check
   * this is to convert the physical location into a standardized location, then
   * check against the radius and theta bounds.
   */
  const std::vector<Real> location = extractLocationFromPoint(point);
  const std::vector<Real> standardized_location = getStandardizedLocation(location);
 
  /*
   * The radius (standardized_location[0]) is always positive, so only check
   * against the maximum radius (1). The theta components should always be in
   * bounds.
   */
  if (standardized_location[0] > 1.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 Legendre::evaluateOrthonormal(), evaluateOrthonormal(), Legendre::evaluateSqrtMu(), evaluateSqrtMu(), Legendre::evaluateStandard(), evaluateStandard(), and 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 Legendre::evaluateOrthonormal(), evaluateOrthonormal(), CompositeSeriesBasisInterface::evaluateSeries(), Legendre::evaluateSqrtMu(), evaluateSqrtMu(), Legendre::evaluateStandard(), evaluateStandard(), and 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;
}

simpleDoubleToSingle()

std::size_t Zernike::simpleDoubleToSingle ( std::size_t  n, long  m  ) const

protected

Maps the double order/rank idices to a single linear index.

Definition at line 436 of file Zernike.C.

{
  return (n * (n + 2) + m) / 2;
}

Referenced by evaluateOrthonormal(), and evaluateStandard().

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::Legendre(), and 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::Legendre(), and 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().

_negative_azimuthal_components

std::vector<Real> Zernike::_negative_azimuthal_components

protected

Stores the recurrence evaluations for the negative rank azimuthal terms.

Definition at line 69 of file Zernike.h.

_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 Legendre::evaluateOrthonormal(), evaluateOrthonormal(), evaluateSqrtMu(), Legendre::evaluateStandard(), evaluateStandard(), 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 Legendre::getStandardizedLocation(), getStandardizedLocation(), Legendre::isInPhysicalBounds(), and SingleSeriesBasisInterface::setPhysicalBounds().

_positive_azimuthal_components

std::vector<Real> Zernike::_positive_azimuthal_components

protected

Stores the recurrence evaluations for the positive rank azimuthal terms.

Definition at line 72 of file Zernike.h.

_standardized_location

std::vector<Real> SingleSeriesBasisInterface::_standardized_location

protectedinherited

The standardized location of evaluation.

Definition at line 85 of file SingleSeriesBasisInterface.h.

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

---

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

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