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

Comparing trunk/OOPSE/libmdtools/TraPPE_ExFF.cpp (file contents):
Revision 420 by mmeineke, Thu Mar 27 17:32:03 2003 UTC vs.
Revision 941 by gezelter, Tue Jan 13 23:01:43 2004 UTC

# Line 1 | Line 1
1 < #include <cstdlib>
2 < #include <cstdio>
3 < #include <cstring>
1 > #include <stdlib.h>
2 > #include <stdio.h>
3 > #include <string.h>
4  
5   #include <iostream>
6   using namespace std;
# Line 12 | Line 12 | using namespace std;
12   #include "fortranWrappers.hpp"
13  
14   #ifdef IS_MPI
15 – #include <mpi++.h>
15   #include "mpiForceField.h"
16   #endif // is_mpi
17  
# Line 99 | Line 98 | namespace TPE {  // restrict the access of the folowin
98        return NULL;
99      }
100      
101 +    void printMe( void ){
102 +      
103 +      std::cerr << "LinkedAtype " << name << ": ident = " << ident << "\n";
104 +      if( next != NULL ) next->printMe();
105 +
106 +    }
107 +
108      void add( atomStruct &info ){
109  
110        // check for duplicates
# Line 114 | Line 120 | namespace TPE {  // restrict the access of the folowin
120  
121        if( next != NULL ) next->add(info);
122        else{
123 <        next = new LinkedType();
123 >        next = new LinkedAtomType();
124          strcpy(next->name, info.name);
125          next->isDipole = info.isDipole;
126          next->isSSD    = info.isSSD;
# Line 140 | Line 146 | namespace TPE {  // restrict the access of the folowin
146        info.dipole   = dipole;
147        info.w0       = w0;
148        info.v0       = v0;
149 +      info.ident    = ident;
150        info.last     = 0;
151      }
152  
# Line 197 | Line 204 | namespace TPE {  // restrict the access of the folowin
204          
205        if( next != NULL ) next->add(info);
206        else{
207 <        next = new LinkedType();
207 >        next = new LinkedBondType();
208          strcpy(next->nameA, info.nameA);
209          strcpy(next->nameB, info.nameB);
210          strcpy(next->type,  info.type);
# Line 266 | Line 273 | namespace TPE {  // restrict the access of the folowin
273  
274        if( next != NULL ) next->add(info);
275        else{
276 <        next = new LinkedType();
276 >        next = new LinkedBendType();
277          strcpy(next->nameA, info.nameA);
278          strcpy(next->nameB, info.nameB);
279          strcpy(next->nameC, info.nameC);
# Line 350 | Line 357 | namespace TPE {  // restrict the access of the folowin
357  
358        if( next != NULL ) next->add(info);
359        else{
360 <        next = new LinkedType();
360 >        next = new LinkedTorsionType();
361          strcpy(next->nameA, info.nameA);
362          strcpy(next->nameB, info.nameB);
363          strcpy(next->nameC, info.nameC);
# Line 621 | Line 628 | void TraPPE_ExFF::readParams( void ){
628  
629   void TraPPE_ExFF::readParams( void ){
630  
631 <  int i;
631 >  int i, a, b, c, d;
632    int identNum;
633 +  char* atomA;
634 +  char* atomB;
635 +  char* atomC;
636 +  char* atomD;
637    
638    atomStruct atomInfo;
639    bondStruct bondInfo;
640    bendStruct bendInfo;
641    torsionStruct torsionInfo;
642    
643 <  
643 >  bigSigma = 0.0;
644 >
645    atomInfo.last = 1;
646    bondInfo.last = 1;
647    bendInfo.last = 1;
# Line 715 | Line 727 | void TraPPE_ExFF::readParams( void ){
727      
728      MPIcheckPoint();
729  
730 <    headAtomType = new LinkedType;
730 >    headAtomType = new LinkedAtomType;
731      recieveFrcStruct( &atomInfo, mpiAtomStructType );
732      
733      while( !atomInfo.last ){
# Line 729 | Line 741 | void TraPPE_ExFF::readParams( void ){
741        recieveFrcStruct( &atomInfo, mpiAtomStructType );
742      }
743    }
744 +
745   #endif // is_mpi
746  
747 +
748 +
749    // call new A_types in fortran
750    
751    int isError;
# Line 739 | Line 754 | void TraPPE_ExFF::readParams( void ){
754    
755    int isGB = 0;
756    int isLJ = 1;
757 +  int isEAM = 0;
758 +  int isCharge = 0;
759    double GB_dummy = 0.0;
760 +  double charge = 0.0;
761    
762    
763 <  currentAtomType = headAtomType;
763 >  currentAtomType = headAtomType->next;;
764    while( currentAtomType != NULL ){
765      
766      if(currentAtomType->isDipole) entry_plug->useDipole = 1;
767 <    if(currentAtomType->isSSD)    entry_plug->useSticky = 1;
767 >    if(currentAtomType->isSSD) {
768 >      entry_plug->useSticky = 1;
769 >      set_sticky_params( &(currentAtomType->w0), &(currentAtomType->v0));
770 >    }
771  
772      if( currentAtomType->name[0] != '\0' ){
773        isError = 0;
# Line 755 | Line 776 | void TraPPE_ExFF::readParams( void ){
776                   &(currentAtomType->isSSD),
777                   &(currentAtomType->isDipole),
778                   &isGB,
779 +                 &isEAM,
780 +                 &isCharge,
781                   &(currentAtomType->epslon),
782                   &(currentAtomType->sigma),
783 +                 &charge,
784                   &(currentAtomType->dipole),
761 –                 &(currentAtomType->w0),
762 –                 &(currentAtomType->v0),
763 –                 &GB_dummy,
764 –                 &GB_dummy,
765 –                 &GB_dummy,
766 –                 &GB_dummy,
767 –                 &GB_dummy,
768 –                 &GB_dummy,
785                   &isError );
786        if( isError ){
787          sprintf( painCave.errMsg,
# Line 787 | Line 803 | void TraPPE_ExFF::readParams( void ){
803    
804  
805    // read in the bonds
790 –
806    
807 <  
808 <  
809 < }
807 > #ifdef IS_MPI
808 >  if( worldRank == 0 ){
809 > #endif
810 >    
811 >    // read in the bond types.
812 >    
813 >    headBondType = new LinkedBondType;
814 >    
815 >    fastForward( "BondTypes", "initializeBonds" );
816  
817 +    // we are now at the bondTypes section
818  
819 +    eof_test =  fgets( readLine, sizeof(readLine), frcFile );
820 +    lineNum++;
821 +    
822 +    
823 +    // read a line, and start parseing out the atom types
824  
825 < void TraPPE_ExFF::initializeAtoms( void ){
826 <  
825 >    if( eof_test == NULL ){
826 >      sprintf( painCave.errMsg,
827 >               "Error in reading bonds from force file at line %d.\n",
828 >               lineNum );
829 >      painCave.isFatal = 1;
830 >      simError();
831 >    }
832 >    
833 >    // stop reading at end of file, or at next section
834 >    while( readLine[0] != '#' && eof_test != NULL ){
835  
836 +      // toss comment lines
837 +      if( readLine[0] != '!' ){
838 +        
839 +        // the parser returns 0 if the line was blank
840 +        if( parseBond( readLine, lineNum, bondInfo ) ){
841 +          headBondType->add( bondInfo );
842 +        }
843 +      }
844 +      eof_test = fgets( readLine, sizeof(readLine), frcFile );
845 +      lineNum++;
846 +    }
847 +        
848 + #ifdef IS_MPI
849 +    
850 +    // send out the linked list to all the other processes
851 +    
852 +    sprintf( checkPointMsg,
853 +             "TraPPE_Ex bond structures read successfully." );
854 +    MPIcheckPoint();
855 +    
856 +    currentBondType = headBondType->next;
857 +    while( currentBondType != NULL ){
858 +      currentBondType->duplicate( bondInfo );
859 +      sendFrcStruct( &bondInfo, mpiBondStructType );
860 +      currentBondType = currentBondType->next;
861 +    }
862 +    bondInfo.last = 1;
863 +    sendFrcStruct( &bondInfo, mpiBondStructType );
864 +    
865 +  }
866 +
867 +  else{
868 +    
869 +    // listen for node 0 to send out the force params
870 +    
871 +    MPIcheckPoint();
872 +
873 +    headBondType = new LinkedBondType;
874 +    recieveFrcStruct( &bondInfo, mpiBondStructType );
875 +    while( !bondInfo.last ){
876 +
877 +      headBondType->add( bondInfo );
878 +      recieveFrcStruct( &bondInfo, mpiBondStructType );
879 +    }
880 +  }
881 +
882 +  sprintf( checkPointMsg,
883 +           "TraPPE_ExFF bond structures broadcast successfully." );
884 +  MPIcheckPoint();
885 +
886 + #endif // is_mpi
887    
888 +
889 +  // read in the bends
890 +
891 + #ifdef IS_MPI
892 +  if( worldRank == 0 ){
893 + #endif
894 +
895 +    // read in the bend types.
896 +
897 +    headBendType = new LinkedBendType;
898 +    
899 +    fastForward( "BendTypes", "initializeBends" );
900 +
901 +    // we are now at the bendTypes section
902 +
903 +    eof_test =  fgets( readLine, sizeof(readLine), frcFile );
904 +    lineNum++;
905 +        
906 +    // read a line, and start parseing out the bend types
907 +
908 +    if( eof_test == NULL ){
909 +      sprintf( painCave.errMsg,
910 +               "Error in reading bends from force file at line %d.\n",
911 +               lineNum );
912 +      painCave.isFatal = 1;
913 +      simError();
914 +    }
915 +    
916 +    // stop reading at end of file, or at next section
917 +    while( readLine[0] != '#' && eof_test != NULL ){
918 +      
919 +      // toss comment lines
920 +      if( readLine[0] != '!' ){
921 +        
922 +        // the parser returns 0 if the line was blank
923 +        if( parseBend( readLine, lineNum, bendInfo ) ){
924 +          headBendType->add( bendInfo );
925 +        }
926 +      }
927 +      eof_test = fgets( readLine, sizeof(readLine), frcFile );
928 +      lineNum++;
929 +    }
930 +    
931 + #ifdef IS_MPI
932 +    
933 +    // send out the linked list to all the other processes
934  
935 +    sprintf( checkPointMsg,
936 +             "TraPPE_Ex bend structures read successfully." );
937 +    MPIcheckPoint();
938  
939 +    currentBendType = headBendType->next;
940 +    while( currentBendType != NULL ){
941 +      currentBendType->duplicate( bendInfo );
942 +      sendFrcStruct( &bendInfo, mpiBendStructType );
943 +      currentBendType = currentBendType->next;
944 +    }
945 +    bendInfo.last = 1;
946 +    sendFrcStruct( &bendInfo, mpiBendStructType );
947 +    
948 +  }
949 +
950 +  else{
951 +    
952 +    // listen for node 0 to send out the force params
953 +    
954 +    MPIcheckPoint();
955 +
956 +    headBendType = new LinkedBendType;
957 +    recieveFrcStruct( &bendInfo, mpiBendStructType );
958 +    while( !bendInfo.last ){
959 +
960 +      headBendType->add( bendInfo );
961 +      recieveFrcStruct( &bendInfo, mpiBendStructType );
962 +    }
963 +  }
964 +
965 +  sprintf( checkPointMsg,
966 +           "TraPPE_ExFF bend structures broadcast successfully." );
967 +  MPIcheckPoint();
968 +
969 + #endif // is_mpi
970 +
971 +
972 +  // read in the torsions
973 +
974 + #ifdef IS_MPI
975 +  if( worldRank == 0 ){
976 + #endif
977 +
978 +    // read in the torsion types.
979 +
980 +    headTorsionType = new LinkedTorsionType;
981 +    
982 +    fastForward( "TorsionTypes", "initializeTorsions" );
983 +
984 +    // we are now at the torsionTypes section
985 +
986 +    eof_test =  fgets( readLine, sizeof(readLine), frcFile );
987 +    lineNum++;
988 +    
989 +    
990 +    // read a line, and start parseing out the atom types
991 +
992 +    if( eof_test == NULL ){
993 +      sprintf( painCave.errMsg,
994 +               "Error in reading torsions from force file at line %d.\n",
995 +               lineNum );
996 +      painCave.isFatal = 1;
997 +      simError();
998 +    }
999 +    
1000 +    // stop reading at end of file, or at next section
1001 +    while( readLine[0] != '#' && eof_test != NULL ){
1002 +
1003 +      // toss comment lines
1004 +      if( readLine[0] != '!' ){
1005 +        
1006 +        // the parser returns 0 if the line was blank
1007 +        if( parseTorsion( readLine, lineNum, torsionInfo ) ){
1008 +          headTorsionType->add( torsionInfo );
1009 +
1010 +        }
1011 +      }
1012 +      eof_test = fgets( readLine, sizeof(readLine), frcFile );
1013 +      lineNum++;
1014 +    }
1015 +
1016 + #ifdef IS_MPI
1017 +    
1018 +    // send out the linked list to all the other processes
1019 +    
1020 +    sprintf( checkPointMsg,
1021 +             "TraPPE_Ex torsion structures read successfully." );
1022 +    MPIcheckPoint();
1023 +    
1024 +    currentTorsionType = headTorsionType->next;
1025 +    while( currentTorsionType != NULL ){
1026 +      currentTorsionType->duplicate( torsionInfo );
1027 +      sendFrcStruct( &torsionInfo, mpiTorsionStructType );
1028 +      currentTorsionType = currentTorsionType->next;
1029 +    }
1030 +    torsionInfo.last = 1;
1031 +    sendFrcStruct( &torsionInfo, mpiTorsionStructType );
1032 +    
1033 +  }
1034 +
1035 +  else{
1036 +    
1037 +    // listen for node 0 to send out the force params
1038 +    
1039 +    MPIcheckPoint();
1040 +
1041 +    headTorsionType = new LinkedTorsionType;
1042 +    recieveFrcStruct( &torsionInfo, mpiTorsionStructType );
1043 +    while( !torsionInfo.last ){
1044 +
1045 +      headTorsionType->add( torsionInfo );
1046 +      recieveFrcStruct( &torsionInfo, mpiTorsionStructType );
1047 +    }
1048 +  }
1049 +
1050 +  sprintf( checkPointMsg,
1051 +           "TraPPE_ExFF torsion structures broadcast successfully." );
1052 +  MPIcheckPoint();
1053 +
1054 + #endif // is_mpi
1055 +
1056 +  entry_plug->useLJ = 1;
1057 + }
1058 +
1059 +
1060 +
1061 + void TraPPE_ExFF::initializeAtoms( int nAtoms, Atom** the_atoms ){
1062    
805 –  Atom** the_atoms;
806 –  int nAtoms;
807 –  the_atoms = entry_plug->atoms;
808 –  nAtoms = entry_plug->n_atoms;
1063    
1064    //////////////////////////////////////////////////
1065    // a quick water fix
# Line 837 | Line 1091 | void TraPPE_ExFF::initializeAtoms( void ){
1091    headI[2][1] = 0.0;
1092    headI[2][2] = 250;
1093  
840 –  
841 –
1094    //////////////////////////////////////////////////
1095  
844 –
845 –
1096    
1097    // initialize the atoms
1098    
849 –  double bigSigma = 0.0;
1099    DirectionalAtom* dAtom;
1100  
1101 <  for( i=0; i<nAtoms; i++ ){
1101 >  for(int i=0; i<nAtoms; i++ ){
1102  
854 –    
1103      currentAtomType = headAtomType->find( the_atoms[i]->getType() );
1104      if( currentAtomType == NULL ){
1105        sprintf( painCave.errMsg,
# Line 917 | Line 1165 | void TraPPE_ExFF::initializeAtoms( void ){
1165        }
1166      }
1167    }
920 –
921 – #ifdef IS_MPI
922 –  double tempBig = bigSigma;
923 –  MPI::COMM_WORLD.Allreduce( &tempBig, &bigSigma, 1, MPI_DOUBLE, MPI_MAX );
924 – #endif  //is_mpi
925 –
926 –  //calc rCut and rList
927 –
928 –  entry_plug->rCut = 2.5 * bigSigma;
929 –  
930 –  if(entry_plug->rCut > (entry_plug->box_x / 2.0))
931 –    entry_plug->rCut = entry_plug->box_x / 2.0;
932 –  
933 –  if(entry_plug->rCut > (entry_plug->box_y / 2.0))
934 –    entry_plug->rCut = entry_plug->box_y / 2.0;
935 –  
936 –  if(entry_plug->rCut > (entry_plug->box_z / 2.0))
937 –    entry_plug->rCut = entry_plug->box_z / 2.0;
938 –
939 –  entry_plug->rList = entry_plug->rCut + 1.0;
940 –
941 –  entry_plug->useLJ = 1; // use Lennard Jones is on by default
942 –
943 –  // clean up the memory
944 –  
945 –  delete headAtomType;
946 –
947 – #ifdef IS_MPI
948 –  sprintf( checkPointMsg, "TraPPE_Ex atoms initialized succesfully" );
949 –  MPIcheckPoint();
950 – #endif // is_mpi
951 –
1168   }
1169  
1170 < void TraPPE_ExFF::initializeBonds( bond_pair* the_bonds ){
1170 > void TraPPE_ExFF::initializeBonds( int nBonds, Bond** bondArray,
1171 >                                   bond_pair* the_bonds ){
1172 >  int i,a,b;
1173 >  char* atomA;
1174 >  char* atomB;
1175    
956 –
957 –
958 –
959 –  
960 –
961 –
962 –  info.last = 1; // initialize last to have the last set.
963 –                 // if things go well, last will be set to 0
964 –
965 –  SRI **the_sris;
1176    Atom** the_atoms;
967 –  int nBonds;
968 –  the_sris = entry_plug->sr_interactions;
1177    the_atoms = entry_plug->atoms;
970 –  nBonds = entry_plug->n_bonds;
971 –
972 –  int i, a, b;
973 –  char* atomA;
974 –  char* atomB;
1178    
976 – #ifdef IS_MPI
977 –  if( worldRank == 0 ){
978 – #endif
979 –    
980 –    // read in the bond types.
981 –    
982 –    headBondType = new LinkedType;
983 –    
984 –    fastForward( "BondTypes", "initializeBonds" );
1179  
986 –    // we are now at the bondTypes section
987 –
988 –    eof_test =  fgets( readLine, sizeof(readLine), frcFile );
989 –    lineNum++;
990 –    
991 –    
992 –    // read a line, and start parseing out the atom types
993 –
994 –    if( eof_test == NULL ){
995 –      sprintf( painCave.errMsg,
996 –               "Error in reading bonds from force file at line %d.\n",
997 –               lineNum );
998 –      painCave.isFatal = 1;
999 –      simError();
1000 –    }
1001 –    
1002 –    // stop reading at end of file, or at next section
1003 –    while( readLine[0] != '#' && eof_test != NULL ){
1004 –
1005 –      // toss comment lines
1006 –      if( readLine[0] != '!' ){
1007 –        
1008 –        // the parser returns 0 if the line was blank
1009 –        if( parseBond( readLine, lineNum, info ) ){
1010 –          headBondType->add( info );
1011 –        }
1012 –      }
1013 –      eof_test = fgets( readLine, sizeof(readLine), frcFile );
1014 –      lineNum++;
1015 –    }
1016 –        
1017 – #ifdef IS_MPI
1018 –    
1019 –    // send out the linked list to all the other processes
1020 –    
1021 –    sprintf( checkPointMsg,
1022 –             "TraPPE_Ex bond structures read successfully." );
1023 –    MPIcheckPoint();
1024 –    
1025 –    currentBondType = headBondType;
1026 –    while( currentBondType != NULL ){
1027 –      currentBondType->duplicate( info );
1028 –      sendFrcStruct( &info, mpiBondStructType );
1029 –      currentBondType = currentBondType->next;
1030 –    }
1031 –    info.last = 1;
1032 –    sendFrcStruct( &info, mpiBondStructType );
1033 –    
1034 –  }
1035 –
1036 –  else{
1037 –    
1038 –    // listen for node 0 to send out the force params
1039 –    
1040 –    MPIcheckPoint();
1041 –
1042 –    headBondType = new LinkedType;
1043 –    recieveFrcStruct( &info, mpiBondStructType );
1044 –    while( !info.last ){
1045 –
1046 –      headBondType->add( info );
1047 –      recieveFrcStruct( &info, mpiBondStructType );
1048 –    }
1049 –  }
1050 – #endif // is_mpi
1051 –  
1052 –  
1180    // initialize the Bonds
1181    
1055 –
1182    for( i=0; i<nBonds; i++ ){
1183      
1184      a = the_bonds[i].a;
# Line 1071 | Line 1197 | void TraPPE_ExFF::initializeBonds( bond_pair* the_bond
1197      
1198      if( !strcmp( currentBondType->type, "fixed" ) ){
1199        
1200 <      the_sris[i] = new ConstrainedBond( *the_atoms[a],
1201 <                                         *the_atoms[b],
1202 <                                         currentBondType->d0 );
1200 >      bondArray[i] = new ConstrainedBond( *the_atoms[a],
1201 >                                          *the_atoms[b],
1202 >                                          currentBondType->d0 );
1203        entry_plug->n_constraints++;
1204      }
1205    }
1080 –
1081 –
1082 –  // clean up the memory
1083 –  
1084 –  delete headBondType;
1085 –
1086 – #ifdef IS_MPI
1087 –  sprintf( checkPointMsg, "TraPPE_Ex bonds initialized succesfully" );
1088 –  MPIcheckPoint();
1089 – #endif // is_mpi
1090 –
1206   }
1207  
1208 < void TraPPE_ExFF::initializeBends( bend_set* the_bends ){
1208 > void TraPPE_ExFF::initializeBends( int nBends, Bend** bendArray,
1209 >                                   bend_set* the_bends ){
1210    
1095 –
1096 –  
1097 –
1098 –  bendStruct info;
1099 –  info.last = 1; // initialize last to have the last set.
1100 –                 // if things go well, last will be set to 0
1101 –
1211    QuadraticBend* qBend;
1212    GhostBend* gBend;
1104 –  SRI **the_sris;
1213    Atom** the_atoms;
1106 –  int nBends;
1107 –  the_sris = entry_plug->sr_interactions;
1214    the_atoms = entry_plug->atoms;
1215 <  nBends = entry_plug->n_bends;
1110 <
1215 >  
1216    int i, a, b, c;
1217    char* atomA;
1218    char* atomB;
1219    char* atomC;
1115 –
1116 –
1117 – #ifdef IS_MPI
1118 –  if( worldRank == 0 ){
1119 – #endif
1120 –
1121 –    // read in the bend types.
1122 –
1123 –    headBendType = new LinkedType;
1124 –    
1125 –    fastForward( "BendTypes", "initializeBends" );
1126 –
1127 –    // we are now at the bendTypes section
1128 –
1129 –    eof_test =  fgets( readLine, sizeof(readLine), frcFile );
1130 –    lineNum++;
1131 –        
1132 –    // read a line, and start parseing out the bend types
1133 –
1134 –    if( eof_test == NULL ){
1135 –      sprintf( painCave.errMsg,
1136 –               "Error in reading bends from force file at line %d.\n",
1137 –               lineNum );
1138 –      painCave.isFatal = 1;
1139 –      simError();
1140 –    }
1141 –    
1142 –    // stop reading at end of file, or at next section
1143 –    while( readLine[0] != '#' && eof_test != NULL ){
1144 –      
1145 –      // toss comment lines
1146 –      if( readLine[0] != '!' ){
1147 –        
1148 –        // the parser returns 0 if the line was blank
1149 –        if( parseBend( readLine, lineNum, info ) ){
1150 –          headBendType->add( info );
1151 –        }
1152 –      }
1153 –      eof_test = fgets( readLine, sizeof(readLine), frcFile );
1154 –      lineNum++;
1155 –    }
1156 –    
1157 – #ifdef IS_MPI
1158 –    
1159 –    // send out the linked list to all the other processes
1160 –
1161 –    sprintf( checkPointMsg,
1162 –             "TraPPE_Ex bend structures read successfully." );
1163 –    MPIcheckPoint();
1164 –
1165 –    currentBendType = headBendType;
1166 –    while( currentBendType != NULL ){
1167 –      currentBendType->duplicate( info );
1168 –      sendFrcStruct( &info, mpiBendStructType );
1169 –      currentBendType = currentBendType->next;
1170 –    }
1171 –    info.last = 1;
1172 –    sendFrcStruct( &info, mpiBendStructType );
1173 –    
1174 –  }
1175 –
1176 –  else{
1177 –    
1178 –    // listen for node 0 to send out the force params
1179 –    
1180 –    MPIcheckPoint();
1181 –
1182 –    headBendType = new LinkedType;
1183 –    recieveFrcStruct( &info, mpiBendStructType );
1184 –    while( !info.last ){
1185 –
1186 –      headBendType->add( info );
1187 –      recieveFrcStruct( &info, mpiBendStructType );
1188 –    }
1189 –  }
1190 – #endif // is_mpi
1220    
1221    // initialize the Bends
1193 –  
1194 –  int index;
1222  
1223    for( i=0; i<nBends; i++ ){
1224      
# Line 1216 | Line 1243 | void TraPPE_ExFF::initializeBends( bend_set* the_bends
1243      
1244      if( !strcmp( currentBendType->type, "quadratic" ) ){
1245        
1219 –      index = i + entry_plug->n_bonds;
1220 –      
1246        if( the_bends[i].isGhost){
1247          
1248          if( the_bends[i].ghost == b ){
# Line 1226 | Line 1251 | void TraPPE_ExFF::initializeBends( bend_set* the_bends
1251          else if( the_bends[i].ghost == a ){
1252            c = a;
1253            a = b;
1254 <          b = a;
1254 >          b = c;
1255          }
1256          else{
1257            sprintf( painCave.errMsg,
# Line 1245 | Line 1270 | void TraPPE_ExFF::initializeBends( bend_set* the_bends
1270                               currentBendType->k2,
1271                               currentBendType->k3,
1272                               currentBendType->t0 );
1273 <        the_sris[index] = gBend;
1273 >        bendArray[i] = gBend;
1274        }
1275        else{
1276          qBend = new QuadraticBend( *the_atoms[a],
# Line 1255 | Line 1280 | void TraPPE_ExFF::initializeBends( bend_set* the_bends
1280                               currentBendType->k2,
1281                               currentBendType->k3,
1282                               currentBendType->t0 );
1283 <        the_sris[index] = qBend;
1283 >        bendArray[i] = qBend;
1284        }
1285      }
1286    }
1262 –
1263 –
1264 –  // clean up the memory
1265 –  
1266 –  delete headBendType;
1267 –
1268 – #ifdef IS_MPI
1269 –  sprintf( checkPointMsg, "TraPPE_Ex bends initialized succesfully" );
1270 –  MPIcheckPoint();
1271 – #endif // is_mpi
1272 –
1287   }
1288  
1289 < void TraPPE_ExFF::initializeTorsions( torsion_set* the_torsions ){
1289 > void TraPPE_ExFF::initializeTorsions( int nTorsions, Torsion** torsionArray,
1290 >                                      torsion_set* the_torsions ){
1291  
1292 <
1278 <  
1279 <
1280 <  torsionStruct info;
1281 <  info.last = 1; // initialize last to have the last set.
1282 <                 // if things go well, last will be set to 0
1283 <
1284 <  int i, a, b, c, d, index;
1292 >  int i, a, b, c, d;
1293    char* atomA;
1294    char* atomB;
1295    char* atomC;
1296    char* atomD;
1289 –  CubicTorsion* cTors;
1297  
1298 <  SRI **the_sris;
1298 >  CubicTorsion* cTors;
1299    Atom** the_atoms;
1293 –  int nTorsions;
1294 –  the_sris = entry_plug->sr_interactions;
1300    the_atoms = entry_plug->atoms;
1296 –  nTorsions = entry_plug->n_torsions;
1297 –
1298 – #ifdef IS_MPI
1299 –  if( worldRank == 0 ){
1300 – #endif
1301 –
1302 –    // read in the torsion types.
1303 –
1304 –    headTorsionType = new LinkedType;
1305 –    
1306 –    fastForward( "TorsionTypes", "initializeTorsions" );
1307 –
1308 –    // we are now at the torsionTypes section
1309 –
1310 –    eof_test =  fgets( readLine, sizeof(readLine), frcFile );
1311 –    lineNum++;
1312 –    
1313 –    
1314 –    // read a line, and start parseing out the atom types
1315 –
1316 –    if( eof_test == NULL ){
1317 –      sprintf( painCave.errMsg,
1318 –               "Error in reading torsions from force file at line %d.\n",
1319 –               lineNum );
1320 –      painCave.isFatal = 1;
1321 –      simError();
1322 –    }
1323 –    
1324 –    // stop reading at end of file, or at next section
1325 –    while( readLine[0] != '#' && eof_test != NULL ){
1326 –
1327 –      // toss comment lines
1328 –      if( readLine[0] != '!' ){
1329 –        
1330 –        // the parser returns 0 if the line was blank
1331 –        if( parseTorsion( readLine, lineNum, info ) ){
1332 –          headTorsionType->add( info );
1333 –
1334 –        }
1335 –      }
1336 –      eof_test = fgets( readLine, sizeof(readLine), frcFile );
1337 –      lineNum++;
1338 –    }
1339 –
1340 – #ifdef IS_MPI
1341 –    
1342 –    // send out the linked list to all the other processes
1343 –    
1344 –    sprintf( checkPointMsg,
1345 –             "TraPPE_Ex torsion structures read successfully." );
1346 –    MPIcheckPoint();
1347 –    
1348 –    currentTorsionType = headTorsionType;
1349 –    while( currentTorsionType != NULL ){
1350 –      currentTorsionType->duplicate( info );
1351 –      sendFrcStruct( &info, mpiTorsionStructType );
1352 –      currentTorsionType = currentTorsionType->next;
1353 –    }
1354 –    info.last = 1;
1355 –    sendFrcStruct( &info, mpiTorsionStructType );
1356 –    
1357 –  }
1301  
1359 –  else{
1360 –    
1361 –    // listen for node 0 to send out the force params
1362 –    
1363 –    MPIcheckPoint();
1364 –
1365 –    headTorsionType = new LinkedType;
1366 –    recieveFrcStruct( &info, mpiTorsionStructType );
1367 –    while( !info.last ){
1368 –
1369 –      headTorsionType->add( info );
1370 –      recieveFrcStruct( &info, mpiTorsionStructType );
1371 –    }
1372 –  }
1373 – #endif // is_mpi
1374 –  
1302    // initialize the Torsions
1303  
1304    for( i=0; i<nTorsions; i++ ){
# Line 1396 | Line 1323 | void TraPPE_ExFF::initializeTorsions( torsion_set* the
1323      }
1324      
1325      if( !strcmp( currentTorsionType->type, "cubic" ) ){
1399 –      index = i + entry_plug->n_bonds + entry_plug->n_bends;
1326        
1327        cTors = new CubicTorsion( *the_atoms[a], *the_atoms[b],
1328                                  *the_atoms[c], *the_atoms[d] );
1329        cTors->setConstants( currentTorsionType->k1, currentTorsionType->k2,
1330                             currentTorsionType->k3, currentTorsionType->k4 );
1331 <      the_sris[index] = cTors;
1331 >      torsionArray[i] = cTors;
1332      }
1333    }
1408 –
1409 –
1410 –  // clean up the memory
1411 –  
1412 –  delete headTorsionType;
1413 –
1414 – #ifdef IS_MPI
1415 –  sprintf( checkPointMsg, "TraPPE_Ex torsions initialized succesfully" );
1416 –  MPIcheckPoint();
1417 – #endif // is_mpi
1418 –
1334   }
1335  
1336   void TraPPE_ExFF::fastForward( char* stopText, char* searchOwner ){

Diff Legend

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