This class interpolates tabulated data with a bicubic function. More...

#include <BicubicInterpolation.h>

Inheritance diagram for BicubicInterpolation:

Public Member Functions
	BicubicInterpolation (const std::vector< Real > &x1, const std::vector< Real > &x2, const std::vector< std::vector< Real > > &y)

virtual	~BicubicInterpolation ()=default

void	errorCheck ()
	Sanity checks on input data.

Real	sample (const Real x1, const Real x2) const override
	Samples value at point (x1, x2)

ADReal	sample (const ADReal &x1, const ADReal &x2) const override

ChainedReal	sample (const ChainedReal &x1, const ChainedReal &x2) const override

virtual void	sampleValueAndDerivatives (Real x1, Real x2, Real &y, Real &dy1, Real &dy2) const override
	Samples value and first derivatives at point (x1, x2) Use this function for speed when computing both value and derivatives, as it minimizes the amount of time spent locating the point in the tabulated data.

virtual void	sampleValueAndDerivatives (const ADReal &x1, const ADReal &x2, ADReal &y, ADReal &dy1, ADReal &dy2) const override

virtual void	sampleValueAndDerivatives (const ChainedReal &x1, const ChainedReal &x2, ChainedReal &y, ChainedReal &dy1, ChainedReal &dy2) const override

Real	sampleDerivative (Real x1, Real x2, unsigned int deriv_var) const override
	Samples first derivative at point (x1, x2)

Real	sample2ndDerivative (Real x1, Real x2, unsigned int deriv_var) const override
	Samples second derivative at point (x1, x2)

void	precomputeCoefficients ()
	Precompute all of the coefficients for the bicubic interpolation to avoid calculating them repeatedly.

virtual void	sampleValueAndDerivatives (Real, Real, Real &, Real &, Real &) const
	Samples value and first derivatives at point (x1, x2) Use this function for speed when computing both value and derivatives, as it minimizes the amount of time spent locating the point in the tabulated data.

virtual void	sampleValueAndDerivatives (const ADReal &, const ADReal &, ADReal &, ADReal &, ADReal &) const
	Samples value and first derivatives at point (x1, x2) Use this function for speed when computing both value and derivatives, as it minimizes the amount of time spent locating the point in the tabulated data.

virtual void	sampleValueAndDerivatives (const ChainedReal &, const ChainedReal &, ChainedReal &, ChainedReal &, ChainedReal &) const
	Samples value and first derivatives at point (x1, x2) Use this function for speed when computing both value and derivatives, as it minimizes the amount of time spent locating the point in the tabulated data.

virtual Real	sampleDerivative (const Real, const Real, unsigned int) const
	Samples first derivative at point (x1, x2)

virtual ADReal	sampleDerivative (const ADReal &, const ADReal &, unsigned int) const
	Samples first derivative at point (x1, x2)

virtual ChainedReal	sampleDerivative (const ChainedReal &, const ChainedReal &, unsigned int) const
	Samples first derivative at point (x1, x2)

Public Attributes
std::vector< Real >	_x1
	Independent values in the x1 direction.

std::vector< Real >	_x2
	Independent values in the x2 direction.

Protected Member Functions
template<typename T >
void	findInterval (const std::vector< Real > &x, const T &xi, unsigned int &klo, unsigned int &khi, T &xs) const
	Find the indices of the dependent values axis which bracket the point xi.

template<typename T >
T	sampleInternal (const T &x1, const T &x2) const

template<typename T >
void	sampleValueAndDerivativesInternal (T x1, T x2, T &y, T &dy1, T &dy2) const

void	tableDerivatives (std::vector< std::vector< Real > > &dy_dx1, std::vector< std::vector< Real > > &dy_dx2, std::vector< std::vector< Real > > &d2y_dx1x2)
	Provides the values of the first derivatives in each direction at all points in the table of data, as well as the mixed second derivative.

Protected Attributes
std::vector< std::vector< Real > >	_y
	The dependent values at (x1, x2) points.

std::vector< std::vector< std::vector< std::vector< Real > > > >	_bicubic_coeffs
	Matrix of precomputed coefficients There are four coefficients in each direction at each dependent value.

const std::vector< std::vector< int > >	_wt
	Matrix used to calculate bicubic interpolation coefficients (from Numerical Recipes)

Detailed Description

This class interpolates tabulated data with a bicubic function.

In order to minimize the computational expense of each sample, the coefficients at each point in the tabulated data are computed once in advance, and then accessed during the interpolation.

As a result, this bicubic interpolation can be much faster than the bicubic spline interpolation method in BicubicSplineInterpolation.

Adapted from Numerical Recipes in C (section 3.6). The terminology used is consistent with that used in Numerical Recipes, where moving over a column corresponds to moving over the x1 coord. Likewise, moving over a row means moving over the x2 coord.

Definition at line 29 of file BicubicInterpolation.h.

Constructor & Destructor Documentation

◆ BicubicInterpolation()

BicubicInterpolation::BicubicInterpolation	(	const std::vector< Real > &	x1,
		const std::vector< Real > &	x2,
		const std::vector< std::vector< Real > > &	y
	)

Definition at line 17 of file BicubicInterpolation.C.

  : BidimensionalInterpolation(x1, x2), _y(y)
{
  errorCheck();
 
  auto m = _x1.size();
  auto n = _x2.size();
 
  _bicubic_coeffs.resize(m - 1);
  for (const auto i : index_range(_bicubic_coeffs))
  {
    _bicubic_coeffs[i].resize(n - 1);
    for (const auto j : index_range(_bicubic_coeffs[i]))
    {
      _bicubic_coeffs[i][j].resize(4);
      for (const auto k : make_range(4))
        _bicubic_coeffs[i][j][k].resize(4);
    }
  }
 
  // Precompute the coefficients
  precomputeCoefficients();
}

◆ ~BicubicInterpolation()

virtual BicubicInterpolation::~BicubicInterpolation ( )

virtualdefault

Member Function Documentation

◆ errorCheck()

void BicubicInterpolation::errorCheck ( )

Sanity checks on input data.

Definition at line 425 of file BicubicInterpolation.C.

{
  auto m = _x1.size(), n = _x2.size();
 
  if (_y.size() != m)
    mooseError("y row dimension does not match the size of x1 in BicubicInterpolation");
  else
    for (const auto i : index_range(_y))
      if (_y[i].size() != n)
        mooseError("y column dimension does not match the size of x2 in BicubicInterpolation");
}

Referenced by BicubicInterpolation().

◆ findInterval()

template<typename T >

template void BicubicInterpolation::findInterval	(	const std::vector< Real > &	x,
		const T &	xi,
		unsigned int &	klo,
		unsigned int &	khi,
		T &	xs
	)		const

protected

Find the indices of the dependent values axis which bracket the point xi.

Definition at line 387 of file BicubicInterpolation.C.

{
  // Find the indices that bracket the point xi
  klo = 0;
  mooseAssert(x.size() >= 2,
              "There must be at least two points in the table in BicubicInterpolation");
 
  khi = x.size() - 1;
  while (khi - klo > 1)
  {
    unsigned int kmid = (khi + klo) / 2;
    if (x[kmid] > xi)
      khi = kmid;
    else
      klo = kmid;
  }
 
  // Now find the scaled position, normalized to [0,1]
  Real d = x[khi] - x[klo];
  xs = xi - x[klo];
 
  if (!MooseUtils::absoluteFuzzyEqual(d, Real(0.0)))
    xs /= d;
}

Referenced by sample2ndDerivative(), sampleDerivative(), sampleInternal(), and sampleValueAndDerivativesInternal().

◆ precomputeCoefficients()

void BicubicInterpolation::precomputeCoefficients ( )

Precompute all of the coefficients for the bicubic interpolation to avoid calculating them repeatedly.

Definition at line 256 of file BicubicInterpolation.C.

