UP | HOME

# Gaussian Gaussian

## Table of Contents

- 1. Summary
- 2. Atomic shell
  - 2.1. Type
  - 2.2. Access
  - 2.3. Creation
  - 2.4. Printers
- 3. Atomic shell pair couple
  - 3.1. Type
  - 3.2. Access
  - 3.3. Creation
  - 3.4. Printers
- 4. Atomic shell pair
  - 4.1. Type
  - 4.2. Access
  - 4.3. Creation
  - 4.4. Printers
- 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` | 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

## 5 Summary

Author: scemama

Created: 2023-06-17 Sat 00:26

Validate