MultiQuinticSpline1D< T > Class Template Reference

multivalue implementation for OneDimQuintic Real valued only calling any eval method with r >= r_max will throw an exception More...

Collaboration diagram for MultiQuinticSpline1D< T >:

Public Types
using	RealType = T
using	GridType = OneDimGridBase< T >
using	CoeffType = Matrix< T, OffloadPinnedAllocator< T > >
using	OffloadArray2D = Array< T, 2, OffloadPinnedAllocator< T > >
using	OffloadArray3D = Array< T, 3, OffloadPinnedAllocator< T > >
using	OffloadArray4D = Array< T, 4, OffloadPinnedAllocator< T > >

Public Member Functions
	MultiQuinticSpline1D ()
	MultiQuinticSpline1D (const MultiQuinticSpline1D &in)=default
T	rmax () const
void	evaluate (T r, T *restrict u) const
void	batched_evaluate (const OffloadArray2D &r, OffloadArray3D &u, T Rmax) const
	evaluate MultiQuinticSpline1D for multiple electrons and multiple pbc images More...
void	batched_evaluateVGL (const OffloadArray2D &r, OffloadArray4D &vgl, T Rmax) const
	evaluate value, first deriv, second deriv of MultiQuinticSpline1D for multiple electrons and multiple pbc images More...
void	evaluate (T r, T *restrict u, T *restrict du, T *restrict d2u) const
void	evaluate (T r, T *restrict u, T *restrict du, T *restrict d2u, T *restrict d3u) const
	compute upto 3rd derivatives More...
template<typename GT >
void	initialize (GT &agrid, int norbs, int order=5)
	initialize grid and container More...
template<typename T1 >
void	add_spline (int ispline, OneDimQuinticSpline< T1 > &in)
void	finalize ()
	finalize the construction More...
int	getNumSplines () const
void	setNumSplines (int num_splines)

Private Attributes
size_t	num_splines_
	number of splines More...
size_t	spline_order
	order of spline More...
T	r_max
	maximum radius More...
LogGridLight< T >	myGrid
	will be the real grid More...
const std::shared_ptr< CoeffType >	coeffs_ptr_
	coeffs[6*spline_points][num_splines+padding] More...
const std::shared_ptr< Vector< T, OffloadPinnedAllocator< T > > >	first_deriv_ptr_
CoeffType &	coeffs_
Vector< T, OffloadPinnedAllocator< T > > &	first_deriv_

Detailed Description

template<typename T>
class qmcplusplus::MultiQuinticSpline1D< T >

multivalue implementation for OneDimQuintic Real valued only calling any eval method with r >= r_max will throw an exception

Definition at line 97 of file MultiQuinticSpline1D.h.

Member Typedef Documentation

CoeffType

using CoeffType = Matrix<T, OffloadPinnedAllocator<T> >

Definition at line 102 of file MultiQuinticSpline1D.h.

GridType

using GridType = OneDimGridBase<T>

Definition at line 101 of file MultiQuinticSpline1D.h.

OffloadArray2D

using OffloadArray2D = Array<T, 2, OffloadPinnedAllocator<T> >

Definition at line 103 of file MultiQuinticSpline1D.h.

OffloadArray3D

using OffloadArray3D = Array<T, 3, OffloadPinnedAllocator<T> >

Definition at line 104 of file MultiQuinticSpline1D.h.

OffloadArray4D

using OffloadArray4D = Array<T, 4, OffloadPinnedAllocator<T> >

Definition at line 105 of file MultiQuinticSpline1D.h.

RealType

using RealType = T

Definition at line 100 of file MultiQuinticSpline1D.h.

Constructor & Destructor Documentation

MultiQuinticSpline1D() [1/2]

MultiQuinticSpline1D ( )

inline

