Redundant internal coordinates
GIC
Build an automatic set of redundant internal coordinates using the new GIC algorithm. Geom=GIC is now equivalent to Geom=Redundant and the default is to use GICs whenever the internal coordinates are requested. The coordinates generated with this option can be the same bonds, angles, and dihedral angles generated using the old algorithm (Peng96) if the input geometry does not have any disjoint fragments that require a special treatment with the option Geom=(GIC,Rotors) or any methyl or similar XY3-type functional groups attached to the main skeleton that require a special treatment with the option Geom=(GIC,XY3) (see below). With a few exceptions noted below, Geom=(GIC,Rotors,XY3) is used by default. The option Geom=(GIC, NoRotors,NoXY3) can be used to build only regular bonds, valence angles, and dihedral angles and to use virtual bonds in case if there are disjoint fragments. Opt=GIC can be used as well. If Opt is requested, perform the optimization using the Berny algorithm with the GICs.
DefNoGIC
Build an automatic set of redundant internal coordinates such as bonds, angles, and dihedrals from the current Cartesian coordinates or Z-matrix values using the old algorithm (Peng96) available in Gaussian 16 (no GICs). Opt along with Geom=DefNoGIC can be used as well. If Opt is requested, perform the optimization using the Berny algorithm in these redundant internal coordinates. This was the old default in Gaussian 16.
AddGIC
Build the same GICs as described above. Then read the input stream for user-provided modifications to those GICs before performing any further calculation. This option requires a separate input section following the geometry specification. The syntax of the GIC input section is described in GIC SYMBOLIC INPUT DICTIONARY. The option Opt=AddGIC can be used as well. The option Geom=(GIC,ModRedundant) and Geom=ModRedundant are equivalent to Geom=AddGIC. The option Geom=(DefNoGIC,ModRed) can be used to request the old redundant coordinates (Peng96) modified according to the old modred input. ModRed and ModRedundant are equivalent.
ReadAllGIC
Do not build any redundant internal coordinates by default. Instead, read the input stream for user-provided GIC definitions and create the coordinates. This option requires a separate GIC input section following the geometry specification. The syntax of the GIC input section is described in GIC SYMBOLIC INPUT DICTIONARY. The default is Geom=(ReadAllGIC,NoRotors,NoXY3). The option Opt=ReadAllGIC can be used as well.
GICOld or ModGICOld
Build an automatic set of redundant internal coordinates using the old algorithm (Peng96), read the old modred input in the case of Geom=ModGICOld, and then convert the coordinates into the GICs and treat them as such. No other options such as Rotors or XY3 can be used here. Use this option for the old algorithm input cases that do not work with the new GIC code without input modification.
Z-matrix internal coordinates
GICZmat
Read regular Z-matrix coordinates from the input and then convert them into GIC-type internal coordinates with the original Z-matrix constraints being preserved. The option Opt=GICZmat is acceptable as well. If Opt is requested, perform a geometry optimization like with Opt=Z-Matrix but in terms of the GICs. No other options such as Rotors or XY3 can be used here. To find the corresponding input examples, run the following command:
grep -i 'GICZmat' $gdvroot/gdv/tests/com/*.com
Model-specific internal coordinates
(GIC,Rotors)
Build a special set of GICs (called below the fragment-based rotor-type GICs) to treat disjoint fragments determined from the input Cartesian geometry or from the user-provided connectivity information and do not build any virtual bonds between the fragments. The connectivity information can be introduced by using the option Geom=Connectivity. This is the default for Geom=GIC if two or more qualified fragments are detected. In particular, the fragments should have more than two atoms and this is for a regular calculation that does not use periodic boundary conditions (PBCs), ONIOM with micro-iterations, QST2, QST3, Path, Cartesian atoms or the RdOpt option. Otherwise, the default for Geom=GIC is Geom=(GIC,NoRotors).
The fragments can also be specified explicitly in the Cartesian input section like in the case of a counterpoise calculation request:
O(fragment=1) 0.000000000000 0.000000000000 0.000000000000 H(fragment=1) 0.000000000000 0.000000000000 0.976756085872 N(fragment=2) 0.259655068263 0.000000000000 2.877762253635 H(fragment=2) 1.269044288026 0.000000000000 2.982267037494 H(fragment=2) -0.089902960790 0.816744932713 3.367111592058 H(fragment=2) -0.089902960790 -0.816744932713 3.367111592058 H(fragment=1) -0.924602146888 0.000000000000 -0.254984428189
The current version of the code assigns the fragment-based rotor-type GICs automatically to any default or user-specified fragment used in a counterpoise calculation. If one wants to use regular bonds, valence and dihedral angles instead then the option Geom=(GIC,NoRotors) should be specified to override the Rotors default.
The fragment-based rotor-type GICs include the default internal coordinates (regular bonds, valence and dihedral angles) for individual fragments and an additional set of coordinates to describe the rotational and translational motion of each fragment. The translational GICs of fragment k with Nk atoms are the Cartesian coordinates of its center of geometry (labeled by default as Cxk, Cyk, and Czk):
Cxk = (ΣXik)/Nk
Cyk = (ΣYik)/Nk
Czk = (ΣZik)/Nk
where Σ means a sum over i and the index i runs over Nk atoms in the fragment defined by the atoms’ Cartesian coordinates. The rotational GICs are the Cartesian components of the unit vectors Pk, Qk, and Sk (labeled by default as Pxk, Pyk, Pzk, Qxk, Qyk, Qzk, Sxk, Syk, Szk) to describe the three orthogonal axes of rotation. The vector Pk is directed from the center of geometry (Ck) towards the atom (Ak,1) selected to be most distant from the center and symmetrically unique, if possible. Otherwise, the first qualified atom from the list of symmetrically equivalent ones will be used. The vector is defined by the three GICs:
Pxk = (X1k – Cxk)/R(1,Ck)
Pyk = (Y1k – Cxk)/R(1,Ck)
Pzk = (Z1k – Cxk)/R(1,Ck)
The direction of the unit vector Qk is defined by a vector product of the vector Pk and the vector spanning from Ck to the second atom (Ak,2). The latter is selected to be a symmetrically unique atom (if possible) with the smallest absolute value for the dot product CkAk,1·CkAk,2 and it cannot be the one closest to the center of the fragment at the same time:
Q0xk = Pyk (Z2k – Czk) – Pzk (Y2k – Cyk)
Q0yk = Pzk (X2k – Cxk) – Pxk (Z2k – Czk)
Q0zk = Pxk (Y2k – Cyk) – Pyk (X2k – Cxk)
RQ0k = (Q0xk2 + Q0yk2 + Q0zk2)1/2
Qxk = Q0xk / RQ0k
Qyk = Q0yk / RQ0k
Qzk = Q0zk / RQ0k
The vector Sk is the vector product Pk ⊗ Qk:
Sxk = Pyk Qzk – Pzk Qyk
Syk = Pzk Qxk – Pxk Qzk
Szk = Pxk Qyk – Pyk Qxk
An additional set of six GICs is introduced to freeze the total translations by freezing the center of geometry for the whole N-atom molecule at its initial position as
XTr(Frozen) = (ΣXi)/N
YTr(Frozen) = (ΣYi)/N
ZTr(Frozen) = (ΣZi)/N
and to freeze the total rotations with respect to the initial (reference) geometry as
XRot(Frozen) = (Σ[Yi* Zi – Zi* Yi])/N
YRot(Frozen) = (Σ[Zi* Xi – Xi* Zi])/N
ZRot(Frozen) = (Σ[Xi* Yi – Yi* Xi])/N
where Σ means a sum over i which runs over all the N atoms, and the asterisk refers to the initial values of Cartesian coordinates for atom i (to be determined automatically from the input geometry). This is equivalent to using the Eckart conditions for translations and rotations (see, for example, Page 210 in [Bunker, P. R.; Jensen, P. Molecular symmetry and spectroscopy, 2nd edition, NRC Research Press, Ottawa, 2006]) with all the atomic masses nominally equal to 1 a.u. The translation center of the whole molecule can be placed at the origin of the Cartesian coordinate system by means of IOp(1/156=2xxxx), if desired.
Note that in certain calculations (e.g., with fragments larger than 50 atoms and for some non-regular cases such as PBCs or ONIOM with microiterations) the fragment-based rotor-type GICs of the largest fragment k or, in case of ambiguity, the first largest fragment (Cxk through Szk) will not be built by default and the expressions XTr, YTr, ZTr, XRot, YRot, and ZRot introduced above will be used to freeze the total translations and rotations of that fragment instead of the whole molecule (the index i would run only over Nk atoms in the fragment).
In the case of linear fragments, the vectors Qk and Sk are undefined and their components are replaced with the Cartesian coordinates of the remaining atoms (after the first one). One-atom fragments (they are not assigned by default in the current code) are described using the corresponding Cartesian coordinates.
The option Opt=(GIC,Rotors) is acceptable as well. If Opt is requested, perform a geometry optimization using the resulting GICs. To find the corresponding input examples, run the following command:
grep -i Rotors $gdvroot/gdv/tests/com/*.com | grep -v -i NoRotors
(AddGIC,Rotors)
Build a special set of fragment-based rotor-type GICs to treat disjoint fragments as described above and then read an additional GIC input to modify the new GICs. The option Opt=(AddGIC,Rotors) is acceptable as well. If Opt is requested, perform a geometry optimization using the resulting GICs.
(ReadAllGIC,Rotors)
Read the input stream for user-provided GIC definitions and build a special set of fragment-based rotor-type GICs to treat disjoint fragments as described above. The default is Geom=(ReadAllGIC, NoRotors). Note that the user-provided GIC definitions should include the internal coordinates for all the fragments of interest and also the actual fragment specifications if there are no default fragments found or the default fragments should not be used at all. The option Opt=(ReadAllGIC,Rotors) is acceptable as well. If Opt is requested, perform a geometry optimization using the resulting GICs.
(GIC,QRotors)
Build a special set of the fragment-based rotor-type GICs (to treat disjoint fragments as described above) labeled by default as Pxk, Pyk, Pzk, Qxk, Qyk, Qzk, Sxk, Syk, Szk along with the translation-type GICs labeled as Cxk, Cyk, and Czk for each fragment k and convert them into the quaternion GICs. The rotation (unit) quaternion for each fragment is defined as one scalar component (K0) and three vector components (K1, K2, K3) in terms of the 3x3 rotation matrix (see, for example, Page 169 in [Kuipers, J. B. Quaternions and rotation sequences: a primer with applications to orbits, aerospace, and virtual reality, Princeton University Press, 2002]) as follows:
K0 = (R11+R22+R33+1)½ / 2
K1 = (R23−R32) / (4K0)
K2 = (R31−R13) / (4K0)
K3 = (R12−R21) / (4K0)
The rotation matrix in turn is expressed in terms of the dot products of the P, Q, and S vectors for the same fragment as follows:
R11 = P·P* R12 = P·Q* R13 = P·S*
R21 = Q·P* R22 = Q·Q* R23 = Q·S*
R31 = S·P* R32 = S·Q* R33 = S·S*
The P, Q, or S unit vectors are defined in terms of their Cartesian components at the current geometry (no asterisk) and at the initial geometry (with the asterisk). Thus, the rotation of a fragment is defined wrt its initial position around the center of geometry which can move independently.
The option Opt=(GIC,QRotors) is acceptable as well. If Opt is requested, perform a geometry optimization using the resulting GICs. To find the corresponding input examples, run the following command:
grep -i -e QRotors -e FlQua0 $gdvroot/gdv/tests/com/*.com
(GIC,NoRotors) or (AddGIC,NoRotors) or (ReadAllGIC,NoRotors)
Do not build a special set of GICs to treat disjoint fragments even if there are such fragments. Use regular bonds, valence and dihedral angles as well as virtual bonds to connect the fragments, if any, or any coordinates that come from a user-provided GIC input section. Note that NoRotors is the default for Geom=GIC and AddGIC when used with PBCs, micro-iterative ONIOM, QST2 or similar options and it is always the default for Geom=ReadAllGIC.
(GIC,NoDefaultFrag) or (AddGIC,NoDefaultFrag) or (ReadAllGIC,NoDefaultFrag)
Do not look into the default or user-provided connectivity data for any default fragments. Use regular and virtual bonds, valence and dihedral angles or any coordinates that come from a user-provided GIC input section. Note that a combination of NoDefaultFrag and Rotors with no user-provided fragment information in the GIC input section will cause an error.
(GIC,XY3)
Identify any methyl (CH3) or similar non-planar groups (XY3 or XYY'Y" in general) from the input geometry or connectivity. The connectivity information can be introduced by using the option Geom=(Connectivity,GIC). Build the default GICs (bonds, angles, and dihedral angles) for the remaining skeleton. Build a special set of GICs for the detected XY3-type groups (see the scheme on the right). This is the default for Geom=GIC for any molecule larger than neopentane (17 atoms) and this is for a regular calculation without PBCs, ONIOM with micro-iterations, QST2, QST3, Path, Cartesian atoms or the RdOpt option. Otherwise, the default for Geom=GIC is Geom=(GIC,NoXY3). The option Opt=(GIC,XY3) is acceptable as well. If Opt is requested, perform a geometry optimization using the resulting GICs. Note that the XY3 groups connected to the same atom Z as well as for some special cases (e.g., when some WZX or VWZ angles are linear) will not be assigned the XY3-type GICs automatically because the latter may not work better than regular coordinates. Use a special internal option (IOp(1/156=4x)) to override this restriction. The default label for the torsion GIC (T in the scheme) for each XY3 group is TOxI where I refers to the atomic index for atom X. The deformation GICs (DA and DB) are labeled as DAxI and DBxI. The remaining coordinates generated for each XY3 by default are pure bonds, valence angles, and dihedral angles (labeled as such).
(AddGIC,XY3)
Build a special set of GICs to treat the XY3-type groups as described above and then read an additional GIC input to modify the new GICs. Note that such groups must be present if the XY3 option is specified explicitly. The option Opt=(AddGIC,XY3) is acceptable as well. If Opt is requested, perform a geometry optimization using the resulting GICs. To find the corresponding input examples, run the following command:
grep -i XY3 $gdvroot/gdv/tests/com/*.com | grep -i -v NoXY3
(ReadAllGIC,XY3)
Read the input stream for user-provided GIC definitions that should include the internal coordinates for the skeleton. Build a special set of GICs for the XY3-type groups detected automatically. Note that such groups must be present. The default is Geom=(ReadAllGIC,NoXY3). The option Opt=(ReadAllGIC, XY3) is acceptable as well. If Opt is requested, perform a geometry optimization using the resulting GICs. To find the corresponding input examples, run the following command:
grep -i XY3 $gdvroot/gdv/tests/com/*.com | grep -i ReadAllGIC
(GIC,NoXY3) or (AddGIC,NoXY3) or (ReadAllGIC,NoXY3)
Do not build a special set of GICs to treat the XY3-type groups even if there are such groups. Use regular bonds, valence and dihedral angles or any coordinates that come from a user-provided GIC input section. Note that NoXY3 is the default for Geom=GIC and AddGIC when used with PBCs, micro-iterative ONIOM, QST2 or similar options and it is always the default for Geom=ReadAllGIC.
GIC IOp(1/156=29)
Identify AB3-type planar groups (or ABB'B" in general) and the corresponding near-planar groups where the sum of the three BAB angles exceeds 350°. Build a special set of umbrella-type GICs defined via the U(i,j,k,l) function described in GIC SYMBOLIC INPUT DICTIONARY (see a figure there) for the detected AB3-type groups in addition to the initial set of GICs modified by removing the ABB'B" dihedral angles, if any. A set of GICs generated for an AB3-type planar group with atoms A1, B2, B3, and B4 will be U(1,2,3,4), U(1,3,4,2), and U(1,4,2,3). AddGIC and ReadAllGIC can also be used. If Opt is requested, perform a geometry optimization using the resulting GICs. This option is experimental and it has no dedicated keyword but it can be requested as an internal option (IOp). See the information on other GIC-related IOps at the end of this document. Find more examples by running the following command:
grep -i 'U(1' $gdvroot/gdv/tests/com/*.com
Symmetrized internal coordinates
GICAllSym
Build the default initial GICs as a set of regular bonds, valence and dihedral angles for the current input geometry and symmetrize them based on the current point group (determined from the input Cartesian coordinates) by building symmetrized linear combinations according to each irreducible representation. The option Opt=GICAllSym is acceptable as well. If Opt is requested, perform a geometry optimization using the symmetrized GICs. If the options Opt=QST2 or Opt=QST3 are used as well then the symmetrization will be applied to the final GICs generated for the union (transition state) structure. If there are no other automatic options such as Rotors or XY3 specified explicitly then the initial (unsymmetrized) GICs will be regular internal coordinates with disjoint fragments being connected by virtual bonds (if any) and with no special treatment of XY3-type functional groups (if any). The default is Geom=(GICAllSym,NoRotors, NoXY3).
GICAllFSym
Do Geom=GICAllSym but also freeze all the non-totally symmetric GICs. The option Opt=GICAllFSym is acceptable as well. If Opt is requested, perform a geometry optimization using the symmetrized GICs for the totally symmetric irrep (e.g., for A1g in Oh) with the remaining GICs being kept frozen to preserve the current symmetry. If the symmetry is not expected to change upon geometry optimization, GICOneSym (see below) should be used instead of GICAllFSym. The default is Geom=(GICAllFSym,NoRotors, NoXY3).
GICOneSym
Build symmetrized combinations of GICs only for one irreducible representation, in particular, for the totally symmetric irrep (e.g., for A1g in Oh). The option Opt=GICOneSym is acceptable as well. If Opt is requested, perform a geometry optimization using the IOp(1/156=1xxx) settings and the GICs symmetrized only for the totally symmetric irrep. The default is Geom=(GICOneSym,NoRotors,NoXY3).
(GICAllSym,AddGIC) or (GICAllFSym,AddGIC) or (GICOneSym,AddGIC)
Build the default symmetrized GICs as described above. Then read any user-provided modifications to the final GICs from a GIC input section. The syntax of the GIC input section is described in GIC SYMBOLIC INPUT DICTIONARY. The option ReadAllGIC can be used instead of AddGIC to symmetrize any user-provided set of GICs instead of the default GICs. To find the corresponding input examples, run the following command:
grep -i -e GICAllSym -e GICOneSym $gdvroot/gdv/tests/com/*.com | grep -i ReadAllGIC
ReadAllGIC IOp(1/156=300)
Read the user-provided GICs for a molecule containing nA atoms of type A, nB atoms of type B, and nC atoms of type C (as an example). Then symmetrize them according to the corresponding permutation group which is a direct product of individual symmetric permutation groups S(n) (see, for example, [Bunker, P. R.; Jensen, P. Molecular symmetry and spectroscopy, 2nd edition, NRC Research Press, Ottawa, 2006] or [Flurry, R. L., Jr. Symmetry groups, Prentice-Hall, Inc., Englewood Cliffs, 1980]):
S(nA)⊗S(nB)⊗S(nC)
The total number of possible permutations (symmetry operations) will be nA!nB!nC! for this example. In the case of the PF5 molecule, the corresponding group will be S(1)⊗S(5)≡S(5) with 120 elements. The input molecular geometry does not need to be spatially symmetric and no actual point group symmetry is used in this symmetrization. The options Geom=GIC or Geom=AddGIC can also be used, provided that the initial GICs comprise a full set of permutationally equivalent coordinates. This option is experimental and it has no dedicated keyword but it can be requested as an internal option (IOp). See the information on other GIC-related IOps at the end of this document. Find some examples by running the following command:
grep permutation $gdvroot/gdv/tests/com/*.com
ReadAllGIC IOp(1/156=400)
Read the user-provided GICs for a molecule containing nA atoms of type A, nB atoms of type B, and nC atoms of type C (as an example). Then symmetrize them according to the corresponding permutation−inversion group (see, for example, [Bunker, P. R.; Jensen, P. Molecular symmetry and spectroscopy, 2nd edition, NRC Research Press, Ottawa, 2006] or [Flurry, R. L., Jr. Symmetry groups, Prentice-Hall, Inc., Englewood Cliffs, 1980]) which is a direct product of individual symmetric permutation groups S(n) and the inversion group Inv (the latter has two symmetry elements):
S(nA)⊗S(nB)⊗S(nC)⊗Inv
The total number of possible permutation−inversion symmetry operations will be nA!nB!nC!2 for this example. In the case of the NH3 molecule, the corresponding permutation−inversion group will be S(1)⊗S(3)⊗Inv≡S(3)⊗Inv with 12 elements and the group will be isomorphic to the D3h point group (of the planar NH3 molecule). The input molecular geometry does not need to be spatially symmetric and no actual point group symmetry is used in this symmetrization. The options Geom=GIC or Geom=AddGIC can also be used, provided that the initial GICs comprise a full set of permutationally and inversionally equivalent coordinates. This option is experimental and it has no dedicated keyword but it can be requested as an internal option (IOp). See the information on other GIC-related IOps at the end of this document. Find some examples by running the following command:
grep permutation $gdvroot/gdv/tests/com/*.com
Note on QST2 and QST3 calculations with GIC, AddGIC, ReadAllGIC, and other GIC-related options
The QST2 calculation requires two geometry specifications as usual (one for the reactants and another for the products). The QST3 calculation requires three geometry specifications (for the reactants, for the products, and for the transition state). The options Opt=(QSTx,GIC) where x is equal to 2 or 3 do not require any additional GIC-related input. The union GICs will be built by merging the default GICs for each of the two (QST2) or three (QST3) structures. If the linear bends are required for any of those structures then they will be retained while the corresponding regular angles and dihedral angles will be removed because they may be undefined at certain geometries. The options Opt=(QSTx,ReadAllGIC) require two separate GIC inputs as the only source of GICs where the first input follows the geometry specification for the reactants and the second input follows the geometry specification for the products (no GIC input for the third structure is needed). The options Opt=(QSTx,AddGIC) require one GIC input after the last QSTx geometry specification to modify the final GICs generated by default for the union (transition state) geometry. The options Opt=(QSTx,AddGIC,Y) with Y to be replaced with another keyword such as GICOneSym, GICAllSym, Rotors, or XY3 (note that not every possible combination will be practical or has been tested so far) require the second GIC input to modify the final GICs obtained after an automatic modification (e.g., symmetrization) of the transition-state GICs. Any missing GIC input section that is otherwise required should be replaced with an extra blank line. Here is an example of the QST2 input when we need to modify the final set of GICs (by freezing something in this case):
# hf/3-21g opt=(QST2,AddGIC) nosymm QST2 reactant 0 2 C 0.00000000 0.00000000 0.00000000 H 0.00000000 0.00000000 2.00000000 H 1.08000000 0.00000000 0.00000000 H -0.54000000 -0.93530744 0.00000000 H -0.54000000 0.93530744 0.00000000 F -0.00000000 0.00000000 2.92000000 QST2 product 0 2 C 0.00000000 0.00000000 0.00000000 H 0.00000000 0.00000000 1.08000000 H 1.01817859 0.00000000 -0.36015602 H -0.50908930 -0.88176853 -0.36015602 H -0.50908930 0.88176853 -0.36015602 F -0.00000000 0.00000000 3.08000000 L(1,2,6,3,-1) Frozen L(1,2,6,3,-2) Frozen
Here is an input for the same transition state calculation using QST3:
# hf/3-21g opt=(QST3,AddGIC) nosymm QST3 reactant 0 2 C 0.00000000 0.00000000 0.00000000 H 0.00000000 0.00000000 2.00000000 H 1.08000000 0.00000000 0.00000000 H -0.54000000 -0.93530744 0.00000000 H -0.54000000 0.93530744 0.00000000 F -0.00000000 0.00000000 2.92000000 QST3 product 0 2 C 0.00000000 0.00000000 0.00000000 H 0.00000000 0.00000000 1.08000000 H 1.01817859 0.00000000 -0.36015602 H -0.50908930 -0.88176853 -0.36015602 H -0.50908930 0.88176853 -0.36015602 F -0.00000000 0.00000000 3.08000000 QST3 transition state 0 2 C 0.00000000 0.00000000 0.00000000 H 0.00000000 0.00000000 1.25000000 H 1.06359237 0.00000000 -0.18754003 H -0.53179619 -0.92109801 -0.18754003 H -0.53179619 0.92109801 -0.18754003 F -0.00000000 0.00000000 2.50000000 L(1,2,6,3,-1) Frozen L(1,2,6,3,-2) Frozen
To find more input examples, run the following command:
grep -i 'QST' $gdvroot/gdv/tests/com/*.com | grep -i GIC
Note on IRC calculations with GIC-related options
The intrinsic reaction coordinate (IRC) calculation does not use any GICs but it is possible to compute and print the values of user-specified GICs along the IRC path, provided that the IRC=Report option is requested as well. Find some examples by running the following command:
grep -i 'IRC' $gdvroot/gdv/tests/com/*.com | grep -i GIC
Check-point reading options
Check
Read the Cartesian geometry and any internal coordinate definitions (GICs or others) from the check-point file. To find some input examples that use Geom=Check combined with various GIC options (e.g., GICAllSym), run the following command:
grep -i 'GIC' $gdvroot/gdv/tests/com/*.com | grep -i check
(Check,GIC) or (Check,GIC,NewDefinition)
Read the Cartesian geometry and discard any current internal coordinate definitions (GICs or others) from the check-point file. Build a new set of the default GICs for the current geometry. The options Geom=(Check,GIC), Geom=(Check,NewDefinition), and Geom=(Check,GIC,NewDefinition) are all equivalent. To rebuild the coordinate system using the old redundant internal coordinates instead of GICs, use the option Geom=(Check,DefNoGIC,NewDefinition).
(Check,AddGIC) or (Check,GIC,ModRedundant)
Read the Cartesian geometry and current GIC definitions from the check-point file. Then read the input stream for user-provided modifications to the current GICs before performing any further calculation. The syntax of the GIC input section is described in GIC SYMBOLIC INPUT DICTIONARY.
(Check,ReadAllGIC)
Read the Cartesian geometry and discard any current internal coordinate definitions (GICs or others) from the check-point file. Read the input stream for user-provided GIC definitions. The syntax of the GIC input section is described in GIC SYMBOLIC INPUT DICTIONARY.
ChkGIC
Read check-point GICs and apply them to the current Cartesian geometry from the input (do not use check-point Cartesian coordinates).
Print options
(GIC,GICPrint)
Prints all the primitive (intermediate) expressions for the current GICs and their first and second derivatives with respect to Cartesian coordinates (if applicable) in the form of a symbolic algebra tree. Note that the log file can be very big. The same functionality is available with IOp(1/33=3) (for GDV only). One can also use Geom=(AddGIC,GICPrint), Geom=(ReadAllGIC, GICPrint), etc.
