# | Line 15 | Line 15 | using namespace std; | |
---|---|---|
15 | #include "mpiForceField.h" | |
16 | #endif // is_mpi | |
17 | ||
18 | – | namespace TPE { // restrict the access of the folowing to this file only. |
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{ | |
# | Line 28 | Line 35 | namespace TPE { // restrict the access of the folowin | |
35 | double dipole; | |
36 | double w0; | |
37 | double v0; | |
38 | + | double v0p; |
39 | + | double rl; |
40 | + | double ru; |
41 | + | double rlp; |
42 | + | double rup; |
43 | int isSSD; | |
44 | int isDipole; | |
45 | int ident; | |
# | Line 39 | Line 51 | namespace TPE { // restrict the access of the folowin | |
51 | typedef struct{ | |
52 | char nameA[15]; | |
53 | char nameB[15]; | |
42 | – | char type[30]; |
54 | double d0; | |
55 | + | double k0; |
56 | int last; // 0 -> default | |
57 | // 1 -> tells nodes to stop listening | |
58 | + | int type; |
59 | } bondStruct; | |
60 | ||
61 | ||
# | Line 111 | Line 124 | namespace TPE { // restrict the access of the folowin | |
124 | ||
125 | if( !strcmp( info.name, name ) ){ | |
126 | sprintf( painCave.errMsg, | |
127 | < | "Duplicate TraPPE_Ex atom type \"%s\" found in " |
128 | < | "the TraPPE_ExFF param file./n", |
127 | > | "Duplicate DUFF atom type \"%s\" found in " |
128 | > | "the DUFF param file./n", |
129 | name ); | |
130 | painCave.isFatal = 1; | |
131 | simError(); | |
# | Line 130 | Line 143 | namespace TPE { // restrict the access of the folowin | |
143 | next->dipole = info.dipole; | |
144 | next->w0 = info.w0; | |
145 | next->v0 = info.v0; | |
146 | + | next->v0p = info.v0p; |
147 | + | next->rl = info.rl; |
148 | + | next->ru = info.ru; |
149 | + | next->rlp = info.rlp; |
150 | + | next->rup = info.rup; |
151 | next->ident = info.ident; | |
152 | } | |
153 | } | |
# | Line 146 | Line 164 | namespace TPE { // restrict the access of the folowin | |
164 | info.dipole = dipole; | |
165 | info.w0 = w0; | |
166 | info.v0 = v0; | |
167 | + | info.v0p = v0p; |
168 | + | info.rl = rl; |
169 | + | info.ru = ru; |
170 | + | info.rlp = rlp; |
171 | + | info.rup = rup; |
172 | info.ident = ident; | |
173 | info.last = 0; | |
174 | } | |
# | Line 162 | Line 185 | namespace TPE { // restrict the access of the folowin | |
185 | double dipole; | |
186 | double w0; | |
187 | double v0; | |
188 | + | double v0p; |
189 | + | double rl; |
190 | + | double ru; |
191 | + | double rlp; |
192 | + | double rup; |
193 | int ident; | |
194 | LinkedAtomType* next; | |
195 | }; | |
# | Line 172 | Line 200 | namespace TPE { // restrict the access of the folowin | |
200 | next = NULL; | |
201 | nameA[0] = '\0'; | |
202 | nameB[0] = '\0'; | |
175 | – | type[0] = '\0'; |
203 | } | |
204 | ~LinkedBondType(){ if( next != NULL ) delete next; } | |
205 | ||
# | Line 194 | Line 221 | namespace TPE { // restrict the access of the folowin | |
221 | ||
222 | if(dup){ | |
223 | sprintf( painCave.errMsg, | |
224 | < | "Duplicate TraPPE_Ex bond type \"%s - %s\" found in " |
225 | < | "the TraPPE_ExFF param file./n", |
224 | > | "Duplicate DUFF bond type \"%s - %s\" found in " |
225 | > | "the DUFF param file./n", |
226 | nameA, nameB ); | |
227 | painCave.isFatal = 1; | |
228 | simError(); | |
# | Line 207 | Line 234 | namespace TPE { // restrict the access of the folowin | |
234 | next = new LinkedBondType(); | |
235 | strcpy(next->nameA, info.nameA); | |
236 | strcpy(next->nameB, info.nameB); | |
237 | < | strcpy(next->type, info.type); |
237 | > | next->type = info.type; |
238 | next->d0 = info.d0; | |
239 | + | next->k0 = info.k0; |
240 | } | |
241 | } | |
242 | ||
# | Line 216 | Line 244 | namespace TPE { // restrict the access of the folowin | |
244 | void duplicate( bondStruct &info ){ | |
245 | strcpy(info.nameA, nameA); | |
246 | strcpy(info.nameB, nameB); | |
247 | < | strcpy(info.type, type); |
247 | > | info.type = type; |
248 | info.d0 = d0; | |
249 | + | info.k0 = k0; |
250 | info.last = 0; | |
251 | } | |
252 | ||
# | Line 226 | Line 255 | namespace TPE { // restrict the access of the folowin | |
255 | ||
256 | char nameA[15]; | |
257 | char nameB[15]; | |
258 | < | char type[30]; |
258 | > | int type; |
259 | double d0; | |
260 | + | double k0; |
261 | ||
262 | LinkedBondType* next; | |
263 | }; | |
# | Line 264 | Line 294 | namespace TPE { // restrict the access of the folowin | |
294 | ||
295 | if(dup){ | |
296 | sprintf( painCave.errMsg, | |
297 | < | "Duplicate TraPPE_Ex bend type \"%s - %s - %s\" found in " |
298 | < | "the TraPPE_ExFF param file./n", |
297 | > | "Duplicate DUFF bend type \"%s - %s - %s\" found in " |
298 | > | "the DUFF param file./n", |
299 | nameA, nameB, nameC ); | |
300 | painCave.isFatal = 1; | |
301 | simError(); | |
# | Line 349 | Line 379 | namespace TPE { // restrict the access of the folowin | |
379 | ||
380 | if(dup){ | |
381 | sprintf( painCave.errMsg, | |
382 | < | "Duplicate TraPPE_Ex torsion type \"%s - %s - %s - %s\" found in " |
383 | < | "the TraPPE_ExFF param file./n", nameA, nameB, nameC, nameD ); |
382 | > | "Duplicate DUFF torsion type \"%s - %s - %s - %s\" found in " |
383 | > | "the DUFF param file./n", nameA, nameB, nameC, nameD ); |
384 | painCave.isFatal = 1; | |
385 | simError(); | |
386 | } | |
# | Line 410 | Line 440 | namespace TPE { // restrict the access of the folowin | |
440 | ||
441 | } // namespace | |
442 | ||
443 | < | using namespace TPE; |
443 | > | using namespace DUFF_NS; |
444 | ||
445 | ||
446 | //**************************************************************** | |
# | Line 418 | Line 448 | using namespace TPE; | |
448 | //**************************************************************** | |
449 | ||
450 | ||
451 | < | TraPPE_ExFF::TraPPE_ExFF(){ |
451 | > | DUFF::DUFF(){ |
452 | ||
453 | char fileName[200]; | |
454 | char* ffPath_env = "FORCE_PARAM_PATH"; | |
# | Line 468 | Line 498 | TraPPE_ExFF::TraPPE_ExFF(){ | |
498 | // Init the bondStruct mpi type | |
499 | ||
500 | bondStruct bondProto; // mpiPrototype | |
501 | < | int bondBC[3] = {60,1,1}; // block counts |
501 | > | int bondBC[3] = {30,2,2}; // block counts |
502 | MPI_Aint bondDspls[3]; // displacements | |
503 | MPI_Datatype bondMbrTypes[3]; // member mpi types | |
504 | ||
# | Line 537 | Line 567 | TraPPE_ExFF::TraPPE_ExFF(){ | |
567 | ||
568 | // generate the force file name | |
569 | ||
570 | < | strcpy( fileName, "TraPPE_Ex.frc" ); |
570 | > | strcpy( fileName, "DUFF.frc" ); |
571 | // fprintf( stderr,"Trying to open %s\n", fileName ); | |
572 | ||
573 | // attempt to open the file in the current directory first. | |
# | Line 576 | Line 606 | TraPPE_ExFF::TraPPE_ExFF(){ | |
606 | #ifdef IS_MPI | |
607 | } | |
608 | ||
609 | < | sprintf( checkPointMsg, "TraPPE_ExFF file opened sucessfully." ); |
609 | > | sprintf( checkPointMsg, "DUFF file opened sucessfully." ); |
610 | MPIcheckPoint(); | |
611 | ||
612 | #endif // is_mpi | |
613 | } | |
614 | ||
615 | ||
616 | < | TraPPE_ExFF::~TraPPE_ExFF(){ |
616 | > | DUFF::~DUFF(){ |
617 | ||
618 | if( headAtomType != NULL ) delete headAtomType; | |
619 | if( headBondType != NULL ) delete headBondType; | |
# | Line 601 | Line 631 | TraPPE_ExFF::~TraPPE_ExFF(){ | |
631 | #endif // is_mpi | |
632 | } | |
633 | ||
634 | < | void TraPPE_ExFF::cleanMe( void ){ |
634 | > | void DUFF::cleanMe( void ){ |
635 | ||
636 | #ifdef IS_MPI | |
637 | ||
# | Line 620 | Line 650 | void TraPPE_ExFF::cleanMe( void ){ | |
650 | } | |
651 | ||
652 | ||
653 | < | void TraPPE_ExFF::initForceField( int ljMixRule ){ |
653 | > | void DUFF::initForceField( int ljMixRule ){ |
654 | ||
655 | initFortran( ljMixRule, entry_plug->useReactionField ); | |
656 | } | |
657 | ||
658 | ||
659 | < | void TraPPE_ExFF::readParams( void ){ |
659 | > | void DUFF::readParams( void ){ |
660 | ||
661 | int i, a, b, c, d; | |
662 | int identNum; | |
# | Line 698 | Line 728 | void TraPPE_ExFF::readParams( void ){ | |
728 | // send out the linked list to all the other processes | |
729 | ||
730 | sprintf( checkPointMsg, | |
731 | < | "TraPPE_ExFF atom structures read successfully." ); |
731 | > | "DUFF atom structures read successfully." ); |
732 | MPIcheckPoint(); | |
733 | ||
734 | currentAtomType = headAtomType->next; //skip the first element who is a place holder. | |
# | Line 710 | Line 740 | void TraPPE_ExFF::readParams( void ){ | |
740 | sendFrcStruct( &atomInfo, mpiAtomStructType ); | |
741 | ||
742 | sprintf( checkPointMsg, | |
743 | < | "successfully sent TraPPE_Ex force type: \"%s\"\n", |
743 | > | "successfully sent DUFF force type: \"%s\"\n", |
744 | atomInfo.name ); | |
745 | MPIcheckPoint(); | |
746 | ||
# | Line 754 | Line 784 | void TraPPE_ExFF::readParams( void ){ | |
784 | ||
785 | int isGB = 0; | |
786 | int isLJ = 1; | |
787 | + | int isEAM =0; |
788 | double GB_dummy = 0.0; | |
789 | ||
790 | ||
# | Line 763 | Line 794 | void TraPPE_ExFF::readParams( void ){ | |
794 | if(currentAtomType->isDipole) entry_plug->useDipole = 1; | |
795 | if(currentAtomType->isSSD) { | |
796 | entry_plug->useSticky = 1; | |
797 | < | set_sticky_params( &(currentAtomType->w0), &(currentAtomType->v0)); |
797 | > | set_sticky_params( &(currentAtomType->w0), &(currentAtomType->v0), |
798 | > | &(currentAtomType->v0p), |
799 | > | &(currentAtomType->rl), &(currentAtomType->ru), |
800 | > | &(currentAtomType->rlp), &(currentAtomType->rup)); |
801 | } | |
802 | ||
803 | if( currentAtomType->name[0] != '\0' ){ | |
# | Line 773 | Line 807 | void TraPPE_ExFF::readParams( void ){ | |
807 | &(currentAtomType->isSSD), | |
808 | &(currentAtomType->isDipole), | |
809 | &isGB, | |
810 | + | &isEAM, |
811 | &(currentAtomType->epslon), | |
812 | &(currentAtomType->sigma), | |
813 | &(currentAtomType->dipole), | |
# | Line 790 | Line 825 | void TraPPE_ExFF::readParams( void ){ | |
825 | ||
826 | #ifdef IS_MPI | |
827 | sprintf( checkPointMsg, | |
828 | < | "TraPPE_ExFF atom structures successfully sent to fortran\n" ); |
828 | > | "DUFF atom structures successfully sent to fortran\n" ); |
829 | MPIcheckPoint(); | |
830 | #endif // is_mpi | |
831 | ||
# | Line 844 | Line 879 | void TraPPE_ExFF::readParams( void ){ | |
879 | // send out the linked list to all the other processes | |
880 | ||
881 | sprintf( checkPointMsg, | |
882 | < | "TraPPE_Ex bond structures read successfully." ); |
882 | > | "DUFF bond structures read successfully." ); |
883 | MPIcheckPoint(); | |
884 | ||
885 | currentBondType = headBondType->next; | |
# | Line 874 | Line 909 | void TraPPE_ExFF::readParams( void ){ | |
909 | } | |
910 | ||
911 | sprintf( checkPointMsg, | |
912 | < | "TraPPE_ExFF bond structures broadcast successfully." ); |
912 | > | "DUFF bond structures broadcast successfully." ); |
913 | MPIcheckPoint(); | |
914 | ||
915 | #endif // is_mpi | |
# | Line 927 | Line 962 | void TraPPE_ExFF::readParams( void ){ | |
962 | // send out the linked list to all the other processes | |
963 | ||
964 | sprintf( checkPointMsg, | |
965 | < | "TraPPE_Ex bend structures read successfully." ); |
965 | > | "DUFF bend structures read successfully." ); |
966 | MPIcheckPoint(); | |
967 | ||
968 | currentBendType = headBendType->next; | |
# | Line 957 | Line 992 | void TraPPE_ExFF::readParams( void ){ | |
992 | } | |
993 | ||
994 | sprintf( checkPointMsg, | |
995 | < | "TraPPE_ExFF bend structures broadcast successfully." ); |
995 | > | "DUFF bend structures broadcast successfully." ); |
996 | MPIcheckPoint(); | |
997 | ||
998 | #endif // is_mpi | |
# | Line 1012 | Line 1047 | void TraPPE_ExFF::readParams( void ){ | |
1047 | // send out the linked list to all the other processes | |
1048 | ||
1049 | sprintf( checkPointMsg, | |
1050 | < | "TraPPE_Ex torsion structures read successfully." ); |
1050 | > | "DUFF torsion structures read successfully." ); |
1051 | MPIcheckPoint(); | |
1052 | ||
1053 | currentTorsionType = headTorsionType->next; | |
# | Line 1042 | Line 1077 | void TraPPE_ExFF::readParams( void ){ | |
1077 | } | |
1078 | ||
1079 | sprintf( checkPointMsg, | |
1080 | < | "TraPPE_ExFF torsion structures broadcast successfully." ); |
1080 | > | "DUFF torsion structures broadcast successfully." ); |
1081 | MPIcheckPoint(); | |
1082 | ||
1083 | #endif // is_mpi | |
# | Line 1052 | Line 1087 | void TraPPE_ExFF::readParams( void ){ | |
1087 | ||
1088 | ||
1089 | ||
1090 | < | void TraPPE_ExFF::initializeAtoms( int nAtoms, Atom** the_atoms ){ |
1090 | > | void DUFF::initializeAtoms( int nAtoms, Atom** the_atoms ){ |
1091 | ||
1092 | ||
1093 | ////////////////////////////////////////////////// | |
# | Line 1141 | Line 1176 | void TraPPE_ExFF::initializeAtoms( int nAtoms, Atom** | |
1176 | else{ | |
1177 | ||
1178 | sprintf( painCave.errMsg, | |
1179 | < | "TraPPE_ExFF error: Atom \"%s\" is a dipole, yet no standard" |
1179 | > | "DUFF error: Atom \"%s\" is a dipole, yet no standard" |
1180 | " orientation was specifed in the BASS file.\n", | |
1181 | currentAtomType->name ); | |
1182 | painCave.isFatal = 1; | |
# | Line 1151 | Line 1186 | void TraPPE_ExFF::initializeAtoms( int nAtoms, Atom** | |
1186 | else{ | |
1187 | if( the_atoms[i]->isDirectional() ){ | |
1188 | sprintf( painCave.errMsg, | |
1189 | < | "TraPPE_ExFF error: Atom \"%s\" was given a standard" |
1189 | > | "DUFF error: Atom \"%s\" was given a standard" |
1190 | "orientation in the BASS file, yet it is not a dipole.\n", | |
1191 | currentAtomType->name); | |
1192 | painCave.isFatal = 1; | |
# | Line 1161 | Line 1196 | void TraPPE_ExFF::initializeAtoms( int nAtoms, Atom** | |
1196 | } | |
1197 | } | |
1198 | ||
1199 | < | void TraPPE_ExFF::initializeBonds( int nBonds, Bond** bondArray, |
1199 | > | void DUFF::initializeBonds( int nBonds, Bond** bondArray, |
1200 | bond_pair* the_bonds ){ | |
1201 | int i,a,b; | |
1202 | char* atomA; | |
# | Line 1189 | Line 1224 | void TraPPE_ExFF::initializeBonds( int nBonds, Bond** | |
1224 | simError(); | |
1225 | } | |
1226 | ||
1227 | < | if( !strcmp( currentBondType->type, "fixed" ) ){ |
1228 | < | |
1227 | > | switch( currentBondType->type ){ |
1228 | > | |
1229 | > | case FIXED_BOND: |
1230 | > | |
1231 | bondArray[i] = new ConstrainedBond( *the_atoms[a], | |
1232 | *the_atoms[b], | |
1233 | currentBondType->d0 ); | |
1234 | entry_plug->n_constraints++; | |
1235 | + | break; |
1236 | + | |
1237 | + | case HARMONIC_BOND: |
1238 | + | |
1239 | + | bondArray[i] = new HarmonicBond( *the_atoms[a], |
1240 | + | *the_atoms[b], |
1241 | + | currentBondType->d0, |
1242 | + | currentBondType->k0 ); |
1243 | + | break; |
1244 | + | |
1245 | + | default: |
1246 | + | |
1247 | + | break; |
1248 | + | // do nothing |
1249 | } | |
1250 | } | |
1251 | } | |
1252 | ||
1253 | < | void TraPPE_ExFF::initializeBends( int nBends, Bend** bendArray, |
1253 | > | void DUFF::initializeBends( int nBends, Bend** bendArray, |
1254 | bend_set* the_bends ){ | |
1255 | ||
1256 | QuadraticBend* qBend; | |
# | Line 1280 | Line 1331 | void TraPPE_ExFF::initializeBends( int nBends, Bend** | |
1331 | } | |
1332 | } | |
1333 | ||
1334 | < | void TraPPE_ExFF::initializeTorsions( int nTorsions, Torsion** torsionArray, |
1334 | > | void DUFF::initializeTorsions( int nTorsions, Torsion** torsionArray, |
1335 | torsion_set* the_torsions ){ | |
1336 | ||
1337 | int i, a, b, c, d; | |
# | Line 1327 | Line 1378 | void TraPPE_ExFF::initializeTorsions( int nTorsions, T | |
1378 | } | |
1379 | } | |
1380 | ||
1381 | < | void TraPPE_ExFF::fastForward( char* stopText, char* searchOwner ){ |
1381 | > | void DUFF::fastForward( char* stopText, char* searchOwner ){ |
1382 | ||
1383 | int foundText = 0; | |
1384 | char* the_token; | |
# | Line 1382 | Line 1433 | void TraPPE_ExFF::fastForward( char* stopText, char* s | |
1433 | } | |
1434 | ||
1435 | ||
1436 | < | int TPE::parseAtom( char *lineBuffer, int lineNum, atomStruct &info ){ |
1436 | > | int DUFF_NS::parseAtom( char *lineBuffer, int lineNum, atomStruct &info ){ |
1437 | ||
1438 | char* the_token; | |
1439 | ||
# | Line 1468 | Line 1519 | int TPE::parseAtom( char *lineBuffer, int lineNum, ato | |
1519 | } | |
1520 | ||
1521 | info.v0 = atof( the_token ); | |
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.v0p = atof( the_token ); |
1530 | + | |
1531 | + | if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1532 | + | sprintf( painCave.errMsg, |
1533 | + | "Error parseing AtomTypes: line %d\n", lineNum ); |
1534 | + | painCave.isFatal = 1; |
1535 | + | simError(); |
1536 | + | } |
1537 | + | |
1538 | + | info.rl = atof( the_token ); |
1539 | + | |
1540 | + | if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1541 | + | sprintf( painCave.errMsg, |
1542 | + | "Error parseing AtomTypes: line %d\n", lineNum ); |
1543 | + | painCave.isFatal = 1; |
1544 | + | simError(); |
1545 | + | } |
1546 | + | |
1547 | + | info.ru = atof( the_token ); |
1548 | + | |
1549 | + | if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1550 | + | sprintf( painCave.errMsg, |
1551 | + | "Error parseing AtomTypes: line %d\n", lineNum ); |
1552 | + | painCave.isFatal = 1; |
1553 | + | simError(); |
1554 | + | } |
1555 | + | |
1556 | + | info.rlp = atof( the_token ); |
1557 | + | |
1558 | + | if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1559 | + | sprintf( painCave.errMsg, |
1560 | + | "Error parseing AtomTypes: line %d\n", lineNum ); |
1561 | + | painCave.isFatal = 1; |
1562 | + | simError(); |
1563 | + | } |
1564 | + | |
1565 | + | info.rup = atof( the_token ); |
1566 | } | |
1567 | < | else info.v0 = info.w0 = 0.0; |
1567 | > | else info.v0 = info.w0 = info.v0p = info.rl = info.ru = info.rlp = info.rup = 0.0; |
1568 | ||
1569 | return 1; | |
1570 | } | |
1571 | else return 0; | |
1572 | } | |
1573 | ||
1574 | < | int TPE::parseBond( char *lineBuffer, int lineNum, bondStruct &info ){ |
1574 | > | int DUFF_NS::parseBond( char *lineBuffer, int lineNum, bondStruct &info ){ |
1575 | ||
1576 | char* the_token; | |
1577 | + | char bondType[30]; |
1578 | ||
1579 | the_token = strtok( lineBuffer, " \n\t,;" ); | |
1580 | if( the_token != NULL ){ | |
# | Line 1501 | Line 1597 | int TPE::parseBond( char *lineBuffer, int lineNum, bon | |
1597 | simError(); | |
1598 | } | |
1599 | ||
1600 | < | strcpy( info.type, the_token ); |
1600 | > | strcpy( bondType, the_token ); |
1601 | ||
1602 | < | if( !strcmp( info.type, "fixed" ) ){ |
1602 | > | if( !strcmp( bondType, "fixed" ) ){ |
1603 | > | info.type = FIXED_BOND; |
1604 | > | |
1605 | > | if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1606 | > | sprintf( painCave.errMsg, |
1607 | > | "Error parseing BondTypes: line %d\n", lineNum ); |
1608 | > | painCave.isFatal = 1; |
1609 | > | simError(); |
1610 | > | } |
1611 | > | |
1612 | > | info.d0 = atof( the_token ); |
1613 | > | |
1614 | > | info.k0=0.0; |
1615 | > | } |
1616 | > | else if( !strcmp( bondType, "harmonic" ) ){ |
1617 | > | info.type = HARMONIC_BOND; |
1618 | > | |
1619 | if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ | |
1620 | sprintf( painCave.errMsg, | |
1621 | "Error parseing BondTypes: line %d\n", lineNum ); | |
# | Line 1512 | Line 1624 | int TPE::parseBond( char *lineBuffer, int lineNum, bon | |
1624 | } | |
1625 | ||
1626 | info.d0 = atof( the_token ); | |
1627 | + | |
1628 | + | if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1629 | + | sprintf( painCave.errMsg, |
1630 | + | "Error parseing BondTypes: line %d\n", lineNum ); |
1631 | + | painCave.isFatal = 1; |
1632 | + | simError(); |
1633 | + | } |
1634 | + | |
1635 | + | info.k0 = atof( the_token ); |
1636 | } | |
1637 | + | |
1638 | else{ | |
1639 | sprintf( painCave.errMsg, | |
1640 | < | "Unknown TraPPE_Ex bond type \"%s\" at line %d\n", |
1640 | > | "Unknown DUFF bond type \"%s\" at line %d\n", |
1641 | info.type, | |
1642 | lineNum ); | |
1643 | painCave.isFatal = 1; | |
# | Line 1528 | Line 1650 | int TPE::parseBond( char *lineBuffer, int lineNum, bon | |
1650 | } | |
1651 | ||
1652 | ||
1653 | < | int TPE::parseBend( char *lineBuffer, int lineNum, bendStruct &info ){ |
1653 | > | int DUFF_NS::parseBend( char *lineBuffer, int lineNum, bendStruct &info ){ |
1654 | ||
1655 | char* the_token; | |
1656 | ||
# | Line 1604 | Line 1726 | int TPE::parseBend( char *lineBuffer, int lineNum, ben | |
1726 | ||
1727 | else{ | |
1728 | sprintf( painCave.errMsg, | |
1729 | < | "Unknown TraPPE_Ex bend type \"%s\" at line %d\n", |
1729 | > | "Unknown DUFF bend type \"%s\" at line %d\n", |
1730 | info.type, | |
1731 | lineNum ); | |
1732 | painCave.isFatal = 1; | |
# | Line 1616 | Line 1738 | int TPE::parseBend( char *lineBuffer, int lineNum, ben | |
1738 | else return 0; | |
1739 | } | |
1740 | ||
1741 | < | int TPE::parseTorsion( char *lineBuffer, int lineNum, torsionStruct &info ){ |
1741 | > | int DUFF_NS::parseTorsion( char *lineBuffer, int lineNum, torsionStruct &info ){ |
1742 | ||
1743 | char* the_token; | |
1744 | ||
# | Line 1702 | Line 1824 | int TPE::parseTorsion( char *lineBuffer, int lineNum, | |
1824 | ||
1825 | else{ | |
1826 | sprintf( painCave.errMsg, | |
1827 | < | "Unknown TraPPE_Ex torsion type \"%s\" at line %d\n", |
1827 | > | "Unknown DUFF torsion type \"%s\" at line %d\n", |
1828 | info.type, | |
1829 | lineNum ); | |
1830 | painCave.isFatal = 1; |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |