LinearInterpolation Class Reference

This class interpolates values given a set of data pairs and an abscissa. More...

#include <LinearInterpolation.h>

Inheritance diagram for LinearInterpolation:

Public Member Functions
	LinearInterpolation (const std::vector< Real > &X, const std::vector< Real > &Y, const bool extrap=false)
	LinearInterpolation ()
virtual	~LinearInterpolation ()=default
void	setData (const std::vector< Real > &X, const std::vector< Real > &Y)
	Set the x and y values.
void	errorCheck ()
template<typename T >
T	sample (const T &x) const
	This function will take an independent variable input and will return the dependent variable based on the generated fit.
template<typename T >
T	sampleDerivative (const T &x) const
	This function will take an independent variable input and will return the derivative of the dependent variable with respect to the independent variable based on the generated fit.
unsigned int	getSampleSize () const
	This function returns the size of the array holding the points, i.e.
Real	integrate ()
	This function returns the integral of the function over the whole domain.
template<typename T >
T	integratePartial (const T &x1, const T &x2) const
	Returns the integral of the function over a specified domain.
Real	domain (int i) const
Real	range (int i) const

Private Attributes
std::vector< Real >	_x
std::vector< Real >	_y
bool	_extrap

Detailed Description

This class interpolates values given a set of data pairs and an abscissa.

Definition at line 21 of file LinearInterpolation.h.

Constructor & Destructor Documentation

LinearInterpolation() [1/2]

LinearInterpolation::LinearInterpolation	(	const std::vector< Real > &	X,
		const std::vector< Real > &	Y,
		const bool	extrap = false
	)

Definition at line 19 of file LinearInterpolation.C.

  : _x(x), _y(y), _extrap(extrap)
{
  errorCheck();
}

LinearInterpolation() [2/2]

LinearInterpolation::LinearInterpolation ( )

inline

Definition at line 31 of file LinearInterpolation.h.

: _x(std::vector<Real>()), _y(std::vector<Real>()), _extrap(false) {}

~LinearInterpolation()

virtual LinearInterpolation::~LinearInterpolation ( )

virtualdefault

Member Function Documentation

domain()

Real LinearInterpolation::domain

(

int

i

)

const

Definition at line 271 of file LinearInterpolation.C.

{
  return _x[i];
}

errorCheck()

void LinearInterpolation::errorCheck

(

)

Definition at line 28 of file LinearInterpolation.C.

{
  if (_x.size() != _y.size())
    throw std::domain_error("Vectors are not the same length");
 
  for (unsigned int i = 0; i + 1 < _x.size(); ++i)
    if (_x[i] >= _x[i + 1])
    {
      std::ostringstream oss;
      oss << "x-values are not strictly increasing: x[" << i << "]: " << _x[i] << " x[" << i + 1
          << "]: " << _x[i + 1];
      throw std::domain_error(oss.str());
    }
}

Referenced by LinearInterpolation(), and setData().

getSampleSize()

unsigned int LinearInterpolation::getSampleSize

(

)

const

This function returns the size of the array holding the points, i.e.

the number of sample points

Definition at line 283 of file LinearInterpolation.C.

{
  return _x.size();
}

integrate()

Real LinearInterpolation::integrate

(

)

This function returns the integral of the function over the whole domain.

Definition at line 123 of file LinearInterpolation.C.

{
  Real answer = 0;
  for (unsigned int i = 1; i < _x.size(); ++i)
    answer += 0.5 * (_y[i] + _y[i - 1]) * (_x[i] - _x[i - 1]);
 
  return answer;
}

integratePartial()

template<typename T >

template ADReal LinearInterpolation::integratePartial	(	const T &	x1,
		const T &	x2
	)		const

Returns the integral of the function over a specified domain.

Parameters

[in]	x1	First point in integral domain
[in]	x2	Second point in integral domain

Definition at line 134 of file LinearInterpolation.C.

