---
license: mit
---

# Quantum Electronic Integrals

This dataset contains quantum interaction integrals between randomly sampled pairs/quadruples of Gaussian-Type Orbitals (GTOs).  
The targets were computed in julia using [GaussianBasis.jl](https://github.com/FermiQC/GaussianBasis.jl). 

## Loading data from python 

See [qml/data/integrals.py](https://github.com/aklipf/qml). 
Loading a mono-electronic integral dataset should be as simple as:

```py
from qml.data import MonoIntegral

I_2_1 = MonoIntegral.h5read("integrals/mono_20k/mono_2_1.h5")
```

The `MonoIntegral` class inherits its `h5read` method from the `TensorDict` mixin. 

Each dataset contains its corresponding `TensorDict` dataclass, reading data from any 
compatible HDF5 storage (containing enough keys).

# Mono-Electronic Integrals

See [mono_20k](https://huggingface.co/datasets/qml/integrals/tree/main/mono_20k)
and [mono_100k](https://huggingface.co/datasets/qml/integrals/tree/main/mono_100k) 
for 2-electron integrals. 

Each HDF5 file encodes an object of type: 

```julia
# jqml/Data.jl
""" Object storing 1-electron integrals. """
struct MonoIntegral{T} <: ArrayFields
    l :: Vector{Int64}
    exp :: Union{SArray, Array{T}}
    xyz :: Union{SArray, Array{T}}
    overlap :: Array{T}
    kinetic :: Array{T}
    nuclear :: Array{T}
    Z :: Array{Int64}
end
```

Input wave functions (ψ1, ψ2) are primitive, spherical GTO-shells 
with unit coefficients, i.e.

    ψ(C + r) = rˡ ⋅ Yₗₘ(r/|r|) ⋅ exp(-α |r|²)

where C is `ψ.center`, α is `ψ.exp`, and the magnetic quantum number m 
takes all possible values in {-l, ..., l} within each subshell.

### Inputs:
- `xyz` : center of ψ2 (ψ1 is centered at 0)
- `l`   : pair of angular momenta (l₁, l₂)
- `exp` : exponents (α₁, α₂)
- `Z`   : atomic charges used to compute the nuclear integral.

### Targets:
- `overlap` integrals `S₁₂ =  ∫ ψ1 ⋅ ψ2`
- `kinetic` integrals `T₁₂ = 1/2 * ∫ ∇ψ1 ⋅ ∇ψ2`
- `nuclear` attraction integrals

    `N₁₂ = ∫ ψ1 ⋅ [(Z₁ / |r|) + (Z₂ / |r - xyz|)] ⋅ ψ2`



### Note:
Mono-electronic integrals are square matrices of shape `D × D` with 

    D = (2 * l1 + 1) + (2 * l2 + 1)

Indices correspond to increasing values of `m1 ∈ {-l1, …,  l1}` first,  
then increasing values of `m2 ∈ {-l2, …, l2}`.

# Bi-Electronic Integrals 

Batches of 2-electron integrals are returned in the 
following sparse format: 

```julia
"""Object for storing bi-electronic integrals"""
struct BiIntegral4c{T}  <: ArrayFields
    l :: Vector{Int64}
    exp :: Array{T}
    xyz :: Array{T}
    ijkl :: Array{Int16}
    Bijkl :: Array{Float64}
    index :: Vector{Int64}
end
```

The `index` field has the same length as `ijkl` and `Bijkl`, and maps each integral element 
to the index of the corresponding input GTOs. 

See [bi_200](https://huggingface.co/datasets/qml/integrals/tree/main/bi_200)