MultiFunctorAdapter< FN > Struct Template Reference

generic functor that computes a set of 1D functors More...

Collaboration diagram for MultiFunctorAdapter< FN >:

Public Types
using	RealType = typename FN::real_type
using	GridType = LogGridLight< RealType >
using	single_type = FN
using	OffloadArray2D = Array< RealType, 2, OffloadPinnedAllocator< RealType > >
using	OffloadArray3D = Array< RealType, 3, OffloadPinnedAllocator< RealType > >
using	OffloadArray4D = Array< RealType, 4, OffloadPinnedAllocator< RealType > >

Public Member Functions
	MultiFunctorAdapter ()=default
	MultiFunctorAdapter (const MultiFunctorAdapter &other)
RealType	rmax () const
void	evaluate (RealType r, RealType *restrict u)
void	batched_evaluate (OffloadArray2D &r, OffloadArray3D &u, RealType Rmax) const
	evaluate for multiple electrons and multiple pbc images More...
void	batched_evaluateVGL (OffloadArray2D &r, OffloadArray4D &vgl, RealType Rmax) const
	evaluate value, first deriv, second deriv for multiple electrons and multiple pbc images More...
void	evaluate (RealType r, RealType *restrict u, RealType *restrict du, RealType *restrict d2u)
void	evaluate (RealType r, RealType *restrict u, RealType *restrict du, RealType *restrict d2u, RealType *restrict d3u)

Public Attributes
aligned_vector< std::unique_ptr< single_type > >	Rnl

Detailed Description

template<typename FN>
struct qmcplusplus::MultiFunctorAdapter< FN >

generic functor that computes a set of 1D functors

Template Parameters

FN	analytic functor, SlaterCombo<T>, GaussianCombo<T>

Analytic functors are light and no state but not efficient. Only for benchmarking.

Definition at line 32 of file MultiFunctorAdapter.h.

Member Typedef Documentation

GridType

using GridType = LogGridLight<RealType>

Definition at line 35 of file MultiFunctorAdapter.h.

OffloadArray2D

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

Definition at line 37 of file MultiFunctorAdapter.h.

OffloadArray3D

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

Definition at line 38 of file MultiFunctorAdapter.h.

OffloadArray4D

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

Definition at line 39 of file MultiFunctorAdapter.h.

RealType

using RealType = typename FN::real_type

Definition at line 34 of file MultiFunctorAdapter.h.

single_type

using single_type = FN

Definition at line 36 of file MultiFunctorAdapter.h.

Constructor & Destructor Documentation

MultiFunctorAdapter() [1/2]

MultiFunctorAdapter ( )

default

MultiFunctorAdapter() [2/2]

MultiFunctorAdapter ( const MultiFunctorAdapter< FN > &  other )

inline

Definition at line 43 of file MultiFunctorAdapter.h.

References MultiFunctorAdapter< FN >::Rnl.

  {
    Rnl.reserve(other.Rnl.size());
    for (size_t i = 0; i < other.Rnl.size(); ++i)
      Rnl.push_back(std::make_unique<single_type>(*other.Rnl[i]));
  }

Member Function Documentation

batched_evaluate()

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

inline

evaluate for multiple electrons and multiple pbc images

r is assumed to be up-to-date on the device before entering this function, and u needs to be updated on the device before exiting this function

Eventually, all computation should be done on the device to avoid transfers, but for now this is all done on the host

Parameters

[in]	r	electron distances [Nelec, Npbc]
[out]	u	value of all radial functions at all electron distances [Nelec, Npbc, nRnl]
	Rmax	evaluate to zero for any distance greater than or equal to Rmax

Definition at line 76 of file MultiFunctorAdapter.h.

References qmcplusplus::n, MultiFunctorAdapter< FN >::Rnl, Array< T, D, ALLOC >::size(), Array< T, D, ALLOC >::updateFrom(), and Array< T, D, ALLOC >::updateTo().

  {
    r.updateFrom(); // TODO: remove after offload and make r const

    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

    for (size_t i_e = 0; i_e < nElec; i_e++)
      for (size_t i_xyz = 0; i_xyz < Nxyz; i_xyz++)
        if (r(i_e, i_xyz) >= Rmax)
          for (size_t i = 0, n = Rnl.size(); i < n; ++i)
            u(i_e, i_xyz, i) = 0.0;
        else
          for (size_t i = 0, n = Rnl.size(); i < n; ++i)
            u(i_e, i_xyz, i) = Rnl[i]->f(r(i_e, i_xyz));

    u.updateTo(); // TODO: remove after offload
  }

