LIBINT  2.1.0-stable
Public Types | Public Member Functions | Public Attributes | Static Public Attributes | List of all members
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

SafePtr< cdoubleCdouble (double a)
 

Public Attributes

SafePtr< rdoublevX_Y [np]
 X-Y vectors, where X and Y are for the same particle: X_Y[0] = AB, X_Y[1] = CD, etc.
 
SafePtr< rdoubleX_Y [np][3]
 Cartesian components of X-Y vectors.
 
SafePtr< rdoublevY_X [np]
 Y-X vectors, where X and Y are for the same particle: Y_X[0] = BA, Y_X[1] = DC, etc.
 
SafePtr< rdoubleY_X [np][3]
 Cartesian components of Y_X vectors.
 
SafePtr< rdoublevXY_X [np][2]
 XY-X vectors: XY is either P or Q, X is either (A or B) or (C or D). More...
 
SafePtr< rdoubleXY_X [np][2][3]
 cartesian components of vXY_X vector
 
SafePtr< rdoublevW_XY [np]
 W-XY vectors: vW_XY[0] = W-P, vW_XY[1] = W-Q.
 
SafePtr< rdoubleW_XY [np][3]
 cartesian components of W_XY vector
 
SafePtr< rdoublezeta [np][2]
 orbital exponents
 
SafePtr< rdoublezeta2 [np][2]
 squared orbital exponents
 
SafePtr< rdoublealpha12 [np]
 alpha12[p] is the sum of exponents for particle p: alpha12[0] = zeta, alpha12[1] = eta.
 
SafePtr< rdoublerho
 rho = zeta*eta/(zeta+eta)
 
SafePtr< rdoubleone_o_2alpha12 [np]
 1/(2*alpha12)
 
SafePtr< rdoublerho_o_alpha12 [np]
 rho/alpha12
 
SafePtr< rdoubleone_o_2alphasum
 1/(2*(zeta+eta))
 
SafePtr< rdoubleTwoPRepITR_vpfac0 [np]
 Prefactors for the ITR relation for TwoPRep integrals (a+1 0|c0): More...
 
SafePtr< rdoubleTwoPRepITR_pfac0 [np][3]
 cartesian components of pfac0 vector
 
SafePtr< rdoubleTwoPRepITR_pfac1 [np]
 prefactor in front of (a0|c+1 0) = -alpha12[1]/alpha12[0]
 
SafePtr< rdoubleR12kG12VRR_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] More...
 
SafePtr< rdoubleR12kG12VRR_pfac0 [np][3]
 cartesian components of pfac0 vector
 
SafePtr< rdoubleR12kG12VRR_pfac1 [np]
 prefactor in front of (a-1 0|c0)
 
SafePtr< rdoubleR12kG12VRR_pfac2
 prefactor in front of (a0|c-1 0)
 
SafePtr< rdoubleR12kG12VRR_pfac3 [np]
 prefactor in front of (|k-2|)
 
SafePtr< rdoubleR12kG12VRR_vpfac4 [np]
 prefactor in front of (a0|k-2|c0)
 
SafePtr< rdoubleR12kG12VRR_pfac4 [np][3]
 cartesian components of pfac4 vector
 
SafePtr< rdoubleOverlap00_1d [3]
 Precomputed 1-d integrals. More...
 
SafePtr< cdoubleN_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

SafePtr<rdouble> libint2::Prefactors::Overlap00_1d[3]

Precomputed 1-d integrals.

(0|0)_xyz 1-d overlap integrals

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

SafePtr<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]

SafePtr<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: