The PSI3 User's Manual

C. David Sherrill,

T. Daniel Crawford,

Edward F. Valeev,

Micah L. Abrams,

Rollin A. King,

and Ashley Ringer

Center for Computational Molecular Science and Technology, Georgia Institute of Technology, Atlanta, Georgia 30332-0400

Department of Chemistry, Virginia Tech, Blacksburg, Virginia 24061-0001

Department of Chemistry, Bethel College, St. Paul, Minnesota 55112-6999

PSI3 Version: 3.3.0
Created on: 11 April 2007
Report bugs to: psicode@users.sourceforge.net

Introduction

Overview

This manual explains how to use the PSI3 suite of ab initio quantum chemical programs. In this section, we provide an overview of some of the features of PSI3 along with the prerequisite steps for running calculations. Section 2 provides a brief tutorial to help new users get started. Section 3 offers further details into the structure of PSI3 input files and a discussion of some of the most important options. Later sections deal with the different types of computations which can be done using PSI3 (e.g., Hartree-Fock, MP2, coupled-cluster) and general procedures such as geometry optimization and vibrational frequency analysis. The appendix will eventually include a description of the input keywords and command-line options for each module, as well as numerous examples of PSI3 input and basis set files. For the latest PSI3 documentation, check www.psicode.org.

The PSI3 package was developed to perform high-accuracy quantum mechanical computations on challenging chemical species and to provide an infrastructure for the development of new theoretical techniques. Hence, it has a very flexible input scheme which allows non-standard computations, and it is easily adapted to enable new capabilities.

The following citation should be used in any publication utilizing the PSI3 program package:

T. Daniel Crawford, C. David Sherrill, Edward F. Valeev, Justin T. Fermann, Rollin A. King, Matthew L. Leininger, Shawn T. Brown, Curtis L. Janssen, Edward T. Seidl, Joseph P. Kenny, and Wesley D. Allen, J. Comput. Chem., in press.

Obtaining and Installing `PSI3`

The latest version of the PSI3 program package may be obtained at www.psicode.org. The source code is available as a gzipped tar archive (named, for example, psi3.X.tar.gz), and binaries may be available for certain architectures. For detailed installation and testing instructions, please refer to the the PSI3 Installation Manual, available as part of the package or at the PSI3 website above.

Supported Architectures

The majority of PSI3 was developed on IBM RS/6000/AIX and x86/GNU Linux workstations. The complete list of tested architectures to which PSI3 has been ported is shown in Table 1.

**Table 1:** Platforms on which `PSI3` has been installed successfully.
Architecture	Notes
Compaq Alpha Tru64 UNIX	64-bit mode
IBM AIX 4.3.3, 5.x on PowerPC	64-bit mode
Linux on Intel/AMD x86, AMD x86-64	32 and 64-bit
Apple OS X (Darwin) on PowerPC
SGI IRIX64 (6.5.15)	64-bit

If you don't find your system in the Table, there's a good chance that you will be able to install PSI3 on your system if you have the prerequisite tools and math and utility libraries described in the installation manual.

Capabilities

PSI3 can perform ab initio computations employing basis sets of up to 32768 contracted Gaussian-type functions of virtually arbitrary orbital quantum number. PSI3 can recognize and exploit the largest Abelian subgroup of the point group describing the full symmetry of the molecule. Table 2 displays the range of theoretical methods available in PSI3.

**Table 2:** Summary of theoretical methods available in `PSI3`.
Method	Energy	Gradient	Hessian
RHF SCF	Y	Y	Y
ROHF SCF	Y	Y	N
UHF SCF	Y	N	N
HF DBOC	Y	N	N
CIS/RPA/TDHF	Y	N	N
TCSCF	Y	Y	N
CASSCF	Y	Y	N
RAS-CI	Y	N	N
RAS-CI DBOC	Y	N	N
RHF/UHF/ROHF MP2	Y	N	N
RHF MP2-R12	Y	N	N
RHF/UHF/ROHF CCSD	Y	Y	N
RHF/UHF/ROHF CCSD(T)	Y	N	N
RHF EOM-CCSD	Y	N	N
ROHF EOM-CCSD	Y	N	N

Geometry optimization (currently restricted to true minima on the potential energy surface) can be performed using either analytic gradients or energy points. Likewise, vibrational frequencies can be computed using analytic second derivatives or by finite differences of analytic gradients. PSI3 can also compute an extensive list of one-electron properties.

Technical Support

The PSI3 package is distributed for free and without any guarantee of reliability, accuracy, suitability for any particular purpose. No obligation to provide technical support is expressed or implied. As time allows, the developers will attempt to answer inquiries directed to crawdad@vt.edu. For bug reports, specific and detailed information, with example inputs, would be appreciated. Questions or comments regarding this user's manual may be sent to sherrill@gatech.edu.

A `PSI3` Tutorial

Before Getting Started: A Warning about Scratch Files

Generally, electronic structure programs like PSI3 make significant use of disk drives. Therefore, it is very important to ensure that PSI3 is writing its temporary files to a disk drive phsyically attached to the computer running the computation. If it is not, it will significantly slow down the program and the network. By default, PSI3 will write temporary files to /tmp, but you will want to set up a default scratch path (as described in sections 3.5 and 3.6) because the /tmp directory is usually not large enough except for small test cases. In any event, you want to be very careful that you are not writing scratch files to an NFS-mounted directory that is physically attached to a fileserver elsewhere on the network.

Basic Input File Structure

PSI3 reads input from a text file, which can be prepared in any standard text editor. The default input file name is input.dat and the default output file name is output.dat. So that you can give your files meaningful names, these defaults can be changed by specifying the input file name and output file name on the the command line. The syntax is:

psi3 input-name output-name

PSI3 is a modular program, with each module performing specific tasks and computations. Which modules are run for a particular computation depends on the type of computation and the particular keywords specified in the input file. All keywords in PSI3 use the structure keyword = value, where values may be strings, booleans, integers, or real numbers. If the value is a string which contains a special character (such as a space or a dash) you must enclose the string in double quotation marks. You can give keywords in the input file for specific modules; however, in the first few examples, we will place all our keywords in one section of our input file called psi. Generally, every module you run during your computation will read the keywords in psi, so you can place all your keywords in this section if you choose to do so.

Running a basic SCF calculation

In our first example, we will consider a Hartree-Fock SCF computation for the water molecule using a cc-pVDZ basis set. We will specify the geometry of our water molecule using a standard z-matrix.

psi:(
 label = "cc-pVDZ SCF H2O"
 jobtype = sp
 wfn = scf
 reference = rhf
 basis = "cc-pVDZ"
 zmat = (
   o
   h 1 0.957
   h 1 0.957 2 104.5
  )
 )

In each computation, you can specify the type of wavefunction (keyword wfn), the reference wavefunction for post-Hartree-Fock computations (keyword reference), and the type of computation you want to perform (keyword jobtype). In the example above, we used a restricted Hartree-Fock (RHF) reference in an SCF computation of a single-point energy. To change the level of electron correlation, one would specify a different wavefunction type using the keyword wfn. In the example above, to perform an MP2 computation, simply set wfn = mp2.

Geometry Optimization and Vibrational Frequency Analysis

The above example was a simple single-point energy computation. To perform a different type of computation, change the keyword jobtype. In the example below, we will set up a CCSD geometry optimization. To illustrate a more flexible z-matrix input, we will now define variables for the bond length and bond angle (in the zvars section).

% 6-31G** H2O Test optimization calculation

psi: (
  label = "6-31G** SCF H2O"
  jobtype = opt
  wfn = ccsd
  reference = rhf
  dertype = first
  basis = "6-31G**"
  zmat = (
    o
    h 1 roh
    h 1 roh 2 ahoh
  )
  zvars = (
    roh     0.96031231
    ahoh  104.09437511
  )
)

Once you have optimized the geometry of a molecule, you might wish to perform a frequency analysis to determine the nature of the stationary point. To do this, change the value of jobtype to freq. For an SCF frequeny calculation, you would also set dertype = second to compute the second derivatives analytically. Unfortunately, analytical second derivitives are not available in PSI3 for wavefunctions beyond SCF, so instead use the highest order analytical derivitives that are available for the type of wavefunction you have chosen. This information is given in Table 2. For our CCSD example, the highest-order derivitives available are first, so dertype = first.

% 6-31G** H2O Test computation of frequencies

psi: (
  label = "6-31G** SCF H2O"
  jobtype = freq
  wfn = ccsd
  reference = rhf
  dertype = first
  basis = "6-31G**"
  zmat = (
    o
    h 1 roh
    h 1 roh 2 ahoh
  )
  zvars = (
    roh     0.96031231
    ahoh  104.09437511
  )
)

More Advanced Input Options

If you wish to add comments to your input file, you can start any line with % and the line will be a comment line. This can make the input file easier to understand because you can provide explainations about each keyword. Another way to make the input file more organized is to seperate it into sections that correspond to particular modules the calculation will use. This can be particularly helpful for more complicated computations which can utilize many of keywords. In the example below, a CCSD(T) computation for the BH molecule is performed using a cc-pVDZ basis set. The keywords are divided into sections and several new keywords are introduced, including ones to specify symmetry and orbital occupations. Orbitial occupations are specified by a list of integers enclosed in parentheses. These integers give the number of orbitials which belong to each irreducible representation in the point group. The ordering of the irreps are those given by Cotton in Chemical Applications of Group Theory. In this example, comment lines will be included to explain the new keywords used.

psi: (
  wfn = ccsd_t
  reference = rhf
)

default: (
  label = "BH cc-pVDZ CCSD(T)"

% Allocating memory for the calculation
  memory = (600.0 MB)

% charge and multiplicity (2S+1) default to values of 0 and 1, respectively
  charge = 0
  multp = 1

% The program will generally guess the symmetry of the molecule, but
% it can be overridden.  Here we specify C2V because only D2H and its
% subgroups can be used by the program.
  symmetry = c2v

% Number of doubly-occupied orbitals per irrep can be specified manually
% if desired
  docc = (3 0 0 0)

% Freeze the 1A1 orbital (Boron 1s-like) in the CCSD(T) computation
  frozen_docc = (1 0 0 0)
)

