CompositeSeriesBasisInterface Class Reference

This class is the basis for constructing a composite—or convolved—functional series by combining multiple other series together. More...

#include <CompositeSeriesBasisInterface.h>

Inheritance diagram for CompositeSeriesBasisInterface:

Public Member Functions
	CompositeSeriesBasisInterface (const std::string &who_is_using_me)
	CompositeSeriesBasisInterface (const std::vector< std::size_t > &orders, std::vector< MooseEnum > series_types, const std::string &who_is_using_me)
virtual	~CompositeSeriesBasisInterface ()
	CompositeSeriesBasisInterface (const CompositeSeriesBasisInterface &)=delete
	CompositeSeriesBasisInterface (CompositeSeriesBasisInterface &&)=delete
void	operator= (const CompositeSeriesBasisInterface &)=delete
CompositeSeriesBasisInterface &	operator= (CompositeSeriesBasisInterface &&)=delete
virtual const std::vector< Real > &	getStandardizedFunctionLimits () const final
	Returns a vector of the lower and upper bounds of the standard functional space.
virtual Real	getStandardizedFunctionVolume () const final
	Returns the volume within the standardized function local_limits.
virtual bool	isCacheInvalid () const final
	Whether the cached values correspond to the current point.
virtual bool	isInPhysicalBounds (const Point &point) const final
	Determines if the point provided is in within the physical bounds.
virtual void	setLocation (const Point &p) 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.
std::vector< Real >	combineStandardizedFunctionLimits () const
	Get the function limits by looping over each of the single series.
void	setNumberOfTerms ()
	Initialize the number of terms in the composite series by looping over the single series.
virtual void	formatCoefficients (std::ostream &stream, const std::vector< Real > &coefficients) const
	Appends a tabulated form of the coefficients to the stream.
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.
virtual void	setPhysicalBounds (const std::vector< Real > &bounds)=0
	Sets the bounds of the series.

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

Protected Member Functions
virtual void	evaluateGeneration () final
	Evaluate the generation form of the functional basis.
virtual void	evaluateExpansion () final
	Evaluate the expansion form of the functional basis.
void	evaluateSeries (const std::vector< std::vector< Real > > &single_series_basis_evaluations)
	Evaluates the values of _basis_evaluation for either evaluateGeneration() or evaluateExpansion()
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< MooseEnum >	_series_types
	The series types in this composite series.
std::vector< std::unique_ptr< SingleSeriesBasisInterface > >	_series
	A pointer to the single series type (one for each entry in _domains)
const std::string &	_who_is_using_me
	The name of the MooseObject that is using this class.
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
Point	_previous_point
	The previous point at which the series was evaluated.
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 the basis for constructing a composite—or convolved—functional series by combining multiple other series together.

Nonseparability is currently assumed.

Definition at line 24 of file CompositeSeriesBasisInterface.h.

Constructor & Destructor Documentation

CompositeSeriesBasisInterface() [1/4]

CompositeSeriesBasisInterface::CompositeSeriesBasisInterface

(

const std::string &

who_is_using_me

)

Definition at line 19 of file CompositeSeriesBasisInterface.C.

  : FunctionalBasisInterface(1), _who_is_using_me(who_is_using_me)
{
  _series.push_back(std::make_unique<Legendre>());
}

CompositeSeriesBasisInterface() [2/4]

CompositeSeriesBasisInterface::CompositeSeriesBasisInterface	(	const std::vector< std::size_t > &	orders,
		std::vector< MooseEnum >	series_types,
		const std::string &	who_is_using_me
	)

Definition at line 30 of file CompositeSeriesBasisInterface.C.

  : FunctionalBasisInterface(), _series_types(series_types), _who_is_using_me(who_is_using_me)
{
  if (orders.size() != _series_types.size())
    mooseError(_who_is_using_me,
               " calling CSBI::CSBI(...): Incorrect number of 'orders' specified for "
               "'FunctionSeries'! Check that 'orders' is the correct length and no invalid "
               "enumerations are specified for the series.");
}

~CompositeSeriesBasisInterface()

CompositeSeriesBasisInterface::~CompositeSeriesBasisInterface ( )

virtual

Definition at line 301 of file CompositeSeriesBasisInterface.C.

{}

CompositeSeriesBasisInterface() [3/4]

CompositeSeriesBasisInterface::CompositeSeriesBasisInterface ( const CompositeSeriesBasisInterface &  )

delete

CompositeSeriesBasisInterface() [4/4]

CompositeSeriesBasisInterface::CompositeSeriesBasisInterface ( CompositeSeriesBasisInterface &&  )

delete