Definition at line 126 of file MultiQuinticSpline1D.h.

      : coeffs_ptr_(std::make_shared<CoeffType>()),
        first_deriv_ptr_(std::make_shared<Vector<T, OffloadPinnedAllocator<T>>>()),
        coeffs_(*coeffs_ptr_),
        first_deriv_(*first_deriv_ptr_)
  {}

MultiQuinticSpline1D() [2/2]

MultiQuinticSpline1D ( const MultiQuinticSpline1D< T > &  in )

default

Member Function Documentation

add_spline()

void add_spline ( int  ispline, OneDimQuinticSpline< T1 > &  in  )

inline

Definition at line 430 of file MultiQuinticSpline1D.h.

References qmcplusplus::Units::distance::A, B(), OneDimQuinticSpline< Td, Tg, CTd, CTg >::B, qmcplusplus::Units::charge::C, MultiQuinticSpline1D< T >::coeffs_, Matrix< T, Alloc >::cols(), OneDimQuinticSpline< Td, Tg, CTd, CTg >::D, Matrix< T, Alloc >::data(), OneDimQuinticSpline< Td, Tg, CTd, CTg >::E, OneDimQuinticSpline< Td, Tg, CTd, CTg >::F, OneDimQuinticSpline< Td, Tg, CTd, CTg >::first_deriv, MultiQuinticSpline1D< T >::first_deriv_, OneDimQuinticSpline< Td, Tg, CTd, CTg >::m_Y, OneDimQuinticSpline< Td, Tg, CTd, CTg >::m_Y2, and OneDimGridFunctor< Td, Tg, CTd, CTg >::size().

Referenced by CuspCorrectionAtomicBasis< T >::addSpline(), A2NTransformer< T, FnIn >::convert(), and qmcplusplus::TEST_CASE().

  {
    first_deriv_[ispline] = in.first_deriv;
    //if(spline_order==QUINTIC)
    {
      const T1* restrict A    = in.m_Y.data();
      const T1* restrict B    = in.B.data();
      const T1* restrict C    = in.m_Y2.data();
      const T1* restrict D    = in.D.data();
      const T1* restrict E    = in.E.data();
      const T1* restrict F    = in.F.data();
      T* restrict out         = coeffs_.data();
      const size_t ncols      = coeffs_.cols();
      const size_t num_points = in.size();
      for (size_t i = 0; i < num_points; ++i)
      {
        out[(i * 6 + 0) * ncols + ispline] = static_cast<T>(A[i]);
        out[(i * 6 + 1) * ncols + ispline] = static_cast<T>(B[i]);
        out[(i * 6 + 2) * ncols + ispline] = static_cast<T>(C[i]);
        out[(i * 6 + 3) * ncols + ispline] = static_cast<T>(D[i]);
        out[(i * 6 + 4) * ncols + ispline] = static_cast<T>(E[i]);
        out[(i * 6 + 5) * ncols + ispline] = static_cast<T>(F[i]);
      }
    }
  }

batched_evaluate()

void batched_evaluate ( const OffloadArray2D &  r, OffloadArray3D &  u, T  Rmax  ) const

inline

evaluate MultiQuinticSpline1D for multiple electrons and multiple pbc images

Parameters

[in]	r	electron distances [Nelec, Npbc]
[out]	u	value of all splines at all electron distances [Nelec, Npbc, Nsplines]
	Rmax	spline will evaluate to zero for any distance greater than or equal to Rmax

Definition at line 171 of file MultiQuinticSpline1D.h.