% The input section contains information about the molecule and the basis
% set.  The geometry here is specified by cartesian coordinates.
input: (
  basis = "cc-pVDZ"
  units = angstroms
  geometry = (
    ( b      0.0000        0.0000        0.0000)
    ( h      0.0000        0.0000        0.8000)
      )
  origin = (0.0 0.0 0.0)
)
% The modular input structure lets you specify convergence criteria for
% each part of the computation separately
scf: (
  maxiter = 100
  convergence = 11
)

The final example of this tutorial demonstrates an example of a complete-active-space self-consistent-field (CASSCF) computation. CAS computations require specification of several additional keywords because you must specify which orbitals you wish to be in the active space. The notation and ordering for specifying CAS orbitals is the same as for occupied orbitals.

% 6-31G** H2O Test CASSCF Energy Point

psi: (
  label = "6-31G** CASSCF H2O"
  jobtype = sp
  wfn = casscf
  reference = rhf
% The restricted_docc orbitals are those which are optimized, but are not
% in the active space.
  restricted_docc = (1 0 0 0)

% The active space orbitals; here, the valence orbitals are chosen
  active          = (3 0 1 2)

  basis = "6-31G**"
  zmat = (
    o
    h 1 1.00
    h 1 1.00 2 103.1
  )
)

`PSI3` Input Files

Syntax

PSI3 input files are case-insensitive and free-format, with a grammar designed for maximum flexibility and relative simplicity. Input values are assigned using the structure:

keyword = value

where keyword is the parameter chosen (e.g., convergence) and value has one of the following data types:

string: A character sequence surrounded by double-quotes. Example: basis = "cc-pVDZ"
integer: Any positive or negative number (or zero) with no decimal point. Example: maxiter = 100
real: Any floating-point number. Example: omega = 0.077357
boolean: true, false, yes, no, 1, 0.
array: a parenthetical list of values of the above data types. Example: docc = (3 0 1 1).

Note that the input parsing system is general enough to allow multidimensional arrays, with elements of more than one data type. A good example is the z-matrix keyword:

zmat = (
  (O)
  (H 1 r)
  (H 1 r 2 a)
)

For z-matrices, z-matrix variables, and Cartesian coordinates, it is also possible to discard the inner parentheses. The following is equivalent in this case:

zmat = (
  O
  H 1 r
  H 1 r 2 a
)

Keywords must grouped together in blocks, based on the module or modules that require them. The default block is labelled psi:, and most users will require only a psi: block when using PSI3. For example, the following is a simple input file for a single-point CCSD energy calculation on HO:

psi: (
  label = "6-31G**/CCSD H2O"
  wfn = ccsd
  reference = rhf
  jobtype = sp
  basis = "6-31G**"
  zmat = (
     O
     H 1 r 
     H 1 r 2 a 
  )
  zvars = (
     r 1.0 
     a 104.5 
  )
)

In this example, the psi: identifier collects all the keywords (of varying types) together. Every PSI3 module will have access to every keyword in the psi: block by default. One may use other identifiers (e.g., ccenergy:) to separate certain keywords to be used only by selected modules. For example, consider the keyword convergence, which is used by several PSI3 modules to determine the convergence criteria for constructing various types of wave functions. If one wanted to use a high convergence cutoff for the PSI3 SCF module but a lower cutoff for the coupled cluster module, one could modify the above input:

psi: (
  ...
  convergence = 7
)
scf:convergence = 12

Note that, since we have only one keyword associated with the scf: block, we do not need to enclose it parentheses.

Some additional aspects of the PSI3 grammar to keep in mind:

The ``%'' character denotes a comment line, i.e. any information following the ``%'' up to the next linebreak is ignored by the program.
Anything in between double quotes (i.e. strings) is case-sensitive.
Multiple spaces are treated as a single space.

Specifying the Type of Computation

The most important keywords in a PSI3 input file are those which tell the program what type of computation are to be performed. They jobtype keyword tells the psi3 program whether this is a single-point computation, a geometry optimization, a vibrational frequency calculation, etc. The reference keyword specifies whether an RHF, ROHF, UHF, etc., reference is to be used for the SCF wavefunction. The wfn specifies what theoretical method is to be used, either SCF, determinant-based CI, coupled-cluster, etc. Also of critical importance are the charge and multiplicity of the molecule, the molecular geometry, and the basis set to be used. The latter two topics are discussed below in sections 3.3 and 3.7. General keywords determining the general type of computation to be performed are described below.

LABEL = string

This is a character string to be included in the output to help keep track of what computation has been run. It is not otherwise used by the program. There is no default.

JOBTYPE = string

This tells the program whether to run a single-point energy calculation (SP), a geometry optimization (OPT), a series of calculations at different displaced geometries (DISP), a frequency calculation (FREQ), frequencies only for symmetric vibrational modes (SYMM_FREQ), a Diagonal Born-Oppenheimer Correction (DBOC) energy computation, or certain response properties (RESPONSE). The default is SP.

WFN = string

This specifies the wavefunction type. Possible values are:
SCF, MP2, MP2R12, CIS, DETCI, CASSCF, RASSCF, CCSD, CCSD_T, BCCD, BCCD_T, EOM_CCSD.

REFERENCE = string

This specifies the type of SCF calculation one wants to do. It can be one of RHF (for a closed shell singlet), ROHF (for a restricted open shell calculation), UHF (for an unrestricted open shell calculation), or TWOCON (for a two configuration singlet). The default is RHF.

MULTP = integer

Specifies the multiplicity of the molecule, i.e., 2S+1. Default is 1 (singlet).

CHARGE = integer

Specifies the charge of the molecule. Default is 0.

DERTYPE = string

This specifies the order of the derivative that is to be obtained. The default is NONE (energy only).

DOCC = integer vector

This gives the number of doubly occupied orbitals in each irreducible representation. There is no default. If this is not given, cscf will attempt to guess at the occupations.

SOCC = integer vector

This gives the number of singly occupied orbitals in each irreducible representation. There is no default. If this is not given, cscf will attempt to guess at the occupations.

FREEZE_CORE = string

PSI3 can automatically freeze core orbitals. Core orbitals are defined as follows:

 H-Be  no core 
 B-Ne  1s 
Na-Ar  small: 1s2s
       large: 1s2s2p

YES or TRUE will freeze the core orbitals, SMALL or LARGE are for elements Na-Ar. The default is NO or FALSE. Always check to make sure that the occupations are correct!

Geometry Specification

The molecular geometry may be specified using either Cartesian a Z-matrix coordinates. Cartesian coordinates are specified via the keyword geometry:

  geometry = (
     atomname1 x1 y1 z1 
     atomname2 x2 y2 z2 
     atomname3 x3 y3 z3 
             ...
     atomnameN xN yN zN 
  )

where atomname can take the following values:

The element symbol: H, He, Li, Be, B, etc.
The full element name: hydrogen, helium, lithium, etc.
As a ghost atom with the symbol, G, or name, ghost. A ghost atom has a formal charge 0.0, and can be useful to specify the location of the off-nucleus basis functions.
As a dummy atom with the symbol, X. Dummy atoms can be useful only to specify Z-matrix coordinates of proper symmetry or which contain linear fragments.

Hence the following two examples are equivalent to one another:

  geometry = (
     H 0.0 0.0 0.0 
     f 1.0 0.0 0.0 
     Li 3.0 0.0 0.0 
     BE 6.0 0.0 0.0 
  )

  geometry = (
     hydrogen  0.0 0.0 0.0 
     FLUORINE  1.0 0.0 0.0 
     Lithium   3.0 0.0 0.0 
     beryllium 6.0 0.0 0.0 
  )

It is also possible to include an inner set of parentheses around each line containing atomname1 x1 y1 z1.

The keyword units specifies the units for the coordinates:

units = angstrom - angstroms (Å), default;
units = bohr - atomic units (Bohr);

Z-matrix coordinates are specified using the keyword zmat:

  zmat = (
     atomname1
     atomname2 ref21 bond_dist2
     atomname3 ref31 bond_dist3 ref32 bond_angle3 
     atomname4 ref41 bond_dist4 ref42 bond_angle4 ref43 tors_angle4 
     atomname5 ref51 bond_dist5 ref52 bond_angle5 ref53 tors_angle5 
                             ...                
     atomnameN refN1 bond_distN refN2 bond_angleN refN3 tors_angleN 
  )

where

bond_dist is the distance (in units specified by keyword units) from nucleus number to nucleus number ref1. The units
bond_angle is the angle formed by nuclei , ref1, and ref2;
tors_angle is the torsion angle formed by nuclei , ref1, ref2, and ref3;

Molecular Symmetry

PSI3 can determine automatically the largest Abelian point group for a valid framework of centers (including ghost atoms, but dummy atoms are ignored). It will then use the symmetry properties of the system in computing the energy, forces, and other properties. However, in certain instances it is desirable to use less than the full symmetry of the molecule. The keyword subgroup is used to specify a subgroup of the full molecular point group. The allowed values are c2v, c2h, d2, c2, cs, ci, and c1. For certain combinations of a group and its subgroup there is no unique way to determine which subgroup is implied. For example, $D_{\rm 2h}$ has 3 non-equivalent $C_{\rm 2v}$ subgroups, e.g. $C_{\rm 2v}(X)$ consists of symmetry operations , $\hat{C}_2(x)$ , $\hat{\sigma}_{xy}$ , and $\hat{\sigma_{xz}}$ . To specify such subgroups precisely one has to use the keyword unique_axis. For example, the following input will specify the $C_{\rm 2v}(X)$ subgroup of $D_{\rm 2h}$ to be the computational point group:

  psi: (
    ...
    geometry = (
         ...
    )
    units = angstrom
    subgroup = c2v
    unique_axis = x
  )

