Cartesian Class Reference

This class constructs a functional expansion using a separate series for each Cartesian dimension. More...

#include <Cartesian.h>

Inheritance diagram for Cartesian:

Public Member Functions
	Cartesian (const std::string &who_is_using_me)
	Cartesian (const std::vector< MooseEnum > &domain, const std::vector< std::size_t > &order, const std::vector< MooseEnum > &series_types, const std::string &who_is_using_me, MooseEnum expansion_type, MooseEnum generation_type)
virtual void	setPhysicalBounds (const std::vector< Real > &bounds) final
	Sets the bounds of the series. More...
virtual const std::vector< Real > &	getStandardizedFunctionLimits () const final
	Returns a vector of the lower and upper bounds of the standard functional space. More...
virtual Real	getStandardizedFunctionVolume () const final
	Returns the volume within the standardized function local_limits. More...
virtual bool	isCacheInvalid () const final
	Whether the cached values correspond to the current point. More...
virtual bool	isInPhysicalBounds (const Point &point) const final
	Determines if the point provided is in within the physical bounds. More...
virtual void	setLocation (const Point &p) final
	Set the location that will be used by the series to compute values. More...
virtual void	setOrder (const std::vector< std::size_t > &orders) final
	Set the order of the series. More...
std::vector< Real >	combineStandardizedFunctionLimits () const
	Get the function limits by looping over each of the single series. More...
void	setNumberOfTerms ()
	Initialize the number of terms in the composite series by looping over the single series. More...
virtual void	formatCoefficients (std::ostream &stream, const std::vector< Real > &coefficients) const
	Appends a tabulated form of the coefficients to the stream. More...
Real	operator[] (std::size_t index) const
	Returns the current evaluation at the given index. More...
const std::vector< Real > &	getAllGeneration ()
	Returns an array reference containing the value of each generation term. More...
const std::vector< Real > &	getAllExpansion ()
	Returns an array reference containing the value of each expansion term. More...
std::size_t	getNumberOfTerms () const
	Returns the number of terms in the series. More...
Real	getGeneration ()
	Gets the last term of the generation functional basis. More...
Real	getGenerationSeriesSum ()
	Gets the sum of all terms in the generation functional basis. More...
Real	getExpansion ()
	Gets the #_order-th term of the expansion functional basis. More...
Real	getExpansionSeriesSum ()
	Evaluates the sum of all terms in the expansion functional basis up to #_order. More...
bool	isGeneration () const
	Returns true if the current evaluation is generation. More...
bool	isExpansion () const
	Returns true if the current evaluation is expansion. More...

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

Protected Member Functions
virtual void	evaluateGeneration () final
	Evaluate the generation form of the functional basis. More...
virtual void	evaluateExpansion () final
	Evaluate the expansion form of the functional basis. More...
void	evaluateSeries (const std::vector< std::vector< Real >> &single_series_basis_evaluations)
	Evaluates the values of _basis_evaluation for either evaluateGeneration() or evaluateExpansion() More...
virtual void	clearBasisEvaluation (const unsigned int &number_of_terms)
	Set all entries of the basis evaluation to zero. More...
Real	load (std::size_t index) const
	Helper function to load a value from #_series. More...
void	save (std::size_t index, Real value)
	Helper function to store a value in #_series. More...

Protected Attributes
std::vector< MooseEnum >	_series_types
	The series types in this composite series. More...
std::vector< std::unique_ptr< SingleSeriesBasisInterface > >	_series
	A pointer to the single series type (one for each entry in _domains) More...
const std::string &	_who_is_using_me
	The name of the MooseObject that is using this class. More...
unsigned int	_number_of_terms
	The number of terms in the series. More...

Detailed Description

This class constructs a functional expansion using a separate series for each Cartesian dimension.

1D, 2D, and 3D domains are supported.

Definition at line 19 of file Cartesian.h.

Constructor & Destructor Documentation

Cartesian() [1/2]

Cartesian::Cartesian

(

const std::string &

who_is_using_me

)

Definition at line 13 of file Cartesian.C.

  : CompositeSeriesBasisInterface(who_is_using_me)
{
}

Cartesian() [2/2]

Cartesian::Cartesian	(	const std::vector< MooseEnum > &	domain,
		const std::vector< std::size_t > &	order,
		const std::vector< MooseEnum > &	series_types,
		const std::string &	who_is_using_me,
		MooseEnum	expansion_type,
		MooseEnum	generation_type
	)

Definition at line 18 of file Cartesian.C.

  : CompositeSeriesBasisInterface(orders, series_types, who_is_using_me)
{
  // Initialize the pointers to each of the single series
  for (std::size_t i = 0; i < _series_types.size(); ++i)
    if (_series_types[i] == "Legendre")
    {
      std::vector<MooseEnum> local_domain = {domains[i]};
      std::vector<std::size_t> local_order = {orders[i]};
      _series.push_back(libmesh_make_unique<Legendre>(
          local_domain, local_order, expansion_type, generation_type));
    }
    else
      mooseError("Cartesian: No other linear series implemented except Legendre!");

  /*
   * Set the _number_of_terms for the composite series by looping over each of the single series.
   * This also initializes _basis_evaluation with zero values and the appropriate length.
   */
  setNumberOfTerms();
}

Member Function Documentation

clearBasisEvaluation()

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

protectedvirtualinherited

Set all entries of the basis evaluation to zero.

Definition at line 144 of file FunctionalBasisInterface.C.

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

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

combineStandardizedFunctionLimits()

std::vector< Real > CompositeSeriesBasisInterface::combineStandardizedFunctionLimits ( ) const

inherited

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

Definition at line 133 of file CompositeSeriesBasisInterface.C.

Referenced by CompositeSeriesBasisInterface::getStandardizedFunctionLimits().

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

evaluateExpansion()

void CompositeSeriesBasisInterface::evaluateExpansion ( )

finalprotectedvirtualinherited

Evaluate the expansion form of the functional basis.

Implements FunctionalBasisInterface.

Definition at line 99 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 ( )

finalprotectedvirtualinherited

Evaluate the generation form of the functional basis.

Implements FunctionalBasisInterface.

Definition at line 42 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 )

protectedinherited

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

Definition at line 57 of file CompositeSeriesBasisInterface.C.

Referenced by CompositeSeriesBasisInterface::evaluateExpansion(), and CompositeSeriesBasisInterface::evaluateGeneration().