Member Function Documentation

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

combineStandardizedFunctionLimits()

std::vector< Real > CompositeSeriesBasisInterface::combineStandardizedFunctionLimits

(

)

const

Get the function limits by looping over each of the single series.

Definition at line 135 of file CompositeSeriesBasisInterface.C.

{
  std::vector<Real> function_limits;
 
  for (auto & series : _series)
  {
    std::vector<Real> local_limits = series->getStandardizedFunctionLimits();
    for (auto & limit : local_limits)
      function_limits.push_back(limit);
  }
 
  return function_limits;
}

Referenced by getStandardizedFunctionLimits().

evaluateExpansion()

void CompositeSeriesBasisInterface::evaluateExpansion ( )

finalprotectedvirtual

Evaluate the expansion form of the functional basis.

Implements FunctionalBasisInterface.

Definition at line 101 of file CompositeSeriesBasisInterface.C.

{
  /*
   * Evaluate the expansion versions of each of the single series, and collect the results before
   * passing them to evaluateSeries, where they will be multiplied together correctly and stored in
   * the composite series basis evaluation.
   */
  std::vector<std::vector<Real>> single_series_basis_evaluation;
  for (auto & series : _series)
    single_series_basis_evaluation.push_back(series->getAllExpansion());
 
  evaluateSeries(single_series_basis_evaluation);
}

evaluateGeneration()

void CompositeSeriesBasisInterface::evaluateGeneration ( )

finalprotectedvirtual

Evaluate the generation form of the functional basis.

Implements FunctionalBasisInterface.

Definition at line 44 of file CompositeSeriesBasisInterface.C.

{
  /*
   * Evaluate the generation versions of each of the single series, and collect the results before
   * passing them to evaluateSeries, where they will be multiplied together correctly and stored in
   * the composite series basis evaluation.
   */
  std::vector<std::vector<Real>> single_series_basis_evaluation;
  for (auto & series : _series)
    single_series_basis_evaluation.push_back(series->getAllGeneration());
 
  evaluateSeries(single_series_basis_evaluation);
}

evaluateSeries()

void CompositeSeriesBasisInterface::evaluateSeries ( const std::vector< std::vector< Real > > &  single_series_basis_evaluations )

protected

Evaluates the values of _basis_evaluation for either evaluateGeneration() or evaluateExpansion()

Definition at line 59 of file CompositeSeriesBasisInterface.C.

{
  /*
   * Appropriate number of loops based on 1-D, 2-D, or 3-D to multiply the basis evaluations of the
   * single series together to form the basis evaluation of the entire composite series.
   */
  Real f1, f2, f3;
  std::size_t term = 0;
 
  if (single_series_basis_evaluations.size() == 1)
    for (std::size_t i = 0; i < _series[0]->getNumberOfTerms(); ++i, ++term)
      save(term, single_series_basis_evaluations[0][i]);
 
  if (single_series_basis_evaluations.size() == 2)
    for (std::size_t i = 0; i < _series[0]->getNumberOfTerms(); ++i)
    {
      f1 = single_series_basis_evaluations[0][i];
      for (std::size_t j = 0; j < _series[1]->getNumberOfTerms(); ++j, ++term)
      {
        f2 = single_series_basis_evaluations[1][j];
        save(term, f1 * f2);
      }
    }
 
  if (single_series_basis_evaluations.size() == 3)
    for (std::size_t i = 0; i < _series[0]->getNumberOfTerms(); ++i)
    {
      f1 = single_series_basis_evaluations[0][i];
      for (std::size_t j = 0; j < _series[1]->getNumberOfTerms(); ++j)
      {
        f2 = single_series_basis_evaluations[1][j];
        for (std::size_t k = 0; k < _series[2]->getNumberOfTerms(); ++k, ++term)
        {
          f3 = single_series_basis_evaluations[2][k];
          save(term, f1 * f2 * f3);
        }
      }
    }
}

Referenced by evaluateExpansion(), and evaluateGeneration().

formatCoefficients()

void CompositeSeriesBasisInterface::formatCoefficients ( std::ostream &  stream, const std::vector< Real > &  coefficients  ) const

virtual

Appends a tabulated form of the coefficients to the stream.

Definition at line 150 of file CompositeSeriesBasisInterface.C.

