kernels.h File Reference

#include <occ/ints/boys.h>
#include <occ/ints/ecoeffs.h>
#include <occ/ints/rints.h>
#include <Eigen/Dense>
#include <array>
#include <vector>

Include dependency graph for kernels.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	occ::ints::PrimitivePairData< T >
	Data for a single primitive pair (precomputed at initialization) More...
struct	occ::ints::ShellPairData< T >
	Data for a shell pair (all primitive pairs) More...
struct	occ::ints::AuxPrimitiveData< T >
	Data for a single auxiliary primitive (single-center) More...
struct	occ::ints::AuxShellData< T >
	Data for an auxiliary shell. More...

Namespaces
namespace	occ
namespace	occ::ints

Macros
#define	DISPATCH_PAIR(LA, LB)

Functions
template<typename T >
OCC_GPU_ENABLED OCC_GPU_INLINE constexpr T	occ::ints::spherical_harmonic_factor (int l)
template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED void	occ::ints::esp_primitive (T a, T b, const T *A, const T *B, const T *C, const T *boys_table, T *integrals)
	ESP integral for a single primitive pair at a single point.
template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED void	occ::ints::esp_contracted (int na_prim, int nb_prim, const T *exponents_a, const T *exponents_b, const T *coeffs_a, const T *coeffs_b, const T *A, const T *B, const T *C, const T *boys_table, T *integrals)
	ESP integral for contracted shell pair at a single point.
template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>
void	occ::ints::esp_contracted_batch (int na_prim, int nb_prim, const T *exponents_a, const T *exponents_b, const T *coeffs_a, const T *coeffs_b, const T *A, const T *B, int npts, const T *C, const T *boys_table, T *integrals)
	ESP integrals for a shell pair at multiple points (vectorized over points) SHARK-style: E-coefficients computed once per primitive pair, reused for all points.
template<typename T , int LA, int LB>
void	occ::ints::build_e_matrix (const ECoeffs3D< T, LA, LB > &E, T *E_matrix)
	Build E-matrix for a primitive pair.
template<typename T , int LA, int LB>
ShellPairData< T >	occ::ints::precompute_shell_pair (int na_prim, int nb_prim, const T *exponents_a, const T *exponents_b, const T *coeffs_a, const T *coeffs_b, const T *A, const T *B)
	Precompute ShellPairData for a shell pair.
template<int LA, int LB>
constexpr size_t	occ::ints::esp_workspace_size (int npts)
	Calculate workspace size for esp_evaluate_with_precomputed.
template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>
void	occ::ints::esp_evaluate_with_precomputed (const ShellPairData< T > &shell_pair, int npts, const T *C, const T *boys_table, T *integrals, T *workspace)
	ESP evaluation using precomputed ShellPairData This is the hot path - E-matrices are already computed!
template<typename T >
void	occ::ints::build_aux_e_1d (int lc, T gamma, T *E_1d)
	Build 1D E-coefficients for single-center auxiliary with exponent gamma Uses recurrence: E^{l+1}_t = (1/2γ) E^l_{t-1} + (t+1) E^l_{t+1}.
template<typename T >
void	occ::ints::build_aux_e_matrix_with_gamma (const T *E_1d, int lc, T *E_matrix)
	Build E-matrix for single-center auxiliary shell with ket signs.
template<typename T , int L>
AuxShellData< T >	occ::ints::precompute_aux_shell (int nprim, const T *exponents, const T *coeffs, const T *C)
	Precompute auxiliary shell data with gamma-dependent E-coefficients.
template<typename T >
ShellPairData< T >	occ::ints::precompute_shell_pair_dispatch (int la, int lb, int na_prim, int nb_prim, const T *exponents_a, const T *exponents_b, const T *coeffs_a, const T *coeffs_b, const T *A, const T *B)
	Dispatch shell pair precomputation based on runtime angular momenta Supports angular momenta up to L=4 (g functions)
template<typename T >
AuxShellData< T >	occ::ints::precompute_aux_shell_dispatch (int lc, int nprim, const T *exponents, const T *coeffs, const T *C)
	Dispatch auxiliary shell precomputation based on runtime angular momentum.
template<typename T , int LA, int LB, int LC, typename BoysParams = BoysParamsDefault>
void	occ::ints::eri3c_evaluate_with_precomputed (const ShellPairData< T > &ao_pair, const AuxShellData< T > &aux_shell, const T *boys_table, T *integrals)
	3-center ERI (μν|P) using precomputed data
template<typename T , int LP, int LQ, typename BoysParams = BoysParamsDefault>
void	occ::ints::eri2c_evaluate_with_precomputed (const AuxShellData< T > &shell_P, const AuxShellData< T > &shell_Q, const T *boys_table, T *integrals)
	2-center Coulomb (P|Q) using precomputed data
