FunctionSeries.C File Reference

Go to the source code of this file.

Functions
	registerMooseObject ("FunctionalExpansionToolsApp", FunctionSeries)
template<>
InputParameters	validParams< FunctionSeries > ()
std::ostream &	operator<< (std::ostream &stream, const FunctionSeries &me)

Function Documentation

operator<<()

std::ostream& operator<<	(	std::ostream &	stream,
		const FunctionSeries &	me
	)

Definition at line 278 of file FunctionSeries.C.

{
  stream << "\n\n"
         << "FunctionSeries: " << me.name() << "\n"
         << "         Terms: " << me.getNumberOfTerms() << "\n";
  me._series_type->formatCoefficients(stream, me._coefficients);
  stream << "\n\n";
 
  return stream;
}

registerMooseObject()

registerMooseObject	(	"FunctionalExpansionToolsApp"	,
		FunctionSeries
	)

validParams< FunctionSeries >()

template<>

InputParameters validParams< FunctionSeries >

(

)

Definition at line 21 of file FunctionSeries.C.

{
  InputParameters params = validParams<MutableCoefficientsFunctionInterface>();
 
  params.addClassDescription("This function uses a convolution of functional series (functional "
                             "expansion or FX) to create a 1D, 2D, or 3D function");
 
  // The available composite series types.
  //   Cartesian:      1D, 2D, or 3D, depending on which of x, y, and z are present
  //   CylindricalDuo: planar disc expansion and axial expansion
  MooseEnum series_types("Cartesian CylindricalDuo");
  MooseEnum single_series_types_1D("Legendre");
  MooseEnum single_series_types_2D("Zernike");
 
  params.addRequiredParam<MooseEnum>(
      "series_type", series_types, "The type of function series to construct.");
 
  /*
   * This needs to use `unsigned int` instead of `std::size_t` because otherwise MOOSE errors at
   * runtime
   */
  params.addRequiredParam<std::vector<unsigned int>>("orders",
                                                     "The order of each series. These must be "
                                                     "defined as \"x y z\" for Cartesian, and \"z "
                                                     "disc\" for CylindricalDuo.");
 
  params.addParam<std::vector<Real>>("physical_bounds",
                                     "The physical bounds of the function series. These must be "
                                     "defined as \"x_min x_max y_min y_max z_min z_max\" for "
                                     "Cartesian, and \"axial_min axial_max disc_center1 "
                                     "disc_center2 radius\" for CylindricalDuo");
 
  params.addParam<MooseEnum>("x", single_series_types_1D, "The series to use for the x-direction.");
  params.addParam<MooseEnum>("y", single_series_types_1D, "The series to use for the y-direction.");
  params.addParam<MooseEnum>("z", single_series_types_1D, "The series to use for the z-direction.");
 
  params.addParam<MooseEnum>("disc",
                             single_series_types_2D,
                             "The series to use for the disc. Its direction is determined by "
                             "orthogonality to the declared direction of the axis.");
 
  std::string normalization_types = "orthonormal sqrt_mu standard";
  MooseEnum expansion_type(normalization_types, "standard");
  MooseEnum generation_type(normalization_types, "orthonormal");
  params.addParam<MooseEnum>("expansion_type",
                             expansion_type,
                             "The normalization used for expansion of the basis functions");
  params.addParam<MooseEnum>(
      "generation_type",
      generation_type,
      "The normalization used for generation of the basis function coefficients");
  return params;
}