ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-1.0/libBASS/Globals.cpp
Revision: 1402
Committed: Fri Jul 23 19:58:37 2004 UTC (20 years, 9 months ago) by gezelter
File size: 41917 byte(s)
Log Message: 
changed minimizer keywords

File Contents

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