libint2::Prefactors Class Reference

Prefactors is a collection of common quantities which appear as prefactors in recurrence relations for Gaussian integrals. More...

#include <prefactors.h>

Public Types
typedef RTimeEntity< double >	rdouble
typedef CTimeEntity< double >	cdouble

Public Member Functions
std::shared_ptr< cdouble >	Cdouble (double a)

Public Attributes
std::shared_ptr< rdouble >	vX_Y [np]
	X-Y vectors, where X and Y are for the same particle: X_Y[0] = AB, X_Y[1] = CD, etc.
std::shared_ptr< rdouble >	X_Y [np][3]
	Cartesian components of X-Y vectors.
std::shared_ptr< rdouble >	vY_X [np]
	Y-X vectors, where X and Y are for the same particle: Y_X[0] = BA, Y_X[1] = DC, etc.
std::shared_ptr< rdouble >	Y_X [np][3]
	Cartesian components of Y_X vectors.
std::shared_ptr< rdouble >	vXY_X [np][2]
	XY-X vectors: XY is either P or Q, X is either (A or B) or (C or D).
std::shared_ptr< rdouble >	XY_X [np][2][3]
	cartesian components of vXY_X vector
std::shared_ptr< rdouble >	vW_XY [np]
	W-XY vectors: vW_XY[0] = W-P, vW_XY[1] = W-Q.
std::shared_ptr< rdouble >	W_XY [np][3]
	cartesian components of W_XY vector
std::shared_ptr< rdouble >	zeta [np][2]
	orbital exponents
std::shared_ptr< rdouble >	zeta2 [np][2]
	squared orbital exponents
std::shared_ptr< rdouble >	alpha12 [np]
	alpha12[p] is the sum of exponents for particle p: alpha12[0] = zeta, alpha12[1] = eta.
std::shared_ptr< rdouble >	rho
	rho = zeta*eta/(zeta+eta)
std::shared_ptr< rdouble >	one_o_2alpha12 [np]
	1/(2*alpha12)
std::shared_ptr< rdouble >	rho_o_alpha12 [np]
	rho/alpha12
std::shared_ptr< rdouble >	one_o_2alphasum
	1/(2*(zeta+eta))
std::shared_ptr< rdouble >	TwoPRepITR_vpfac0 [np]
	Prefactors for the ITR relation for TwoPRep integrals (a+1 0|c0):
std::shared_ptr< rdouble >	TwoPRepITR_pfac0 [np][3]
	cartesian components of pfac0 vector
std::shared_ptr< rdouble >	TwoPRepITR_pfac1 [np]
	prefactor in front of (a0|c+1 0) = -alpha12[1]/alpha12[0]
std::shared_ptr< rdouble >	R12kG12VRR_vpfac0 [np]
	prefactor in front of (a-1 0|c0) is one_o_2alpha12[0] prefactor in front of (a0|c-1 0) is one_o_2alpha12[0]
std::shared_ptr< rdouble >	R12kG12VRR_pfac0 [np][3]
	cartesian components of pfac0 vector
std::shared_ptr< rdouble >	R12kG12VRR_pfac1 [np]
	prefactor in front of (a-1 0|c0)
std::shared_ptr< rdouble >	R12kG12VRR_pfac2
	prefactor in front of (a0|c-1 0)
std::shared_ptr< rdouble >	R12kG12VRR_pfac3 [np]
	prefactor in front of (|k-2|)
std::shared_ptr< rdouble >	R12kG12VRR_vpfac4 [np]
	prefactor in front of (a0|k-2|c0)
std::shared_ptr< rdouble >	R12kG12VRR_pfac4 [np][3]
	cartesian components of pfac4 vector
std::shared_ptr< rdouble >	Overlap00_1d [3]
	Precomputed 1-d integrals.
std::shared_ptr< cdouble >	N_i [NMAX]
	integers represented as doubles

Static Public Attributes
static const unsigned int	NMAX = 200
static const unsigned int	np = 2
static const unsigned int	nfunc_per_part = 1

Detailed Description

Prefactors is a collection of common quantities which appear as prefactors in recurrence relations for Gaussian integrals.

See Obara-Saika paper for description of the most common ones.

Member Data Documentation

Overlap00_1d

std::shared_ptr<rdouble> libint2::Prefactors::Overlap00_1d[3]

Precomputed 1-d integrals.

(0|0)_xyz 1-d overlap integrals

R12kG12VRR_vpfac0

std::shared_ptr<rdouble> libint2::Prefactors::R12kG12VRR_vpfac0[np]

prefactor in front of (a-1 0|c0) is one_o_2alpha12[0] prefactor in front of (a0|c-1 0) is one_o_2alpha12[0]

Prefactors for the VRR relation for R12_k_G12 integrals (k>=0): prefactor in front of (a0|c0)

TwoPRepITR_vpfac0

std::shared_ptr<rdouble> libint2::Prefactors::TwoPRepITR_vpfac0[np]

Prefactors for the ITR relation for TwoPRep integrals (a+1 0|c0):

prefactor in front of (a0|c0) = -(zeta[0][1] AB + zeta[1][1] CD)/alpha12[0]

vXY_X

std::shared_ptr<rdouble> libint2::Prefactors::vXY_X[np][2]

XY-X vectors: XY is either P or Q, X is either (A or B) or (C or D).

Hence, vXY_X[0][0] = P-A, vXY_X[1][0] = Q-C, vXY_X[0][1] = P-B, and vXY_X[1][1] = Q-D.

---

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

• prefactors.h
• prefactors.cc