# CI: Configuration Interaction¶

*Code author: Daniel G. A. Smith, C. David Sherrill, and Matthew L. Leininger*

*Section author: Daniel G. A. Smith and C. David Sherrill*

*Module:* Keywords, PSI Variables, DETCI

Configuration interaction (CI) is one of the most general ways to improve upon Hartree–Fock theory by adding a description of the correlated motions of electrons. Simply put, a CI wavefunction is a linear combination of Slater determinants (or spin-adapted configuration state functions), with the linear coefficients being determined variationally via diagonalization of the Hamiltonian in the given subspace of determinants. For a “single-reference” CI based on reference function \(| \Phi_0 \rangle\), we can write the CI expansion as follows:

The simplest standard CI method that improves upon Hartree–Fock is a CI that adds all singly \(| \Phi_i^a \rangle\) and doubly \(| \Phi_{ij}^{ab} \rangle\) substituted determinants (CISD) to the reference determinant \(| \Phi_0 \rangle\). The CISD wavefunction has fallen out of favor because truncated CI wavefunctions are not size-extensive, meaning that their quality degrades for larger molecules. MP2 is a less expensive alternative giving results similar to those of CISD for small molecules, but the quality of MP2 does not degrade for larger molecules. Coupled-cluster singles and doubles (CCSD) is another size-extensive alternative; it is only slightly more costly computationally than CISD, but it typically provides significantly more accurate results.

The CI code in PSI4 is described in detail in [Sherrill:1999:CI]. For the reasons stated above, the CI code in PSI4 is not optimized for CISD computations, and it uses data structures that are particularly inefficient for CISD and may result in the program running out of memory and crashing for CISD except on very small molecules. Instead, DETCI was designed to be efficient in handling more highly correlated CI wavefunctions that can be helpful in more challenging cases such as highly strained molecules or bond breaking reactions. The CI code is based on the fast, determinant-based string formalism of Handy [Handy:1980]. It can solve for restricted active space configuration interaction (RAS CI) wavefunctions as described by Olsen, Roos, Jorgensen, and Aa. Jensen [Olsen:1988]. Excitation-class selected multi-reference CI wavefunctions, such as second-order CI, can be formulated as RAS CI’s. A RAS CI selects determinants for the model space as those which have no more than \(n\) holes in the lowest set of orbitals (called RAS I) and no more than \(m\) electrons in the highest set of orbitals (called RAS III). An intermediate set of orbitals, if present (RAS II), has no restrictions placed upon it. All determinants satisfying these rules are included in the RAS CI.

The DETCI module is also very efficient at computing full configuration interaction wavefunctions, and it is used in this capacity in the complete-active-space self-consistent-field (CASSCF) code. It can also perform approximate CASSCF computations in which one uses RAS restrictions on the CI excitations, rather than doing a full CI in the active space. This is called a RASSCF. CASSCF and RASSCF computations are types of multi-configurational self-consistent-field procedures, and are described in sec:mcscf.

As mentioned above, the DETCI module is designed for challenging chemical systems for which simple CISD is not suitable. Because CI wavefunctions which go beyond CISD (such as RAS CI) are fairly complex, typically the DETCI code will be used in cases where the tradeoffs between computational expense and completeness of the model space are nontrivial. Hence, the user is advised to develop a good working knowledge of multi-reference and RAS CI methods before attempting to use the program for a production-level project. This user’s manual will provide only an elementary introduction to the most important keywords. Additional information is available in the complete list of keywords for DETCI provided in Appendix DETCI.

For single-reference CI computations, the easiest way to invoke a CI
computation with DETCI is simply to call `energy()`

, `optimize()`

, *etc.*,
with the common name for that CI wavefunction, like `energy('cisd')`

for a CISD single-point energy. The Python driver
recognizes `cisd`

, `cisdt`

, and `cisdtq`

. Higher order
single-reference CI wavefunctions, like those including singles through
6-fold excitations, can be invoked using numbers, like `ci6`

