intder

intder(1)                                                            intder(1)



NAME
       intder - program for performing various vibrational analyses and
       higher-order nonlinear transformations among force field
       representations


PREFACE
       This manual documents the INTDER program, which was originally
       developed by Wesley D. Allen and co-workers.  in various forms. It is
       currently being reworked in the C/C++ format by Justin Turney, Nathan
       DeYonker, and Steven Wheeler. While much care has been exercised in
       preparing the program package and this manual, no representation is
       made that the manual and/or the program are without error or suitable
       for every application to which the user may attempt to apply them.  Any
       expressed or implied warranties of merchantability or fitness of the
       software described herein are disclaimed.  No part of the software may
       be reproduced or transmitted in any form or by any means, or stored in
       a data base or retrieval system, for any purpose without the consent of
       Wesley D. Allen.  Users are responsible for testing the program package
       on their own system and comparing results with those supplied with the
       software.  INTDER is written in C/C++ and is currently inoperable.


REQUIRED CITATIONS FOR INTDER
       General:

       1.     INTDER is a general program developed by Wesley D. Allen and co-
              workers which performs various vibrational analyses and higher-
              order nonlinear transformations among force field
              representations.

       For force field transformations or Cartesian projection scheme:

       2.     W. D. Allen and A. G. Czaszar, "On the Ab Initio Determination
              of Higher-Order Force Constants at Nonstationary Reference
              Geometries," J. Chem. Phys.  98, 2983(1993).

       For Scaled Quantum Mechanical (SQM) force field analyses:

       3.     W. D. Allen, A. G. Csaszar, and D. A. Horner, "The Puckering
              Inversion Barrier and Vibrational Spectrum of Cyclopentene.  A
              Scaled Quantum Mechanical Force Field Algorithm," J. Am. Chem.
              Soc.  114, 6834(1992).


INTRODUCTION
       INTDER is a connected set of programs for performing general
       curvilinear transformations and associated tasks often encountered in
       the calculation of anharmonic molecular force fields.  The capabilites
       of INTDER include:

       (1)    Force field transformations between Cartesian and general
              internal coordinate spaces up to fourth order, including
              nonstationary reference structures.  Both forward and reverse
              transformations are possible; hence, by using intermediate
              Cartesian coordinates, force fields can be transferred among
              different representations in the internal space.

       (2)    Harmonic vibrational frequency and infrared intensity analyses,
              both in Cartesian and internal coordinate space.

       (3)    Scaled quantum mechanical (SQM) force field analyses, including
              efficient nonlinear optimization of scale factors.

       (4)    Transformation of dipole-moment derivatives between Cartesian
              and internal coordinates.

       (5)    Generation of displaced geometries along general internal
              coordinates for use in finite-difference computations of
              molecular force fields.

       (6)    Direct Cartesian projection of any external
              (translation/rotation) variable dependence out of Cartesian
              anharmonic force fields.

              The original program INTDER was developed to run with the ab
              initio molecular orbital package PSI (PSITECH Inc.,
              Watkinsville, Georgia).  Accordingly, it used several
              conventions for the naming and handling of files.  Such
              conventions are essentially retained in INTDER95, although new
              output and scratch files have been added.  Vide infra for a
              summary of the files used by INTDER95.  It is well imagined that
              many of these scratch files and PSI files are going to be
              modified or eliminated to coincide with PSI 3.2


       The files and are the 1st, 2nd, 3rd and 4th derivatives, respectively,
       in Cartesian coordinates.  The files and are the 1st, 2nd, 3rd and 4th
       derivatives, respectively, in internal  coordinates.  The file is the
       dipole moment derivatives in Cartesian coordinates.  The file is the
       dipole moment derivatives in internal  coordinates.





