ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/DUFF.cpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/DUFF.cpp (file contents):
Revision 559 by mmeineke, Thu Jun 19 22:02:44 2003 UTC vs.
Revision 721 by mmeineke, Tue Aug 26 18:32:03 2003 UTC

# Line 15 | Line 15 | namespace TPE {  // restrict the access of the folowin
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 | using namespace TPE;
440  
441   } // namespace
442  
443 < using namespace TPE;
443 > using namespace DUFF_NS;
444  
445  
446   //****************************************************************
# Line 418 | Line 448 | TraPPE_ExFF::TraPPE_ExFF(){
448   //****************************************************************
449  
450  
451 < TraPPE_ExFF::TraPPE_ExFF(){
451 > DUFF::DUFF(){
452  
453    char fileName[200];
454    char* ffPath_env = "FORCE_PARAM_PATH";
# Line 446 | Line 476 | TraPPE_ExFF::TraPPE_ExFF(){
476    // Init the atomStruct mpi type
477  
478    atomStruct atomProto; // mpiPrototype
479 <  int atomBC[3] = {15,6,4};  // block counts
479 >  int atomBC[3] = {15,11,4};  // block counts
480    MPI_Aint atomDspls[3];           // displacements
481    MPI_Datatype atomMbrTypes[3];    // member mpi types
482  
# 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 | void TraPPE_ExFF::cleanMe( void ){
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::initForceField( int ljMixRule ){
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::initializeAtoms( int nAtoms, Atom**
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::initializeBonds( int nBonds, Bond**
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 1259 | Line 1310 | void TraPPE_ExFF::initializeBends( int nBends, Bend**
1310          }
1311          
1312          gBend = new GhostBend( *the_atoms[a],
1313 <                               *the_atoms[b] );                        
1313 >                               *the_atoms[b]);
1314 >                                                                      
1315          gBend->setConstants( currentBendType->k1,
1316                               currentBendType->k2,
1317                               currentBendType->k3,
# Line 1275 | Line 1327 | void TraPPE_ExFF::initializeBends( int nBends, Bend**
1327                               currentBendType->k3,
1328                               currentBendType->t0 );
1329          bendArray[i] = qBend;
1330 <      }
1330 >      }      
1331      }
1332    }
1333   }
1334  
1335 < void TraPPE_ExFF::initializeTorsions( int nTorsions, Torsion** torsionArray,
1335 > void DUFF::initializeTorsions( int nTorsions, Torsion** torsionArray,
1336                                        torsion_set* the_torsions ){
1337  
1338    int i, a, b, c, d;
# Line 1327 | Line 1379 | void TraPPE_ExFF::fastForward( char* stopText, char* s
1379    }
1380   }
1381  
1382 < void TraPPE_ExFF::fastForward( char* stopText, char* searchOwner ){
1382 > void DUFF::fastForward( char* stopText, char* searchOwner ){
1383  
1384    int foundText = 0;
1385    char* the_token;
# Line 1382 | Line 1434 | int TPE::parseAtom( char *lineBuffer, int lineNum, ato
1434   }
1435  
1436  
1437 < int TPE::parseAtom( char *lineBuffer, int lineNum, atomStruct &info ){
1437 > int DUFF_NS::parseAtom( char *lineBuffer, int lineNum, atomStruct &info ){
1438  
1439    char* the_token;
1440    
# Line 1468 | Line 1520 | int TPE::parseAtom( char *lineBuffer, int lineNum, ato
1520        }
1521        
1522        info.v0 = atof( the_token );
1523 +      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1524 +        sprintf( painCave.errMsg,
1525 +                 "Error parseing AtomTypes: line %d\n", lineNum );
1526 +        painCave.isFatal = 1;
1527 +        simError();
1528 +      }
1529 +      
1530 +      info.v0p = atof( the_token );
1531 +
1532 +      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1533 +        sprintf( painCave.errMsg,
1534 +                 "Error parseing AtomTypes: line %d\n", lineNum );
1535 +        painCave.isFatal = 1;
1536 +        simError();
1537 +      }
1538 +      
1539 +      info.rl = atof( the_token );
1540 +
1541 +      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1542 +        sprintf( painCave.errMsg,
1543 +                 "Error parseing AtomTypes: line %d\n", lineNum );
1544 +        painCave.isFatal = 1;
1545 +        simError();
1546 +      }
1547 +      
1548 +      info.ru = atof( the_token );
1549 +
1550 +      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1551 +        sprintf( painCave.errMsg,
1552 +                 "Error parseing AtomTypes: line %d\n", lineNum );
1553 +        painCave.isFatal = 1;
1554 +        simError();
1555 +      }
1556 +      
1557 +      info.rlp = atof( the_token );
1558 +
1559 +      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1560 +        sprintf( painCave.errMsg,
1561 +                 "Error parseing AtomTypes: line %d\n", lineNum );
1562 +        painCave.isFatal = 1;
1563 +        simError();
1564 +      }
1565 +      
1566 +      info.rup = atof( the_token );
1567      }
1568 <    else info.v0 = info.w0 = 0.0;
1568 >    else info.v0 = info.w0 = info.v0p = info.rl = info.ru = info.rlp = info.rup = 0.0;
1569  
1570      return 1;
1571    }
1572    else return 0;
1573   }
1574  
1575 < int TPE::parseBond( char *lineBuffer, int lineNum, bondStruct &info ){
1575 > int DUFF_NS::parseBond( char *lineBuffer, int lineNum, bondStruct &info ){
1576  
1577    char* the_token;
1578 +  char bondType[30];
1579    
1580    the_token = strtok( lineBuffer, " \n\t,;" );
1581    if( the_token != NULL ){
# Line 1501 | Line 1598 | int TPE::parseBond( char *lineBuffer, int lineNum, bon
1598        simError();
1599      }
1600      
1601 <    strcpy( info.type, the_token );
1601 >    strcpy( bondType, the_token );
1602      
1603 <    if( !strcmp( info.type, "fixed" ) ){
1603 >    if( !strcmp( bondType, "fixed" ) ){
1604 >      info.type = FIXED_BOND;
1605 >      
1606 >      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1607 >        sprintf( painCave.errMsg,
1608 >                 "Error parseing BondTypes: line %d\n", lineNum );
1609 >        painCave.isFatal = 1;
1610 >        simError();
1611 >      }
1612 >      
1613 >      info.d0 = atof( the_token );
1614 >      
1615 >      info.k0=0.0;
1616 >    }
1617 >    else if( !strcmp( bondType, "harmonic" ) ){
1618 >      info.type = HARMONIC_BOND;
1619 >      
1620        if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1621          sprintf( painCave.errMsg,
1622                   "Error parseing BondTypes: line %d\n", lineNum );
# Line 1512 | Line 1625 | int TPE::parseBond( char *lineBuffer, int lineNum, bon
1625        }
1626        
1627        info.d0 = atof( the_token );
1628 +
1629 +      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1630 +        sprintf( painCave.errMsg,
1631 +                 "Error parseing BondTypes: line %d\n", lineNum );
1632 +        painCave.isFatal = 1;
1633 +        simError();
1634 +      }
1635 +      
1636 +      info.k0 = atof( the_token );
1637      }
1638 +
1639      else{
1640        sprintf( painCave.errMsg,
1641 <               "Unknown TraPPE_Ex bond type \"%s\" at line %d\n",
1641 >               "Unknown DUFF bond type \"%s\" at line %d\n",
1642                 info.type,
1643                 lineNum );
1644        painCave.isFatal = 1;
# Line 1528 | Line 1651 | int TPE::parseBend( char *lineBuffer, int lineNum, ben
1651   }
1652  
1653  
1654 < int TPE::parseBend( char *lineBuffer, int lineNum, bendStruct &info ){
1654 > int DUFF_NS::parseBend( char *lineBuffer, int lineNum, bendStruct &info ){
1655  
1656    char* the_token;
1657    
# Line 1604 | Line 1727 | int TPE::parseBend( char *lineBuffer, int lineNum, ben
1727      
1728      else{
1729        sprintf( painCave.errMsg,
1730 <               "Unknown TraPPE_Ex bend type \"%s\" at line %d\n",
1730 >               "Unknown DUFF bend type \"%s\" at line %d\n",
1731                 info.type,
1732                 lineNum );
1733        painCave.isFatal = 1;
# Line 1616 | Line 1739 | int TPE::parseTorsion( char *lineBuffer, int lineNum,
1739    else return 0;
1740   }
1741  
1742 < int TPE::parseTorsion( char *lineBuffer, int lineNum, torsionStruct &info ){
1742 > int DUFF_NS::parseTorsion( char *lineBuffer, int lineNum, torsionStruct &info ){
1743    
1744    char*  the_token;
1745  
# Line 1702 | Line 1825 | int TPE::parseTorsion( char *lineBuffer, int lineNum,
1825      
1826      else{
1827        sprintf( painCave.errMsg,
1828 <               "Unknown TraPPE_Ex torsion type \"%s\" at line %d\n",
1828 >               "Unknown DUFF torsion type \"%s\" at line %d\n",
1829                 info.type,
1830                 lineNum );
1831        painCave.isFatal = 1;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines