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 656 by mmeineke, Tue Jul 29 16:32:37 2003 UTC vs.
Revision 1268 by tim, Fri Jun 11 17:16:21 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 21 | Line 22 | namespace dumpRead{
22   #define TAKE_THIS_TAG_INT 1
23   #endif // is_mpi
24  
24 – namespace dumpRead{
25  
26 < #ifdef IS_MPI
27 <  void nodeZeroError( void );
28 <  void anonymousNodeDie( void );
29 < #endif // is_mpi
30 <  
31 <  class FilePos{
32 <    
33 <  public:
34 <    FilePos(){ myPos = NULL; }
35 <    FilePos( fpos_t* thePos ) { myPos = thePos; }
36 <    ~FilePos(){ if( myPos != NULL ) delete myPos; }
26 > DumpReader :: DumpReader(const char *in_name ){
27  
38 –    FilePos &operator=(fpos_t *thePos){ myPos = thePos; return *this; }
39 –
40 –    void setPos( fpos_t *thePos ){ myPos = thePos; }
41 –    fpos_t *getPos( void ){ return myPos; }
42 –  
43 –  private:
44 –    
45 –    fpos_t *myPos
46 –
47 –  };
48 –
49 –  bool operator<(FilePos a, FilePos b){
50 –    return (a.getPos())->__pos < (b.getPos())->__pos; }
51 –
52 –  bool operator==(FilePos a, FilePos b){
53 –    return (a.getPos())->__pos == (b.getPos())->__pos; }
54 –
55 –  vector<FilePos> frameStart;
56 – }
57 –
58 – using namespace dumpRead;
59 –
60 –
61 – DumpReader :: DumpReader( char *in_name ){
62 –
28    isScanned = false;
29  
30   #ifdef IS_MPI
# Line 74 | Line 39 | DumpReader :: DumpReader( char *in_name ){
39      simError();
40    }
41    
42 <  strcpy( inName, in_name);
42 >  inFileName = in_name;
43   #ifdef IS_MPI
44    }
45    strcpy( checkPointMsg, "Dump file opened for reading successfully." );
# Line 87 | Line 52 | DumpReader :: ~DumpReader( ){
52   #ifdef IS_MPI
53    if (worldRank == 0) {
54   #endif
55 +  vector<fpos_t*>::iterator i;
56 +
57    int error;
58    error = fclose( inFile );
59    if( error ){
60      sprintf( painCave.errMsg,
61 <             "Error closing %s\n", inName );
61 >             "Error closing %s\n", inFileName.c_str());
62      simError();
63    }
64 +
65 +  for(i = framePos.begin(); i != framePos.end(); ++i)
66 +    delete *i;
67 +  framePos.clear();
68 +  
69   #ifdef IS_MPI
70    }
71    strcpy( checkPointMsg, "Dump file closed successfully." );
# Line 105 | Line 77 | int DumpReader::getNframes( void ){
77  
78   int DumpReader::getNframes( void ){
79  
80 <  if( !isScanned ) scanFile();
81 <  return nFrames;
80 >  if( !isScanned )
81 >    scanFile();
82 >  return framePos.size();
83   }
84  
85   void DumpReader::scanFile( void ){
86  
87 <  int vectorSize;
115 <  int i, j, k;
87 >  int i, j;
88    int lineNum = 0;
89    char readBuffer[2000];
118 –  char* foo;
90    fpos_t *currPos;
91  
92   #ifdef IS_MPI
# Line 126 | Line 97 | void DumpReader::scanFile( void ){
97      
98      currPos = new fpos_t;
99      fgetpos( inFile, currPos );
100 <    fgets( readBuffer, sizeof( readBuffer ), in_file );
100 >    fgets( readBuffer, sizeof( readBuffer ), inFile );
101      lineNum++;
102 <    if( feof( in_file ) ){
102 >    if( feof( inFile ) ){
103        sprintf( painCave.errMsg,
104                 "File \"%s\" ended unexpectedly at line %d\n",
105 <               inName,
105 >               inFileName.c_str(),
106                 lineNum );
107        painCave.isFatal = 1;
108        simError();
109      }
110 <    
111 <    while( !feof( in_file ) ){
110 >
111 >    while( !feof( inFile ) ){
112        
113 <      frameStart.push_back( FilePos( currPos ) );
113 >      framePos.push_back(currPos);
114 >
115        i = atoi(readBuffer);
116        
117 <      fgets( readBuffer, sizeof( readBuffer ), in_file );
117 >      fgets( readBuffer, sizeof( readBuffer ), inFile );
118        lineNum++;    
119 <      if( feof( in_file ) ){
119 >      if( feof( inFile ) ){
120          sprintf( painCave.errMsg,
121                   "File \"%s\" ended unexpectedly at line %d\n",
122 <                 inName,
122 >                 inFileName.c_str(),
123                   lineNum );
124          painCave.isFatal = 1;
125          simError();
126        }
127 <      
156 <      if(outTime){
157 <        foo = strtok( readBuffer, " ,;\t" );
158 <        time = atof( foo );
159 <      }
160 <      
127 >            
128        for(j=0; j<i; j++){
129          
130 <        fgets( readBuffer, sizeof( readBuffer ), in_file );
130 >        fgets( readBuffer, sizeof( readBuffer ), inFile );
131          lineNum++;    
132 <        if( feof( in_file ) ){
132 >        if( feof( inFile ) ){
133            sprintf( painCave.errMsg,
134                     "File \"%s\" ended unexpectedly at line %d,"
135                     " with atom %d\n",
136 <                   inName,
136 >                   inFileName.c_str(),
137                     lineNum,
138                     j );
139            painCave.isFatal = 1;
# Line 177 | Line 144 | void DumpReader::scanFile( void ){
144        
145        currPos = new fpos_t;
146        fgetpos( inFile, currPos );
147 <      fgets( readBuffer, sizeof( readBuffer ), in_file );
147 >      fgets( readBuffer, sizeof( readBuffer ), inFile );
148        lineNum++;
149      }
150      
151      delete currPos;
185 –    vectorSize = frameStart.size();
152      rewind( inFile );
153 <    
153 >    
154 >    isScanned = true;
155 >
156   #ifdef IS_MPI
157    }
158    strcpy( checkPointMsg, "Successfully scanned DumpFile\n" );
159    MPIcheckPoint();
160   #endif // is_mpi
193 –
194 –  nFrames = vectorSize;
195 –  isScanned = true;
161   }
162  
163   void DumpReader :: readFrame( SimInfo* the_simnfo, int whichFrame){
# Line 206 | Line 171 | void DumpReader :: readSet( int whichFrame ){
171  
172   void DumpReader :: readSet( int whichFrame ){
173  
174 <  int i, j, done, which_node, which_atom; // loop counter
174 >  int i;
175 >  unsigned int j;
176  
211 –  const int BUFFERSIZE = 2000; // size of the read buffer
212 –  int n_atoms; // the number of atoms
213 –  char read_buffer[BUFFERSIZE]; //the line buffer for reading
177   #ifdef IS_MPI
178 <  char send_buffer[BUFFERSIZE];
179 < #endif
178 >  int done, which_node, which_atom; // loop counter
179 > #endif //is_mpi
180  
181 <  char *eof_test; // ptr to see when we reach the end of the file
181 >  const int BUFFERSIZE = 2000; // size of the read buffer
182 >  int nTotObjs; // the number of atoms
183 >  char read_buffer[BUFFERSIZE]; //the line buffer for reading
184 >
185 >  char *eof_test; // ptr to see when we reach the end of the file
186    char *parseErr;
220 –  int procIndex;
221 –  double boxMat[9];
222 –  double theBoxMat3[3][3];
223 –  
224 –  fpos_t *framePos;
225 –  
226 – #ifndef IS_MPI
227 –  
228 –  framePos = startFrame[whichFrame].getPos();
187  
188 <  
188 >  vector<StuntDouble*> integrableObjects;
189  
190  
191 + #ifndef IS_MPI
192 +
193 +  fsetpos(inFile, framePos[whichFrame]);
194    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
195    if( eof_test == NULL ){
196      sprintf( painCave.errMsg,
197               "DumpReader error: error reading 1st line of \"%s\"\n",
198 <             inName );
198 >             inFileName.c_str() );
199      painCave.isFatal = 1;
200      simError();
201    }
241 –  
242 –  n_atoms = atoi( read_buffer );
202  
203 <  Atom **atoms = simnfo->atoms;
245 <  DirectionalAtom* dAtom;
203 >  nTotObjs = atoi( read_buffer );
204  
205 <  if( n_atoms != simnfo->n_atoms ){
205 >  if( nTotObjs != simnfo->getTotIntegrableObjects() ){
206      sprintf( painCave.errMsg,
207               "DumpReader error. %s n_atoms, %d, "
208               "does not match the BASS file's n_atoms, %d.\n",
209 <             inName, n_atoms, simnfo->n_atoms );
209 >             inFileName.c_str(), nTotObjs, simnfo->getTotIntegrableObjects());
210      painCave.isFatal = 1;
211      simError();
212    }
213 <  
214 <  //read the box mat from the comment line
215 <  
213 >
214 >  //read the box mat from the comment line
215 >
216    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
217    if(eof_test == NULL){
218      sprintf( painCave.errMsg,
219 <             "error in reading commment in %s\n", inName);
219 >             "error in reading commment in %s\n", inFileName.c_str());
220      painCave.isFatal = 1;
221      simError();
222    }
223  
224 <  parseErr = parseCommentLine( read_buffer, time, boxMat );
224 >  parseErr = parseCommentLine( read_buffer, simnfo);
225    if( parseErr != NULL ){
226      strcpy( painCave.errMsg, parseErr );
227      painCave.isFatal = 1;
228      simError();
229    }
230  
231 <  simnfo->setTime( time );
274 <  
275 <  for(i=0;i<3;i++)
276 <    for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
277 <  
231 >  //parse dump lines
232  
233 <  simnfo->setBoxM( theBoxMat3 );
280 <  
233 >  for( i=0; i < simnfo->n_mol; i++){
234  
235 <  for( i=0; i < n_atoms; i++){
283 <    
284 <    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
285 <    if(eof_test == NULL){
286 <      sprintf(painCave.errMsg,
287 <              "error in reading file %s\n"
288 <              "natoms  = %d; index = %d\n"
289 <              "error reading the line from the file.\n",
290 <              inName, n_atoms, i );
291 <      painCave.isFatal = 1;
292 <      simError();
293 <    }
235 >    integrableObjects = (simnfo->molecules[i]).getIntegrableObjects();
236  
237 <    
238 <    parseErr = parseDumpLine( read_buffer, i );
239 <    if( parseErr != NULL ){
240 <      strcpy( painCave.errMsg, parseErr );
241 <      painCave.isFatal = 1;
242 <      simError();
237 >    for(j = 0; j < integrableObjects.size(); j++){
238 >
239 >      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
240 >      if(eof_test == NULL){
241 >        sprintf(painCave.errMsg,
242 >              "error in reading file %s\n"
243 >              "natoms  = %d; index = %d\n"
244 >              "error reading the line from the file.\n",
245 >              inFileName.c_str(), nTotObjs, i );
246 >        painCave.isFatal = 1;
247 >        simError();
248 >      }
249 >      
250 >      parseErr = parseDumpLine( read_buffer, integrableObjects[j]);
251 >      if( parseErr != NULL ){
252 >        strcpy( painCave.errMsg, parseErr );
253 >        painCave.isFatal = 1;
254 >        simError();
255 >      }
256      }
257    }
258  
304 –
259    // MPI Section of code..........
260   #else //IS_MPI
261  
# Line 310 | Line 264 | void DumpReader :: readSet( int whichFrame ){
264  
265    int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
266    int haveError;
267 <  
267 >
268    MPI_Status istatus;
269 <  int *AtomToProcMap = mpiSim->getAtomToProcMap();
269 >  int *MolToProcMap = mpiSim->getMolToProcMap();
270 >  int localIndex;
271 >  int nCurObj;
272 >  int nitems;
273  
274 <  
274 >  nTotObjs = simnfo->getTotIntegrableObjects();
275    haveError = 0;
276    if (worldRank == 0) {
277 +     fsetpos(inFile,  framePos[whichFrame]);
278  
279      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
280      if( eof_test == NULL ){
281        sprintf( painCave.errMsg,
282 <               "Error reading 1st line of %d \n ",inName);
282 >               "Error reading 1st line of %s \n ",inFileName.c_str());
283        haveError = 1;
284        simError();
285      }
286 <    
287 <    n_atoms = atoi( read_buffer );
288 <    
289 <    Atom **atoms = simnfo->atoms;
290 <    DirectionalAtom* dAtom;
291 <
292 <    // Check to see that the number of atoms in the intial configuration file is the
293 <    // same as declared in simBass.
294 <    
337 <    if( n_atoms != mpiSim->getTotAtoms() ){
338 <      sprintf( painCave.errMsg,
339 <               "Initialize from File error. %s n_atoms, %d, "
286 >
287 >    nitems = atoi( read_buffer );
288 >
289 >    // Check to see that the number of integrable objects  in the intial configuration file is the
290 >    // same as declared in simBass.
291 >
292 >    if( nTotObjs != nitems){
293 >      sprintf( painCave.errMsg,
294 >               "DumpReadererror. %s n_atoms, %d, "
295                 "does not match the BASS file's n_atoms, %d.\n",
296 <               inName, n_atoms, simnfo->n_atoms );
296 >               inFileName.c_str(), nTotObjs, simnfo->getTotIntegrableObjects());
297        haveError= 1;
298        simError();
299      }
300 <    
301 <    //read the time and boxMat from the comment line
302 <    
300 >
301 >    //read the boxMat from the comment line
302 >
303      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
304      if(eof_test == NULL){
305        sprintf( painCave.errMsg,
306 <               "error in reading commment in %s\n", inName);
306 >               "error in reading commment in %s\n", inFileName.c_str());
307        haveError = 1;
308        simError();
309      }
310 <    
311 <    parseErr = parseCommentLine( read_buffer, time, boxMat );
310 >
311 >    //Every single processor will parse the comment line by itself
312 >    //By using this way, we might lose some efficiency, but if we want to add
313 >    //more parameters into comment line, we only need to modify function
314 >    //parseCommentLine
315 >
316 >    MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
317 >
318 >    parseErr = parseCommentLine( read_buffer, simnfo);
319 >
320      if( parseErr != NULL ){
321        strcpy( painCave.errMsg, parseErr );
322        haveError = 1;
323        simError();
324      }
325  
326 <    MPI_Bcast(time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD );
327 <    
328 <    MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD );
329 <    
330 <    if(haveError) nodeZeroError();
331 <    
332 <    for (i=0 ; i < mpiSim->getTotAtoms(); i++) {
333 <      
334 <      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
335 <      if(eof_test == NULL){
336 <        sprintf(painCave.errMsg,
374 <                "error in reading file %s\n"
375 <                "natoms  = %d; index = %d\n"
376 <                "error reading the line from the file.\n",
377 <                inName, n_atoms, i );
378 <        haveError= 1;
379 <        simError();
326 >    for (i=0 ; i < mpiSim->getNMolGlobal(); i++) {
327 >      which_node = MolToProcMap[i];
328 >      if(which_node == 0){
329 >       //molecules belong to master node
330 >
331 >      localIndex = mpiSim->getGlobalToLocalMol(i);
332 >
333 >      if(localIndex == -1) {
334 >        strcpy(painCave.errMsg, "Molecule not found on node 0!");
335 >        haveError = 1;
336 >        simError();
337        }
381 –    
382 –      if(haveError) nodeZeroError();
338  
339 <      // Get the Node number which wants this atom:
340 <      which_node = AtomToProcMap[i];    
341 <      if (which_node == 0) {
342 <        parseErr = parseDumpLine( read_buffer, i );
343 <        if( parseErr != NULL ){
344 <          strcpy( painCave.errMsg, parseErr );
345 <          haveError = 1;
346 <          simError();
347 <        }    
348 <        if(haveError) nodeZeroError();
349 <      }
339 >       integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();
340 >       for(j=0; j < integrableObjects.size(); j++){
341 >        
342 >          eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
343 >          if(eof_test == NULL){
344 >                sprintf(painCave.errMsg,
345 >                    "error in reading file %s\n"
346 >                    "natoms  = %d; index = %d\n"
347 >                    "error reading the line from the file.\n",
348 >                    inFileName.c_str(), nTotObjs, i );
349 >                haveError= 1;
350 >                simError();
351 >          }
352 >          
353 >          if(haveError) nodeZeroError();
354 >
355 >          parseDumpLine(read_buffer, integrableObjects[j]);
356 >          
357 >       }
358 >
359 >
360 >      }
361 >      else{
362 >      //molecule belongs to slave nodes
363 >
364 >        MPI_Recv(&nCurObj, 1, MPI_INT, which_node,
365 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
366        
367 <      else {
368 <      
369 <        myStatus = 1;
370 <        MPI_Send(&myStatus, 1, MPI_INT, which_node,
371 <                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
372 <        MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
373 <                 TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
374 <        MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
375 <                 MPI_COMM_WORLD);
376 <        MPI_Recv(&myStatus, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
377 <                 MPI_COMM_WORLD, &istatus);
378 <        
379 <        if(!myStatus) nodeZeroError();
367 >       for(j=0; j < nCurObj; j++){
368 >        
369 >          eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
370 >          if(eof_test == NULL){
371 >                sprintf(painCave.errMsg,
372 >                    "error in reading file %s\n"
373 >                    "natoms  = %d; index = %d\n"
374 >                    "error reading the line from the file.\n",
375 >                    inFileName.c_str(), nTotObjs, i );
376 >                haveError= 1;
377 >                simError();
378 >          }
379 >          
380 >          if(haveError) nodeZeroError();
381 >
382 >            MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
383 >                      TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
384 >          
385 >       }
386 >
387        }
388 +      
389      }
411 –    myStatus = -1;
412 –    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
413 –      MPI_Send( &myStatus, 1, MPI_INT, j,
414 –                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
415 –    }
390      
391 <  } else {
392 <    
393 <    MPI_Bcast(time, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
394 <    MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD);
391 >  }
392 >  else{
393 >  //actions taken at slave nodes
394 >    MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
395  
396 <    done = 0;
423 <    while (!done) {
396 >    parseErr = parseCommentLine( read_buffer, simnfo);
397  
398 <      MPI_Recv(&myStatus, 1, MPI_INT, 0,
399 <               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
398 >    if( parseErr != NULL ){
399 >      strcpy( painCave.errMsg, parseErr );
400 >      haveError = 1;
401 >      simError();
402 >    }
403 >  
404 >    for (i=0 ; i < mpiSim->getNMolGlobal(); i++) {
405 >      which_node = MolToProcMap[i];
406        
407 <      if(!myStatus) anonymousNodeDie();
407 >      if(which_node == worldRank){
408 >      //molecule with global index i belongs to this processor
409        
410 <      if(myStatus < 0) break;
410 >        localIndex = mpiSim->getGlobalToLocalMol(i);
411  
412 <      MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
413 <               TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
414 <      MPI_Recv(&which_atom, 1, MPI_INT, 0,
415 <               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
416 <      
417 <      myStatus = 1;
418 <      parseErr = parseDumpLine( read_buffer, which_atom );
419 <      if( parseErr != NULL ){
420 <        strcpy( painCave.errMsg, parseErr );
421 <        myStatus = 0;;
422 <        simError();
412 >        if(localIndex == -1) {
413 >          sprintf(painCave.errMsg, "Molecule not found on node %d\n", worldRank);
414 >          haveError = 1;
415 >          simError();
416 >        }
417 >
418 >        integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();        
419 >
420 >        nCurObj = integrableObjects.size();
421 >        
422 >        MPI_Send(&nCurObj, 1, MPI_INT, 0,
423 >                        TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
424 >
425 >        for(j = 0; j < integrableObjects.size(); j++){
426 >
427 >          MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
428 >                              TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
429 >
430 >          parseErr = parseDumpLine(read_buffer, integrableObjects[j]);
431 >
432 >          if( parseErr != NULL ){
433 >                strcpy( painCave.errMsg, parseErr );
434 >                simError();
435 >          }
436 >
437 >        }
438 >          
439        }
440        
445 –      MPI_Send( &myStatus, 1, MPI_INT, 0,
446 –                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
447 –      
441      }
442 +
443    }
450 –    
451 – // last  thing last, enable  fatalities.
452 –  painCave.isEventLoop = 0;
444  
454 –  simnfo->setTime( time );
455 –
456 –  for(i=0;i<3;i++)
457 –    for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
458 –
459 –  simnfo->setBoxM( theBoxMat3 );
460 –
461 –  
445   #endif
446   }
447  
448 < char* DumpReader::parseDumpLine(char* readLine, int globalIndex){
448 > char* DumpReader::parseDumpLine(char* readLine, StuntDouble* sd){
449  
450 <  char *foo; // the pointer to the current string token
451 <  
452 <  double rx, ry, rz; // position place holders
453 <  double vx, vy, vz; // velocity placeholders
450 >  char *foo; // the pointer to the current string token
451 >
452 >  double pos[3]; // position place holders
453 >  double vel[3]; // velocity placeholders
454    double q[4]; // the quaternions
455 <  double jx, jy, jz; // angular velocity placeholders;
455 >  double ji[3]; // angular velocity placeholders;
456    double qSqr, qLength; // needed to normalize the quaternion vector.
474 –  
475 –  Atom **atoms = simnfo->atoms;
476 –  DirectionalAtom* dAtom;
477 –  
478 –  int j, n_atoms, atomIndex;
457  
480 – #ifdef IS_MPI
481 –  n_atoms = mpiSim->getTotAtoms();
482 –  atomIndex=-1;        
483 –  for (j=0; j < mpiSim->getMyNlocal(); j++) {
484 –    if (atoms[j]->getGlobalIndex() == globalIndex) atomIndex = j;
485 –  }
486 –  if (atomIndex == -1) {
487 –    sprintf( painCave.errMsg,
488 –             "Initialize from file error. Atom at index %d "
489 –             "in file %s does not exist on processor %d .\n",
490 –             globalIndex, inName, mpiSim->getMyNode() );
491 –    return strdup( painCave.errMsg );
492 –  }  
493 – #else
494 –  n_atoms = simnfo->n_atoms;
495 –  atomIndex = globalIndex;
496 – #endif // is_mpi
458  
459    // set the string tokenizer
460 <  
460 >
461    foo = strtok(readLine, " ,;\t");
462 <  
462 >
463    // check the atom name to the current atom
464 <  
465 <  if( strcmp( foo, atoms[atomIndex]->getType() ) ){
464 >
465 >  if( strcmp( foo, sd->getType() ) ){
466      sprintf( painCave.errMsg,
467 <             "Initialize from file error. Atom %s at index %d "
507 <             "in file %s does not"
467 >             "DumpReader error.  Does not"
468               " match the BASS atom %s.\n",
469 <             foo, atomIndex, inName, atoms[atomIndex]->getType() );
469 >             sd->getType() );
470      return strdup( painCave.errMsg );
471    }
472 <    
472 >
473    // get the positions
474  
475    foo = strtok(NULL, " ,;\t");
476    if(foo == NULL){
477      sprintf( painCave.errMsg,
478 <             "error in reading postition x from %s\n"
479 <             "natoms  = %d, index = %d\n",
520 <             inName, n_atoms, atomIndex );
478 >             "error in reading postition x from %s\n",
479 >             inFileName.c_str());
480      return strdup( painCave.errMsg );
481    }
482 <  rx = atof( foo );
483 <  
482 >  pos[0] = atof( foo );
483 >
484    foo = strtok(NULL, " ,;\t");
485    if(foo == NULL){
486      sprintf( painCave.errMsg,
487 <             "error in reading postition y from %s\n"
488 <             "natoms  = %d, index = %d\n",
530 <             inName, n_atoms, atomIndex );
487 >             "error in reading postition y from %s\n",
488 >             inFileName.c_str());
489      return strdup( painCave.errMsg );
490    }
491 <  ry = atof( foo );
492 <    
491 >  pos[1] = atof( foo );
492 >
493    foo = strtok(NULL, " ,;\t");
494    if(foo == NULL){
495      sprintf( painCave.errMsg,
496 <             "error in reading postition z from %s\n"
497 <             "natoms  = %d, index = %d\n",
540 <             inName, n_atoms, atomIndex );
496 >             "error in reading postition z from %s\n",
497 >             inFileName.c_str());
498      return strdup( painCave.errMsg );
499    }
500 <  rz = atof( foo );    
500 >  pos[2] = atof( foo );
501  
502  
503    // get the velocities
# Line 548 | Line 505 | char* DumpReader::parseDumpLine(char* readLine, int gl
505    foo = strtok(NULL, " ,;\t");
506    if(foo == NULL){
507      sprintf( painCave.errMsg,
508 <             "error in reading velocity x from %s\n"
509 <             "natoms  = %d, index = %d\n",
553 <             inName, n_atoms, atomIndex );
508 >             "error in reading velocity x from %s\n",
509 >             inFileName.c_str() );
510      return strdup( painCave.errMsg );
511    }
512 <  vx = atof( foo );
513 <    
512 >  vel[0] = atof( foo );
513 >
514    foo = strtok(NULL, " ,;\t");
515    if(foo == NULL){
516      sprintf( painCave.errMsg,
517 <             "error in reading velocity y from %s\n"
518 <             "natoms  = %d, index = %d\n",
563 <             inName, n_atoms, atomIndex );
517 >             "error in reading velocity x from %s\n",
518 >             inFileName.c_str() );
519      return strdup( painCave.errMsg );
520    }
521 <  vy = atof( foo );
522 <    
521 >  vel[1] = atof( foo );
522 >
523    foo = strtok(NULL, " ,;\t");
524    if(foo == NULL){
525      sprintf( painCave.errMsg,
526 <             "error in reading velocity z from %s\n"
527 <             "natoms  = %d, index = %d\n",
573 <             inName, n_atoms, atomIndex );
526 >             "error in reading velocity x from %s\n",
527 >             inFileName.c_str() );
528      return strdup( painCave.errMsg );
529    }
530 <  vz = atof( foo );
531 <    
532 <    
530 >  vel[2] = atof( foo );
531 >
532 >
533 >  // add the positions and velocities to the atom
534 >
535 >  sd->setPos( pos );
536 >  sd->setVel( vel );
537 >
538 >  if (!sd->isDirectional())
539 >    return NULL;
540 >
541    // get the quaternions
542 <    
543 <  if( atoms[atomIndex]->isDirectional() ){
544 <      
542 >
543 >  if( sd->isDirectional() ){
544 >
545      foo = strtok(NULL, " ,;\t");
546      if(foo == NULL){
547 <      sprintf(painCave.errMsg,
548 <              "error in reading quaternion 0 from %s\n"
549 <              "natoms  = %d, index = %d\n",
588 <              inName, n_atoms, atomIndex );
547 >      sprintf( painCave.errMsg,
548 >                     "error in reading velocity x from %s\n",
549 >                      inFileName.c_str() );
550        return strdup( painCave.errMsg );
551      }
552      q[0] = atof( foo );
553 <      
553 >
554      foo = strtok(NULL, " ,;\t");
555      if(foo == NULL){
556        sprintf( painCave.errMsg,
557 <               "error in reading quaternion 1 from %s\n"
558 <               "natoms  = %d, index = %d\n",
598 <               inName, n_atoms, atomIndex );
557 >                     "error in reading velocity x from %s\n",
558 >                      inFileName.c_str() );
559        return strdup( painCave.errMsg );
560      }
561      q[1] = atof( foo );
562 <      
562 >
563      foo = strtok(NULL, " ,;\t");
564      if(foo == NULL){
565        sprintf( painCave.errMsg,
566 <               "error in reading quaternion 2 from %s\n"
567 <               "natoms  = %d, index = %d\n",
608 <               inName, n_atoms, atomIndex );
566 >                     "error in reading velocity x from %s\n",
567 >                      inFileName.c_str() );
568        return strdup( painCave.errMsg );
569      }
570      q[2] = atof( foo );
571 <      
571 >
572      foo = strtok(NULL, " ,;\t");
573      if(foo == NULL){
574        sprintf( painCave.errMsg,
575 <               "error in reading quaternion 3 from %s\n"
576 <               "natoms  = %d, index = %d\n",
618 <               inName, n_atoms, atomIndex );
575 >                     "error in reading velocity x from %s\n",
576 >                      inFileName.c_str() );
577        return strdup( painCave.errMsg );
578      }
579      q[3] = atof( foo );
580 <      
580 >
581      // get the angular velocities
582 <      
582 >
583      foo = strtok(NULL, " ,;\t");
584      if(foo == NULL){
585        sprintf( painCave.errMsg,
586 <               "error in reading angular momentum jx from %s\n"
587 <               "natoms  = %d, index = %d\n",
630 <               inName, n_atoms, atomIndex );
586 >                     "error in reading velocity x from %s\n",
587 >                      inFileName.c_str() );
588        return strdup( painCave.errMsg );
589      }
590 <    jx = atof( foo );
591 <      
590 >    ji[0] = atof( foo );
591 >
592      foo = strtok(NULL, " ,;\t");
593      if(foo == NULL){
594        sprintf( painCave.errMsg,
595 <               "error in reading angular momentum jy from %s\n"
596 <               "natoms  = %d, index = %d\n",
640 <               inName, n_atoms, atomIndex );
595 >                     "error in reading velocity x from %s\n",
596 >                      inFileName.c_str() );
597        return strdup( painCave.errMsg );
598      }
599 <    jy = atof(foo );
600 <      
599 >    ji[1] = atof(foo );
600 >
601      foo = strtok(NULL, " ,;\t");
602      if(foo == NULL){
603        sprintf( painCave.errMsg,
604 <               "error in reading angular momentum jz from %s\n"
605 <               "natoms  = %d, index = %d\n",
650 <               inName, n_atoms, atomIndex );
604 >                     "error in reading velocity x from %s\n",
605 >                      inFileName.c_str() );
606        return strdup( painCave.errMsg );
607      }
608 <    jz = atof( foo );
654 <      
655 <    dAtom = ( DirectionalAtom* )atoms[atomIndex];
608 >    ji[2] = atof( foo );
609  
610 +
611      // check that the quaternion vector is normalized
612  
613      qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
614 <      
614 >
615 >    if (fabs(qSqr) < 1e-6) {
616 >      sprintf(painCave.errMsg,
617 >          "initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2 ~ 0).\n");
618 >       return strdup(painCave.errMsg);
619 >    }
620 >
621      qLength = sqrt( qSqr );
622      q[0] = q[0] / qLength;
623      q[1] = q[1] / qLength;
624      q[2] = q[2] / qLength;
625      q[3] = q[3] / qLength;
666 –      
667 –    dAtom->setQ( q );
668 –      
669 –    // add the angular velocities
626  
627 <    dAtom->setJx( jx );
628 <    dAtom->setJy( jy );
629 <    dAtom->setJz( jz );
627 >    // add quaternion and angular velocities
628 >
629 >    sd->setQ( q );
630 >    sd->setJ( ji );
631    }
675 –    
676 –  // add the positions and velocities to the atom
677 –    
678 –  atoms[atomIndex]->setX( rx );
679 –  atoms[atomIndex]->setY( ry );
680 –  atoms[atomIndex]->setZ( rz );
681 –    
682 –  atoms[atomIndex]->set_vx( vx );
683 –  atoms[atomIndex]->set_vy( vy );
684 –  atoms[atomIndex]->set_vz( vz );
632  
633 +
634 +
635    return NULL;
636   }
637  
638  
639 < char* DumpReader::parseCommentLine(char* readLine, double time,
691 <                                   double boxMat[9]){
692 <
693 <  char *foo; // the pointer to the current string token
694 <  int j;
639 > char* DumpReader::parseCommentLine(char* readLine, SimInfo* entry_plug){
640  
641 +  double currTime;
642 +  double boxMat[9];
643 +  double theBoxMat3[3][3];
644 +  double chi;
645 +  double integralOfChidt;
646 +  double eta[9];
647 +
648 +  char *foo; // the pointer to the current string token
649 +
650    // set the string tokenizer
651 <  
651 >
652    foo = strtok(readLine, " ,;\t");
653 +  // set the timeToken.
654 +
655    if(foo == NULL){
656      sprintf( painCave.errMsg,
657 <             "error in reading time from %s\n",
658 <             inName );
657 >             "error in reading Time from %s\n",
658 >             inFileName.c_str() );
659      return strdup( painCave.errMsg );
660    }
705 –  time = atof( foo );
661  
662 <  // get the Hx vector
662 >  currTime = atof( foo );
663 >  entry_plug->setTime( currTime );
664  
665 <  foo = strtok(NULL, " ,;\t");
666 <  if(foo == NULL){
667 <    sprintf( painCave.errMsg,
668 <             "error in reading Hx[0] from %s\n",
669 <             inName );
670 <    return strdup( painCave.errMsg );
665 >  //get H-Matrix
666 >
667 >  for(int i = 0 ; i < 9; i++){
668 >    foo = strtok(NULL, " ,;\t");
669 >    if(foo == NULL){
670 >      sprintf( painCave.errMsg,
671 >               "error in reading H[%d] from %s\n", i, inFileName.c_str() );
672 >      return strdup( painCave.errMsg );
673 >    }
674 >    boxMat[i] = atof( foo );
675    }
716 –  boxMat[0] = atof( foo );
717 –  
718 –  foo = strtok(NULL, " ,;\t");
719 –  if(foo == NULL){
720 –    sprintf( painCave.errMsg,
721 –             "error in reading Hx[1] from %s\n",
722 –             inName );
723 –    return strdup( painCave.errMsg );
724 –  }
725 –  boxMat[1] = atof( foo );
726 –    
727 –  foo = strtok(NULL, " ,;\t");
728 –  if(foo == NULL){
729 –    sprintf( painCave.errMsg,
730 –             "error in reading Hx[2] from %s\n",
731 –             inName );
732 –    return strdup( painCave.errMsg );
733 –  }
734 –  boxMat[2] = atof( foo );    
676  
677 <  // get the Hy vector
677 >  for(int i=0;i<3;i++)
678 >    for(int j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
679  
680 <  foo = strtok(NULL, " ,;\t");
681 <  if(foo == NULL){
740 <    sprintf( painCave.errMsg,
741 <             "error in reading Hy[0] from %s\n",
742 <             inName );
743 <    return strdup( painCave.errMsg );
744 <  }
745 <  boxMat[3] = atof( foo );
746 <  
747 <  foo = strtok(NULL, " ,;\t");
748 <  if(foo == NULL){
749 <    sprintf( painCave.errMsg,
750 <             "error in reading Hy[1] from %s\n",
751 <             inName );
752 <    return strdup( painCave.errMsg );
753 <  }
754 <  boxMat[4] = atof( foo );
755 <    
756 <  foo = strtok(NULL, " ,;\t");
757 <  if(foo == NULL){
758 <    sprintf( painCave.errMsg,
759 <             "error in reading Hy[2] from %s\n",
760 <             inName );
761 <    return strdup( painCave.errMsg );
762 <  }
763 <  boxMat[5] = atof( foo );    
680 >  //set H-Matrix
681 >  entry_plug->setBoxM( theBoxMat3 );
682  
683 <  // get the Hz vector
683 >  //get chi and integralOfChidt, they should appear by pair
684  
685 <  foo = strtok(NULL, " ,;\t");
686 <  if(foo == NULL){
687 <    sprintf( painCave.errMsg,
688 <             "error in reading Hz[0] from %s\n",
689 <             inName );
690 <    return strdup( painCave.errMsg );
685 >  if( entry_plug->useInitXSstate ){
686 >    foo = strtok(NULL, " ,;\t\n");
687 >    if(foo != NULL){
688 >      chi = atof(foo);
689 >      
690 >      foo = strtok(NULL, " ,;\t\n");
691 >      if(foo == NULL){
692 >        sprintf( painCave.errMsg,
693 >                 "chi and integralOfChidt should appear by pair in %s\n", inFileName.c_str() );
694 >        return strdup( painCave.errMsg );
695 >      }
696 >      integralOfChidt = atof( foo );
697 >      
698 >      //push chi and integralOfChidt into SimInfo::properties which can be
699 >      //retrieved by integrator later
700 >      DoubleData* chiValue = new DoubleData();
701 >      chiValue->setID(CHIVALUE_ID);
702 >      chiValue->setData(chi);
703 >      entry_plug->addProperty(chiValue);
704 >      
705 >      DoubleData* integralOfChidtValue = new DoubleData();
706 >      integralOfChidtValue->setID(INTEGRALOFCHIDT_ID);
707 >      integralOfChidtValue->setData(integralOfChidt);
708 >      entry_plug->addProperty(integralOfChidtValue);
709 >      
710 >    }
711 >    else
712 >      return NULL;
713 >    
714 >    //get eta
715 >    foo = strtok(NULL, " ,;\t\n");
716 >    if(foo != NULL ){
717 >  
718 >      for(int i = 0 ; i < 9; i++){
719 >        
720 >        if(foo == NULL){
721 >          sprintf( painCave.errMsg,
722 >                   "error in reading eta[%d] from %s\n", i, inFileName.c_str() );
723 >          return strdup( painCave.errMsg );
724 >        }
725 >        eta[i] = atof( foo );
726 >        foo = strtok(NULL, " ,;\t\n");
727 >      }
728 >    }
729 >    else
730 >      return NULL;
731 >    
732 >    //push eta into SimInfo::properties which can be
733 >    //retrieved by integrator later
734 >    //entry_plug->setBoxM( theBoxMat3 );
735 >    DoubleArrayData* etaValue = new DoubleArrayData();
736 >    etaValue->setID(ETAVALUE_ID);
737 >    etaValue->setData(eta, 9);
738 >    entry_plug->addProperty(etaValue);
739    }
774 –  boxMat[6] = atof( foo );
775 –  
776 –  foo = strtok(NULL, " ,;\t");
777 –  if(foo == NULL){
778 –    sprintf( painCave.errMsg,
779 –             "error in reading Hz[1] from %s\n",
780 –             inName );
781 –    return strdup( painCave.errMsg );
782 –  }
783 –  boxMat[7] = atof( foo );
784 –    
785 –  foo = strtok(NULL, " ,;\t");
786 –  if(foo == NULL){
787 –    sprintf( painCave.errMsg,
788 –             "error in reading Hz[2] from %s\n",
789 –             inName );
790 –    return strdup( painCave.errMsg );
791 –  }
792 –  boxMat[8] = atof( foo );    
740  
741    return NULL;
742   }
743  
797 –
744   #ifdef IS_MPI
745 <
800 < // a couple of functions to let us escape the read loop
801 <
802 < void initFile::nodeZeroError( void ){
745 > void DumpReader::nodeZeroError( void ){
746    int j, myStatus;
747 <  
747 >
748    myStatus = 0;
749 <  for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
750 <    MPI_Send( &myStatus, 1, MPI_INT, j,
749 >  for (j = 0; j < mpiSim->getNProcessors(); j++) {
750 >    MPI_Send( &myStatus, 1, MPI_INT, j,
751                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
752 <  }  
810 <  
752 >  }
753  
754 +
755    MPI_Finalize();
756    exit (0);
757 <  
757 >
758   }
759  
760 < void initFile::anonymousNodeDie( void ){
760 > void DumpReader::anonymousNodeDie( void ){
761  
762    MPI_Finalize();
763    exit (0);
764   }
765 <
823 < #endif //is_mpi
765 > #endif

Diff Legend

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