www.mooseframework.org
LeastSquaresFitHistory.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #include "LeastSquaresFitHistory.h"
12 #include "PolynomialFit.h"
13 #include "Conversion.h"
14 
16 
19 {
21 
22  params.addRequiredParam<VectorPostprocessorName>(
23  "vectorpostprocessor",
24  "The vectorpostprocessor on whose values we perform a least squares fit");
25  params.addRequiredParam<std::string>("x_name", "The name of the independent variable");
26  params.addRequiredParam<std::string>("y_name", "The name of the dependent variable");
27  params.addRequiredParam<unsigned int>("order", "The order of the polynomial fit");
28  params.addParam<bool>(
29  "truncate_order",
30  true,
31  "Truncate the order of the fitted polynomial if an insufficient number of data points are "
32  "provided. If this is set to false, an error will be generated in that case.");
33  params.addParam<Real>(
34  "x_scale", 1.0, "Value used to scale x values (scaling is done after shifting)");
35  params.addParam<Real>(
36  "x_shift", 0.0, "Value used to shift x values (shifting is done before scaling)");
37  params.addParam<Real>(
38  "y_scale", 1.0, "Value used to scale y values (scaling is done after shifting)");
39  params.addParam<Real>(
40  "y_shift", 0.0, "Value used to shift y values (shifting is done before scaling)");
41  params.addClassDescription(
42  "Performs a polynomial least squares fit on the data contained in "
43  "another VectorPostprocessor and stores the full time history of the coefficients");
44 
45  params.set<bool>("contains_complete_history") = true;
46  params.addParamNamesToGroup("contains_complete_history", "Advanced");
47 
48  return params;
49 }
50 
52  : GeneralVectorPostprocessor(parameters),
53  _vpp_name(getParam<VectorPostprocessorName>("vectorpostprocessor")),
54  _order(parameters.get<unsigned int>("order")),
55  _truncate_order(parameters.get<bool>("truncate_order")),
56  _x_name(getParam<std::string>("x_name")),
57  _y_name(getParam<std::string>("y_name")),
58  _x_values(getVectorPostprocessorValue("vectorpostprocessor", _x_name)),
59  _y_values(getVectorPostprocessorValue("vectorpostprocessor", _y_name)),
60  _x_scale(parameters.get<Real>("x_scale")),
61  _x_shift(parameters.get<Real>("x_shift")),
62  _y_scale(parameters.get<Real>("y_scale")),
63  _y_shift(parameters.get<Real>("y_shift"))
64 {
65  _coeffs.resize(_order + 1);
66  for (unsigned int i = 0; i < _coeffs.size(); ++i)
67  _coeffs[i] = &declareVector("coef_" + Moose::stringify(i));
68  _times = &declareVector("time");
69 }
70 
71 void
73 {
74  // no reset/clear needed since contains complete history
75 }
76 
77 void
79 {
80  if (_x_values.size() != _y_values.size())
81  mooseError("In LeastSquresFitTimeHistory size of data in x_values and y_values must be equal");
82  if (_x_values.size() == 0)
83  mooseError("In LeastSquresFitTimeHistory size of data in x_values and y_values must be > 0");
84 
85  // Create a copy of _x_values that we can modify.
86  std::vector<Real> x_values(_x_values.begin(), _x_values.end());
87  std::vector<Real> y_values(_y_values.begin(), _y_values.end());
88 
89  for (MooseIndex(_x_values) i = 0; i < _x_values.size(); ++i)
90  {
91  x_values[i] = (x_values[i] + _x_shift) * _x_scale;
92  y_values[i] = (y_values[i] + _y_shift) * _y_scale;
93  }
94 
95  PolynomialFit pf(x_values, y_values, _order, _truncate_order);
96  pf.generate();
97 
98  std::vector<Real> coeffs = pf.getCoefficients();
99  mooseAssert(coeffs.size() == _coeffs.size(),
100  "Sizes of current coefficients and vector of coefficient vectors must match");
101  for (MooseIndex(coeffs) i = 0; i < coeffs.size(); ++i)
102  _coeffs[i]->push_back(coeffs[i]);
103 
104  _times->push_back(_t);
105 }
registerMooseObject("MooseApp", LeastSquaresFitHistory)
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
Definition: MooseUtils.h:1147
This class is here to combine the VectorPostprocessor interface and the base class VectorPostprocesso...
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void addRequiredParam(const std::string &name, const std::string &doc_string)
This method adds a parameter and documentation string to the InputParameters object that will be extr...
LeastSquaresFitHistory(const InputParameters &parameters)
Class constructor.
std::vector< VectorPostprocessorValue * > _coeffs
Vector of vectors with the individual coefficients.
const VectorPostprocessorValue & _x_values
The variables with the x, y data to be fit.
const Real _x_scale
Values used to scale and or shift x and y data.
static InputParameters validParams()
const VectorPostprocessorValue & _y_values
virtual void generate()
Generate the fit.
const bool _truncate_order
Whether to truncate the polynomial order if an insufficient number of points is provided.
Least squares polynomial fit.
Definition: PolynomialFit.h:19
VectorPostprocessorValue & declareVector(const std::string &vector_name)
Register a new vector to fill up.
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:62
virtual void execute() override
Perform the least squares fit.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
LeastSquaresFitHistory is a VectorPostprocessor that performs a least squares fit on data calculated ...
const unsigned int _order
The order of the polynomial fit to be performed.
const std::vector< Real > & getCoefficients()
Const reference to the vector of coefficients of the least squares fit.
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump...
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an option parameter and a documentation string to the InputParameters object...
static InputParameters validParams()
VectorPostprocessorValue * _times
Vector of times.
void ErrorVector unsigned int
virtual void initialize() override
Initialize, clears old results.
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
This method takes a space delimited list of parameter names and adds them to the specified group name...