{
  /*
   * 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);
        }
      }
    }
}

formatCoefficients()

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

virtualinherited

Appends a tabulated form of the coefficients to the stream.

Definition at line 148 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();
}

getAllExpansion()

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

inherited

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

Definition at line 72 of file FunctionalBasisInterface.C.

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

{
  if (isGeneration() || isCacheInvalid())
  {
    clearBasisEvaluation(_number_of_terms);

    evaluateExpansion();

    _is_generation = false;
    _is_cache_invalid = false;
  }

  return _basis_evaluation;
}

getAllGeneration()

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

inherited

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

Definition at line 56 of file FunctionalBasisInterface.C.

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

{
  if (isExpansion() || isCacheInvalid())
  {
    clearBasisEvaluation(_number_of_terms);

    evaluateGeneration();

    _is_generation = true;
    _is_cache_invalid = false;
  }

  return _basis_evaluation;
}

getExpansion()

Real FunctionalBasisInterface::getExpansion ( )

inherited

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

Definition at line 113 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 120 of file FunctionalBasisInterface.C.

Referenced by TEST().

{
  Real sum = 0.0;

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

  return sum;
}

getGeneration()

Real FunctionalBasisInterface::getGeneration ( )

inherited

Gets the last term of the generation functional basis.

Definition at line 94 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 101 of file FunctionalBasisInterface.C.

Referenced by TEST().

{
  Real sum = 0.0;

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

  return sum;
}

getNumberOfTerms()

std::size_t FunctionalBasisInterface::getNumberOfTerms ( ) const

inherited

Returns the number of terms in the series.

Definition at line 88 of file FunctionalBasisInterface.C.

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

{
  return _number_of_terms;
}

getStandardizedFunctionLimits()

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

finalvirtualinherited

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

Implements FunctionalBasisInterface.

Definition at line 114 of file CompositeSeriesBasisInterface.C.

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

  return function_limits;
}

getStandardizedFunctionVolume()

Real CompositeSeriesBasisInterface::getStandardizedFunctionVolume ( ) const

finalvirtualinherited

Returns the volume within the standardized function local_limits.

Implements FunctionalBasisInterface.

Definition at line 122 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

finalvirtualinherited

Whether the cached values correspond to the current point.

Implements FunctionalBasisInterface.

Definition at line 218 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 50 of file FunctionalBasisInterface.C.

Referenced by FunctionalBasisInterface::getAllGeneration().

{
  return !_is_generation;
}

isGeneration()

bool FunctionalBasisInterface::isGeneration ( ) const

inherited

Returns true if the current evaluation is generation.

Definition at line 44 of file FunctionalBasisInterface.C.

Referenced by FunctionalBasisInterface::getAllExpansion().

{
  return _is_generation;
}

isInPhysicalBounds()

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

finalvirtualinherited

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

Implements FunctionalBasisInterface.

Definition at line 232 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 132 of file FunctionalBasisInterface.C.

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

{
  return _basis_evaluation[index];
}

operator[]()

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

inherited

Returns the current evaluation at the given index.

Definition at line 38 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 138 of file FunctionalBasisInterface.C.

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

{
  _basis_evaluation[index] = value;
}

setLocation()

void CompositeSeriesBasisInterface::setLocation ( const Point &  point )

finalvirtualinherited

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

Implements FunctionalBasisInterface.

Definition at line 285 of file CompositeSeriesBasisInterface.C.

Referenced by TEST().

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

setNumberOfTerms()

void CompositeSeriesBasisInterface::setNumberOfTerms ( )

inherited

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

Definition at line 246 of file CompositeSeriesBasisInterface.C.

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

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

setOrder()

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

finalvirtualinherited

Set the order of the series.

Implements FunctionalBasisInterface.

Definition at line 264 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();
}

setPhysicalBounds()

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

finalvirtual

Sets the bounds of the series.

Implements FunctionalBasisInterface.

Definition at line 46 of file Cartesian.C.

{
  // Each single series is assumed to be a function of a single variable so that it has two bounds
  if (bounds.size() != _series_types.size() * 2)
    mooseError("Cartesian: Mismatch between the physical bounds provided and the number of series "
               "in the functional basis!");

  // Update the _physical_bounds of each of the single series
  unsigned int j = 0;
  for (std::size_t i = 0; i < _series_types.size(); ++i, j += 2)
    _series[i]->setPhysicalBounds({bounds[j], bounds[j + 1]});
}

Member Data Documentation

_domain_options

MooseEnum FunctionalBasisInterface::_domain_options

staticinherited

An enumeration of the domains available to each functional series.

Definition at line 116 of file FunctionalBasisInterface.h.

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

_number_of_terms

unsigned int FunctionalBasisInterface::_number_of_terms

protectedinherited

The number of terms in the series.

Definition at line 145 of file FunctionalBasisInterface.h.

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

_series

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

protectedinherited

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

Definition at line 80 of file CompositeSeriesBasisInterface.h.

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

_series_types

std::vector<MooseEnum> CompositeSeriesBasisInterface::_series_types

protectedinherited

The series types in this composite series.

Definition at line 77 of file CompositeSeriesBasisInterface.h.

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

_who_is_using_me

const std::string& CompositeSeriesBasisInterface::_who_is_using_me

protectedinherited

The name of the MooseObject that is using this class.

Definition at line 83 of file CompositeSeriesBasisInterface.h.

Referenced by CompositeSeriesBasisInterface::CompositeSeriesBasisInterface(), and CompositeSeriesBasisInterface::setOrder().

---

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

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