class to match ST real spline with BsplineSet::ValueType (real) SPOs More...

Inheritance diagram for SplineR2R< ST >:

Collaboration diagram for SplineR2R< ST >:

Public Types
using	SplineType = typename bspline_traits< ST, 3 >::SplineType

using	BCType = typename bspline_traits< ST, 3 >::BCType

using	DataType = ST

using	PointType = TinyVector< ST, 3 >

using	SingleSplineType = UBspline_3d_d

using	TT = typename BsplineSet::ValueType

using	vContainer_type = Vector< ST, aligned_allocator< ST > >

using	gContainer_type = VectorSoaContainer< ST, 3 >

using	hContainer_type = VectorSoaContainer< ST, 6 >

using	ghContainer_type = VectorSoaContainer< ST, 10 >

Public Types inherited from SPOSet
using	ValueVector = OrbitalSetTraits< ValueType >::ValueVector

using	ValueMatrix = OrbitalSetTraits< ValueType >::ValueMatrix

using	GradVector = OrbitalSetTraits< ValueType >::GradVector

using	GradMatrix = OrbitalSetTraits< ValueType >::GradMatrix

using	HessVector = OrbitalSetTraits< ValueType >::HessVector

using	HessMatrix = OrbitalSetTraits< ValueType >::HessMatrix

using	GGGVector = OrbitalSetTraits< ValueType >::GradHessVector

using	GGGMatrix = OrbitalSetTraits< ValueType >::GradHessMatrix

using	SPOMap = std::map< std::string, const std::unique_ptr< const SPOSet > >

using	OffloadMWVGLArray = Array< ValueType, 3, OffloadPinnedAllocator< ValueType > >

using	OffloadMWVArray = Array< ValueType, 2, OffloadPinnedAllocator< ValueType > >

template<typename DT >
using	OffloadMatrix = Matrix< DT, OffloadPinnedAllocator< DT > >

Public Types inherited from QMCTraits
enum	{ DIM = OHMMS_DIM, DIM_VGL = OHMMS_DIM + 2 }

using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >

using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >

using	RealType = QTBase::RealType

using	ComplexType = QTBase::ComplexType

using	ValueType = QTBase::ValueType

using	PosType = QTBase::PosType

using	GradType = QTBase::GradType

using	TensorType = QTBase::TensorType

using	IndexType = OHMMS_INDEXTYPE
	define other types More...

using	FullPrecRealType = QTFull::RealType

using	FullPrecValueType = QTFull::ValueType

using	PropertySetType = RecordNamedProperty< FullPrecRealType >
	define PropertyList_t More...

using	PtclGrpIndexes = std::vector< std::pair< int, int > >

Public Member Functions
	SplineR2R (const std::string &my_name)

	SplineR2R (const SplineR2R &in)

virtual std::string	getClassName () const override
	return class name More...

virtual std::string	getKeyword () const override

bool	isComplex () const override

bool	isRotationSupported () const override
	return true if this SPOSet can be wrappered by RotatedSPO More...

std::unique_ptr< SPOSet >	makeClone () const override
	make a clone of itself every derived class must implement this to have threading working correctly. More...

void	storeParamsBeforeRotation () override
	Store an original copy of the spline coefficients for orbital rotation. More...

void	applyRotation (const ValueMatrix &rot_mat, bool use_stored_copy) override
	apply rotation to all the orbitals More...

void	resizeStorage (size_t n, size_t nvals)

void	bcast_tables (Communicate *comm)

void	gather_tables (Communicate *comm)

template<typename GT , typename BCT >
void	create_spline (GT &xyz_g, BCT &xyz_bc)

void	flush_zero ()

void	set_spline (SingleSplineType spline_r, SingleSplineType spline_i, int twist, int ispline, int level)

bool	read_splines (hdf_archive &h5f)

bool	write_splines (hdf_archive &h5f)

int	convertPos (const PointType &r, PointType &ru)
	convert position in PrimLattice unit and return sign More...

void	assign_v (int bc_sign, const vContainer_type &myV, ValueVector &psi, int first, int last) const

void	evaluateValue (const ParticleSet &P, const int iat, ValueVector &psi) override
	evaluate the values of this single-particle orbital set More...

void	evaluateDetRatios (const VirtualParticleSet &VP, ValueVector &psi, const ValueVector &psiinv, std::vector< TT > &ratios) override

void	assign_vgl (int bc_sign, ValueVector &psi, GradVector &dpsi, ValueVector &d2psi, int first, int last) const

void	assign_vgl_from_l (int bc_sign, ValueVector &psi, GradVector &dpsi, ValueVector &d2psi)
	assign_vgl_from_l can be used when myL is precomputed and myV,myG,myL in cartesian More...

void	evaluateVGL (const ParticleSet &P, const int iat, ValueVector &psi, GradVector &dpsi, ValueVector &d2psi) override
	evaluate the values, gradients and laplacians of this single-particle orbital set More...

void	assign_vgh (int bc_sign, ValueVector &psi, GradVector &dpsi, HessVector &grad_grad_psi, int first, int last) const

void	evaluateVGH (const ParticleSet &P, const int iat, ValueVector &psi, GradVector &dpsi, HessVector &grad_grad_psi) override
	evaluate the values, gradients and hessians of this single-particle orbital set More...

void	assign_vghgh (int bc_sign, ValueVector &psi, GradVector &dpsi, HessVector &grad_grad_psi, GGGVector &grad_grad_grad_psi, int first=0, int last=-1) const

void	evaluateVGHGH (const ParticleSet &P, const int iat, ValueVector &psi, GradVector &dpsi, HessVector &grad_grad_psi, GGGVector &grad_grad_grad_psi) override
	evaluate the values, gradients, hessians, and grad hessians of this single-particle orbital set More...

Public Member Functions inherited from BsplineSet
	BsplineSet (const std::string &my_name)

auto &	getHalfG () const

void	init_base (int n)

int	remap_kpoints ()
	remap kpoints to group general kpoints & special kpoints More...

void	setOrbitalSetSize (int norbs) override
	set the OrbitalSetSize More...

void	evaluate_notranspose (const ParticleSet &P, int first, int last, ValueMatrix &logdet, GradMatrix &dlogdet, ValueMatrix &d2logdet) override
	evaluate the values, gradients and laplacians of this single-particle orbital for [first,last) particles More...

void	mw_evaluate_notranspose (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int first, int last, const RefVector< ValueMatrix > &logdet_list, const RefVector< GradMatrix > &dlogdet_list, const RefVector< ValueMatrix > &d2logdet_list) const override

void	evaluate_notranspose (const ParticleSet &P, int first, int last, ValueMatrix &logdet, GradMatrix &dlogdet, HessMatrix &grad_grad_logdet) override
	evaluate the values, gradients and hessians of this single-particle orbital for [first,last) particles More...

void	evaluate_notranspose (const ParticleSet &P, int first, int last, ValueMatrix &logdet, GradMatrix &dlogdet, HessMatrix &grad_grad_logdet, GGGMatrix &grad_grad_grad_logdet) override
	evaluate the values, gradients, hessians and third derivatives of this single-particle orbital for [first,last) particles More...

void	evaluateGradSource (const ParticleSet &P, int first, int last, const ParticleSet &source, int iat_src, GradMatrix &gradphi) override
	evaluate the gradients of this single-particle orbital for [first,last) target particles with respect to the given source particle More...

void	evaluateGradSource (const ParticleSet &P, int first, int last, const ParticleSet &source, int iat_src, GradMatrix &grad_phi, HessMatrix &grad_grad_phi, GradMatrix &grad_lapl_phi) override
	evaluate the gradients of values, gradients, laplacians of this single-particle orbital for [first,last) target particles with respect to the given source particle More...

virtual void	evaluateDetRatios (const VirtualParticleSet &VP, ValueVector &psi, const ValueVector &psiinv, std::vector< ValueType > &ratios)
	evaluate determinant ratios for virtual moves, e.g., sphere move for nonlocalPP More...