INPUT FORMAT
       The input for this program is read from the file The intder program
       reads the definition of internal coordinates from the INTCO section of
       the input, and then searches through the default keyword path (first
       INTDER and then DEFAULT ).  The following keywords are valid:



       DERLVL = integer
              This gives the highest order of derivative to be transformed.
              It can have a value from 1 to 4.  The default is 2.


       DISP = displacement_vector
              If the DISP vector is present, this indicates that INTDER95 is
              to obtain molecular geometries that are distorted in a
              prescribed way from the reference geometry.  Note that the
              distortions are exact curvilinear distortions.  Each element of
              this vector is a vector consisting of internal coordinate
              indices and displacement values.  For example, if you desire two
              displacements, the first being a displacement of internal
              coordinate 1 by 0.01 angstroms, the second being a combination
              of displacements, e.g. coordinate 1 displaced by 0.01 angstroms
              and coordinate 2 by 0.05 angstroms, the DISP vector would be:
                 disp = (
                   (1 0.01)
                   (1 0.01 2 0.05)
                   )

              If the MASSES array is present, then the Eckart conditions are
              invoked for the displacements.  This is important in the
              evaluation of infrared intensities by finite differences of
              dipole moments.  Otherwise, unit masses are used in the
              calculation.  If the HIGH_ORDER option is set, then the new
              Cartesian geometry is converged upon using first and second-
              order information (see HIGH_ORDER).


       HIGH_ORDER =  boolean
              If true, then first- and second-order information, i.e. the
              analytic B(p)(ij) matrices, are used to accelerate convergence
              to new Cartesian geometries in displacement calculations.


       PRINT_LVL = integer
              This is a four digit number which will be explained below.  The
              default is 3000.


       DUMMY_ATOMS = real_array
              This array specifies the Cartesian coordinates of dummy atoms
              for LIN1 linear bending coordinates.  Each dummy atom position
              is actually treated as a fixed direction vector perpendicular to
              the plane of bending.  The real_array is a vector of coordinates
              of each dummy atom.  Each element of this vector is another
              vector in the form (x y z).  The numbering for the dummy atoms
              begins at NA+1 (NA = number of atoms).  Note that the new LIN1
              definition was referred to as LIN2 in the old intder program.
              Also note that this keyword is not invalid since we are getting
              our information from optking/input


       FREQ_ANAL = string
              This option specifies what type of harmonic frequency analysis
              to perform.  The options are: The default is NONE.


        SKIP_T = boolean
              If true, no derivatives are transformed. This is to make the
              FREQ_ANAL keyword less confusing.


       IRINT_T = boolean
              If = NO, then no IR intensities are computed.  If = YES then
              internal coordinate dipole moment derivatives are read in from
              and IR intensities are computed.  Setting IRINT_T = DO_R does
              the same as DO except that internal coordinate dipole moment
              derivatives are read from the INT_DIPDER vector. The default is
              NONE.  Will eventually be changed so that this works
              automatically.


       INT_DIPDER = real_matrix
              This matrix must be present if IRINT_T = DO_R.  It is made up of
              NSX vectors of length 3 and contains internal (symmetry)
              coordinate dipole moment derivatives (x, y, z) in units of
              Debye/Angstrom or Debye/radian.  NSX is as defined for
              Q_F_CONSTS.


       TRANS_DIPDER = boolean
              If true then dipole moment derivatives are transformed.  Masses
              are read in later so that the transformation is performed
              according to the Eckart conditions.  The dipole derivatives are
              read from or (see below for a description of the input
              required).  For TRANS_DIPDER = true, set DERLVL = 1 and
              TRANS_TYPE = C_TO_I or I_TO_C.  (TRANS_DIPDER = TRUE assigns
              TRANS_1DER = TRUE).  It is not possible to transform dipole
              moment derivatives at the same time as energy derivatives.  If
              TRANS_DIPDER = TRUE, FREQ_ANAL and IRINT_T should be NONE.  The
              default is FALSE.


       MASS_TRANS = boolean
              If true, the masses specified by the MASSES array are used for
              derivative transformations, including Cartesian projections.
              Otherwise, unit masses are used.


       MULTI = integer
              This option specifies the number of geometries to read from If
              MULTI = 0, the last geometry in is used.  If MULTI = n, then n
              geometries are read from from the top to bottom.  The default is
              0.  (Supported by new-style input only).  I don't know why this
              would be necessary?


       NUMTEST = string
              Numerical testing of derivatives of the internal coodinates with
              respect to the Cartesian coordinates is useful for debugging new
              types of coordinates added to the program.  The default is NONE.


       NTCO_INCLUDE = oolean array
              A boolean array that should be less than or equal to the number
              of internal coordinates This keyword must be present if you are
              numerically testing internal coordinates.  Use a "0" in the
              array to skip that specific intco, and use a "1" to test that
              intco.  For example, if you have four internal coordinates and
              you wish to only test the second you would use INTCO_INCLUDE =
              (0 1 0 0)


       Q_F_CONSTS = real_matrix
              This matrix must be present if FREQ_ANAL = NONE_R.  Its
              dimension is NSX by NSX, where NSX = the number of symmetrized
              internal coordinates, or the number of simple internal
              coordinates if no symmetrized internal coordinates are given.
              Confused here, NONE_R is not given as a possible keyword of
              FREQ_ANAL


       PED =  boolean
              If true, assign normal modes according to the simplified
              potential energy distribution (PED) method.  Default is false;
              normal modes are now assigned according to the diagonal elements
              of the total energy distribution (TED).


       RXN_COORD =  integer
              If FREQ_ANAL = RXN_PATH, then the RXN_COORD keyword specifies
              the number of the internal coordinate which is constrained as
              the reaction variable.  There is no default.


       STOP = string
              If STOP = B_AND_C, stop after forming the B(P)(I,J) and
              C(P)(Q,R) matrices (stored on FILE91, FILE92, and FILE96), and
              the B(P)(I,J,K), and C(P)(Q,R,S) matrices (stored on FILE93,
              FILE94, and FILE97), as governed by DERLVL and TRANS_1DER.  No
              auxiliary files are required (unless READ_GEOM = TRUE).  If STOP
              = B, stop after forming the B(eta)(I1,I2,I3,...,In) matrices for
              Cartesian projection.  If STOP = C, stop after forming the
              explicit Cartesian projection matrices.  The default is 0.


       TRANS_1DER = boolean
              If true, then assume non-zero first derivatives are to be
              transformed.  The default is FALSE.  not included yet


       TRANS_TYPE = string
              This specifies what type of transformation to perform.  If equal
              to C_TO_I, Cartesian derivatives are transformed to internal
              coordinate derivatives.  If equal to I_TO_C, then internal
              coordinate derivatives are transformed to Cartesian derivatives.
              I_TO_C_R is the same as I_TO_C except the internal coordinate
              derivatives are read from the file which is produced by the
              intdif program.  If equal to PROJECT, then Cartesian force
              constants are projected onto the internal space of the molecular
              system.  Direct projection is currently not available for linear
              molecules.  However, such analyses can be performed indirectly
              by neglecting Cartesian gradients (TRANS_1DER = FALSE),
              transforming the force field into any valid, complete set of
              internal coordinates (TRANS_TYPE = C_TO_I), and finally back-
              transforming the results once again to the Cartesian space
              (TRANS_TYPE = I_TO_C or I_TO_C_R).  The default is C_TO_I.  not
              included. Think this is an intdif function.


       INVARIANCE = boolean
              Test the Cartesian force field for invariance with respect to
              external variables (translations/rotations).  The default is
              FALSE.