template<typename T , typename BoysParams = BoysParamsDefault>
void	occ::ints::esp_primitive_dynamic (int la, int lb, T a, T b, const T *A, const T *B, const T *C, const T *boys_table, T *integrals)
	ESP integral with runtime angular momentum.
template<typename T , typename BoysParams = BoysParamsDefault>
void	occ::ints::esp_contracted_dynamic (int la, int lb, int na_prim, int nb_prim, const T *exponents_a, const T *exponents_b, const T *coeffs_a, const T *coeffs_b, const T *A, const T *B, const T *C, const T *boys_table, T *integrals)
	Contracted ESP with runtime angular momentum.
template<typename T , typename BoysParams = BoysParamsDefault>
void	occ::ints::eri3c_dynamic (int la, int lb, int lc, int na_prim, int nb_prim, int nc_prim, const T *exponents_a, const T *exponents_b, const T *exponents_c, const T *coeffs_a, const T *coeffs_b, const T *coeffs_c, const T *A, const T *B, const T *C, const T *boys_table, T *integrals)
	Dynamic 3-center ERI (μν|P) for runtime angular momentum.
template<typename T , typename BoysParams = BoysParamsDefault>
void	occ::ints::eri2c_dynamic (int lp, int lq, int np_prim, int nq_prim, const T *exponents_p, const T *exponents_q, const T *coeffs_p, const T *coeffs_q, const T *P, const T *Q, const T *boys_table, T *integrals)
	Dynamic 2-center Coulomb (P|Q) for runtime angular momentum.
template<typename T >
void	occ::ints::build_E_ab_matrix_dynamic (const ECoeffs1DDynamic< T > &Ex, const ECoeffs1DDynamic< T > &Ey, const ECoeffs1DDynamic< T > &Ez, int la, int lb, T *E_ab)
	Build E_ab matrix [nab × nherm_ab] from 3D E-coefficients Row order: standard Cartesian order (descending in first index)
template<typename T >
void	occ::ints::build_E_c_matrix_dynamic (const T *E_c_1d, int lc, T *E_c_matrix)
	Build E_c matrix [nc × nherm_c] from single-center E-coefficients with ket signs The sign (-1)^(tx+ty+tz) is baked into the matrix.
template<typename T >
void	occ::ints::build_R_tensor_dynamic (const RIntsDynamic< T > &R, int L_ab, int lc, T *R_tensor)
	Build R_tensor [nherm_ab × nherm_c] from R-integrals R_tensor[h_ab, h_c] = R[combined_hermite_index(h_ab, h_c)].
template<typename T , typename BoysParams = BoysParamsDefault>
void	occ::ints::eri3c_dynamic_matmul (int la, int lb, int lc, int na_prim, int nb_prim, int nc_prim, const T *exponents_a, const T *exponents_b, const T *exponents_c, const T *coeffs_a, const T *coeffs_b, const T *coeffs_c, const T *A, const T *B, const T *C, const T *boys_table, T *integrals)
	Dynamic 3-center ERI using matrix multiplication for contraction This version pre-allocates workspace and uses Eigen matmul.
template<typename T , typename BoysParams = BoysParamsDefault>
void	occ::ints::eri3c_dynamic_matmul_workspace (int la, int lb, int lc, int na_prim, int nb_prim, int nc_prim, const T *exponents_a, const T *exponents_b, const T *exponents_c, const T *coeffs_a, const T *coeffs_b, const T *coeffs_c, const T *A, const T *B, const T *C, const T *boys_table, T *integrals, T *E_ab_workspace, T *E_c_workspace, T *R_workspace, T *temp_workspace)
	Dynamic 3-center ERI using matrix multiplication with external workspace This version eliminates internal allocations by using caller-provided buffers.
std::tuple< size_t, size_t, size_t, size_t >	occ::ints::eri3c_workspace_sizes (int la, int lb, int lc)
	Required workspace sizes for eri3c_dynamic_matmul_workspace Returns sizes as tuple: (E_ab_size, E_c_size, R_tensor_size, temp_size)
std::tuple< size_t, size_t, size_t, size_t >	occ::ints::eri3c_workspace_sizes_max (int max_l_ao, int max_l_aux)
	Maximum workspace sizes given max angular momenta Useful for pre-allocating workspace for all shell combinations.

Macro Definition Documentation

DISPATCH_PAIR

#define DISPATCH_PAIR	(		LA,
			LB
	)

Value:

        if (la == LA && lb == LB) \
            return precompute_shell_pair<T, LA, LB>(na_prim, nb_prim, \
                exponents_a, exponents_b, coeffs_a, coeffs_b, A, B)