{
  // Calculate the first derivatives in each direction at each point, and the
  // mixed second derivative
  std::vector<std::vector<Real>> dy_dx1, dy_dx2, d2y_dx1x2;
  tableDerivatives(dy_dx1, dy_dx2, d2y_dx1x2);
 
  // Now solve for the coefficients at each point in the grid
  for (const auto i : index_range(_bicubic_coeffs))
    for (const auto j : index_range(_bicubic_coeffs[i]))
    {
      // Distance between corner points in each direction
      const Real d1 = _x1[i + 1] - _x1[i];
      const Real d2 = _x2[j + 1] - _x2[j];
 
      // Values of function and derivatives of the four corner points
      std::vector<Real> y = {_y[i][j], _y[i + 1][j], _y[i + 1][j + 1], _y[i][j + 1]};
      std::vector<Real> y1 = {
          dy_dx1[i][j], dy_dx1[i + 1][j], dy_dx1[i + 1][j + 1], dy_dx1[i][j + 1]};
      std::vector<Real> y2 = {
          dy_dx2[i][j], dy_dx2[i + 1][j], dy_dx2[i + 1][j + 1], dy_dx2[i][j + 1]};
      std::vector<Real> y12 = {
          d2y_dx1x2[i][j], d2y_dx1x2[i + 1][j], d2y_dx1x2[i + 1][j + 1], d2y_dx1x2[i][j + 1]};
 
      std::vector<Real> cl(16), x(16);
      Real xx;
      unsigned int count = 0;
 
      // Temporary vector used in the matrix multiplication
      for (const auto k : make_range(4))
      {
        x[k] = y[k];
        x[k + 4] = y1[k] * d1;
        x[k + 8] = y2[k] * d2;
        x[k + 12] = y12[k] * d1 * d2;
      }
 
      // Multiply by the matrix of constants
      for (const auto k : make_range(16))
      {
        xx = 0.0;
        for (const auto q : make_range(16))
          xx += _wt[k][q] * x[q];
 
        cl[k] = xx;
      }
 
      // Unpack results into coefficient table
      for (const auto k : make_range(4))
        for (const auto q : make_range(4))
        {
          _bicubic_coeffs[i][j][k][q] = cl[count];
          count++;
        }
    }
}

Referenced by BicubicInterpolation().

◆ sample() [1/3]

ADReal BicubicInterpolation::sample	(	const ADReal &	x1,
		const ADReal &	x2
	)		const

overridevirtual

Implements BidimensionalInterpolation.

Definition at line 50 of file BicubicInterpolation.C.

{
  return sampleInternal(x1, x2);
}

◆ sample() [2/3]

ChainedReal BicubicInterpolation::sample	(	const ChainedReal &	x1,
		const ChainedReal &	x2
	)		const

overridevirtual

Implements BidimensionalInterpolation.

Definition at line 56 of file BicubicInterpolation.C.

{
  return sampleInternal(x1, x2);
}

◆ sample() [3/3]

Real BicubicInterpolation::sample	(	const Real	x1,
		const Real	x2
	)		const

overridevirtual

Samples value at point (x1, x2)

Implements BidimensionalInterpolation.

Definition at line 44 of file BicubicInterpolation.C.

{
  return sampleInternal(x1, x2);
}

Referenced by sampleInternal().

◆ sample2ndDerivative()

Real BicubicInterpolation::sample2ndDerivative	(	Real	x1,
		Real	x2,
		unsigned int	deriv_var
	)		const

overridevirtual

Samples second derivative at point (x1, x2)

Reimplemented from BidimensionalInterpolation.

Definition at line 128 of file BicubicInterpolation.C.

