---

molfile_plugin.h

Go to the documentation of this file.

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

/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: molfile_plugin.h,v $
 *      $Author: johns $       $Locker:  $             $State: Exp $
 *      $Revision: 1.48 $       $Date: 2008/06/25 04:46:44 $
 *
 ***************************************************************************/

#ifndef MOL_FILE_PLUGIN_H
#define MOL_FILE_PLUGIN_H

#include "vmdplugin.h"

#define MOLFILE_PLUGIN_TYPE "mol file reader"

#define MOLFILE_CONVERTER_PLUGIN_TYPE "mol file converter"

/* File plugin symbolic constants for better code readability */
#define MOLFILE_SUCCESS           0   
#define MOLFILE_EOF              -1   
#define MOLFILE_ERROR            -1   
#define MOLFILE_NOSTRUCTUREDATA  -2   
#define MOLFILE_NUMATOMS_UNKNOWN -1   
#define MOLFILE_NUMATOMS_NONE     0   
#define MOLFILE_BUFSIZ           81   
typedef struct {
  char database[81];   
  char accession[81];  
  char date[81];       
  char title[81];      
  int remarklen;       
  char *remarks;       
} molfile_metadata_t;


/* 
 * Struct for specifying atoms in a molecular structure.  The first 
 * six components are required, the rest are optional and their presence is 
 * indicating by setting the corresponding bit in optsflag.  When omitted,
 * the application (for read_structure) or plugin (for write_structure) 
 * must be able to supply default values if the missing parameters are 
 * part of its internal data structure.
 * Note that it is not possible to specify coordinates with this structure.
 * This is intentional; all coordinate I/O is done with the read_timestep and 
 * write_timestep functions. 
 */

typedef struct {
  /* these fields absolutely must be set or initialized to empty */
  char name[16];      
  char type[16];      
  char resname[8];    
  int resid;          
  char segid[8];      
  char chain[2];      
  /* rest are optional; use optflags to specify what's present   */
  char altloc[2];     
  char insertion[2];  
  float occupancy;    
  float bfactor;      
  float mass;         
  float charge;       
  float radius;       
  int atomicnumber;   
} molfile_atom_t;

#define MOLFILE_NOOPTIONS     0x0000 
#define MOLFILE_INSERTION     0x0001 
#define MOLFILE_OCCUPANCY     0x0002 
#define MOLFILE_BFACTOR       0x0004 
#define MOLFILE_MASS          0x0008 
#define MOLFILE_CHARGE        0x0010 
#define MOLFILE_RADIUS        0x0020 
#define MOLFILE_ALTLOC        0x0040 
#define MOLFILE_ATOMICNUMBER  0x0080 
#define MOLFILE_BONDSSPECIAL  0x0100 
#define MOLFILE_BADOPTIONS    0xFFFFFFFF 

#if vmdplugin_ABIVERSION > 10
typedef struct molfile_timestep_metadata {
  unsigned count;      
  unsigned avg_bytes_per_timestep; 
  int has_velocities;  
} molfile_timestep_metadata_t;
#endif

/*
 * Per-timestep atom coordinates and periodic cell information
 */ 
typedef struct {
  float *coords;  
  float *velocities; 
  float A, B, C, alpha, beta, gamma; 
  double physical_time; 
} molfile_timestep_t;


typedef struct {
  char dataname[256]; 
  float origin[3];    
  /*
   * x/y/z axis:
   * These the three cell sides, providing both direction and length
   * (not unit vectors) for the x, y, and z axes.  In the simplest
   * case, these would be <size,0,0> <0,size,0> and <0,0,size) for 
   * an orthogonal cubic volume set.  For other cell shapes these
   * axes can be oriented non-orthogonally, and the parallelpiped
   * may have different side lengths, not just a cube/rhombus.
   */
  float xaxis[3];     
  float yaxis[3];     
  float zaxis[3];     
  /*
   * x/y/z size: 
   * Number of grid cells along each axis.  This is _not_ the
   * physical size of the box, this is the number of voxels in each
   * direction, independent of the shape of the volume set. 
   */
  int xsize;          
  int ysize;          
  int zsize;          
  int has_color;      
} molfile_volumetric_t;


/* XXX disabled until next major plugin ABI rev */
#if vmdplugin_ABIVERSION > 9