virtual void	evaluateValue (const ParticleSet &P, int iat, ValueVector &psi)=0
	evaluate the values of this single-particle orbital set More...

virtual void	evaluateVGH (const ParticleSet &P, int iat, ValueVector &psi, GradVector &dpsi, HessVector &grad_grad_psi)
	evaluate the values, gradients and hessians of this single-particle orbital set More...

virtual void	evaluateVGHGH (const ParticleSet &P, int iat, ValueVector &psi, GradVector &dpsi, HessVector &grad_grad_psi, GGGVector &grad_grad_grad_psi)
	evaluate the values, gradients, hessians, and grad hessians of this single-particle orbital set More...

virtual void	evaluateVGL (const ParticleSet &P, int iat, ValueVector &psi, GradVector &dpsi, ValueVector &d2psi)=0
	evaluate the values, gradients and laplacians of this single-particle orbital set More...

virtual void	finalizeConstruction ()
	finalize the construction of SPOSet More...

virtual void	mw_evaluateDetRatios (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< const VirtualParticleSet > &vp_list, const RefVector< ValueVector > &psi_list, const std::vector< const ValueType * > &invRow_ptr_list, std::vector< std::vector< ValueType >> &ratios_list) const
	evaluate determinant ratios for virtual moves, e.g., sphere move for nonlocalPP, of multiple walkers More...

virtual void	mw_evaluateVGL (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const RefVector< ValueVector > &psi_v_list, const RefVector< GradVector > &dpsi_v_list, const RefVector< ValueVector > &d2psi_v_list) const
	evaluate the values, gradients and laplacians of this single-particle orbital sets of multiple walkers More...

virtual void	mw_evaluateVGLandDetRatioGrads (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const std::vector< const ValueType * > &invRow_ptr_list, OffloadMWVGLArray &phi_vgl_v, std::vector< ValueType > &ratios, std::vector< GradType > &grads) const
	evaluate the values, gradients and laplacians of this single-particle orbital sets and determinant ratio and grads of multiple walkers. More...

virtual void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< SPOSet > &spo_list) const
	acquire a shared resource from collection More...

virtual void	createResource (ResourceCollection &collection) const
	initialize a shared resource and hand it to collection More...

virtual void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< SPOSet > &spo_list) const
	return a shared resource to collection More...

Public Member Functions inherited from SPOSet
	SPOSet (const std::string &my_name)
	constructor More...

virtual	~SPOSet ()=default
	destructor More...

int	size () const
	return the size of the orbital set Ye: this needs to be replaced by getOrbitalSetSize(); More...

void	basic_report (const std::string &pad="") const
	print basic SPOSet information More...

virtual void	report (const std::string &pad="") const
	print SPOSet information More...

int	getOrbitalSetSize () const
	return the size of the orbitals More...

virtual bool	isOptimizable () const
	Query if this SPOSet is optimizable. More...

virtual void	extractOptimizableObjectRefs (UniqueOptObjRefs &opt_obj_refs)
	extract underlying OptimizableObject references More...

virtual void	checkOutVariables (const opt_variables_type &active)
	check out variational optimizable variables More...

virtual bool	isOMPoffload () const
	Query if this SPOSet uses OpenMP offload. More...

virtual bool	hasIonDerivs () const
	Query if this SPOSet has an explicit ion dependence. More...

virtual void	checkObject () const
	check a few key parameters before putting the SPO into a determinant More...

virtual void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi, const int &FirstIndex, const int &LastIndex)
	Parameter derivatives of the wavefunction and the Laplacian of the wavefunction. More...

virtual void	evaluateDerivativesWF (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, int FirstIndex, int LastIndex)
	Parameter derivatives of the wavefunction. More...

virtual void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi, const ValueType &psiCurrent, const std::vector< ValueType > &Coeff, const std::vector< size_t > &C2node_up, const std::vector< size_t > &C2node_dn, const ValueVector &detValues_up, const ValueVector &detValues_dn, const GradMatrix &grads_up, const GradMatrix &grads_dn, const ValueMatrix &lapls_up, const ValueMatrix &lapls_dn, const ValueMatrix &M_up, const ValueMatrix &M_dn, const ValueMatrix &Minv_up, const ValueMatrix &Minv_dn, const GradMatrix &B_grad, const ValueMatrix &B_lapl, const std::vector< int > &detData_up, const size_t N1, const size_t N2, const size_t NP1, const size_t NP2, const std::vector< std::vector< int >> &lookup_tbl)
	Evaluate the derivative of the optimized orbitals with respect to the parameters this is used only for MSD, to be refined for better serving both single and multi SD. More...

virtual void	evaluateDerivativesWF (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, const QTFull::ValueType &psiCurrent, const std::vector< ValueType > &Coeff, const std::vector< size_t > &C2node_up, const std::vector< size_t > &C2node_dn, const ValueVector &detValues_up, const ValueVector &detValues_dn, const ValueMatrix &M_up, const ValueMatrix &M_dn, const ValueMatrix &Minv_up, const ValueMatrix &Minv_dn, const std::vector< int > &detData_up, const std::vector< std::vector< int >> &lookup_tbl)
	Evaluate the derivative of the optimized orbitals with respect to the parameters this is used only for MSD, to be refined for better serving both single and multi SD. More...

virtual void	evaluateDetRatios (const VirtualParticleSet &VP, ValueVector &psi, const ValueVector &psiinv, std::vector< ValueType > &ratios)
	evaluate determinant ratios for virtual moves, e.g., sphere move for nonlocalPP More...

virtual void	evaluateDetSpinorRatios (const VirtualParticleSet &VP, ValueVector &psi, const std::pair< ValueVector, ValueVector > &spinor_multiplier, const ValueVector &invrow, std::vector< ValueType > &ratios)
	evaluate determinant ratios for virtual moves, specifically for Spinor SPOSets More...

virtual void	evaluateDerivRatios (const VirtualParticleSet &VP, const opt_variables_type &optvars, ValueVector &psi, const ValueVector &psiinv, std::vector< ValueType > &ratios, Matrix< ValueType > &dratios, int FirstIndex, int LastIndex)
	Determinant ratios and parameter derivatives of the wavefunction for virtual moves. More...

virtual void	mw_evaluateDetRatios (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< const VirtualParticleSet > &vp_list, const RefVector< ValueVector > &psi_list, const std::vector< const ValueType *> &invRow_ptr_list, std::vector< std::vector< ValueType >> &ratios_list) const
	evaluate determinant ratios for virtual moves, e.g., sphere move for nonlocalPP, of multiple walkers More...

virtual void	evaluateVGL_spin (const ParticleSet &P, int iat, ValueVector &psi, GradVector &dpsi, ValueVector &d2psi, ValueVector &dspin)
	evaluate the values, gradients and laplacians and spin gradient of this single-particle orbital set More...

virtual void	mw_evaluateValue (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const RefVector< ValueVector > &psi_v_list) const
	evaluate the values this single-particle orbital sets of multiple walkers More...

virtual void	mw_evaluateVGL (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const RefVector< ValueVector > &psi_v_list, const RefVector< GradVector > &dpsi_v_list, const RefVector< ValueVector > &d2psi_v_list) const
	evaluate the values, gradients and laplacians of this single-particle orbital sets of multiple walkers More...

virtual void	mw_evaluateVGLWithSpin (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const RefVector< ValueVector > &psi_v_list, const RefVector< GradVector > &dpsi_v_list, const RefVector< ValueVector > &d2psi_v_list, OffloadMatrix< ComplexType > &mw_dspin) const
	evaluate the values, gradients and laplacians and spin gradient of this single-particle orbital sets of multiple walkers More...

virtual void	mw_evaluateVGLandDetRatioGrads (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const std::vector< const ValueType *> &invRow_ptr_list, OffloadMWVGLArray &phi_vgl_v, std::vector< ValueType > &ratios, std::vector< GradType > &grads) const
	evaluate the values, gradients and laplacians of this single-particle orbital sets and determinant ratio and grads of multiple walkers. More...