References MultiQuinticSpline1D< T >::coeffs_, Matrix< T, Alloc >::cols(), Array< T, D, ALLOC >::data(), Matrix< T, Alloc >::data(), qmcplusplus::Units::charge::e, MultiQuinticSpline1D< T >::first_deriv_, LogGridLight< T >::getCL(), qmcplusplus::lower_bound(), MultiQuinticSpline1D< T >::myGrid, MultiQuinticSpline1D< T >::num_splines_, Array< T, D, ALLOC >::size(), and Matrix< T, Alloc >::size().

  {
    const size_t nElec = r.size(0);
    const size_t Nxyz  = r.size(1); // number of PBC images
    assert(nElec == u.size(0));
    assert(Nxyz == u.size(1));
    const size_t nRnl = u.size(2);    // number of splines
    const size_t nR   = nElec * Nxyz; // total number of positions to evaluate

    double one_over_log_delta = myGrid.OneOverLogDelta;
    T lower_bound             = myGrid.lower_bound;
    T log_delta               = myGrid.LogDelta;

    auto* r_ptr = r.data();
    auto* u_ptr = u.data();

    auto* coeff_ptr       = coeffs_.data();
    auto* first_deriv_ptr = first_deriv_.data();
    const size_t nCols    = coeffs_.cols();
    const size_t coefsize = coeffs_.size();
    const int nsplines   = num_splines_;

    PRAGMA_OFFLOAD("omp target teams distribute parallel for \
                    map(to:coeff_ptr[:coefsize], first_deriv_ptr[:nsplines]) \
                    map(to:r_ptr[:nR], u_ptr[:nRnl*nR])")
    for (int ir = 0; ir < nR; ir++)
    {
      if (r_ptr[ir] >= Rmax)
      {
        for (int i = 0; i < nsplines; ++i)
          u_ptr[ir * nRnl + i] = 0.0;
      }
      else if (r_ptr[ir] < lower_bound)
      {
        const T dr = r_ptr[ir] - lower_bound;
        for (int i = 0; i < nsplines; ++i)
          u_ptr[ir * nRnl + i] = coeff_ptr[i] + first_deriv_ptr[i] * dr;
      }
      else
      {
        int loc;
        const auto cL       = LogGridLight<T>::getCL(r_ptr[ir], loc, one_over_log_delta, lower_bound, log_delta);
        const size_t offset = loc * 6;
        const T* restrict a = coeff_ptr + nCols * (offset + 0);
        const T* restrict b = coeff_ptr + nCols * (offset + 1);
        const T* restrict c = coeff_ptr + nCols * (offset + 2);
        const T* restrict d = coeff_ptr + nCols * (offset + 3);
        const T* restrict e = coeff_ptr + nCols * (offset + 4);
        const T* restrict f = coeff_ptr + nCols * (offset + 5);
        for (int i = 0; i < nsplines; ++i)
          u_ptr[ir * nRnl + i] = a[i] + cL * (b[i] + cL * (c[i] + cL * (d[i] + cL * (e[i] + cL * f[i]))));
      }
    }
  }

batched_evaluateVGL()

void batched_evaluateVGL ( const OffloadArray2D &  r, OffloadArray4D &  vgl, T  Rmax  ) const

inline

evaluate value, first deriv, second deriv of MultiQuinticSpline1D for multiple electrons and multiple pbc images

r is assumed to be up-to-date on the device when entering this function, and vgl will be up to date on the device when exiting this function

Parameters

[in]	r	electron distances [Nelec, Npbc]
[out]	vgl	val/d1/d2 of all splines at all electron distances [3(val,d1,d2), Nelec, Npbc, Nsplines]
	Rmax	spline and derivatives will evaluate to zero for any distance greater than or equal to Rmax

Definition at line 236 of file MultiQuinticSpline1D.h.

