Line data    Source code

       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 "PiecewiseMulticonstant.h"
      11             : #include "GriddedData.h"
      12             : 
      13             : registerMooseObject("MooseApp", PiecewiseMulticonstant);
      14             : registerMooseObjectAliased("MooseApp", PiecewiseMulticonstant, "PiecewiseMultiConstant");
      15             : 
      16             : InputParameters
      17       28555 : PiecewiseMulticonstant::validParams()
      18             : {
      19       28555 :   InputParameters params = PiecewiseMultiInterpolation::validParams();
      20             : 
      21       28555 :   MultiMooseEnum direction("left=0 right=1");
      22       28555 :   params.addParam<MultiMooseEnum>(
      23             :       "direction", direction, "Direction to look to find value for each interpolation dimension.");
      24             : 
      25       28555 :   params.addClassDescription(
      26             :       "PiecewiseMulticonstant performs constant interpolation on 1D, 2D, 3D or 4D "
      27             :       "data.  The data_file specifies the axes directions and the function "
      28             :       "values.  If a point lies outside the data range, the appropriate end "
      29             :       "value is used.");
      30       57110 :   return params;
      31       28555 : }
      32             : 
      33          13 : PiecewiseMulticonstant::PiecewiseMulticonstant(const InputParameters & parameters)
      34          13 :   : PiecewiseMultiInterpolation(parameters), _direction(getParam<MultiMooseEnum>("direction"))
      35             : {
      36          13 :   if (_direction.size() != _dim)
      37           0 :     mooseError("Parameter direction must have a size identical to ", _dim);
      38          13 : }
      39             : 
      40             : ADReal
      41           0 : PiecewiseMulticonstant::value(const ADReal & t, const ADPoint & p) const
      42             : {
      43             :   // piecewise constant derivatives are zero everywhere (ignore discontinuities)
      44           0 :   return value(MetaPhysicL::raw_value(t), MetaPhysicL::raw_value(p));
      45             : }
      46             : 
      47             : Real
      48        1024 : PiecewiseMulticonstant::sample(const GridPoint & pt) const
      49             : {
      50        1024 :   GridIndex left(_dim);
      51        1024 :   GridIndex right(_dim);
      52        1024 :   GridIndex arg(_dim);
      53        3072 :   for (unsigned int i = 0; i < _dim; ++i)
      54             :   {
      55        2048 :     getNeighborIndices(_grid[i], pt[i], left[i], right[i]);
      56        2048 :     if (_direction.get(i) == 0)
      57        1024 :       arg[i] = left[i];
      58             :     else
      59        1024 :       arg[i] = right[i];
      60             :   }
      61             : 
      62             :   // return the point
      63        2048 :   return _gridded_data->evaluateFcn(arg);
      64             : }
      65             : 
      66             : RealGradient
      67           0 : PiecewiseMulticonstant::gradient(Real, const Point &) const
      68             : {
      69           0 :   return 0.0;
      70             : }
      71             : 
      72             : Real
      73           0 : PiecewiseMulticonstant::timeDerivative(Real, const Point &) const
      74             : {
      75           0 :   return 0.0;
      76             : }