1mpqc(1) MPQC mpqc(1)
2
6 mpqc - The Massively Parallel Quantum Chemistry program (MPQC) computes
7 the properties of molecules from first principles.
8 This documentation is divided into the following chapters:
10 o MPQC Overview
12 o Running MPQC
13 o MPQC Input
14 o Validating MPQC
15 o Running Psi 3 from MPQC
16 o CCA Components
17 o MPQC License
18 o MPQC Warranty
20 The Massively Parallel Quantum Chemistry program (MPQC) computes the
21 properties of molecules, ab initio, on a wide variety of computer
22 architectures.
23 MPQC can compute closed shell and general restricted open-shell
24 Hartree-Fock energies and gradients, second order open-shell
25 perturbation theory (OPT2[2]) and Z-averaged perturbation theory
26 (ZAPT2) energies, and second order closed shell Moeller-Plesset
27 perturbation theory energies and gradients. It also includes methods
28 for optimizing molecules in either Cartesian or internal coordinates.
29 MPQC is designed using object-oriented programming techniques and
30 implemented in the C++ programming language.
32 This chapter explains how to run MPQC in a variety of environments.
33 The first two sections give general information on running MPQC:
34 o Command Line Options
35 o Environmental Variables
36 The final sections given specific information on running MPQC in
37 different environments:
38 o Shared Memory Multiprocessor with SysV IPC
39 o Shared Memory Multiprocessor with POSIX Threads
40 o Shared or Distributed Memory Multiprocessor with MPI
41 o Special Notes for MP2 Gradients
42 o Special Notes for MP2-R12 energies
43 o Special Notes for CCA Components
44 Command Line Options
45 MPQC can be given options followed by an optional input file name. If
46 the input file name is not given, it will default to 'mpqc.in'. The
47 following command line options are recognized:
48 -o Gives the name of the output file. The default is the console.
49 -i Convert a simple input file to an object oriented input file and
50 write the result to the ouput. No calculations are done.
51 -messagegrp
52 A ParsedKeyVal specification of a MessageGrp object. The default
53 depends on how MPQC was compiled.
54 -memorygrp
55 A ParsedKeyVal specification of a MemoryGrp object. The default
56 depends on how MPQC was compiled.
57 -threadgrp
58 A ParsedKeyVal specification of a ThreadGrp object. The default
59 depends on how MPQC was compiled.
60 -integral
61 A ParsedKeyVal specification of an Integral object. The default is
62 IntegralV3. Note that some MolecularEnergy specializations require
63 specific choices of Integral specializations and may not work with
64 IntegralV3.
65 -l Sets a limit on the number of basis functions. The default is zero,
66 which means an unlimited number of basis functions.
67 -W Sets the working directory. The default is the current directory.
68 -c Check the input and exit.
69 -v Print the version number.
70 -w Print the warranty information (there is no warranty).
71 -d If a debugger object was given in the input, start the debugger
72 running as soon as MPQC is started.
73 -h Print a list of options.
74 -f The name of an object-oriented input file. The default is mpqc.in.
75 This cannot be used if another input file is specified. This option
76 is deprecated, as both input file formats can be read by given the
77 input file name on the command line without any option flags.
78 -cca-path
79 A colon-separated list of directories in which CCA component
80 libraries may be found.
81 -cca-load
82 A colon-separated list of sidl class names for CCA components which
83 will be instantiated from the libraries found in the path given by
84 -cca-path
85 Some MPI environments do not pass the command line to slave programs,
86 but supply it when MPI_Init is called. To make MPQC call MPI_Init with
87 the correct arguments as early as possible use the configure option
88 --enable-always-use-mpi.
89 Environmental Variables
90 MPQC looks at five environmental variables to set up communication,
91 find library files, and specify the default Integral object. Machine
92 specific libraries and utilities to run programs in parallel might look
93 at other environment variables as well. The five that apply on all
94 platforms are:
95 SCLIBDIR
96 The name of the library directory. See the GaussianBasisSet
97 documentation and look below for more information.
98 MESSAGEGRP
99 A ParsedKeyVal specification of a MessageGrp object. The default
100 depends on how MPQC was compiled. See the MessageGrp class
101 documentation for more information.
102 MEMORYGRP
103 A ParsedKeyVal specification of a MemoryGrp object. The default
104 depends on how MPQC was compiled and the MessageGrp in use.
105 THREADGRP
106 A ParsedKeyVal specification of a ThreadGrp object. The default
107 depends on how MPQC was compiled.
108 INTEGRAL
109 A ParsedKeyVal specification of an Integral object. The default is
110 IntegralV3. Note that some MolecularEnergy specializations require
111 specific choices of Integral specializations and may not work with
112 IntegralV3.
113 By default, MPQC tries to find library files first in the lib
114 subdirectory of the installation directory and then the source code
115 directory. If the library files cannot be found, MPQC must be notified
116 of the new location with the environmental variable SCLIBDIR.
117 For example, if you need to run MPQC on a machine that doesn't have the
118 source code distribution in the same place as it was located on the
119 machine on which MPQC is compiled you must do something like the
120 following on the machine with the source code:
121 cd mpqc/lib
122 tar cvf ../sclib.tar basis atominfo.kv
123 Then transfer sclib.tar to the machine on which you want to run MPQC
124 and do something like
125 mkdir ~/sclib
126 cd ~/sclib
127 tar xvf ../sclib.tar
128 setenv SCLIBDIR ~/sclib
129 The setenv command is specific to the C-shell. You will need to do what
130 is appropriate for your shell.
131 The other three keywords specify objects. This is done by giving a mini
132 ParsedKeyVal input in a string. The object is anonymous, that is, no
133 keyword is associated with it. Here is an example:
134 setenv MESSAGEGRP '<ShmMessageGrp>:(n = 4)'
135 Shared Memory Multiprocessor with SysV IPC
136 By default, MPQC will run on only one CPU. To specify more, you can
137 give a ShmMessageGrp object on the command line. The following would
138 run MPQC in four processes:
139 mpqc -messagegrp '<ShmMessageGrp>:(n = 4)' input_file
140 Alternately, the ShmMessageGrp object can be given as an environmental
141 variable:
142 setenv MESSAGEGRP '<ShmMessageGrp>:(n = 4)'
143 mpqc input_file
144 If MPQC should unexpectedly die, shared memory segments and semaphores
145 will be left on the machine. These should be promptly cleaned up or
146 other jobs may be prevented from running successfully. To see if you
147 have any of these resources allocated, use the ipcs command. The output
148 will look something like:
149 IPC status from /dev/kmem as of Wed Mar 13 14:42:18 1996
150 T ID KEY MODE OWNER GROUP
151 Message Queues:
152 Shared Memory:
153 m 288800 0x00000000 --rw------- cljanss user
154 Semaphores:
155 s 390 0x00000000 --ra------- cljanss user
156 s 391 0x00000000 --ra------- cljanss user
157 To remove the IPC resources used by cljanss in the above example on
158 IRIX, type:
159 ipcrm -m 288800
160 ipcrm -s 390
161 ipcrm -s 391
162 And on Linux, type:
163 ipcrm shm 288800
164 ipcrm sem 390
165 ipcrm sem 391
166 Shared Memory Multiprocessor with POSIX Threads
167 By default, MPQC will run with only one thread. To specify more, you
168 can give a PthreadThreadGrp object on the command line. MPQC is not
169 parallelized to as large an extent with threads as it is with the more
170 conventional distributed memory model, so you might not get the best
171 performance using this technique. On the other the memory overhead is
172 lower and no interprocess communication is needed.
173 The following would run MPQC in four threads:
174 mpqc -threadgrp '<PthreadThreadGrp>:(num_threads = 4)' input_file
175 Alternately, the PthreadThreadGrp object can be given as an
176 environmental variable:
177 setenv THREADGRP '<PthreadThreadGrp>:(num_threads = 4)'
178 mpqc input_file
179 Shared or Distributed Memory Multiprocessor with MPI
180 A MPIMessageGrp object is used to run using MPI. The number of nodes
181 used is determined by the MPI run-time and is not specified as input
182 data to MPIMessageGrp.
183 mpqc -messagegrp '<MPIMessageGrp>:()' input_file
184 Alternately, the MPIMessageGrp object can be given as an environmental
185 variable:
186 setenv MESSAGEGRP '<MPIMessageGrp>:()'
187 mpqc input_file
188 Usually, a special command is needed to start MPI jobs; typically it is
189 named mpirun.
190 Special Notes for MP2 Gradients
191 The MP2 gradient algorithm uses MemoryGrp object to access distributed
192 shared memory. The MTMPIMemoryGrp class is the most efficient and
193 reliable implementation of MemoryGrp. It requires a multi-thread aware
194 MPI implementation, which is still not common. To run MP2 gradients on
195 a machine with POSIX threads and an multi-thread aware MPI, use:
196 mpqc -messagegrp '<MPIMessageGrp>:()' \
197 -threadgrp '<PthreadThreadGrp>:()' \
198 -memorygrp '<MTMPIMemoryGrp>:()' \
199 input_file
200 or
201 setenv MESSAGEGRP '<MPIMessageGrp>:()'
202 setenv THREADGRP '<PthreadThreadGrp>:()'
203 setenv MEMORYGRP '<MTMPIMemoryGrp>:()'
204 mpqc input_file
205 Special Notes for MP2-R12 energies
206 Distributed Memory
207 The MP2-R12 energy algorithm is similar to the MP2 energy algorithm
208 that uses MemoryGrp object to access distributed memory. Hence the
209 MTMPIMemoryGrp is the recommended implementation of MemoryGrp for such
210 computations (see Special Notes for MP2 Gradients).
211 Disk I/O
212 In contrast to the MP2 energy and gradient algorithms, the MP2-R12
213 energy algorithm may have to use disk to store transformed MO integrals
214 if a single pass through the AO integrals is not possible due to
215 insufficient memory. The best option in such case is to increase the
216 total amount of memory available to the computation by either
217 increasing the number of tasks or the amount of memory per task or
218 both.
219 When increasing memory further is not possible, the user has to specify
220 which type of disk I/O should be used for the MP2-R12 energy algorithm.
221 It is done through the r12ints keyword in input for the MBPT2_R12
222 object. The default choice is to use POSIX I/O on the node on which
223 task 0 resides. This kind of disk I/O is guaranteed to work on all
224 parallel machines, provided there's enough disk space on the node.
225 However, this is hardly most efficient on machines with some sort of
226 parallel I/O available. On machines which have an efficient
227 implementation of MPI-IO the r12ints should be set instead to mpi-mem.
228 This will force the MBPT2_R12 object to use MPI-IO for disk I/O. It is
229 user's responsibility to make sure that the MO integrals file resides
230 on an MPI-IO-compatible file system. Hence the r12ints_file keyword,
231 which specifies the name of the MO integrals file, should be set to a
232 location which is guaranteed to work properly with MPI-IO. For example,
233 on IBM SP and other IBM machines which have General Parallel File
234 System (GPFS), the user should set r12ints = mpi-mem and r12ints_file
235 to a file on a GPFS file system.
236 Integral object
237 At the moment, MBPT2_R12 objects require specific specialization of
238 Integral, IntegralCints. Thus in order to compute MP2-R12 energies,
239 your version of MPQC needs to be compiled with support for
240 IntegralCints. A free, open-source library called libint is a
241 prerequisite for IntegralCints. In order to use IntegralCints as the
242 default Integral object, add -integral '<IntegralCints>:()' to the
243 command line, or set environmental variable INTEGRAL to
244 '<IntegralCints>:()'.
245 Special Notes for CCA Components
246 Common Component Architecture (CCA)
247 Portions of MPQC functionality are being packaged into CCA components.
248 For general overviews of CCA technology and framework usage, please see
249 www.cca-forum.org (the tutorial in particular) and the cca-chem-apps
250 documentation. MPQC components may be utilized directly within the
251 ccaffeine framework, while some components may be instantiated and used
252 within MPQC itself, making use of an embedded CCA framework.
253 CCA Runtime Environment
254 For MPQC runs utilizing embedded components, the runtime environment
255 for the CCA framework must be specified. The colon-separated path used
256 to locate component libraries must be specified either using the -cca-
257 path command-line option or using the cca_path key within the mpqc
258 section of a keyval input. The colon-separated list of component sidl
259 class names which will be referenced within the input must be specified
260 using either the -cca-load command-line option or using the cca_load
261 key within the mpqc section of a keyval input. If defaults for the cca-
262 path and cca-load options are desired, do_cca must be set to yes in the
263 keyval input.
265 MPQC supports two input formats. The primary input is an object
266 oriented format which gives users access to all of MPQC's options. The
267 second format allows access to a subset of MPQC's capabilities, but is
268 more intuitive and easier to learn. New users are advised to start with
269 the simplified format. MPQC can be used to convert the simplified
270 format to the full object-oriented format with the -i option.
271 Each of these input formats is described in the following two chapters:
272 o Simple Input
273 o Object-Oriented Input
275 The simple input format consists of keywords followed by a ':' followed
276 by a value. The keywords are case sensitive. The values might be
277 modified by options found in parenthesis. For example, the following
278 input performs an optimization of water using density functional theory
279 with the B3LYP exchange-correlation functional:
280 % B3LYP optimization of water
281 optimize: yes
282 method: KS (xc = B3LYP)
283 basis: 3-21G*
284 molecule: (angstrom)
285 O 0.172 0.000 0.000
286 H 0.745 0.000 0.754
287 H 0.745 0.000 -0.754
288 Comments begin with a % and continue to the end of the line. Basis set
289 names containing special characters, such as a space or parentheses,
290 must be quoted inside a pair of double quotes. The accepted keywords
291 are:
292 molecule
293 Gives the atoms types and coordinates. The following options can be
294 used
295 bohr
296 The coordinates are given in Bohr.
297 angstrom
298 The coordinates are given in Angstroms (the default).
299 charge
300 This option can be given after an 'element x y z' quadruple. This
301 will override the charge on the atom. For example, (charge = 0) can
302 be given for the ghost atoms in a counterpoise correction
303 calculation.
304 multiplicity
305 Gives the multiplicity of the molecule. The default is 1.
306 optimize
307 If yes, then an optimization will be performed. The default is no.
308 The following options can be given.
309 cartesian
310 Use Cartesian coordinates.
311 internal
312 Use internal coordinates.
313 redundant
314 Use redundant internal coordinates.
315 gradient
316 If yes, then a gradient calculation will be performed. The default
317 is no.
318 frequencies
319 If yes, then the frequencies will be obtained. The default is no.
320 charge
321 Specificies the charge on the molecule. The default is 0.
322 method
323 Specifices the method. There is no default and the possible values
324 are:
325 HF Hartree-Fock. Unrestricted HF is used if multiplicity > 1
326 RHF
327 Restricted Hartree-Fock.
328 UHF
329 Unrestricted Hartree-Fock.
330 KS Kohn-Sham. Unrestricted KS is used if multiplicity > 1
331 RKS
332 Restricted Kohn-Sham.
333 UKS
334 Unrestricted Kohn-Sham.
335 MP2
336 Second order Moeller-Plesset perturbation theory. Only available
337 for multiplicity = 1.
338 MP2-R12/A
339 The A version of MP2-R12. Only available for multiplicity = 1. An
340 auxiliary basis may be specified. No gradient, optimization, or
341 frequencies are possible.
342 MP2-R12/A'
343 The A' version of MP2-R12. Only available for multiplicity = 1. An
344 auxiliary basis may be specified. No gradient, optimization, or
345 frequencies are possible.
346 ZAPT2
347 Z-averaged perturbation theory. Only available for multiplicity >
348 1. No gradient, optimization, or frequencies are possible.
349 The following options are valid with the KS, RKS, and UKS methods:
350 grid
351 Specifies the grid to be used for numerical integrations. The
352 following values can be given:
353 xcoarse
354 coarse
355 medium
356 fine
357 xfine
358 ultrafine
359 xc Specifies the exchange-correlation functional. There is no default.
360 See the table in the StdDenFunctional class documentation for the
361 possible values.
362 The following options are valid with the MP2-R12/A and MP2-R12/A'
363 methods. These options are mutually exclusive:
364 abs
365 Use the standard Auxiliary Basis Set method.
366 abs+
367 Use the standard Auxiliary Basis Set method, but use the union of
368 the orbital and the given auxiliary basis as the actual auxiliary
369 basis set used.
370 cabs
371 Use the Complementary Auxiliary Basis Set method.
372 cabs+
373 Use the Complementary Auxiliary Basis Set method, but use the union
374 of the orbital and the given auxiliary basis as the actual
375 auxiliary basis set used.
376 The following options are valid with the MP2-R12/A' method:
377 ebc
378 Assume the Extended Brillion Condition to hold. This is the
379 default.
380 gbc
381 Assume the Generalized Brillion Condition to hold. This is the
382 default.
383 !ebc
384 Do not assume the Extended Brillion Condition to hold.
385 !gbc
386 Do not assume the Generalized Brillion Condition to hold.
387 basis
388 Specifies the basis set. There is no default. See the table in the
389 GaussianBasisSet class documentation for the available basis sets.
390 auxbasis
391 Specifies the auxiliary basis set for MP2-R12 methods. There is no
392 default. See the table in the GaussianBasisSet class documentation
393 for the available basis sets.
394 restart
395 Set to yes to restart an optimization. The default is no.
396 checkpoint
397 Set to no to not save checkpoint files during an optimization. The
398 default is yes.
399 symmetry
400 Specifices the Schoenflies symbol of the point group of the
401 molecule. The default is auto, which will cause to program to find
402 the highest order Abelian subgroup of the molecule.
403 docc
404 Gives the number of doubly occupied orbitals in each each
405 irreducible representation in a parenthesized list. The symmetry
406 must be specified and not be auto. The method must be restricted.
407 socc
408 Gives the number of single occupied orbitals in each each
409 irreducible representation in a parenthesized list. The symmetry
410 must be specified and not be auto. The method must be restricted.
411 alpha
412 Gives the number of alpha occupied orbitals in each each
413 irreducible representation in a parenthesized list. The symmetry
414 must be specified and not be auto. The method must be unrestricted.
415 beta
416 Gives the number of beta occupied orbitals in each each irreducible
417 representation in a parenthesized list. The symmetry must be
418 specified and not be auto. The method must be unrestricted.
419 frozen_docc
420 Gives the number of frozen core orbitals. Can be either a single
421 integer or a parenthesized list giving the frozen core orbitals in
422 each irreducible representation. In the latter case the symmetry
423 must be given and not be auto.
424 frozen_uocc
425 Gives the number of frozen virtual orbitals. Can be either a single
426 integer or a parenthesized list giving the frozen virtual orbitals
427 in each irreducible representation. In the latter case the symmetry
428 must be given and not be auto.
429 memory
430 Gives a hint for the amount of memory in bytes that can be used.
431 This is typically a lower bound, more memory will be used in
432 practice and the exact amount cannot be precisely controlled. The
433 format is a fixed or floating point number optionally followed
434 (without spaces) by one of the following suffixes: KB, MB, GB, KIB,
435 MIB, or GIB.
437 MPQC is an object-oriented program that directly allows the user to
438 specify objects that MPQC then manipulates to obtain energies,
439 properties, etc. This makes the input very flexible, but very complex.
440 However, most calculations should be quite similar to the one of the
441 examples given later in this chapter. The best way to get started is to
442 use one of the example input files and modify it to meet your needs.
443 The object-oriented input format is described in the following
444 sections:
445 o Overview of the Object-Oriented Input
446 o A Walk-Through of an Object-Oriented Input File
447 o Sample Object-Oriented Input Files
448 Overview of the Object-Oriented Input
449 MPQC starts off by creating a ParsedKeyVal object that parses the input
450 file specified on the command line. The format of the input file is
451 documented in the KeyVal documentation. It is basically a free format
452 input that associates keywords and logical groupings of keywords with
453 values. The values can be scalars, arrays, or objects.
454 The keywords recognized by MPQC begin with the mpqc prefix. That is,
455 they must be nested between an mpqc:( and a ). Alternately, each
456 keyword can be individually prefixed by mpqc:. The primary keywords are
457 given below. Some of the keywords specify objects, in which case the
458 object will require more ParsedKeyVal input. These objects are created
459 from the input by using their ParsedKeyVal constructors. These
460 constructors are documented with the source code documentation for the
461 class.
462 mole
463 This is the most important keyword for MPQC. It specifies the
464 MolecularEnergy object. This is an object that knows how to compute
465 the energy of a molecule. The specializations of MolecularEnergy
466 that are most commonly used are CLKS, HSOSKS, UKS, CLHF, HSOSHF,
467 UHF, and MBPT2.
468 opt
469 This keyword must be specified for optimizations. It specifies an
470 Optimize object. Usually, QNewtonOpt is best for finding minima and
471 EFCOpt is best for transition states.
472 freq
473 This keyword must be specified to compute frequencies. It specifies
474 a MolecularFrequencies object.
475 thread
476 This specifies an object of type ThreadGrp that can be used to
477 advantage on shared-memory multiprocessor machines for certain
478 types of calculations. This keyword can be overridden by giving the
479 ThreadGrp in the environment or command line. See the section on
480 running MPQC for more information.
481 integrals
482 This specifies an object of type Integral that will be used as the
483 default integral evaluator. If MP2-R12 is used, then this should be
484 set to use IntegralCints with a line like integrals<IntegralCints>:
485 ().
486 checkpoint
487 The value of this keyword is boolean.
488 o true and optimization is to be performed
489 opt object will be checkpointed after each iteration. The checkpoint
490 file suffix is '.ckpt'.
491 o true and optimization is not performed
492 mole object will be checkpointed at intermediate points. The manner in
493 which mole will be checkpointed depends on its particular type. The
494 checkpoint file suffix is usually '.wfn', however in general it will
495 depend on the particular specialization of MolecularEnergy.
496 The default is to not checkpoint.
497 checkpoint_freq
498 This specifies how often to checkpoint certain MolecularEnergy
499 specializations which compute iteratively. Currently, mole objects
500 of SCF type can use this keyword. The default is 1, which means to
501 checkpoint after every iteration.
502 savestate
503 The value of this keyword is boolean. If true, then the states of
504 the Optimize and MolecularEnergy objects will be saved after the
505 calculation completes. The output file suffixes are '.ckpt' and
506 '.wfn', respectively. The default is to save state.
507 restart
508 The value of this keyword is boolean. If true, mpqc will attempt to
509 restart the calculation. If the checkpoint file is not found, the
510 calculation will continue as if the value were false. The default
511 is true.
512 restart_file
513 This gives the name of a file from which restart information is
514 read. If the file name ends with '.wfn' then MPQC will try to
515 restore a MolecularEnergy object from it and query for the opt
516 object in the input file. If the file name ends with '.ckpt' MPQC
517 will try to restore an Optimize object from this file. The default
518 file name is formed by appending '.ckpt' to the input file name
519 with the extension removed.
520 do_energy
521 The value of this keyword is boolean. If true a single point energy
522 calculation will be done for the MolecularEnergy object given with
523 the mole keyword. The default is true.
524 do_gradient
525 The value of this keyword is boolean. If true a single point
526 gradient calculation will be done for the MolecularEnergy object
527 given with the mole keyword. The default is false.
528 do_cca
529 The value of this keywork is boolean. If true the cca embedded
530 framework will be initialized. The default is false.
531 cca_path
532 The value of this keyword is a string that provides a colon-
533 separated list of directories in which CCA component libraries may
534 be found.
535 cca_load
536 The value of this keyword is a string that provides a colon-
537 separated list of sidl class names for CCA components which will be
538 instantiated from the libraries found in the path given by
539 cca_path.
540 optimize
541 The value of this keyword is boolean. If true and the opt keyword
542 was set to a valid value, then an optimization will be performed.
543 The default is true.
544 write_pdb
545 The value of this keyword is boolean. If true a PDB file with the
546 molecular coordinates will be written.
547 filename
548 The value of this keyword is a string that gives a name from which
549 checkpoint and other filenames are constructed. The default is the
550 basename of the input file.
551 print_timings
552 If this is true, timing information is printed at the end of the
553 run. The default is true.
554 There are also some utility keywords that tell mpqc some technical
555 details about how to do the calculation:
556 debug
557 This optional keyword gives a Debugger object which can be used to
558 help find the problem if MPQC encounters a catastrophic error.
559 matrixkit
560 This optional keyword gives a SCMatrixKit specialization which is
561 used to produce matrices of the desired type. The default is a
562 ReplSCMatrixKit which replicates matrices on all of the nodes.
563 Other choices are not thoroughly tested.
564 A Walk-Through of an Object-Oriented Input File
565 This example input does a Hartree-Fock calculation on water. Following
566 is the entire input, followed by a breakdown with descriptions.
567 % This input does a Hartree-Fock calculation on water.
568 molecule<Molecule>: (
569 symmetry = C2V
570 unit = angstrom
571 { atoms geometry } = {
572 O [ 0.00000000 0.00000000 0.37000000 ]
573 H [ 0.78000000 0.00000000 -0.18000000 ]
574 H [ -0.78000000 0.00000000 -0.18000000 ]
575 }
576 )
577 basis<GaussianBasisSet>: (
578 name = 'STO-3G'
579 molecule = $:molecule
580 )
581 mpqc: (
582 mole<CLHF>: (
583 molecule = $:molecule
584 basis = $:basis
585 )
586 )
587 We start with a descriptive comment. Comments begin with a %.
588 Everything from the % to the end of the line is ignored.
589 % This input does a Hartree-Fock calculation on water.
590 Now lets set up a Molecule object. The name of the object comes first,
591 it is molecule. Then, in angle brackets, comes the type of the
592 molecule, which is the class Molecule. The keyword and class name are
593 followed by a : and then several pieces of input grouped between a pair
594 of matching parentheses. These parentheses contain the information that
595 will be given to Molecule KeyVal constructor.
596 molecule<Molecule>: (
597 The point group of the molecule is needed. This is done by assigning
598 symmetry to a case insensitive Schoenflies symbol that is used to
599 initialize a PointGroup object. An Abelian point group should be used.
600 symmetry = C2V
601 The default unit for the Cartesian coordinates is Bohr. You can specify
602 other units by assigned unit to a string that will be used to
603 initialize a Units object.
604 unit = angstrom
605 Finally, the atoms and coordinates are given. This can be given in the
606 shorthand table syntax shown below. The headings of the table are the
607 keywords between the first pair of brackets. These are followed by an =
608 and another pair of brackets that contain the data. The first datum is
609 assigned to the first element of the array that corresponds to the
610 first heading, atom. The second datum is assigned to the first element
611 of the array associated with the second heading, geometry, and so on.
612 Here the second datum is actually a vector: the x, y and z coordinates
613 of the first atom.
614 { atoms geometry } = {
615 O [ 0.00000000 0.00000000 0.37000000 ]
616 H [ 0.78000000 0.00000000 -0.18000000 ]
617 H [ -0.78000000 0.00000000 -0.18000000 ]
618 }
619 )
620 Next, a basis set object is given.
621 basis<GaussianBasisSet>: (
622 name = 'STO-3G'
623 molecule = $:molecule
624 )
625 Now we will give the main body of input. All the subsequent keywords
626 will be grouped in the mpqc section of the input (that is, each keyword
627 will be prefixed with mpqc:).
628 mpqc: (
629 Next we give the mole keyword which provides a specialization of the
630 MolecularEnergy class. In this case we will do a closed-shell Hartree-
631 Fock calculation. That is done with an object of type CLHF. The
632 keywords that CLHF accepts are given with the documentation for the
633 CLHF class, usually in the description of the const RefKeyVal&
634 constructor for the class. Also with the CLHF documentation is a list
635 of parent classes. Each of the parent classes may also have input. This
636 input is included with the rest of the input for the child class.
637 mole<CLHF>: (
638 The next line specifies the molecule to be used. There are two things
639 to note, first that this is actually a reference to complete molecule
640 specification elsewhere in the input file. The $ indicates that this is
641 a reference and the keyword following the $ is the actual location of
642 the molecule. The : in front of the keyword means that the keyword is
643 not relative to the current location in the input, but rather relative
644 to the root of the tree of keywords. Thus, this line grabs the molecule
645 that was specified above. The molecule object could have been placed
646 here, but frequently it is necessary that several objects refer to the
647 exact same object and this can only be done using references.
648 The second point is that if you look at the documentation for CLHF, you
649 will see that it doesn't read molecule keyword. However, if you follow
650 its parent classes up to MolecularEnergy, you'll find that molecule is
651 indeed read.
652 molecule = $:molecule
653 Just as we gave molecule, specify the basis set with the basis keyword
654 as follows:
655 basis = $:basis
656 Now we close off the parentheses we opened above and we are finished.
657 )
658 )
659 Sample Object-Oriented Input Files
660 The easiest way to get started with mpqc is to start with one of sample
661 inputs that most nearly matches your problem. The src/bin/mpqc/samples
662 contains all of the sample inputs below:
663 o Hartree-Fock Energy
664 o MP2 Energy
665 o MP2-R12 energy
666 o Hartree-Fock Optimization
667 o Optimization with a Computed Guess Hessian
668 o Optimization Using Newton's Method
669 o Hartree-Fock Frequencies
670 o Giving Coordinates and a Guess Hessian
671 o Optimization with a Hydrogen Bond
672 o Fixed Coordinate Optimization
673 o Transition State Optimization
674 o Transition State Optimization with a Computed Guess Hessian
675 o Hartree-Fock energy with intermediate checkpointing
676 o MP2-R12 energy with intermediate checkpointing
677 o HF gradient computed from a previously computed HF wave funtion
678 o MP2 Energy computed using precomputed Hartree-Fock wave function
679 o CLHF energy using a CCA integrals component
680 Hartree-Fock Energy
681 The following input will compute the Hartree-Fock energy of water.
682 % emacs should use -*- KeyVal -*- mode
683 % molecule specification
684 molecule<Molecule>: (
685 symmetry = C2V
686 unit = angstrom
687 { atoms geometry } = {
688 O [ 0.00000000 0.00000000 0.37000000 ]
689 H [ 0.78000000 0.00000000 -0.18000000 ]
690 H [ -0.78000000 0.00000000 -0.18000000 ]
691 }
692 )
693 % basis set specification
694 basis<GaussianBasisSet>: (
695 name = 'STO-3G'
696 molecule = $:molecule
697 )
698 mpqc: (
699 checkpoint = no
700 savestate = no
701 % method for computing the molecule's energy
702 mole<CLHF>: (
703 molecule = $:molecule
704 basis = $:basis
705 memory = 16000000
706 )
707 )
708 MP2 Energy
709 The following input will compute the MP2 energy of water.
710 % emacs should use -*- KeyVal -*- mode
711 % molecule specification
712 molecule<Molecule>: (
713 symmetry = C2V
714 unit = angstrom
715 { atoms geometry } = {
716 O [ 0.00000000 0.00000000 0.37000000 ]
717 H [ 0.78000000 0.00000000 -0.18000000 ]
718 H [ -0.78000000 0.00000000 -0.18000000 ]
719 }
720 )
721 % basis set specification
722 basis<GaussianBasisSet>: (
723 name = 'STO-3G'
724 molecule = $:molecule
725 )
726 mpqc: (
727 checkpoint = no
728 savestate = no
729 % method for computing the molecule's energy
730 mole<MBPT2>: (
731 molecule = $:molecule
732 basis = $:basis
733 memory = 16000000
734 % reference wavefunction
735 reference<CLHF>: (
736 molecule = $:molecule
737 basis = $:basis
738 memory = 16000000
739 )
740 )
741 )
742 MP2-R12 energy
743 The following will compute the MP2-R12 energy of water in standard
744 approximation A' (MP2-R12/A').
745 % emacs should use -*- KeyVal -*- mode
746 % molecule specification
747 molecule<Molecule>: (
748 symmetry = C2V
749 unit = angstrom
750 { atoms geometry } = {
751 O [ 0.00000000 0.00000000 0.37000000 ]
752 H [ 0.78000000 0.00000000 -0.18000000 ]
753 H [ -0.78000000 0.00000000 -0.18000000 ]
754 }
755 )
756 % basis set specification
757 basis<GaussianBasisSet>: (
758 name = 'cc-pVDZ'
759 molecule = $:molecule
760 )
761 % auxiliary basis set specification
762 abasis<GaussianBasisSet>: (
763 name = 'aug-cc-pVDZ'
764 molecule = $:molecule
765 )
766 mpqc: (
767 checkpoint = no
768 savestate = no
769 % method for computing the molecule's energy
770 mole<MBPT2_R12>: (
771 molecule = $:molecule
772 basis = $:basis
773 aux_basis = $:abasis
774 stdapprox = 'A''
775 nfzc = 1
776 memory = 16000000
777 integrals<IntegralCints>:()
778 % reference wavefunction
779 reference<CLHF>: (
780 molecule = $:molecule
781 basis = $:basis
782 memory = 16000000
783 integrals<IntegralCints>:()
784 )
785 )
786 )
787 Hartree-Fock Optimization
788 The following input will optimize the geometry of water using the
789 quasi-Newton method.
790 % emacs should use -*- KeyVal -*- mode
791 % molecule specification
792 molecule<Molecule>: (
793 symmetry = C2V
794 unit = angstrom
795 { atoms geometry } = {
796 O [ 0.00000000 0.00000000 0.37000000 ]
797 H [ 0.78000000 0.00000000 -0.18000000 ]
798 H [ -0.78000000 0.00000000 -0.18000000 ]
799 }
800 )
801 % basis set specification
802 basis<GaussianBasisSet>: (
803 name = '6-31G*'
804 molecule = $:molecule
805 )
806 mpqc: (
807 checkpoint = no
808 savestate = no
809 % molecular coordinates for optimization
810 coor<SymmMolecularCoor>: (
811 molecule = $:molecule
812 generator<IntCoorGen>: (
813 molecule = $:molecule
814 )
815 )
816 % method for computing the molecule's energy
817 mole<CLHF>: (
818 molecule = $:molecule
819 basis = $:basis
820 coor = $..:coor
821 memory = 16000000
822 )
823 % optimizer object for the molecular geometry
824 opt<QNewtonOpt>: (
825 function = $..:mole
826 update<BFGSUpdate>: ()
827 convergence<MolEnergyConvergence>: (
828 cartesian = yes
829 energy = $..:..:mole
830 )
831 )
832 )
833 Optimization with a Computed Guess Hessian
834 The following input will optimize the geometry of water using the
835 quasi-Newton method. The guess Hessian will be computed at a lower
836 level of theory.
837 % emacs should use -*- KeyVal -*- mode
838 % molecule specification
839 molecule<Molecule>: (
840 symmetry = C2V
841 unit = angstrom
842 { atoms geometry } = {
843 O [ 0.00000000 0.00000000 0.37000000 ]
844 H [ 0.78000000 0.00000000 -0.18000000 ]
845 H [ -0.78000000 0.00000000 -0.18000000 ]
846 }
847 )
848 % basis set specification
849 basis<GaussianBasisSet>: (
850 name = '6-31G*'
851 molecule = $:molecule
852 )
853 mpqc: (
854 checkpoint = no
855 savestate = no
856 % molecular coordinates for optimization
857 coor<SymmMolecularCoor>: (
858 molecule = $:molecule
859 generator<IntCoorGen>: (
860 molecule = $:molecule
861 )
862 )
863 % method for computing the molecule's energy
864 mole<CLHF>: (
865 molecule = $:molecule
866 basis = $:basis
867 coor = $..:coor
868 memory = 16000000
869 guess_hessian<FinDispMolecularHessian>: (
870 molecule = $:molecule
871 only_totally_symmetric = yes
872 eliminate_cubic_terms = no
873 checkpoint = no
874 energy<CLHF>: (
875 molecule = $:molecule
876 memory = 16000000
877 basis<GaussianBasisSet>: (
878 name = '3-21G'
879 molecule = $:molecule
880 )
881 )
882 )
883 )
884 % optimizer object for the molecular geometry
885 opt<QNewtonOpt>: (
886 function = $..:mole
887 update<BFGSUpdate>: ()
888 convergence<MolEnergyConvergence>: (
889 cartesian = yes
890 energy = $..:..:mole
891 )
892 )
893 )
894 Optimization Using Newton's Method
895 The following input will optimize the geometry of water using the
896 Newton's method. The Hessian will be computed at each step in the
897 optimization. However, Hessian recomputation is usually not worth the
898 cost; try using the computed Hessian as a guess Hessian for a quasi-
899 Newton method before resorting to a Newton optimization.
900 % Emacs should use -*- KeyVal -*- mode
901 % molecule specification
902 molecule<Molecule>: (
903 symmetry = c2v
904 unit = angstrom
905 { atoms geometry } = {
906 O [ 0.00000000 0.00000000 0.36937294 ]
907 H [ 0.78397590 0.00000000 -0.18468647 ]
908 H [ -0.78397590 0.00000000 -0.18468647 ]
909 }
910 )
911 % basis set specification
912 basis<GaussianBasisSet>: (
913 name = '3-21G'
914 molecule = $:molecule
915 )
916 mpqc: (
917 checkpoint = no
918 savestate = no
919 restart = no
920 % molecular coordinates for optimization
921 coor<SymmMolecularCoor>: (
922 molecule = $:molecule
923 generator<IntCoorGen>: (
924 molecule = $:molecule
925 )
926 )
927 do_energy = no
928 do_gradient = no
929 % method for computing the molecule's energy
930 mole<CLHF>: (
931 molecule = $:molecule
932 basis = $:basis
933 memory = 16000000
934 coor = $..:coor
935 guess_wavefunction<CLHF>: (
936 molecule = $:molecule
937 total_charge = 0
938 basis<GaussianBasisSet>: (
939 molecule = $:molecule
940 name = 'STO-3G'
941 )
942 memory = 16000000
943 )
944 hessian<FinDispMolecularHessian>: (
945 only_totally_symmetric = yes
946 eliminate_cubic_terms = no
947 checkpoint = no
948 )
949 )
950 optimize = yes
951 % optimizer object for the molecular geometry
952 opt<NewtonOpt>: (
953 print_hessian = yes
954 max_iterations = 20
955 function = $..:mole
956 convergence<MolEnergyConvergence>: (
957 cartesian = yes
958 energy = $..:..:mole
959 )
960 )
961 )
962 Hartree-Fock Frequencies
963 The following input will compute Hartree-Fock frequencies by finite
964 displacements. A thermodynamic analysis will also be performed. If
965 optimization input is also provided, then the optimization will be run
966 first, then the frequencies.
967 % emacs should use -*- KeyVal -*- mode
968 % molecule specification
969 molecule<Molecule>: (
970 symmetry = C1
971 { atoms geometry } = {
972 O [ 0.0000000000 0.0000000000 0.8072934188 ]
973 H [ 1.4325589285 0.0000000000 -0.3941980761 ]
974 H [ -1.4325589285 0.0000000000 -0.3941980761 ]
975 }
976 )
977 % basis set specification
978 basis<GaussianBasisSet>: (
979 name = 'STO-3G'
980 molecule = $:molecule
981 )
982 mpqc: (
983 checkpoint = no
984 savestate = no
985 % method for computing the molecule's energy
986 mole<CLHF>: (
987 molecule = $:molecule
988 basis = $:basis
989 memory = 16000000
990 )
991 % vibrational frequency input
992 freq<MolecularFrequencies>: (
993 molecule = $:molecule
994 )
995 )
996 Giving Coordinates and a Guess Hessian
997 The following example shows several features that are really
998 independent. The variable coordinates are explicitly given, rather than
999 generated automatically. This is especially useful when a guess Hessian
1000 is to be provided, as it is here. This Hessian, as given by the user,
1001 is not complete and the QNewtonOpt object will fill in the missing
1002 values using a guess the Hessian provided by the MolecularEnergy
1003 object. Also, fixed coordinates are given in this sample input.
1004 % emacs should use -*- KeyVal -*- mode
1005 % molecule specification
1006 molecule<Molecule>: (
1007 symmetry = C1
1008 { atoms geometry } = {
1009 H [ 0.088 2.006 1.438 ]
1010 O [ 0.123 3.193 0.000 ]
1011 H [ 0.088 2.006 -1.438 ]
1012 O [ 4.502 5.955 -0.000 ]
1013 H [ 2.917 4.963 -0.000 ]
1014 H [ 3.812 7.691 -0.000 ]
1015 }
1016 )
1017 % basis set specification
1018 basis<GaussianBasisSet>: (
1019 name = 'STO-3G'
1020 molecule = $:molecule
1021 )
1022 mpqc: (
1023 checkpoint = no
1024 savestate = no
1025 % method for computing the molecule's energy
1026 mole<CLHF>: (
1027 molecule = $:molecule
1028 basis = $:basis
1029 coor = $..:coor
1030 memory = 16000000
1031 )
1032 % molecular coordinates for optimization
1033 coor<SymmMolecularCoor>: (
1034 molecule = $:molecule
1035 generator<IntCoorGen>: (
1036 molecule = $:molecule
1037 extra_bonds = [ 2 5 ]
1038 )
1039 % use these instead of generated coordinates
1040 variable<SetIntCoor>: [
1041 <StreSimpleCo>:( atoms = [ 2 5 ] )
1042 <BendSimpleCo>:( atoms = [ 2 5 4 ] )
1043 <OutSimpleCo>: ( atoms = [ 5 2 1 3 ] )
1044 <SumIntCoor>: (
1045 coor: [
1046 <StreSimpleCo>:( atoms = [ 1 2 ] )
1047 <StreSimpleCo>:( atoms = [ 2 3 ] )
1048 ]
1049 coef = [ 1.0 1.0 ]
1050 )
1051 <SumIntCoor>: (
1052 coor: [
1053 <StreSimpleCo>:( atoms = [ 4 5 ] )
1054 <StreSimpleCo>:( atoms = [ 4 6 ] )
1055 ]
1056 coef = [ 1.0 1.0 ]
1057 )
1058 <BendSimpleCo>:( atoms = [ 1 2 3 ] )
1059 <BendSimpleCo>:( atoms = [ 5 4 6 ] )
1060 ]
1061 % these are fixed by symmetry anyway,
1062 fixed<SetIntCoor>: [
1063 <SumIntCoor>: (
1064 coor: [
1065 <StreSimpleCo>:( atoms = [ 1 2 ] )
1066 <StreSimpleCo>:( atoms = [ 2 3 ] )
1067 ]
1068 coef = [ 1.0 -1.0 ]
1069 )
1070 <SumIntCoor>: (
1071 coor: [
1072 <StreSimpleCo>:( atoms = [ 4 5 ] )
1073 <StreSimpleCo>:( atoms = [ 4 6 ] )
1074 ]
1075 coef = [ 1.0 -1.0 ]
1076 )
1077 <TorsSimpleCo>:( atoms = [ 2 5 4 6] )
1078 <OutSimpleCo>:( atoms = [ 3 2 6 4 ] )
1079 <OutSimpleCo>:( atoms = [ 1 2 6 4 ] )
1080 ]
1081 )
1082 % optimizer object for the molecular geometry
1083 opt<QNewtonOpt>: (
1084 function = $..:mole
1085 update<BFGSUpdate>: ()
1086 convergence<MolEnergyConvergence>: (
1087 cartesian = yes
1088 energy = $..:..:mole
1089 )
1090 % give a partial guess hessian in internal coordinates
1091 % the missing elements will be filled in automatically
1092 hessian = [
1093 [ 0.0109261670 ]
1094 [ -0.0004214845 0.0102746106 ]
1095 [ -0.0008600592 0.0030051330 0.0043149957 ]
1096 [ 0.0 0.0 0.0 ]
1097 [ 0.0 0.0 0.0 ]
1098 [ 0.0 0.0 0.0 ]
1099 [ 0.0 0.0 0.0 ]
1100 ]
1101 )
1102 )
1103 Optimization with a Hydrogen Bond
1104 The automatic internal coordinate generator will fail if it cannot find
1105 enough redundant internal coordinates. In this case, the internal
1106 coordinate generator must be explicitly created in the input and given
1107 extra connectivity information, as is shown below.
1108 % emacs should use -*- KeyVal -*- mode
1109 % molecule specification
1110 molecule<Molecule>: (
1111 symmetry = C1
1112 { atoms geometry } = {
1113 H [ 0.088 2.006 1.438 ]
1114 O [ 0.123 3.193 0.000 ]
1115 H [ 0.088 2.006 -1.438 ]
1116 O [ 4.502 5.955 -0.000 ]
1117 H [ 2.917 4.963 -0.000 ]
1118 H [ 3.812 7.691 -0.000 ]
1119 }
1120 )
1121 % basis set specification
1122 basis<GaussianBasisSet>: (
1123 name = 'STO-3G'
1124 molecule = $:molecule
1125 )
1126 mpqc: (
1127 checkpoint = no
1128 savestate = no
1129 % method for computing the molecule's energy
1130 mole<CLHF>: (
1131 molecule = $:molecule
1132 basis = $:basis
1133 coor = $..:coor
1134 memory = 16000000
1135 )
1136 % molecular coordinates for optimization
1137 coor<SymmMolecularCoor>: (
1138 molecule = $:molecule
1139 % give an internal coordinate generator that knows about the
1140 % hydrogen bond between atoms 2 and 5
1141 generator<IntCoorGen>: (
1142 molecule = $:molecule
1143 extra_bonds = [ 2 5 ]
1144 )
1145 )
1146 % optimizer object for the molecular geometry
1147 opt<QNewtonOpt>: (
1148 function = $..:mole
1149 update<BFGSUpdate>: ()
1150 convergence<MolEnergyConvergence>: (
1151 cartesian = yes
1152 energy = $..:..:mole
1153 )
1154 )
1155 )
1156 Fixed Coordinate Optimization
1157 This example shows how to selectively fix internal coordinates in an
1158 optimization. Any number of linearly independent coordinates can be
1159 given. These coordinates must remain linearly independent throughout
1160 the optimization, a condition that might not hold since the coordinates
1161 can be nonlinear.
1162 By default, the initial fixed coordinates' values are taken from the
1163 cartesian geometry given by the Molecule object; however, the molecule
1164 will be displaced to the internal coordinate values given with the
1165 fixed internal coordinates if have_fixed_values keyword is set to true,
1166 as shown in this example. In this case, the initial cartesian geometry
1167 should be reasonably close to the desired initial geometry and all of
1168 the variable coordinates will be frozen to their original values during
1169 the initial displacement.
1170 % emacs should use -*- KeyVal -*- mode
1171 % molecule specification
1172 molecule<Molecule>: (
1173 symmetry = CS
1174 { atoms geometry } = {
1175 H [ 3.04 -0.69 -1.59 ]
1176 H [ 3.04 -0.69 1.59 ]
1177 N [ 2.09 -0.48 -0.00 ]
1178 C [ -0.58 -0.15 0.00 ]
1179 H [ -1.17 1.82 0.00 ]
1180 H [ -1.41 -1.04 -1.64 ]
1181 H [ -1.41 -1.04 1.64 ]
1182 }
1183 )
1184 % basis set specification
1185 basis<GaussianBasisSet>: (
1186 name = '3-21G*'
1187 molecule = $:molecule
1188 )
1189 mpqc: (
1190 checkpoint = no
1191 savestate = no
1192 % molecular coordinates for optimization
1193 coor<SymmMolecularCoor>: (
1194 molecule = $:molecule
1195 generator<IntCoorGen>: (
1196 molecule = $:molecule
1197 )
1198 have_fixed_values = yes
1199 fixed<SetIntCoor>: [
1200 <OutSimpleCo>: ( value = -0.1
1201 label = 'N-inversion'
1202 atoms = [4 3 2 1] )
1203 ]
1204 )
1205 % method for computing the molecule's energy
1206 mole<CLHF>: (
1207 molecule = $:molecule
1208 basis = $:basis
1209 coor = $..:coor
1210 memory = 16000000
1211 )
1212 % optimizer object for the molecular geometry
1213 opt<QNewtonOpt>: (
1214 max_iterations = 20
1215 function = $..:mole
1216 update<BFGSUpdate>: ()
1217 convergence<MolEnergyConvergence>: (
1218 cartesian = yes
1219 energy = $..:..:mole
1220 )
1221 )
1222 )
1223 Transition State Optimization
1224 This example shows a transition state optimization of the N-inversion
1225 in $thrm{CH}_3thrm{NH}_2$ using mode following. The initial geometry
1226 was obtained by doing a few fixed coordinate optimizations along the
1227 inversion coordinate.
1228 % emacs should use -*- KeyVal -*- mode
1229 % molecule specification
1230 molecule<Molecule>: (
1231 symmetry = CS
1232 { atoms geometry } = {
1233 H [ 3.045436 -0.697438 -1.596748 ]
1234 H [ 3.045436 -0.697438 1.596748 ]
1235 N [ 2.098157 -0.482779 -0.000000 ]
1236 C [ -0.582616 -0.151798 0.000000 ]
1237 H [ -1.171620 1.822306 0.000000 ]
1238 H [ -1.417337 -1.042238 -1.647529 ]
1239 H [ -1.417337 -1.042238 1.647529 ]
1240 }
1241 )
1242 % basis set specification
1243 basis<GaussianBasisSet>: (
1244 name = '3-21G*'
1245 molecule = $:molecule
1246 )
1247 mpqc: (
1248 checkpoint = no
1249 savestate = no
1250 % molecular coordinates for optimization
1251 coor<SymmMolecularCoor>: (
1252 molecule = $:molecule
1253 generator<IntCoorGen>: (
1254 molecule = $:molecule
1255 )
1256 followed<OutSimpleCo> = [ 'N-inversion' 4 3 2 1 ]
1257 )
1258 % method for computing the molecule's energy
1259 mole<CLHF>: (
1260 molecule = $:molecule
1261 basis = $:basis
1262 coor = $..:coor
1263 memory = 16000000
1264 )
1265 % optimizer object for the molecular geometry
1266 opt<EFCOpt>: (
1267 transition_state = yes
1268 mode_following = yes
1269 max_iterations = 20
1270 function = $..:mole
1271 update<PowellUpdate>: ()
1272 convergence<MolEnergyConvergence>: (
1273 cartesian = yes
1274 energy = $..:..:mole
1275 )
1276 )
1277 )
1278 Transition State Optimization with a Computed Guess Hessian
1279 This example shows a transition state optimization of the N-inversion
1280 in $thrm{CH}_3thrm{NH}_2$ using mode following. The initial geometry
1281 was obtained by doing a few fixed coordinate optimizations along the
1282 inversion coordinate. An approximate guess Hessian will be computed,
1283 which makes the optimiziation converge much faster in this case.
1284 % emacs should use -*- KeyVal -*- mode
1285 % molecule specification
1286 molecule<Molecule>: (
1287 symmetry = CS
1288 { atoms geometry } = {
1289 H [ 3.045436 -0.697438 -1.596748 ]
1290 H [ 3.045436 -0.697438 1.596748 ]
1291 N [ 2.098157 -0.482779 -0.000000 ]
1292 C [ -0.582616 -0.151798 0.000000 ]
1293 H [ -1.171620 1.822306 0.000000 ]
1294 H [ -1.417337 -1.042238 -1.647529 ]
1295 H [ -1.417337 -1.042238 1.647529 ]
1296 }
1297 )
1298 % basis set specification
1299 basis<GaussianBasisSet>: (
1300 name = '3-21G*'
1301 molecule = $:molecule
1302 )
1303 mpqc: (
1304 checkpoint = no
1305 savestate = no
1306 % molecular coordinates for optimization
1307 coor<SymmMolecularCoor>: (
1308 molecule = $:molecule
1309 generator<IntCoorGen>: (
1310 molecule = $:molecule
1311 )
1312 followed<OutSimpleCo> = [ 'N-inversion' 4 3 2 1 ]
1313 )
1314 % method for computing the molecule's energy
1315 mole<CLHF>: (
1316 molecule = $:molecule
1317 basis = $:basis
1318 coor = $..:coor
1319 memory = 16000000
1320 guess_hessian<FinDispMolecularHessian>: (
1321 molecule = $:molecule
1322 only_totally_symmetric = yes
1323 eliminate_cubic_terms = no
1324 checkpoint = no
1325 energy<CLHF>: (
1326 molecule = $:molecule
1327 memory = 16000000
1328 basis<GaussianBasisSet>: (
1329 name = '3-21G'
1330 molecule = $:molecule
1331 )
1332 )
1333 )
1334 )
1335 % optimizer object for the molecular geometry
1336 opt<EFCOpt>: (
1337 transition_state = yes
1338 mode_following = yes
1339 max_iterations = 20
1340 function = $..:mole
1341 update<PowellUpdate>: ()
1342 convergence<MolEnergyConvergence>: (
1343 cartesian = yes
1344 energy = $..:..:mole
1345 )
1346 )
1347 )
1348 Hartree-Fock energy with intermediate checkpointing
1349 The following two sections demonstrate how MPQC can be used to save the
1350 mole object periodically. This input will compute the Hartree-Fock
1351 energy of water while saving the mole object every 3 iterations.
1352 % emacs should use -*- KeyVal -*- mode
1353 % molecule specification
1354 molecule<Molecule>: (
1355 symmetry = C2V
1356 unit = angstrom
1357 { atoms geometry } = {
1358 O [ 0.00000000 0.00000000 0.37000000 ]
1359 H [ 0.78000000 0.00000000 -0.18000000 ]
1360 H [ -0.78000000 0.00000000 -0.18000000 ]
1361 }
1362 )
1363 % basis set specification
1364 basis<GaussianBasisSet>: (
1365 name = 'STO-3G'
1366 molecule = $:molecule
1367 )
1368 mpqc: (
1369 checkpoint = yes
1370 filename = 'h2o-rhf-STO3G'
1371 checkpoint_freq = 3
1372 savestate = no
1373 % method for computing the molecule's energy
1374 mole<CLHF>: (
1375 molecule = $:molecule
1376 basis = $:basis
1377 memory = 16000000
1378 )
1379 )
1380 The mole object will be saved to files named 'h2o-rhf-
1381 STO3G.wfn.<iter#>.tmp' where <iter#> is the SCF iteration number (3, 6,
1382 etc.). Only the most recent file is kept, files from previous
1383 iterations are removed automatically. Keyword filename here is used to
1384 set the default file name prefix.
1385 MP2-R12 energy with intermediate checkpointing
1386 The following input will compute the MP2-R12 energy of water in
1387 standard approximation A' (MP2-R12/A') while saving the mole object at
1388 intermediate checkpoints.
1389 % emacs should use -*- KeyVal -*- mode
1390 % molecule specification
1391 molecule<Molecule>: (
1392 symmetry = C2V
1393 unit = angstrom
1394 { atoms geometry } = {
1395 O [ 0.00000000 0.00000000 0.37000000 ]
1396 H [ 0.78000000 0.00000000 -0.18000000 ]
1397 H [ -0.78000000 0.00000000 -0.18000000 ]
1398 }
1399 )
1400 % basis set specification
1401 basis<GaussianBasisSet>: (
1402 name = 'cc-pVDZ'
1403 molecule = $:molecule
1404 )
1405 % auxiliary basis set specification
1406 abasis<GaussianBasisSet>: (
1407 name = 'aug-cc-pVDZ'
1408 molecule = $:molecule
1409 )
1410 mpqc: (
1411 checkpoint = yes
1412 filename = 'h2o-mp2r12ap-vdz-avdz'
1413 savestate = no
1414 % method for computing the molecule's energy
1415 mole<MBPT2_R12>: (
1416 molecule = $:molecule
1417 basis = $:basis
1418 aux_basis = $:abasis
1419 stdapprox = 'A''
1420 nfzc = 1
1421 memory = 16000000
1422 integrals<IntegralCints>:()
1423 % reference wavefunction
1424 reference<CLHF>: (
1425 molecule = $:molecule
1426 basis = $:basis
1427 memory = 16000000
1428 integrals<IntegralCints>:()
1429 )
1430 )
1431 )
1432 The mole object will be saved to a file named h2o-mp2r12ap-vdz-
1433 avdz.wfn". Keyword filename here is used to set the default file name
1434 prefix. Objects of the MBPT2_R12 type are checkpointed after the HF
1435 procedure, after the first integrals (SBS) transformation, and after
1436 the optional second (ABS) transformation.
1437 HF gradient computed from a previously computed HF wave funtion
1438 The following will illustrate how to reuse previously computed
1439 MolecularEnergy objects in subsequent computations. The first input
1440 computes Hartree-Fock energy for water and saves the mole object to
1441 file h2o-rhf-sto3g.wfn.
1442 % emacs should use -*- KeyVal -*- mode
1443 % molecule specification
1444 molecule<Molecule>: (
1445 symmetry = C2V
1446 unit = angstrom
1447 { atoms geometry } = {
1448 O [ 0.00000000 0.00000000 0.37000000 ]
1449 H [ 0.78000000 0.00000000 -0.18000000 ]
1450 H [ -0.78000000 0.00000000 -0.18000000 ]
1451 }
1452 )
1453 % basis set specification
1454 basis<GaussianBasisSet>: (
1455 name = 'STO-3G'
1456 molecule = $:molecule
1457 )
1458 mpqc: (
1459 checkpoint = no
1460 savestate = yes
1461 filename = 'h2o-rhf-sto3g'
1462 % method for computing the molecule's energy
1463 mole<CLHF>: (
1464 molecule = $:molecule
1465 basis = $:basis
1466 memory = 16000000
1467 )
1468 )
1469 The second input reuses the mole object from the previous run to
1470 compute the gradient of the Hartree-Fock energy.
1471 % emacs should use -*- KeyVal -*- mode
1472 mpqc: (
1473 checkpoint = no
1474 savestate = no
1475 restart = yes
1476 restart_file = 'h2o-rhf-sto3g.wfn'
1477 do_gradient = yes
1478 )
1479 MP2 Energy computed using precomputed Hartree-Fock wave function
1480 The following input will compute the MP2 energy of water using a saved
1481 Hartree-Fock wave function obtained using the first input from HF
1482 gradient computed from a previously computed HF wave funtion.
1483 % emacs should use -*- KeyVal -*- mode
1484 % molecule specification
1485 molecule<Molecule>: (
1486 symmetry = C2V
1487 unit = angstrom
1488 { atoms geometry } = {
1489 O [ 0.00000000 0.00000000 0.37000000 ]
1490 H [ 0.78000000 0.00000000 -0.18000000 ]
1491 H [ -0.78000000 0.00000000 -0.18000000 ]
1492 }
1493 )
1494 % basis set specification
1495 basis<GaussianBasisSet>: (
1496 name = 'STO-3G'
1497 molecule = $:molecule
1498 )
1499 % wave function file object specification
1500 wfnfile<BcastStateInBin>:file = 'h2o-rhf-sto3g.wfn'
1501 mpqc: (
1502 checkpoint = no
1503 savestate = no
1504 % method for computing the molecule's energy
1505 mole<MBPT2>: (
1506 molecule = $:molecule
1507 basis = $:basis
1508 memory = 16000000
1509 % reference wavefunction
1510 reference<SavableStateProxy>: (
1511 statein = $:wfnfile
1512 object = 'CLHF'
1513 )
1514 )
1515 )
1516 Note that now object reference is of type SavableStateProxy, rather
1517 than CLHF. SavableStateProxy is a special object type that can be
1518 converted at runtime into the desired type (in this case, CLHF, as
1519 indicated by object).
1520 CLHF energy using a CCA integrals component
1521 The following input will compute the CLHF energy of water using a CCA
1522 integrals component via the IntegralCCA adaptor class.
1523 % emacs should use -*- KeyVal -*- mode
1524 % molecule specification
1525 molecule<Molecule>: (
1526 symmetry = C2V
1527 unit = angstrom
1528 { atoms geometry } = {
1529 O [ 0.00000000 0.00000000 0.37000000 ]
1530 H [ 0.78000000 0.00000000 -0.18000000 ]
1531 H [ -0.78000000 0.00000000 -0.18000000 ]
1532 }
1533 )
1534 % basis set specification
1535 basis<GaussianBasisSet>: (
1536 name = 'STO-3G'
1537 molecule = $:molecule
1538 )
1539 mpqc: (
1540 % path to component libraries
1541 cca_path = /usr/local/lib/cca
1542 % sidl class names of components which will be instantiated
1543 cca_load = MPQC.IntegralEvaluatorFactory
1544 do_cca = yes
1545 checkpoint = no
1546 savestate = no
1547 % method for computing the molecule's energy
1548 mole<CLHF>: (
1549 molecule = $:molecule
1550 basis = $:basis
1551 % cca integrals adaptor class
1552 integrals<IntegralCCA>: (
1553 molecule = $:molecule
1554 % integral buffer type
1555 integral_buffer = opaque
1556 % integral package
1557 integral_package = intv3
1558 % factory component sidl class name
1559 evaluator_factory = MPQC.IntegralEvaluatorFactory
1560 )
1561 )
1562 )
1564 After you compile MPQC, you should run the validation suite. You should
1565 also run the validation suite if you upgrade your operating system
1566 software, since this could change shared libraries that are linking
1567 with MPQC and could affect the results. Note that the reference
1568 validation suite has not been verified relative to an independent code,
1569 except for a few spot checks. If you find that MPQC doesn't produce the
1570 same answer as another quantum chemistry program that you trust, then
1571 please promptly notify us and send all the details.
1572 The top-level Makefile has several targets that can be used to check an
1573 MPQC build. MPQC must be built before one of these targets is used:
1574 check
1575 The same as check0 below. This is only available from the top-level
1576 directory and src/bin/mpqc/validate.
1577 check0
1578 Run the smallest MPQC verification suite. It tests basic
1579 functionality. This is only available from the top-level directory
1580 and src/bin/mpqc/validate.
1581 check1
1582 Run the intermediate MPQC verification suite. It runs most of the
1583 tests, only leaving out very expensive runs. This is only available
1584 from the top-level directory and src/bin/mpqc/validate.
1585 check2
1586 Run the complete MPQC verification suite. Depending on the
1587 compilation and runtime environment, tests that are not expected to
1588 work will be omitted. This is only available from the top-level
1589 directory and src/bin/mpqc/validate.
1590 check_clean
1591 Remove MPQC verification suite output files. This is only available
1592 from the top-level directory and src/bin/mpqc/validate.
1593 testbuild
1594 Verify that a variety of small test programs compile. If static
1595 libraries are used, this will require a substantial amount of disk
1596 space.
1597 testrun
1598 Run a variety of small test programs. This will build them if
1599 necessary.
1600 The check targets will run mpqc with the mpqcrun (see mpqcrun) command.
1601 You can give arguments to mpqcrun by setting the MPQCRUN_ARGS variable
1602 on the make command line.
1603 The verification suite is in src/bin/mpqc/validate. After running it,
1604 the output files can be found in src/bin/mpqc/validate/run. The check
1605 targets will compare outputs that your build produced to the reference
1606 files in src/bin/mpqc/validate/ref. The input files can be found with
1607 the reference files. For each comparison, first the status (ok,
1608 missing, or failed) for each file is printed. If both statuses are ok
1609 then an E: is printed followed by the number of digits to which the
1610 energies agree. If they agree to all digits 99 is printed. If a
1611 gradient was computed, then Grad: is printed followed by the number of
1612 digits to which the gradients in least agreement agree. Other
1613 properties checked in this way include frequencies, diagnostics, and
1614 populations.
1615 If two numbers do not agree to the expected accuracy, then an asterisk,
1616 *, is printed after the number of digits in agreement.
1617 Finally, you can do a detailed comparison of the contents of the ref
1618 and run subdirectories by typing make diff.
1619 The input files in the verification suite are divided into several
1620 categories:
1621 h2o
1622 These are simple tests that exercise many of MPQC's features.
1623 h2omp2
1624 Tests that further exercise MP2.
1625 h2ofrq
1626 Tests of H2 O frequencies with a variety of methods.
1627 mbpt
1628 These tests exercise MP2 as well as the open-shell perturbation
1629 theory methods. The various available algorithms are tested as
1630 well.
1631 ckpt
1632 Tests the checkpoint and restart capabilities.
1633 symm1
1634 Tests of point group symmetry.
1635 symm2
1636 More point group symmetry tests. These use basis sets with higher
1637 angular momentum than symm1#.
1638 symm3
1639 Tests automatic point group determination.
1640 basis1
1641 A variety of basis sets are tested for first row atoms along with
1642 hydrogen and helium.
1643 basis2
1644 Basis sets test for second row atoms.
1645 methods
1646 Basic tests of several of MPQC's methods.
1647 clscf
1648 More tests of methods based on CLSCF.
1649 hsosscf
1650 More tests of methods based on HSOSSCF.
1651 uscf
1652 More tests of methods based on UnrestrictedSCF.
1653 dft
1654 More tests of the CLKS method.
1655 mp2r12
1656 More tests of MP2-R12.
1657 ccaintv3
1658 Tests of embedded CCA integrals components using intv3.
1659 ccacints
1660 Tests of embedded CCA integrals components using cints.
1662 Psi 3 is a suite of ab initio codes related to the original Psi package
1663 started in Prof. Fritz Schaefer's group at UC Berkeley. Current version
1664 of MPQC works with stable versions of Psi 3 starting with 3.2.0. From
1665 now on we will refer to Psi 3 as simply Psi. Psi is written primarily
1666 in C and executes in serial mode only. The interface between Psi and
1667 MPQC is intended mainly for Psi users who wish to exploit MPQC's
1668 geometry optimization and frequency analyses capabilities with Psi
1669 energies and gradients.
1670 The following sections explain how to use Psi from MPQC:
1671 o How the MPQC-Psi interface works
1672 o Environmental Variables
1673 o Preparing an input file
1674 o Psi Execution Environment
1675 o PsiWavefunction specializations
1676 o More examples
1677 How the MPQC-Psi interface works
1678 The current version of the interface is rather slim. It is only
1679 possible to import energies and gradients computed with Psi into MPQC,
1680 i.e. wave functions cannot be imported. All MPQC-Psi interaction
1681 happens via text files and system calls. MPQC generates input file for
1682 Psi, calls appropriate Psi modules, and then parses the output files
1683 for energies and gradients.
1684 Environmental Variables
1685 Several environmental variables are used to control MPQC-Psi
1686 interaction:
1687 PSIBIN
1688 By default, MPQC will try to find Psi binaries under
1689 /usr/local/psi/bin. Use PSIBIN environmental variable to point to
1690 the right location.
1691 The rest of the Psi environment is job specific and specified in the
1692 input file.
1693 Preparing an input file
1694 As noted above, MPQC parses the input file, and as such the input file
1695 has to be in the MPQC OO input format. All features of usual MPQC input
1696 files are there (mpqc section, mole MolecularEnergy object, etc.). In
1697 addition the following rules apply:
1698 o instead of using MPQC Wavefunction objects (CLHF, MBPT2, etc.), the
1700 Psi specific Wavefunction types (i.e. specializations of
1701 PsiWavefunction) have to be used. Presently the following
1702 specializations are supported: PsiCLHF, PsiHSOSHF, PsiUHF, PsiCCSD,
1703 PsiCCSD_T . The first three are directly analogous to MPQC
1704 Wavefunction types CLHF, HSOSHF, and UHF. The latter two do not have
1705 MPQC analogs yet. See appropriate class documentation on how to
1706 specify them properly.
1707 o each Psi-specific Wavefunction object has to have a member object
1708 psienv of type PsiExEnv. PsiExEnv contains job specific information,
1709 such as the directory in which Psi input, output, and checkpoint
1710 files will be kept, filename prefix, scratch directories, etc. It
1711 makes sense to define one such object and simply refer to it from all
1712 PsiWavefunction objects. See PsiExEnv class documentation for more
1713 info.
1714 Psi Execution Environment
1715 Each PsiWavefunction-derived class has to have a member object called
1716 psienv of type PsiExEnv. The following keywords are used by its KeyVal
1717 constructor:
1718 cwd
1719 The directory where to keep Psi input, checkpoint, stdout, stderr,
1720 and other files. Default is /tmp.
1721 fileprefix
1722 The file prefix to use for Psi checkpoint, scratch, and some ASCII
1723 files. Equivalent to keyword name in Psi psi:files:default section.
1724 Defaults to psi.
1725 stdout
1726 The file into which to redirect standard output of Psi modules.
1727 Defaults to psi.stdout.
1728 stderr
1729 The file into which to redirect standard error of Psi modules.
1730 Defaults to psi.stderr.
1731 nscratch
1732 The number of locations over which to stripe Psi binary files.
1733 Equivalent to keyword nvolume in Psi psi:files:default section.
1734 Default is 1.
1735 scratch
1736 The locations over which to stripe Psi binary files. Equivalent to
1737 keyword volumex in Psi psi:files:default section. There's no
1738 default.
1739 Here's an example:
1740 psienv<PsiExEnv>: (
1741 cwd = ./
1742 fileprefix = psi.test
1743 nscratch = 2
1744 scratch = [ '/scratch1/' '/scratch2/' ]
1745 )
1746 PsiWavefunction specializations
1747 Class PsiWavefunction is derived from class Wavefunction, hence its
1748 KeyVal constructor uses all keywords that Wavefunction's KeyVal
1749 constructor uses (basis, molecule, etc.). In addition,
1750 PsiWavefunction's KeyVal constructor looks for the following keywords
1751 in the input file:
1752 psienv
1753 The PsiExEnv object that provides job specific Psi environment.
1754 There's no default.
1755 docc
1756 An optional array of integers that specifies the number of doubly-
1757 occupied orbitals in each irrep.
1758 socc
1759 An optional array of integers that specifies the number of singly-
1760 occupied orbitals in each irrep.
1761 frozen_docc
1762 An optional array of integers that specifies the number of doubly-
1763 occupied orbitals in each irrep frozen in correlated computations.
1764 frozen_uocc
1765 An optional array of integers that specifies the number of
1766 unoccupied orbitals in each irrep frozen in correlated
1767 computations.
1768 total_charge
1769 The total charge of the system. This keyword is queried only if
1770 neither docc nor socc are given.
1771 multiplicity
1772 The spin multiplicity of the system (2*M_S+1). This keyword is
1773 queried only if neither docc nor socc are given.
1774 memory
1775 The number of bytes of memory Psi modules associated with this
1776 PsiWavefunction are allowed to use. Default is 2000000 (2 million
1777 bytes, approximately 2 MB).
1778 Note that keywords docc, socc, frozen_docc, frozen_uocc, total_charge,
1779 and multiplicity are used by appropriate specializations of
1780 PsiWavefunctions, i.e. PsiCLHF only checks for docc, etc.
1781 PsiWavefunction specializations PsiCCSD and PsiCCSD_T also look for
1782 keyword reference which specifies the reference wave function (an
1783 object of type PsiSCF). All classes for correlated Psi wave functions
1784 will require such an object.
1785 Here are a few examples of PsiWavefunctions:
1786 %
1787 % ROHF DZ on F atom
1788 %
1789 mole<PsiHSOSHF>: (
1790 docc = [ 2 0 0 0 0 1 1 0 ] socc = [ 0 0 0 0 0 0 0 1]
1791 memory = 10000000
1792 % Psi Environment data
1793 psienv<PsiExEnv>: (
1794 cwd = ./
1795 fileprefix = f.dz.test
1796 stdout = f.dz.test.stdout
1797 stderr = f.dz.test.stderr
1798 nscratch = 1
1799 scratch = [ '/scratch/mpqc/' ]
1800 )
1801 % MolecularEnergy input
1802 molecule<Molecule>: (
1803 {atoms geometry} = {
1804 F [ 0.0 0.0 0.0 ]
1805 }
1806 )
1807 % Basis input
1808 basis<GaussianBasisSet>: (
1809 molecule = $..:molecule
1810 name = 'DZ (Dunning)'
1811 )
1812 )
1813 %
1814 % RHF CCSD/cc-pVDZ on water
1815 %
1816 mole<PsiCCSD>: (
1817 frozen_docc = [1 0 0 0]
1818 memory = 40000000
1819 % Psi Environment data
1820 psienv<PsiExEnv>: (
1821 cwd = ./
1822 fileprefix = h2o.ccpvdz.ccsd.test
1823 nscratch = 1
1824 scratch = [ '/tmp/' ]
1825 )
1826 % MolecularEnergy input
1827 molecule<Molecule>: (
1828 {atoms geometry} = {
1829 H [ -1.5 0.0 -0.3 ]
1830 H [ 1.5 0.0 -0.3 ]
1831 O [ 0.0 0.0 1.0 ]
1832 }
1833 )
1834 % Basis input
1835 basis<GaussianBasisSet>: (
1836 molecule = $..:molecule
1837 name = 'cc-pVDZ'
1838 )
1839 reference<PsiCLHF>: (
1840 psienv = $..:psienv
1841 molecule = $..:molecule
1842 basis = $..:basis
1843 total_charge = 0
1844 multiplicity = 1
1845 )
1846 )
1847 More examples
1848 This section contains some examples of complete inputs that specify an
1849 MPQC/Psi computations.
1850 Here's an optimization + subsequent frequency analysis on water
1851 molecule at the RHF CCSD 6-311G** level:
1852 % Emacs should use -*- KeyVal -*- mode
1853 % this file was automatically generated
1854 % label: water test series
1855 % molecule specification
1856 molecule<Molecule>: (
1857 symmetry = C2V
1858 unit = angstrom
1859 { atoms geometry } = {
1860 O [ 0.000000000000 0.000000000000 0.369372944000 ]
1861 H [ 0.783975899000 0.000000000000 -0.184686472000 ]
1862 H [ -0.783975899000 0.000000000000 -0.184686472000 ]
1863 }
1864 )
1865 % basis set specification
1866 basis<GaussianBasisSet>: (
1867 name = '6-311G**'
1868 molecule = $:molecule
1869 )
1870 % Psi environment specification
1871 psienv<PsiExEnv>: (
1872 cwd = ./
1873 fileprefix = mpqcpsi
1874 stdout = mpqcpsi.stdout
1875 stderr = mpqcpsi.stderr
1876 nscratch = 1
1877 scratch = [ '/scratch/evaleev/' ]
1878 )
1879 mpqc: (
1880 checkpoint = no
1881 savestate = no
1882 restart = no
1883 coor<SymmMolecularCoor>: (
1884 molecule = $:molecule
1885 generator<IntCoorGen>: (
1886 molecule = $:molecule
1887 )
1888 )
1889 % molecular coordinates for optimization do_energy = yes
1890 do_gradient = no
1891 % method for computing the molecule's energy
1892 mole<PsiCCSD>: (
1893 molecule = $:molecule
1894 basis = $:basis
1895 coor = $..:coor
1896 psienv = $:psienv
1897 memory = 32000000
1898 reference<PsiCLHF>: (
1899 psienv = $:psienv
1900 molecule = $:molecule
1901 total_charge = 0
1902 multiplicity = 1
1903 basis = $:basis
1904 memory = 32000000
1905 )
1906 hessian<FinDispMolecularHessian>: (
1907 point_group<PointGroup>: symmetry = C2V
1908 checkpoint = no
1909 restart = no
1910 )
1911 )
1912 optimize = yes
1913 % optimizer object for the molecular geometry
1914 opt<QNewtonOpt>: (
1915 max_iterations = 20
1916 function = $..:mole
1917 update<BFGSUpdate>: ()
1918 convergence<MolEnergyConvergence>: (
1919 cartesian = yes
1920 energy = $..:..:mole
1921 )
1922 )
1923 % vibrational frequency input
1924 freq<MolecularFrequencies>: (
1925 point_group<PointGroup>: symmetry = C2V
1926 molecule = $:molecule
1927 )
1928 )
1930 Common Component Architecture (CCA) component wrappers, conforming to
1931 interfaces developed for the CCA Chemistry Component Toolkit, have been
1932 created to encapsulate some MPQC functionality. The following
1933 components are provided by MPQC:
1934 o MPQC.Chemistry_QC_ModelFactory
1935 o MPQC.ChemistryOpt_CoordinateModel
1936 o MPQC.IntegralEvaluatorFactory
1937 MPQC.Chemistry_QC_ModelFactory
1938 This is an implementation of the Chemistry.QC.ModelFactory interface.
1939 This factory produces model objects (implementing the
1940 Chemistry.QC.Model interface) based on the MPQC package. The MPQC model
1941 allows calculation of molecular energies and energy derivatives using a
1942 variety of methods.
1943 Provides Ports
1944 o Chemistry.QC.ModelFactory ModelFactory
1945 Uses Ports
1946 o Chemistry.QC.MoleculeFactory MoleculeFactory (required)
1947 Parameters
1948 o theory The method for determining the electronic structure. Defaults
1949 to HF.
1950 o HF Hartree-Fock method.
1952 o B3LYP Density Functional Theory (DFT) with B3LYP functional.
1953 o Use keyval input for other options.
1954 o basis The atomic orbital basis set. Defaults to STO-3G.
1955 o Any basis set defined in the MPQC package.
1957 o Use keyval input for mixed basis sets.
1958 o molecule_filename Path to the molecule file (see cca-chem-generic
1959 documentation for format). No default -- required.
1960 o keyval_filename Path to the keyval input file (see below). No default
1961 -- optional.
1962 Keyval Input
1963 The theory and basis parameters allow very basic calculations to be
1964 performed. More complex calculations will require the use of a keyval
1965 input file. The keyval file format is the same as that used to run MPQC
1966 stand-alone, and any valid MPQC options may be used. The molecular
1967 energy object must be named model. The user-supplied keyval cannot
1968 contain a molecule section; the molecule section will be automatically
1969 inserted by the ModelFactory using the required molecule_filename. This
1970 molecule section should be referred to as $:molecule.
1971 Example keyval input:
1972 model<CLHF>:(
1973 molecule=$:molecule
1974 basis<GaussianBasisSet>:(
1975 name = '6-31G'
1976 molecule = $:molecule
1977 )
1978 )
1979 MPQC.ChemistryOpt_CoordinateModel
1980 This is an implementation of the ChemistryOpt.CoordinateModel interface
1981 based on the MPQC package. It supports molecular structure optimization
1982 in cartesian, symmetrized internal, and redundant internal coordinates.
1983 Hessian approximation is supported.
1984 Provides Ports
1985 o ChemistryOpt.CoordinateModel CoordinateModel
1986 Uses Ports
1987 o Chemistry.QC.ModelFactory ModelFactory (required)
1988 o Chemistry.QC.ModelFactory BackupModelFactory (optional)
1989 o Chemistry.MoleculeViewer MoleculeViewer (optional)
1990 A backup model factory may be supplied. If an error is detected in the
1991 primary model, then a model obtained from the backup factory will be
1992 used. The molecule viewer is currently only used to communicate with
1993 the python viewer, in which case component instantiation and connection
1994 is handled automatically.
1995 Parameters
1996 o grad_rms RMS gradient convergence criteria. Defaults to 0.00030.
1997 o grad_max Max gradient convergence criteria. Defaults to 0.00045.
1998 o disp_rms RMS displacement convergence criteria. Defaults to 0.00120.
1999 o disp_max Max displacement convergence criteria. Defaults to 0.00180.
2000 o coordinate_type Optimization coordinate type. Defaults to
2001 symmetrized.
2002 o cartesian Cartesian coordinates.
2004 o symmetrized Symmetrized internal coordinates.
2005 o redundant Redundant internal coordinates.
2006 o multiple_guess_h Compute new guess Hessian at each call to
2007 guess_hessian_solve() (true) or use guess from first iteration only
2008 (false). Only meaningful in conjunction with solvers supporting use
2009 of dense guess Hessians with limited-memory methods. Defaults to
2010 true.
2011 o use_current_geom If multiple_guess_h is true, either use the current
2012 geometry (true) or the geometry at which the earliest correction pair
2013 used by the solver was determined (false) when computing the guess
2014 Hessian. Defaults to false.
2015 MPQC.IntegralEvaluatorFactory
2016 This is an implementation of the
2017 Chemistry.QC.GaussianBasis.IntegralEvaluatorFactory interface. This
2018 factory produces molecular integral evaluator objects based on the MPQC
2019 package. This code is experimental and does not currently support
2020 derivative integrals.
2021 Provides Ports
2022 o Chemistry.QC.GaussianBasis.IntegralEvaluatorFactory
2023 IntegralEvaluatorFactory
2024 Parameters
2025 o package Integral package, either intv3 or cints. Defaults to intv3.
2026 o integral_buffer Integral buffer type, either opaque or array. The
2027 opaque option uses pointers and is therefore higher performance. The
2028 array option may be used by components implemented in languages which
2029 are not pointer-aware.
2031 MPQC is open-source software; you can redistribute it and/or modify it
2032 under the terms of the GNU General Public License as published by the
2033 Free Software Foundation; either version 2 of the License, or (at your
2034 option) any later version.
2036 MPQC is distributed in the hope that it will be useful, but WITHOUT ANY
2037 WARRANTY; without even the implied warranty of MERCHANTABILITY or
2038 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
2039 for more details.
2040Version 2.3.1 Thu Dec 9 2010 mpqc(1)