References MultiQuinticSpline1D< T >::coeffs_, Matrix< T, Alloc >::cols(), Array< T, D, ALLOC >::data(), Matrix< T, Alloc >::data(), Array< T, D, ALLOC >::data_at(), qmcplusplus::Units::charge::e, MultiQuinticSpline1D< T >::first_deriv_, LogGridLight< T >::getCL(), qmcplusplus::lower_bound(), MultiQuinticSpline1D< T >::myGrid, MultiQuinticSpline1D< T >::num_splines_, Array< T, D, ALLOC >::size(), and Matrix< T, Alloc >::size().

  {
    const size_t nElec = r.size(0);
    const size_t Nxyz  = r.size(1); // number of PBC images
    assert(3 == vgl.size(0));
    assert(nElec == vgl.size(1));
    assert(Nxyz == vgl.size(2));
    const size_t nRnl = vgl.size(3);  // number of splines
    const size_t nR   = nElec * Nxyz; // total number of positions to evaluate

    double one_over_log_delta = myGrid.OneOverLogDelta;
    T lower_bound             = myGrid.lower_bound;
    T dlog_ratio              = myGrid.LogDelta;

    auto* r_ptr   = r.data();
    auto* u_ptr   = vgl.data_at(0, 0, 0, 0);
    auto* du_ptr  = vgl.data_at(1, 0, 0, 0);
    auto* d2u_ptr = vgl.data_at(2, 0, 0, 0);

    auto* coeff_ptr       = coeffs_.data();
    auto* first_deriv_ptr = first_deriv_.data();
    const size_t nCols    = coeffs_.cols();
    const size_t coefsize = coeffs_.size();
    const auto nsplines   = num_splines_;

    constexpr T ctwo(2);
    constexpr T cthree(3);
    constexpr T cfour(4);
    constexpr T cfive(5);
    constexpr T csix(6);
    constexpr T c12(12);
    constexpr T c20(20);

    PRAGMA_OFFLOAD("omp target teams distribute parallel for \
                    map(to: first_deriv_ptr[:nsplines], coeff_ptr[:coefsize]) \
                    map(to: r_ptr[:nR], u_ptr[:nRnl*nR], du_ptr[:nRnl*nR], d2u_ptr[:nRnl*nR])")
    for (size_t ir = 0; ir < nR; ir++)
    {
      if (r_ptr[ir] >= Rmax)
      {
        for (size_t i = 0; i < nsplines; ++i)
        {
          u_ptr[ir * nRnl + i]   = 0.0;
          du_ptr[ir * nRnl + i]  = 0.0;
          d2u_ptr[ir * nRnl + i] = 0.0;
        }
      }
      else if (r_ptr[ir] < lower_bound)
      {
        const T dr          = r_ptr[ir] - lower_bound;
        const T* restrict a = coeff_ptr;
        // const T* restrict a = coeffs_[0];
        for (size_t i = 0; i < nsplines; ++i)
        {
          u_ptr[ir * nRnl + i]   = a[i] + first_deriv_ptr[i] * dr;
          du_ptr[ir * nRnl + i]  = first_deriv_ptr[i];
          d2u_ptr[ir * nRnl + i] = 0.0;
        }
      }
      else
      {
        int loc;
        const auto cL = LogGridLight<T>::getCL(r_ptr[ir], loc, one_over_log_delta, lower_bound, dlog_ratio);
        // const auto cL       = myGrid.getCLForQuintic(r_list[ir], loc);
        const size_t offset = loc * 6;
        const T* restrict a = coeff_ptr + nCols * (offset + 0);
        const T* restrict b = coeff_ptr + nCols * (offset + 1);
        const T* restrict c = coeff_ptr + nCols * (offset + 2);
        const T* restrict d = coeff_ptr + nCols * (offset + 3);
        const T* restrict e = coeff_ptr + nCols * (offset + 4);
        const T* restrict f = coeff_ptr + nCols * (offset + 5);
        for (size_t i = 0; i < nsplines; ++i)
        {
          u_ptr[ir * nRnl + i] = a[i] + cL * (b[i] + cL * (c[i] + cL * (d[i] + cL * (e[i] + cL * f[i]))));
          du_ptr[ir * nRnl + i] =
              b[i] + cL * (ctwo * c[i] + cL * (cthree * d[i] + cL * (cfour * e[i] + cL * f[i] * cfive)));
          d2u_ptr[ir * nRnl + i] = ctwo * c[i] + cL * (csix * d[i] + cL * (c12 * e[i] + cL * f[i] * c20));
        }
      }
    }
  }