virtual void	mw_evaluateVGLandDetRatioGradsWithSpin (const RefVectorWithLeader< SPOSet > &spo_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, const std::vector< const ValueType *> &invRow_ptr_list, OffloadMWVGLArray &phi_vgl_v, std::vector< ValueType > &ratios, std::vector< GradType > &grads, std::vector< ValueType > &spingrads) const
	evaluate the values, gradients and laplacians of this single-particle orbital sets and determinant ratio and grads of multiple walkers. More...

virtual void	evaluate_spin (const ParticleSet &P, int iat, ValueVector &psi, ValueVector &dpsi)
	evaluate the values of this single-particle orbital set More...

virtual void	evaluateThirdDeriv (const ParticleSet &P, int first, int last, GGGMatrix &grad_grad_grad_logdet)
	evaluate the third derivatives of this single-particle orbital set More...

virtual void	evaluate_notranspose_spin (const ParticleSet &P, int first, int last, ValueMatrix &logdet, GradMatrix &dlogdet, ValueMatrix &d2logdet, ValueMatrix &dspinlogdet)
	evaluate the values, gradients and laplacians of this single-particle orbital for [first,last) particles, including the spin gradient More...

virtual void	evaluateGradSourceRow (const ParticleSet &P, int iel, const ParticleSet &source, int iat_src, GradVector &gradphi)
	Returns a row of d/dR_iat phi_j(r) evaluated at position r. More...

virtual PosType	get_k (int orb)
	access the k point related to the given orbital More...

virtual void	createResource (ResourceCollection &collection) const
	initialize a shared resource and hand it to collection More...

virtual void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< SPOSet > &spo_list) const
	acquire a shared resource from collection More...

virtual void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< SPOSet > &spo_list) const
	return a shared resource to collection More...

virtual bool	transformSPOSet ()
	Used only by cusp correction in AOS LCAO. More...

virtual void	finalizeConstruction ()
	finalize the construction of SPOSet More...

const std::string &	getName () const
	return object name More...

Protected Attributes
CrystalLattice< ST, 3 >	PrimLattice
	primitive cell More...

vContainer_type	myV
	intermediate result vectors More...

vContainer_type	myL

gContainer_type	myG

hContainer_type	myH

ghContainer_type	mygH

Protected Attributes inherited from BsplineSet
size_t	MyIndex
	Index of this adoptor, when multiple adoptors are used for NUMA or distributed cases. More...

size_t	first_spo
	first index of the SPOs this Spline handles More...

size_t	last_spo
	last index of the SPOs this Spline handles More...

TinyVector< int, D >	HalfG
	sign bits at the G/2 boundaries More...

std::vector< bool >	MakeTwoCopies
	flags to unpack sin/cos More...

std::vector< SPOSet::PosType >	kPoints
	kpoints for each unique orbitals. More...

aligned_vector< int >	BandIndexMap
	remap splines to orbitals More...

std::vector< int >	offset
	band offsets used for communication More...

Protected Attributes inherited from SPOSet
const std::string	my_name_
	name of the object, unique identifier More...

IndexType	OrbitalSetSize
	number of Single-particle orbitals More...

opt_variables_type	myVars
	Optimizable variables. More...

Private Attributes
bool	IsGamma

Tensor< ST, 3 >	GGt
	, transformation for tensor in LatticeUnit to CartesianUnit, e.g. Hessian More...

std::shared_ptr< MultiBspline< ST > >	SplineInst
	multi bspline set More...

std::shared_ptr< std::vector< ST > >	coef_copy_
	Copy of original splines for orbital rotation. More...

Matrix< TT >	ratios_private
	thread private ratios for reduction when using nested threading, numVP x numThread More...

Friends
template<class BSPLINESPO >
class	SplineSetReader

struct	BsplineReader

Additional Inherited Members
Static Protected Attributes inherited from BsplineSet
static const int	D = DIM

Detailed Description

template<typename ST>
class qmcplusplus::SplineR2R< ST >

class to match ST real spline with BsplineSet::ValueType (real) SPOs

Template Parameters

ST	precision of spline

Requires temporage storage and multiplication of the sign of the real part of the phase Internal storage ST type arrays are aligned and padded.

Definition at line 34 of file SplineR2R.h.

Member Typedef Documentation

◆ BCType

using BCType = typename bspline_traits<ST, 3>::BCType

Definition at line 38 of file SplineR2R.h.

◆ DataType

using DataType = ST

Definition at line 39 of file SplineR2R.h.

◆ gContainer_type

using gContainer_type = VectorSoaContainer<ST, 3>

Definition at line 50 of file SplineR2R.h.

◆ ghContainer_type

using ghContainer_type = VectorSoaContainer<ST, 10>

Definition at line 52 of file SplineR2R.h.

◆ hContainer_type

using hContainer_type = VectorSoaContainer<ST, 6>

Definition at line 51 of file SplineR2R.h.

◆ PointType

using PointType = TinyVector<ST, 3>

Definition at line 40 of file SplineR2R.h.

◆ SingleSplineType

using SingleSplineType = UBspline_3d_d

Definition at line 41 of file SplineR2R.h.

◆ SplineType

using SplineType = typename bspline_traits<ST, 3>::SplineType

Definition at line 37 of file SplineR2R.h.

◆ TT

using TT = typename BsplineSet::ValueType

Definition at line 43 of file SplineR2R.h.

◆ vContainer_type

using vContainer_type = Vector<ST, aligned_allocator<ST> >

Definition at line 49 of file SplineR2R.h.

Constructor & Destructor Documentation

◆ SplineR2R() [1/2]

SplineR2R ( const std::string & my_name )

inline

Definition at line 79 of file SplineR2R.h.

79 : BsplineSet(my_name) {}

qmcplusplus::BsplineSet::BsplineSet

BsplineSet(const std::string &my_name)

Definition: BsplineSet.h:59

◆ SplineR2R() [2/2]

SplineR2R ( const SplineR2R< ST > & in )

default

Member Function Documentation

◆ applyRotation()

void applyRotation	(	const ValueMatrix &	rot_mat,
		bool	use_stored_copy
	)

overridevirtual

apply rotation to all the orbitals

Reimplemented from SPOSet.

Definition at line 106 of file SplineR2R.cpp.

References qmcplusplus::syclBLAS::copy_n(), and BLAS::gemm().

 {
   // SplineInst is a MultiBspline. See src/spline2/MultiBspline.hpp
   const auto spline_ptr = SplineInst->getSplinePtr();
   assert(spline_ptr != nullptr);
   const auto spl_coefs      = spline_ptr->coefs;
   const auto Nsplines       = spline_ptr->num_splines; // May include padding
   const auto coefs_tot_size = spline_ptr->coefs_size;
   const auto BasisSetSize   = coefs_tot_size / Nsplines;
   const auto TrueNOrbs      = rot_mat.size1(); // == Nsplines - padding
   assert(OrbitalSetSize == rot_mat.rows());
   assert(OrbitalSetSize == rot_mat.cols());
 
   if (!use_stored_copy)
   {
     assert(coef_copy_ != nullptr);
     std::copy_n(spl_coefs, coefs_tot_size, coef_copy_->begin());
   }
 
 
   if constexpr (std::is_same_v<ST, RealType>)
   {
     //Here, ST should be equal to ValueType, which will be double for R2R. Using BLAS to make things faster
     BLAS::gemm('N', 'N', OrbitalSetSize, BasisSetSize, OrbitalSetSize, ST(1.0), rot_mat.data(), OrbitalSetSize,
                coef_copy_->data(), Nsplines, ST(0.0), spl_coefs, Nsplines);
   }
   else
   {
     //Here, ST is float but ValueType is double for R2R. Due to issues with type conversions, just doing naive matrix multiplication in this case to not lose precision on rot_mat
     for (IndexType i = 0; i < BasisSetSize; i++)
       for (IndexType j = 0; j < OrbitalSetSize; j++)
       {
         const auto cur_elem = Nsplines * i + j;
         FullPrecValueType newval{0.};
         for (IndexType k = 0; k < OrbitalSetSize; k++)
         {
           const auto index = i * Nsplines + k;
           newval += (*coef_copy_)[index] * rot_mat[k][j];
         }
         spl_coefs[cur_elem] = newval;
       }
   }
 }