typedef struct {
  /* hessian data */
  unsigned int nimag;            /* number of imaginary modes */
  unsigned int nintcoords;       /* number of internal coordinates */
  unsigned int ncart;            /* number of cartesian coordinates */

  /* orbital data */
  unsigned int num_basis_funcs;  /* number of uncontracted basis functions in basis array */
  unsigned int num_shells;       /* total number of atomic shells */
  unsigned int orbital_counter;  /* counts the number of orbitals present in the output file */

  /* everything else */
  unsigned int num_traj_points;  /* number of trajectory points, 1 for single point runs */
  unsigned int have_trajectory;  /* flag indicating trajectory data */
} molfile_qm_metadata_t;


typedef struct {
  double *carthessian;      /* hessian matrix in cartesian coordinates (ncart)*(ncart) as a single array of doubles (row(1), ...,row(natoms)) */
  int *imag_modes;          /* list(nimag) of imaginary modes */
  double *inthessian;       /* hessian matrix in internal coordinates (nintcoords*nintcoords) as a single array of doubles (row(1), ...,row(nintcoords)) */
  double *wavenumbers;      /* array(ncart) of wavenumbers of normal modes */
  double *intensities;      /* array(ncart) of intensities of normal modes */
  double *normalmodes;      /* matrix(ncart*ncart) of normal modes  */
} molfile_qm_hessian_t;


typedef struct {
  unsigned int *basis_counter;    /* array holding the number of basis function per atom i */
  unsigned int *atomic_shells;    /* number of shells per atom i */
  unsigned int *shell_primitives; /* number of shell primitives shell i */
  unsigned int homo_index;        /* index "pointing" to the HOMO */

  float *basis;                   /* array holding the contraction coeffients and exponents for the basis functions in the form { exp(1), c-coeff(1), exp(2), c-coeff(2), ....}; of size 2*num_basis_funcs */
  char *orbital_symmetry;         /* symmetry type (S, L, P, ..) per (exp(),c-coeff()) pair in basis */
} molfile_qm_orbital_t;


typedef struct {
  unsigned int runtyp;                  /* runtyp for internal use */
  unsigned int nproc;                   /* number of processors used */
  unsigned int num_gauss_basis_funcs;   /* number of gaussian basis functions */
  unsigned int num_electrons;           /* number of electrons */
  unsigned int totalcharge;             /* total charge of system */
  unsigned int multiplicity;            /* multiplicity of system */
  unsigned int num_orbitals_A;          /* number of alpha orbitals */
  unsigned int num_orbitals_B;          /* number of beta orbitals */
  unsigned int scftyp;                  /* scftyp for internal use */
  unsigned int ngauss;                  /* number of gaussian basis functions */
  unsigned int npfunc;                  /* number of p polarization functions: 0 ..3 */
  unsigned int ndfunc;                  /* number of d polarization functions: 0 ..3 */
  unsigned int nffunc;                  /* number of f polarization functions: 0 or 1 */
  unsigned int diffs;                   /* number of diffuse s functions: 0 or 1 */
  unsigned int diffsp;                  /* number of diffuse sp functions: 0 or 1 */
  double *nuc_charge;                   /* array(natom) containing the nuclear charge of atom i */

  char runtyp_string[MOLFILE_BUFSIZ];   /* runtyp as string for punching */
  char scftyp_string[MOLFILE_BUFSIZ];   /* scftyp as string for punching */
  char basis_string[MOLFILE_BUFSIZ];    /* basis name as "nice" string for punch
ing */
  char memory[MOLFILE_BUFSIZ];          /* amount of memory used, e.g. 1Gb */
  char gbasis[MOLFILE_BUFSIZ];          /* type of gbasis used, e.g. N21, N31, N
311, ... */
  char runtitle[MOLFILE_BUFSIZ];        /* title of run */
  char guess[MOLFILE_BUFSIZ];           /* guess option used */
  char geometry[MOLFILE_BUFSIZ];        /* typ of provided geometry, e.g. UNIQUE
, ZMT, CART, ... */
  char version_string[MOLFILE_BUFSIZ];  /* QM code version information */
} molfile_qm_sysinfo_t;


typedef struct {
  float *wave_function;     /* expansion coefficients for wavefunction in the form {orbital1(c1),orbital1(c2),.....,orbi talM(cN)} */
#if vmdplugin_ABIVERSION > 11
  int   scfiter;            /* number of SCF iterations */
#endif
  double *scfenergies;      /* scfenergies per trajectory point */
  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 */
} molfile_qm_timestep_t;


typedef struct {
  molfile_qm_hessian_t hess;            /* hessian info */
  molfile_qm_orbital_t orb;             /* orbital info */
  molfile_qm_sysinfo_t run;             /* system info  */
} molfile_qm_t;