INPUT FOR SQM FORCE FIELD ANALYSES (not yet begun)
       An SQM force field analysis is performed if FREQ_ANAL=SQMFC or
       SQMFC_NO_T.  If an SQM analysis is desired, a separate input section is
       required.  In the input file, begin a new input section with the label
       sqmfc.  This input section may be contained outside or inside the
       intder section.  The following options are valid.


       FUNDAMENTALS = real_array
              This keyword specifies the experimental frequencies to be used
              in the fit.  Although the keyword is named FUNDAMENTALS, note
              that it is also possible to fit to experimental harmonic
              frequencies, if available.  FUNDAMENTALS is a vector of arrays.
              Each vector specifies the experimental frequencies for a given
              isotopomer, along with the corresponding normal mode and an
              optional weight factor.  For example, suppose that we wish to
              perform an SQMFC analysis on HNCO and DNCO.  Suppose further
              that we have experimental frequencies for all six modes of HNCO,
              but for only three modes of DNCO.  The appropriate input might
              be

                    fundamentals = (
                        ((1   568.3)
                         (2   635.1)
                         (3   826.8)
                         (4  1336.3)
                         (5  2313.6)
                         (6  3724.1 1.0))
                        ((4  1323.1)
                         (5  2288.4)
                         (6  2738.6))
                       )

              The frequency 3724.1 is given a weight factor of 1.0, which will
              override any weights assigned by the WEIGHT keyword ( vide infra
              ).

              For each isotopomer, the fundamentals are to be numbered from
              lowest wavenumber to highest wavenumber, disregarding symmetry
              species but accounting for missing assignments.  In essence,
              after the eigenvalues of the GF matrix have been determined and
              ordered in a given step of the optimization, the specified
              numbering indicates the correspondence of these eigenvalues to
              the experimental fundamental frequencies involved in the SQMFC
              procedure.


       ISOTOPES = real_array or character_array
              Masses are input following this keyword for each of the isotopes
              to be considered in the SQMFC procedure.  The format is the same
              as for the MASSES keyword, except that ISOTOPES is a vector of
              mass vectors.   For example, the ISOTOPES vector for HNCO might
              be

                 isotopes = ((O C N H))

              whereas if the deuterated isotopomer was also to be considered,
              the appropriate input would be

                 isotopes = (
                    (O C N H)
                    (O C N D)
                   )


       OPT_SF =  boolean
              This keyword tells the program whether to optimize the scale
              factors in the SQMFC analysis (true) or to use fixed scale
              factors (false).


       SCALE_FACTORS =  real and int array
              This keyword allows the input of the scale factors for the SQMFC
              procedure (fixed or initial guesses, depending on the value of
              OPT_SF).  The input consists of one array for each scale factor.
              Each array contains a scale factor (real) followed by the
              internal coordinates to which the scale factor applies
              (integers).  The following example shows a scale factor of 0.815
              for internal coordinates 1 and 2, and a scale factor of 0.898
              for internal coordinate 3:

                 scale_factors = (
                    (0.815 1 2)
                    (0.898 3)
                   )


       SF_HESS =  string
              This keyword tells the program how to determine the scale factor
              Hessian for an optimization.  The options are:

              If SF_HESS = INPUT, the SF_HESS_DIAG vector must be specified.
              The ANAL option is recommended, as it employs a full second-
              order algorithm using the Newton-Raphson method.  This choice
              provides the most rapid and cost-effective convergence.  The LLS
              option employs a Newton-Raphson method but with the analytic
              Hessian appropriate for a linear least-squares problem.
              Convergence is significantly degraded relative to ANAL in the
              later iterations.  The NUM_FD option is not as cost-effective as
              either ANAL or LLS, even though convergence is obtained in the
              same number of steps as ANAL.  The primary use of this option is
              to test the analytic Hessians computed by the ANAL option.  Note
              that the Hessian is printed at each iteration to the CHECK file.
              The INPUT option provides rapid iterations, but several cycles
              may be required for convergence.  This option allows one to damp
              the initial steps by appropriate choice of the diagonal elements
              of the inverse Hessian.  Both GUESS and INPUT utilize a Davidon-
              Fletcher-Powell scheme with cubic interpolation.


       SF_HESS_DIAG = real_array
              If SF_HESS = INPUT, then SF_HESS_DIAG specifies the diagonal
              elements of the inverse of the scale factor Hessian.  The length
              of the array is the number of scale factors used (see
              SCALE_FACTORS above).


       WEIGHT =  integer
              This keyword determines how the weights are set in the SQMFC
              analysis.  A value of 0 sets weights for each frequency to the
              inverse of the frequency, a value of 1 sets all weights equal to
              1, and a value of 2 sets weights according to the reciprocal of
              the square of the frequencies.  The default is 0 (recommended by
              Pulay et al.)  Weights may be overridden for specific
              frequencies in the FUNDAMENTALS input (vide supra).  All weights
              are normalized before scale factor optimization begins.


