1mpqc(1) MPQC mpqc(1)
2
3
4
6 mpqc - The Massively Parallel Quantum Chemistry program (MPQC) computes
7 the properties of molecules from first principles.
8
9 This documentation is divided into the following chapters:
10
11 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 <ul>
489
490 <li><tt>true</tt> and optimization is to be performed <br>
491
492 <tt>opt</tt> object will be checkpointed after each iteration.
493 The checkpoint file suffix is ".ckpt".
494
495 <li><tt>true</tt> and optimization is not performed <br>
496
497 <tt>mole</tt> object will be checkpointed at intermediate points.
498 The manner in which
499 <tt>mole</tt> will be checkpointed depends on its particular type.
500 The checkpoint file suffix is usually ".wfn", however
501 in general it will depend on the particular specialization of
502 <tt>MolecularEnergy</tt>.
503
504 </ul>
505
506 The default is to not checkpoint.
507 </dd>
508
509 checkpoint_freq
510 This specifies how often to checkpoint certain MolecularEnergy
511 specializations which compute iteratively. Currently, mole objects
512 of SCF type can use this keyword. The default is 1, which means to
513 checkpoint after every iteration.
514 savestate
515 The value of this keyword is boolean. If true, then the states of
516 the Optimize and MolecularEnergy objects will be saved after the
517 calculation completes. The output file suffixes are '.ckpt' and
518 '.wfn', respectively. The default is to save state.
519 restart
520 The value of this keyword is boolean. If true, mpqc will attempt to
521 restart the calculation. If the checkpoint file is not found, the
522 calculation will continue as if the value were false. The default
523 is true.
524 restart_file
525 This gives the name of a file from which restart information is
526 read. If the file name ends with '.wfn' then MPQC will try to
527 restore a MolecularEnergy object from it and query for the opt
528 object in the input file. If the file name ends with '.ckpt' MPQC
529 will try to restore an Optimize object from this file. The default
530 file name is formed by appending '.ckpt' to the input file name
531 with the extension removed.
532 do_energy
533 The value of this keyword is boolean. If true a single point energy
534 calculation will be done for the MolecularEnergy object given with
535 the mole keyword. The default is true.
536 do_gradient
537 The value of this keyword is boolean. If true a single point
538 gradient calculation will be done for the MolecularEnergy object
539 given with the mole keyword. The default is false.
540 do_cca
541 The value of this keywork is boolean. If true the cca embedded
542 framework will be initialized. The default is false.
543 cca_path
544 The value of this keyword is a string that provides a colon-
545 separated list of directories in which CCA component libraries may
546 be found.
547 cca_load
548 The value of this keyword is a string that provides a colon-
549 separated list of sidl class names for CCA components which will be
550 instantiated from the libraries found in the path given by
551 cca_path.
552 optimize
553 The value of this keyword is boolean. If true and the opt keyword
554 was set to a valid value, then an optimization will be performed.
555 The default is true.
556 write_pdb
557 The value of this keyword is boolean. If true a PDB file with the
558 molecular coordinates will be written.
559 filename
560 The value of this keyword is a string that gives a name from which
561 checkpoint and other filenames are constructed. The default is the
562 basename of the input file.
563 print_timings
564 If this is true, timing information is printed at the end of the
565 run. The default is true.
566 There are also some utility keywords that tell mpqc some technical
567 details about how to do the calculation:
568 debug
569 This optional keyword gives a Debugger object which can be used to
570 help find the problem if MPQC encounters a catastrophic error.
571 matrixkit
572 This optional keyword gives a SCMatrixKit specialization which is
573 used to produce matrices of the desired type. The default is a
574 ReplSCMatrixKit which replicates matrices on all of the nodes.
575 Other choices are not thoroughly tested.
576 A Walk-Through of an Object-Oriented Input File
577 This example input does a Hartree-Fock calculation on water. Following
578 is the entire input, followed by a breakdown with descriptions.
579 % This input does a Hartree-Fock calculation on water.
580 molecule<Molecule>: (
581 symmetry = C2V
582 unit = angstrom
583 { atoms geometry } = {
584 O [ 0.00000000 0.00000000 0.37000000 ]
585 H [ 0.78000000 0.00000000 -0.18000000 ]
586 H [ -0.78000000 0.00000000 -0.18000000 ]
587 }
588 )
589 basis<GaussianBasisSet>: (
590 name = 'STO-3G'
591 molecule = $:molecule
592 )
593 mpqc: (
594 mole<CLHF>: (
595 molecule = $:molecule
596 basis = $:basis
597 )
598 )
599 We start with a descriptive comment. Comments begin with a %.
600 Everything from the % to the end of the line is ignored.
601 % This input does a Hartree-Fock calculation on water.
602 Now lets set up a Molecule object. The name of the object comes first,
603 it is molecule. Then, in angle brackets, comes the type of the
604 molecule, which is the class Molecule. The keyword and class name are
605 followed by a : and then several pieces of input grouped between a pair
606 of matching parentheses. These parentheses contain the information that
607 will be given to Molecule KeyVal constructor.
608 molecule<Molecule>: (
609 The point group of the molecule is needed. This is done by assigning
610 symmetry to a case insensitive Schoenflies symbol that is used to
611 initialize a PointGroup object. An Abelian point group should be used.
612 symmetry = C2V
613 The default unit for the Cartesian coordinates is Bohr. You can specify
614 other units by assigned unit to a string that will be used to
615 initialize a Units object.
616 unit = angstrom
617 Finally, the atoms and coordinates are given. This can be given in the
618 shorthand table syntax shown below. The headings of the table are the
619 keywords between the first pair of brackets. These are followed by an =
620 and another pair of brackets that contain the data. The first datum is
621 assigned to the first element of the array that corresponds to the
622 first heading, atom. The second datum is assigned to the first element
623 of the array associated with the second heading, geometry, and so on.
624 Here the second datum is actually a vector: the x, y and z coordinates
625 of the first atom.
626 { atoms geometry } = {
627 O [ 0.00000000 0.00000000 0.37000000 ]
628 H [ 0.78000000 0.00000000 -0.18000000 ]
629 H [ -0.78000000 0.00000000 -0.18000000 ]
630 }
631 )
632 Next, a basis set object is given.
633 basis<GaussianBasisSet>: (
634 name = 'STO-3G'
635 molecule = $:molecule
636 )
637 Now we will give the main body of input. All the subsequent keywords
638 will be grouped in the mpqc section of the input (that is, each keyword
639 will be prefixed with mpqc:).
640 mpqc: (
641 Next we give the mole keyword which provides a specialization of the
642 MolecularEnergy class. In this case we will do a closed-shell Hartree-
643 Fock calculation. That is done with an object of type CLHF. The
644 keywords that CLHF accepts are given with the documentation for the
645 CLHF class, usually in the description of the const RefKeyVal&
646 constructor for the class. Also with the CLHF documentation is a list
647 of parent classes. Each of the parent classes may also have input. This
648 input is included with the rest of the input for the child class.
649 mole<CLHF>: (
650 The next line specifies the molecule to be used. There are two things
651 to note, first that this is actually a reference to complete molecule
652 specification elsewhere in the input file. The $ indicates that this is
653 a reference and the keyword following the $ is the actual location of
654 the molecule. The : in front of the keyword means that the keyword is
655 not relative to the current location in the input, but rather relative
656 to the root of the tree of keywords. Thus, this line grabs the molecule
657 that was specified above. The molecule object could have been placed
658 here, but frequently it is necessary that several objects refer to the
659 exact same object and this can only be done using references.
660 The second point is that if you look at the documentation for CLHF, you
661 will see that it doesn't read molecule keyword. However, if you follow
662 its parent classes up to MolecularEnergy, you'll find that molecule is
663 indeed read.
664 molecule = $:molecule
665 Just as we gave molecule, specify the basis set with the basis keyword
666 as follows:
667 basis = $:basis
668 Now we close off the parentheses we opened above and we are finished.
669 )
670 )
671 Sample Object-Oriented Input Files
672 The easiest way to get started with mpqc is to start with one of sample
673 inputs that most nearly matches your problem. The src/bin/mpqc/samples
674 contains all of the sample inputs below:
675 o Hartree-Fock Energy
676 o MP2 Energy
677 o MP2-R12 energy
678 o Hartree-Fock Optimization
679 o Optimization with a Computed Guess Hessian
680 o Optimization Using Newton's Method
681 o Hartree-Fock Frequencies
682 o Giving Coordinates and a Guess Hessian
683 o Optimization with a Hydrogen Bond
684 o Fixed Coordinate Optimization
685 o Transition State Optimization
686 o Transition State Optimization with a Computed Guess Hessian
687 o Hartree-Fock energy with intermediate checkpointing
688 o MP2-R12 energy with intermediate checkpointing
689 o HF gradient computed from a previously computed HF wave funtion
690 o MP2 Energy computed using precomputed Hartree-Fock wave function
691 o CLHF energy using a CCA integrals component
692 Hartree-Fock Energy
693 The following input will compute the Hartree-Fock energy of water.
694 % emacs should use -*- KeyVal -*- mode
695 % molecule specification
696 molecule<Molecule>: (
697 symmetry = C2V
698 unit = angstrom
699 { atoms geometry } = {
700 O [ 0.00000000 0.00000000 0.37000000 ]
701 H [ 0.78000000 0.00000000 -0.18000000 ]
702 H [ -0.78000000 0.00000000 -0.18000000 ]
703 }
704 )
705 % basis set specification
706 basis<GaussianBasisSet>: (
707 name = 'STO-3G'
708 molecule = $:molecule
709 )
710 mpqc: (
711 checkpoint = no
712 savestate = no
713 % method for computing the molecule's energy
714 mole<CLHF>: (
715 molecule = $:molecule
716 basis = $:basis
717 memory = 16000000
718 )
719 )
720 MP2 Energy
721 The following input will compute the MP2 energy of water.
722 % emacs should use -*- KeyVal -*- mode
723 % molecule specification
724 molecule<Molecule>: (
725 symmetry = C2V
726 unit = angstrom
727 { atoms geometry } = {
728 O [ 0.00000000 0.00000000 0.37000000 ]
729 H [ 0.78000000 0.00000000 -0.18000000 ]
730 H [ -0.78000000 0.00000000 -0.18000000 ]
731 }
732 )
733 % basis set specification
734 basis<GaussianBasisSet>: (
735 name = 'STO-3G'
736 molecule = $:molecule
737 )
738 mpqc: (
739 checkpoint = no
740 savestate = no
741 % method for computing the molecule's energy
742 mole<MBPT2>: (
743 molecule = $:molecule
744 basis = $:basis
745 memory = 16000000
746 % reference wavefunction
747 reference<CLHF>: (
748 molecule = $:molecule
749 basis = $:basis
750 memory = 16000000
751 )
752 )
753 )
754 MP2-R12 energy
755 The following will compute the MP2-R12 energy of water in standard
756 approximation A' (MP2-R12/A').
757 % emacs should use -*- KeyVal -*- mode
758 % molecule specification
759 molecule<Molecule>: (
760 symmetry = C2V
761 unit = angstrom
762 { atoms geometry } = {
763 O [ 0.00000000 0.00000000 0.37000000 ]
764 H [ 0.78000000 0.00000000 -0.18000000 ]
765 H [ -0.78000000 0.00000000 -0.18000000 ]
766 }
767 )
768 % basis set specification
769 basis<GaussianBasisSet>: (
770 name = 'cc-pVDZ'
771 molecule = $:molecule
772 )
773 % auxiliary basis set specification
774 abasis<GaussianBasisSet>: (
775 name = 'aug-cc-pVDZ'
776 molecule = $:molecule
777 )
778 mpqc: (
779 checkpoint = no
780 savestate = no
781 % method for computing the molecule's energy
782 mole<MBPT2_R12>: (
783 molecule = $:molecule
784 basis = $:basis
785 aux_basis = $:abasis
786 stdapprox = 'A''
787 nfzc = 1
788 memory = 16000000
789 integrals<IntegralCints>:()
790 % reference wavefunction
791 reference<CLHF>: (
792 molecule = $:molecule
793 basis = $:basis
794 memory = 16000000
795 integrals<IntegralCints>:()
796 )
797 )
798 )
799 Hartree-Fock Optimization
800 The following input will optimize the geometry of water using the
801 quasi-Newton method.
802 % emacs should use -*- KeyVal -*- mode
803 % molecule specification
804 molecule<Molecule>: (
805 symmetry = C2V
806 unit = angstrom
807 { atoms geometry } = {
808 O [ 0.00000000 0.00000000 0.37000000 ]
809 H [ 0.78000000 0.00000000 -0.18000000 ]
810 H [ -0.78000000 0.00000000 -0.18000000 ]
811 }
812 )
813 % basis set specification
814 basis<GaussianBasisSet>: (
815 name = '6-31G*'
816 molecule = $:molecule
817 )
818 mpqc: (
819 checkpoint = no
820 savestate = no
821 % molecular coordinates for optimization
822 coor<SymmMolecularCoor>: (
823 molecule = $:molecule
824 generator<IntCoorGen>: (
825 molecule = $:molecule
826 )
827 )
828 % method for computing the molecule's energy
829 mole<CLHF>: (
830 molecule = $:molecule
831 basis = $:basis
832 coor = $..:coor
833 memory = 16000000
834 )
835 % optimizer object for the molecular geometry
836 opt<QNewtonOpt>: (
837 function = $..:mole
838 update<BFGSUpdate>: ()
839 convergence<MolEnergyConvergence>: (
840 cartesian = yes
841 energy = $..:..:mole
842 )
843 )
844 )
845 Optimization with a Computed Guess Hessian
846 The following input will optimize the geometry of water using the
847 quasi-Newton method. The guess Hessian will be computed at a lower
848 level of theory.
849 % emacs should use -*- KeyVal -*- mode
850 % molecule specification
851 molecule<Molecule>: (
852 symmetry = C2V
853 unit = angstrom
854 { atoms geometry } = {
855 O [ 0.00000000 0.00000000 0.37000000 ]
856 H [ 0.78000000 0.00000000 -0.18000000 ]
857 H [ -0.78000000 0.00000000 -0.18000000 ]
858 }
859 )
860 % basis set specification
861 basis<GaussianBasisSet>: (
862 name = '6-31G*'
863 molecule = $:molecule
864 )
865 mpqc: (
866 checkpoint = no
867 savestate = no
868 % molecular coordinates for optimization
869 coor<SymmMolecularCoor>: (
870 molecule = $:molecule
871 generator<IntCoorGen>: (
872 molecule = $:molecule
873 )
874 )
875 % method for computing the molecule's energy
876 mole<CLHF>: (
877 molecule = $:molecule
878 basis = $:basis
879 coor = $..:coor
880 memory = 16000000
881 guess_hessian<FinDispMolecularHessian>: (
882 molecule = $:molecule
883 only_totally_symmetric = yes
884 eliminate_cubic_terms = no
885 checkpoint = no
886 energy<CLHF>: (
887 molecule = $:molecule
888 memory = 16000000
889 basis<GaussianBasisSet>: (
890 name = '3-21G'
891 molecule = $:molecule
892 )
893 )
894 )
895 )
896 % optimizer object for the molecular geometry
897 opt<QNewtonOpt>: (
898 function = $..:mole
899 update<BFGSUpdate>: ()
900 convergence<MolEnergyConvergence>: (
901 cartesian = yes
902 energy = $..:..:mole
903 )
904 )
905 )
906 Optimization Using Newton's Method
907 The following input will optimize the geometry of water using the
908 Newton's method. The Hessian will be computed at each step in the
909 optimization. However, Hessian recomputation is usually not worth the
910 cost; try using the computed Hessian as a guess Hessian for a quasi-
911 Newton method before resorting to a Newton optimization.
912 % Emacs should use -*- KeyVal -*- mode
913 % molecule specification
914 molecule<Molecule>: (
915 symmetry = c2v
916 unit = angstrom
917 { atoms geometry } = {
918 O [ 0.00000000 0.00000000 0.36937294 ]
919 H [ 0.78397590 0.00000000 -0.18468647 ]
920 H [ -0.78397590 0.00000000 -0.18468647 ]
921 }
922 )
923 % basis set specification
924 basis<GaussianBasisSet>: (
925 name = '3-21G'
926 molecule = $:molecule
927 )
928 mpqc: (
929 checkpoint = no
930 savestate = no
931 restart = no
932 % molecular coordinates for optimization
933 coor<SymmMolecularCoor>: (
934 molecule = $:molecule
935 generator<IntCoorGen>: (
936 molecule = $:molecule
937 )
938 )
939 do_energy = no
940 do_gradient = no
941 % method for computing the molecule's energy
942 mole<CLHF>: (
943 molecule = $:molecule
944 basis = $:basis
945 memory = 16000000
946 coor = $..:coor
947 guess_wavefunction<CLHF>: (
948 molecule = $:molecule
949 total_charge = 0
950 basis<GaussianBasisSet>: (
951 molecule = $:molecule
952 name = 'STO-3G'
953 )
954 memory = 16000000
955 )
956 hessian<FinDispMolecularHessian>: (
957 only_totally_symmetric = yes
958 eliminate_cubic_terms = no
959 checkpoint = no
960 )
961 )
962 optimize = yes
963 % optimizer object for the molecular geometry
964 opt<NewtonOpt>: (
965 print_hessian = yes
966 max_iterations = 20
967 function = $..:mole
968 convergence<MolEnergyConvergence>: (
969 cartesian = yes
970 energy = $..:..:mole
971 )
972 )
973 )
974 Hartree-Fock Frequencies
975 The following input will compute Hartree-Fock frequencies by finite
976 displacements. A thermodynamic analysis will also be performed. If
977 optimization input is also provided, then the optimization will be run
978 first, then the frequencies.
979 % emacs should use -*- KeyVal -*- mode
980 % molecule specification
981 molecule<Molecule>: (
982 symmetry = C1
983 { atoms geometry } = {
984 O [ 0.0000000000 0.0000000000 0.8072934188 ]
985 H [ 1.4325589285 0.0000000000 -0.3941980761 ]
986 H [ -1.4325589285 0.0000000000 -0.3941980761 ]
987 }
988 )
989 % basis set specification
990 basis<GaussianBasisSet>: (
991 name = 'STO-3G'
992 molecule = $:molecule
993 )
994 mpqc: (
995 checkpoint = no
996 savestate = no
997 % method for computing the molecule's energy
998 mole<CLHF>: (
999 molecule = $:molecule
1000 basis = $:basis
1001 memory = 16000000
1002 )
1003 % vibrational frequency input
1004 freq<MolecularFrequencies>: (
1005 molecule = $:molecule
1006 )
1007 )
1008 Giving Coordinates and a Guess Hessian
1009 The following example shows several features that are really
1010 independent. The variable coordinates are explicitly given, rather than
1011 generated automatically. This is especially useful when a guess Hessian
1012 is to be provided, as it is here. This Hessian, as given by the user,
1013 is not complete and the QNewtonOpt object will fill in the missing
1014 values using a guess the Hessian provided by the MolecularEnergy
1015 object. Also, fixed coordinates are given in this sample input.
1016 % emacs should use -*- KeyVal -*- mode
1017 % molecule specification
1018 molecule<Molecule>: (
1019 symmetry = C1
1020 { atoms geometry } = {
1021 H [ 0.088 2.006 1.438 ]
1022 O [ 0.123 3.193 0.000 ]
1023 H [ 0.088 2.006 -1.438 ]
1024 O [ 4.502 5.955 -0.000 ]
1025 H [ 2.917 4.963 -0.000 ]
1026 H [ 3.812 7.691 -0.000 ]
1027 }
1028 )
1029 % basis set specification
1030 basis<GaussianBasisSet>: (
1031 name = 'STO-3G'
1032 molecule = $:molecule
1033 )
1034 mpqc: (
1035 checkpoint = no
1036 savestate = no
1037 % method for computing the molecule's energy
1038 mole<CLHF>: (
1039 molecule = $:molecule
1040 basis = $:basis
1041 coor = $..:coor
1042 memory = 16000000
1043 )
1044 % molecular coordinates for optimization
1045 coor<SymmMolecularCoor>: (
1046 molecule = $:molecule
1047 generator<IntCoorGen>: (
1048 molecule = $:molecule
1049 extra_bonds = [ 2 5 ]
1050 )
1051 % use these instead of generated coordinates
1052 variable<SetIntCoor>: [
1053 <StreSimpleCo>:( atoms = [ 2 5 ] )
1054 <BendSimpleCo>:( atoms = [ 2 5 4 ] )
1055 <OutSimpleCo>: ( atoms = [ 5 2 1 3 ] )
1056 <SumIntCoor>: (
1057 coor: [
1058 <StreSimpleCo>:( atoms = [ 1 2 ] )
1059 <StreSimpleCo>:( atoms = [ 2 3 ] )
1060 ]
1061 coef = [ 1.0 1.0 ]
1062 )
1063 <SumIntCoor>: (
1064 coor: [
1065 <StreSimpleCo>:( atoms = [ 4 5 ] )
1066 <StreSimpleCo>:( atoms = [ 4 6 ] )
1067 ]
1068 coef = [ 1.0 1.0 ]
1069 )
1070 <BendSimpleCo>:( atoms = [ 1 2 3 ] )
1071 <BendSimpleCo>:( atoms = [ 5 4 6 ] )
1072 ]
1073 % these are fixed by symmetry anyway,
1074 fixed<SetIntCoor>: [
1075 <SumIntCoor>: (
1076 coor: [
1077 <StreSimpleCo>:( atoms = [ 1 2 ] )
1078 <StreSimpleCo>:( atoms = [ 2 3 ] )
1079 ]
1080 coef = [ 1.0 -1.0 ]
1081 )
1082 <SumIntCoor>: (
1083 coor: [
1084 <StreSimpleCo>:( atoms = [ 4 5 ] )
1085 <StreSimpleCo>:( atoms = [ 4 6 ] )
1086 ]
1087 coef = [ 1.0 -1.0 ]
1088 )
1089 <TorsSimpleCo>:( atoms = [ 2 5 4 6] )
1090 <OutSimpleCo>:( atoms = [ 3 2 6 4 ] )
1091 <OutSimpleCo>:( atoms = [ 1 2 6 4 ] )
1092 ]
1093 )
1094 % optimizer object for the molecular geometry
1095 opt<QNewtonOpt>: (
1096 function = $..:mole
1097 update<BFGSUpdate>: ()
1098 convergence<MolEnergyConvergence>: (
1099 cartesian = yes
1100 energy = $..:..:mole
1101 )
1102 % give a partial guess hessian in internal coordinates
1103 % the missing elements will be filled in automatically
1104 hessian = [
1105 [ 0.0109261670 ]
1106 [ -0.0004214845 0.0102746106 ]
1107 [ -0.0008600592 0.0030051330 0.0043149957 ]
1108 [ 0.0 0.0 0.0 ]
1109 [ 0.0 0.0 0.0 ]
1110 [ 0.0 0.0 0.0 ]
1111 [ 0.0 0.0 0.0 ]
1112 ]
1113 )
1114 )
1115 Optimization with a Hydrogen Bond
1116 The automatic internal coordinate generator will fail if it cannot find
1117 enough redundant internal coordinates. In this case, the internal
1118 coordinate generator must be explicitly created in the input and given
1119 extra connectivity information, as is shown below.
1120 % emacs should use -*- KeyVal -*- mode
1121 % molecule specification
1122 molecule<Molecule>: (
1123 symmetry = C1
1124 { atoms geometry } = {
1125 H [ 0.088 2.006 1.438 ]
1126 O [ 0.123 3.193 0.000 ]
1127 H [ 0.088 2.006 -1.438 ]
1128 O [ 4.502 5.955 -0.000 ]
1129 H [ 2.917 4.963 -0.000 ]
1130 H [ 3.812 7.691 -0.000 ]
1131 }
1132 )
1133 % basis set specification
1134 basis<GaussianBasisSet>: (
1135 name = 'STO-3G'
1136 molecule = $:molecule
1137 )
1138 mpqc: (
1139 checkpoint = no
1140 savestate = no
1141 % method for computing the molecule's energy
1142 mole<CLHF>: (
1143 molecule = $:molecule
1144 basis = $:basis
1145 coor = $..:coor
1146 memory = 16000000
1147 )
1148 % molecular coordinates for optimization
1149 coor<SymmMolecularCoor>: (
1150 molecule = $:molecule
1151 % give an internal coordinate generator that knows about the
1152 % hydrogen bond between atoms 2 and 5
1153 generator<IntCoorGen>: (
1154 molecule = $:molecule
1155 extra_bonds = [ 2 5 ]
1156 )
1157 )
1158 % optimizer object for the molecular geometry
1159 opt<QNewtonOpt>: (
1160 function = $..:mole
1161 update<BFGSUpdate>: ()
1162 convergence<MolEnergyConvergence>: (
1163 cartesian = yes
1164 energy = $..:..:mole
1165 )
1166 )
1167 )
1168 Fixed Coordinate Optimization
1169 This example shows how to selectively fix internal coordinates in an
1170 optimization. Any number of linearly independent coordinates can be
1171 given. These coordinates must remain linearly independent throughout
1172 the optimization, a condition that might not hold since the coordinates
1173 can be nonlinear.
1174 By default, the initial fixed coordinates' values are taken from the
1175 cartesian geometry given by the Molecule object; however, the molecule
1176 will be displaced to the internal coordinate values given with the
1177 fixed internal coordinates if have_fixed_values keyword is set to true,
1178 as shown in this example. In this case, the initial cartesian geometry
1179 should be reasonably close to the desired initial geometry and all of
1180 the variable coordinates will be frozen to their original values during
1181 the initial displacement.
1182 % emacs should use -*- KeyVal -*- mode
1183 % molecule specification
1184 molecule<Molecule>: (
1185 symmetry = CS
1186 { atoms geometry } = {
1187 H [ 3.04 -0.69 -1.59 ]
1188 H [ 3.04 -0.69 1.59 ]
1189 N [ 2.09 -0.48 -0.00 ]
1190 C [ -0.58 -0.15 0.00 ]
1191 H [ -1.17 1.82 0.00 ]
1192 H [ -1.41 -1.04 -1.64 ]
1193 H [ -1.41 -1.04 1.64 ]
1194 }
1195 )
1196 % basis set specification
1197 basis<GaussianBasisSet>: (
1198 name = '3-21G*'
1199 molecule = $:molecule
1200 )
1201 mpqc: (
1202 checkpoint = no
1203 savestate = no
1204 % molecular coordinates for optimization
1205 coor<SymmMolecularCoor>: (
1206 molecule = $:molecule
1207 generator<IntCoorGen>: (
1208 molecule = $:molecule
1209 )
1210 have_fixed_values = yes
1211 fixed<SetIntCoor>: [
1212 <OutSimpleCo>: ( value = -0.1
1213 label = 'N-inversion'
1214 atoms = [4 3 2 1] )
1215 ]
1216 )
1217 % method for computing the molecule's energy
1218 mole<CLHF>: (
1219 molecule = $:molecule
1220 basis = $:basis
1221 coor = $..:coor
1222 memory = 16000000
1223 )
1224 % optimizer object for the molecular geometry
1225 opt<QNewtonOpt>: (
1226 max_iterations = 20
1227 function = $..:mole
1228 update<BFGSUpdate>: ()
1229 convergence<MolEnergyConvergence>: (
1230 cartesian = yes
1231 energy = $..:..:mole
1232 )
1233 )
1234 )
1235 Transition State Optimization
1236 This example shows a transition state optimization of the N-inversion
1237 in $thrm{CH}_3thrm{NH}_2$ using mode following. The initial geometry
1238 was obtained by doing a few fixed coordinate optimizations along the
1239 inversion coordinate.
1240 % emacs should use -*- KeyVal -*- mode
1241 % molecule specification
1242 molecule<Molecule>: (
1243 symmetry = CS
1244 { atoms geometry } = {
1245 H [ 3.045436 -0.697438 -1.596748 ]
1246 H [ 3.045436 -0.697438 1.596748 ]
1247 N [ 2.098157 -0.482779 -0.000000 ]
1248 C [ -0.582616 -0.151798 0.000000 ]
1249 H [ -1.171620 1.822306 0.000000 ]
1250 H [ -1.417337 -1.042238 -1.647529 ]
1251 H [ -1.417337 -1.042238 1.647529 ]
1252 }
1253 )
1254 % basis set specification
1255 basis<GaussianBasisSet>: (
1256 name = '3-21G*'
1257 molecule = $:molecule
1258 )
1259 mpqc: (
1260 checkpoint = no
1261 savestate = no
1262 % molecular coordinates for optimization
1263 coor<SymmMolecularCoor>: (
1264 molecule = $:molecule
1265 generator<IntCoorGen>: (
1266 molecule = $:molecule
1267 )
1268 followed<OutSimpleCo> = [ 'N-inversion' 4 3 2 1 ]
1269 )
1270 % method for computing the molecule's energy
1271 mole<CLHF>: (
1272 molecule = $:molecule
1273 basis = $:basis
1274 coor = $..:coor
1275 memory = 16000000
1276 )
1277 % optimizer object for the molecular geometry
1278 opt<EFCOpt>: (
1279 transition_state = yes
1280 mode_following = yes
1281 max_iterations = 20
1282 function = $..:mole
1283 update<PowellUpdate>: ()
1284 convergence<MolEnergyConvergence>: (
1285 cartesian = yes
1286 energy = $..:..:mole
1287 )
1288 )
1289 )
1290 Transition State Optimization with a Computed Guess Hessian
1291 This example shows a transition state optimization of the N-inversion
1292 in $thrm{CH}_3thrm{NH}_2$ using mode following. The initial geometry
1293 was obtained by doing a few fixed coordinate optimizations along the
1294 inversion coordinate. An approximate guess Hessian will be computed,
1295 which makes the optimiziation converge much faster in this case.
1296 % emacs should use -*- KeyVal -*- mode
1297 % molecule specification
1298 molecule<Molecule>: (
1299 symmetry = CS
1300 { atoms geometry } = {
1301 H [ 3.045436 -0.697438 -1.596748 ]
1302 H [ 3.045436 -0.697438 1.596748 ]
1303 N [ 2.098157 -0.482779 -0.000000 ]
1304 C [ -0.582616 -0.151798 0.000000 ]
1305 H [ -1.171620 1.822306 0.000000 ]
1306 H [ -1.417337 -1.042238 -1.647529 ]
1307 H [ -1.417337 -1.042238 1.647529 ]
1308 }
1309 )
1310 % basis set specification
1311 basis<GaussianBasisSet>: (
1312 name = '3-21G*'
1313 molecule = $:molecule
1314 )
1315 mpqc: (
1316 checkpoint = no
1317 savestate = no
1318 % molecular coordinates for optimization
1319 coor<SymmMolecularCoor>: (
1320 molecule = $:molecule
1321 generator<IntCoorGen>: (
1322 molecule = $:molecule
1323 )
1324 followed<OutSimpleCo> = [ 'N-inversion' 4 3 2 1 ]
1325 )
1326 % method for computing the molecule's energy
1327 mole<CLHF>: (
1328 molecule = $:molecule
1329 basis = $:basis
1330 coor = $..:coor
1331 memory = 16000000
1332 guess_hessian<FinDispMolecularHessian>: (
1333 molecule = $:molecule
1334 only_totally_symmetric = yes
1335 eliminate_cubic_terms = no
1336 checkpoint = no
1337 energy<CLHF>: (
1338 molecule = $:molecule
1339 memory = 16000000
1340 basis<GaussianBasisSet>: (
1341 name = '3-21G'
1342 molecule = $:molecule
1343 )
1344 )
1345 )
1346 )
1347 % optimizer object for the molecular geometry
1348 opt<EFCOpt>: (
1349 transition_state = yes
1350 mode_following = yes
1351 max_iterations = 20
1352 function = $..:mole
1353 update<PowellUpdate>: ()
1354 convergence<MolEnergyConvergence>: (
1355 cartesian = yes
1356 energy = $..:..:mole
1357 )
1358 )
1359 )
1360 Hartree-Fock energy with intermediate checkpointing
1361 The following two sections demonstrate how MPQC can be used to save the
1362 mole object periodically. This input will compute the Hartree-Fock
1363 energy of water while saving the mole object every 3 iterations.
1364 % emacs should use -*- KeyVal -*- mode
1365 % molecule specification
1366 molecule<Molecule>: (
1367 symmetry = C2V
1368 unit = angstrom
1369 { atoms geometry } = {
1370 O [ 0.00000000 0.00000000 0.37000000 ]
1371 H [ 0.78000000 0.00000000 -0.18000000 ]
1372 H [ -0.78000000 0.00000000 -0.18000000 ]
1373 }
1374 )
1375 % basis set specification
1376 basis<GaussianBasisSet>: (
1377 name = 'STO-3G'
1378 molecule = $:molecule
1379 )
1380 mpqc: (
1381 checkpoint = yes
1382 filename = 'h2o-rhf-STO3G'
1383 checkpoint_freq = 3
1384 savestate = no
1385 % method for computing the molecule's energy
1386 mole<CLHF>: (
1387 molecule = $:molecule
1388 basis = $:basis
1389 memory = 16000000
1390 )
1391 )
1392 The mole object will be saved to files named 'h2o-rhf-
1393 STO3G.wfn.<iter#>.tmp' where <iter#> is the SCF iteration number (3, 6,
1394 etc.). Only the most recent file is kept, files from previous
1395 iterations are removed automatically. Keyword filename here is used to
1396 set the default file name prefix.
1397 MP2-R12 energy with intermediate checkpointing
1398 The following input will compute the MP2-R12 energy of water in
1399 standard approximation A' (MP2-R12/A') while saving the mole object at
1400 intermediate checkpoints.
1401 % emacs should use -*- KeyVal -*- mode
1402 % molecule specification
1403 molecule<Molecule>: (
1404 symmetry = C2V
1405 unit = angstrom
1406 { atoms geometry } = {
1407 O [ 0.00000000 0.00000000 0.37000000 ]
1408 H [ 0.78000000 0.00000000 -0.18000000 ]
1409 H [ -0.78000000 0.00000000 -0.18000000 ]
1410 }
1411 )
1412 % basis set specification
1413 basis<GaussianBasisSet>: (
1414 name = 'cc-pVDZ'
1415 molecule = $:molecule
1416 )
1417 % auxiliary basis set specification
1418 abasis<GaussianBasisSet>: (
1419 name = 'aug-cc-pVDZ'
1420 molecule = $:molecule
1421 )
1422 mpqc: (
1423 checkpoint = yes
1424 filename = 'h2o-mp2r12ap-vdz-avdz'
1425 savestate = no
1426 % method for computing the molecule's energy
1427 mole<MBPT2_R12>: (
1428 molecule = $:molecule
1429 basis = $:basis
1430 aux_basis = $:abasis
1431 stdapprox = 'A''
1432 nfzc = 1
1433 memory = 16000000
1434 integrals<IntegralCints>:()
1435 % reference wavefunction
1436 reference<CLHF>: (
1437 molecule = $:molecule
1438 basis = $:basis
1439 memory = 16000000
1440 integrals<IntegralCints>:()
1441 )
1442 )
1443 )
1444 The mole object will be saved to a file named h2o-mp2r12ap-vdz-
1445 avdz.wfn". Keyword filename here is used to set the default file name
1446 prefix. Objects of the MBPT2_R12 type are checkpointed after the HF
1447 procedure, after the first integrals (SBS) transformation, and after
1448 the optional second (ABS) transformation.
1449 HF gradient computed from a previously computed HF wave funtion
1450 The following will illustrate how to reuse previously computed
1451 MolecularEnergy objects in subsequent computations. The first input
1452 computes Hartree-Fock energy for water and saves the mole object to
1453 file h2o-rhf-sto3g.wfn.
1454 % emacs should use -*- KeyVal -*- mode
1455 % molecule specification
1456 molecule<Molecule>: (
1457 symmetry = C2V
1458 unit = angstrom
1459 { atoms geometry } = {
1460 O [ 0.00000000 0.00000000 0.37000000 ]
1461 H [ 0.78000000 0.00000000 -0.18000000 ]
1462 H [ -0.78000000 0.00000000 -0.18000000 ]
1463 }
1464 )
1465 % basis set specification
1466 basis<GaussianBasisSet>: (
1467 name = 'STO-3G'
1468 molecule = $:molecule
1469 )
1470 mpqc: (
1471 checkpoint = no
1472 savestate = yes
1473 filename = 'h2o-rhf-sto3g'
1474 % method for computing the molecule's energy
1475 mole<CLHF>: (
1476 molecule = $:molecule
1477 basis = $:basis
1478 memory = 16000000
1479 )
1480 )
1481 The second input reuses the mole object from the previous run to
1482 compute the gradient of the Hartree-Fock energy.
1483 % emacs should use -*- KeyVal -*- mode
1484 mpqc: (
1485 checkpoint = no
1486 savestate = no
1487 restart = yes
1488 restart_file = 'h2o-rhf-sto3g.wfn'
1489 do_gradient = yes
1490 )
1491 MP2 Energy computed using precomputed Hartree-Fock wave function
1492 The following input will compute the MP2 energy of water using a saved
1493 Hartree-Fock wave function obtained using the first input from HF
1494 gradient computed from a previously computed HF wave funtion.
1495 % emacs should use -*- KeyVal -*- mode
1496 % molecule specification
1497 molecule<Molecule>: (
1498 symmetry = C2V
1499 unit = angstrom
1500 { atoms geometry } = {
1501 O [ 0.00000000 0.00000000 0.37000000 ]
1502 H [ 0.78000000 0.00000000 -0.18000000 ]
1503 H [ -0.78000000 0.00000000 -0.18000000 ]
1504 }
1505 )
1506 % basis set specification
1507 basis<GaussianBasisSet>: (
1508 name = 'STO-3G'
1509 molecule = $:molecule
1510 )
1511 % wave function file object specification
1512 wfnfile<BcastStateInBin>:file = 'h2o-rhf-sto3g.wfn'
1513 mpqc: (
1514 checkpoint = no
1515 savestate = no
1516 % method for computing the molecule's energy
1517 mole<MBPT2>: (
1518 molecule = $:molecule
1519 basis = $:basis
1520 memory = 16000000
1521 % reference wavefunction
1522 reference<SavableStateProxy>: (
1523 statein = $:wfnfile
1524 object = 'CLHF'
1525 )
1526 )
1527 )
1528 Note that now object reference is of type SavableStateProxy, rather
1529 than CLHF. SavableStateProxy is a special object type that can be
1530 converted at runtime into the desired type (in this case, CLHF, as
1531 indicated by object).
1532 CLHF energy using a CCA integrals component
1533 The following input will compute the CLHF energy of water using a CCA
1534 integrals component via the IntegralCCA adaptor class.
1535 % emacs should use -*- KeyVal -*- mode
1536 % molecule specification
1537 molecule<Molecule>: (
1538 symmetry = C2V
1539 unit = angstrom
1540 { atoms geometry } = {
1541 O [ 0.00000000 0.00000000 0.37000000 ]
1542 H [ 0.78000000 0.00000000 -0.18000000 ]
1543 H [ -0.78000000 0.00000000 -0.18000000 ]
1544 }
1545 )
1546 % basis set specification
1547 basis<GaussianBasisSet>: (
1548 name = 'STO-3G'
1549 molecule = $:molecule
1550 )
1551 mpqc: (
1552 % path to component libraries
1553 cca_path = /usr/local/lib/cca
1554 % sidl class names of components which will be instantiated
1555 cca_load = MPQC.IntegralEvaluatorFactory
1556 do_cca = yes
1557 checkpoint = no
1558 savestate = no
1559 % method for computing the molecule's energy
1560 mole<CLHF>: (
1561 molecule = $:molecule
1562 basis = $:basis
1563 % cca integrals adaptor class
1564 integrals<IntegralCCA>: (
1565 molecule = $:molecule
1566 % integral buffer type
1567 integral_buffer = opaque
1568 % integral package
1569 integral_package = intv3
1570 % factory component sidl class name
1571 evaluator_factory = MPQC.IntegralEvaluatorFactory
1572 )
1573 )
1574 )
1576 After you compile MPQC, you should run the validation suite. You should
1577 also run the validation suite if you upgrade your operating system
1578 software, since this could change shared libraries that are linking
1579 with MPQC and could affect the results. Note that the reference
1580 validation suite has not been verified relative to an independent code,
1581 except for a few spot checks. If you find that MPQC doesn't produce the
1582 same answer as another quantum chemistry program that you trust, then
1583 please promptly notify us and send all the details.
1584 The top-level Makefile has several targets that can be used to check an
1585 MPQC build. MPQC must be built before one of these targets is used:
1586 check
1587 The same as check0 below. This is only available from the top-level
1588 directory and src/bin/mpqc/validate.
1589 check0
1590 Run the smallest MPQC verification suite. It tests basic
1591 functionality. This is only available from the top-level directory
1592 and src/bin/mpqc/validate.
1593 check1
1594 Run the intermediate MPQC verification suite. It runs most of the
1595 tests, only leaving out very expensive runs. This is only available
1596 from the top-level directory and src/bin/mpqc/validate.
1597 check2
1598 Run the complete MPQC verification suite. Depending on the
1599 compilation and runtime environment, tests that are not expected to
1600 work will be omitted. This is only available from the top-level
1601 directory and src/bin/mpqc/validate.
1602 check_clean
1603 Remove MPQC verification suite output files. This is only available
1604 from the top-level directory and src/bin/mpqc/validate.
1605 testbuild
1606 Verify that a variety of small test programs compile. If static
1607 libraries are used, this will require a substantial amount of disk
1608 space.
1609 testrun
1610 Run a variety of small test programs. This will build them if
1611 necessary.
1612 The check targets will run mpqc with the mpqcrun (see mpqcrun) command.
1613 You can give arguments to mpqcrun by setting the MPQCRUN_ARGS variable
1614 on the make command line.
1615 The verification suite is in src/bin/mpqc/validate. After running it,
1616 the output files can be found in src/bin/mpqc/validate/run. The check
1617 targets will compare outputs that your build produced to the reference
1618 files in src/bin/mpqc/validate/ref. The input files can be found with
1619 the reference files. For each comparison, first the status (ok,
1620 missing, or failed) for each file is printed. If both statuses are ok
1621 then an E: is printed followed by the number of digits to which the
1622 energies agree. If they agree to all digits 99 is printed. If a
1623 gradient was computed, then Grad: is printed followed by the number of
1624 digits to which the gradients in least agreement agree. Other
1625 properties checked in this way include frequencies, diagnostics, and
1626 populations.
1627 If two numbers do not agree to the expected accuracy, then an asterisk,
1628 *, is printed after the number of digits in agreement.
1629 Finally, you can do a detailed comparison of the contents of the ref
1630 and run subdirectories by typing make diff.
1631 The input files in the verification suite are divided into several
1632 categories:
1633 h2o
1634 These are simple tests that exercise many of MPQC's features.
1635 h2omp2
1636 Tests that further exercise MP2.
1637 h2ofrq
1638 Tests of H2 O frequencies with a variety of methods.
1639 mbpt
1640 These tests exercise MP2 as well as the open-shell perturbation
1641 theory methods. The various available algorithms are tested as
1642 well.
1643 ckpt
1644 Tests the checkpoint and restart capabilities.
1645 symm1
1646 Tests of point group symmetry.
1647 symm2
1648 More point group symmetry tests. These use basis sets with higher
1649 angular momentum than #symm1#.
1650 symm3
1651 Tests automatic point group determination.
1652 basis1
1653 A variety of basis sets are tested for first row atoms along with
1654 hydrogen and helium.
1655 basis2
1656 Basis sets test for second row atoms.
1657 methods
1658 Basic tests of several of MPQC's methods.
1659 clscf
1660 More tests of methods based on CLSCF.
1661 hsosscf
1662 More tests of methods based on HSOSSCF.
1663 uscf
1664 More tests of methods based on UnrestrictedSCF.
1665 dft
1666 More tests of the CLKS method.
1667 mp2r12
1668 More tests of MP2-R12.
1669 ccaintv3
1670 Tests of embedded CCA integrals components using intv3.
1671 ccacints
1672 Tests of embedded CCA integrals components using cints.
1674 Psi 3 is a suite of ab initio codes related to the original Psi package
1675 started in Prof. Fritz Schaefer's group at UC Berkeley. Current version
1676 of MPQC works with stable versions of Psi 3 starting with 3.2.0. From
1677 now on we will refer to Psi 3 as simply Psi. Psi is written primarily
1678 in C and executes in serial mode only. The interface between Psi and
1679 MPQC is intended mainly for Psi users who wish to exploit MPQC's
1680 geometry optimization and frequency analyses capabilities with Psi
1681 energies and gradients.
1682 The following sections explain how to use Psi from MPQC:
1683 o How the MPQC-Psi interface works
1684 o Environmental Variables
1685 o Preparing an input file
1686 o Psi Execution Environment
1687 o PsiWavefunction specializations
1688 o More examples
1689 How the MPQC-Psi interface works
1690 The current version of the interface is rather slim. It is only
1691 possible to import energies and gradients computed with Psi into MPQC,
1692 i.e. wave functions cannot be imported. All MPQC-Psi interaction
1693 happens via text files and system calls. MPQC generates input file for
1694 Psi, calls appropriate Psi modules, and then parses the output files
1695 for energies and gradients.
1696 Environmental Variables
1697 Several environmental variables are used to control MPQC-Psi
1698 interaction:
1699 PSIBIN
1700 By default, MPQC will try to find Psi binaries under
1701 /usr/local/psi/bin. Use PSIBIN environmental variable to point to
1702 the right location.
1703 The rest of the Psi environment is job specific and specified in the
1704 input file.
1705 Preparing an input file
1706 As noted above, MPQC parses the input file, and as such the input file
1707 has to be in the MPQC OO input format. All features of usual MPQC input
1708 files are there (mpqc section, mole MolecularEnergy object, etc.). In
1709 addition the following rules apply:
1710
1711 o instead of using MPQC Wavefunction objects (CLHF, MBPT2, etc.), the
1712 Psi specific Wavefunction types (i.e. specializations of
1713 PsiWavefunction) have to be used. Presently the following
1714 specializations are supported: PsiCLHF, PsiHSOSHF, PsiUHF, PsiCCSD,
1715 PsiCCSD_T . The first three are directly analogous to MPQC
1716 Wavefunction types CLHF, HSOSHF, and UHF. The latter two do not have
1717 MPQC analogs yet. See appropriate class documentation on how to
1718 specify them properly.
1719 o each Psi-specific Wavefunction object has to have a member object
1720 psienv of type PsiExEnv. PsiExEnv contains job specific information,
1721 such as the directory in which Psi input, output, and checkpoint
1722 files will be kept, filename prefix, scratch directories, etc. It
1723 makes sense to define one such object and simply refer to it from all
1724 PsiWavefunction objects. See PsiExEnv class documentation for more
1725 info.
1726 Psi Execution Environment
1727 Each PsiWavefunction-derived class has to have a member object called
1728 psienv of type PsiExEnv. The following keywords are used by its KeyVal
1729 constructor:
1730 cwd
1731 The directory where to keep Psi input, checkpoint, stdout, stderr,
1732 and other files. Default is /tmp.
1733 fileprefix
1734 The file prefix to use for Psi checkpoint, scratch, and some ASCII
1735 files. Equivalent to keyword name in Psi psi:files:default section.
1736 Defaults to psi.
1737 stdout
1738 The file into which to redirect standard output of Psi modules.
1739 Defaults to psi.stdout.
1740 stderr
1741 The file into which to redirect standard error of Psi modules.
1742 Defaults to psi.stderr.
1743 nscratch
1744 The number of locations over which to stripe Psi binary files.
1745 Equivalent to keyword nvolume in Psi psi:files:default section.
1746 Default is 1.
1747 scratch
1748 The locations over which to stripe Psi binary files. Equivalent to
1749 keyword volumex in Psi psi:files:default section. There's no
1750 default.
1751 Here's an example:
1752 psienv<PsiExEnv>: (
1753 cwd = ./
1754 fileprefix = psi.test
1755 nscratch = 2
1756 scratch = [ '/scratch1/' '/scratch2/' ]
1757 )
1758 PsiWavefunction specializations
1759 Class PsiWavefunction is derived from class Wavefunction, hence its
1760 KeyVal constructor uses all keywords that Wavefunction's KeyVal
1761 constructor uses (basis, molecule, etc.). In addition,
1762 PsiWavefunction's KeyVal constructor looks for the following keywords
1763 in the input file:
1764 psienv
1765 The PsiExEnv object that provides job specific Psi environment.
1766 There's no default.
1767 docc
1768 An optional array of integers that specifies the number of doubly-
1769 occupied orbitals in each irrep.
1770 socc
1771 An optional array of integers that specifies the number of singly-
1772 occupied orbitals in each irrep.
1773 frozen_docc
1774 An optional array of integers that specifies the number of doubly-
1775 occupied orbitals in each irrep frozen in correlated computations.
1776 frozen_uocc
1777 An optional array of integers that specifies the number of
1778 unoccupied orbitals in each irrep frozen in correlated
1779 computations.
1780 total_charge
1781 The total charge of the system. This keyword is queried only if
1782 neither docc nor socc are given.
1783 multiplicity
1784 The spin multiplicity of the system (2*M_S+1). This keyword is
1785 queried only if neither docc nor socc are given.
1786 memory
1787 The number of bytes of memory Psi modules associated with this
1788 PsiWavefunction are allowed to use. Default is 2000000 (2 million
1789 bytes, approximately 2 MB).
1790 Note that keywords docc, socc, frozen_docc, frozen_uocc, total_charge,
1791 and multiplicity are used by appropriate specializations of
1792 PsiWavefunctions, i.e. PsiCLHF only checks for docc, etc.
1793 PsiWavefunction specializations PsiCCSD and PsiCCSD_T also look for
1794 keyword reference which specifies the reference wave function (an
1795 object of type PsiSCF). All classes for correlated Psi wave functions
1796 will require such an object.
1797 Here are a few examples of PsiWavefunctions:
1798 %
1799 % ROHF DZ on F atom
1800 %
1801 mole<PsiHSOSHF>: (
1802 docc = [ 2 0 0 0 0 1 1 0 ] socc = [ 0 0 0 0 0 0 0 1]
1803 memory = 10000000
1804 % Psi Environment data
1805 psienv<PsiExEnv>: (
1806 cwd = ./
1807 fileprefix = f.dz.test
1808 stdout = f.dz.test.stdout
1809 stderr = f.dz.test.stderr
1810 nscratch = 1
1811 scratch = [ '/scratch/mpqc/' ]
1812 )
1813 % MolecularEnergy input
1814 molecule<Molecule>: (
1815 {atoms geometry} = {
1816 F [ 0.0 0.0 0.0 ]
1817 }
1818 )
1819 % Basis input
1820 basis<GaussianBasisSet>: (
1821 molecule = $..:molecule
1822 name = 'DZ (Dunning)'
1823 )
1824 )
1825 %
1826 % RHF CCSD/cc-pVDZ on water
1827 %
1828 mole<PsiCCSD>: (
1829 frozen_docc = [1 0 0 0]
1830 memory = 40000000
1831 % Psi Environment data
1832 psienv<PsiExEnv>: (
1833 cwd = ./
1834 fileprefix = h2o.ccpvdz.ccsd.test
1835 nscratch = 1
1836 scratch = [ '/tmp/' ]
1837 )
1838 % MolecularEnergy input
1839 molecule<Molecule>: (
1840 {atoms geometry} = {
1841 H [ -1.5 0.0 -0.3 ]
1842 H [ 1.5 0.0 -0.3 ]
1843 O [ 0.0 0.0 1.0 ]
1844 }
1845 )
1846 % Basis input
1847 basis<GaussianBasisSet>: (
1848 molecule = $..:molecule
1849 name = 'cc-pVDZ'
1850 )
1851 reference<PsiCLHF>: (
1852 psienv = $..:psienv
1853 molecule = $..:molecule
1854 basis = $..:basis
1855 total_charge = 0
1856 multiplicity = 1
1857 )
1858 )
1859 More examples
1860 This section contains some examples of complete inputs that specify an
1861 MPQC/Psi computations.
1862 Here's an optimization + subsequent frequency analysis on water
1863 molecule at the RHF CCSD 6-311G** level:
1864 % Emacs should use -*- KeyVal -*- mode
1865 % this file was automatically generated
1866 % label: water test series
1867 % molecule specification
1868 molecule<Molecule>: (
1869 symmetry = C2V
1870 unit = angstrom
1871 { atoms geometry } = {
1872 O [ 0.000000000000 0.000000000000 0.369372944000 ]
1873 H [ 0.783975899000 0.000000000000 -0.184686472000 ]
1874 H [ -0.783975899000 0.000000000000 -0.184686472000 ]
1875 }
1876 )
1877 % basis set specification
1878 basis<GaussianBasisSet>: (
1879 name = '6-311G**'
1880 molecule = $:molecule
1881 )
1882 % Psi environment specification
1883 psienv<PsiExEnv>: (
1884 cwd = ./
1885 fileprefix = mpqcpsi
1886 stdout = mpqcpsi.stdout
1887 stderr = mpqcpsi.stderr
1888 nscratch = 1
1889 scratch = [ '/scratch/evaleev/' ]
1890 )
1891 mpqc: (
1892 checkpoint = no
1893 savestate = no
1894 restart = no
1895 coor<SymmMolecularCoor>: (
1896 molecule = $:molecule
1897 generator<IntCoorGen>: (
1898 molecule = $:molecule
1899 )
1900 )
1901 % molecular coordinates for optimization do_energy = yes
1902 do_gradient = no
1903 % method for computing the molecule's energy
1904 mole<PsiCCSD>: (
1905 molecule = $:molecule
1906 basis = $:basis
1907 coor = $..:coor
1908 psienv = $:psienv
1909 memory = 32000000
1910 reference<PsiCLHF>: (
1911 psienv = $:psienv
1912 molecule = $:molecule
1913 total_charge = 0
1914 multiplicity = 1
1915 basis = $:basis
1916 memory = 32000000
1917 )
1918 hessian<FinDispMolecularHessian>: (
1919 point_group<PointGroup>: symmetry = C2V
1920 checkpoint = no
1921 restart = no
1922 )
1923 )
1924 optimize = yes
1925 % optimizer object for the molecular geometry
1926 opt<QNewtonOpt>: (
1927 max_iterations = 20
1928 function = $..:mole
1929 update<BFGSUpdate>: ()
1930 convergence<MolEnergyConvergence>: (
1931 cartesian = yes
1932 energy = $..:..:mole
1933 )
1934 )
1935 % vibrational frequency input
1936 freq<MolecularFrequencies>: (
1937 point_group<PointGroup>: symmetry = C2V
1938 molecule = $:molecule
1939 )
1940 )
1942 Common Component Architecture (CCA) component wrappers, conforming to
1943 interfaces developed for the CCA Chemistry Component Toolkit, have been
1944 created to encapsulate some MPQC functionality. The following
1945 components are provided by MPQC:
1946 o MPQC.Chemistry_QC_ModelFactory
1947 o MPQC.ChemistryOpt_CoordinateModel
1948 o MPQC.IntegralEvaluatorFactory
1949 MPQC.Chemistry_QC_ModelFactory
1950 This is an implementation of the Chemistry.QC.ModelFactory interface.
1951 This factory produces model objects (implementing the
1952 Chemistry.QC.Model interface) based on the MPQC package. The MPQC model
1953 allows calculation of molecular energies and energy derivatives using a
1954 variety of methods.
1955 Provides Ports
1956 o Chemistry.QC.ModelFactory ModelFactory
1957 Uses Ports
1958 o Chemistry.QC.MoleculeFactory MoleculeFactory (required)
1959 Parameters
1960 o theory The method for determining the electronic structure. Defaults
1961 to HF.
1962
1963 o HF Hartree-Fock method.
1964 o B3LYP Density Functional Theory (DFT) with B3LYP functional.
1965 o Use keyval input for other options.
1966 o basis The atomic orbital basis set. Defaults to STO-3G.
1967
1968 o Any basis set defined in the MPQC package.
1969 o Use keyval input for mixed basis sets.
1970 o molecule_filename Path to the molecule file (see cca-chem-generic
1971 documentation for format). No default -- required.
1972 o keyval_filename Path to the keyval input file (see below). No default
1973 -- optional.
1974 Keyval Input
1975 The theory and basis parameters allow very basic calculations to be
1976 performed. More complex calculations will require the use of a keyval
1977 input file. The keyval file format is the same as that used to run MPQC
1978 stand-alone, and any valid MPQC options may be used. The molecular
1979 energy object must be named model. The user-supplied keyval cannot
1980 contain a molecule section; the molecule section will be automatically
1981 inserted by the ModelFactory using the required molecule_filename. This
1982 molecule section should be referred to as $:molecule.
1983 Example keyval input:
1984 model<CLHF>:(
1985 molecule=$:molecule
1986 basis<GaussianBasisSet>:(
1987 name = '6-31G'
1988 molecule = $:molecule
1989 )
1990 )
1991 MPQC.ChemistryOpt_CoordinateModel
1992 This is an implementation of the ChemistryOpt.CoordinateModel interface
1993 based on the MPQC package. It supports molecular structure optimization
1994 in cartesian, symmetrized internal, and redundant internal coordinates.
1995 Hessian approximation is supported.
1996 Provides Ports
1997 o ChemistryOpt.CoordinateModel CoordinateModel
1998 Uses Ports
1999 o Chemistry.QC.ModelFactory ModelFactory (required)
2000 o Chemistry.QC.ModelFactory BackupModelFactory (optional)
2001 o Chemistry.MoleculeViewer MoleculeViewer (optional)
2002 A backup model factory may be supplied. If an error is detected in the
2003 primary model, then a model obtained from the backup factory will be
2004 used. The molecule viewer is currently only used to communicate with
2005 the python viewer, in which case component instantiation and connection
2006 is handled automatically.
2007 Parameters
2008 o grad_rms RMS gradient convergence criteria. Defaults to 0.00030.
2009 o grad_max Max gradient convergence criteria. Defaults to 0.00045.
2010 o disp_rms RMS displacement convergence criteria. Defaults to 0.00120.
2011 o disp_max Max displacement convergence criteria. Defaults to 0.00180.
2012 o coordinate_type Optimization coordinate type. Defaults to
2013 symmetrized.
2014
2015 o cartesian Cartesian coordinates.
2016 o symmetrized Symmetrized internal coordinates.
2017 o redundant Redundant internal coordinates.
2018 o multiple_guess_h Compute new guess Hessian at each call to
2019 guess_hessian_solve() (true) or use guess from first iteration only
2020 (false). Only meaningful in conjunction with solvers supporting use
2021 of dense guess Hessians with limited-memory methods. Defaults to
2022 true.
2023 o use_current_geom If multiple_guess_h is true, either use the current
2024 geometry (true) or the geometry at which the earliest correction pair
2025 used by the solver was determined (false) when computing the guess
2026 Hessian. Defaults to false.
2027 MPQC.IntegralEvaluatorFactory
2028 This is an implementation of the
2029 Chemistry.QC.GaussianBasis.IntegralEvaluatorFactory interface. This
2030 factory produces molecular integral evaluator objects based on the MPQC
2031 package. This code is experimental and does not currently support
2032 derivative integrals.
2033 Provides Ports
2034 o Chemistry.QC.GaussianBasis.IntegralEvaluatorFactory
2035 IntegralEvaluatorFactory
2036 Parameters
2037 o package Integral package, either intv3 or cints. Defaults to intv3.
2038 o integral_buffer Integral buffer type, either opaque or array. The
2039 opaque option uses pointers and is therefore higher performance. The
2040 array option may be used by components implemented in languages which
2041 are not pointer-aware.
2043 MPQC is open-source software; you can redistribute it and/or modify it
2044 under the terms of the GNU General Public License as published by the
2045 Free Software Foundation; either version 2 of the License, or (at your
2046 option) any later version.
2048 MPQC is distributed in the hope that it will be useful, but WITHOUT ANY
2049 WARRANTY; without even the implied warranty of MERCHANTABILITY or
2050 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
2051 for more details.
2052Version 2.3.1 Sun Aug 16 2020 mpqc(1)