. A full
CI can be specified by `fci`

. More complicated CI computations, like
RASCI, can be performed by setting the appropriate keywords and calling the
module generically like `energy('detci')`

. The latter approach
will also work for any of the previously-mentioned CI wavefunctions for
which the driver has built-in shortcuts, so long as the relevant options
(especially EX_LEVEL) are set appropriately. Some
examples of single-refence CI, RASCI, and full CI computations are provided
in psi4/samples.

CI (e.g., CISD, FCI) | RASCI | CASCI |
---|---|---|

FROZEN_UOCC | FROZEN_UOCC | FROZEN_UOCC [1] |

(all orbitals not in FROZEN_UOCC or FROZEN_DOCC are included in CI) | RAS4 | ACTIVE |

RAS3 | ||

RAS2 | ||

RAS1 | ||

FROZEN_DOCC | FROZEN_DOCC | FROZEN_DOCC |

[1] | FROZEN_UOCC is not required and will be inferred if ACTIVE is provided. However, if it is easier to specify FROZEN_UOCC, then this may be provided and ACTIVE can be inferred. |

The table above shows the relevant orbitals spaces for CI computations (an
analogous table for MCSCF is also available).
The third column of the
table refers to CASCI, in which a full CI is performed in some smaller
set of `active`

orbitals; it is equivalent to CASSCF except without
any orbital optimization. It can be invoked via `energy('fci')`

with appropriate values selected for FROZEN_DOCC and
ACTIVE. For CI computations, there is no difference between
FROZEN_DOCC and RESTRICTED_DOCC, or between
FROZEN_UOCC and RESTRICTED_UOCC. There are
differences between these keywords for sec:mcscf.

## Basic DETCI Keywords¶

### R_CONVERGENCE¶

Convergence criterion for CI residual vector in the Davidson algorithm (RMS error). The default is 1e-4 for energies and 1e-7 for gradients.

Type: conv doubleDefault: 1e-4

### FROZEN_DOCC¶

