Gaussian Gaussian

1. Summary
2. Atomic shell
3. Atomic shell pair couple
4. Atomic shell pair
5. Summary

1 Summary

2 Atomic shell

Set of contracted Gaussians differing only by the powers of $x$, $y$ and $z$, with a constant Angular_momentum.t, all centered on the same point.

In other words, it is the set of all contracted shells sharing the same center.

\begin{align*} \chi_{n_x,n_y,n_z}(r) & = f(n_x,n_y,n_z) \sum_{j=1}^{n} \sum_{i=1}^{m} \mathcal{N}_{ij}\, d_{ij}\, g_{ij\,n_x,n_y,n_z}(r) \\ & = (x-X_A)^{n_x} (y-Y_A)^{n_y} (z-Z_A)^{n_z} f(n_x,n_y,n_z) \sum_{j=1}^{n} \sum_{i=1}^{m} \mathcal{N}_{ij}\, d_{ij}\, \exp \left( -\alpha_{ij} |r-R_A|^2 \right) \end{align*}

where:

$g_{ij\,n_x,n_y,n_z}(r)$ is the $i$-th PrimitiveShell.t of the $j$-th Contracted_shell.t
$n_x + n_y + n_z = l$, the total angular momentum
$\alpha_{ij}$ are the exponents (tabulated) of the $j$-th Contracted_shell.t
$d_{ij}$ are the contraction coefficients of the $j$-th Contracted_shell.t
$\mathcal{N}_{ij}$ is the normalization coefficient of the $i$-th primitive shell (PrimitiveShell.norm_coef) of the $j$-th Contracted_shell.t
$f(n_x,n_y,n_z)$ is a scaling factor adjusting the normalization coefficient for the particular powers of $x,y,z$ (PrimitiveShell.norm_coef_scale)

2.1 Type

type t

open Common

2.2 Access

val ang_mom           : t -> Angular_momentum.t
val center            : t -> Coordinate.t
val coefficients      : t -> float array array
val contracted_shells : t -> Contracted_shell.t array
val exponents         : t -> float array array
val index             : t -> int
val normalizations    : t -> float array array
val norm_scales       : t -> float array
val size_of_shell     : t -> int
val size              : t -> int

`ang_mom`	Total angular momentum : $l = n_x + n_y + n_z$.
`center`	Coordinate of the center $\mathbf{A} = (X_A,Y_A,Z_A)$.
`coefficients`	Array of contraction coefficients $d_{ij}$. The first index is the index of the contracted function, and the second index is the index of the primitive.
`contracted_shells:`	Array of contracted gaussians
`exponents`	Array of exponents $\alpha_{ij}$. The first index is the index of the contracted function, and the second index is the index of the primitive.
`index`	Index in the basis set, represented as an array of contracted shells.
`normalizations`	Normalization coefficients $\mathcal{N}_{ij}$. The first index is the index of the contracted function, and the second index is the index of the primitive.
`norm_scales`	Scaling factors $f(n_x,n_y,n_z)$, given in the same order as `Angular_momentum.zkey_array ang_mom`.
`size`	Number of contracted functions, $n$ in the definition.
`size_of_shell`	Number of contracted functions in the shell: length of `norm_coef_scale`.

2.3 Creation

val make : ?index:int -> Contracted_shell.t array -> t 

val with_index  : t -> int -> t

`make`	Creates a contracted shell from a list of coefficients and primitives.
`with_index`	Returns a copy of the contracted shell with a modified index.

2.4 Printers

val pp : Format.formatter -> t -> unit

3 Atomic shell pair couple

An atomic shell pair couple is the cartesian product between two sets of functions, one set over electron one and one set over electron two. Both sets are atomic shell pairs.

These are usually called shell quartets in the literature, but we prefer to use pair for two functions with the same electron, and couple for two functions acting on different electrons, since they will be coupled by a two-electron operator.

3.1 Type

type t

open Common

3.2 Access

val ang_mom                       : t -> Angular_momentum.t
val atomic_shell_a                : t -> Atomic_shell.t
val atomic_shell_b                : t -> Atomic_shell.t
val atomic_shell_c                : t -> Atomic_shell.t
val atomic_shell_d                : t -> Atomic_shell.t
val atomic_shell_pair_p           : t -> Atomic_shell_pair.t
val atomic_shell_pair_q           : t -> Atomic_shell_pair.t
val contracted_shell_pair_couples : t -> Contracted_shell_pair_couple.t list
val monocentric                   : t -> bool
val norm_scales                   : t -> float array
val zkey_array                    : t -> Zkey.t array

`ang_mom`	Total angular momentum of the shell pair couple: sum of the angular momenta of all the shells.
`atomic_shell_a`	Returns the first atomic shell of the first shell pair.
`atomic_shell_b`	Returns the second atomic shell of the first shell pair.
`atomic_shell_c`	Returns the first atomic shell of the second shell pair.
`atomic_shell_d`	Returns the second atomic shell of the second shell pair.
`atomic_shell_pair_p`	Returns the first atomic shell pair that was used to build the shell pair.
`atomic_shell_pair_q`	Returns the second atomic shell pair that was used to build the shell pair.
`contracted_shell_pair_couples`	Returns the list of significant contracted shell pair couples.
`monocentric`	True if all four atomic shells have the same center.
`norm_scales`	Scaling factors of normalization coefficients inside the shell. The ordering is the same as `zkey_array`.
`zkey_array`	Returns the array of `Zkey.t` relative to the four shells of the shell pair couple.

3.3 Creation

val make : ?cutoff:float -> Atomic_shell_pair.t -> Atomic_shell_pair.t -> t option

Default cutoff is $\epsilon$.

make Creates an atomic shell pair couple using two atomic shell pairs.

3.4 Printers

val pp : Format.formatter -> t -> unit

4 Atomic shell pair

Data structure to represent pairs of atomic shells. The products of functions in the shell pair are one-electron functions.

An atomic shell pair is an array of pairs of contracted shells.

4.1 Type

type t

open Common

4.2 Access

val atomic_shell_a         : t -> Atomic_shell.t
val atomic_shell_b         : t -> Atomic_shell.t
val contracted_shell_pairs : t -> Contracted_shell_pair.t list
val ang_mom                : t -> Angular_momentum.t
val monocentric            : t -> bool
val norm_scales            : t -> float array
val a_minus_b              : t -> Coordinate.t
val a_minus_b_sq           : t -> float

`atomic_shell_a`	Returns the first `Atomic_shell.t` which was used to build the atomic shell pair.
`atomic_shell_b`	Returns the second `Atomic_shell.t` which was used to build the atomic shell pair.
`contracted_shell_pairs`	Returns an array of `ContractedShellPair.t`, containing all the pairs of contracted functions used to build the atomic shell pair.
`norm_scales`	norm_coef.(i) / norm_coef.(0)
`ang_mom`	Total angular Momentum
`monocentric`	If true, the two atomic shells have the same center.
`a_minus_b`	Returns $A-B$
`a_minus_b_sq`	Returns $\vert A-B \vert^2$

4.3 Creation

val make : ?cutoff:float -> Atomic_shell.t -> Atomic_shell.t -> t option

Creates an atomic shell pair from two atomic shells.

The contracted shell pairs contains the only pairs of primitives for which the norm is greater than cutoff.

If all the contracted shell pairs are not significant, the function returns None.

val of_atomic_shell_array : ?cutoff:float -> Atomic_shell.t array -> t option array array

Creates all possible atomic shell pairs from an array of atomic shells. If an atomic shell pair is not significant, sets the value to None.

4.4 Printers

val pp : Format.formatter -> t -> unit