Point Group	Cotton Ordering of Irreps
C	A
C	A A
C	A B
C	A' A''
C $_{2h}$	A B A B
C $_{2v}$	A A B B
D	A B B B
D $_{2h}$	A B $_{1g}$ B $_{2g}$ B $_{3g}$ A B $_{1u}$ B B $_{3u}$

Specifying Scratch Disk Usage in `PSI3`

Depending on the calculation, the PSI3 package often requires substantial temporary disk storage for integrals, wave function ampltiudes, etc. By default, PSI3 will write all such datafiles to /tmp (except for the checkpoint file, which is written to ./ by default). However, to allow for various customized arrangements of scratch disks, the PSI3 files: block gives the user considerable control over how temporary files are organized, including file names, scratch directories, and the ability to ``stripe'' files over several disks (much like RAID0 systems). This section of keywords is normally placed within the psi: section of input, but may be used for specific PSI3 modules, just like other keywords.

For example, if the user is working with PSI3 on a computer system with only one scratch disk (mounted at, e.g., /scr), one could identify the disk in the input file as follows:

psi: (
  ...
  files: (
    default: (
      nvolume = 1
      volume1 = "/scr/"
    )
  )
)

The nvolume keyword indicates the number of scratch directories/disks to be used to stripe files, and each of these is specified by a corresponding volumen keyword. (NB: the trailing slash ``/'' is essential in the directoy name.) Thus, in the above example, all temporary storage files generated by the various PSI3 modules would automatically be placed in the /scr directory.

By default, the scratch files are given the prefix ``psi'', and named ``psi.nnn'', where nnn is a number used by the PSI3 modules. The user can select a different prefix by specifying it in the input file with the name keyword:

psi: (
  ...
  files: (
    default: (
      name = "H2O"
      nvolume = 1
      volume1 = "/scr/"
    )
  )
)

The name keyword allows the user to store data associated with multiple calculations in the same scratch area. Alternatively, one may specify the filename prefix on the command-line of the psi3 driver program (or any PSI3 module) with the -p argument:

psi3 -p H2O

If the user has multiple scratch areas available, PSI3 files may be automatically split (evenly) across them:

psi: (
  ...
  files: (
    default: (
      nvolume = 3
      volume1 = "/scr1/"
      volume2 = "/scr2/"
      volume3 = "/scr3/"
    )
  )
)

In this case, each PSI3 datafile will be written in chunks (65 kB each) to three separate files, e.g., /scr1/psi.72, /scr2/psi.72, and /scr3/psi.72. The maximum number of volumes allowed for striping files is eight (8), though this may be easily extended in the PSI3 I/O code, if necessary.

The format of the files section of input also allows the user to place selected files in alternative directories, such as the current working directory. This feature is especially important if some of the data need to be retained between calculations. For example, the following files: section will put file32 (the PSI3 checkpoint file) into the working directory, but all scratch files into the temporary areas:

psi: (
  ...
  files: (
    default: (
      nvolume = 3
      volume1 = "/scr1/"
      volume2 = "/scr2/"
      volume3 = "/scr3/"
    )
    file32: ( nvolume = 1  volume1 = "./" )
  )
)

The `.psirc` File

Users of PSI3 often find that they wish to use certain keywords or input sections in every calculation they run, especially those keywords associated with the files: section. The .psirc file, which is kept in the user's $HOME directory, helps to avoid repetition of keywords whose defaults are essentially user- or system-specific. A typical .psirc file would look like:

psi: (
  files: (
    default: (
      nvolume=3
      volume1 = "/tmp1/mylogin/"
      volume2 = "/tmp2/mylogin/"
      volume3 = "/tmp3/mylogin/"
    )
    file32: (nvolume=1 volume1 = "./")
  )
)

Specifying Basis Sets

PSI3 uses basis sets comprised of Cartesian or spherical harmonic Gaussian functions. A basis set is identified by a string, enclosed in double quotes. Currently, there exist three ways to specify which basis sets to use for which atoms:

basis = string - all atoms use basis set type.
basis = (string1 string2 string3 ... stringN) - string i specifies the basis set for atom i. Thus, the number of strings in the basis vector has to be the same as the number of atoms (including ghost atoms but excluding dummy atoms). Another restriction is that symmetry equivalent atoms should have same basis sets, otherwise input will use the string provided for the so-called unique atom out of the set of symmetry equivalent ones.

  basis = (
    (element1 string1)
    (element2 string2)
            ...
    (elementN stringN)
  )

string i specifies the basis set for chemical element element i.

Default Basis Sets

PSI3 default basis sets are located in pbasis.dat which may be found by default in $psipath/share. Tables 3, 4, 5, and 6 list basis sets pre-defined in pbasis.dat.

The predefined basis sets use either spherical harmonics or Cartesian Gaussians, which is determined by the authors of the basis. Currently PSI3 cannot handle basis sets that consist of a mix of Cartesian and spherical harmonics Gaussians. Therefore there may be combinations of basis sets that are forbidden, e.g. cc-pVTZ and 6-31G**. In such case one can override the predetermined choice of the type of the Gaussians by specifying the puream keyword. It takes two values, true or false, for spherical harmonics and Cartesian Gaussians, respectively.

**Table 3:** Pople-type basis sets available in `PSI3`
Basis Set	Atoms	Aliases
STO-3G	H-Ar
3-21G	H-Ar
6-31G	H-Ar, K, Ca, Cu
6-31G*	H-Ar, K, Ca, Cu	6-31G(d)
6-31+G*	H-Ar	6-31+G(d)
6-31G**	H-Ar, K, Ca, Cu	6-31G(d,p)
6-311G	H-Ar
6-311G*	H-Ar	6-311G(d)
6-311+G*	H-Ne	6-311+G(d)
6-311G**	H-Ar	6-311G(d,p)
6-311G(2df,2pd)	H-Ne
6-311++G**	H, B-Ar	6-311++G(d,p)
6-311G(2d,2p)	H-Ar
6-311++G(2d,2p)	H-Ar
6-311++G(3df,3pd)	H-Ar

**Table 4:** Huzinaga-Dunning basis sets available in `PSI3`
Basis Set	Atoms
(4S/2S)	H
(9S5P/4S2P)	B-F
(11S7P/6S4P)	Al-Cl
DZ	H, Li, B-F, Al-Cl
DZP	H, Li, Be, B-F, Na, Al-Cl
DZ-DIF	H, B-F, Al-Cl
DZP-DIF	H, B-F, Al-Cl
TZ2P	H, B-F, Al-Cl
TZ2PD	H
TZ2PF	H, B-F, Al-Cl
TZ-DIF	H, B-F, Al-Cl
TZ2P-DIF	H, B-F, Al-Cl
TZ2PD-DIF	H
TZ2PF-DIF	H, B-F, Al-Cl

**Table 5:** Wachters basis sets available in `PSI3`
Basis Set	Atoms
WACHTERS	K, Sc-Cu
WACHTERS-F	Sc-Cu

**Table 6:** Correlation-consistent basis sets available in `PSI3`
Basis Set	Atoms	Aliases
(N = D,T,Q,5,6)
cc-pVNZ	H-Ar	CC-PVNZ
cc-pV(N+D)Z	Al-Ar	CC-PV(N+D)Z
cc-pCVNZ	B-Ne	CC-PCVNZ
aug-cc-pVNZ	H-He, B-Ne, Al-Ar	AUG-CC-PVNZ
aug-cc-pV(N+D)Z	Al-Ar	AUG-CC-PCV(N+d)Z
aug-cc-pCVNZ	B-F (N6)	AUG-CC-PCVNZ
d-aug-cc-pVNZ	H
pV7Z¹	H, C, N, O, F, S	PV7Z
cc-pV7Z²	H, C, N, O, F, S	CC-PV7Z
aug-pV7Z³	H, C, N, O, F, S	AUG-PV7Z
aug-cc-pV7Z⁴	H, N, O, F	AUG-CC-PV7Z

Custom Basis Sets

If the basis set you desire is not already defined in PSI3, a custom set may be used by specifying its exponents and contraction coefficients (either in the input file or another file named basis.dat.) A contracted Cartesian Gaussian-type orbital

$\begin{displaymath} \phi_{\rm CGTO} = x^ly^mz^n\sum_i^N C_i \exp(-\alpha_i[x^2+y^2+z^2]) \end{displaymath}$

(1)

where

$\begin{displaymath} L = l+m+n \end{displaymath}$

(2)

is written as

basis: (
  ATOM_NAME: "BASIS_SET_LABEL" = (
    (L (C1  alpha1)
       (C2  alpha2)
       (C3  alpha3)
       ...
       (CN  alpha4))   
    )
  )

One must further specify whether Cartesian or spherical harmonics Gaussians are to be used. One can specify that in two ways:

It can be done on a basis by basis case, such as
```
basis: (
  "BASIS_SET_LABEL1":puream = true
  "BASIS_SET_LABEL2":puream = false
  "BASIS_SET_LABEL3":puream = true
  ....
)
```
By default, if puream is not given for a basis, then Cartesian Gaussians will be used.
The choice between Cartesian or spherical harmonics Gaussian can be made globally by specifying puream keyword in the standard input section, e.g.
```
psi: (
  ...
  puream = true
  ...
)
```

Note that currently PSI3 cannot handle basis sets that consist of a mix of Cartesian and spherical harmonics Gaussians.

Note that the basis set must be given in a separate basis: section of input, outside all other sections (including psi:). For example, the PSI3 DZP basis set for carbon could be specified as:

