ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-2.0/src/io/Globals.cpp
Revision: 2302
Committed: Fri Sep 16 16:07:39 2005 UTC (18 years, 9 months ago) by chrisfen
File size: 54259 byte(s)
Log Message: 
some fixes but even more breaking (cutting out the old way to do reaction field)

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_TARGETPRESSURE 24
87 #define G_TAUTHERMOSTAT 25
88 #define G_TAUBAROSTAT 26
89 #define G_ZCONSTIME 27
90 #define G_NZCONSTRAINTS 28
91 #define G_ZCONSTOL 29
92 #define G_ZCONSFORCEPOLICY 30
93 #define G_SEED 31
94 #define G_RESETTIME 32
95 #define G_USEINITTIME 33
96 #define G_USEINIT_XS_STATE 34
97 #define G_ORTHOBOXTOLERANCE 35
98 #define G_MINIMIZER 36
99 #define G_MIN_MAXITER 37
100 #define G_MIN_WRITEFRQ 38
101 #define G_MIN_STEPSIZE 39
102 #define G_MIN_FTOL 40
103 #define G_MIN_GTOL 41
104 #define G_MIN_LSTOL 42
105 #define G_MIN_LSMAXITER 43
106 #define G_ZCONSGAP 44
107 #define G_ZCONSFIXTIME 45
108 #define G_ZCONSUSINGSMD 46
109 #define G_USE_SOLID_THERM_INT 47
110 #define G_USE_LIQUID_THERM_INT 48
111 #define G_THERM_INT_LAMBDA 49
112 #define G_THERM_INT_K 50
113 #define G_FORCEFIELD_VARIANT 51
114 #define G_FORCEFIELD_FILENAME 52
115 #define G_THERM_INT_DIST_SPRING 53
116 #define G_THERM_INT_THETA_SPRING 54
117 #define G_THERM_INT_OMEGA_SPRING 55
118 #define G_SURFACETENSION 56
119 #define G_PRINTPRESSURETENSOR 57
120 #define G_ELECTRO_SUM_METHOD 58
121 #define G_DAMPING_ALPHA 59
122 #define G_CUTOFFPOLICY 60
123
124 Globals::Globals(){
125 initalize();
126 }
127
128 Globals::~Globals(){
129 int i;
130 if( components != NULL ){
131 for( i=0; i<n_components; i++ ) delete components[i];
132 delete[] components;
133 }
134 }
135
136 void Globals::initalize(){
137 int i;
138
139 components = NULL;
140
141 command_table.insert(CommandMapType::value_type("forceField", G_FORCEFIELD));
142 command_table.insert(CommandMapType::value_type("nComponents", G_NCOMPONENTS));
143 command_table.insert(CommandMapType::value_type("targetTemp", G_TARGETTEMP));
144 command_table.insert(CommandMapType::value_type("ensemble", G_ENSEMBLE));
145 command_table.insert(CommandMapType::value_type("dt", G_DT));
146 command_table.insert(CommandMapType::value_type("runTime", G_RUNTIME));
147 command_table.insert(CommandMapType::value_type("initialConfig", G_INITIALCONFIG));
148 command_table.insert(CommandMapType::value_type("finalConfig", G_FINALCONFIG));
149 command_table.insert(CommandMapType::value_type("nMol", G_NMOL));
150 command_table.insert(CommandMapType::value_type("density", G_DENSITY));
151 command_table.insert(CommandMapType::value_type("box", G_BOX));
152 command_table.insert(CommandMapType::value_type("boxX", G_BOXX));
153 command_table.insert(CommandMapType::value_type("boxY", G_BOXY));
154 command_table.insert(CommandMapType::value_type("boxZ", G_BOXZ));
155 command_table.insert(CommandMapType::value_type("sampleTime", G_SAMPLETIME));
156 command_table.insert(CommandMapType::value_type("resetTime", G_RESETTIME));
157 command_table.insert(CommandMapType::value_type("statusTime", G_STATUSTIME));
158 command_table.insert(CommandMapType::value_type("cutoffRadius", G_RCUT));
159 command_table.insert(CommandMapType::value_type("switchingRadius", G_RSW));
160 command_table.insert(CommandMapType::value_type("dielectric", G_DIELECTRIC));
161 command_table.insert(CommandMapType::value_type("tempSet", G_TEMPSET));
162 command_table.insert(CommandMapType::value_type("thermalTime", G_THERMALTIME));
163 command_table.insert(CommandMapType::value_type("mixingRule", G_MIXINGRULE));
164 command_table.insert(CommandMapType::value_type("usePeriodicBoundaryConditions", G_USEPBC));
165 command_table.insert(CommandMapType::value_type("targetPressure", G_TARGETPRESSURE));
166 command_table.insert(CommandMapType::value_type("tauThermostat", G_TAUTHERMOSTAT));
167 command_table.insert(CommandMapType::value_type("tauBarostat", G_TAUBAROSTAT));
168 command_table.insert(CommandMapType::value_type("zconsTime", G_ZCONSTIME));
169 command_table.insert(CommandMapType::value_type("nZconstraints", G_NZCONSTRAINTS));
170 command_table.insert(CommandMapType::value_type("zconsTol", G_ZCONSTOL));
171 command_table.insert(CommandMapType::value_type("zconsForcePolicy", G_ZCONSFORCEPOLICY));
172 command_table.insert(CommandMapType::value_type("seed", G_SEED));
173 command_table.insert(CommandMapType::value_type("useInitialTime", G_USEINITTIME));
174 command_table.insert(CommandMapType::value_type("useInitialExtendedSystemState", G_USEINIT_XS_STATE));
175 command_table.insert(CommandMapType::value_type("orthoBoxTolerance", G_ORTHOBOXTOLERANCE));
176 command_table.insert(CommandMapType::value_type("minimizer", G_MINIMIZER));
177 command_table.insert(CommandMapType::value_type("minimizerMaxIter", G_MIN_MAXITER));
178 command_table.insert(CommandMapType::value_type("minimizerWriteFrq", G_MIN_WRITEFRQ));
179 command_table.insert(CommandMapType::value_type("minimizerStepSize", G_MIN_STEPSIZE));
180 command_table.insert(CommandMapType::value_type("minimizerFTol", G_MIN_FTOL));
181 command_table.insert(CommandMapType::value_type("minimizerGTol", G_MIN_GTOL));
182 command_table.insert(CommandMapType::value_type("minimizerLSTol", G_MIN_LSTOL));
183 command_table.insert(CommandMapType::value_type("minimizerLSMaxIter", G_MIN_LSMAXITER));
184 command_table.insert(CommandMapType::value_type("zconsGap", G_ZCONSGAP));
185 command_table.insert(CommandMapType::value_type("zconsFixtime", G_ZCONSFIXTIME));
186 command_table.insert(CommandMapType::value_type("zconsUsingSMD", G_ZCONSUSINGSMD));
187 command_table.insert(CommandMapType::value_type("useSolidThermInt", G_USE_SOLID_THERM_INT));
188 command_table.insert(CommandMapType::value_type("useLiquidThermInt", G_USE_LIQUID_THERM_INT));
189 command_table.insert(CommandMapType::value_type("thermodynamicIntegrationLambda", G_THERM_INT_LAMBDA));
190 command_table.insert(CommandMapType::value_type("thermodynamicIntegrationK", G_THERM_INT_K));
191 command_table.insert(CommandMapType::value_type("forceFieldVariant", G_FORCEFIELD_VARIANT));
192 command_table.insert(CommandMapType::value_type("forceFieldFileName", G_FORCEFIELD_FILENAME));
193 command_table.insert(CommandMapType::value_type("thermIntDistSpringConst", G_THERM_INT_DIST_SPRING));
194 command_table.insert(CommandMapType::value_type("thermIntThetaSpringConst", G_THERM_INT_THETA_SPRING));
195 command_table.insert(CommandMapType::value_type("thermIntOmegaSpringConst", G_THERM_INT_OMEGA_SPRING));
196 command_table.insert(CommandMapType::value_type("surfaceTension", G_SURFACETENSION));
197 command_table.insert(CommandMapType::value_type("printPressureTensor", G_PRINTPRESSURETENSOR));
198 command_table.insert(CommandMapType::value_type("electrostaticSummationMethod", G_ELECTRO_SUM_METHOD));
199 command_table.insert(CommandMapType::value_type("dampingAlpha", G_DAMPING_ALPHA));
200 command_table.insert(CommandMapType::value_type("cutoffPolicy", G_CUTOFFPOLICY));
201
202 strcpy( mixingRule,"standard"); //default mixing rules to standard.
203 usePBC = 1; //default periodic boundry conditions to on
204 useInitTime = 0; // default to pull init time from the init file
205 useInitXSstate = 0; // default to pull the extended state from the init file
206 orthoBoxTolerance = 1E-6;
207 useSolidThermInt = 0; // default solid-state thermodynamic integration to off
208 useLiquidThermInt = 0; // default liquid thermodynamic integration to off
209 dampingAlpha = 1.5; // default damping parameter in Wolf Electrostatics
210
211 have_force_field = 0;
212 have_n_components = 0;
213 have_target_temp = 0;
214 have_ensemble = 0;
215 have_dt = 0;
216 have_run_time = 0;
217
218 have_initial_config = 0;
219 have_final_config = 0;
220 have_n_mol = 0;
221 have_density = 0;
222 have_box = 0;
223 have_box_x = 0;
224 have_box_y = 0;
225 have_box_y = 0;
226 have_box_z = 0;
227 have_sample_time = 0;
228 have_status_time = 0;
229 have_reset_time = 0;
230 have_thermal_time = 0;
231 have_rcut = 0;
232 have_rsw = 0;
233 have_dielectric = 0;
234 have_tempSet = 0;
235 have_target_pressure =0;
236 have_q_mass = 0;
237 have_tau_thermostat = 0;
238 have_tau_barostat = 0;
239 have_zcons_time = 0;
240 have_n_zConstraints = 0;
241 have_zConstraints = 0;
242 have_zcons_tol = 0;
243 have_zcons_gap = 0;
244 have_zcons_fixtime = 0;
245 have_zcons_using_smd = 0;
246 have_seed = 0;
247 have_minimizer = 0;
248 have_minimizer_maxiteration = 0;
249 have_minimizer_writefrq = 0;
250 have_minimizer_stepsize = 0;
251 have_minimizer_ftol = 0;
252 have_minimizer_gtol = 0;
253 have_minimizer_ls_tol = 0;
254 have_minimizer_ls_maxiteration = 0;
255 have_thermodynamic_integration_lambda = 0;
256 have_thermodynamic_integration_k = 0;
257 have_forcefield_variant = 0;
258 have_forcefield_filename = 0;
259 have_dist_spring_constant = 0;
260 have_theta_spring_constant = 0;
261 have_omega_spring_constant = 0;
262 have_surface_tension = 0;
263 have_print_pressure_tensor = 0;
264 have_electro_sum_method = 0;
265 have_damping_alpha = 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_TARGETPRESSURE:
1098 switch( the_type ){
1099
1100 case STRING:
1101 the_event->err_msg =
1102 strdup( "Error in parsing meta-data file!\n\ttargetPressure is not a double or int.\n" );
1103 return 0;
1104 break;
1105
1106 case DOUBLE:
1107 target_pressure = the_event->evt.asmt.rhs.dval;
1108 have_target_pressure = 1;
1109 return 1;
1110 break;
1111
1112 case INT:
1113 target_pressure = (double)the_event->evt.asmt.rhs.ival;
1114 have_target_pressure = 1;
1115 return 1;
1116 break;
1117
1118 default:
1119 the_event->err_msg =
1120 strdup( "Error in parsing meta-data file!\n\ttargetPressure unrecognized.\n" );
1121 return 0;
1122 break;
1123 }
1124 break;
1125
1126 case G_TAUTHERMOSTAT:
1127 switch( the_type ){
1128
1129 case STRING:
1130 the_event->err_msg =
1131 strdup( "Error in parsing meta-data file!\n\ttauThermostat is not a double or int.\n" );
1132 return 0;
1133 break;
1134
1135 case DOUBLE:
1136 tau_thermostat = the_event->evt.asmt.rhs.dval;
1137 have_tau_thermostat = 1;
1138 return 1;
1139 break;
1140
1141 case INT:
1142 tau_thermostat = (double)the_event->evt.asmt.rhs.ival;
1143 have_tau_thermostat = 1;
1144 return 1;
1145 break;
1146
1147 default:
1148 the_event->err_msg =
1149 strdup( "Error in parsing meta-data file!\n\ttauThermostat unrecognized.\n" );
1150 return 0;
1151 break;
1152 }
1153 break;
1154
1155 case G_TAUBAROSTAT:
1156 switch( the_type ){
1157
1158 case STRING:
1159 the_event->err_msg =
1160 strdup( "Error in parsing meta-data file!\n\ttauBarostat is not a double or int.\n" );
1161 return 0;
1162 break;
1163
1164 case DOUBLE:
1165 tau_barostat = the_event->evt.asmt.rhs.dval;
1166 have_tau_barostat = 1;
1167 return 1;
1168 break;
1169
1170 case INT:
1171 tau_barostat = (double)the_event->evt.asmt.rhs.ival;
1172 have_tau_barostat = 1;
1173 return 1;
1174 break;
1175
1176 default:
1177 the_event->err_msg =
1178 strdup( "Error in parsing meta-data file!\n\ttauBarostat unrecognized.\n" );
1179 return 0;
1180 break;
1181 }
1182 break;
1183
1184 case G_ZCONSTIME:
1185 switch( the_type ){
1186
1187 case STRING:
1188 the_event->err_msg =
1189 strdup( "Error in parsing meta-data file!\n\tzcons_time is not a double or int.\n" );
1190 return 0;
1191 break;
1192
1193 case DOUBLE:
1194 zcons_time = the_event->evt.asmt.rhs.dval;
1195 have_zcons_time = 1;
1196 return 1;
1197 break;
1198
1199 case INT:
1200 zcons_time = (double)the_event->evt.asmt.rhs.ival;
1201 have_zcons_time = 1;
1202 return 1;
1203 break;
1204
1205 default:
1206 the_event->err_msg =
1207 strdup( "Error in parsing meta-data file!\n\tzcons_time unrecognized.\n" );
1208 return 0;
1209 break;
1210 }
1211 break;
1212
1213 case G_ZCONSTOL:
1214 switch( the_type ){
1215
1216 case STRING:
1217 the_event->err_msg =
1218 strdup( "Error in parsing meta-data file!\n\tzcons_tol is not a double or int.\n" );
1219 return 0;
1220 break;
1221
1222 case DOUBLE:
1223 zcons_tol = the_event->evt.asmt.rhs.dval;
1224 have_zcons_tol = 1;
1225 return 1;
1226 break;
1227
1228 case INT:
1229 zcons_tol = (double)the_event->evt.asmt.rhs.ival;
1230 have_zcons_tol = 1;
1231 return 1;
1232 break;
1233
1234 default:
1235 the_event->err_msg =
1236 strdup( "Error in parsing meta-data file!\n\tzcons_ol unrecognized.\n" );
1237 return 0;
1238 break;
1239 }
1240 break;
1241
1242 case G_ZCONSFORCEPOLICY:
1243 switch( the_type ){
1244
1245 case STRING:
1246 strcpy(zconsForcePolicy, the_event->evt.asmt.rhs.sval);
1247
1248 for(int i = 0; zconsForcePolicy[i] != '\0'; i++)
1249 {
1250 zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1251 }
1252 have_zcons_force_policy = 1;
1253 return 1;
1254 break;
1255
1256 case DOUBLE:
1257 the_event->err_msg =
1258 strdup( "Error in parsing meta-data file!\n\tzconsForcePolicy is not a double or int.\n" );
1259 return 0;
1260 break;
1261
1262 case INT:
1263 the_event->err_msg =
1264 strdup( "Error in parsing meta-data file!\n\tzconsForcePolicy is not a double or int.\n" );
1265 return 0;
1266 break;
1267
1268 default:
1269 the_event->err_msg =
1270 strdup( "Error in parsing meta-data file!\n\tzconsForcePolicy unrecognized.\n" );
1271 return 0;
1272 break;
1273 }
1274 break;
1275
1276 case G_ZCONSGAP:
1277 switch( the_type ){
1278
1279 case STRING:
1280 the_event->err_msg =
1281 strdup( "Error in parsing meta-data file!\n\tzcons_gap is not a double or int.\n" );
1282 return 0;
1283 break;
1284
1285 case DOUBLE:
1286 zcons_gap = the_event->evt.asmt.rhs.dval;
1287 have_zcons_gap= 1;
1288 return 1;
1289 break;
1290
1291 case INT:
1292 zcons_gap= (double)the_event->evt.asmt.rhs.ival;
1293 have_zcons_gap= 1;
1294 return 1;
1295 break;
1296
1297 default:
1298 the_event->err_msg =
1299 strdup( "Error in parsing meta-data file!\n\tzcons_gap unrecognized.\n" );
1300 return 0;
1301 break;
1302 }
1303 break;
1304
1305 case G_ZCONSFIXTIME:
1306 switch( the_type ){
1307
1308 case STRING:
1309 the_event->err_msg =
1310 strdup( "Error in parsing meta-data file!\n\tzcons_fixtime is not a double or int.\n" );
1311 return 0;
1312 break;
1313
1314 case DOUBLE:
1315 zcons_fixtime= the_event->evt.asmt.rhs.dval;
1316 have_zcons_fixtime= 1;
1317 return 1;
1318 break;
1319
1320 case INT:
1321 zcons_fixtime= (double)the_event->evt.asmt.rhs.ival;
1322 have_zcons_fixtime= 1;
1323 return 1;
1324 break;
1325
1326 default:
1327 the_event->err_msg =
1328 strdup( "Error in parsing meta-data file!\n\tzcons_fixtime unrecognized.\n" );
1329 return 0;
1330 break;
1331 }
1332 break;
1333
1334 case G_ZCONSUSINGSMD:
1335 switch( the_type ){
1336
1337 case STRING:
1338 the_event->err_msg =
1339 strdup( "Error in parsing meta-data file!\n\tzcons_fixtime is not an int.\n" );
1340 return 0;
1341 break;
1342
1343 case DOUBLE:
1344 the_event->err_msg =
1345 strdup( "Error in parsing meta-data file!\n\tzcons_fixtime is not an int.\n" );
1346 return 0;
1347 break;
1348
1349 case INT:
1350 zcons_using_smd= the_event->evt.asmt.rhs.ival;
1351 have_zcons_using_smd= 1;
1352 return 1;
1353 break;
1354
1355 default:
1356 the_event->err_msg =
1357 strdup( "Error in parsing meta-data file!\n\tzcons_usingsmd unrecognized.\n" );
1358 return 0;
1359 break;
1360 }
1361 break;
1362
1363 case G_MINIMIZER:
1364 switch( the_type ){
1365
1366 case STRING:
1367 strcpy(minimizer_name, the_event->evt.asmt.rhs.sval);
1368
1369 for(int i = 0; zconsForcePolicy[i] != '\0'; i++){
1370 zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1371 }
1372 have_minimizer= 1;
1373 return 1;
1374 break;
1375
1376 case DOUBLE:
1377 the_event->err_msg =
1378 strdup( "Error in parsing meta-data file!\n\tminimizer_name is not a double or int.\n" );
1379 return 0;
1380 break;
1381
1382 case INT:
1383 the_event->err_msg =
1384 strdup( "Error in parsing meta-data file!\n\tminimizer_name is not a double or int.\n" );
1385 return 0;
1386 break;
1387
1388 default:
1389 the_event->err_msg =
1390 strdup( "Error in parsing meta-data file!\n\tminimizer_name unrecognized.\n" );
1391 return 0;
1392 break;
1393 }
1394 break;
1395
1396 case G_MIN_MAXITER:
1397 switch( the_type ){
1398
1399 case STRING:
1400 the_event->err_msg =
1401 strdup( "Error in parsing meta-data file!\n\tminimizer_maxiteration is not a double or int.\n" );
1402 return 1;
1403 break;
1404
1405 case DOUBLE:
1406 minimizer_maxiteration = (int)the_event->evt.asmt.rhs.dval;
1407 have_minimizer_maxiteration = 1;
1408 return 1;
1409 break;
1410
1411 case INT:
1412 minimizer_maxiteration = the_event->evt.asmt.rhs.ival;
1413 have_minimizer_maxiteration = 1;
1414 return 1;
1415 break;
1416
1417 default:
1418 the_event->err_msg =
1419 strdup( "Error in parsing meta-data file!\n\tminimizer_maxiteration unrecognized.\n" );
1420 return 0;
1421 break;
1422 }
1423 break;
1424
1425 case G_MIN_WRITEFRQ:
1426 switch( the_type ){
1427
1428 case STRING:
1429 the_event->err_msg =
1430 strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq is not an int.\n" );
1431 return 1;
1432 break;
1433
1434 case DOUBLE:
1435 the_event->err_msg =
1436 strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq is not an int.\n" );
1437 return 1;
1438 break;
1439
1440 case INT:
1441 minimizer_writefrq= the_event->evt.asmt.rhs.ival;
1442 have_minimizer_writefrq = 1;
1443 return 1;
1444 break;
1445
1446 default:
1447 the_event->err_msg =
1448 strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq unrecognized.\n" );
1449 return 0;
1450 break;
1451 }
1452 break;
1453
1454 case G_MIN_STEPSIZE:
1455 switch( the_type ){
1456
1457 case STRING:
1458 the_event->err_msg =
1459 strdup( "Error in parsing meta-data file!\n\tminimizer_resetfrq is not a double or int.\n" );
1460 return 1;
1461 break;
1462
1463 case DOUBLE:
1464 minimizer_stepsize= the_event->evt.asmt.rhs.dval;
1465 have_minimizer_stepsize = 1;
1466 return 1;
1467 break;
1468
1469 case INT:
1470 minimizer_stepsize= the_event->evt.asmt.rhs.ival;
1471 have_minimizer_stepsize = 1;
1472 return 1;
1473 break;
1474
1475 default:
1476 the_event->err_msg =
1477 strdup( "Error in parsing meta-data file!\n\tminimizer_resetfrq unrecognized.\n" );
1478 return 0;
1479 break;
1480 }
1481 break;
1482
1483 case G_MIN_FTOL:
1484 switch( the_type ){
1485
1486 case STRING:
1487 the_event->err_msg =
1488 strdup( "Error in parsing meta-data file!\n\tminimizer_ftol is not a double or int.\n" );
1489 return 1;
1490 break;
1491
1492 case DOUBLE:
1493 minimizer_ftol= the_event->evt.asmt.rhs.dval;
1494 have_minimizer_ftol = 1;
1495 return 1;
1496 break;
1497
1498 case INT:
1499 minimizer_ftol= the_event->evt.asmt.rhs.ival;
1500 have_minimizer_ftol = 1;
1501 return 1;
1502 break;
1503
1504 default:
1505 the_event->err_msg =
1506 strdup( "Error in parsing meta-data file!\n\tminimizer_ftol unrecognized.\n" );
1507 return 0;
1508 break;
1509 }
1510 break;
1511
1512 case G_MIN_GTOL:
1513 switch( the_type ){
1514
1515 case STRING:
1516 the_event->err_msg =
1517 strdup( "Error in parsing meta-data file!\n\tminimizer_gtol is not a double or int.\n" );
1518 return 1;
1519 break;
1520
1521 case DOUBLE:
1522 minimizer_gtol= the_event->evt.asmt.rhs.dval;
1523 have_minimizer_gtol = 1;
1524 return 1;
1525 break;
1526
1527 case INT:
1528 minimizer_gtol= the_event->evt.asmt.rhs.ival;
1529 have_minimizer_gtol = 1;
1530 return 1;
1531 break;
1532
1533 default:
1534 the_event->err_msg =
1535 strdup( "Error in parsing meta-data file!\n\tminimizer_gtol unrecognized.\n" );
1536 return 0;
1537 break;
1538 }
1539 break;
1540
1541 case G_MIN_LSMAXITER:
1542 switch( the_type ){
1543
1544 case STRING:
1545 the_event->err_msg =
1546 strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration is not an int.\n" );
1547 return 1;
1548 break;
1549
1550 case DOUBLE:
1551 the_event->err_msg =
1552 strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration is not an int.\n" );
1553 return 1;
1554 break;
1555
1556 case INT:
1557 minimizer_ls_maxiteration = the_event->evt.asmt.rhs.ival;
1558 have_minimizer_ls_maxiteration = 1;
1559 return 1;
1560 break;
1561
1562 default:
1563 the_event->err_msg =
1564 strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration unrecognized.\n" );
1565 return 0;
1566 break;
1567 }
1568 break;
1569
1570 case G_MIN_LSTOL:
1571 switch( the_type ){
1572
1573 case STRING:
1574 the_event->err_msg =
1575 strdup( "Error in parsing meta-data file!\n\tminimizer_ls_tol is not a double or int.\n" );
1576 return 1;
1577 break;
1578
1579 case DOUBLE:
1580 minimizer_ls_tol= the_event->evt.asmt.rhs.dval;
1581 have_minimizer_ls_tol = 1;
1582 return 1;
1583 break;
1584
1585 case INT:
1586 minimizer_ls_tol= the_event->evt.asmt.rhs.ival;
1587 have_minimizer_ls_tol = 1;
1588 return 1;
1589 break;
1590
1591 default:
1592 the_event->err_msg =
1593 strdup( "Error in parsing meta-data file!\n\tminimizer_ls_tol unrecognized.\n" );
1594 return 0;
1595 break;
1596 }
1597 break;
1598
1599 // add more token cases here.
1600 case G_SEED:
1601 switch( the_type ){
1602
1603 case STRING:
1604 the_event->err_msg =
1605 strdup( "Error in parsing meta-data file!\n\tseed is not a string.\n" );
1606 return 0;
1607 return 0;
1608 break;
1609
1610 case DOUBLE:
1611 have_seed = 1;
1612 seed = (int)the_event->evt.asmt.rhs.dval;
1613 return 1;
1614 break;
1615
1616 case INT:
1617 have_seed = 1;
1618 seed = the_event->evt.asmt.rhs.ival ;
1619 return 1;
1620 break;
1621
1622 default:
1623 the_event->err_msg =
1624 strdup( "Error in parsing meta-data file!\n\tseed unrecognized.\n" );
1625 return 0;
1626 break;
1627 }
1628 break;
1629
1630 case G_USE_SOLID_THERM_INT:
1631 if( the_type == STRING ){
1632
1633 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useSolidThermInt = 1;
1634 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useSolidThermInt = 0;
1635 else{
1636 the_event->err_msg =
1637 strdup( "Error in parsing meta-data file!\n\tuseSolidThermInt was not \"true\" or \"false\".\n" );
1638 return 0;
1639 }
1640 return 1;
1641 }
1642
1643 the_event->err_msg =
1644 strdup( "Error in parsing meta-data file!\n\tuseSolidThermInt was not \"true\" or \"false\".\n" );
1645 return 0;
1646 break;
1647
1648 case G_USE_LIQUID_THERM_INT:
1649 if( the_type == STRING ){
1650
1651 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useLiquidThermInt = 1;
1652 else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useLiquidThermInt = 0;
1653 else{
1654 the_event->err_msg =
1655 strdup( "Error in parsing meta-data file!\n\tuseLiquidThermInt 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\tuseLiquidThermInt was not \"true\" or \"false\".\n" );
1663 return 0;
1664 break;
1665
1666 case G_THERM_INT_LAMBDA:
1667 switch( the_type ){
1668
1669 case STRING:
1670 the_event->err_msg =
1671 strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationLambda is not a double or int.\n" );
1672 return 1;
1673 break;
1674
1675 case DOUBLE:
1676 thermodynamic_integration_lambda = the_event->evt.asmt.rhs.dval;
1677 have_thermodynamic_integration_lambda = 1;
1678 return 1;
1679 break;
1680
1681 case INT:
1682 thermodynamic_integration_lambda = (double)the_event->evt.asmt.rhs.dval;
1683 have_thermodynamic_integration_lambda = 1;
1684 return 1;
1685 break;
1686
1687 default:
1688 the_event->err_msg =
1689 strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationLambda unrecognized.\n" );
1690 return 0;
1691 break;
1692 }
1693 break;
1694
1695 case G_THERM_INT_K:
1696 switch( the_type ){
1697
1698 case STRING:
1699 the_event->err_msg =
1700 strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationK is not a double or int.\n" );
1701 return 1;
1702 break;
1703
1704 case DOUBLE:
1705 thermodynamic_integration_k = the_event->evt.asmt.rhs.dval;
1706 have_thermodynamic_integration_k = 1;
1707 return 1;
1708 break;
1709
1710 case INT:
1711 thermodynamic_integration_k = (double)the_event->evt.asmt.rhs.dval;
1712 have_thermodynamic_integration_k = 1;
1713 return 1;
1714 break;
1715
1716 default:
1717 the_event->err_msg =
1718 strdup( "Error in parsing meta-data file!\n\tthermodynamicIntegrationK unrecognized.\n" );
1719 return 0;
1720 break;
1721 }
1722 break;
1723
1724 case G_FORCEFIELD_VARIANT:
1725 if( the_type == STRING ){
1726 strcpy( forcefield_variant, the_event->evt.asmt.rhs.sval );
1727 have_forcefield_variant = 1;
1728 return 1;
1729 }
1730
1731 the_event->err_msg =
1732 strdup( "Error in parsing meta-data file!\n\tforceFieldVariant was not a string assignment.\n" );
1733 return 0;
1734 break;
1735 // add more token cases here.
1736
1737 case G_FORCEFIELD_FILENAME:
1738 if( the_type == STRING ){
1739 strcpy( forcefield_filename, the_event->evt.asmt.rhs.sval );
1740 have_forcefield_filename = 1;
1741 return 1;
1742 }
1743
1744 the_event->err_msg =
1745 strdup( "Error in parsing meta-data file!\n\tforceFieldFileName was not a string assignment.\n" );
1746 return 0;
1747 break;
1748
1749 case G_THERM_INT_DIST_SPRING:
1750 switch( the_type ){
1751
1752 case STRING:
1753 the_event->err_msg =
1754 strdup( "Error in parsing meta-data file!\n\tthermIntDistSpringConst is not a double or int.\n" );
1755 return 1;
1756 break;
1757
1758 case DOUBLE:
1759 therm_int_dist_spring = the_event->evt.asmt.rhs.dval;
1760 have_dist_spring_constant = 1;
1761 return 1;
1762 break;
1763
1764 case INT:
1765 therm_int_dist_spring = (double)the_event->evt.asmt.rhs.dval;
1766 have_dist_spring_constant = 1;
1767 return 1;
1768 break;
1769
1770 default:
1771 the_event->err_msg =
1772 strdup( "Error in parsing meta-data file!\n\tthermIntDistSpringConst unrecognized.\n" );
1773 return 0;
1774 break;
1775 }
1776 break;
1777
1778 case G_THERM_INT_THETA_SPRING:
1779 switch( the_type ){
1780
1781 case STRING:
1782 the_event->err_msg =
1783 strdup( "Error in parsing meta-data file!\n\tthermIntThetaSpringConst is not a double or int.\n" );
1784 return 1;
1785 break;
1786
1787 case DOUBLE:
1788 therm_int_theta_spring = the_event->evt.asmt.rhs.dval;
1789 have_theta_spring_constant = 1;
1790 return 1;
1791 break;
1792
1793 case INT:
1794 therm_int_theta_spring = (double)the_event->evt.asmt.rhs.dval;
1795 have_theta_spring_constant = 1;
1796 return 1;
1797 break;
1798
1799 default:
1800 the_event->err_msg =
1801 strdup( "Error in parsing meta-data file!\n\tthermIntThetaSpringConst unrecognized.\n" );
1802 return 0;
1803 break;
1804 }
1805 break;
1806
1807 case G_THERM_INT_OMEGA_SPRING:
1808 switch( the_type ){
1809
1810 case STRING:
1811 the_event->err_msg =
1812 strdup( "Error in parsing meta-data file!\n\tthermIntOmegaSpringConst is not a double or int.\n" );
1813 return 1;
1814 break;
1815
1816 case DOUBLE:
1817 therm_int_omega_spring = the_event->evt.asmt.rhs.dval;
1818 have_omega_spring_constant = 1;
1819 return 1;
1820 break;
1821
1822 case INT:
1823 therm_int_omega_spring = (double)the_event->evt.asmt.rhs.dval;
1824 have_omega_spring_constant = 1;
1825 return 1;
1826 break;
1827
1828 default:
1829 the_event->err_msg =
1830 strdup( "Error in parsing meta-data file!\n\tthermIntOmegaSpringConst unrecognized.\n" );
1831 return 0;
1832 break;
1833 }
1834 break;
1835
1836 case G_SURFACETENSION:
1837 switch( the_type ){
1838
1839 case STRING:
1840 the_event->err_msg =
1841 strdup( "Error in parsing meta-data file!\n\tsurfaceTension is not a double or int.\n" );
1842 return 1;
1843 break;
1844
1845 case DOUBLE:
1846 surface_tension= the_event->evt.asmt.rhs.dval;
1847 have_surface_tension = 1;
1848 return 1;
1849 break;
1850
1851 case INT:
1852 surface_tension = (double)the_event->evt.asmt.rhs.dval;
1853 have_surface_tension = 1;
1854 return 1;
1855 break;
1856
1857 default:
1858 the_event->err_msg =
1859 strdup( "Error in parsing meta-data file!\n\tsurfaceTension unrecognized.\n" );
1860 return 0;
1861 break;
1862 }
1863 break;
1864
1865 case G_PRINTPRESSURETENSOR:
1866 if( the_type == STRING ){
1867
1868 if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) {
1869 have_print_pressure_tensor= 1;
1870 print_pressure_tensor = 1;
1871 } else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) {
1872 have_print_pressure_tensor= 1;
1873 print_pressure_tensor = 0;
1874 } else{
1875 the_event->err_msg =
1876 strdup( "Error in parsing meta-data file!\n\tprintPressureTensor was not \"true\" or \"false\".\n" );
1877 return 0;
1878 }
1879 return 1;
1880 }
1881
1882 the_event->err_msg =
1883 strdup( "Error in parsing meta-data file!\n\tprintPressureTensor was not \"true\" or \"false\".\n" );
1884 return 0;
1885 break;
1886
1887 case G_ELECTRO_SUM_METHOD:
1888 switch( the_type ){
1889
1890 case STRING:
1891 strcpy(electrostaticSummationMethod, the_event->evt.asmt.rhs.sval);
1892
1893 for(int i = 0; electrostaticSummationMethod[i] != '\0'; i++)
1894 {
1895 electrostaticSummationMethod[i] = toupper(electrostaticSummationMethod[i]);
1896 }
1897 have_electro_sum_method = 1;
1898 return 1;
1899 break;
1900
1901 case DOUBLE:
1902 the_event->err_msg =
1903 strdup( "Error in parsing meta-data file!\n\telectrostaticSummationMethod should be a string!\n" );
1904 return 0;
1905 break;
1906
1907 case INT:
1908 the_event->err_msg =
1909 strdup( "Error in parsing meta-data file!\n\telectrostaticSummationMethod should be a string!\n" );
1910 return 0;
1911 break;
1912
1913 default:
1914 the_event->err_msg =
1915 strdup( "Error in parsing meta-data file!\n\telectrostaticSummationMethod unrecognized.\n" );
1916 return 0;
1917 break;
1918 }
1919 break;
1920
1921 case G_DAMPING_ALPHA:
1922 switch( the_type ){
1923
1924 case STRING:
1925 the_event->err_msg =
1926 strdup( "Error in parsing meta-data file!\n\tdampingAlpha is not a double or int.\n" );
1927 return 1;
1928 break;
1929
1930 case DOUBLE:
1931 dampingAlpha = the_event->evt.asmt.rhs.dval;
1932 have_damping_alpha = 1;
1933 return 1;
1934 break;
1935
1936 case INT:
1937 dampingAlpha = (double)the_event->evt.asmt.rhs.dval;
1938 have_damping_alpha = 1;
1939 return 1;
1940 break;
1941
1942 default:
1943 the_event->err_msg =
1944 strdup( "Error in parsing meta-data file!\n\tdampingAlpha unrecognized.\n" );
1945 return 0;
1946 break;
1947 }
1948 break;
1949
1950 case G_CUTOFFPOLICY:
1951 switch( the_type ){
1952
1953 case STRING:
1954 strcpy(cutoffPolicy, the_event->evt.asmt.rhs.sval);
1955
1956 for(int i = 0; cutoffPolicy[i] != '\0'; i++)
1957 {
1958 cutoffPolicy[i] = toupper(cutoffPolicy[i]);
1959 }
1960 have_cutoff_policy = 1;
1961 return 1;
1962 break;
1963
1964 case DOUBLE:
1965 the_event->err_msg =
1966 strdup( "Error in parsing meta-data file!\n\tcutoffPolicy should be a string!\n" );
1967 return 0;
1968 break;
1969
1970 case INT:
1971 the_event->err_msg =
1972 strdup( "Error in parsing meta-data file!\n\tcutoffPolicy should be a string!\n" );
1973 return 0;
1974 break;
1975
1976 default:
1977 the_event->err_msg =
1978 strdup( "Error in parsing meta-data file!\n\tcutoffPolicy unrecognized.\n" );
1979 return 0;
1980 break;
1981 }
1982 break;
1983
1984
1985 // add more token cases here.
1986 }
1987 }
1988
1989 switch( the_type ){
1990
1991 case STRING:
1992 sprintf( err,
1993 "\tUnrecognized assignment:\n"
1994 "\t\t-> %s = %s\n",
1995 lhs, the_event->evt.asmt.rhs.sval );
1996 break;
1997
1998 case DOUBLE:
1999 sprintf( err,
2000 "\tUnrecognized assignment:\n"
2001 "\t\t-> %s = %lf\n",
2002 lhs, the_event->evt.asmt.rhs.dval );
2003 break;
2004
2005 case INT:
2006 sprintf( err,
2007 "\tUnrecognized assignment:\n"
2008 "\t\t-> %s = %d\n",
2009 lhs, the_event->evt.asmt.rhs.ival );
2010 break;
2011
2012 default:
2013 sprintf( err,
2014 "\tUnrecognized assignment:\n"
2015 "\t\t-> %s = ?\n",
2016 lhs );
2017 break;
2018 }
2019
2020 the_event->err_msg = strdup( err );
2021 return 0;
2022 }
2023
2024 char* Globals::checkMe( void ){
2025
2026 char err[300];
2027 short int have_err = 0;
2028
2029 strcpy( err, "The following required keywords are missing:\n" );
2030
2031 if( !have_force_field ){
2032 strcat( err, "\t\t->forceField\n" );
2033 have_err= 1;
2034 }
2035
2036 if( !have_n_components ){
2037 strcat( err, "\t\t->nComponents\n" );
2038 have_err= 1;
2039 }
2040
2041
2042 if ( !have_ensemble ) {
2043 // I'm not doing MD:
2044 if ( !have_minimizer ) {
2045 // I'm not doing MD or minimization:
2046 strcat( err, "\t\t->either ensemble or minimizer must be set!\n" );
2047 have_err = 1;
2048 } else {
2049 // I'm a minimizer:
2050 }
2051 } else {
2052 // I *am* doing MD:
2053 if( !have_dt ){
2054 strcat( err, "\t\t->dt (timestep in fs)\n" );
2055 have_err= 1;
2056 }
2057 if( !have_run_time ){
2058 strcat( err, "\t\t->runTime (total run time in fs)\n" );
2059 have_err= 1;
2060 }
2061 }
2062
2063 if( have_err ) return strdup( err );
2064
2065 return NULL;
2066 }
2067
2068 int Globals::globalEnd( event* the_event ){
2069
2070 the_event->err_msg = checkMe();
2071 if( the_event->err_msg != NULL ) return 0;
2072
2073 return 1;
2074 }
2075