ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-2.0/src/UseTheForce/DUFF.cpp
Revision: 1490
Committed: Fri Sep 24 04:16:43 2004 UTC (19 years, 9 months ago) by gezelter
File size: 43754 byte(s)
Log Message: 
Import of OOPSE v. 2.0

File Contents

# Content
1 #include <stdlib.h>
2 #include <stdio.h>
3 #include <string.h>
4
5 #include <iostream>
6 using namespace std;
7
8 #include "ForceFields.hpp"
9 #include "SRI.hpp"
10 #include "simError.h"
11
12 #include "fortranWrappers.hpp"
13
14 #ifdef IS_MPI
15 #include "mpiForceField.h"
16 #endif // is_mpi
17
18
19 // define some bond Types
20
21 #define FIXED_BOND 0
22 #define HARMONIC_BOND 1
23
24
25 namespace DUFF_NS { // restrict the access of the folowing to this file only.
26
27
28 // Declare the structures that will be passed by MPI
29
30 typedef struct{
31 char name[15];
32 double mass;
33 double epslon;
34 double sigma;
35 double charge;
36 double dipole;
37 double w0;
38 double v0;
39 double v0p;
40 double rl;
41 double ru;
42 double rlp;
43 double rup;
44 int isSSD;
45 int isCharge;
46 int isDipole;
47 int ident;
48 int last; // 0 -> default
49 // 1 -> tells nodes to stop listening
50 } atomStruct;
51
52
53 typedef struct{
54 char nameA[15];
55 char nameB[15];
56 double d0;
57 double k0;
58 int last; // 0 -> default
59 // 1 -> tells nodes to stop listening
60 int type;
61 } bondStruct;
62
63
64 typedef struct{
65 char nameA[15];
66 char nameB[15];
67 char nameC[15];
68 char type[30];
69 double k1, k2, k3, t0;
70 int last; // 0 -> default
71 // 1 -> tells nodes to stop listening
72 } bendStruct;
73
74
75 typedef struct{
76 char nameA[15];
77 char nameB[15];
78 char nameC[15];
79 char nameD[15];
80 char type[30];
81 double k1, k2, k3, k4;
82 int last; // 0 -> default
83 // 1 -> tells nodes to stop listening
84 } torsionStruct;
85
86
87 int parseAtom( char *lineBuffer, int lineNum, atomStruct &info );
88 int parseBond( char *lineBuffer, int lineNum, bondStruct &info );
89 int parseBend( char *lineBuffer, int lineNum, bendStruct &info );
90 int parseTorsion( char *lineBuffer, int lineNum, torsionStruct &info );
91
92
93 #ifdef IS_MPI
94
95 MPI_Datatype mpiAtomStructType;
96 MPI_Datatype mpiBondStructType;
97 MPI_Datatype mpiBendStructType;
98 MPI_Datatype mpiTorsionStructType;
99
100 #endif
101
102 class LinkedAtomType {
103 public:
104 LinkedAtomType(){
105 next = NULL;
106 name[0] = '\0';
107 }
108 ~LinkedAtomType(){ if( next != NULL ) delete next; }
109
110 LinkedAtomType* find(char* key){
111 if( !strcmp(name, key) ) return this;
112 if( next != NULL ) return next->find(key);
113 return NULL;
114 }
115
116 void printMe( void ){
117
118 std::cerr << "LinkedAtype " << name << ": ident = " << ident << "\n";
119 // if( next != NULL ) next->printMe();
120
121 }
122
123 void add( atomStruct &info ){
124
125 // check for duplicates
126
127 if( !strcmp( info.name, name ) ){
128 sprintf( painCave.errMsg,
129 "Duplicate DUFF atom type \"%s\" found in "
130 "the DUFF param file./n",
131 name );
132 painCave.isFatal = 1;
133 simError();
134 }
135
136 if( next != NULL ) next->add(info);
137 else{
138 next = new LinkedAtomType();
139 strcpy(next->name, info.name);
140 next->isDipole = info.isDipole;
141 next->isSSD = info.isSSD;
142 next->mass = info.mass;
143 next->epslon = info.epslon;
144 next->sigma = info.sigma;
145 next->dipole = info.dipole;
146 next->w0 = info.w0;
147 next->v0 = info.v0;
148 next->v0p = info.v0p;
149 next->rl = info.rl;
150 next->ru = info.ru;
151 next->rlp = info.rlp;
152 next->rup = info.rup;
153 next->ident = info.ident;
154 }
155 }
156
157 #ifdef IS_MPI
158
159 void duplicate( atomStruct &info ){
160 strcpy(info.name, name);
161 info.isDipole = isDipole;
162 info.isSSD = isSSD;
163 info.mass = mass;
164 info.epslon = epslon;
165 info.sigma = sigma;
166 info.dipole = dipole;
167 info.w0 = w0;
168 info.v0 = v0;
169 info.v0p = v0p;
170 info.rl = rl;
171 info.ru = ru;
172 info.rlp = rlp;
173 info.rup = rup;
174 info.ident = ident;
175 info.last = 0;
176 }
177
178
179 #endif
180
181 char name[15];
182 int isDipole;
183 int isSSD;
184 double mass;
185 double epslon;
186 double sigma;
187 double dipole;
188 double w0;
189 double v0;
190 double v0p;
191 double rl;
192 double ru;
193 double rlp;
194 double rup;
195 int ident;
196 LinkedAtomType* next;
197 };
198
199 class LinkedBondType {
200 public:
201 LinkedBondType(){
202 next = NULL;
203 nameA[0] = '\0';
204 nameB[0] = '\0';
205 }
206 ~LinkedBondType(){ if( next != NULL ) delete next; }
207
208 LinkedBondType* find(char* key1, char* key2){
209 if( !strcmp(nameA, key1 ) && !strcmp( nameB, key2 ) ) return this;
210 if( !strcmp(nameA, key2 ) && !strcmp( nameB, key1 ) ) return this;
211 if( next != NULL ) return next->find(key1, key2);
212 return NULL;
213 }
214
215
216 void add( bondStruct &info ){
217
218 // check for duplicates
219 int dup = 0;
220
221 if( !strcmp(nameA, info.nameA ) && !strcmp( nameB, info.nameB ) ) dup = 1;
222 if( !strcmp(nameA, info.nameB ) && !strcmp( nameB, info.nameA ) ) dup = 1;
223
224 if(dup){
225 sprintf( painCave.errMsg,
226 "Duplicate DUFF bond type \"%s - %s\" found in "
227 "the DUFF param file./n",
228 nameA, nameB );
229 painCave.isFatal = 1;
230 simError();
231 }
232
233
234 if( next != NULL ) next->add(info);
235 else{
236 next = new LinkedBondType();
237 strcpy(next->nameA, info.nameA);
238 strcpy(next->nameB, info.nameB);
239 next->type = info.type;
240 next->d0 = info.d0;
241 next->k0 = info.k0;
242 }
243 }
244
245 #ifdef IS_MPI
246 void duplicate( bondStruct &info ){
247 strcpy(info.nameA, nameA);
248 strcpy(info.nameB, nameB);
249 info.type = type;
250 info.d0 = d0;
251 info.k0 = k0;
252 info.last = 0;
253 }
254
255
256 #endif
257
258 char nameA[15];
259 char nameB[15];
260 int type;
261 double d0;
262 double k0;
263
264 LinkedBondType* next;
265 };
266
267 class LinkedBendType {
268 public:
269 LinkedBendType(){
270 next = NULL;
271 nameA[0] = '\0';
272 nameB[0] = '\0';
273 nameC[0] = '\0';
274 type[0] = '\0';
275 }
276 ~LinkedBendType(){ if( next != NULL ) delete next; }
277
278 LinkedBendType* find( char* key1, char* key2, char* key3 ){
279 if( !strcmp( nameA, key1 ) && !strcmp( nameB, key2 )
280 && !strcmp( nameC, key3 ) ) return this;
281 if( !strcmp( nameA, key3 ) && !strcmp( nameB, key2 )
282 && !strcmp( nameC, key1 ) ) return this;
283 if( next != NULL ) return next->find(key1, key2, key3);
284 return NULL;
285 }
286
287 void add( bendStruct &info ){
288
289 // check for duplicates
290 int dup = 0;
291
292 if( !strcmp( nameA, info.nameA ) && !strcmp( nameB, info.nameB )
293 && !strcmp( nameC, info.nameC ) ) dup = 1;
294 if( !strcmp( nameA, info.nameC ) && !strcmp( nameB, info.nameB )
295 && !strcmp( nameC, info.nameA ) ) dup = 1;
296
297 if(dup){
298 sprintf( painCave.errMsg,
299 "Duplicate DUFF bend type \"%s - %s - %s\" found in "
300 "the DUFF param file./n",
301 nameA, nameB, nameC );
302 painCave.isFatal = 1;
303 simError();
304 }
305
306 if( next != NULL ) next->add(info);
307 else{
308 next = new LinkedBendType();
309 strcpy(next->nameA, info.nameA);
310 strcpy(next->nameB, info.nameB);
311 strcpy(next->nameC, info.nameC);
312 strcpy(next->type, info.type);
313 next->k1 = info.k1;
314 next->k2 = info.k2;
315 next->k3 = info.k3;
316 next->t0 = info.t0;
317 }
318 }
319
320 #ifdef IS_MPI
321
322 void duplicate( bendStruct &info ){
323 strcpy(info.nameA, nameA);
324 strcpy(info.nameB, nameB);
325 strcpy(info.nameC, nameC);
326 strcpy(info.type, type);
327 info.k1 = k1;
328 info.k2 = k2;
329 info.k3 = k3;
330 info.t0 = t0;
331 info.last = 0;
332 }
333
334 #endif // is_mpi
335
336 char nameA[15];
337 char nameB[15];
338 char nameC[15];
339 char type[30];
340 double k1, k2, k3, t0;
341
342 LinkedBendType* next;
343 };
344
345 class LinkedTorsionType {
346 public:
347 LinkedTorsionType(){
348 next = NULL;
349 nameA[0] = '\0';
350 nameB[0] = '\0';
351 nameC[0] = '\0';
352 type[0] = '\0';
353 }
354 ~LinkedTorsionType(){ if( next != NULL ) delete next; }
355
356 LinkedTorsionType* find( char* key1, char* key2, char* key3, char* key4 ){
357
358
359
360
361 if( !strcmp( nameA, key1 ) && !strcmp( nameB, key2 ) &&
362 !strcmp( nameC, key3 ) && !strcmp( nameD, key4 ) ) return this;
363
364 if( !strcmp( nameA, key4 ) && !strcmp( nameB, key3 ) &&
365 !strcmp( nameC, key2 ) && !strcmp( nameD, key1 ) ) return this;
366
367 if( next != NULL ) return next->find(key1, key2, key3, key4);
368 return NULL;
369 }
370
371 void add( torsionStruct &info ){
372
373 // check for duplicates
374 int dup = 0;
375
376 if( !strcmp( nameA, info.nameA ) && !strcmp( nameB, info.nameB ) &&
377 !strcmp( nameC, info.nameC ) && !strcmp( nameD, info.nameD ) ) dup = 1;
378
379 if( !strcmp( nameA, info.nameD ) && !strcmp( nameB, info.nameC ) &&
380 !strcmp( nameC, info.nameB ) && !strcmp( nameD, info.nameA ) ) dup = 1;
381
382 if(dup){
383 sprintf( painCave.errMsg,
384 "Duplicate DUFF torsion type \"%s - %s - %s - %s\" found in "
385 "the DUFF param file./n", nameA, nameB, nameC, nameD );
386 painCave.isFatal = 1;
387 simError();
388 }
389
390 if( next != NULL ) next->add(info);
391 else{
392 next = new LinkedTorsionType();
393 strcpy(next->nameA, info.nameA);
394 strcpy(next->nameB, info.nameB);
395 strcpy(next->nameC, info.nameC);
396 strcpy(next->nameD, info.nameD);
397 strcpy(next->type, info.type);
398 next->k1 = info.k1;
399 next->k2 = info.k2;
400 next->k3 = info.k3;
401 next->k4 = info.k4;
402
403 }
404 }
405
406 #ifdef IS_MPI
407
408 void duplicate( torsionStruct &info ){
409 strcpy(info.nameA, nameA);
410 strcpy(info.nameB, nameB);
411 strcpy(info.nameC, nameC);
412 strcpy(info.nameD, nameD);
413 strcpy(info.type, type);
414 info.k1 = k1;
415 info.k2 = k2;
416 info.k3 = k3;
417 info.k4 = k4;
418 info.last = 0;
419 }
420
421 #endif
422
423 char nameA[15];
424 char nameB[15];
425 char nameC[15];
426 char nameD[15];
427 char type[30];
428 double k1, k2, k3, k4;
429
430 LinkedTorsionType* next;
431 };
432
433
434 LinkedAtomType* headAtomType;
435 LinkedAtomType* currentAtomType;
436 LinkedBondType* headBondType;
437 LinkedBondType* currentBondType;
438 LinkedBendType* headBendType;
439 LinkedBendType* currentBendType;
440 LinkedTorsionType* headTorsionType;
441 LinkedTorsionType* currentTorsionType;
442
443 } // namespace
444
445 using namespace DUFF_NS;
446
447
448 //****************************************************************
449 // begins the actual forcefield stuff.
450 //****************************************************************
451
452
453 DUFF::DUFF(){
454
455 char fileName[200];
456 char* ffPath_env = "FORCE_PARAM_PATH";
457 char* ffPath;
458 char temp[200];
459
460 headAtomType = NULL;
461 currentAtomType = NULL;
462 headBondType = NULL;
463 currentBondType = NULL;
464 headBendType = NULL;
465 currentBendType = NULL;
466 headTorsionType = NULL;
467 currentTorsionType = NULL;
468
469 // do the funtion wrapping
470 wrapMeFF( this );
471
472
473 #ifdef IS_MPI
474 int i;
475
476 // **********************************************************************
477 // Init the atomStruct mpi type
478
479 atomStruct atomProto; // mpiPrototype
480 int atomBC[3] = {15,12,5}; // block counts
481 MPI_Aint atomDspls[3]; // displacements
482 MPI_Datatype atomMbrTypes[3]; // member mpi types
483
484 MPI_Address(&atomProto.name, &atomDspls[0]);
485 MPI_Address(&atomProto.mass, &atomDspls[1]);
486 MPI_Address(&atomProto.isSSD, &atomDspls[2]);
487
488 atomMbrTypes[0] = MPI_CHAR;
489 atomMbrTypes[1] = MPI_DOUBLE;
490 atomMbrTypes[2] = MPI_INT;
491
492 for (i=2; i >= 0; i--) atomDspls[i] -= atomDspls[0];
493
494 MPI_Type_struct(3, atomBC, atomDspls, atomMbrTypes, &mpiAtomStructType);
495 MPI_Type_commit(&mpiAtomStructType);
496
497
498 // **********************************************************************
499 // Init the bondStruct mpi type
500
501 bondStruct bondProto; // mpiPrototype
502 int bondBC[3] = {30,2,2}; // block counts
503 MPI_Aint bondDspls[3]; // displacements
504 MPI_Datatype bondMbrTypes[3]; // member mpi types
505
506 MPI_Address(&bondProto.nameA, &bondDspls[0]);
507 MPI_Address(&bondProto.d0, &bondDspls[1]);
508 MPI_Address(&bondProto.last, &bondDspls[2]);
509
510 bondMbrTypes[0] = MPI_CHAR;
511 bondMbrTypes[1] = MPI_DOUBLE;
512 bondMbrTypes[2] = MPI_INT;
513
514 for (i=2; i >= 0; i--) bondDspls[i] -= bondDspls[0];
515
516 MPI_Type_struct(3, bondBC, bondDspls, bondMbrTypes, &mpiBondStructType);
517 MPI_Type_commit(&mpiBondStructType);
518
519
520 // **********************************************************************
521 // Init the bendStruct mpi type
522
523 bendStruct bendProto; // mpiPrototype
524 int bendBC[3] = {75,4,1}; // block counts
525 MPI_Aint bendDspls[3]; // displacements
526 MPI_Datatype bendMbrTypes[3]; // member mpi types
527
528 MPI_Address(&bendProto.nameA, &bendDspls[0]);
529 MPI_Address(&bendProto.k1, &bendDspls[1]);
530 MPI_Address(&bendProto.last, &bendDspls[2]);
531
532 bendMbrTypes[0] = MPI_CHAR;
533 bendMbrTypes[1] = MPI_DOUBLE;
534 bendMbrTypes[2] = MPI_INT;
535
536 for (i=2; i >= 0; i--) bendDspls[i] -= bendDspls[0];
537
538 MPI_Type_struct(3, bendBC, bendDspls, bendMbrTypes, &mpiBendStructType);
539 MPI_Type_commit(&mpiBendStructType);
540
541
542 // **********************************************************************
543 // Init the torsionStruct mpi type
544
545 torsionStruct torsionProto; // mpiPrototype
546 int torsionBC[3] = {90,4,1}; // block counts
547 MPI_Aint torsionDspls[3]; // displacements
548 MPI_Datatype torsionMbrTypes[3]; // member mpi types
549
550 MPI_Address(&torsionProto.nameA, &torsionDspls[0]);
551 MPI_Address(&torsionProto.k1, &torsionDspls[1]);
552 MPI_Address(&torsionProto.last, &torsionDspls[2]);
553
554 torsionMbrTypes[0] = MPI_CHAR;
555 torsionMbrTypes[1] = MPI_DOUBLE;
556 torsionMbrTypes[2] = MPI_INT;
557
558 for (i=2; i >= 0; i--) torsionDspls[i] -= torsionDspls[0];
559
560 MPI_Type_struct(3, torsionBC, torsionDspls, torsionMbrTypes,
561 &mpiTorsionStructType);
562 MPI_Type_commit(&mpiTorsionStructType);
563
564 // ***********************************************************************
565
566 if( worldRank == 0 ){
567 #endif
568
569 // generate the force file name
570
571 strcpy( fileName, "DUFF.frc" );
572 // fprintf( stderr,"Trying to open %s\n", fileName );
573
574 // attempt to open the file in the current directory first.
575
576 frcFile = fopen( fileName, "r" );
577
578 if( frcFile == NULL ){
579
580 // next see if the force path enviorment variable is set
581
582 ffPath = getenv( ffPath_env );
583 if( ffPath == NULL ) {
584 STR_DEFINE(ffPath, FRC_PATH );
585 }
586
587
588 strcpy( temp, ffPath );
589 strcat( temp, "/" );
590 strcat( temp, fileName );
591 strcpy( fileName, temp );
592
593 frcFile = fopen( fileName, "r" );
594
595 if( frcFile == NULL ){
596
597 sprintf( painCave.errMsg,
598 "Error opening the force field parameter file:\n"
599 "\t%s\n"
600 "\tHave you tried setting the FORCE_PARAM_PATH environment "
601 "variable?\n",
602 fileName );
603 painCave.severity = OOPSE_ERROR;
604 painCave.isFatal = 1;
605 simError();
606 }
607 }
608
609 #ifdef IS_MPI
610 }
611
612 sprintf( checkPointMsg, "DUFF file opened sucessfully." );
613 MPIcheckPoint();
614
615 #endif // is_mpi
616 }
617
618
619 DUFF::~DUFF(){
620
621 if( headAtomType != NULL ) delete headAtomType;
622 if( headBondType != NULL ) delete headBondType;
623 if( headBendType != NULL ) delete headBendType;
624 if( headTorsionType != NULL ) delete headTorsionType;
625
626 #ifdef IS_MPI
627 if( worldRank == 0 ){
628 #endif // is_mpi
629
630 fclose( frcFile );
631
632 #ifdef IS_MPI
633 }
634 #endif // is_mpi
635 }
636
637 void DUFF::cleanMe( void ){
638
639 #ifdef IS_MPI
640
641 // keep the linked lists in the mpi version
642
643 #else // is_mpi
644
645 // delete the linked lists in the single processor version
646
647 if( headAtomType != NULL ) delete headAtomType;
648 if( headBondType != NULL ) delete headBondType;
649 if( headBendType != NULL ) delete headBendType;
650 if( headTorsionType != NULL ) delete headTorsionType;
651
652 #endif // is_mpi
653 }
654
655
656 void DUFF::initForceField( int ljMixRule ){
657
658 initFortran( ljMixRule, entry_plug->useReactionField );
659 }
660
661 double DUFF::getAtomTypeMass (char* atomType) {
662
663 currentAtomType = headAtomType->find( atomType );
664 if( currentAtomType == NULL ){
665 sprintf( painCave.errMsg,
666 "AtomType error, %s not found in force file.\n",
667 atomType );
668 painCave.isFatal = 1;
669 simError();
670 }
671
672 return currentAtomType->mass;
673 }
674
675 void DUFF::readParams( void ){
676
677 int identNum;
678
679 atomStruct atomInfo;
680 bondStruct bondInfo;
681 bendStruct bendInfo;
682 torsionStruct torsionInfo;
683
684 bigSigma = 0.0;
685
686 atomInfo.last = 1;
687 bondInfo.last = 1;
688 bendInfo.last = 1;
689 torsionInfo.last = 1;
690
691 // read in the atom info
692
693 #ifdef IS_MPI
694 if( worldRank == 0 ){
695 #endif
696
697 // read in the atom types.
698
699 headAtomType = new LinkedAtomType;
700
701 fastForward( "AtomTypes", "initializeAtoms" );
702
703 // we are now at the AtomTypes section.
704
705 eof_test = fgets( readLine, sizeof(readLine), frcFile );
706 lineNum++;
707
708
709 // read a line, and start parseing out the atom types
710
711 if( eof_test == NULL ){
712 sprintf( painCave.errMsg,
713 "Error in reading Atoms from force file at line %d.\n",
714 lineNum );
715 painCave.isFatal = 1;
716 simError();
717 }
718
719 identNum = 1;
720 // stop reading at end of file, or at next section
721 while( readLine[0] != '#' && eof_test != NULL ){
722
723 // toss comment lines
724 if( readLine[0] != '!' ){
725
726 // the parser returns 0 if the line was blank
727 if( parseAtom( readLine, lineNum, atomInfo ) ){
728 atomInfo.ident = identNum;
729 headAtomType->add( atomInfo );;
730 identNum++;
731 }
732 }
733 eof_test = fgets( readLine, sizeof(readLine), frcFile );
734 lineNum++;
735 }
736
737 #ifdef IS_MPI
738
739 // send out the linked list to all the other processes
740
741 sprintf( checkPointMsg,
742 "DUFF atom structures read successfully." );
743 MPIcheckPoint();
744
745 currentAtomType = headAtomType->next; //skip the first element who is a place holder.
746 while( currentAtomType != NULL ){
747 currentAtomType->duplicate( atomInfo );
748
749 sendFrcStruct( &atomInfo, mpiAtomStructType );
750
751 sprintf( checkPointMsg,
752 "successfully sent DUFF force type: \"%s\"\n",
753 atomInfo.name );
754 MPIcheckPoint();
755
756 currentAtomType = currentAtomType->next;
757 }
758 atomInfo.last = 1;
759 sendFrcStruct( &atomInfo, mpiAtomStructType );
760
761 }
762
763 else{
764
765 // listen for node 0 to send out the force params
766
767 MPIcheckPoint();
768
769 headAtomType = new LinkedAtomType;
770 receiveFrcStruct( &atomInfo, mpiAtomStructType );
771
772 while( !atomInfo.last ){
773
774 headAtomType->add( atomInfo );
775
776 MPIcheckPoint();
777
778 receiveFrcStruct( &atomInfo, mpiAtomStructType );
779 }
780 }
781
782 #endif // is_mpi
783
784
785
786 // call new A_types in fortran
787
788 int isError;
789
790 // dummy variables
791
792 int isGB = 0;
793 int isLJ = 1;
794 int isEAM =0;
795 int isCharge = 0;
796 double charge=0.0;
797
798 currentAtomType = headAtomType->next;;
799 while( currentAtomType != NULL ){
800
801 if(currentAtomType->isDipole) entry_plug->useDipoles = 1;
802 if(currentAtomType->isSSD) {
803 entry_plug->useSticky = 1;
804 set_sticky_params( &(currentAtomType->w0), &(currentAtomType->v0),
805 &(currentAtomType->v0p),
806 &(currentAtomType->rl), &(currentAtomType->ru),
807 &(currentAtomType->rlp), &(currentAtomType->rup));
808 }
809
810 if( currentAtomType->name[0] != '\0' ){
811 isError = 0;
812 makeAtype( &(currentAtomType->ident),
813 &isLJ,
814 &(currentAtomType->isSSD),
815 &(currentAtomType->isDipole),
816 &isGB,
817 &isEAM,
818 &isCharge,
819 &(currentAtomType->epslon),
820 &(currentAtomType->sigma),
821 &charge,
822 &(currentAtomType->dipole),
823 &isError );
824 if( isError ){
825 sprintf( painCave.errMsg,
826 "Error initializing the \"%s\" atom type in fortran\n",
827 currentAtomType->name );
828 painCave.isFatal = 1;
829 simError();
830 }
831 }
832 currentAtomType = currentAtomType->next;
833 }
834
835 #ifdef IS_MPI
836 sprintf( checkPointMsg,
837 "DUFF atom structures successfully sent to fortran\n" );
838 MPIcheckPoint();
839 #endif // is_mpi
840
841
842
843 // read in the bonds
844
845 #ifdef IS_MPI
846 if( worldRank == 0 ){
847 #endif
848
849 // read in the bond types.
850
851 headBondType = new LinkedBondType;
852
853 fastForward( "BondTypes", "initializeBonds" );
854
855 // we are now at the bondTypes section
856
857 eof_test = fgets( readLine, sizeof(readLine), frcFile );
858 lineNum++;
859
860
861 // read a line, and start parseing out the atom types
862
863 if( eof_test == NULL ){
864 sprintf( painCave.errMsg,
865 "Error in reading bonds from force file at line %d.\n",
866 lineNum );
867 painCave.isFatal = 1;
868 simError();
869 }
870
871 // stop reading at end of file, or at next section
872 while( readLine[0] != '#' && eof_test != NULL ){
873
874 // toss comment lines
875 if( readLine[0] != '!' ){
876
877 // the parser returns 0 if the line was blank
878 if( parseBond( readLine, lineNum, bondInfo ) ){
879 headBondType->add( bondInfo );
880 }
881 }
882 eof_test = fgets( readLine, sizeof(readLine), frcFile );
883 lineNum++;
884 }
885
886 #ifdef IS_MPI
887
888 // send out the linked list to all the other processes
889
890 sprintf( checkPointMsg,
891 "DUFF bond structures read successfully." );
892 MPIcheckPoint();
893
894 currentBondType = headBondType->next;
895 while( currentBondType != NULL ){
896 currentBondType->duplicate( bondInfo );
897 sendFrcStruct( &bondInfo, mpiBondStructType );
898 currentBondType = currentBondType->next;
899 }
900 bondInfo.last = 1;
901 sendFrcStruct( &bondInfo, mpiBondStructType );
902
903 }
904
905 else{
906
907 // listen for node 0 to send out the force params
908
909 MPIcheckPoint();
910
911 headBondType = new LinkedBondType;
912 receiveFrcStruct( &bondInfo, mpiBondStructType );
913 while( !bondInfo.last ){
914
915 headBondType->add( bondInfo );
916 receiveFrcStruct( &bondInfo, mpiBondStructType );
917 }
918 }
919
920 sprintf( checkPointMsg,
921 "DUFF bond structures broadcast successfully." );
922 MPIcheckPoint();
923
924 #endif // is_mpi
925
926
927 // read in the bends
928
929 #ifdef IS_MPI
930 if( worldRank == 0 ){
931 #endif
932
933 // read in the bend types.
934
935 headBendType = new LinkedBendType;
936
937 fastForward( "BendTypes", "initializeBends" );
938
939 // we are now at the bendTypes section
940
941 eof_test = fgets( readLine, sizeof(readLine), frcFile );
942 lineNum++;
943
944 // read a line, and start parseing out the bend types
945
946 if( eof_test == NULL ){
947 sprintf( painCave.errMsg,
948 "Error in reading bends from force file at line %d.\n",
949 lineNum );
950 painCave.isFatal = 1;
951 simError();
952 }
953
954 // stop reading at end of file, or at next section
955 while( readLine[0] != '#' && eof_test != NULL ){
956
957 // toss comment lines
958 if( readLine[0] != '!' ){
959
960 // the parser returns 0 if the line was blank
961 if( parseBend( readLine, lineNum, bendInfo ) ){
962 headBendType->add( bendInfo );
963 }
964 }
965 eof_test = fgets( readLine, sizeof(readLine), frcFile );
966 lineNum++;
967 }
968
969 #ifdef IS_MPI
970
971 // send out the linked list to all the other processes
972
973 sprintf( checkPointMsg,
974 "DUFF bend structures read successfully." );
975 MPIcheckPoint();
976
977 currentBendType = headBendType->next;
978 while( currentBendType != NULL ){
979 currentBendType->duplicate( bendInfo );
980 sendFrcStruct( &bendInfo, mpiBendStructType );
981 currentBendType = currentBendType->next;
982 }
983 bendInfo.last = 1;
984 sendFrcStruct( &bendInfo, mpiBendStructType );
985
986 }
987
988 else{
989
990 // listen for node 0 to send out the force params
991
992 MPIcheckPoint();
993
994 headBendType = new LinkedBendType;
995 receiveFrcStruct( &bendInfo, mpiBendStructType );
996 while( !bendInfo.last ){
997
998 headBendType->add( bendInfo );
999 receiveFrcStruct( &bendInfo, mpiBendStructType );
1000 }
1001 }
1002
1003 sprintf( checkPointMsg,
1004 "DUFF bend structures broadcast successfully." );
1005 MPIcheckPoint();
1006
1007 #endif // is_mpi
1008
1009
1010 // read in the torsions
1011
1012 #ifdef IS_MPI
1013 if( worldRank == 0 ){
1014 #endif
1015
1016 // read in the torsion types.
1017
1018 headTorsionType = new LinkedTorsionType;
1019
1020 fastForward( "TorsionTypes", "initializeTorsions" );
1021
1022 // we are now at the torsionTypes section
1023
1024 eof_test = fgets( readLine, sizeof(readLine), frcFile );
1025 lineNum++;
1026
1027
1028 // read a line, and start parseing out the atom types
1029
1030 if( eof_test == NULL ){
1031 sprintf( painCave.errMsg,
1032 "Error in reading torsions from force file at line %d.\n",
1033 lineNum );
1034 painCave.isFatal = 1;
1035 simError();
1036 }
1037
1038 // stop reading at end of file, or at next section
1039 while( readLine[0] != '#' && eof_test != NULL ){
1040
1041 // toss comment lines
1042 if( readLine[0] != '!' ){
1043
1044 // the parser returns 0 if the line was blank
1045 if( parseTorsion( readLine, lineNum, torsionInfo ) ){
1046 headTorsionType->add( torsionInfo );
1047
1048 }
1049 }
1050 eof_test = fgets( readLine, sizeof(readLine), frcFile );
1051 lineNum++;
1052 }
1053
1054 #ifdef IS_MPI
1055
1056 // send out the linked list to all the other processes
1057
1058 sprintf( checkPointMsg,
1059 "DUFF torsion structures read successfully." );
1060 MPIcheckPoint();
1061
1062 currentTorsionType = headTorsionType->next;
1063 while( currentTorsionType != NULL ){
1064 currentTorsionType->duplicate( torsionInfo );
1065 sendFrcStruct( &torsionInfo, mpiTorsionStructType );
1066 currentTorsionType = currentTorsionType->next;
1067 }
1068 torsionInfo.last = 1;
1069 sendFrcStruct( &torsionInfo, mpiTorsionStructType );
1070
1071 }
1072
1073 else{
1074
1075 // listen for node 0 to send out the force params
1076
1077 MPIcheckPoint();
1078
1079 headTorsionType = new LinkedTorsionType;
1080 receiveFrcStruct( &torsionInfo, mpiTorsionStructType );
1081 while( !torsionInfo.last ){
1082
1083 headTorsionType->add( torsionInfo );
1084 receiveFrcStruct( &torsionInfo, mpiTorsionStructType );
1085 }
1086 }
1087
1088 sprintf( checkPointMsg,
1089 "DUFF torsion structures broadcast successfully." );
1090 MPIcheckPoint();
1091
1092 #endif // is_mpi
1093
1094 entry_plug->useLJ = 1;
1095 }
1096
1097
1098
1099 void DUFF::initializeAtoms( int nAtoms, Atom** the_atoms ){
1100
1101
1102 //////////////////////////////////////////////////
1103 // a quick water fix
1104
1105 double waterI[3][3];
1106 waterI[0][0] = 1.76958347772500;
1107 waterI[0][1] = 0.0;
1108 waterI[0][2] = 0.0;
1109
1110 waterI[1][0] = 0.0;
1111 waterI[1][1] = 0.614537057924513;
1112 waterI[1][2] = 0.0;
1113
1114 waterI[2][0] = 0.0;
1115 waterI[2][1] = 0.0;
1116 waterI[2][2] = 1.15504641980049;
1117
1118
1119 double headI[3][3];
1120 headI[0][0] = 1125;
1121 headI[0][1] = 0.0;
1122 headI[0][2] = 0.0;
1123
1124 headI[1][0] = 0.0;
1125 headI[1][1] = 1125;
1126 headI[1][2] = 0.0;
1127
1128 headI[2][0] = 0.0;
1129 headI[2][1] = 0.0;
1130 headI[2][2] = 250;
1131
1132 //////////////////////////////////////////////////
1133
1134
1135 // initialize the atoms
1136
1137 DirectionalAtom* dAtom;
1138 double ji[3];
1139
1140 for(int i=0; i<nAtoms; i++ ){
1141
1142 currentAtomType = headAtomType->find( the_atoms[i]->getType() );
1143 if( currentAtomType == NULL ){
1144 sprintf( painCave.errMsg,
1145 "AtomType error, %s not found in force file.\n",
1146 the_atoms[i]->getType() );
1147 painCave.isFatal = 1;
1148 simError();
1149 }
1150
1151 the_atoms[i]->setMass( currentAtomType->mass );
1152 the_atoms[i]->setIdent( currentAtomType->ident );
1153
1154 if( bigSigma < currentAtomType->sigma ) bigSigma = currentAtomType->sigma;
1155
1156 if( currentAtomType->isDipole ){
1157 if( the_atoms[i]->isDirectional() ){
1158
1159 dAtom = (DirectionalAtom *) the_atoms[i];
1160 dAtom->setHasDipole( 1 );
1161
1162 ji[0] = 0.0;
1163 ji[1] = 0.0;
1164 ji[2] = 0.0;
1165
1166 dAtom->setJ( ji );
1167
1168 if(!strcmp("SSD",the_atoms[i]->getType())){
1169 dAtom->setI( waterI );
1170 }
1171 else if(!strcmp("HEAD",the_atoms[i]->getType())){
1172 dAtom->setI( headI );
1173 }
1174 else{
1175 sprintf(painCave.errMsg,
1176 "AtmType error, %s does not have a moment of inertia set.\n",
1177 the_atoms[i]->getType() );
1178 painCave.isFatal = 1;
1179 simError();
1180 }
1181 entry_plug->n_dipoles++;
1182 }
1183 else{
1184
1185 sprintf( painCave.errMsg,
1186 "DUFF error: Atom \"%s\" is a dipole, yet no standard"
1187 " orientation was specifed in the meta-data file.\n",
1188 currentAtomType->name );
1189 painCave.isFatal = 1;
1190 simError();
1191 }
1192 }
1193 else{
1194 if( the_atoms[i]->isDirectional() ){
1195 sprintf( painCave.errMsg,
1196 "DUFF error: Atom \"%s\" was given a standard "
1197 "orientation in the meta-data file, yet it is not a dipole.\n",
1198 currentAtomType->name);
1199 painCave.isFatal = 1;
1200 simError();
1201 }
1202 }
1203 }
1204 }
1205
1206 void DUFF::initializeBonds( int nBonds, Bond** bondArray,
1207 bond_pair* the_bonds ){
1208 int i,a,b;
1209 char* atomA;
1210 char* atomB;
1211
1212 Atom** the_atoms;
1213 the_atoms = entry_plug->atoms;
1214
1215
1216 // initialize the Bonds
1217
1218 for( i=0; i<nBonds; i++ ){
1219
1220 a = the_bonds[i].a;
1221 b = the_bonds[i].b;
1222
1223 atomA = the_atoms[a]->getType();
1224 atomB = the_atoms[b]->getType();
1225 currentBondType = headBondType->find( atomA, atomB );
1226 if( currentBondType == NULL ){
1227 sprintf( painCave.errMsg,
1228 "BondType error, %s - %s not found in force file.\n",
1229 atomA, atomB );
1230 painCave.isFatal = 1;
1231 simError();
1232 }
1233
1234 switch( currentBondType->type ){
1235
1236 case FIXED_BOND:
1237
1238 bondArray[i] = new ConstrainedBond( *the_atoms[a],
1239 *the_atoms[b],
1240 currentBondType->d0 );
1241 entry_plug->n_constraints++;
1242 break;
1243
1244 case HARMONIC_BOND:
1245
1246 bondArray[i] = new HarmonicBond( *the_atoms[a],
1247 *the_atoms[b],
1248 currentBondType->d0,
1249 currentBondType->k0 );
1250 break;
1251
1252 default:
1253
1254 break;
1255 // do nothing
1256 }
1257 }
1258 }
1259
1260 void DUFF::initializeBends( int nBends, Bend** bendArray,
1261 bend_set* the_bends ){
1262
1263 QuadraticBend* qBend;
1264 GhostBend* gBend;
1265 Atom** the_atoms;
1266 the_atoms = entry_plug->atoms;
1267
1268 int i, a, b, c;
1269 char* atomA;
1270 char* atomB;
1271 char* atomC;
1272
1273 // initialize the Bends
1274
1275 for( i=0; i<nBends; i++ ){
1276
1277 a = the_bends[i].a;
1278 b = the_bends[i].b;
1279 c = the_bends[i].c;
1280
1281 atomA = the_atoms[a]->getType();
1282 atomB = the_atoms[b]->getType();
1283
1284 if( the_bends[i].isGhost ) atomC = "GHOST";
1285 else atomC = the_atoms[c]->getType();
1286
1287 currentBendType = headBendType->find( atomA, atomB, atomC );
1288 if( currentBendType == NULL ){
1289 sprintf( painCave.errMsg, "BendType error, %s - %s - %s not found"
1290 " in force file.\n",
1291 atomA, atomB, atomC );
1292 painCave.isFatal = 1;
1293 simError();
1294 }
1295
1296 if( !strcmp( currentBendType->type, "quadratic" ) ){
1297
1298 if( the_bends[i].isGhost){
1299
1300 if( the_bends[i].ghost == b ){
1301 // do nothing
1302 }
1303 else if( the_bends[i].ghost == a ){
1304 c = a;
1305 a = b;
1306 b = c;
1307 }
1308 else{
1309 sprintf( painCave.errMsg,
1310 "BendType error, %s - %s - %s,\n"
1311 " --> central atom is not "
1312 "correctly identified with the "
1313 "\"ghostVectorSource = \" tag.\n",
1314 atomA, atomB, atomC );
1315 painCave.isFatal = 1;
1316 simError();
1317 }
1318
1319 gBend = new GhostBend( *the_atoms[a],
1320 *the_atoms[b]);
1321
1322 gBend->setConstants( currentBendType->k1,
1323 currentBendType->k2,
1324 currentBendType->k3,
1325 currentBendType->t0 );
1326 bendArray[i] = gBend;
1327 }
1328 else{
1329 qBend = new QuadraticBend( *the_atoms[a],
1330 *the_atoms[b],
1331 *the_atoms[c] );
1332 qBend->setConstants( currentBendType->k1,
1333 currentBendType->k2,
1334 currentBendType->k3,
1335 currentBendType->t0 );
1336 bendArray[i] = qBend;
1337 }
1338 }
1339 }
1340 }
1341
1342 void DUFF::initializeTorsions( int nTorsions, Torsion** torsionArray,
1343 torsion_set* the_torsions ){
1344
1345 int i, a, b, c, d;
1346 char* atomA;
1347 char* atomB;
1348 char* atomC;
1349 char* atomD;
1350
1351 CubicTorsion* cTors;
1352 Atom** the_atoms;
1353 the_atoms = entry_plug->atoms;
1354
1355 // initialize the Torsions
1356
1357 for( i=0; i<nTorsions; i++ ){
1358
1359 a = the_torsions[i].a;
1360 b = the_torsions[i].b;
1361 c = the_torsions[i].c;
1362 d = the_torsions[i].d;
1363
1364 atomA = the_atoms[a]->getType();
1365 atomB = the_atoms[b]->getType();
1366 atomC = the_atoms[c]->getType();
1367 atomD = the_atoms[d]->getType();
1368 currentTorsionType = headTorsionType->find( atomA, atomB, atomC, atomD );
1369 if( currentTorsionType == NULL ){
1370 sprintf( painCave.errMsg,
1371 "TorsionType error, %s - %s - %s - %s not found"
1372 " in force file.\n",
1373 atomA, atomB, atomC, atomD );
1374 painCave.isFatal = 1;
1375 simError();
1376 }
1377
1378 if( !strcmp( currentTorsionType->type, "cubic" ) ){
1379
1380 cTors = new CubicTorsion( *the_atoms[a], *the_atoms[b],
1381 *the_atoms[c], *the_atoms[d] );
1382 cTors->setConstants( currentTorsionType->k1, currentTorsionType->k2,
1383 currentTorsionType->k3, currentTorsionType->k4 );
1384 torsionArray[i] = cTors;
1385 }
1386 }
1387 }
1388
1389 void DUFF::fastForward( char* stopText, char* searchOwner ){
1390
1391 int foundText = 0;
1392 char* the_token;
1393
1394 rewind( frcFile );
1395 lineNum = 0;
1396
1397 eof_test = fgets( readLine, sizeof(readLine), frcFile );
1398 lineNum++;
1399 if( eof_test == NULL ){
1400 sprintf( painCave.errMsg, "Error fast forwarding force file for %s: "
1401 " file is empty.\n",
1402 searchOwner );
1403 painCave.isFatal = 1;
1404 simError();
1405 }
1406
1407
1408 while( !foundText ){
1409 while( eof_test != NULL && readLine[0] != '#' ){
1410 eof_test = fgets( readLine, sizeof(readLine), frcFile );
1411 lineNum++;
1412 }
1413 if( eof_test == NULL ){
1414 sprintf( painCave.errMsg,
1415 "Error fast forwarding force file for %s at "
1416 "line %d: file ended unexpectedly.\n",
1417 searchOwner,
1418 lineNum );
1419 painCave.isFatal = 1;
1420 simError();
1421 }
1422
1423 the_token = strtok( readLine, " ,;\t#\n" );
1424 foundText = !strcmp( stopText, the_token );
1425
1426 if( !foundText ){
1427 eof_test = fgets( readLine, sizeof(readLine), frcFile );
1428 lineNum++;
1429
1430 if( eof_test == NULL ){
1431 sprintf( painCave.errMsg,
1432 "Error fast forwarding force file for %s at "
1433 "line %d: file ended unexpectedly.\n",
1434 searchOwner,
1435 lineNum );
1436 painCave.isFatal = 1;
1437 simError();
1438 }
1439 }
1440 }
1441 }
1442
1443
1444 int DUFF_NS::parseAtom( char *lineBuffer, int lineNum, atomStruct &info ){
1445
1446 char* the_token;
1447
1448 the_token = strtok( lineBuffer, " \n\t,;" );
1449 if( the_token != NULL ){
1450
1451 strcpy( info.name, the_token );
1452
1453 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1454 sprintf( painCave.errMsg,
1455 "Error parseing AtomTypes: line %d\n", lineNum );
1456 painCave.isFatal = 1;
1457 simError();
1458 }
1459
1460 info.isDipole = atoi( the_token );
1461
1462 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1463 sprintf( painCave.errMsg,
1464 "Error parseing AtomTypes: line %d\n", lineNum );
1465 painCave.isFatal = 1;
1466 simError();
1467 }
1468
1469 info.isSSD = atoi( the_token );
1470
1471 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1472 sprintf( painCave.errMsg,
1473 "Error parseing AtomTypes: line %d\n", lineNum );
1474 painCave.isFatal = 1;
1475 simError();
1476 }
1477
1478 info.mass = atof( the_token );
1479
1480 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1481 sprintf( painCave.errMsg,
1482 "Error parseing AtomTypes: line %d\n", lineNum );
1483 painCave.isFatal = 1;
1484 simError();
1485 }
1486
1487 info.epslon = atof( the_token );
1488
1489 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1490 sprintf( painCave.errMsg,
1491 "Error parseing AtomTypes: line %d\n", lineNum );
1492 painCave.isFatal = 1;
1493 simError();
1494 }
1495
1496 info.sigma = atof( the_token );
1497
1498 if( info.isDipole ){
1499
1500 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1501 sprintf( painCave.errMsg,
1502 "Error parseing AtomTypes: line %d\n", lineNum );
1503 painCave.isFatal = 1;
1504 simError();
1505 }
1506
1507 info.dipole = atof( the_token );
1508 }
1509 else info.dipole = 0.0;
1510
1511 if( info.isSSD ){
1512
1513 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1514 sprintf( painCave.errMsg,
1515 "Error parseing AtomTypes: line %d\n", lineNum );
1516 painCave.isFatal = 1;
1517 simError();
1518 }
1519
1520 info.w0 = atof( the_token );
1521
1522 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1523 sprintf( painCave.errMsg,
1524 "Error parseing AtomTypes: line %d\n", lineNum );
1525 painCave.isFatal = 1;
1526 simError();
1527 }
1528
1529 info.v0 = atof( the_token );
1530 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1531 sprintf( painCave.errMsg,
1532 "Error parseing AtomTypes: line %d\n", lineNum );
1533 painCave.isFatal = 1;
1534 simError();
1535 }
1536
1537 info.v0p = atof( the_token );
1538
1539 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1540 sprintf( painCave.errMsg,
1541 "Error parseing AtomTypes: line %d\n", lineNum );
1542 painCave.isFatal = 1;
1543 simError();
1544 }
1545
1546 info.rl = atof( the_token );
1547
1548 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1549 sprintf( painCave.errMsg,
1550 "Error parseing AtomTypes: line %d\n", lineNum );
1551 painCave.isFatal = 1;
1552 simError();
1553 }
1554
1555 info.ru = atof( the_token );
1556
1557 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1558 sprintf( painCave.errMsg,
1559 "Error parseing AtomTypes: line %d\n", lineNum );
1560 painCave.isFatal = 1;
1561 simError();
1562 }
1563
1564 info.rlp = atof( the_token );
1565
1566 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1567 sprintf( painCave.errMsg,
1568 "Error parseing AtomTypes: line %d\n", lineNum );
1569 painCave.isFatal = 1;
1570 simError();
1571 }
1572
1573 info.rup = atof( the_token );
1574 }
1575 else info.v0 = info.w0 = info.v0p = info.rl = info.ru = info.rlp = info.rup = 0.0;
1576
1577 return 1;
1578 }
1579 else return 0;
1580 }
1581
1582 int DUFF_NS::parseBond( char *lineBuffer, int lineNum, bondStruct &info ){
1583
1584 char* the_token;
1585 char bondType[30];
1586
1587 the_token = strtok( lineBuffer, " \n\t,;" );
1588 if( the_token != NULL ){
1589
1590 strcpy( info.nameA, the_token );
1591
1592 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1593 sprintf( painCave.errMsg,
1594 "Error parseing BondTypes: line %d\n", lineNum );
1595 painCave.isFatal = 1;
1596 simError();
1597 }
1598
1599 strcpy( info.nameB, the_token );
1600
1601 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1602 sprintf( painCave.errMsg,
1603 "Error parseing BondTypes: line %d\n", lineNum );
1604 painCave.isFatal = 1;
1605 simError();
1606 }
1607
1608 strcpy( bondType, the_token );
1609
1610 if( !strcmp( bondType, "fixed" ) ){
1611 info.type = FIXED_BOND;
1612
1613 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1614 sprintf( painCave.errMsg,
1615 "Error parseing BondTypes: line %d\n", lineNum );
1616 painCave.isFatal = 1;
1617 simError();
1618 }
1619
1620 info.d0 = atof( the_token );
1621
1622 info.k0=0.0;
1623 }
1624 else if( !strcmp( bondType, "harmonic" ) ){
1625 info.type = HARMONIC_BOND;
1626
1627 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1628 sprintf( painCave.errMsg,
1629 "Error parseing BondTypes: line %d\n", lineNum );
1630 painCave.isFatal = 1;
1631 simError();
1632 }
1633
1634 info.d0 = atof( the_token );
1635
1636 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1637 sprintf( painCave.errMsg,
1638 "Error parseing BondTypes: line %d\n", lineNum );
1639 painCave.isFatal = 1;
1640 simError();
1641 }
1642
1643 info.k0 = atof( the_token );
1644 }
1645
1646 else{
1647 sprintf( painCave.errMsg,
1648 "Unknown DUFF bond type \"%s\" at line %d\n",
1649 bondType,
1650 lineNum );
1651 painCave.isFatal = 1;
1652 simError();
1653 }
1654
1655 return 1;
1656 }
1657 else return 0;
1658 }
1659
1660
1661 int DUFF_NS::parseBend( char *lineBuffer, int lineNum, bendStruct &info ){
1662
1663 char* the_token;
1664
1665 the_token = strtok( lineBuffer, " \n\t,;" );
1666 if( the_token != NULL ){
1667
1668 strcpy( info.nameA, the_token );
1669
1670 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1671 sprintf( painCave.errMsg,
1672 "Error parseing BendTypes: line %d\n", lineNum );
1673 painCave.isFatal = 1;
1674 simError();
1675 }
1676
1677 strcpy( info.nameB, the_token );
1678
1679 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1680 sprintf( painCave.errMsg,
1681 "Error parseing BendTypes: line %d\n", lineNum );
1682 painCave.isFatal = 1;
1683 simError();
1684 }
1685
1686 strcpy( info.nameC, the_token );
1687
1688 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1689 sprintf( painCave.errMsg,
1690 "Error parseing BendTypes: line %d\n", lineNum );
1691 painCave.isFatal = 1;
1692 simError();
1693 }
1694
1695 strcpy( info.type, the_token );
1696
1697 if( !strcmp( info.type, "quadratic" ) ){
1698 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1699 sprintf( painCave.errMsg,
1700 "Error parseing BendTypes: line %d\n", lineNum );
1701 painCave.isFatal = 1;
1702 simError();
1703 }
1704
1705 info.k1 = atof( the_token );
1706
1707 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1708 sprintf( painCave.errMsg,
1709 "Error parseing BendTypes: line %d\n", lineNum );
1710 painCave.isFatal = 1;
1711 simError();
1712 }
1713
1714 info.k2 = atof( the_token );
1715
1716 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1717 sprintf( painCave.errMsg,
1718 "Error parseing BendTypes: line %d\n", lineNum );
1719 painCave.isFatal = 1;
1720 simError();
1721 }
1722
1723 info.k3 = atof( the_token );
1724
1725 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1726 sprintf( painCave.errMsg,
1727 "Error parseing BendTypes: line %d\n", lineNum );
1728 painCave.isFatal = 1;
1729 simError();
1730 }
1731
1732 info.t0 = atof( the_token );
1733 }
1734
1735 else{
1736 sprintf( painCave.errMsg,
1737 "Unknown DUFF bend type \"%s\" at line %d\n",
1738 info.type,
1739 lineNum );
1740 painCave.isFatal = 1;
1741 simError();
1742 }
1743
1744 return 1;
1745 }
1746 else return 0;
1747 }
1748
1749 int DUFF_NS::parseTorsion( char *lineBuffer, int lineNum, torsionStruct &info ){
1750
1751 char* the_token;
1752
1753 the_token = strtok( lineBuffer, " \n\t,;" );
1754 if( the_token != NULL ){
1755
1756 strcpy( info.nameA, the_token );
1757
1758 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1759 sprintf( painCave.errMsg,
1760 "Error parseing TorsionTypes: line %d\n", lineNum );
1761 painCave.isFatal = 1;
1762 simError();
1763 }
1764
1765 strcpy( info.nameB, the_token );
1766
1767 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1768 sprintf( painCave.errMsg,
1769 "Error parseing TorsionTypes: line %d\n", lineNum );
1770 painCave.isFatal = 1;
1771 simError();
1772 }
1773
1774 strcpy( info.nameC, the_token );
1775
1776 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1777 sprintf( painCave.errMsg,
1778 "Error parseing TorsionTypes: line %d\n", lineNum );
1779 painCave.isFatal = 1;
1780 simError();
1781 }
1782
1783 strcpy( info.nameD, the_token );
1784
1785 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1786 sprintf( painCave.errMsg,
1787 "Error parseing TorsionTypes: line %d\n", lineNum );
1788 painCave.isFatal = 1;
1789 simError();
1790 }
1791
1792 strcpy( info.type, the_token );
1793
1794 if( !strcmp( info.type, "cubic" ) ){
1795 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1796 sprintf( painCave.errMsg,
1797 "Error parseing TorsionTypes: line %d\n", lineNum );
1798 painCave.isFatal = 1;
1799 simError();
1800 }
1801
1802 info.k1 = atof( the_token );
1803
1804 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1805 sprintf( painCave.errMsg,
1806 "Error parseing TorsionTypes: line %d\n", lineNum );
1807 painCave.isFatal = 1;
1808 simError();
1809 }
1810
1811 info.k2 = atof( the_token );
1812
1813 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1814 sprintf( painCave.errMsg,
1815 "Error parseing TorsionTypes: line %d\n", lineNum );
1816 painCave.isFatal = 1;
1817 simError();
1818 }
1819
1820 info.k3 = atof( the_token );
1821
1822 if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1823 sprintf( painCave.errMsg,
1824 "Error parseing TorsionTypes: line %d\n", lineNum );
1825 painCave.isFatal = 1;
1826 simError();
1827 }
1828
1829 info.k4 = atof( the_token );
1830
1831 }
1832
1833 else{
1834 sprintf( painCave.errMsg,
1835 "Unknown DUFF torsion type \"%s\" at line %d\n",
1836 info.type,
1837 lineNum );
1838 painCave.isFatal = 1;
1839 simError();
1840 }
1841
1842 return 1;
1843 }
1844
1845 else return 0;
1846 }