evaluate() [1/3]

void evaluate ( T  r, T *restrict  u  ) const

inline

Definition at line 137 of file MultiQuinticSpline1D.h.

References MultiQuinticSpline1D< T >::coeffs_, qmcplusplus::Units::charge::e, MultiQuinticSpline1D< T >::first_deriv_, MultiQuinticSpline1D< T >::myGrid, and MultiQuinticSpline1D< T >::num_splines_.

Referenced by CuspCorrectionAtomicBasis< T >::evaluate(), CuspCorrectionAtomicBasis< T >::evaluate_vgl(), and qmcplusplus::TEST_CASE().

  {
    if (r < myGrid.lower_bound)
    {
      const T dr          = r - myGrid.lower_bound;
      const T* restrict a = coeffs_[0];
      for (size_t i = 0; i < num_splines_; ++i)
        u[i] = a[i] + first_deriv_[i] * dr;
    }
    else
    {
      int loc;
      const auto cL       = myGrid.getCLForQuintic(r, loc);
      const size_t offset = loc * 6;
      //coeffs is an OhmmsMatrix and [] is a row access operator
      //returning a pointer to 'row' which is normal type pointer []
      const T* restrict a = coeffs_[offset + 0];
      const T* restrict b = coeffs_[offset + 1];
      const T* restrict c = coeffs_[offset + 2];
      const T* restrict d = coeffs_[offset + 3];
      const T* restrict e = coeffs_[offset + 4];
      const T* restrict f = coeffs_[offset + 5];
      for (size_t i = 0; i < num_splines_; ++i)
        u[i] = a[i] + cL * (b[i] + cL * (c[i] + cL * (d[i] + cL * (e[i] + cL * f[i]))));
    }
  }

evaluate() [2/3]

void evaluate ( T  r, T *restrict  u, T *restrict  du, T *restrict  d2u  ) const

inline

Definition at line 317 of file MultiQuinticSpline1D.h.

References MultiQuinticSpline1D< T >::coeffs_, qmcplusplus::Units::charge::e, MultiQuinticSpline1D< T >::first_deriv_, MultiQuinticSpline1D< T >::myGrid, and MultiQuinticSpline1D< T >::num_splines_.

  {
    if (r < myGrid.lower_bound)
    {
      const T dr          = r - myGrid.lower_bound;
      const T* restrict a = coeffs_[0];
      for (size_t i = 0; i < num_splines_; ++i)
      {
        u[i]   = a[i] + first_deriv_[i] * dr;
        du[i]  = first_deriv_[i];
        d2u[i] = 0.0;
      }
    }
    else
    {
      int loc;
      const auto cL       = myGrid.getCLForQuintic(r, loc);
      const size_t offset = loc * 6;

      constexpr T ctwo(2);
      constexpr T cthree(3);
      constexpr T cfour(4);
      constexpr T cfive(5);
      constexpr T csix(6);
      constexpr T c12(12);
      constexpr T c20(20);

      const T* restrict a = coeffs_[offset + 0];
      const T* restrict b = coeffs_[offset + 1];
      const T* restrict c = coeffs_[offset + 2];
      const T* restrict d = coeffs_[offset + 3];
      const T* restrict e = coeffs_[offset + 4];
      const T* restrict f = coeffs_[offset + 5];

      for (size_t i = 0; i < num_splines_; ++i)
      {
        u[i]   = a[i] + cL * (b[i] + cL * (c[i] + cL * (d[i] + cL * (e[i] + cL * f[i]))));
        du[i]  = b[i] + cL * (ctwo * c[i] + cL * (cthree * d[i] + cL * (cfour * e[i] + cL * f[i] * cfive)));
        d2u[i] = ctwo * c[i] + cL * (csix * d[i] + cL * (c12 * e[i] + cL * f[i] * c20));
      }
    }
  }