basis: (
  carbon: "DZP" = (
    (S (   4232.6100      0.002029) 
       (    634.8820      0.015535)
       (    146.0970      0.075411)
       (     42.4974      0.257121)
       (     14.1892      0.596555) 
       (      1.9666      0.242517))
    (S (      5.1477      1.0))
    (S (      0.4962      1.0))
    (S (      0.1533      1.0))
    (P (     18.1557      0.018534)
       (      3.9864      0.115442)
       (      1.1429      0.386206)
       (      0.3594      0.640089))
    (P (      0.1146      1.0))
    (D (      0.75        1.0))
  )
)

Here are a couple of additional points that may be useful when specifying customized basis sets:

Normally the basis.dat file is placed in the same directory as the main input file, but it may also be placed in a global location specified by the keyword basisfile:
```
  basisfile = "/home/users/tool/chem/h2o/mybasis.in"
```
To scale a basis set, a scale factor may be added as the last item in the specification of each contracted Gaussian function. For example, to scale the S functions in a 6-31G** basis for hydrogen, one would use the following
```
  hydrogen: "6-31G**" =
      ( (S (    18.73113696     0.03349460)
           (     2.82539437     0.23472695)
           (     0.64012169     0.81375733) 1.2 )
        (S (     0.16127776     1.00000000) 1.2 )
        (P (     1.10000000     1.00000000))
       )
```
In this example, both contracted S functions have their exponents scaled by a factor of (1.2) = 1.44. The output file should show the exponents after scaling.

Automated Conversion of Basis Sets