batched_evaluateVGL()

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

inline

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

r is assumed to be up-to-date on the device before entering this function, and vgl needs to be updated on the device before exiting this function

Eventually, all computation should be done on the device to avoid transfers, but for now this is all done on the host

Parameters

[in]	r	electron distances [Nelec, Npbc]
[out]	vgl	val/d1/d2 of all radial functions at all electron distances [3(val,d1,d2), Nelec, Npbc, nRnl]
	Rmax	radial function and derivs will evaluate to zero for any distance greater than or equal to Rmax

Definition at line 112 of file MultiFunctorAdapter.h.

References Array< T, D, ALLOC >::data(), Array< T, D, ALLOC >::data_at(), MultiFunctorAdapter< FN >::Rnl, Array< T, D, ALLOC >::size(), Array< T, D, ALLOC >::updateFrom(), and Array< T, D, ALLOC >::updateTo().

  {
    r.updateFrom(); // TODO: remove when eval is offloaded
    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 primitives
    const size_t nR   = nElec * Nxyz; // total number of positions to evaluate
    assert(nRnl == Rnl.size());

    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);

    for (size_t ir = 0; ir < nR; ir++)
    {
      // TODO: once this is offloaded, maybe better to just avoid branching and keep values past Rmax
      if (r_ptr[ir] >= Rmax)
      {
        for (size_t i = 0; i < nRnl; ++i)
        {
          u_ptr[ir * nRnl + i]   = 0.0;
          du_ptr[ir * nRnl + i]  = 0.0;
          d2u_ptr[ir * nRnl + i] = 0.0;
        }
      }
      else
      {
        const RealType r    = r_ptr[ir];
        const RealType rinv = RealType(1) / r;
        for (size_t i = 0; i < nRnl; ++i)
        {
          Rnl[i]->evaluateAll(r, rinv);
          u_ptr[ir * nRnl + i]   = Rnl[i]->Y;
          du_ptr[ir * nRnl + i]  = Rnl[i]->dY;
          d2u_ptr[ir * nRnl + i] = Rnl[i]->d2Y;
        }
      }
    }
    vgl.updateTo(); // TODO: remove when eval is offloaded
  }

evaluate() [1/3]

void evaluate ( RealType  r, RealType *restrict  u  )

inline

Definition at line 57 of file MultiFunctorAdapter.h.

References qmcplusplus::n, and MultiFunctorAdapter< FN >::Rnl.

  {
    for (size_t i = 0, n = Rnl.size(); i < n; ++i)
      u[i] = Rnl[i]->f(r);
  }

evaluate() [2/3]

void evaluate ( RealType  r, RealType *restrict  u, RealType *restrict  du, RealType *restrict  d2u  )

inline

Definition at line 157 of file MultiFunctorAdapter.h.

References qmcplusplus::n, and MultiFunctorAdapter< FN >::Rnl.

  {
    const RealType rinv = RealType(1) / r;
    for (size_t i = 0, n = Rnl.size(); i < n; ++i)
    {
      Rnl[i]->evaluateAll(r, rinv);
      u[i]   = Rnl[i]->Y;
      du[i]  = Rnl[i]->dY;
      d2u[i] = Rnl[i]->d2Y;
    }
  }

evaluate() [3/3]

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

inline

Definition at line 168 of file MultiFunctorAdapter.h.

References qmcplusplus::n, and MultiFunctorAdapter< FN >::Rnl.

  {
    const RealType rinv = RealType(1) / r;
    for (size_t i = 0, n = Rnl.size(); i < n; ++i)
    {
      Rnl[i]->evaluateWithThirdDeriv(r, rinv);
      u[i]   = Rnl[i]->Y;
      du[i]  = Rnl[i]->dY;
      d2u[i] = Rnl[i]->d2Y;
      d3u[i] = Rnl[i]->d3Y;
    }
  }

rmax()

RealType rmax ( ) const

inline

Definition at line 50 of file MultiFunctorAdapter.h.

  {
    //Another magic r_max
    constexpr RealType r0(100);
    return r0;
  }

Member Data Documentation

Rnl

aligned_vector<std::unique_ptr<single_type> > Rnl

Definition at line 40 of file MultiFunctorAdapter.h.

Referenced by MultiFunctorAdapter< FN >::batched_evaluate(), MultiFunctorAdapter< FN >::batched_evaluateVGL(), MultiFunctorAdapter< FN >::evaluate(), and MultiFunctorAdapter< FN >::MultiFunctorAdapter().

---

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

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