QCaml/Basis/ContractedShell.mli

(** Set of contracted Gaussians with a given {!AngularMomentum.t}

{% \\[
\chi(r) = (x-X_A)^{n_x} (y-Y_A)^{n_y} (z-Z_A)^{n_z} \sum_{i=1}^{m} \mathcal{N}_i f_i d_i \exp \left( -\alpha_i |r-R_A|^2 \right)
   \\] %}

where:

- {% $n_x + n_y + n_z = l$ %}, the total angular momentum

- {% $\alpha_i$ %} are the exponents (tabulated)

- {% $d_i$ %} are the contraction coefficients

- {% $\mathcal{N}_i$ %} is the normalization coefficient of the i-th primitive:

{% \\[
\mathcal{N}_i = \sqrt{\iiint \left[ (x-X_A)^{l} \exp (-\alpha_i |r-R_A|^2) \right]^2 \, dx\, dy\, dz}
   \\] %}

- {% $f_i$ %} is a scaling factor adjusting the normalization coefficient for the
  particular powers of {% $x,y,z$ %}:

{% \\[
f_i = \frac{1}{\mathcal{N}_i}
    \sqrt{\iiint \left[ (x-X_A)^{n_x} (y-Y_A)^{n_y} (z-Z_A)^{n_z} \exp (-\alpha_i |r-R_A|^2) \right]^2 \, dx\, dy\, dz}
   \\] %}

*)

type t 

val to_string : t -> string
(** Pretty-printing of the contracted shell in a string *)

val make :
  index:int ->
  expo:float array ->
  coef:float array ->
  center:Coordinate.t -> totAngMom:AngularMomentum.t -> t
(** Creates a contracted shell *)

val with_index  : t -> int -> t
(** Returns a copy of the contracted shell with a modified index *)


val expo : t -> float array
(** Array of exponents {% $\alpha_i$ %} *)

val coef : t -> float array
(** Array of contraction coefficients {% $d_i$ %} *)

val center : t -> Coordinate.t
(** Coordinate of the center {% $\mathbf{A} = (X_A,Y_A,Z_A)$ %} *)

val totAngMom : t -> AngularMomentum.t
(** Total angular momentum : {% $l = n_x + n_y + n_z$ %} *)

val size : t -> int
(** Number of contracted functions, {% $m$ %} in the formula *)

val norm_coef : t -> float array
(** Normalization coefficients of primitive functions {% $\mathcal{N}_i$ %} *)

val norm_coef_scale : t -> float array
(** Scaling factors {% $f_i$ %}, given in the same order as [AngularMomentum.zkey_array totAngMom]. *)

val index : t -> int
(** Index in the basis set, represented as an array of contracted shells. *)

val size_of_shell : t -> int
(** Number of contracted functions in the shell *)