◆ assign_v()

void assign_v	(	int	bc_sign,
		const vContainer_type &	myV,
		ValueVector &	psi,
		int	first,
		int	last
	)		const

inline

Definition at line 152 of file SplineR2R.cpp.

References omptarget::min().

 {
   // protect last against kPoints.size() and psi.size()
   size_t last_real = std::min(kPoints.size(), psi.size());
   last             = last > last_real ? last_real : last;
 
   const ST signed_one = (bc_sign & 1) ? -1 : 1;
 #pragma omp simd
   for (size_t j = first; j < last; ++j)
     psi[first_spo + j] = signed_one * myV[j];
 }

◆ assign_vgh()

void assign_vgh	(	int	bc_sign,
		ValueVector &	psi,
		GradVector &	dpsi,
		HessVector &	grad_grad_psi,
		int	first,
		int	last
	)		const

Definition at line 310 of file SplineR2R.cpp.

References omptarget::min(), and qmcplusplus::v_m_v().

 {
   // protect last against kPoints.size() and psi.size()
   const size_t last_real = std::min(kPoints.size(), psi.size());
   last                   = last > last_real ? last_real : last;
 
   const ST signed_one = (bc_sign & 1) ? -1 : 1;
   const ST g00 = PrimLattice.G(0), g01 = PrimLattice.G(1), g02 = PrimLattice.G(2), g10 = PrimLattice.G(3),
            g11 = PrimLattice.G(4), g12 = PrimLattice.G(5), g20 = PrimLattice.G(6), g21 = PrimLattice.G(7),
            g22 = PrimLattice.G(8);
 
   const ST* restrict g0  = myG.data(0);
   const ST* restrict g1  = myG.data(1);
   const ST* restrict g2  = myG.data(2);
   const ST* restrict h00 = myH.data(0);
   const ST* restrict h01 = myH.data(1);
   const ST* restrict h02 = myH.data(2);
   const ST* restrict h11 = myH.data(3);
   const ST* restrict h12 = myH.data(4);
   const ST* restrict h22 = myH.data(5);
 
 #pragma omp simd
   for (size_t j = first; j < last; ++j)
   {
     //dot(PrimLattice.G,myG[j])
     const ST dX_r = g00 * g0[j] + g01 * g1[j] + g02 * g2[j];
     const ST dY_r = g10 * g0[j] + g11 * g1[j] + g12 * g2[j];
     const ST dZ_r = g20 * g0[j] + g21 * g1[j] + g22 * g2[j];
 
     const size_t psiIndex = j + first_spo;
     psi[psiIndex]         = signed_one * myV[j];
     dpsi[psiIndex][0]     = signed_one * dX_r;
     dpsi[psiIndex][1]     = signed_one * dY_r;
     dpsi[psiIndex][2]     = signed_one * dZ_r;
 
     const ST h_xx_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g00, g01, g02, g00, g01, g02);
     const ST h_xy_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g00, g01, g02, g10, g11, g12);
     const ST h_xz_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g00, g01, g02, g20, g21, g22);
     const ST h_yx_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g10, g11, g12, g00, g01, g02);
     const ST h_yy_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g10, g11, g12, g10, g11, g12);
     const ST h_yz_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g10, g11, g12, g20, g21, g22);
     const ST h_zx_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g20, g21, g22, g00, g01, g02);
     const ST h_zy_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g20, g21, g22, g10, g11, g12);
     const ST h_zz_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g20, g21, g22, g20, g21, g22);
 
     grad_grad_psi[psiIndex][0] = signed_one * h_xx_r;
     grad_grad_psi[psiIndex][1] = signed_one * h_xy_r;
     grad_grad_psi[psiIndex][2] = signed_one * h_xz_r;
     grad_grad_psi[psiIndex][3] = signed_one * h_yx_r;
     grad_grad_psi[psiIndex][4] = signed_one * h_yy_r;
     grad_grad_psi[psiIndex][5] = signed_one * h_yz_r;
     grad_grad_psi[psiIndex][6] = signed_one * h_zx_r;
     grad_grad_psi[psiIndex][7] = signed_one * h_zy_r;
     grad_grad_psi[psiIndex][8] = signed_one * h_zz_r;
   }
 }

◆ assign_vghgh()

void assign_vghgh	(	int	bc_sign,
		ValueVector &	psi,
		GradVector &	dpsi,
		HessVector &	grad_grad_psi,
		GGGVector &	grad_grad_grad_psi,
		int	first = `0`,
		int	last = `-1`
	)		const

Definition at line 394 of file SplineR2R.cpp.

