| MPQC(1) | General Commands Manual | MPQC(1) |
mpqc - The Massively Parallel Quantum Chemistry program (MPQC)
mpqc [options] [filename]
MPQC computes the properties of molecules, ab initio, on a wide variety of computer architectures.
It can compute closed shell and general restricted openshell HartreeFock energies and gradients, second order openshell perturbation theory (OPT2[2]) and Zaveraged perturbation theory (ZAPT2) energies, and second order closed shell MoellerPlesset perturbation theory energies and gradients. It also includes methods for optimizing molecules in either Cartesian or internal coordinates.
MPQC is designed using objectoriented programming techniques and implemented in the C++ programming language.
MPQC can be given options followed by an optional input file name. If the input file name is not given, it will default to 'mpqc.in'. The following command line options are recognized:
Some MPI environments do not pass the command line to slave programs, but supply it when MPI_Init is called. To make MPQC call MPI_Init on start-up, instead of when an MPIMessageGrp is created, name the executable mpqc-mpi.
MPQC looks at four environmental variables to set up communication and find library files. Machine specific libraries and utilities to run programs in parallel might look at other environment variables as well. The four that apply on all platforms are:
By default, MPQC tries to find library files first in the lib sub-directory of the installation directory and then the source code directory. If the library files cannot be found, MPQC must be notified of the new location with the environmental variable SCLIBDIR.
The other three keywords specify objects. This is done by giving a mini ParsedKeyVal input in a string. The object is anonymous, that is, no keyword is associated with it. Here is an example:
setenv MESSAGEGRP '<ShmMessageGrp>:(n = 4)'
By default, MPQC will run on only one CPU. To specify more, you can give a ShmMessageGrp object on the command line. The following would run mpqc in four processes:
mpqc -messagegrp '<ShmMessageGrp>:(n = 4)' input_file
Alternately, the ShmMessageGrp object can be given as an environmental variable:
setenv MESSAGEGRP '<ShmMessageGrp>:(n = 4)' mpqc input_file
If MPQC should unexpectedly die, shared memory segments and semaphores will be left on the machine. These should be promptly cleaned up or other jobs may be prevented from running successfully. To see if you have any of these resources allocated, use the ipcs command. The output will look something like:
IPC status from /dev/kmem as of Wed Mar 13 14:42:18 1996 T ID KEY MODE OWNER GROUP Message Queues: Shared Memory: m 288800 0x00000000 --rw------- cljanss user Semaphores: s 390 0x00000000 --ra------- cljanss user s 391 0x00000000 --ra------- cljanss user
To remove the IPC resources used by cljanss in the above example on IRIX, type:
ipcrm -m 288800 ipcrm -s 390 ipcrm -s 391
And on Linux, type:
ipcrm shm 288800 ipcrm sem 390 ipcrm sem 391
By default, MPQC will run with only one thread. To specify more, you can give a PthreadThreadGrp object on the command line. MPQC is not parallelized to as large an extent with threads as it is with the more conventional distributed memory model, so you might not get the best performance using this technique. On the other the memory overhead is lower and no interprocess communication is needed.
The following would run MPQC in four threads:
mpqc -threadgrp '<PthreadThreadGrp>:(num_threads = 4)' input_file
Alternately, the PthreadThreadGrp object can be given as an environmental variable:
setenv THREADGRP '<PthreadThreadGrp>:(n = 4)' mpqc input_file
A MPIMessageGrp object is used to run using MPI. The number of nodes used is determined by the MPI run-time and is not specified as input data to MPIMessageGrp.
mpqc -messagegrp '<MPIMessageGrp>:()' input_file
Alternately, the MPIMessageGrp object can be given as an environmental variable:
setenv MESSAGEGRP '<MPIMessageGrp>:()' mpqc input_file
Usually, a special command is needed to start MPI jobs; typically it is named mpirun.
MPQC supports two input formats. The primary input is an object oriented format which gives users access to all of MPQCs options. The second format allows access to a subset of MPQCs capabilities, but is more intuitive and easier to learn. New users are advised to start with the simplified format. MPQC can be used to convert the simplified format to the full object-oriented format with the -i option.
The simple input format consists of keywords followed by a ':' followed by a value. The keywords are case sensitive. The values might be modified by options found in parenthesis. For example, the following input performs an optimization of water using density functional theory with the B3LYP exchange-correlation functional:
% B3LYP optimization of water optimize: yes method: KS (xc = B3LYP) basis: 3-21G* molecule:
O 0.172 0.000 0.000
H 0.745 0.000 0.754
H 0.745 0.000 -0.754
Comments begin with a % and continue to the end of the line. Basis set names containing special characters, such as a space or parentheses, must be quoted inside a pair of double quotes. The accepted keywords are:
The following options are valid with the KS, RKS, and UKS methods:
MPQC is an object-oriented program that directly allows the user to specify objects that MPQC then manipulates to obtain energies, properties, etc. This makes the input very flexible, but very complex. However, most calculations should be quite similar to the one of the examples given later in this chapter. The best way to get started is to use one of the example input files and modify it to meet your needs.
MPQC starts off by creating a ParsedKeyVal object that parses the input file specified on the command line. The format of the input file is documented in . It is basically a free format input that associates keywords and logical groupings of keywords with values. The values can be scalars, arrays, or objects.
The keywords recognized by MPQC begin with the mpqc prefix. That is, they must be nested between an mpqc:( and a ). Alternately, each keyword can be individually prefixed by mpqc:. The primary keywords are given below. Some of the keywords specify objects, in which case the object will require more ParsedKeyVal input. These objects are created from the input by using their ParsedKeyVal constructors. These constructors are documented with the source code documentation for the class.
There are also some utility keywords that tell mpqc some technical details about how to do the calculation:
This example input does a Hartree-Fock calculation on water. Following is the entire input, followed by a breakdown with descriptions.
% This input does a Hartree-Fock calculation on water. molecule<Molecule>: (
symmetry = C2V
unit = angstrom
{ atoms geometry } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
} ) basis<GaussianBasisSet>: (
name = 'STO-3G'
molecule = $:molecule ) mpqc: (
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
) )
We start with a descriptive comment. Comments begin with a %. Everything from the % to the end of the line is ignored.
% This input does a Hartree-Fock calculation on water.
Now lets set up a Molecule object. The name of the object comes first, it is molecule. Then, in angle brackets, comes the type of the molecule, which is the class Molecule. The keyword and class name are followed by a : and then several pieces of input grouped between a pair of matching parentheses. These parentheses contain the information that will be given to Molecule KeyVal constructor.
molecule<Molecule>: (
The point group of the molecule is needed. This is done by assigning symmetry to a case insensitive Schoenflies symbol that is used to initialize a PointGroup object. An Abelian point group should be used.
symmetry = C2V
The default unit for the Cartesian coordinates is Bohr. You can specify other units by assigned unit to a string that will be used to initialize a Units object.
unit = angstrom
Finally, the atoms and coordinates are given. This can be given in the shorthand table syntax shown below. The headings of the table are the keywords between the first pair of brackets. These are followed by an = and another pair of brackets that contain the data. The first datum is assigned to the first element of the array that corresponds to the first heading, atom. The second datum is assigned to the first element of the array associated with the second heading, geometry, and so on. Here the second datum is actually a vector: the x, y and z coordinates of the first atom.
{ atoms geometry } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
} )
Next, a basis set object is given.
basis<GaussianBasisSet>: (
name = 'STO-3G'
molecule = $:molecule )
Now we will give the main body of input. All the subsequent keywords will be grouped in the mpqc section of the input (that is, each keyword will be prefixed with mpqc:).
mpqc: (
Next we give the mole keyword which provides a specialization of the MolecularEnergy class. In this case we will do a closed-shell Hartree-Fock calculation. That is done with an object of type CLHF. The keywords that CLHF accepts are given with the documentation for the CLHF class, usually in the description of the const RefKeyVal& constructor for the class. Also with the CLHF documentation is a list of parent classes. Each of the parent classes may also have input. This input is included with the rest of the input for the child class.
mole<CLHF>: (
The next line specifies the molecule to be used. There are two things to note, first that this is actually a reference to complete molecule specification elsewhere in the input file. The $ indicates that this is a reference and the keyword following the $ is the actual location of the molecule. The : in front of the keyword means that the keyword is not relative to the current location in the input, but rather relative to the root of the tree of keywords. Thus, this line grabs the molecule that was specified above. The molecule object could have been placed here, but frequently it is necessary that several objects refer to the exact same object and this can only be done using references.
The second point is that if you look at the documentation for CLHF, you will see that it doesn't read molecule keyword. However, if you follow its parent classes up to MolecularEnergy, you'll find that molecule is indeed read.
molecule = $:molecule
Just as we gave molecule, specify the basis set with the basis keyword as follows:
basis = $:basis
Now we close off the parentheses we opened above and we are finished.
) )
The easiest way to get started with mpqc is to start with one of sample inputs that most nearly matches your problem. All of the samples inputs shown here can be found in the directory src/bin/mpqc/samples.
The following input will compute the Hartree-Fock energy of water.
% emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = C2V
unit = angstrom
{ atoms geometry } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = 'STO-3G'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
% method for computing the molecule's energy
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
memory = 16000000
) )
The following input will compute the MP2 energy of water.
% emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = C2V
unit = angstrom
{ atoms geometry } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = 'STO-3G'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
% method for computing the molecule's energy
mole<MBPT2>: (
molecule = $:molecule
basis = $:basis
memory = 16000000
% reference wavefunction
reference<CLHF>: (
molecule = $:molecule
basis = $:basis
memory = 16000000
)
) )
The following input will optimize the geometry of water using the quasi-Newton method.
% emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = C2V
unit = angstrom
{ atoms geometry } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = '6-31G*'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
% molecular coordinates for optimization
coor<SymmMolecularCoor>: (
molecule = $:molecule
generator<IntCoorGen>: (
molecule = $:molecule
)
)
% method for computing the molecule's energy
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
coor = $..:coor
memory = 16000000
)
% optimizer object for the molecular geometry
opt<QNewtonOpt>: (
function = $..:mole
update<BFGSUpdate>: ()
convergence<MolEnergyConvergence>: (
cartesian = yes
energy = $..:..:mole
)
) )
The following input will optimize the geometry of water using the quasi-Newton method. The guess Hessian will be computed at a lower level of theory.
% emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = C2V
unit = angstrom
{ atoms geometry } = {
O [ 0.00000000 0.00000000 0.37000000 ]
H [ 0.78000000 0.00000000 -0.18000000 ]
H [ -0.78000000 0.00000000 -0.18000000 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = '6-31G*'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
% molecular coordinates for optimization
coor<SymmMolecularCoor>: (
molecule = $:molecule
generator<IntCoorGen>: (
molecule = $:molecule
)
)
% method for computing the molecule's energy
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
coor = $..:coor
memory = 16000000
guess_hessian<FinDispMolecularHessian>: (
molecule = $:molecule
only_totally_symmetric = yes
eliminate_cubic_terms = no
checkpoint = no
energy<CLHF>: (
molecule = $:molecule
memory = 16000000
basis<GaussianBasisSet>: (
name = '3-21G'
molecule = $:molecule
)
)
)
)
% optimizer object for the molecular geometry
opt<QNewtonOpt>: (
function = $..:mole
update<BFGSUpdate>: ()
convergence<MolEnergyConvergence>: (
cartesian = yes
energy = $..:..:mole
)
) )
The following input will optimize the geometry of water using the Newton's method. The Hessian will be computed at each step in the optimization. However, Hessian recomputation is usually not worth the cost; try using the computed Hessian as a guess Hessian for a quasi-Newton method before resorting to a Newton optimization.
% Emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = c2v
unit = angstrom
{ atoms geometry } = {
O [ 0.00000000 0.00000000 0.36937294 ]
H [ 0.78397590 0.00000000 -0.18468647 ]
H [ -0.78397590 0.00000000 -0.18468647 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = '3-21G'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
restart = no
% molecular coordinates for optimization
coor<SymmMolecularCoor>: (
molecule = $:molecule
generator<IntCoorGen>: (
molecule = $:molecule
)
)
do_energy = no
do_gradient = no
% method for computing the molecule's energy
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
memory = 16000000
coor = $..:coor
guess_wavefunction<CLHF>: (
molecule = $:molecule
total_charge = 0
basis<GaussianBasisSet>: (
molecule = $:molecule
name = 'STO-3G'
)
memory = 16000000
)
hessian<FinDispMolecularHessian>: (
only_totally_symmetric = yes
eliminate_cubic_terms = no
checkpoint = no
)
)
optimize = yes
% optimizer object for the molecular geometry
opt<NewtonOpt>: (
print_hessian = yes
max_iterations = 20
function = $..:mole
convergence<MolEnergyConvergence>: (
cartesian = yes
energy = $..:..:mole
)
) )
The following input will compute Hartree-Fock frequencies by finite displacements. A thermodynamic analysis will also be performed. If optimization input is also provided, then the optimization will be run first, then the frequencies.
% emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = C1
{ atoms geometry } = {
O [ 0.0000000000 0.0000000000 0.8072934188 ]
H [ 1.4325589285 0.0000000000 -0.3941980761 ]
H [ -1.4325589285 0.0000000000 -0.3941980761 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = 'STO-3G'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
% method for computing the molecule's energy
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
memory = 16000000
) % vibrational frequency input
freq<MolecularFrequencies>: (
molecule = $:molecule
) )
The following example shows several features that are really independent. The variable coordinates are explicitly given, rather than generated automatically. This is especially useful when a guess Hessian is to be provided, as it is here. This Hessian, as given by the user, is not complete and the QNewtonOpt object will fill in the missing values using a guess the Hessian provided by the MolecularEnergy object. Also, fixed coordinates are given in this sample input.
% emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = C1
{ atoms geometry } = {
H [ 0.088 2.006 1.438 ]
O [ 0.123 3.193 0.000 ]
H [ 0.088 2.006 -1.438 ]
O [ 4.502 5.955 -0.000 ]
H [ 2.917 4.963 -0.000 ]
H [ 3.812 7.691 -0.000 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = 'STO-3G'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
% method for computing the molecule's energy
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
coor = $..:coor
memory = 16000000
)
% molecular coordinates for optimization
coor<SymmMolecularCoor>: (
molecule = $:molecule
generator<IntCoorGen>: (
molecule = $:molecule
extra_bonds = [ 2 5 ]
)
% use these instead of generated coordinates
variable<SetIntCoor>: [
<StreSimpleCo>:( atoms = [ 2 5 ] )
<BendSimpleCo>:( atoms = [ 2 5 4 ] )
<OutSimpleCo>: ( atoms = [ 5 2 1 3 ] )
<SumIntCoor>: (
coor: [
<StreSimpleCo>:( atoms = [ 1 2 ] )
<StreSimpleCo>:( atoms = [ 2 3 ] )
]
coef = [ 1.0 1.0 ]
)
<SumIntCoor>: (
coor: [
<StreSimpleCo>:( atoms = [ 4 5 ] )
<StreSimpleCo>:( atoms = [ 4 6 ] )
]
coef = [ 1.0 1.0 ]
)
<BendSimpleCo>:( atoms = [ 1 2 3 ] )
<BendSimpleCo>:( atoms = [ 5 4 6 ] )
]
% these are fixed by symmetry anyway,
fixed<SetIntCoor>: [
<SumIntCoor>: (
coor: [
<StreSimpleCo>:( atoms = [ 1 2 ] )
<StreSimpleCo>:( atoms = [ 2 3 ] )
]
coef = [ 1.0 -1.0 ]
)
<SumIntCoor>: (
coor: [
<StreSimpleCo>:( atoms = [ 4 5 ] )
<StreSimpleCo>:( atoms = [ 4 6 ] )
]
coef = [ 1.0 -1.0 ]
)
<TorsSimpleCo>:( atoms = [ 2 5 4 6] )
<OutSimpleCo>:( atoms = [ 3 2 6 4 ] )
<OutSimpleCo>:( atoms = [ 1 2 6 4 ] )
]
)
% optimizer object for the molecular geometry
opt<QNewtonOpt>: (
function = $..:mole
update<BFGSUpdate>: ()
convergence<MolEnergyConvergence>: (
cartesian = yes
energy = $..:..:mole
)
% give a partial guess hessian in internal coordinates
% the missing elements will be filled in automatically
hessian = [
[ 0.0109261670 ]
[ -0.0004214845 0.0102746106 ]
[ -0.0008600592 0.0030051330 0.0043149957 ]
[ 0.0 0.0 0.0 ]
[ 0.0 0.0 0.0 ]
[ 0.0 0.0 0.0 ]
[ 0.0 0.0 0.0 ]
]
) )
The automatic internal coordinate generator will fail if it cannot find enough redundant internal coordinates. In this case, the internal coordinate generator must be explicitly created in the input and given extra connectivity information, as is shown below.
% emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = C1
{ atoms geometry } = {
H [ 0.088 2.006 1.438 ]
O [ 0.123 3.193 0.000 ]
H [ 0.088 2.006 -1.438 ]
O [ 4.502 5.955 -0.000 ]
H [ 2.917 4.963 -0.000 ]
H [ 3.812 7.691 -0.000 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = 'STO-3G'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
% method for computing the molecule's energy
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
coor = $..:coor
memory = 16000000
)
% molecular coordinates for optimization
coor<SymmMolecularCoor>: (
molecule = $:molecule
% give an internal coordinate generator that knows about the
% hydrogen bond between atoms 2 and 5
generator<IntCoorGen>: (
molecule = $:molecule
extra_bonds = [ 2 5 ]
)
)
% optimizer object for the molecular geometry
opt<QNewtonOpt>: (
function = $..:mole
update<BFGSUpdate>: ()
convergence<MolEnergyConvergence>: (
cartesian = yes
energy = $..:..:mole
)
) )
This example shows how to selectively fix internal coordinates in an optimization. Any number of linearly independent coordinates can be given. These coordinates must remain linearly independent throughout the optimization, a condition that might not hold since the coordinates can be nonlinear.
By default, the initial fixed coordinates' values are taken from the cartesian geometry given by the Molecule object; however, the molecule will be displaced to the internal coordinate values given with the fixed internal coordinates if have_fixed_values keyword is set to true, as shown in this example. In this case, the initial Cartesian geometry should be reasonably close to the desired initial geometry and all of the variable coordinates will be frozen to their original values during the initial displacement.
% emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = CS
{ atoms geometry } = {
H [ 3.04 -0.69 -1.59 ]
H [ 3.04 -0.69 1.59 ]
N [ 2.09 -0.48 -0.00 ]
C [ -0.58 -0.15 0.00 ]
H [ -1.17 1.82 0.00 ]
H [ -1.41 -1.04 -1.64 ]
H [ -1.41 -1.04 1.64 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = '4-31G*'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
% molecular coordinates for optimization
coor<SymmMolecularCoor>: (
molecule = $:molecule
generator<IntCoorGen>: (
molecule = $:molecule
)
have_fixed_values = yes
fixed<SetIntCoor>: [
<OutSimpleCo>: ( value = -0.1
label = 'N-inversion'
atoms = [4 3 2 1] )
]
)
% method for computing the molecule's energy
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
coor = $..:coor
memory = 16000000
)
% optimizer object for the molecular geometry
opt<QNewtonOpt>: (
max_iterations = 20
function = $..:mole
update<BFGSUpdate>: ()
convergence<MolEnergyConvergence>: (
cartesian = yes
energy = $..:..:mole
)
) )
This example shows a transition state optimization of the N-inversion in using mode following. The initial geometry was obtained by doing a few fixed coordinate optimizations along the inversion coordinate.
% emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = CS
{ atoms geometry } = {
H [ 3.045436 -0.697438 -1.596748 ]
H [ 3.045436 -0.697438 1.596748 ]
N [ 2.098157 -0.482779 -0.000000 ]
C [ -0.582616 -0.151798 0.000000 ]
H [ -1.171620 1.822306 0.000000 ]
H [ -1.417337 -1.042238 -1.647529 ]
H [ -1.417337 -1.042238 1.647529 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = '4-31G*'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
% molecular coordinates for optimization
coor<SymmMolecularCoor>: (
molecule = $:molecule
generator<IntCoorGen>: (
molecule = $:molecule
)
followed<OutSimpleCo> = [ 'N-inversion' 4 3 2 1 ]
)
% method for computing the molecule's energy
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
coor = $..:coor
memory = 16000000
)
% optimizer object for the molecular geometry
opt<EFCOpt>: (
transition_state = yes
mode_following = yes
max_iterations = 20
function = $..:mole
update<PowellUpdate>: ()
convergence<MolEnergyConvergence>: (
cartesian = yes
energy = $..:..:mole
)
) )
This example shows a transition state optimization of the N-inversion in using mode following. The initial geometry was obtained by doing a few fixed coordinate optimizations along the inversion coordinate. An approximate guess Hessian will be computed, which makes the optimization converge much faster in this case.
% emacs should use -*- KeyVal -*- mode % molecule specification molecule<Molecule>: (
symmetry = CS
{ atoms geometry } = {
H [ 3.045436 -0.697438 -1.596748 ]
H [ 3.045436 -0.697438 1.596748 ]
N [ 2.098157 -0.482779 -0.000000 ]
C [ -0.582616 -0.151798 0.000000 ]
H [ -1.171620 1.822306 0.000000 ]
H [ -1.417337 -1.042238 -1.647529 ]
H [ -1.417337 -1.042238 1.647529 ]
} ) % basis set specification basis<GaussianBasisSet>: (
name = '4-31G*'
molecule = $:molecule ) mpqc: (
checkpoint = no
savestate = no
% molecular coordinates for optimization
coor<SymmMolecularCoor>: (
molecule = $:molecule
generator<IntCoorGen>: (
molecule = $:molecule
)
followed<OutSimpleCo> = [ 'N-inversion' 4 3 2 1 ]
)
% method for computing the molecule's energy
mole<CLHF>: (
molecule = $:molecule
basis = $:basis
coor = $..:coor
memory = 16000000
guess_hessian<FinDispMolecularHessian>: (
molecule = $:molecule
only_totally_symmetric = yes
eliminate_cubic_terms = no
checkpoint = no
energy<CLHF>: (
molecule = $:molecule
memory = 16000000
basis<GaussianBasisSet>: (
name = '3-21G'
molecule = $:molecule
)
)
)
)
% optimizer object for the molecular geometry
opt<EFCOpt>: (
transition_state = yes
mode_following = yes
max_iterations = 20
function = $..:mole
update<PowellUpdate>: ()
convergence<MolEnergyConvergence>: (
cartesian = yes
energy = $..:..:mole
)
) )
| 15 Feb 2008 | Version 2 |