{
  unsigned int x1l, x1u, x2l, x2u;
  Real t, u;
  findInterval(_x1, x1, x1l, x1u, t);
  findInterval(_x2, x2, x2l, x2u, u);
 
  // Take derivative along x1 axis
  // Note: sum from i = 2 as the first two terms are zero
  if (deriv_var == 1)
  {
    Real sample_deriv = 0.0;
    for (const auto i : make_range(2, 4))
      for (const auto j : make_range(4))
        sample_deriv += i * (i - 1) * _bicubic_coeffs[x1l][x2l][i][j] * MathUtils::pow(t, i - 2) *
                        MathUtils::pow(u, j);
 
    Real d = _x1[x1u] - _x1[x1l];
 
    if (!MooseUtils::absoluteFuzzyEqual(d, Real(0.0)))
      sample_deriv /= (d * d);
 
    return sample_deriv;
  }
 
  // Take derivative along x2 axis
  // Note: sum from j = 2 as the first two terms are zero
  else if (deriv_var == 2)
  {
    Real sample_deriv = 0.0;
    for (const auto i : make_range(4))
      for (const auto j : make_range(2, 4))
        sample_deriv += j * (j - 1) * _bicubic_coeffs[x1l][x2l][i][j] * MathUtils::pow(t, i) *
                        MathUtils::pow(u, j - 2);
 
    Real d = _x2[x2u] - _x2[x2l];
 
    if (!MooseUtils::absoluteFuzzyEqual(d, Real(0.0)))
      sample_deriv /= (d * d);
 
    return sample_deriv;
  }
 
  // Take mixed derivative along x1 and x2 axes
  // Note: sum from i = 1 and j = 1 as the first terms are zero
  else if (deriv_var == 3)
  {
    Real sample_deriv = 0.0;
    for (const auto i : make_range(1, 4))
      for (const auto j : make_range(1, 4))
        sample_deriv += i * j * _bicubic_coeffs[x1l][x2l][i][j] * MathUtils::pow(t, i - 1) *
                        MathUtils::pow(u, j - 1);
 
    const Real d1 = _x1[x1u] - _x1[x1l];
    const Real d2 = _x2[x2u] - _x2[x2l];
 
    if (!MooseUtils::absoluteFuzzyEqual(d1, Real(0.0)) &&
        !MooseUtils::absoluteFuzzyEqual(d2, Real(0.0)))
      sample_deriv /= (d1 * d2);
 
    return sample_deriv;
  }
 
  else
    mooseError("deriv_var must be either 1, 2 or 3 in BicubicInterpolation");
}

◆ sampleDerivative() [1/4]

virtual ADReal BidimensionalInterpolation::sampleDerivative	(	const ADReal &	,
		const ADReal &	,
		unsigned int
	)		const

inlinevirtual

Samples first derivative at point (x1, x2)

Reimplemented from BidimensionalInterpolation.

Definition at line 57 of file BidimensionalInterpolation.h.

  {
    mooseError(
        "sampleDerivative for ADReal numbers is not implemented for this interpolation class");
  }

◆ sampleDerivative() [2/4]

virtual ChainedReal BidimensionalInterpolation::sampleDerivative	(	const ChainedReal &	,
		const ChainedReal &	,
		unsigned int
	)		const

inlinevirtual

Samples first derivative at point (x1, x2)

Reimplemented from BidimensionalInterpolation.

Definition at line 62 of file BidimensionalInterpolation.h.

  {
    mooseError(
        "sampleDerivative for ChainedReal numbers is not implemented for this interpolation class");
  }

◆ sampleDerivative() [3/4]

virtual Real BidimensionalInterpolation::sampleDerivative	(	const Real	,
		const Real	,
		unsigned int
	)		const

inlinevirtual

Samples first derivative at point (x1, x2)

Reimplemented from BidimensionalInterpolation.

Definition at line 52 of file BidimensionalInterpolation.h.

  {
    mooseError("sampleDerivative for Real numbers is not implemented for this interpolation class");
  }

◆ sampleDerivative() [4/4]

Real BicubicInterpolation::sampleDerivative	(	Real	,
		Real	,
		unsigned int
	)		const

overridevirtual

Samples first derivative at point (x1, x2)

Reimplemented from BidimensionalInterpolation.

Definition at line 79 of file BicubicInterpolation.C.

{
  unsigned int x1l, x1u, x2l, x2u;
  Real t, u;
  findInterval(_x1, x1, x1l, x1u, t);
  findInterval(_x2, x2, x2l, x2u, u);
 
  // Take derivative along x1 axis
  // Note: sum from i = 1 as the first term is zero
  if (deriv_var == 1)
  {
    Real sample_deriv = 0.0;
    for (const auto i : make_range(1, 4))
      for (const auto j : make_range(4))
        sample_deriv +=
            i * _bicubic_coeffs[x1l][x2l][i][j] * MathUtils::pow(t, i - 1) * MathUtils::pow(u, j);
 
    Real d = _x1[x1u] - _x1[x1l];
 
    if (!MooseUtils::absoluteFuzzyEqual(d, 0.0))
      sample_deriv /= d;
 
    return sample_deriv;
  }
 
  // Take derivative along x2 axis
  // Note: sum from j = 1 as the first term is zero
  else if (deriv_var == 2)
  {
    Real sample_deriv = 0.0;
 
    for (const auto i : make_range(4))
      for (const auto j : make_range(1, 4))
        sample_deriv +=
            j * _bicubic_coeffs[x1l][x2l][i][j] * MathUtils::pow(t, i) * MathUtils::pow(u, j - 1);
 
    Real d = _x2[x2u] - _x2[x2l];
 
    if (!MooseUtils::absoluteFuzzyEqual(d, Real(0.0)))
      sample_deriv /= d;
 
    return sample_deriv;
  }
 
  else
    mooseError("deriv_var must be either 1 or 2 in BicubicInterpolation");
}

