ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/Globals.cpp
Revision: 1210
Committed: Tue Jun 1 14:27:28 2004 UTC (20 years, 1 month ago) by chrisfen
File size: 41450 byte(s)
Log Message: 
Added useLiquidThermInt keyword and changed useThermInt to useSolidThermInt

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