SimParameters.h

Go to the documentation of this file.
00001 
00007 /*****************************************************************************
00008  * $Source: /home/cvs/namd/cvsroot/namd2/src/SimParameters.h,v $
00009  * $Author: jim $
00010  * $Date: 2017/03/30 20:06:17 $
00011  * $Revision: 1.1248 $
00012  *****************************************************************************/
00013 
00014 #ifndef SIMPARAMETERS_H
00015 #define SIMPARAMETERS_H
00016 
00017 #include "common.h"
00018 #include "Vector.h"
00019 #include "Lattice.h"
00020 
00021 #include "MGridforceParams.h"
00022 
00023 class ParseOptions;
00024 class Communicate;
00025 class ConfigList;
00026 class MIStream;
00027 
00028 //  The class SimParameters is really just a glorified structure used to
00029 //  maintain the global simulation parameters.  The only functions
00030 //  associated with the class are used to get the parameters from the
00031 //  ConfigList object, to send that Parameters from the master node 
00032 //  to the other nodes, and to receive the Parameters on the other nodes.
00033 
00034 
00035 //  The following definitions are used to distinguish between possible
00036 //  bonded exclusion settings
00037 typedef int  ExclusionSettings;
00038 
00039 #define NONE            0
00040 #define ONETWO          1
00041 #define ONETHREE        2
00042 #define ONEFOUR         3
00043 #define SCALED14        4
00044 
00045 //  The following definitions are used to distinguish between multiple
00046 //  timestep integration schemes
00047 typedef int  MTSChoices;
00048 
00049 #define NAIVE           0
00050 #define VERLETI         1
00051 
00052 //  The following definitions are used to distinuish between multiple
00053 //  long-short range force splittings
00054 #define SHARP           0
00055 #define XPLOR           1
00056 #define C1              2
00057 #define C2              3
00058 
00059 //  The following definitions are used to distinguish among load
00060 //  balancers and their strategies
00061 #define LDBAL_NONE              0
00062 #define LDBAL_CENTRALIZED       1       // default
00063 #define LDBAL_HYBRID            2
00064 
00065 #define LDBSTRAT_DEFAULT        10      // default
00066 #define LDBSTRAT_COMPREHENSIVE  11
00067 #define LDBSTRAT_REFINEONLY     12
00068 #define LDBSTRAT_OLD            13
00069 
00070 // The following definitions are used to distinguish between patch-splitting
00071 // strategies
00072 #define SPLIT_PATCH_POSITION    0       // atom position determines patch
00073 #define SPLIT_PATCH_HYDROGEN    1       // hydrogen groups are not broken up
00074 
00075 // The following definitions are used to distinguish the range of rigid
00076 // bond calculations: none, all bonds to hydrogen, or only water
00077 #define RIGID_NONE    0
00078 #define RIGID_ALL     1
00079 #define RIGID_WATER   2
00080 
00081 // Added by JLai -- The following definitions are used to distinguish
00082 // the different GoMethodologies available to the Go program
00083 // -- 6.3.11
00084 typedef int GoChoices;
00085 #define GO_MATRIX 1
00086 #define GO_SPARSE 2
00087 #define GO_LOWMEM 3
00088 
00089 // Used for controlling PME parallelization with ckloop
00090 // The higher level will include all parallelization for lower ones
00091 // E.g. If setting useCkLoop to 3, then xpencil's kspace, all
00092 // backward ffts and send_untrans/ungrid routines will be parallelized
00093 #define CKLOOP_CTRL_PME_UNGRIDCALC 6
00094 #define CKLOOP_CTRL_PME_FORWARDFFT 5
00095 #define CKLOOP_CTRL_PME_SENDTRANS 4
00096 #define CKLOOP_CTRL_PME_KSPACE 3
00097 #define CKLOOP_CTRL_PME_BACKWARDFFT 2
00098 #define CKLOOP_CTRL_PME_SENDUNTRANS 1
00099 
00100 class SimParameters
00101 {
00102 private:
00103 public:
00104 
00105 //  MAKE SURE THAT THIS CLASS CAN BE BIT COPIED OR YOU WILL HAVE TO
00106 //  ADD SPECIAL CODE TO send_SimParameters() and receive_SimParameters()
00107 
00108   Bool lonepairs;  // enable lone pairs
00109   int watmodel; // integer code for the water model in use
00110                 // choices are defined in common.h
00111   Bool LJcorrection; // flag for whether water tail corrections should be used
00112         BigReal dt;                     //  Timestep size
00113         int N;                          //  Number of steps to be performed
00114         int stepsPerCycle;              //  Number of timesteps per cycle
00115 
00116         zVector cellBasisVector1;       //  Basis vector for periodic cell
00117         zVector cellBasisVector2;       //  Basis vector for periodic cell
00118         zVector cellBasisVector3;       //  Basis vector for periodic cell
00119         zVector cellOrigin;             //  Fixed center of periodic cell
00120         Lattice lattice;                //  All data for periodic cell
00121         
00122         int nonbondedFrequency;         //  Number of timesteps between
00123                                         //  nonbonded evaluation
00124         int fullElectFrequency;         //  Number of timesteps between
00125                                         //  full electrostatic evaluation
00126         BigReal fmaTheta;               //  DPMTA theta value
00127         int ldBalancer;                 //  None, Centralized or Hybrid
00128         int ldbStrategy;                //  What load balancing strategy to use
00129         int ldbPeriod;                  //  How often to do load balancing
00130         int firstLdbStep;               //  What step to do the first 
00131                                         //  load-balance on.
00132         int lastLdbStep;                //  What step to do the last
00133                                         //  load-balance on.
00134         int hybridGroupSize;            //  hybrid group size
00135         BigReal ldbBackgroundScaling;   //  scaling factor for background load
00136         BigReal ldbPMEBackgroundScaling;//  scaling factor for PME background
00137         BigReal ldbHomeBackgroundScaling;//  scaling factor for home background
00138         BigReal ldbRelativeGrainsize;   //  fraction of average load per compute
00139         
00140         int traceStartStep; //the timestep when trace is turned on, default to 3*firstLdbStep;
00141         int numTraceSteps; //the number of timesteps that are traced, default to 2*ldbPeriod;
00142         
00143 #ifdef MEASURE_NAMD_WITH_PAPI
00144         Bool papiMeasure; //default to false
00145         int papiMeasureStartStep; //the timestep when to measure using PAPI, default to 3*firstLdbStep;
00146         int numPapiMeasureSteps; //the number of timesteps when performance are measured with PAPI, default to 40;
00147 #endif
00148         
00149         Bool outputMaps; //control whether to dump compute/patch map before load balancing
00150         Bool simulateInitialMapping; //if true, the initial mapping during startup is dumped and exit
00151         int simulatedPEs;
00152         int simulatedNodeSize;
00153         Bool disableTopology; // ignore torus information during patch placement
00154         Bool verboseTopology; // print torus information during patch placement
00155 
00156         Bool benchTimestep; //only cares about benchmarking the timestep, so no file output to save SUs for large-scale benchmarking
00157 
00158         //whether to use CkLoop library to parallelize a loop in a function like OpenMP.
00159         //It has multiple control levels. The higher the value is (must be positive), the more parallelization will be performed
00160         //Currently, it is mainly used for PME computation. The default value is 0, meaning it is disabled
00161         //Refer to macros CKLOOP_CTRL_* in this file for the ordering of different levels
00162         int useCkLoop; 
00163 
00164         int twoAwayX;                   //  half-size patches in X dimension
00165         int twoAwayY;                   //  half-size patches in Y dimension
00166         int twoAwayZ;                   //  half-size patches in Z dimension
00167         int maxPatches;                 //  maximum patch count
00168         Bool ldbUnloadPME;              //  unload processors doing PME
00169         Bool ldbUnloadZero;             //  unload processor 0
00170         Bool ldbUnloadOne;              //  unload processor 1 
00171         Bool ldbUnloadOutputPEs;        //  unload output processors
00172         Bool noPatchesOnZero;           //  no patches on processor 0
00173         Bool noPatchesOnOutputPEs;      //  no patches on output PEs
00174         Bool noPatchesOnOne;            //  no patches on processor 1
00175         
00176         BigReal initialTemp;            //  Initial temperature for the 
00177                                         //  simulation
00178         Bool comMove;                   //  Should the center of mass be 
00179                                         //  able to move
00180         Bool zeroMomentum;              //  remove momentum drift from PME
00181         Bool zeroMomentumAlt;           //  alternate method for testing
00182         Bool wrapWater;                 //  Wrap water around on output
00183         Bool wrapAll;                   //  Wrap clusters around on output
00184         Bool wrapNearest;               //  Wrap to closest image to origin
00185         BigReal dielectric;             //  Dielectric constant
00186         ExclusionSettings exclude;      //  What electrostatic exclusions should
00187                                         //  be made
00188         BigReal scale14;                //  Scaling factor for 1-4 
00189                                         //  electrostatics
00190         BigReal nonbondedScaling;       //  Scaling factor for nonbonded forces
00191         int dcdFrequency;               //  How often (in timesteps) should
00192                                         //  a DCD trajectory file be updated
00193   int dcdUnitCell;  // Whether to write unit cell information in the DCD
00194         int velDcdFrequency;            //  How often (in timesteps) should
00195                                         //  a velocity DCD file be updated
00196         int forceDcdFrequency;          //  How often (in timesteps) should
00197                                         //  a force DCD file be updated
00198         int xstFrequency;               //  How often (in timesteps) should
00199                                         //  a XST trajectory file be updated
00200         char auxFilename[128];          //  auxilary output filename
00201         char dcdFilename[128];          //  DCD filename
00202         char velDcdFilename[128];       //  Velocity DCD filename
00203         char forceDcdFilename[128];     //  Force DCD filename
00204         char xstFilename[128];          //  Extended system trajectory filename
00205         char outputFilename[128];       //  Output file name.  This name will
00206                                         //  have .coor appended to it 
00207                                         //  for the coordinates and 
00208                                         //  .vel appended to
00209                                         //  it for the velocities
00210         char restartFilename[128];      //  Base name of the restart file
00211         int restartFrequency;           //  How often (in timesteps) shoud the
00212                                         //  restart files be updated
00213         Bool restartSave;               //  unique filenames for restart files
00214         Bool restartSaveDcd;            //  unique filenames for DCD files
00215         Bool binaryRestart;             //  should restart files be
00216                                         //  binary format rather than PDB
00217         Bool binaryOutput;              //  should output files be
00218                                         //  binary format rather than PDB
00219         BigReal cutoff;                 //  Cutoff distance
00220         BigReal margin;                 //  Fudge factor on patch size
00221         BigReal patchDimension;         //  Dimension of each side of a patch
00222                                         //  This is either cutoff+margin or
00223                                         //  pairlistDist+margin depending on
00224                                         //  whether or not switching is on
00225                                         //  or not
00226         BigReal limitDist;              //  Distance below which nonbonded
00227                                         //  forces between atoms are limited
00228         Bool switchingActive;           //  Flag TRUE->using switching function
00229                                         //  for electrostatics and vdw
00230         Bool vdwForceSwitching;         //  Flag TRUE->using force switching
00231                                         //  function for vdw
00232         BigReal switchingDist;          //  Distance at which switching
00233                                         //  becomes active
00234         Bool martiniSwitching;          //  Flag TRUE->use Martini residue-based
00235                                         //  coarse-grain switching function
00236         Bool martiniDielAllow;          //  Allow non-standard dielectric constant 
00237                                         //  for use with Martini when dielectric != 15.0
00238         BigReal pairlistDist;           //  Distance within which atom pairs 
00239                                         //  should be added to pairlist
00240         int pairlistMinProcs;           //  Minimum number of processors
00241                                         //  to enable pairlists
00242         int usePairlists;               //  Derived from pairlistMinProcs
00243 
00244         int pairlistsPerCycle;          //  regenerate x times per cycle
00245         BigReal pairlistShrink;         //  tol *= (1 - x) on regeneration
00246         BigReal pairlistGrow;           //  tol *= (1 + x) on trigger
00247         BigReal pairlistTrigger;        //  trigger is atom > (1 - x) * tol
00248         int outputPairlists;            //  print pairlist warnings this often
00249 
00250         Bool constraintsOn;             //  Flag TRUE-> harmonic constraints 
00251                                         //  active
00252         int constraintExp;              //  Exponent for harmonic constraints
00253 
00254         /* BEGIN gf */
00255         Bool gridforceOn;               //  Flag TRUE -> gridforce active
00256         Bool gridforceVolts;            //  Flag TRUE -> gridforce using volts as units
00257         zVector gridforceScale;         //  Gridforce scale factor
00258         Bool gridforceContA1;           //  Flag TRUE -> grid continuous in A1 direction
00259         Bool gridforceContA2;           //  Flag TRUE -> grid continuous in A2 direction
00260         Bool gridforceContA3;           //  Flag TRUE -> grid continuous in A3 direction
00261         zVector gridforceVOffset;       //  Gridforce potential offsets
00262         Bool gridforceLite;             //  Flag TRUE -> use lightweight, fast, feature-poor gridforce
00263         Bool gridforcechecksize; //Flag TRUE -> check if grid is larger than PBC cell dimensions
00264   /* END gf */
00265         Bool mgridforceOn;
00266         MGridforceParamsList mgridforcelist;
00267 
00268         //****** BEGIN selective restraints (X,Y,Z) changes 
00269         Bool selectConstraintsOn;       //  Flag TRUE-> selective restraints  
00270                                         //  active
00271         Bool constrXOn, constrYOn,       
00272              constrZOn;                 //  Flag TRUE-> select which Cartesian 
00273                                         //  component to restrain
00274         //****** END selective restraints (X,Y,Z) changes 
00275 
00276         // spherical constraints
00277         Bool sphericalConstraintsOn;
00278         zVector sphericalConstrCenter;
00279 
00280         BigReal constraintScaling;      //  Scaling factor for constraint forces
00281 
00282         //****** BEGIN CHARMM/XPLOR type changes
00283         Bool paraTypeXplorOn;           //  FLAG TRUE-> parametrs are XPLOR format (default)
00284         Bool paraTypeCharmmOn;          //  FLAG TRUE-> parametrs are CHARMM format
00285         //****** END CHARMM/XPLOR type changes
00286 
00287         // Ported by JLai -- JE - Go
00288         Bool goGroPair;           //  FLAG FALSE->Explicit Gromacs pairs will be calculated
00289         Bool goForcesOn;          //  FLAG TRUE-> Go forces will be calculated
00290         char goParameters[128];   //  File for Go parameters
00291         char goCoordinates[128];  //  File for Go structure and atom chain types
00292         //JLai 6.3.11
00293         GoChoices  goMethod;      //  Integer for Go method -- 1) Matrix-Go, 3) Low-mem-Go
00294         // End of port -- JL
00295 
00296         //****** BEGIN moving constraints changes 
00297         Bool movingConstraintsOn;       //  Flag TRUE-> moving constraints 
00298                                         //  active
00299         zVector movingConsVel;           //  Velocity of the movement, A/timestep
00300         //****** END moving constraints changes 
00301         //****** BEGIN rotating constraints changes 
00302         Bool rotConstraintsOn;          //  Flag TRUE-> rotating constraints 
00303                                         //  active
00304         zVector rotConsAxis;             //  Axis of rotation
00305         zVector rotConsPivot;            //  Pivot point of rotation
00306         BigReal rotConsVel;             //  Velocity of rotation, Deg/timestep
00307         //****** END rotating constraints changes 
00308 
00309         //****** BEGIN moving drag changes
00310         Bool movDragOn;               //  Flag TRUE-> moving drag active
00311         char movDragFile[128];        //  PDB file defining dragged atoms
00312                                       //  by non-zero value in the column
00313         BigReal movDragGlobVel;       //  global drag velocity (A/step)
00314         char movDragVelFile[128];     //  PDB file; XYZ scale moving drag
00315                                       //  velocity for each atom
00316         //****** END moving drag changes
00317         //****** BEGIN rotating drag changes
00318         Bool rotDragOn;               //  Flag TRUE-> rotating drag active
00319         char rotDragFile[128];        //  PDB file defining dragged atoms
00320                                       //  by non-zero value in the column
00321         char rotDragAxisFile[128];    //  PDB file; XYZ define axes for atoms;
00322         char rotDragPivotFile[128];   //  PDB file; XYZ define pivots for atoms
00323         BigReal rotDragGlobVel;       //  global drag velocity (deg/step)
00324         char rotDragVelFile[128];     //  PDB file; B or O scales angular
00325                                       //  velocity for each atom
00326         //****** END rotating drag changes
00327         //****** BEGIN "constant" torque changes
00328         Bool consTorqueOn;            //  Flag TRUE-> "constant" torque active
00329         char consTorqueFile[128];     //  PDB file defining torqued atoms
00330                                       //  by non-zero value in the column
00331         char consTorqueAxisFile[128]; //  PDB file; XYZ define axes for atoms;
00332         char consTorquePivotFile[128];//  PDB file; XYZ define pivots for atoms
00333         BigReal consTorqueGlobVal;    //  global "torque" (Kcal/(mol*A^2))
00334         char consTorqueValFile[128];  //  PDB file; B or O scales "torque"
00335                                       //  for each atom
00336         //****** END "constant" torque changes
00337 
00338         //****** BEGIN SMD constraints changes   
00339         Bool SMDOn;                     //  Flag TRUE-> SMD constraints active
00340         BigReal SMDVel;                 //  Velocity of the movement, A/timestep
00341         zVector SMDDir;                  //  Direction of the movement
00342         BigReal SMDk;                   //  Elastic constant for SMD
00343         BigReal SMDk2;                  //  Transverse elastic constant for SMD
00344         char SMDFile[128];              //  File for SMD information
00345         int SMDOutputFreq;              //  Output frequency for SMD constr.
00346         //****** END SMD constraints changes 
00347         
00348   //****** BEGIN tabulated energy section
00349   Bool tabulatedEnergies;
00350   int tableNumTypes;
00351   char tabulatedEnergiesFile[128];
00352   char tableInterpType[128];
00353   Real tableSpacing;
00354   BigReal tableMaxDist;
00355   //****** END tabulated energy section
00356 
00357         // TMD
00358         Bool TMDOn, TMDDiffRMSD;
00359         BigReal TMDk;
00360         char TMDFile[128], TMDFile2[128];
00361         int TMDOutputFreq;
00362         int TMDFirstStep, TMDLastStep;
00363         BigReal TMDInitialRMSD, TMDFinalRMSD;
00364 
00365         //Symmetry restraints
00366         Bool symmetryOn, symmetryScaleForces;
00367         BigReal symmetryk;
00368         char symmetrykfile[128];
00369         char symmetryFile[128];
00370         char symmetryMatrixFile[128];
00371         int symmetryFirstStep, symmetryLastStep, symmetryFirstFullStep, symmetryLastFullStep;
00372 
00373         
00374 //fepb
00375   Bool alchOnAtStartup;     //  Ensure that alchemy is set up properly
00376   Bool alchOn;              //  Doing alchemical simulation?
00377   Bool alchFepOn;           //  Doing alchemical simulation?
00378   Bool alchThermIntOn;      //  Doing thermodynamic integration?
00379   Bool alchFepWCARepuOn;    //  Doing WCA decomposition repulsion interaction?
00380   Bool alchFepWCADispOn;    //  Doing WCA decomposition dispersion interaction?
00381   Bool alchFepElecOn;       //  Doing electrostatic interaction perturbation?
00382   Bool alchFepWhamOn;       //  Doing Wham postprocessing for FEP?
00383   int alchMethod;           //  Which alchemical method to use? fep or ti
00384   BigReal alchLambda;       //  lambda for dynamics
00385   BigReal alchLambda2;      //  lambda for comparison
00386   int alchLambdaFreq;       //  freq. (in steps) with which lambda changes 
00387                             //  from alchLambda to alchLambda2
00388   BigReal getCurrentLambda(const int); // getter for changing lambda
00389   BigReal getLambdaDelta(void); // getter for lambda increment
00390   BigReal alchRepLambda;    //  lambda for WCA repulsive interaction
00391   BigReal alchDispLambda;   //  lambda for WCA dispersion interaction
00392   BigReal alchElecLambda;   //  lambda for electrostatic perturbation
00393   BigReal alchFepWCArcut1;  //  rcut1 of WCA decompistion repulsion
00394   BigReal alchFepWCArcut2;  //  rcut2 of WCA decomposition repulsion
00395   BigReal alchFepWCArcut3;  //  rcut3 of WCA decomposition repulsion
00396   BigReal alchTemp;         //  temperature for alchemical calculation
00397   int alchOutFreq;          //  freq. of alchemical output
00398   Bool alchEnsembleAvg;      //if do ensemble average for the net free energy difference 
00399   char alchOutFile[128];    //  alchemical output filename
00400   int alchEquilSteps;       //  # of equil. steps in the window
00401   BigReal alchVdwShiftCoeff; //  r2 shift coeff used for generating  
00402                             //  the alchemical altered vdW interactions
00403   BigReal alchElecLambdaStart;  //  lambda value for starting point of
00404                                 //  electrostatic interactions of 
00405                                 //  exnihilated particles.  For annihilated
00406                                 //  particles the starting point is
00407                                 //  (1-alchElecLambdaStart)
00408   BigReal getElecLambda(const BigReal); // return min[0,x/(1-elecStart)]
00409   BigReal alchVdwLambdaEnd;  //  lambda value for endpoint of vdW
00410                              //  interactions of exnihilated particles.
00411                              //  For annihilated particles the endpoint is 
00412                              //  (1-alchVdwLambdaEnd)
00413   BigReal getVdwLambda(const BigReal); // return max[1,x/vdwEnd]
00414   BigReal alchBondLambdaEnd; //  lambda value for endpoint of bonded 
00415                              //  interactions involving exnihilated particles.
00416                              //  For annihilated particles the endpoint is 
00417                              //  (1-alchBondLambdaEnd)
00418   BigReal getBondLambda(const BigReal); // return max[1,x/bondEnd]
00419   Bool alchDecouple;  // alchemical decoupling rather than annihilation
00420   Bool alchBondDecouple; // decouple purely alchemical bonds
00421 //fepe
00422 
00423   
00424         Bool lesOn;                     //  Locally enhanced sampling?
00425         int lesFactor;                  //  local enhancement factor
00426         Bool lesReduceTemp;             //  Reduce enhanced atom temperature?
00427         Bool lesReduceMass;             //  Reduce enhanced atom mass?
00428 
00429         Bool extForcesOn;               //  Are ext command forces present?
00430         char extForcesCommand[256];
00431         char extCoordFilename[128];
00432         char extForceFilename[128];
00433 
00434         
00435         // Defines variables for QM/MM calculations
00436         Bool qmForcesOn;               //  Are QM/MM command forces present?
00437         char qmParamPDB[128];
00438         Bool qmParamPDBDefined;
00439         Bool qmChrgFromPSF;
00440         char qmExecPath[256];
00441         char qmSoftware[128];
00442         char qmChrgModeS[16];
00443         int qmChrgMode;
00444         char qmColumn[16];
00445         char qmBaseDir[256];
00446         char qmSecProc[256];
00447         Bool qmSecProcOn;
00448         char qmPrepProc[256];
00449         Bool qmPrepProcOn;
00450         int qmFormat ;
00451         Bool qmReplaceAll ;
00452         Bool qmMOPACAddConfigChrg;
00453         
00454         Bool qmBondOn;
00455         char qmBondColumn[16];
00456         Bool qmBondDist;
00457         int qmBondValType;
00458         char qmBondValueTypeS[16];
00459         char qmBondSchemeS[16] ;
00460         int qmBondScheme;
00461         Bool qmPCSwitchOn;
00462         char qmPCSwitchTypeS[16];
00463         int qmPCSwitchType;
00464         char qmPCSchemeS[16];
00465         int qmPCScheme;
00466         int qmSimsPerNode;
00467         
00468         Bool qmVDW ;
00469         Bool qmNoPC ;
00470         Bool qmElecEmbed ;
00471         int qmPCSelFreq ;
00472         Bool qmCustomPCSel;
00473 
00474         Bool qmLSSOn ;
00475         int qmLSSFreq ;
00476         char qmLSSResname[5] ;
00477         char qmLSSModeS[16];
00478         int qmLSSMode;
00479         
00480         Bool qmCSMD;
00481         char qmCSMDFile[128];
00482         
00483         int qmEnergyOutFreq ;
00484         int qmOutFreq ;
00485         int qmPosOutFreq ;
00486         
00487   Bool printBadContacts;        //print indices of bad contacts being moved downhill
00488 
00489   //gbis implicit solvent parameters
00490   Bool GBISOn;                    //do generalized born implicit solvent
00491   BigReal fsMax;
00492   Bool GBISserOn;                 //do generalized born implicit solvent serial
00493   BigReal solvent_dielectric;     //epsilon_s
00494   BigReal coulomb_radius_offset;  //rho_0
00495   BigReal kappa;      //debye screening length; k = sqrt(ion concentration mol/L ) / 0.304
00496   BigReal ion_concentration;
00497         BigReal gbis_delta;                                                     //three parameters for born radius calc
00498         BigReal gbis_beta;
00499         BigReal gbis_gamma;
00500         BigReal alpha_cutoff;                                           //pairwise cutoff for integrating born radius
00501         BigReal alpha_max;                                                              //maximum allowable born radius
00502   Bool LCPOOn;                    //do LCPO SASA for GBSA
00503   BigReal surface_tension;        //surface tension (kcal/mol/Ang^2) for LCPO
00504 
00505         Bool drudeOn;       // Perform integration of Drude oscillators?
00506         Bool drudeHardWallOn;  // Apply maximum Drude bond length restriction?
00507         BigReal drudeTemp;  // (low) temperature for freezing Drude oscillators
00508         BigReal drudeDamping;    // Langevin damping coefficient (1/ps)
00509                                  //   defaults to langevinDamping
00510         BigReal drudeBondLen;    // Length beyond which to apply quartic
00511                                  //   restraining potential to Drude bond
00512         BigReal drudeBondConst;  // Force constant for restraining potential
00513         BigReal drudeNbtholeCut;             // Radius of thole pair interaction
00514 
00515         Bool pairInteractionOn;         //  Calculate pair interactions?
00516         int pairInteractionGroup1;      //  Interaction group 1.
00517         int pairInteractionGroup2;      //  Interaction group 2.
00518         Bool pairInteractionSelf;       //  Compute just within group.
00519      
00520         Bool cosAngles;    // Can some angles be cos-based
00521         Bool globalForcesOn;            //  Are global forces present?
00522         Bool tclForcesOn;               //  Are Tcl forces present?
00523 #ifdef NAMD_TCL
00524         Bool tclIsThreaded;             //  Is Tcl library thread-safe?
00525 #endif
00526         Bool tclBCOn;                   //  Are Tcl boundary forces present
00527         char *tclBCScript;              //  Script defining tclBC calcforces
00528         char tclBCArgs[128];            //  Extra args for calcforces command
00529         Bool freeEnergyOn;              //  Doing free energy perturbation?
00530         Bool miscForcesOn;              //  Using misc forces?
00531         Bool colvarsOn;         //  Using the colvars module?
00532 
00533         Bool fixedAtomsOn;              //  Are there fixed atoms?
00534         Bool fixedAtomsForces;          //  Calculate forces anyway?
00535         Bool fixedAtomsForceOutput; // Output fixed forces?
00536 
00537         Bool langevinOnAtStartup;       //  Ensure that langevin is set up properly
00538         Bool langevinOn;                //  Flag TRUE-> langevin dynamics active
00539         BigReal langevinTemp;           //  Temperature for Langevin dynamics
00540         BigReal langevinDamping;        //  Damping coefficient (1/ps)
00541         Bool langevinHydrogen;          //  Flag TRUE-> apply to hydrogens
00542         Bool langevin_useBAOAB;         //  Flag TRUE-> use the experimental BAOAB integrator for NVT instead of the BBK one
00543                                         //  See Leimkuhler and Matthews (AMRX 2012); implemented in NAMD by CM June2012
00544         
00545         // BEGIN LA
00546         Bool loweAndersenOn;            //  Flag TRUE-> Lowe-Andersen dynamics active
00547         BigReal loweAndersenTemp;       //  Temperature for Lowe-Andersen dynamics
00548         BigReal loweAndersenRate;       //  Collision frequency for Lowe-Andersen dynamics (1/ps)
00549         BigReal loweAndersenCutoff;     //  Cutoff radius for Lowe-Andersen dynamics
00550         // END LA
00551 
00552         Bool globalOn;                  //  Flag TRUE-> use global integrator
00553         Bool dihedralOn;                //  Flag TRUE-> dihedral dynamics active
00554         Bool COLDOn;                    //  Flag TRUE-> constrained overdamped
00555                                         //  langevin dynamics active
00556         BigReal COLDRate;               //  Damping coefficient for COLD.
00557         BigReal COLDTemp;               //  Temperature for COLD.
00558 
00559         Bool tCoupleOn;                 //  Flag TRUE-> Temperature coupling 
00560                                         //  active
00561         BigReal tCoupleTemp;            //  Temperature for temp coupling
00562 
00563         int rescaleFreq;                //  Velocity rescale frequency
00564         BigReal rescaleTemp;            //  Temperature to rescale to
00565 
00566         Bool accelMDOn;                 //  Perform accelerated MD
00567         Bool accelMDdihe;               //  Apply boost to the dihedral potential
00568         Bool accelMDdual;               //  dual boost mode  
00569         Bool accelMDDebugOn;            //  Debugging accelerated MD
00570         BigReal accelMDFirstStep;       //  First aMD step
00571         BigReal accelMDLastStep;        //  Last aMD step
00572         int accelMDOutFreq;             //  aMD output frequency
00573         BigReal accelMDE;               //  aMD E
00574         BigReal accelMDalpha;           //  aMD alpha
00575         BigReal accelMDTE;              //  E for total potential in the dual boost mode
00576         BigReal accelMDTalpha;          //  alpha for total potential in the dual boost mode
00577 
00578         Bool accelMDG;                  //  Perform Gaussian accelMD calculation
00579         int accelMDGiE;                 //  Flag to set the mode iE in Gaussian accelMD
00580         int accelMDGcMDSteps;           //  No. of cMD steps
00581         int accelMDGEquiSteps;          //  No. of quilibration steps after adding boost potential
00582         int accelMDGcMDPrepSteps;       //  No. of preparation cMD steps
00583         int accelMDGEquiPrepSteps;      //  No. of preparation equilibration steps
00584         BigReal accelMDGSigma0P;        //  upper limit of std of total potential
00585         BigReal accelMDGSigma0D;        //  upper limit of std of dihedral potential
00586         Bool accelMDGRestart;           //  Flag to set use restart file in Gaussian accelMD
00587         char accelMDGRestartFile[128];  //  restart file name
00588         Bool accelMDGresetVaftercmd;    //  Flag to reset potential after first accelMDGcMDSteps steps
00589 
00590         /* Begin Adaptive Temperature Sampling */
00591         Bool adaptTempOn;                      //  is adaptTempOn
00592         Bool adaptTempDebug;                   //  Debuggin adaptive temperature sampling
00593         int adaptTempFirstStep;                //  First adaptTemp step
00594         int adaptTempLastStep;                 //  Last adaptTemp step
00595         int adaptTempOutFreq;                  //  adaptTemp output frequency
00596         int adaptTempFreq;                     //  Steps between adaptTemp updates
00597         BigReal adaptTempTmin;                 //  Lower temperature bound
00598         BigReal adaptTempTmax;                 //  Upper temperature bound
00599         BigReal adaptTempAutoDt;               //  Auto jump size. Value determines upper bound, adaotTempDt determines lower bound 
00600         int adaptTempBins;                     //  Number of bins to store average energy values
00601         BigReal adaptTempDt;                   //  timestep for adaptTemp updates - only affects Temperature random walk
00602         BigReal adaptTempCgamma;               //  Cgamma variable for adaptive bin averaging Cgamma = 0 is normal Averaging. 1 > Cgamma >= 0
00603         Bool adaptTempLangevin;                //  Couple to Langevin Thermostat
00604         Bool adaptTempRescale;                 //  Couple to Vel. Rescaling
00605         char adaptTempInFile[128];             //  Restart information for adaptTemp to read
00606         char adaptTempRestartFile[128];        //  File to write restart information
00607         int  adaptTempRestartFreq;             //  Frequency of writing restart output
00608         Bool adaptTempRandom;                  //  Do we assign random temperatures when we step out of [Tmin,Tmax]?
00609         /* End Adaptive Temperature Sampling */
00610 
00611         int reassignFreq;               //  Velocity reassignment frequency
00612         BigReal reassignTemp;           //  Temperature to reassign to
00613         BigReal reassignIncr;           //  Added to reassignTemp each time
00614         BigReal reassignHold;           //  Hold reassignTemp at this value
00615 
00616         Bool useGroupPressure;          //  Use group rather than atomic
00617                                         //  quantities for pressure calc
00618 
00619         Bool excludeFromPressure;       //  Flag TRUE-> some atoms not rescaled
00620  
00621         Bool useFlexibleCell;           //  Use anisotropic cell fluctuations
00622         Bool useConstantArea;           //  x,y dimensions fixed.
00623         Bool useConstantRatio;          //  x,y ratio fixed.
00624 
00625   Bool fixCellDims; // fix the cell dimensions
00626   Bool fixCellDimX;
00627   Bool fixCellDimY;
00628   Bool fixCellDimZ;
00629 
00630         Bool berendsenPressureOn;       //  Berendsen pressure bath
00631         BigReal berendsenPressureTarget;
00632         BigReal berendsenPressureCompressibility;
00633         BigReal berendsenPressureRelaxationTime;
00634         int berendsenPressureFreq;
00635 
00636         Bool langevinPistonOn;          //  Langevin piston pressure control
00637         Bool langevinPistonBarrier;     //  Turn off to extrapolate cell
00638         BigReal langevinPistonTarget;
00639         BigReal langevinPistonPeriod;
00640         BigReal langevinPistonDecay;
00641         BigReal langevinPistonTemp;
00642 
00643         Bool multigratorOn;     // Multigrator temperature and/or pressure control
00644         BigReal multigratorPressureTarget;
00645         BigReal multigratorPressureRelaxationTime;
00646         int multigratorPressureFreq;
00647         BigReal multigratorTemperatureTarget;
00648         BigReal multigratorTemperatureRelaxationTime;
00649         int multigratorTemperatureFreq;
00650         int multigratorNoseHooverChainLength;
00651 
00652         BigReal surfaceTensionTarget;
00653 
00654         Bool pressureProfileOn;         // Compute lateral pressure profile?
00655         int pressureProfileSlabs;       // Number of slabs
00656         int pressureProfileFreq;        // How often to store profile data
00657         int pressureProfileAtomTypes;
00658         Bool pressureProfileEwaldOn;    // Compute Ewald contribution?
00659         int pressureProfileEwaldX;
00660         int pressureProfileEwaldY;
00661         int pressureProfileEwaldZ;
00662         
00663         zVector strainRate;
00664         zVector strainRate2; // off diagonal elements (xy, xz, yz)
00665 
00666         unsigned int randomSeed;        //  Seed for random number generator
00667 
00668         Bool FMAOn;                     //  Flag TRUE-> FMA active
00669         int FMALevels;                  //  Number of Levels for FMA
00670         int FMAMp;                      //  Number of multipole terms for FMA
00671         Bool FMAFFTOn;                  //  FFT on/off flag for FMA
00672         int FMAFFTBlock;                //  FFT blocking factor for FMA
00673 
00674         Bool fullDirectOn;              //  Should direct calculations of
00675                                         //  full electrostatics be performed?
00676 
00677         Bool MSMOn;      // enable MSM (multilevel summation method)
00678                          // for long-range electrostatics
00679 
00680         int MSMQuality;  // choose MSM quality 0 (low) - 3 (high), using
00681                          // optimal combination of approximation and splitting
00682                          // defaults to "low" for fastest performance
00683 
00684         int MSMApprox;   // choose MSM approximation
00685                          // defaults to "cubic" (low) for fastest performance
00686 
00687         int MSMSplit;    // choose MSM splitting function
00688                          // defaults to "Taylor2" (low) for fastest performance
00689 
00690         int MSMLevels;   // select number of MSM levels
00691                          // default (0) adapts number of levels to the
00692                          // system for fastest performance
00693 
00694         int MSMBlockSizeX;  // controls size of parallel work decomposition
00695         int MSMBlockSizeY;  // controls size of parallel work decomposition
00696         int MSMBlockSizeZ;  // controls size of parallel work decomposition
00697 
00698         BigReal MSMGridSpacing;  // defaults to 2.5 A, best for atomic systems
00699 
00700         BigReal MSMPadding;      // pad grid along non-periodic boundaries
00701                                  // defaults to 2.5 A
00702                                  // increase if atoms are drifting beyond
00703                                  // edge of grid, which will terminate 
00704                                  // simulation prematurely
00705 
00706         BigReal MSMxmin;  // define extent of non-periodic boundaries
00707         BigReal MSMxmax;
00708         BigReal MSMymin;
00709         BigReal MSMymax;
00710         BigReal MSMzmin;
00711         BigReal MSMzmax;
00712 
00713         Bool MsmSerialOn;   // use serial MSM solver for testing
00714 
00715         Bool FMMOn;
00716         int FMMLevels;
00717         BigReal FMMPadding;
00718 
00719         Bool PMEOn;                     //  Flag TRUE -> PME active
00720         BigReal PMETolerance;           //  Direct space tolerance
00721         BigReal PMEEwaldCoefficient;    //  From tolerance and cutoff
00722         int PMEInterpOrder;             //  Order of interpolation
00723         int PMEGridSizeX;               //  No. of grid points in x dim
00724         int PMEGridSizeY;               //  No. of grid points in y dim
00725         int PMEGridSizeZ;               //  No. of grid points in z dim
00726         BigReal PMEGridSpacing;         //  Maximum spacing between points
00727         int PMEProcessors;              //  No. of processors to use
00728         int PMEMinSlices;               //  Min slices per PME slab
00729         int PMEMinPoints;               //  Min points per PME pencil
00730         Bool PMEBarrier;                //  Use barrier before sendTrans
00731         int PMEPencils;                 //  Size of pencil grid in each dim
00732         int PMEPencilsX;                //  Size of pencil grid in X dim
00733         int PMEPencilsY;                //  Size of pencil grid in Y dim
00734         int PMEPencilsZ;                //  Size of pencil grid in Z dim
00735         int PMEPencilsYLayout;          //  Y pencil layout strategy
00736         int PMEPencilsXLayout;          //  X pencil layout strategy
00737         int PMESendOrder;               //  Message ordering strategy
00738         Bool PMEOffload;                //  Offload reciprocal sum to accelerator
00739 
00740         Bool useDPME;                   //  Flag TRUE -> old DPME code
00741         Bool usePMECUDA;                //  Flag TRUE -> use the PME CUDA version
00742         Bool useCUDA2;                  //  Flag TRUE -> use ComputeNonbondedCUDA2
00743   int bondedCUDA;                 //  Bitmask for calculating bonded interactions on GPU
00744         Bool useOptPME;                 //  Flag TRUE -> use the scalable version of PME
00745         Bool useManyToMany;             //  Flag TRUE -> use the manytomany optimization of PME. 
00746                                         //  This flag requres useOptPME to be set.
00747 
00748         Bool FFTWEstimate;
00749         Bool FFTWPatient;
00750         Bool FFTWUseWisdom;
00751         char FFTWWisdomFile[128];
00752         char *FFTWWisdomString;
00753 
00754         #ifdef OPENATOM_VERSION
00755         Bool openatom;                  // Flag TRUE -> OpenAtom QM/MM active
00756         #endif // OPENATOM_VERSION 
00757 
00758         Bool minimizeCGOn;              //  Flag TRUE-> CG minimization active
00759         Bool minVerbose;                //  Flag TRUE-> print extra minimization data
00760         BigReal minTinyStep;            //  Minimization parameter
00761         BigReal minBabyStep;            //  Minimization parameter
00762         BigReal minLineGoal;            //  Minimization parameter
00763         Bool minimizeOn;                //  Flag TRUE-> minimization active
00764         BigReal maximumMove;            //  Maximum movement per timestep 
00765                                         //  during minimization
00766 
00767         Bool sphericalBCOn;             //  Flag TRUE-> spherical boundary 
00768                                         //  conditions are active
00769         zVector sphericalCenter;                //  Center specified by user
00770         BigReal sphericalBCk1;          //  First force constant for 
00771                                         //  spherical BC
00772         BigReal sphericalBCk2;          //  Second force constant for 
00773                                         //  spherical BC
00774         BigReal sphericalBCr1;          //  First radius for spherical BC
00775         BigReal sphericalBCr2;          //  Second radius for spherical BC
00776         int sphericalBCexp1;            //  First radius for spherical BC
00777         int sphericalBCexp2;            //  Second radius for spherical BC
00778 
00779         Bool cylindricalBCOn;           //  Flag TRUE->cylindrical boundary
00780                                         //  conditions are active
00781         zVector cylindricalCenter;
00782         char cylindricalBCAxis;         //  'x', 'y', or 'z'
00783         BigReal cylindricalBCr1;
00784         BigReal cylindricalBCr2;
00785         BigReal cylindricalBCl1;
00786         BigReal cylindricalBCl2;
00787         int cylindricalBCexp1;
00788         int cylindricalBCexp2;
00789         BigReal cylindricalBCk1;
00790         BigReal cylindricalBCk2;
00791 
00792         Bool eFieldOn;                  //  Should a electric field be applied
00793         Bool eFieldNormalized;          //  Is eField vector scaled by cell basis vectors
00794         zVector eField;                 //  Electric field vector to be applied
00795         BigReal eFieldFreq;             // Frequency of the electric field
00796         BigReal eFieldPhase;            // Phase phi, cos(w*t-phi*PI/180) 
00797 
00798         Bool stirOn;                   // Should a stirring torque be applied
00799         char stirFilename[128];        // Stirring filename (atoms marked)
00800         //do the below two even needed to be defined?
00801         BigReal stirStartingTheta;     // Stir starting theta offset
00802         BigReal stirVel;               // Stir angular velocity
00803         BigReal stirK;                 // Stir force harmonic spring constant
00804         zVector stirAxis;              // Direction of stir axis
00805         zVector stirPivot;             // Pivot point of stir axis
00806 
00807         Bool extraBondsOn;              // read extra bonded forces
00808 
00809         Bool consForceOn;               //  Should constant force be applied
00810   char consForceFile[128];
00811         BigReal consForceScaling;
00812 
00813         int outputEnergies;             //  Number of timesteps between energy
00814                                         //  outputs
00815 
00816         int outputMomenta;              //  Number of timesteps between momentum
00817                                         //  outputs
00818 
00819         int outputTiming;               //  Number of timesteps between timing
00820                                         //  outputs
00821 
00822         int outputCudaTiming;           //  Number of timesteps between timing
00823                                         //  outputs of CUDA code
00824 
00825         int outputPressure;             //  Number of timesteps between pressure
00826                                         //  tensor outputs
00827 
00828         Bool mergeCrossterms;           //  Merge crossterm energy w/ dihedrals
00829 
00830         int firstTimestep;              //  Starting timestep.  Will be 0 unless
00831                                         //  restarting a simulation
00832 
00833         MTSChoices MTSAlgorithm;        //  What multiple timestep algorithm
00834                                         //  to use
00835 
00836         int longSplitting;              //  What electrostatic splitting        
00837                                         //  to use
00838 
00839         Bool ignoreMass;                //  Mass < 3.5 does not indicate hydrogen, etc.
00840 
00841         int splitPatch;                 // How are patches determined?
00842         BigReal hgroupCutoff;           // what is the added hydrogen margin?
00843 
00844         int mollyOn;                    // mollify long range forces?
00845         BigReal mollyTol;               // error tolerance for molly
00846         int mollyIter;                  // max number of iterations for molly
00847 
00848         int rigidBonds;                 // what type of rigid bonds to hydrogens
00849                                         // none, all, or only water
00850 
00851         BigReal rigidTol;               // error tolerance for rigid bonds
00852         int rigidIter;                  // Number of NR iterations 
00853         int rigidDie;                   // die if rigidTol not achieved
00854 
00855         Bool useSettle;                 // Use SETTLE; requires rigid waters
00856 
00857         Bool testOn;                    //  Do tests rather than simulation
00858         Bool commOnly;                  //  Don't do any force evaluations
00859         Bool statsOn;                   //  Don't do any force evaluations
00860 
00861         int totalAtoms;                 //  Total Number of atoms in simulation
00862         int maxSelfPart;                // maximum number of self partitions
00863                                         // that a patch can be split into
00864         int maxPairPart;                // maximum number of pair partitions
00865                                         // that a patch can be split into
00866         int numAtomsSelf;               // maximum number of atoms in a single
00867                                         // self-compute 
00868         int numAtomsSelf2;              // maximum number of atoms in a pair compute
00869                                         // in the presence of twoAwayX,Y,Z options
00870         int numAtomsPair;               // maximum number of atoms in a single
00871                                         // pair-compute 
00872         int numAtomsPair2;              // maximum number of atoms in a single
00873                                         // pair-compute 
00874         int minAtomsPerPatch;           // minimum average atoms per patch
00875                                         //  (may create larger patches) 
00876         int maxExclusionFlags;          // maximum size of exclusion check list
00877                                         // for any given atom
00878         Bool outputPatchDetails;        // print number of atoms per patch
00879         Bool staticAtomAssignment;      // never migrate atoms
00880         Bool replicaUniformPatchGrids;  // same patch grid size on all replicas
00881 
00882         //
00883         // hydrogen bond simulation parameters
00884         //
00885 
00886         // should the hydrogen bond term be used?  If FALSE, all other
00887         // hydrogen bond parameters are unnecessary in simulation.
00888         Bool HydrogenBonds;
00889 
00890         // should the antecedent atom be used in the calculation of hbonds?
00891         Bool useAntecedent;
00892 
00893         // exponents used in hydrogen bond energy function:
00894         //   aaAngleExp = exp for H-A-AA angle term (n)
00895         //   haAngleExp = exp for D-H-A angle term (m)
00896         //   distAttExp = exp for attractive A-D distance term (j)
00897         //   distRepExp = exp for repulsive A-D distance term (i)
00898         int aaAngleExp, haAngleExp, distAttExp, distRepExp;
00899 
00900         // cutoff D-H-A angle, and on/off angles for switch fcn (in degrees)
00901         BigReal dhaCutoffAngle, dhaOnAngle, dhaOffAngle;
00902 
00903         // cutoff distance for D-A separation in hbonds (in Angstroms), and
00904         // on/off distances for hbond radial term switching function
00905         BigReal daCutoffDist, daOnDist, daOffDist;
00906 
00907         // IMD parameters
00908         int IMDon;    // enable IMD
00909         int IMDport;  // port on which to listen for connections
00910         int IMDfreq;  // frequency at which coordinates will be available
00911         int IMDwait;  // if true, pause the simulation when there is no
00912                       // connection
00913         int IMDignore;  // IMD connection does not influence simulation
00914                         // only sends coordinates and energies to VMD
00915         int IMDignoreForces;  // Only the Forces are ignored. Finish, Pause and Resume are enabled
00916                         
00917         
00918         // AMBER options
00919         Bool amberOn; // FLAG TRUE-> amber force field is used
00920         Bool readExclusions; // FLAG TRUE-> Read exclusions from parm file
00921         BigReal vdwscale14; //  Scaling factor for 1-4 VDW interactions
00922 
00923         // GROMACS options
00924         Bool gromacsOn; // FLAG TRUE -> gromacs-style force field is used
00925 
00926         // OPLS options
00927         Bool vdwGeometricSigma;  // Lennard-J sigma uses geometric mean
00928 
00929         // ScriptTcl argument passing
00930         BigReal scriptArg1;
00931         BigReal scriptArg2;
00932         BigReal scriptArg3;
00933         BigReal scriptArg4;
00934         BigReal scriptArg5;
00935         int scriptIntArg1;
00936         int scriptIntArg2;
00937         char scriptStringArg1[128];
00938         char scriptStringArg2[128];
00939 
00940         Bool useCompressedPsf;
00941         Bool genCompressedPsf;
00942 
00943         Bool usePluginIO;
00944 
00945         Bool mallocTest;
00946         Bool printExclusions;
00947 
00948         //default value is -1
00949         int proxySendSpanningTree;
00950         int proxyRecvSpanningTree;
00951 
00952     int proxyTreeBranchFactor;
00953 
00954 
00955     //fields needed for Parallel IO Input
00956     int numinputprocs;
00957     char *binAtomFile;
00958     char *binCoorFile;
00959     char *binVelFile; 
00960     char *binRefFile; 
00961     
00962     //fields needed for Parallel IO Output
00963     int numoutputprocs; 
00964     int numoutputwrts;
00965 
00966         char computeMapFilename[128];           //  store compute map
00967         Bool storeComputeMap;
00968         Bool loadComputeMap;
00969 
00970         // MIC-specific parameters
00971         int mic_hostSplit;
00972         int mic_numParts_self_p1;
00973         int mic_numParts_pair_p1;
00974         int mic_numParts_pair_p2;
00975         int mic_unloadMICPEs;
00976         int mic_deviceThreshold;
00977         int mic_singleKernel;
00978 
00979 public:
00980 
00981         SimParameters() : mgridforcelist(), parseopts(0) {};
00982         SimParameters(ConfigList *c, char *&cwd) : mgridforcelist(), parseopts(0) {
00983           initialize_config_data(c,cwd);
00984         };
00985         ~SimParameters() {};
00986 
00987         void initialize_config_data(ConfigList *, char *&cwd);
00988                                         //  Initialize SimParameters data
00989                                         //  from the ConfigList object
00990         void send_SimParameters(MOStream *);    
00991                                         //  Used by the master process
00992                                         //  to send the paramters to
00993                                         //  the other processors
00994         void receive_SimParameters(MIStream *);  
00995                                         //  Used by the other processors
00996                                         //  to receive the data from the
00997                                         //  master process
00998         void scriptSet(const char *, const char *);
00999                                         //  Set parameters at run time
01000         void close_dcdfile();  // *** implemented in Output.C ***
01001         void close_veldcdfile();  // *** implemented in Output.C ***
01002         static void nonbonded_select();
01003 
01004         int isSendSpanningTreeOn(){ return proxySendSpanningTree == 1; }
01005         int isSendSpanningTreeUnset() { return proxySendSpanningTree == -1; }
01006         int isRecvSpanningTreeOn(){ return proxyRecvSpanningTree == 1; }
01007         int isRecvSpanningTreeUnset() { return proxyRecvSpanningTree == -1; }
01008 
01009         char* getfromparseopts(const char* name, char *outbuf);
01010         int istrueinparseopts(const char* name);
01011         int issetinparseopts(const char* name);
01012 
01013         void readExtendedSystem(const char *filename, Lattice *latptr=0);
01014 private:
01015         ParseOptions *parseopts;
01016 
01017         void config_parser(ParseOptions &opts);
01018 
01019         void config_parser_basic(ParseOptions &opts);
01020         void config_parser_fileio(ParseOptions &opts);
01021         void config_parser_fullelect(ParseOptions &opts);
01022         void config_parser_methods(ParseOptions &opts);
01023         void config_parser_constraints(ParseOptions &opts);
01024 #ifdef OPENATOM_VERSION
01025         void config_parser_openatom(ParseOptions &opts);
01026 #endif //OPENATOM_VERSION
01027         /* BEGIN gf */
01028         void config_parser_gridforce(ParseOptions &opts);
01029         /* END gf */
01030         void config_parser_movdrag(ParseOptions &opts);
01031         void config_parser_rotdrag(ParseOptions &opts);
01032         void config_parser_constorque(ParseOptions &opts);
01033         void config_parser_boundary(ParseOptions &opts);
01034         void config_parser_misc(ParseOptions &opts);
01035         void config_parser_mgridforce(ParseOptions &opts);
01036         void parse_mgrid_string_param(ConfigList *config,
01037                                       const char *fieldname, char** dest);
01038         void parse_mgrid_params(ConfigList *config);
01039         void print_mgrid_params();
01040 
01041         void check_config(ParseOptions &opts, ConfigList *config, char *&cwd);
01042 
01043         void print_config(ParseOptions &opts, ConfigList *config, char *&cwd);
01044 
01045         void create_output_directories(const char *dirname);
01046 
01047         int fmaFrequency;               //  outdated parameter name
01048         char loadBalancer[64];          //  Load balancer
01049         char loadStrategy[64];          //  Load balancing strategy
01050 
01051 };
01052 
01053 #endif
01054 

Generated on Sat Nov 18 01:17:16 2017 for NAMD by  doxygen 1.4.7