ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-3.0/src/io/Globals.cpp
Revision: 2285
Committed: Wed Sep 7 20:46:46 2005 UTC (18 years, 9 months ago) by gezelter
File size: 54435 byte(s)
Log Message: 
adding c-side interface to change cutoff Policy

File Contents

# Content
1 /*
2 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 *
4 * The University of Notre Dame grants you ("Licensee") a
5 * non-exclusive, royalty free, license to use, modify and
6 * redistribute this software in source and binary code form, provided
7 * that the following conditions are met:
8 *
9 * 1. Acknowledgement of the program authors must be made in any
10 * publication of scientific results based in part on use of the
11 * program. An acceptable form of acknowledgement is citation of
12 * the article in which the program was described (Matthew
13 * A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 * J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 * Parallel Simulation Engine for Molecular Dynamics,"
16 * J. Comput. Chem. 26, pp. 252-271 (2005))
17 *
18 * 2. Redistributions of source code must retain the above copyright
19 * notice, this list of conditions and the following disclaimer.
20 *
21 * 3. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the
24 * distribution.
25 *
26 * This software is provided "AS IS," without a warranty of any
27 * kind. All express or implied conditions, representations and
28 * warranties, including any implied warranty of merchantability,
29 * fitness for a particular purpose or non-infringement, are hereby
30 * excluded. The University of Notre Dame and its licensors shall not
31 * be liable for any damages suffered by licensee as a result of
32 * using, modifying or distributing the software or its
33 * derivatives. In no event will the University of Notre Dame or its
34 * licensors be liable for any lost revenue, profit or data, or for
35 * direct, indirect, special, consequential, incidental or punitive
36 * damages, however caused and regardless of the theory of liability,
37 * arising out of the use of or inability to use software, even if the
38 * University of Notre Dame has been advised of the possibility of
39 * such damages.
40 */
41
42 #include <stdlib.h>
43 #include <stdio.h>
44 #include <string.h>
45
46 #include "io/Globals.hpp"
47 #include "utils/simError.h"
48 #ifdef IS_MPI
49 #include "io/mpiBASS.h"
50 #endif // is_mpi
51
52 /*
53 * The following section lists all of the defined tokens for the
54 * global assignment statements. All are prefixed with a G_ to avoid
55 * stepping on any previously defined enumerations.
56 *
57 * NOTE: tokens start at 1, 0 is a resrved token number
58 */
59
60 //required parameters
61 #define G_FORCEFIELD 1
62 #define G_NCOMPONENTS 2
63 #define G_TARGETTEMP 3
64 #define G_ENSEMBLE 4
65 #define G_DT 5
66 #define G_RUNTIME 6
67
68 //optional parameters
69 #define G_INITIALCONFIG 7
70 #define G_FINALCONFIG 8
71 #define G_NMOL 9
72 #define G_DENSITY 10
73 #define G_BOX 11
74 #define G_BOXX 12
75 #define G_BOXY 13
76 #define G_BOXZ 14
77 #define G_SAMPLETIME 15
78 #define G_STATUSTIME 16
79 #define G_RCUT 17
80 #define G_RSW 18
81 #define G_DIELECTRIC 19
82 #define G_TEMPSET 20
83 #define G_THERMALTIME 21
84 #define G_USEPBC 22
85 #define G_MIXINGRULE 23
86 #define G_USERF 24
87 #define G_TARGETPRESSURE 25
88 #define G_TAUTHERMOSTAT 26
89 #define G_TAUBAROSTAT 27
90 #define G_ZCONSTIME 28
91 #define G_NZCONSTRAINTS 29
92 #define G_ZCONSTOL 30
93 #define G_ZCONSFORCEPOLICY 31
94 #define G_SEED 32
95 #define G_RESETTIME 33
96 #define G_USEINITTIME 34
97 #define G_USEINIT_XS_STATE 35
98 #define G_ORTHOBOXTOLERANCE 36
99 #define G_MINIMIZER 37
100 #define G_MIN_MAXITER 38
101 #define G_MIN_WRITEFRQ 39
102 #define G_MIN_STEPSIZE 40
103 #define G_MIN_FTOL 41
104 #define G_MIN_GTOL 42
105 #define G_MIN_LSTOL 43
106 #define G_MIN_LSMAXITER 44
107 #define G_ZCONSGAP 45
108 #define G_ZCONSFIXTIME 46
109 #define G_ZCONSUSINGSMD 47
110 #define G_USE_SOLID_THERM_INT 48
111 #define G_USE_LIQUID_THERM_INT 49
112 #define G_THERM_INT_LAMBDA 50
113 #define G_THERM_INT_K 51
114 #define G_FORCEFIELD_VARIANT 52
115 #define G_FORCEFIELD_FILENAME 53
116 #define G_THERM_INT_DIST_SPRING 54
117 #define G_THERM_INT_THETA_SPRING 55
118 #define G_THERM_INT_OMEGA_SPRING 56
119 #define G_SURFACETENSION 57
120 #define G_PRINTPREESURETENSOR 58
121 #define G_USE_UNDAMPED_WOLF 59
122 #define G_USE_DAMPED_WOLF 60
123 #define G_CUTOFFPOLICY 61
124
125 Globals::Globals(){
126 initalize();
127 }
128
129 Globals::~Globals(){
130 int i;
131 if( components != NULL ){
132 for( i=0; i<n_components; i++ ) delete components[i];
133 delete[] components;
134 }
135 }
136
137 void Globals::initalize(){
138 int i;
139
140 components = NULL;
141
142 command_table.insert(CommandMapType::value_type("forceField", G_FORCEFIELD));
143 command_table.insert(CommandMapType::value_type("nComponents", G_NCOMPONENTS));
144 command_table.insert(CommandMapType::value_type("targetTemp", G_TARGETTEMP));
145 command_table.insert(CommandMapType::value_type("ensemble", G_ENSEMBLE));
146 command_table.insert(CommandMapType::value_type("dt", G_DT));
147 command_table.insert(CommandMapType::value_type("runTime", G_RUNTIME));
148 command_table.insert(CommandMapType::value_type("initialConfig", G_INITIALCONFIG));
149 command_table.insert(CommandMapType::value_type("finalConfig", G_FINALCONFIG));
150 command_table.insert(CommandMapType::value_type("nMol", G_NMOL));
151 command_table.insert(CommandMapType::value_type("density", G_DENSITY));
152 command_table.insert(CommandMapType::value_type("box", G_BOX));
153 command_table.insert(CommandMapType::value_type("boxX", G_BOXX));
154 command_table.insert(CommandMapType::value_type("boxY", G_BOXY));
155 command_table.insert(CommandMapType::value_type("boxZ", G_BOXZ));
156 command_table.insert(CommandMapType::value_type("sampleTime", G_SAMPLETIME));
157 command_table.insert(CommandMapType::value_type("resetTime", G_RESETTIME));
158 command_table.insert(CommandMapType::value_type("statusTime", G_STATUSTIME));
159 command_table.insert(CommandMapType::value_type("cutoffRadius", G_RCUT));
160 command_table.insert(CommandMapType::value_type("switchingRadius", G_RSW));
161 command_table.insert(CommandMapType::value_type("dielectric", G_DIELECTRIC));
162 command_table.insert(CommandMapType::value_type("tempSet", G_TEMPSET));
163 command_table.insert(CommandMapType::value_type("thermalTime", G_THERMALTIME));
164 command_table.insert(CommandMapType::value_type("mixingRule", G_MIXINGRULE));
165 command_table.insert(CommandMapType::value_type("usePeriodicBoundaryConditions", G_USEPBC));
166 command_table.insert(CommandMapType::value_type("useReactionField", G_USERF));
167 command_table.insert(CommandMapType::value_type("targetPressure", G_TARGETPRESSURE));
168 command_table.insert(CommandMapType::value_type("tauThermostat", G_TAUTHERMOSTAT));
169 command_table.insert(CommandMapType::value_type("tauBarostat", G_TAUBAROSTAT));
170 command_table.insert(CommandMapType::value_type("zconsTime", G_ZCONSTIME));
171 command_table.insert(CommandMapType::value_type("nZconstraints", G_NZCONSTRAINTS));
172 command_table.insert(CommandMapType::value_type("zconsTol", G_ZCONSTOL));
173 command_table.insert(CommandMapType::value_type("zconsForcePolicy", G_ZCONSFORCEPOLICY));
174 command_table.insert(CommandMapType::value_type("seed", G_SEED));
175 command_table.insert(CommandMapType::value_type("useInitialTime", G_USEINITTIME));
176 command_table.insert(CommandMapType::value_type("useInitialExtendedSystemState", G_USEINIT_XS_STATE));
177 command_table.insert(CommandMapType::value_type("orthoBoxTolerance", G_ORTHOBOXTOLERANCE));
178 command_table.insert(CommandMapType::value_type("minimizer", G_MINIMIZER));
179 command_table.insert(CommandMapType::value_type("minimizerMaxIter", G_MIN_MAXITER));
180 command_table.insert(CommandMapType::value_type("minimizerWriteFrq", G_MIN_WRITEFRQ));
181 command_table.insert(CommandMapType::value_type("minimizerStepSize", G_MIN_STEPSIZE));
182 command_table.insert(CommandMapType::value_type("minimizerFTol", G_MIN_FTOL));
183 command_table.insert(CommandMapType::value_type("minimizerGTol", G_MIN_GTOL));
184 command_table.insert(CommandMapType::value_type("minimizerLSTol", G_MIN_LSTOL));
185 command_table.insert(CommandMapType::value_type("minimizerLSMaxIter", G_MIN_LSMAXITER));
186 command_table.insert(CommandMapType::value_type("zconsGap", G_ZCONSGAP));
187 command_table.insert(CommandMapType::value_type("zconsFixtime", G_ZCONSFIXTIME));
188 command_table.insert(CommandMapType::value_type("zconsUsingSMD", G_ZCONSUSINGSMD));
189 command_table.insert(CommandMapType::value_type("useSolidThermInt", G_USE_SOLID_THERM_INT));
190 command_table.insert(CommandMapType::value_type("useLiquidThermInt", G_USE_LIQUID_THERM_INT));
191 command_table.insert(CommandMapType::value_type("thermodynamicIntegrationLambda", G_THERM_INT_LAMBDA));
192 command_table.insert(CommandMapType::value_type("thermodynamicIntegrationK", G_THERM_INT_K));
193 command_table.insert(CommandMapType::value_type("forceFieldVariant", G_FORCEFIELD_VARIANT));
194 command_table.insert(CommandMapType::value_type("forceFieldFileName", G_FORCEFIELD_FILENAME));
195 command_table.insert(CommandMapType::value_type("thermIntDistSpringConst", G_THERM_INT_DIST_SPRING));
196 command_table.insert(CommandMapType::value_type("thermIntThetaSpringConst", G_THERM_INT_THETA_SPRING));
197 command_table.insert(CommandMapType::value_type("thermIntOmegaSpringConst", G_THERM_INT_OMEGA_SPRING));
198 command_table.insert(CommandMapType::value_type("surfaceTension", G_SURFACETENSION));
199 command_table.insert(CommandMapType::value_type("printPressureTensor", G_PRINTPREESURETENSOR));
200 command_table.insert(CommandMapType::value_type("useUndampedWolf", G_USE_UNDAMPED_WOLF));
201 command_table.insert(CommandMapType::value_type("useDampedWolf", G_USE_DAMPED_WOLF));
202 command_table.insert(CommandMapType::value_type("cutoffPolicy", G_CUTOFFPOLICY));
203
204 strcpy( mixingRule,"standard"); //default mixing rules to standard.
205 usePBC = 1; //default periodic boundry conditions to on
206 useRF = 0;
207 useInitTime = 0; // default to pull init time from the init file
208 useInitXSstate = 0; // default to pull the extended state from the init file
209 orthoBoxTolerance = 1E-6;
210 useSolidThermInt = 0; // default solid-state thermodynamic integration to off
211 useLiquidThermInt = 0; // default liquid thermodynamic integration to off
212
213 have_force_field = 0;
214 have_n_components = 0;
215 have_target_temp = 0;
216 have_ensemble = 0;
217 have_dt = 0;
218 have_run_time = 0;
219
220 have_initial_config = 0;
221 have_final_config = 0;
222 have_n_mol = 0;
223 have_density = 0;
224 have_box = 0;
225 have_box_x = 0;
226 have_box_y = 0;
227 have_box_y = 0;
228 have_box_z = 0;
229 have_sample_time = 0;
230 have_status_time = 0;
231 have_reset_time = 0;
232 have_thermal_time = 0;
233 have_rcut = 0;
234 have_rsw = 0;
235 have_dielectric = 0;
236 have_tempSet = 0;
237 have_target_pressure =0;
238 have_q_mass = 0;
239 have_tau_thermostat = 0;
240 have_tau_barostat = 0;
241 have_zcons_time = 0;
242 have_n_zConstraints = 0;
243 have_zConstraints = 0;
244 have_zcons_tol = 0;
245 have_zcons_gap = 0;
246 have_zcons_fixtime = 0;
247 have_zcons_using_smd = 0;
248 have_seed = 0;
249 have_minimizer = 0;
250 have_minimizer_maxiteration = 0;
251 have_minimizer_writefrq = 0;
252 have_minimizer_stepsize = 0;
253 have_minimizer_ftol = 0;
254 have_minimizer_gtol = 0;
255 have_minimizer_ls_tol = 0;
256 have_minimizer_ls_maxiteration = 0;
257 have_thermodynamic_integration_lambda = 0;
258 have_thermodynamic_integration_k = 0;
259 have_forcefield_variant = 0;
260 have_forcefield_filename = 0;
261 have_dist_spring_constant = 0;
262 have_theta_spring_constant = 0;
263 have_omega_spring_constant = 0;
264 have_surface_tension = 0;
265 have_print_pressure_tensor = 0;
266 have_cutoff_policy = 0;
267 }
268
269 int Globals::newComponent( event* the_event ){
270
271 current_component = new Component;
272 int index = the_event->evt.blk_index;
273 char err[200];
274
275 if( have_n_components && index < n_components )
276 components[index] = current_component;
277 else{
278 if( have_n_components ){
279 sprintf( err, "meta-data parsing error: %d out of nComponents range",
280 index );
281 the_event->err_msg = strdup( err );
282 return 0;
283 }
284 else{
285 the_event->err_msg = strdup("meta-data parsing error: nComponents not given before"
286 " first component declaration." );
287 return 0;
288 }
289 }
290
291 return 1;
292 }
293
294
295
296 int Globals::componentAssign( event* the_event ){
297
298 switch( the_event->evt.asmt.asmt_type ){
299
300 case STRING:
301 return current_component->assignString( the_event->evt.asmt.lhs,
302 the_event->evt.asmt.rhs.sval,
303 &(the_event->err_msg));
304 break;
305
306 case DOUBLE:
307 return current_component->assignDouble( the_event->evt.asmt.lhs,
308 the_event->evt.asmt.rhs.dval,
309 &(the_event->err_msg));
310 break;
311
312 case INT:
313 return current_component->assignInt( the_event->evt.asmt.lhs,
314 the_event->evt.asmt.rhs.ival,
315 &(the_event->err_msg));
316 break;
317
318 default:
319 the_event->err_msg = strdup( "Globals error. Invalid component"
320 " assignment type" );
321 return 0;
322 break;
323 }
324 return 0;
325 }
326
327 int Globals::componentEnd( event* the_event ){
328
329 the_event->err_msg = current_component->checkMe();
330 if( the_event->err_msg != NULL ) return 0;
331
332 return 1;
333 }
334
335 int Globals::newZconstraint( event* the_event ){
336
337
338 int index = the_event->evt.blk_index;
339 char err[200];
340 current_zConstraint = new ZconStamp( index );
341
342 have_zConstraints = 1;
343
344 if( have_n_zConstraints && index < n_zConstraints )
345 zConstraints[index] = current_zConstraint;
346 else{
347 if( have_n_zConstraints ){
348 sprintf( err, "meta-data parsing error: %d out of nZconstraints range",
349 index );
350 the_event->err_msg = strdup( err );
351 return 0;
352 }
353 else{
354 the_event->err_msg = strdup("meta-data parsing error: nZconstraints"
355 " not given before"
356 " first zConstraint declaration." );
357 return 0;
358 }
359 }
360
361 return 1;
362 }
363
364
365
366 int Globals::zConstraintAssign( event* the_event ){
367
368 switch( the_event->evt.asmt.asmt_type ){
369
370 case STRING:
371 return current_zConstraint->assignString( the_event->evt.asmt.lhs,
372 the_event->evt.asmt.rhs.sval,
373 &(the_event->err_msg));
374 break;
375
376 case DOUBLE:
377 return current_zConstraint->assignDouble( the_event->evt.asmt.lhs,
378 the_event->evt.asmt.rhs.dval,
379 &(the_event->err_msg));
380 break;
381
382 case INT:
383 return current_zConstraint->assignInt( the_event->evt.asmt.lhs,
384 the_event->evt.asmt.rhs.ival,
385 &(the_event->err_msg));
386 break;
387
388 default:
389 the_event->err_msg = strdup( "Globals error. Invalid zConstraint"
390 " assignment type" );
391 return 0;
392 break;
393 }
394 return 0;
395 }
396
397 int Globals::zConstraintEnd( event* the_event ){
398
399 the_event->err_msg = current_zConstraint->checkMe();
400 if( the_event->err_msg != NULL ) return 0;
401
402 return 1;
403 }
404
405 int Globals::globalAssign( event* the_event ){
406
407 int key;
408 int token;
409 interface_assign_type the_type = the_event->evt.asmt.asmt_type;
410 char* lhs = the_event->evt.asmt.lhs;
411 char err[300];
412
413 token = 0;
414
415 CommandMapType::iterator iter;
416 std::string keyword(lhs);
417 iter = command_table.find(keyword);
418 if (iter != command_table.end()) {
419 token = iter->second;
420 }
421
422 if( token ){
423
424 switch( token ){
425
426 case G_FORCEFIELD:
427 if( the_type == STRING ){
428 strcpy( force_field, the_event->evt.asmt.rhs.sval );
429 have_force_field = 1;
430 return 1;
431 }
432
433 the_event->err_msg =
434 strdup( "Error in parsing meta-data file!\n\tforceField was not a string assignment.\n" );
435 return 0;
436 break;
437
438 case G_NCOMPONENTS:
439 if( the_type == STRING ){
440 the_event->err_msg =
441 strdup("Error in parsing meta-data file!\n\tnComponents is not a double or an int.\n" );
442 return 0;
443 }
444
445 else if( the_type == DOUBLE ){
446 n_components = (int)the_event->evt.asmt.rhs.dval;
447 components = new Component*[n_components];
448 have_n_components = 1;
449 return 1;
450 }
451
452 else{
453 n_components = the_event->evt.asmt.rhs.ival;
454 components = new Component*[n_components];
455 have_n_components = 1;
456 return 1;
457 }
458 break;
459
460 case G_NZCONSTRAINTS:
461 if( the_type == STRING ){
462 the_event->err_msg =
463 strdup("Error in parsing meta-data file!\n\tnZconstraints is not a double or an int.\n" );
464 return 0;
465 }
466
467 else if( the_type == DOUBLE ){
468 n_zConstraints = (int)the_event->evt.asmt.rhs.dval;
469 zConstraints = new ZconStamp*[n_zConstraints];
470 have_n_zConstraints = 1;
471 return 1;
472 }
473
474 else{
475 n_zConstraints = the_event->evt.asmt.rhs.ival;
476 zConstraints = new ZconStamp*[n_zConstraints];
477 have_n_zConstraints = 1;
478 return 1;
479 }
480 break;
481
482 case G_TARGETTEMP:
483 switch( the_type ){
484
485 case STRING:
486 the_event->err_msg =
487 strdup( "Error in parsing meta-data file!\n\ttargetTemp is not a double or int.\n" );
488 return 0;
489 break;
490
491 case DOUBLE:
492 target_temp = the_event->evt.asmt.rhs.dval;
493 have_target_temp = 1;
494 return 1;
495 break;
496
497 case INT:
498 target_temp = (double)the_event->evt.asmt.rhs.ival;
499 have_target_temp = 1;
500 return 1;
501 break;
502
503 default:
504 the_event->err_msg =
505 strdup( "Error in parsing meta-data file!\n\ttargetTemp unrecognized.\n" );
506 return 0;
507 break;
508 }
509 break;
510
511 case G_ORTHOBOXTOLERANCE:
512 switch( the_type ){
513
514 case STRING:
515 the_event->err_msg =
516 strdup( "Error in parsing meta-data file!\n\torthoBoxTolerance is not a double or int.\n" );
517 return 0;
518 break;
519
520 case DOUBLE:
521 orthoBoxTolerance = the_event->evt.asmt.rhs.dval;
522 have_target_temp = 1;
523 return 1;
524 break;
525
526 case INT:
527 orthoBoxTolerance = (double)the_event->evt.asmt.rhs.ival;
528 have_target_temp = 1;
529 return 1;
530 break;
531
532 default:
533 the_event->err_msg =
534 strdup( "Global error.orthoBoxTolerance unrecognized.\n" );
535 return 0;
536 break;
537 }
538 break;
539
540 case G_ENSEMBLE:
541 if( the_type == STRING ){
542 strcpy( ensemble, the_event->evt.asmt.rhs.sval );
543 have_ensemble = 1;
544 return 1;
545 }
546
547 the_event->err_msg =
548 strdup( "Error in parsing meta-data file!\n\tensemble was not assigned to a string\n" );
549 return 0;
550 break;
551
552 case G_MIXINGRULE:
553 if( the_type == STRING ){
554 strcpy( mixingRule, the_event->evt.asmt.rhs.sval );
555 return 1;
556 }
557
558 the_event->err_msg =
559 strdup( "Error in parsing meta-data file!\n\tmixing rule was not assigned to a string\n" );
560 return 0;
561 break;
562
563 case G_DT:
564 switch( the_type ){
565
566 case STRING:
567 the_event->err_msg =
568 strdup( "Error in parsing meta-data file!\n\tdt is not a double or int.\n" );
569 return 0;
570 break;
571
572 case DOUBLE:
573 dt = the_event->evt.asmt.rhs.dval;
574 have_dt = 1;
575 return 1;
576 break;
577
578 case INT:
579 dt = (double)the_event->evt.asmt.rhs.ival;
580 have_dt = 1;
581 return 1;
582 break;
583
584 default:
585 the_event->err_msg =
586 strdup( "Error in parsing meta-data file!\n\tdt unrecognized.\n" );
587 return 0;
588 break;
589 }
590 break;
591
592 case G_RUNTIME:
593 switch( the_type ){
594
595 case STRING:
596 the_event->err_msg =
597 strdup( "Error in parsing meta-data file!\n\trunTime is not a double or int.\n" );
598 return 0;
599 break;
600
601 case DOUBLE:
602 run_time = the_event->evt.asmt.rhs.dval;
603 have_run_time = 1;
604 return 1;
605 break;
606
607 case INT:
608 run_time = (double)the_event->evt.asmt.rhs.ival;
609 have_run_time = 1;
610 return 1;
611 break;
612
613 default:
614 the_event->err_msg =
615 strdup( "Error in parsing meta-data file!\n\trunTime unrecognized.\n" );
616 return 0;
617 break;
618 }
619 break;
620
621 case G_INITIALCONFIG:
622 if( the_type == STRING ){
623 strcpy( initial_config, the_event->evt.asmt.rhs.sval );
624 have_initial_config = 1;
625 return 1;
626 }
627
628 the_event->err_msg =
629 strdup( "Error in parsing meta-data file!\n\tinitialConfig was not a string assignment.\n" );
630 return 0;
631 break;
632
633 case G_FINALCONFIG:
634 if( the_type == STRING ){
635 strcpy( final_config, the_event->evt.asmt.rhs.sval );
636 have_final_config = 1;
637 return 1;
638 }
639
640 the_event->err_msg =
641 strdup( "Error in parsing meta-data file!\n\tfinalConfig was not a string assignment.\n" );
642 return 0;
643 break;
644
645 case G_NMOL:
646 switch( the_type ){
647
648 case STRING:
649 the_event->err_msg =
650 strdup( "Error in parsing meta-data file!\n\tnMol is not a double or int.\n" );
651 return 0;
652 break;
653
654 case DOUBLE:
655 n_mol = (int)the_event->evt.asmt.rhs.dval;
656 have_n_mol = 1;
657 return 1;
658 break;
659
660 case INT:
661 n_mol = the_event->evt.asmt.rhs.ival;
662 have_n_mol = 1;
663 return 1;
664 break;
665
666 default:
667 the_event->err_msg =
668 strdup( "Error in parsing meta-data file!\n\tnMol unrecognized.\n" );
669 return 0;
670 break;
671 }
672 break;
673
674 case G_DENSITY:
675 switch( the_type ){
676
677 case STRING:
678 the_event->err_msg =
679 strdup( "Error in parsing meta-data file!\n\tdensity is not a double or int.\n" );
680 return 0;
681 break;
682
683 case DOUBLE:
684 density = the_event->evt.asmt.rhs.dval;
685 have_density = 1;
686 return 1;
687 break;
688
689 case INT:
690 density = (double)the_event->evt.asmt.rhs.ival;
691 have_density = 1;
692 return 1;
693 break;
694
695 default:
696 the_event->err_msg =
697 strdup( "Error in parsing meta-data file!\n\tdensity unrecognized.\n" );
698 return 0;
699 break;
700 }
701 break;
702
703 case G_BOX:
704 switch( the_type ){
705
706 case STRING:
707 the_event->err_msg =
708 strdup( "Error in parsing meta-data file!\n\tbox is not a double or int.\n" );
709 return 0;
710 break;
711
712 case DOUBLE:
713 box = the_event->evt.asmt.rhs.dval;
714 have_box = 1;
715 return 1;
716 break;
717
718 case INT:
719 box = (double)the_event->evt.asmt.rhs.ival;
720 have_box = 1;
721 return 1;
722 break;
723
724 default:
725 the_event->err_msg =
726 strdup( "Error in parsing meta-data file!\n\tbox unrecognized.\n" );
727 return 0;
728 break;
729 }
730 break;
731
732 case G_BOXX:
733 switch( the_type ){
734
735 case STRING:
736 the_event->err_msg =
737 strdup( "Error in parsing meta-data file!\n\tboxX is not a double or int.\n" );
738 return 0;
739 break;
740
741 case DOUBLE:
742 box_x = the_event->evt.asmt.rhs.dval;
743 have_box_x = 1;
744 return 1;
745 break;
746
747 case INT:
748 box_x = (double)the_event->evt.asmt.rhs.ival;
749 have_box_x = 1;
750 return 1;
751 break;
752
753 default:
754 the_event->err_msg =
755 strdup( "Error in parsing meta-data file!\n\tboxX unrecognized.\n" );
756 return 0;
757 break;
758 }
759 break;
760
761 case G_BOXY:
762 switch( the_type ){
763
764 case STRING:
765 the_event->err_msg =
766 strdup( "Error in parsing meta-data file!\n\tboxY is not a double or int.\n" );
767 return 0;
768 break;
769
770 case DOUBLE:
771 box_y = the_event->evt.asmt.rhs.dval;
772 have_box_y = 1;
773 return 1;
774 break;
775
776 case INT:
777 box_y = (double)the_event->evt.asmt.rhs.ival;
778 have_box_y = 1;
779 return 1;
780 break;
781
782 default:
783 the_event->err_msg =
784 strdup( "Error in parsing meta-data file!\n\tboxY unrecognized.\n" );
785 return 0;
786 break;
787 }
788 break;
789
790 case G_BOXZ:
791 switch( the_type ){
792
793 case STRING:
794 the_event->err_msg =
795 strdup( "Error in parsing meta-data file!\n\tboxZ is not a double or int.\n" );
796 return 0;
797 break;
798
799 case DOUBLE:
800 box_z = the_event->evt.asmt.rhs.dval;
801 have_box_z = 1;
802 return 1;
803 break;
804
805 case INT:
806 box_z = (double)the_event->evt.asmt.rhs.ival;
807 have_box_z = 1;
808 return 1;
809 break;
810
811 default:
812 the_event->err_msg =
813 strdup( "Error in parsing meta-data file!\n\tboxZ unrecognized.\n" );
814 return 0;
815 break;
816 }
817 break;
818
819 case G_SAMPLETIME:
820 switch( the_type ){
821
822 case STRING:
823 the_event->err_msg =
824 strdup( "Error in parsing meta-data file!\n\tsampleTime is not a double or int.\n" );
825 return 0;
826 break;
827
828 case DOUBLE:
829 sample_time = the_event->evt.asmt.rhs.dval;
830 have_sample_time = 1;
831 return 1;
832 break;
833
834 case INT:
835 sample_time = (double)the_event->evt.asmt.rhs.ival;
836 have_sample_time = 1;
837 return 1;
838 break;
839
840 default:
841 the_event->err_msg =
842 strdup( "Error in parsing meta-data file!\n\tsampleTime unrecognized.\n" );
843 return 0;
844 break;
845 }
846 break;
847
848 case G_STATUSTIME:
849 switch( the_type ){
850
851 case STRING:
852 the_event->err_msg =
853 strdup( "Error in parsing meta-data file!\n\tstatusTime is not a double or int.\n" );
854 return 0;
855 break;
856
857 case DOUBLE:
858 status_time = the_event->evt.asmt.rhs.dval;
859 have_status_time = 1;
860 return 1;
861 break;
862
863 case INT:
864 status_time = (double)the_event->evt.asmt.rhs.ival;
865 have_status_time = 1;
866 return 1;
867 break;
868
869 default:
870 the_event->err_msg =
871 strdup( "Error in parsing meta-data file!\n\tstatusTime unrecognized.\n" );
872 return 0;
873 break;
874 }
875 break;
876
877 case G_RESETTIME:
878 switch( the_type ){
879
880 case STRING:
881 the_event->err_msg =
882 strdup( "Error in parsing meta-data file!\n\tresetTime is not a double or int.\n" );
883 return 0;
884 break;
885
886 case DOUBLE:
887 resetTime = the_event->evt.asmt.rhs.dval;
888 have_reset_time = 1;
889 return 1;
890 break;
891
892 case INT:
893 resetTime = (double)the_event->evt.asmt.rhs.ival;
894 have_reset_time = 1;
895 return 1;
896 break;
897
898 default:
899 the_event->err_msg =
900 strdup( "Error in parsing meta-data file!\n\tresetTime unrecognized.\n" );
901 return 0;
902 break;
903 }
904 break;
905
906 case G_THERMALTIME:
907 switch( the_type ){
908
909 case STRING:
910 the_event->err_msg =
911 strdup( "Error in parsing meta-data file!\n\tthermalTime is not a double or int.\n" );
912 return 0;
913 break;
914
915 case DOUBLE:
916 thermal_time = the_event->evt.asmt.rhs.dval;
917 have_thermal_time = 1;
918 return 1;
919 break;
920
921 case INT:
922 thermal_time = (double)the_event->evt.asmt.rhs.ival;
923 have_thermal_time = 1;
924 return 1;
925 break;
926
927 default:
928 the_event->err_msg =
929 strdup( "Error in parsing meta-data file!\n\tthermalTime unrecognized.\n" );
930 return 0;
931 break;
932 }
933 break;
934
935 case G_RCUT:
936 switch( the_type ){
937
938 case STRING:
939 the_event->err_msg =
940 strdup( "Error in parsing meta-data file!\n\tcutoffRadius is not a double or int.\n" );
941 return 0;
942 break;
943
944 case DOUBLE:
945 rcut = the_event->evt.asmt.rhs.dval;
946 have_rcut = 1;
947 return 1;
948 break;
949
950 case INT:
951 rcut = (double)the_event->evt.asmt.rhs.ival;
952 have_rcut = 1;
953 return 1;
954 break;
955
956 default:
957 the_event->err_msg =
958 strdup( "Error in parsing meta-data file!\n\tcutoffRadius unrecognized.\n" );
959 return 0;
960 break;
961 }
962 break;
963
964 case G_RSW:
965 switch( the_type ){
966
967 case STRING:
968 the_event->err_msg =
969 strdup( "Error in parsing meta-data file!\n\tswitchingRadius is not a double or int.\n" );
970 return 0;
971 break;
972
973 case DOUBLE:
974 rsw = the_event->evt.asmt.rhs.dval;
975 have_rsw = 1;
976 return 1;
977 break;
978
979 case INT:
980 rsw = (double)the_event->evt.asmt.rhs.ival;
981 have_rsw = 1;
982 return 1;
983 break;
984
985 default:
986 the_event->err_msg =
987 strdup( "Error in parsing meta-data file!\n\tswitchingRadius unrecognized.\n" );
988 return 0;
989 break;
990 }
991 break;
992
993 case G_DIELECTRIC:
994 switch( the_type ){
995
996 case STRING:
997 the_event->err_msg =
998 strdup( "Error in parsing meta-data file!\n\tdielectric is not a double or int.\n" );
999 return 0;
1000 break;
1001
1002 case DOUBLE:
1003 dielectric = the_event->evt.asmt.rhs.dval;
1004 have_dielectric = 1;
1005 return 1;
1006 break;
1007
1008 case INT:
1009 dielectric = (double)the_event->evt.asmt.rhs.ival;
1010 have_dielectric = 1;
1011 return 1;
1012 break;
1013
1014 default:
1015 the_event->err_msg =
1016 strdup( "Error in parsing meta-data file!\n\tdielectric unrecognized.\n" );
1017 return 0;
1018 break;
1019 }
1020 break;
1021
1022 case G_TEMPSET:
1023 if( the_type == STRING ){
1024
1025 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
1026 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
1027 else{
1028 the_event->err_msg =
1029 strdup( "Error in parsing meta-data file!\n\ttempSet was not \"true\" or \"false\".\n" );
1030 return 0;
1031 }
1032 have_tempSet = 1;
1033 return 1;
1034 }
1035
1036 the_event->err_msg =
1037 strdup( "Error in parsing meta-data file!\n\ttempSet was not \"true\" or \"false\".\n" );
1038 return 0;
1039 break;
1040
1041 case G_USEINITTIME:
1042 if( the_type == STRING ){
1043
1044 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useInitTime = 1;
1045 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useInitTime = 0;
1046 else{
1047 the_event->err_msg =
1048 strdup( "Error in parsing meta-data file!\n\tuseInitTime was not \"true\" or \"false\".\n" );
1049 return 0;
1050 }
1051 return 1;
1052 }
1053
1054 the_event->err_msg =
1055 strdup( "Error in parsing meta-data file!\n\tuseInitTime was not \"true\" or \"false\".\n" );
1056 return 0;
1057 break;
1058
1059 case G_USEINIT_XS_STATE:
1060 if( the_type == STRING ){
1061
1062 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval ))
1063 useInitXSstate = 1;
1064 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval ))
1065 useInitXSstate = 0;
1066 else{
1067 the_event->err_msg =
1068 strdup( "Error in parsing meta-data file!\n\tuseInitExtendedSystemState was not \"true\" or \"false\".\n" );
1069 return 0;
1070 }
1071 return 1;
1072 }
1073
1074 the_event->err_msg =
1075 strdup( "Error in parsing meta-data file!\n\tuseInitExtendedSystemState was not \"true\" or \"false\".\n" );
1076 return 0;
1077 break;
1078
1079 case G_USEPBC:
1080 if( the_type == STRING ){
1081
1082 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
1083 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
1084 else{
1085 the_event->err_msg =
1086 strdup( "Error in parsing meta-data file!\n\tusePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
1087 return 0;
1088 }
1089 return 1;
1090 }
1091
1092 the_event->err_msg =
1093 strdup( "Error in parsing meta-data file!\n\tusePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
1094 return 0;
1095 break;
1096
1097 case G_USERF:
1098 if( the_type == STRING ){
1099
1100 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
1101 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0;
1102 else{
1103 the_event->err_msg =
1104 strdup( "Error in parsing meta-data file!\n\tuseReactionField was not \"true\" or \"false\".\n" );
1105 return 0;
1106 }
1107 return 1;
1108 }
1109
1110 the_event->err_msg =
1111 strdup( "Error in parsing meta-data file!\n\tuseReactionField was not \"true\" or \"false\".\n" );
1112 return 0;
1113 break;
1114
1115 case G_TARGETPRESSURE:
1116 switch( the_type ){
1117
1118 case STRING:
1119 the_event->err_msg =
1120 strdup( "Error in parsing meta-data file!\n\ttargetPressure is not a double or int.\n" );
1121 return 0;
1122 break;
1123
1124 case DOUBLE:
1125 target_pressure = the_event->evt.asmt.rhs.dval;
1126 have_target_pressure = 1;
1127 return 1;
1128 break;
1129
1130 case INT:
1131 target_pressure = (double)the_event->evt.asmt.rhs.ival;
1132 have_target_pressure = 1;
1133 return 1;
1134 break;
1135
1136 default:
1137 the_event->err_msg =
1138 strdup( "Error in parsing meta-data file!\n\ttargetPressure unrecognized.\n" );
1139 return 0;
1140 break;
1141 }
1142 break;
1143
1144 case G_TAUTHERMOSTAT:
1145 switch( the_type ){
1146
1147 case STRING:
1148 the_event->err_msg =
1149 strdup( "Error in parsing meta-data file!\n\ttauThermostat is not a double or int.\n" );
1150 return 0;
1151 break;
1152
1153 case DOUBLE:
1154 tau_thermostat = the_event->evt.asmt.rhs.dval;
1155 have_tau_thermostat = 1;
1156 return 1;
1157 break;
1158
1159 case INT:
1160 tau_thermostat = (double)the_event->evt.asmt.rhs.ival;
1161 have_tau_thermostat = 1;
1162 return 1;
1163 break;
1164
1165 default:
1166 the_event->err_msg =
1167 strdup( "Error in parsing meta-data file!\n\ttauThermostat unrecognized.\n" );
1168 return 0;
1169 break;
1170 }
1171 break;
1172
1173 case G_TAUBAROSTAT:
1174 switch( the_type ){
1175
1176 case STRING:
1177 the_event->err_msg =
1178 strdup( "Error in parsing meta-data file!\n\ttauBarostat is not a double or int.\n" );
1179 return 0;
1180 break;
1181
1182 case DOUBLE:
1183 tau_barostat = the_event->evt.asmt.rhs.dval;
1184 have_tau_barostat = 1;
1185 return 1;
1186 break;
1187
1188 case INT:
1189 tau_barostat = (double)the_event->evt.asmt.rhs.ival;
1190 have_tau_barostat = 1;
1191 return 1;
1192 break;
1193
1194 default:
1195 the_event->err_msg =
1196 strdup( "Error in parsing meta-data file!\n\ttauBarostat unrecognized.\n" );
1197 return 0;
1198 break;
1199 }
1200 break;
1201
1202 case G_ZCONSTIME:
1203 switch( the_type ){
1204
1205 case STRING:
1206 the_event->err_msg =
1207 strdup( "Error in parsing meta-data file!\n\tzcons_time is not a double or int.\n" );
1208 return 0;
1209 break;
1210
1211 case DOUBLE:
1212 zcons_time = the_event->evt.asmt.rhs.dval;
1213 have_zcons_time = 1;
1214 return 1;
1215 break;
1216
1217 case INT:
1218 zcons_time = (double)the_event->evt.asmt.rhs.ival;
1219 have_zcons_time = 1;
1220 return 1;
1221 break;
1222
1223 default:
1224 the_event->err_msg =
1225 strdup( "Error in parsing meta-data file!\n\tzcons_time unrecognized.\n" );
1226 return 0;
1227 break;
1228 }
1229 break;
1230
1231 case G_ZCONSTOL:
1232 switch( the_type ){
1233
1234 case STRING:
1235 the_event->err_msg =
1236 strdup( "Error in parsing meta-data file!\n\tzcons_tol is not a double or int.\n" );
1237 return 0;
1238 break;
1239
1240 case DOUBLE:
1241 zcons_tol = the_event->evt.asmt.rhs.dval;
1242 have_zcons_tol = 1;
1243 return 1;
1244 break;
1245
1246 case INT:
1247 zcons_tol = (double)the_event->evt.asmt.rhs.ival;
1248 have_zcons_tol = 1;
1249 return 1;
1250 break;
1251
1252 default:
1253 the_event->err_msg =
1254 strdup( "Error in parsing meta-data file!\n\tzcons_ol unrecognized.\n" );
1255 return 0;
1256 break;
1257 }
1258 break;
1259
1260 case G_ZCONSFORCEPOLICY:
1261 switch( the_type ){
1262
1263 case STRING:
1264 strcpy(zconsForcePolicy, the_event->evt.asmt.rhs.sval);
1265
1266 for(int i = 0; zconsForcePolicy[i] != '\0'; i++)
1267 {
1268 zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1269 }
1270 have_zcons_force_policy = 1;
1271 return 1;
1272 break;
1273
1274 case DOUBLE:
1275 the_event->err_msg =
1276 strdup( "Error in parsing meta-data file!\n\tzconsForcePolicy is not a double or int.\n" );
1277 return 0;
1278 break;
1279
1280 case INT:
1281 the_event->err_msg =
1282 strdup( "Error in parsing meta-data file!\n\tzconsForcePolicy is not a double or int.\n" );
1283 return 0;
1284 break;
1285
1286 default:
1287 the_event->err_msg =
1288 strdup( "Error in parsing meta-data file!\n\tzconsForcePolicy unrecognized.\n" );
1289 return 0;
1290 break;
1291 }
1292 break;
1293
1294 case G_ZCONSGAP:
1295 switch( the_type ){
1296
1297 case STRING:
1298 the_event->err_msg =
1299 strdup( "Error in parsing meta-data file!\n\tzcons_gap is not a double or int.\n" );
1300 return 0;
1301 break;
1302
1303 case DOUBLE:
1304 zcons_gap = the_event->evt.asmt.rhs.dval;
1305 have_zcons_gap= 1;
1306 return 1;
1307 break;
1308
1309 case INT:
1310 zcons_gap= (double)the_event->evt.asmt.rhs.ival;
1311 have_zcons_gap= 1;
1312 return 1;
1313 break;
1314
1315 default:
1316 the_event->err_msg =
1317 strdup( "Error in parsing meta-data file!\n\tzcons_gap unrecognized.\n" );
1318 return 0;
1319 break;
1320 }
1321 break;
1322
1323 case G_ZCONSFIXTIME:
1324 switch( the_type ){
1325
1326 case STRING:
1327 the_event->err_msg =
1328 strdup( "Error in parsing meta-data file!\n\tzcons_fixtime is not a double or int.\n" );
1329 return 0;
1330 break;
1331
1332 case DOUBLE:
1333 zcons_fixtime= the_event->evt.asmt.rhs.dval;
1334 have_zcons_fixtime= 1;
1335 return 1;
1336 break;
1337
1338 case INT:
1339 zcons_fixtime= (double)the_event->evt.asmt.rhs.ival;
1340 have_zcons_fixtime= 1;
1341 return 1;
1342 break;
1343
1344 default:
1345 the_event->err_msg =
1346 strdup( "Error in parsing meta-data file!\n\tzcons_fixtime unrecognized.\n" );
1347 return 0;
1348 break;
1349 }
1350 break;
1351
1352 case G_ZCONSUSINGSMD:
1353 switch( the_type ){
1354
1355 case STRING:
1356 the_event->err_msg =
1357 strdup( "Error in parsing meta-data file!\n\tzcons_fixtime is not an int.\n" );
1358 return 0;
1359 break;
1360
1361 case DOUBLE:
1362 the_event->err_msg =
1363 strdup( "Error in parsing meta-data file!\n\tzcons_fixtime is not an int.\n" );
1364 return 0;
1365 break;
1366
1367 case INT:
1368 zcons_using_smd= the_event->evt.asmt.rhs.ival;
1369 have_zcons_using_smd= 1;
1370 return 1;
1371 break;
1372
1373 default:
1374 the_event->err_msg =
1375 strdup( "Error in parsing meta-data file!\n\tzcons_usingsmd unrecognized.\n" );
1376 return 0;
1377 break;
1378 }
1379 break;
1380
1381 case G_MINIMIZER:
1382 switch( the_type ){
1383
1384 case STRING:
1385 strcpy(minimizer_name, the_event->evt.asmt.rhs.sval);
1386
1387 for(int i = 0; zconsForcePolicy[i] != '\0'; i++){
1388 zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1389 }
1390 have_minimizer= 1;
1391 return 1;
1392 break;
1393
1394 case DOUBLE:
1395 the_event->err_msg =
1396 strdup( "Error in parsing meta-data file!\n\tminimizer_name is not a double or int.\n" );
1397 return 0;
1398 break;
1399
1400 case INT:
1401 the_event->err_msg =
1402 strdup( "Error in parsing meta-data file!\n\tminimizer_name is not a double or int.\n" );
1403 return 0;
1404 break;
1405
1406 default:
1407 the_event->err_msg =
1408 strdup( "Error in parsing meta-data file!\n\tminimizer_name unrecognized.\n" );
1409 return 0;
1410 break;
1411 }
1412 break;
1413
1414 case G_MIN_MAXITER:
1415 switch( the_type ){
1416
1417 case STRING:
1418 the_event->err_msg =
1419 strdup( "Error in parsing meta-data file!\n\tminimizer_maxiteration is not a double or int.\n" );
1420 return 1;
1421 break;
1422
1423 case DOUBLE:
1424 minimizer_maxiteration = (int)the_event->evt.asmt.rhs.dval;
1425 have_minimizer_maxiteration = 1;
1426 return 1;
1427 break;
1428
1429 case INT:
1430 minimizer_maxiteration = the_event->evt.asmt.rhs.ival;
1431 have_minimizer_maxiteration = 1;
1432 return 1;
1433 break;
1434
1435 default:
1436 the_event->err_msg =
1437 strdup( "Error in parsing meta-data file!\n\tminimizer_maxiteration unrecognized.\n" );
1438 return 0;
1439 break;
1440 }
1441 break;
1442
1443 case G_MIN_WRITEFRQ:
1444 switch( the_type ){
1445
1446 case STRING:
1447 the_event->err_msg =
1448 strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq is not an int.\n" );
1449 return 1;
1450 break;
1451
1452 case DOUBLE:
1453 the_event->err_msg =
1454 strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq is not an int.\n" );
1455 return 1;
1456 break;
1457
1458 case INT:
1459 minimizer_writefrq= the_event->evt.asmt.rhs.ival;
1460 have_minimizer_writefrq = 1;
1461 return 1;
1462 break;
1463
1464 default:
1465 the_event->err_msg =
1466 strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq unrecognized.\n" );
1467 return 0;
1468 break;
1469 }
1470 break;
1471
1472 case G_MIN_STEPSIZE:
1473 switch( the_type ){
1474
1475 case STRING:
1476 the_event->err_msg =
1477 strdup( "Error in parsing meta-data file!\n\tminimizer_resetfrq is not a double or int.\n" );
1478 return 1;
1479 break;
1480
1481 case DOUBLE:
1482 minimizer_stepsize= the_event->evt.asmt.rhs.dval;
1483 have_minimizer_stepsize = 1;
1484 return 1;
1485 break;
1486
1487 case INT:
1488 minimizer_stepsize= the_event->evt.asmt.rhs.ival;
1489 have_minimizer_stepsize = 1;
1490 return 1;
1491 break;
1492
1493 default:
1494 the_event->err_msg =
1495 strdup( "Error in parsing meta-data file!\n\tminimizer_resetfrq unrecognized.\n" );
1496 return 0;
1497 break;
1498 }
1499 break;
1500
1501 case G_MIN_FTOL:
1502 switch( the_type ){
1503
1504 case STRING:
1505 the_event->err_msg =
1506 strdup( "Error in parsing meta-data file!\n\tminimizer_ftol is not a double or int.\n" );
1507 return 1;
1508 break;
1509
1510 case DOUBLE:
1511 minimizer_ftol= the_event->evt.asmt.rhs.dval;
1512 have_minimizer_ftol = 1;
1513 return 1;
1514 break;
1515
1516 case INT:
1517 minimizer_ftol= the_event->evt.asmt.rhs.ival;
1518 have_minimizer_ftol = 1;
1519 return 1;
1520 break;
1521
1522 default:
1523 the_event->err_msg =
1524 strdup( "Error in parsing meta-data file!\n\tminimizer_ftol unrecognized.\n" );
1525 return 0;
1526 break;
1527 }
1528 break;
1529
1530 case G_MIN_GTOL:
1531 switch( the_type ){
1532
1533 case STRING:
1534 the_event->err_msg =
1535 strdup( "Error in parsing meta-data file!\n\tminimizer_gtol is not a double or int.\n" );
1536 return 1;
1537 break;
1538
1539 case DOUBLE:
1540 minimizer_gtol= the_event->evt.asmt.rhs.dval;
1541 have_minimizer_gtol = 1;
1542 return 1;
1543 break;
1544
1545 case INT:
1546 minimizer_gtol= the_event->evt.asmt.rhs.ival;
1547 have_minimizer_gtol = 1;
1548 return 1;
1549 break;
1550
1551 default:
1552 the_event->err_msg =
1553 strdup( "Error in parsing meta-data file!\n\tminimizer_gtol unrecognized.\n" );
1554 return 0;
1555 break;
1556 }
1557 break;
1558
1559 case G_MIN_LSMAXITER:
1560 switch( the_type ){
1561
1562 case STRING:
1563 the_event->err_msg =
1564 strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration is not an int.\n" );
1565 return 1;
1566 break;
1567
1568 case DOUBLE:
1569 the_event->err_msg =
1570 strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration is not an int.\n" );
1571 return 1;
1572 break;
1573
1574 case INT:
1575 minimizer_ls_maxiteration = the_event->evt.asmt.rhs.ival;
1576 have_minimizer_ls_maxiteration = 1;
1577 return 1;
1578 break;
1579
1580 default:
1581 the_event->err_msg =
1582 strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration unrecognized.\n" );
1583 return 0;
1584 break;
1585 }
1586 break;
1587
1588 case G_MIN_LSTOL:
1589 switch( the_type ){
1590
1591 case STRING:
1592 the_event->err_msg =
1593 strdup( "Error in parsing meta-data file!\n\tminimizer_ls_tol is not a double or int.\n" );
1594 return 1;
1595 break;
1596
1597 case DOUBLE:
1598 minimizer_ls_tol= the_event->evt.asmt.rhs.dval;
1599 have_minimizer_ls_tol = 1;
1600 return 1;
1601 break;
1602
1603 case INT:
1604 minimizer_ls_tol= the_event->evt.asmt.rhs.ival;
1605 have_minimizer_ls_tol = 1;
1606 return 1;
1607 break;
1608
1609 default:
1610 the_event->err_msg =
1611 strdup( "Error in parsing meta-data file!\n\tminimizer_ls_tol unrecognized.\n" );
1612 return 0;
1613 break;
1614 }
1615 break;
1616
1617 // add more token cases here.
1618 case G_SEED:
1619 switch( the_type ){
1620
1621 case STRING:
1622 the_event->err_msg =
1623 strdup( "Error in parsing meta-data file!\n\tseed is not a string.\n" );
1624 return 0;
1625 return 0;
1626 break;
1627
1628 case DOUBLE:
1629 have_seed = 1;
1630 seed = (int)the_event->evt.asmt.rhs.dval;
1631 return 1;
1632 break;
1633
1634 case INT:
1635 have_seed = 1;
1636 seed = the_event->evt.asmt.rhs.ival ;
1637 return 1;
1638 break;
1639
1640 default:
1641 the_event->err_msg =
1642 strdup( "Error in parsing meta-data file!\n\tseed unrecognized.\n" );
1643 return 0;
1644 break;
1645 }
1646 break;
1647
1648 case G_USE_SOLID_THERM_INT:
1649 if( the_type == STRING ){
1650
1651 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useSolidThermInt = 1;
1652 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useSolidThermInt = 0;
1653 else{
1654 the_event->err_msg =
1655 strdup( "Error in parsing meta-data file!\n\tuseSolidThermInt was not \"true\" or \"false\".\n" );
1656 return 0;
1657 }
1658 return 1;
1659 }
1660
1661 the_event->err_msg =
1662 strdup( "Error in parsing meta-data file!\n\tuseSolidThermInt was not \"true\" or \"false\".\n" );
1663 return 0;
1664 break;
1665
1666 case G_USE_LIQUID_THERM_INT:
1667 if( the_type == STRING ){
1668
1669 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useLiquidThermInt = 1;
1670 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useLiquidThermInt = 0;
1671 else{
1672 the_event->err_msg =
1673 strdup( "Error in parsing meta-data file!\n\tuseLiquidThermInt was not \"true\" or \"false\".\n" );
1674 return 0;
1675 }
1676 return 1;
1677 }
1678
1679 the_event->err_msg =
1680 strdup( "Error in parsing meta-data file!\n\tuseLiquidThermInt was not \"true\" or \"false\".\n" );
1681 return 0;
1682 break;
1683
1684 case G_THERM_INT_LAMBDA:
1685 switch( the_type ){
1686
1687 case STRING:
1688 the_event->err_msg =
1689 strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationLambda is not a double or int.\n" );
1690 return 1;
1691 break;
1692
1693 case DOUBLE:
1694 thermodynamic_integration_lambda = the_event->evt.asmt.rhs.dval;
1695 have_thermodynamic_integration_lambda = 1;
1696 return 1;
1697 break;
1698
1699 case INT:
1700 thermodynamic_integration_lambda = (double)the_event->evt.asmt.rhs.dval;
1701 have_thermodynamic_integration_lambda = 1;
1702 return 1;
1703 break;
1704
1705 default:
1706 the_event->err_msg =
1707 strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationLambda unrecognized.\n" );
1708 return 0;
1709 break;
1710 }
1711 break;
1712
1713 case G_THERM_INT_K:
1714 switch( the_type ){
1715
1716 case STRING:
1717 the_event->err_msg =
1718 strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationK is not a double or int.\n" );
1719 return 1;
1720 break;
1721
1722 case DOUBLE:
1723 thermodynamic_integration_k = the_event->evt.asmt.rhs.dval;
1724 have_thermodynamic_integration_k = 1;
1725 return 1;
1726 break;
1727
1728 case INT:
1729 thermodynamic_integration_k = (double)the_event->evt.asmt.rhs.dval;
1730 have_thermodynamic_integration_k = 1;
1731 return 1;
1732 break;
1733
1734 default:
1735 the_event->err_msg =
1736 strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationK unrecognized.\n" );
1737 return 0;
1738 break;
1739 }
1740 break;
1741
1742 case G_FORCEFIELD_VARIANT:
1743 if( the_type == STRING ){
1744 strcpy( forcefield_variant, the_event->evt.asmt.rhs.sval );
1745 have_forcefield_variant = 1;
1746 return 1;
1747 }
1748
1749 the_event->err_msg =
1750 strdup( "Error in parsing meta-data file!\n\tforceFieldVariant was not a string assignment.\n" );
1751 return 0;
1752 break;
1753 // add more token cases here.
1754
1755 case G_FORCEFIELD_FILENAME:
1756 if( the_type == STRING ){
1757 strcpy( forcefield_filename, the_event->evt.asmt.rhs.sval );
1758 have_forcefield_filename = 1;
1759 return 1;
1760 }
1761
1762 the_event->err_msg =
1763 strdup( "Error in parsing meta-data file!\n\tforceFieldFileName was not a string assignment.\n" );
1764 return 0;
1765 break;
1766
1767 case G_THERM_INT_DIST_SPRING:
1768 switch( the_type ){
1769
1770 case STRING:
1771 the_event->err_msg =
1772 strdup( "Error in parsing meta-data file!\n\tthermIntDistSpringConst is not a double or int.\n" );
1773 return 1;
1774 break;
1775
1776 case DOUBLE:
1777 therm_int_dist_spring = the_event->evt.asmt.rhs.dval;
1778 have_dist_spring_constant = 1;
1779 return 1;
1780 break;
1781
1782 case INT:
1783 therm_int_dist_spring = (double)the_event->evt.asmt.rhs.dval;
1784 have_dist_spring_constant = 1;
1785 return 1;
1786 break;
1787
1788 default:
1789 the_event->err_msg =
1790 strdup( "Error in parsing meta-data file!\n\tthermIntDistSpringConst unrecognized.\n" );
1791 return 0;
1792 break;
1793 }
1794 break;
1795
1796 case G_THERM_INT_THETA_SPRING:
1797 switch( the_type ){
1798
1799 case STRING:
1800 the_event->err_msg =
1801 strdup( "Error in parsing meta-data file!\n\tthermIntThetaSpringConst is not a double or int.\n" );
1802 return 1;
1803 break;
1804
1805 case DOUBLE:
1806 therm_int_theta_spring = the_event->evt.asmt.rhs.dval;
1807 have_theta_spring_constant = 1;
1808 return 1;
1809 break;
1810
1811 case INT:
1812 therm_int_theta_spring = (double)the_event->evt.asmt.rhs.dval;
1813 have_theta_spring_constant = 1;
1814 return 1;
1815 break;
1816
1817 default:
1818 the_event->err_msg =
1819 strdup( "Error in parsing meta-data file!\n\tthermIntThetaSpringConst unrecognized.\n" );
1820 return 0;
1821 break;
1822 }
1823 break;
1824
1825 case G_THERM_INT_OMEGA_SPRING:
1826 switch( the_type ){
1827
1828 case STRING:
1829 the_event->err_msg =
1830 strdup( "Error in parsing meta-data file!\n\tthermIntOmegaSpringConst is not a double or int.\n" );
1831 return 1;
1832 break;
1833
1834 case DOUBLE:
1835 therm_int_omega_spring = the_event->evt.asmt.rhs.dval;
1836 have_omega_spring_constant = 1;
1837 return 1;
1838 break;
1839
1840 case INT:
1841 therm_int_omega_spring = (double)the_event->evt.asmt.rhs.dval;
1842 have_omega_spring_constant = 1;
1843 return 1;
1844 break;
1845
1846 default:
1847 the_event->err_msg =
1848 strdup( "Error in parsing meta-data file!\n\tthermIntOmegaSpringConst unrecognized.\n" );
1849 return 0;
1850 break;
1851 }
1852 break;
1853
1854 case G_SURFACETENSION:
1855 switch( the_type ){
1856
1857 case STRING:
1858 the_event->err_msg =
1859 strdup( "Error in parsing meta-data file!\n\tsurfaceTension is not a double or int.\n" );
1860 return 1;
1861 break;
1862
1863 case DOUBLE:
1864 surface_tension= the_event->evt.asmt.rhs.dval;
1865 have_surface_tension = 1;
1866 return 1;
1867 break;
1868
1869 case INT:
1870 surface_tension = (double)the_event->evt.asmt.rhs.dval;
1871 have_surface_tension = 1;
1872 return 1;
1873 break;
1874
1875 default:
1876 the_event->err_msg =
1877 strdup( "Error in parsing meta-data file!\n\tsurfaceTension unrecognized.\n" );
1878 return 0;
1879 break;
1880 }
1881 break;
1882
1883 case G_PRINTPREESURETENSOR:
1884 if( the_type == STRING ){
1885
1886 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) {
1887 have_print_pressure_tensor= 1;
1888 print_pressure_tensor = 1;
1889 } else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) {
1890 have_print_pressure_tensor= 1;
1891 print_pressure_tensor = 0;
1892 } else{
1893 the_event->err_msg =
1894 strdup( "Error in parsing meta-data file!\n\tprintPressureTensor was not \"true\" or \"false\".\n" );
1895 return 0;
1896 }
1897 return 1;
1898 }
1899
1900 the_event->err_msg =
1901 strdup( "Error in parsing meta-data file!\n\tprintPressureTensor was not \"true\" or \"false\".\n" );
1902 return 0;
1903 break;
1904
1905 case G_USE_UNDAMPED_WOLF:
1906 if( the_type == STRING ){
1907
1908 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useUndampedWolf = 1;
1909 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useUndampedWolf = 0;
1910 else{
1911 the_event->err_msg =
1912 strdup( "Error in parsing meta-data file!\n\tuseUndampedWolf was not \"true\" or \"false\".\n" );
1913 return 0;
1914 }
1915 return 1;
1916 }
1917
1918 the_event->err_msg =
1919 strdup( "Error in parsing meta-data file!\n\tuseUndampedWolf was not \"true\" or \"false\".\n" );
1920 return 0;
1921 break;
1922
1923 case G_USE_DAMPED_WOLF:
1924 if( the_type == STRING ){
1925
1926 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useDampedWolf = 1;
1927 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useDampedWolf = 0;
1928 else{
1929 the_event->err_msg =
1930 strdup( "Error in parsing meta-data file!\n\tuseDampedWolf was not \"true\" or \"false\".\n" );
1931 return 0;
1932 }
1933 return 1;
1934 }
1935
1936 the_event->err_msg =
1937 strdup( "Error in parsing meta-data file!\n\tuseDampedWolf was not \"true\" or \"false\".\n" );
1938 return 0;
1939 break;
1940
1941 case G_CUTOFFPOLICY:
1942 switch( the_type ){
1943
1944 case STRING:
1945 strcpy(cutoffPolicy, the_event->evt.asmt.rhs.sval);
1946
1947 for(int i = 0; cutoffPolicy[i] != '\0'; i++)
1948 {
1949 cutoffPolicy[i] = toupper(cutoffPolicy[i]);
1950 }
1951 have_cutoff_policy = 1;
1952 return 1;
1953 break;
1954
1955 case DOUBLE:
1956 the_event->err_msg =
1957 strdup( "Error in parsing meta-data file!\n\tcutoffPolicy should be a string!\n" );
1958 return 0;
1959 break;
1960
1961 case INT:
1962 the_event->err_msg =
1963 strdup( "Error in parsing meta-data file!\n\tcutoffPolicy should be a string!\n" );
1964 return 0;
1965 break;
1966
1967 default:
1968 the_event->err_msg =
1969 strdup( "Error in parsing meta-data file!\n\tcutoffPolicy unrecognized.\n" );
1970 return 0;
1971 break;
1972 }
1973 break;
1974
1975
1976 // add more token cases here.
1977 }
1978 }
1979
1980 switch( the_type ){
1981
1982 case STRING:
1983 sprintf( err,
1984 "\tUnrecognized assignment:\n"
1985 "\t\t-> %s = %s\n",
1986 lhs, the_event->evt.asmt.rhs.sval );
1987 break;
1988
1989 case DOUBLE:
1990 sprintf( err,
1991 "\tUnrecognized assignment:\n"
1992 "\t\t-> %s = %lf\n",
1993 lhs, the_event->evt.asmt.rhs.dval );
1994 break;
1995
1996 case INT:
1997 sprintf( err,
1998 "\tUnrecognized assignment:\n"
1999 "\t\t-> %s = %d\n",
2000 lhs, the_event->evt.asmt.rhs.ival );
2001 break;
2002
2003 default:
2004 sprintf( err,
2005 "\tUnrecognized assignment:\n"
2006 "\t\t-> %s = ?\n",
2007 lhs );
2008 break;
2009 }
2010
2011 the_event->err_msg = strdup( err );
2012 return 0;
2013 }
2014
2015 char* Globals::checkMe( void ){
2016
2017 char err[300];
2018 short int have_err = 0;
2019
2020 strcpy( err, "The following required keywords are missing:\n" );
2021
2022 if( !have_force_field ){
2023 strcat( err, "\t\t->forceField\n" );
2024 have_err= 1;
2025 }
2026
2027 if( !have_n_components ){
2028 strcat( err, "\t\t->nComponents\n" );
2029 have_err= 1;
2030 }
2031
2032
2033 if ( !have_ensemble ) {
2034 // I'm not doing MD:
2035 if ( !have_minimizer ) {
2036 // I'm not doing MD or minimization:
2037 strcat( err, "\t\t->either ensemble or minimizer must be set!\n" );
2038 have_err = 1;
2039 } else {
2040 // I'm a minimizer:
2041 }
2042 } else {
2043 // I *am* doing MD:
2044 if( !have_dt ){
2045 strcat( err, "\t\t->dt (timestep in fs)\n" );
2046 have_err= 1;
2047 }
2048 if( !have_run_time ){
2049 strcat( err, "\t\t->runTime (total run time in fs)\n" );
2050 have_err= 1;
2051 }
2052 }
2053
2054 if( have_err ) return strdup( err );
2055
2056 return NULL;
2057 }
2058
2059 int Globals::globalEnd( event* the_event ){
2060
2061 the_event->err_msg = checkMe();
2062 if( the_event->err_msg != NULL ) return 0;
2063
2064 return 1;
2065 }
2066