UP | HOME

Gaussian

Table of Contents

1 Summmary

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 normcoef.(i) / normcoef.(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

Author: Anthony Scemama

Created: 2021-01-27 Wed 23:44

Validate