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 "PiecewiseLinearBase.h"
      11             : 
      12             : InputParameters
      13       60037 : PiecewiseLinearBase::validParams()
      14             : {
      15       60037 :   InputParameters params = PiecewiseTabularBase::validParams();
      16       60037 :   params.addClassDescription("Linearly interpolates between pairs of x-y data");
      17       60037 :   return params;
      18           0 : }
      19             : 
      20        1579 : PiecewiseLinearBase::PiecewiseLinearBase(const InputParameters & parameters)
      21        1579 :   : PiecewiseTabularBase(parameters), _linear_interp(nullptr), _interpolation_created(false)
      22             : {
      23        1515 : }
      24             : 
      25             : void
      26          13 : PiecewiseLinearBase::initialSetup()
      27             : {
      28          13 :   if (!_linear_interp)
      29           0 :     mooseError("Classes derived from PiecewiseLinearBase need to call buildInterpolation()");
      30          13 : }
      31             : 
      32             : void
      33        1515 : PiecewiseLinearBase::buildInterpolation(const bool extrap)
      34             : {
      35             :   // try building a linear interpolation object
      36             :   try
      37             :   {
      38        1515 :     _linear_interp = std::make_unique<LinearInterpolation>(_raw_x, _raw_y, extrap);
      39             :   }
      40           0 :   catch (std::domain_error & e)
      41             :   {
      42           0 :     mooseError("In PiecewiseLinearBase ", _name, ": ", e.what());
      43           0 :   }
      44        1515 : }
      45             : 
      46             : Real
      47      638179 : PiecewiseLinearBase::value(Real t, const Point & p) const
      48             : {
      49      638179 :   const auto x = _has_axis ? p(_axis) : t;
      50      638179 :   return _scale_factor * _linear_interp->sample(x);
      51             : }
      52             : 
      53             : ADReal
      54           0 : PiecewiseLinearBase::value(const ADReal & t, const ADPoint & p) const
      55             : {
      56           0 :   const auto x = _has_axis ? p(_axis) : t;
      57           0 :   return _scale_factor * _linear_interp->sample(x);
      58           0 : }
      59             : 
      60             : Real
      61         576 : PiecewiseLinearBase::timeDerivative(Real t, const Point &) const
      62             : {
      63         576 :   return _has_axis ? 0.0 : _scale_factor * _linear_interp->sampleDerivative(t);
      64             : }
      65             : 
      66             : RealGradient
      67           0 : PiecewiseLinearBase::gradient(Real, const Point & p) const
      68             : {
      69           0 :   RealGradient ret;
      70           0 :   if (_has_axis)
      71           0 :     ret(_axis) = _scale_factor * _linear_interp->sampleDerivative(p(_axis));
      72           0 :   return ret;
      73             : }
      74             : 
      75             : Real
      76           0 : PiecewiseLinearBase::integral() const
      77             : {
      78           0 :   return _scale_factor * _linear_interp->integrate();
      79             : }
      80             : 
      81             : Real
      82           0 : PiecewiseLinearBase::average() const
      83             : {
      84           0 :   return integral() /
      85           0 :          (_linear_interp->domain(_linear_interp->getSampleSize() - 1) - _linear_interp->domain(0));
      86             : }
      87             : 
      88             : Real
      89           6 : PiecewiseLinearBase::timeIntegral(Real t1, Real t2, const Point & p) const
      90             : {
      91           6 :   if (_has_axis)
      92             :     // function is constant in time; evaluate at arbitrary point in time
      93             :     // and multiply by time integral domain width
      94           1 :     return value(t1, p) * (t2 - t1);
      95             :   else
      96             :     // function is piecewise linear in time
      97           5 :     return _scale_factor * _linear_interp->integratePartial(t1, t2);
      98             : }
      99             : 
     100             : void
     101          13 : PiecewiseLinearBase::setData(const std::vector<Real> & x, const std::vector<Real> & y)
     102             : {
     103          13 :   PiecewiseTabularBase::setData(x, y);
     104          13 :   buildInterpolation();
     105          13 : }