◆ sampleInternal()

template<typename T >

T BicubicInterpolation::sampleInternal	(	const T &	x1,
		const T &	x2
	)		const

protected

Definition at line 63 of file BicubicInterpolation.C.

{
  unsigned int x1l, x1u, x2l, x2u;
  T t, u;
  findInterval(_x1, x1, x1l, x1u, t);
  findInterval(_x2, x2, x2l, x2u, u);
 
  T sample = 0.0;
  for (const auto i : make_range(4))
    for (const auto j : make_range(4))
      sample += _bicubic_coeffs[x1l][x2l][i][j] * MathUtils::pow(t, i) * MathUtils::pow(u, j);
 
  return sample;
}

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

◆ sampleValueAndDerivatives() [1/6]

virtual void BidimensionalInterpolation::sampleValueAndDerivatives	(	const ADReal &	,
		const ADReal &	,
		ADReal &	,
		ADReal &	,
		ADReal &
	)		const

inlinevirtual

Samples value and first derivatives at point (x1, x2) Use this function for speed when computing both value and derivatives, as it minimizes the amount of time spent locating the point in the tabulated data.

Reimplemented from BidimensionalInterpolation.

Definition at line 90 of file BidimensionalInterpolation.h.

  {
    mooseError("sampleValueAndDerivatives for ADReal numbers is not implemented for this "
               "interpolation class");
  }

◆ sampleValueAndDerivatives() [2/6]

void BicubicInterpolation::sampleValueAndDerivatives	(	const ADReal &	x1,
		const ADReal &	x2,
		ADReal &	y,
		ADReal &	dy1,
		ADReal &	dy2
	)		const

overridevirtual

Reimplemented from BidimensionalInterpolation.

Definition at line 203 of file BicubicInterpolation.C.

{
  sampleValueAndDerivativesInternal(x1, x2, y, dy1, dy2);
}

◆ sampleValueAndDerivatives() [3/6]

virtual void BidimensionalInterpolation::sampleValueAndDerivatives	(	const ChainedReal &	,
		const ChainedReal &	,
		ChainedReal &	,
		ChainedReal &	,
		ChainedReal &
	)		const

inlinevirtual

Samples value and first derivatives at point (x1, x2) Use this function for speed when computing both value and derivatives, as it minimizes the amount of time spent locating the point in the tabulated data.

Reimplemented from BidimensionalInterpolation.

Definition at line 99 of file BidimensionalInterpolation.h.

  {
    mooseError("sampleValueAndDerivatives for ChainedReal numbers is not implemented for this "
               "interpolation class");
  }

◆ sampleValueAndDerivatives() [4/6]

void BicubicInterpolation::sampleValueAndDerivatives	(	const ChainedReal &	x1,
		const ChainedReal &	x2,
		ChainedReal &	y,
		ChainedReal &	dy1,
		ChainedReal &	dy2
	)		const

overridevirtual

Reimplemented from BidimensionalInterpolation.

Definition at line 209 of file BicubicInterpolation.C.

{
  sampleValueAndDerivativesInternal(x1, x2, y, dy1, dy2);
}

◆ sampleValueAndDerivatives() [5/6]

void BicubicInterpolation::sampleValueAndDerivatives	(	Real	,
		Real	,
		Real &	,
		Real &	,
		Real &
	)		const

overridevirtual

Samples value and first derivatives at point (x1, x2) Use this function for speed when computing both value and derivatives, as it minimizes the amount of time spent locating the point in the tabulated data.

Reimplemented from BidimensionalInterpolation.

Definition at line 196 of file BicubicInterpolation.C.

{
  sampleValueAndDerivativesInternal(x1, x2, y, dy1, dy2);
}

◆ sampleValueAndDerivatives() [6/6]

virtual void BidimensionalInterpolation::sampleValueAndDerivatives	(	Real	,
		Real	,
		Real &	,
		Real &	,
		Real &
	)		const