evaluate() [3/3]

void evaluate ( T  r, T *restrict  u, T *restrict  du, T *restrict  d2u, T *restrict  d3u  ) const

inline

compute upto 3rd derivatives

Definition at line 361 of file MultiQuinticSpline1D.h.

References MultiQuinticSpline1D< T >::coeffs_, qmcplusplus::Units::charge::e, MultiQuinticSpline1D< T >::first_deriv_, MultiQuinticSpline1D< T >::myGrid, and MultiQuinticSpline1D< T >::num_splines_.

  {
    if (r < myGrid.lower_bound)
    {
      const T dr          = r - myGrid.lower_bound;
      const T* restrict a = coeffs_[0];
      for (size_t i = 0; i < num_splines_; ++i)
      {
        u[i]   = a[i] + first_deriv_[i] * dr;
        du[i]  = first_deriv_[i];
        d2u[i] = 0.0;
        d3u[i] = 0.0;
      }
    }
    else
    {
      int loc;
      const auto cL       = myGrid.getCLForQuintic(r, loc);
      const size_t offset = loc * 6;

      constexpr T ctwo(2);
      constexpr T cthree(3);
      constexpr T cfour(4);
      constexpr T cfive(5);
      constexpr T csix(6);
      constexpr T c12(12);
      constexpr T c20(20);
      constexpr T c24(24);
      constexpr T c60(60);

      const T* restrict a = coeffs_[offset + 0];
      const T* restrict b = coeffs_[offset + 1];
      const T* restrict c = coeffs_[offset + 2];
      const T* restrict d = coeffs_[offset + 3];
      const T* restrict e = coeffs_[offset + 4];
      const T* restrict f = coeffs_[offset + 5];

      for (size_t i = 0; i < num_splines_; ++i)
      {
        u[i]   = a[i] + cL * (b[i] + cL * (c[i] + cL * (d[i] + cL * (e[i] + cL * f[i]))));
        du[i]  = b[i] + cL * (ctwo * c[i] + cL * (cthree * d[i] + cL * (cfour * e[i] + cL * f[i] * cfive)));
        d2u[i] = ctwo * c[i] + cL * (csix * d[i] + cL * (c12 * e[i] + cL * f[i] * c20));
        d3u[i] = csix * d[i] + cL * (c24 * e[i] + cL * f[i] * c60);
      }
    }
  }

finalize()

void finalize ( )

inline

finalize the construction

Definition at line 457 of file MultiQuinticSpline1D.h.

References MultiQuinticSpline1D< T >::coeffs_, MultiQuinticSpline1D< T >::first_deriv_, and Matrix< T, Alloc >::updateTo().

  {
    first_deriv_.updateTo();
    coeffs_.updateTo();
  }

getNumSplines()

int getNumSplines ( ) const

inline

Definition at line 463 of file MultiQuinticSpline1D.h.

References MultiQuinticSpline1D< T >::num_splines_.

Referenced by CuspCorrectionAtomicBasis< T >::evaluate(), CuspCorrectionAtomicBasis< T >::evaluate_vgl(), and CuspCorrectionAtomicBasis< T >::getNumOrbs().

{ return num_splines_; }

initialize()

void initialize ( GT &  agrid, int  norbs, int  order = 5  )

inline

initialize grid and container

Parameters

ri	minimum grid point
rf	maximum grid point
npts	number of grid points
n	number of splines
oreder	5=quintic and 3=cubic

Definition at line 416 of file MultiQuinticSpline1D.h.

References MultiQuinticSpline1D< T >::coeffs_, MultiQuinticSpline1D< T >::first_deriv_, MultiQuinticSpline1D< T >::myGrid, MultiQuinticSpline1D< T >::num_splines_, MultiQuinticSpline1D< T >::r_max, Matrix< T, Alloc >::resize(), Matrix< T, Alloc >::size(), and MultiQuinticSpline1D< T >::spline_order.

