2021-05-21 12:10:29 +02:00
|
|
|
#+TITLE: TREX Configuration file
|
2021-06-02 00:02:42 +02:00
|
|
|
#+STARTUP: latexpreview
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
All the quantities are saved in atomic units.
|
2021-05-21 14:04:19 +02:00
|
|
|
The dimensions of the arrays in the tables below are given in
|
|
|
|
column-major order (as in Fortran), and the ordering of the dimensions
|
|
|
|
is reversed in the produces JSON configuration file as the library is
|
|
|
|
written in C.
|
|
|
|
|
2021-06-04 14:43:27 +02:00
|
|
|
In Fortran, the arrays are 1-based and in most other languages the
|
|
|
|
arrays are 0-base. Hence, we introduce the ~index~ type which is an
|
|
|
|
1-based ~int~ in the Fortran interface and 0-based otherwise.
|
|
|
|
|
2021-05-21 12:10:29 +02:00
|
|
|
#+begin_src python :tangle trex.json
|
|
|
|
{
|
|
|
|
#+end_src
|
|
|
|
|
|
|
|
* Metadata
|
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
As we expect our files to be archived in open-data repositories, we
|
|
|
|
need to give the possibility to the users to store some metadata
|
|
|
|
inside the files. We propose to store the list of names of the codes
|
|
|
|
which have participated to the creation of the file, a list of
|
|
|
|
authors of the file, and a textual description.
|
|
|
|
|
2021-05-21 12:10:29 +02:00
|
|
|
#+NAME: metadata
|
|
|
|
| ~code_num~ | ~int~ | | Number of codes used to produce the file |
|
2021-05-21 14:04:19 +02:00
|
|
|
| ~code~ | ~str~ | ~(metadata.code_num)~ | Names of the codes used |
|
2021-05-21 12:10:29 +02:00
|
|
|
| ~author_num~ | ~int~ | | Number of authors of the file |
|
|
|
|
| ~author~ | ~str~ | ~(metadata.author_num)~ | Names of the authors of the file |
|
|
|
|
| ~description~ | ~str~ | | Text describing the content of file |
|
|
|
|
|
|
|
|
#+CALL: json(data=metadata, title="metadata")
|
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
2021-05-24 15:45:30 +02:00
|
|
|
"metadata": {
|
|
|
|
"code_num" : [ "int", [] ]
|
|
|
|
, "code" : [ "str", [ "metadata.code_num" ] ]
|
|
|
|
, "author_num" : [ "int", [] ]
|
|
|
|
, "author" : [ "str", [ "metadata.author_num" ] ]
|
|
|
|
, "description" : [ "str", [] ]
|
|
|
|
} ,
|
2021-05-21 12:10:29 +02:00
|
|
|
#+end_src
|
|
|
|
:end:
|
|
|
|
|
|
|
|
* Electron
|
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
We consider wave functions expressed in the spin-free formalism, where
|
|
|
|
the number of \uparrow and \downarrow electrons is fixed.
|
|
|
|
|
2021-05-21 12:10:29 +02:00
|
|
|
#+NAME:electron
|
2021-05-24 15:45:30 +02:00
|
|
|
| ~up_num~ | ~int~ | | Number of \uparrow-spin electrons |
|
|
|
|
| ~dn_num~ | ~int~ | | Number of \downarrow-spin electrons |
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
#+CALL: json(data=electron, title="electron")
|
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
|
|
|
"electron": {
|
|
|
|
"up_num" : [ "int", [] ]
|
|
|
|
, "dn_num" : [ "int", [] ]
|
|
|
|
} ,
|
|
|
|
#+end_src
|
|
|
|
:end:
|
|
|
|
|
|
|
|
* Nucleus
|
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
The nuclei are considered as fixed point charges. Coordinates are
|
|
|
|
given in Cartesian $(x,y,z)$ format.
|
|
|
|
|
2021-05-21 12:10:29 +02:00
|
|
|
#+NAME: nucleus
|
2021-05-21 14:04:19 +02:00
|
|
|
| ~num~ | ~int~ | | Number of nuclei |
|
|
|
|
| ~charge~ | ~float~ | ~(nucleus.num)~ | Charges of the nuclei |
|
|
|
|
| ~coord~ | ~float~ | ~(3,nucleus.num)~ | Coordinates of the atoms |
|
|
|
|
| ~label~ | ~str~ | ~(nucleus.num)~ | Atom labels |
|
|
|
|
| ~point_group~ | ~str~ | | Symmetry point group |
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
#+CALL: json(data=nucleus, title="nucleus")
|
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
|
|
|
"nucleus": {
|
|
|
|
"num" : [ "int" , [] ]
|
|
|
|
, "charge" : [ "float", [ "nucleus.num" ] ]
|
|
|
|
, "coord" : [ "float", [ "nucleus.num", "3" ] ]
|
|
|
|
, "label" : [ "str" , [ "nucleus.num" ] ]
|
|
|
|
, "point_group" : [ "str" , [] ]
|
|
|
|
} ,
|
|
|
|
#+end_src
|
|
|
|
:end:
|
|
|
|
|
|
|
|
* TODO Effective core potentials
|
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
An effective core potential (ECP) $V_A^{\text{pp}}$ replacing the
|
|
|
|
core electrons of atom $A$ is the sum of a local component
|
|
|
|
$V_A^{\text{l}}$ and a non-local component $V_A^{\text{nl}}$.
|
|
|
|
The local component is given by
|
|
|
|
|
|
|
|
\[
|
|
|
|
\hat{V}_A^{\text{l}}(r) = -\frac{Z_A^{\text{eff}}}{r} +
|
|
|
|
\frac{Z_A^{\text{eff}}}{r}\, \exp\left( -\alpha_A\, r^2\right) +
|
|
|
|
Z_{\text{eff}}\, \alpha_A\, r\, \exp\left( -\beta_A\, r^2\right) +
|
|
|
|
\gamma_A \exp\left( -\delta_A\, r^2\right),
|
|
|
|
\]
|
|
|
|
|
|
|
|
and the component obtained after localizing the non-local operator is
|
|
|
|
|
|
|
|
\[
|
|
|
|
\hat{V}_A^{\text{nl}}(r) =
|
|
|
|
\zeta_A\, \exp\left( -\eta_A\, r^2\right) |0\rangle \langle 0| +
|
|
|
|
\mu_A \, \exp\left( -\nu_A \, r^2\right) |1\rangle \langle 1|
|
|
|
|
\]
|
|
|
|
|
|
|
|
where $r=|\mathbf{r-R}_A|$ is the distance to the nucleus on which the
|
|
|
|
potential is centered, $Z_A^{\text{eff}}$ is the effective charge
|
|
|
|
due to the removed electrons, $|0\rangle \langle 0|$
|
|
|
|
and $|1\rangle \langle 1|$ are projections over zero and one principal angular
|
|
|
|
momenta, respectively (generalization to higher angular momenta is
|
|
|
|
straightforward), and all the parameters labeled by Greek
|
|
|
|
letters are parameters.
|
|
|
|
|
|
|
|
- $\hat{V}_\text{ecp,l} = \sum_A \hat{V}_A^{\text{l}}$ : local component
|
|
|
|
- $\hat{V}_\text{ecp,nl} = \sum_A \hat{V}_A^{\text{nl}}$ : non-local component
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
#+NAME: ecp
|
|
|
|
| ~lmax_plus_1~ | ~int~ | ~(nucleus.num)~ | $l_{\max} + 1$ |
|
|
|
|
| ~z_core~ | ~float~ | ~(nucleus.num)~ | Charges to remove |
|
|
|
|
| ~local_n~ | ~int~ | ~(nucleus.num)~ | Number of local function |
|
|
|
|
| ~local_num_n_max~ | ~int~ | | Maximum value of ~local_n~ |
|
2021-05-21 14:04:19 +02:00
|
|
|
| ~local_exponent~ | ~float~ | ~(ecp.local_num_n_max, nucleus.num)~ | |
|
|
|
|
| ~local_coef~ | ~float~ | ~(ecp.local_num_n_max, nucleus.num)~ | |
|
|
|
|
| ~local_power~ | ~int~ | ~(ecp.local_num_n_max, nucleus.num)~ | |
|
2021-05-21 12:10:29 +02:00
|
|
|
| ~non_local_n~ | ~int~ | ~(nucleus.num)~ | |
|
|
|
|
| ~non_local_num_n_max~ | ~int~ | | |
|
2021-05-21 14:04:19 +02:00
|
|
|
| ~non_local_exponent~ | ~float~ | ~(ecp.non_local_num_n_max, nucleus.num)~ | |
|
|
|
|
| ~non_local_coef~ | ~float~ | ~(ecp.non_local_num_n_max, nucleus.num)~ | |
|
|
|
|
| ~non_local_power~ | ~int~ | ~(ecp.non_local_num_n_max, nucleus.num)~ | |
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
#+CALL: json(data=ecp, title="ecp")
|
|
|
|
|
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
2021-05-24 15:45:30 +02:00
|
|
|
"ecp": {
|
|
|
|
"lmax_plus_1" : [ "int" , [ "nucleus.num" ] ]
|
|
|
|
, "z_core" : [ "float", [ "nucleus.num" ] ]
|
|
|
|
, "local_n" : [ "int" , [ "nucleus.num" ] ]
|
|
|
|
, "local_num_n_max" : [ "int" , [] ]
|
|
|
|
, "local_exponent" : [ "float", [ "nucleus.num", "ecp.local_num_n_max" ] ]
|
|
|
|
, "local_coef" : [ "float", [ "nucleus.num", "ecp.local_num_n_max" ] ]
|
|
|
|
, "local_power" : [ "int" , [ "nucleus.num", "ecp.local_num_n_max" ] ]
|
|
|
|
, "non_local_n" : [ "int" , [ "nucleus.num" ] ]
|
|
|
|
, "non_local_num_n_max" : [ "int" , [] ]
|
|
|
|
, "non_local_exponent" : [ "float", [ "nucleus.num", "ecp.non_local_num_n_max" ] ]
|
|
|
|
, "non_local_coef" : [ "float", [ "nucleus.num", "ecp.non_local_num_n_max" ] ]
|
|
|
|
, "non_local_power" : [ "int" , [ "nucleus.num", "ecp.non_local_num_n_max" ] ]
|
|
|
|
} ,
|
2021-05-21 12:10:29 +02:00
|
|
|
#+end_src
|
|
|
|
:end:
|
|
|
|
|
|
|
|
* Basis set
|
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
We consider here basis functions centered on nuclei. Hence, we enable
|
|
|
|
the possibility to define \emph{dummy atoms} to place basis functions
|
|
|
|
in random positions.
|
|
|
|
|
|
|
|
The atomic basis set is defined as a list of shells. Each shell $s$ is
|
|
|
|
centered on a center $A$, possesses a given angular momentum $l$ and a
|
|
|
|
radial function $R_s$. The radial function is a linear combination of
|
|
|
|
$N_{\text{prim}}$ /primitive/ functions that can be of type
|
|
|
|
Slater ($p=1$) or Gaussian ($p=2$),
|
|
|
|
parameterized by exponents $\gamma_{ks}$ and coefficients $a_{ks}$:
|
|
|
|
\[
|
|
|
|
R_s(\mathbf{r}) = \mathcal{N}_s \vert\mathbf{r}-\mathbf{R}_A\vert^{n_s}
|
2021-05-25 00:01:29 +02:00
|
|
|
\sum_{k=1}^{N_{\text{prim}}} a_{ks}\, f_{ks}(\gamma_{ks},p)\,
|
2021-05-21 14:04:19 +02:00
|
|
|
\exp \left( - \gamma_{ks}
|
|
|
|
\vert \mathbf{r}-\mathbf{R}_A \vert ^p \right).
|
|
|
|
\]
|
|
|
|
|
2021-05-25 00:01:29 +02:00
|
|
|
In the case of Gaussian functions, $n_s$ is always zero.
|
|
|
|
|
|
|
|
Different codes normalize functions at different levels. Computing
|
|
|
|
normalization factors requires the ability to compute overlap
|
|
|
|
integrals, so the normalization factors should be written in the
|
|
|
|
file to ensure that the file is self-contained and does not need the
|
|
|
|
client program to have the ability to compute such integrals.
|
|
|
|
|
|
|
|
Some codes assume that the contraction coefficients are for a linear
|
|
|
|
combination of /normalized/ primitives. This implies that a normalization
|
|
|
|
constant for the primitive $ks$ needs to be computed and stored. If
|
|
|
|
this normalization factor is not required, set $f_{ks}$ to one.
|
|
|
|
|
|
|
|
Some codes assume that the basis function are normalized. This
|
|
|
|
implies the computation of an extra normalization factor, $\mathcal{N}_s$.
|
|
|
|
If the the basis function is not normalized, set $\mathcal{N}_s=1$.
|
2021-05-21 14:04:19 +02:00
|
|
|
|
|
|
|
|
2021-05-21 12:10:29 +02:00
|
|
|
#+NAME: basis
|
2021-05-25 00:01:29 +02:00
|
|
|
| ~type~ | ~str~ | | Type of basis set: "Gaussian" or "Slater" |
|
|
|
|
| ~shell_num~ | ~int~ | | Total Number of shells |
|
2021-06-04 14:43:27 +02:00
|
|
|
| ~shell_center~ | ~index~ | ~(basis.shell_num)~ | Nucleus on which the shell is centered ($A$) |
|
2021-05-25 00:01:29 +02:00
|
|
|
| ~shell_ang_mom~ | ~int~ | ~(basis.shell_num)~ | Angular momentum ~0:S, 1:P, 2:D, ...~ |
|
|
|
|
| ~shell_prim_num~ | ~int~ | ~(basis.shell_num)~ | Number of primitives in the shell ($N_{\text{prim}}$) |
|
|
|
|
| ~shell_factor~ | ~float~ | ~(basis.shell_num)~ | Normalization factor of the shell ($\mathcal{N}_s$) |
|
2021-06-04 14:43:27 +02:00
|
|
|
| ~prim_index~ | ~index~ | ~(basis.shell_num)~ | Index of the first primitive in the complete list |
|
2021-05-25 00:01:29 +02:00
|
|
|
| ~prim_num~ | ~int~ | | Total number of primitives |
|
|
|
|
| ~exponent~ | ~float~ | ~(basis.prim_num)~ | Exponents of the primitives ($\gamma_{ks}) |
|
|
|
|
| ~coefficient~ | ~float~ | ~(basis.prim_num)~ | Coefficients of the primitives ($a_{ks}$) |
|
|
|
|
| ~prim_factor~ | ~float~ | ~(basis.prim_num)~ | Normalization coefficients for the primitives ($f_{ks}$) |
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
#+CALL: json(data=basis, title="basis")
|
|
|
|
|
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
|
|
|
"basis": {
|
|
|
|
"type" : [ "str" , [] ]
|
|
|
|
, "shell_num" : [ "int" , [] ]
|
2021-06-04 14:43:27 +02:00
|
|
|
, "shell_center" : [ "index", [ "basis.shell_num" ] ]
|
2021-05-21 12:10:29 +02:00
|
|
|
, "shell_ang_mom" : [ "int" , [ "basis.shell_num" ] ]
|
|
|
|
, "shell_prim_num" : [ "int" , [ "basis.shell_num" ] ]
|
2021-05-24 15:45:30 +02:00
|
|
|
, "shell_factor" : [ "float", [ "basis.shell_num" ] ]
|
2021-06-04 14:43:27 +02:00
|
|
|
, "prim_index" : [ "index", [ "basis.shell_num" ] ]
|
2021-05-21 12:10:29 +02:00
|
|
|
, "prim_num" : [ "int" , [] ]
|
|
|
|
, "exponent" : [ "float", [ "basis.prim_num" ] ]
|
|
|
|
, "coefficient" : [ "float", [ "basis.prim_num" ] ]
|
2021-05-25 00:01:29 +02:00
|
|
|
, "prim_factor" : [ "float", [ "basis.prim_num" ] ]
|
2021-05-21 12:10:29 +02:00
|
|
|
} ,
|
|
|
|
#+end_src
|
|
|
|
:end:
|
|
|
|
|
|
|
|
* Atomic orbitals
|
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
Going from the atomic basis set to AOs implies a systematic
|
|
|
|
construction of all the angular functions of each shell. We
|
|
|
|
consider two cases for the angular functions: the real-valued
|
|
|
|
spherical harmonics, and the polynomials in Cartesian coordinates.
|
|
|
|
In the case of spherical harmonics, the AOs are ordered in
|
|
|
|
increasing magnetic quantum number ($-l \le m \le l$), and in the case
|
|
|
|
of polynomials we impose the canonical ordering of the
|
|
|
|
Libint2 library, i.e
|
|
|
|
|
|
|
|
\begin{eqnarray}
|
|
|
|
p & : & p_x, p_y, p_z \nonumber \\
|
|
|
|
d & : & d_{xx}, d_{xy}, d_{xz}, d_{yy}, d_{yz}, d_{zz} \nonumber \\
|
|
|
|
f & : & f_{xxx}, f_{xxy}, f_{xxz}, f_{xyy}, f_{xyz}, f_{xzz}, f_{yyy}, f_{yyz}, f_{yzz}, …f_{zzz} \nonumber \\
|
|
|
|
{\rm etc.} \nonumber
|
|
|
|
\end{eqnarray}
|
|
|
|
|
|
|
|
AOs are defined as
|
|
|
|
|
|
|
|
\[
|
|
|
|
\chi_i (\mathbf{r}) = \mathcal{N}_i\, P_{\eta(i)}(\mathbf{r})\, R_{\theta(i)} (\mathbf{r})
|
|
|
|
\]
|
|
|
|
|
2021-06-04 14:43:27 +02:00
|
|
|
where $i$ is the atomic orbital index, $P$ encodes for either the
|
2021-05-21 14:04:19 +02:00
|
|
|
polynomials or the spherical harmonics, $\theta(i)$ returns the
|
|
|
|
shell on which the AO is expanded, and $\eta(i)$ denotes which
|
|
|
|
angular function is chosen.
|
|
|
|
$\mathcal{N}_i$ is a normalization factor that enables the
|
|
|
|
possibility to have different normalization coefficients within a
|
|
|
|
shell, as in the GAMESS convention where
|
|
|
|
$\mathcal{N}_{x^2} \ne \mathcal{N}_{xy}$ because
|
|
|
|
\[ \left[ \iiint \left(x-X_A \right)^2 R_{\theta(i)}
|
|
|
|
(\mathbf{r}) dx\, dy\, dz \right]^{-1/2} \ne
|
|
|
|
\left[ \iiint \left( x-X_A \right) \left( y-Y_A \right) R_{\theta(i)}
|
|
|
|
(\mathbf{r}) dx\, dy\, dz \right]^{-1/2}. \]
|
|
|
|
|
|
|
|
In such a case, one should set the normalization of the shell (in
|
|
|
|
the [[Basis set][Basis set]] section) to $\mathcal{N}_{z^2}$, which is the
|
|
|
|
normalization factor of the atomic orbitals in spherical coordinates.
|
|
|
|
The normalization factor of the $xy$ function which should be
|
|
|
|
introduced here should be $\frac{\mathcal{N}_{xy}}{\mathcal{N}_{z^2}}$.
|
|
|
|
|
2021-05-21 12:10:29 +02:00
|
|
|
#+NAME: ao
|
2021-05-24 15:45:30 +02:00
|
|
|
| ~cartesian~ | ~int~ | | ~1~: true, ~0~: false |
|
|
|
|
| ~num~ | ~int~ | | Total number of atomic orbitals |
|
2021-06-04 14:43:27 +02:00
|
|
|
| ~shell~ | ~index~ | ~(ao.num)~ | basis set shell for each AO |
|
2021-05-24 15:01:04 +02:00
|
|
|
| ~normalization~ | ~float~ | ~(ao.num)~ | Normalization factors |
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
#+CALL: json(data=ao, title="ao")
|
|
|
|
|
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
2021-05-24 15:01:04 +02:00
|
|
|
"ao": {
|
|
|
|
"cartesian" : [ "int" , [] ]
|
|
|
|
, "num" : [ "int" , [] ]
|
2021-06-04 14:43:27 +02:00
|
|
|
, "shell" : [ "index", [ "ao.num" ] ]
|
2021-05-24 15:01:04 +02:00
|
|
|
, "normalization" : [ "float", [ "ao.num" ] ]
|
|
|
|
} ,
|
2021-05-21 12:10:29 +02:00
|
|
|
#+end_src
|
|
|
|
:end:
|
|
|
|
|
|
|
|
** One-electron integrals
|
2021-05-24 15:01:04 +02:00
|
|
|
:PROPERTIES:
|
|
|
|
:CUSTOM_ID: ao_one_e
|
|
|
|
:END:
|
2021-05-21 12:10:29 +02:00
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
- \[ \hat{V}_{\text{ne}} = \sum_{A=1}^{N_\text{nucl}}
|
|
|
|
\sum_{i=1}^{N_\text{elec}} \frac{-Z_A }{\vert \mathbf{R}_A -
|
|
|
|
\mathbf{r}_i \vert} \] : electron-nucleus attractive potential,
|
|
|
|
- \[ \hat{T}_{\text{e}} =
|
|
|
|
\sum_{i=1}^{N_\text{elec}} -\frac{1}{2}\hat{\Delta}_i \] : electronic kinetic energy
|
|
|
|
- $\hat{h} = \hat{T}_\text{e} + \hat{V}_\text{ne} +
|
|
|
|
\hat{V}_\text{ecp,l} + \hat{V}_\text{ecp,nl}$ : core electronic Hamiltonian
|
|
|
|
|
|
|
|
The one-electron integrals for a one-electron operator $\hat{O}$ are
|
|
|
|
\[ \langle p \vert \hat{O} \vert q \rangle \], returned as a matrix
|
|
|
|
over atomic orbitals.
|
|
|
|
|
|
|
|
#+NAME: ao_1e_int
|
|
|
|
| ~overlap~ | ~float~ | ~(ao.num, ao.num)~ | $\langle p \vert q \rangle$ |
|
|
|
|
| ~kinetic~ | ~float~ | ~(ao.num, ao.num)~ | $\langle p \vert \hat{T}_e \vert q \rangle$ |
|
|
|
|
| ~potential_n_e~ | ~float~ | ~(ao.num, ao.num)~ | $\langle p \vert \hat{V}_{\text{ne}} \vert q \rangle$ |
|
|
|
|
| ~ecp_local~ | ~float~ | ~(ao.num, ao.num)~ | $\langle p \vert \hat{V}_{\text{ecp,l} \vert q \rangle$ |
|
|
|
|
| ~ecp_non_local~ | ~float~ | ~(ao.num, ao.num)~ | $\langle p \vert \hat{V}_{\text{ecp,nl} \vert q \rangle$ |
|
|
|
|
| ~core_hamiltonian~ | ~float~ | ~(ao.num, ao.num)~ | $\langle p \vert \hat{h} \vert q \rangle$ |
|
|
|
|
|
|
|
|
#+CALL: json(data=ao_1e_int, title="ao_1e_int")
|
2021-05-21 12:10:29 +02:00
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
2021-05-24 15:45:30 +02:00
|
|
|
"ao_1e_int": {
|
|
|
|
"overlap" : [ "float", [ "ao.num", "ao.num" ] ]
|
|
|
|
, "kinetic" : [ "float", [ "ao.num", "ao.num" ] ]
|
|
|
|
, "potential_n_e" : [ "float", [ "ao.num", "ao.num" ] ]
|
|
|
|
, "ecp_local" : [ "float", [ "ao.num", "ao.num" ] ]
|
|
|
|
, "ecp_non_local" : [ "float", [ "ao.num", "ao.num" ] ]
|
|
|
|
, "core_hamiltonian" : [ "float", [ "ao.num", "ao.num" ] ]
|
|
|
|
} ,
|
2021-05-21 14:04:19 +02:00
|
|
|
#+end_src
|
|
|
|
:end:
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
** Two-electron integrals
|
2021-05-24 15:01:04 +02:00
|
|
|
:PROPERTIES:
|
|
|
|
:CUSTOM_ID: ao_two_e
|
|
|
|
:END:
|
2021-05-21 12:10:29 +02:00
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
The two-electron integrals for a two-electron operator $\hat{O}$ are
|
|
|
|
\[ \langle p q \vert \hat{O} \vert r s \rangle \] in physicists
|
|
|
|
notation or \[ ( pr \vert \hat{O} \vert qs ) \] in chemists
|
|
|
|
notation, where $p,q,r,s$ are indices over atomic orbitals.
|
2021-05-21 12:10:29 +02:00
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
Functions are provided to get the indices in physicists or chemists
|
|
|
|
notation.
|
2021-05-21 12:10:29 +02:00
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
# TODO: Physicist / Chemist functions
|
2021-05-21 12:10:29 +02:00
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
- \[ \hat{W}_{\text{ee}} = \sum_{i=2}^{N_\text{elec}} \sum_{j=1}^{i-1} \frac{1}{\vert \mathbf{r}_i - \mathbf{r}_j \vert} \] : electron-electron repulsive potential operator.
|
|
|
|
- \[ \hat{W}^{lr}_{\text{ee}} = \sum_{i=2}^{N_\text{elec}}
|
|
|
|
\sum_{j=1}^{i-1} \frac{\text{erf}(\vert \mathbf{r}_i -
|
|
|
|
\mathbf{r}_j \vert)}{\vert \mathbf{r}_i - \mathbf{r}_j \vert} \] : electron-electron long range potential
|
2021-05-21 12:10:29 +02:00
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
#+NAME: ao_2e_int
|
|
|
|
| ~eri~ | ~float sparse~ | ~(ao.num, ao.num, ao.num, ao.num)~ | Electron repulsion integrals |
|
|
|
|
| ~eri_lr~ | ~float sparse~ | ~(ao.num, ao.num, ao.num, ao.num)~ | Long-range Electron repulsion integrals |
|
2021-05-21 12:10:29 +02:00
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
#+CALL: json(data=ao_2e_int, title="ao_2e_int")
|
2021-05-21 12:10:29 +02:00
|
|
|
|
2021-05-21 14:04:19 +02:00
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
2021-05-24 15:45:30 +02:00
|
|
|
"ao_2e_int": {
|
|
|
|
"eri" : [ "float sparse", [ "ao.num", "ao.num", "ao.num", "ao.num" ] ]
|
|
|
|
, "eri_lr" : [ "float sparse", [ "ao.num", "ao.num", "ao.num", "ao.num" ] ]
|
|
|
|
} ,
|
2021-05-21 14:04:19 +02:00
|
|
|
#+end_src
|
|
|
|
:end:
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
* Molecular orbitals
|
|
|
|
|
|
|
|
#+NAME: mo
|
2021-05-24 15:01:04 +02:00
|
|
|
| ~type~ | ~str~ | | String identify the set of MOs |
|
|
|
|
| ~num~ | ~int~ | | Number of MOs |
|
|
|
|
| ~coefficient~ | ~float~ | ~(ao.num, mo.num)~ | MO coefficients |
|
|
|
|
| ~class~ | ~str~ | ~(mo.num)~ | Core, Inactive, Active, Virtual, Deleted |
|
|
|
|
| ~symmetry~ | ~str~ | ~(mo.num)~ | Symmetry in the point group |
|
|
|
|
| ~occupation~ | ~float~ | ~(mo.num)~ | Occupation number |
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
#+CALL: json(data=mo, title="mo")
|
|
|
|
|
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
|
|
|
"mo": {
|
2021-05-24 15:01:04 +02:00
|
|
|
"type" : [ "str" , [] ]
|
|
|
|
, "num" : [ "int" , [] ]
|
|
|
|
, "coefficient" : [ "float", [ "mo.num", "ao.num" ] ]
|
|
|
|
, "class" : [ "str" , [ "mo.num" ] ]
|
|
|
|
, "symmetry" : [ "str" , [ "mo.num" ] ]
|
|
|
|
, "occupation" : [ "float", [ "mo.num" ] ]
|
2021-05-21 12:10:29 +02:00
|
|
|
} ,
|
|
|
|
#+end_src
|
|
|
|
:end:
|
|
|
|
|
|
|
|
** One-electron integrals
|
|
|
|
|
2021-05-24 15:01:04 +02:00
|
|
|
The operators as the same as those defined in the
|
|
|
|
[[ao_one_e][AO one-electron integrals section]]. Here, the integrals are given in
|
|
|
|
the basis of molecular orbitals.
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
#+NAME: mo_1e_int
|
|
|
|
| ~overlap~ | ~float~ | ~(mo.num, mo.num)~ | $\langle i \vert j \rangle$ |
|
|
|
|
| ~kinetic~ | ~float~ | ~(mo.num, mo.num)~ | $\langle i \vert \hat{T}_e \vert j \rangle$ |
|
|
|
|
| ~potential_n_e~ | ~float~ | ~(mo.num, mo.num)~ | $\langle i \vert \hat{V}_{\text{ne}} \vert j \rangle$ |
|
|
|
|
| ~ecp_local~ | ~float~ | ~(mo.num, mo.num)~ | $\langle i \vert \hat{V}_{\text{ecp,l} \vert j \rangle$ |
|
|
|
|
| ~ecp_non_local~ | ~float~ | ~(mo.num, mo.num)~ | $\langle i \vert \hat{V}_{\text{ecp,nl} \vert j \rangle$ |
|
|
|
|
| ~core_hamiltonian~ | ~float~ | ~(mo.num, mo.num)~ | $\langle i \vert \hat{h} \vert j \rangle$ |
|
|
|
|
|
|
|
|
#+CALL: json(data=mo_1e_int, title="mo_1e_int")
|
|
|
|
|
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
|
|
|
"mo_1e_int": {
|
|
|
|
"overlap" : [ "float", [ "mo.num", "mo.num" ] ]
|
|
|
|
, "kinetic" : [ "float", [ "mo.num", "mo.num" ] ]
|
|
|
|
, "potential_n_e" : [ "float", [ "mo.num", "mo.num" ] ]
|
|
|
|
, "ecp_local" : [ "float", [ "mo.num", "mo.num" ] ]
|
|
|
|
, "ecp_non_local" : [ "float", [ "mo.num", "mo.num" ] ]
|
|
|
|
, "core_hamiltonian" : [ "float", [ "mo.num", "mo.num" ] ]
|
|
|
|
} ,
|
|
|
|
#+end_src
|
|
|
|
:end:
|
|
|
|
|
|
|
|
** Two-electron integrals
|
|
|
|
|
2021-05-24 15:01:04 +02:00
|
|
|
The operators as the same as those defined in the
|
|
|
|
[[ao_two_e][AO two-electron integrals section]]. Here, the integrals are given in
|
|
|
|
the basis of molecular orbitals.
|
2021-05-21 12:10:29 +02:00
|
|
|
|
|
|
|
#+NAME: mo_2e_int
|
|
|
|
| ~eri~ | ~float sparse~ | ~(mo.num, mo.num, mo.num, mo.num)~ | Electron repulsion integrals |
|
|
|
|
| ~eri_lr~ | ~float sparse~ | ~(mo.num, mo.num, mo.num, mo.num)~ | Long-range Electron repulsion integrals |
|
|
|
|
|
|
|
|
#+CALL: json(data=mo_2e_int, title="mo_2e_int")
|
|
|
|
|
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
|
|
|
"mo_2e_int": {
|
|
|
|
"eri" : [ "float sparse", [ "mo.num", "mo.num", "mo.num", "mo.num" ] ]
|
|
|
|
, "eri_lr" : [ "float sparse", [ "mo.num", "mo.num", "mo.num", "mo.num" ] ]
|
|
|
|
} ,
|
|
|
|
#+end_src
|
|
|
|
:end:
|
|
|
|
|
|
|
|
* TODO Slater determinants
|
|
|
|
* TODO Reduced density matrices
|
|
|
|
|
|
|
|
#+NAME: rdm
|
|
|
|
| ~one_e~ | ~float~ | ~(mo.num, mo.num)~ |
|
|
|
|
| ~one_e_up~ | ~float~ | ~(mo.num, mo.num)~ |
|
|
|
|
| ~one_e_dn~ | ~float~ | ~(mo.num, mo.num)~ |
|
|
|
|
| ~two_e~ | ~float sparse~ | ~(mo.num, mo.num, mo.num, mo.num)~ |
|
|
|
|
|
|
|
|
#+CALL: json(data=rdm, title="rdm", last=1)
|
|
|
|
|
|
|
|
#+RESULTS:
|
|
|
|
:results:
|
|
|
|
#+begin_src python :tangle trex.json
|
|
|
|
"rdm": {
|
|
|
|
"one_e" : [ "float" , [ "mo.num", "mo.num" ] ]
|
|
|
|
, "one_e_up" : [ "float" , [ "mo.num", "mo.num" ] ]
|
|
|
|
, "one_e_dn" : [ "float" , [ "mo.num", "mo.num" ] ]
|
|
|
|
, "two_e" : [ "float sparse", [ "mo.num", "mo.num", "mo.num", "mo.num" ] ]
|
|
|
|
}
|
|
|
|
#+end_src
|
|
|
|
:end:
|
|
|
|
|
|
|
|
* Appendix :noexport:
|
|
|
|
** Python script from table to json
|
|
|
|
|
|
|
|
#+NAME: json
|
|
|
|
#+begin_src python :var data=nucleus title="nucleus" last=0 :results output drawer
|
|
|
|
print("""#+begin_src python :tangle trex.json""")
|
|
|
|
print(""" "%s": {"""%(title))
|
|
|
|
indent = " "
|
|
|
|
f1 = 0 ; f2 = 0 ; f3 = 0
|
|
|
|
for line in data:
|
|
|
|
line = [ x.replace("~","") for x in line ]
|
|
|
|
name = '"'+line[0]+'"'
|
|
|
|
typ = '"'+line[1]+'"'
|
|
|
|
dims = line[2]
|
|
|
|
if '(' in dims:
|
|
|
|
dims = dims.strip()[1:-1]
|
|
|
|
dims = [ '"'+x.strip()+'"' for x in dims.split(',') ]
|
|
|
|
dims = "[ " + ", ".join(dims) + " ]"
|
|
|
|
else:
|
|
|
|
dims = "[ ]"
|
|
|
|
f1 = max(f1, len(name))
|
|
|
|
f2 = max(f2, len(typ))
|
|
|
|
f3 = max(f3, len(dims))
|
|
|
|
|
|
|
|
fmt = "%%s%%%ds : [ %%%ds, %%%ds ]" % (f1, f2, f3)
|
|
|
|
for line in data:
|
|
|
|
line = [ x.replace("~","") for x in line ]
|
|
|
|
name = '"'+line[0]+'"'
|
|
|
|
typ = '"'+line[1]+'"'
|
|
|
|
dims = line[2]
|
|
|
|
if '(' in dims:
|
|
|
|
dims = dims.strip()[1:-1]
|
|
|
|
dims = [ '"'+x.strip()+'"' for x in dims.split(',') ]
|
2021-05-21 14:04:19 +02:00
|
|
|
dims.reverse()
|
2021-05-21 12:10:29 +02:00
|
|
|
dims = "[ " + ", ".join(dims) + " ]"
|
|
|
|
else:
|
2021-05-24 15:01:04 +02:00
|
|
|
if dims.strip() != "":
|
|
|
|
dims = "ERROR"
|
|
|
|
else:
|
|
|
|
dims = "[]"
|
2021-05-21 12:10:29 +02:00
|
|
|
buffer = fmt % (indent, name, typ.ljust(f2), dims.ljust(f3))
|
|
|
|
indent = " , "
|
|
|
|
print(buffer)
|
|
|
|
|
|
|
|
if last == 0:
|
|
|
|
print(" } ,")
|
|
|
|
else:
|
|
|
|
print(" }")
|
|
|
|
print("""#+end_src""")
|
|
|
|
|
|
|
|
#+end_src
|
|
|
|
|
|
|
|
|
|
|
|
#+begin_src python :tangle trex.json :results output drawer
|
|
|
|
}
|
|
|
|
#+end_src
|