inlinevirtual

Samples value and first derivatives at point (x1, x2) Use this function for speed when computing both value and derivatives, as it minimizes the amount of time spent locating the point in the tabulated data.

Reimplemented from BidimensionalInterpolation.

Definition at line 84 of file BidimensionalInterpolation.h.

  {
    mooseError("sampleValueAndDerivatives for Real numbers is not implemented for this "
               "interpolation class");
  }

◆ sampleValueAndDerivativesInternal()

template<typename T >

void BicubicInterpolation::sampleValueAndDerivativesInternal	(	T	x1,
		T	x2,
		T &	y,
		T &	dy1,
		T &	dy2
	)		const

protected

Definition at line 220 of file BicubicInterpolation.C.

{
  unsigned int x1l, x1u, x2l, x2u;
  T t, u;
  findInterval(_x1, x1, x1l, x1u, t);
  findInterval(_x2, x2, x2l, x2u, u);
 
  y = 0.0;
  for (const auto i : make_range(4))
    for (const auto j : make_range(4))
      y += _bicubic_coeffs[x1l][x2l][i][j] * MathUtils::pow(t, i) * MathUtils::pow(u, j);
 
  // Note: sum from i = 1 as the first term is zero
  dy1 = 0.0;
  for (const auto i : make_range(1, 4))
    for (const auto j : make_range(4))
      dy1 += i * _bicubic_coeffs[x1l][x2l][i][j] * MathUtils::pow(t, i - 1) * MathUtils::pow(u, j);
 
  // Note: sum from j = 1 as the first term is zero
  dy2 = 0.0;
  for (const auto i : make_range(4))
    for (const auto j : make_range(1, 4))
      dy2 += j * _bicubic_coeffs[x1l][x2l][i][j] * MathUtils::pow(t, i) * MathUtils::pow(u, j - 1);
 
  T d1 = _x1[x1u] - _x1[x1l];
 
  if (!MooseUtils::absoluteFuzzyEqual(d1, 0.0))
    dy1 /= d1;
 
  T d2 = _x2[x2u] - _x2[x2l];
 
  if (!MooseUtils::absoluteFuzzyEqual(d2, 0.0))
    dy2 /= d2;
}

Referenced by sampleValueAndDerivatives(), sampleValueAndDerivatives(), and sampleValueAndDerivatives().

◆ tableDerivatives()

void BicubicInterpolation::tableDerivatives	(	std::vector< std::vector< Real > > &	dy_dx1,
		std::vector< std::vector< Real > > &	dy_dx2,
		std::vector< std::vector< Real > > &	d2y_dx1x2
	)

protected

Provides the values of the first derivatives in each direction at all points in the table of data, as well as the mixed second derivative.

This is implemented using finite differencing, but could be supplied through other means (such as by sampling with cubic splines)

Definition at line 314 of file BicubicInterpolation.C.