Referenced by CuspCorrectionAtomicBasis< T >::initializeRadialSet(), and qmcplusplus::TEST_CASE().

  {
    myGrid.set(agrid.rmin(), agrid.rmax(), agrid.size());
    r_max = myGrid.upper_bound;
    if (coeffs_.size())
      throw std::runtime_error("MultiQuinticSpline1D::initialize cannot reinitialize coeffs.");

    spline_order = order;
    num_splines_ = norbs;
    coeffs_.resize((order + 1) * agrid.size(), getAlignedSize<T>(norbs));
    first_deriv_.resize(num_splines_);
  }

rmax()

T rmax ( ) const

inline

Definition at line 135 of file MultiQuinticSpline1D.h.

References MultiQuinticSpline1D< T >::myGrid.

{ return myGrid.upper_bound; }

setNumSplines()

void setNumSplines ( int  num_splines )

inline

Definition at line 464 of file MultiQuinticSpline1D.h.

References MultiQuinticSpline1D< T >::num_splines_.

{ num_splines_ = num_splines; }

Member Data Documentation

coeffs_

CoeffType& coeffs_

private

Definition at line 122 of file MultiQuinticSpline1D.h.

Referenced by MultiQuinticSpline1D< T >::add_spline(), MultiQuinticSpline1D< T >::batched_evaluate(), MultiQuinticSpline1D< T >::batched_evaluateVGL(), MultiQuinticSpline1D< T >::evaluate(), MultiQuinticSpline1D< T >::finalize(), and MultiQuinticSpline1D< T >::initialize().

coeffs_ptr_

const std::shared_ptr<CoeffType> coeffs_ptr_

private

coeffs[6*spline_points][num_splines+padding]

Definition at line 119 of file MultiQuinticSpline1D.h.

first_deriv_

Vector<T, OffloadPinnedAllocator<T> >& first_deriv_

private

Definition at line 123 of file MultiQuinticSpline1D.h.

Referenced by MultiQuinticSpline1D< T >::add_spline(), MultiQuinticSpline1D< T >::batched_evaluate(), MultiQuinticSpline1D< T >::batched_evaluateVGL(), MultiQuinticSpline1D< T >::evaluate(), MultiQuinticSpline1D< T >::finalize(), and MultiQuinticSpline1D< T >::initialize().

first_deriv_ptr_

const std::shared_ptr<Vector<T, OffloadPinnedAllocator<T> > > first_deriv_ptr_

private

Definition at line 120 of file MultiQuinticSpline1D.h.

myGrid

LogGridLight<T> myGrid

private

will be the real grid

Definition at line 116 of file MultiQuinticSpline1D.h.

Referenced by MultiQuinticSpline1D< T >::batched_evaluate(), MultiQuinticSpline1D< T >::batched_evaluateVGL(), MultiQuinticSpline1D< T >::evaluate(), MultiQuinticSpline1D< T >::initialize(), and MultiQuinticSpline1D< T >::rmax().

num_splines_

size_t num_splines_

private

number of splines

Definition at line 109 of file MultiQuinticSpline1D.h.

Referenced by MultiQuinticSpline1D< T >::batched_evaluate(), MultiQuinticSpline1D< T >::batched_evaluateVGL(), MultiQuinticSpline1D< T >::evaluate(), MultiQuinticSpline1D< T >::getNumSplines(), MultiQuinticSpline1D< T >::initialize(), and MultiQuinticSpline1D< T >::setNumSplines().

r_max

T r_max

private

maximum radius

Definition at line 113 of file MultiQuinticSpline1D.h.

Referenced by MultiQuinticSpline1D< T >::initialize().

spline_order

size_t spline_order

private

order of spline

Definition at line 111 of file MultiQuinticSpline1D.h.

Referenced by MultiQuinticSpline1D< T >::initialize().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/LCAO/MultiQuinticSpline1D.h