NAMD
SimParameters.h
Go to the documentation of this file.
1 
7 /*****************************************************************************
8  * $Source: /home/cvs/namd/cvsroot/namd2/src/SimParameters.h,v $
9  * $Author: jim $
10  * $Date: 2017/03/30 20:06:17 $
11  * $Revision: 1.1248 $
12  *****************************************************************************/
13 
14 #ifndef SIMPARAMETERS_H
15 #define SIMPARAMETERS_H
16 
17 #include "common.h"
18 #include "Vector.h"
19 #include "Lattice.h"
20 
21 #include "MGridforceParams.h"
22 
23 class ParseOptions;
24 class Communicate;
25 class ConfigList;
26 class MIStream;
27 
28 // The class SimParameters is really just a glorified structure used to
29 // maintain the global simulation parameters. The only functions
30 // associated with the class are used to get the parameters from the
31 // ConfigList object, to send that Parameters from the master node
32 // to the other nodes, and to receive the Parameters on the other nodes.
33 
34 
35 // The following definitions are used to distinguish between possible
36 // bonded exclusion settings
37 typedef int ExclusionSettings;
38 
39 #define NONE 0
40 #define ONETWO 1
41 #define ONETHREE 2
42 #define ONEFOUR 3
43 #define SCALED14 4
44 
45 // The following definitions are used to distinguish between multiple
46 // timestep integration schemes
47 typedef int MTSChoices;
48 
49 #define NAIVE 0
50 #define VERLETI 1
51 
52 // The following definitions are used to distinuish between multiple
53 // long-short range force splittings
54 #define SHARP 0
55 #define XPLOR 1
56 #define C1 2
57 #define C2 3
58 
59 // The following definitions are used to distinguish among load
60 // balancers and their strategies
61 #define LDBAL_NONE 0
62 #define LDBAL_CENTRALIZED 1 // default
63 #define LDBAL_HYBRID 2
64 
65 #define LDBSTRAT_DEFAULT 10 // default
66 #define LDBSTRAT_COMPREHENSIVE 11
67 #define LDBSTRAT_REFINEONLY 12
68 #define LDBSTRAT_OLD 13
69 
70 // The following definitions are used to distinguish between patch-splitting
71 // strategies
72 #define SPLIT_PATCH_POSITION 0 // atom position determines patch
73 #define SPLIT_PATCH_HYDROGEN 1 // hydrogen groups are not broken up
74 
75 // The following definitions are used to distinguish the range of rigid
76 // bond calculations: none, all bonds to hydrogen, or only water
77 #define RIGID_NONE 0
78 #define RIGID_ALL 1
79 #define RIGID_WATER 2
80 
81 // Added by JLai -- The following definitions are used to distinguish
82 // the different GoMethodologies available to the Go program
83 // -- 6.3.11
84 typedef int GoChoices;
85 #define GO_MATRIX 1
86 #define GO_SPARSE 2
87 #define GO_LOWMEM 3
88 
89 // Used for controlling PME parallelization with ckloop
90 // The higher level will include all parallelization for lower ones
91 // E.g. If setting useCkLoop to 3, then xpencil's kspace, all
92 // backward ffts and send_untrans/ungrid routines will be parallelized
93 #define CKLOOP_CTRL_PME_UNGRIDCALC 6
94 #define CKLOOP_CTRL_PME_FORWARDFFT 5
95 #define CKLOOP_CTRL_PME_SENDTRANS 4
96 #define CKLOOP_CTRL_PME_KSPACE 3
97 #define CKLOOP_CTRL_PME_BACKWARDFFT 2
98 #define CKLOOP_CTRL_PME_SENDUNTRANS 1
99 
101 {
102 private:
103 public:
104 
105 // MAKE SURE THAT THIS CLASS CAN BE BIT COPIED OR YOU WILL HAVE TO
106 // ADD SPECIAL CODE TO send_SimParameters() and receive_SimParameters()
107 
108 #if defined(NAMD_NVTX_ENABLED) || defined(NAMD_CMK_TRACE_ENABLED)
109  int beginEventPatchID;
110  int endEventPatchID;
111  int beginEventStep;
112  int endEventStep;
113 #endif
114 
115 #ifdef TIMER_COLLECTION
116  double timerBinWidth; // default 1
117 #endif
118 
119  Bool lonepairs; // enable lone pairs
120  int watmodel; // integer code for the water model in use
121  // choices are defined in common.h
122  Bool LJcorrection; // flag for whether water tail corrections should be used
123  BigReal dt; // Timestep size
124  int N; // Number of steps to be performed
125  int stepsPerCycle; // Number of timesteps per cycle
126 
127  zVector cellBasisVector1; // Basis vector for periodic cell
128  zVector cellBasisVector2; // Basis vector for periodic cell
129  zVector cellBasisVector3; // Basis vector for periodic cell
130  zVector cellOrigin; // Fixed center of periodic cell
131  Lattice lattice; // All data for periodic cell
132 
133  int nonbondedFrequency; // Number of timesteps between
134  // nonbonded evaluation
135  int fullElectFrequency; // Number of timesteps between
136  // full electrostatic evaluation
137  BigReal fmaTheta; // DPMTA theta value
138  int ldBalancer; // None, Centralized or Hybrid
139  int ldbStrategy; // What load balancing strategy to use
140  int ldbPeriod; // How often to do load balancing
141  int firstLdbStep; // What step to do the first
142  // load-balance on.
143  int lastLdbStep; // What step to do the last
144  // load-balance on.
145  int hybridGroupSize; // hybrid group size
146  BigReal ldbBackgroundScaling; // scaling factor for background load
147  BigReal ldbPMEBackgroundScaling;// scaling factor for PME background
148  BigReal ldbHomeBackgroundScaling;// scaling factor for home background
149  BigReal ldbRelativeGrainsize; // fraction of average load per compute
150 
151  int traceStartStep; //the timestep when trace is turned on, default to 3*firstLdbStep;
152  int numTraceSteps; //the number of timesteps that are traced, default to 2*ldbPeriod;
153 
154 #ifdef MEASURE_NAMD_WITH_PAPI
155  Bool papiMeasure; //default to false
156  int papiMeasureStartStep; //the timestep when to measure using PAPI, default to 3*firstLdbStep;
157  int numPapiMeasureSteps; //the number of timesteps when performance are measured with PAPI, default to 40;
158 #endif
159 
160  Bool outputMaps; //control whether to dump compute/patch map before load balancing
161  Bool simulateInitialMapping; //if true, the initial mapping during startup is dumped and exit
164  Bool disableTopology; // ignore torus information during patch placement
165  Bool verboseTopology; // print torus information during patch placement
166 
167  Bool benchTimestep; //only cares about benchmarking the timestep, so no file output to save SUs for large-scale benchmarking
168 
169  //whether to use CkLoop library to parallelize a loop in a function like OpenMP.
170  //It has multiple control levels. The higher the value is (must be positive), the more parallelization will be performed
171  //Currently, it is mainly used for PME computation. The default value is 0, meaning it is disabled
172  //Refer to macros CKLOOP_CTRL_* in this file for the ordering of different levels
173  int useCkLoop;
174 
175  int twoAwayX; // half-size patches in X dimension
176  int twoAwayY; // half-size patches in Y dimension
177  int twoAwayZ; // half-size patches in Z dimension
178  int maxPatches; // maximum patch count
179  Bool ldbUnloadPME; // unload processors doing PME
180  Bool ldbUnloadZero; // unload processor 0
181  Bool ldbUnloadOne; // unload processor 1
182  Bool ldbUnloadOutputPEs; // unload output processors
183  Bool noPatchesOnZero; // no patches on processor 0
184  Bool noPatchesOnOutputPEs; // no patches on output PEs
185  Bool noPatchesOnOne; // no patches on processor 1
186 
187  BigReal initialTemp; // Initial temperature for the
188  // simulation
189  Bool comMove; // Should the center of mass be
190  // able to move
191  Bool zeroMomentum; // remove momentum drift from PME
192  Bool zeroMomentumAlt; // alternate method for testing
193  Bool wrapWater; // Wrap water around on output
194  Bool wrapAll; // Wrap clusters around on output
195  Bool wrapNearest; // Wrap to closest image to origin
196  BigReal dielectric; // Dielectric constant
197  ExclusionSettings exclude; // What electrostatic exclusions should
198  // be made
199  BigReal scale14; // Scaling factor for 1-4
200  // electrostatics
201  BigReal nonbondedScaling; // Scaling factor for nonbonded forces
202  int dcdFrequency; // How often (in timesteps) should
203  // a DCD trajectory file be updated
204  int dcdUnitCell; // Whether to write unit cell information in the DCD
205  int velDcdFrequency; // How often (in timesteps) should
206  // a velocity DCD file be updated
207  int forceDcdFrequency; // How often (in timesteps) should
208  // a force DCD file be updated
209  int xstFrequency; // How often (in timesteps) should
210  // a XST trajectory file be updated
211  char auxFilename[128]; // auxilary output filename
212  char dcdFilename[128]; // DCD filename
213  char velDcdFilename[128]; // Velocity DCD filename
214  char forceDcdFilename[128]; // Force DCD filename
215  char xstFilename[128]; // Extended system trajectory filename
216  char outputFilename[128]; // Output file name. This name will
217  // have .coor appended to it
218  // for the coordinates and
219  // .vel appended to
220  // it for the velocities
221  char restartFilename[128]; // Base name of the restart file
222  int restartFrequency; // How often (in timesteps) shoud the
223  // restart files be updated
224  Bool restartSave; // unique filenames for restart files
225  Bool restartSaveDcd; // unique filenames for DCD files
226  Bool binaryRestart; // should restart files be
227  // binary format rather than PDB
228  Bool binaryOutput; // should output files be
229  // binary format rather than PDB
230  BigReal cutoff; // Cutoff distance
231  BigReal margin; // Fudge factor on patch size
232  BigReal patchDimension; // Dimension of each side of a patch
233  // This is either cutoff+margin or
234  // pairlistDist+margin depending on
235  // whether or not switching is on
236  // or not
237  BigReal limitDist; // Distance below which nonbonded
238  // forces between atoms are limited
239  Bool switchingActive; // Flag TRUE->using switching function
240  // for electrostatics and vdw
241  Bool vdwForceSwitching; // Flag TRUE->using force switching
242  // function for vdw
243  BigReal switchingDist; // Distance at which switching
244  // becomes active
245  Bool martiniSwitching; // Flag TRUE->use Martini residue-based
246  // coarse-grain switching function
247  Bool martiniDielAllow; // Allow non-standard dielectric constant
248  // for use with Martini when dielectric != 15.0
249  BigReal pairlistDist; // Distance within which atom pairs
250  // should be added to pairlist
251  int pairlistMinProcs; // Minimum number of processors
252  // to enable pairlists
253  int usePairlists; // Derived from pairlistMinProcs
254 
255  int pairlistsPerCycle; // regenerate x times per cycle
256  BigReal pairlistShrink; // tol *= (1 - x) on regeneration
257  BigReal pairlistGrow; // tol *= (1 + x) on trigger
258  BigReal pairlistTrigger; // trigger is atom > (1 - x) * tol
259  int outputPairlists; // print pairlist warnings this often
260 
261  Bool constraintsOn; // Flag TRUE-> harmonic constraints
262  // active
263  int constraintExp; // Exponent for harmonic constraints
264 
265  /* BEGIN gf */
266  Bool gridforceOn; // Flag TRUE -> gridforce active
267  Bool gridforceVolts; // Flag TRUE -> gridforce using volts as units
268  zVector gridforceScale; // Gridforce scale factor
269  Bool gridforceContA1; // Flag TRUE -> grid continuous in A1 direction
270  Bool gridforceContA2; // Flag TRUE -> grid continuous in A2 direction
271  Bool gridforceContA3; // Flag TRUE -> grid continuous in A3 direction
272  zVector gridforceVOffset; // Gridforce potential offsets
273  Bool gridforceLite; // Flag TRUE -> use lightweight, fast, feature-poor gridforce
274  Bool gridforcechecksize; //Flag TRUE -> check if grid is larger than PBC cell dimensions
275  /* END gf */
278 
279  //****** BEGIN selective restraints (X,Y,Z) changes
280  Bool selectConstraintsOn; // Flag TRUE-> selective restraints
281  // active
283  constrZOn; // Flag TRUE-> select which Cartesian
284  // component to restrain
285  //****** END selective restraints (X,Y,Z) changes
286 
287  // spherical constraints
290 
291  BigReal constraintScaling; // Scaling factor for constraint forces
292 
293  //****** BEGIN CHARMM/XPLOR type changes
294  Bool paraTypeXplorOn; // FLAG TRUE-> parametrs are XPLOR format (default)
295  Bool paraTypeCharmmOn; // FLAG TRUE-> parametrs are CHARMM format
296  //****** END CHARMM/XPLOR type changes
297 
298  // Ported by JLai -- JE - Go
299  Bool goGroPair; // FLAG FALSE->Explicit Gromacs pairs will be calculated
300  Bool goForcesOn; // FLAG TRUE-> Go forces will be calculated
301  char goParameters[128]; // File for Go parameters
302  char goCoordinates[128]; // File for Go structure and atom chain types
303  //JLai 6.3.11
304  GoChoices goMethod; // Integer for Go method -- 1) Matrix-Go, 3) Low-mem-Go
305  // End of port -- JL
306 
307  //****** BEGIN moving constraints changes
308  Bool movingConstraintsOn; // Flag TRUE-> moving constraints
309  // active
310  zVector movingConsVel; // Velocity of the movement, A/timestep
311  //****** END moving constraints changes
312  //****** BEGIN rotating constraints changes
313  Bool rotConstraintsOn; // Flag TRUE-> rotating constraints
314  // active
315  zVector rotConsAxis; // Axis of rotation
316  zVector rotConsPivot; // Pivot point of rotation
317  BigReal rotConsVel; // Velocity of rotation, Deg/timestep
318  //****** END rotating constraints changes
319 
320  //****** BEGIN moving drag changes
321  Bool movDragOn; // Flag TRUE-> moving drag active
322  char movDragFile[128]; // PDB file defining dragged atoms
323  // by non-zero value in the column
324  BigReal movDragGlobVel; // global drag velocity (A/step)
325  char movDragVelFile[128]; // PDB file; XYZ scale moving drag
326  // velocity for each atom
327  //****** END moving drag changes
328  //****** BEGIN rotating drag changes
329  Bool rotDragOn; // Flag TRUE-> rotating drag active
330  char rotDragFile[128]; // PDB file defining dragged atoms
331  // by non-zero value in the column
332  char rotDragAxisFile[128]; // PDB file; XYZ define axes for atoms;
333  char rotDragPivotFile[128]; // PDB file; XYZ define pivots for atoms
334  BigReal rotDragGlobVel; // global drag velocity (deg/step)
335  char rotDragVelFile[128]; // PDB file; B or O scales angular
336  // velocity for each atom
337  //****** END rotating drag changes
338  //****** BEGIN "constant" torque changes
339  Bool consTorqueOn; // Flag TRUE-> "constant" torque active
340  char consTorqueFile[128]; // PDB file defining torqued atoms
341  // by non-zero value in the column
342  char consTorqueAxisFile[128]; // PDB file; XYZ define axes for atoms;
343  char consTorquePivotFile[128];// PDB file; XYZ define pivots for atoms
344  BigReal consTorqueGlobVal; // global "torque" (Kcal/(mol*A^2))
345  char consTorqueValFile[128]; // PDB file; B or O scales "torque"
346  // for each atom
347  //****** END "constant" torque changes
348 
349  //****** BEGIN SMD constraints changes
350  Bool SMDOn; // Flag TRUE-> SMD constraints active
351  BigReal SMDVel; // Velocity of the movement, A/timestep
352  zVector SMDDir; // Direction of the movement
353  BigReal SMDk; // Elastic constant for SMD
354  BigReal SMDk2; // Transverse elastic constant for SMD
355  char SMDFile[128]; // File for SMD information
356  int SMDOutputFreq; // Output frequency for SMD constr.
357  //****** END SMD constraints changes
358 
359  //****** BEGIN tabulated energy section
363  char tableInterpType[128];
366  //****** END tabulated energy section
367 
368  // TMD
371  char TMDFile[128], TMDFile2[128];
375 
376  //Symmetry restraints
379  char symmetrykfile[128];
380  char symmetryFile[128];
383 
384 
385 //fepb
386  Bool alchOnAtStartup; // Ensure that alchemy is set up properly
389  Bool alchOn; // Doing alchemical simulation?
390  Bool alchFepOn; // Doing alchemical simulation?
391  Bool singleTopology; // Using single topology setup?
392  Bool sdScaling; // Scaling S-D bond terms in single topology?
393  Bool alchThermIntOn; // Doing thermodynamic integration?
394  Bool alchWCAOn; // Using WCA decomposition for vdWs?
395  int alchMethod; // Which alchemical method to use? fep or ti
396  BigReal alchLambda; // lambda for dynamics
397  BigReal alchLambda2; // lambda for comparison
398  BigReal alchLambdaIDWS; // alternate lambda for interleaved double-wide sampling
399  int alchIDWSFreq; // freq with which lambda2 changes to lambdaIDWS
400  int alchLambdaFreq; // freq. (in steps) with which lambda changes
401  // from alchLambda to alchLambda2
402  BigReal getCurrentLambda(const int); // getter for changing lambda
403  BigReal getCurrentLambda2(const int); // getter for alternating lambda2 in IDWS
404  int setupIDWS(); // activates IDWS and sets alchIDWSFreq
405  BigReal getLambdaDelta(void); // getter for lambda increment
406  BigReal alchTemp; // temperature for alchemical calculation
407  int alchOutFreq; // freq. of alchemical output
408  Bool alchEnsembleAvg; //if do ensemble average for the net free energy difference
409  char alchOutFile[128]; // alchemical output filename
410  int alchEquilSteps; // # of equil. steps in the window
411  BigReal alchVdwShiftCoeff; // r2 shift coeff used for generating
412  // the alchemical altered vdW interactions
413  BigReal alchElecLambdaStart; // lambda value for starting point of
414  // electrostatic interactions of
415  // exnihilated particles. For annihilated
416  // particles the starting point is
417  // (1-alchElecLambdaStart)
418  BigReal getElecLambda(const BigReal); // return min[0,x/(1-elecStart)]
419  BigReal alchVdwLambdaEnd; // lambda value for endpoint of vdW
420  // interactions of exnihilated particles.
421  // For annihilated particles the endpoint is
422  // (1-alchVdwLambdaEnd)
423  BigReal getVdwLambda(const BigReal); // return max[1,x/vdwEnd]
424  BigReal alchRepLambdaEnd; // lambda value for endpoint of repulsive vdW
425  // interactions of exnihilated particles.
426  // For annihilated particles the endpoint is
427  // (1-alchRepLambdaEnd). This also implies the
428  // START for attractive vdW interactions.
429  BigReal getRepLambda(const BigReal); // return max[1,x/repEnd]
430  BigReal alchBondLambdaEnd; // lambda value for endpoint of bonded
431  // interactions involving exnihilated particles.
432  // For annihilated particles the endpoint is
433  // (1-alchBondLambdaEnd)
434  BigReal getBondLambda(const BigReal); // return max[1,x/bondEnd]
435  Bool alchDecouple; // alchemical decoupling rather than annihilation
436  Bool alchBondDecouple; // decouple purely alchemical bonds
437 //fepe
438 
439 
440  Bool lesOn; // Locally enhanced sampling?
441  int lesFactor; // local enhancement factor
442  Bool lesReduceTemp; // Reduce enhanced atom temperature?
443  Bool lesReduceMass; // Reduce enhanced atom mass?
444 
445  // REST2
459  Bool extForcesOn; // Are ext command forces present?
460  char extForcesCommand[256];
461  char extCoordFilename[128];
462  char extForceFilename[128];
463 
464 
465  // Defines variables for QM/MM calculations
466  Bool qmForcesOn; // Are QM/MM command forces present?
467  char qmParamPDB[128];
470  char qmExecPath[256];
471  char qmSoftware[128];
472  char qmChrgModeS[16];
474  char qmColumn[16];
475  char qmBaseDir[256];
476  char qmSecProc[256];
478  char qmPrepProc[256];
480  int qmFormat ;
483 
485  char qmBondColumn[16];
489  char qmBondSchemeS[16] ;
492  char qmPCSwitchTypeS[16];
494  char qmPCSchemeS[16];
497 
503 
505  int qmLSSFreq ;
506  char qmLSSResname[5] ;
507  char qmLSSModeS[16];
509 
511  char qmCSMDFile[128];
512 
514  int qmOutFreq ;
516 
517  Bool printBadContacts; //print indices of bad contacts being moved downhill
518 
519  //gbis implicit solvent parameters
520  Bool GBISOn; //do generalized born implicit solvent
522  Bool GBISserOn; //do generalized born implicit solvent serial
525  BigReal kappa; //debye screening length; k = sqrt(ion concentration mol/L ) / 0.304
527  BigReal gbis_delta; //three parameters for born radius calc
530  BigReal alpha_cutoff; //pairwise cutoff for integrating born radius
531  BigReal alpha_max; //maximum allowable born radius
532  Bool LCPOOn; //do LCPO SASA for GBSA
533  BigReal surface_tension; //surface tension (kcal/mol/Ang^2) for LCPO
534 
535  Bool drudeOn; // Perform integration of Drude oscillators?
536  Bool drudeHardWallOn; // Apply maximum Drude bond length restriction?
537  BigReal drudeTemp; // (low) temperature for freezing Drude oscillators
538  BigReal drudeDamping; // Langevin damping coefficient (1/ps)
539  // defaults to langevinDamping
540  BigReal drudeBondLen; // Length beyond which to apply quartic
541  // restraining potential to Drude bond
542  BigReal drudeBondConst; // Force constant for restraining potential
543  BigReal drudeNbtholeCut; // Radius of thole pair interaction
544 
545  Bool pairInteractionOn; // Calculate pair interactions?
546  int pairInteractionGroup1; // Interaction group 1.
547  int pairInteractionGroup2; // Interaction group 2.
548  Bool pairInteractionSelf; // Compute just within group.
549 
550  Bool cosAngles; // Can some angles be cos-based
551  Bool globalForcesOn; // Are global forces present?
552  Bool tclForcesOn; // Are Tcl forces present?
553 #ifdef NAMD_TCL
554  Bool tclIsThreaded; // Is Tcl library thread-safe?
555 #endif
556  Bool tclBCOn; // Are Tcl boundary forces present
557  char *tclBCScript; // Script defining tclBC calcforces
558  char tclBCArgs[128]; // Extra args for calcforces command
559  Bool freeEnergyOn; // Doing free energy perturbation?
560  Bool miscForcesOn; // Using misc forces?
561  Bool colvarsOn; // Using the colvars module?
562 
563  Bool fixedAtomsOn; // Are there fixed atoms?
564  Bool fixedAtomsForces; // Calculate forces anyway?
565  Bool fixedAtomsForceOutput; // Output fixed forces?
566 
567  Bool langevinOnAtStartup; // Ensure that langevin is set up properly
568  Bool langevinOn; // Flag TRUE-> langevin dynamics active
569  BigReal langevinTemp; // Temperature for Langevin dynamics
570  BigReal langevinDamping; // Damping coefficient (1/ps)
571  Bool langevinHydrogen; // Flag TRUE-> apply to hydrogens
572  Bool langevin_useBAOAB; // Flag TRUE-> use the experimental BAOAB integrator for NVT instead of the BBK one
573  // See Leimkuhler and Matthews (AMRX 2012); implemented in NAMD by CM June2012
574 
575  // BEGIN LA
576  Bool loweAndersenOn; // Flag TRUE-> Lowe-Andersen dynamics active
577  BigReal loweAndersenTemp; // Temperature for Lowe-Andersen dynamics
578  BigReal loweAndersenRate; // Collision frequency for Lowe-Andersen dynamics (1/ps)
579  BigReal loweAndersenCutoff; // Cutoff radius for Lowe-Andersen dynamics
580  // END LA
581 
582  Bool globalOn; // Flag TRUE-> use global integrator
583  Bool dihedralOn; // Flag TRUE-> dihedral dynamics active
584  Bool COLDOn; // Flag TRUE-> constrained overdamped
585  // langevin dynamics active
586  BigReal COLDRate; // Damping coefficient for COLD.
587  BigReal COLDTemp; // Temperature for COLD.
588 
589  Bool tCoupleOn; // Flag TRUE-> Temperature coupling
590  // active
591  BigReal tCoupleTemp; // Temperature for temp coupling
592 
614  int rescaleFreq; // Velocity rescale frequency
615  BigReal rescaleTemp; // Temperature to rescale to
616 
617  Bool accelMDOn; // Perform accelerated MD
618  Bool accelMDdihe; // Apply boost to the dihedral potential
619  Bool accelMDdual; // dual boost mode
620  Bool accelMDDebugOn; // Debugging accelerated MD
621  BigReal accelMDFirstStep; // First aMD step
622  BigReal accelMDLastStep; // Last aMD step
623  int accelMDOutFreq; // aMD output frequency
624  BigReal accelMDE; // aMD E
625  BigReal accelMDalpha; // aMD alpha
626  BigReal accelMDTE; // E for total potential in the dual boost mode
627  BigReal accelMDTalpha; // alpha for total potential in the dual boost mode
628 
629  Bool accelMDG; // Perform Gaussian accelMD calculation
630  int accelMDGiE; // Flag to set the mode iE in Gaussian accelMD
631  int accelMDGcMDSteps; // Number of cMD steps
632  int accelMDGEquiSteps; // Number of quilibration steps after adding boost potential
633  int accelMDGcMDPrepSteps; // Number of preparation cMD steps
634  int accelMDGEquiPrepSteps; // Number of preparation equilibration steps
635  int accelMDGStatWindow; // Number of steps to calc avg and std
636  BigReal accelMDGSigma0P; // upper limit of std of total potential
637  BigReal accelMDGSigma0D; // upper limit of std of dihedral potential
638  Bool accelMDGRestart; // Flag to set use restart file in Gaussian accelMD
639  char accelMDGRestartFile[128]; // restart file name
640  Bool accelMDGresetVaftercmd; // Flag to reset potential after first accelMDGcMDSteps steps
641 
642  /* Begin Adaptive Temperature Sampling */
643  Bool adaptTempOn; // is adaptTempOn
644  Bool adaptTempDebug; // Debuggin adaptive temperature sampling
645  int adaptTempFirstStep; // First adaptTemp step
646  int adaptTempLastStep; // Last adaptTemp step
647  int adaptTempOutFreq; // adaptTemp output frequency
648  int adaptTempFreq; // Steps between adaptTemp updates
649  BigReal adaptTempTmin; // Lower temperature bound
650  BigReal adaptTempTmax; // Upper temperature bound
651  BigReal adaptTempAutoDt; // Auto jump size. Value determines upper bound, adaotTempDt determines lower bound
652  int adaptTempBins; // Number of bins to store average energy values
653  BigReal adaptTempDt; // timestep for adaptTemp updates - only affects Temperature random walk
654  BigReal adaptTempCgamma; // Cgamma variable for adaptive bin averaging Cgamma = 0 is normal Averaging. 1 > Cgamma >= 0
655  Bool adaptTempLangevin; // Couple to Langevin Thermostat
656  Bool adaptTempRescale; // Couple to Vel. Rescaling
657  char adaptTempInFile[128]; // Restart information for adaptTemp to read
658  char adaptTempRestartFile[128]; // File to write restart information
659  int adaptTempRestartFreq; // Frequency of writing restart output
660  Bool adaptTempRandom; // Do we assign random temperatures when we step out of [Tmin,Tmax]?
661  /* End Adaptive Temperature Sampling */
662 
663  int reassignFreq; // Velocity reassignment frequency
664  BigReal reassignTemp; // Temperature to reassign to
665  BigReal reassignIncr; // Added to reassignTemp each time
666  BigReal reassignHold; // Hold reassignTemp at this value
667 
668  Bool useGroupPressure; // Use group rather than atomic
669  // quantities for pressure calc
670 
671  Bool excludeFromPressure; // Flag TRUE-> some atoms not rescaled
672 
673  Bool useFlexibleCell; // Use anisotropic cell fluctuations
674  Bool useConstantArea; // x,y dimensions fixed.
675  Bool useConstantRatio; // x,y ratio fixed.
676 
677  Bool fixCellDims; // fix the cell dimensions
681 
682  Bool berendsenPressureOn; // Berendsen pressure bath
687 
688  Bool langevinPistonOn; // Langevin piston pressure control
689  Bool langevinPistonBarrier; // Turn off to extrapolate cell
694 
695  Bool multigratorOn; // Multigrator temperature and/or pressure control
703 
705 
706  Bool pressureProfileOn; // Compute lateral pressure profile?
707  int pressureProfileSlabs; // Number of slabs
708  int pressureProfileFreq; // How often to store profile data
710  Bool pressureProfileEwaldOn; // Compute Ewald contribution?
714 
716  zVector strainRate2; // off diagonal elements (xy, xz, yz)
717 
718  unsigned int randomSeed; // Seed for random number generator
719 
720  Bool FMAOn; // Flag TRUE-> FMA active
721  int FMALevels; // Number of Levels for FMA
722  int FMAMp; // Number of multipole terms for FMA
723  Bool FMAFFTOn; // FFT on/off flag for FMA
724  int FMAFFTBlock; // FFT blocking factor for FMA
725 
726  Bool fullDirectOn; // Should direct calculations of
727  // full electrostatics be performed?
728 
729  Bool MSMOn; // enable MSM (multilevel summation method)
730  // for long-range electrostatics
731 
732  int MSMQuality; // choose MSM quality 0 (low) - 3 (high), using
733  // optimal combination of approximation and splitting
734  // defaults to "low" for fastest performance
735 
736  int MSMApprox; // choose MSM approximation
737  // defaults to "cubic" (low) for fastest performance
738 
739  int MSMSplit; // choose MSM splitting function
740  // defaults to "Taylor2" (low) for fastest performance
741 
742  int MSMLevels; // select number of MSM levels
743  // default (0) adapts number of levels to the
744  // system for fastest performance
745 
746  int MSMBlockSizeX; // controls size of parallel work decomposition
747  int MSMBlockSizeY; // controls size of parallel work decomposition
748  int MSMBlockSizeZ; // controls size of parallel work decomposition
749 
750  BigReal MSMGridSpacing; // defaults to 2.5 A, best for atomic systems
751 
752  BigReal MSMPadding; // pad grid along non-periodic boundaries
753  // defaults to 2.5 A
754  // increase if atoms are drifting beyond
755  // edge of grid, which will terminate
756  // simulation prematurely
757 
758  BigReal MSMxmin; // define extent of non-periodic boundaries
764 
765  Bool MsmSerialOn; // use serial MSM solver for testing
766 
770 
771  Bool PMEOn; // Flag TRUE -> PME active
772  BigReal PMETolerance; // Direct space tolerance
773  BigReal PMEEwaldCoefficient; // From tolerance and cutoff
774  int PMEInterpOrder; // Order of interpolation
775  int PMEGridSizeX; // No. of grid points in x dim
776  int PMEGridSizeY; // No. of grid points in y dim
777  int PMEGridSizeZ; // No. of grid points in z dim
778  BigReal PMEGridSpacing; // Maximum spacing between points
779  int PMEProcessors; // No. of processors to use
780  int PMEMinSlices; // Min slices per PME slab
781  int PMEMinPoints; // Min points per PME pencil
782  Bool PMEBarrier; // Use barrier before sendTrans
783  int PMEPencils; // Size of pencil grid in each dim
784  int PMEPencilsX; // Size of pencil grid in X dim
785  int PMEPencilsY; // Size of pencil grid in Y dim
786  int PMEPencilsZ; // Size of pencil grid in Z dim
787  int PMEPencilsYLayout; // Y pencil layout strategy
788  int PMEPencilsXLayout; // X pencil layout strategy
789  int PMESendOrder; // Message ordering strategy
790  Bool PMEOffload; // Offload reciprocal sum to accelerator
791 
792  Bool useDPME; // Flag TRUE -> old DPME code
793 
820  char FFTWWisdomFile[128];
822 
823  #ifdef OPENATOM_VERSION
824  Bool openatom; // Flag TRUE -> OpenAtom QM/MM active
825  #endif // OPENATOM_VERSION
826 
827  Bool minimizeCGOn; // Flag TRUE-> CG minimization active
828  Bool minVerbose; // Flag TRUE-> print extra minimization data
829  BigReal minTinyStep; // Minimization parameter
830  BigReal minBabyStep; // Minimization parameter
831  BigReal minLineGoal; // Minimization parameter
832  Bool minimizeOn; // Flag TRUE-> minimization active
833  BigReal maximumMove; // Maximum movement per timestep
834  // during minimization
835 
836  Bool sphericalBCOn; // Flag TRUE-> spherical boundary
837  // conditions are active
838  zVector sphericalCenter; // Center specified by user
839  BigReal sphericalBCk1; // First force constant for
840  // spherical BC
841  BigReal sphericalBCk2; // Second force constant for
842  // spherical BC
843  BigReal sphericalBCr1; // First radius for spherical BC
844  BigReal sphericalBCr2; // Second radius for spherical BC
845  int sphericalBCexp1; // First radius for spherical BC
846  int sphericalBCexp2; // Second radius for spherical BC
847 
848  Bool cylindricalBCOn; // Flag TRUE->cylindrical boundary
849  // conditions are active
851  char cylindricalBCAxis; // 'x', 'y', or 'z'
860 
861  Bool eFieldOn; // Should a electric field be applied
862  Bool eFieldNormalized; // Is eField vector scaled by cell basis vectors
863  zVector eField; // Electric field vector to be applied
864  BigReal eFieldFreq; // Frequency of the electric field
865  BigReal eFieldPhase; // Phase phi, cos(w*t-phi*PI/180)
866 
867  Bool stirOn; // Should a stirring torque be applied
868  char stirFilename[128]; // Stirring filename (atoms marked)
869  //do the below two even needed to be defined?
870  BigReal stirStartingTheta; // Stir starting theta offset
871  BigReal stirVel; // Stir angular velocity
872  BigReal stirK; // Stir force harmonic spring constant
873  zVector stirAxis; // Direction of stir axis
874  zVector stirPivot; // Pivot point of stir axis
875 
876  Bool extraBondsOn; // read extra bonded forces
877  Bool extraBondsCosAngles; // extra angles are cosine-based
878  Bool extraBondsCosAnglesSetByUser; // did the user set this explicitly
879 
880  Bool consForceOn; // Should constant force be applied
881  char consForceFile[128];
883 
884  int outputEnergies; // Number of timesteps between energy
885  // outputs
886 
887  int outputMomenta; // Number of timesteps between momentum
888  // outputs
889 
890  int outputTiming; // Number of timesteps between timing
891  // outputs
892 
893  int outputCudaTiming; // Number of timesteps between timing
894  // outputs of CUDA code
895 
896  int outputPressure; // Number of timesteps between pressure
897  // tensor outputs
898 
899  Bool mergeCrossterms; // Merge crossterm energy w/ dihedrals
900 
901  int firstTimestep; // Starting timestep. Will be 0 unless
902  // restarting a simulation
903 
904  MTSChoices MTSAlgorithm; // What multiple timestep algorithm
905  // to use
906 
907  int longSplitting; // What electrostatic splitting
908  // to use
909 
910  Bool ignoreMass; // Mass < 3.5 does not indicate hydrogen, etc.
911 
912  int splitPatch; // How are patches determined?
913  BigReal hgroupCutoff; // what is the added hydrogen margin?
914 
915  int mollyOn; // mollify long range forces?
916  BigReal mollyTol; // error tolerance for molly
917  int mollyIter; // max number of iterations for molly
918 
919  int rigidBonds; // what type of rigid bonds to hydrogens
920  // none, all, or only water
921 
922  BigReal rigidTol; // error tolerance for rigid bonds
923  int rigidIter; // Number of NR iterations
924  int rigidDie; // die if rigidTol not achieved
925 
926  Bool useSettle; // Use SETTLE; requires rigid waters
927 
928  Bool testOn; // Do tests rather than simulation
929  Bool commOnly; // Don't do any force evaluations
930  Bool statsOn; // Don't do any force evaluations
931 
932  int totalAtoms; // Total Number of atoms in simulation
933  int maxSelfPart; // maximum number of self partitions
934  // that a patch can be split into
935  int maxPairPart; // maximum number of pair partitions
936  // that a patch can be split into
937  int numAtomsSelf; // maximum number of atoms in a single
938  // self-compute
939  int numAtomsSelf2; // maximum number of atoms in a pair compute
940  // in the presence of twoAwayX,Y,Z options
941  int numAtomsPair; // maximum number of atoms in a single
942  // pair-compute
943  int numAtomsPair2; // maximum number of atoms in a single
944  // pair-compute
945  int minAtomsPerPatch; // minimum average atoms per patch
946  // (may create larger patches)
947  int maxExclusionFlags; // maximum size of exclusion check list
948  // for any given atom
949  Bool outputPatchDetails; // print number of atoms per patch
950  Bool staticAtomAssignment; // never migrate atoms
951  Bool replicaUniformPatchGrids; // same patch grid size on all replicas
952 
953  //
954  // hydrogen bond simulation parameters
955  //
956 
957  // should the hydrogen bond term be used? If FALSE, all other
958  // hydrogen bond parameters are unnecessary in simulation.
960 
961  // should the antecedent atom be used in the calculation of hbonds?
963 
964  // exponents used in hydrogen bond energy function:
965  // aaAngleExp = exp for H-A-AA angle term (n)
966  // haAngleExp = exp for D-H-A angle term (m)
967  // distAttExp = exp for attractive A-D distance term (j)
968  // distRepExp = exp for repulsive A-D distance term (i)
970 
971  // cutoff D-H-A angle, and on/off angles for switch fcn (in degrees)
973 
974  // cutoff distance for D-A separation in hbonds (in Angstroms), and
975  // on/off distances for hbond radial term switching function
977 
978  // IMD parameters
979  int IMDon; // enable IMD
980  int IMDport; // port on which to listen for connections
981  int IMDfreq; // frequency at which coordinates will be available
982  int IMDwait; // if true, pause the simulation when there is no
983  // connection
984  int IMDignore; // IMD connection does not influence simulation
985  // only sends coordinates and energies to VMD
986  int IMDignoreForces; // Only the Forces are ignored. Finish, Pause and Resume are enabled
987 
988 
989  // AMBER options
990  Bool amberOn; // FLAG TRUE-> amber force field is used
991  Bool readExclusions; // FLAG TRUE-> Read exclusions from parm file
992  BigReal vdwscale14; // Scaling factor for 1-4 VDW interactions
993 
994  // GROMACS options
995  Bool gromacsOn; // FLAG TRUE -> gromacs-style force field is used
996 
997  // OPLS options
998  Bool vdwGeometricSigma; // Lennard-J sigma uses geometric mean
999 
1000  // ScriptTcl argument passing
1008  char scriptStringArg1[128];
1009  char scriptStringArg2[128];
1010 
1013 
1015 
1018 
1019  //default value is -1
1022 
1024 
1025 
1026  //fields needed for Parallel IO Input
1030  char *binVelFile;
1031  char *binRefFile;
1032 
1033  //fields needed for Parallel IO Output
1036 
1037  char computeMapFilename[128]; // store compute map
1040 
1041  // MIC-specific parameters
1049 
1050  // AVX-512 Tiles optimizations
1052 
1053 public:
1054 
1055  SimParameters() : mgridforcelist(), parseopts(0) {};
1056  SimParameters(ConfigList *c, char *&cwd) : mgridforcelist(), parseopts(0) {
1057  initialize_config_data(c,cwd);
1058  };
1060 
1061  void initialize_config_data(ConfigList *, char *&cwd);
1062  // Initialize SimParameters data
1063  // from the ConfigList object
1064  void send_SimParameters(MOStream *);
1065  // Used by the master process
1066  // to send the paramters to
1067  // the other processors
1069  // Used by the other processors
1070  // to receive the data from the
1071  // master process
1072  void scriptSet(const char *, const char *);
1073  // Set parameters at run time
1074  void close_dcdfile(); // *** implemented in Output.C ***
1075  void close_veldcdfile(); // *** implemented in Output.C ***
1076  static void nonbonded_select();
1077  static void pme_select();
1078 
1083 
1084  char* getfromparseopts(const char* name, char *outbuf);
1085  int istrueinparseopts(const char* name);
1086  int issetinparseopts(const char* name);
1087 
1088  void readExtendedSystem(const char *filename, Lattice *latptr=0);
1089 private:
1090  ParseOptions *parseopts;
1091 
1092  void config_parser(ParseOptions &opts);
1093 
1094  void config_parser_basic(ParseOptions &opts);
1095  void config_parser_fileio(ParseOptions &opts);
1096  void config_parser_fullelect(ParseOptions &opts);
1097  void config_parser_methods(ParseOptions &opts);
1098  void config_parser_constraints(ParseOptions &opts);
1099 #ifdef OPENATOM_VERSION
1100  void config_parser_openatom(ParseOptions &opts);
1101 #endif //OPENATOM_VERSION
1102  /* BEGIN gf */
1103  void config_parser_gridforce(ParseOptions &opts);
1104  /* END gf */
1105  void config_parser_movdrag(ParseOptions &opts);
1106  void config_parser_rotdrag(ParseOptions &opts);
1107  void config_parser_constorque(ParseOptions &opts);
1108  void config_parser_boundary(ParseOptions &opts);
1109  void config_parser_misc(ParseOptions &opts);
1110  void config_parser_mgridforce(ParseOptions &opts);
1111  void parse_mgrid_string_param(ConfigList *config,
1112  const char *fieldname, char** dest);
1113  void parse_mgrid_params(ConfigList *config);
1114  void print_mgrid_params();
1115 
1116  void check_config(ParseOptions &opts, ConfigList *config, char *&cwd);
1117 
1118  void print_config(ParseOptions &opts, ConfigList *config, char *&cwd);
1119 
1120  void create_output_directories(const char *dirname);
1121 
1122  int fmaFrequency; // outdated parameter name
1123  char loadBalancer[64]; // Load balancer
1124  char loadStrategy[64]; // Load balancing strategy
1125 
1126 };
1127 
1128 #endif
1129 
char qmLSSResname[5]
BigReal adaptTempTmax
int adaptTempRestartFreq
zVector sphericalCenter
Bool accelMDGresetVaftercmd
BigReal sphericalBCr2
BigReal berendsenPressureCompressibility
BigReal daOnDist
Bool berendsenPressureOn
BigReal scriptArg3
BigReal TMDInitialRMSD
char qmSecProc[256]
BigReal hgroupCutoff
char scriptStringArg1[128]
BigReal berendsenPressureRelaxationTime
BigReal soluteScalingFactorCharge
char consTorqueValFile[128]
BigReal cylindricalBCl1
char qmChrgModeS[16]
char restartFilename[128]
char auxFilename[128]
char qmPCSchemeS[16]
Bool simulateInitialMapping
Bool fixedAtomsForceOutput
BigReal scriptArg2
char consTorqueFile[128]
int isSendSpanningTreeUnset()
char scriptStringArg2[128]
BigReal minTinyStep
BigReal accelMDE
BigReal getLambdaDelta(void)
BigReal cylindricalBCl2
char velDcdFilename[128]
BigReal adaptTempCgamma
int pressureProfileEwaldX
BigReal ldbRelativeGrainsize
int istrueinparseopts(const char *name)
BigReal pairlistTrigger
void receive_SimParameters(MIStream *)
BigReal solvent_dielectric
zVector rotConsAxis
Bool vdwGeometricSigma
char qmBondSchemeS[16]
BigReal langevinPistonTemp
BigReal dhaOffAngle
BigReal accelMDLastStep
void close_veldcdfile()
Definition: Output.C:664
BigReal adaptTempTmin
Bool extraBondsCosAngles
char rotDragVelFile[128]
char rotDragFile[128]
int isRecvSpanningTreeUnset()
char computeMapFilename[128]
char extForcesCommand[256]
zVector sphericalConstrCenter
BigReal alchElecLambdaStart
BigReal eFieldFreq
zVector gridforceVOffset
BigReal scriptArg5
BigReal multigratorPressureTarget
BigReal nonbondedScaling
char movDragFile[128]
int accelMDGEquiPrepSteps
char * FFTWWisdomString
Bool excludeFromPressure
BigReal constraintScaling
Bool selectConstraintsOn
BigReal sphericalBCk1
Bool ldbUnloadOutputPEs
BigReal surfaceTensionTarget
BigReal COLDTemp
BigReal reassignTemp
float Real
Definition: common.h:107
int symmetryLastFullStep
char forceDcdFilename[128]
Bool movingConstraintsOn
BigReal gbis_gamma
char * tclBCScript
BigReal dhaOnAngle
BigReal alchLambda2
BigReal limitDist
BigReal alchBondLambdaEnd
BigReal accelMDTE
void scriptSet(const char *, const char *)
BigReal rotDragGlobVel
zVector cellBasisVector1
BigReal minLineGoal
BigReal minBabyStep
int berendsenPressureFreq
char TMDFile2[128]
BigReal cylindricalBCk2
BigReal cylindricalBCk1
BigReal rigidTol
zVector stirPivot
BigReal getRepLambda(const BigReal)
Bool langevinPistonBarrier
zVector rotConsPivot
char qmPrepProc[256]
BigReal accelMDalpha
zVector cellBasisVector3
int pressureProfileSlabs
BigReal FMMPadding
char consForceFile[128]
BigReal alchLambda
Bool pairInteractionOn
char tclBCArgs[128]
void close_dcdfile()
Definition: Output.C:655
BigReal switchingDist
BigReal coulomb_radius_offset
void initialize_config_data(ConfigList *, char *&cwd)
Bool langevinOnAtStartup
BigReal drudeNbtholeCut
Bool symmetryScaleForces
BigReal mollyTol
BigReal daOffDist
Bool sphericalConstraintsOn
BigReal vdwscale14
BigReal eFieldPhase
BigReal accelMDTalpha
BigReal alchRepLambdaEnd
char rotDragPivotFile[128]
BigReal langevinPistonDecay
char qmPCSwitchTypeS[16]
BigReal rotConsVel
BigReal ldbHomeBackgroundScaling
BigReal alchLambdaIDWS
zVector stirAxis
BigReal alpha_max
Bool langevin_useBAOAB
char outputFilename[128]
BigReal berendsenPressureTarget
char qmLSSModeS[16]
char tabulatedEnergiesFile[128]
char goCoordinates[128]
zVector cylindricalCenter
BigReal stochRescalePeriod
char cylindricalBCAxis
char symmetryFile[128]
zVector gridforceScale
int accelMDGcMDPrepSteps
BigReal rescaleTemp
char consTorqueAxisFile[128]
BigReal surface_tension
BigReal ion_concentration
BigReal PMEGridSpacing
char adaptTempRestartFile[128]
BigReal accelMDFirstStep
Bool adaptTempLangevin
BigReal getBondLambda(const BigReal)
BigReal soluteScalingFactor
BigReal dhaCutoffAngle
zVector strainRate2
BigReal langevinDamping
GoChoices goMethod
Bool gridforcechecksize
Bool staticAtomAssignment
BigReal getCurrentLambda2(const int)
char movDragVelFile[128]
int Bool
Definition: common.h:131
Bool replicaUniformPatchGrids
BigReal drudeBondLen
static void pme_select()
BigReal gbis_beta
BigReal langevinTemp
char qmCSMDFile[128]
char xstFilename[128]
MTSChoices MTSAlgorithm
BigReal scriptArg1
char adaptTempInFile[128]
char consTorquePivotFile[128]
BigReal loweAndersenRate
void readExtendedSystem(const char *filename, Lattice *latptr=0)
BigReal alpha_cutoff
BigReal PMEEwaldCoefficient
BigReal fmaTheta
BigReal MSMGridSpacing
int multigratorNoseHooverChainLength
BigReal multigratorTemperatureTarget
BigReal multigratorPressureRelaxationTime
int ExclusionSettings
Definition: SimParameters.h:26
char goParameters[128]
BigReal tableMaxDist
BigReal reassignIncr
Bool outputPatchDetails
BigReal cylindricalBCr2
char extCoordFilename[128]
BigReal soluteScalingFactorVdw
zVector strainRate
BigReal sphericalBCr1
Bool pressureProfileEwaldOn
BigReal alchVdwLambdaEnd
BigReal daCutoffDist
int GoChoices
Definition: SimParameters.h:84
BigReal multigratorTemperatureRelaxationTime
BigReal ldbBackgroundScaling
Bool vdwForceSwitching
BigReal adaptTempDt
MGridforceParamsList mgridforcelist
BigReal drudeBondConst
static void nonbonded_select()
BigReal consTorqueGlobVal
char SMDFile[128]
BigReal accelMDGSigma0P
char stirFilename[128]
BigReal langevinPistonPeriod
BigReal stirStartingTheta
int pressureProfileEwaldY
Bool qmMOPACAddConfigChrg
int isRecvSpanningTreeOn()
char * getfromparseopts(const char *name, char *outbuf)
char qmSoftware[128]
char qmBaseDir[256]
SimParameters(ConfigList *c, char *&cwd)
BigReal loweAndersenCutoff
Bool alchFepOnAtStartup
unsigned int randomSeed
BigReal alchTemp
zVector cellBasisVector2
BigReal initialTemp
int pressureProfileAtomTypes
char alchOutFile[128]
BigReal scriptArg4
int MTSChoices
Definition: SimParameters.h:47
Bool extraBondsCosAnglesSetByUser
BigReal TMDFinalRMSD
char qmExecPath[256]
BigReal movDragGlobVel
BigReal symmetryk
BigReal ldbPMEBackgroundScaling
BigReal getCurrentLambda(const int)
Bool alchThermIntOnAtStartup
Bool pressureProfileOn
int symmetryFirstFullStep
char accelMDGRestartFile[128]
BigReal PMETolerance
BigReal tCoupleTemp
BigReal pairlistDist
Bool pairInteractionSelf
char qmParamPDB[128]
int multigratorPressureFreq
BigReal patchDimension
BigReal maximumMove
Bool qmParamPDBDefined
BigReal getVdwLambda(const BigReal)
BigReal COLDRate
BigReal gbis_delta
int pairInteractionGroup2
BigReal pairlistShrink
BigReal dielectric
char qmBondValueTypeS[16]
BigReal adaptTempAutoDt
int isSendSpanningTreeOn()
char symmetrykfile[128]
BigReal cylindricalBCr1
BigReal pairlistGrow
BigReal accelMDGSigma0D
BigReal reassignHold
char dcdFilename[128]
Bool tabulatedEnergies
BigReal MSMPadding
int pairInteractionGroup1
char rotDragAxisFile[128]
ExclusionSettings exclude
char FFTWWisdomFile[128]
BigReal drudeDamping
char TMDFile[128]
char symmetryMatrixFile[128]
BigReal langevinPistonTarget
int issetinparseopts(const char *name)
char extForceFilename[128]
char qmBondColumn[16]
BigReal sphericalBCk2
Bool noPatchesOnOutputPEs
char tableInterpType[128]
int multigratorTemperatureFreq
zVector cellOrigin
BigReal stochRescaleTemp
BigReal getElecLambda(const BigReal)
double BigReal
Definition: common.h:112
zVector movingConsVel
BigReal consForceScaling
void send_SimParameters(MOStream *)
char qmColumn[16]
BigReal loweAndersenTemp
BigReal alchVdwShiftCoeff
int pressureProfileEwaldZ
BigReal drudeTemp