{
  const auto m = _x1.size();
  const auto n = _x2.size();
  dy_dx1.resize(m);
  dy_dx2.resize(m);
  d2y_dx1x2.resize(m);
 
  for (const auto i : make_range(m))
  {
    dy_dx1[i].resize(n);
    dy_dx2[i].resize(n);
    d2y_dx1x2[i].resize(n);
  }
 
  // Central difference calculations of derivatives
  for (const auto i : make_range(m))
    for (const auto j : make_range(n))
    {
      // Derivative wrt x1
      if (i == 0)
      {
        dy_dx1[i][j] = (_y[i + 1][j] - _y[i][j]) / (_x1[i + 1] - _x1[i]);
      }
      else if (i == m - 1)
        dy_dx1[i][j] = (_y[i][j] - _y[i - 1][j]) / (_x1[i] - _x1[i - 1]);
      else
        dy_dx1[i][j] = (_y[i + 1][j] - _y[i - 1][j]) / (_x1[i + 1] - _x1[i - 1]);
 
      // Derivative wrt x2
      if (j == 0)
        dy_dx2[i][j] = (_y[i][j + 1] - _y[i][j]) / (_x2[j + 1] - _x2[j]);
      else if (j == n - 1)
        dy_dx2[i][j] = (_y[i][j] - _y[i][j - 1]) / (_x2[j] - _x2[j - 1]);
      else
        dy_dx2[i][j] = (_y[i][j + 1] - _y[i][j - 1]) / (_x2[j + 1] - _x2[j - 1]);
 
      // Mixed derivative d2y/dx1x2
      if (i == 0 && j == 0)
        d2y_dx1x2[i][j] = (_y[i + 1][j + 1] - _y[i + 1][j] - _y[i][j + 1] + _y[i][j]) /
                          (_x1[i + 1] - _x1[i]) / (_x2[j + 1] - _x2[j]);
      else if (i == 0 && j == n - 1)
        d2y_dx1x2[i][j] = (_y[i + 1][j] - _y[i + 1][j - 1] - _y[i][j] + _y[i][j - 1]) /
                          (_x1[i + 1] - _x1[i]) / (_x2[j] - _x2[j - 1]);
      else if (i == m - 1 && j == 0)
        d2y_dx1x2[i][j] = (_y[i][j + 1] - _y[i][j] - _y[i - 1][j + 1] + _y[i - 1][j]) /
                          (_x1[i] - _x1[i - 1]) / (_x2[j + 1] - _x2[j]);
      else if (i == m - 1 && j == n - 1)
        d2y_dx1x2[i][j] = (_y[i][j] - _y[i][j - 1] - _y[i - 1][j] + _y[i - 1][j - 1]) /
                          (_x1[i] - _x1[i - 1]) / (_x2[j] - _x2[j - 1]);
      else if (i == 0)
        d2y_dx1x2[i][j] = (_y[i + 1][j + 1] - _y[i + 1][j - 1] - _y[i][j + 1] + _y[i][j - 1]) /
                          (_x1[i + 1] - _x1[i]) / (_x2[j + 1] - _x2[j - 1]);
      else if (i == m - 1)
        d2y_dx1x2[i][j] = (_y[i][j + 1] - _y[i][j - 1] - _y[i - 1][j + 1] + _y[i - 1][j - 1]) /
                          (_x1[i] - _x1[i - 1]) / (_x2[j + 1] - _x2[j - 1]);
      else if (j == 0)
        d2y_dx1x2[i][j] = (_y[i + 1][j + 1] - _y[i + 1][j] - _y[i - 1][j + 1] + _y[i - 1][j]) /
                          (_x1[i + 1] - _x1[i - 1]) / (_x2[j + 1] - _x2[j]);
      else if (j == n - 1)
        d2y_dx1x2[i][j] = (_y[i + 1][j] - _y[i + 1][j - 1] - _y[i - 1][j] + _y[i - 1][j - 1]) /
                          (_x1[i + 1] - _x1[i - 1]) / (_x2[j] - _x2[j - 1]);
      else
        d2y_dx1x2[i][j] =
            (_y[i + 1][j + 1] - _y[i + 1][j - 1] - _y[i - 1][j + 1] + _y[i - 1][j - 1]) /
            (_x1[i + 1] - _x1[i - 1]) / (_x2[j + 1] - _x2[j - 1]);
    }
}

Referenced by precomputeCoefficients().

Member Data Documentation

◆ _bicubic_coeffs

std::vector<std::vector<std::vector<std::vector<Real> > > > BicubicInterpolation::_bicubic_coeffs

protected

Matrix of precomputed coefficients There are four coefficients in each direction at each dependent value.

Definition at line 116 of file BicubicInterpolation.h.

Referenced by BicubicInterpolation(), precomputeCoefficients(), sample2ndDerivative(), sampleDerivative(), sampleInternal(), and sampleValueAndDerivativesInternal().

◆ _wt

const std::vector<std::vector<int> > BicubicInterpolation::_wt

protected

Initial value:

{
      {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
      {-3, 0, 0, 3, 0, 0, 0, 0, -2, 0, 0, -1, 0, 0, 0, 0},
      {2, 0, 0, -2, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0},
      {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
      {0, 0, 0, 0, -3, 0, 0, 3, 0, 0, 0, 0, -2, 0, 0, -1},
      {0, 0, 0, 0, 2, 0, 0, -2, 0, 0, 0, 0, 1, 0, 0, 1},
      {-3, 3, 0, 0, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0, 0, 0, -3, 3, 0, 0, -2, -1, 0, 0},
      {9, -9, 9, -9, 6, 3, -3, -6, 6, -6, -3, 3, 4, 2, 1, 2},
      {-6, 6, -6, 6, -4, -2, 2, 4, -3, 3, 3, -3, -2, -1, -1, -2},
      {2, -2, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 1, 1, 0, 0},
      {-6, 6, -6, 6, -3, -3, 3, 3, -4, 4, 2, -2, -2, -2, -1, -1},
      {4, -4, 4, -4, 2, 2, -2, -2, 2, -2, -2, 2, 1, 1, 1, 1}}

Matrix used to calculate bicubic interpolation coefficients (from Numerical Recipes)

Definition at line 120 of file BicubicInterpolation.h.

                                     {
      {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
      {-3, 0, 0, 3, 0, 0, 0, 0, -2, 0, 0, -1, 0, 0, 0, 0},
      {2, 0, 0, -2, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0},
      {0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
      {0, 0, 0, 0, -3, 0, 0, 3, 0, 0, 0, 0, -2, 0, 0, -1},
      {0, 0, 0, 0, 2, 0, 0, -2, 0, 0, 0, 0, 1, 0, 0, 1},
      {-3, 3, 0, 0, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0, 0, 0, -3, 3, 0, 0, -2, -1, 0, 0},
      {9, -9, 9, -9, 6, 3, -3, -6, 6, -6, -3, 3, 4, 2, 1, 2},
      {-6, 6, -6, 6, -4, -2, 2, 4, -3, 3, 3, -3, -2, -1, -1, -2},
      {2, -2, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 1, 1, 0, 0},
      {-6, 6, -6, 6, -3, -3, 3, 3, -4, 4, 2, -2, -2, -2, -1, -1},
      {4, -4, 4, -4, 2, 2, -2, -2, 2, -2, -2, 2, 1, 1, 1, 1}};

Referenced by precomputeCoefficients().

◆ _x1

std::vector<Real> BidimensionalInterpolation::_x1

inherited

Independent values in the x1 direction.

Definition at line 37 of file BidimensionalInterpolation.h.

Referenced by BicubicInterpolation(), errorCheck(), precomputeCoefficients(), sample2ndDerivative(), sampleDerivative(), BilinearInterpolation::sampleDerivativeInternal(), BilinearInterpolation::sampleInternal(), sampleInternal(), sampleValueAndDerivativesInternal(), and tableDerivatives().

◆ _x2

std::vector<Real> BidimensionalInterpolation::_x2

inherited

Independent values in the x2 direction.

Definition at line 39 of file BidimensionalInterpolation.h.

Referenced by BicubicInterpolation(), errorCheck(), precomputeCoefficients(), sample2ndDerivative(), sampleDerivative(), BilinearInterpolation::sampleDerivativeInternal(), BilinearInterpolation::sampleInternal(), sampleInternal(), sampleValueAndDerivativesInternal(), and tableDerivatives().

◆ _y

std::vector<std::vector<Real> > BicubicInterpolation::_y

protected

The dependent values at (x1, x2) points.

Definition at line 112 of file BicubicInterpolation.h.

Referenced by errorCheck(), precomputeCoefficients(), and tableDerivatives().

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

include/utils/BicubicInterpolation.h
src/utils/BicubicInterpolation.C

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BicubicInterpolation()

◆ ~BicubicInterpolation()

Member Function Documentation

◆ errorCheck()

◆ findInterval()

◆ precomputeCoefficients()

◆ sample() [1/3]

◆ sample() [2/3]

◆ sample() [3/3]

◆ sample2ndDerivative()

◆ sampleDerivative() [1/4]

◆ sampleDerivative() [2/4]

◆ sampleDerivative() [3/4]

◆ sampleDerivative() [4/4]

◆ sampleInternal()

◆ sampleValueAndDerivatives() [1/6]

◆ sampleValueAndDerivatives() [2/6]

◆ sampleValueAndDerivatives() [3/6]

◆ sampleValueAndDerivatives() [4/6]

◆ sampleValueAndDerivatives() [5/6]

◆ sampleValueAndDerivatives() [6/6]

◆ sampleValueAndDerivativesInternal()

◆ tableDerivatives()

Member Data Documentation

◆ _bicubic_coeffs

◆ _wt

◆ _x1

◆ _x2

◆ _y