QCaml/Basis/ContractedShell.mli

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

{% \\[
(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 = private {
  expo      : float array;       (** Array of exponents {% $\alpha_i$ %} *)
  coef      : float array;       (** Array of contraction coefficients {% $d_i$ %} *)
  center    : Coordinate.t;      (** Coordinate of the center {% $\mathbf{A} = (X_A,Y_A,Z_A)$ %} *)
  totAngMom : AngularMomentum.t; (** Total angular momentum : {% $l = n_x + n_y + n_z$ %} *)
  size      : int;               (** Number of contracted functions, {% $m$ %} in the formula *)
  norm_coef : float array;       (** Normalization coefficients of primitive functions {% $\mathcal{N}_i$ %} *)
  norm_coef_scale : float array; (** Scaling factors {% $f_i$ %}, given in the same order as [AngularMomentum.zkey_array totAngMom]. *)
  index    : int;                (** Index in the basis set, represented as an array of contracted shells. *)
}



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

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

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