References omptarget::min(), qmcplusplus::t3_contract(), and qmcplusplus::v_m_v().

 {
   // protect last against kPoints.size() and psi.size()
   const size_t last_real = std::min(kPoints.size(), psi.size());
   last                   = last < 0 ? last_real : (last > last_real ? last_real : last);
 
   const ST signed_one = (bc_sign & 1) ? -1 : 1;
   const ST g00 = PrimLattice.G(0), g01 = PrimLattice.G(1), g02 = PrimLattice.G(2), g10 = PrimLattice.G(3),
            g11 = PrimLattice.G(4), g12 = PrimLattice.G(5), g20 = PrimLattice.G(6), g21 = PrimLattice.G(7),
            g22 = PrimLattice.G(8);
 
   const ST* restrict g0  = myG.data(0);
   const ST* restrict g1  = myG.data(1);
   const ST* restrict g2  = myG.data(2);
   const ST* restrict h00 = myH.data(0);
   const ST* restrict h01 = myH.data(1);
   const ST* restrict h02 = myH.data(2);
   const ST* restrict h11 = myH.data(3);
   const ST* restrict h12 = myH.data(4);
   const ST* restrict h22 = myH.data(5);
 
   const ST* restrict gh000 = mygH.data(0);
   const ST* restrict gh001 = mygH.data(1);
   const ST* restrict gh002 = mygH.data(2);
   const ST* restrict gh011 = mygH.data(3);
   const ST* restrict gh012 = mygH.data(4);
   const ST* restrict gh022 = mygH.data(5);
   const ST* restrict gh111 = mygH.data(6);
   const ST* restrict gh112 = mygH.data(7);
   const ST* restrict gh122 = mygH.data(8);
   const ST* restrict gh222 = mygH.data(9);
 
   //SIMD doesn't work quite right yet.  Comment out until further debugging.
   //#pragma omp simd
   for (size_t j = first; j < last; ++j)
   {
     const ST val_r = myV[j];
 
 
     //dot(PrimLattice.G,myG[j])
     const ST dX_r = g00 * g0[j] + g01 * g1[j] + g02 * g2[j];
     const ST dY_r = g10 * g0[j] + g11 * g1[j] + g12 * g2[j];
     const ST dZ_r = g20 * g0[j] + g21 * g1[j] + g22 * g2[j];
 
     const size_t psiIndex = j + first_spo;
     psi[psiIndex]         = signed_one * val_r;
     dpsi[psiIndex][0]     = signed_one * dX_r;
     dpsi[psiIndex][1]     = signed_one * dY_r;
     dpsi[psiIndex][2]     = signed_one * dZ_r;
 
     //intermediates for computation of hessian. \partial_i \partial_j phi in cartesian coordinates.
     const ST f_xx_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g00, g01, g02, g00, g01, g02);
     const ST f_xy_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g00, g01, g02, g10, g11, g12);
     const ST f_xz_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g00, g01, g02, g20, g21, g22);
     const ST f_yy_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g10, g11, g12, g10, g11, g12);
     const ST f_yz_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g10, g11, g12, g20, g21, g22);
     const ST f_zz_r = v_m_v(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], g20, g21, g22, g20, g21, g22);
 
     /*    const ST h_xx_r=f_xx_r;
       const ST h_xy_r=f_xy_r+(kX*dY_i+kY*dX_i)-kX*kY*val_r;
       const ST h_xz_r=f_xz_r+(kX*dZ_i+kZ*dX_i)-kX*kZ*val_r;
       const ST h_yy_r=f_yy_r+2*kY*dY_i-kY*kY*val_r;
       const ST h_yz_r=f_yz_r+(kY*dZ_i+kZ*dY_i)-kY*kZ*val_r;
       const ST h_zz_r=f_zz_r+2*kZ*dZ_i-kZ*kZ*val_r; */
 
     grad_grad_psi[psiIndex][0] = f_xx_r * signed_one;
     grad_grad_psi[psiIndex][1] = f_xy_r * signed_one;
     grad_grad_psi[psiIndex][2] = f_xz_r * signed_one;
     grad_grad_psi[psiIndex][4] = f_yy_r * signed_one;
     grad_grad_psi[psiIndex][5] = f_yz_r * signed_one;
     grad_grad_psi[psiIndex][8] = f_zz_r * signed_one;
 
     //symmetry:
     grad_grad_psi[psiIndex][3] = grad_grad_psi[psiIndex][1];
     grad_grad_psi[psiIndex][6] = grad_grad_psi[psiIndex][2];
     grad_grad_psi[psiIndex][7] = grad_grad_psi[psiIndex][5];
     //These are the real and imaginary components of the third SPO derivative.  _xxx denotes
     // third derivative w.r.t. x, _xyz, a derivative with resepect to x,y, and z, and so on.
 
     const ST f3_xxx_r = t3_contract(gh000[j], gh001[j], gh002[j], gh011[j], gh012[j], gh022[j], gh111[j], gh112[j],
                                     gh122[j], gh222[j], g00, g01, g02, g00, g01, g02, g00, g01, g02);
     const ST f3_xxy_r = t3_contract(gh000[j], gh001[j], gh002[j], gh011[j], gh012[j], gh022[j], gh111[j], gh112[j],
                                     gh122[j], gh222[j], g00, g01, g02, g00, g01, g02, g10, g11, g12);
     const ST f3_xxz_r = t3_contract(gh000[j], gh001[j], gh002[j], gh011[j], gh012[j], gh022[j], gh111[j], gh112[j],
                                     gh122[j], gh222[j], g00, g01, g02, g00, g01, g02, g20, g21, g22);
     const ST f3_xyy_r = t3_contract(gh000[j], gh001[j], gh002[j], gh011[j], gh012[j], gh022[j], gh111[j], gh112[j],
                                     gh122[j], gh222[j], g00, g01, g02, g10, g11, g12, g10, g11, g12);
     const ST f3_xyz_r = t3_contract(gh000[j], gh001[j], gh002[j], gh011[j], gh012[j], gh022[j], gh111[j], gh112[j],
                                     gh122[j], gh222[j], g00, g01, g02, g10, g11, g12, g20, g21, g22);
     const ST f3_xzz_r = t3_contract(gh000[j], gh001[j], gh002[j], gh011[j], gh012[j], gh022[j], gh111[j], gh112[j],
                                     gh122[j], gh222[j], g00, g01, g02, g20, g21, g22, g20, g21, g22);
     const ST f3_yyy_r = t3_contract(gh000[j], gh001[j], gh002[j], gh011[j], gh012[j], gh022[j], gh111[j], gh112[j],
                                     gh122[j], gh222[j], g10, g11, g12, g10, g11, g12, g10, g11, g12);
     const ST f3_yyz_r = t3_contract(gh000[j], gh001[j], gh002[j], gh011[j], gh012[j], gh022[j], gh111[j], gh112[j],
                                     gh122[j], gh222[j], g10, g11, g12, g10, g11, g12, g20, g21, g22);
     const ST f3_yzz_r = t3_contract(gh000[j], gh001[j], gh002[j], gh011[j], gh012[j], gh022[j], gh111[j], gh112[j],
                                     gh122[j], gh222[j], g10, g11, g12, g20, g21, g22, g20, g21, g22);
     const ST f3_zzz_r = t3_contract(gh000[j], gh001[j], gh002[j], gh011[j], gh012[j], gh022[j], gh111[j], gh112[j],
                                     gh122[j], gh222[j], g20, g21, g22, g20, g21, g22, g20, g21, g22);
 
     //Here is where we build up the components of the physical hessian gradient, namely, d^3/dx^3(e^{-ik*r}\phi(r)
     /*     const ST gh_xxx_r= f3_xxx_r + 3*kX*f_xx_i - 3*kX*kX*dX_r - kX*kX*kX*val_i;
       const ST gh_xxy_r= f3_xxy_r +(kY*f_xx_i+2*kX*f_xy_i) - (kX*kX*dY_r+2*kX*kY*dX_r)-kX*kX*kY*val_i; 
       const ST gh_xxz_r= f3_xxz_r +(kZ*f_xx_i+2*kX*f_xz_i) - (kX*kX*dZ_r+2*kX*kZ*dX_r)-kX*kX*kZ*val_i; 
       const ST gh_xyy_r= f3_xyy_r +(2*kY*f_xy_i+kX*f_yy_i) - (2*kX*kY*dY_r+kY*kY*dX_r)-kX*kY*kY*val_i;
       const ST gh_xyz_r= f3_xyz_r +(kX*f_yz_i+kY*f_xz_i+kZ*f_xy_i)-(kX*kY*dZ_r+kY*kZ*dX_r+kZ*kX*dY_r) - kX*kY*kZ*val_i;
       const ST gh_xzz_r= f3_xzz_r +(2*kZ*f_xz_i+kX*f_zz_i) - (2*kX*kZ*dZ_r+kZ*kZ*dX_r)-kX*kZ*kZ*val_i;
       const ST gh_yyy_r= f3_yyy_r + 3*kY*f_yy_i - 3*kY*kY*dY_r - kY*kY*kY*val_i;
       const ST gh_yyz_r= f3_yyz_r +(kZ*f_yy_i+2*kY*f_yz_i) - (kY*kY*dZ_r+2*kY*kZ*dY_r)-kY*kY*kZ*val_i; 
       const ST gh_yzz_r= f3_yzz_r +(2*kZ*f_yz_i+kY*f_zz_i) - (2*kY*kZ*dZ_r+kZ*kZ*dY_r)-kY*kZ*kZ*val_i;
       const ST gh_zzz_r= f3_zzz_r + 3*kZ*f_zz_i - 3*kZ*kZ*dZ_r - kZ*kZ*kZ*val_i;*/
     //[x][xx] //These are the unique entries
     grad_grad_grad_psi[psiIndex][0][0] = signed_one * f3_xxx_r;
     grad_grad_grad_psi[psiIndex][0][1] = signed_one * f3_xxy_r;
     grad_grad_grad_psi[psiIndex][0][2] = signed_one * f3_xxz_r;
     grad_grad_grad_psi[psiIndex][0][4] = signed_one * f3_xyy_r;
     grad_grad_grad_psi[psiIndex][0][5] = signed_one * f3_xyz_r;
     grad_grad_grad_psi[psiIndex][0][8] = signed_one * f3_xzz_r;
 
     //filling in the symmetric terms.  Filling out the xij terms
     grad_grad_grad_psi[psiIndex][0][3] = grad_grad_grad_psi[psiIndex][0][1];
     grad_grad_grad_psi[psiIndex][0][6] = grad_grad_grad_psi[psiIndex][0][2];
     grad_grad_grad_psi[psiIndex][0][7] = grad_grad_grad_psi[psiIndex][0][5];
 
     //Now for everything that's a permutation of the above:
     grad_grad_grad_psi[psiIndex][1][0] = grad_grad_grad_psi[psiIndex][0][1];
     grad_grad_grad_psi[psiIndex][1][1] = grad_grad_grad_psi[psiIndex][0][4];
     grad_grad_grad_psi[psiIndex][1][2] = grad_grad_grad_psi[psiIndex][0][5];
     grad_grad_grad_psi[psiIndex][1][3] = grad_grad_grad_psi[psiIndex][0][4];
     grad_grad_grad_psi[psiIndex][1][6] = grad_grad_grad_psi[psiIndex][0][5];
 
     grad_grad_grad_psi[psiIndex][2][0] = grad_grad_grad_psi[psiIndex][0][2];
     grad_grad_grad_psi[psiIndex][2][1] = grad_grad_grad_psi[psiIndex][0][5];
     grad_grad_grad_psi[psiIndex][2][2] = grad_grad_grad_psi[psiIndex][0][8];
     grad_grad_grad_psi[psiIndex][2][3] = grad_grad_grad_psi[psiIndex][0][5];
     grad_grad_grad_psi[psiIndex][2][6] = grad_grad_grad_psi[psiIndex][0][8];
 
     grad_grad_grad_psi[psiIndex][1][4] = signed_one * f3_yyy_r;
     grad_grad_grad_psi[psiIndex][1][5] = signed_one * f3_yyz_r;
     grad_grad_grad_psi[psiIndex][1][8] = signed_one * f3_yzz_r;
 
     grad_grad_grad_psi[psiIndex][1][7] = grad_grad_grad_psi[psiIndex][1][5];
     grad_grad_grad_psi[psiIndex][2][4] = grad_grad_grad_psi[psiIndex][1][5];
     grad_grad_grad_psi[psiIndex][2][5] = grad_grad_grad_psi[psiIndex][1][8];
     grad_grad_grad_psi[psiIndex][2][7] = grad_grad_grad_psi[psiIndex][1][8];
 
     grad_grad_grad_psi[psiIndex][2][8] = signed_one * f3_zzz_r;
   }
 }

