ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE_old/src/mdtools/libmdCode/LJ_FF.cpp
(Generate patch)

Comparing trunk/OOPSE_old/src/mdtools/libmdCode/LJ_FF.cpp (file contents):
Revision 290 by chuckv, Thu Feb 27 21:25:47 2003 UTC vs.
Revision 348 by mmeineke, Fri Mar 14 21:33:10 2003 UTC

# Line 14 | Line 14 | using namespace std;
14   #include "SRI.hpp"
15   #include "simError.h"
16  
17 + #include <fortranWrappers.hpp>
18  
18 –
19 – // Declare the structures that will be passed by the parser and  MPI
20 –
21 – typedef struct{
22 –  char name[15];
23 –  double mass;
24 –  double epslon;
25 –  double sigma;
26 –  int ident;
27 –  int last;      //  0  -> default
28 –                 //  1  -> in MPI: tells nodes to stop listening
29 – } atomStruct;
30 –
31 – int parseAtomLJ( char *lineBuffer, int lineNum, atomStruct &info );
32 –
19   #ifdef IS_MPI
20   #include "mpiForceField.h"
21 + #endif // is_mpi
22  
36 – MPI_Datatype mpiAtomStructType;
23  
38 – #endif
24  
25 + namespace LJ_NS{
26  
27 < // declaration of functions needed to wrap the fortran module
27 >  // Declare the structures that will be passed by the parser and  MPI
28 >  
29 >  typedef struct{
30 >    char name[15];
31 >    double mass;
32 >    double epslon;
33 >    double sigma;
34 >    int ident;
35 >    int last;      //  0  -> default
36 >                   //  1  -> in MPI: tells nodes to stop listening
37 >  } atomStruct;
38  
39 < extern "C" {
40 <  void forcefactory_( char* forceName,
41 <                      int* status,
42 <                      void (*wrapFunction)( void (*p1)( int* ident,
43 <                                                        double* mass,
44 <                                                        double* epslon,
45 <                                                        double* sigma,
50 <                                                        int* status ),
51 <                                            void (*p2)( int *nLocal,
52 <                                                        int *identArray,
53 <                                                        int *isError ),
54 <                                            void (*p3)( double* positionArray,
55 <                                                        double* forceArray,
56 <                                                        double* potentialEnergy,
57 <                                                        double* tau,
58 <                                                        short int* doPotentialCalc,
59 <                                                        int* isError)),
60 <                      int forceNameLength );
39 >  int parseAtom( char *lineBuffer, int lineNum, atomStruct &info );
40 >  
41 > #ifdef IS_MPI
42 >  
43 >  MPI_Datatype mpiAtomStructType;
44 >  
45 > #endif
46   }
47  
48 + using namespace LJ_NS;
49  
64 – void LJfunctionWrapper( void (*p1)( int* ident, double* mass, double* epslon,
65 –                                   double* sigma, int* status ),
66 –                        void (*p2)( int *nLocal, int *identArray, int *isError ),
67 –                        void (*p3)( double* positionArray,double* forceArray,
68 –                                    double* potentialEnergy, double* tau,
69 –                                    short int* doPotentialCalc, int* isError ) );
70 –
71 – void (*newLJtype)( int* ident, double* mass, double* epslon, double* sigma,
72 –                   int* status );
73 –
74 – void (*initLJfortran) ( int *nLocal, int *identArray, int *isError );
75 –
76 – LJ_FF* currentLJwrap;
77 –
78 –
50   //****************************************************************
51   // begins the actual forcefield stuff.  
52   //****************************************************************
# Line 90 | Line 61 | LJ_FF::LJ_FF(){
61    char errMsg[1000];
62  
63    // do the funtion wrapping
64 <  currentLJwrap = this;
94 <  wrapMe();
64 >  wrapMeFF( this );
65  
66   #ifdef IS_MPI
67    int i;
# Line 137 | Line 107 | LJ_FF::LJ_FF(){
107        
108        ffPath = getenv( ffPath_env );
109        if( ffPath == NULL ) {
110 <        sprintf( painCave.errMsg,
141 <                 "Error opening the force field parameter file: %s\n"
142 <                 "Have you tried setting the FORCE_PARAM_PATH environment "
143 <                 "vairable?\n",
144 <                 fileName );
145 <        painCave.isFatal = 1;
146 <        simError();
110 >        STR_DEFINE(ffPath, FRC_PATH );
111        }
112        
113        
# Line 190 | Line 154 | void LJ_FF::wrapMe( void ){
154   }
155  
156  
193 – void LJ_FF::wrapMe( void ){
194 –  
195 –  char* currentFF = "LJ";
196 –  int isError = 0;
197 –  
198 –  forcefactory_( currentFF, &isError, LJfunctionWrapper, strlen(currentFF) );
157  
200 –  if( isError ){
201 –    
202 –    sprintf( painCave.errMsg,
203 –             "LJ_FF error: an error was returned from fortran when the "
204 –             "the functions were being wrapped.\n" );
205 –    painCave.isFatal = 1;
206 –    simError();
207 –  }
208 –
209 – #ifdef IS_MPI
210 –  sprintf( checkPointMsg, "LJ_FF functions succesfully wrapped." );
211 –  MPIcheckPoint();
212 – #endif // is_mpi
213 – }
214 –  
215 –
216 – void LJfunctionWrapper( void (*p1)( int* ident, double* mass, double* epslon,
217 –                                   double* sigma, int* status ),
218 –                        void (*p2)( int*, int*, int* ),
219 –                        void (*p3)( double* positionArray,double* forceArray,
220 –                                    double* potentialEnergy,
221 –                                    short int* doPotentialCalc ) ){
222 –  
223 –  
224 –  newLJtype = p1;
225 –  initLJfortran = p2;
226 –  currentLJwrap->setLJfortran( p3 );
227 – }
228 –
229 –
230 –
158   void LJ_FF::initializeAtoms( void ){
159    
160    class LinkedType {
# Line 341 | Line 268 | void LJ_FF::initializeAtoms( void ){
268        if( readLine[0] != '!' ){
269          
270          // the parser returns 0 if the line was blank
271 <        if( parseAtomLJ( readLine, lineNum, info ) ){
271 >        if( parseAtom( readLine, lineNum, info ) ){
272            info.ident = identNum;
273            headAtomType->add( info );;
274            identNum++;
# Line 404 | Line 331 | void LJ_FF::initializeAtoms( void ){
331    // call new A_types in fortran
332    
333    int isError;
334 +
335 +  // dummy variables
336 +  int isLJ = 1;
337 +  int isDipole = 0;
338 +  int isSSD = 0;
339 +  int isGB = 0;
340 +  double w0 = 0.0;
341 +  double v0 = 0.0;
342 +  double dipole = 0.0;
343 +  
344 +  
345    currentAtomType = headAtomType;
346    while( currentAtomType != NULL ){
347      
348      if( currentAtomType->name[0] != '\0' ){
349        isError = 0;
350 <          newLJtype( &(currentAtomType->ident),
351 <                 &(currentAtomType->mass),
352 <                 &(currentAtomType->epslon),
353 <                 &(currentAtomType->sigma),
354 <                 &isError );
350 >      makeAtype( &(currentAtomType->ident),
351 >                &(currentAtomType->mass),
352 >                &(currentAtomType->epslon),
353 >                &(currentAtomType->sigma),
354 >                &isLJ, &isSSD, &isDipole, &isGB, &w0, &v0, &dipole,
355 >                &isError );
356        if( isError ){
357          sprintf( painCave.errMsg,
358                   "Error initializing the \"%s\" atom type in fortran\n",
# Line 482 | Line 421 | void LJ_FF::initializeAtoms( void ){
421    MPIcheckPoint();
422   #endif // is_mpi
423  
424 <  initFortran();
424 >  this->initFortran();
425    entry_plug->refreshSim();
426 <
426 >  
427   }
428  
429   void LJ_FF::initializeBonds( bond_pair* the_bonds ){
# Line 529 | Line 468 | void LJ_FF::initializeTorsions( torsion_set* the_torsi
468  
469   }
470  
532 –
471   void LJ_FF::fastForward( char* stopText, char* searchOwner ){
472  
473    int foundText = 0;
# Line 586 | Line 524 | int parseAtomLJ( char *lineBuffer, int lineNum,  atomS
524  
525  
526  
527 < int parseAtomLJ( char *lineBuffer, int lineNum,  atomStruct &info ){
527 > int parseAtom( char *lineBuffer, int lineNum,  atomStruct &info ){
528  
529    char* the_token;
530    
# Line 626 | Line 564 | int parseAtomLJ( char *lineBuffer, int lineNum,  atomS
564    }
565    else return 0;
566   }
629 –
630 –
631 – void LJ_FF::doForces( int calcPot ){
632 –
633 –  int i, isError;
634 –  double* frc;
635 –  double* pos;
636 –  double* tau;
637 –  short int passedCalcPot = (short int)calcPot;
638 –
639 –  // forces are zeroed here, before any are acumulated.
640 –  // NOTE: do not rezero the forces in Fortran.
641 –
642 –  for(i=0; i<entry_plug->n_atoms; i++){
643 –    entry_plug->atoms[i]->zeroForces();
644 –  }
645 –
646 –  frc = Atom::getFrcArray();
647 –  pos = Atom::getPosArray();
648 –  tau = entry_plug->tau;
649 –
650 –  isError = 0;
651 –  doLJfortran( pos, frc, &(entry_plug->lrPot), tau, &passedCalcPot, &isError );
652 –
653 –
654 –  if( isError ){
655 –    sprintf( painCave.errMsg,
656 –             "Error returned from the fortran force calculation.\n" );
657 –    painCave.isFatal = 1;
658 –    simError();
659 –  }
660 –
661 – #ifdef IS_MPI
662 –  sprintf( checkPointMsg,
663 –           "returned from the force calculation.\n" );
664 –  MPIcheckPoint();
665 – #endif // is_mpi
666 –
667 – }
668 –  
669 – void LJ_FF::initFortran( void ){
670 –  
671 –  int nLocal = entry_plug->n_atoms;
672 –  int *ident;
673 –  int isError;
674 –  int i;
675 –
676 –  ident = new int[nLocal];
677 –
678 –  for(i=0; i<nLocal; i++){
679 –    ident[i] = entry_plug->atoms[i]->getIdent();
680 –  }
681 –
682 –  isError = 0;
683 –  initLJfortran( &nLocal, ident, &isError );
684 –  
685 –  if(isError){
686 –    sprintf( painCave.errMsg,
687 –             "LJ_FF error: There was an error initializing the component list in fortran.\n" );
688 –    painCave.isFatal = 1;
689 –    simError();
690 –  }
691 –
692 –  
693 – #ifdef IS_MPI
694 –  sprintf( checkPointMsg, "LJ_FF successfully initialized the fortran component list.\n" );
695 –  MPIcheckPoint();
696 – #endif // is_mpi
697 –  
698 –  delete[] ident;
699 –
700 – }
701 –  

Diff Legend

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