src/gromacs/legacyheaders/types/inputrec.h

   1 /*
   2  *
   3  *                This source code is part of
   4  *
   5  *                 G   R   O   M   A   C   S
   6  *
   7  *          GROningen MAchine for Chemical Simulations
   8  *
   9  *                        VERSION 3.2.0
  10  * Written by David van der Spoel, Erik Lindahl, Berk Hess, and others.
  11  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
  12  * Copyright (c) 2001-2004, The GROMACS development team,
  13  * check out http://www.gromacs.org for more information.
  14
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  * If you want to redistribute modifications, please consider that
  21  * scientific software is very special. Version control is crucial -
  22  * bugs must be traceable. We will be happy to consider code for
  23  * inclusion in the official distribution, but derived work must not
  24  * be called official GROMACS. Details are found in the README & COPYING
  25  * files - if they are missing, get the official version at www.gromacs.org.
  26  *
  27  * To help us fund GROMACS development, we humbly ask that you cite
  28  * the papers on the package - you can find them in the top README file.
  29  *
  30  * For more info, check our website at http://www.gromacs.org
  31  *
  32  * And Hey:
  33  * GRoups of Organic Molecules in ACtion for Science
  34  */
  35 #ifndef _inputrec_h_
  36 #define _inputrec_h_
  37
  38
  39 #include "simple.h"
  40 #include "../sysstuff.h"
  41
  42 #ifdef __cplusplus
  43 extern "C" {
  44 #endif
  45
  46
  47 typedef struct {
  48     int   n;    /* Number of terms                              */
  49     real *a;    /* Coeffients (V / nm )                     */
  50     real *phi;  /* Phase angles                                 */
  51 } t_cosines;
  52
  53 typedef struct {
  54     real E0;            /* Field strength (V/nm)                        */
  55     real omega;         /* Frequency (1/ps)                             */
  56     real t0;            /* Centre of the Gaussian pulse (ps)            */
  57     real sigma;         /* Width of the Gaussian pulse (FWHM) (ps)      */
  58 } t_efield;
  59
  60 #define EGP_EXCL  (1<<0)
  61 #define EGP_TABLE (1<<1)
  62
  63 typedef struct {
  64     int       ngtc;           /* # T-Coupl groups                        */
  65     int       nhchainlength;  /* # of nose-hoover chains per group       */
  66     int       ngacc;          /* # Accelerate groups                     */
  67     int       ngfrz;          /* # Freeze groups                         */
  68     int       ngener;         /* # Ener groups                      */
  69     real     *nrdf;           /* Nr of degrees of freedom in a group        */
  70     real     *ref_t;          /* Coupling temperature   per group   */
  71     int      *annealing;      /* No/simple/periodic SA for each group    */
  72     int      *anneal_npoints; /* Number of annealing time points per grp */
  73     real    **anneal_time;    /* For ea. group: Time points              */
  74     real    **anneal_temp;    /* For ea. grp: Temperature at these times */
  75                               /* Final temp after all intervals is ref_t */
  76     real     *tau_t;          /* Tau coupling time              */
  77     rvec     *acc;            /* Acceleration per group             */
  78     ivec     *nFreeze;        /* Freeze the group in each direction ?    */
  79     int      *egp_flags;      /* Exclusions/tables of energy group pairs */
  80
  81     /* QMMM stuff */
  82     int          ngQM;         /* nr of QM groups                              */
  83     int         *QMmethod;     /* Level of theory in the QM calculation        */
  84     int         *QMbasis;      /* Basisset in the QM calculation               */
  85     int         *QMcharge;     /* Total charge in the QM region                */
  86     int         *QMmult;       /* Spin multiplicicty in the QM region          */
  87     gmx_bool    *bSH;          /* surface hopping (diabatic hop only)          */
  88     int         *CASorbitals;  /* number of orbiatls in the active space       */
  89     int         *CASelectrons; /* number of electrons in the active space      */
  90     real        *SAon;         /* at which gap (A.U.) the SA is switched on    */
  91     real        *SAoff;
  92     int         *SAsteps;      /* in how many steps SA goes from 1-1 to 0.5-0.5*/
  93     gmx_bool    *bOPT;
  94     gmx_bool    *bTS;
  95 } t_grpopts;
  96
  97 enum {
  98     epgrppbcNONE, epgrppbcREFAT, epgrppbcCOS
  99 };
 100
 101 typedef struct {
 102     int         nat;        /* Number of atoms in the pull group */
 103     atom_id    *ind;        /* The global atoms numbers */
 104     int         nat_loc;    /* Number of local pull atoms */
 105     int         nalloc_loc; /* Allocation size for ind_loc and weight_loc */
 106     atom_id    *ind_loc;    /* Local pull indices */
 107     int         nweight;    /* The number of weights (0 or nat) */
 108     real       *weight;     /* Weights (use all 1 when weight==NULL) */
 109     real       *weight_loc; /* Weights for the local indices */
 110     int         epgrppbc;   /* The type of pbc for this pull group, see enum above */
 111     atom_id     pbcatom;    /* The reference atom for pbc (global number) */
 112     rvec        vec;        /* The pull vector, direction or position */
 113     rvec        init;       /* Initial reference displacement */
 114     real        rate;       /* Rate of motion (nm/ps) */
 115     real        k;          /* force constant */
 116     real        kB;         /* force constant for state B */
 117     real        wscale;     /* scaling factor for the weights: sum w m/sum w w m */
 118     real        invtm;      /* inverse total mass of the group: 1/wscale sum w m */
 119     dvec        x;          /* center of mass before update */
 120     dvec        xp;         /* center of mass after update before constraining */
 121     dvec        dr;         /* The distance from the reference group */
 122     double      f_scal;     /* Scalar force for directional pulling */
 123     dvec        f;          /* force due to the pulling/constraining */
 124 } t_pullgrp;
 125
 126 typedef struct {
 127     int   eSimTempScale; /* simulated temperature scaling; linear or exponential */
 128     real  simtemp_low;   /* the low temperature for simulated tempering  */
 129     real  simtemp_high;  /* the high temperature for simulated tempering */
 130     real *temperatures;  /* the range of temperatures used for simulated tempering */
 131 } t_simtemp;
 132
 133 typedef struct {
 134     int    nstdhdl;                 /* The frequency for calculating dhdl           */
 135     double init_lambda;             /* fractional value of lambda (usually will use
 136                                        init_fep_state, this will only be for slow growth,
 137                                        and for legacy free energy code. Only has a
 138                                        valid value if positive)   */
 139     int      init_fep_state;        /* the initial number of the state                   */
 140     double   delta_lambda;          /* change of lambda per time step (fraction of (0.1) */
 141     gmx_bool bPrintEnergy;          /* Whether to print the energy in the dhdl           */
 142     int      n_lambda;              /* The number of foreign lambda points               */
 143     double **all_lambda;            /* The array of all lambda values                    */
 144     int      lambda_neighbors;      /* The number of neighboring lambda states to
 145                                        calculate the energy for in up and down directions
 146                                        (-1 for all) */
 147     int      lambda_start_n;        /* The first lambda to calculate energies for */
 148     int      lambda_stop_n;         /* The last lambda +1 to calculate energies for */
 149     real     sc_alpha;              /* free energy soft-core parameter                   */
 150     int      sc_power;              /* lambda power for soft-core interactions           */
 151     real     sc_r_power;            /* r power for soft-core interactions                */
 152     real     sc_sigma;              /* free energy soft-core sigma when c6 or c12=0      */
 153     real     sc_sigma_min;          /* free energy soft-core sigma for ?????             */
 154     gmx_bool bScCoul;               /* use softcore for the coulomb portion as well (default FALSE) */
 155     gmx_bool separate_dvdl[efptNR]; /* whether to print the dvdl term associated with
 156                                        this term; if it is not specified as separate,
 157                                        it is lumped with the FEP term */
 158     int    separate_dhdl_file;      /* whether to write a separate dhdl.xvg file
 159                                        note: NOT a gmx_bool, but an enum */
 160     int    dhdl_derivatives;        /* whether to calculate+write dhdl derivatives
 161                                        note: NOT a gmx_bool, but an enum */
 162     int    dh_hist_size;            /* The maximum table size for the dH histogram */
 163     double dh_hist_spacing;         /* The spacing for the dH histogram */
 164 } t_lambda;
 165
 166 typedef struct {
 167     int      nstexpanded;         /* The frequency of expanded ensemble state changes */
 168     int      elamstats;           /* which type of move updating do we use for lambda monte carlo (or no for none) */
 169     int      elmcmove;            /* what move set will be we using for state space moves */
 170     int      elmceq;              /* the method we use to decide of we have equilibrated the weights */
 171     int      equil_n_at_lam;      /* the minumum number of samples at each lambda for deciding whether we have reached a minimum */
 172     real     equil_wl_delta;      /* WL delta at which we stop equilibrating weights */
 173     real     equil_ratio;         /* use the ratio of weights (ratio of minimum to maximum) to decide when to stop equilibrating */
 174     int      equil_steps;         /* after equil_steps steps we stop equilibrating the weights */
 175     int      equil_samples;       /* after equil_samples total samples (steps/nstfep), we stop equilibrating the weights */
 176     int      lmc_seed;            /* random number seed for lambda mc switches */
 177     gmx_bool minvar;              /* whether to use minumum variance weighting */
 178     int      minvarmin;           /* the number of samples needed before kicking into minvar routine */
 179     real     minvar_const;        /* the offset for the variance in MinVar */
 180     int      c_range;             /* range of cvalues used for BAR */
 181     gmx_bool bSymmetrizedTMatrix; /* whether to print symmetrized matrices */
 182     int      nstTij;              /* How frequently to print the transition matrices */
 183     int      lmc_repeats;         /* number of repetitions in the MC lambda jumps */  /*MRS -- VERIFY THIS */
 184     int      lmc_forced_nstart;   /* minimum number of samples for each state before free sampling */ /* MRS -- VERIFY THIS! */
 185     int      gibbsdeltalam;       /* distance in lambda space for the gibbs interval */
 186     real     wl_scale;            /* scaling factor for wang-landau */
 187     real     wl_ratio;            /* ratio between largest and smallest number for freezing the weights */
 188     real     init_wl_delta;       /* starting delta for wang-landau */
 189     gmx_bool bWLoneovert;         /* use one over t convergece for wang-landau when the delta get sufficiently small */
 190     gmx_bool bInit_weights;       /* did we initialize the weights? */
 191     real     mc_temp;             /* To override the main temperature, or define it if it's not defined */
 192     real    *init_lambda_weights; /* user-specified initial weights to start with  */
 193 } t_expanded;
 194
 195 typedef struct {
 196     int            ngrp;       /* number of groups */
 197     int            eGeom;      /* pull geometry */
 198     ivec           dim;        /* used to select components for constraint */
 199     real           cyl_r1;     /* radius of cylinder for dynamic COM */
 200     real           cyl_r0;     /* radius of cylinder including switch length */
 201     real           constr_tol; /* absolute tolerance for constraints in (nm) */
 202     int            nstxout;    /* Output frequency for pull x */
 203     int            nstfout;    /* Output frequency for pull f */
 204     int            ePBC;       /* the boundary conditions */
 205     int            npbcdim;    /* do pbc in dims 0 <= dim < npbcdim */
 206     gmx_bool       bRefAt;     /* do we need reference atoms for a group COM ? */
 207     int            cosdim;     /* dimension for cosine weighting, -1 if none */
 208     gmx_bool       bVirial;    /* do we need to add the pull virial? */
 209     t_pullgrp     *grp;        /* groups to pull/restrain/etc/ */
 210     t_pullgrp     *dyna;       /* dynamic groups for use with local constraints */
 211     rvec          *rbuf;       /* COM calculation buffer */
 212     dvec          *dbuf;       /* COM calculation buffer */
 213     double        *dbuf_cyl;   /* cylinder ref. groups COM calculation buffer */
 214
 215     FILE          *out_x;      /* output file for pull data */
 216     FILE          *out_f;      /* output file for pull data */
 217 } t_pull;
 218
 219
 220 /* Abstract types for enforced rotation only defined in pull_rotation.c       */
 221 typedef struct gmx_enfrot *gmx_enfrot_t;
 222 typedef struct gmx_enfrotgrp *gmx_enfrotgrp_t;
 223
 224 typedef struct {
 225     int         eType;             /* Rotation type for this group                  */
 226     int         bMassW;            /* Use mass-weighed positions?                   */
 227     int         nat;               /* Number of atoms in the group                  */
 228     atom_id    *ind;               /* The global atoms numbers                      */
 229     rvec       *x_ref;             /* The reference positions                       */
 230     rvec        vec;               /* The normalized rotation vector                */
 231     real        rate;              /* Rate of rotation (degree/ps)                  */
 232     real        k;                 /* Force constant (kJ/(mol nm^2)                 */
 233     rvec        pivot;             /* Pivot point of rotation axis (nm)             */
 234     int         eFittype;          /* Type of fit to determine actual group angle   */
 235     int         PotAngle_nstep;    /* Number of angles around the reference angle
 236                                       for which the rotation potential is also
 237                                       evaluated (for fit type 'potential' only)     */
 238     real            PotAngle_step; /* Distance between two angles in degrees (for
 239                                       fit type 'potential' only)                    */
 240     real            slab_dist;     /* Slab distance (nm)                            */
 241     real            min_gaussian;  /* Minimum value the gaussian must have so that
 242                                       the force is actually evaluated               */
 243     real            eps;           /* Additive constant for radial motion2 and
 244                                       flexible2 potentials (nm^2)                   */
 245     gmx_enfrotgrp_t enfrotgrp;     /* Stores non-inputrec rotation data per group   */
 246 } t_rotgrp;
 247
 248 typedef struct {
 249     int          ngrp;       /* Number of rotation groups                     */
 250     int          nstrout;    /* Output frequency for main rotation outfile    */
 251     int          nstsout;    /* Output frequency for per-slab data            */
 252     t_rotgrp    *grp;        /* Groups to rotate                              */
 253     gmx_enfrot_t enfrot;     /* Stores non-inputrec enforced rotation data    */
 254 } t_rot;
 255
 256
 257 typedef struct {
 258     int      type;           /* type of AdResS simulation                    */
 259     gmx_bool bnew_wf;        /* enable new AdResS weighting function         */
 260     gmx_bool bchempot_dx;    /*true:interaction table format input is F=-dmu/dx   false: dmu_dwp  */
 261     gmx_bool btf_full_box;   /* true: appy therm force everywhere in the box according to table false: only in hybrid region */
 262     real     const_wf;       /* value of weighting function for eAdressConst */
 263     real     ex_width;       /* center of the explicit zone                  */
 264     real     hy_width;       /* width of the hybrid zone                     */
 265     int      icor;           /* type of interface correction                 */
 266     int      site;           /* AdResS CG site location                      */
 267     rvec     refs;           /* Coordinates for AdResS reference             */
 268     real     ex_forcecap;    /* in the hybrid zone, cap forces large then this to adress_ex_forcecap */
 269     gmx_bool do_hybridpairs; /* If true pair interaction forces are also scaled in an adress way*/
 270
 271     int    * tf_table_index; /* contains mapping of energy group index -> i-th adress tf table*/
 272     int      n_tf_grps;
 273     int     *group_explicit;
 274     int      n_energy_grps;
 275 } t_adress;
 276
 277 typedef struct {
 278     int             eI;                   /* Integration method                 */
 279     gmx_large_int_t nsteps;               /* number of steps to be taken                        */
 280     int             simulation_part;      /* Used in checkpointing to separate chunks */
 281     gmx_large_int_t init_step;            /* start at a stepcount >0 (used w. tpbconv)    */
 282     int             nstcalcenergy;        /* frequency of energy calc. and T/P coupl. upd.      */
 283     int             cutoff_scheme;        /* group or verlet cutoffs     */
 284     int             ns_type;              /* which ns method should we use?               */
 285     int             nstlist;              /* number of steps before pairlist is generated       */
 286     int             ndelta;               /* number of cells per rlong                  */
 287     int             nstcomm;              /* number of steps after which center of mass */
 288     /* motion is removed                                */
 289     int             comm_mode;            /* Center of mass motion removal algorithm      */
 290     int             nstcheckpoint;        /* checkpointing frequency                      */
 291     int             nstlog;               /* number of steps after which print to logfile       */
 292     int             nstxout;              /* number of steps after which X is output    */
 293     int             nstvout;              /* id. for V                                  */
 294     int             nstfout;              /* id. for F                                  */
 295     int             nstenergy;            /* number of steps after which energies printed */
 296     int             nstxtcout;            /* id. for compressed trj (.xtc)              */
 297     double          init_t;               /* initial time (ps)              */
 298     double          delta_t;              /* time step (ps)                             */
 299     real            xtcprec;              /* precision of xtc file                        */
 300     real            fourier_spacing;      /* requested fourier_spacing, when nk? not set  */
 301     int             nkx, nky, nkz;        /* number of k vectors in each spatial dimension*/
 302                                           /* for fourier methods for long range electrost.*/
 303     int             pme_order;            /* interpolation order for PME                  */
 304     real            ewald_rtol;           /* Real space tolerance for Ewald, determines   */
 305                                           /* the real/reciprocal space relative weight    */
 306     int             ewald_geometry;       /* normal/3d ewald, or pseudo-2d LR corrections */
 307     real            epsilon_surface;      /* Epsilon for PME dipole correction            */
 308     gmx_bool        bOptFFT;              /* optimize the fft plan at start               */
 309     int             ePBC;                 /* Type of periodic boundary conditions               */
 310     int             bPeriodicMols;        /* Periodic molecules                           */
 311     gmx_bool        bContinuation;        /* Continuation run: starting state is correct        */
 312     int             etc;                  /* temperature coupling               */
 313     int             nsttcouple;           /* interval in steps for temperature coupling   */
 314     gmx_bool        bPrintNHChains;       /* whether to print nose-hoover chains        */
 315     int             epc;                  /* pressure coupling                            */
 316     int             epct;                 /* pressure coupling type                     */
 317     int             nstpcouple;           /* interval in steps for pressure coupling      */
 318     real            tau_p;                /* pressure coupling time (ps)                        */
 319     tensor          ref_p;                /* reference pressure (kJ/(mol nm^3))         */
 320     tensor          compress;             /* compressability ((mol nm^3)/kJ)        */
 321     int             refcoord_scaling;     /* How to scale absolute reference coordinates  */
 322     rvec            posres_com;           /* The COM of the posres atoms                  */
 323     rvec            posres_comB;          /* The B-state COM of the posres atoms          */
 324     int             andersen_seed;        /* Random seed for Andersen thermostat (obsolete) */
 325     real            verletbuf_drift;      /* Max. drift (kJ/mol/ps/atom) for list buffer  */
 326     real            rlist;                /* short range pairlist cut-off (nm)          */
 327     real            rlistlong;            /* long range pairlist cut-off (nm)           */
 328     int             nstcalclr;            /* Frequency of evaluating direct space long-range interactions */
 329     real            rtpi;                 /* Radius for test particle insertion           */
 330     int             coulombtype;          /* Type of electrostatics treatment             */
 331     int             coulomb_modifier;     /* Modify the Coulomb interaction              */
 332     real            rcoulomb_switch;      /* Coulomb switch range start (nm)            */
 333     real            rcoulomb;             /* Coulomb cutoff (nm)                                */
 334     real            epsilon_r;            /* relative dielectric constant                 */
 335     real            epsilon_rf;           /* relative dielectric constant of the RF       */
 336     int             implicit_solvent;     /* No (=explicit water), or GBSA solvent models */
 337     int             gb_algorithm;         /* Algorithm to use for calculation Born radii  */
 338     int             nstgbradii;           /* Frequency of updating Generalized Born radii */
 339     real            rgbradii;             /* Cutoff for GB radii calculation              */
 340     real            gb_saltconc;          /* Salt concentration (M) for GBSA models       */
 341     real            gb_epsilon_solvent;   /* dielectric coeff. of implicit solvent     */
 342     real            gb_obc_alpha;         /* 1st scaling factor for Bashford-Case GB      */
 343     real            gb_obc_beta;          /* 2nd scaling factor for Bashford-Case GB      */
 344     real            gb_obc_gamma;         /* 3rd scaling factor for Bashford-Case GB      */
 345     real            gb_dielectric_offset; /* Dielectric offset for Still/HCT/OBC     */
 346     int             sa_algorithm;         /* Algorithm for SA part of GBSA                */
 347     real            sa_surface_tension;   /* Energy factor for SA part of GBSA */
 348     int             vdwtype;              /* Type of Van der Waals treatment              */
 349     int             vdw_modifier;         /* Modify the VdW interaction                   */
 350     real            rvdw_switch;          /* Van der Waals switch range start (nm)        */
 351     real            rvdw;                 /* Van der Waals cutoff (nm)          */
 352     int             eDispCorr;            /* Perform Long range dispersion corrections    */
 353     real            tabext;               /* Extension of the table beyond the cut-off,   *
 354                                            * as well as the table length for 1-4 interac. */
 355     real            shake_tol;            /* tolerance for shake                                */
 356     int             efep;                 /* free energy calculations                     */
 357     t_lambda       *fepvals;              /* Data for the FEP state                       */
 358     gmx_bool        bSimTemp;             /* Whether to do simulated tempering            */
 359     t_simtemp      *simtempvals;          /* Variables for simulated tempering            */
 360     gmx_bool        bExpanded;            /* Whether expanded ensembles are used          */
 361     t_expanded     *expandedvals;         /* Expanded ensemble parameters              */
 362     int             eDisre;               /* Type of distance restraining                 */
 363     real            dr_fc;                /* force constant for ta_disre                        */
 364     int             eDisreWeighting;      /* type of weighting of pairs in one restraints       */
 365     gmx_bool        bDisreMixed;          /* Use comb of time averaged and instan. viol's       */
 366     int             nstdisreout;          /* frequency of writing pair distances to enx   */
 367     real            dr_tau;               /* time constant for memory function in disres    */
 368     real            orires_fc;            /* force constant for orientational restraints  */
 369     real            orires_tau;           /* time constant for memory function in orires    */
 370     int             nstorireout;          /* frequency of writing tr(SD) to enx           */
 371     real            dihre_fc;             /* force constant for dihedral restraints (obsolete)  */
 372     real            em_stepsize;          /* The stepsize for updating                  */
 373     real            em_tol;               /* The tolerance                              */
 374     int             niter;                /* Number of iterations for convergence of      */
 375                                           /* steepest descent in relax_shells             */
 376     real            fc_stepsize;          /* Stepsize for directional minimization        */
 377                                           /* in relax_shells                              */
 378     int             nstcgsteep;           /* number of steps after which a steepest       */
 379                                           /* descents step is done while doing cg         */
 380     int             nbfgscorr;            /* Number of corrections to the hessian to keep */
 381     int             eConstrAlg;           /* Type of constraint algorithm                 */
 382     int             nProjOrder;           /* Order of the LINCS Projection Algorithm      */
 383     real            LincsWarnAngle;       /* If bond rotates more than %g degrees, warn   */
 384     int             nLincsIter;           /* Number of iterations in the final Lincs step */
 385     gmx_bool        bShakeSOR;            /* Use successive overrelaxation for shake      */
 386     real            bd_fric;              /* Friction coefficient for BD (amu/ps)         */
 387     int             ld_seed;              /* Random seed for SD and BD                    */
 388     int             nwall;                /* The number of walls                          */
 389     int             wall_type;            /* The type of walls                            */
 390     real            wall_r_linpot;        /* The potentail is linear for r<=wall_r_linpot */
 391     int             wall_atomtype[2];     /* The atom type for walls                      */
 392     real            wall_density[2];      /* Number density for walls                     */
 393     real            wall_ewald_zfac;      /* Scaling factor for the box for Ewald         */
 394     int             ePull;                /* Type of pulling: no, umbrella or constraint  */
 395     t_pull         *pull;                 /* The data for center of mass pulling          */
 396     gmx_bool        bRot;                 /* Calculate enforced rotation potential(s)?    */
 397     t_rot          *rot;                  /* The data for enforced rotation potentials    */
 398     real            cos_accel;            /* Acceleration for viscosity calculation       */
 399     tensor          deform;               /* Triclinic deformation velocities (nm/ps)     */
 400     int             userint1;             /* User determined parameters                   */
 401     int             userint2;
 402     int             userint3;
 403     int             userint4;
 404     real            userreal1;
 405     real            userreal2;
 406     real            userreal3;
 407     real            userreal4;
 408     t_grpopts       opts;          /* Group options                             */
 409     t_cosines       ex[DIM];       /* Electric field stuff      (spatial part)          */
 410     t_cosines       et[DIM];       /* Electric field stuff      (time part)             */
 411     gmx_bool        bQMMM;         /* QM/MM calculation                            */
 412     int             QMconstraints; /* constraints on QM bonds                      */
 413     int             QMMMscheme;    /* Scheme: ONIOM or normal                      */
 414     real            scalefactor;   /* factor for scaling the MM charges in QM calc.*/
 415                                    /* parameter needed for AdResS simulation       */
 416     gmx_bool        bAdress;       /* Is AdResS enabled ? */
 417     t_adress       *adress;        /* The data for adress simulations */
 418 } t_inputrec;
 419
 420 #define DEFORM(ir) ((ir).deform[XX][XX] != 0 || (ir).deform[YY][YY] != 0 || (ir).deform[ZZ][ZZ] != 0 || (ir).deform[YY][XX] != 0 || (ir).deform[ZZ][XX] != 0 || (ir).deform[ZZ][YY] != 0)
 421
 422 #define DYNAMIC_BOX(ir) ((ir).epc != epcNO || (ir).eI == eiTPI || DEFORM(ir))
 423
 424 #define PRESERVE_SHAPE(ir) ((ir).epc != epcNO && (ir).deform[XX][XX] == 0 && ((ir).epct == epctISOTROPIC || (ir).epct == epctSEMIISOTROPIC))
 425
 426 #define NEED_MUTOT(ir) (((ir).coulombtype == eelEWALD || EEL_PME((ir).coulombtype)) && ((ir).ewald_geometry == eewg3DC || (ir).epsilon_surface != 0))
 427
 428 #define IR_TWINRANGE(ir) ((ir).rlist > 0 && ((ir).rlistlong == 0 || (ir).rlistlong > (ir).rlist))
 429
 430 #define IR_ELEC_FIELD(ir) ((ir).ex[XX].n > 0 || (ir).ex[YY].n > 0 || (ir).ex[ZZ].n > 0)
 431
 432 #define IR_EXCL_FORCES(ir) (EEL_FULL((ir).coulombtype) || (EEL_RF((ir).coulombtype) && (ir).coulombtype != eelRF_NEC) || (ir).implicit_solvent != eisNO)
 433 /* use pointer definitions of ir here, since that's what's usually used in the code */
 434 #define IR_NPT_TROTTER(ir) ((((ir)->eI == eiVV) || ((ir)->eI == eiVVAK)) && (((ir)->epc == epcMTTK) && ((ir)->etc == etcNOSEHOOVER)))
 435
 436 #define IR_NVT_TROTTER(ir) ((((ir)->eI == eiVV) || ((ir)->eI == eiVVAK)) && ((!((ir)->epc == epcMTTK)) && ((ir)->etc == etcNOSEHOOVER)))
 437
 438 #define IR_NPH_TROTTER(ir) ((((ir)->eI == eiVV) || ((ir)->eI == eiVVAK)) && (((ir)->epc == epcMTTK) && (!(((ir)->etc == etcNOSEHOOVER)))))
 439
 440 #ifdef __cplusplus
 441 }
 442 #endif
 443
 444
 445 #endif