{
  // integral computation below will assume that x2 > x1; if this is not the
  // case, compute as if it is and then use identity to convert
  const T *x1_ptr, *x2_ptr;
  bool switch_bounds;
  const Real rawA = MetaPhysicL::raw_value(xA), rawB = MetaPhysicL::raw_value(xB);
  Real raw1, raw2;
  if (MooseUtils::absoluteFuzzyEqual(rawA, rawB))
    return 0.0;
  else if (rawB > rawA)
  {
    x1_ptr = &xA;
    x2_ptr = &xB;
    raw1 = rawA;
    raw2 = rawB;
    switch_bounds = false;
  }
  else
  {
    x1_ptr = &xB;
    x2_ptr = &xA;
    raw1 = rawB;
    raw2 = rawA;
    switch_bounds = true;
  }
  const auto & x1 = *x1_ptr;
  const auto & x2 = *x2_ptr;
 
  // compute integral with knowledge that x2 > x1
  T integral = 0.0;
  // find minimum i : x[i] > x; if x > x[n-1], i = n
  const auto n = _x.size();
  const unsigned int i1 =
      raw1 <= _x[n - 1] ? std::distance(_x.begin(), std::upper_bound(_x.begin(), _x.end(), raw1))
                        : n;
  const unsigned int i2 =
      raw2 <= _x[n - 1] ? std::distance(_x.begin(), std::upper_bound(_x.begin(), _x.end(), raw2))
                        : n;
  unsigned int i = i1;
  while (i <= i2)
  {
    if (i == 0)
    {
      // note i1 = i
      T integral1, integral2;
      if (_extrap)
      {
        const auto dydx = (_y[1] - _y[0]) / (_x[1] - _x[0]);
        const auto y1 = _y[0] + dydx * (x1 - _x[0]);
        integral1 = 0.5 * (y1 + _y[0]) * (_x[0] - x1);
        if (i2 == i)
        {
          const auto y2 = _y[0] + dydx * (x2 - _x[0]);
          integral2 = 0.5 * (y2 + _y[0]) * (_x[0] - x2);
        }
        else
          integral2 = 0.0;
      }
      else
      {
        integral1 = _y[0] * (_x[0] - x1);
        if (i2 == i)
          integral2 = _y[0] * (_x[0] - x2);
        else
          integral2 = 0.0;
      }
 
      integral += integral1 - integral2;
    }
    else if (i == n)
    {
      // note i2 = i
      T integral1, integral2;
      if (_extrap)
      {
        const auto dydx = (_y[n - 1] - _y[n - 2]) / (_x[n - 1] - _x[n - 2]);
        const auto y2 = _y[n - 1] + dydx * (x2 - _x[n - 1]);
        integral2 = 0.5 * (y2 + _y[n - 1]) * (x2 - _x[n - 1]);
        if (i1 == n)
        {
          const auto y1 = _y[n - 1] + dydx * (x1 - _x[n - 1]);
          integral1 = 0.5 * (y1 + _y[n - 1]) * (x1 - _x[n - 1]);
        }
        else
          integral1 = 0.0;
      }
      else
      {
        integral2 = _y[n - 1] * (x2 - _x[n - 1]);
        if (i1 == n)
          integral1 = _y[n - 1] * (x1 - _x[n - 1]);
        else
          integral1 = 0.0;
      }
 
      integral += integral2 - integral1;
    }
    else
    {
      T integral1;
      if (i == i1)
      {
        const auto dydx = (_y[i] - _y[i - 1]) / (_x[i] - _x[i - 1]);
        const auto y1 = _y[i - 1] + dydx * (x1 - _x[i - 1]);
        integral1 = 0.5 * (y1 + _y[i - 1]) * (x1 - _x[i - 1]);
      }
      else
        integral1 = 0.0;
 
      T integral2;
      if (i == i2)
      {
        const auto dydx = (_y[i] - _y[i - 1]) / (_x[i] - _x[i - 1]);
        const auto y2 = _y[i - 1] + dydx * (x2 - _x[i - 1]);
        integral2 = 0.5 * (y2 + _y[i - 1]) * (x2 - _x[i - 1]);
      }
      else
        integral2 = 0.5 * (_y[i] + _y[i - 1]) * (_x[i] - _x[i - 1]);
 
      integral += integral2 - integral1;
    }
 
    i++;
  }
 
  // apply identity if bounds were switched
  if (switch_bounds)
    return -1.0 * integral;
  else
    return integral;
}

range()

Real LinearInterpolation::range

