---

gaussianplugin.h

Go to the documentation of this file.

/***************************************************************************
 *cr
 *cr            (C) Copyright 1995-2016 The Board of Trustees of the
 *cr                        University of Illinois
 *cr                         All Rights Reserved
 *cr
 ***************************************************************************/

/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: gaussianplugin.h,v $
 *      $Author: johns $       $Locker:  $             $State: Exp $
 *      $Revision: 1.10 $       $Date: 2016/11/28 05:01:54 $
 *
 ***************************************************************************/
/*******************************************************************
 * 
 *  headerfile for the gaussianplugin
 *  
 ******************************************************************/

#ifndef GAUSSIANPLUGIN_H
#define GAUSSIANPLUGIN_H

#include <stdio.h>
#include "molfile_plugin.h"

/* define macros for true/false to make code 
* look somewhat nicer; the macro DONE signals
* that we're done with reading an should return
* with what we have */
#define FALSE 0
#define TRUE  1

#define RUNTYP_UNKNOWN    0     
#define RUNTYP_ENERGY     1     
#define RUNTYP_OPTIMIZE   2     
#define RUNTYP_SADPOINT   3     
#define RUNTYP_HESSIAN    4     
#define RUNTYP_SURFACE    5     
#define RUNTYP_DYNAMICS   6     
#define RUNTYP_PROPERTIES 7     
#define SCFTYP_UNKNOWN 0        
#define SCFTYP_RHF   1          
#define SCFTYP_UHF   2          
#define SCFTYP_ROHF  3          
#define SCFTYP_GVB   4          
#define SCFTYP_MCSCF 5          
#define SCFTYP_FF    6          
#define MAX_NUM_WAVE 10

typedef struct {
  float exponent;
  float contraction_coeff;
} prim_t;


typedef struct {
  int symmetry;                 /* symmetry of this shell (S, P, D, ...) */
  int numprims;                 /* number of primitive basis functions */
  prim_t *prim;                 /* array of primitives */
} shell_t;


typedef struct {
  char name[20];                /* atom name or type (pseudopotentialfile?) */
  int atomicnum;                /* atomic number (nuclear charge XXX) */
  int numshells;
  shell_t *shell;
} basis_atom_t;


typedef struct 
{
  char type [8];                /* atom type H,N,O ..... */
  int atomicnum;                /* index in PTE. */
  float x,y,z;                  /* coordinates of atom i */
} qm_atom_t;


typedef struct {
  int   idtag;              
  int   type;               
  int   spin;               
  int   cartesian;          
  int   excitation;         
  char info[MOLFILE_BUFSIZ]; 
  int   num_orbitals;       
  int   *orb_indices;       
  float *occupancies;       
  float *orb_energies;      
  float *wave_coeffs;       
} qm_wavefunction_t;


typedef struct {
  qm_wavefunction_t *wave;  
  int numwave;              
  int num_orbitals;         
  int num_scfiter;          
  double *scfenergies;      /* scfenergies per trajectory point 
                             * XXX: how about post-HF calculations?
                             *      we have the HF, MP2, CASSCF, CCS,
                             *      CCSD, CCSD(T) energies... */

  double *mulliken_charges; /* per-atom Mulliken charges */
  double *lowdin_charges;   /* per-atom Lowdin charges */
  double *esp_charges;      /* per-atom esp charges */
  double *npa_charges;      /* per-atom npa charges */

  float *gradient;          /* energy gradient for each atom */
} qm_timestep_t;