◆ assign_vgl()

void assign_vgl	(	int	bc_sign,
		ValueVector &	psi,
		GradVector &	dpsi,
		ValueVector &	d2psi,
		int	first,
		int	last
	)		const

inline

Definition at line 226 of file SplineR2R.cpp.

References omptarget::min(), and qmcplusplus::SymTrace().

 {
   // protect last against kPoints.size() and psi.size()
   size_t last_real = std::min(kPoints.size(), psi.size());
   last             = last > last_real ? last_real : last;
 
   const ST signed_one = (bc_sign & 1) ? -1 : 1;
   const ST g00 = PrimLattice.G(0), g01 = PrimLattice.G(1), g02 = PrimLattice.G(2), g10 = PrimLattice.G(3),
            g11 = PrimLattice.G(4), g12 = PrimLattice.G(5), g20 = PrimLattice.G(6), g21 = PrimLattice.G(7),
            g22      = PrimLattice.G(8);
   const ST symGG[6] = {GGt[0], GGt[1] + GGt[3], GGt[2] + GGt[6], GGt[4], GGt[5] + GGt[7], GGt[8]};
 
   const ST* restrict g0  = myG.data(0);
   const ST* restrict g1  = myG.data(1);
   const ST* restrict g2  = myG.data(2);
   const ST* restrict h00 = myH.data(0);
   const ST* restrict h01 = myH.data(1);
   const ST* restrict h02 = myH.data(2);
   const ST* restrict h11 = myH.data(3);
   const ST* restrict h12 = myH.data(4);
   const ST* restrict h22 = myH.data(5);
 
 #pragma omp simd
   for (size_t j = first; j < last; ++j)
   {
     const size_t psiIndex = first_spo + j;
     psi[psiIndex]         = signed_one * myV[j];
     dpsi[psiIndex][0]     = signed_one * (g00 * g0[j] + g01 * g1[j] + g02 * g2[j]);
     dpsi[psiIndex][1]     = signed_one * (g10 * g0[j] + g11 * g1[j] + g12 * g2[j]);
     dpsi[psiIndex][2]     = signed_one * (g20 * g0[j] + g21 * g1[j] + g22 * g2[j]);
     d2psi[psiIndex]       = signed_one * SymTrace(h00[j], h01[j], h02[j], h11[j], h12[j], h22[j], symGG);
   }
 }

◆ assign_vgl_from_l()

void assign_vgl_from_l	(	int	bc_sign,
		ValueVector &	psi,
		GradVector &	dpsi,
		ValueVector &	d2psi
	)

inline

assign_vgl_from_l can be used when myL is precomputed and myV,myG,myL in cartesian

Definition at line 268 of file SplineR2R.cpp.

 {
   const ST signed_one   = (bc_sign & 1) ? -1 : 1;
   const ST* restrict g0 = myG.data(0);
   const ST* restrict g1 = myG.data(1);
   const ST* restrict g2 = myG.data(2);
 
   const size_t last_real = last_spo > psi.size() ? psi.size() : last_spo;
 #pragma omp simd
   for (int psiIndex = first_spo; psiIndex < last_real; ++psiIndex)
   {
     const size_t j    = psiIndex - first_spo;
     psi[psiIndex]     = signed_one * myV[j];
     dpsi[psiIndex][0] = signed_one * g0[j];
     dpsi[psiIndex][1] = signed_one * g1[j];
     dpsi[psiIndex][2] = signed_one * g2[j];
     d2psi[psiIndex]   = signed_one * myL[j];
   }
 }

◆ bcast_tables()

void bcast_tables ( Communicate * comm )

inline

Definition at line 120 of file SplineR2R.h.

References qmcplusplus::comm, and SplineR2R< ST >::SplineInst.

120 { chunked_bcast(comm, SplineInst->getSplinePtr()); }

qmcplusplus::comm

Communicate * comm

Definition: test_EstimatorManagerNew.cpp:50

qmcplusplus::SplineR2R::SplineInst

std::shared_ptr< MultiBspline< ST > > SplineInst

multi bspline set

Definition: SplineR2R.h:59

◆ convertPos()

int convertPos	(	const PointType &	r,
		PointType &	ru
	)

inline

convert position in PrimLattice unit and return sign

Definition at line 153 of file SplineR2R.h.

References BsplineSet::D, qmcplusplus::floor(), BsplineSet::HalfG, SplineR2R< ST >::PrimLattice, and CrystalLattice< T, D >::toUnit().

   {
     ru          = PrimLattice.toUnit(r);
     int bc_sign = 0;
     for (int i = 0; i < D; i++)
       if (-std::numeric_limits<ST>::epsilon() < ru[i] && ru[i] < 0)
         ru[i] = ST(0.0);
       else
       {
         ST img = std::floor(ru[i]);
         ru[i] -= img;
         bc_sign += HalfG[i] * (int)img;
       }
     return bc_sign;
   }

◆ create_spline()

void create_spline	(	GT &	xyz_g,
		BCT &	xyz_bc
	)

inline

Definition at line 134 of file SplineR2R.h.

References qmcplusplus::app_log(), qmcplusplus::dot(), CrystalLattice< T, D >::G, SplineR2R< ST >::GGt, SplineR2R< ST >::myV, SplineR2R< ST >::PrimLattice, Vector< T, Alloc >::size(), SplineR2R< ST >::SplineInst, and qmcplusplus::transpose().

   {
     GGt        = dot(transpose(PrimLattice.G), PrimLattice.G);
     SplineInst = std::make_shared<MultiBspline<ST>>();
     SplineInst->create(xyz_g, xyz_bc, myV.size());
 
     app_log() << "MEMORY " << SplineInst->sizeInByte() / (1 << 20) << " MB allocated "
               << "for the coefficients in 3D spline orbital representation" << std::endl;
   }

◆ evaluateDetRatios()