The PSI3 package is distributed with a Perl-based utility, named g94_2_PSI3, which will convert basis sets from the Gaussian ('94 or later) format to PSI3 format automatically. This utility is especially useful for basis sets downloaded from the EMSL database at http://www.emsl.pnl.gov/forms/basisform.html. To use this utility, save the desired basis set to a file (e.g., g94_basis.dat) in the Gaussian format. Then execute:

g94_2_PSI3 < g94_basis.dat > basis.dat

You may either incorporate the results from the basis.dat file into your input file as described above, or place the results into a global basis.dat file. Be sure to surround the basis-set definition with the basis:() keyword (as shown in the above examples) or input parsing errors will result.

Specification of Ghost Atoms

To specify ghost atoms, use atom symbol G in zmat or geometry keywords:

  zmat = (
    he
    g 1 r
  )
  basis = "aug-cc-pVTZ"

Basis sets for ghost atoms must be defined explicitly using GHOST as the element name:

  basis:GHOST:"aug-cc-pVTZ": (
    ....
  )

This method leads to replication of existing basis set definitions. It is usually more convenient to specify ghost atoms as regular atoms with zero charge:

  zmat = (
    he
    he 1 r
  )
  charges = (2.0 0.0)
  basis = "aug-cc-pVTZ"

In this example, the second helium atom is a ``ghost'' atom which carries helium's aug-cc-pVTZ basis set.

Theoretical Methods Available in `PSI3`

Several electronic structure methods are available in the PSI3 package, from Hatree-Fock molecular orbital theory to coupled-cluster theory to full configuration interaction. This section introduces the methods available and some of their most common input parameters. Less commonly used keywords are described in the man pages for each module.

Hartree-Fock Self-Consistent-Field

Hartree-Fock molecular orbital theory forms the cornerstone of ab initio quantum chemistry. Until the advances in the accuracy of Kohn-Sham density functional theory in the 1990's, Hartree-Fock theory was the method of choice for obtaining results for large molecules without resorting to standard empirical or semiempirical approaches. Molecular properties obtained by Hatree-Fock theory are generally at least qualitatively correct, although they can be quantitatively poor in many instances.

PSI3 solves the Hatree-Fock equations in a basis of Gaussian functions using an iterative, self-consistent-field (SCF) procedure. The final molecular orbitals are those which minimize the energy, subject to the electron configuration specified by the user (or guessed by the program). The process is continued until the largest change in an element of the density matrix drops below 10 $^{-n}$ , where is an integer specified by the convergence keyword.

Of course the efficiency of the iterative procedure depends on the choice of initial guess. The cscf module will attempt to use previously obtained orbitals as a guess if they are available. This can be particularly advantageous when diffuse functions are present; in that case, it may be easiest to run the computation with a smaller basis and project those orbitals onto the larger basis by specifying the -chkptmos command-line argument or the chkpt_mos=true keyword in input when running the input program for the larger basis. If old MO's are not available, cscf uses a core Hamiltonian guess by default. The convergence of the SCF procedure is accelerated by Pulay's direct inversion of the iterative subspace (DIIS) approach, and it is possible to modify the behavior of the DIIS through various keywords, although this is seldom necessary.

It is important to point out that the SCF approach does not rigorously guarantee that the final orbitals actually correspond to a minimum in orbital space; at convergence, the only guarantee is that the gradient of the energy with respect to orbital rotations is zero: this could be a global minimum, a local minimum, or a saddle point in orbital rotation space. While this is not usually an issue (typically the lowest minimum consistent with the electron configuration is found), it can be a problem sometimes for radicals, diradicals, bond breaking, or unusual bonding situations. The stable module can be used to test for the stability of Hartree-Fock wave functions.

The most commonly used keywords are found below. More specialized keywords are available in the man pages.

MAXITER = integer: This gives the maximum number of iterations. The default is 40.
CONVERGENCE = integer: This specifies how tightly the wavefunction will be converged. Convergence is determined by comparing the RMS change in the density matrix ("delta P") to the given value. The convergence criterion is 10**(-integer). The default is 7 if both DERTYPE = NONE and WFN = SCF are given and 10 otherwise.
LEVELSHIFT = real: This specifies the level shift. The default is 1.
DIRECT = boolean: Specifies whether to do the SCF calculation with an integral-direct technique. The default is false.
NUM_THREADS = integer: Specified the number of threads to be used in the integral-direct computation (only valid if DIRECT is set to true). Default is 1.
PRINT_MOS = boolean: Specifies whether to print the molecular orbitals or not. The default is false.

Second-order Møller-Plesset Theory: MP2 and MP2-R12 methods

Second-order Møller-Plesset theory is one of the most basic wave function approaches which includes electron correlation directly. Due to its simplicity, the MP2 method is often the best level one can afford for a larger molecular system. At the other end of the spectrum, the MP2-R12 method of Kutzelnigg, Klopper, and co-workers is a promising approach to computing MP2 energies in the complete basis set limit for smaller systems. PSI3 is one of the very few publicly available programs to feature a robust implementation of the MP2-R12 method.

PSI3 is capable of computing closed-shell MP2 and MP2-R12/A energies using integral-direct techniques and a multithreaded algorithm, which lends itself perfectly for execution on symmetric multiprocessor (SMP) machines. PSI3 is also capable of computing RHF, UHF, and ROHF (using semicanonical orbitals) MP2 energies and one-particle density matrices, and RHF MP2 analytic gradients. Occupied and virtual orbitals can be frozen during the energy calculation, but not for the calculation of the one-particle density matrix or the analytic gradient.

Table 7 summarizes these capabilities.

Reference	Method	Energy (conv)	Energy (integral-direct)	Gradient
RHF	MP2	Y	Y	Y
UHF	MP2	Y	N	N
ROHF	MP2	Y	N	N
RHF	MP2-R12/A	N	Y	N

Basic Keywords

To compute a ground-state MP2 or MP2-R12 energy at a fixed geometry, the following keywords are common:

WFN = string: Acceptable values are mp2 for MP2, mp2r12 [for MP2-R12/A] There is no default.
REFERENCE = string: The only acceptable value are rhf, uhf, and rohf. There is no default.
JOBTYPE = string: Acceptable values are sp and opt. There is no default.
MEMORY = (real MB): Specified the amount of core memory to be used, in MB. Defaults to 256. Other units (e.g., KB or GB) are also allowed.
DIRECT = boolean: Specifies whether to use the conventional (false) or integral-direct (true) algorithm. Default is false.
NUM_THREADS = integer: Specified the number of threads to be used in the integral-direct computation (only valid if DIRECT is set to true). Default is 1.
FREEZE_CORE = boolean: Specifies whether core orbitals (which are determined automatically) are to be excluded from the correlated calculations. Default is false.
PRINT = integer: The desired print level for detailed output. Setting this to 2 is a good idea for larger calculations so that the progress of the calculation may be easily followed. Defaults to 0.
OPDM = boolean: If true, calculate the one-particle density matrix. The default is false.
OPDM_WRITE = boolean: If true, write the one-particle density matrix to disk.
OPDM_PRINT = boolean: If true, print the one-particle density matrix to the output file.

Using the MP2-R12 method

Although this manual is not a how-to on running quantum chemistry applications, the MP2-R12 method is a rather non-standard tool, hence a few comments on its use are appropriate.

The version of the MP2-R12 method implemented in PSI3 is a so-called single-basis MP2-R12 method in standard approximation A. This means that a basis set rather complete in Hartree-Fock (or one-particle) sense is absolutely mandatory for meaningful computations with the MP2-R12 method. The user is strongly urged to read literature on linear R12 methods before using PSI3 to compute MP2-R12 energies.
More robust, two-basis versions of the MP2-R12 method, also known as the auxiliary basis MP2-R12 method, have been implemented in a publicly available Massively Parallel Quantum Chemistry (MPQC) package (see http://aros.ca.sandia.gov/~cljanss/mpqc/). The two-basis version of the MP2-R12 method is a theoretically more sound approach, and thus should be preferred to the single-basis method. In some situations, however, it may make sense to use the single-basis method.

Larger Calculations

Here are a few recommendations for carrying out extended integral-direct MP2 and MP2-R12 calculations with PSI3:

While the integral-direct MP2 algorithm doesn't need any significant disk storage, the integral-direct algorithm for the MP2-R12 energy stores the transformed integrals to disk, hence very large computations will require a lot of disk space. In general the storage requirement is bytes, where is the number of occupied orbitals, and is the size of the basis.
If there is not enough memory to perform the computation in one pass, the program will do multiple passes through the entire set of integrals, hence your computation will run that many times longer. In such case, find the machine with the most memory and processors available.
On SMP machines, set the NUM_THREADS to the number of processors available for the job, or, if all processors are allocated for your job, set NUM_THREADS to twice the number of processors you have. Modern operating systems schedulers are usually very efficient at handling multithreaded programs, so the overhead of thread context switching is not significant, but using more threads may lead to better load balancing, and lower execution times. For example, on a 32-processor IBM eServer p690 we found that the optimal number of threads was 128. For the optimal performance, do a few runs with different number of threads and see which number works best. Avoid excessively large number of threads, as this descreases the net amount of memory available to the computation and thus may increase the number of passes.
Set the MEMORY keyword to the 90% of the available physical memory, at most. There is a small amount of overhead associated with the integral-direct algorithms that is not accounted for by the internal memory handling routines.
The implementation of the integral-direct MP2-R12 (and MP2) method in PSI3 can run efficiently on SMP, or shared-memory, machines, by utilizing multiple processors via multithreaded approach. However, it cannot utilize distributed memory machines, such as commodity (PC) clusters and massively parallel machines, to their full potential, since one computation can only take advantage of one node of such machine at a time. In such environments, the aformentioned MPQC implementation of the MP2-R12 method should be preferred (see http://aros.ca.sandia.gov/~cljanss/mpqc/).

Coupled Cluster Methods

The coupled cluster approach is one of the most accurate and reliable quantum chemical techniques for including the effects of electron correlation. PSI3 is capable of computing energies, analytic gradients, and linear response properties using a number of coupled cluster models. Table 8 summarizes these capabilities. This section describes how to carry out coupled cluster calculations within PSI3.

Reference	Method	Energy	Gradient	Exc. Energies	LR Props
RHF	CC2	Y	N	Y	Y
UHF	CC2	Y	N	Y	N
ROHF	CC2	Y	N	Y	N
RHF	CCSD	Y	Y	Y	Y
RHF	CCSD(T)	Y	N	-	-
ROHF	CCSD	Y	Y	Y	N
ROHF	CCSD(T)	N	N	-	-
UHF	CCSD	Y	Y	Y	N
UHF	CCSD(T)	Y	N	-	-
Brueckner	CCD	Y	N	N	N
Brueckner	CCD(T)	Y	N	-	-

Basic Keywords

To compute a ground-state CCSD or CCSD(T) energy at a fixed geometry, the following keywords are common:

WFN = string: Acceptable values are ccsd, ccsd_t [for CCSD(T)], bccd (for Brueckner-orbital-based CCD), or bccd_t [for Brueckner-orbital-based CCSD(T)] There is no default.
REFERENCE = string: Acceptable values are reference = rhf, rohf, or uhf. There is no default.
JOBTYPE = string: Acceptable values are sp, opt, freq, oeprop, or response. There is no default.
CONVERGENCE = integer: Sets the order of magnitude on the convergence of the CC wave function, perturbed wave function, and/or lambda parameters. The root-mean-square of the difference in amplitude vectors from consecutive iterations is used to determine the convergence. The default is 7.
MAXITER = integer: The maximum number of iterations allowed for solving the CC amplitude or lambda amplitude equations. Defaults to 50.
MEMORY = (real MB): Specified the amount of core memory to be used, in MB. Defaults to 256. Other units (e.g., KB or GB) are also allowed.
BRUECKNER_CONV = integer: Specifies the order of magnitude convergence required for the Brueckner orbitals. The convergence is determined based on the largest T1 amplitude.
AO_BASIS = string: Specifies the algorithm to be used in computing the contribution of the four-virtual-index integrals ( $\langle ab\vert\vert cd\rangle$ ) to the CC amplitude equations. If AO_BASIS=NONE, the MO-basis integrals will be used; if AO_BASIS=DISK, the AO-basis integrals, stored on disk, will be used; if AO_BASIS=DIRECT, the AO-basis integrals will be computed on the fly as necessary. NB: The AO_BASIS=DIRECT option is not fully implemented and should only be used by experts. Default is NONE. New algorithms are in progress for significantly speeding up this portion of the computation.
FREEZE_CORE = boolean: Specifies whether core orbitals (which are determined automatically) are to be excluded from the correlated calculations. Default is FALSE.
RESTART = boolean: Determine whether previous amplitude vectors may be used as guesses in a given CC calculation. Defaults to TRUE. For geometry optimizations, Brueckner calculations, etc. the iterative solution of the CC amplitude equations may benefit considerably by reusing old vectors as initial guesses. Assuming that the MO phases remain the same between updates, the CC codes will, by default, re-use old vectors, unless the user sets RESTART = false.
PRINT = integer: The desired print level for detailed output. Setting this to 2 is a good idea for larger calculations so that the progress of the calculation may be easily followed. Defaults to 0.
CACHELEV = integer: Sets the level of automated cacheing of four-index quantities in the CC modules. These modules are capable of keeping in core as much as possible, various four-index quantities categorized by the number of virtual/unoccupied-orbital indices they contain. Setting CACHELEV=0 will cache nothing (wise and sometimes necessary for very large CC calculations), CACHELEV=1 will keep quantities with up to one virtual index in core (e.g., integrals of the form $\langle ij\vert\vert ka\rangle$ ), CACHELEV=2 will keep quantities with up two two virtual indices in core (e.g., integrals of the form $\langle ij\vert\vert ab \rangle$ or $\hat{T}_2$ amplitudes), CACHELEV=3 will keep three-virtual-index quantities in core, and CACHELEV=4 will keep everything in core. Note that the cache behavior is tempered by the MEMORY keyword, and items will be deleted from the cache (in an order determined based on the CACHETYEP keyword) as additional memory is required in a given calculation.
CACHETYPE = string: Specifies the type of cache to be used, either LOW or LRU. If CACHETYPE=LOW, then elements are deleted from the cache based on a predefined order of priority. If CACHETYPE=LRU, then elements are deleted from the cache based on a ``least recently used'' criterion: the least recently used item is the first to be deleted. The LOW criterion has been developed only ccenergy codes. The default is LRU for all CC modules except ccenergy.
NUM_AMPS = integer: Specifies the number of wave function amplitudes to print at the end of the energy calculation. Defaults to 10.
PRINT_MP2_AMPS = boolean: Specifies if the initial guess (MP2) amplitudes should be printed in the output file. Defaults to FALSE.

Larger Calculations

Here are a few recommendations for carrying out large-basis-set coupled cluster calculations with PSI3:

Set the MEMORY keyword to 90% of the available physical memory, at most. There is a small amount of overhead associated with the coupled cluster modules that is not accounted for by the internal CC memory handling routines. Thus, the user should not sepcify the entire physical memory of the system, or swapping is likely.
Set the CACHELEV keyword to 0. This will turn off cacheing, which, for very large calculations, can lead to heap fragmentation and memory faults, even when sufficient physical memory exists.
Set the PRINT keyword to 2. This will help narrow where memory bottlenecks or other errors exist in the event of a crash.
Set the AO_BASIS keyword to DISK. This will save significantly on disk space.

Excited State Coupled Cluster Calculations

The most important keywords associated with EOM-CC calculations are:

STATES_PER_IRREP = (integer array): Specifies the desired number of excited states per irreducible representation for both EOM-CC and CC-LR calculations. Note that the irreps in this keyword denote the final state symmetry, not the symmetry of the transition.
PRINT_SINGLES = boolean: Specifies whether information regarding the iterative solution to the single-excitation EOM-CC problem (normally used to obtain guesses for a ful EOM-CCSD calculation) will be printed.
RESIDUAL_TOL = integer: Specifies the order of magnitude cutoff used to determine the convergence of the Davidson algorithm residuals in the EOM-CC iterative procedure.
EVAL_TOL = integer: Specifies the order of magnitude cutoff used to determine the convergence of the final eigenvalues in the EOM-CC iterative procedure.
EOM_GUESS = (mixed array): Specifies a set of single-excitation guess vectors for the EOM-CC procedure. This is especially useful for converging to difficult states. The EOM_GUESS keyword is an array, each element of which includes an occupied orbital index (in coupled cluster ordering), a virtual orbital index, a weighting factor, and a spin (0 for $\alpha$ and 1 for $\beta$ ). The guess vector will be normalized after it is read, so only the relative magnitudes of the weight factors are important.
JOBTYPE = string: A value of oeprop will result in the calculation of oscillator strengths, rotational strengths, and dipole moments for an RHF reference and all but the rotational strengths for an ROHF or UHF reference.

Linear Response (CCLR) Calculations

The most important keywords associated with CC-LR calculations are:

PROPERTY = string: For linear-response calculations, this specifies the type or response property desired. Acceptable values are POLARIZABILITY (default) for dipole-polarizabilities and ROTATION for specific rotations. For PROPERTY=ROTATION, both types of property are actually computed.
OMEGA = real or (real UNITS): Specifies the desired frequency of the incident radiation field in CCLR calculations. Acceptable units are HZ, NM, and EV. If given without units, atomic units (Hartrees) are assumed.
MU_IRREPS = (integer array): Specifies the irreducible representations associated with the -, -, and -axes. This may be determined from the standard Cotton tables. Eventually this will be determined automatically by the program, so this keyword will go away.

Configuration Interaction

Configuration interaction (CI) is one of the most general ways to improve upon Hartree-Fock theory by adding a description of the correlations between electron motions. 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. The simplest standard CI method which improves upon Hartree-Fock is a CI which adds all singly and doubly substituted determinants (CISD). The CISD wavefunction has fallen out of favor because truncated CI wavefunctions short of full configuration interaction are not size-extensive, meaning that their quality degrades for larger molecules. MP2 offers a less expensive alternative whose quality does not degrade for larger molecules and which gives similar results to CISD for well-behaved molecules. CCSD is usually a more accurate alternative, at only slightly higher cost.

For the reasons stated above, the CI code in PSI3 is not optimized for CISD computations. Instead, emphasis has been placed on developing a very efficient program to handle more general CI wavefunctions which may be helpful in more challenging cases such as highly strained molecules or bond breaking reactions. The detci program is a fast, determinant-based CI program based upon the string formalism of Handy [1]. It can solve for restricted active space configuration interaction (RAS CI) wavefunctions as described by Olsen, Roos, Jorgensen, and Aa. Jensen [2]. 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 CI.

The detci program is also very efficient at full configuration interaction wavefunctions, and is used in this capacity in the complete-active-space self-consistent-field (CASSCF) code. Use of detci for CASSCF wavefunctions is described in the following section of this manual.

As just mentioned, the PSI3 program 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 program 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 man pages for detci.

The division of the molecular orbitals into various subspaces such as RAS spaces, or frozen vs active orbitals, etc, needs to be clear not only to the detci program, but also at least to the transformation program (and in the case of MCSCF, to other programs as well). Thus, orbital subspace keywords such as RAS1, RAS2, RAS3, frozen_docc, frozen_uocc, active, etc., need to be in the psi:() or default:() sections of input so they may also be read by other modules.

Basic Keywords

WFN = string: Acceptable values for determinant-based CI computations in PSI3 are detci and, for CASSCF, detcas.
REFERENCE = string: Most reference types allowed by PSI3 are allowed by detci, except that uhf is not supported.
DERTYPE = string: Only single-point calculations are allowed for wfn = detci. For wfn = detcas, first derivatives are also available.
CONVERGENCE = integer: Convergence desired on the CI vector. Convergence is achieved when the RMS of the error in the CI vector is less than 10**(-n). The default is 4 for energies and 7 for gradients.
EX_LVL = integer: Excitation level for excitations into virtual orbitals (default 2, i.e. CISD). In a RAS CI, this is the number of electrons allowed in RAS III.
VAL_EX_LVL = integer: In a RAS CI, this is the additional excitation level for allowing electrons out of RAS I into RAS II. The maximum number of holes in RAS I is therefore EX_LVL + VAL_EX_LVL. Defaults to zero.
FROZEN_DOCC = (integer array): Core may be frozen by setting FREEZE_CORE. To manually select how many orbitals per irrep to freeze, use the FROZEN_DOCC keyword. Should be in psi:() or default:() sections of input. The number of lowest energy doubly occupied orbitals in each irreducible representation from which there will be no excitations. The Cotton ordering of the irredicible representations is used. The default is the zero vector.
FROZEN_UOCC = (integer array): Should be in psi:() or default:() sections of input. The number of highest energy unoccupied orbitals in each irreducible representation into which there will be no excitations. The default is the zero vector.
RAS1 = (integer array): Should be in psi:() or default:() sections of input. The number of orbitals for each irrep making up the RAS I space, from which a maximum of EX_LVL + VAL_EX_LVL excitations are allowed. This does not include frozen core orbitals. For a normal CI truncated at an excitation level such as CISD, CISDT, etc., it is not necessary to specify this or RAS2 or RAS3. Note: this keyword must be visible to the transqt program also so that orbitals are ordered correctly (placing it in default or psi should be adequate).
RAS2 = (integer array): Should be in psi:() or default:() sections of input. As above for RAS1, but for the RAS II subspace. No restrictions are placed on the occupancy of RAS II orbitals. Typically this will correspond to the conventional idea of an ``active space'' in multi-reference CI.
RAS 3 = (integer array): Should be in psi:() or default:() sections of input. As above for RAS3, but for the RAS III subspace. A maximum of EX_LVL electrons are allowed in RAS III.
MAXITER = integer: Maximum number of iterations to diagonalize the Hamiltonian. Defaults to 12.
NUM_ROOTS = integer: This value gives the number of roots which are to be obtained from the secular equations. The default is one. If more than one root is required, set DIAG_METHOD to SEM (or, for very small cases, RSP or SEMTEST). Note that only roots of the same irrep as the reference will be computed. To compute roots of a different irrep, one can use the REF_SYM keyword (for full CI only).
OPDM = boolean: If TRUE, compute the one-particle density matrix for each root. By default, it will be written to disk. Except for MCSCF computations (e.g., CASSCF, RASSCF), this will also turn on computation of dipole moments by default.
TRANSITION_DENSITY = boolean: If TRUE, compute the transition density matrix from the ground state to each other state obtained in the computation. By default, this information will be written to disk. Transition dipole moments will be evaluated in detci. 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 using the subgroup keyword in psi:() or default:() (see section 3.4).
DIPMOM = boolean: If TRUE, evaluate the dipole moment for each root (using the expectation value formula; orbital relaxation contributions are neglected). This is an alternative to evaluation using the oeprop module, which has more features.
REF_SYM = integer: This option allows the user to look for CI vectors of a different irrep than the reference. This probably only makes sense for Full CI, and it is not supported for unit vector guesses.

For larger computations, additional keywords may be required, as described in the detci man pages.

Complete-Active-Space Self-Consistent-Field (CASSCF)

Multi-configurational self-consistent-field (MCSCF) is a general method for obtaining qualitatively correct wavefunctions for highly strained molecules, diradicals, or bond breaking reactions. The most commonly used MCSCF procedure is the complete-active-space self-consistent-field (CASSCF) approach [3], which includes all possible determinants (with the proper symmetry) that can be formed by distributing a set of active electrons among a set of active orbitals. The detcasman module performs CASSCF optimization of molecular orbitals via a two-step procedure in which the CI wavefunction is computed using detci and the orbital rotation step is computed using detcas. The detcas program is fairly simple and uses an approximate orbital Hessian [4] and a Newton-Raphson update, accelerated by Pulay's DIIS procedure [5]. We have also implemented a prototype version of the RASSCF method [6], which is another kind of MCSCF which is typically less complete (and less expensive) than CASSCF. However, orbital convergence for RASSCF can be difficult in our current implementation.

Inactive orbitals in the MCSCF may be specified by the RESTRICTED_DOCC and RESTRICTED_UOCC keywords. These orbitals will remain doubly-occupied or doubly-unoccupied, respectively, in the MCSCF wavefunction. However, the form of these orbitals will be optimized in the MCSCF procedure. It is also possible to literally freeze inactive orbitals in their original (SCF) form using the FROZEN_DOCC and FROZEN_UOCC keywords. This is not normally what one wishes to do in an MCSCF computation (e.g., it complicates the computation of gradients), but it can make the computations faster and is helpful in some circumstances where unphysical mixing of inactive and active occupied orbitals might occur. Presently, it is not possible to mix the use of restricted and frozen orbitals in PSI3.

The ability to perform state-averaged [7,8] CASSCF or RASSCF computations has been added. This is accomplished using the average_states keyword.

See the casscf-sp and casscf-sa-sp examples in the tests directory and the example below.

Basic Keywords

WFN = string: This may be casscf or rasscf.
REFERENCE = string: Any of the references allowed by detci should work (i.e., not uhf), but there should be no reason not to use rhf.
DERTYPE = string: At present, only energies (none) are supported; future releases will implement gradients (first).
CONVERGENCE = integer: Convergence desired on the orbital gradient. Convergence is achieved when the RMS of the error in the orbital gradient is less than 10**(-n). The default is 4 for energy calculations and 7 for gradients. Note that this is a different convergence criterion than for the detci program itself. These can be differentiated, if changed by the user, by placing the CONVERGENCE keywords within separate sections of input, such as detcas: ( convergence = x ).
ENERGY_CONVERGENCE = integer: Convergence desired on the total MCSCF energy. The default is 7.
RESTRICTED_DOCC = (integer array): Should be in psi:() or default:() sections of input. The number of lowest energy doubly occupied orbitals in each irreducible representation from which there will be no excitations. These orbitals are optimized in the MCSCF. The Cotton ordering of the irredicible representations is used. The default is the zero vector.
RESTRICTED_UOCC = (integer array): Should be in psi:() or default:() sections of input. The number of highest energy unoccupied orbitals in each irreducible representation into which there will be no excitations. These orbitals are optimized in the MCSCF. The default is the zero vector.
FROZEN_DOCC = (integer array): Should be in psi:() or default:() sections of input. The number of lowest energy doubly occupied orbitals in each irreducible representation from which there will be no excitations. These orbitals are literally frozen and are not optimized in the MCSCF; usually one wishes to use RESTRICTED_DOCC instead. The current version of the program does not allow both RESTRICTED_DOCC and FROZEN_DOCC. Should be in psi:() or default:() sections of input. The Cotton ordering of the irredicible representations is used. The default is the zero vector.
FROZEN_UOCC = (integer array): Should be in psi:() or default:() sections of input. The number of highest energy unoccupied orbitals in each irreducible representation into which there will be no excitations. These orbitals are literally frozen and are not optimized in the MCSCF; usually one wishes to use RESTRICTED_UOCC instead. The current version of the program does not allow both RESTRICTED_UOCC and FROZEN_UOCC. Should be in psi:() or default:() sections of input. The default is the zero vector.
NCASITER = integer: Maximum number of iterations to optimize the orbitals. This option should be specified in the DEFAULT section of input, because it needs to be visible to the control program PSI. Defaults to 20.
AVERAGE_STATES = (integer array): This gives a list of what states to average for the orbital optimization. States are numbered starting from 1.
PRINT = integer: This option determines the verbosity of the output. A value of 1 or 2 specifies minimal printing, a value of 3 specifies verbose printing. Values of 4 or 5 are used for debugging. Do not use level 5 unless the test case is very small (e.g. STO HO CISD).

Examples

**Figure 1:** Example of a CASSCF single-point calculation for HO using a valence active space 3a 1b 2b.
$\begin{figure}\begin{verbatim}% 6-31G H2O Test CASSCF Energy Point psi: ( ... ...31G'' zmat = ( o h 1 1.00 h 1 1.00 2 103.1 ) )\end{verbatim} \end{figure}$

Geometry Optimization and Vibrational Frequency Analysis

PSI3 is capable of carrying out geometry optimizations (minimization only, at present) for a variety of molecular structures using either analytic and numerical energy gradients.

When analytic gradients are available (see Table 2), PSI3 will automatically generate and use redundant, simple internal coordinates for carrying out the optimization. These simple stretch, bend, torsion, and linear bend coordinates may be read from the intco.dat file or determined completely by distance criteria using the input geometry. By default, optimization is performed in redundant internal coordinates regardless of how the geometry was provided in the input. Alternatively, the user may specify zmat_simples=true, in which case the simple internal coordinates will be taken from the ZMAT given in the input file. Also, the user may specify optimization in delocalized internal coordinates with delocalize=true.

Geometrical constraints may be imposed by the addition of a section with nearly the same format as intco.dat. For example, to fix the distance between atoms 1 and 2, as well as the angle between atoms 2, 1 and 3 in an optimization, add the following to your input file. fixed_intco: ( stre = ( (1 2) ) bend = ( (2 1 3) ) ) The constrained simple internals must be ones present (either manually or automatically) among the simple internals in intco.dat. Alternatively, the z-matrix input format may be used to specify constrained optimizations. If zmat_simples=true, then variables in the z-matrix which end in a dollar sign will be taken as simple internals to be optimized, and all other variables will be taken as simple internals to keep frozen.

For methods for which only energies are available, PSI3 will use symmetry-adapted delocalized internal coordinates to generate geometrical displacements for computing finite-difference gradients. The simple coordinates can be linearly combined by hand or automatically. The goal is to form 3N-6(5) symmetry-adapted internal coordinates. The automated delocalized coordinates may work for low-symmetry molecules without linear angles, but has not been extensively tested. For both analytic- and finite-difference-gradient optimization methods, Hessian updates are performed using the BFGS method.

PSI3 is also capable of computing harmonic vibrational frequencies for a number of different methods using energy points or analytic energy first or second derivatives. (At present, only RHF-SCF analytic second derivatives are available.) If analytic energy second derivatives are not available, PSI3 will generate displaced geometries along symmetry adapted cartesian coordinates, compute the appropriate energies or first derivatives, and use finite-difference methods to compute the Hessian.

The following keywords are pertinent for geometry optimizations and vibrational frequency analyses:

JOBTYPE = string: This keyword (described earlier in this manual) must be set to OPT for geometry optimizations and FREQ for frequency analyses.
DERTYPE = string: This keyword (also described earlier) must be set to NONE is only energies are available for the chosen method and FIRST if analytic gradients are available.
BFGS_USE_LAST = integer: This keyword is used to specify the number of gradient step for the BFGS update of the Hessian. The default is six.

Evaluation of one-electron properties

PSI3 is capable of computing a number of one-electron properties Table 9 summarizes these capabilities. This section describes details of how to have PSI3 compute desired one-electron properties

Feature	On by default?	Notes
Electric dipole moment	Y
Electric quadrupole moment	N	Set `MPMAX` to 2 or 3.
Electric octupole moment	N	Set `MPMAX` to 3.
Electrostatic potential	Y	At the nuclei; on 2-D grid set `GRID=2`.
Electric field	Y	At the nuclei.
Electric field gradient	Y	At the nuclei.
Hyperfine coupling constant	N	Set `SPIN_PROP=true`.
Relativistic (MVD) corrections	N	Set `MPMAX` to 2.
Electron density	Y	At the nuclei; on 2-D grid set `GRID=2`;
		on 3-D grid set `GRID=6`.
Spin density	N	Set `SPIN_PROP=true`; at the nuclei;
		on 3-D grid set `GRID=6`.
Electron density gradient	N	on 2-D grid set `GRID=3`.
Spin density gradient	N	on 2-D grid set `GRID=3` and `SPIN_PROP=true`.
Electron density Laplacian	N	on 2-D grid set `GRID=4`.
Spin density Laplacian	N	on 2-D grid set `GRID=4` and `SPIN_PROP=true`.
Molecular Orbitals (MO)	N	on 3-D grid set `GRID=5`.
Natural Orbitals (NO)	N	Set `WRTNOS` to true; written to `file32`.
MO/NO spatial extents	N	Set `MPMAX` to 2 or 3;
		MOs are used if `WFN=SCF`, otherwise NOs.

Basic Keywords

To compute one-electron properties at a fixed geometry, the following keywords are common:

JOBTYPE = string

This keyword should be set to oeprop for PSI3 to compute electron properties. There is no default. For CI wavefunctions, limited properties such as dipole and transition moments may be evaluated directly in detci without having to specify JOBTYPE = oeprop.

WFN = string

Acceptable values are scf for HF, mp2 for MP2, detci for CI, detcas for CASSCF, and ccsd for CCSD. There is no default.

REFERENCE = string

Acceptable value are rhf and rohf. There is no default.

FREEZE_CORE = boolean

Specifies whether core orbitals (which are determined automatically) are to be excluded from the correlated calculations. Default is false.

PRINT = integer

The desired print level for detailed output. Defaults to 1.

MPMAX = integer

This integer specifies the highest-order electric multipole moment to be computed. Valid values are 1 (dipole), 2 (up to quadrupole), or 3 (up to octupole). Default is 1.

MP_REF = integer

This integer specifies the reference point for the evaluation of electric multipole moments. Valid values are 1 (center of mass), 2 (origin), 3 (center of electronic change) and 4 (center of the nuclear charge). For charge-neutral systems the choice of MP_REF is irrelevant. Default is 1.

GRID = integer

This integer specifies the type of one-electron property and the type of grid on which to evaluate it. The valid choices are

0 - compute nothing
1 - electrostatic potential on a 2-D grid
2 - electron density on a 2-D grid (spin density, if SPIN_PROP=true)
3 - projection of electron density gradient on a 2-D grid (spin density gradient, if SPIN_PROP=true)
4 - Laplacian of electron density on a 2-D grid (Laplacian of spin density, if SPIN_PROP=true)
5 - values of molecular orbitals on a 3-D grid
6 - electron density on a 3-D grid (spin density if SPIN_PROP=true)

Default is 0.

NIX = integer

The number of grid points along the x direction. This parameter has be greater than 1. Default is 20.

NIY = integer

The number of grid points along the y direction. This parameter has be greater than 1. Default is 20.

NIZ = integer

The number of grid points along the z direction (if a 3-D grid is chosen). This parameter has be greater than 1. Default is 20.

GRID_FORMAT = string

This keyword specifies in which format to produce grid data. The only valid choice for 2-D grids is plotmtv (format of plotting software program PlotMTV). For 3-D grids, valid choices are gausscube (Gaussian 94 cube format) and megapovplus (format of 3D rendering software MegaPOV+). The defaults are plotmtv and gausscube for 2-d and 3-d grids, respectively.

MO_TO_PLOT = vector

Specifies indices of the molecular orbitals to be computed on the 3-d grid. Indices can be specified as:

unsigned integer - index in Pitzer ordering (ordered accoring to irreps, not eigenvalues). Ranges from 1 to the number of MOs.
signed integer - index with respect to Fermi level. +1 means LUMO, +2 means second lowest virtual orbital, -1 means HOMO, etc.

All indices have to be either unsigned or signed, you can't mix and match, or you will get unpredictable results. Default is to compute HOMO and LUMO.

SPIN_PROP = boolean

Whether to compute spin-dependent properties. Default is false.

WRTNOS = boolean

If set to true, natural orbitals will be written to the checkpoint file. Default is false.

Evaluation of properties on rectalinear grids

PSI3 can evaluate a number of one-electron properties on rectalinear 2-D and 3-D grids. In most cases, 3-D grids are utilized. In such cases you only need to specify the appropriate value for GRID and PSI3 will automatically construct a rectalinear 3-D grid that covers the entire molecular system. However, there's no default way to construct a useful 2-D grid in general. Even in the 3-D case you may want to ``zoom in'' on a particular part of the molecule. Hence one needs to be able to specify general 2-D and 3-D grids. In the absence of graphical user interface, PSI3 has a very flexible system for specifying arbitrary rectalinear grids.

The following keywords may be used in construction of the grid:

GRID_ORIGIN = real_vector: A vector of 3 real numbers, this keyword specifies the origin of the grid coordinate system. A rectangular grid box which envelops the entire molecule will be computed automatically if GRID_ORIGIN is missing, however, there is no default for 2-D grids.
GRID_UNIT_X = real_vector: A vector of 3 real numbers, this keyword specifies the direction of the first (x) side of the grid. It doesn't have have to be of unit length. There is no default for 2-D grids.
GRID_UNIT_Y = real_vector: A vector of 3 real numbers, this keyword specifies the direction of the second (y) side. It doesn't have to be of unit length or even orthogonal to GRID_UNIT_X. There is no default for 2-D grids.
GRID_UNIT_XY0 = real_vector: A vector of 2 real numbers, this keyword specifies the coordinates of the lower left corner of a 2-D grid in the 2-D coordinate system defined by GRID_ORIGIN, GRID_UNIT_X, and GRID_UNIT_Y. This keyword is only used to specify a 2-D grid. There is no default.
GRID_UNIT_XY1 = real_vector: A vector of 2 real numbers, this keyword specifies the coordinates of the upper right corner of a 2-D grid in the 2-D coordinate system defined by GRID_ORIGIN, GRID_UNIT_X, and GRID_UNIT_Y. This keyword is only used to specify a 2-D grid. There is no default.
GRID_UNIT_XYZ0 = real_vector: A vector of 3 real numbers, this keyword specifies the coordinates of the far lower left corner of a 3-D grid in the 3-D coordinate system defined by GRID_ORIGIN, GRID_UNIT_X, and GRID_UNIT_Y. This keyword is only used to specify a 3-D grid. There is no default.
GRID_UNIT_XYZ1 = real_vector: A vector of 3 real numbers, this keyword specifies the coordinates of the near upper right corner of a 3-D grid in the 3-D coordinate system defined by GRID_ORIGIN, GRID_UNIT_X, and GRID_UNIT_Y. This keyword is only used to specify a 3-D grid. There is no default.

In addition, the following keywords are useful for evaluation of certain properties on 2-D grids:

GRID_ZMIN = real: This keyword specifies the lower limit on displayed z-values for contour plots of electron density and its Laplacian. Only useful when GRID=2 or GRID=4. Default is 0.0
GRID_ZMAX = real: This keyword specifies the upper limit on displayed z-values for contour plots of electron density and its Laplacian. Only useful when GRID=2 or GRID=4. Default is 3.0
EDGRAD_LOGSCALE = integer: This keyword controls the logarithmic scaling of the produced electron density gradient plot. Turns the scaling off if set to zero, otherwise the higher value - the stronger the gradient field will be scaled. Recommended value (default) is 5. This keyword is only useful when GRID=3.

Grid specification mini-tutorial

Let's look at how to set up input for spin density evaluation on a two-dimensional grid. The relevant input section of PSI3 might look like this:

  jobtype = oeprop

  grid = 2
  spin_prop = true
  grid_origin = (0.0 -5.0 -5.0)
  grid_unit_x = (0.0 1.0 0.0)
  grid_unit_y = (0.0 0.0 1.0)
  grid_xy0 = (0.0 0.0)
  grid_xy1 = (10.0 10.0)
  nix = 30
  niy = 30

grid specifies the type of a property and the type of a grid oeprop needs to compute. Since spin_prop is set and grid=2, the spin density will be evaluated on a grid.

Grid specification is a little bit tricky but very flexible. grid_origin specifies the origin of the rectangular coordinate system associated with the grid in the reference frame. grid_unit_x specifies a reference frame vector which designates the direction of the x-axis of the grid coordinate system. grid_unit_y is analogously a reference frame vector which, along with the grid_unit_x, completely specifies the grid coordinate system. grid_unit_x and grid_unit_y do not have to be normalized, neither they need to be orthogonal to either other - orthogonalization is done automatically to ensure that unit vectors of the grid coordinate system are normalized in the reference frame too. grid_xy0 is a vector in the grid coordinate system that specifies a vertex of the grid rectangle with the most negative coordinates. Similarly, grid_xy1 specifies a vertex of the the grid rectangle diagonally opposite to grid_xy0. Finally, nix and niy specify the number of intervals into which the and sides of the grid rectangle are subdivided. To summarize, the above input specifies a rectangular (in fact, square) 30 by 30 grid of dimensions 10.0 by 10.0 lying in the plane and centered at origin of molecular frame.

Running PSI3 on such input will create a file called sdens.dat (for file names refer to man page on oeprop), which can be fed directly to PlotMTV to plot the 2-D data.

Specification of a three-dimensional grid for plotting MOs (grid = 5) or densities (grid = 6) is just slightly more complicated. For example, let's look at producing data for plotting a HOMO and a LUMO. The indices of the MOs which needs to be plotted will be specified by keyword mo_to_plot. The reference frame is specified by keywords grid_origin, grid_unit_x and grid_origin_y (the third axis of the grid coordinate system is specified by by the vector product of grid_unit_x and grid_unit_y). Since in this case we are dealing with the three-dimensional grid coordinate system, one needs to specify two diagonally opposite vertices of the grid box via grid_xyz0 and grid_xyz1. The number of intervals along is specified via niz. The relevant section of input file may look like this:

  jobtype = oeprop

  grid = 5
  mo_to_plot = (-1 +1)
  grid_origin = (-5.0 -5.0 -5.0)
  grid_unit_x = (1.0 0.0 0.0)
  grid_unit_y = (0.0 1.0 0.0)
  grid_xyz0 = (0.0 0.0 0.0)
  grid_xyz1 = (10.0 10.0 10.0)
  nix = 30
  niy = 30
  niz = 30

Running PSI3 on input like this will produce a Gaussian Cube file called mo.cube, which can be used to render images of HOMO and LUMO using an external visualization software.

Plotting grid data

2-D grids should be plotted by an interactive visualization code PlotMTV. PlotMTV is a freeware code developed by Kenny Toh. It can be downloaded off many web sites in source or binary form.

3-D grids can be produced in two formats: megapovplus and gausscube (see GRID_FORMAT). First is used to render high-quality images with a program MegaPov (version 0.5). MegaPov is an unofficial patch for a ray-tracing code POV-Ray. Information on MegaPov can be found at http://nathan.kopp.com/patched.htm. Gaussian Cube files can be processed by a number of programs. We cannot recommend any particular program for that purpose here.

Visualizing Molecular Obitals with gOpenMol

The Gaussian Cube files generated by oeprop can be converted and viewed with gOpenMol. gOpenMol offers good looking plots in a graphical user interface. Information on downloading gOpenMol and samples of gOpenMol output may be found at http://www.csc.fi/gopenmol/.

Installation instructions are included with the gOpenMol download. Once installed, the first step to viewing molecular orbitals is to convert the mo.cube into a format that gOpenMol recognizes. Under the Run menu, select gCube2plt/g94cub2pl (cube) , this will bring up a window with the heading Run gCube2plt/g94cub2pl. In the input file name field, select the mo.cube file you want to convert. Likewise, in the output file name field type the name of the output file you want. Click the Apply button to perform the conversion. This procedure will create a .plt and a .crd file. Once converted, click Dismiss to close the window. The Gaussian Cube file is now converted and in a form that gOpenMol can recognize.

In order to view the molecular orbital, the first step is to import the coordinate file (.crd). This is done under the File menu $\rightarrow$ Import $\rightarrow$ Coords $\dots$ . Again, a window will pop up. In the Import file name field chose the .crd you just created from the conversion procedure. Click apply, then Dismiss to close the window. Now we have to import the .plt file to view the molecular orbital. Under the the Plot menu selct Contour $\dots$ , this will bring up a window. In the File name field, either type the full path of the file name or use browse to select the .plt file you just created in the conversion, then click Import. In the Define contour levels we have to define the contour cutoffs for the positive and negative parts of the wave function seperately. I recommend trying 0.1 in the first box and -0.1 in the second. Click Apply to view the molecular orbital. You can change the colors of the positive and negative sections independently by clicking on the Colour button next to the respective cutoffs. Also, in the Details $\dots$ section, you can fine tune the properties of the molecular orbital, such as, the opacity, solid vs. mesh, smoothness, and cullface state. You can play around with various settings to get the surface to look exactly how you want it to. There is more information in the Help $\rightarrow$ Tutorials menu on this subject as well as many other abilities of gOpenMol.

`PSI3` Driver

The PSI3 suite of programs is built around a modular design. Any module can be run independently or the driver module, psi3, can parse the input file, recognize the calculation desired, and run all the necessary modules in the correct order. psi3 reads the file psi.dat by default. psi.dat contains macros for several standard calculations, however, anything in psi.dat can be overriden by the user.

Environment Variables

PSIDATADIR: This flag is used to specify an alternate location for platform-independent read-only files such as psi.dat and pbasis.dat. By default, PSI3 will look for these files under $psipath/share.

Command-Line Options

-i or -f: This flag is used to specify the input file name, e.g. psi3 -i h2o.in where h2o.in is the name of the input file. By default, psi3 and the other PSI3 modules look for input.dat.
-o: This flag is used to specify the output file name, e.g. psi3 -o h2o.out where h2o.out is the name of the output file. By default, psi3 and the other PSI3 modules look for output.dat.
-p: This flag is used to specify the PSI3 file prefix, e.g. psi3 -p h2o.dzp where h2o.dzp is the prefix that will be used for all PSI3 files. By default, psi3 and the other PSI3 modules use psi for the file prefix. Hence, the checkpoint file is by default called psi.32.
-n: This flag tells psi3 not to run the input module. This flag is useful for scripting and debugging.
-c: This flag tells psi3 to check the input and print out the list of programs which would be executed to STDOUT. Equivalent to check = true in the input file.
-m: This flag tells psi3 not to run the cleanup module psiclean. Usually, psiclean is invoked by the $done macro in psi.dat. This flag is useful for scripting and debugging.

Input Format

The psi3 module searches through the default keyword path (first PSI then DEFAULT) for the following keywords:

JOBTYPE = string

This keyword specifies what kind of calculation to run.

WFN = string

This keyword specifies the type of wave function.

REFERENCE = string

This keyword specifies the spin-reference.

DERTYPE = string

This keyword specifies the order of the derivative to be used. The default is none.

OPT = boolean

Set equal to true if performing a geometry optimization. The default is false.

CHECK = boolean

If true, psi3 will parse your input file and print the sequence of programs to be executed to STDOUT. The default is false.

EXEC = string vector

The EXEC vector contains a list of commands to be executed by psi3. Explicit commands can be entered in double quotes, or preset variables can be entered using the convention $variable, e.g.

psi: (
  exec = ("ints")
)

psi: (
  ints = "ints"
  exec = ($ints)
)

Loop Control

Loop control is handled with the repeat and end commands. The syntax is:

repeat n [commands to be executed] end

where n is the number of times to repeat the loop. An inspection of the psi.dat file will show that this is how geometry optimizations and finite displacements are performed.

Introduction

Obtaining and Installing PSI3

A PSI3 Tutorial

PSI3 Input Files

Syntax

Geometry Specification

Molecular Symmetry

Specifying Scratch Disk Usage in PSI3

The .psirc File

Specifying Basis Sets

Custom Basis Sets

Hartree-Fock Self-Consistent-Field

Second-order Møller-Plesset Theory: MP2 and MP2-R12 methods

Coupled Cluster Methods

Configuration Interaction

Complete-Active-Space Self-Consistent-Field (CASSCF)

Geometry Optimization and Vibrational Frequency Analysis

Evaluation of one-electron properties

PSI3 Driver

Obtaining and Installing `PSI3`

A `PSI3` Tutorial

`PSI3` Input Files

Specifying Scratch Disk Usage in `PSI3`

The `.psirc` File

`PSI3` Driver