https://mooseframework.inl.gov
PiecewiseMultiInterpolation.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
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 "MooseUtils.h"
12 #include "GriddedData.h"
13 
16 {
18  params.addParam<FileName>(
19  "data_file",
20  "File holding data for use with PiecewiseMultiInterpolation. Format: any empty line and any "
21  "line "
22  "beginning with # are ignored, all other lines are assumed to contain relevant information. "
23  "The file must begin with specification of the grid. This is done through lines containing "
24  "the keywords: AXIS X; AXIS Y; AXIS Z; or AXIS T. Immediately following the keyword line "
25  "must be a space-separated line of real numbers which define the grid along the specified "
26  "axis. These data must be monotonically increasing. After all the axes and their grids "
27  "have been specified, there must be a line that is DATA. Following that line, function "
28  "values are given in the correct order (they may be on individual lines, or be "
29  "space-separated on a number of lines). When the function is evaluated, f[i,j,k,l] "
30  "corresponds to the i + j*Ni + k*Ni*Nj + l*Ni*Nj*Nk data value. Here i>=0 corresponding to "
31  "the index along the first AXIS, j>=0 corresponding to the index along the second AXIS, etc, "
32  "and Ni = number of grid points along the first AXIS, etc.");
33  return params;
34 }
35 
37  : Function(parameters),
38  _gridded_data(std::make_unique<GriddedData>(getParam<FileName>("data_file"))),
39  _dim(_gridded_data->getDim())
40 {
41  _gridded_data->getAxes(_axes);
42  _gridded_data->getGrid(_grid);
43 
44  // GriddedData does not require monotonicity of axes, but we do
45  for (unsigned int i = 0; i < _dim; ++i)
46  for (unsigned int j = 1; j < _grid[i].size(); ++j)
47  if (_grid[i][j - 1] >= _grid[i][j])
48  mooseError("PiecewiseMultiInterpolation needs monotonically-increasing axis data. Axis ",
49  i,
50  " contains non-monotonicity at value ",
51  _grid[i][j]);
52 
53  // GriddedData does not demand that each axis is independent, but we do
54  std::set<int> s(_axes.begin(), _axes.end());
55  if (s.size() != _dim)
56  mooseError(
57  "PiecewiseMultiInterpolation needs the AXES to be independent. Check the AXIS lines in "
58  "your data file.");
59 }
60 
62 
63 template <bool is_ad>
66  const Moose::GenericType<Point, is_ad> & p) const
67 {
68  // convert the inputs to an input to the sample function using _axes
70  for (unsigned int i = 0; i < _dim; ++i)
71  {
72  if (_axes[i] < 3)
73  point_in_grid[i] = p(_axes[i]);
74  else if (_axes[i] == 3) // the time direction
75  point_in_grid[i] = t;
76  }
77  return point_in_grid;
78 }
79 
81 PiecewiseMultiInterpolation::pointInGrid<false>(const Real &, const Point &) const;
83 PiecewiseMultiInterpolation::pointInGrid<true>(const ADReal &, const ADPoint &) const;
84 
85 Real
86 PiecewiseMultiInterpolation::value(Real t, const Point & p) const
87 {
88  return sample(pointInGrid<false>(t, p));
89 }
90 
91 ADReal
93 {
94  return sample(pointInGrid<true>(t, p));
95 }
96 
97 ADReal
99 {
100  mooseError("The AD variant of 'sample' needs to be implemented");
101 }
102 
103 void
105  Real x,
106  unsigned int & lower_x,
107  unsigned int & upper_x) const
108 {
109  int N = in_arr.size();
110  if (x <= in_arr[0])
111  {
112  lower_x = 0;
113  upper_x = 0;
114  }
115  else if (x >= in_arr[N - 1])
116  {
117  lower_x = N - 1;
118  upper_x = N - 1;
119  }
120  else
121  {
122  // returns up which points at the first element in inArr that is not less than x
123  std::vector<double>::iterator up = std::lower_bound(in_arr.begin(), in_arr.end(), x);
124 
125  // std::distance returns std::difference_type, which can be negative in theory, but
126  // in this context will always be >=0. Therefore the explicit cast is just to shut
127  // the compiler up.
128  upper_x = static_cast<unsigned int>(std::distance(in_arr.begin(), up));
129  if (in_arr[upper_x] == x)
130  lower_x = upper_x;
131  else
132  lower_x = upper_x - 1;
133  }
134 }
Container for holding a function defined on a grid of arbitrary dimension.
Definition: GriddedData.h:32
Base class for function objects.
Definition: Function.h:36
static InputParameters validParams()
Create new PiecewiseMultiInterpolation object.
std::unique_ptr< GriddedData > _gridded_data
object to provide function evaluations at points on the grid
std::vector< std::vector< Real > > _grid
the grid
Moose::GenericType< GridPoint, is_ad > pointInGrid(const Moose::GenericType< Real, is_ad > &t, const Moose::GenericType< Point, is_ad > &p) const
convert cartesian+time coordinates into grid coordinates
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
DualNumber< Real, DNDerivativeType, true > ADReal
Definition: ADRealForward.h:46
typename std::conditional< is_ad, typename ADType< T >::type, T >::type GenericType
Definition: MooseTypes.h:644
Utility class template for a semidynamic vector with a maximum size N and a chosen dynamic size...
Definition: MooseUtils.h:1096
void getNeighborIndices(std::vector< Real > in_arr, Real x, unsigned int &lower_x, unsigned int &upper_x) const
Operates on monotonically increasing in_arr.
std::vector< int > _axes
_axes specifies how to embed the grid into the MOOSE coordinate frame if _axes[i] = 0 then the i_th a...
unsigned int _dim
dimension of the grid
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
PiecewiseMultiInterpolation(const InputParameters &parameters)
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
virtual Real value(Real t, const Point &pt) const override
Given t and p, return the interpolated value.
virtual Real sample(const GridPoint &pt) const =0
This does the core work.
static InputParameters validParams()
Class constructor.
Definition: Function.C:16