FunctionSeries.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "MutableCoefficientsFunctionInterface.h"
#include "CompositeSeriesBasisInterface.h"
 
class FunctionSeries;
 
template <>
InputParameters validParams<FunctionSeries>();
 
class FunctionSeries : public MutableCoefficientsFunctionInterface
{
public:
  FunctionSeries(const InputParameters & parameters);
 
  static FunctionSeries & checkAndConvertFunction(const Function & function,
                                                  const std::string & typeName,
                                                  const std::string & objectName);
 
  // Override from MemoizedFunctionInterface
  virtual Real evaluateValue(Real t, const Point & p) override;
 
  Real expand();
 
  Real expand(const std::vector<Real> & coefficients);
 
  std::size_t getNumberOfTerms() const;
 
  Real getStandardizedFunctionVolume() const;
 
  const std::vector<std::size_t> & getOrders() const;
 
  const std::vector<Real> & getGeneration();
 
  const std::vector<Real> & getExpansion();
 
  bool isInPhysicalBounds(const Point & point) const;
 
  void setLocation(const Point & point);
 
  friend std::ostream & operator<<(std::ostream & stream, const FunctionSeries & me);
 
protected:
  const std::vector<std::size_t> _orders;
 
  const std::vector<Real> _physical_bounds;
 
  std::unique_ptr<CompositeSeriesBasisInterface> _series_type;
 
  const MooseEnum & _series_type_name;
 
  /*
   * Enumerations of the possible series types for the different spatial expansions. Not all of
   * these will be provided for any one series.
   */
  const MooseEnum & _x;
  const MooseEnum & _y;
  const MooseEnum & _z;
  const MooseEnum & _disc;
  const MooseEnum & _expansion_type;
  const MooseEnum & _generation_type;
 
private:
  static std::vector<std::size_t> convertOrders(const std::vector<unsigned int> & orders);
};