typedef struct 
{
  FILE *file;
  int numatoms;
  int runtyp;        /* run type of this job as int for internal use */
  char gbasis[20];   /* canonicalized basis set string
                        for loading and external basis set. */

  char basis_string[MOLFILE_BUFSIZ]; /* basis name as "nice" string */

  char runtitle[MOLFILE_BUFSIZ];  /* title/info section of run */

  char geometry[MOLFILE_BUFSIZ];  /* either UNIQUE, CART or ZMP/ZMTMPC */
  char guess[MOLFILE_BUFSIZ];    /* type of guess method used */

  char version_string[MOLFILE_BUFSIZ]; /* full version string of binary used for run */
  int  version;  /* gaussian version code;
                  * canonicalized and set up for integer comparisons.
                  * here we keep track the exact Gaussian version,
                  * since the log file format keeps changing all
                  * the time. 
                  * Format is Year/Revision/Patchlevel: YYYYRRPP
                  * with:
                  * YYYY: g94 -> 1994, g98 -> 1998, g03 -> 2003
                  *   RR: A -> 1, B -> 2, C ->3, ...
                  *   PP: 01, 02, 03, ...
                  *
                  *   Example: G03RevB.04 -> 20030204
                  *
                  *   version = 0  => unknown/unreadable version. 
                  */

  char *file_name;

  /******************************************************
   * new API functions
   *****************************************************/

  int  scftyp;              /* UHF, RHF, ROHF, as in for 
                             * internal use*/
  char scftyp_string[MOLFILE_BUFSIZ]; /* scftyp as string. XXX: remove */
  int totalcharge;              /* Total charge of the system */
  int multiplicity;             /* Multiplicity of the system */
  int num_electrons;            /* Number of electrons */
  int nimag;                    /* Number of imaginary frequencies */
  int *nimag_modes;             /* List of imaginary modes */

  float *wavenumbers;          /* rotational and translational DoF are
                                 * included, but can be removed due to
                                 * their zero frequencies */
  float *intensities;          /* Intensities of spectral lines */

  float *normal_modes;         /* the normal modes themselves */

  int nproc;                    /* Number processors used */
  int memory;                   /* Amount of memory used in MBytes */

  int have_wavefunction; 
  int have_basis;        
  int have_cart_basis;   
  /* arrays with atom charges */
  double *mulliken_charges; 
  int   have_mulliken; 

  int have_normal_modes; 
  /******************************************************
   * internal coordinate stuff
   *****************************************************/

  int have_internals;  /* TRUE/FALSE flag indicating if we
                        * could properly read the internal
                        * coordinates + internal hessian */

  int have_cart_hessian; /* TRUE/FALSE flag indicating if the
                          * cartesian Hessian matrix could
                          * be read from the output file */

  int nintcoords;    /* Number of internal coordinates */
  int nbonds;        /* Number of bonds */
  int nangles;       /* Number of angles */
  int ndiheds;       /* Number of dihedrals */
  int nimprops;      /* Number of impropers */

  int *bonds;        /* bond list (atom tuples) */
  int *angles;       /* angle list (atom triples) */
  int *dihedrals;    /* dihedral list (atom quadrupels) */
  int *impropers;    /* improper list (atom quadrupels) */

  double *internal_coordinates; /* value of internal coordinates */ 
  
  /*******************************************************
   * end internal coordinate stuff
   *******************************************************/

  double *carthessian;  /* Hessian matrix in cartesian coordinates,
                         * dimension (3*numatoms)*(3*numatoms),
                         * single array of floats 
                         * (row(1),row(2),...,row(numatoms))
                         */

  double *inthessian;  /* Hessian matrix in internal coordinates,
                        * dimension nintcoords*nintcoords,
                        * single array of floats 
                        * (row(1),row(2),...,row(nintcoords))
                        */

  /*********************************************************
   * END OF NEW API data members
   *********************************************************/

  /* this array of floats stores the contraction coefficients
   * and exponents for the basis functions:
   * { exp(1), c-coeff(1), exp(2), c-coeff(2), .... }
   * This holds also for double-zeta basis functions with
   * exp(i) = exp(j) and c-coeff(i) != c-coeff(j). */
  float *basis;

  basis_atom_t *basis_set;

  int num_basis_funcs;          
  int num_basis_atoms;          
  int *atomicnum_per_basisatom;

  int num_shells;
  int *num_shells_per_atom;
  int *num_prim_per_shell;
  int *shell_symmetry; 

  int occ_orbitals_A;
  int occ_orbitals_B;

  int wavef_size;
  int num_orbitals;      /* number of orbitals in file. can be less if pure WF. */

  int *angular_momentum;

  int converged;
  int opt_status;

  /* the structure qm_atom_t was defined to read in data from
   * the Gaussian output file and store it temporarily;
   * it is then copied into the VMD specific arrays at the
   * appropriate point in time;
   * this was partially implemented since the output file does
   * not, e.g., contain the number of atoms per se. One rather
   * has to count them by hand - at that point one could as 
   * well already read in the initial coordinates, atom types ...
   * which is not really supported by the way the VMD provided
   * function are arranged....this implementation could of
   * course be changed later..... */
  qm_atom_t *initatoms;

  float initcell[6];

  qm_timestep_t *qm_timestep;

  int num_frames;
  int num_frames_sent;
  int num_frames_read;

  int end_of_trajectory;

} gaussiandata;

#endif

---