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

Comparing trunk/OOPSE/libmdtools/WATER.cpp (file contents):
Revision 976 by chrisfen, Thu Jan 22 17:34:20 2004 UTC vs.
Revision 1224 by gezelter, Wed Jun 2 18:27:52 2004 UTC

# Line 23 | Line 23 | namespace WATER_NS{
23  
24   namespace WATER_NS{
25  
26 <  // Declare the structures that will be passed by the parser and  MPI
26 >  // Declare the structures that will be passed by the parser and MPI
27    
28    typedef struct{
29      char name[15];
# Line 41 | Line 41 | namespace WATER_NS{
41  
42    typedef struct{
43      char name[15];
44 +    double Ixx;
45 +    double Iyy;
46 +    double Izz;
47      double dipole;
48      double w0;
49      double v0;
# Line 172 | Line 175 | namespace WATER_NS{
175          strcpy(next->name, info.name);
176          next->isDipole = info.isDipole;
177          next->isSticky = info.isSticky;
178 <        next->dipole   = info.dipole;
178 >        next->Ixx      = info.Ixx;
179 >        next->Iyy      = info.Iyy;
180 >        next->Izz      = info.Izz;
181 >        next->dipole   = info.dipole;
182          next->w0       = info.w0;
183          next->v0       = info.v0;
184          next->v0p      = info.v0p;
# Line 189 | Line 195 | namespace WATER_NS{
195        strcpy(info.name, name);
196        info.isDipole = isDipole;
197        info.isSticky = isSticky;
198 +      info.Ixx      = Ixx;
199 +      info.Iyy      = Iyy;
200 +      info.Izz      = Izz;
201        info.dipole   = dipole;
202        info.w0       = w0;
203        info.v0       = v0;
# Line 205 | Line 214 | namespace WATER_NS{
214      char name[15];
215      int isDipole;
216      int isSticky;
217 +    double Ixx;
218 +    double Iyy;
219 +    double Izz;
220      double dipole;
221      double w0;
222      double v0;
# Line 220 | Line 232 | namespace WATER_NS{
232    LinkedAtomType* currentAtomType;
233    LinkedDirectionalType* headDirectionalType;
234    LinkedDirectionalType* currentDirectionalType;
235 < }
235 > } // namespace
236  
237   using namespace WATER_NS;
238  
# Line 257 | Line 269 | WATER::WATER(){
269  
270    MPI_Address(&atomProto.name, &atomDspls[0]);
271    MPI_Address(&atomProto.mass, &atomDspls[1]);
272 <  MPI_Address(&atomProto.ident, &atomDspls[2]);
272 >  MPI_Address(&atomProto.isDirectional, &atomDspls[2]);
273    
274    atomMbrTypes[0] = MPI_CHAR;
275    atomMbrTypes[1] = MPI_DOUBLE;
# Line 274 | Line 286 | WATER::WATER(){
286    // Init the directionalStruct mpi type
287  
288    directionalStruct directionalProto; // mpiPrototype
289 <  int directionalBC[3] = {15,8,3};  // block counts
289 >  int directionalBC[3] = {15,11,3};  // block counts
290    MPI_Aint directionalDspls[3];           // displacements
291    MPI_Datatype directionalMbrTypes[3];    // member mpi types
292  
293    MPI_Address(&directionalProto.name, &directionalDspls[0]);
294 <  MPI_Address(&directionalProto.mass, &directionalDspls[1]);
295 <  MPI_Address(&directionalProto.ident, &directionalDspls[2]);
294 >  MPI_Address(&directionalProto.Ixx, &directionalDspls[1]);
295 >  MPI_Address(&directionalProto.isDipole, &directionalDspls[2]);
296    
297    directionalMbrTypes[0] = MPI_CHAR;
298    directionalMbrTypes[1] = MPI_DOUBLE;
# Line 293 | Line 305 | WATER::WATER(){
305    MPI_Type_commit(&mpiDirectionalStructType);
306  
307    // ***********************************************************************
308 <  
308 >
309    if( worldRank == 0 ){
310   #endif
311      
# Line 326 | Line 338 | WATER::WATER(){
338        if( frcFile == NULL ){
339          
340          sprintf( painCave.errMsg,
341 <                 "Error opening the force field parameter file: %s\n"
342 <                 "Have you tried setting the FORCE_PARAM_PATH environment "
341 >                 "Error opening the force field parameter file:\n"
342 >                 "\t%s\n"
343 >                 "\tHave you tried setting the FORCE_PARAM_PATH environment "
344                   "variable?\n",
345                   fileName );
346 +        painCave.severity = OOPSE_ERROR;
347          painCave.isFatal = 1;
348          simError();
349        }
# Line 387 | Line 401 | void WATER::readParams( void ){
401   void WATER::readParams( void ){
402  
403    int identNum;
404 +  int tempDirect0, tempDirect1;
405  
406    atomStruct atomInfo;
407    directionalStruct directionalInfo;
408 +  fpos_t *atomPos;
409  
410    atomInfo.last = 1;         // initialize last to have the last set.
411    directionalInfo.last = 1;  // if things go well, last will be set to 0
412    
413    atomPos = new fpos_t;
414    bigSigma = 0.0;
415 <
415 >  
416   #ifdef IS_MPI
417    if( worldRank == 0 ){
418   #endif
# Line 404 | Line 420 | void WATER::readParams( void ){
420      // read in the atom types.
421  
422      headAtomType = new LinkedAtomType;
423 +    headDirectionalType = new LinkedDirectionalType;
424      
425      fastForward( "AtomTypes", "initializeAtoms" );
426 <
426 >    
427      // we are now at the AtomTypes section.
428      
429      eof_test = fgets( readLine, sizeof(readLine), frcFile );
# Line 414 | Line 431 | void WATER::readParams( void ){
431      
432      
433      // read a line, and start parsing out the atom types
434 <
434 >    
435      if( eof_test == NULL ){
436        sprintf( painCave.errMsg,
437                 "Error in reading Atoms from force file at line %d.\n",
# Line 442 | Line 459 | void WATER::readParams( void ){
459              sectionSearch( "DirectionalTypes", atomInfo.name,
460                             "initializeDirectional" );
461              parseDirectional( readLine, lineNum, directionalInfo );
462 +            headDirectionalType->add( directionalInfo );
463  
464              // return to the AtomTypes section
465              fsetpos( frcFile, atomPos );
# Line 454 | Line 472 | void WATER::readParams( void ){
472      }
473  
474   #ifdef IS_MPI
475 <    
475 >  
476      // send out the linked list to all the other processes
477      
478      sprintf( checkPointMsg,
479 <             "WATER atom structures read successfully." );
479 >           "WATER atom and directional structures read successfully." );
480      MPIcheckPoint();
481 +    currentAtomType = headAtomType->next; //skip the first element place holder
482 +    currentDirectionalType = headDirectionalType->next; // same w/ directional
483      
464 –    currentAtomType = headAtomType->next; //skip the first element who is a place holder.
484      while( currentAtomType != NULL ){
485        currentAtomType->duplicate( atomInfo );
486 <      
486 >
487        sendFrcStruct( &atomInfo, mpiAtomStructType );
488        
489        sprintf( checkPointMsg,
490                 "successfully sent WATER force type: \"%s\"\n",
491                 atomInfo.name );
473 –      MPIcheckPoint();
492        
493 +      if ( atomInfo.isDirectional ){
494 +        // send out the directional linked list to all the other processes
495 +        
496 +        currentDirectionalType->duplicate( directionalInfo );
497 +        sendFrcStruct( &directionalInfo, mpiDirectionalStructType );
498 +        
499 +        sprintf( checkPointMsg,
500 +                 "successfully sent WATER directional type: \"%s\"\n",
501 +                 directionalInfo.name );
502 +      }
503 +      
504 +      MPIcheckPoint();
505 +      tempDirect0 = atomInfo.isDirectional;
506        currentAtomType = currentAtomType->next;
507 +      if( tempDirect0 )
508 +        currentDirectionalType = currentDirectionalType->next;
509      }
510 +    
511      atomInfo.last = 1;
512      sendFrcStruct( &atomInfo, mpiAtomStructType );
513 <
514 <    if ( atomInfo.isDirectional ){
481 <      // send out the linked list to all the other processes
482 <      
483 <      sprintf( checkPointMsg,
484 <               "WATER directional structures read successfully." );
485 <      MPIcheckPoint();
486 <      
487 <      currentDirectionalType = headDirectionalType->next;
488 <      while( currentDirectionalType != NULL ){
489 <        currentDirectionalType->duplicate( directionalInfo );
490 <        sendFrcStruct( &directionalInfo, mpiDirectionalStructType );
491 <        currentDirectionalType = currentDirectionalType->next;
492 <      }
493 <      directionalInfo.last = 1;
513 >    directionalInfo.last = 1;
514 >    if ( atomInfo.isDirectional )
515        sendFrcStruct( &directionalInfo, mpiDirectionalStructType );
495 –    }
516    }
517    
518    else{
499 –    
519      // listen for node 0 to send out the force params
520      
521      MPIcheckPoint();
522 <    
522 >
523      headAtomType = new LinkedAtomType;
524 +    headDirectionalType = new LinkedDirectionalType;
525      receiveFrcStruct( &atomInfo, mpiAtomStructType );
526 <    
526 >
527 >    if ( atomInfo.isDirectional )
528 >      receiveFrcStruct( &directionalInfo, mpiDirectionalStructType );
529 >
530      while( !atomInfo.last ){
531 <      
531 >
532        headAtomType->add( atomInfo );
533        
534        MPIcheckPoint();
535 <      
535 >
536        receiveFrcStruct( &atomInfo, mpiAtomStructType );
514 –    }
537  
538 <    if ( atomInfo.isDirectional ) {
517 <      // listen for node 0 to send out the force params
518 <      
519 <      MPIcheckPoint();
520 <      
521 <      headDirectionalType = new LinkedDirectionalType;
522 <      receiveFrcStruct( &directionalInfo, mpiDirectionalStructType );
523 <      while( !directionalInfo.last ){
524 <        
538 >      if( atomInfo.isDirectional ){
539          headDirectionalType->add( directionalInfo );
540 +
541          receiveFrcStruct( &directionalInfo, mpiDirectionalStructType );
542        }
528 –      
529 –      sprintf( checkPointMsg,
530 –               "WATER directional structures broadcast successfully." );
531 –      MPIcheckPoint();
543      }
544    }
545  
546   #endif // is_mpi
536 –
537 –
547    
548    // call new A_types in fortran
549    
# Line 543 | Line 552 | void WATER::readParams( void ){
552    // dummy variables
553    int isGB = 0;
554    int isEAM = 0;
555 <  
556 <  currentAtomType = headAtomType;
555 >  int notDipole = 0;
556 >  int notSSD = 0;
557 >  double noDipMoment = 0.0;
558 >
559 >
560 >  currentAtomType = headAtomType->next;
561 >  currentDirectionalType = headDirectionalType->next;
562 >
563    while( currentAtomType != NULL ){
564  
565      if( currentAtomType->isLJ ) entry_plug->useLJ = 1;
566 <    if( currentAtomType->isCharge ) entry_plug->useCharge = 1;
566 >    if( currentAtomType->isCharge ) entry_plug->useCharges = 1;
567      if( currentAtomType->isDirectional ){
568 <      if ( currentAtomType->isDipole ){
569 <        entry_plug->useDipoles = 1;
570 <        &(currentAtomType->dipole);
556 <      }
557 <      if ( currentAtomType->isSticky ) {
568 >      // only directional atoms can have dipoles or be sticky
569 >      if ( currentDirectionalType->isDipole ) entry_plug->useDipoles = 1;
570 >      if ( currentDirectionalType->isSticky ) {
571          entry_plug->useSticky = 1;
572 <        set_sticky_params( &(currentAtomType->w0), &(currentAtomType->v0),
573 <                           &(currentAtomType->v0p),
574 <                           &(currentAtomType->rl), &(currentAtomType->ru),
575 <                           &(currentAtomType->rlp), &(currentAtomType->rup));
572 >        set_sticky_params( &(currentDirectionalType->w0),
573 >                           &(currentDirectionalType->v0),
574 >                           &(currentDirectionalType->v0p),
575 >                           &(currentDirectionalType->rl),
576 >                           &(currentDirectionalType->ru),
577 >                           &(currentDirectionalType->rlp),
578 >                           &(currentDirectionalType->rup));
579        }
580 +      if( currentAtomType->name[0] != '\0' ){
581 +        isError = 0;
582 +        makeAtype( &(currentAtomType->ident),
583 +                   &(currentAtomType->isLJ),
584 +                   &(currentDirectionalType->isSticky),
585 +                   &(currentDirectionalType->isDipole),
586 +                   &isGB,
587 +                   &isEAM,
588 +                   &(currentAtomType->isCharge),
589 +                   &(currentAtomType->epslon),
590 +                   &(currentAtomType->sigma),
591 +                   &(currentAtomType->charge),
592 +                   &(currentDirectionalType->dipole),
593 +                   &isError );
594 +        if( isError ){
595 +          sprintf( painCave.errMsg,
596 +                   "Error initializing the \"%s\" atom type in fortran\n",
597 +                   currentAtomType->name );
598 +          painCave.isFatal = 1;
599 +          simError();
600 +        }
601 +      }
602 +      currentDirectionalType->next;
603      }
604 <    if( currentAtomType->name[0] != '\0' ){
605 <      isError = 0;
606 <      makeAtype( &(currentAtomType->ident),
607 <                 &isGB,
608 <                 &isEAM,
609 <                 &(currentAtomType->isDirectional),
610 <                 &(currentAtomType->isLJ),
611 <                 &(currentAtomType->isCharge),
612 <                 &(currentAtomType->epslon),
613 <                 &(currentAtomType->sigma),
614 <                 &(currentAtomType->charge),
615 <                 &isError );
616 <      if( isError ){
617 <        sprintf( painCave.errMsg,
618 <                 "Error initializing the \"%s\" atom type in fortran\n",
619 <                 currentAtomType->name );
620 <        painCave.isFatal = 1;
621 <        simError();
604 >
605 >    else {
606 >      // use all dummy variables if this is not a directional atom
607 >      if( currentAtomType->name[0] != '\0' ){
608 >        isError = 0;
609 >        makeAtype( &(currentAtomType->ident),
610 >                   &(currentAtomType->isLJ),
611 >                   &notSSD,
612 >                   &notDipole,
613 >                   &isGB,
614 >                   &isEAM,
615 >                   &(currentAtomType->isCharge),
616 >                   &(currentAtomType->epslon),
617 >                   &(currentAtomType->sigma),
618 >                   &(currentAtomType->charge),
619 >                   &noDipMoment,
620 >                   &isError );
621 >        if( isError ){
622 >          sprintf( painCave.errMsg,
623 >                   "Error initializing the \"%s\" atom type in fortran\n",
624 >                   currentAtomType->name );
625 >          painCave.isFatal = 1;
626 >          simError();
627 >        }
628        }
629      }
630      currentAtomType = currentAtomType->next;
# Line 587 | Line 632 | void WATER::readParams( void ){
632  
633   #ifdef IS_MPI
634    sprintf( checkPointMsg,
635 <           "WATER atom structures successfully sent to fortran\n" );
635 >           "WATER atom and directional structures successfully"
636 >           "sent to fortran\n" );
637    MPIcheckPoint();
638   #endif // is_mpi
639  
594 –
595 –
596 –  // now read in the directional stuff
597 –
598 – #ifdef IS_MPI
599 –  if( worldRank == 0 ) {
600 – #endif
601 –
602 –    // read in the directional types
603 –
604 –    headDirectionalType = new LinkedDirectionalType;
605 –    
606 –    fastForward( "DirectionalTypes", "initializeDirectionals" );
607 –  
608 –    // we are now at the directionalTypes section
609 –    
610 –    eof_test =  fgets( readLine, sizeof(readLine), frcFile );
611 –    lineNum++;
612 –    
613 –    
614 –    // read a line, and start parsing out the atom types
615 –
616 –    if( eof_test == NULL ){
617 –      sprintf( painCave.errMsg,
618 –               "Error in reading directionals from force file at line %d.\n",
619 –               lineNum );
620 –      painCave.isFatal = 1;
621 –      simError();
622 –    }
623 –    
624 –    // stop reading at end of file, or at next section
625 –    while( readLine[0] != '#' && eof_test != NULL ){
626 –
627 –      // toss comment lines
628 –      if( readLine[0] != '!' ){
629 –        
630 –        // the parser returns 0 if the line was blank
631 –        if( parseDirectional( readLine, lineNum, directionalInfo ) ){
632 –          headDirectionalType->add( directionalInfo );
633 –        }
634 –      }
635 –      eof_test = fgets( readLine, sizeof(readLine), frcFile );
636 –      lineNum++;
637 –    }
638 –        
639 – #ifdef IS_MPI
640 –    
641 –    // send out the linked list to all the other processes
642 –    
643 –    sprintf( checkPointMsg,
644 –             "DUFF directional structures read successfully." );
645 –    MPIcheckPoint();
646 –    
647 –    currentDirectionalType = headDirectionalType->next;
648 –    while( currentDirectionalType != NULL ){
649 –      currentDirectionalType->duplicate( directionalInfo );
650 –      sendFrcStruct( &directionalInfo, mpiDirectionalStructType );
651 –      currentDirectionalType = currentDirectionalType->next;
652 –    }
653 –    directionalInfo.last = 1;
654 –    sendFrcStruct( &directionalInfo, mpiDirectionalStructType );
655 –    
656 –  }
657 –
658 –  else{
659 –    
660 –    // listen for node 0 to send out the force params
661 –    
662 –    MPIcheckPoint();
663 –
664 –    headDirectionalType = new LinkedDirectionalType;
665 –    receiveFrcStruct( &directionalInfo, mpiDirectionalStructType );
666 –    while( !directionalInfo.last ){
667 –
668 –      headDirectionalType->add( directionalInfo );
669 –      receiveFrcStruct( &directionalInfo, mpiDirectionalStructType );
670 –    }
671 –  }
672 –
673 –  sprintf( checkPointMsg,
674 –           "WATER directional structures broadcast successfully." );
675 –  MPIcheckPoint();
676 –
677 – #endif // is_mpi
640   }
641  
642  
643   void WATER::initializeAtoms( int nAtoms, Atom** the_atoms ){
644    
645 <  int i;
645 >  int i,j,k;
646  
647    // initialize the atoms
648 <  
648 >  DirectionalAtom* dAtom;
649 >  double ji[3];
650 >  double inertialMat[3][3];
651  
652    for( i=0; i<nAtoms; i++ ){
689 –    
653      currentAtomType = headAtomType->find( the_atoms[i]->getType() );
654      if( currentAtomType == NULL ){
655        sprintf( painCave.errMsg,
# Line 695 | Line 658 | void WATER::initializeAtoms( int nAtoms, Atom** the_at
658        painCave.isFatal = 1;
659        simError();
660      }
698 –
699 –    the_atoms[i]->setisLJ( currentAtomType->isLJ);
700 –    the_atoms[i]->setisCharge( currentAtomType->isCharge);
661      the_atoms[i]->setMass( currentAtomType->mass );
702 –    the_atoms[i]->setEpslon( currentAtomType->epslon );
703 –    the_atoms[i]->setSigma( currentAtomType->sigma );
704 –    the_atoms[i]->setCharge( currentAtomType->charge );
662      the_atoms[i]->setIdent( currentAtomType->ident );
663  
664 <  }
708 < }
664 >    if( bigSigma < currentAtomType->sigma ) bigSigma = currentAtomType->sigma;
665  
666 < void WATER::initializeDirectional( int nAtoms, Atom** the_atoms ){
711 <  
712 <  int i;
666 >    the_atoms[i]->setHasCharge(currentAtomType->isCharge);
667  
668 <  // initialize the atoms
669 <  
668 >    if( currentAtomType->isDirectional ){
669 >      currentDirectionalType =
670 >        headDirectionalType->find( the_atoms[i]->getType() );
671 >      if( currentDirectionalType == NULL ){
672 >        sprintf( painCave.errMsg,
673 >                 "DirectionalType error, %s not found in force file.\n",
674 >                 the_atoms[i]->getType() );
675 >        painCave.isFatal = 1;
676 >        simError();
677 >      }
678  
679 <  for( i=0; i<nAtoms; i++ ){
680 <    
681 <    currentAtomType = headAtomType->find( the_atoms[i]->getType() );
682 <    if( currentAtomType == NULL ){
721 <      sprintf( painCave.errMsg,
722 <               "AtomType error, %s not found in force file.\n",
723 <               the_atoms[i]->getType() );
724 <      painCave.isFatal = 1;
725 <      simError();
726 <    }
679 >      // zero out the moments of inertia matrix
680 >      for( j=0; j<3; j++ )
681 >        for( k=0; k<3; k++ )
682 >          inertialMat[j][k] = 0.0;
683  
684 <    the_atoms[i]->setisLJ( currentAtomType->isLJ);
685 <    the_atoms[i]->setisCharge( currentAtomType->isCharge);
686 <    the_atoms[i]->setMass( currentAtomType->mass );
687 <    the_atoms[i]->setEpslon( currentAtomType->epslon );
688 <    the_atoms[i]->setSigma( currentAtomType->sigma );
689 <    the_atoms[i]->setCharge( currentAtomType->charge );
690 <    the_atoms[i]->setIdent( currentAtomType->ident );
684 >      // load the force file moments of inertia
685 >      inertialMat[0][0] = currentDirectionalType->Ixx;
686 >      inertialMat[1][1] = currentDirectionalType->Iyy;
687 >      inertialMat[2][2] = currentDirectionalType->Izz;
688 >
689 >      dAtom = (DirectionalAtom *) the_atoms[i];
690 >      dAtom->setHasDipole( currentDirectionalType->isDipole );
691  
692 +      ji[0] = 0.0;
693 +      ji[1] = 0.0;
694 +      ji[2] = 0.0;
695 +      dAtom->setJ( ji );
696 +      dAtom->setI( inertialMat );
697 +
698 +      entry_plug->n_dipoles++;
699 +    }
700    }
701   }
702  
# Line 828 | Line 792 | void WATER::sectionSearch( char* secHead, char* stopTe
792    int foundSection = 0;
793    int foundText = 0;
794    char* the_token;
795 <  tempPos = new fpos_t;
795 >  fpos_t *tempPos;
796  
797    rewind( frcFile );
798    lineNum = 0;
799 +  tempPos = new fpos_t;
800  
801    eof_test = fgets( readLine, sizeof(readLine), frcFile );
802    lineNum++;
# Line 843 | Line 808 | void WATER::sectionSearch( char* secHead, char* stopTe
808      simError();
809    }
810    
846 –  
811    while( !foundSection ){
812      while( eof_test != NULL && readLine[0] != '#' ){
813        eof_test = fgets( readLine, sizeof(readLine), frcFile );
# Line 858 | Line 822 | void WATER::sectionSearch( char* secHead, char* stopTe
822        painCave.isFatal = 1;
823        simError();
824      }
861 –    
825      the_token = strtok( readLine, " ,;\t#\n" );
826      foundSection = !strcmp( secHead, the_token );
827      
865 –    
828      if( !foundSection ){
829        eof_test = fgets( readLine, sizeof(readLine), frcFile );
830        lineNum++;
# Line 877 | Line 839 | void WATER::sectionSearch( char* secHead, char* stopTe
839          simError();
840        }
841      }
842 <  }  
842 >  }
843  
844    while( !foundText ){
845 <    if( !foundText ){
846 <      fgetpos( frcFile, tempPos );
847 <      eof_test = fgets( readLine, sizeof(readLine), frcFile );
848 <      lineNum++;
849 <      
850 <      if( eof_test == NULL ){
851 <        sprintf( painCave.errMsg,
852 <                 "Error fast forwarding force file for %s at "
853 <                 "line %d: file ended unexpectedly.\n",
854 <                 searchOwner,
855 <                 lineNum );
856 <        painCave.isFatal = 1;
845 >    
846 >    fgetpos( frcFile, tempPos );
847 >    eof_test = fgets( readLine, sizeof(readLine), frcFile );
848 >    lineNum++;
849 >    
850 >    if( eof_test == NULL ){
851 >      sprintf( painCave.errMsg,
852 >               "Error fast forwarding force file for %s at "
853 >               "line %d: file ended unexpectedly.\n",
854 >               searchOwner,
855 >               lineNum );
856 >      painCave.isFatal = 1;
857          simError();
858 <      }
897 <    }
858 >    }
859      
860      the_token = strtok( readLine, " ,;\t#\n" );
861 <    foundText = !strcmp( stopText, the_token );
861 >    if( the_token != NULL ){
862 >      foundText = !strcmp( stopText, the_token );
863 >    }
864    }  
865 <  
866 <  fsetPos( frcFile, tempPos );
865 >  fsetpos( frcFile, tempPos );
866 >  eof_test = fgets( readLine, sizeof(readLine), frcFile );
867 >  lineNum++;
868   }
869  
870  
# Line 1015 | Line 979 | int WATER_NS::parseDirectional( char *lineBuffer, int
979        simError();
980      }
981  
982 <    info.I_xx = atof( the_token );
982 >    info.Ixx = atof( the_token );
983      
984      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
985        sprintf( painCave.errMsg,
# Line 1024 | Line 988 | int WATER_NS::parseDirectional( char *lineBuffer, int
988        simError();
989      }
990  
991 <    info.I_yy = atof( the_token );
991 >    info.Iyy = atof( the_token );
992      
993      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
994        sprintf( painCave.errMsg,
# Line 1033 | Line 997 | int WATER_NS::parseDirectional( char *lineBuffer, int
997        simError();
998      }
999  
1000 <    info.I_zz = atof( the_token );
1000 >    info.Izz = atof( the_token );
1001      
1002      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
1003        sprintf( painCave.errMsg,

Diff Legend

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