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 : public MutableCoefficientsFunctionInterface
{
public:
  static InputParameters validParams();

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