void evaluateDetRatios	(	const VirtualParticleSet &	VP,
		ValueVector &	psi,
		const ValueVector &	psiinv,
		std::vector< TT > &	ratios
	)

override

Definition at line 183 of file SplineR2R.cpp.

References ParticleSet::activeR(), qmcplusplus::C2C::assign_v(), qmcplusplus::simd::dot(), FairDivideAligned(), VirtualParticleSet::getTotalNum(), omp_get_num_threads(), and omp_get_thread_num().

 {
   const bool need_resize = ratios_private.rows() < VP.getTotalNum();
 
 #pragma omp parallel
   {
     int tid = omp_get_thread_num();
     // initialize thread private ratios
     if (need_resize)
     {
       if (tid == 0) // just like #pragma omp master, but one fewer call to the runtime
         ratios_private.resize(VP.getTotalNum(), omp_get_num_threads());
 #pragma omp barrier
     }
     int first, last;
     FairDivideAligned(psi.size(), getAlignment<ST>(), omp_get_num_threads(), tid, first, last);
     const int last_real = kPoints.size() < last ? kPoints.size() : last;
 
     for (int iat = 0; iat < VP.getTotalNum(); ++iat)
     {
       const PointType& r = VP.activeR(iat);
       PointType ru;
       int bc_sign = convertPos(r, ru);
 
       spline2::evaluate3d(SplineInst->getSplinePtr(), ru, myV, first, last);
       assign_v(bc_sign, myV, psi, first, last_real);
       ratios_private[iat][tid] = simd::dot(psi.data() + first, psiinv.data() + first, last_real - first);
     }
   }
 
   // do the reduction manually
   for (int iat = 0; iat < VP.getTotalNum(); ++iat)
   {
     ratios[iat] = TT(0);
     for (int tid = 0; tid < ratios_private.cols(); tid++)
       ratios[iat] += ratios_private[iat][tid];
   }
 }

◆ evaluateValue()

void evaluateValue	(	const ParticleSet &	P,
		const int	iat,
		ValueVector &	psi
	)

overridevirtual

evaluate the values of this single-particle orbital set

Parameters

P	current ParticleSet
iat	active particle
psi	values of the SPO

Implements SPOSet.

Definition at line 166 of file SplineR2R.cpp.

References ParticleSet::activeR(), qmcplusplus::C2C::assign_v(), FairDivideAligned(), omp_get_num_threads(), and omp_get_thread_num().

 {
   const PointType& r = P.activeR(iat);
   PointType ru;
   int bc_sign = convertPos(r, ru);
 
 #pragma omp parallel
   {
     int first, last;
     FairDivideAligned(psi.size(), getAlignment<ST>(), omp_get_num_threads(), omp_get_thread_num(), first, last);
 
     spline2::evaluate3d(SplineInst->getSplinePtr(), ru, myV, first, last);
     assign_v(bc_sign, myV, psi, first, last);
   }
 }

◆ evaluateVGH()

void evaluateVGH	(	const ParticleSet &	P,
		const int	iat,
		ValueVector &	psi,
		GradVector &	dpsi,
		HessVector &	grad_grad_psi
	)

overridevirtual

evaluate the values, gradients and hessians of this single-particle orbital set

Parameters

P	current ParticleSet
iat	active particle
psi	values of the SPO
dpsi	gradients of the SPO
grad_grad_psi	hessians of the SPO

Reimplemented from SPOSet.

Definition at line 373 of file SplineR2R.cpp.

References ParticleSet::activeR(), FairDivideAligned(), omp_get_num_threads(), and omp_get_thread_num().

 {
   const PointType& r = P.activeR(iat);
   PointType ru;
   int bc_sign = convertPos(r, ru);
 
 #pragma omp parallel
   {
     int first, last;
     FairDivideAligned(psi.size(), getAlignment<ST>(), omp_get_num_threads(), omp_get_thread_num(), first, last);
 
     spline2::evaluate3d_vgh(SplineInst->getSplinePtr(), ru, myV, myG, myH, first, last);
     assign_vgh(bc_sign, psi, dpsi, grad_grad_psi, first, last);
   }
 }

◆ evaluateVGHGH()

void evaluateVGHGH	(	const ParticleSet &	P,
		const int	iat,
		ValueVector &	psi,
		GradVector &	dpsi,
		HessVector &	grad_grad_psi,
		GGGVector &	grad_grad_grad_psi
	)

overridevirtual

evaluate the values, gradients, hessians, and grad hessians of this single-particle orbital set

Parameters

P	current ParticleSet
iat	active particle
psi	values of the SPO
dpsi	gradients of the SPO
grad_grad_psi	hessians of the SPO
grad_grad_grad_psi	grad hessians of the SPO

Reimplemented from SPOSet.

Definition at line 551 of file SplineR2R.cpp.

References ParticleSet::activeR(), FairDivideAligned(), omp_get_num_threads(), and omp_get_thread_num().

 {
   const PointType& r = P.activeR(iat);
   PointType ru;
   int bc_sign = convertPos(r, ru);
 
 #pragma omp parallel
   {
     int first, last;
     FairDivideAligned(psi.size(), getAlignment<ST>(), omp_get_num_threads(), omp_get_thread_num(), first, last);
 
     spline2::evaluate3d_vghgh(SplineInst->getSplinePtr(), ru, myV, myG, myH, mygH, first, last);
     assign_vghgh(bc_sign, psi, dpsi, grad_grad_psi, grad_grad_grad_psi, first, last);
   }
 }

◆ evaluateVGL()

void evaluateVGL	(	const ParticleSet &	P,
		const int	iat,
		ValueVector &	psi,
		GradVector &	dpsi,
		ValueVector &	d2psi
	)

overridevirtual

evaluate the values, gradients and laplacians of this single-particle orbital set

Parameters

P	current ParticleSet
iat	active particle
psi	values of the SPO
dpsi	gradients of the SPO
d2psi	laplacians of the SPO

Implements SPOSet.

Definition at line 289 of file SplineR2R.cpp.

References ParticleSet::activeR(), qmcplusplus::C2C::assign_vgl(), FairDivideAligned(), omp_get_num_threads(), and omp_get_thread_num().

 {
   const PointType& r = P.activeR(iat);
   PointType ru;
   int bc_sign = convertPos(r, ru);
 
 #pragma omp parallel
   {
     int first, last;
     FairDivideAligned(psi.size(), getAlignment<ST>(), omp_get_num_threads(), omp_get_thread_num(), first, last);
 
     spline2::evaluate3d_vgh(SplineInst->getSplinePtr(), ru, myV, myG, myH, first, last);
     assign_vgl(bc_sign, psi, dpsi, d2psi, first, last);
   }
 }

◆ flush_zero()

void flush_zero ( )

inline

Definition at line 144 of file SplineR2R.h.

References SplineR2R< ST >::SplineInst.

144 { SplineInst->flush_zero(); }

qmcplusplus::SplineR2R::SplineInst

std::shared_ptr< MultiBspline< ST > > SplineInst

multi bspline set

Definition: SplineR2R.h:59

◆ gather_tables()

void gather_tables ( Communicate * comm )

inline

Definition at line 122 of file SplineR2R.h.

References qmcplusplus::comm, FairDivideLow(), gatherv(), BsplineSet::kPoints, BsplineSet::offset, Communicate::size(), and SplineR2R< ST >::SplineInst.

   {
     if (comm->size() == 1)
       return;
     const int Nbands      = kPoints.size();
     const int Nbandgroups = comm->size();
     offset.resize(Nbandgroups + 1, 0);
     FairDivideLow(Nbands, Nbandgroups, offset);
     gatherv(comm, SplineInst->getSplinePtr(), SplineInst->getSplinePtr()->z_stride, offset);
   }

◆ getClassName()

virtual std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements SPOSet.

Definition at line 82 of file SplineR2R.h.

82 { return "SplineR2R"; }

◆ getKeyword()