{
  // clang-format off
  std::ostringstream formatted, domains, orders;
  std::size_t term = 0;
 
  stream <<               "---------------- Coefficients ----------------\n"
         <<               "               == Subindices ==\n";
 
  if (_series_types.size() == 1)
  {
    orders <<             "         Orders: " << std::setw(3) << _series[0]->getOrder(0) << "\n";
    domains <<            " == Index  ==    " << std::setw(3) << _series[0]->_domains[0]
            <<                                "             === Value ===\n"
            <<            "----------------------------------------------\n";
 
    for (std::size_t i = 0; i < _series[0]->getNumberOfTerms(); ++i, ++term)
      formatted <<        "    " << std::setw(4) << term
                <<                "         " << std::setw(3) << i
                <<                            "             " << std::setw(12) << coefficients[term] << "\n";
  }
  else if (_series_types.size() == 2)
  {
    orders <<             "         Orders: " << std::setw(3) << _series[0]->getOrder(0)
           <<                                 " " << std::setw(3) << _series[1]->getOrder(0) << "\n";
    domains <<            " == Index  ==    " << std::setw(3) << _series[0]->_domains[0]
            <<                                " " << std::setw(3) << _series[1]->_domains[0]
            <<                                   "          === Value ===\n"
            <<            "----------------------------------------------\n";
 
    for (std::size_t i = 0; i < _series[0]->getNumberOfTerms(); ++i)
    {
      for (std::size_t j = 0; j < _series[1]->getNumberOfTerms(); ++j, ++term)
        formatted <<      "    " << std::setw(4) << term
                  <<              "         " << std::setw(3) << i
                  <<                          " " << std::setw(3) << j
                  <<                              "         " << std::setw(12) << coefficients[term] << "\n";
    }
  }
  else if (_series_types.size() == 3)
  {
    orders <<             "         Orders: " << std::setw(3) << _series[0]->getOrder(0)
           <<                                 " " << std::setw(3) << _series[1]->getOrder(0)
           <<                                     " " << std::setw(3) << _series[2]->getOrder(0) << "\n";
    domains <<            " == Index  ==    " << std::setw(3) << _series[0]->_domains[0]
            <<                                " " << std::setw(3) << _series[1]->_domains[0]
            <<                                    " " << std::setw(3) << _series[2]->_domains[0]
            <<                                        "     === Value ===\n"
            <<            "----------------------------------------------\n";
 
    for (std::size_t i = 0; i < _series[0]->getNumberOfTerms(); ++i)
    {
      for (std::size_t j = 0; j < _series[1]->getNumberOfTerms(); ++j)
      {
        for (std::size_t k = 0; k < _series[2]->getNumberOfTerms(); ++k, ++term)
          formatted <<    "    " << std::setw(4) << term
                    <<            "         " << std::setw(3) << i
                    <<                        " " << std::setw(3) << j
                    <<                            " " << std::setw(3) << k
                    <<                                "     " << std::setw(12) << coefficients[term] << "\n";
      }
    }
  }
  // clang-format on
 
  stream << orders.str() << domains.str() << formatted.str() << std::flush;
}

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

getStandardizedFunctionLimits()

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

finalvirtual

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

Implements FunctionalBasisInterface.

Definition at line 116 of file CompositeSeriesBasisInterface.C.

{
  static const std::vector<Real> function_limits = combineStandardizedFunctionLimits();
 
  return function_limits;
}

getStandardizedFunctionVolume()

Real CompositeSeriesBasisInterface::getStandardizedFunctionVolume ( ) const

finalvirtual

Returns the volume within the standardized function local_limits.

Implements FunctionalBasisInterface.

Definition at line 124 of file CompositeSeriesBasisInterface.C.

{
  Real function_volume = 1.0;
 
  for (auto & series : _series)
    function_volume *= series->getStandardizedFunctionVolume();
 
  return function_volume;
}

isCacheInvalid()

bool CompositeSeriesBasisInterface::isCacheInvalid ( ) const

finalvirtual

Whether the cached values correspond to the current point.

Implements FunctionalBasisInterface.

Definition at line 220 of file CompositeSeriesBasisInterface.C.

{
  /*
   * If any one of the single series have an invalid cache, then we need to re-evaluate the entire
   * composite series because the terms are multiplied.
   */
  for (auto & series : _series)
    if (series->isCacheInvalid())
      return true;
 
  return false;
}

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

finalvirtual

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

Implements FunctionalBasisInterface.

Definition at line 234 of file CompositeSeriesBasisInterface.C.