An array containing the number of frozen doubly-occupied orbitals per irrep (these are not excited in a correlated wavefunction, nor can they be optimized in MCSCF. This trumps NUM_FROZEN_DOCC and FREEZE_CORE

Type: arrayDefault: No Default

### RESTRICTED_DOCC¶

An array giving the number of restricted doubly-occupied orbitals per irrep (not excited in CI wavefunctions, but orbitals can be optimized in MCSCF)

Type: arrayDefault: No Default

### RESTRICTED_UOCC¶

An array giving the number of restricted unoccupied orbitals per irrep (not occupied in CI wavefunctions, but orbitals can be optimized in MCSCF)

Type: arrayDefault: No Default

### FROZEN_UOCC¶

An array containing the number of frozen unoccupied orbitals per irrep (these are not populated in a correlated wavefunction, nor can they be optimized in MCSCF. This trumps NUM_FROZEN_UOCC

Type: arrayDefault: No Default

### CI_MAXITER¶

Maximum number of iterations to diagonalize the Hamiltonian

Type: integerDefault: 24

### ICORE¶

Specifies how to handle buffering of CI vectors. A value of 0 makes the program perform I/O one RAS subblock at a time; 1 uses entire CI vectors at a time; and 2 uses one irrep block at a time. Values of 0 or 2 cause some inefficiency in the I/O (requiring multiple reads of the C vector when constructing H in the iterative subspace if DIAG_METHOD = SEM), but require less core memory.

Type: integerDefault: 1

### DIAG_METHOD¶

This specifies which method is to be used in diagonalizing the Hamiltonian. The valid options are:

`RSP`

, to form the entire H matrix and diagonalize using libciomr to obtain all eigenvalues (n.b. requires HUGE memory);`OLSEN`

, to use Olsen’s preconditioned inverse subspace method (1990);`MITRUSHENKOV`

, to use a 2x2 Olsen/Davidson method; and`DAVIDSON`

(or`SEM`

) to use Liu’s Simultaneous Expansion Method, which is identical to the Davidson method if only one root is to be found. There also exists a SEM debugging mode,`SEMTEST`

. The`SEM`

method is the most robust, but it also requires \(2NM+1\) CI vectors on disk, where \(N\) is the maximum number of iterations and \(M\) is the number of roots.

Type: stringPossible Values: RSP, DAVIDSON, SEMDefault: SEM

### OPDM¶

Do compute one-particle density matrix if not otherwise required?

Type: booleanDefault: false

### TDM¶

Do compute the transition density? Note: only transition densities between roots of the same symmetry will be evaluated. DETCI does not compute states of different irreps within the same computation; to do this, lower the symmetry of the computation.

Type: booleanDefault: false

### MPN¶

Do compute the MPn series out to kth order where k is determined by MAX_NUM_VECS ? For open-shell systems REFERENCE is ROHF, WFN is ZAPTN), DETCI will compute the ZAPTn series. GUESS_VECTOR must be set to UNIT, HD_OTF must be set to TRUE, and HD_AVG must be set to orb_ener; these should happen by default for MPN = TRUE.

Type: booleanDefault: false

For larger computations, additional keywords may be required, as described in the DETCI section of the Appendix DETCI.

## Arbitrary Order Perturbation Theory¶

The DETCI module is capable of computing energies for arbitrary order Møller–Plesset perturbation theory (MPn, for closed-shell systems with an RHF reference) and for Z-averaged perturbation theory (ZAPTn, open-shell systems with a ROHF reference). However, please note that these computations are essentially doing high-order CI (up to full CI) computations to obtain these results, and hence they will only be possible for very small systems (generally a dozen electrons or less).

The simplest way to run high-order perturbation theory computations is to
call, *e.g.*, `energy('mp10')`

to invoke a MP10 computation or
`energy('zapt25')`

to invoke a ZAPT25 computation. This will
automatically set several additional user options to their appropriate
values. The program uses the Wigner (2n+1) rule to obtain higher-order
energies from lower-order wavefunctions.

For the interested reader, the additional user options that are
automatically set up by the calls above are as follows. A call like
`energy('mp10')`

sets MPN to TRUE.
The program uses the Wigner (2n+1) rule by default
(MPN_WIGNER = TRUE)
and figures out what order of wavefunction is
necessary to reach the desired order in the energy. The program then
sets MAX_NUM_VECS to the required order in the
wavefunction.
By default, the requested n-th order energy is saved as the current
energy to the process environment. ZAPTN works essentially the same
way for an ROHF reference.

## Arbitrary Order Coupled-Cluster Theory¶

*This DETCI-based version of this feature is not yet released. However,
the current version of the code does include an interface to*
Kallay’s MRCC *code.*

The DETCI module is also capable of computing arbitrary-order
coupled-cluster energies, using an approach similar to that of Hirata
and Bartlett [Hirata:2000:216], or of Olsen [Olsen:2000:7140].
Notably, the approach in DETCI also allows arbitrary-order
*active space* coupled-cluster procedures. The general algorithm
for doing this in DETCI is inefficient compared to optimized
lower-order coupled-cluster codes and should not be used for CCSD,
where the CCENERGY module is much more efficient. For higher-order
CC (like CCSDT and beyond), the code is also not as efficient as the
MRCC code by Kállay, to which PSI4 can interface (see Section
Interface to MRCC by M. Kállay); however, it may allow certain truncations of the model
space that might not be available presently in MRCC. For very small
systems, the code can be useful for testing of, for example, CCSDTQ or
its active-space CCSDtq analog [Piecuch:1999:6103].

To perform arbitrary-order coupled-cluster, set the DETCI
option CC to TRUE, and set
CC_EX_LEVEL (note: not EX_LEVEL)
to the desired coupled-cluster excitation level, and invoke
`energy('detci')`

. Various other DETCI options have a similar
option for coupled-cluster, usually named beginning with CC. The full
list of options is given in Appendix DETCI.