virtual std::string getKeyword ( ) const

inlineoverridevirtual

Implements BsplineSet.

Definition at line 83 of file SplineR2R.h.

83 { return "SplineR2R"; }

◆ isComplex()

bool isComplex ( ) const

inlineoverridevirtual

Implements BsplineSet.

Definition at line 84 of file SplineR2R.h.

84 { return false; };

◆ isRotationSupported()

bool isRotationSupported ( ) const

inlineoverridevirtual

return true if this SPOSet can be wrappered by RotatedSPO

Reimplemented from SPOSet.

Definition at line 85 of file SplineR2R.h.

85 { return true; }

◆ makeClone()

std::unique_ptr<SPOSet> makeClone ( ) const

inlineoverridevirtual

make a clone of itself every derived class must implement this to have threading working correctly.

Implements BsplineSet.

Definition at line 87 of file SplineR2R.h.

87 { return std::make_unique<SplineR2R>(*this); }

◆ read_splines()

bool read_splines ( hdf_archive & h5f )

Definition at line 39 of file SplineR2R.cpp.

References hdf_archive::readEntry().

 {
   std::ostringstream o;
   o << "spline_" << MyIndex;
   einspline_engine<SplineType> bigtable(SplineInst->getSplinePtr());
   return h5f.readEntry(bigtable, o.str().c_str()); //"spline_0");
 }

◆ resizeStorage()

void resizeStorage	(	size_t	n,
		size_t	nvals
	)

inline

Definition at line 107 of file SplineR2R.h.

References BsplineSet::HalfG, BsplineSet::init_base(), SplineR2R< ST >::IsGamma, SplineR2R< ST >::myG, SplineR2R< ST >::mygH, SplineR2R< ST >::myH, SplineR2R< ST >::myL, SplineR2R< ST >::myV, qmcplusplus::n, VectorSoaContainer< T, D, Alloc >::resize(), and Vector< T, Alloc >::resize().

   {
     init_base(n);
     const size_t npad = getAlignedSize<ST>(n);
     myV.resize(npad);
     myG.resize(npad);
     myL.resize(npad);
     myH.resize(npad);
     mygH.resize(npad);
 
     IsGamma = ((HalfG[0] == 0) && (HalfG[1] == 0) && (HalfG[2] == 0));
   }

◆ set_spline()

void set_spline	(	SingleSplineType *	spline_r,
		SingleSplineType *	spline_i,
		int	twist,
		int	ispline,
		int	level
	)

inline

Definition at line 29 of file SplineR2R.cpp.

 {
   SplineInst->copy_spline(spline_r, ispline);
 }

◆ storeParamsBeforeRotation()

void storeParamsBeforeRotation ( )

overridevirtual

Store an original copy of the spline coefficients for orbital rotation.

Reimplemented from SPOSet.

Definition at line 57 of file SplineR2R.cpp.

References qmcplusplus::syclBLAS::copy_n().

 {
   const auto spline_ptr     = SplineInst->getSplinePtr();
   const auto coefs_tot_size = spline_ptr->coefs_size;
   coef_copy_                = std::make_shared<std::vector<ST>>(coefs_tot_size);
 
   std::copy_n(spline_ptr->coefs, coefs_tot_size, coef_copy_->begin());
 }

◆ write_splines()

bool write_splines ( hdf_archive & h5f )

Definition at line 48 of file SplineR2R.cpp.

References hdf_archive::writeEntry().

 {
   std::ostringstream o;
   o << "spline_" << MyIndex;
   einspline_engine<SplineType> bigtable(SplineInst->getSplinePtr());
   return h5f.writeEntry(bigtable, o.str().c_str()); //"spline_0");
 }

Friends And Related Function Documentation

◆ BsplineReader

friend struct BsplineReader

friend

Definition at line 216 of file SplineR2R.h.

◆ SplineSetReader

friend class SplineSetReader

friend

Definition at line 215 of file SplineR2R.h.

Member Data Documentation

◆ coef_copy_

std::shared_ptr<std::vector<ST> > coef_copy_

private

Copy of original splines for orbital rotation.

Definition at line 62 of file SplineR2R.h.

◆ GGt

Tensor<ST, 3> GGt

private

$GGt=G^t G $ , transformation for tensor in LatticeUnit to CartesianUnit, e.g. Hessian

Definition at line 57 of file SplineR2R.h.

Referenced by SplineR2R< ST >::create_spline().

◆ IsGamma

bool IsGamma

private

Definition at line 55 of file SplineR2R.h.

Referenced by SplineR2R< ST >::resizeStorage().

◆ myG

gContainer_type myG

protected

Definition at line 74 of file SplineR2R.h.

Referenced by SplineR2R< ST >::resizeStorage().

◆ mygH

ghContainer_type mygH

protected

Definition at line 76 of file SplineR2R.h.

Referenced by SplineR2R< ST >::resizeStorage().

◆ myH

hContainer_type myH

protected

Definition at line 75 of file SplineR2R.h.

Referenced by SplineR2R< ST >::resizeStorage().

◆ myL

vContainer_type myL

protected

Definition at line 73 of file SplineR2R.h.

Referenced by SplineR2R< ST >::resizeStorage().

◆ myV

vContainer_type myV

protected

intermediate result vectors

Definition at line 72 of file SplineR2R.h.

Referenced by SplineR2R< ST >::create_spline(), and SplineR2R< ST >::resizeStorage().

◆ PrimLattice

CrystalLattice<ST, 3> PrimLattice

protected

primitive cell

Definition at line 70 of file SplineR2R.h.

Referenced by SplineR2R< ST >::convertPos(), and SplineR2R< ST >::create_spline().

◆ ratios_private

Matrix<TT> ratios_private

private

thread private ratios for reduction when using nested threading, numVP x numThread

Definition at line 65 of file SplineR2R.h.

◆ SplineInst

std::shared_ptr<MultiBspline<ST> > SplineInst

private

multi bspline set

Definition at line 59 of file SplineR2R.h.

Referenced by SplineR2R< ST >::bcast_tables(), SplineR2R< ST >::create_spline(), SplineR2R< ST >::flush_zero(), and SplineR2R< ST >::gather_tables().

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

/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/BsplineFactory/SplineR2R.h
/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/BsplineFactory/SplineR2R.cpp

Public Types

Public Member Functions

Protected Attributes

Private Attributes

Friends

Additional Inherited Members

Detailed Description

template<typename ST> class qmcplusplus::SplineR2R< ST >

Member Typedef Documentation

◆ BCType

◆ DataType

◆ gContainer_type

◆ ghContainer_type

◆ hContainer_type

◆ PointType

◆ SingleSplineType

◆ SplineType

◆ TT

◆ vContainer_type

Constructor & Destructor Documentation

◆ SplineR2R() [1/2]

◆ SplineR2R() [2/2]

Member Function Documentation

◆ applyRotation()

◆ assign_v()

◆ assign_vgh()

◆ assign_vghgh()

◆ assign_vgl()

◆ assign_vgl_from_l()

◆ bcast_tables()

◆ convertPos()

◆ create_spline()

◆ evaluateDetRatios()

◆ evaluateValue()

◆ evaluateVGH()

◆ evaluateVGHGH()

◆ evaluateVGL()

◆ flush_zero()

◆ gather_tables()

◆ getClassName()

◆ getKeyword()

◆ isComplex()

◆ isRotationSupported()

◆ makeClone()

◆ read_splines()

◆ resizeStorage()

◆ set_spline()

◆ storeParamsBeforeRotation()

◆ write_splines()

Friends And Related Function Documentation

◆ BsplineReader

◆ SplineSetReader

Member Data Documentation

◆ coef_copy_

◆ GGt

◆ IsGamma

◆ myG

◆ mygH

◆ myH

◆ myL

◆ myV

◆ PrimLattice

◆ ratios_private

◆ SplineInst

template<typename ST>
class qmcplusplus::SplineR2R< ST >