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 270 by mmeineke, Fri Feb 14 17:08:46 2003 UTC vs.
Revision 296 by mmeineke, Thu Mar 6 20:05:39 2003 UTC

# Line 5 | Line 5 | using namespace std;
5   #include <iostream>
6   using namespace std;
7  
8 + #ifdef IS_MPI
9 + #include <mpi.h>
10 + #include <mpi++.h>
11 + #endif //is_mpi
12 +
13   #include "ForceFields.hpp"
14   #include "SRI.hpp"
15   #include "simError.h"
16  
17 < // Declare the structures that will be passed by the parser and  MPI
17 > #include <fortranWrappers.hpp>
18  
14 – typedef struct{
15 –  char name[15];
16 –  double mass;
17 –  double epslon;
18 –  double sigma;
19 –  int ident;
20 –  int last;      //  0  -> default
21 –                 //  1  -> in MPI: tells nodes to stop listening
22 – } atomStruct;
23 –
24 – int parseAtomLJ( char *lineBuffer, int lineNum, atomStruct &info );
25 –
19   #ifdef IS_MPI
20   #include "mpiForceField.h"
21 + #endif // is_mpi
22  
29 – MPI_Datatype mpiAtomStructType;
23  
31 – #endif
24  
25 + namespace {
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,
43 <                                                        int* status ),
44 <                                            void (*p2)( int *nLocal,
45 <                                                        int *identArray,
46 <                                                        int *isError ),
47 <                                            void (*p3)( double* positionArray,
48 <                                                        double* forceArray,
49 <                                                        double* potentialEnergy,
50 <                                                        short int* doPotentialCalc )),
51 <                      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  
55 – void LJfunctionWrapper( void (*p1)( int* ident, double* mass, double* epslon,
56 –                                   double* sigma, int* status ),
57 –                        void (*p2)( int *nLocal, int *identArray, int *isError ),
58 –                        void (*p3)( double* positionArray,double* forceArray,
59 –                                    double* potentialEnergy,
60 –                                    short int* doPotentialCalc ) );
61 –
62 – void (*newLJtype)( int* ident, double* mass, double* epslon, double* sigma,
63 –                   int* status );
64 –
65 – void (*initLJfortran) ( int *nLocal, int *identArray, int *isError );
66 –
67 – LJ_FF* currentLJwrap;
68 –
69 –
49   //****************************************************************
50   // begins the actual forcefield stuff.  
51   //****************************************************************
# Line 81 | Line 60 | LJ_FF::LJ_FF(){
60    char errMsg[1000];
61  
62    // do the funtion wrapping
63 <  currentLJwrap = this;
85 <  wrapMe();
63 >  wrapMeFF( this );
64  
65   #ifdef IS_MPI
66    int i;
# Line 178 | Line 156 | LJ_FF::~LJ_FF(){
156   #ifdef IS_MPI
157    }
158   #endif // is_mpi
181 – }
182 –
183 –
184 – void LJ_FF::wrapMe( void ){
185 –  
186 –  char* currentFF = "LJ";
187 –  int isError = 0;
188 –  
189 –  forcefactory_( currentFF, &isError, LJfunctionWrapper, strlen(currentFF) );
190 –
191 –  if( isError ){
192 –    
193 –    sprintf( painCave.errMsg,
194 –             "LJ_FF error: an error was returned from fortran when the "
195 –             "the functions were being wrapped.\n" );
196 –    painCave.isFatal = 1;
197 –    simError();
198 –  }
199 –
200 – #ifdef IS_MPI
201 –  sprintf( checkPointMsg, "LJ_FF functions succesfully wrapped." );
202 –  MPIcheckPoint();
203 – #endif // is_mpi
204 – }
205 –  
206 –
207 – void LJfunctionWrapper( void (*p1)( int* ident, double* mass, double* epslon,
208 –                                   double* sigma, int* status ),
209 –                        void (*p2)( int*, int*, int* ),
210 –                        void (*p3)( double* positionArray,double* forceArray,
211 –                                    double* potentialEnergy,
212 –                                    short int* doPotentialCalc ) ){
213 –  
214 –  
215 –  newLJtype = p1;
216 –  initLJfortran = p2;
217 –  currentLJwrap->setLJfortran( p3 );
159   }
160  
161  
# Line 395 | Line 336 | void LJ_FF::initializeAtoms( void ){
336    // call new A_types in fortran
337    
338    int isError;
339 +
340 +  // dummy variables
341 +  int isLJ = 1;
342 +  int isDipole = 0;
343 +  int isSSD = 0;
344 +  int isGB = 0;
345 +  double w0 = 0.0;
346 +  double v0 = 0.0;
347 +  double dipole = 0.0;
348 +  
349 +  
350    currentAtomType = headAtomType;
351    while( currentAtomType != NULL ){
352      
353      if( currentAtomType->name[0] != '\0' ){
354        isError = 0;
355 <          newLJtype( &(currentAtomType->ident),
356 <                 &(currentAtomType->mass),
357 <                 &(currentAtomType->epslon),
358 <                 &(currentAtomType->sigma),
359 <                 &isError );
355 >      newAtype( &(currentAtomType->ident),
356 >                &(currentAtomType->mass),
357 >                &(currentAtomType->epslon),
358 >                &(currentAtomType->sigma),
359 >                &isLJ, &isSSD, &isDipole, &isGB, &w0, &v0, &dipole,
360 >                &isError );
361        if( isError ){
362          sprintf( painCave.errMsg,
363                   "Error initializing the \"%s\" atom type in fortran\n",
# Line 475 | Line 428 | void LJ_FF::initializeAtoms( void ){
428  
429    initFortran();
430    entry_plug->refreshSim();
431 <
431 >  
432   }
433  
434   void LJ_FF::initializeBonds( bond_pair* the_bonds ){
# Line 514 | Line 467 | void LJ_FF::initializeTorsions( torsion_set* the_torsi
467        painCave.isFatal = 1;
468        simError();
469      }
470 + #ifdef IS_MPI
471 +  MPIcheckPoint();
472 + #endif // is_mpi
473 +
474 + }
475 +
476 + void LJ_FF::doForces( int calcPot ){
477 +
478 +  int i, isError;
479 +  double* frc;
480 +  double* pos;
481 +  double* trq;
482 +  double* tau;
483 +  short int passedCalcPot = (short int)calcPot;
484 +
485 +  // forces are zeroed here, before any are acumulated.
486 +  // NOTE: do not rezero the forces in Fortran.
487 +
488 +  for(i=0; i<entry_plug->n_atoms; i++){
489 +    entry_plug->atoms[i]->zeroForces();
490 +  }
491 +
492 +  frc = Atom::getFrcArray();
493 +  pos = Atom::getPosArray();
494 +  trq = Atom::getTrqArray();
495 +  tau = entry_plug->tau;
496 +
497 +  // dummy variables
498 +  // NOTE: THIS IS A MAJOR POTENTIAL BUG!!!!!! be careful.
499 +  // that said, here we go anyway.
500 +  
501 +  double* A     = NULL;
502 +  double* mu    = NULL;
503 +  double* u_l   = NULL;
504 +    
505 +  isError = 0;
506 +  fortranForceLoop( pos, A, mu, u_l, frc, trq, tau, &(entry_plug->lrPot),
507 +                    &passedCalcPot, &isError );
508 +
509 +
510 +  if( isError ){
511 +    sprintf( painCave.errMsg,
512 +             "Error returned from the fortran force calculation.\n" );
513 +    painCave.isFatal = 1;
514 +    simError();
515 +  }
516 +
517   #ifdef IS_MPI
518 +  sprintf( checkPointMsg,
519 +           "returned from the force calculation.\n" );
520    MPIcheckPoint();
521   #endif // is_mpi
522  
523   }
524 +  
525 + void LJ_FF::initFortran( void ){
526 +  
527 +  int nLocal = entry_plug->n_atoms;
528 +  int *ident;
529 +  int isError;
530 +  int i;
531  
532 +  ident = new int[nLocal];
533  
534 +  for(i=0; i<nLocal; i++){
535 +    ident[i] = entry_plug->atoms[i]->getIdent();
536 +  }
537 +
538 +  isError = 0;
539 +  initfortran( &nLocal, ident, &isError );
540 +  
541 +  if(isError){
542 +    sprintf( painCave.errMsg,
543 +             "LJ_FF error: There was an error initializing the component list in fortran.\n" );
544 +    painCave.isFatal = 1;
545 +    simError();
546 +  }
547 +
548 +  
549 + #ifdef IS_MPI
550 +  sprintf( checkPointMsg, "LJ_FF successfully initialized the fortran component list.\n" );
551 +  MPIcheckPoint();
552 + #endif // is_mpi
553 +  
554 +  delete[] ident;
555 +
556 + }
557 +
558 +  
559   void LJ_FF::fastForward( char* stopText, char* searchOwner ){
560  
561    int foundText = 0;
# Line 577 | Line 612 | int parseAtomLJ( char *lineBuffer, int lineNum,  atomS
612  
613  
614  
615 < int parseAtomLJ( char *lineBuffer, int lineNum,  atomStruct &info ){
615 > int parseAtom( char *lineBuffer, int lineNum,  atomStruct &info ){
616  
617    char* the_token;
618    
# Line 617 | Line 652 | int parseAtomLJ( char *lineBuffer, int lineNum,  atomS
652    }
653    else return 0;
654   }
620 –
621 –
622 – void LJ_FF::doForces( int calcPot ){
623 –
624 –  int i;
625 –  double* frc;
626 –  double* pos;
627 –  short int passedCalcPot = (short int)calcPot;
628 –
629 –  // forces are zeroed here, before any are acumulated.
630 –  // NOTE: do not rezero the forces in Fortran.
631 –
632 –  for(i=0; i<entry_plug->n_atoms; i++){
633 –    entry_plug->atoms[i]->zeroForces();
634 –  }
635 –
636 –  frc = Atom::getFrcArray();
637 –  pos = Atom::getPosArray();
638 –
639 – //   entry_plug->lrPot = -1;
640 –  doLJfortran( pos, frc, &(entry_plug->lrPot), &passedCalcPot );
641 –
642 –
643 –  //   fprintf( stderr,
644 –  //   "lrPot =  %lf\n", entry_plug->lrPot );
645 –  
646 – }
647 –  
648 – void LJ_FF::initFortran( void ){
649 –  
650 –  int nLocal = entry_plug->n_atoms;
651 –  int *ident;
652 –  int isError;
653 –  int i;
654 –
655 –  ident = new int[nLocal];
656 –
657 –  for(i=0; i<nLocal; i++){
658 –    ident[i] = entry_plug->atoms[i]->getIdent();
659 –  }
660 –
661 –  isError = 0;
662 –  initLJfortran( &nLocal, ident, &isError );
663 –  
664 –  if(isError){
665 –    sprintf( painCave.errMsg,
666 –             "LJ_FF error: There was an error initializing the component list in fortran.\n" );
667 –    painCave.isFatal = 1;
668 –    simError();
669 –  }
670 –
671 –  
672 – #ifdef IS_MPI
673 –  sprintf( checkPointMsg, "LJ_FF successfully initialized the fortran component list.\n" );
674 –  MPIcheckPoint();
675 – #endif // is_mpi
676 –  
677 –  delete[] ident;
678 –
679 – }
680 –  

Diff Legend

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