(

int

i

)

const

Definition at line 277 of file LinearInterpolation.C.

{
  return _y[i];
}

sample()

template<typename T >

template ChainedReal LinearInterpolation::sample< ChainedReal >

(

const T &

x

)

const

This function will take an independent variable input and will return the dependent variable based on the generated fit.

Definition at line 45 of file LinearInterpolation.C.

{
  // this is a hard error
  if (_x.empty())
    mooseError("Trying to evaluate an empty LinearInterpolation");
 
  // special case for single function nodes
  if (_x.size() == 1)
    return _y[0];
 
  // endpoint cases
  if (_extrap)
  {
    if (x < _x[0])
      return _y[0] + (x - _x[0]) / (_x[1] - _x[0]) * (_y[1] - _y[0]);
    if (x >= _x.back())
      return _y.back() +
             (x - _x.back()) / (_x[_x.size() - 2] - _x.back()) * (_y[_y.size() - 2] - _y.back());
  }
  else
  {
    if (x < _x[0])
      return _y[0];
    if (x >= _x.back())
      return _y.back();
  }
 
  auto upper = std::upper_bound(_x.begin(), _x.end(), x);
  const auto i = cast_int<std::size_t>(std::distance(_x.begin(), upper) - 1);
  if (i == cast_int<std::size_t>(_x.size() - 1))
    // std::upper_bound returns the end() iterator if there are no elements that are
    // an upper bound to the value. Since x >= _x.back() has already returned above,
    // this means x is a NaN, so we return a NaN here.
    return std::nan("");
  else
    return _y[i] + (_y[i + 1] - _y[i]) * (x - _x[i]) / (_x[i + 1] - _x[i]);
}

Referenced by IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeInitialDT(), and IterationAdaptiveDT::computeInterpolationDT().

sampleDerivative()

template<typename T >

template ChainedReal LinearInterpolation::sampleDerivative< ChainedReal >

(

const T &

x

)

const

This function will take an independent variable input and will return the derivative of the dependent variable with respect to the independent variable based on the generated fit.

Definition at line 89 of file LinearInterpolation.C.

{
  // endpoint cases
  if (_extrap)
  {
    if (x <= _x[0])
      return (_y[1] - _y[0]) / (_x[1] - _x[0]);
    if (x >= _x.back())
      return (_y[_y.size() - 2] - _y.back()) / (_x[_x.size() - 2] - _x.back());
  }
  else
  {
    if (x < _x[0])
      return 0.0;
    if (x >= _x.back())
      return 0.0;
  }
 
  auto upper = std::upper_bound(_x.begin(), _x.end(), x);
  const auto i = cast_int<std::size_t>(std::distance(_x.begin(), upper) - 1);
  if (i == cast_int<std::size_t>(_x.size() - 1))
    // std::upper_bound returns the end() iterator if there are no elements that are
    // an upper bound to the value. Since x >= _x.back() has already returned above,
    // this means x is a NaN, so we return a NaN here.
    return std::nan("");
  else
    return (_y[i + 1] - _y[i]) / (_x[i + 1] - _x[i]);
}

setData()

void LinearInterpolation::setData ( const std::vector< Real > &  X, const std::vector< Real > &  Y  )

inline

Set the x and y values.

Definition at line 38 of file LinearInterpolation.h.

  {
    _x = X;
    _y = Y;
    errorCheck();
  }

Member Data Documentation

_extrap

bool LinearInterpolation::_extrap

private

Definition at line 89 of file LinearInterpolation.h.

Referenced by integratePartial(), sample(), and sampleDerivative().

_x

std::vector<Real> LinearInterpolation::_x

private

Definition at line 86 of file LinearInterpolation.h.

Referenced by domain(), errorCheck(), getSampleSize(), integrate(), integratePartial(), sample(), sampleDerivative(), and setData().

_y

std::vector<Real> LinearInterpolation::_y

private

Definition at line 87 of file LinearInterpolation.h.

Referenced by errorCheck(), integrate(), integratePartial(), range(), sample(), sampleDerivative(), and setData().

---

The documentation for this class was generated from the following files:

• include/utils/LinearInterpolation.h
• src/utils/LinearInterpolation.C