#endif


enum molfile_graphics_type {
  MOLFILE_POINT,  MOLFILE_TRIANGLE, MOLFILE_TRINORM, MOLFILE_NORMS, 
  MOLFILE_LINE,   MOLFILE_CYLINDER, MOLFILE_CAPCYL,  MOLFILE_CONE,    
  MOLFILE_SPHERE, MOLFILE_TEXT,     MOLFILE_COLOR,   MOLFILE_TRICOLOR
};

typedef struct {
  int type;             /* One of molfile_graphics_type */
  int style;            /* A general style parameter    */
  float size;           /* A general size parameter     */
  float data[9];        /* All data for the element     */
} molfile_graphics_t;


/*
 * Types for raw graphics elements stored in files.  Data for each type
 * should be stored by the plugin as follows:

type        data                                     style       size
----        ----                                     -----       ----
point       x, y, z                                              pixel size
triangle    x1,y1,z1,x2,y2,z2,x3,y3,z3                 
trinorm     x1,y1,z1,x2,y2,z2,x3,y3,z3                 
            the next array element must be NORMS
tricolor    x1,y1,z1,x2,y2,z2,x3,y3,z3                 
            the next array elements must be NORMS
            the following element must be COLOR, with three RGB triples
norms       x1,y1,z1,x2,y2,z2,x3,y3,z3                 
line        x1,y1,z1,x2,y2,z2                        0=solid     pixel width
                                                     1=stippled
cylinder    x1,y1,z1,x2,y2,z2                        resolution  radius
capcyl      x1,y1,z1,x2,y2,z2                        resolution  radius
sphere      x1,y1,z1                                 resolution  radius
text        x, y, z, up to 24 bytes of text                      pixel size
color       r, g, b
*/


typedef struct {
  vmdplugin_HEAD

  const char *filename_extension;

  void *(* open_file_read)(const char *filepath, const char *filetype, 
      int *natoms);
  
  int (*read_structure)(void *, int *optflags, molfile_atom_t *atoms);

  int (*read_bonds)(void *, int *nbonds, int **from, int **to, float **bondorder);

  int (* read_next_timestep)(void *, int natoms, molfile_timestep_t *);

  void (* close_file_read)(void *);
   
  void *(* open_file_write)(const char *filepath, const char *filetype, 
      int natoms);
  
  int (* write_structure)(void *, int optflags, const molfile_atom_t *atoms);

  int (* write_timestep)(void *, const molfile_timestep_t *);
  
  void (* close_file_write)(void *);

  int (* read_volumetric_metadata)(void *, int *nsets, 
        molfile_volumetric_t **metadata);

  int (* read_volumetric_data)(void *, int set, float *datablock, 
        float *colorblock);

  int (* read_rawgraphics)(void *, int *nelem, const molfile_graphics_t **data);

  int (* read_molecule_metadata)(void *, molfile_metadata_t **metadata);
  
  int (* write_bonds)(void *, int nbonds, int *from, int *to, float *bondorder);

/* XXX disabled until next major plugin ABI rev */
#if vmdplugin_ABIVERSION > 9

  int (* write_volumetric_data)(void *, molfile_volumetric_t *metadata,
                                float *datablock, float *colorblock);

  int (* read_angles)(void *,
                int *numangles,    int *angles,    double *angleforces,
                int *numdihedrals, int *dihedrals, double *dihedralforces,
                int *numimpropers, int *impropers, double *improperforces,
                int *numcterms,    int *cterms, 
                int *ctermcols, int *ctermrows, double *ctermforces);

  int (* write_angles)(void *,
        int numangles,    const int *angles,    const double *angleforces,
        int numdihedrals, const int *dihedrals, const double *dihedralforces,
        int numimpropers, const int *impropers, const double *improperforces,
        int numcterms,   const int *cterms,    
        int ctermcols, int ctermrows, const double *ctermforces);

  int (* read_qm_metadata)(void *, molfile_qm_metadata_t *metadata);

  int (* read_qm_rundata)(void *, molfile_qm_t *qmdata);

  int (* read_timestep)(void *, int natoms, molfile_timestep_t *,
                        molfile_qm_metadata_t *, molfile_qm_timestep_t *);
#endif

#if vmdplugin_ABIVERSION > 10
  int (* read_timestep_metadata)(void *, molfile_timestep_metadata_t *);
#endif

} molfile_plugin_t;

#endif

---