{
  /*
   * A point is in the physical bounds of the composite series if it is in the physical bounds of
   * each of the single series
   */
  for (auto & series : _series)
    if (!series->isInPhysicalBounds(point))
      return false;
 
  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(), Zernike::evaluateOrthonormal(), Legendre::evaluateSqrtMu(), Zernike::evaluateSqrtMu(), Legendre::evaluateStandard(), Zernike::evaluateStandard(), and Zernike::fillOutNegativeRankAndApplyAzimuthalComponent().

operator=() [1/2]

CompositeSeriesBasisInterface & CompositeSeriesBasisInterface::operator= ( CompositeSeriesBasisInterface &&  )

delete

operator=() [2/2]

void CompositeSeriesBasisInterface::operator= ( const CompositeSeriesBasisInterface &  )

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

setLocation()

void CompositeSeriesBasisInterface::setLocation ( const Point &  point )

finalvirtual

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

Implements FunctionalBasisInterface.

Definition at line 287 of file CompositeSeriesBasisInterface.C.

{
  // Return if this point is the same as the last at which the composite series was evaluated
  if (point.absolute_fuzzy_equals(_previous_point))
    return;
 
  // Set the location of each of the single series
  for (auto & series : _series)
    series->setLocation(point);
 
  // Store the previous point
  _previous_point = point;
}

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

setNumberOfTerms()

void CompositeSeriesBasisInterface::setNumberOfTerms

(

)

Initialize the number of terms in the composite series by looping over the single series.

Definition at line 248 of file CompositeSeriesBasisInterface.C.

{
  unsigned int number_of_terms = 1;
 
  // Accumulate the number of terms for each series
  for (auto & series : _series)
    number_of_terms *= series->getNumberOfTerms();
 
  _number_of_terms = number_of_terms;
 
  /*
   * The length of the _basis_evaluation depends on the number of terms, so we need to clear the
   * entries because the number of terms in the composite series may have changed.
   */
  clearBasisEvaluation(_number_of_terms);
}

Referenced by Cartesian::Cartesian(), CylindricalDuo::CylindricalDuo(), and setOrder().

setOrder()

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

finalvirtual

Set the order of the series.

Implements FunctionalBasisInterface.

Definition at line 266 of file CompositeSeriesBasisInterface.C.

{
  // One order must be specified for each single series
  if (orders.size() != _series.size())
    mooseError(_who_is_using_me,
               " calling CSBI::setOrder(): Mismatch between the orders provided and the number of "
               "series in the functional basis!");
 
  // Update the orders of each of the single series
  for (std::size_t i = 0; i < _series.size(); ++i)
    _series[i]->setOrder({orders[i]});
 
  /*
   * After changing the order of each single series, we need to recompute the number of terms by
   * looping over those single series. This also clears the basis evaluation of the composite
   * series.
   */
  setNumberOfTerms();
}

Referenced by setOrder().

setPhysicalBounds()

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

pure virtualinherited

Sets the bounds of the series.

Implemented in Cartesian, CylindricalDuo, and SingleSeriesBasisInterface.

Member Data Documentation

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

_is_cache_invalid

bool FunctionalBasisInterface::_is_cache_invalid

private

indicates if the evaluated values correspond to the current location

Definition at line 146 of file FunctionalBasisInterface.h.

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

_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(), setNumberOfTerms(), and SingleSeriesBasisInterface::setOrder().

_previous_point

Point CompositeSeriesBasisInterface::_previous_point

private

The previous point at which the series was evaluated.

Definition at line 86 of file CompositeSeriesBasisInterface.h.

Referenced by setLocation().

_series

std::vector<std::unique_ptr<SingleSeriesBasisInterface> > CompositeSeriesBasisInterface::_series

protected

A pointer to the single series type (one for each entry in _domains)

Definition at line 79 of file CompositeSeriesBasisInterface.h.

Referenced by Cartesian::Cartesian(), combineStandardizedFunctionLimits(), CompositeSeriesBasisInterface(), CylindricalDuo::CylindricalDuo(), evaluateExpansion(), evaluateGeneration(), evaluateSeries(), formatCoefficients(), getStandardizedFunctionVolume(), isCacheInvalid(), isInPhysicalBounds(), setLocation(), setNumberOfTerms(), setOrder(), Cartesian::setPhysicalBounds(), and CylindricalDuo::setPhysicalBounds().

_series_types

std::vector<MooseEnum> CompositeSeriesBasisInterface::_series_types

protected

The series types in this composite series.

Definition at line 76 of file CompositeSeriesBasisInterface.h.

Referenced by Cartesian::Cartesian(), CompositeSeriesBasisInterface(), CylindricalDuo::CylindricalDuo(), formatCoefficients(), and Cartesian::setPhysicalBounds().

_who_is_using_me

const std::string& CompositeSeriesBasisInterface::_who_is_using_me

protected

The name of the MooseObject that is using this class.

Definition at line 82 of file CompositeSeriesBasisInterface.h.

Referenced by CompositeSeriesBasisInterface(), and setOrder().

---

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

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