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

Comparing trunk/OOPSE/libmdtools/DumpReader.cpp (file contents):
Revision 646 by mmeineke, Tue Jul 22 20:05:30 2003 UTC vs.
Revision 1097 by gezelter, Mon Apr 12 20:32:20 2004 UTC

# Line 1 | Line 1
1 + #define _LARGEFILE_SOURCE64
2   #define _FILE_OFFSET_BITS 64
3  
4 + #include <sys/types.h>
5 + #include <sys/stat.h>
6 +
7   #include <iostream>
8 < #include <cmath>
5 < #include <vector>
8 > #include <math.h>
9  
10   #include <stdio.h>
11   #include <stdlib.h>
12   #include <string.h>
10 – #include <unistd.h>
11 – #include <sys/types.h>
12 – #include <sys/stat.h>
13  
14 +
15   #include "ReadWrite.hpp"
16   #include "simError.h"
17  
# Line 19 | Line 20
20   #include "mpiSimulation.hpp"
21   #define TAKE_THIS_TAG_CHAR 0
22   #define TAKE_THIS_TAG_INT 1
23 + #endif // is_mpi
24  
25   namespace dumpRead{
26 +
27 + #ifdef IS_MPI
28    void nodeZeroError( void );
29    void anonymousNodeDie( void );
30 <
30 > #endif // is_mpi
31    
28 –  class FilePos{
29 –  public:
30 –    
31 –
32 –  private:
33 –    
34 –
35 –  };
36 –
37 –  vector<FilePos> frameStart;
32   }
33  
34   using namespace dumpRead;
35  
42 – #endif // is_mpi
36  
37 < DumpReader :: DumpReader( char *in_name ){
37 > DumpReader :: DumpReader(const char *in_name ){
38 >
39 >  isScanned = false;
40 >  headFP = new FilePos;
41 >
42   #ifdef IS_MPI
43    if (worldRank == 0) {
44   #endif
45  
46 <  c_in_file = fopen(in_name, "r");
47 <  if(c_in_file == NULL){
46 >  inFile = fopen(in_name, "r");
47 >  if(inFile == NULL){
48      sprintf(painCave.errMsg,
49              "Cannot open file: %s\n", in_name);
50      painCave.isFatal = 1;
51      simError();
52    }
53    
54 <  strcpy( c_in_name, in_name);
54 >  strcpy( inName, in_name);
55   #ifdef IS_MPI
56    }
57    strcpy( checkPointMsg, "Dump file opened for reading successfully." );
# Line 68 | Line 65 | DumpReader :: ~DumpReader( ){
65    if (worldRank == 0) {
66   #endif
67    int error;
68 <  error = fclose( c_in_file );
68 >  error = fclose( inFile );
69    if( error ){
70      sprintf( painCave.errMsg,
71 <             "Error closing %s\n", c_in_name );
71 >             "Error closing %s\n", inName );
72      simError();
73    }
74   #ifdef IS_MPI
# Line 83 | Line 80 | DumpReader :: ~DumpReader( ){
80    return;
81   }
82  
83 + int DumpReader::getNframes( void ){
84  
85 +  if( !isScanned ) scanFile();
86 +  return nFrames;
87 + }
88  
89 < void DumpReader :: getFrame( SimInfo* the_simnfo, int whichFrame){
89 > void DumpReader::scanFile( void ){
90  
91 +  int vectorSize;
92 +  int i, j, k;
93 +  int lineNum = 0;
94 +  char readBuffer[2000];
95 +  char* foo;
96 +  fpos_t *currPos;
97 +  double time;
98 +
99 +  FilePos *currFP;
100 +
101 +
102 + #ifdef IS_MPI
103 +  if( worldRank == 0 ){
104 + #endif // is_mpi
105 +    
106 +    rewind( inFile );
107 +    
108 +    currPos = new fpos_t;
109 +    fgetpos( inFile, currPos );
110 +    fgets( readBuffer, sizeof( readBuffer ), inFile );
111 +    lineNum++;
112 +    if( feof( inFile ) ){
113 +      sprintf( painCave.errMsg,
114 +               "File \"%s\" ended unexpectedly at line %d\n",
115 +               inName,
116 +               lineNum );
117 +      painCave.isFatal = 1;
118 +      simError();
119 +    }
120 +    
121 +    nFrames = 0;
122 +    while( !feof( inFile ) ){
123 +
124 +      headFP->add( currPos );
125 +      nFrames++;
126 +
127 +      i = atoi(readBuffer);
128 +      
129 +      fgets( readBuffer, sizeof( readBuffer ), inFile );
130 +      lineNum++;    
131 +      if( feof( inFile ) ){
132 +        sprintf( painCave.errMsg,
133 +                 "File \"%s\" ended unexpectedly at line %d\n",
134 +                 inName,
135 +                 lineNum );
136 +        painCave.isFatal = 1;
137 +        simError();
138 +      }
139 +      
140 + //       if(outTime){
141 + //      foo = strtok( readBuffer, " ,;\t" );
142 + //      time = atof( foo );
143 + //       }
144 +      
145 +      for(j=0; j<i; j++){
146 +        
147 +        fgets( readBuffer, sizeof( readBuffer ), inFile );
148 +        lineNum++;    
149 +        if( feof( inFile ) ){
150 +          sprintf( painCave.errMsg,
151 +                   "File \"%s\" ended unexpectedly at line %d,"
152 +                   " with atom %d\n",
153 +                   inName,
154 +                   lineNum,
155 +                   j );
156 +          painCave.isFatal = 1;
157 +          simError();
158 +        }
159 +        
160 +      }
161 +      
162 +      currPos = new fpos_t;
163 +      fgetpos( inFile, currPos );
164 +      fgets( readBuffer, sizeof( readBuffer ), inFile );
165 +      lineNum++;
166 +    }
167 +    
168 +    delete currPos;
169 +    rewind( inFile );
170 +    
171 +    frameStart = new FilePos*[nFrames];
172 +    currFP = headFP;
173 +    for(i=0; i<nFrames; i++){
174 +      
175 +      currFP = currFP->getNext();
176 +      if( currFP == NULL ){
177 +        sprintf( painCave.errMsg,
178 +                 "DumpReader error: scanFile FilePos mismatch at "
179 +                 "nFrames = %d\n",
180 +                 i );
181 +        painCave.isFatal = 1;
182 +        simError();
183 +      }
184 +      
185 +      frameStart[i] = currFP;
186 +    }
187 +
188 +    isScanned = true;
189 +
190 + #ifdef IS_MPI
191 +  }
192 +  strcpy( checkPointMsg, "Successfully scanned DumpFile\n" );
193 +  MPIcheckPoint();
194 + #endif // is_mpi
195 + }
196 +
197 + void DumpReader :: readFrame( SimInfo* the_simnfo, int whichFrame){
198 +
199 +  simnfo = the_simnfo;
200 +
201 +  this->readSet( whichFrame );
202 + }
203 +
204 +
205 +
206 + void DumpReader :: readSet( int whichFrame ){
207 +
208    int i, j, done, which_node, which_atom; // loop counter
209  
210    const int BUFFERSIZE = 2000; // size of the read buffer
# Line 101 | Line 219 | void DumpReader :: getFrame( SimInfo* the_simnfo, int
219    int procIndex;
220    double boxMat[9];
221    double theBoxMat3[3][3];
222 +  double time;
223  
224 <  simnfo = the_simnfo;
225 <
224 >  fpos_t *framePos;
225 >  framePos = frameStart[whichFrame]->getPos();
226 >  
227   #ifndef IS_MPI
228 <  eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
228 >  
229 >  fsetpos(inFile, framePos);
230 >  
231 >
232 >  eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
233    if( eof_test == NULL ){
234      sprintf( painCave.errMsg,
235               "DumpReader error: error reading 1st line of \"%s\"\n",
236 <             c_in_name );
236 >             inName );
237      painCave.isFatal = 1;
238      simError();
239    }
# Line 123 | Line 247 | void DumpReader :: getFrame( SimInfo* the_simnfo, int
247      sprintf( painCave.errMsg,
248               "DumpReader error. %s n_atoms, %d, "
249               "does not match the BASS file's n_atoms, %d.\n",
250 <             c_in_name, n_atoms, simnfo->n_atoms );
250 >             inName, n_atoms, simnfo->n_atoms );
251      painCave.isFatal = 1;
252      simError();
253    }
254    
255    //read the box mat from the comment line
256    
257 <  eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
257 >  eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
258    if(eof_test == NULL){
259      sprintf( painCave.errMsg,
260 <             "error in reading commment in %s\n", c_in_name);
260 >             "error in reading commment in %s\n", inName);
261      painCave.isFatal = 1;
262      simError();
263    }
# Line 156 | Line 280 | void DumpReader :: getFrame( SimInfo* the_simnfo, int
280  
281    for( i=0; i < n_atoms; i++){
282      
283 <    eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
283 >    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
284      if(eof_test == NULL){
285        sprintf(painCave.errMsg,
286                "error in reading file %s\n"
287                "natoms  = %d; index = %d\n"
288                "error reading the line from the file.\n",
289 <              c_in_name, n_atoms, i );
289 >              inName, n_atoms, i );
290        painCave.isFatal = 1;
291        simError();
292      }
# Line 192 | Line 316 | void DumpReader :: getFrame( SimInfo* the_simnfo, int
316    
317    haveError = 0;
318    if (worldRank == 0) {
319 <
320 <    eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
319 >    fsetpos(inFile, framePos);
320 >    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
321      if( eof_test == NULL ){
322        sprintf( painCave.errMsg,
323 <               "Error reading 1st line of %d \n ",c_in_name);
323 >               "Error reading 1st line of %d \n ",inName);
324        haveError = 1;
325        simError();
326      }
# Line 213 | Line 337 | void DumpReader :: getFrame( SimInfo* the_simnfo, int
337        sprintf( painCave.errMsg,
338                 "Initialize from File error. %s n_atoms, %d, "
339                 "does not match the BASS file's n_atoms, %d.\n",
340 <               c_in_name, n_atoms, simnfo->n_atoms );
340 >               inName, n_atoms, simnfo->n_atoms );
341        haveError= 1;
342        simError();
343      }
344      
345      //read the time and boxMat from the comment line
346      
347 <    eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
347 >    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
348      if(eof_test == NULL){
349        sprintf( painCave.errMsg,
350 <               "error in reading commment in %s\n", c_in_name);
350 >               "error in reading commment in %s\n", inName);
351        haveError = 1;
352        simError();
353      }
# Line 235 | Line 359 | void DumpReader :: getFrame( SimInfo* the_simnfo, int
359        simError();
360      }
361  
362 <    MPI_Bcast(time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD );
362 >    MPI_Bcast(&time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD );
363      
364      MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD );
365      
# Line 243 | Line 367 | void DumpReader :: getFrame( SimInfo* the_simnfo, int
367      
368      for (i=0 ; i < mpiSim->getTotAtoms(); i++) {
369        
370 <      eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
370 >      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
371        if(eof_test == NULL){
372          sprintf(painCave.errMsg,
373                  "error in reading file %s\n"
374                  "natoms  = %d; index = %d\n"
375                  "error reading the line from the file.\n",
376 <                c_in_name, n_atoms, i );
376 >                inName, n_atoms, i );
377          haveError= 1;
378          simError();
379        }
# Line 291 | Line 415 | void DumpReader :: getFrame( SimInfo* the_simnfo, int
415      
416    } else {
417      
418 <    MPI_Bcast(time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
418 >    MPI_Bcast(&time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
419      MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD);
420  
421      done = 0;
# Line 341 | Line 465 | char* DumpReader::parseDumpLine(char* readLine, int gl
465  
466    char *foo; // the pointer to the current string token
467    
468 <  double rx, ry, rz; // position place holders
469 <  double vx, vy, vz; // velocity placeholders
470 <  double q[4]; // the quaternions
471 <  double jx, jy, jz; // angular velocity placeholders;
468 >  double pos[3];        // position place holders
469 >  double vel[3];        // velocity placeholders
470 >  double q[4];          // the quaternions
471 >  double ji[3];         // angular velocity placeholders;
472    double qSqr, qLength; // needed to normalize the quaternion vector.
473    
474    Atom **atoms = simnfo->atoms;
# Line 362 | Line 486 | char* DumpReader::parseDumpLine(char* readLine, int gl
486      sprintf( painCave.errMsg,
487               "Initialize from file error. Atom at index %d "
488               "in file %s does not exist on processor %d .\n",
489 <             globalIndex, c_in_name, mpiSim->getMyNode() );
489 >             globalIndex, inName, mpiSim->getMyNode() );
490      return strdup( painCave.errMsg );
491    }  
492   #else
# Line 373 | Line 497 | char* DumpReader::parseDumpLine(char* readLine, int gl
497    // set the string tokenizer
498    
499    foo = strtok(readLine, " ,;\t");
500 <  
500 >  atoms[atomIndex]->setType(foo);
501    // check the atom name to the current atom
502    
503 <  if( strcmp( foo, atoms[atomIndex]->getType() ) ){
504 <    sprintf( painCave.errMsg,
505 <             "Initialize from file error. Atom %s at index %d "
506 <             "in file %s does not"
507 <             " match the BASS atom %s.\n",
508 <             foo, atomIndex, c_in_name, atoms[atomIndex]->getType() );
509 <    return strdup( painCave.errMsg );
510 <  }
503 >  //if( strcmp( foo, atoms[atomIndex]->getType() ) ){
504 >  //  sprintf( painCave.errMsg,
505 >  //    "Initialize from file error. Atom %s at index %d "
506 >  //     "in file %s does not"
507 >  //     " match the BASS atom %s.\n",
508 >  //     foo, atomIndex, inName, atoms[atomIndex]->getType() );
509 >  //  return strdup( painCave.errMsg );
510 >  //}
511      
512    // get the positions
513  
# Line 392 | Line 516 | char* DumpReader::parseDumpLine(char* readLine, int gl
516      sprintf( painCave.errMsg,
517               "error in reading postition x from %s\n"
518               "natoms  = %d, index = %d\n",
519 <             c_in_name, n_atoms, atomIndex );
519 >             inName, n_atoms, atomIndex );
520      return strdup( painCave.errMsg );
521    }
522 <  rx = atof( foo );
522 >  pos[0] = atof( foo );
523    
524    foo = strtok(NULL, " ,;\t");
525    if(foo == NULL){
526      sprintf( painCave.errMsg,
527               "error in reading postition y from %s\n"
528               "natoms  = %d, index = %d\n",
529 <             c_in_name, n_atoms, atomIndex );
529 >             inName, n_atoms, atomIndex );
530      return strdup( painCave.errMsg );
531    }
532 <  ry = atof( foo );
532 >  pos[1] = atof( foo );
533      
534    foo = strtok(NULL, " ,;\t");
535    if(foo == NULL){
536      sprintf( painCave.errMsg,
537               "error in reading postition z from %s\n"
538               "natoms  = %d, index = %d\n",
539 <             c_in_name, n_atoms, atomIndex );
539 >             inName, n_atoms, atomIndex );
540      return strdup( painCave.errMsg );
541    }
542 <  rz = atof( foo );    
542 >  pos[2] = atof( foo );    
543  
544  
545    // get the velocities
# Line 425 | Line 549 | char* DumpReader::parseDumpLine(char* readLine, int gl
549      sprintf( painCave.errMsg,
550               "error in reading velocity x from %s\n"
551               "natoms  = %d, index = %d\n",
552 <             c_in_name, n_atoms, atomIndex );
552 >             inName, n_atoms, atomIndex );
553      return strdup( painCave.errMsg );
554    }
555 <  vx = atof( foo );
555 >  vel[0] = atof( foo );
556      
557    foo = strtok(NULL, " ,;\t");
558    if(foo == NULL){
559      sprintf( painCave.errMsg,
560               "error in reading velocity y from %s\n"
561               "natoms  = %d, index = %d\n",
562 <             c_in_name, n_atoms, atomIndex );
562 >             inName, n_atoms, atomIndex );
563      return strdup( painCave.errMsg );
564    }
565 <  vy = atof( foo );
565 >  vel[1] = atof( foo );
566      
567    foo = strtok(NULL, " ,;\t");
568    if(foo == NULL){
569      sprintf( painCave.errMsg,
570               "error in reading velocity z from %s\n"
571               "natoms  = %d, index = %d\n",
572 <             c_in_name, n_atoms, atomIndex );
572 >             inName, n_atoms, atomIndex );
573      return strdup( painCave.errMsg );
574    }
575 <  vz = atof( foo );
575 >  vel[2] = atof( foo );
576      
577      
578    // get the quaternions
# Line 460 | Line 584 | char* DumpReader::parseDumpLine(char* readLine, int gl
584        sprintf(painCave.errMsg,
585                "error in reading quaternion 0 from %s\n"
586                "natoms  = %d, index = %d\n",
587 <              c_in_name, n_atoms, atomIndex );
587 >              inName, n_atoms, atomIndex );
588        return strdup( painCave.errMsg );
589      }
590      q[0] = atof( foo );
# Line 470 | Line 594 | char* DumpReader::parseDumpLine(char* readLine, int gl
594        sprintf( painCave.errMsg,
595                 "error in reading quaternion 1 from %s\n"
596                 "natoms  = %d, index = %d\n",
597 <               c_in_name, n_atoms, atomIndex );
597 >               inName, n_atoms, atomIndex );
598        return strdup( painCave.errMsg );
599      }
600      q[1] = atof( foo );
# Line 480 | Line 604 | char* DumpReader::parseDumpLine(char* readLine, int gl
604        sprintf( painCave.errMsg,
605                 "error in reading quaternion 2 from %s\n"
606                 "natoms  = %d, index = %d\n",
607 <               c_in_name, n_atoms, atomIndex );
607 >               inName, n_atoms, atomIndex );
608        return strdup( painCave.errMsg );
609      }
610      q[2] = atof( foo );
# Line 490 | Line 614 | char* DumpReader::parseDumpLine(char* readLine, int gl
614        sprintf( painCave.errMsg,
615                 "error in reading quaternion 3 from %s\n"
616                 "natoms  = %d, index = %d\n",
617 <               c_in_name, n_atoms, atomIndex );
617 >               inName, n_atoms, atomIndex );
618        return strdup( painCave.errMsg );
619      }
620      q[3] = atof( foo );
# Line 502 | Line 626 | char* DumpReader::parseDumpLine(char* readLine, int gl
626        sprintf( painCave.errMsg,
627                 "error in reading angular momentum jx from %s\n"
628                 "natoms  = %d, index = %d\n",
629 <               c_in_name, n_atoms, atomIndex );
629 >               inName, n_atoms, atomIndex );
630        return strdup( painCave.errMsg );
631      }
632 <    jx = atof( foo );
632 >    ji[0] = atof( foo );
633        
634      foo = strtok(NULL, " ,;\t");
635      if(foo == NULL){
636        sprintf( painCave.errMsg,
637                 "error in reading angular momentum jy from %s\n"
638                 "natoms  = %d, index = %d\n",
639 <               c_in_name, n_atoms, atomIndex );
639 >               inName, n_atoms, atomIndex );
640        return strdup( painCave.errMsg );
641      }
642 <    jy = atof(foo );
642 >    ji[1] = atof(foo );
643        
644      foo = strtok(NULL, " ,;\t");
645      if(foo == NULL){
646        sprintf( painCave.errMsg,
647                 "error in reading angular momentum jz from %s\n"
648                 "natoms  = %d, index = %d\n",
649 <               c_in_name, n_atoms, atomIndex );
649 >               inName, n_atoms, atomIndex );
650        return strdup( painCave.errMsg );
651      }
652 <    jz = atof( foo );
652 >    ji[2] = atof( foo );
653        
654      dAtom = ( DirectionalAtom* )atoms[atomIndex];
655  
# Line 543 | Line 667 | char* DumpReader::parseDumpLine(char* readLine, int gl
667        
668      // add the angular velocities
669  
670 <    dAtom->setJx( jx );
547 <    dAtom->setJy( jy );
548 <    dAtom->setJz( jz );
670 >    dAtom->setJ( ji );
671    }
672      
673    // add the positions and velocities to the atom
552 –    
553 –  atoms[atomIndex]->setX( rx );
554 –  atoms[atomIndex]->setY( ry );
555 –  atoms[atomIndex]->setZ( rz );
556 –    
557 –  atoms[atomIndex]->set_vx( vx );
558 –  atoms[atomIndex]->set_vy( vy );
559 –  atoms[atomIndex]->set_vz( vz );
674  
675 +  atoms[atomIndex]->setPos( pos );
676 +  atoms[atomIndex]->setVel( vel );
677 +
678    return NULL;
679   }
680  
681  
682 < char* DumpReader::parseCommentLine(char* readLine, double time,
682 > char* DumpReader::parseCommentLine(char* readLine, double &time,
683                                     double boxMat[9]){
684  
685    char *foo; // the pointer to the current string token
686    int j;
687 +  double chi, integralOfChidt;
688 +  double eta[9];
689  
690    // set the string tokenizer
691    
# Line 574 | Line 693 | char* DumpReader::parseCommentLine(char* readLine, dou
693    if(foo == NULL){
694      sprintf( painCave.errMsg,
695               "error in reading time from %s\n",
696 <             c_in_name );
696 >             inName );
697      return strdup( painCave.errMsg );
698    }
699    time = atof( foo );
# Line 585 | Line 704 | char* DumpReader::parseCommentLine(char* readLine, dou
704    if(foo == NULL){
705      sprintf( painCave.errMsg,
706               "error in reading Hx[0] from %s\n",
707 <             c_in_name );
707 >             inName );
708      return strdup( painCave.errMsg );
709    }
710    boxMat[0] = atof( foo );
# Line 594 | Line 713 | char* DumpReader::parseCommentLine(char* readLine, dou
713    if(foo == NULL){
714      sprintf( painCave.errMsg,
715               "error in reading Hx[1] from %s\n",
716 <             c_in_name );
716 >             inName );
717      return strdup( painCave.errMsg );
718    }
719    boxMat[1] = atof( foo );
# Line 603 | Line 722 | char* DumpReader::parseCommentLine(char* readLine, dou
722    if(foo == NULL){
723      sprintf( painCave.errMsg,
724               "error in reading Hx[2] from %s\n",
725 <             c_in_name );
725 >             inName );
726      return strdup( painCave.errMsg );
727    }
728    boxMat[2] = atof( foo );    
# Line 614 | Line 733 | char* DumpReader::parseCommentLine(char* readLine, dou
733    if(foo == NULL){
734      sprintf( painCave.errMsg,
735               "error in reading Hy[0] from %s\n",
736 <             c_in_name );
736 >             inName );
737      return strdup( painCave.errMsg );
738    }
739    boxMat[3] = atof( foo );
# Line 623 | Line 742 | char* DumpReader::parseCommentLine(char* readLine, dou
742    if(foo == NULL){
743      sprintf( painCave.errMsg,
744               "error in reading Hy[1] from %s\n",
745 <             c_in_name );
745 >             inName );
746      return strdup( painCave.errMsg );
747    }
748    boxMat[4] = atof( foo );
# Line 632 | Line 751 | char* DumpReader::parseCommentLine(char* readLine, dou
751    if(foo == NULL){
752      sprintf( painCave.errMsg,
753               "error in reading Hy[2] from %s\n",
754 <             c_in_name );
754 >             inName );
755      return strdup( painCave.errMsg );
756    }
757    boxMat[5] = atof( foo );    
# Line 643 | Line 762 | char* DumpReader::parseCommentLine(char* readLine, dou
762    if(foo == NULL){
763      sprintf( painCave.errMsg,
764               "error in reading Hz[0] from %s\n",
765 <             c_in_name );
765 >             inName );
766      return strdup( painCave.errMsg );
767    }
768    boxMat[6] = atof( foo );
# Line 652 | Line 771 | char* DumpReader::parseCommentLine(char* readLine, dou
771    if(foo == NULL){
772      sprintf( painCave.errMsg,
773               "error in reading Hz[1] from %s\n",
774 <             c_in_name );
774 >             inName );
775      return strdup( painCave.errMsg );
776    }
777    boxMat[7] = atof( foo );
# Line 661 | Line 780 | char* DumpReader::parseCommentLine(char* readLine, dou
780    if(foo == NULL){
781      sprintf( painCave.errMsg,
782               "error in reading Hz[2] from %s\n",
783 <             c_in_name );
783 >             inName );
784      return strdup( painCave.errMsg );
785    }
786    boxMat[8] = atof( foo );    
787  
788    return NULL;
789 +
790 +  //get chi and integralOfChidt, they should appear by pair
791 +  foo = strtok(NULL, " ,;\t\n");
792 +  if(foo != NULL){
793 +    chi = atof(foo);
794 +    
795 +    foo = strtok(NULL, " ,;\t\n");
796 +    if(foo == NULL){
797 +      sprintf( painCave.errMsg,
798 +               "chi and integralOfChidt should appear by pair in %s\n", inName );
799 +      return strdup( painCave.errMsg );
800 +    }
801 +    integralOfChidt = atof( foo );
802 +    
803 +    //push chi and integralOfChidt into SimInfo::properties which can be
804 +    //retrieved by integrator later
805 +    DoubleData* chiValue = new DoubleData();
806 +    chiValue->setID(CHIVALUE_ID);
807 +    chiValue->setData(chi);
808 +    simnfo->addProperty(chiValue);
809 +    
810 +    DoubleData* integralOfChidtValue = new DoubleData();
811 +    integralOfChidtValue->setID(INTEGRALOFCHIDT_ID);
812 +    integralOfChidtValue->setData(integralOfChidt);
813 +    simnfo->addProperty(integralOfChidtValue);
814 +    
815 +  }
816 +  else
817 +    return NULL;
818 +  
819 +  //get eta
820 +  for(int i = 0 ; i < 9; i++){
821 +    foo = strtok(NULL, " ,;\t");
822 +    if(foo == NULL){
823 +      sprintf( painCave.errMsg,
824 +               "error in reading eta[%d] from %s\n", i, inName );
825 +      return strdup( painCave.errMsg );
826 +    }
827 +    eta[i] = atof( foo );
828 +  }
829 +  
830 +  //push eta into SimInfo::properties which can be
831 +  //retrieved by integrator later
832 +  //simnfo->setBoxM( theBoxMat3 );
833 +  DoubleArrayData* etaValue = new DoubleArrayData();
834 +  etaValue->setID(ETAVALUE_ID);
835 +  etaValue->setData(eta, 9);
836 +  simnfo->addProperty(etaValue);
837 +  
838 +  
839 +  return NULL;
840 +  
841 +  
842 +
843   }
844  
845  
# Line 674 | Line 847 | void initFile::nodeZeroError( void ){
847  
848   // a couple of functions to let us escape the read loop
849  
850 < void initFile::nodeZeroError( void ){
850 > void dumpRead::nodeZeroError( void ){
851    int j, myStatus;
852    
853    myStatus = 0;
# Line 689 | Line 862 | void initFile::anonymousNodeDie( void ){
862    
863   }
864  
865 < void initFile::anonymousNodeDie( void ){
865 > void dumpRead::anonymousNodeDie( void ){
866  
867    MPI_Finalize();
868    exit (0);

Diff Legend

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