File: | gromacs/gmxpreprocess/readir.c |
Location: | line 3619, column 5 |
Description: | Value stored to 'nSAoff' is never read |
1 | /* |
2 | * This file is part of the GROMACS molecular simulation package. |
3 | * |
4 | * Copyright (c) 1991-2000, University of Groningen, The Netherlands. |
5 | * Copyright (c) 2001-2004, The GROMACS development team. |
6 | * Copyright (c) 2013,2014, by the GROMACS development team, led by |
7 | * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl, |
8 | * and including many others, as listed in the AUTHORS file in the |
9 | * top-level source directory and at http://www.gromacs.org. |
10 | * |
11 | * GROMACS is free software; you can redistribute it and/or |
12 | * modify it under the terms of the GNU Lesser General Public License |
13 | * as published by the Free Software Foundation; either version 2.1 |
14 | * of the License, or (at your option) any later version. |
15 | * |
16 | * GROMACS is distributed in the hope that it will be useful, |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
19 | * Lesser General Public License for more details. |
20 | * |
21 | * You should have received a copy of the GNU Lesser General Public |
22 | * License along with GROMACS; if not, see |
23 | * http://www.gnu.org/licenses, or write to the Free Software Foundation, |
24 | * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
25 | * |
26 | * If you want to redistribute modifications to GROMACS, please |
27 | * consider that scientific software is very special. Version |
28 | * control is crucial - bugs must be traceable. We will be happy to |
29 | * consider code for inclusion in the official distribution, but |
30 | * derived work must not be called official GROMACS. Details are found |
31 | * in the README & COPYING files - if they are missing, get the |
32 | * official version at http://www.gromacs.org. |
33 | * |
34 | * To help us fund GROMACS development, we humbly ask that you cite |
35 | * the research papers on the package. Check out http://www.gromacs.org. |
36 | */ |
37 | #ifdef HAVE_CONFIG_H1 |
38 | #include <config.h> |
39 | #endif |
40 | |
41 | #include <ctype.h> |
42 | #include <stdlib.h> |
43 | #include <limits.h> |
44 | #include "gromacs/utility/smalloc.h" |
45 | #include "typedefs.h" |
46 | #include "physics.h" |
47 | #include "names.h" |
48 | #include "gromacs/utility/fatalerror.h" |
49 | #include "macros.h" |
50 | #include "index.h" |
51 | #include "symtab.h" |
52 | #include "gromacs/utility/cstringutil.h" |
53 | #include "readinp.h" |
54 | #include "warninp.h" |
55 | #include "readir.h" |
56 | #include "toputil.h" |
57 | #include "index.h" |
58 | #include "network.h" |
59 | #include "gromacs/math/vec.h" |
60 | #include "pbc.h" |
61 | #include "mtop_util.h" |
62 | #include "chargegroup.h" |
63 | #include "inputrec.h" |
64 | #include "calc_verletbuf.h" |
65 | |
66 | #define MAXPTR254 254 |
67 | #define NOGID255 255 |
68 | |
69 | /* Resource parameters |
70 | * Do not change any of these until you read the instruction |
71 | * in readinp.h. Some cpp's do not take spaces after the backslash |
72 | * (like the c-shell), which will give you a very weird compiler |
73 | * message. |
74 | */ |
75 | |
76 | typedef struct t_inputrec_strings |
77 | { |
78 | char tcgrps[STRLEN4096], tau_t[STRLEN4096], ref_t[STRLEN4096], |
79 | acc[STRLEN4096], accgrps[STRLEN4096], freeze[STRLEN4096], frdim[STRLEN4096], |
80 | energy[STRLEN4096], user1[STRLEN4096], user2[STRLEN4096], vcm[STRLEN4096], x_compressed_groups[STRLEN4096], |
81 | couple_moltype[STRLEN4096], orirefitgrp[STRLEN4096], egptable[STRLEN4096], egpexcl[STRLEN4096], |
82 | wall_atomtype[STRLEN4096], wall_density[STRLEN4096], deform[STRLEN4096], QMMM[STRLEN4096], |
83 | imd_grp[STRLEN4096]; |
84 | char fep_lambda[efptNR][STRLEN4096]; |
85 | char lambda_weights[STRLEN4096]; |
86 | char **pull_grp; |
87 | char **rot_grp; |
88 | char anneal[STRLEN4096], anneal_npoints[STRLEN4096], |
89 | anneal_time[STRLEN4096], anneal_temp[STRLEN4096]; |
90 | char QMmethod[STRLEN4096], QMbasis[STRLEN4096], QMcharge[STRLEN4096], QMmult[STRLEN4096], |
91 | bSH[STRLEN4096], CASorbitals[STRLEN4096], CASelectrons[STRLEN4096], SAon[STRLEN4096], |
92 | SAoff[STRLEN4096], SAsteps[STRLEN4096], bTS[STRLEN4096], bOPT[STRLEN4096]; |
93 | char efield_x[STRLEN4096], efield_xt[STRLEN4096], efield_y[STRLEN4096], |
94 | efield_yt[STRLEN4096], efield_z[STRLEN4096], efield_zt[STRLEN4096]; |
95 | |
96 | } gmx_inputrec_strings; |
97 | |
98 | static gmx_inputrec_strings *is = NULL((void*)0); |
99 | |
100 | void init_inputrec_strings() |
101 | { |
102 | if (is) |
103 | { |
104 | gmx_incons("Attempted to call init_inputrec_strings before calling done_inputrec_strings. Only one inputrec (i.e. .mdp file) can be parsed at a time.")_gmx_error("incons", "Attempted to call init_inputrec_strings before calling done_inputrec_strings. Only one inputrec (i.e. .mdp file) can be parsed at a time." , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 104); |
105 | } |
106 | snew(is, 1)(is) = save_calloc("is", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 106, (1), sizeof(*(is))); |
107 | } |
108 | |
109 | void done_inputrec_strings() |
110 | { |
111 | sfree(is)save_free("is", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 111, (is)); |
112 | is = NULL((void*)0); |
113 | } |
114 | |
115 | static char swapgrp[STRLEN4096], splitgrp0[STRLEN4096], splitgrp1[STRLEN4096], solgrp[STRLEN4096]; |
116 | |
117 | enum { |
118 | egrptpALL, /* All particles have to be a member of a group. */ |
119 | egrptpALL_GENREST, /* A rest group with name is generated for particles * |
120 | * that are not part of any group. */ |
121 | egrptpPART, /* As egrptpALL_GENREST, but no name is generated * |
122 | * for the rest group. */ |
123 | egrptpONE /* Merge all selected groups into one group, * |
124 | * make a rest group for the remaining particles. */ |
125 | }; |
126 | |
127 | static const char *constraints[eshNR+1] = { |
128 | "none", "h-bonds", "all-bonds", "h-angles", "all-angles", NULL((void*)0) |
129 | }; |
130 | |
131 | static const char *couple_lam[ecouplamNR+1] = { |
132 | "vdw-q", "vdw", "q", "none", NULL((void*)0) |
133 | }; |
134 | |
135 | void init_ir(t_inputrec *ir, t_gromppopts *opts) |
136 | { |
137 | snew(opts->include, STRLEN)(opts->include) = save_calloc("opts->include", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 137, (4096), sizeof(*(opts->include))); |
138 | snew(opts->define, STRLEN)(opts->define) = save_calloc("opts->define", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 138, (4096), sizeof(*(opts->define))); |
139 | snew(ir->fepvals, 1)(ir->fepvals) = save_calloc("ir->fepvals", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 139, (1), sizeof(*(ir->fepvals))); |
140 | snew(ir->expandedvals, 1)(ir->expandedvals) = save_calloc("ir->expandedvals", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 140, (1), sizeof(*(ir->expandedvals))); |
141 | snew(ir->simtempvals, 1)(ir->simtempvals) = save_calloc("ir->simtempvals", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 141, (1), sizeof(*(ir->simtempvals))); |
142 | } |
143 | |
144 | static void GetSimTemps(int ntemps, t_simtemp *simtemp, double *temperature_lambdas) |
145 | { |
146 | |
147 | int i; |
148 | |
149 | for (i = 0; i < ntemps; i++) |
150 | { |
151 | /* simple linear scaling -- allows more control */ |
152 | if (simtemp->eSimTempScale == esimtempLINEAR) |
153 | { |
154 | simtemp->temperatures[i] = simtemp->simtemp_low + (simtemp->simtemp_high-simtemp->simtemp_low)*temperature_lambdas[i]; |
155 | } |
156 | else if (simtemp->eSimTempScale == esimtempGEOMETRIC) /* should give roughly equal acceptance for constant heat capacity . . . */ |
157 | { |
158 | simtemp->temperatures[i] = simtemp->simtemp_low * pow(simtemp->simtemp_high/simtemp->simtemp_low, (1.0*i)/(ntemps-1)); |
159 | } |
160 | else if (simtemp->eSimTempScale == esimtempEXPONENTIAL) |
161 | { |
162 | simtemp->temperatures[i] = simtemp->simtemp_low + (simtemp->simtemp_high-simtemp->simtemp_low)*((exp(temperature_lambdas[i])-1)/(exp(1.0)-1)); |
163 | } |
164 | else |
165 | { |
166 | char errorstr[128]; |
167 | sprintf(errorstr, "eSimTempScale=%d not defined", simtemp->eSimTempScale); |
168 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 168, errorstr); |
169 | } |
170 | } |
171 | } |
172 | |
173 | |
174 | |
175 | static void _low_check(gmx_bool b, char *s, warninp_t wi) |
176 | { |
177 | if (b) |
178 | { |
179 | warning_error(wi, s); |
180 | } |
181 | } |
182 | |
183 | static void check_nst(const char *desc_nst, int nst, |
184 | const char *desc_p, int *p, |
185 | warninp_t wi) |
186 | { |
187 | char buf[STRLEN4096]; |
188 | |
189 | if (*p > 0 && *p % nst != 0) |
190 | { |
191 | /* Round up to the next multiple of nst */ |
192 | *p = ((*p)/nst + 1)*nst; |
193 | sprintf(buf, "%s should be a multiple of %s, changing %s to %d\n", |
194 | desc_p, desc_nst, desc_p, *p); |
195 | warning(wi, buf); |
196 | } |
197 | } |
198 | |
199 | static gmx_bool ir_NVE(const t_inputrec *ir) |
200 | { |
201 | return ((ir->eI == eiMD || EI_VV(ir->eI)((ir->eI) == eiVV || (ir->eI) == eiVVAK)) && ir->etc == etcNO); |
202 | } |
203 | |
204 | static int lcd(int n1, int n2) |
205 | { |
206 | int d, i; |
207 | |
208 | d = 1; |
209 | for (i = 2; (i <= n1 && i <= n2); i++) |
210 | { |
211 | if (n1 % i == 0 && n2 % i == 0) |
212 | { |
213 | d = i; |
214 | } |
215 | } |
216 | |
217 | return d; |
218 | } |
219 | |
220 | static void process_interaction_modifier(const t_inputrec *ir, int *eintmod) |
221 | { |
222 | if (*eintmod == eintmodPOTSHIFT_VERLET) |
223 | { |
224 | if (ir->cutoff_scheme == ecutsVERLET) |
225 | { |
226 | *eintmod = eintmodPOTSHIFT; |
227 | } |
228 | else |
229 | { |
230 | *eintmod = eintmodNONE; |
231 | } |
232 | } |
233 | } |
234 | |
235 | void check_ir(const char *mdparin, t_inputrec *ir, t_gromppopts *opts, |
236 | warninp_t wi) |
237 | /* Check internal consistency */ |
238 | { |
239 | /* Strange macro: first one fills the err_buf, and then one can check |
240 | * the condition, which will print the message and increase the error |
241 | * counter. |
242 | */ |
243 | #define CHECK(b)_low_check(b, err_buf, wi) _low_check(b, err_buf, wi) |
244 | char err_buf[256], warn_buf[STRLEN4096]; |
245 | int i, j; |
246 | int ns_type = 0; |
247 | real dt_coupl = 0; |
248 | real dt_pcoupl; |
249 | int nstcmin; |
250 | t_lambda *fep = ir->fepvals; |
251 | t_expanded *expand = ir->expandedvals; |
252 | |
253 | set_warning_line(wi, mdparin, -1); |
254 | |
255 | /* BASIC CUT-OFF STUFF */ |
256 | if (ir->rcoulomb < 0) |
257 | { |
258 | warning_error(wi, "rcoulomb should be >= 0"); |
259 | } |
260 | if (ir->rvdw < 0) |
261 | { |
262 | warning_error(wi, "rvdw should be >= 0"); |
263 | } |
264 | if (ir->rlist < 0 && |
265 | !(ir->cutoff_scheme == ecutsVERLET && ir->verletbuf_tol > 0)) |
266 | { |
267 | warning_error(wi, "rlist should be >= 0"); |
268 | } |
269 | |
270 | process_interaction_modifier(ir, &ir->coulomb_modifier); |
271 | process_interaction_modifier(ir, &ir->vdw_modifier); |
272 | |
273 | if (ir->cutoff_scheme == ecutsGROUP) |
274 | { |
275 | warning_note(wi, |
276 | "The group cutoff scheme is deprecated in Gromacs 5.0 and will be removed in a future " |
277 | "release when all interaction forms are supported for the verlet scheme. The verlet " |
278 | "scheme already scales better, and it is compatible with GPUs and other accelerators."); |
279 | |
280 | /* BASIC CUT-OFF STUFF */ |
281 | if (ir->rlist == 0 || |
282 | !((ir_coulomb_might_be_zero_at_cutoff(ir) && ir->rcoulomb > ir->rlist) || |
283 | (ir_vdw_might_be_zero_at_cutoff(ir) && ir->rvdw > ir->rlist))) |
284 | { |
285 | /* No switched potential and/or no twin-range: |
286 | * we can set the long-range cut-off to the maximum of the other cut-offs. |
287 | */ |
288 | ir->rlistlong = max_cutoff(ir->rlist, max_cutoff(ir->rvdw, ir->rcoulomb)); |
289 | } |
290 | else if (ir->rlistlong < 0) |
291 | { |
292 | ir->rlistlong = max_cutoff(ir->rlist, max_cutoff(ir->rvdw, ir->rcoulomb)); |
293 | sprintf(warn_buf, "rlistlong was not set, setting it to %g (no buffer)", |
294 | ir->rlistlong); |
295 | warning(wi, warn_buf); |
296 | } |
297 | if (ir->rlistlong == 0 && ir->ePBC != epbcNONE) |
298 | { |
299 | warning_error(wi, "Can not have an infinite cut-off with PBC"); |
300 | } |
301 | if (ir->rlistlong > 0 && (ir->rlist == 0 || ir->rlistlong < ir->rlist)) |
302 | { |
303 | warning_error(wi, "rlistlong can not be shorter than rlist"); |
304 | } |
305 | if (IR_TWINRANGE(*ir)((*ir).rlist > 0 && ((*ir).rlistlong == 0 || (*ir) .rlistlong > (*ir).rlist)) && ir->nstlist <= 0) |
306 | { |
307 | warning_error(wi, "Can not have nstlist<=0 with twin-range interactions"); |
308 | } |
309 | } |
310 | |
311 | if (ir->rlistlong == ir->rlist) |
312 | { |
313 | ir->nstcalclr = 0; |
314 | } |
315 | else if (ir->rlistlong > ir->rlist && ir->nstcalclr == 0) |
316 | { |
317 | warning_error(wi, "With different cutoffs for electrostatics and VdW, nstcalclr must be -1 or a positive number"); |
318 | } |
319 | |
320 | if (ir->cutoff_scheme == ecutsVERLET) |
321 | { |
322 | real rc_max; |
323 | |
324 | /* Normal Verlet type neighbor-list, currently only limited feature support */ |
325 | if (inputrec2nboundeddim(ir) < 3) |
326 | { |
327 | warning_error(wi, "With Verlet lists only full pbc or pbc=xy with walls is supported"); |
328 | } |
329 | if (ir->rcoulomb != ir->rvdw) |
330 | { |
331 | warning_error(wi, "With Verlet lists rcoulomb!=rvdw is not supported"); |
332 | } |
333 | if (ir->vdwtype == evdwSHIFT || ir->vdwtype == evdwSWITCH) |
334 | { |
335 | if (ir->vdw_modifier == eintmodNONE || |
336 | ir->vdw_modifier == eintmodPOTSHIFT) |
337 | { |
338 | ir->vdw_modifier = (ir->vdwtype == evdwSHIFT ? eintmodFORCESWITCH : eintmodPOTSWITCH); |
339 | |
340 | sprintf(warn_buf, "Replacing vdwtype=%s by the equivalent combination of vdwtype=%s and vdw_modifier=%s", evdw_names[ir->vdwtype], evdw_names[evdwCUT], eintmod_names[ir->vdw_modifier]); |
341 | warning_note(wi, warn_buf); |
342 | |
343 | ir->vdwtype = evdwCUT; |
344 | } |
345 | else |
346 | { |
347 | sprintf(warn_buf, "Unsupported combination of vdwtype=%s and vdw_modifier=%s", evdw_names[ir->vdwtype], eintmod_names[ir->vdw_modifier]); |
348 | warning_error(wi, warn_buf); |
349 | } |
350 | } |
351 | |
352 | if (!(ir->vdwtype == evdwCUT || ir->vdwtype == evdwPME)) |
353 | { |
354 | warning_error(wi, "With Verlet lists only cut-off and PME LJ interactions are supported"); |
355 | } |
356 | if (!(ir->coulombtype == eelCUT || |
357 | (EEL_RF(ir->coulombtype)((ir->coulombtype) == eelRF || (ir->coulombtype) == eelGRF || (ir->coulombtype) == eelRF_NEC || (ir->coulombtype) == eelRF_ZERO ) && ir->coulombtype != eelRF_NEC) || |
358 | EEL_PME(ir->coulombtype)((ir->coulombtype) == eelPME || (ir->coulombtype) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir->coulombtype ) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD) || ir->coulombtype == eelEWALD)) |
359 | { |
360 | warning_error(wi, "With Verlet lists only cut-off, reaction-field, PME and Ewald electrostatics are supported"); |
361 | } |
362 | if (!(ir->coulomb_modifier == eintmodNONE || |
363 | ir->coulomb_modifier == eintmodPOTSHIFT)) |
364 | { |
365 | sprintf(warn_buf, "coulomb_modifier=%s is not supported with the Verlet cut-off scheme", eintmod_names[ir->coulomb_modifier]); |
366 | warning_error(wi, warn_buf); |
367 | } |
368 | |
369 | if (ir->nstlist <= 0) |
370 | { |
371 | warning_error(wi, "With Verlet lists nstlist should be larger than 0"); |
372 | } |
373 | |
374 | if (ir->nstlist < 10) |
375 | { |
376 | warning_note(wi, "With Verlet lists the optimal nstlist is >= 10, with GPUs >= 20. Note that with the Verlet scheme, nstlist has no effect on the accuracy of your simulation."); |
377 | } |
378 | |
379 | rc_max = max(ir->rvdw, ir->rcoulomb)(((ir->rvdw) > (ir->rcoulomb)) ? (ir->rvdw) : (ir ->rcoulomb) ); |
380 | |
381 | if (ir->verletbuf_tol <= 0) |
382 | { |
383 | if (ir->verletbuf_tol == 0) |
384 | { |
385 | warning_error(wi, "Can not have Verlet buffer tolerance of exactly 0"); |
386 | } |
387 | |
388 | if (ir->rlist < rc_max) |
389 | { |
390 | warning_error(wi, "With verlet lists rlist can not be smaller than rvdw or rcoulomb"); |
391 | } |
392 | |
393 | if (ir->rlist == rc_max && ir->nstlist > 1) |
394 | { |
395 | warning_note(wi, "rlist is equal to rvdw and/or rcoulomb: there is no explicit Verlet buffer. The cluster pair list does have a buffering effect, but choosing a larger rlist might be necessary for good energy conservation."); |
396 | } |
397 | } |
398 | else |
399 | { |
400 | if (ir->rlist > rc_max) |
401 | { |
402 | warning_note(wi, "You have set rlist larger than the interaction cut-off, but you also have verlet-buffer-tolerance > 0. Will set rlist using verlet-buffer-tolerance."); |
403 | } |
404 | |
405 | if (ir->nstlist == 1) |
406 | { |
407 | /* No buffer required */ |
408 | ir->rlist = rc_max; |
409 | } |
410 | else |
411 | { |
412 | if (EI_DYNAMICS(ir->eI)(((ir->eI) == eiMD || ((ir->eI) == eiVV || (ir->eI) == eiVVAK)) || ((ir->eI) == eiSD1 || (ir->eI) == eiSD2) || (ir->eI) == eiBD)) |
413 | { |
414 | if (inputrec2nboundeddim(ir) < 3) |
415 | { |
416 | warning_error(wi, "The box volume is required for calculating rlist from the energy drift with verlet-buffer-tolerance > 0. You are using at least one unbounded dimension, so no volume can be computed. Either use a finite box, or set rlist yourself together with verlet-buffer-tolerance = -1."); |
417 | } |
418 | /* Set rlist temporarily so we can continue processing */ |
419 | ir->rlist = rc_max; |
420 | } |
421 | else |
422 | { |
423 | /* Set the buffer to 5% of the cut-off */ |
424 | ir->rlist = (1.0 + verlet_buffer_ratio_nodynamics)*rc_max; |
425 | } |
426 | } |
427 | } |
428 | |
429 | /* No twin-range calculations with Verlet lists */ |
430 | ir->rlistlong = ir->rlist; |
431 | } |
432 | |
433 | if (ir->nstcalclr == -1) |
434 | { |
435 | /* if rlist=rlistlong, this will later be changed to nstcalclr=0 */ |
436 | ir->nstcalclr = ir->nstlist; |
437 | } |
438 | else if (ir->nstcalclr > 0) |
439 | { |
440 | if (ir->nstlist > 0 && (ir->nstlist % ir->nstcalclr != 0)) |
441 | { |
442 | warning_error(wi, "nstlist must be evenly divisible by nstcalclr. Use nstcalclr = -1 to automatically follow nstlist"); |
443 | } |
444 | } |
445 | else if (ir->nstcalclr < -1) |
446 | { |
447 | warning_error(wi, "nstcalclr must be a positive number (divisor of nstcalclr), or -1 to follow nstlist."); |
448 | } |
449 | |
450 | if (EEL_PME(ir->coulombtype)((ir->coulombtype) == eelPME || (ir->coulombtype) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir->coulombtype ) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD) && ir->rcoulomb > ir->rvdw && ir->nstcalclr > 1) |
451 | { |
452 | warning_error(wi, "When used with PME, the long-range component of twin-range interactions must be updated every step (nstcalclr)"); |
453 | } |
454 | |
455 | /* GENERAL INTEGRATOR STUFF */ |
456 | if (!(ir->eI == eiMD || EI_VV(ir->eI)((ir->eI) == eiVV || (ir->eI) == eiVVAK))) |
457 | { |
458 | ir->etc = etcNO; |
459 | } |
460 | if (ir->eI == eiVVAK) |
461 | { |
462 | sprintf(warn_buf, "Integrator method %s is implemented primarily for validation purposes; for molecular dynamics, you should probably be using %s or %s", ei_names[eiVVAK], ei_names[eiMD], ei_names[eiVV]); |
463 | warning_note(wi, warn_buf); |
464 | } |
465 | if (!EI_DYNAMICS(ir->eI)(((ir->eI) == eiMD || ((ir->eI) == eiVV || (ir->eI) == eiVVAK)) || ((ir->eI) == eiSD1 || (ir->eI) == eiSD2) || (ir->eI) == eiBD)) |
466 | { |
467 | ir->epc = epcNO; |
468 | } |
469 | if (EI_DYNAMICS(ir->eI)(((ir->eI) == eiMD || ((ir->eI) == eiVV || (ir->eI) == eiVVAK)) || ((ir->eI) == eiSD1 || (ir->eI) == eiSD2) || (ir->eI) == eiBD)) |
470 | { |
471 | if (ir->nstcalcenergy < 0) |
472 | { |
473 | ir->nstcalcenergy = ir_optimal_nstcalcenergy(ir); |
474 | if (ir->nstenergy != 0 && ir->nstenergy < ir->nstcalcenergy) |
475 | { |
476 | /* nstcalcenergy larger than nstener does not make sense. |
477 | * We ideally want nstcalcenergy=nstener. |
478 | */ |
479 | if (ir->nstlist > 0) |
480 | { |
481 | ir->nstcalcenergy = lcd(ir->nstenergy, ir->nstlist); |
482 | } |
483 | else |
484 | { |
485 | ir->nstcalcenergy = ir->nstenergy; |
486 | } |
487 | } |
488 | } |
489 | else if ( (ir->nstenergy > 0 && ir->nstcalcenergy > ir->nstenergy) || |
490 | (ir->efep != efepNO && ir->fepvals->nstdhdl > 0 && |
491 | (ir->nstcalcenergy > ir->fepvals->nstdhdl) ) ) |
492 | |
493 | { |
494 | const char *nsten = "nstenergy"; |
495 | const char *nstdh = "nstdhdl"; |
496 | const char *min_name = nsten; |
497 | int min_nst = ir->nstenergy; |
498 | |
499 | /* find the smallest of ( nstenergy, nstdhdl ) */ |
500 | if (ir->efep != efepNO && ir->fepvals->nstdhdl > 0 && |
501 | (ir->nstenergy == 0 || ir->fepvals->nstdhdl < ir->nstenergy)) |
502 | { |
503 | min_nst = ir->fepvals->nstdhdl; |
504 | min_name = nstdh; |
505 | } |
506 | /* If the user sets nstenergy small, we should respect that */ |
507 | sprintf(warn_buf, |
508 | "Setting nstcalcenergy (%d) equal to %s (%d)", |
509 | ir->nstcalcenergy, min_name, min_nst); |
510 | warning_note(wi, warn_buf); |
511 | ir->nstcalcenergy = min_nst; |
512 | } |
513 | |
514 | if (ir->epc != epcNO) |
515 | { |
516 | if (ir->nstpcouple < 0) |
517 | { |
518 | ir->nstpcouple = ir_optimal_nstpcouple(ir); |
519 | } |
520 | } |
521 | if (IR_TWINRANGE(*ir)((*ir).rlist > 0 && ((*ir).rlistlong == 0 || (*ir) .rlistlong > (*ir).rlist))) |
522 | { |
523 | check_nst("nstlist", ir->nstlist, |
524 | "nstcalcenergy", &ir->nstcalcenergy, wi); |
525 | if (ir->epc != epcNO) |
526 | { |
527 | check_nst("nstlist", ir->nstlist, |
528 | "nstpcouple", &ir->nstpcouple, wi); |
529 | } |
530 | } |
531 | |
532 | if (ir->nstcalcenergy > 0) |
533 | { |
534 | if (ir->efep != efepNO) |
535 | { |
536 | /* nstdhdl should be a multiple of nstcalcenergy */ |
537 | check_nst("nstcalcenergy", ir->nstcalcenergy, |
538 | "nstdhdl", &ir->fepvals->nstdhdl, wi); |
539 | /* nstexpanded should be a multiple of nstcalcenergy */ |
540 | check_nst("nstcalcenergy", ir->nstcalcenergy, |
541 | "nstexpanded", &ir->expandedvals->nstexpanded, wi); |
542 | } |
543 | /* for storing exact averages nstenergy should be |
544 | * a multiple of nstcalcenergy |
545 | */ |
546 | check_nst("nstcalcenergy", ir->nstcalcenergy, |
547 | "nstenergy", &ir->nstenergy, wi); |
548 | } |
549 | } |
550 | |
551 | /* LD STUFF */ |
552 | if ((EI_SD(ir->eI)((ir->eI) == eiSD1 || (ir->eI) == eiSD2) || ir->eI == eiBD) && |
553 | ir->bContinuation && ir->ld_seed != -1) |
554 | { |
555 | warning_note(wi, "You are doing a continuation with SD or BD, make sure that ld_seed is different from the previous run (using ld_seed=-1 will ensure this)"); |
556 | } |
557 | |
558 | /* TPI STUFF */ |
559 | if (EI_TPI(ir->eI)((ir->eI) == eiTPI || (ir->eI) == eiTPIC)) |
560 | { |
561 | sprintf(err_buf, "TPI only works with pbc = %s", epbc_names[epbcXYZ]); |
562 | CHECK(ir->ePBC != epbcXYZ)_low_check(ir->ePBC != epbcXYZ, err_buf, wi); |
563 | sprintf(err_buf, "TPI only works with ns = %s", ens_names[ensGRID]); |
564 | CHECK(ir->ns_type != ensGRID)_low_check(ir->ns_type != ensGRID, err_buf, wi); |
565 | sprintf(err_buf, "with TPI nstlist should be larger than zero"); |
566 | CHECK(ir->nstlist <= 0)_low_check(ir->nstlist <= 0, err_buf, wi); |
567 | sprintf(err_buf, "TPI does not work with full electrostatics other than PME"); |
568 | CHECK(EEL_FULL(ir->coulombtype) && !EEL_PME(ir->coulombtype))_low_check(((((ir->coulombtype) == eelPME || (ir->coulombtype ) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir ->coulombtype) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD) || (ir->coulombtype) == eelEWALD) || (ir-> coulombtype) == eelPOISSON) && !((ir->coulombtype) == eelPME || (ir->coulombtype) == eelPMESWITCH || (ir-> coulombtype) == eelPMEUSER || (ir->coulombtype) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD), err_buf, wi); |
569 | } |
570 | |
571 | /* SHAKE / LINCS */ |
572 | if ( (opts->nshake > 0) && (opts->bMorse) ) |
573 | { |
574 | sprintf(warn_buf, |
575 | "Using morse bond-potentials while constraining bonds is useless"); |
576 | warning(wi, warn_buf); |
577 | } |
578 | |
579 | if ((EI_SD(ir->eI)((ir->eI) == eiSD1 || (ir->eI) == eiSD2) || ir->eI == eiBD) && |
580 | ir->bContinuation && ir->ld_seed != -1) |
581 | { |
582 | warning_note(wi, "You are doing a continuation with SD or BD, make sure that ld_seed is different from the previous run (using ld_seed=-1 will ensure this)"); |
583 | } |
584 | /* verify simulated tempering options */ |
585 | |
586 | if (ir->bSimTemp) |
587 | { |
588 | gmx_bool bAllTempZero = TRUE1; |
589 | for (i = 0; i < fep->n_lambda; i++) |
590 | { |
591 | sprintf(err_buf, "Entry %d for %s must be between 0 and 1, instead is %g", i, efpt_names[efptTEMPERATURE], fep->all_lambda[efptTEMPERATURE][i]); |
592 | CHECK((fep->all_lambda[efptTEMPERATURE][i] < 0) || (fep->all_lambda[efptTEMPERATURE][i] > 1))_low_check((fep->all_lambda[efptTEMPERATURE][i] < 0) || (fep->all_lambda[efptTEMPERATURE][i] > 1), err_buf, wi ); |
593 | if (fep->all_lambda[efptTEMPERATURE][i] > 0) |
594 | { |
595 | bAllTempZero = FALSE0; |
596 | } |
597 | } |
598 | sprintf(err_buf, "if simulated tempering is on, temperature-lambdas may not be all zero"); |
599 | CHECK(bAllTempZero == TRUE)_low_check(bAllTempZero == 1, err_buf, wi); |
600 | |
601 | sprintf(err_buf, "Simulated tempering is currently only compatible with md-vv"); |
602 | CHECK(ir->eI != eiVV)_low_check(ir->eI != eiVV, err_buf, wi); |
603 | |
604 | /* check compatability of the temperature coupling with simulated tempering */ |
605 | |
606 | if (ir->etc == etcNOSEHOOVER) |
607 | { |
608 | sprintf(warn_buf, "Nose-Hoover based temperature control such as [%s] my not be entirelyconsistent with simulated tempering", etcoupl_names[ir->etc]); |
609 | warning_note(wi, warn_buf); |
610 | } |
611 | |
612 | /* check that the temperatures make sense */ |
613 | |
614 | sprintf(err_buf, "Higher simulated tempering temperature (%g) must be >= than the simulated tempering lower temperature (%g)", ir->simtempvals->simtemp_high, ir->simtempvals->simtemp_low); |
615 | CHECK(ir->simtempvals->simtemp_high <= ir->simtempvals->simtemp_low)_low_check(ir->simtempvals->simtemp_high <= ir->simtempvals ->simtemp_low, err_buf, wi); |
616 | |
617 | sprintf(err_buf, "Higher simulated tempering temperature (%g) must be >= zero", ir->simtempvals->simtemp_high); |
618 | CHECK(ir->simtempvals->simtemp_high <= 0)_low_check(ir->simtempvals->simtemp_high <= 0, err_buf , wi); |
619 | |
620 | sprintf(err_buf, "Lower simulated tempering temperature (%g) must be >= zero", ir->simtempvals->simtemp_low); |
621 | CHECK(ir->simtempvals->simtemp_low <= 0)_low_check(ir->simtempvals->simtemp_low <= 0, err_buf , wi); |
622 | } |
623 | |
624 | /* verify free energy options */ |
625 | |
626 | if (ir->efep != efepNO) |
627 | { |
628 | fep = ir->fepvals; |
629 | sprintf(err_buf, "The soft-core power is %d and can only be 1 or 2", |
630 | fep->sc_power); |
631 | CHECK(fep->sc_alpha != 0 && fep->sc_power != 1 && fep->sc_power != 2)_low_check(fep->sc_alpha != 0 && fep->sc_power != 1 && fep->sc_power != 2, err_buf, wi); |
632 | |
633 | sprintf(err_buf, "The soft-core sc-r-power is %d and can only be 6 or 48", |
634 | (int)fep->sc_r_power); |
635 | CHECK(fep->sc_alpha != 0 && fep->sc_r_power != 6.0 && fep->sc_r_power != 48.0)_low_check(fep->sc_alpha != 0 && fep->sc_r_power != 6.0 && fep->sc_r_power != 48.0, err_buf, wi); |
636 | |
637 | sprintf(err_buf, "Can't use postive delta-lambda (%g) if initial state/lambda does not start at zero", fep->delta_lambda); |
638 | CHECK(fep->delta_lambda > 0 && ((fep->init_fep_state > 0) || (fep->init_lambda > 0)))_low_check(fep->delta_lambda > 0 && ((fep->init_fep_state > 0) || (fep->init_lambda > 0)), err_buf, wi); |
639 | |
640 | sprintf(err_buf, "Can't use postive delta-lambda (%g) with expanded ensemble simulations", fep->delta_lambda); |
641 | CHECK(fep->delta_lambda > 0 && (ir->efep == efepEXPANDED))_low_check(fep->delta_lambda > 0 && (ir->efep == efepEXPANDED), err_buf, wi); |
642 | |
643 | sprintf(err_buf, "Can only use expanded ensemble with md-vv for now; should be supported for other integrators in 5.0"); |
644 | CHECK(!(EI_VV(ir->eI)) && (ir->efep == efepEXPANDED))_low_check(!(((ir->eI) == eiVV || (ir->eI) == eiVVAK)) && (ir->efep == efepEXPANDED), err_buf, wi); |
645 | |
646 | sprintf(err_buf, "Free-energy not implemented for Ewald"); |
647 | CHECK(ir->coulombtype == eelEWALD)_low_check(ir->coulombtype == eelEWALD, err_buf, wi); |
648 | |
649 | /* check validty of lambda inputs */ |
650 | if (fep->n_lambda == 0) |
651 | { |
652 | /* Clear output in case of no states:*/ |
653 | sprintf(err_buf, "init-lambda-state set to %d: no lambda states are defined.", fep->init_fep_state); |
654 | CHECK((fep->init_fep_state >= 0) && (fep->n_lambda == 0))_low_check((fep->init_fep_state >= 0) && (fep-> n_lambda == 0), err_buf, wi); |
655 | } |
656 | else |
657 | { |
658 | sprintf(err_buf, "initial thermodynamic state %d does not exist, only goes to %d", fep->init_fep_state, fep->n_lambda-1); |
659 | CHECK((fep->init_fep_state >= fep->n_lambda))_low_check((fep->init_fep_state >= fep->n_lambda), err_buf , wi); |
660 | } |
661 | |
662 | sprintf(err_buf, "Lambda state must be set, either with init-lambda-state or with init-lambda"); |
663 | CHECK((fep->init_fep_state < 0) && (fep->init_lambda < 0))_low_check((fep->init_fep_state < 0) && (fep-> init_lambda < 0), err_buf, wi); |
664 | |
665 | sprintf(err_buf, "init-lambda=%g while init-lambda-state=%d. Lambda state must be set either with init-lambda-state or with init-lambda, but not both", |
666 | fep->init_lambda, fep->init_fep_state); |
667 | CHECK((fep->init_fep_state >= 0) && (fep->init_lambda >= 0))_low_check((fep->init_fep_state >= 0) && (fep-> init_lambda >= 0), err_buf, wi); |
668 | |
669 | |
670 | |
671 | if ((fep->init_lambda >= 0) && (fep->delta_lambda == 0)) |
672 | { |
673 | int n_lambda_terms; |
674 | n_lambda_terms = 0; |
675 | for (i = 0; i < efptNR; i++) |
676 | { |
677 | if (fep->separate_dvdl[i]) |
678 | { |
679 | n_lambda_terms++; |
680 | } |
681 | } |
682 | if (n_lambda_terms > 1) |
683 | { |
684 | sprintf(warn_buf, "If lambda vector states (fep-lambdas, coul-lambdas etc.) are set, don't use init-lambda to set lambda state (except for slow growth). Use init-lambda-state instead."); |
685 | warning(wi, warn_buf); |
686 | } |
687 | |
688 | if (n_lambda_terms < 2 && fep->n_lambda > 0) |
689 | { |
690 | warning_note(wi, |
691 | "init-lambda is deprecated for setting lambda state (except for slow growth). Use init-lambda-state instead."); |
692 | } |
693 | } |
694 | |
695 | for (j = 0; j < efptNR; j++) |
696 | { |
697 | for (i = 0; i < fep->n_lambda; i++) |
698 | { |
699 | sprintf(err_buf, "Entry %d for %s must be between 0 and 1, instead is %g", i, efpt_names[j], fep->all_lambda[j][i]); |
700 | CHECK((fep->all_lambda[j][i] < 0) || (fep->all_lambda[j][i] > 1))_low_check((fep->all_lambda[j][i] < 0) || (fep->all_lambda [j][i] > 1), err_buf, wi); |
701 | } |
702 | } |
703 | |
704 | if ((fep->sc_alpha > 0) && (!fep->bScCoul)) |
705 | { |
706 | for (i = 0; i < fep->n_lambda; i++) |
707 | { |
708 | sprintf(err_buf, "For state %d, vdw-lambdas (%f) is changing with vdw softcore, while coul-lambdas (%f) is nonzero without coulomb softcore: this will lead to crashes, and is not supported.", i, fep->all_lambda[efptVDW][i], |
709 | fep->all_lambda[efptCOUL][i]); |
710 | CHECK((fep->sc_alpha > 0) &&_low_check((fep->sc_alpha > 0) && (((fep->all_lambda [efptCOUL][i] > 0.0) && (fep->all_lambda[efptCOUL ][i] < 1.0)) && ((fep->all_lambda[efptVDW][i] > 0.0) && (fep->all_lambda[efptVDW][i] < 1.0))), err_buf, wi) |
711 | (((fep->all_lambda[efptCOUL][i] > 0.0) &&_low_check((fep->sc_alpha > 0) && (((fep->all_lambda [efptCOUL][i] > 0.0) && (fep->all_lambda[efptCOUL ][i] < 1.0)) && ((fep->all_lambda[efptVDW][i] > 0.0) && (fep->all_lambda[efptVDW][i] < 1.0))), err_buf, wi) |
712 | (fep->all_lambda[efptCOUL][i] < 1.0)) &&_low_check((fep->sc_alpha > 0) && (((fep->all_lambda [efptCOUL][i] > 0.0) && (fep->all_lambda[efptCOUL ][i] < 1.0)) && ((fep->all_lambda[efptVDW][i] > 0.0) && (fep->all_lambda[efptVDW][i] < 1.0))), err_buf, wi) |
713 | ((fep->all_lambda[efptVDW][i] > 0.0) &&_low_check((fep->sc_alpha > 0) && (((fep->all_lambda [efptCOUL][i] > 0.0) && (fep->all_lambda[efptCOUL ][i] < 1.0)) && ((fep->all_lambda[efptVDW][i] > 0.0) && (fep->all_lambda[efptVDW][i] < 1.0))), err_buf, wi) |
714 | (fep->all_lambda[efptVDW][i] < 1.0))))_low_check((fep->sc_alpha > 0) && (((fep->all_lambda [efptCOUL][i] > 0.0) && (fep->all_lambda[efptCOUL ][i] < 1.0)) && ((fep->all_lambda[efptVDW][i] > 0.0) && (fep->all_lambda[efptVDW][i] < 1.0))), err_buf, wi); |
715 | } |
716 | } |
717 | |
718 | if ((fep->bScCoul) && (EEL_PME(ir->coulombtype)((ir->coulombtype) == eelPME || (ir->coulombtype) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir->coulombtype ) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD))) |
719 | { |
720 | real sigma, lambda, r_sc; |
721 | |
722 | sigma = 0.34; |
723 | /* Maximum estimate for A and B charges equal with lambda power 1 */ |
724 | lambda = 0.5; |
725 | r_sc = pow(lambda*fep->sc_alpha*pow(sigma/ir->rcoulomb, fep->sc_r_power) + 1.0, 1.0/fep->sc_r_power); |
726 | sprintf(warn_buf, "With PME there is a minor soft core effect present at the cut-off, proportional to (LJsigma/rcoulomb)^%g. This could have a minor effect on energy conservation, but usually other effects dominate. With a common sigma value of %g nm the fraction of the particle-particle potential at the cut-off at lambda=%g is around %.1e, while ewald-rtol is %.1e.", |
727 | fep->sc_r_power, |
728 | sigma, lambda, r_sc - 1.0, ir->ewald_rtol); |
729 | warning_note(wi, warn_buf); |
730 | } |
731 | |
732 | /* Free Energy Checks -- In an ideal world, slow growth and FEP would |
733 | be treated differently, but that's the next step */ |
734 | |
735 | for (i = 0; i < efptNR; i++) |
736 | { |
737 | for (j = 0; j < fep->n_lambda; j++) |
738 | { |
739 | sprintf(err_buf, "%s[%d] must be between 0 and 1", efpt_names[i], j); |
740 | CHECK((fep->all_lambda[i][j] < 0) || (fep->all_lambda[i][j] > 1))_low_check((fep->all_lambda[i][j] < 0) || (fep->all_lambda [i][j] > 1), err_buf, wi); |
741 | } |
742 | } |
743 | } |
744 | |
745 | if ((ir->bSimTemp) || (ir->efep == efepEXPANDED)) |
746 | { |
747 | fep = ir->fepvals; |
748 | expand = ir->expandedvals; |
749 | |
750 | /* checking equilibration of weights inputs for validity */ |
751 | |
752 | sprintf(err_buf, "weight-equil-number-all-lambda (%d) is ignored if lmc-weights-equil is not equal to %s", |
753 | expand->equil_n_at_lam, elmceq_names[elmceqNUMATLAM]); |
754 | CHECK((expand->equil_n_at_lam > 0) && (expand->elmceq != elmceqNUMATLAM))_low_check((expand->equil_n_at_lam > 0) && (expand ->elmceq != elmceqNUMATLAM), err_buf, wi); |
755 | |
756 | sprintf(err_buf, "weight-equil-number-samples (%d) is ignored if lmc-weights-equil is not equal to %s", |
757 | expand->equil_samples, elmceq_names[elmceqSAMPLES]); |
758 | CHECK((expand->equil_samples > 0) && (expand->elmceq != elmceqSAMPLES))_low_check((expand->equil_samples > 0) && (expand ->elmceq != elmceqSAMPLES), err_buf, wi); |
759 | |
760 | sprintf(err_buf, "weight-equil-number-steps (%d) is ignored if lmc-weights-equil is not equal to %s", |
761 | expand->equil_steps, elmceq_names[elmceqSTEPS]); |
762 | CHECK((expand->equil_steps > 0) && (expand->elmceq != elmceqSTEPS))_low_check((expand->equil_steps > 0) && (expand ->elmceq != elmceqSTEPS), err_buf, wi); |
763 | |
764 | sprintf(err_buf, "weight-equil-wl-delta (%d) is ignored if lmc-weights-equil is not equal to %s", |
765 | expand->equil_samples, elmceq_names[elmceqWLDELTA]); |
766 | CHECK((expand->equil_wl_delta > 0) && (expand->elmceq != elmceqWLDELTA))_low_check((expand->equil_wl_delta > 0) && (expand ->elmceq != elmceqWLDELTA), err_buf, wi); |
767 | |
768 | sprintf(err_buf, "weight-equil-count-ratio (%f) is ignored if lmc-weights-equil is not equal to %s", |
769 | expand->equil_ratio, elmceq_names[elmceqRATIO]); |
770 | CHECK((expand->equil_ratio > 0) && (expand->elmceq != elmceqRATIO))_low_check((expand->equil_ratio > 0) && (expand ->elmceq != elmceqRATIO), err_buf, wi); |
771 | |
772 | sprintf(err_buf, "weight-equil-number-all-lambda (%d) must be a positive integer if lmc-weights-equil=%s", |
773 | expand->equil_n_at_lam, elmceq_names[elmceqNUMATLAM]); |
774 | CHECK((expand->equil_n_at_lam <= 0) && (expand->elmceq == elmceqNUMATLAM))_low_check((expand->equil_n_at_lam <= 0) && (expand ->elmceq == elmceqNUMATLAM), err_buf, wi); |
775 | |
776 | sprintf(err_buf, "weight-equil-number-samples (%d) must be a positive integer if lmc-weights-equil=%s", |
777 | expand->equil_samples, elmceq_names[elmceqSAMPLES]); |
778 | CHECK((expand->equil_samples <= 0) && (expand->elmceq == elmceqSAMPLES))_low_check((expand->equil_samples <= 0) && (expand ->elmceq == elmceqSAMPLES), err_buf, wi); |
779 | |
780 | sprintf(err_buf, "weight-equil-number-steps (%d) must be a positive integer if lmc-weights-equil=%s", |
781 | expand->equil_steps, elmceq_names[elmceqSTEPS]); |
782 | CHECK((expand->equil_steps <= 0) && (expand->elmceq == elmceqSTEPS))_low_check((expand->equil_steps <= 0) && (expand ->elmceq == elmceqSTEPS), err_buf, wi); |
783 | |
784 | sprintf(err_buf, "weight-equil-wl-delta (%f) must be > 0 if lmc-weights-equil=%s", |
785 | expand->equil_wl_delta, elmceq_names[elmceqWLDELTA]); |
786 | CHECK((expand->equil_wl_delta <= 0) && (expand->elmceq == elmceqWLDELTA))_low_check((expand->equil_wl_delta <= 0) && (expand ->elmceq == elmceqWLDELTA), err_buf, wi); |
787 | |
788 | sprintf(err_buf, "weight-equil-count-ratio (%f) must be > 0 if lmc-weights-equil=%s", |
789 | expand->equil_ratio, elmceq_names[elmceqRATIO]); |
790 | CHECK((expand->equil_ratio <= 0) && (expand->elmceq == elmceqRATIO))_low_check((expand->equil_ratio <= 0) && (expand ->elmceq == elmceqRATIO), err_buf, wi); |
791 | |
792 | sprintf(err_buf, "lmc-weights-equil=%s only possible when lmc-stats = %s or lmc-stats %s", |
793 | elmceq_names[elmceqWLDELTA], elamstats_names[elamstatsWL], elamstats_names[elamstatsWWL]); |
794 | CHECK((expand->elmceq == elmceqWLDELTA) && (!EWL(expand->elamstats)))_low_check((expand->elmceq == elmceqWLDELTA) && (! ((expand->elamstats) == elamstatsWL || (expand->elamstats ) == elamstatsWWL)), err_buf, wi); |
795 | |
796 | sprintf(err_buf, "lmc-repeats (%d) must be greater than 0", expand->lmc_repeats); |
797 | CHECK((expand->lmc_repeats <= 0))_low_check((expand->lmc_repeats <= 0), err_buf, wi); |
798 | sprintf(err_buf, "minimum-var-min (%d) must be greater than 0", expand->minvarmin); |
799 | CHECK((expand->minvarmin <= 0))_low_check((expand->minvarmin <= 0), err_buf, wi); |
800 | sprintf(err_buf, "weight-c-range (%d) must be greater or equal to 0", expand->c_range); |
801 | CHECK((expand->c_range < 0))_low_check((expand->c_range < 0), err_buf, wi); |
802 | sprintf(err_buf, "init-lambda-state (%d) must be zero if lmc-forced-nstart (%d)> 0 and lmc-move != 'no'", |
803 | fep->init_fep_state, expand->lmc_forced_nstart); |
804 | CHECK((fep->init_fep_state != 0) && (expand->lmc_forced_nstart > 0) && (expand->elmcmove != elmcmoveNO))_low_check((fep->init_fep_state != 0) && (expand-> lmc_forced_nstart > 0) && (expand->elmcmove != elmcmoveNO ), err_buf, wi); |
805 | sprintf(err_buf, "lmc-forced-nstart (%d) must not be negative", expand->lmc_forced_nstart); |
806 | CHECK((expand->lmc_forced_nstart < 0))_low_check((expand->lmc_forced_nstart < 0), err_buf, wi ); |
807 | sprintf(err_buf, "init-lambda-state (%d) must be in the interval [0,number of lambdas)", fep->init_fep_state); |
808 | CHECK((fep->init_fep_state < 0) || (fep->init_fep_state >= fep->n_lambda))_low_check((fep->init_fep_state < 0) || (fep->init_fep_state >= fep->n_lambda), err_buf, wi); |
809 | |
810 | sprintf(err_buf, "init-wl-delta (%f) must be greater than or equal to 0", expand->init_wl_delta); |
811 | CHECK((expand->init_wl_delta < 0))_low_check((expand->init_wl_delta < 0), err_buf, wi); |
812 | sprintf(err_buf, "wl-ratio (%f) must be between 0 and 1", expand->wl_ratio); |
813 | CHECK((expand->wl_ratio <= 0) || (expand->wl_ratio >= 1))_low_check((expand->wl_ratio <= 0) || (expand->wl_ratio >= 1), err_buf, wi); |
814 | sprintf(err_buf, "wl-scale (%f) must be between 0 and 1", expand->wl_scale); |
815 | CHECK((expand->wl_scale <= 0) || (expand->wl_scale >= 1))_low_check((expand->wl_scale <= 0) || (expand->wl_scale >= 1), err_buf, wi); |
816 | |
817 | /* if there is no temperature control, we need to specify an MC temperature */ |
818 | sprintf(err_buf, "If there is no temperature control, and lmc-mcmove!= 'no',mc_temperature must be set to a positive number"); |
819 | if (expand->nstTij > 0) |
820 | { |
821 | sprintf(err_buf, "nst-transition-matrix (%d) must be an integer multiple of nstlog (%d)", |
822 | expand->nstTij, ir->nstlog); |
823 | CHECK((mod(expand->nstTij, ir->nstlog) != 0))_low_check((_mod((expand->nstTij), (ir->nstlog), "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 823) != 0), err_buf, wi); |
824 | } |
825 | } |
826 | |
827 | /* PBC/WALLS */ |
828 | sprintf(err_buf, "walls only work with pbc=%s", epbc_names[epbcXY]); |
829 | CHECK(ir->nwall && ir->ePBC != epbcXY)_low_check(ir->nwall && ir->ePBC != epbcXY, err_buf , wi); |
830 | |
831 | /* VACUUM STUFF */ |
832 | if (ir->ePBC != epbcXYZ && ir->nwall != 2) |
833 | { |
834 | if (ir->ePBC == epbcNONE) |
835 | { |
836 | if (ir->epc != epcNO) |
837 | { |
838 | warning(wi, "Turning off pressure coupling for vacuum system"); |
839 | ir->epc = epcNO; |
840 | } |
841 | } |
842 | else |
843 | { |
844 | sprintf(err_buf, "Can not have pressure coupling with pbc=%s", |
845 | epbc_names[ir->ePBC]); |
846 | CHECK(ir->epc != epcNO)_low_check(ir->epc != epcNO, err_buf, wi); |
847 | } |
848 | sprintf(err_buf, "Can not have Ewald with pbc=%s", epbc_names[ir->ePBC]); |
849 | CHECK(EEL_FULL(ir->coulombtype))_low_check(((((ir->coulombtype) == eelPME || (ir->coulombtype ) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir ->coulombtype) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD) || (ir->coulombtype) == eelEWALD) || (ir-> coulombtype) == eelPOISSON), err_buf, wi); |
850 | |
851 | sprintf(err_buf, "Can not have dispersion correction with pbc=%s", |
852 | epbc_names[ir->ePBC]); |
853 | CHECK(ir->eDispCorr != edispcNO)_low_check(ir->eDispCorr != edispcNO, err_buf, wi); |
854 | } |
855 | |
856 | if (ir->rlist == 0.0) |
857 | { |
858 | sprintf(err_buf, "can only have neighborlist cut-off zero (=infinite)\n" |
859 | "with coulombtype = %s or coulombtype = %s\n" |
860 | "without periodic boundary conditions (pbc = %s) and\n" |
861 | "rcoulomb and rvdw set to zero", |
862 | eel_names[eelCUT], eel_names[eelUSER], epbc_names[epbcNONE]); |
863 | CHECK(((ir->coulombtype != eelCUT) && (ir->coulombtype != eelUSER)) ||_low_check(((ir->coulombtype != eelCUT) && (ir-> coulombtype != eelUSER)) || (ir->ePBC != epbcNONE) || (ir-> rcoulomb != 0.0) || (ir->rvdw != 0.0), err_buf, wi) |
864 | (ir->ePBC != epbcNONE) ||_low_check(((ir->coulombtype != eelCUT) && (ir-> coulombtype != eelUSER)) || (ir->ePBC != epbcNONE) || (ir-> rcoulomb != 0.0) || (ir->rvdw != 0.0), err_buf, wi) |
865 | (ir->rcoulomb != 0.0) || (ir->rvdw != 0.0))_low_check(((ir->coulombtype != eelCUT) && (ir-> coulombtype != eelUSER)) || (ir->ePBC != epbcNONE) || (ir-> rcoulomb != 0.0) || (ir->rvdw != 0.0), err_buf, wi); |
866 | |
867 | if (ir->nstlist < 0) |
868 | { |
869 | warning_error(wi, "Can not have heuristic neighborlist updates without cut-off"); |
870 | } |
871 | if (ir->nstlist > 0) |
872 | { |
873 | warning_note(wi, "Simulating without cut-offs can be (slightly) faster with nstlist=0, nstype=simple and only one MPI rank"); |
874 | } |
875 | } |
876 | |
877 | /* COMM STUFF */ |
878 | if (ir->nstcomm == 0) |
879 | { |
880 | ir->comm_mode = ecmNO; |
881 | } |
882 | if (ir->comm_mode != ecmNO) |
883 | { |
884 | if (ir->nstcomm < 0) |
885 | { |
886 | warning(wi, "If you want to remove the rotation around the center of mass, you should set comm_mode = Angular instead of setting nstcomm < 0. nstcomm is modified to its absolute value"); |
887 | ir->nstcomm = abs(ir->nstcomm); |
888 | } |
889 | |
890 | if (ir->nstcalcenergy > 0 && ir->nstcomm < ir->nstcalcenergy) |
891 | { |
892 | warning_note(wi, "nstcomm < nstcalcenergy defeats the purpose of nstcalcenergy, setting nstcomm to nstcalcenergy"); |
893 | ir->nstcomm = ir->nstcalcenergy; |
894 | } |
895 | |
896 | if (ir->comm_mode == ecmANGULAR) |
897 | { |
898 | sprintf(err_buf, "Can not remove the rotation around the center of mass with periodic molecules"); |
899 | CHECK(ir->bPeriodicMols)_low_check(ir->bPeriodicMols, err_buf, wi); |
900 | if (ir->ePBC != epbcNONE) |
901 | { |
902 | warning(wi, "Removing the rotation around the center of mass in a periodic system (this is not a problem when you have only one molecule)."); |
903 | } |
904 | } |
905 | } |
906 | |
907 | if (EI_STATE_VELOCITY(ir->eI)(((ir->eI) == eiMD || ((ir->eI) == eiVV || (ir->eI) == eiVVAK)) || ((ir->eI) == eiSD1 || (ir->eI) == eiSD2)) && ir->ePBC == epbcNONE && ir->comm_mode != ecmANGULAR) |
908 | { |
909 | warning_note(wi, "Tumbling and or flying ice-cubes: We are not removing rotation around center of mass in a non-periodic system. You should probably set comm_mode = ANGULAR."); |
910 | } |
911 | |
912 | sprintf(err_buf, "Twin-range neighbour searching (NS) with simple NS" |
913 | " algorithm not implemented"); |
914 | CHECK(((ir->rcoulomb > ir->rlist) || (ir->rvdw > ir->rlist))_low_check(((ir->rcoulomb > ir->rlist) || (ir->rvdw > ir->rlist)) && (ir->ns_type == ensSIMPLE) , err_buf, wi) |
915 | && (ir->ns_type == ensSIMPLE))_low_check(((ir->rcoulomb > ir->rlist) || (ir->rvdw > ir->rlist)) && (ir->ns_type == ensSIMPLE) , err_buf, wi); |
916 | |
917 | /* TEMPERATURE COUPLING */ |
918 | if (ir->etc == etcYES) |
919 | { |
920 | ir->etc = etcBERENDSEN; |
921 | warning_note(wi, "Old option for temperature coupling given: " |
922 | "changing \"yes\" to \"Berendsen\"\n"); |
923 | } |
924 | |
925 | if ((ir->etc == etcNOSEHOOVER) || (ir->epc == epcMTTK)) |
926 | { |
927 | if (ir->opts.nhchainlength < 1) |
928 | { |
929 | sprintf(warn_buf, "number of Nose-Hoover chains (currently %d) cannot be less than 1,reset to 1\n", ir->opts.nhchainlength); |
930 | ir->opts.nhchainlength = 1; |
931 | warning(wi, warn_buf); |
932 | } |
933 | |
934 | if (ir->etc == etcNOSEHOOVER && !EI_VV(ir->eI)((ir->eI) == eiVV || (ir->eI) == eiVVAK) && ir->opts.nhchainlength > 1) |
935 | { |
936 | warning_note(wi, "leapfrog does not yet support Nose-Hoover chains, nhchainlength reset to 1"); |
937 | ir->opts.nhchainlength = 1; |
938 | } |
939 | } |
940 | else |
941 | { |
942 | ir->opts.nhchainlength = 0; |
943 | } |
944 | |
945 | if (ir->eI == eiVVAK) |
946 | { |
947 | sprintf(err_buf, "%s implemented primarily for validation, and requires nsttcouple = 1 and nstpcouple = 1.", |
948 | ei_names[eiVVAK]); |
949 | CHECK((ir->nsttcouple != 1) || (ir->nstpcouple != 1))_low_check((ir->nsttcouple != 1) || (ir->nstpcouple != 1 ), err_buf, wi); |
950 | } |
951 | |
952 | if (ETC_ANDERSEN(ir->etc)(((ir->etc) == etcANDERSENMASSIVE) || ((ir->etc) == etcANDERSEN ))) |
953 | { |
954 | sprintf(err_buf, "%s temperature control not supported for integrator %s.", etcoupl_names[ir->etc], ei_names[ir->eI]); |
955 | CHECK(!(EI_VV(ir->eI)))_low_check(!(((ir->eI) == eiVV || (ir->eI) == eiVVAK)), err_buf, wi); |
956 | |
957 | for (i = 0; i < ir->opts.ngtc; i++) |
958 | { |
959 | sprintf(err_buf, "all tau_t must currently be equal using Andersen temperature control, violated for group %d", i); |
960 | CHECK(ir->opts.tau_t[0] != ir->opts.tau_t[i])_low_check(ir->opts.tau_t[0] != ir->opts.tau_t[i], err_buf , wi); |
961 | sprintf(err_buf, "all tau_t must be postive using Andersen temperature control, tau_t[%d]=%10.6f", |
962 | i, ir->opts.tau_t[i]); |
963 | CHECK(ir->opts.tau_t[i] < 0)_low_check(ir->opts.tau_t[i] < 0, err_buf, wi); |
964 | } |
965 | if (ir->nstcomm > 0 && (ir->etc == etcANDERSEN)) |
966 | { |
967 | sprintf(warn_buf, "Center of mass removal not necessary for %s. All velocities of coupled groups are rerandomized periodically, so flying ice cube errors will not occur.", etcoupl_names[ir->etc]); |
968 | warning_note(wi, warn_buf); |
969 | } |
970 | |
971 | sprintf(err_buf, "nstcomm must be 1, not %d for %s, as velocities of atoms in coupled groups are randomized every time step", ir->nstcomm, etcoupl_names[ir->etc]); |
972 | CHECK(ir->nstcomm > 1 && (ir->etc == etcANDERSEN))_low_check(ir->nstcomm > 1 && (ir->etc == etcANDERSEN ), err_buf, wi); |
973 | |
974 | for (i = 0; i < ir->opts.ngtc; i++) |
975 | { |
976 | int nsteps = (int)(ir->opts.tau_t[i]/ir->delta_t); |
977 | sprintf(err_buf, "tau_t/delta_t for group %d for temperature control method %s must be a multiple of nstcomm (%d), as velocities of atoms in coupled groups are randomized every time step. The input tau_t (%8.3f) leads to %d steps per randomization", i, etcoupl_names[ir->etc], ir->nstcomm, ir->opts.tau_t[i], nsteps); |
978 | CHECK((nsteps % ir->nstcomm) && (ir->etc == etcANDERSENMASSIVE))_low_check((nsteps % ir->nstcomm) && (ir->etc == etcANDERSENMASSIVE), err_buf, wi); |
979 | } |
980 | } |
981 | if (ir->etc == etcBERENDSEN) |
982 | { |
983 | sprintf(warn_buf, "The %s thermostat does not generate the correct kinetic energy distribution. You might want to consider using the %s thermostat.", |
984 | ETCOUPLTYPE(ir->etc)((((ir->etc) < 0) || ((ir->etc) >= (etcNR))) ? "UNDEFINED" : (etcoupl_names)[ir->etc]), ETCOUPLTYPE(etcVRESCALE)((((etcVRESCALE) < 0) || ((etcVRESCALE) >= (etcNR))) ? "UNDEFINED" : (etcoupl_names)[etcVRESCALE])); |
985 | warning_note(wi, warn_buf); |
986 | } |
987 | |
988 | if ((ir->etc == etcNOSEHOOVER || ETC_ANDERSEN(ir->etc)(((ir->etc) == etcANDERSENMASSIVE) || ((ir->etc) == etcANDERSEN ))) |
989 | && ir->epc == epcBERENDSEN) |
990 | { |
991 | sprintf(warn_buf, "Using Berendsen pressure coupling invalidates the " |
992 | "true ensemble for the thermostat"); |
993 | warning(wi, warn_buf); |
994 | } |
995 | |
996 | /* PRESSURE COUPLING */ |
997 | if (ir->epc == epcISOTROPIC) |
998 | { |
999 | ir->epc = epcBERENDSEN; |
1000 | warning_note(wi, "Old option for pressure coupling given: " |
1001 | "changing \"Isotropic\" to \"Berendsen\"\n"); |
1002 | } |
1003 | |
1004 | if (ir->epc != epcNO) |
1005 | { |
1006 | dt_pcoupl = ir->nstpcouple*ir->delta_t; |
1007 | |
1008 | sprintf(err_buf, "tau-p must be > 0 instead of %g\n", ir->tau_p); |
1009 | CHECK(ir->tau_p <= 0)_low_check(ir->tau_p <= 0, err_buf, wi); |
1010 | |
1011 | if (ir->tau_p/dt_pcoupl < pcouple_min_integration_steps(ir->epc)) |
1012 | { |
1013 | sprintf(warn_buf, "For proper integration of the %s barostat, tau-p (%g) should be at least %d times larger than nstpcouple*dt (%g)", |
1014 | EPCOUPLTYPE(ir->epc)((((ir->epc) < 0) || ((ir->epc) >= (epcNR))) ? "UNDEFINED" : (epcoupl_names)[ir->epc]), ir->tau_p, pcouple_min_integration_steps(ir->epc), dt_pcoupl); |
1015 | warning(wi, warn_buf); |
1016 | } |
1017 | |
1018 | sprintf(err_buf, "compressibility must be > 0 when using pressure" |
1019 | " coupling %s\n", EPCOUPLTYPE(ir->epc)((((ir->epc) < 0) || ((ir->epc) >= (epcNR))) ? "UNDEFINED" : (epcoupl_names)[ir->epc])); |
1020 | CHECK(ir->compress[XX][XX] < 0 || ir->compress[YY][YY] < 0 ||_low_check(ir->compress[0][0] < 0 || ir->compress[1] [1] < 0 || ir->compress[2][2] < 0 || (trace(ir->compress ) == 0 && ir->compress[1][0] <= 0 && ir ->compress[2][0] <= 0 && ir->compress[2][1] <= 0), err_buf, wi) |
1021 | ir->compress[ZZ][ZZ] < 0 ||_low_check(ir->compress[0][0] < 0 || ir->compress[1] [1] < 0 || ir->compress[2][2] < 0 || (trace(ir->compress ) == 0 && ir->compress[1][0] <= 0 && ir ->compress[2][0] <= 0 && ir->compress[2][1] <= 0), err_buf, wi) |
1022 | (trace(ir->compress) == 0 && ir->compress[YY][XX] <= 0 &&_low_check(ir->compress[0][0] < 0 || ir->compress[1] [1] < 0 || ir->compress[2][2] < 0 || (trace(ir->compress ) == 0 && ir->compress[1][0] <= 0 && ir ->compress[2][0] <= 0 && ir->compress[2][1] <= 0), err_buf, wi) |
1023 | ir->compress[ZZ][XX] <= 0 && ir->compress[ZZ][YY] <= 0))_low_check(ir->compress[0][0] < 0 || ir->compress[1] [1] < 0 || ir->compress[2][2] < 0 || (trace(ir->compress ) == 0 && ir->compress[1][0] <= 0 && ir ->compress[2][0] <= 0 && ir->compress[2][1] <= 0), err_buf, wi); |
1024 | |
1025 | if (epcPARRINELLORAHMAN == ir->epc && opts->bGenVel) |
1026 | { |
1027 | sprintf(warn_buf, |
1028 | "You are generating velocities so I am assuming you " |
1029 | "are equilibrating a system. You are using " |
1030 | "%s pressure coupling, but this can be " |
1031 | "unstable for equilibration. If your system crashes, try " |
1032 | "equilibrating first with Berendsen pressure coupling. If " |
1033 | "you are not equilibrating the system, you can probably " |
1034 | "ignore this warning.", |
1035 | epcoupl_names[ir->epc]); |
1036 | warning(wi, warn_buf); |
1037 | } |
1038 | } |
1039 | |
1040 | if (EI_VV(ir->eI)((ir->eI) == eiVV || (ir->eI) == eiVVAK)) |
1041 | { |
1042 | if (ir->epc > epcNO) |
1043 | { |
1044 | if ((ir->epc != epcBERENDSEN) && (ir->epc != epcMTTK)) |
1045 | { |
1046 | warning_error(wi, "for md-vv and md-vv-avek, can only use Berendsen and Martyna-Tuckerman-Tobias-Klein (MTTK) equations for pressure control; MTTK is equivalent to Parrinello-Rahman."); |
1047 | } |
1048 | } |
1049 | } |
1050 | else |
1051 | { |
1052 | if (ir->epc == epcMTTK) |
1053 | { |
1054 | warning_error(wi, "MTTK pressure coupling requires a Velocity-verlet integrator"); |
1055 | } |
1056 | } |
1057 | |
1058 | /* ELECTROSTATICS */ |
1059 | /* More checks are in triple check (grompp.c) */ |
1060 | |
1061 | if (ir->coulombtype == eelSWITCH) |
1062 | { |
1063 | sprintf(warn_buf, "coulombtype = %s is only for testing purposes and can lead to serious " |
1064 | "artifacts, advice: use coulombtype = %s", |
1065 | eel_names[ir->coulombtype], |
1066 | eel_names[eelRF_ZERO]); |
1067 | warning(wi, warn_buf); |
1068 | } |
1069 | |
1070 | if (ir->epsilon_r != 1 && ir->implicit_solvent == eisGBSA) |
1071 | { |
1072 | sprintf(warn_buf, "epsilon-r = %g with GB implicit solvent, will use this value for inner dielectric", ir->epsilon_r); |
1073 | warning_note(wi, warn_buf); |
1074 | } |
1075 | |
1076 | if (EEL_RF(ir->coulombtype)((ir->coulombtype) == eelRF || (ir->coulombtype) == eelGRF || (ir->coulombtype) == eelRF_NEC || (ir->coulombtype) == eelRF_ZERO ) && ir->epsilon_rf == 1 && ir->epsilon_r != 1) |
1077 | { |
1078 | sprintf(warn_buf, "epsilon-r = %g and epsilon-rf = 1 with reaction field, proceeding assuming old format and exchanging epsilon-r and epsilon-rf", ir->epsilon_r); |
1079 | warning(wi, warn_buf); |
1080 | ir->epsilon_rf = ir->epsilon_r; |
1081 | ir->epsilon_r = 1.0; |
1082 | } |
1083 | |
1084 | if (getenv("GALACTIC_DYNAMICS") == NULL((void*)0)) |
1085 | { |
1086 | sprintf(err_buf, "epsilon-r must be >= 0 instead of %g\n", ir->epsilon_r); |
1087 | CHECK(ir->epsilon_r < 0)_low_check(ir->epsilon_r < 0, err_buf, wi); |
1088 | } |
1089 | |
1090 | if (EEL_RF(ir->coulombtype)((ir->coulombtype) == eelRF || (ir->coulombtype) == eelGRF || (ir->coulombtype) == eelRF_NEC || (ir->coulombtype) == eelRF_ZERO )) |
1091 | { |
1092 | /* reaction field (at the cut-off) */ |
1093 | |
1094 | if (ir->coulombtype == eelRF_ZERO) |
1095 | { |
1096 | sprintf(warn_buf, "With coulombtype = %s, epsilon-rf must be 0, assuming you meant epsilon_rf=0", |
1097 | eel_names[ir->coulombtype]); |
1098 | CHECK(ir->epsilon_rf != 0)_low_check(ir->epsilon_rf != 0, err_buf, wi); |
1099 | ir->epsilon_rf = 0.0; |
1100 | } |
1101 | |
1102 | sprintf(err_buf, "epsilon-rf must be >= epsilon-r"); |
1103 | CHECK((ir->epsilon_rf < ir->epsilon_r && ir->epsilon_rf != 0) ||_low_check((ir->epsilon_rf < ir->epsilon_r && ir->epsilon_rf != 0) || (ir->epsilon_r == 0), err_buf, wi) |
1104 | (ir->epsilon_r == 0))_low_check((ir->epsilon_rf < ir->epsilon_r && ir->epsilon_rf != 0) || (ir->epsilon_r == 0), err_buf, wi); |
1105 | if (ir->epsilon_rf == ir->epsilon_r) |
1106 | { |
1107 | sprintf(warn_buf, "Using epsilon-rf = epsilon-r with %s does not make sense", |
1108 | eel_names[ir->coulombtype]); |
1109 | warning(wi, warn_buf); |
1110 | } |
1111 | } |
1112 | /* Allow rlist>rcoulomb for tabulated long range stuff. This just |
1113 | * means the interaction is zero outside rcoulomb, but it helps to |
1114 | * provide accurate energy conservation. |
1115 | */ |
1116 | if (ir_coulomb_might_be_zero_at_cutoff(ir)) |
1117 | { |
1118 | if (ir_coulomb_switched(ir)) |
1119 | { |
1120 | sprintf(err_buf, |
1121 | "With coulombtype = %s rcoulomb_switch must be < rcoulomb. Or, better: Use the potential modifier options!", |
1122 | eel_names[ir->coulombtype]); |
1123 | CHECK(ir->rcoulomb_switch >= ir->rcoulomb)_low_check(ir->rcoulomb_switch >= ir->rcoulomb, err_buf , wi); |
1124 | } |
1125 | } |
1126 | else if (ir->coulombtype == eelCUT || EEL_RF(ir->coulombtype)((ir->coulombtype) == eelRF || (ir->coulombtype) == eelGRF || (ir->coulombtype) == eelRF_NEC || (ir->coulombtype) == eelRF_ZERO )) |
1127 | { |
1128 | if (ir->cutoff_scheme == ecutsGROUP && ir->coulomb_modifier == eintmodNONE) |
1129 | { |
1130 | sprintf(err_buf, "With coulombtype = %s, rcoulomb should be >= rlist unless you use a potential modifier", |
1131 | eel_names[ir->coulombtype]); |
1132 | CHECK(ir->rlist > ir->rcoulomb)_low_check(ir->rlist > ir->rcoulomb, err_buf, wi); |
1133 | } |
1134 | } |
1135 | |
1136 | if (ir->coulombtype == eelSWITCH || ir->coulombtype == eelSHIFT || |
1137 | ir->vdwtype == evdwSWITCH || ir->vdwtype == evdwSHIFT) |
1138 | { |
1139 | sprintf(warn_buf, |
1140 | "The switch/shift interaction settings are just for compatibility; you will get better " |
1141 | "performance from applying potential modifiers to your interactions!\n"); |
1142 | warning_note(wi, warn_buf); |
1143 | } |
1144 | |
1145 | if (ir->coulombtype == eelPMESWITCH) |
1146 | { |
1147 | if (ir->rcoulomb_switch/ir->rcoulomb < 0.9499) |
1148 | { |
1149 | sprintf(warn_buf, "The switching range for %s should be 5%% or less, energy conservation will be good anyhow, since ewald_rtol = %g", |
1150 | eel_names[ir->coulombtype], |
1151 | ir->ewald_rtol); |
1152 | warning(wi, warn_buf); |
1153 | } |
1154 | } |
1155 | |
1156 | if (EEL_FULL(ir->coulombtype)((((ir->coulombtype) == eelPME || (ir->coulombtype) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir->coulombtype ) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD) || (ir->coulombtype) == eelEWALD) || (ir->coulombtype) == eelPOISSON)) |
1157 | { |
1158 | if (ir->coulombtype == eelPMESWITCH || ir->coulombtype == eelPMEUSER || |
1159 | ir->coulombtype == eelPMEUSERSWITCH) |
1160 | { |
1161 | sprintf(err_buf, "With coulombtype = %s, rcoulomb must be <= rlist", |
1162 | eel_names[ir->coulombtype]); |
1163 | CHECK(ir->rcoulomb > ir->rlist)_low_check(ir->rcoulomb > ir->rlist, err_buf, wi); |
1164 | } |
1165 | else if (ir->cutoff_scheme == ecutsGROUP && ir->coulomb_modifier == eintmodNONE) |
1166 | { |
1167 | if (ir->coulombtype == eelPME || ir->coulombtype == eelP3M_AD) |
1168 | { |
1169 | sprintf(err_buf, |
1170 | "With coulombtype = %s (without modifier), rcoulomb must be equal to rlist,\n" |
1171 | "or rlistlong if nstcalclr=1. For optimal energy conservation,consider using\n" |
1172 | "a potential modifier.", eel_names[ir->coulombtype]); |
1173 | if (ir->nstcalclr == 1) |
1174 | { |
1175 | CHECK(ir->rcoulomb != ir->rlist && ir->rcoulomb != ir->rlistlong)_low_check(ir->rcoulomb != ir->rlist && ir-> rcoulomb != ir->rlistlong, err_buf, wi); |
1176 | } |
1177 | else |
1178 | { |
1179 | CHECK(ir->rcoulomb != ir->rlist)_low_check(ir->rcoulomb != ir->rlist, err_buf, wi); |
1180 | } |
1181 | } |
1182 | } |
1183 | } |
1184 | |
1185 | if (EEL_PME(ir->coulombtype)((ir->coulombtype) == eelPME || (ir->coulombtype) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir->coulombtype ) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD) || EVDW_PME(ir->vdwtype)((ir->vdwtype) == evdwPME)) |
1186 | { |
1187 | if (ir->pme_order < 3) |
1188 | { |
1189 | warning_error(wi, "pme-order can not be smaller than 3"); |
1190 | } |
1191 | } |
1192 | |
1193 | if (ir->nwall == 2 && EEL_FULL(ir->coulombtype)((((ir->coulombtype) == eelPME || (ir->coulombtype) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir->coulombtype ) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD) || (ir->coulombtype) == eelEWALD) || (ir->coulombtype) == eelPOISSON)) |
1194 | { |
1195 | if (ir->ewald_geometry == eewg3D) |
1196 | { |
1197 | sprintf(warn_buf, "With pbc=%s you should use ewald-geometry=%s", |
1198 | epbc_names[ir->ePBC], eewg_names[eewg3DC]); |
1199 | warning(wi, warn_buf); |
1200 | } |
1201 | /* This check avoids extra pbc coding for exclusion corrections */ |
1202 | sprintf(err_buf, "wall-ewald-zfac should be >= 2"); |
1203 | CHECK(ir->wall_ewald_zfac < 2)_low_check(ir->wall_ewald_zfac < 2, err_buf, wi); |
1204 | } |
1205 | |
1206 | if (ir_vdw_switched(ir)) |
1207 | { |
1208 | sprintf(err_buf, "With switched vdw forces or potentials, rvdw-switch must be < rvdw"); |
1209 | CHECK(ir->rvdw_switch >= ir->rvdw)_low_check(ir->rvdw_switch >= ir->rvdw, err_buf, wi); |
1210 | |
1211 | if (ir->rvdw_switch < 0.5*ir->rvdw) |
1212 | { |
1213 | sprintf(warn_buf, "You are applying a switch function to vdw forces or potentials from %g to %g nm, which is more than half the interaction range, whereas switch functions are intended to act only close to the cut-off.", |
1214 | ir->rvdw_switch, ir->rvdw); |
1215 | warning_note(wi, warn_buf); |
1216 | } |
1217 | } |
1218 | else if (ir->vdwtype == evdwCUT || ir->vdwtype == evdwPME) |
1219 | { |
1220 | if (ir->cutoff_scheme == ecutsGROUP && ir->vdw_modifier == eintmodNONE) |
1221 | { |
1222 | sprintf(err_buf, "With vdwtype = %s, rvdw must be >= rlist unless you use a potential modifier", evdw_names[ir->vdwtype]); |
1223 | CHECK(ir->rlist > ir->rvdw)_low_check(ir->rlist > ir->rvdw, err_buf, wi); |
1224 | } |
1225 | } |
1226 | |
1227 | if (ir->vdwtype == evdwPME) |
1228 | { |
1229 | if (!(ir->vdw_modifier == eintmodNONE || ir->vdw_modifier == eintmodPOTSHIFT)) |
1230 | { |
1231 | sprintf(err_buf, "With vdwtype = %s, the only supported modifiers are %s a\ |
1232 | nd %s", |
1233 | evdw_names[ir->vdwtype], |
1234 | eintmod_names[eintmodPOTSHIFT], |
1235 | eintmod_names[eintmodNONE]); |
1236 | } |
1237 | } |
1238 | |
1239 | if (ir->cutoff_scheme == ecutsGROUP) |
1240 | { |
1241 | if (((ir->coulomb_modifier != eintmodNONE && ir->rcoulomb == ir->rlist) || |
1242 | (ir->vdw_modifier != eintmodNONE && ir->rvdw == ir->rlist)) && |
1243 | ir->nstlist != 1) |
1244 | { |
1245 | warning_note(wi, "With exact cut-offs, rlist should be " |
1246 | "larger than rcoulomb and rvdw, so that there " |
1247 | "is a buffer region for particle motion " |
1248 | "between neighborsearch steps"); |
1249 | } |
1250 | |
1251 | if (ir_coulomb_is_zero_at_cutoff(ir) && ir->rlistlong <= ir->rcoulomb) |
1252 | { |
1253 | sprintf(warn_buf, "For energy conservation with switch/shift potentials, %s should be 0.1 to 0.3 nm larger than rcoulomb.", |
1254 | IR_TWINRANGE(*ir)((*ir).rlist > 0 && ((*ir).rlistlong == 0 || (*ir) .rlistlong > (*ir).rlist)) ? "rlistlong" : "rlist"); |
1255 | warning_note(wi, warn_buf); |
1256 | } |
1257 | if (ir_vdw_switched(ir) && (ir->rlistlong <= ir->rvdw)) |
1258 | { |
1259 | sprintf(warn_buf, "For energy conservation with switch/shift potentials, %s should be 0.1 to 0.3 nm larger than rvdw.", |
1260 | IR_TWINRANGE(*ir)((*ir).rlist > 0 && ((*ir).rlistlong == 0 || (*ir) .rlistlong > (*ir).rlist)) ? "rlistlong" : "rlist"); |
1261 | warning_note(wi, warn_buf); |
1262 | } |
1263 | } |
1264 | |
1265 | if (ir->vdwtype == evdwUSER && ir->eDispCorr != edispcNO) |
1266 | { |
1267 | warning_note(wi, "You have selected user tables with dispersion correction, the dispersion will be corrected to -C6/r^6 beyond rvdw_switch (the tabulated interaction between rvdw_switch and rvdw will not be double counted). Make sure that you really want dispersion correction to -C6/r^6."); |
1268 | } |
1269 | |
1270 | if (ir->nstlist == -1) |
1271 | { |
1272 | sprintf(err_buf, "With nstlist=-1 rvdw and rcoulomb should be smaller than rlist to account for diffusion and possibly charge-group radii"); |
1273 | CHECK(ir->rvdw >= ir->rlist || ir->rcoulomb >= ir->rlist)_low_check(ir->rvdw >= ir->rlist || ir->rcoulomb >= ir->rlist, err_buf, wi); |
1274 | } |
1275 | sprintf(err_buf, "nstlist can not be smaller than -1"); |
1276 | CHECK(ir->nstlist < -1)_low_check(ir->nstlist < -1, err_buf, wi); |
1277 | |
1278 | if (ir->eI == eiLBFGS && (ir->coulombtype == eelCUT || ir->vdwtype == evdwCUT) |
1279 | && ir->rvdw != 0) |
1280 | { |
1281 | warning(wi, "For efficient BFGS minimization, use switch/shift/pme instead of cut-off."); |
1282 | } |
1283 | |
1284 | if (ir->eI == eiLBFGS && ir->nbfgscorr <= 0) |
1285 | { |
1286 | warning(wi, "Using L-BFGS with nbfgscorr<=0 just gets you steepest descent."); |
1287 | } |
1288 | |
1289 | /* ENERGY CONSERVATION */ |
1290 | if (ir_NVE(ir) && ir->cutoff_scheme == ecutsGROUP) |
1291 | { |
1292 | if (!ir_vdw_might_be_zero_at_cutoff(ir) && ir->rvdw > 0 && ir->vdw_modifier == eintmodNONE) |
1293 | { |
1294 | sprintf(warn_buf, "You are using a cut-off for VdW interactions with NVE, for good energy conservation use vdwtype = %s (possibly with DispCorr)", |
1295 | evdw_names[evdwSHIFT]); |
1296 | warning_note(wi, warn_buf); |
1297 | } |
1298 | if (!ir_coulomb_might_be_zero_at_cutoff(ir) && ir->rcoulomb > 0) |
1299 | { |
1300 | sprintf(warn_buf, "You are using a cut-off for electrostatics with NVE, for good energy conservation use coulombtype = %s or %s", |
1301 | eel_names[eelPMESWITCH], eel_names[eelRF_ZERO]); |
1302 | warning_note(wi, warn_buf); |
1303 | } |
1304 | } |
1305 | |
1306 | /* IMPLICIT SOLVENT */ |
1307 | if (ir->coulombtype == eelGB_NOTUSED) |
1308 | { |
1309 | ir->coulombtype = eelCUT; |
1310 | ir->implicit_solvent = eisGBSA; |
1311 | fprintf(stderrstderr, "Note: Old option for generalized born electrostatics given:\n" |
1312 | "Changing coulombtype from \"generalized-born\" to \"cut-off\" and instead\n" |
1313 | "setting implicit-solvent value to \"GBSA\" in input section.\n"); |
1314 | } |
1315 | |
1316 | if (ir->sa_algorithm == esaSTILL) |
1317 | { |
1318 | sprintf(err_buf, "Still SA algorithm not available yet, use %s or %s instead\n", esa_names[esaAPPROX], esa_names[esaNO]); |
1319 | CHECK(ir->sa_algorithm == esaSTILL)_low_check(ir->sa_algorithm == esaSTILL, err_buf, wi); |
1320 | } |
1321 | |
1322 | if (ir->implicit_solvent == eisGBSA) |
1323 | { |
1324 | sprintf(err_buf, "With GBSA implicit solvent, rgbradii must be equal to rlist."); |
1325 | CHECK(ir->rgbradii != ir->rlist)_low_check(ir->rgbradii != ir->rlist, err_buf, wi); |
1326 | |
1327 | if (ir->coulombtype != eelCUT) |
1328 | { |
1329 | sprintf(err_buf, "With GBSA, coulombtype must be equal to %s\n", eel_names[eelCUT]); |
1330 | CHECK(ir->coulombtype != eelCUT)_low_check(ir->coulombtype != eelCUT, err_buf, wi); |
1331 | } |
1332 | if (ir->vdwtype != evdwCUT) |
1333 | { |
1334 | sprintf(err_buf, "With GBSA, vdw-type must be equal to %s\n", evdw_names[evdwCUT]); |
1335 | CHECK(ir->vdwtype != evdwCUT)_low_check(ir->vdwtype != evdwCUT, err_buf, wi); |
1336 | } |
1337 | if (ir->nstgbradii < 1) |
1338 | { |
1339 | sprintf(warn_buf, "Using GBSA with nstgbradii<1, setting nstgbradii=1"); |
1340 | warning_note(wi, warn_buf); |
1341 | ir->nstgbradii = 1; |
1342 | } |
1343 | if (ir->sa_algorithm == esaNO) |
1344 | { |
1345 | sprintf(warn_buf, "No SA (non-polar) calculation requested together with GB. Are you sure this is what you want?\n"); |
1346 | warning_note(wi, warn_buf); |
1347 | } |
1348 | if (ir->sa_surface_tension < 0 && ir->sa_algorithm != esaNO) |
1349 | { |
1350 | sprintf(warn_buf, "Value of sa_surface_tension is < 0. Changing it to 2.05016 or 2.25936 kJ/nm^2/mol for Still and HCT/OBC respectively\n"); |
1351 | warning_note(wi, warn_buf); |
1352 | |
1353 | if (ir->gb_algorithm == egbSTILL) |
1354 | { |
1355 | ir->sa_surface_tension = 0.0049 * CAL2JOULE(4.184) * 100; |
1356 | } |
1357 | else |
1358 | { |
1359 | ir->sa_surface_tension = 0.0054 * CAL2JOULE(4.184) * 100; |
1360 | } |
1361 | } |
1362 | if (ir->sa_surface_tension == 0 && ir->sa_algorithm != esaNO) |
1363 | { |
1364 | sprintf(err_buf, "Surface tension set to 0 while SA-calculation requested\n"); |
1365 | CHECK(ir->sa_surface_tension == 0 && ir->sa_algorithm != esaNO)_low_check(ir->sa_surface_tension == 0 && ir->sa_algorithm != esaNO, err_buf, wi); |
1366 | } |
1367 | |
1368 | } |
1369 | |
1370 | if (ir->bAdress) |
1371 | { |
1372 | if (ir->cutoff_scheme != ecutsGROUP) |
1373 | { |
1374 | warning_error(wi, "AdresS simulation supports only cutoff-scheme=group"); |
1375 | } |
1376 | if (!EI_SD(ir->eI)((ir->eI) == eiSD1 || (ir->eI) == eiSD2)) |
1377 | { |
1378 | warning_error(wi, "AdresS simulation supports only stochastic dynamics"); |
1379 | } |
1380 | if (ir->epc != epcNO) |
1381 | { |
1382 | warning_error(wi, "AdresS simulation does not support pressure coupling"); |
1383 | } |
1384 | if (EEL_FULL(ir->coulombtype)((((ir->coulombtype) == eelPME || (ir->coulombtype) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir->coulombtype ) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD) || (ir->coulombtype) == eelEWALD) || (ir->coulombtype) == eelPOISSON)) |
1385 | { |
1386 | warning_error(wi, "AdresS simulation does not support long-range electrostatics"); |
1387 | } |
1388 | } |
1389 | } |
1390 | |
1391 | /* count the number of text elemets separated by whitespace in a string. |
1392 | str = the input string |
1393 | maxptr = the maximum number of allowed elements |
1394 | ptr = the output array of pointers to the first character of each element |
1395 | returns: the number of elements. */ |
1396 | int str_nelem(const char *str, int maxptr, char *ptr[]) |
1397 | { |
1398 | int np = 0; |
1399 | char *copy0, *copy; |
1400 | |
1401 | copy0 = strdup(str)(__extension__ (__builtin_constant_p (str) && ((size_t )(const void *)((str) + 1) - (size_t)(const void *)(str) == 1 ) ? (((const char *) (str))[0] == '\0' ? (char *) calloc ((size_t ) 1, (size_t) 1) : ({ size_t __len = strlen (str) + 1; char * __retval = (char *) malloc (__len); if (__retval != ((void*)0 )) __retval = (char *) memcpy (__retval, str, __len); __retval ; })) : __strdup (str))); |
1402 | copy = copy0; |
1403 | ltrim(copy); |
1404 | while (*copy != '\0') |
1405 | { |
1406 | if (np >= maxptr) |
1407 | { |
1408 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1408, "Too many groups on line: '%s' (max is %d)", |
1409 | str, maxptr); |
1410 | } |
1411 | if (ptr) |
1412 | { |
1413 | ptr[np] = copy; |
1414 | } |
1415 | np++; |
1416 | while ((*copy != '\0') && !isspace(*copy)((*__ctype_b_loc ())[(int) ((*copy))] & (unsigned short int ) _ISspace)) |
1417 | { |
1418 | copy++; |
1419 | } |
1420 | if (*copy != '\0') |
1421 | { |
1422 | *copy = '\0'; |
1423 | copy++; |
1424 | } |
1425 | ltrim(copy); |
1426 | } |
1427 | if (ptr == NULL((void*)0)) |
1428 | { |
1429 | sfree(copy0)save_free("copy0", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1429, (copy0)); |
1430 | } |
1431 | |
1432 | return np; |
1433 | } |
1434 | |
1435 | /* interpret a number of doubles from a string and put them in an array, |
1436 | after allocating space for them. |
1437 | str = the input string |
1438 | n = the (pre-allocated) number of doubles read |
1439 | r = the output array of doubles. */ |
1440 | static void parse_n_real(char *str, int *n, real **r) |
1441 | { |
1442 | char *ptr[MAXPTR254]; |
1443 | int i; |
1444 | |
1445 | *n = str_nelem(str, MAXPTR254, ptr); |
1446 | |
1447 | snew(*r, *n)(*r) = save_calloc("*r", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1447, (*n), sizeof(*(*r))); |
1448 | for (i = 0; i < *n; i++) |
1449 | { |
1450 | (*r)[i] = strtod(ptr[i], NULL((void*)0)); |
1451 | } |
1452 | } |
1453 | |
1454 | static void do_fep_params(t_inputrec *ir, char fep_lambda[][STRLEN4096], char weights[STRLEN4096]) |
1455 | { |
1456 | |
1457 | int i, j, max_n_lambda, nweights, nfep[efptNR]; |
1458 | t_lambda *fep = ir->fepvals; |
1459 | t_expanded *expand = ir->expandedvals; |
1460 | real **count_fep_lambdas; |
1461 | gmx_bool bOneLambda = TRUE1; |
1462 | |
1463 | snew(count_fep_lambdas, efptNR)(count_fep_lambdas) = save_calloc("count_fep_lambdas", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1463, (efptNR), sizeof(*(count_fep_lambdas))); |
1464 | |
1465 | /* FEP input processing */ |
1466 | /* first, identify the number of lambda values for each type. |
1467 | All that are nonzero must have the same number */ |
1468 | |
1469 | for (i = 0; i < efptNR; i++) |
1470 | { |
1471 | parse_n_real(fep_lambda[i], &(nfep[i]), &(count_fep_lambdas[i])); |
1472 | } |
1473 | |
1474 | /* now, determine the number of components. All must be either zero, or equal. */ |
1475 | |
1476 | max_n_lambda = 0; |
1477 | for (i = 0; i < efptNR; i++) |
1478 | { |
1479 | if (nfep[i] > max_n_lambda) |
1480 | { |
1481 | max_n_lambda = nfep[i]; /* here's a nonzero one. All of them |
1482 | must have the same number if its not zero.*/ |
1483 | break; |
1484 | } |
1485 | } |
1486 | |
1487 | for (i = 0; i < efptNR; i++) |
1488 | { |
1489 | if (nfep[i] == 0) |
1490 | { |
1491 | ir->fepvals->separate_dvdl[i] = FALSE0; |
1492 | } |
1493 | else if (nfep[i] == max_n_lambda) |
1494 | { |
1495 | if (i != efptTEMPERATURE) /* we treat this differently -- not really a reason to compute the derivative with |
1496 | respect to the temperature currently */ |
1497 | { |
1498 | ir->fepvals->separate_dvdl[i] = TRUE1; |
1499 | } |
1500 | } |
1501 | else |
1502 | { |
1503 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1503, "Number of lambdas (%d) for FEP type %s not equal to number of other types (%d)", |
1504 | nfep[i], efpt_names[i], max_n_lambda); |
1505 | } |
1506 | } |
1507 | /* we don't print out dhdl if the temperature is changing, since we can't correctly define dhdl in this case */ |
1508 | ir->fepvals->separate_dvdl[efptTEMPERATURE] = FALSE0; |
1509 | |
1510 | /* the number of lambdas is the number we've read in, which is either zero |
1511 | or the same for all */ |
1512 | fep->n_lambda = max_n_lambda; |
1513 | |
1514 | /* allocate space for the array of lambda values */ |
1515 | snew(fep->all_lambda, efptNR)(fep->all_lambda) = save_calloc("fep->all_lambda", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1515, (efptNR), sizeof(*(fep->all_lambda))); |
1516 | /* if init_lambda is defined, we need to set lambda */ |
1517 | if ((fep->init_lambda > 0) && (fep->n_lambda == 0)) |
1518 | { |
1519 | ir->fepvals->separate_dvdl[efptFEP] = TRUE1; |
1520 | } |
1521 | /* otherwise allocate the space for all of the lambdas, and transfer the data */ |
1522 | for (i = 0; i < efptNR; i++) |
1523 | { |
1524 | snew(fep->all_lambda[i], fep->n_lambda)(fep->all_lambda[i]) = save_calloc("fep->all_lambda[i]" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1524, (fep->n_lambda), sizeof(*(fep->all_lambda[i]))); |
1525 | if (nfep[i] > 0) /* if it's zero, then the count_fep_lambda arrays |
1526 | are zero */ |
1527 | { |
1528 | for (j = 0; j < fep->n_lambda; j++) |
1529 | { |
1530 | fep->all_lambda[i][j] = (double)count_fep_lambdas[i][j]; |
1531 | } |
1532 | sfree(count_fep_lambdas[i])save_free("count_fep_lambdas[i]", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1532, (count_fep_lambdas[i])); |
1533 | } |
1534 | } |
1535 | sfree(count_fep_lambdas)save_free("count_fep_lambdas", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1535, (count_fep_lambdas)); |
1536 | |
1537 | /* "fep-vals" is either zero or the full number. If zero, we'll need to define fep-lambdas for internal |
1538 | bookkeeping -- for now, init_lambda */ |
1539 | |
1540 | if ((nfep[efptFEP] == 0) && (fep->init_lambda >= 0)) |
1541 | { |
1542 | for (i = 0; i < fep->n_lambda; i++) |
1543 | { |
1544 | fep->all_lambda[efptFEP][i] = fep->init_lambda; |
1545 | } |
1546 | } |
1547 | |
1548 | /* check to see if only a single component lambda is defined, and soft core is defined. |
1549 | In this case, turn on coulomb soft core */ |
1550 | |
1551 | if (max_n_lambda == 0) |
1552 | { |
1553 | bOneLambda = TRUE1; |
1554 | } |
1555 | else |
1556 | { |
1557 | for (i = 0; i < efptNR; i++) |
1558 | { |
1559 | if ((nfep[i] != 0) && (i != efptFEP)) |
1560 | { |
1561 | bOneLambda = FALSE0; |
1562 | } |
1563 | } |
1564 | } |
1565 | if ((bOneLambda) && (fep->sc_alpha > 0)) |
1566 | { |
1567 | fep->bScCoul = TRUE1; |
1568 | } |
1569 | |
1570 | /* Fill in the others with the efptFEP if they are not explicitly |
1571 | specified (i.e. nfep[i] == 0). This means if fep is not defined, |
1572 | they are all zero. */ |
1573 | |
1574 | for (i = 0; i < efptNR; i++) |
1575 | { |
1576 | if ((nfep[i] == 0) && (i != efptFEP)) |
1577 | { |
1578 | for (j = 0; j < fep->n_lambda; j++) |
1579 | { |
1580 | fep->all_lambda[i][j] = fep->all_lambda[efptFEP][j]; |
1581 | } |
1582 | } |
1583 | } |
1584 | |
1585 | |
1586 | /* make it easier if sc_r_power = 48 by increasing it to the 4th power, to be in the right scale. */ |
1587 | if (fep->sc_r_power == 48) |
1588 | { |
1589 | if (fep->sc_alpha > 0.1) |
1590 | { |
1591 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1591, "sc_alpha (%f) for sc_r_power = 48 should usually be between 0.001 and 0.004", fep->sc_alpha); |
1592 | } |
1593 | } |
1594 | |
1595 | expand = ir->expandedvals; |
1596 | /* now read in the weights */ |
1597 | parse_n_real(weights, &nweights, &(expand->init_lambda_weights)); |
1598 | if (nweights == 0) |
1599 | { |
1600 | snew(expand->init_lambda_weights, fep->n_lambda)(expand->init_lambda_weights) = save_calloc("expand->init_lambda_weights" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1600, (fep->n_lambda), sizeof(*(expand->init_lambda_weights ))); /* initialize to zero */ |
1601 | } |
1602 | else if (nweights != fep->n_lambda) |
1603 | { |
1604 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1604, "Number of weights (%d) is not equal to number of lambda values (%d)", |
1605 | nweights, fep->n_lambda); |
1606 | } |
1607 | if ((expand->nstexpanded < 0) && (ir->efep != efepNO)) |
1608 | { |
1609 | expand->nstexpanded = fep->nstdhdl; |
1610 | /* if you don't specify nstexpanded when doing expanded ensemble free energy calcs, it is set to nstdhdl */ |
1611 | } |
1612 | if ((expand->nstexpanded < 0) && ir->bSimTemp) |
1613 | { |
1614 | expand->nstexpanded = 2*(int)(ir->opts.tau_t[0]/ir->delta_t); |
1615 | /* if you don't specify nstexpanded when doing expanded ensemble simulated tempering, it is set to |
1616 | 2*tau_t just to be careful so it's not to frequent */ |
1617 | } |
1618 | } |
1619 | |
1620 | |
1621 | static void do_simtemp_params(t_inputrec *ir) |
1622 | { |
1623 | |
1624 | snew(ir->simtempvals->temperatures, ir->fepvals->n_lambda)(ir->simtempvals->temperatures) = save_calloc("ir->simtempvals->temperatures" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1624, (ir->fepvals->n_lambda), sizeof(*(ir->simtempvals ->temperatures))); |
1625 | GetSimTemps(ir->fepvals->n_lambda, ir->simtempvals, ir->fepvals->all_lambda[efptTEMPERATURE]); |
1626 | |
1627 | return; |
1628 | } |
1629 | |
1630 | static void do_wall_params(t_inputrec *ir, |
1631 | char *wall_atomtype, char *wall_density, |
1632 | t_gromppopts *opts) |
1633 | { |
1634 | int nstr, i; |
1635 | char *names[MAXPTR254]; |
1636 | double dbl; |
1637 | |
1638 | opts->wall_atomtype[0] = NULL((void*)0); |
1639 | opts->wall_atomtype[1] = NULL((void*)0); |
1640 | |
1641 | ir->wall_atomtype[0] = -1; |
1642 | ir->wall_atomtype[1] = -1; |
1643 | ir->wall_density[0] = 0; |
1644 | ir->wall_density[1] = 0; |
1645 | |
1646 | if (ir->nwall > 0) |
1647 | { |
1648 | nstr = str_nelem(wall_atomtype, MAXPTR254, names); |
1649 | if (nstr != ir->nwall) |
1650 | { |
1651 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1651, "Expected %d elements for wall_atomtype, found %d", |
1652 | ir->nwall, nstr); |
1653 | } |
1654 | for (i = 0; i < ir->nwall; i++) |
1655 | { |
1656 | opts->wall_atomtype[i] = strdup(names[i])(__extension__ (__builtin_constant_p (names[i]) && (( size_t)(const void *)((names[i]) + 1) - (size_t)(const void * )(names[i]) == 1) ? (((const char *) (names[i]))[0] == '\0' ? (char *) calloc ((size_t) 1, (size_t) 1) : ({ size_t __len = strlen (names[i]) + 1; char *__retval = (char *) malloc (__len ); if (__retval != ((void*)0)) __retval = (char *) memcpy (__retval , names[i], __len); __retval; })) : __strdup (names[i]))); |
1657 | } |
1658 | |
1659 | if (ir->wall_type == ewt93 || ir->wall_type == ewt104) |
1660 | { |
1661 | nstr = str_nelem(wall_density, MAXPTR254, names); |
1662 | if (nstr != ir->nwall) |
1663 | { |
1664 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1664, "Expected %d elements for wall-density, found %d", ir->nwall, nstr); |
1665 | } |
1666 | for (i = 0; i < ir->nwall; i++) |
1667 | { |
1668 | sscanf(names[i], "%lf", &dbl); |
1669 | if (dbl <= 0) |
1670 | { |
1671 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1671, "wall-density[%d] = %f\n", i, dbl); |
1672 | } |
1673 | ir->wall_density[i] = dbl; |
1674 | } |
1675 | } |
1676 | } |
1677 | } |
1678 | |
1679 | static void add_wall_energrps(gmx_groups_t *groups, int nwall, t_symtab *symtab) |
1680 | { |
1681 | int i; |
1682 | t_grps *grps; |
1683 | char str[STRLEN4096]; |
1684 | |
1685 | if (nwall > 0) |
1686 | { |
1687 | srenew(groups->grpname, groups->ngrpname+nwall)(groups->grpname) = save_realloc("groups->grpname", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1687, (groups->grpname), (groups->ngrpname+nwall), sizeof (*(groups->grpname))); |
1688 | grps = &(groups->grps[egcENER]); |
1689 | srenew(grps->nm_ind, grps->nr+nwall)(grps->nm_ind) = save_realloc("grps->nm_ind", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1689, (grps->nm_ind), (grps->nr+nwall), sizeof(*(grps ->nm_ind))); |
1690 | for (i = 0; i < nwall; i++) |
1691 | { |
1692 | sprintf(str, "wall%d", i); |
1693 | groups->grpname[groups->ngrpname] = put_symtab(symtab, str); |
1694 | grps->nm_ind[grps->nr++] = groups->ngrpname++; |
1695 | } |
1696 | } |
1697 | } |
1698 | |
1699 | void read_expandedparams(int *ninp_p, t_inpfile **inp_p, |
1700 | t_expanded *expand, warninp_t wi) |
1701 | { |
1702 | int ninp, nerror = 0; |
1703 | t_inpfile *inp; |
1704 | |
1705 | ninp = *ninp_p; |
1706 | inp = *inp_p; |
1707 | |
1708 | /* read expanded ensemble parameters */ |
1709 | CCTYPE ("expanded ensemble variables")get_estr(&ninp, &inp, "\n; " "expanded ensemble variables" , ((void*)0)); |
1710 | ITYPE ("nstexpanded", expand->nstexpanded, -1)expand->nstexpanded = get_eint(&ninp, &inp, "nstexpanded" , -1, wi); |
1711 | EETYPE("lmc-stats", expand->elamstats, elamstats_names)expand->elamstats = get_eeenum(&ninp, &inp, "lmc-stats" , elamstats_names, wi); |
1712 | EETYPE("lmc-move", expand->elmcmove, elmcmove_names)expand->elmcmove = get_eeenum(&ninp, &inp, "lmc-move" , elmcmove_names, wi); |
1713 | EETYPE("lmc-weights-equil", expand->elmceq, elmceq_names)expand->elmceq = get_eeenum(&ninp, &inp, "lmc-weights-equil" , elmceq_names, wi); |
1714 | ITYPE ("weight-equil-number-all-lambda", expand->equil_n_at_lam, -1)expand->equil_n_at_lam = get_eint(&ninp, &inp, "weight-equil-number-all-lambda" , -1, wi); |
1715 | ITYPE ("weight-equil-number-samples", expand->equil_samples, -1)expand->equil_samples = get_eint(&ninp, &inp, "weight-equil-number-samples" , -1, wi); |
1716 | ITYPE ("weight-equil-number-steps", expand->equil_steps, -1)expand->equil_steps = get_eint(&ninp, &inp, "weight-equil-number-steps" , -1, wi); |
1717 | RTYPE ("weight-equil-wl-delta", expand->equil_wl_delta, -1)expand->equil_wl_delta = get_ereal(&ninp, &inp, "weight-equil-wl-delta" , -1, wi); |
1718 | RTYPE ("weight-equil-count-ratio", expand->equil_ratio, -1)expand->equil_ratio = get_ereal(&ninp, &inp, "weight-equil-count-ratio" , -1, wi); |
1719 | CCTYPE("Seed for Monte Carlo in lambda space")get_estr(&ninp, &inp, "\n; " "Seed for Monte Carlo in lambda space" , ((void*)0)); |
1720 | ITYPE ("lmc-seed", expand->lmc_seed, -1)expand->lmc_seed = get_eint(&ninp, &inp, "lmc-seed" , -1, wi); |
1721 | RTYPE ("mc-temperature", expand->mc_temp, -1)expand->mc_temp = get_ereal(&ninp, &inp, "mc-temperature" , -1, wi); |
1722 | ITYPE ("lmc-repeats", expand->lmc_repeats, 1)expand->lmc_repeats = get_eint(&ninp, &inp, "lmc-repeats" , 1, wi); |
1723 | ITYPE ("lmc-gibbsdelta", expand->gibbsdeltalam, -1)expand->gibbsdeltalam = get_eint(&ninp, &inp, "lmc-gibbsdelta" , -1, wi); |
1724 | ITYPE ("lmc-forced-nstart", expand->lmc_forced_nstart, 0)expand->lmc_forced_nstart = get_eint(&ninp, &inp, "lmc-forced-nstart" , 0, wi); |
1725 | EETYPE("symmetrized-transition-matrix", expand->bSymmetrizedTMatrix, yesno_names)expand->bSymmetrizedTMatrix = get_eeenum(&ninp, &inp , "symmetrized-transition-matrix", yesno_names, wi); |
1726 | ITYPE("nst-transition-matrix", expand->nstTij, -1)expand->nstTij = get_eint(&ninp, &inp, "nst-transition-matrix" , -1, wi); |
1727 | ITYPE ("mininum-var-min", expand->minvarmin, 100)expand->minvarmin = get_eint(&ninp, &inp, "mininum-var-min" , 100, wi); /*default is reasonable */ |
1728 | ITYPE ("weight-c-range", expand->c_range, 0)expand->c_range = get_eint(&ninp, &inp, "weight-c-range" , 0, wi); /* default is just C=0 */ |
1729 | RTYPE ("wl-scale", expand->wl_scale, 0.8)expand->wl_scale = get_ereal(&ninp, &inp, "wl-scale" , 0.8, wi); |
1730 | RTYPE ("wl-ratio", expand->wl_ratio, 0.8)expand->wl_ratio = get_ereal(&ninp, &inp, "wl-ratio" , 0.8, wi); |
1731 | RTYPE ("init-wl-delta", expand->init_wl_delta, 1.0)expand->init_wl_delta = get_ereal(&ninp, &inp, "init-wl-delta" , 1.0, wi); |
1732 | EETYPE("wl-oneovert", expand->bWLoneovert, yesno_names)expand->bWLoneovert = get_eeenum(&ninp, &inp, "wl-oneovert" , yesno_names, wi); |
1733 | |
1734 | *ninp_p = ninp; |
1735 | *inp_p = inp; |
1736 | |
1737 | return; |
1738 | } |
1739 | |
1740 | void get_ir(const char *mdparin, const char *mdparout, |
1741 | t_inputrec *ir, t_gromppopts *opts, |
1742 | warninp_t wi) |
1743 | { |
1744 | char *dumstr[2]; |
1745 | double dumdub[2][6]; |
1746 | t_inpfile *inp; |
1747 | const char *tmp; |
1748 | int i, j, m, ninp; |
1749 | char warn_buf[STRLEN4096]; |
1750 | t_lambda *fep = ir->fepvals; |
1751 | t_expanded *expand = ir->expandedvals; |
1752 | |
1753 | init_inputrec_strings(); |
1754 | inp = read_inpfile(mdparin, &ninp, wi); |
1755 | |
1756 | snew(dumstr[0], STRLEN)(dumstr[0]) = save_calloc("dumstr[0]", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1756, (4096), sizeof(*(dumstr[0]))); |
1757 | snew(dumstr[1], STRLEN)(dumstr[1]) = save_calloc("dumstr[1]", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 1757, (4096), sizeof(*(dumstr[1]))); |
1758 | |
1759 | if (-1 == search_einp(ninp, inp, "cutoff-scheme")) |
1760 | { |
1761 | sprintf(warn_buf, |
1762 | "%s did not specify a value for the .mdp option " |
1763 | "\"cutoff-scheme\". Probably it was first intended for use " |
1764 | "with GROMACS before 4.6. In 4.6, the Verlet scheme was " |
1765 | "introduced, but the group scheme was still the default. " |
1766 | "The default is now the Verlet scheme, so you will observe " |
1767 | "different behaviour.", mdparin); |
1768 | warning_note(wi, warn_buf); |
1769 | } |
1770 | |
1771 | /* remove the following deprecated commands */ |
1772 | REM_TYPE("title")replace_inp_entry(ninp, inp, "title", ((void*)0)); |
1773 | REM_TYPE("cpp")replace_inp_entry(ninp, inp, "cpp", ((void*)0)); |
1774 | REM_TYPE("domain-decomposition")replace_inp_entry(ninp, inp, "domain-decomposition", ((void*) 0)); |
1775 | REM_TYPE("andersen-seed")replace_inp_entry(ninp, inp, "andersen-seed", ((void*)0)); |
1776 | REM_TYPE("dihre")replace_inp_entry(ninp, inp, "dihre", ((void*)0)); |
1777 | REM_TYPE("dihre-fc")replace_inp_entry(ninp, inp, "dihre-fc", ((void*)0)); |
1778 | REM_TYPE("dihre-tau")replace_inp_entry(ninp, inp, "dihre-tau", ((void*)0)); |
1779 | REM_TYPE("nstdihreout")replace_inp_entry(ninp, inp, "nstdihreout", ((void*)0)); |
1780 | REM_TYPE("nstcheckpoint")replace_inp_entry(ninp, inp, "nstcheckpoint", ((void*)0)); |
1781 | |
1782 | /* replace the following commands with the clearer new versions*/ |
1783 | REPL_TYPE("unconstrained-start", "continuation")replace_inp_entry(ninp, inp, "unconstrained-start", "continuation" ); |
1784 | REPL_TYPE("foreign-lambda", "fep-lambdas")replace_inp_entry(ninp, inp, "foreign-lambda", "fep-lambdas"); |
1785 | REPL_TYPE("verlet-buffer-drift", "verlet-buffer-tolerance")replace_inp_entry(ninp, inp, "verlet-buffer-drift", "verlet-buffer-tolerance" ); |
1786 | REPL_TYPE("nstxtcout", "nstxout-compressed")replace_inp_entry(ninp, inp, "nstxtcout", "nstxout-compressed" ); |
1787 | REPL_TYPE("xtc-grps", "compressed-x-grps")replace_inp_entry(ninp, inp, "xtc-grps", "compressed-x-grps"); |
1788 | REPL_TYPE("xtc-precision", "compressed-x-precision")replace_inp_entry(ninp, inp, "xtc-precision", "compressed-x-precision" ); |
1789 | |
1790 | CCTYPE ("VARIOUS PREPROCESSING OPTIONS")get_estr(&ninp, &inp, "\n; " "VARIOUS PREPROCESSING OPTIONS" , ((void*)0)); |
1791 | CTYPE ("Preprocessor information: use cpp syntax."); |
1792 | CTYPE ("e.g.: -I/home/joe/doe -I/home/mary/roe"); |
1793 | STYPE ("include", opts->include, NULL)if ((tmp = get_estr(&ninp, &inp, "include", ((void*)0 ))) != ((void*)0)) strcpy(opts->include, tmp); |
1794 | CTYPE ("e.g.: -DPOSRES -DFLEXIBLE (note these variable names are case sensitive)"); |
1795 | STYPE ("define", opts->define, NULL)if ((tmp = get_estr(&ninp, &inp, "define", ((void*)0) )) != ((void*)0)) strcpy(opts->define, tmp); |
1796 | |
1797 | CCTYPE ("RUN CONTROL PARAMETERS")get_estr(&ninp, &inp, "\n; " "RUN CONTROL PARAMETERS" , ((void*)0)); |
1798 | EETYPE("integrator", ir->eI, ei_names)ir->eI = get_eeenum(&ninp, &inp, "integrator", ei_names , wi); |
1799 | CTYPE ("Start time and timestep in ps"); |
1800 | RTYPE ("tinit", ir->init_t, 0.0)ir->init_t = get_ereal(&ninp, &inp, "tinit", 0.0, wi ); |
1801 | RTYPE ("dt", ir->delta_t, 0.001)ir->delta_t = get_ereal(&ninp, &inp, "dt", 0.001, wi ); |
1802 | STEPTYPE ("nsteps", ir->nsteps, 0)ir->nsteps = get_eint64(&ninp, &inp, "nsteps", 0, wi ); |
1803 | CTYPE ("For exact run continuation or redoing part of a run"); |
1804 | STEPTYPE ("init-step", ir->init_step, 0)ir->init_step = get_eint64(&ninp, &inp, "init-step" , 0, wi); |
1805 | CTYPE ("Part index is updated automatically on checkpointing (keeps files separate)"); |
1806 | ITYPE ("simulation-part", ir->simulation_part, 1)ir->simulation_part = get_eint(&ninp, &inp, "simulation-part" , 1, wi); |
1807 | CTYPE ("mode for center of mass motion removal"); |
1808 | EETYPE("comm-mode", ir->comm_mode, ecm_names)ir->comm_mode = get_eeenum(&ninp, &inp, "comm-mode" , ecm_names, wi); |
1809 | CTYPE ("number of steps for center of mass motion removal"); |
1810 | ITYPE ("nstcomm", ir->nstcomm, 100)ir->nstcomm = get_eint(&ninp, &inp, "nstcomm", 100 , wi); |
1811 | CTYPE ("group(s) for center of mass motion removal"); |
1812 | STYPE ("comm-grps", is->vcm, NULL)if ((tmp = get_estr(&ninp, &inp, "comm-grps", ((void* )0))) != ((void*)0)) strcpy(is->vcm, tmp); |
1813 | |
1814 | CCTYPE ("LANGEVIN DYNAMICS OPTIONS")get_estr(&ninp, &inp, "\n; " "LANGEVIN DYNAMICS OPTIONS" , ((void*)0)); |
1815 | CTYPE ("Friction coefficient (amu/ps) and random seed"); |
1816 | RTYPE ("bd-fric", ir->bd_fric, 0.0)ir->bd_fric = get_ereal(&ninp, &inp, "bd-fric", 0.0 , wi); |
1817 | STEPTYPE ("ld-seed", ir->ld_seed, -1)ir->ld_seed = get_eint64(&ninp, &inp, "ld-seed", - 1, wi); |
1818 | |
1819 | /* Em stuff */ |
1820 | CCTYPE ("ENERGY MINIMIZATION OPTIONS")get_estr(&ninp, &inp, "\n; " "ENERGY MINIMIZATION OPTIONS" , ((void*)0)); |
1821 | CTYPE ("Force tolerance and initial step-size"); |
1822 | RTYPE ("emtol", ir->em_tol, 10.0)ir->em_tol = get_ereal(&ninp, &inp, "emtol", 10.0, wi); |
1823 | RTYPE ("emstep", ir->em_stepsize, 0.01)ir->em_stepsize = get_ereal(&ninp, &inp, "emstep", 0.01, wi); |
1824 | CTYPE ("Max number of iterations in relax-shells"); |
1825 | ITYPE ("niter", ir->niter, 20)ir->niter = get_eint(&ninp, &inp, "niter", 20, wi); |
1826 | CTYPE ("Step size (ps^2) for minimization of flexible constraints"); |
1827 | RTYPE ("fcstep", ir->fc_stepsize, 0)ir->fc_stepsize = get_ereal(&ninp, &inp, "fcstep", 0, wi); |
1828 | CTYPE ("Frequency of steepest descents steps when doing CG"); |
1829 | ITYPE ("nstcgsteep", ir->nstcgsteep, 1000)ir->nstcgsteep = get_eint(&ninp, &inp, "nstcgsteep" , 1000, wi); |
1830 | ITYPE ("nbfgscorr", ir->nbfgscorr, 10)ir->nbfgscorr = get_eint(&ninp, &inp, "nbfgscorr", 10, wi); |
1831 | |
1832 | CCTYPE ("TEST PARTICLE INSERTION OPTIONS")get_estr(&ninp, &inp, "\n; " "TEST PARTICLE INSERTION OPTIONS" , ((void*)0)); |
1833 | RTYPE ("rtpi", ir->rtpi, 0.05)ir->rtpi = get_ereal(&ninp, &inp, "rtpi", 0.05, wi ); |
1834 | |
1835 | /* Output options */ |
1836 | CCTYPE ("OUTPUT CONTROL OPTIONS")get_estr(&ninp, &inp, "\n; " "OUTPUT CONTROL OPTIONS" , ((void*)0)); |
1837 | CTYPE ("Output frequency for coords (x), velocities (v) and forces (f)"); |
1838 | ITYPE ("nstxout", ir->nstxout, 0)ir->nstxout = get_eint(&ninp, &inp, "nstxout", 0, wi ); |
1839 | ITYPE ("nstvout", ir->nstvout, 0)ir->nstvout = get_eint(&ninp, &inp, "nstvout", 0, wi ); |
1840 | ITYPE ("nstfout", ir->nstfout, 0)ir->nstfout = get_eint(&ninp, &inp, "nstfout", 0, wi ); |
1841 | ir->nstcheckpoint = 1000; |
1842 | CTYPE ("Output frequency for energies to log file and energy file"); |
1843 | ITYPE ("nstlog", ir->nstlog, 1000)ir->nstlog = get_eint(&ninp, &inp, "nstlog", 1000, wi); |
1844 | ITYPE ("nstcalcenergy", ir->nstcalcenergy, 100)ir->nstcalcenergy = get_eint(&ninp, &inp, "nstcalcenergy" , 100, wi); |
1845 | ITYPE ("nstenergy", ir->nstenergy, 1000)ir->nstenergy = get_eint(&ninp, &inp, "nstenergy", 1000, wi); |
1846 | CTYPE ("Output frequency and precision for .xtc file"); |
1847 | ITYPE ("nstxout-compressed", ir->nstxout_compressed, 0)ir->nstxout_compressed = get_eint(&ninp, &inp, "nstxout-compressed" , 0, wi); |
1848 | RTYPE ("compressed-x-precision", ir->x_compression_precision, 1000.0)ir->x_compression_precision = get_ereal(&ninp, &inp , "compressed-x-precision", 1000.0, wi); |
1849 | CTYPE ("This selects the subset of atoms for the compressed"); |
1850 | CTYPE ("trajectory file. You can select multiple groups. By"); |
1851 | CTYPE ("default, all atoms will be written."); |
1852 | STYPE ("compressed-x-grps", is->x_compressed_groups, NULL)if ((tmp = get_estr(&ninp, &inp, "compressed-x-grps", ((void*)0))) != ((void*)0)) strcpy(is->x_compressed_groups , tmp); |
1853 | CTYPE ("Selection of energy groups"); |
1854 | STYPE ("energygrps", is->energy, NULL)if ((tmp = get_estr(&ninp, &inp, "energygrps", ((void *)0))) != ((void*)0)) strcpy(is->energy, tmp); |
1855 | |
1856 | /* Neighbor searching */ |
1857 | CCTYPE ("NEIGHBORSEARCHING PARAMETERS")get_estr(&ninp, &inp, "\n; " "NEIGHBORSEARCHING PARAMETERS" , ((void*)0)); |
1858 | CTYPE ("cut-off scheme (Verlet: particle based cut-offs, group: using charge groups)"); |
1859 | EETYPE("cutoff-scheme", ir->cutoff_scheme, ecutscheme_names)ir->cutoff_scheme = get_eeenum(&ninp, &inp, "cutoff-scheme" , ecutscheme_names, wi); |
1860 | CTYPE ("nblist update frequency"); |
1861 | ITYPE ("nstlist", ir->nstlist, 10)ir->nstlist = get_eint(&ninp, &inp, "nstlist", 10, wi); |
1862 | CTYPE ("ns algorithm (simple or grid)"); |
1863 | EETYPE("ns-type", ir->ns_type, ens_names)ir->ns_type = get_eeenum(&ninp, &inp, "ns-type", ens_names , wi); |
1864 | /* set ndelta to the optimal value of 2 */ |
1865 | ir->ndelta = 2; |
1866 | CTYPE ("Periodic boundary conditions: xyz, no, xy"); |
1867 | EETYPE("pbc", ir->ePBC, epbc_names)ir->ePBC = get_eeenum(&ninp, &inp, "pbc", epbc_names , wi); |
1868 | EETYPE("periodic-molecules", ir->bPeriodicMols, yesno_names)ir->bPeriodicMols = get_eeenum(&ninp, &inp, "periodic-molecules" , yesno_names, wi); |
1869 | CTYPE ("Allowed energy error due to the Verlet buffer in kJ/mol/ps per atom,"); |
1870 | CTYPE ("a value of -1 means: use rlist"); |
1871 | RTYPE("verlet-buffer-tolerance", ir->verletbuf_tol, 0.005)ir->verletbuf_tol = get_ereal(&ninp, &inp, "verlet-buffer-tolerance" , 0.005, wi); |
1872 | CTYPE ("nblist cut-off"); |
1873 | RTYPE ("rlist", ir->rlist, 1.0)ir->rlist = get_ereal(&ninp, &inp, "rlist", 1.0, wi ); |
1874 | CTYPE ("long-range cut-off for switched potentials"); |
1875 | RTYPE ("rlistlong", ir->rlistlong, -1)ir->rlistlong = get_ereal(&ninp, &inp, "rlistlong" , -1, wi); |
1876 | ITYPE ("nstcalclr", ir->nstcalclr, -1)ir->nstcalclr = get_eint(&ninp, &inp, "nstcalclr", -1, wi); |
1877 | |
1878 | /* Electrostatics */ |
1879 | CCTYPE ("OPTIONS FOR ELECTROSTATICS AND VDW")get_estr(&ninp, &inp, "\n; " "OPTIONS FOR ELECTROSTATICS AND VDW" , ((void*)0)); |
1880 | CTYPE ("Method for doing electrostatics"); |
1881 | EETYPE("coulombtype", ir->coulombtype, eel_names)ir->coulombtype = get_eeenum(&ninp, &inp, "coulombtype" , eel_names, wi); |
1882 | EETYPE("coulomb-modifier", ir->coulomb_modifier, eintmod_names)ir->coulomb_modifier = get_eeenum(&ninp, &inp, "coulomb-modifier" , eintmod_names, wi); |
1883 | CTYPE ("cut-off lengths"); |
1884 | RTYPE ("rcoulomb-switch", ir->rcoulomb_switch, 0.0)ir->rcoulomb_switch = get_ereal(&ninp, &inp, "rcoulomb-switch" , 0.0, wi); |
1885 | RTYPE ("rcoulomb", ir->rcoulomb, 1.0)ir->rcoulomb = get_ereal(&ninp, &inp, "rcoulomb", 1.0 , wi); |
1886 | CTYPE ("Relative dielectric constant for the medium and the reaction field"); |
1887 | RTYPE ("epsilon-r", ir->epsilon_r, 1.0)ir->epsilon_r = get_ereal(&ninp, &inp, "epsilon-r" , 1.0, wi); |
1888 | RTYPE ("epsilon-rf", ir->epsilon_rf, 0.0)ir->epsilon_rf = get_ereal(&ninp, &inp, "epsilon-rf" , 0.0, wi); |
1889 | CTYPE ("Method for doing Van der Waals"); |
1890 | EETYPE("vdw-type", ir->vdwtype, evdw_names)ir->vdwtype = get_eeenum(&ninp, &inp, "vdw-type", evdw_names , wi); |
1891 | EETYPE("vdw-modifier", ir->vdw_modifier, eintmod_names)ir->vdw_modifier = get_eeenum(&ninp, &inp, "vdw-modifier" , eintmod_names, wi); |
1892 | CTYPE ("cut-off lengths"); |
1893 | RTYPE ("rvdw-switch", ir->rvdw_switch, 0.0)ir->rvdw_switch = get_ereal(&ninp, &inp, "rvdw-switch" , 0.0, wi); |
1894 | RTYPE ("rvdw", ir->rvdw, 1.0)ir->rvdw = get_ereal(&ninp, &inp, "rvdw", 1.0, wi); |
1895 | CTYPE ("Apply long range dispersion corrections for Energy and Pressure"); |
1896 | EETYPE("DispCorr", ir->eDispCorr, edispc_names)ir->eDispCorr = get_eeenum(&ninp, &inp, "DispCorr" , edispc_names, wi); |
1897 | CTYPE ("Extension of the potential lookup tables beyond the cut-off"); |
1898 | RTYPE ("table-extension", ir->tabext, 1.0)ir->tabext = get_ereal(&ninp, &inp, "table-extension" , 1.0, wi); |
1899 | CTYPE ("Separate tables between energy group pairs"); |
1900 | STYPE ("energygrp-table", is->egptable, NULL)if ((tmp = get_estr(&ninp, &inp, "energygrp-table", ( (void*)0))) != ((void*)0)) strcpy(is->egptable, tmp); |
1901 | CTYPE ("Spacing for the PME/PPPM FFT grid"); |
1902 | RTYPE ("fourierspacing", ir->fourier_spacing, 0.12)ir->fourier_spacing = get_ereal(&ninp, &inp, "fourierspacing" , 0.12, wi); |
1903 | CTYPE ("FFT grid size, when a value is 0 fourierspacing will be used"); |
1904 | ITYPE ("fourier-nx", ir->nkx, 0)ir->nkx = get_eint(&ninp, &inp, "fourier-nx", 0, wi ); |
1905 | ITYPE ("fourier-ny", ir->nky, 0)ir->nky = get_eint(&ninp, &inp, "fourier-ny", 0, wi ); |
1906 | ITYPE ("fourier-nz", ir->nkz, 0)ir->nkz = get_eint(&ninp, &inp, "fourier-nz", 0, wi ); |
1907 | CTYPE ("EWALD/PME/PPPM parameters"); |
1908 | ITYPE ("pme-order", ir->pme_order, 4)ir->pme_order = get_eint(&ninp, &inp, "pme-order", 4, wi); |
1909 | RTYPE ("ewald-rtol", ir->ewald_rtol, 0.00001)ir->ewald_rtol = get_ereal(&ninp, &inp, "ewald-rtol" , 0.00001, wi); |
1910 | RTYPE ("ewald-rtol-lj", ir->ewald_rtol_lj, 0.001)ir->ewald_rtol_lj = get_ereal(&ninp, &inp, "ewald-rtol-lj" , 0.001, wi); |
1911 | EETYPE("lj-pme-comb-rule", ir->ljpme_combination_rule, eljpme_names)ir->ljpme_combination_rule = get_eeenum(&ninp, &inp , "lj-pme-comb-rule", eljpme_names, wi); |
1912 | EETYPE("ewald-geometry", ir->ewald_geometry, eewg_names)ir->ewald_geometry = get_eeenum(&ninp, &inp, "ewald-geometry" , eewg_names, wi); |
1913 | RTYPE ("epsilon-surface", ir->epsilon_surface, 0.0)ir->epsilon_surface = get_ereal(&ninp, &inp, "epsilon-surface" , 0.0, wi); |
1914 | EETYPE("optimize-fft", ir->bOptFFT, yesno_names)ir->bOptFFT = get_eeenum(&ninp, &inp, "optimize-fft" , yesno_names, wi); |
1915 | |
1916 | CCTYPE("IMPLICIT SOLVENT ALGORITHM")get_estr(&ninp, &inp, "\n; " "IMPLICIT SOLVENT ALGORITHM" , ((void*)0)); |
1917 | EETYPE("implicit-solvent", ir->implicit_solvent, eis_names)ir->implicit_solvent = get_eeenum(&ninp, &inp, "implicit-solvent" , eis_names, wi); |
1918 | |
1919 | CCTYPE ("GENERALIZED BORN ELECTROSTATICS")get_estr(&ninp, &inp, "\n; " "GENERALIZED BORN ELECTROSTATICS" , ((void*)0)); |
1920 | CTYPE ("Algorithm for calculating Born radii"); |
1921 | EETYPE("gb-algorithm", ir->gb_algorithm, egb_names)ir->gb_algorithm = get_eeenum(&ninp, &inp, "gb-algorithm" , egb_names, wi); |
1922 | CTYPE ("Frequency of calculating the Born radii inside rlist"); |
1923 | ITYPE ("nstgbradii", ir->nstgbradii, 1)ir->nstgbradii = get_eint(&ninp, &inp, "nstgbradii" , 1, wi); |
1924 | CTYPE ("Cutoff for Born radii calculation; the contribution from atoms"); |
1925 | CTYPE ("between rlist and rgbradii is updated every nstlist steps"); |
1926 | RTYPE ("rgbradii", ir->rgbradii, 1.0)ir->rgbradii = get_ereal(&ninp, &inp, "rgbradii", 1.0 , wi); |
1927 | CTYPE ("Dielectric coefficient of the implicit solvent"); |
1928 | RTYPE ("gb-epsilon-solvent", ir->gb_epsilon_solvent, 80.0)ir->gb_epsilon_solvent = get_ereal(&ninp, &inp, "gb-epsilon-solvent" , 80.0, wi); |
1929 | CTYPE ("Salt concentration in M for Generalized Born models"); |
1930 | RTYPE ("gb-saltconc", ir->gb_saltconc, 0.0)ir->gb_saltconc = get_ereal(&ninp, &inp, "gb-saltconc" , 0.0, wi); |
1931 | CTYPE ("Scaling factors used in the OBC GB model. Default values are OBC(II)"); |
1932 | RTYPE ("gb-obc-alpha", ir->gb_obc_alpha, 1.0)ir->gb_obc_alpha = get_ereal(&ninp, &inp, "gb-obc-alpha" , 1.0, wi); |
1933 | RTYPE ("gb-obc-beta", ir->gb_obc_beta, 0.8)ir->gb_obc_beta = get_ereal(&ninp, &inp, "gb-obc-beta" , 0.8, wi); |
1934 | RTYPE ("gb-obc-gamma", ir->gb_obc_gamma, 4.85)ir->gb_obc_gamma = get_ereal(&ninp, &inp, "gb-obc-gamma" , 4.85, wi); |
1935 | RTYPE ("gb-dielectric-offset", ir->gb_dielectric_offset, 0.009)ir->gb_dielectric_offset = get_ereal(&ninp, &inp, "gb-dielectric-offset" , 0.009, wi); |
1936 | EETYPE("sa-algorithm", ir->sa_algorithm, esa_names)ir->sa_algorithm = get_eeenum(&ninp, &inp, "sa-algorithm" , esa_names, wi); |
1937 | CTYPE ("Surface tension (kJ/mol/nm^2) for the SA (nonpolar surface) part of GBSA"); |
1938 | CTYPE ("The value -1 will set default value for Still/HCT/OBC GB-models."); |
1939 | RTYPE ("sa-surface-tension", ir->sa_surface_tension, -1)ir->sa_surface_tension = get_ereal(&ninp, &inp, "sa-surface-tension" , -1, wi); |
1940 | |
1941 | /* Coupling stuff */ |
1942 | CCTYPE ("OPTIONS FOR WEAK COUPLING ALGORITHMS")get_estr(&ninp, &inp, "\n; " "OPTIONS FOR WEAK COUPLING ALGORITHMS" , ((void*)0)); |
1943 | CTYPE ("Temperature coupling"); |
1944 | EETYPE("tcoupl", ir->etc, etcoupl_names)ir->etc = get_eeenum(&ninp, &inp, "tcoupl", etcoupl_names , wi); |
1945 | ITYPE ("nsttcouple", ir->nsttcouple, -1)ir->nsttcouple = get_eint(&ninp, &inp, "nsttcouple" , -1, wi); |
1946 | ITYPE("nh-chain-length", ir->opts.nhchainlength, 10)ir->opts.nhchainlength = get_eint(&ninp, &inp, "nh-chain-length" , 10, wi); |
1947 | EETYPE("print-nose-hoover-chain-variables", ir->bPrintNHChains, yesno_names)ir->bPrintNHChains = get_eeenum(&ninp, &inp, "print-nose-hoover-chain-variables" , yesno_names, wi); |
1948 | CTYPE ("Groups to couple separately"); |
1949 | STYPE ("tc-grps", is->tcgrps, NULL)if ((tmp = get_estr(&ninp, &inp, "tc-grps", ((void*)0 ))) != ((void*)0)) strcpy(is->tcgrps, tmp); |
1950 | CTYPE ("Time constant (ps) and reference temperature (K)"); |
1951 | STYPE ("tau-t", is->tau_t, NULL)if ((tmp = get_estr(&ninp, &inp, "tau-t", ((void*)0)) ) != ((void*)0)) strcpy(is->tau_t, tmp); |
1952 | STYPE ("ref-t", is->ref_t, NULL)if ((tmp = get_estr(&ninp, &inp, "ref-t", ((void*)0)) ) != ((void*)0)) strcpy(is->ref_t, tmp); |
1953 | CTYPE ("pressure coupling"); |
1954 | EETYPE("pcoupl", ir->epc, epcoupl_names)ir->epc = get_eeenum(&ninp, &inp, "pcoupl", epcoupl_names , wi); |
1955 | EETYPE("pcoupltype", ir->epct, epcoupltype_names)ir->epct = get_eeenum(&ninp, &inp, "pcoupltype", epcoupltype_names , wi); |
1956 | ITYPE ("nstpcouple", ir->nstpcouple, -1)ir->nstpcouple = get_eint(&ninp, &inp, "nstpcouple" , -1, wi); |
1957 | CTYPE ("Time constant (ps), compressibility (1/bar) and reference P (bar)"); |
1958 | RTYPE ("tau-p", ir->tau_p, 1.0)ir->tau_p = get_ereal(&ninp, &inp, "tau-p", 1.0, wi ); |
1959 | STYPE ("compressibility", dumstr[0], NULL)if ((tmp = get_estr(&ninp, &inp, "compressibility", ( (void*)0))) != ((void*)0)) strcpy(dumstr[0], tmp); |
1960 | STYPE ("ref-p", dumstr[1], NULL)if ((tmp = get_estr(&ninp, &inp, "ref-p", ((void*)0)) ) != ((void*)0)) strcpy(dumstr[1], tmp); |
1961 | CTYPE ("Scaling of reference coordinates, No, All or COM"); |
1962 | EETYPE ("refcoord-scaling", ir->refcoord_scaling, erefscaling_names)ir->refcoord_scaling = get_eeenum(&ninp, &inp, "refcoord-scaling" , erefscaling_names, wi); |
1963 | |
1964 | /* QMMM */ |
1965 | CCTYPE ("OPTIONS FOR QMMM calculations")get_estr(&ninp, &inp, "\n; " "OPTIONS FOR QMMM calculations" , ((void*)0)); |
1966 | EETYPE("QMMM", ir->bQMMM, yesno_names)ir->bQMMM = get_eeenum(&ninp, &inp, "QMMM", yesno_names , wi); |
1967 | CTYPE ("Groups treated Quantum Mechanically"); |
1968 | STYPE ("QMMM-grps", is->QMMM, NULL)if ((tmp = get_estr(&ninp, &inp, "QMMM-grps", ((void* )0))) != ((void*)0)) strcpy(is->QMMM, tmp); |
1969 | CTYPE ("QM method"); |
1970 | STYPE("QMmethod", is->QMmethod, NULL)if ((tmp = get_estr(&ninp, &inp, "QMmethod", ((void*) 0))) != ((void*)0)) strcpy(is->QMmethod, tmp); |
1971 | CTYPE ("QMMM scheme"); |
1972 | EETYPE("QMMMscheme", ir->QMMMscheme, eQMMMscheme_names)ir->QMMMscheme = get_eeenum(&ninp, &inp, "QMMMscheme" , eQMMMscheme_names, wi); |
1973 | CTYPE ("QM basisset"); |
1974 | STYPE("QMbasis", is->QMbasis, NULL)if ((tmp = get_estr(&ninp, &inp, "QMbasis", ((void*)0 ))) != ((void*)0)) strcpy(is->QMbasis, tmp); |
1975 | CTYPE ("QM charge"); |
1976 | STYPE ("QMcharge", is->QMcharge, NULL)if ((tmp = get_estr(&ninp, &inp, "QMcharge", ((void*) 0))) != ((void*)0)) strcpy(is->QMcharge, tmp); |
1977 | CTYPE ("QM multiplicity"); |
1978 | STYPE ("QMmult", is->QMmult, NULL)if ((tmp = get_estr(&ninp, &inp, "QMmult", ((void*)0) )) != ((void*)0)) strcpy(is->QMmult, tmp); |
1979 | CTYPE ("Surface Hopping"); |
1980 | STYPE ("SH", is->bSH, NULL)if ((tmp = get_estr(&ninp, &inp, "SH", ((void*)0))) != ((void*)0)) strcpy(is->bSH, tmp); |
1981 | CTYPE ("CAS space options"); |
1982 | STYPE ("CASorbitals", is->CASorbitals, NULL)if ((tmp = get_estr(&ninp, &inp, "CASorbitals", ((void *)0))) != ((void*)0)) strcpy(is->CASorbitals, tmp); |
1983 | STYPE ("CASelectrons", is->CASelectrons, NULL)if ((tmp = get_estr(&ninp, &inp, "CASelectrons", ((void *)0))) != ((void*)0)) strcpy(is->CASelectrons, tmp); |
1984 | STYPE ("SAon", is->SAon, NULL)if ((tmp = get_estr(&ninp, &inp, "SAon", ((void*)0))) != ((void*)0)) strcpy(is->SAon, tmp); |
1985 | STYPE ("SAoff", is->SAoff, NULL)if ((tmp = get_estr(&ninp, &inp, "SAoff", ((void*)0)) ) != ((void*)0)) strcpy(is->SAoff, tmp); |
1986 | STYPE ("SAsteps", is->SAsteps, NULL)if ((tmp = get_estr(&ninp, &inp, "SAsteps", ((void*)0 ))) != ((void*)0)) strcpy(is->SAsteps, tmp); |
1987 | CTYPE ("Scale factor for MM charges"); |
1988 | RTYPE ("MMChargeScaleFactor", ir->scalefactor, 1.0)ir->scalefactor = get_ereal(&ninp, &inp, "MMChargeScaleFactor" , 1.0, wi); |
1989 | CTYPE ("Optimization of QM subsystem"); |
1990 | STYPE ("bOPT", is->bOPT, NULL)if ((tmp = get_estr(&ninp, &inp, "bOPT", ((void*)0))) != ((void*)0)) strcpy(is->bOPT, tmp); |
1991 | STYPE ("bTS", is->bTS, NULL)if ((tmp = get_estr(&ninp, &inp, "bTS", ((void*)0))) != ((void*)0)) strcpy(is->bTS, tmp); |
1992 | |
1993 | /* Simulated annealing */ |
1994 | CCTYPE("SIMULATED ANNEALING")get_estr(&ninp, &inp, "\n; " "SIMULATED ANNEALING", ( (void*)0)); |
1995 | CTYPE ("Type of annealing for each temperature group (no/single/periodic)"); |
1996 | STYPE ("annealing", is->anneal, NULL)if ((tmp = get_estr(&ninp, &inp, "annealing", ((void* )0))) != ((void*)0)) strcpy(is->anneal, tmp); |
1997 | CTYPE ("Number of time points to use for specifying annealing in each group"); |
1998 | STYPE ("annealing-npoints", is->anneal_npoints, NULL)if ((tmp = get_estr(&ninp, &inp, "annealing-npoints", ((void*)0))) != ((void*)0)) strcpy(is->anneal_npoints, tmp ); |
1999 | CTYPE ("List of times at the annealing points for each group"); |
2000 | STYPE ("annealing-time", is->anneal_time, NULL)if ((tmp = get_estr(&ninp, &inp, "annealing-time", (( void*)0))) != ((void*)0)) strcpy(is->anneal_time, tmp); |
2001 | CTYPE ("Temp. at each annealing point, for each group."); |
2002 | STYPE ("annealing-temp", is->anneal_temp, NULL)if ((tmp = get_estr(&ninp, &inp, "annealing-temp", (( void*)0))) != ((void*)0)) strcpy(is->anneal_temp, tmp); |
2003 | |
2004 | /* Startup run */ |
2005 | CCTYPE ("GENERATE VELOCITIES FOR STARTUP RUN")get_estr(&ninp, &inp, "\n; " "GENERATE VELOCITIES FOR STARTUP RUN" , ((void*)0)); |
2006 | EETYPE("gen-vel", opts->bGenVel, yesno_names)opts->bGenVel = get_eeenum(&ninp, &inp, "gen-vel", yesno_names, wi); |
2007 | RTYPE ("gen-temp", opts->tempi, 300.0)opts->tempi = get_ereal(&ninp, &inp, "gen-temp", 300.0 , wi); |
2008 | ITYPE ("gen-seed", opts->seed, -1)opts->seed = get_eint(&ninp, &inp, "gen-seed", -1, wi); |
2009 | |
2010 | /* Shake stuff */ |
2011 | CCTYPE ("OPTIONS FOR BONDS")get_estr(&ninp, &inp, "\n; " "OPTIONS FOR BONDS", ((void *)0)); |
2012 | EETYPE("constraints", opts->nshake, constraints)opts->nshake = get_eeenum(&ninp, &inp, "constraints" , constraints, wi); |
2013 | CTYPE ("Type of constraint algorithm"); |
2014 | EETYPE("constraint-algorithm", ir->eConstrAlg, econstr_names)ir->eConstrAlg = get_eeenum(&ninp, &inp, "constraint-algorithm" , econstr_names, wi); |
2015 | CTYPE ("Do not constrain the start configuration"); |
2016 | EETYPE("continuation", ir->bContinuation, yesno_names)ir->bContinuation = get_eeenum(&ninp, &inp, "continuation" , yesno_names, wi); |
2017 | CTYPE ("Use successive overrelaxation to reduce the number of shake iterations"); |
2018 | EETYPE("Shake-SOR", ir->bShakeSOR, yesno_names)ir->bShakeSOR = get_eeenum(&ninp, &inp, "Shake-SOR" , yesno_names, wi); |
2019 | CTYPE ("Relative tolerance of shake"); |
2020 | RTYPE ("shake-tol", ir->shake_tol, 0.0001)ir->shake_tol = get_ereal(&ninp, &inp, "shake-tol" , 0.0001, wi); |
2021 | CTYPE ("Highest order in the expansion of the constraint coupling matrix"); |
2022 | ITYPE ("lincs-order", ir->nProjOrder, 4)ir->nProjOrder = get_eint(&ninp, &inp, "lincs-order" , 4, wi); |
2023 | CTYPE ("Number of iterations in the final step of LINCS. 1 is fine for"); |
2024 | CTYPE ("normal simulations, but use 2 to conserve energy in NVE runs."); |
2025 | CTYPE ("For energy minimization with constraints it should be 4 to 8."); |
2026 | ITYPE ("lincs-iter", ir->nLincsIter, 1)ir->nLincsIter = get_eint(&ninp, &inp, "lincs-iter" , 1, wi); |
2027 | CTYPE ("Lincs will write a warning to the stderr if in one step a bond"); |
2028 | CTYPE ("rotates over more degrees than"); |
2029 | RTYPE ("lincs-warnangle", ir->LincsWarnAngle, 30.0)ir->LincsWarnAngle = get_ereal(&ninp, &inp, "lincs-warnangle" , 30.0, wi); |
2030 | CTYPE ("Convert harmonic bonds to morse potentials"); |
2031 | EETYPE("morse", opts->bMorse, yesno_names)opts->bMorse = get_eeenum(&ninp, &inp, "morse", yesno_names , wi); |
2032 | |
2033 | /* Energy group exclusions */ |
2034 | CCTYPE ("ENERGY GROUP EXCLUSIONS")get_estr(&ninp, &inp, "\n; " "ENERGY GROUP EXCLUSIONS" , ((void*)0)); |
2035 | CTYPE ("Pairs of energy groups for which all non-bonded interactions are excluded"); |
2036 | STYPE ("energygrp-excl", is->egpexcl, NULL)if ((tmp = get_estr(&ninp, &inp, "energygrp-excl", (( void*)0))) != ((void*)0)) strcpy(is->egpexcl, tmp); |
2037 | |
2038 | /* Walls */ |
2039 | CCTYPE ("WALLS")get_estr(&ninp, &inp, "\n; " "WALLS", ((void*)0)); |
2040 | CTYPE ("Number of walls, type, atom types, densities and box-z scale factor for Ewald"); |
2041 | ITYPE ("nwall", ir->nwall, 0)ir->nwall = get_eint(&ninp, &inp, "nwall", 0, wi); |
2042 | EETYPE("wall-type", ir->wall_type, ewt_names)ir->wall_type = get_eeenum(&ninp, &inp, "wall-type" , ewt_names, wi); |
2043 | RTYPE ("wall-r-linpot", ir->wall_r_linpot, -1)ir->wall_r_linpot = get_ereal(&ninp, &inp, "wall-r-linpot" , -1, wi); |
2044 | STYPE ("wall-atomtype", is->wall_atomtype, NULL)if ((tmp = get_estr(&ninp, &inp, "wall-atomtype", ((void *)0))) != ((void*)0)) strcpy(is->wall_atomtype, tmp); |
2045 | STYPE ("wall-density", is->wall_density, NULL)if ((tmp = get_estr(&ninp, &inp, "wall-density", ((void *)0))) != ((void*)0)) strcpy(is->wall_density, tmp); |
2046 | RTYPE ("wall-ewald-zfac", ir->wall_ewald_zfac, 3)ir->wall_ewald_zfac = get_ereal(&ninp, &inp, "wall-ewald-zfac" , 3, wi); |
2047 | |
2048 | /* COM pulling */ |
2049 | CCTYPE("COM PULLING")get_estr(&ninp, &inp, "\n; " "COM PULLING", ((void*)0 )); |
2050 | CTYPE("Pull type: no, umbrella, constraint or constant-force"); |
2051 | EETYPE("pull", ir->ePull, epull_names)ir->ePull = get_eeenum(&ninp, &inp, "pull", epull_names , wi); |
2052 | if (ir->ePull != epullNO) |
2053 | { |
2054 | snew(ir->pull, 1)(ir->pull) = save_calloc("ir->pull", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2054, (1), sizeof(*(ir->pull))); |
2055 | is->pull_grp = read_pullparams(&ninp, &inp, ir->pull, &opts->pull_start, wi); |
2056 | } |
2057 | |
2058 | /* Enforced rotation */ |
2059 | CCTYPE("ENFORCED ROTATION")get_estr(&ninp, &inp, "\n; " "ENFORCED ROTATION", ((void *)0)); |
2060 | CTYPE("Enforced rotation: No or Yes"); |
2061 | EETYPE("rotation", ir->bRot, yesno_names)ir->bRot = get_eeenum(&ninp, &inp, "rotation", yesno_names , wi); |
2062 | if (ir->bRot) |
2063 | { |
2064 | snew(ir->rot, 1)(ir->rot) = save_calloc("ir->rot", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2064, (1), sizeof(*(ir->rot))); |
2065 | is->rot_grp = read_rotparams(&ninp, &inp, ir->rot, wi); |
2066 | } |
2067 | |
2068 | /* Interactive MD */ |
2069 | ir->bIMD = FALSE0; |
2070 | CCTYPE("Group to display and/or manipulate in interactive MD session")get_estr(&ninp, &inp, "\n; " "Group to display and/or manipulate in interactive MD session" , ((void*)0)); |
2071 | STYPE ("IMD-group", is->imd_grp, NULL)if ((tmp = get_estr(&ninp, &inp, "IMD-group", ((void* )0))) != ((void*)0)) strcpy(is->imd_grp, tmp); |
2072 | if (is->imd_grp[0] != '\0') |
2073 | { |
2074 | snew(ir->imd, 1)(ir->imd) = save_calloc("ir->imd", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2074, (1), sizeof(*(ir->imd))); |
2075 | ir->bIMD = TRUE1; |
2076 | } |
2077 | |
2078 | /* Refinement */ |
2079 | CCTYPE("NMR refinement stuff")get_estr(&ninp, &inp, "\n; " "NMR refinement stuff", ( (void*)0)); |
2080 | CTYPE ("Distance restraints type: No, Simple or Ensemble"); |
2081 | EETYPE("disre", ir->eDisre, edisre_names)ir->eDisre = get_eeenum(&ninp, &inp, "disre", edisre_names , wi); |
2082 | CTYPE ("Force weighting of pairs in one distance restraint: Conservative or Equal"); |
2083 | EETYPE("disre-weighting", ir->eDisreWeighting, edisreweighting_names)ir->eDisreWeighting = get_eeenum(&ninp, &inp, "disre-weighting" , edisreweighting_names, wi); |
2084 | CTYPE ("Use sqrt of the time averaged times the instantaneous violation"); |
2085 | EETYPE("disre-mixed", ir->bDisreMixed, yesno_names)ir->bDisreMixed = get_eeenum(&ninp, &inp, "disre-mixed" , yesno_names, wi); |
2086 | RTYPE ("disre-fc", ir->dr_fc, 1000.0)ir->dr_fc = get_ereal(&ninp, &inp, "disre-fc", 1000.0 , wi); |
2087 | RTYPE ("disre-tau", ir->dr_tau, 0.0)ir->dr_tau = get_ereal(&ninp, &inp, "disre-tau", 0.0 , wi); |
2088 | CTYPE ("Output frequency for pair distances to energy file"); |
2089 | ITYPE ("nstdisreout", ir->nstdisreout, 100)ir->nstdisreout = get_eint(&ninp, &inp, "nstdisreout" , 100, wi); |
2090 | CTYPE ("Orientation restraints: No or Yes"); |
2091 | EETYPE("orire", opts->bOrire, yesno_names)opts->bOrire = get_eeenum(&ninp, &inp, "orire", yesno_names , wi); |
2092 | CTYPE ("Orientation restraints force constant and tau for time averaging"); |
2093 | RTYPE ("orire-fc", ir->orires_fc, 0.0)ir->orires_fc = get_ereal(&ninp, &inp, "orire-fc", 0.0, wi); |
2094 | RTYPE ("orire-tau", ir->orires_tau, 0.0)ir->orires_tau = get_ereal(&ninp, &inp, "orire-tau" , 0.0, wi); |
2095 | STYPE ("orire-fitgrp", is->orirefitgrp, NULL)if ((tmp = get_estr(&ninp, &inp, "orire-fitgrp", ((void *)0))) != ((void*)0)) strcpy(is->orirefitgrp, tmp); |
2096 | CTYPE ("Output frequency for trace(SD) and S to energy file"); |
2097 | ITYPE ("nstorireout", ir->nstorireout, 100)ir->nstorireout = get_eint(&ninp, &inp, "nstorireout" , 100, wi); |
2098 | |
2099 | /* free energy variables */ |
2100 | CCTYPE ("Free energy variables")get_estr(&ninp, &inp, "\n; " "Free energy variables", ((void*)0)); |
2101 | EETYPE("free-energy", ir->efep, efep_names)ir->efep = get_eeenum(&ninp, &inp, "free-energy", efep_names , wi); |
2102 | STYPE ("couple-moltype", is->couple_moltype, NULL)if ((tmp = get_estr(&ninp, &inp, "couple-moltype", (( void*)0))) != ((void*)0)) strcpy(is->couple_moltype, tmp); |
2103 | EETYPE("couple-lambda0", opts->couple_lam0, couple_lam)opts->couple_lam0 = get_eeenum(&ninp, &inp, "couple-lambda0" , couple_lam, wi); |
2104 | EETYPE("couple-lambda1", opts->couple_lam1, couple_lam)opts->couple_lam1 = get_eeenum(&ninp, &inp, "couple-lambda1" , couple_lam, wi); |
2105 | EETYPE("couple-intramol", opts->bCoupleIntra, yesno_names)opts->bCoupleIntra = get_eeenum(&ninp, &inp, "couple-intramol" , yesno_names, wi); |
2106 | |
2107 | RTYPE ("init-lambda", fep->init_lambda, -1)fep->init_lambda = get_ereal(&ninp, &inp, "init-lambda" , -1, wi); /* start with -1 so |
2108 | we can recognize if |
2109 | it was not entered */ |
2110 | ITYPE ("init-lambda-state", fep->init_fep_state, -1)fep->init_fep_state = get_eint(&ninp, &inp, "init-lambda-state" , -1, wi); |
2111 | RTYPE ("delta-lambda", fep->delta_lambda, 0.0)fep->delta_lambda = get_ereal(&ninp, &inp, "delta-lambda" , 0.0, wi); |
2112 | ITYPE ("nstdhdl", fep->nstdhdl, 50)fep->nstdhdl = get_eint(&ninp, &inp, "nstdhdl", 50 , wi); |
2113 | STYPE ("fep-lambdas", is->fep_lambda[efptFEP], NULL)if ((tmp = get_estr(&ninp, &inp, "fep-lambdas", ((void *)0))) != ((void*)0)) strcpy(is->fep_lambda[efptFEP], tmp); |
2114 | STYPE ("mass-lambdas", is->fep_lambda[efptMASS], NULL)if ((tmp = get_estr(&ninp, &inp, "mass-lambdas", ((void *)0))) != ((void*)0)) strcpy(is->fep_lambda[efptMASS], tmp ); |
2115 | STYPE ("coul-lambdas", is->fep_lambda[efptCOUL], NULL)if ((tmp = get_estr(&ninp, &inp, "coul-lambdas", ((void *)0))) != ((void*)0)) strcpy(is->fep_lambda[efptCOUL], tmp ); |
2116 | STYPE ("vdw-lambdas", is->fep_lambda[efptVDW], NULL)if ((tmp = get_estr(&ninp, &inp, "vdw-lambdas", ((void *)0))) != ((void*)0)) strcpy(is->fep_lambda[efptVDW], tmp); |
2117 | STYPE ("bonded-lambdas", is->fep_lambda[efptBONDED], NULL)if ((tmp = get_estr(&ninp, &inp, "bonded-lambdas", (( void*)0))) != ((void*)0)) strcpy(is->fep_lambda[efptBONDED ], tmp); |
2118 | STYPE ("restraint-lambdas", is->fep_lambda[efptRESTRAINT], NULL)if ((tmp = get_estr(&ninp, &inp, "restraint-lambdas", ((void*)0))) != ((void*)0)) strcpy(is->fep_lambda[efptRESTRAINT ], tmp); |
2119 | STYPE ("temperature-lambdas", is->fep_lambda[efptTEMPERATURE], NULL)if ((tmp = get_estr(&ninp, &inp, "temperature-lambdas" , ((void*)0))) != ((void*)0)) strcpy(is->fep_lambda[efptTEMPERATURE ], tmp); |
2120 | ITYPE ("calc-lambda-neighbors", fep->lambda_neighbors, 1)fep->lambda_neighbors = get_eint(&ninp, &inp, "calc-lambda-neighbors" , 1, wi); |
2121 | STYPE ("init-lambda-weights", is->lambda_weights, NULL)if ((tmp = get_estr(&ninp, &inp, "init-lambda-weights" , ((void*)0))) != ((void*)0)) strcpy(is->lambda_weights, tmp ); |
2122 | EETYPE("dhdl-print-energy", fep->bPrintEnergy, yesno_names)fep->bPrintEnergy = get_eeenum(&ninp, &inp, "dhdl-print-energy" , yesno_names, wi); |
2123 | RTYPE ("sc-alpha", fep->sc_alpha, 0.0)fep->sc_alpha = get_ereal(&ninp, &inp, "sc-alpha", 0.0, wi); |
2124 | ITYPE ("sc-power", fep->sc_power, 1)fep->sc_power = get_eint(&ninp, &inp, "sc-power", 1 , wi); |
2125 | RTYPE ("sc-r-power", fep->sc_r_power, 6.0)fep->sc_r_power = get_ereal(&ninp, &inp, "sc-r-power" , 6.0, wi); |
2126 | RTYPE ("sc-sigma", fep->sc_sigma, 0.3)fep->sc_sigma = get_ereal(&ninp, &inp, "sc-sigma", 0.3, wi); |
2127 | EETYPE("sc-coul", fep->bScCoul, yesno_names)fep->bScCoul = get_eeenum(&ninp, &inp, "sc-coul", yesno_names , wi); |
2128 | ITYPE ("dh_hist_size", fep->dh_hist_size, 0)fep->dh_hist_size = get_eint(&ninp, &inp, "dh_hist_size" , 0, wi); |
2129 | RTYPE ("dh_hist_spacing", fep->dh_hist_spacing, 0.1)fep->dh_hist_spacing = get_ereal(&ninp, &inp, "dh_hist_spacing" , 0.1, wi); |
2130 | EETYPE("separate-dhdl-file", fep->separate_dhdl_file,fep->separate_dhdl_file = get_eeenum(&ninp, &inp, "separate-dhdl-file" , separate_dhdl_file_names, wi) |
2131 | separate_dhdl_file_names)fep->separate_dhdl_file = get_eeenum(&ninp, &inp, "separate-dhdl-file" , separate_dhdl_file_names, wi); |
2132 | EETYPE("dhdl-derivatives", fep->dhdl_derivatives, dhdl_derivatives_names)fep->dhdl_derivatives = get_eeenum(&ninp, &inp, "dhdl-derivatives" , dhdl_derivatives_names, wi); |
2133 | ITYPE ("dh_hist_size", fep->dh_hist_size, 0)fep->dh_hist_size = get_eint(&ninp, &inp, "dh_hist_size" , 0, wi); |
2134 | RTYPE ("dh_hist_spacing", fep->dh_hist_spacing, 0.1)fep->dh_hist_spacing = get_ereal(&ninp, &inp, "dh_hist_spacing" , 0.1, wi); |
2135 | |
2136 | /* Non-equilibrium MD stuff */ |
2137 | CCTYPE("Non-equilibrium MD stuff")get_estr(&ninp, &inp, "\n; " "Non-equilibrium MD stuff" , ((void*)0)); |
2138 | STYPE ("acc-grps", is->accgrps, NULL)if ((tmp = get_estr(&ninp, &inp, "acc-grps", ((void*) 0))) != ((void*)0)) strcpy(is->accgrps, tmp); |
2139 | STYPE ("accelerate", is->acc, NULL)if ((tmp = get_estr(&ninp, &inp, "accelerate", ((void *)0))) != ((void*)0)) strcpy(is->acc, tmp); |
2140 | STYPE ("freezegrps", is->freeze, NULL)if ((tmp = get_estr(&ninp, &inp, "freezegrps", ((void *)0))) != ((void*)0)) strcpy(is->freeze, tmp); |
2141 | STYPE ("freezedim", is->frdim, NULL)if ((tmp = get_estr(&ninp, &inp, "freezedim", ((void* )0))) != ((void*)0)) strcpy(is->frdim, tmp); |
2142 | RTYPE ("cos-acceleration", ir->cos_accel, 0)ir->cos_accel = get_ereal(&ninp, &inp, "cos-acceleration" , 0, wi); |
2143 | STYPE ("deform", is->deform, NULL)if ((tmp = get_estr(&ninp, &inp, "deform", ((void*)0) )) != ((void*)0)) strcpy(is->deform, tmp); |
2144 | |
2145 | /* simulated tempering variables */ |
2146 | CCTYPE("simulated tempering variables")get_estr(&ninp, &inp, "\n; " "simulated tempering variables" , ((void*)0)); |
2147 | EETYPE("simulated-tempering", ir->bSimTemp, yesno_names)ir->bSimTemp = get_eeenum(&ninp, &inp, "simulated-tempering" , yesno_names, wi); |
2148 | EETYPE("simulated-tempering-scaling", ir->simtempvals->eSimTempScale, esimtemp_names)ir->simtempvals->eSimTempScale = get_eeenum(&ninp, & inp, "simulated-tempering-scaling", esimtemp_names, wi); |
2149 | RTYPE("sim-temp-low", ir->simtempvals->simtemp_low, 300.0)ir->simtempvals->simtemp_low = get_ereal(&ninp, & inp, "sim-temp-low", 300.0, wi); |
2150 | RTYPE("sim-temp-high", ir->simtempvals->simtemp_high, 300.0)ir->simtempvals->simtemp_high = get_ereal(&ninp, & inp, "sim-temp-high", 300.0, wi); |
2151 | |
2152 | /* expanded ensemble variables */ |
2153 | if (ir->efep == efepEXPANDED || ir->bSimTemp) |
2154 | { |
2155 | read_expandedparams(&ninp, &inp, expand, wi); |
2156 | } |
2157 | |
2158 | /* Electric fields */ |
2159 | CCTYPE("Electric fields")get_estr(&ninp, &inp, "\n; " "Electric fields", ((void *)0)); |
2160 | CTYPE ("Format is number of terms (int) and for all terms an amplitude (real)"); |
2161 | CTYPE ("and a phase angle (real)"); |
2162 | STYPE ("E-x", is->efield_x, NULL)if ((tmp = get_estr(&ninp, &inp, "E-x", ((void*)0))) != ((void*)0)) strcpy(is->efield_x, tmp); |
2163 | STYPE ("E-xt", is->efield_xt, NULL)if ((tmp = get_estr(&ninp, &inp, "E-xt", ((void*)0))) != ((void*)0)) strcpy(is->efield_xt, tmp); |
2164 | STYPE ("E-y", is->efield_y, NULL)if ((tmp = get_estr(&ninp, &inp, "E-y", ((void*)0))) != ((void*)0)) strcpy(is->efield_y, tmp); |
2165 | STYPE ("E-yt", is->efield_yt, NULL)if ((tmp = get_estr(&ninp, &inp, "E-yt", ((void*)0))) != ((void*)0)) strcpy(is->efield_yt, tmp); |
2166 | STYPE ("E-z", is->efield_z, NULL)if ((tmp = get_estr(&ninp, &inp, "E-z", ((void*)0))) != ((void*)0)) strcpy(is->efield_z, tmp); |
2167 | STYPE ("E-zt", is->efield_zt, NULL)if ((tmp = get_estr(&ninp, &inp, "E-zt", ((void*)0))) != ((void*)0)) strcpy(is->efield_zt, tmp); |
2168 | |
2169 | CCTYPE("Ion/water position swapping for computational electrophysiology setups")get_estr(&ninp, &inp, "\n; " "Ion/water position swapping for computational electrophysiology setups" , ((void*)0)); |
2170 | CTYPE("Swap positions along direction: no, X, Y, Z"); |
2171 | EETYPE("swapcoords", ir->eSwapCoords, eSwapTypes_names)ir->eSwapCoords = get_eeenum(&ninp, &inp, "swapcoords" , eSwapTypes_names, wi); |
2172 | if (ir->eSwapCoords != eswapNO) |
2173 | { |
2174 | snew(ir->swap, 1)(ir->swap) = save_calloc("ir->swap", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2174, (1), sizeof(*(ir->swap))); |
2175 | CTYPE("Swap attempt frequency"); |
2176 | ITYPE("swap-frequency", ir->swap->nstswap, 1)ir->swap->nstswap = get_eint(&ninp, &inp, "swap-frequency" , 1, wi); |
2177 | CTYPE("Two index groups that contain the compartment-partitioning atoms"); |
2178 | STYPE("split-group0", splitgrp0, NULL)if ((tmp = get_estr(&ninp, &inp, "split-group0", ((void *)0))) != ((void*)0)) strcpy(splitgrp0, tmp); |
2179 | STYPE("split-group1", splitgrp1, NULL)if ((tmp = get_estr(&ninp, &inp, "split-group1", ((void *)0))) != ((void*)0)) strcpy(splitgrp1, tmp); |
2180 | CTYPE("Use center of mass of split groups (yes/no), otherwise center of geometry is used"); |
2181 | EETYPE("massw-split0", ir->swap->massw_split[0], yesno_names)ir->swap->massw_split[0] = get_eeenum(&ninp, &inp , "massw-split0", yesno_names, wi); |
2182 | EETYPE("massw-split1", ir->swap->massw_split[1], yesno_names)ir->swap->massw_split[1] = get_eeenum(&ninp, &inp , "massw-split1", yesno_names, wi); |
2183 | |
2184 | CTYPE("Group name of ions that can be exchanged with solvent molecules"); |
2185 | STYPE("swap-group", swapgrp, NULL)if ((tmp = get_estr(&ninp, &inp, "swap-group", ((void *)0))) != ((void*)0)) strcpy(swapgrp, tmp); |
2186 | CTYPE("Group name of solvent molecules"); |
2187 | STYPE("solvent-group", solgrp, NULL)if ((tmp = get_estr(&ninp, &inp, "solvent-group", ((void *)0))) != ((void*)0)) strcpy(solgrp, tmp); |
2188 | |
2189 | CTYPE("Split cylinder: radius, upper and lower extension (nm) (this will define the channels)"); |
2190 | CTYPE("Note that the split cylinder settings do not have an influence on the swapping protocol,"); |
2191 | CTYPE("however, if correctly defined, the ion permeation events are counted per channel"); |
2192 | RTYPE("cyl0-r", ir->swap->cyl0r, 2.0)ir->swap->cyl0r = get_ereal(&ninp, &inp, "cyl0-r" , 2.0, wi); |
2193 | RTYPE("cyl0-up", ir->swap->cyl0u, 1.0)ir->swap->cyl0u = get_ereal(&ninp, &inp, "cyl0-up" , 1.0, wi); |
2194 | RTYPE("cyl0-down", ir->swap->cyl0l, 1.0)ir->swap->cyl0l = get_ereal(&ninp, &inp, "cyl0-down" , 1.0, wi); |
2195 | RTYPE("cyl1-r", ir->swap->cyl1r, 2.0)ir->swap->cyl1r = get_ereal(&ninp, &inp, "cyl1-r" , 2.0, wi); |
2196 | RTYPE("cyl1-up", ir->swap->cyl1u, 1.0)ir->swap->cyl1u = get_ereal(&ninp, &inp, "cyl1-up" , 1.0, wi); |
2197 | RTYPE("cyl1-down", ir->swap->cyl1l, 1.0)ir->swap->cyl1l = get_ereal(&ninp, &inp, "cyl1-down" , 1.0, wi); |
2198 | |
2199 | CTYPE("Average the number of ions per compartment over these many swap attempt steps"); |
2200 | ITYPE("coupl-steps", ir->swap->nAverage, 10)ir->swap->nAverage = get_eint(&ninp, &inp, "coupl-steps" , 10, wi); |
2201 | CTYPE("Requested number of anions and cations for each of the two compartments"); |
2202 | CTYPE("-1 means fix the numbers as found in time step 0"); |
2203 | ITYPE("anionsA", ir->swap->nanions[0], -1)ir->swap->nanions[0] = get_eint(&ninp, &inp, "anionsA" , -1, wi); |
2204 | ITYPE("cationsA", ir->swap->ncations[0], -1)ir->swap->ncations[0] = get_eint(&ninp, &inp, "cationsA" , -1, wi); |
2205 | ITYPE("anionsB", ir->swap->nanions[1], -1)ir->swap->nanions[1] = get_eint(&ninp, &inp, "anionsB" , -1, wi); |
2206 | ITYPE("cationsB", ir->swap->ncations[1], -1)ir->swap->ncations[1] = get_eint(&ninp, &inp, "cationsB" , -1, wi); |
2207 | CTYPE("Start to swap ions if threshold difference to requested count is reached"); |
2208 | RTYPE("threshold", ir->swap->threshold, 1.0)ir->swap->threshold = get_ereal(&ninp, &inp, "threshold" , 1.0, wi); |
2209 | } |
2210 | |
2211 | /* AdResS defined thingies */ |
2212 | CCTYPE ("AdResS parameters")get_estr(&ninp, &inp, "\n; " "AdResS parameters", ((void *)0)); |
2213 | EETYPE("adress", ir->bAdress, yesno_names)ir->bAdress = get_eeenum(&ninp, &inp, "adress", yesno_names , wi); |
2214 | if (ir->bAdress) |
2215 | { |
2216 | snew(ir->adress, 1)(ir->adress) = save_calloc("ir->adress", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2216, (1), sizeof(*(ir->adress))); |
2217 | read_adressparams(&ninp, &inp, ir->adress, wi); |
2218 | } |
2219 | |
2220 | /* User defined thingies */ |
2221 | CCTYPE ("User defined thingies")get_estr(&ninp, &inp, "\n; " "User defined thingies", ((void*)0)); |
2222 | STYPE ("user1-grps", is->user1, NULL)if ((tmp = get_estr(&ninp, &inp, "user1-grps", ((void *)0))) != ((void*)0)) strcpy(is->user1, tmp); |
2223 | STYPE ("user2-grps", is->user2, NULL)if ((tmp = get_estr(&ninp, &inp, "user2-grps", ((void *)0))) != ((void*)0)) strcpy(is->user2, tmp); |
2224 | ITYPE ("userint1", ir->userint1, 0)ir->userint1 = get_eint(&ninp, &inp, "userint1", 0 , wi); |
2225 | ITYPE ("userint2", ir->userint2, 0)ir->userint2 = get_eint(&ninp, &inp, "userint2", 0 , wi); |
2226 | ITYPE ("userint3", ir->userint3, 0)ir->userint3 = get_eint(&ninp, &inp, "userint3", 0 , wi); |
2227 | ITYPE ("userint4", ir->userint4, 0)ir->userint4 = get_eint(&ninp, &inp, "userint4", 0 , wi); |
2228 | RTYPE ("userreal1", ir->userreal1, 0)ir->userreal1 = get_ereal(&ninp, &inp, "userreal1" , 0, wi); |
2229 | RTYPE ("userreal2", ir->userreal2, 0)ir->userreal2 = get_ereal(&ninp, &inp, "userreal2" , 0, wi); |
2230 | RTYPE ("userreal3", ir->userreal3, 0)ir->userreal3 = get_ereal(&ninp, &inp, "userreal3" , 0, wi); |
2231 | RTYPE ("userreal4", ir->userreal4, 0)ir->userreal4 = get_ereal(&ninp, &inp, "userreal4" , 0, wi); |
2232 | #undef CTYPE |
2233 | |
2234 | write_inpfile(mdparout, ninp, inp, FALSE0, wi); |
2235 | for (i = 0; (i < ninp); i++) |
2236 | { |
2237 | sfree(inp[i].name)save_free("inp[i].name", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2237, (inp[i].name)); |
2238 | sfree(inp[i].value)save_free("inp[i].value", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2238, (inp[i].value)); |
2239 | } |
2240 | sfree(inp)save_free("inp", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2240, (inp)); |
2241 | |
2242 | /* Process options if necessary */ |
2243 | for (m = 0; m < 2; m++) |
2244 | { |
2245 | for (i = 0; i < 2*DIM3; i++) |
2246 | { |
2247 | dumdub[m][i] = 0.0; |
2248 | } |
2249 | if (ir->epc) |
2250 | { |
2251 | switch (ir->epct) |
2252 | { |
2253 | case epctISOTROPIC: |
2254 | if (sscanf(dumstr[m], "%lf", &(dumdub[m][XX0])) != 1) |
2255 | { |
2256 | warning_error(wi, "Pressure coupling not enough values (I need 1)"); |
2257 | } |
2258 | dumdub[m][YY1] = dumdub[m][ZZ2] = dumdub[m][XX0]; |
2259 | break; |
2260 | case epctSEMIISOTROPIC: |
2261 | case epctSURFACETENSION: |
2262 | if (sscanf(dumstr[m], "%lf%lf", |
2263 | &(dumdub[m][XX0]), &(dumdub[m][ZZ2])) != 2) |
2264 | { |
2265 | warning_error(wi, "Pressure coupling not enough values (I need 2)"); |
2266 | } |
2267 | dumdub[m][YY1] = dumdub[m][XX0]; |
2268 | break; |
2269 | case epctANISOTROPIC: |
2270 | if (sscanf(dumstr[m], "%lf%lf%lf%lf%lf%lf", |
2271 | &(dumdub[m][XX0]), &(dumdub[m][YY1]), &(dumdub[m][ZZ2]), |
2272 | &(dumdub[m][3]), &(dumdub[m][4]), &(dumdub[m][5])) != 6) |
2273 | { |
2274 | warning_error(wi, "Pressure coupling not enough values (I need 6)"); |
2275 | } |
2276 | break; |
2277 | default: |
2278 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2278, "Pressure coupling type %s not implemented yet", |
2279 | epcoupltype_names[ir->epct]); |
2280 | } |
2281 | } |
2282 | } |
2283 | clear_mat(ir->ref_p); |
2284 | clear_mat(ir->compress); |
2285 | for (i = 0; i < DIM3; i++) |
2286 | { |
2287 | ir->ref_p[i][i] = dumdub[1][i]; |
2288 | ir->compress[i][i] = dumdub[0][i]; |
2289 | } |
2290 | if (ir->epct == epctANISOTROPIC) |
2291 | { |
2292 | ir->ref_p[XX0][YY1] = dumdub[1][3]; |
2293 | ir->ref_p[XX0][ZZ2] = dumdub[1][4]; |
2294 | ir->ref_p[YY1][ZZ2] = dumdub[1][5]; |
2295 | if (ir->ref_p[XX0][YY1] != 0 && ir->ref_p[XX0][ZZ2] != 0 && ir->ref_p[YY1][ZZ2] != 0) |
2296 | { |
2297 | warning(wi, "All off-diagonal reference pressures are non-zero. Are you sure you want to apply a threefold shear stress?\n"); |
2298 | } |
2299 | ir->compress[XX0][YY1] = dumdub[0][3]; |
2300 | ir->compress[XX0][ZZ2] = dumdub[0][4]; |
2301 | ir->compress[YY1][ZZ2] = dumdub[0][5]; |
2302 | for (i = 0; i < DIM3; i++) |
2303 | { |
2304 | for (m = 0; m < i; m++) |
2305 | { |
2306 | ir->ref_p[i][m] = ir->ref_p[m][i]; |
2307 | ir->compress[i][m] = ir->compress[m][i]; |
2308 | } |
2309 | } |
2310 | } |
2311 | |
2312 | if (ir->comm_mode == ecmNO) |
2313 | { |
2314 | ir->nstcomm = 0; |
2315 | } |
2316 | |
2317 | opts->couple_moltype = NULL((void*)0); |
2318 | if (strlen(is->couple_moltype) > 0) |
2319 | { |
2320 | if (ir->efep != efepNO) |
2321 | { |
2322 | opts->couple_moltype = strdup(is->couple_moltype)(__extension__ (__builtin_constant_p (is->couple_moltype) && ((size_t)(const void *)((is->couple_moltype) + 1) - (size_t )(const void *)(is->couple_moltype) == 1) ? (((const char * ) (is->couple_moltype))[0] == '\0' ? (char *) calloc ((size_t ) 1, (size_t) 1) : ({ size_t __len = strlen (is->couple_moltype ) + 1; char *__retval = (char *) malloc (__len); if (__retval != ((void*)0)) __retval = (char *) memcpy (__retval, is-> couple_moltype, __len); __retval; })) : __strdup (is->couple_moltype ))); |
2323 | if (opts->couple_lam0 == opts->couple_lam1) |
2324 | { |
2325 | warning(wi, "The lambda=0 and lambda=1 states for coupling are identical"); |
2326 | } |
2327 | if (ir->eI == eiMD && (opts->couple_lam0 == ecouplamNONE || |
2328 | opts->couple_lam1 == ecouplamNONE)) |
2329 | { |
2330 | warning(wi, "For proper sampling of the (nearly) decoupled state, stochastic dynamics should be used"); |
2331 | } |
2332 | } |
2333 | else |
2334 | { |
2335 | warning(wi, "Can not couple a molecule with free_energy = no"); |
2336 | } |
2337 | } |
2338 | /* FREE ENERGY AND EXPANDED ENSEMBLE OPTIONS */ |
2339 | if (ir->efep != efepNO) |
2340 | { |
2341 | if (fep->delta_lambda > 0) |
2342 | { |
2343 | ir->efep = efepSLOWGROWTH; |
2344 | } |
2345 | } |
2346 | |
2347 | if (ir->bSimTemp) |
2348 | { |
2349 | fep->bPrintEnergy = TRUE1; |
2350 | /* always print out the energy to dhdl if we are doing expanded ensemble, since we need the total energy |
2351 | if the temperature is changing. */ |
2352 | } |
2353 | |
2354 | if ((ir->efep != efepNO) || ir->bSimTemp) |
2355 | { |
2356 | ir->bExpanded = FALSE0; |
2357 | if ((ir->efep == efepEXPANDED) || ir->bSimTemp) |
2358 | { |
2359 | ir->bExpanded = TRUE1; |
2360 | } |
2361 | do_fep_params(ir, is->fep_lambda, is->lambda_weights); |
2362 | if (ir->bSimTemp) /* done after fep params */ |
2363 | { |
2364 | do_simtemp_params(ir); |
2365 | } |
2366 | } |
2367 | else |
2368 | { |
2369 | ir->fepvals->n_lambda = 0; |
2370 | } |
2371 | |
2372 | /* WALL PARAMETERS */ |
2373 | |
2374 | do_wall_params(ir, is->wall_atomtype, is->wall_density, opts); |
2375 | |
2376 | /* ORIENTATION RESTRAINT PARAMETERS */ |
2377 | |
2378 | if (opts->bOrire && str_nelem(is->orirefitgrp, MAXPTR254, NULL((void*)0)) != 1) |
2379 | { |
2380 | warning_error(wi, "ERROR: Need one orientation restraint fit group\n"); |
2381 | } |
2382 | |
2383 | /* DEFORMATION PARAMETERS */ |
2384 | |
2385 | clear_mat(ir->deform); |
2386 | for (i = 0; i < 6; i++) |
2387 | { |
2388 | dumdub[0][i] = 0; |
2389 | } |
2390 | m = sscanf(is->deform, "%lf %lf %lf %lf %lf %lf", |
2391 | &(dumdub[0][0]), &(dumdub[0][1]), &(dumdub[0][2]), |
2392 | &(dumdub[0][3]), &(dumdub[0][4]), &(dumdub[0][5])); |
2393 | for (i = 0; i < 3; i++) |
2394 | { |
2395 | ir->deform[i][i] = dumdub[0][i]; |
2396 | } |
2397 | ir->deform[YY1][XX0] = dumdub[0][3]; |
2398 | ir->deform[ZZ2][XX0] = dumdub[0][4]; |
2399 | ir->deform[ZZ2][YY1] = dumdub[0][5]; |
2400 | if (ir->epc != epcNO) |
2401 | { |
2402 | for (i = 0; i < 3; i++) |
2403 | { |
2404 | for (j = 0; j <= i; j++) |
2405 | { |
2406 | if (ir->deform[i][j] != 0 && ir->compress[i][j] != 0) |
2407 | { |
2408 | warning_error(wi, "A box element has deform set and compressibility > 0"); |
2409 | } |
2410 | } |
2411 | } |
2412 | for (i = 0; i < 3; i++) |
2413 | { |
2414 | for (j = 0; j < i; j++) |
2415 | { |
2416 | if (ir->deform[i][j] != 0) |
2417 | { |
2418 | for (m = j; m < DIM3; m++) |
2419 | { |
2420 | if (ir->compress[m][j] != 0) |
2421 | { |
2422 | sprintf(warn_buf, "An off-diagonal box element has deform set while compressibility > 0 for the same component of another box vector, this might lead to spurious periodicity effects."); |
2423 | warning(wi, warn_buf); |
2424 | } |
2425 | } |
2426 | } |
2427 | } |
2428 | } |
2429 | } |
2430 | |
2431 | /* Ion/water position swapping checks */ |
2432 | if (ir->eSwapCoords != eswapNO) |
2433 | { |
2434 | if (ir->swap->nstswap < 1) |
2435 | { |
2436 | warning_error(wi, "swap_frequency must be 1 or larger when ion swapping is requested"); |
2437 | } |
2438 | if (ir->swap->nAverage < 1) |
2439 | { |
2440 | warning_error(wi, "coupl_steps must be 1 or larger.\n"); |
2441 | } |
2442 | if (ir->swap->threshold < 1.0) |
2443 | { |
2444 | warning_error(wi, "Ion count threshold must be at least 1.\n"); |
2445 | } |
2446 | } |
2447 | |
2448 | sfree(dumstr[0])save_free("dumstr[0]", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2448, (dumstr[0])); |
2449 | sfree(dumstr[1])save_free("dumstr[1]", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2449, (dumstr[1])); |
2450 | } |
2451 | |
2452 | static int search_QMstring(const char *s, int ng, const char *gn[]) |
2453 | { |
2454 | /* same as normal search_string, but this one searches QM strings */ |
2455 | int i; |
2456 | |
2457 | for (i = 0; (i < ng); i++) |
2458 | { |
2459 | if (gmx_strcasecmp(s, gn[i]) == 0) |
2460 | { |
2461 | return i; |
2462 | } |
2463 | } |
2464 | |
2465 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2465, "this QM method or basisset (%s) is not implemented\n!", s); |
2466 | |
2467 | return -1; |
2468 | |
2469 | } /* search_QMstring */ |
2470 | |
2471 | /* We would like gn to be const as well, but C doesn't allow this */ |
2472 | int search_string(const char *s, int ng, char *gn[]) |
2473 | { |
2474 | int i; |
2475 | |
2476 | for (i = 0; (i < ng); i++) |
2477 | { |
2478 | if (gmx_strcasecmp(s, gn[i]) == 0) |
2479 | { |
2480 | return i; |
2481 | } |
2482 | } |
2483 | |
2484 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2484, |
2485 | "Group %s referenced in the .mdp file was not found in the index file.\n" |
2486 | "Group names must match either [moleculetype] names or custom index group\n" |
2487 | "names, in which case you must supply an index file to the '-n' option\n" |
2488 | "of grompp.", |
2489 | s); |
2490 | |
2491 | return -1; |
2492 | } |
2493 | |
2494 | static gmx_bool do_numbering(int natoms, gmx_groups_t *groups, int ng, char *ptrs[], |
2495 | t_blocka *block, char *gnames[], |
2496 | int gtype, int restnm, |
2497 | int grptp, gmx_bool bVerbose, |
2498 | warninp_t wi) |
2499 | { |
2500 | unsigned short *cbuf; |
2501 | t_grps *grps = &(groups->grps[gtype]); |
2502 | int i, j, gid, aj, ognr, ntot = 0; |
2503 | const char *title; |
2504 | gmx_bool bRest; |
2505 | char warn_buf[STRLEN4096]; |
2506 | |
2507 | if (debug) |
2508 | { |
2509 | fprintf(debug, "Starting numbering %d groups of type %d\n", ng, gtype); |
2510 | } |
2511 | |
2512 | title = gtypes[gtype]; |
2513 | |
2514 | snew(cbuf, natoms)(cbuf) = save_calloc("cbuf", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2514, (natoms), sizeof(*(cbuf))); |
2515 | /* Mark all id's as not set */ |
2516 | for (i = 0; (i < natoms); i++) |
2517 | { |
2518 | cbuf[i] = NOGID255; |
2519 | } |
2520 | |
2521 | snew(grps->nm_ind, ng+1)(grps->nm_ind) = save_calloc("grps->nm_ind", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2521, (ng+1), sizeof(*(grps->nm_ind))); /* +1 for possible rest group */ |
2522 | for (i = 0; (i < ng); i++) |
2523 | { |
2524 | /* Lookup the group name in the block structure */ |
2525 | gid = search_string(ptrs[i], block->nr, gnames); |
2526 | if ((grptp != egrptpONE) || (i == 0)) |
2527 | { |
2528 | grps->nm_ind[grps->nr++] = gid; |
2529 | } |
2530 | if (debug) |
2531 | { |
2532 | fprintf(debug, "Found gid %d for group %s\n", gid, ptrs[i]); |
2533 | } |
2534 | |
2535 | /* Now go over the atoms in the group */ |
2536 | for (j = block->index[gid]; (j < block->index[gid+1]); j++) |
2537 | { |
2538 | |
2539 | aj = block->a[j]; |
2540 | |
2541 | /* Range checking */ |
2542 | if ((aj < 0) || (aj >= natoms)) |
2543 | { |
2544 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2544, "Invalid atom number %d in indexfile", aj); |
2545 | } |
2546 | /* Lookup up the old group number */ |
2547 | ognr = cbuf[aj]; |
2548 | if (ognr != NOGID255) |
2549 | { |
2550 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2550, "Atom %d in multiple %s groups (%d and %d)", |
2551 | aj+1, title, ognr+1, i+1); |
2552 | } |
2553 | else |
2554 | { |
2555 | /* Store the group number in buffer */ |
2556 | if (grptp == egrptpONE) |
2557 | { |
2558 | cbuf[aj] = 0; |
2559 | } |
2560 | else |
2561 | { |
2562 | cbuf[aj] = i; |
2563 | } |
2564 | ntot++; |
2565 | } |
2566 | } |
2567 | } |
2568 | |
2569 | /* Now check whether we have done all atoms */ |
2570 | bRest = FALSE0; |
2571 | if (ntot != natoms) |
2572 | { |
2573 | if (grptp == egrptpALL) |
2574 | { |
2575 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2575, "%d atoms are not part of any of the %s groups", |
2576 | natoms-ntot, title); |
2577 | } |
2578 | else if (grptp == egrptpPART) |
2579 | { |
2580 | sprintf(warn_buf, "%d atoms are not part of any of the %s groups", |
2581 | natoms-ntot, title); |
2582 | warning_note(wi, warn_buf); |
2583 | } |
2584 | /* Assign all atoms currently unassigned to a rest group */ |
2585 | for (j = 0; (j < natoms); j++) |
2586 | { |
2587 | if (cbuf[j] == NOGID255) |
2588 | { |
2589 | cbuf[j] = grps->nr; |
2590 | bRest = TRUE1; |
2591 | } |
2592 | } |
2593 | if (grptp != egrptpPART) |
2594 | { |
2595 | if (bVerbose) |
2596 | { |
2597 | fprintf(stderrstderr, |
2598 | "Making dummy/rest group for %s containing %d elements\n", |
2599 | title, natoms-ntot); |
2600 | } |
2601 | /* Add group name "rest" */ |
2602 | grps->nm_ind[grps->nr] = restnm; |
2603 | |
2604 | /* Assign the rest name to all atoms not currently assigned to a group */ |
2605 | for (j = 0; (j < natoms); j++) |
2606 | { |
2607 | if (cbuf[j] == NOGID255) |
2608 | { |
2609 | cbuf[j] = grps->nr; |
2610 | } |
2611 | } |
2612 | grps->nr++; |
2613 | } |
2614 | } |
2615 | |
2616 | if (grps->nr == 1 && (ntot == 0 || ntot == natoms)) |
2617 | { |
2618 | /* All atoms are part of one (or no) group, no index required */ |
2619 | groups->ngrpnr[gtype] = 0; |
2620 | groups->grpnr[gtype] = NULL((void*)0); |
2621 | } |
2622 | else |
2623 | { |
2624 | groups->ngrpnr[gtype] = natoms; |
2625 | snew(groups->grpnr[gtype], natoms)(groups->grpnr[gtype]) = save_calloc("groups->grpnr[gtype]" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2625, (natoms), sizeof(*(groups->grpnr[gtype]))); |
2626 | for (j = 0; (j < natoms); j++) |
2627 | { |
2628 | groups->grpnr[gtype][j] = cbuf[j]; |
2629 | } |
2630 | } |
2631 | |
2632 | sfree(cbuf)save_free("cbuf", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2632, (cbuf)); |
2633 | |
2634 | return (bRest && grptp == egrptpPART); |
2635 | } |
2636 | |
2637 | static void calc_nrdf(gmx_mtop_t *mtop, t_inputrec *ir, char **gnames) |
2638 | { |
2639 | t_grpopts *opts; |
2640 | gmx_groups_t *groups; |
2641 | t_pull *pull; |
2642 | int natoms, ai, aj, i, j, d, g, imin, jmin; |
2643 | t_iatom *ia; |
2644 | int *nrdf2, *na_vcm, na_tot; |
2645 | double *nrdf_tc, *nrdf_vcm, nrdf_uc, n_sub = 0; |
2646 | gmx_mtop_atomloop_all_t aloop; |
2647 | t_atom *atom; |
2648 | int mb, mol, ftype, as; |
2649 | gmx_molblock_t *molb; |
2650 | gmx_moltype_t *molt; |
2651 | |
2652 | /* Calculate nrdf. |
2653 | * First calc 3xnr-atoms for each group |
2654 | * then subtract half a degree of freedom for each constraint |
2655 | * |
2656 | * Only atoms and nuclei contribute to the degrees of freedom... |
2657 | */ |
2658 | |
2659 | opts = &ir->opts; |
2660 | |
2661 | groups = &mtop->groups; |
2662 | natoms = mtop->natoms; |
2663 | |
2664 | /* Allocate one more for a possible rest group */ |
2665 | /* We need to sum degrees of freedom into doubles, |
2666 | * since floats give too low nrdf's above 3 million atoms. |
2667 | */ |
2668 | snew(nrdf_tc, groups->grps[egcTC].nr+1)(nrdf_tc) = save_calloc("nrdf_tc", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2668, (groups->grps[egcTC].nr+1), sizeof(*(nrdf_tc))); |
2669 | snew(nrdf_vcm, groups->grps[egcVCM].nr+1)(nrdf_vcm) = save_calloc("nrdf_vcm", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2669, (groups->grps[egcVCM].nr+1), sizeof(*(nrdf_vcm))); |
2670 | snew(na_vcm, groups->grps[egcVCM].nr+1)(na_vcm) = save_calloc("na_vcm", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2670, (groups->grps[egcVCM].nr+1), sizeof(*(na_vcm))); |
2671 | |
2672 | for (i = 0; i < groups->grps[egcTC].nr; i++) |
2673 | { |
2674 | nrdf_tc[i] = 0; |
2675 | } |
2676 | for (i = 0; i < groups->grps[egcVCM].nr+1; i++) |
2677 | { |
2678 | nrdf_vcm[i] = 0; |
2679 | } |
2680 | |
2681 | snew(nrdf2, natoms)(nrdf2) = save_calloc("nrdf2", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2681, (natoms), sizeof(*(nrdf2))); |
2682 | aloop = gmx_mtop_atomloop_all_init(mtop); |
2683 | while (gmx_mtop_atomloop_all_next(aloop, &i, &atom)) |
2684 | { |
2685 | nrdf2[i] = 0; |
2686 | if (atom->ptype == eptAtom || atom->ptype == eptNucleus) |
2687 | { |
2688 | g = ggrpnr(groups, egcFREEZE, i)((groups)->grpnr[egcFREEZE] ? (groups)->grpnr[egcFREEZE ][i] : 0); |
2689 | /* Double count nrdf for particle i */ |
2690 | for (d = 0; d < DIM3; d++) |
2691 | { |
2692 | if (opts->nFreeze[g][d] == 0) |
2693 | { |
2694 | nrdf2[i] += 2; |
2695 | } |
2696 | } |
2697 | nrdf_tc [ggrpnr(groups, egcTC, i)((groups)->grpnr[egcTC] ? (groups)->grpnr[egcTC][i] : 0 )] += 0.5*nrdf2[i]; |
2698 | nrdf_vcm[ggrpnr(groups, egcVCM, i)((groups)->grpnr[egcVCM] ? (groups)->grpnr[egcVCM][i] : 0)] += 0.5*nrdf2[i]; |
2699 | } |
2700 | } |
2701 | |
2702 | as = 0; |
2703 | for (mb = 0; mb < mtop->nmolblock; mb++) |
2704 | { |
2705 | molb = &mtop->molblock[mb]; |
2706 | molt = &mtop->moltype[molb->type]; |
2707 | atom = molt->atoms.atom; |
2708 | for (mol = 0; mol < molb->nmol; mol++) |
2709 | { |
2710 | for (ftype = F_CONSTR; ftype <= F_CONSTRNC; ftype++) |
2711 | { |
2712 | ia = molt->ilist[ftype].iatoms; |
2713 | for (i = 0; i < molt->ilist[ftype].nr; ) |
2714 | { |
2715 | /* Subtract degrees of freedom for the constraints, |
2716 | * if the particles still have degrees of freedom left. |
2717 | * If one of the particles is a vsite or a shell, then all |
2718 | * constraint motion will go there, but since they do not |
2719 | * contribute to the constraints the degrees of freedom do not |
2720 | * change. |
2721 | */ |
2722 | ai = as + ia[1]; |
2723 | aj = as + ia[2]; |
2724 | if (((atom[ia[1]].ptype == eptNucleus) || |
2725 | (atom[ia[1]].ptype == eptAtom)) && |
2726 | ((atom[ia[2]].ptype == eptNucleus) || |
2727 | (atom[ia[2]].ptype == eptAtom))) |
2728 | { |
2729 | if (nrdf2[ai] > 0) |
2730 | { |
2731 | jmin = 1; |
2732 | } |
2733 | else |
2734 | { |
2735 | jmin = 2; |
2736 | } |
2737 | if (nrdf2[aj] > 0) |
2738 | { |
2739 | imin = 1; |
2740 | } |
2741 | else |
2742 | { |
2743 | imin = 2; |
2744 | } |
2745 | imin = min(imin, nrdf2[ai])(((imin) < (nrdf2[ai])) ? (imin) : (nrdf2[ai]) ); |
2746 | jmin = min(jmin, nrdf2[aj])(((jmin) < (nrdf2[aj])) ? (jmin) : (nrdf2[aj]) ); |
2747 | nrdf2[ai] -= imin; |
2748 | nrdf2[aj] -= jmin; |
2749 | nrdf_tc [ggrpnr(groups, egcTC, ai)((groups)->grpnr[egcTC] ? (groups)->grpnr[egcTC][ai] : 0 )] -= 0.5*imin; |
2750 | nrdf_tc [ggrpnr(groups, egcTC, aj)((groups)->grpnr[egcTC] ? (groups)->grpnr[egcTC][aj] : 0 )] -= 0.5*jmin; |
2751 | nrdf_vcm[ggrpnr(groups, egcVCM, ai)((groups)->grpnr[egcVCM] ? (groups)->grpnr[egcVCM][ai] : 0)] -= 0.5*imin; |
2752 | nrdf_vcm[ggrpnr(groups, egcVCM, aj)((groups)->grpnr[egcVCM] ? (groups)->grpnr[egcVCM][aj] : 0)] -= 0.5*jmin; |
2753 | } |
2754 | ia += interaction_function[ftype].nratoms+1; |
2755 | i += interaction_function[ftype].nratoms+1; |
2756 | } |
2757 | } |
2758 | ia = molt->ilist[F_SETTLE].iatoms; |
2759 | for (i = 0; i < molt->ilist[F_SETTLE].nr; ) |
2760 | { |
2761 | /* Subtract 1 dof from every atom in the SETTLE */ |
2762 | for (j = 0; j < 3; j++) |
2763 | { |
2764 | ai = as + ia[1+j]; |
2765 | imin = min(2, nrdf2[ai])(((2) < (nrdf2[ai])) ? (2) : (nrdf2[ai]) ); |
2766 | nrdf2[ai] -= imin; |
2767 | nrdf_tc [ggrpnr(groups, egcTC, ai)((groups)->grpnr[egcTC] ? (groups)->grpnr[egcTC][ai] : 0 )] -= 0.5*imin; |
2768 | nrdf_vcm[ggrpnr(groups, egcVCM, ai)((groups)->grpnr[egcVCM] ? (groups)->grpnr[egcVCM][ai] : 0)] -= 0.5*imin; |
2769 | } |
2770 | ia += 4; |
2771 | i += 4; |
2772 | } |
2773 | as += molt->atoms.nr; |
2774 | } |
2775 | } |
2776 | |
2777 | if (ir->ePull == epullCONSTRAINT) |
2778 | { |
2779 | /* Correct nrdf for the COM constraints. |
2780 | * We correct using the TC and VCM group of the first atom |
2781 | * in the reference and pull group. If atoms in one pull group |
2782 | * belong to different TC or VCM groups it is anyhow difficult |
2783 | * to determine the optimal nrdf assignment. |
2784 | */ |
2785 | pull = ir->pull; |
2786 | |
2787 | for (i = 0; i < pull->ncoord; i++) |
2788 | { |
2789 | imin = 1; |
2790 | |
2791 | for (j = 0; j < 2; j++) |
2792 | { |
2793 | const t_pull_group *pgrp; |
2794 | |
2795 | pgrp = &pull->group[pull->coord[i].group[j]]; |
2796 | |
2797 | if (pgrp->nat > 0) |
2798 | { |
2799 | /* Subtract 1/2 dof from each group */ |
2800 | ai = pgrp->ind[0]; |
2801 | nrdf_tc [ggrpnr(groups, egcTC, ai)((groups)->grpnr[egcTC] ? (groups)->grpnr[egcTC][ai] : 0 )] -= 0.5*imin; |
2802 | nrdf_vcm[ggrpnr(groups, egcVCM, ai)((groups)->grpnr[egcVCM] ? (groups)->grpnr[egcVCM][ai] : 0)] -= 0.5*imin; |
2803 | if (nrdf_tc[ggrpnr(groups, egcTC, ai)((groups)->grpnr[egcTC] ? (groups)->grpnr[egcTC][ai] : 0 )] < 0) |
2804 | { |
2805 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2805, "Center of mass pulling constraints caused the number of degrees of freedom for temperature coupling group %s to be negative", gnames[groups->grps[egcTC].nm_ind[ggrpnr(groups, egcTC, ai)((groups)->grpnr[egcTC] ? (groups)->grpnr[egcTC][ai] : 0 )]]); |
2806 | } |
2807 | } |
2808 | else |
2809 | { |
2810 | /* We need to subtract the whole DOF from group j=1 */ |
2811 | imin += 1; |
2812 | } |
2813 | } |
2814 | } |
2815 | } |
2816 | |
2817 | if (ir->nstcomm != 0) |
2818 | { |
2819 | /* Subtract 3 from the number of degrees of freedom in each vcm group |
2820 | * when com translation is removed and 6 when rotation is removed |
2821 | * as well. |
2822 | */ |
2823 | switch (ir->comm_mode) |
2824 | { |
2825 | case ecmLINEAR: |
2826 | n_sub = ndof_com(ir); |
2827 | break; |
2828 | case ecmANGULAR: |
2829 | n_sub = 6; |
2830 | break; |
2831 | default: |
2832 | n_sub = 0; |
2833 | gmx_incons("Checking comm_mode")_gmx_error("incons", "Checking comm_mode", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2833); |
2834 | } |
2835 | |
2836 | for (i = 0; i < groups->grps[egcTC].nr; i++) |
2837 | { |
2838 | /* Count the number of atoms of TC group i for every VCM group */ |
2839 | for (j = 0; j < groups->grps[egcVCM].nr+1; j++) |
2840 | { |
2841 | na_vcm[j] = 0; |
2842 | } |
2843 | na_tot = 0; |
2844 | for (ai = 0; ai < natoms; ai++) |
2845 | { |
2846 | if (ggrpnr(groups, egcTC, ai)((groups)->grpnr[egcTC] ? (groups)->grpnr[egcTC][ai] : 0 ) == i) |
2847 | { |
2848 | na_vcm[ggrpnr(groups, egcVCM, ai)((groups)->grpnr[egcVCM] ? (groups)->grpnr[egcVCM][ai] : 0)]++; |
2849 | na_tot++; |
2850 | } |
2851 | } |
2852 | /* Correct for VCM removal according to the fraction of each VCM |
2853 | * group present in this TC group. |
2854 | */ |
2855 | nrdf_uc = nrdf_tc[i]; |
2856 | if (debug) |
2857 | { |
2858 | fprintf(debug, "T-group[%d] nrdf_uc = %g, n_sub = %g\n", |
2859 | i, nrdf_uc, n_sub); |
2860 | } |
2861 | nrdf_tc[i] = 0; |
2862 | for (j = 0; j < groups->grps[egcVCM].nr+1; j++) |
2863 | { |
2864 | if (nrdf_vcm[j] > n_sub) |
2865 | { |
2866 | nrdf_tc[i] += nrdf_uc*((double)na_vcm[j]/(double)na_tot)* |
2867 | (nrdf_vcm[j] - n_sub)/nrdf_vcm[j]; |
2868 | } |
2869 | if (debug) |
2870 | { |
2871 | fprintf(debug, " nrdf_vcm[%d] = %g, nrdf = %g\n", |
2872 | j, nrdf_vcm[j], nrdf_tc[i]); |
2873 | } |
2874 | } |
2875 | } |
2876 | } |
2877 | for (i = 0; (i < groups->grps[egcTC].nr); i++) |
2878 | { |
2879 | opts->nrdf[i] = nrdf_tc[i]; |
2880 | if (opts->nrdf[i] < 0) |
2881 | { |
2882 | opts->nrdf[i] = 0; |
2883 | } |
2884 | fprintf(stderrstderr, |
2885 | "Number of degrees of freedom in T-Coupling group %s is %.2f\n", |
2886 | gnames[groups->grps[egcTC].nm_ind[i]], opts->nrdf[i]); |
2887 | } |
2888 | |
2889 | sfree(nrdf2)save_free("nrdf2", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2889, (nrdf2)); |
2890 | sfree(nrdf_tc)save_free("nrdf_tc", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2890, (nrdf_tc)); |
2891 | sfree(nrdf_vcm)save_free("nrdf_vcm", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2891, (nrdf_vcm)); |
2892 | sfree(na_vcm)save_free("na_vcm", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2892, (na_vcm)); |
2893 | } |
2894 | |
2895 | static void decode_cos(char *s, t_cosines *cosine) |
2896 | { |
2897 | char *t; |
2898 | char format[STRLEN4096], f1[STRLEN4096]; |
2899 | double a, phi; |
2900 | int i; |
2901 | |
2902 | t = strdup(s)(__extension__ (__builtin_constant_p (s) && ((size_t) (const void *)((s) + 1) - (size_t)(const void *)(s) == 1) ? ( ((const char *) (s))[0] == '\0' ? (char *) calloc ((size_t) 1 , (size_t) 1) : ({ size_t __len = strlen (s) + 1; char *__retval = (char *) malloc (__len); if (__retval != ((void*)0)) __retval = (char *) memcpy (__retval, s, __len); __retval; })) : __strdup (s))); |
2903 | trim(t); |
2904 | |
2905 | cosine->n = 0; |
2906 | cosine->a = NULL((void*)0); |
2907 | cosine->phi = NULL((void*)0); |
2908 | if (strlen(t)) |
2909 | { |
2910 | sscanf(t, "%d", &(cosine->n)); |
2911 | if (cosine->n <= 0) |
2912 | { |
2913 | cosine->n = 0; |
2914 | } |
2915 | else |
2916 | { |
2917 | snew(cosine->a, cosine->n)(cosine->a) = save_calloc("cosine->a", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2917, (cosine->n), sizeof(*(cosine->a))); |
2918 | snew(cosine->phi, cosine->n)(cosine->phi) = save_calloc("cosine->phi", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2918, (cosine->n), sizeof(*(cosine->phi))); |
2919 | |
2920 | sprintf(format, "%%*d"); |
2921 | for (i = 0; (i < cosine->n); i++) |
2922 | { |
2923 | strcpy(f1, format); |
2924 | strcat(f1, "%lf%lf"); |
2925 | if (sscanf(t, f1, &a, &phi) < 2) |
2926 | { |
2927 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2927, "Invalid input for electric field shift: '%s'", t); |
2928 | } |
2929 | cosine->a[i] = a; |
2930 | cosine->phi[i] = phi; |
2931 | strcat(format, "%*lf%*lf"); |
2932 | } |
2933 | } |
2934 | } |
2935 | sfree(t)save_free("t", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2935, (t)); |
2936 | } |
2937 | |
2938 | static gmx_bool do_egp_flag(t_inputrec *ir, gmx_groups_t *groups, |
2939 | const char *option, const char *val, int flag) |
2940 | { |
2941 | /* The maximum number of energy group pairs would be MAXPTR*(MAXPTR+1)/2. |
2942 | * But since this is much larger than STRLEN, such a line can not be parsed. |
2943 | * The real maximum is the number of names that fit in a string: STRLEN/2. |
2944 | */ |
2945 | #define EGP_MAX(4096/2) (STRLEN4096/2) |
2946 | int nelem, i, j, k, nr; |
2947 | char *names[EGP_MAX(4096/2)]; |
2948 | char ***gnames; |
2949 | gmx_bool bSet; |
2950 | |
2951 | gnames = groups->grpname; |
2952 | |
2953 | nelem = str_nelem(val, EGP_MAX(4096/2), names); |
2954 | if (nelem % 2 != 0) |
2955 | { |
2956 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2956, "The number of groups for %s is odd", option); |
2957 | } |
2958 | nr = groups->grps[egcENER].nr; |
2959 | bSet = FALSE0; |
2960 | for (i = 0; i < nelem/2; i++) |
2961 | { |
2962 | j = 0; |
2963 | while ((j < nr) && |
2964 | gmx_strcasecmp(names[2*i], *(gnames[groups->grps[egcENER].nm_ind[j]]))) |
2965 | { |
2966 | j++; |
2967 | } |
2968 | if (j == nr) |
2969 | { |
2970 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2970, "%s in %s is not an energy group\n", |
2971 | names[2*i], option); |
2972 | } |
2973 | k = 0; |
2974 | while ((k < nr) && |
2975 | gmx_strcasecmp(names[2*i+1], *(gnames[groups->grps[egcENER].nm_ind[k]]))) |
2976 | { |
2977 | k++; |
2978 | } |
2979 | if (k == nr) |
2980 | { |
2981 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 2981, "%s in %s is not an energy group\n", |
2982 | names[2*i+1], option); |
2983 | } |
2984 | if ((j < nr) && (k < nr)) |
2985 | { |
2986 | ir->opts.egp_flags[nr*j+k] |= flag; |
2987 | ir->opts.egp_flags[nr*k+j] |= flag; |
2988 | bSet = TRUE1; |
2989 | } |
2990 | } |
2991 | |
2992 | return bSet; |
2993 | } |
2994 | |
2995 | |
2996 | static void make_swap_groups( |
2997 | t_swapcoords *swap, |
2998 | char *swapgname, |
2999 | char *splitg0name, |
3000 | char *splitg1name, |
3001 | char *solgname, |
3002 | t_blocka *grps, |
3003 | char **gnames) |
3004 | { |
3005 | int ig = -1, i = 0, j; |
3006 | char *splitg; |
3007 | |
3008 | |
3009 | /* Just a quick check here, more thorough checks are in mdrun */ |
3010 | if (strcmp(splitg0name, splitg1name)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (splitg0name) && __builtin_constant_p (splitg1name) && (__s1_len = strlen (splitg0name), __s2_len = strlen (splitg1name ), (!((size_t)(const void *)((splitg0name) + 1) - (size_t)(const void *)(splitg0name) == 1) || __s1_len >= 4) && ( !((size_t)(const void *)((splitg1name) + 1) - (size_t)(const void *)(splitg1name) == 1) || __s2_len >= 4)) ? __builtin_strcmp (splitg0name, splitg1name) : (__builtin_constant_p (splitg0name ) && ((size_t)(const void *)((splitg0name) + 1) - (size_t )(const void *)(splitg0name) == 1) && (__s1_len = strlen (splitg0name), __s1_len < 4) ? (__builtin_constant_p (splitg1name ) && ((size_t)(const void *)((splitg1name) + 1) - (size_t )(const void *)(splitg1name) == 1) ? __builtin_strcmp (splitg0name , splitg1name) : (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (splitg1name); int __result = (((const unsigned char *) (const char *) (splitg0name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (splitg0name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (splitg0name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (splitg0name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (splitg1name ) && ((size_t)(const void *)((splitg1name) + 1) - (size_t )(const void *)(splitg1name) == 1) && (__s2_len = strlen (splitg1name), __s2_len < 4) ? (__builtin_constant_p (splitg0name ) && ((size_t)(const void *)((splitg0name) + 1) - (size_t )(const void *)(splitg0name) == 1) ? __builtin_strcmp (splitg0name , splitg1name) : (- (__extension__ ({ const unsigned char *__s2 = (const unsigned char *) (const char *) (splitg0name); int __result = (((const unsigned char *) (const char *) (splitg1name))[0] - __s2[0]); if (__s2_len > 0 && __result == 0) { __result = (((const unsigned char *) (const char *) (splitg1name))[1] - __s2[1]); if (__s2_len > 1 && __result == 0) { __result = (((const unsigned char *) (const char *) (splitg1name))[2] - __s2[2]); if (__s2_len > 2 && __result == 0) __result = (((const unsigned char *) (const char *) (splitg1name))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp (splitg0name , splitg1name)))); }) == 0) |
3011 | { |
3012 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3012, "The split groups can not both be '%s'.", splitg0name); |
3013 | } |
3014 | |
3015 | /* First get the swap group index atoms */ |
3016 | ig = search_string(swapgname, grps->nr, gnames); |
3017 | swap->nat = grps->index[ig+1] - grps->index[ig]; |
3018 | if (swap->nat > 0) |
3019 | { |
3020 | fprintf(stderrstderr, "Swap group '%s' contains %d atoms.\n", swapgname, swap->nat); |
3021 | snew(swap->ind, swap->nat)(swap->ind) = save_calloc("swap->ind", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3021, (swap->nat), sizeof(*(swap->ind))); |
3022 | for (i = 0; i < swap->nat; i++) |
3023 | { |
3024 | swap->ind[i] = grps->a[grps->index[ig]+i]; |
3025 | } |
3026 | } |
3027 | else |
3028 | { |
3029 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3029, "You defined an empty group of atoms for swapping."); |
3030 | } |
3031 | |
3032 | /* Now do so for the split groups */ |
3033 | for (j = 0; j < 2; j++) |
3034 | { |
3035 | if (j == 0) |
3036 | { |
3037 | splitg = splitg0name; |
3038 | } |
3039 | else |
3040 | { |
3041 | splitg = splitg1name; |
3042 | } |
3043 | |
3044 | ig = search_string(splitg, grps->nr, gnames); |
3045 | swap->nat_split[j] = grps->index[ig+1] - grps->index[ig]; |
3046 | if (swap->nat_split[j] > 0) |
3047 | { |
3048 | fprintf(stderrstderr, "Split group %d '%s' contains %d atom%s.\n", |
3049 | j, splitg, swap->nat_split[j], (swap->nat_split[j] > 1) ? "s" : ""); |
3050 | snew(swap->ind_split[j], swap->nat_split[j])(swap->ind_split[j]) = save_calloc("swap->ind_split[j]" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3050, (swap->nat_split[j]), sizeof(*(swap->ind_split[ j]))); |
3051 | for (i = 0; i < swap->nat_split[j]; i++) |
3052 | { |
3053 | swap->ind_split[j][i] = grps->a[grps->index[ig]+i]; |
3054 | } |
3055 | } |
3056 | else |
3057 | { |
3058 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3058, "Split group %d has to contain at least 1 atom!", j); |
3059 | } |
3060 | } |
3061 | |
3062 | /* Now get the solvent group index atoms */ |
3063 | ig = search_string(solgname, grps->nr, gnames); |
3064 | swap->nat_sol = grps->index[ig+1] - grps->index[ig]; |
3065 | if (swap->nat_sol > 0) |
3066 | { |
3067 | fprintf(stderrstderr, "Solvent group '%s' contains %d atoms.\n", solgname, swap->nat_sol); |
3068 | snew(swap->ind_sol, swap->nat_sol)(swap->ind_sol) = save_calloc("swap->ind_sol", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3068, (swap->nat_sol), sizeof(*(swap->ind_sol))); |
3069 | for (i = 0; i < swap->nat_sol; i++) |
3070 | { |
3071 | swap->ind_sol[i] = grps->a[grps->index[ig]+i]; |
3072 | } |
3073 | } |
3074 | else |
3075 | { |
3076 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3076, "You defined an empty group of solvent. Cannot exchange ions."); |
3077 | } |
3078 | } |
3079 | |
3080 | |
3081 | void make_IMD_group(t_IMD *IMDgroup, char *IMDgname, t_blocka *grps, char **gnames) |
3082 | { |
3083 | int ig = -1, i; |
3084 | |
3085 | |
3086 | ig = search_string(IMDgname, grps->nr, gnames); |
3087 | IMDgroup->nat = grps->index[ig+1] - grps->index[ig]; |
3088 | |
3089 | if (IMDgroup->nat > 0) |
3090 | { |
3091 | fprintf(stderrstderr, "Group '%s' with %d atoms can be activated for interactive molecular dynamics (IMD).\n", |
3092 | IMDgname, IMDgroup->nat); |
3093 | snew(IMDgroup->ind, IMDgroup->nat)(IMDgroup->ind) = save_calloc("IMDgroup->ind", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3093, (IMDgroup->nat), sizeof(*(IMDgroup->ind))); |
3094 | for (i = 0; i < IMDgroup->nat; i++) |
3095 | { |
3096 | IMDgroup->ind[i] = grps->a[grps->index[ig]+i]; |
3097 | } |
3098 | } |
3099 | } |
3100 | |
3101 | |
3102 | void do_index(const char* mdparin, const char *ndx, |
3103 | gmx_mtop_t *mtop, |
3104 | gmx_bool bVerbose, |
3105 | t_inputrec *ir, rvec *v, |
3106 | warninp_t wi) |
3107 | { |
3108 | t_blocka *grps; |
3109 | gmx_groups_t *groups; |
3110 | int natoms; |
3111 | t_symtab *symtab; |
3112 | t_atoms atoms_all; |
3113 | char warnbuf[STRLEN4096], **gnames; |
3114 | int nr, ntcg, ntau_t, nref_t, nacc, nofg, nSA, nSA_points, nSA_time, nSA_temp; |
3115 | real tau_min; |
3116 | int nstcmin; |
3117 | int nacg, nfreeze, nfrdim, nenergy, nvcm, nuser; |
3118 | char *ptr1[MAXPTR254], *ptr2[MAXPTR254], *ptr3[MAXPTR254]; |
3119 | int i, j, k, restnm; |
3120 | real SAtime; |
3121 | gmx_bool bExcl, bTable, bSetTCpar, bAnneal, bRest; |
3122 | int nQMmethod, nQMbasis, nQMcharge, nQMmult, nbSH, nCASorb, nCASelec, |
3123 | nSAon, nSAoff, nSAsteps, nQMg, nbOPT, nbTS; |
3124 | char warn_buf[STRLEN4096]; |
3125 | |
3126 | if (bVerbose) |
3127 | { |
3128 | fprintf(stderrstderr, "processing index file...\n"); |
3129 | } |
3130 | debug_gmx(); |
3131 | if (ndx == NULL((void*)0)) |
3132 | { |
3133 | snew(grps, 1)(grps) = save_calloc("grps", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3133, (1), sizeof(*(grps))); |
3134 | snew(grps->index, 1)(grps->index) = save_calloc("grps->index", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3134, (1), sizeof(*(grps->index))); |
3135 | snew(gnames, 1)(gnames) = save_calloc("gnames", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3135, (1), sizeof(*(gnames))); |
3136 | atoms_all = gmx_mtop_global_atoms(mtop); |
3137 | analyse(&atoms_all, grps, &gnames, FALSE0, TRUE1); |
3138 | free_t_atoms(&atoms_all, FALSE0); |
3139 | } |
3140 | else |
3141 | { |
3142 | grps = init_index(ndx, &gnames); |
3143 | } |
3144 | |
3145 | groups = &mtop->groups; |
3146 | natoms = mtop->natoms; |
3147 | symtab = &mtop->symtab; |
3148 | |
3149 | snew(groups->grpname, grps->nr+1)(groups->grpname) = save_calloc("groups->grpname", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3149, (grps->nr+1), sizeof(*(groups->grpname))); |
3150 | |
3151 | for (i = 0; (i < grps->nr); i++) |
3152 | { |
3153 | groups->grpname[i] = put_symtab(symtab, gnames[i]); |
3154 | } |
3155 | groups->grpname[i] = put_symtab(symtab, "rest"); |
3156 | restnm = i; |
3157 | srenew(gnames, grps->nr+1)(gnames) = save_realloc("gnames", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3157, (gnames), (grps->nr+1), sizeof(*(gnames))); |
3158 | gnames[restnm] = *(groups->grpname[i]); |
3159 | groups->ngrpname = grps->nr+1; |
3160 | |
3161 | set_warning_line(wi, mdparin, -1); |
3162 | |
3163 | ntau_t = str_nelem(is->tau_t, MAXPTR254, ptr1); |
3164 | nref_t = str_nelem(is->ref_t, MAXPTR254, ptr2); |
3165 | ntcg = str_nelem(is->tcgrps, MAXPTR254, ptr3); |
3166 | if ((ntau_t != ntcg) || (nref_t != ntcg)) |
3167 | { |
3168 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3168, "Invalid T coupling input: %d groups, %d ref-t values and " |
3169 | "%d tau-t values", ntcg, nref_t, ntau_t); |
3170 | } |
3171 | |
3172 | bSetTCpar = (ir->etc || EI_SD(ir->eI)((ir->eI) == eiSD1 || (ir->eI) == eiSD2) || ir->eI == eiBD || EI_TPI(ir->eI)((ir->eI) == eiTPI || (ir->eI) == eiTPIC)); |
3173 | do_numbering(natoms, groups, ntcg, ptr3, grps, gnames, egcTC, |
3174 | restnm, bSetTCpar ? egrptpALL : egrptpALL_GENREST, bVerbose, wi); |
3175 | nr = groups->grps[egcTC].nr; |
3176 | ir->opts.ngtc = nr; |
3177 | snew(ir->opts.nrdf, nr)(ir->opts.nrdf) = save_calloc("ir->opts.nrdf", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3177, (nr), sizeof(*(ir->opts.nrdf))); |
3178 | snew(ir->opts.tau_t, nr)(ir->opts.tau_t) = save_calloc("ir->opts.tau_t", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3178, (nr), sizeof(*(ir->opts.tau_t))); |
3179 | snew(ir->opts.ref_t, nr)(ir->opts.ref_t) = save_calloc("ir->opts.ref_t", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3179, (nr), sizeof(*(ir->opts.ref_t))); |
3180 | if (ir->eI == eiBD && ir->bd_fric == 0) |
3181 | { |
3182 | fprintf(stderrstderr, "bd-fric=0, so tau-t will be used as the inverse friction constant(s)\n"); |
3183 | } |
3184 | |
3185 | if (bSetTCpar) |
3186 | { |
3187 | if (nr != nref_t) |
3188 | { |
3189 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3189, "Not enough ref-t and tau-t values!"); |
3190 | } |
3191 | |
3192 | tau_min = 1e20; |
3193 | for (i = 0; (i < nr); i++) |
3194 | { |
3195 | ir->opts.tau_t[i] = strtod(ptr1[i], NULL((void*)0)); |
3196 | if ((ir->eI == eiBD || ir->eI == eiSD2) && ir->opts.tau_t[i] <= 0) |
3197 | { |
3198 | sprintf(warn_buf, "With integrator %s tau-t should be larger than 0", ei_names[ir->eI]); |
3199 | warning_error(wi, warn_buf); |
3200 | } |
3201 | |
3202 | if (ir->etc != etcVRESCALE && ir->opts.tau_t[i] == 0) |
3203 | { |
3204 | warning_note(wi, "tau-t = -1 is the value to signal that a group should not have temperature coupling. Treating your use of tau-t = 0 as if you used -1."); |
3205 | } |
3206 | |
3207 | if (ir->opts.tau_t[i] >= 0) |
3208 | { |
3209 | tau_min = min(tau_min, ir->opts.tau_t[i])(((tau_min) < (ir->opts.tau_t[i])) ? (tau_min) : (ir-> opts.tau_t[i]) ); |
3210 | } |
3211 | } |
3212 | if (ir->etc != etcNO && ir->nsttcouple == -1) |
3213 | { |
3214 | ir->nsttcouple = ir_optimal_nsttcouple(ir); |
3215 | } |
3216 | |
3217 | if (EI_VV(ir->eI)((ir->eI) == eiVV || (ir->eI) == eiVVAK)) |
3218 | { |
3219 | if ((ir->etc == etcNOSEHOOVER) && (ir->epc == epcBERENDSEN)) |
3220 | { |
3221 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3221, "Cannot do Nose-Hoover temperature with Berendsen pressure control with md-vv; use either vrescale temperature with berendsen pressure or Nose-Hoover temperature with MTTK pressure"); |
3222 | } |
3223 | if ((ir->epc == epcMTTK) && (ir->etc > etcNO)) |
3224 | { |
3225 | if (ir->nstpcouple != ir->nsttcouple) |
3226 | { |
3227 | int mincouple = min(ir->nstpcouple, ir->nsttcouple)(((ir->nstpcouple) < (ir->nsttcouple)) ? (ir->nstpcouple ) : (ir->nsttcouple) ); |
3228 | ir->nstpcouple = ir->nsttcouple = mincouple; |
3229 | sprintf(warn_buf, "for current Trotter decomposition methods with vv, nsttcouple and nstpcouple must be equal. Both have been reset to min(nsttcouple,nstpcouple) = %d", mincouple); |
3230 | warning_note(wi, warn_buf); |
3231 | } |
3232 | } |
3233 | } |
3234 | /* velocity verlet with averaged kinetic energy KE = 0.5*(v(t+1/2) - v(t-1/2)) is implemented |
3235 | primarily for testing purposes, and does not work with temperature coupling other than 1 */ |
3236 | |
3237 | if (ETC_ANDERSEN(ir->etc)(((ir->etc) == etcANDERSENMASSIVE) || ((ir->etc) == etcANDERSEN ))) |
3238 | { |
3239 | if (ir->nsttcouple != 1) |
3240 | { |
3241 | ir->nsttcouple = 1; |
3242 | sprintf(warn_buf, "Andersen temperature control methods assume nsttcouple = 1; there is no need for larger nsttcouple > 1, since no global parameters are computed. nsttcouple has been reset to 1"); |
3243 | warning_note(wi, warn_buf); |
3244 | } |
3245 | } |
3246 | nstcmin = tcouple_min_integration_steps(ir->etc); |
3247 | if (nstcmin > 1) |
3248 | { |
3249 | if (tau_min/(ir->delta_t*ir->nsttcouple) < nstcmin) |
3250 | { |
3251 | sprintf(warn_buf, "For proper integration of the %s thermostat, tau-t (%g) should be at least %d times larger than nsttcouple*dt (%g)", |
3252 | ETCOUPLTYPE(ir->etc)((((ir->etc) < 0) || ((ir->etc) >= (etcNR))) ? "UNDEFINED" : (etcoupl_names)[ir->etc]), |
3253 | tau_min, nstcmin, |
3254 | ir->nsttcouple*ir->delta_t); |
3255 | warning(wi, warn_buf); |
3256 | } |
3257 | } |
3258 | for (i = 0; (i < nr); i++) |
3259 | { |
3260 | ir->opts.ref_t[i] = strtod(ptr2[i], NULL((void*)0)); |
3261 | if (ir->opts.ref_t[i] < 0) |
3262 | { |
3263 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3263, "ref-t for group %d negative", i); |
3264 | } |
3265 | } |
3266 | /* set the lambda mc temperature to the md integrator temperature (which should be defined |
3267 | if we are in this conditional) if mc_temp is negative */ |
3268 | if (ir->expandedvals->mc_temp < 0) |
3269 | { |
3270 | ir->expandedvals->mc_temp = ir->opts.ref_t[0]; /*for now, set to the first reft */ |
3271 | } |
3272 | } |
3273 | |
3274 | /* Simulated annealing for each group. There are nr groups */ |
3275 | nSA = str_nelem(is->anneal, MAXPTR254, ptr1); |
3276 | if (nSA == 1 && (ptr1[0][0] == 'n' || ptr1[0][0] == 'N')) |
3277 | { |
3278 | nSA = 0; |
3279 | } |
3280 | if (nSA > 0 && nSA != nr) |
3281 | { |
3282 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3282, "Not enough annealing values: %d (for %d groups)\n", nSA, nr); |
3283 | } |
3284 | else |
3285 | { |
3286 | snew(ir->opts.annealing, nr)(ir->opts.annealing) = save_calloc("ir->opts.annealing" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3286, (nr), sizeof(*(ir->opts.annealing))); |
3287 | snew(ir->opts.anneal_npoints, nr)(ir->opts.anneal_npoints) = save_calloc("ir->opts.anneal_npoints" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3287, (nr), sizeof(*(ir->opts.anneal_npoints))); |
3288 | snew(ir->opts.anneal_time, nr)(ir->opts.anneal_time) = save_calloc("ir->opts.anneal_time" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3288, (nr), sizeof(*(ir->opts.anneal_time))); |
3289 | snew(ir->opts.anneal_temp, nr)(ir->opts.anneal_temp) = save_calloc("ir->opts.anneal_temp" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3289, (nr), sizeof(*(ir->opts.anneal_temp))); |
3290 | for (i = 0; i < nr; i++) |
3291 | { |
3292 | ir->opts.annealing[i] = eannNO; |
3293 | ir->opts.anneal_npoints[i] = 0; |
3294 | ir->opts.anneal_time[i] = NULL((void*)0); |
3295 | ir->opts.anneal_temp[i] = NULL((void*)0); |
3296 | } |
3297 | if (nSA > 0) |
3298 | { |
3299 | bAnneal = FALSE0; |
3300 | for (i = 0; i < nr; i++) |
3301 | { |
3302 | if (ptr1[i][0] == 'n' || ptr1[i][0] == 'N') |
3303 | { |
3304 | ir->opts.annealing[i] = eannNO; |
3305 | } |
3306 | else if (ptr1[i][0] == 's' || ptr1[i][0] == 'S') |
3307 | { |
3308 | ir->opts.annealing[i] = eannSINGLE; |
3309 | bAnneal = TRUE1; |
3310 | } |
3311 | else if (ptr1[i][0] == 'p' || ptr1[i][0] == 'P') |
3312 | { |
3313 | ir->opts.annealing[i] = eannPERIODIC; |
3314 | bAnneal = TRUE1; |
3315 | } |
3316 | } |
3317 | if (bAnneal) |
3318 | { |
3319 | /* Read the other fields too */ |
3320 | nSA_points = str_nelem(is->anneal_npoints, MAXPTR254, ptr1); |
3321 | if (nSA_points != nSA) |
3322 | { |
3323 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3323, "Found %d annealing-npoints values for %d groups\n", nSA_points, nSA); |
3324 | } |
3325 | for (k = 0, i = 0; i < nr; i++) |
3326 | { |
3327 | ir->opts.anneal_npoints[i] = strtol(ptr1[i], NULL((void*)0), 10); |
3328 | if (ir->opts.anneal_npoints[i] == 1) |
3329 | { |
3330 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3330, "Please specify at least a start and an end point for annealing\n"); |
3331 | } |
3332 | snew(ir->opts.anneal_time[i], ir->opts.anneal_npoints[i])(ir->opts.anneal_time[i]) = save_calloc("ir->opts.anneal_time[i]" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3332, (ir->opts.anneal_npoints[i]), sizeof(*(ir->opts .anneal_time[i]))); |
3333 | snew(ir->opts.anneal_temp[i], ir->opts.anneal_npoints[i])(ir->opts.anneal_temp[i]) = save_calloc("ir->opts.anneal_temp[i]" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3333, (ir->opts.anneal_npoints[i]), sizeof(*(ir->opts .anneal_temp[i]))); |
3334 | k += ir->opts.anneal_npoints[i]; |
3335 | } |
3336 | |
3337 | nSA_time = str_nelem(is->anneal_time, MAXPTR254, ptr1); |
3338 | if (nSA_time != k) |
3339 | { |
3340 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3340, "Found %d annealing-time values, wanter %d\n", nSA_time, k); |
3341 | } |
3342 | nSA_temp = str_nelem(is->anneal_temp, MAXPTR254, ptr2); |
3343 | if (nSA_temp != k) |
3344 | { |
3345 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3345, "Found %d annealing-temp values, wanted %d\n", nSA_temp, k); |
3346 | } |
3347 | |
3348 | for (i = 0, k = 0; i < nr; i++) |
3349 | { |
3350 | |
3351 | for (j = 0; j < ir->opts.anneal_npoints[i]; j++) |
3352 | { |
3353 | ir->opts.anneal_time[i][j] = strtod(ptr1[k], NULL((void*)0)); |
3354 | ir->opts.anneal_temp[i][j] = strtod(ptr2[k], NULL((void*)0)); |
3355 | if (j == 0) |
3356 | { |
3357 | if (ir->opts.anneal_time[i][0] > (ir->init_t+GMX_REAL_EPS5.96046448E-08)) |
3358 | { |
3359 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3359, "First time point for annealing > init_t.\n"); |
3360 | } |
3361 | } |
3362 | else |
3363 | { |
3364 | /* j>0 */ |
3365 | if (ir->opts.anneal_time[i][j] < ir->opts.anneal_time[i][j-1]) |
3366 | { |
3367 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3367, "Annealing timepoints out of order: t=%f comes after t=%f\n", |
3368 | ir->opts.anneal_time[i][j], ir->opts.anneal_time[i][j-1]); |
3369 | } |
3370 | } |
3371 | if (ir->opts.anneal_temp[i][j] < 0) |
3372 | { |
3373 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3373, "Found negative temperature in annealing: %f\n", ir->opts.anneal_temp[i][j]); |
3374 | } |
3375 | k++; |
3376 | } |
3377 | } |
3378 | /* Print out some summary information, to make sure we got it right */ |
3379 | for (i = 0, k = 0; i < nr; i++) |
3380 | { |
3381 | if (ir->opts.annealing[i] != eannNO) |
3382 | { |
3383 | j = groups->grps[egcTC].nm_ind[i]; |
3384 | fprintf(stderrstderr, "Simulated annealing for group %s: %s, %d timepoints\n", |
3385 | *(groups->grpname[j]), eann_names[ir->opts.annealing[i]], |
3386 | ir->opts.anneal_npoints[i]); |
3387 | fprintf(stderrstderr, "Time (ps) Temperature (K)\n"); |
3388 | /* All terms except the last one */ |
3389 | for (j = 0; j < (ir->opts.anneal_npoints[i]-1); j++) |
3390 | { |
3391 | fprintf(stderrstderr, "%9.1f %5.1f\n", ir->opts.anneal_time[i][j], ir->opts.anneal_temp[i][j]); |
3392 | } |
3393 | |
3394 | /* Finally the last one */ |
3395 | j = ir->opts.anneal_npoints[i]-1; |
3396 | if (ir->opts.annealing[i] == eannSINGLE) |
3397 | { |
3398 | fprintf(stderrstderr, "%9.1f- %5.1f\n", ir->opts.anneal_time[i][j], ir->opts.anneal_temp[i][j]); |
3399 | } |
3400 | else |
3401 | { |
3402 | fprintf(stderrstderr, "%9.1f %5.1f\n", ir->opts.anneal_time[i][j], ir->opts.anneal_temp[i][j]); |
3403 | if (fabs(ir->opts.anneal_temp[i][j]-ir->opts.anneal_temp[i][0]) > GMX_REAL_EPS5.96046448E-08) |
3404 | { |
3405 | warning_note(wi, "There is a temperature jump when your annealing loops back.\n"); |
3406 | } |
3407 | } |
3408 | } |
3409 | } |
3410 | } |
3411 | } |
3412 | } |
3413 | |
3414 | if (ir->ePull != epullNO) |
3415 | { |
3416 | make_pull_groups(ir->pull, is->pull_grp, grps, gnames); |
3417 | |
3418 | make_pull_coords(ir->pull); |
3419 | } |
3420 | |
3421 | if (ir->bRot) |
3422 | { |
3423 | make_rotation_groups(ir->rot, is->rot_grp, grps, gnames); |
3424 | } |
3425 | |
3426 | if (ir->eSwapCoords != eswapNO) |
3427 | { |
3428 | make_swap_groups(ir->swap, swapgrp, splitgrp0, splitgrp1, solgrp, grps, gnames); |
3429 | } |
3430 | |
3431 | /* Make indices for IMD session */ |
3432 | if (ir->bIMD) |
3433 | { |
3434 | make_IMD_group(ir->imd, is->imd_grp, grps, gnames); |
3435 | } |
3436 | |
3437 | nacc = str_nelem(is->acc, MAXPTR254, ptr1); |
3438 | nacg = str_nelem(is->accgrps, MAXPTR254, ptr2); |
3439 | if (nacg*DIM3 != nacc) |
3440 | { |
3441 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3441, "Invalid Acceleration input: %d groups and %d acc. values", |
3442 | nacg, nacc); |
3443 | } |
3444 | do_numbering(natoms, groups, nacg, ptr2, grps, gnames, egcACC, |
3445 | restnm, egrptpALL_GENREST, bVerbose, wi); |
3446 | nr = groups->grps[egcACC].nr; |
3447 | snew(ir->opts.acc, nr)(ir->opts.acc) = save_calloc("ir->opts.acc", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3447, (nr), sizeof(*(ir->opts.acc))); |
3448 | ir->opts.ngacc = nr; |
3449 | |
3450 | for (i = k = 0; (i < nacg); i++) |
3451 | { |
3452 | for (j = 0; (j < DIM3); j++, k++) |
3453 | { |
3454 | ir->opts.acc[i][j] = strtod(ptr1[k], NULL((void*)0)); |
3455 | } |
3456 | } |
3457 | for (; (i < nr); i++) |
3458 | { |
3459 | for (j = 0; (j < DIM3); j++) |
3460 | { |
3461 | ir->opts.acc[i][j] = 0; |
3462 | } |
3463 | } |
3464 | |
3465 | nfrdim = str_nelem(is->frdim, MAXPTR254, ptr1); |
3466 | nfreeze = str_nelem(is->freeze, MAXPTR254, ptr2); |
3467 | if (nfrdim != DIM3*nfreeze) |
3468 | { |
3469 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3469, "Invalid Freezing input: %d groups and %d freeze values", |
3470 | nfreeze, nfrdim); |
3471 | } |
3472 | do_numbering(natoms, groups, nfreeze, ptr2, grps, gnames, egcFREEZE, |
3473 | restnm, egrptpALL_GENREST, bVerbose, wi); |
3474 | nr = groups->grps[egcFREEZE].nr; |
3475 | ir->opts.ngfrz = nr; |
3476 | snew(ir->opts.nFreeze, nr)(ir->opts.nFreeze) = save_calloc("ir->opts.nFreeze", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3476, (nr), sizeof(*(ir->opts.nFreeze))); |
3477 | for (i = k = 0; (i < nfreeze); i++) |
3478 | { |
3479 | for (j = 0; (j < DIM3); j++, k++) |
3480 | { |
3481 | ir->opts.nFreeze[i][j] = (gmx_strncasecmp(ptr1[k], "Y", 1) == 0); |
3482 | if (!ir->opts.nFreeze[i][j]) |
3483 | { |
3484 | if (gmx_strncasecmp(ptr1[k], "N", 1) != 0) |
3485 | { |
3486 | sprintf(warnbuf, "Please use Y(ES) or N(O) for freezedim only " |
3487 | "(not %s)", ptr1[k]); |
3488 | warning(wi, warn_buf); |
3489 | } |
3490 | } |
3491 | } |
3492 | } |
3493 | for (; (i < nr); i++) |
3494 | { |
3495 | for (j = 0; (j < DIM3); j++) |
3496 | { |
3497 | ir->opts.nFreeze[i][j] = 0; |
3498 | } |
3499 | } |
3500 | |
3501 | nenergy = str_nelem(is->energy, MAXPTR254, ptr1); |
3502 | do_numbering(natoms, groups, nenergy, ptr1, grps, gnames, egcENER, |
3503 | restnm, egrptpALL_GENREST, bVerbose, wi); |
3504 | add_wall_energrps(groups, ir->nwall, symtab); |
3505 | ir->opts.ngener = groups->grps[egcENER].nr; |
3506 | nvcm = str_nelem(is->vcm, MAXPTR254, ptr1); |
3507 | bRest = |
3508 | do_numbering(natoms, groups, nvcm, ptr1, grps, gnames, egcVCM, |
3509 | restnm, nvcm == 0 ? egrptpALL_GENREST : egrptpPART, bVerbose, wi); |
3510 | if (bRest) |
3511 | { |
3512 | warning(wi, "Some atoms are not part of any center of mass motion removal group.\n" |
3513 | "This may lead to artifacts.\n" |
3514 | "In most cases one should use one group for the whole system."); |
3515 | } |
3516 | |
3517 | /* Now we have filled the freeze struct, so we can calculate NRDF */ |
3518 | calc_nrdf(mtop, ir, gnames); |
3519 | |
3520 | if (v && NULL((void*)0)) |
3521 | { |
3522 | real fac, ntot = 0; |
3523 | |
3524 | /* Must check per group! */ |
3525 | for (i = 0; (i < ir->opts.ngtc); i++) |
3526 | { |
3527 | ntot += ir->opts.nrdf[i]; |
3528 | } |
3529 | if (ntot != (DIM3*natoms)) |
3530 | { |
3531 | fac = sqrt(ntot/(DIM3*natoms)); |
3532 | if (bVerbose) |
3533 | { |
3534 | fprintf(stderrstderr, "Scaling velocities by a factor of %.3f to account for constraints\n" |
3535 | "and removal of center of mass motion\n", fac); |
3536 | } |
3537 | for (i = 0; (i < natoms); i++) |
3538 | { |
3539 | svmul(fac, v[i], v[i]); |
3540 | } |
3541 | } |
3542 | } |
3543 | |
3544 | nuser = str_nelem(is->user1, MAXPTR254, ptr1); |
3545 | do_numbering(natoms, groups, nuser, ptr1, grps, gnames, egcUser1, |
3546 | restnm, egrptpALL_GENREST, bVerbose, wi); |
3547 | nuser = str_nelem(is->user2, MAXPTR254, ptr1); |
3548 | do_numbering(natoms, groups, nuser, ptr1, grps, gnames, egcUser2, |
3549 | restnm, egrptpALL_GENREST, bVerbose, wi); |
3550 | nuser = str_nelem(is->x_compressed_groups, MAXPTR254, ptr1); |
3551 | do_numbering(natoms, groups, nuser, ptr1, grps, gnames, egcCompressedX, |
3552 | restnm, egrptpONE, bVerbose, wi); |
3553 | nofg = str_nelem(is->orirefitgrp, MAXPTR254, ptr1); |
3554 | do_numbering(natoms, groups, nofg, ptr1, grps, gnames, egcORFIT, |
3555 | restnm, egrptpALL_GENREST, bVerbose, wi); |
3556 | |
3557 | /* QMMM input processing */ |
3558 | nQMg = str_nelem(is->QMMM, MAXPTR254, ptr1); |
3559 | nQMmethod = str_nelem(is->QMmethod, MAXPTR254, ptr2); |
3560 | nQMbasis = str_nelem(is->QMbasis, MAXPTR254, ptr3); |
3561 | if ((nQMmethod != nQMg) || (nQMbasis != nQMg)) |
3562 | { |
3563 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3563, "Invalid QMMM input: %d groups %d basissets" |
3564 | " and %d methods\n", nQMg, nQMbasis, nQMmethod); |
3565 | } |
3566 | /* group rest, if any, is always MM! */ |
3567 | do_numbering(natoms, groups, nQMg, ptr1, grps, gnames, egcQMMM, |
3568 | restnm, egrptpALL_GENREST, bVerbose, wi); |
3569 | nr = nQMg; /*atoms->grps[egcQMMM].nr;*/ |
3570 | ir->opts.ngQM = nQMg; |
3571 | snew(ir->opts.QMmethod, nr)(ir->opts.QMmethod) = save_calloc("ir->opts.QMmethod", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3571, (nr), sizeof(*(ir->opts.QMmethod))); |
3572 | snew(ir->opts.QMbasis, nr)(ir->opts.QMbasis) = save_calloc("ir->opts.QMbasis", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3572, (nr), sizeof(*(ir->opts.QMbasis))); |
3573 | for (i = 0; i < nr; i++) |
3574 | { |
3575 | /* input consists of strings: RHF CASSCF PM3 .. These need to be |
3576 | * converted to the corresponding enum in names.c |
3577 | */ |
3578 | ir->opts.QMmethod[i] = search_QMstring(ptr2[i], eQMmethodNR, |
3579 | eQMmethod_names); |
3580 | ir->opts.QMbasis[i] = search_QMstring(ptr3[i], eQMbasisNR, |
3581 | eQMbasis_names); |
3582 | |
3583 | } |
3584 | nQMmult = str_nelem(is->QMmult, MAXPTR254, ptr1); |
3585 | nQMcharge = str_nelem(is->QMcharge, MAXPTR254, ptr2); |
3586 | nbSH = str_nelem(is->bSH, MAXPTR254, ptr3); |
3587 | snew(ir->opts.QMmult, nr)(ir->opts.QMmult) = save_calloc("ir->opts.QMmult", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3587, (nr), sizeof(*(ir->opts.QMmult))); |
3588 | snew(ir->opts.QMcharge, nr)(ir->opts.QMcharge) = save_calloc("ir->opts.QMcharge", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3588, (nr), sizeof(*(ir->opts.QMcharge))); |
3589 | snew(ir->opts.bSH, nr)(ir->opts.bSH) = save_calloc("ir->opts.bSH", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3589, (nr), sizeof(*(ir->opts.bSH))); |
3590 | |
3591 | for (i = 0; i < nr; i++) |
3592 | { |
3593 | ir->opts.QMmult[i] = strtol(ptr1[i], NULL((void*)0), 10); |
3594 | ir->opts.QMcharge[i] = strtol(ptr2[i], NULL((void*)0), 10); |
3595 | ir->opts.bSH[i] = (gmx_strncasecmp(ptr3[i], "Y", 1) == 0); |
3596 | } |
3597 | |
3598 | nCASelec = str_nelem(is->CASelectrons, MAXPTR254, ptr1); |
3599 | nCASorb = str_nelem(is->CASorbitals, MAXPTR254, ptr2); |
3600 | snew(ir->opts.CASelectrons, nr)(ir->opts.CASelectrons) = save_calloc("ir->opts.CASelectrons" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3600, (nr), sizeof(*(ir->opts.CASelectrons))); |
3601 | snew(ir->opts.CASorbitals, nr)(ir->opts.CASorbitals) = save_calloc("ir->opts.CASorbitals" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3601, (nr), sizeof(*(ir->opts.CASorbitals))); |
3602 | for (i = 0; i < nr; i++) |
3603 | { |
3604 | ir->opts.CASelectrons[i] = strtol(ptr1[i], NULL((void*)0), 10); |
3605 | ir->opts.CASorbitals[i] = strtol(ptr2[i], NULL((void*)0), 10); |
3606 | } |
3607 | /* special optimization options */ |
3608 | |
3609 | nbOPT = str_nelem(is->bOPT, MAXPTR254, ptr1); |
3610 | nbTS = str_nelem(is->bTS, MAXPTR254, ptr2); |
3611 | snew(ir->opts.bOPT, nr)(ir->opts.bOPT) = save_calloc("ir->opts.bOPT", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3611, (nr), sizeof(*(ir->opts.bOPT))); |
3612 | snew(ir->opts.bTS, nr)(ir->opts.bTS) = save_calloc("ir->opts.bTS", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3612, (nr), sizeof(*(ir->opts.bTS))); |
3613 | for (i = 0; i < nr; i++) |
3614 | { |
3615 | ir->opts.bOPT[i] = (gmx_strncasecmp(ptr1[i], "Y", 1) == 0); |
3616 | ir->opts.bTS[i] = (gmx_strncasecmp(ptr2[i], "Y", 1) == 0); |
3617 | } |
3618 | nSAon = str_nelem(is->SAon, MAXPTR254, ptr1); |
3619 | nSAoff = str_nelem(is->SAoff, MAXPTR254, ptr2); |
Value stored to 'nSAoff' is never read | |
3620 | nSAsteps = str_nelem(is->SAsteps, MAXPTR254, ptr3); |
3621 | snew(ir->opts.SAon, nr)(ir->opts.SAon) = save_calloc("ir->opts.SAon", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3621, (nr), sizeof(*(ir->opts.SAon))); |
3622 | snew(ir->opts.SAoff, nr)(ir->opts.SAoff) = save_calloc("ir->opts.SAoff", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3622, (nr), sizeof(*(ir->opts.SAoff))); |
3623 | snew(ir->opts.SAsteps, nr)(ir->opts.SAsteps) = save_calloc("ir->opts.SAsteps", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3623, (nr), sizeof(*(ir->opts.SAsteps))); |
3624 | |
3625 | for (i = 0; i < nr; i++) |
3626 | { |
3627 | ir->opts.SAon[i] = strtod(ptr1[i], NULL((void*)0)); |
3628 | ir->opts.SAoff[i] = strtod(ptr2[i], NULL((void*)0)); |
3629 | ir->opts.SAsteps[i] = strtol(ptr3[i], NULL((void*)0), 10); |
3630 | } |
3631 | /* end of QMMM input */ |
3632 | |
3633 | if (bVerbose) |
3634 | { |
3635 | for (i = 0; (i < egcNR); i++) |
3636 | { |
3637 | fprintf(stderrstderr, "%-16s has %d element(s):", gtypes[i], groups->grps[i].nr); |
3638 | for (j = 0; (j < groups->grps[i].nr); j++) |
3639 | { |
3640 | fprintf(stderrstderr, " %s", *(groups->grpname[groups->grps[i].nm_ind[j]])); |
3641 | } |
3642 | fprintf(stderrstderr, "\n"); |
3643 | } |
3644 | } |
3645 | |
3646 | nr = groups->grps[egcENER].nr; |
3647 | snew(ir->opts.egp_flags, nr*nr)(ir->opts.egp_flags) = save_calloc("ir->opts.egp_flags" , "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3647, (nr*nr), sizeof(*(ir->opts.egp_flags))); |
3648 | |
3649 | bExcl = do_egp_flag(ir, groups, "energygrp-excl", is->egpexcl, EGP_EXCL(1<<0)); |
3650 | if (bExcl && ir->cutoff_scheme == ecutsVERLET) |
3651 | { |
3652 | warning_error(wi, "Energy group exclusions are not (yet) implemented for the Verlet scheme"); |
3653 | } |
3654 | if (bExcl && EEL_FULL(ir->coulombtype)((((ir->coulombtype) == eelPME || (ir->coulombtype) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir->coulombtype ) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD) || (ir->coulombtype) == eelEWALD) || (ir->coulombtype) == eelPOISSON)) |
3655 | { |
3656 | warning(wi, "Can not exclude the lattice Coulomb energy between energy groups"); |
3657 | } |
3658 | |
3659 | bTable = do_egp_flag(ir, groups, "energygrp-table", is->egptable, EGP_TABLE(1<<1)); |
3660 | if (bTable && !(ir->vdwtype == evdwUSER) && |
3661 | !(ir->coulombtype == eelUSER) && !(ir->coulombtype == eelPMEUSER) && |
3662 | !(ir->coulombtype == eelPMEUSERSWITCH)) |
3663 | { |
3664 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3664, "Can only have energy group pair tables in combination with user tables for VdW and/or Coulomb"); |
3665 | } |
3666 | |
3667 | decode_cos(is->efield_x, &(ir->ex[XX0])); |
3668 | decode_cos(is->efield_xt, &(ir->et[XX0])); |
3669 | decode_cos(is->efield_y, &(ir->ex[YY1])); |
3670 | decode_cos(is->efield_yt, &(ir->et[YY1])); |
3671 | decode_cos(is->efield_z, &(ir->ex[ZZ2])); |
3672 | decode_cos(is->efield_zt, &(ir->et[ZZ2])); |
3673 | |
3674 | if (ir->bAdress) |
3675 | { |
3676 | do_adress_index(ir->adress, groups, gnames, &(ir->opts), wi); |
3677 | } |
3678 | |
3679 | for (i = 0; (i < grps->nr); i++) |
3680 | { |
3681 | sfree(gnames[i])save_free("gnames[i]", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3681, (gnames[i])); |
3682 | } |
3683 | sfree(gnames)save_free("gnames", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3683, (gnames)); |
3684 | done_blocka(grps); |
3685 | sfree(grps)save_free("grps", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3685, (grps)); |
3686 | |
3687 | } |
3688 | |
3689 | |
3690 | |
3691 | static void check_disre(gmx_mtop_t *mtop) |
3692 | { |
3693 | gmx_ffparams_t *ffparams; |
3694 | t_functype *functype; |
3695 | t_iparams *ip; |
3696 | int i, ndouble, ftype; |
3697 | int label, old_label; |
3698 | |
3699 | if (gmx_mtop_ftype_count(mtop, F_DISRES) > 0) |
3700 | { |
3701 | ffparams = &mtop->ffparams; |
3702 | functype = ffparams->functype; |
3703 | ip = ffparams->iparams; |
3704 | ndouble = 0; |
3705 | old_label = -1; |
3706 | for (i = 0; i < ffparams->ntypes; i++) |
3707 | { |
3708 | ftype = functype[i]; |
3709 | if (ftype == F_DISRES) |
3710 | { |
3711 | label = ip[i].disres.label; |
3712 | if (label == old_label) |
3713 | { |
3714 | fprintf(stderrstderr, "Distance restraint index %d occurs twice\n", label); |
3715 | ndouble++; |
3716 | } |
3717 | old_label = label; |
3718 | } |
3719 | } |
3720 | if (ndouble > 0) |
3721 | { |
3722 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3722, "Found %d double distance restraint indices,\n" |
3723 | "probably the parameters for multiple pairs in one restraint " |
3724 | "are not identical\n", ndouble); |
3725 | } |
3726 | } |
3727 | } |
3728 | |
3729 | static gmx_bool absolute_reference(t_inputrec *ir, gmx_mtop_t *sys, |
3730 | gmx_bool posres_only, |
3731 | ivec AbsRef) |
3732 | { |
3733 | int d, g, i; |
3734 | gmx_mtop_ilistloop_t iloop; |
3735 | t_ilist *ilist; |
3736 | int nmol; |
3737 | t_iparams *pr; |
3738 | |
3739 | clear_ivec(AbsRef); |
3740 | |
3741 | if (!posres_only) |
3742 | { |
3743 | /* Check the COM */ |
3744 | for (d = 0; d < DIM3; d++) |
3745 | { |
3746 | AbsRef[d] = (d < ndof_com(ir) ? 0 : 1); |
3747 | } |
3748 | /* Check for freeze groups */ |
3749 | for (g = 0; g < ir->opts.ngfrz; g++) |
3750 | { |
3751 | for (d = 0; d < DIM3; d++) |
3752 | { |
3753 | if (ir->opts.nFreeze[g][d] != 0) |
3754 | { |
3755 | AbsRef[d] = 1; |
3756 | } |
3757 | } |
3758 | } |
3759 | } |
3760 | |
3761 | /* Check for position restraints */ |
3762 | iloop = gmx_mtop_ilistloop_init(sys); |
3763 | while (gmx_mtop_ilistloop_next(iloop, &ilist, &nmol)) |
3764 | { |
3765 | if (nmol > 0 && |
3766 | (AbsRef[XX0] == 0 || AbsRef[YY1] == 0 || AbsRef[ZZ2] == 0)) |
3767 | { |
3768 | for (i = 0; i < ilist[F_POSRES].nr; i += 2) |
3769 | { |
3770 | pr = &sys->ffparams.iparams[ilist[F_POSRES].iatoms[i]]; |
3771 | for (d = 0; d < DIM3; d++) |
3772 | { |
3773 | if (pr->posres.fcA[d] != 0) |
3774 | { |
3775 | AbsRef[d] = 1; |
3776 | } |
3777 | } |
3778 | } |
3779 | for (i = 0; i < ilist[F_FBPOSRES].nr; i += 2) |
3780 | { |
3781 | /* Check for flat-bottom posres */ |
3782 | pr = &sys->ffparams.iparams[ilist[F_FBPOSRES].iatoms[i]]; |
3783 | if (pr->fbposres.k != 0) |
3784 | { |
3785 | switch (pr->fbposres.geom) |
3786 | { |
3787 | case efbposresSPHERE: |
3788 | AbsRef[XX0] = AbsRef[YY1] = AbsRef[ZZ2] = 1; |
3789 | break; |
3790 | case efbposresCYLINDER: |
3791 | AbsRef[XX0] = AbsRef[YY1] = 1; |
3792 | break; |
3793 | case efbposresX: /* d=XX */ |
3794 | case efbposresY: /* d=YY */ |
3795 | case efbposresZ: /* d=ZZ */ |
3796 | d = pr->fbposres.geom - efbposresX; |
3797 | AbsRef[d] = 1; |
3798 | break; |
3799 | default: |
3800 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3800, " Invalid geometry for flat-bottom position restraint.\n" |
3801 | "Expected nr between 1 and %d. Found %d\n", efbposresNR-1, |
3802 | pr->fbposres.geom); |
3803 | } |
3804 | } |
3805 | } |
3806 | } |
3807 | } |
3808 | |
3809 | return (AbsRef[XX0] != 0 && AbsRef[YY1] != 0 && AbsRef[ZZ2] != 0); |
3810 | } |
3811 | |
3812 | static void |
3813 | check_combination_rule_differences(const gmx_mtop_t *mtop, int state, |
3814 | gmx_bool *bC6ParametersWorkWithGeometricRules, |
3815 | gmx_bool *bC6ParametersWorkWithLBRules, |
3816 | gmx_bool *bLBRulesPossible) |
3817 | { |
3818 | int ntypes, tpi, tpj, thisLBdiff, thisgeomdiff; |
3819 | int *typecount; |
3820 | real tol; |
3821 | double geometricdiff, LBdiff; |
3822 | double c6i, c6j, c12i, c12j; |
3823 | double c6, c6_geometric, c6_LB; |
3824 | double sigmai, sigmaj, epsi, epsj; |
3825 | gmx_bool bCanDoLBRules, bCanDoGeometricRules; |
3826 | const char *ptr; |
3827 | |
3828 | /* A tolerance of 1e-5 seems reasonable for (possibly hand-typed) |
3829 | * force-field floating point parameters. |
3830 | */ |
3831 | tol = 1e-5; |
3832 | ptr = getenv("GMX_LJCOMB_TOL"); |
3833 | if (ptr != NULL((void*)0)) |
3834 | { |
3835 | double dbl; |
3836 | |
3837 | sscanf(ptr, "%lf", &dbl); |
3838 | tol = dbl; |
3839 | } |
3840 | |
3841 | *bC6ParametersWorkWithLBRules = TRUE1; |
3842 | *bC6ParametersWorkWithGeometricRules = TRUE1; |
3843 | bCanDoLBRules = TRUE1; |
3844 | bCanDoGeometricRules = TRUE1; |
3845 | ntypes = mtop->ffparams.atnr; |
3846 | snew(typecount, ntypes)(typecount) = save_calloc("typecount", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3846, (ntypes), sizeof(*(typecount))); |
3847 | gmx_mtop_count_atomtypes(mtop, state, typecount); |
3848 | geometricdiff = LBdiff = 0.0; |
3849 | *bLBRulesPossible = TRUE1; |
3850 | for (tpi = 0; tpi < ntypes; ++tpi) |
3851 | { |
3852 | c6i = mtop->ffparams.iparams[(ntypes + 1) * tpi].lj.c6; |
3853 | c12i = mtop->ffparams.iparams[(ntypes + 1) * tpi].lj.c12; |
3854 | for (tpj = tpi; tpj < ntypes; ++tpj) |
3855 | { |
3856 | c6j = mtop->ffparams.iparams[(ntypes + 1) * tpj].lj.c6; |
3857 | c12j = mtop->ffparams.iparams[(ntypes + 1) * tpj].lj.c12; |
3858 | c6 = mtop->ffparams.iparams[ntypes * tpi + tpj].lj.c6; |
3859 | c6_geometric = sqrt(c6i * c6j); |
3860 | if (!gmx_numzero(c6_geometric)) |
3861 | { |
3862 | if (!gmx_numzero(c12i) && !gmx_numzero(c12j)) |
3863 | { |
3864 | sigmai = pow(c12i / c6i, 1.0/6.0); |
3865 | sigmaj = pow(c12j / c6j, 1.0/6.0); |
3866 | epsi = c6i * c6i /(4.0 * c12i); |
3867 | epsj = c6j * c6j /(4.0 * c12j); |
3868 | c6_LB = 4.0 * pow(epsi * epsj, 1.0/2.0) * pow(0.5 * (sigmai + sigmaj), 6); |
3869 | } |
3870 | else |
3871 | { |
3872 | *bLBRulesPossible = FALSE0; |
3873 | c6_LB = c6_geometric; |
3874 | } |
3875 | bCanDoLBRules = gmx_within_tol(c6_LB, c6, tol); |
3876 | } |
3877 | |
3878 | if (FALSE0 == bCanDoLBRules) |
3879 | { |
3880 | *bC6ParametersWorkWithLBRules = FALSE0; |
3881 | } |
3882 | |
3883 | bCanDoGeometricRules = gmx_within_tol(c6_geometric, c6, tol); |
3884 | |
3885 | if (FALSE0 == bCanDoGeometricRules) |
3886 | { |
3887 | *bC6ParametersWorkWithGeometricRules = FALSE0; |
3888 | } |
3889 | } |
3890 | } |
3891 | sfree(typecount)save_free("typecount", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 3891, (typecount)); |
3892 | } |
3893 | |
3894 | static void |
3895 | check_combination_rules(const t_inputrec *ir, const gmx_mtop_t *mtop, |
3896 | warninp_t wi) |
3897 | { |
3898 | char err_buf[256]; |
3899 | gmx_bool bLBRulesPossible, bC6ParametersWorkWithGeometricRules, bC6ParametersWorkWithLBRules; |
3900 | |
3901 | check_combination_rule_differences(mtop, 0, |
3902 | &bC6ParametersWorkWithGeometricRules, |
3903 | &bC6ParametersWorkWithLBRules, |
3904 | &bLBRulesPossible); |
3905 | if (ir->ljpme_combination_rule == eljpmeLB) |
3906 | { |
3907 | if (FALSE0 == bC6ParametersWorkWithLBRules || FALSE0 == bLBRulesPossible) |
3908 | { |
3909 | warning(wi, "You are using arithmetic-geometric combination rules " |
3910 | "in LJ-PME, but your non-bonded C6 parameters do not " |
3911 | "follow these rules."); |
3912 | } |
3913 | } |
3914 | else |
3915 | { |
3916 | if (FALSE0 == bC6ParametersWorkWithGeometricRules) |
3917 | { |
3918 | if (ir->eDispCorr != edispcNO) |
3919 | { |
3920 | warning_note(wi, "You are using geometric combination rules in " |
3921 | "LJ-PME, but your non-bonded C6 parameters do " |
3922 | "not follow these rules. " |
3923 | "This will introduce very small errors in the forces and energies in " |
3924 | "your simulations. Dispersion correction will correct total energy " |
3925 | "and/or pressure for isotropic systems, but not forces or surface tensions."); |
3926 | } |
3927 | else |
3928 | { |
3929 | warning_note(wi, "You are using geometric combination rules in " |
3930 | "LJ-PME, but your non-bonded C6 parameters do " |
3931 | "not follow these rules. " |
3932 | "This will introduce very small errors in the forces and energies in " |
3933 | "your simulations. If your system is homogeneous, consider using dispersion correction " |
3934 | "for the total energy and pressure."); |
3935 | } |
3936 | } |
3937 | } |
3938 | } |
3939 | |
3940 | void triple_check(const char *mdparin, t_inputrec *ir, gmx_mtop_t *sys, |
3941 | warninp_t wi) |
3942 | { |
3943 | char err_buf[256]; |
3944 | int i, m, c, nmol, npct; |
3945 | gmx_bool bCharge, bAcc; |
3946 | real gdt_max, *mgrp, mt; |
3947 | rvec acc; |
3948 | gmx_mtop_atomloop_block_t aloopb; |
3949 | gmx_mtop_atomloop_all_t aloop; |
3950 | t_atom *atom; |
3951 | ivec AbsRef; |
3952 | char warn_buf[STRLEN4096]; |
3953 | |
3954 | set_warning_line(wi, mdparin, -1); |
3955 | |
3956 | if (EI_DYNAMICS(ir->eI)(((ir->eI) == eiMD || ((ir->eI) == eiVV || (ir->eI) == eiVVAK)) || ((ir->eI) == eiSD1 || (ir->eI) == eiSD2) || (ir->eI) == eiBD) && !EI_SD(ir->eI)((ir->eI) == eiSD1 || (ir->eI) == eiSD2) && ir->eI != eiBD && |
3957 | ir->comm_mode == ecmNO && |
3958 | !(absolute_reference(ir, sys, FALSE0, AbsRef) || ir->nsteps <= 10) && |
3959 | !ETC_ANDERSEN(ir->etc)(((ir->etc) == etcANDERSENMASSIVE) || ((ir->etc) == etcANDERSEN ))) |
3960 | { |
3961 | warning(wi, "You are not using center of mass motion removal (mdp option comm-mode), numerical rounding errors can lead to build up of kinetic energy of the center of mass"); |
3962 | } |
3963 | |
3964 | /* Check for pressure coupling with absolute position restraints */ |
3965 | if (ir->epc != epcNO && ir->refcoord_scaling == erscNO) |
3966 | { |
3967 | absolute_reference(ir, sys, TRUE1, AbsRef); |
3968 | { |
3969 | for (m = 0; m < DIM3; m++) |
3970 | { |
3971 | if (AbsRef[m] && norm2(ir->compress[m]) > 0) |
3972 | { |
3973 | warning(wi, "You are using pressure coupling with absolute position restraints, this will give artifacts. Use the refcoord_scaling option."); |
3974 | break; |
3975 | } |
3976 | } |
3977 | } |
3978 | } |
3979 | |
3980 | bCharge = FALSE0; |
3981 | aloopb = gmx_mtop_atomloop_block_init(sys); |
3982 | while (gmx_mtop_atomloop_block_next(aloopb, &atom, &nmol)) |
3983 | { |
3984 | if (atom->q != 0 || atom->qB != 0) |
3985 | { |
3986 | bCharge = TRUE1; |
3987 | } |
3988 | } |
3989 | |
3990 | if (!bCharge) |
3991 | { |
3992 | if (EEL_FULL(ir->coulombtype)((((ir->coulombtype) == eelPME || (ir->coulombtype) == eelPMESWITCH || (ir->coulombtype) == eelPMEUSER || (ir->coulombtype ) == eelPMEUSERSWITCH || (ir->coulombtype) == eelP3M_AD) || (ir->coulombtype) == eelEWALD) || (ir->coulombtype) == eelPOISSON)) |
3993 | { |
3994 | sprintf(err_buf, |
3995 | "You are using full electrostatics treatment %s for a system without charges.\n" |
3996 | "This costs a lot of performance for just processing zeros, consider using %s instead.\n", |
3997 | EELTYPE(ir->coulombtype)((((ir->coulombtype) < 0) || ((ir->coulombtype) >= (eelNR))) ? "UNDEFINED" : (eel_names)[ir->coulombtype]), EELTYPE(eelCUT)((((eelCUT) < 0) || ((eelCUT) >= (eelNR))) ? "UNDEFINED" : (eel_names)[eelCUT])); |
3998 | warning(wi, err_buf); |
3999 | } |
4000 | } |
4001 | else |
4002 | { |
4003 | if (ir->coulombtype == eelCUT && ir->rcoulomb > 0 && !ir->implicit_solvent) |
4004 | { |
4005 | sprintf(err_buf, |
4006 | "You are using a plain Coulomb cut-off, which might produce artifacts.\n" |
4007 | "You might want to consider using %s electrostatics.\n", |
4008 | EELTYPE(eelPME)((((eelPME) < 0) || ((eelPME) >= (eelNR))) ? "UNDEFINED" : (eel_names)[eelPME])); |
4009 | warning_note(wi, err_buf); |
4010 | } |
4011 | } |
4012 | |
4013 | /* Check if combination rules used in LJ-PME are the same as in the force field */ |
4014 | if (EVDW_PME(ir->vdwtype)((ir->vdwtype) == evdwPME)) |
4015 | { |
4016 | check_combination_rules(ir, sys, wi); |
4017 | } |
4018 | |
4019 | /* Generalized reaction field */ |
4020 | if (ir->opts.ngtc == 0) |
4021 | { |
4022 | sprintf(err_buf, "No temperature coupling while using coulombtype %s", |
4023 | eel_names[eelGRF]); |
4024 | CHECK(ir->coulombtype == eelGRF)_low_check(ir->coulombtype == eelGRF, err_buf, wi); |
4025 | } |
4026 | else |
4027 | { |
4028 | sprintf(err_buf, "When using coulombtype = %s" |
4029 | " ref-t for temperature coupling should be > 0", |
4030 | eel_names[eelGRF]); |
4031 | CHECK((ir->coulombtype == eelGRF) && (ir->opts.ref_t[0] <= 0))_low_check((ir->coulombtype == eelGRF) && (ir-> opts.ref_t[0] <= 0), err_buf, wi); |
4032 | } |
4033 | |
4034 | if (ir->eI == eiSD1 && |
4035 | (gmx_mtop_ftype_count(sys, F_CONSTR) > 0 || |
4036 | gmx_mtop_ftype_count(sys, F_SETTLE) > 0)) |
4037 | { |
4038 | sprintf(warn_buf, "With constraints integrator %s is less accurate, consider using %s instead", ei_names[ir->eI], ei_names[eiSD2]); |
4039 | warning_note(wi, warn_buf); |
4040 | } |
4041 | |
4042 | bAcc = FALSE0; |
4043 | for (i = 0; (i < sys->groups.grps[egcACC].nr); i++) |
4044 | { |
4045 | for (m = 0; (m < DIM3); m++) |
4046 | { |
4047 | if (fabs(ir->opts.acc[i][m]) > 1e-6) |
4048 | { |
4049 | bAcc = TRUE1; |
4050 | } |
4051 | } |
4052 | } |
4053 | if (bAcc) |
4054 | { |
4055 | clear_rvec(acc); |
4056 | snew(mgrp, sys->groups.grps[egcACC].nr)(mgrp) = save_calloc("mgrp", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 4056, (sys->groups.grps[egcACC].nr), sizeof(*(mgrp))); |
4057 | aloop = gmx_mtop_atomloop_all_init(sys); |
4058 | while (gmx_mtop_atomloop_all_next(aloop, &i, &atom)) |
4059 | { |
4060 | mgrp[ggrpnr(&sys->groups, egcACC, i)((&sys->groups)->grpnr[egcACC] ? (&sys->groups )->grpnr[egcACC][i] : 0)] += atom->m; |
4061 | } |
4062 | mt = 0.0; |
4063 | for (i = 0; (i < sys->groups.grps[egcACC].nr); i++) |
4064 | { |
4065 | for (m = 0; (m < DIM3); m++) |
4066 | { |
4067 | acc[m] += ir->opts.acc[i][m]*mgrp[i]; |
4068 | } |
4069 | mt += mgrp[i]; |
4070 | } |
4071 | for (m = 0; (m < DIM3); m++) |
4072 | { |
4073 | if (fabs(acc[m]) > 1e-6) |
4074 | { |
4075 | const char *dim[DIM3] = { "X", "Y", "Z" }; |
4076 | fprintf(stderrstderr, |
4077 | "Net Acceleration in %s direction, will %s be corrected\n", |
4078 | dim[m], ir->nstcomm != 0 ? "" : "not"); |
4079 | if (ir->nstcomm != 0 && m < ndof_com(ir)) |
4080 | { |
4081 | acc[m] /= mt; |
4082 | for (i = 0; (i < sys->groups.grps[egcACC].nr); i++) |
4083 | { |
4084 | ir->opts.acc[i][m] -= acc[m]; |
4085 | } |
4086 | } |
4087 | } |
4088 | } |
4089 | sfree(mgrp)save_free("mgrp", "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 4089, (mgrp)); |
4090 | } |
4091 | |
4092 | if (ir->efep != efepNO && ir->fepvals->sc_alpha != 0 && |
4093 | !gmx_within_tol(sys->ffparams.reppow, 12.0, 10*GMX_DOUBLE_EPS1.11022302E-16)) |
4094 | { |
4095 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 4095, "Soft-core interactions are only supported with VdW repulsion power 12"); |
4096 | } |
4097 | |
4098 | if (ir->ePull != epullNO) |
4099 | { |
4100 | gmx_bool bPullAbsoluteRef; |
4101 | |
4102 | bPullAbsoluteRef = FALSE0; |
4103 | for (i = 0; i < ir->pull->ncoord; i++) |
4104 | { |
4105 | bPullAbsoluteRef = bPullAbsoluteRef || |
4106 | ir->pull->coord[i].group[0] == 0 || |
4107 | ir->pull->coord[i].group[1] == 0; |
4108 | } |
4109 | if (bPullAbsoluteRef) |
4110 | { |
4111 | absolute_reference(ir, sys, FALSE0, AbsRef); |
4112 | for (m = 0; m < DIM3; m++) |
4113 | { |
4114 | if (ir->pull->dim[m] && !AbsRef[m]) |
4115 | { |
4116 | warning(wi, "You are using an absolute reference for pulling, but the rest of the system does not have an absolute reference. This will lead to artifacts."); |
4117 | break; |
4118 | } |
4119 | } |
4120 | } |
4121 | |
4122 | if (ir->pull->eGeom == epullgDIRPBC) |
4123 | { |
4124 | for (i = 0; i < 3; i++) |
4125 | { |
4126 | for (m = 0; m <= i; m++) |
4127 | { |
4128 | if ((ir->epc != epcNO && ir->compress[i][m] != 0) || |
4129 | ir->deform[i][m] != 0) |
4130 | { |
4131 | for (c = 0; c < ir->pull->ncoord; c++) |
4132 | { |
4133 | if (ir->pull->coord[c].vec[m] != 0) |
4134 | { |
4135 | gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxpreprocess/readir.c" , 4135, "Can not have dynamic box while using pull geometry '%s' (dim %c)", EPULLGEOM(ir->pull->eGeom)((((ir->pull->eGeom) < 0) || ((ir->pull->eGeom ) >= (epullgNR))) ? "UNDEFINED" : (epullg_names)[ir->pull ->eGeom]), 'x'+m); |
4136 | } |
4137 | } |
4138 | } |
4139 | } |
4140 | } |
4141 | } |
4142 | } |
4143 | |
4144 | check_disre(sys); |
4145 | } |
4146 | |
4147 | void double_check(t_inputrec *ir, matrix box, gmx_bool bConstr, warninp_t wi) |
4148 | { |
4149 | real min_size; |
4150 | gmx_bool bTWIN; |
4151 | char warn_buf[STRLEN4096]; |
4152 | const char *ptr; |
4153 | |
4154 | ptr = check_box(ir->ePBC, box); |
4155 | if (ptr) |
4156 | { |
4157 | warning_error(wi, ptr); |
4158 | } |
4159 | |
4160 | if (bConstr && ir->eConstrAlg == econtSHAKE) |
4161 | { |
4162 | if (ir->shake_tol <= 0.0) |
4163 | { |
4164 | sprintf(warn_buf, "ERROR: shake-tol must be > 0 instead of %g\n", |
4165 | ir->shake_tol); |
4166 | warning_error(wi, warn_buf); |
4167 | } |
4168 | |
4169 | if (IR_TWINRANGE(*ir)((*ir).rlist > 0 && ((*ir).rlistlong == 0 || (*ir) .rlistlong > (*ir).rlist)) && ir->nstlist > 1) |
4170 | { |
4171 | sprintf(warn_buf, "With twin-range cut-off's and SHAKE the virial and the pressure are incorrect."); |
4172 | if (ir->epc == epcNO) |
4173 | { |
4174 | warning(wi, warn_buf); |
4175 | } |
4176 | else |
4177 | { |
4178 | warning_error(wi, warn_buf); |
4179 | } |
4180 | } |
4181 | } |
4182 | |
4183 | if ( (ir->eConstrAlg == econtLINCS) && bConstr) |
4184 | { |
4185 | /* If we have Lincs constraints: */ |
4186 | if (ir->eI == eiMD && ir->etc == etcNO && |
4187 | ir->eConstrAlg == econtLINCS && ir->nLincsIter == 1) |
4188 | { |
4189 | sprintf(warn_buf, "For energy conservation with LINCS, lincs_iter should be 2 or larger.\n"); |
4190 | warning_note(wi, warn_buf); |
4191 | } |
4192 | |
4193 | if ((ir->eI == eiCG || ir->eI == eiLBFGS) && (ir->nProjOrder < 8)) |
4194 | { |
4195 | sprintf(warn_buf, "For accurate %s with LINCS constraints, lincs-order should be 8 or more.", ei_names[ir->eI]); |
4196 | warning_note(wi, warn_buf); |
4197 | } |
4198 | if (ir->epc == epcMTTK) |
4199 | { |
4200 | warning_error(wi, "MTTK not compatible with lincs -- use shake instead."); |
4201 | } |
4202 | } |
4203 | |
4204 | if (bConstr && ir->epc == epcMTTK) |
4205 | { |
4206 | warning_note(wi, "MTTK with constraints is deprecated, and will be removed in GROMACS 5.1"); |
4207 | } |
4208 | |
4209 | if (ir->LincsWarnAngle > 90.0) |
4210 | { |
4211 | sprintf(warn_buf, "lincs-warnangle can not be larger than 90 degrees, setting it to 90.\n"); |
4212 | warning(wi, warn_buf); |
4213 | ir->LincsWarnAngle = 90.0; |
4214 | } |
4215 | |
4216 | if (ir->ePBC != epbcNONE) |
4217 | { |
4218 | if (ir->nstlist == 0) |
4219 | { |
4220 | warning(wi, "With nstlist=0 atoms are only put into the box at step 0, therefore drifting atoms might cause the simulation to crash."); |
4221 | } |
4222 | bTWIN = (ir->rlistlong > ir->rlist); |
4223 | if (ir->ns_type == ensGRID) |
4224 | { |
4225 | if (sqr(ir->rlistlong) >= max_cutoff2(ir->ePBC, box)) |
4226 | { |
4227 | sprintf(warn_buf, "ERROR: The cut-off length is longer than half the shortest box vector or longer than the smallest box diagonal element. Increase the box size or decrease %s.\n", |
4228 | bTWIN ? (ir->rcoulomb == ir->rlistlong ? "rcoulomb" : "rvdw") : "rlist"); |
4229 | warning_error(wi, warn_buf); |
4230 | } |
4231 | } |
4232 | else |
4233 | { |
4234 | min_size = min(box[XX][XX], min(box[YY][YY], box[ZZ][ZZ]))(((box[0][0]) < ((((box[1][1]) < (box[2][2])) ? (box[1] [1]) : (box[2][2]) ))) ? (box[0][0]) : ((((box[1][1]) < (box [2][2])) ? (box[1][1]) : (box[2][2]) )) ); |
4235 | if (2*ir->rlistlong >= min_size) |
4236 | { |
4237 | sprintf(warn_buf, "ERROR: One of the box lengths is smaller than twice the cut-off length. Increase the box size or decrease rlist."); |
4238 | warning_error(wi, warn_buf); |
4239 | if (TRICLINIC(box)(box[1][0] != 0 || box[2][0] != 0 || box[2][1] != 0)) |
4240 | { |
4241 | fprintf(stderrstderr, "Grid search might allow larger cut-off's than simple search with triclinic boxes."); |
4242 | } |
4243 | } |
4244 | } |
4245 | } |
4246 | } |
4247 | |
4248 | void check_chargegroup_radii(const gmx_mtop_t *mtop, const t_inputrec *ir, |
4249 | rvec *x, |
4250 | warninp_t wi) |
4251 | { |
4252 | real rvdw1, rvdw2, rcoul1, rcoul2; |
4253 | char warn_buf[STRLEN4096]; |
4254 | |
4255 | calc_chargegroup_radii(mtop, x, &rvdw1, &rvdw2, &rcoul1, &rcoul2); |
4256 | |
4257 | if (rvdw1 > 0) |
4258 | { |
4259 | printf("Largest charge group radii for Van der Waals: %5.3f, %5.3f nm\n", |
4260 | rvdw1, rvdw2); |
4261 | } |
4262 | if (rcoul1 > 0) |
4263 | { |
4264 | printf("Largest charge group radii for Coulomb: %5.3f, %5.3f nm\n", |
4265 | rcoul1, rcoul2); |
4266 | } |
4267 | |
4268 | if (ir->rlist > 0) |
4269 | { |
4270 | if (rvdw1 + rvdw2 > ir->rlist || |
4271 | rcoul1 + rcoul2 > ir->rlist) |
4272 | { |
4273 | sprintf(warn_buf, |
4274 | "The sum of the two largest charge group radii (%f) " |
4275 | "is larger than rlist (%f)\n", |
4276 | max(rvdw1+rvdw2, rcoul1+rcoul2)(((rvdw1+rvdw2) > (rcoul1+rcoul2)) ? (rvdw1+rvdw2) : (rcoul1 +rcoul2) ), ir->rlist); |
4277 | warning(wi, warn_buf); |
4278 | } |
4279 | else |
4280 | { |
4281 | /* Here we do not use the zero at cut-off macro, |
4282 | * since user defined interactions might purposely |
4283 | * not be zero at the cut-off. |
4284 | */ |
4285 | if (ir_vdw_is_zero_at_cutoff(ir) && |
4286 | rvdw1 + rvdw2 > ir->rlistlong - ir->rvdw) |
4287 | { |
4288 | sprintf(warn_buf, "The sum of the two largest charge group " |
4289 | "radii (%f) is larger than %s (%f) - rvdw (%f).\n" |
4290 | "With exact cut-offs, better performance can be " |
4291 | "obtained with cutoff-scheme = %s, because it " |
4292 | "does not use charge groups at all.", |
4293 | rvdw1+rvdw2, |
4294 | ir->rlistlong > ir->rlist ? "rlistlong" : "rlist", |
4295 | ir->rlistlong, ir->rvdw, |
4296 | ecutscheme_names[ecutsVERLET]); |
4297 | if (ir_NVE(ir)) |
4298 | { |
4299 | warning(wi, warn_buf); |
4300 | } |
4301 | else |
4302 | { |
4303 | warning_note(wi, warn_buf); |
4304 | } |
4305 | } |
4306 | if (ir_coulomb_is_zero_at_cutoff(ir) && |
4307 | rcoul1 + rcoul2 > ir->rlistlong - ir->rcoulomb) |
4308 | { |
4309 | sprintf(warn_buf, "The sum of the two largest charge group radii (%f) is larger than %s (%f) - rcoulomb (%f).\n" |
4310 | "With exact cut-offs, better performance can be obtained with cutoff-scheme = %s, because it does not use charge groups at all.", |
4311 | rcoul1+rcoul2, |
4312 | ir->rlistlong > ir->rlist ? "rlistlong" : "rlist", |
4313 | ir->rlistlong, ir->rcoulomb, |
4314 | ecutscheme_names[ecutsVERLET]); |
4315 | if (ir_NVE(ir)) |
4316 | { |
4317 | warning(wi, warn_buf); |
4318 | } |
4319 | else |
4320 | { |
4321 | warning_note(wi, warn_buf); |
4322 | } |
4323 | } |
4324 | } |
4325 | } |
4326 | } |