FORMAT OF IDER.DAT FILE
              If TRANS_TYPE = I_TO_C_R the unique internal coordinate
              derivatives which are nonzero are read in from the file, which
              is produced by the intdif program.  Use units consistent with
              the energy in mdyne*Angstrom.  This line takes one or more of
              several forms given in a, b, c, and d.

              This file has the following format:

              This must be present if TRANS_1DER is TRUE.  It is repeated for
              each nonzero first derivative and terminated with M = 0.

              This must be present if DERLVL >= 2.  It is repeated for each
              nonzero second derivative and terminated with M = 0.

              This must be present if DERLVL >= 3, in which case, line 6b must
              also be present.  It is repeated for each nonzero third
              derivative and terminated with M = 0.

              This must be present if DERLVL >= 4, in which case, lines 6b and
              6c must also be present.  It is repeated for each nonzero fourth
              derivative and terminated with M = 0.



INTERNAL COORDINATE SPECIFICATION
       The definition of internal coordinates is nearly the same as for the
       bmat program.  However, there have been several changes and additions
       since the original intder program.  The following is a summary of the
       internal coordinate specifications for the new INTDER95 program.  See
       intco(2) for a description of how to set up the intco input for
       compatibility with  older programs such as intder and bmat.

       The intco section of the input is used to define the internal
       coordinates used by INTDER95(1).  These internal coordinates consist of
       two types, simple internal coordinates and symmetrized internal
       coordinates.  The symmetrized internal coordinates are symmetry-adapted
       linear combinations (SALCs) of the simple internal coordinates.


   SIMPLE INTERNAL COORDINATES
       The following types of simple internal coordinates are valid: for the
       deformation of a linear chain of atoms in the plane perpendicular to a
       specified direction vector Simons-Parr-Finlan coordinates for bond
       lengths, i.e., 1-r0/r.  for the deformation of a linear chain of atoms
       in the plane containing a fourth atom for the deformation of a linear
       chain of atoms perpendicular to the plane containing a fourth atom for
       center-of-mass separation coordinates between intermolecular fragments.


       The simple internal coordinates are entered as:

         TYPE = (
           (index A B <C> <D>)
           (  "   " "   "  "   "  ) (repeat this until
           (  "   " "   "  "   "  )  all simples of this
           (  "   " "   "  "   "  )  type are defined)
           )

       where index is a label used in the SYMM and ASYMM vectors, A-D are atom
       labels.  Note, the indices must run from 1 to nsim where nsim is the
       total number of simple internal coordinates.  The atom labels are
       defined as follows: For STRE, the coordinate is the A-B bond distance,
       and the order of A and B does not matter.  (C and D must not be given.)
       For BEND, it is the A-B-C bond angle.  A and C can be exchanged but the
       central atom must be B.  (D must not be given.)  For OUT, the
       coordinate is the angle between the AB vector and the plane containing
       C-B-D.  The coordinate is positive if A is on the same side of the
       plane as the vector (B->C) X (B->D) (that is, the cross product of the
       vector from atom B to atom C and the vector from atom B to atom D).
       Note that the central atom comes second here and that C and D can be
       exchanged but that this changes the sign of the coordinate.  For TORS,
       the coordinate is defined as the angle between the planes ABC and BCD.
       Note that ABCD and DCBA are equivalent.  For LIN1, the coordinate is
       the bending of the linear chain of atoms ABC in the plane perpendicular
       to the vector D.  The vector D is input as dummy atom coordinates (
       vide supra, DUMMY_ATOMS).  LIN1 is positive if (B->C) X (B->A) (that
       is, the cross product of the vector from atom B to atom C and the
       vector from atom B to atom A) is in the same direction as the D vector.
       For SPF, the coordinate involves the A-B bond distance, and the order
       of A and B does not matter.  SPF is different from all other simple
       coordinates in that C, if specified, is real rather than an integer.
       C, if given, is the reference bond length r0.  If C=0.0 the current
       value of the A-B bond length is taken as the reference.  For LINX the
       coordinate is the x component of the c -> d unit vector in the local
       coordinate system in which the b -> c vector defines the +z axis and
       the a atom lies in the xz plane in the +x direction.  For LINY the
       coordinate is the y component of the c -> d unit vector in the local
       coordinate system in which the b -> c vector defines the +z axis and
       the a atom lies in the xz plane in the +x direction.  For RCOM the
       coordinate is the distance between the center of mass of fragment A
       (range of atoms: [ a,b ]) and that of fragment B (range of atoms: [ c,d
       ]).  Specification of this coordinate type necessitates input of
       masses.


       So, for example, the simple internal coordinates for water would be:

       intco: (
         stre = (
          (1 1 2)
          (2 1 3))
         bend = (
          (3 2 1 3))
        )

       where the oxygen is atom 1, and the hydrogens are atoms 2 and 3.


   SYMMETRIZED INTERNAL COORDINATES
       The definition of symmetrized internal coordinates is a little more
       complex.  SYMM  and ASYMM  arrays are constructed which define the
       totally symmetric and asymmetric symmetrized internal coordinates,
       respectively.

       The symmetry internal coordinates are entered as:
         symm = (
           (label (integer array) <(real array)>)
           (  "   " "   "  "   "  ) (repeat this until
           (  "   " "   "  "   "  )  all symmetric coordinates
           (  "   " "   "  "   "  )  are defined)
           )
         asymm = (
           (label (integer array) <(real array)>)
           (  "   " "   "  "   "  ) (repeat this until
           (  "   " "   "  "   "  )  all asymmetric coordinates
           (  "   " "   "  "   "  )  are defined)
           )

       where label is a string used to denote the particular symmetry
       coordinate, integer array lists the numbers of the simple internal
       coordinates involved in the symmetry coordinate (including a positive
       or negative sign for the linear combination), and real array is an
       optional array of the coefficients of each simple internal coordinate
       in the symmetry coordinate.  For the water example, above, the symmetry
       coordinates would be specified in the intco input section by:

       intco: (
         stre = (
          (1 1 2)
          (2 1 3))
         bend = (
          (3 2 1 3))

         symm = (
           ("o-h symm st" (1 2) (1.0 1.0))
           ("oh2 bend" (3 1 2))
           }
         asymm = (
           ("o-h asymm st" (1 -2)(1.0 1.0))
           )
         )

       If the optional coefficients are not specified they default to 1.0.


PRINT CONTROL
       Printing in intder is controlled by the IPRINT option.  This is a four
       digit number, DCBA, the meaning of which is as follows:









DIPOLE MOMENT DERIVATIVES
       If TRANS_DIPDER = TRUE, then dipole moment derivatives are to be read
       from (if TRANS_TYPE = C_TO_I) or from (if TRANS_TYPE = I_TO_C).

       The information required in is:



       The information required in is:




TESTING INTDER95
       A set of input decks designed for testing many of intder95's features
       are available in the tests subdirectory of the intder95 source code
       repository.  The 18 test cases are provided with input decks with both
       old and new style input, output files, and other data files.

       @



                                   Feb 2004                          intder(1)