ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/io/DumpReader.cpp
(Generate patch)

Comparing trunk/src/io/DumpReader.cpp (file contents):
Revision 601 by tim, Thu Sep 15 19:17:04 2005 UTC vs.
Revision 996 by chrisfen, Wed Jun 28 14:35:14 2006 UTC

# Line 1 | Line 1
1 < /*
2 < * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 < *
4 < * The University of Notre Dame grants you ("Licensee") a
5 < * non-exclusive, royalty free, license to use, modify and
6 < * redistribute this software in source and binary code form, provided
7 < * that the following conditions are met:
8 < *
9 < * 1. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
19 < *    notice, this list of conditions and the following disclaimer.
20 < *
21 < * 3. Redistributions in binary form must reproduce the above copyright
22 < *    notice, this list of conditions and the following disclaimer in the
23 < *    documentation and/or other materials provided with the
24 < *    distribution.
25 < *
26 < * This software is provided "AS IS," without a warranty of any
27 < * kind. All express or implied conditions, representations and
28 < * warranties, including any implied warranty of merchantability,
29 < * fitness for a particular purpose or non-infringement, are hereby
30 < * excluded.  The University of Notre Dame and its licensors shall not
31 < * be liable for any damages suffered by licensee as a result of
32 < * using, modifying or distributing the software or its
33 < * derivatives. In no event will the University of Notre Dame or its
34 < * licensors be liable for any lost revenue, profit or data, or for
35 < * direct, indirect, special, consequential, incidental or punitive
36 < * damages, however caused and regardless of the theory of liability,
37 < * arising out of the use of or inability to use software, even if the
38 < * University of Notre Dame has been advised of the possibility of
39 < * such damages.
40 < */
41 <
42 < #define _LARGEFILE_SOURCE64
43 < #define _FILE_OFFSET_BITS 64
44 <
45 < #include <sys/types.h>
46 < #include <sys/stat.h>
47 <
48 < #include <iostream>
49 < #include <math.h>
50 <
51 < #include <stdio.h>
52 < #include <stdlib.h>
53 < #include <string.h>
54 <
55 < #include "io/DumpReader.hpp"
56 < #include "primitives/Molecule.hpp"
57 < #include "utils/simError.h"
58 < #include "utils/MemoryUtils.hpp"
59 < #include "utils/StringTokenizer.hpp"
60 <
61 < #ifdef IS_MPI
62 <
63 < #include <mpi.h>
64 < #define TAKE_THIS_TAG_CHAR 0
65 < #define TAKE_THIS_TAG_INT 1
66 <
67 < #endif // is_mpi
68 <
69 <
70 < namespace oopse {
1 > /*
2 > * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 > *
4 > * The University of Notre Dame grants you ("Licensee") a
5 > * non-exclusive, royalty free, license to use, modify and
6 > * redistribute this software in source and binary code form, provided
7 > * that the following conditions are met:
8 > *
9 > * 1. Acknowledgement of the program authors must be made in any
10 > *    publication of scientific results based in part on use of the
11 > *    program.  An acceptable form of acknowledgement is citation of
12 > *    the article in which the program was described (Matthew
13 > *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 > *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 > *    Parallel Simulation Engine for Molecular Dynamics,"
16 > *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 > *
18 > * 2. Redistributions of source code must retain the above copyright
19 > *    notice, this list of conditions and the following disclaimer.
20 > *
21 > * 3. Redistributions in binary form must reproduce the above copyright
22 > *    notice, this list of conditions and the following disclaimer in the
23 > *    documentation and/or other materials provided with the
24 > *    distribution.
25 > *
26 > * This software is provided "AS IS," without a warranty of any
27 > * kind. All express or implied conditions, representations and
28 > * warranties, including any implied warranty of merchantability,
29 > * fitness for a particular purpose or non-infringement, are hereby
30 > * excluded.  The University of Notre Dame and its licensors shall not
31 > * be liable for any damages suffered by licensee as a result of
32 > * using, modifying or distributing the software or its
33 > * derivatives. In no event will the University of Notre Dame or its
34 > * licensors be liable for any lost revenue, profit or data, or for
35 > * direct, indirect, special, consequential, incidental or punitive
36 > * damages, however caused and regardless of the theory of liability,
37 > * arising out of the use of or inability to use software, even if the
38 > * University of Notre Dame has been advised of the possibility of
39 > * such damages.
40 > */
41    
42 <  DumpReader::DumpReader(SimInfo* info, const std::string& filename)
43 <    : info_(info), filename_(filename), isScanned_(false), nframes_(0) {
42 > #define _LARGEFILE_SOURCE64
43 > #define _FILE_OFFSET_BITS 64
44 >
45 > #include <sys/types.h>
46 > #include <sys/stat.h>
47 >
48 > #include <iostream>
49 > #include <math.h>
50 >
51 > #include <stdio.h>
52 > #include <stdlib.h>
53 > #include <string.h>
54 >
55 > #include "io/DumpReader.hpp"
56 > #include "primitives/Molecule.hpp"
57 > #include "utils/simError.h"
58 > #include "utils/MemoryUtils.hpp"
59 > #include "utils/StringTokenizer.hpp"
60 >
61 > #ifdef IS_MPI
62 >
63 > #include <mpi.h>
64 > #define TAKE_THIS_TAG_CHAR 0
65 > #define TAKE_THIS_TAG_INT 1
66 >
67 > #endif // is_mpi
68 >
69 >
70 > namespace oopse {
71 >  
72 >  DumpReader::DumpReader(SimInfo* info, const std::string& filename)
73 >    : info_(info), filename_(filename), isScanned_(false), nframes_(0) {
74      
75 < #ifdef IS_MPI
75 > #ifdef IS_MPI
76      
77 <      if (worldRank == 0) {
78 < #endif
77 >    if (worldRank == 0) {
78 > #endif
79        
80 <        inFile_ = fopen(filename_.c_str(), "r");
80 >      inFile_ = new std::ifstream(filename_.c_str());
81        
82 <        if (inFile_ == NULL) {
83 <          sprintf(painCave.errMsg, "DumpReader: Cannot open file: %s\n", filename_.c_str());
84 <          painCave.isFatal = 1;
85 <          simError();
86 <        }
82 >      if (inFile_->fail()) {
83 >        sprintf(painCave.errMsg,
84 >                "DumpReader: Cannot open file: %s\n",
85 >                filename_.c_str());
86 >        painCave.isFatal = 1;
87 >        simError();
88 >      }
89        
90 < #ifdef IS_MPI
90 > #ifdef IS_MPI
91        
92 <      }
92 >    }
93      
94 <      strcpy(checkPointMsg, "Dump file opened for reading successfully.");
95 <      MPIcheckPoint();
94 >    strcpy(checkPointMsg, "Dump file opened for reading successfully.");
95 >    MPIcheckPoint();
96      
97 < #endif
97 > #endif
98      
99 <      return;
100 <    }
99 >    return;
100 >  }
101    
102 <  DumpReader::~DumpReader() {
102 >  DumpReader::~DumpReader() {
103      
104 < #ifdef IS_MPI
104 > #ifdef IS_MPI
105      
106 <    if (worldRank == 0) {
107 < #endif
106 >    if (worldRank == 0) {
107 > #endif
108        
109 <      int error;
108 <      error = fclose(inFile_);
109 >      delete inFile_;
110        
111 <      if (error) {
111 <        sprintf(painCave.errMsg, "DumpReader Error: Error closing %s\n", filename_.c_str());
112 <        painCave.isFatal = 1;            
113 <        simError();
114 <      }
111 > #ifdef IS_MPI
112        
113 <      MemoryUtils::deletePointers(framePos_);
117 <      
118 < #ifdef IS_MPI
119 <      
120 <    }
113 >    }
114      
115 <    strcpy(checkPointMsg, "Dump file closed successfully.");
116 <    MPIcheckPoint();
115 >    strcpy(checkPointMsg, "Dump file closed successfully.");
116 >    MPIcheckPoint();
117      
118 < #endif
126 <    
127 <    return;
128 <  }
129 <  
130 <  int DumpReader::getNFrames(void) {
131 <    
132 <    if (!isScanned_)
133 <      scanFile();
134 <    
135 <    return nframes_;
136 <  }
137 <  
138 <  void DumpReader::scanFile(void) {
139 <    int i, j;
140 <    int lineNum = 0;
141 <    char readBuffer[maxBufferSize];
142 <    fpos_t * currPos;
143 <    
144 < #ifdef IS_MPI
145 <    
146 <    if (worldRank == 0) {
147 < #endif // is_mpi
148 <      
149 <      rewind(inFile_);
150 <      
151 <      currPos = new fpos_t;
152 <      fgetpos(inFile_, currPos);
153 <      fgets(readBuffer, sizeof(readBuffer), inFile_);
154 <      lineNum++;
155 <      
156 <      if (feof(inFile_)) {
157 <        sprintf(painCave.errMsg,
158 <                "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
159 <                filename_.c_str(),
160 <                lineNum);
161 <        painCave.isFatal = 1;
162 <        simError();
163 <      }
164 <      
165 <      while (!feof(inFile_)) {
166 <        framePos_.push_back(currPos);
167 <        
168 <        i = atoi(readBuffer);
169 <        
170 <        fgets(readBuffer, sizeof(readBuffer), inFile_);
171 <        lineNum++;
172 <        
173 <        if (feof(inFile_)) {
174 <          sprintf(painCave.errMsg,
175 <                  "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
176 <                  filename_.c_str(),
177 <                  lineNum);
178 <          painCave.isFatal = 1;
179 <          simError();
180 <        }
181 <        
182 <        for(j = 0; j < i; j++) {
183 <          fgets(readBuffer, sizeof(readBuffer), inFile_);
184 <          lineNum++;
185 <          
186 <          if (feof(inFile_)) {
187 <            sprintf(painCave.errMsg,
188 <                    "DumpReader Error: File \"%s\" ended unexpectedly at line %d,"
189 <                    " with atom %d\n", filename_.c_str(),
190 <                    lineNum,
191 <                    j);
192 <            
193 <            painCave.isFatal = 1;
194 <            simError();
195 <          }
196 <        }
197 <        
198 <        currPos = new fpos_t;
199 <        fgetpos(inFile_, currPos);
200 <        fgets(readBuffer, sizeof(readBuffer), inFile_);
201 <        lineNum++;
202 <      }
203 <      
204 <      delete currPos;
205 <      rewind(inFile_);
206 <      
207 <      nframes_ = framePos_.size();
208 < #ifdef IS_MPI
209 <    }
210 <    
211 <    MPI_Bcast(&nframes_, 1, MPI_INT, 0, MPI_COMM_WORLD);
212 <    
213 <    strcpy(checkPointMsg, "Successfully scanned DumpFile\n");
214 <    MPIcheckPoint();
215 <    
216 < #endif // is_mpi
217 <    
218 <    isScanned_ = true;
219 <  }
220 <  
221 <  void DumpReader::readFrame(int whichFrame) {
222 <    if (!isScanned_)
223 <      scanFile();
224 <        
225 <    int storageLayout = info_->getSnapshotManager()->getStorageLayout();
226 <    
227 <    if (storageLayout & DataStorage::dslPosition) {
228 <      needPos_ = true;
229 <    } else {
230 <      needPos_ = false;
231 <    }
118 > #endif
119      
120 <    if (storageLayout & DataStorage::dslVelocity) {
121 <      needVel_ = true;
235 <    } else {
236 <      needVel_ = false;
237 <    }
238 <    
239 <    if (storageLayout & DataStorage::dslAmat || storageLayout & DataStorage::dslElectroFrame) {
240 <      needQuaternion_ = true;
241 <    } else {
242 <      needQuaternion_ = false;
243 <    }
244 <    
245 <    if (storageLayout & DataStorage::dslAngularMomentum) {
246 <      needAngMom_ = true;
247 <    } else {
248 <      needAngMom_ = false;    
249 <    }
250 <    
251 <    readSet(whichFrame);
252 <  }
120 >    return;
121 >  }
122    
123 <  void DumpReader::readSet(int whichFrame) {
124 <    int i;
125 <    int nTotObjs;                  // the number of atoms
126 <    char read_buffer[maxBufferSize];  //the line buffer for reading
127 <    char * eof_test;               // ptr to see when we reach the end of the file
128 <    
129 <    Molecule* mol;
130 <    StuntDouble* integrableObject;
131 <    SimInfo::MoleculeIterator mi;
132 <    Molecule::IntegrableObjectIterator ii;
133 <    
134 < #ifndef IS_MPI
135 <    
136 <    fsetpos(inFile_, framePos_[whichFrame]);
137 <    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
138 <    
139 <    if (eof_test == NULL) {
140 <      sprintf(painCave.errMsg,
141 <              "DumpReader error: error reading 1st line of \"%s\"\n",
142 <              filename_.c_str());
143 <      painCave.isFatal = 1;
144 <      simError();
145 <    }
146 <    
147 <    nTotObjs = atoi(read_buffer);
148 <    
149 <    if (nTotObjs != info_->getNGlobalIntegrableObjects()) {
150 <      sprintf(painCave.errMsg,
151 <              "DumpReader error. %s nIntegrable, %d, "
152 <              "does not match the meta-data file's nIntegrable, %d.\n",
153 <              filename_.c_str(),
154 <              nTotObjs,
155 <              info_->getNGlobalIntegrableObjects());
287 <      
288 <      painCave.isFatal = 1;
289 <      simError();
290 <    }
291 <    
292 <    //read the box mat from the comment line
293 <    
294 <    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
295 <    
296 <    if (eof_test == NULL) {
297 <      sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
298 <              filename_.c_str());
299 <      painCave.isFatal = 1;
300 <      simError();
301 <    }
302 <    
303 <    parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
304 <    
305 <    //parse dump lines
306 <    
307 <    i = 0;
308 <    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
309 <      
310 <      for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
311 <           integrableObject = mol->nextIntegrableObject(ii)) {          
312 <        
313 <        eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
314 <        
315 <        if (eof_test == NULL) {
316 <          sprintf(painCave.errMsg,
317 <                  "DumpReader Error: error in reading file %s\n"
318 <                  "natoms  = %d; index = %d\n"
319 <                  "error reading the line from the file.\n",
320 <                  filename_.c_str(),
321 <                  nTotObjs,
322 <                  i);
323 <          
324 <          painCave.isFatal = 1;
325 <          simError();
326 <        }
327 <        
328 <        parseDumpLine(read_buffer, integrableObject);
329 <        i++;
330 <      }
331 <    }
332 <    
333 <    // MPI Section of code..........
334 <    
335 < #else //IS_MPI
336 <    
337 <    // first thing first, suspend fatalities.
338 <    int masterNode = 0;
339 <    int nCurObj;
340 <    painCave.isEventLoop = 1;
341 <    
342 <    int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
343 <    int haveError;
344 <    
345 <    MPI_Status istatus;
346 <    int nitems;
347 <    
348 <    nTotObjs = info_->getNGlobalIntegrableObjects();
349 <    haveError = 0;
350 <    
351 <    if (worldRank == masterNode) {
352 <      fsetpos(inFile_, framePos_[whichFrame]);
353 <      
354 <      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
355 <      
356 <      if (eof_test == NULL) {
357 <        sprintf(painCave.errMsg, "DumpReader Error: Error reading 1st line of %s \n ",
358 <                filename_.c_str());
359 <        painCave.isFatal = 1;
360 <        simError();
361 <      }
362 <      
363 <      nitems = atoi(read_buffer);
364 <      
365 <      // Check to see that the number of integrable objects in the
366 <      // intial configuration file is the same as derived from the
367 <      // meta-data file.
368 <      
369 <      if (nTotObjs != nitems) {
370 <        sprintf(painCave.errMsg,
371 <                "DumpReader Error. %s nIntegrable, %d, "
372 <                "does not match the meta-data file's nIntegrable, %d.\n",
373 <                filename_.c_str(),
374 <                nTotObjs,
375 <                info_->getNGlobalIntegrableObjects());
376 <        
377 <        painCave.isFatal = 1;
378 <        simError();
379 <      }
380 <      
381 <      //read the boxMat from the comment line
382 <      
383 <      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
384 <      
385 <      if (eof_test == NULL) {
386 <        sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
387 <                filename_.c_str());
388 <        painCave.isFatal = 1;
389 <        simError();
390 <      }
391 <      
392 <      //Every single processor will parse the comment line by itself
393 <      //By using this way, we might lose some efficiency, but if we want to add
394 <      //more parameters into comment line, we only need to modify function
395 <      //parseCommentLine
396 <      
397 <      MPI_Bcast(read_buffer, maxBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
398 <      parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
399 <      
400 <      for(i = 0; i < info_->getNGlobalMolecules(); i++) {
401 <        int which_node = info_->getMolToProc(i);
402 <        
403 <        if (which_node == masterNode) {
404 <          //molecules belong to master node
405 <          
406 <          mol = info_->getMoleculeByGlobalIndex(i);
407 <          
408 <          if (mol == NULL) {
409 <            sprintf(painCave.errMsg, "DumpReader Error: Molecule not found on node %d!", worldRank);
410 <            painCave.isFatal = 1;
411 <            simError();
412 <          }
413 <          
414 <          for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
415 <               integrableObject = mol->nextIntegrableObject(ii)){
416 <            
417 <            eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
418 <            
419 <            if (eof_test == NULL) {
420 <              sprintf(painCave.errMsg,
421 <                      "DumpReader Error: error in reading file %s\n"
422 <                      "natoms  = %d; index = %d\n"
423 <                      "error reading the line from the file.\n",
424 <                      filename_.c_str(),
425 <                      nTotObjs,
426 <                      i);
427 <              
428 <              painCave.isFatal = 1;
429 <              simError();
430 <            }
431 <            
432 <            parseDumpLine(read_buffer, integrableObject);
433 <          }
434 <        } else {
435 <          //molecule belongs to slave nodes
436 <          
437 <          MPI_Recv(&nCurObj, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
438 <                   MPI_COMM_WORLD, &istatus);
439 <          
440 <          for(int j = 0; j < nCurObj; j++) {
441 <            eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
442 <            
443 <            if (eof_test == NULL) {
444 <              sprintf(painCave.errMsg,
445 <                      "DumpReader Error: error in reading file %s\n"
446 <                      "natoms  = %d; index = %d\n"
447 <                      "error reading the line from the file.\n",
448 <                      filename_.c_str(),
449 <                      nTotObjs,
450 <                      i);
451 <              
452 <              painCave.isFatal = 1;
453 <              simError();
454 <            }
455 <            
456 <            MPI_Send(read_buffer, maxBufferSize, MPI_CHAR, which_node,
457 <                     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
458 <          }
459 <        }
460 <      }
461 <    } else {
462 <      //actions taken at slave nodes
463 <      MPI_Bcast(read_buffer, maxBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
464 <      
465 <      /**@todo*/
466 <      parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
467 <      
468 <      for(i = 0; i < info_->getNGlobalMolecules(); i++) {
469 <        int which_node = info_->getMolToProc(i);
470 <        
471 <        if (which_node == worldRank) {
472 <          //molecule with global index i belongs to this processor
473 <          
474 <          mol = info_->getMoleculeByGlobalIndex(i);
475 <          if (mol == NULL) {
476 <            sprintf(painCave.errMsg, "DumpReader Error: Molecule not found on node %d!", worldRank);
477 <            painCave.isFatal = 1;
478 <            simError();
479 <          }
480 <          
481 <          nCurObj = mol->getNIntegrableObjects();
482 <          
483 <          MPI_Send(&nCurObj, 1, MPI_INT, masterNode, TAKE_THIS_TAG_INT,
484 <                   MPI_COMM_WORLD);
485 <          
486 <          for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
487 <               integrableObject = mol->nextIntegrableObject(ii)){
488 <            
489 <            MPI_Recv(read_buffer, maxBufferSize, MPI_CHAR, masterNode,
490 <                     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
491 <            
492 <            parseDumpLine(read_buffer, integrableObject);
493 <          }
494 <          
495 <        }
496 <        
497 <      }
498 <      
499 <    }
500 <    
501 < #endif
502 <    
503 <  }
504 <  
505 <  void DumpReader::parseDumpLine(char *line, StuntDouble *integrableObject) {
506 <    
507 <    Vector3d pos;  // position place holders
508 <    Vector3d vel;  // velocity placeholders
509 <    Quat4d q;    // the quaternions
510 <    Vector3d ji;   // angular velocity placeholders;
511 <    StringTokenizer tokenizer(line);
512 <    int nTokens;
513 <    
514 <    nTokens = tokenizer.countTokens();
515 <    
516 <    if (nTokens < 14) {
517 <      sprintf(painCave.errMsg,
518 <              "DumpReader Error: Not enough Tokens.\n%s\n", line);
519 <      painCave.isFatal = 1;
520 <      simError();
521 <    }
522 <    
523 <    std::string name = tokenizer.nextToken();
524 <    
525 <    if (name != integrableObject->getType()) {
526 <      
527 <      sprintf(painCave.errMsg,
528 <              "DumpReader Error: Atom type [%s] in %s does not match Atom Type [%s] in .md file.\n",
529 <              name.c_str(), filename_.c_str(), integrableObject->getType().c_str());
530 <      painCave.isFatal = 1;
531 <      simError();        
532 <    }
533 <    
534 <    pos[0] = tokenizer.nextTokenAsDouble();
535 <    pos[1] = tokenizer.nextTokenAsDouble();
536 <    pos[2] = tokenizer.nextTokenAsDouble();
537 <    if (needPos_) {
538 <      integrableObject->setPos(pos);
539 <    }
540 <    
541 <    vel[0] = tokenizer.nextTokenAsDouble();
542 <    vel[1] = tokenizer.nextTokenAsDouble();
543 <    vel[2] = tokenizer.nextTokenAsDouble();
544 <    if (needVel_) {
545 <      integrableObject->setVel(vel);
546 <    }
547 <    
548 <    if (integrableObject->isDirectional()) {
549 <      
550 <      q[0] = tokenizer.nextTokenAsDouble();
551 <      q[1] = tokenizer.nextTokenAsDouble();
552 <      q[2] = tokenizer.nextTokenAsDouble();
553 <      q[3] = tokenizer.nextTokenAsDouble();
554 <      
555 <      double qlen = q.length();
556 <      if (qlen < oopse::epsilon) { //check quaternion is not equal to 0
557 <        
558 <        sprintf(painCave.errMsg,
559 <                "DumpReader Error: initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2 ~ 0).\n");
560 <        painCave.isFatal = 1;
561 <        simError();
562 <        
123 >  int DumpReader::getNFrames(void) {
124 >    
125 >    if (!isScanned_)
126 >      scanFile();
127 >    
128 >    return nframes_;
129 >  }
130 >  
131 >  void DumpReader::scanFile(void) {
132 >    int i, j;
133 >    int lineNum = 0;
134 >    char readBuffer[maxBufferSize];
135 >    std::streampos  currPos;
136 >    
137 > #ifdef IS_MPI
138 >    
139 >    if (worldRank == 0) {
140 > #endif // is_mpi
141 >      
142 >      inFile_->seekg (0, std::ios::beg);
143 >      
144 >
145 >      currPos = inFile_->tellg();
146 >      inFile_->getline(readBuffer, sizeof(readBuffer));
147 >      lineNum++;
148 >      
149 >      if (inFile_->eof()) {
150 >        sprintf(painCave.errMsg,
151 >                "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
152 >                filename_.c_str(),
153 >                lineNum);
154 >        painCave.isFatal = 1;
155 >        simError();
156        }
157 <      
158 <      q.normalize();
159 <      if (needQuaternion_) {          
160 <        integrableObject->setQ(q);
161 <      }
162 <      
163 <      ji[0] = tokenizer.nextTokenAsDouble();
164 <      ji[1] = tokenizer.nextTokenAsDouble();
165 <      ji[2] = tokenizer.nextTokenAsDouble();
166 <      if (needAngMom_) {
167 <        integrableObject->setJ(ji);
168 <      }
169 <    }
170 <    
171 <  }
172 <  
173 <  
174 <  void DumpReader::parseCommentLine(char* line, Snapshot* s) {
175 <    double currTime;
176 <    Mat3x3d hmat;
177 <    double chi;
178 <    double integralOfChiDt;
179 <    Mat3x3d eta;
180 <    
181 <    StringTokenizer tokenizer(line);
182 <    int nTokens;
183 <    
184 <    nTokens = tokenizer.countTokens();
185 <    
186 <    //comment line should at least contain 10 tokens: current time(1 token) and  h-matrix(9 tokens)
187 <    if (nTokens < 10) {
188 <      sprintf(painCave.errMsg,
189 <              "DumpReader Error: Not enough tokens in comment line: %s", line);
190 <      painCave.isFatal = 1;
191 <      simError();  
192 <    }
193 <    
194 <    //read current time
195 <    currTime = tokenizer.nextTokenAsDouble();
196 <    s->setTime(currTime);
197 <    
198 <    //read h-matrix
199 <    hmat(0, 0) = tokenizer.nextTokenAsDouble();
200 <    hmat(0, 1) = tokenizer.nextTokenAsDouble();
201 <    hmat(0, 2) = tokenizer.nextTokenAsDouble();
202 <    hmat(1, 0) = tokenizer.nextTokenAsDouble();
203 <    hmat(1, 1) = tokenizer.nextTokenAsDouble();
204 <    hmat(1, 2) = tokenizer.nextTokenAsDouble();
205 <    hmat(2, 0) = tokenizer.nextTokenAsDouble();
206 <    hmat(2, 1) = tokenizer.nextTokenAsDouble();
207 <    hmat(2, 2) = tokenizer.nextTokenAsDouble();
208 <    s->setHmat(hmat);
209 <    
210 <    //read chi and integralOfChidt, they should apprear in pair
211 <    if (tokenizer.countTokens() >= 2) {
212 <      chi = tokenizer.nextTokenAsDouble();
213 <      integralOfChiDt = tokenizer.nextTokenAsDouble();            
214 <      
215 <      s->setChi(chi);
216 <      s->setIntegralOfChiDt(integralOfChiDt);
217 <    }
218 <    
219 <    //read eta (eta is 3x3 matrix)
220 <    if (tokenizer.countTokens() >= 9) {
221 <      eta(0, 0) = tokenizer.nextTokenAsDouble();
222 <      eta(0, 1) = tokenizer.nextTokenAsDouble();
223 <      eta(0, 2) = tokenizer.nextTokenAsDouble();
224 <      eta(1, 0) = tokenizer.nextTokenAsDouble();
225 <      eta(1, 1) = tokenizer.nextTokenAsDouble();
226 <      eta(1, 2) = tokenizer.nextTokenAsDouble();
227 <      eta(2, 0) = tokenizer.nextTokenAsDouble();
228 <      eta(2, 1) = tokenizer.nextTokenAsDouble();
229 <      eta(2, 2) = tokenizer.nextTokenAsDouble();      
230 <      
231 <      s->setEta(eta);
232 <    }
233 <    
234 <    
235 <  }
236 <  
237 < }//end namespace oopse
157 >      
158 >      while (!inFile_->eof()) {
159 >        framePos_.push_back(currPos);
160 >        
161 >        i = atoi(readBuffer);
162 >        
163 >        inFile_->getline(readBuffer, sizeof(readBuffer));
164 >        lineNum++;
165 >        
166 >        if (inFile_->eof()) {
167 >          sprintf(painCave.errMsg,
168 >                  "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
169 >                  filename_.c_str(),
170 >                  lineNum);
171 >          painCave.isFatal = 1;
172 >          simError();
173 >        }
174 >        
175 >        for(j = 0; j < i; j++) {
176 >          inFile_->getline(readBuffer, sizeof(readBuffer));
177 >          lineNum++;
178 >          
179 >          if (inFile_->eof()) {
180 >            sprintf(painCave.errMsg,
181 >                    "DumpReader Error: File \"%s\" ended unexpectedly at line %d,"
182 >                    " with atom %d\n", filename_.c_str(),
183 >                    lineNum,
184 >                    j);
185 >            
186 >            painCave.isFatal = 1;
187 >            simError();
188 >          }
189 >        }
190 >        
191 >        currPos = inFile_->tellg();
192 >        inFile_->getline(readBuffer, sizeof(readBuffer));
193 >        lineNum++;
194 >      }
195 >
196 >      inFile_->seekg (0, std::ios::beg);
197 >      
198 >      nframes_ = framePos_.size();
199 > #ifdef IS_MPI
200 >    }
201 >    
202 >    MPI_Bcast(&nframes_, 1, MPI_INT, 0, MPI_COMM_WORLD);
203 >    
204 >    strcpy(checkPointMsg, "Successfully scanned DumpFile\n");
205 >    MPIcheckPoint();
206 >    
207 > #endif // is_mpi
208 >    
209 >    isScanned_ = true;
210 >  }
211 >  
212 >  void DumpReader::readFrame(int whichFrame) {
213 >    if (!isScanned_)
214 >      scanFile();
215 >        
216 >    int storageLayout = info_->getSnapshotManager()->getStorageLayout();
217 >    
218 >    if (storageLayout & DataStorage::dslPosition) {
219 >      needPos_ = true;
220 >    } else {
221 >      needPos_ = false;
222 >    }
223 >    
224 >    if (storageLayout & DataStorage::dslVelocity) {
225 >      needVel_ = true;
226 >    } else {
227 >      needVel_ = false;
228 >    }
229 >    
230 >    if (storageLayout & DataStorage::dslAmat || storageLayout & DataStorage::dslElectroFrame) {
231 >      needQuaternion_ = true;
232 >    } else {
233 >      needQuaternion_ = false;
234 >    }
235 >    
236 >    if (storageLayout & DataStorage::dslAngularMomentum) {
237 >      needAngMom_ = true;
238 >    } else {
239 >      needAngMom_ = false;    
240 >    }
241 >    
242 >    readSet(whichFrame);
243 >  }
244 >  
245 >  void DumpReader::readSet(int whichFrame) {
246 >    int i;
247 >    int nTotObjs;                  // the number of atoms
248 >    char read_buffer[maxBufferSize];  //the line buffer for reading
249 >    char * eof_test;               // ptr to see when we reach the end of the file
250 >    
251 >    Molecule* mol;
252 >    StuntDouble* integrableObject;
253 >    SimInfo::MoleculeIterator mi;
254 >    Molecule::IntegrableObjectIterator ii;
255 >    
256 > #ifndef IS_MPI
257 >    inFile_->clear();  
258 >    inFile_->seekg(framePos_[whichFrame]);
259 >        
260 >    if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
261 >      sprintf(painCave.errMsg,
262 >              "DumpReader error: error reading 1st line of \"%s\"\n",
263 >              filename_.c_str());
264 >      painCave.isFatal = 1;
265 >      simError();
266 >    }
267 >    
268 >    nTotObjs = atoi(read_buffer);
269 >    
270 >    if (nTotObjs != info_->getNGlobalIntegrableObjects()) {
271 >      sprintf(painCave.errMsg,
272 >              "DumpReader error. %s nIntegrable, %d, "
273 >              "does not match the meta-data file's nIntegrable, %d.\n",
274 >              filename_.c_str(),
275 >              nTotObjs,
276 >              info_->getNGlobalIntegrableObjects());
277 >      
278 >      painCave.isFatal = 1;
279 >      simError();
280 >    }
281 >    
282 >    //read the box mat from the comment line
283 >    
284 >    
285 >    if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
286 >      sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
287 >              filename_.c_str());
288 >      painCave.isFatal = 1;
289 >      simError();
290 >    }
291 >    
292 >    parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
293 >    
294 >    //parse dump lines
295 >    
296 >    i = 0;
297 >    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
298 >      
299 >      for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;  
300 >           integrableObject = mol->nextIntegrableObject(ii)) {            
301 >        
302 >        
303 >        
304 >        if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
305 >          sprintf(painCave.errMsg,
306 >                  "DumpReader Error: error in reading file %s\n"
307 >                  "natoms  = %d; index = %d\n"
308 >                  "error reading the line from the file.\n",
309 >                  filename_.c_str(),
310 >                  nTotObjs,
311 >                  i);
312 >          
313 >          painCave.isFatal = 1;
314 >          simError();
315 >        }
316 >        
317 >        parseDumpLine(read_buffer, integrableObject);
318 >        i++;
319 >      }
320 >    }
321 >    
322 >    // MPI Section of code..........
323 >    
324 > #else //IS_MPI
325 >    
326 >    // first thing first, suspend fatalities.
327 >    int masterNode = 0;
328 >    int nCurObj;
329 >    painCave.isEventLoop = 1;
330 >    
331 >    int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
332 >    int haveError;
333 >    
334 >    MPI_Status istatus;
335 >    int nitems;
336 >    
337 >    nTotObjs = info_->getNGlobalIntegrableObjects();
338 >    haveError = 0;
339 >    
340 >    if (worldRank == masterNode) {
341 >      inFile_->clear();            
342 >      inFile_->seekg(framePos_[whichFrame]);
343 >      
344 >      if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
345 >        sprintf(painCave.errMsg, "DumpReader Error: Error reading 1st line of %s \n ",
346 >                filename_.c_str());
347 >        painCave.isFatal = 1;
348 >        simError();
349 >      }
350 >      
351 >      nitems = atoi(read_buffer);
352 >      
353 >      // Check to see that the number of integrable objects in the
354 >      // intial configuration file is the same as derived from the
355 >      // meta-data file.
356 >      
357 >      if (nTotObjs != nitems) {
358 >        sprintf(painCave.errMsg,
359 >                "DumpReader Error. %s nIntegrable, %d, "
360 >                "does not match the meta-data file's nIntegrable, %d.\n",
361 >                filename_.c_str(),
362 >                nTotObjs,
363 >                info_->getNGlobalIntegrableObjects());
364 >        
365 >        painCave.isFatal = 1;
366 >        simError();
367 >      }
368 >      
369 >      //read the boxMat from the comment line
370 >      
371 >      
372 >      
373 >      if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
374 >        sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
375 >                filename_.c_str());
376 >        painCave.isFatal = 1;
377 >        simError();
378 >      }
379 >      
380 >      //Every single processor will parse the comment line by itself
381 >      //By using this way, we might lose some efficiency, but if we want to add
382 >      //more parameters into comment line, we only need to modify function
383 >      //parseCommentLine
384 >      
385 >      MPI_Bcast(read_buffer, maxBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
386 >      parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
387 >      
388 >      for(i = 0; i < info_->getNGlobalMolecules(); i++) {
389 >        int which_node = info_->getMolToProc(i);
390 >        
391 >        if (which_node == masterNode) {
392 >          //molecules belong to master node
393 >          
394 >          mol = info_->getMoleculeByGlobalIndex(i);
395 >          
396 >          if (mol == NULL) {
397 >            sprintf(painCave.errMsg, "DumpReader Error: Molecule not found on node %d!", worldRank);
398 >            painCave.isFatal = 1;
399 >            simError();
400 >          }
401 >          
402 >          for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;  
403 >               integrableObject = mol->nextIntegrableObject(ii)){
404 >            
405 >            
406 >            
407 >            if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
408 >              sprintf(painCave.errMsg,
409 >                      "DumpReader Error: error in reading file %s\n"
410 >                      "natoms  = %d; index = %d\n"
411 >                      "error reading the line from the file.\n",
412 >                      filename_.c_str(),
413 >                      nTotObjs,
414 >                      i);
415 >              
416 >              painCave.isFatal = 1;
417 >              simError();
418 >            }
419 >            
420 >            parseDumpLine(read_buffer, integrableObject);
421 >          }
422 >        } else {
423 >          //molecule belongs to slave nodes
424 >          
425 >          MPI_Recv(&nCurObj, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
426 >                   MPI_COMM_WORLD, &istatus);
427 >          
428 >          for(int j = 0; j < nCurObj; j++) {
429 >            
430 >            
431 >            if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
432 >              sprintf(painCave.errMsg,
433 >                      "DumpReader Error: error in reading file %s\n"
434 >                      "natoms  = %d; index = %d\n"
435 >                      "error reading the line from the file.\n",
436 >                      filename_.c_str(),
437 >                      nTotObjs,
438 >                      i);
439 >              
440 >              painCave.isFatal = 1;
441 >              simError();
442 >            }
443 >            
444 >            MPI_Send(read_buffer, maxBufferSize, MPI_CHAR, which_node,
445 >                     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
446 >          }
447 >        }
448 >      }
449 >    } else {
450 >      //actions taken at slave nodes
451 >      MPI_Bcast(read_buffer, maxBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
452 >      
453 >      /**@todo*/
454 >      parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
455 >      
456 >      for(i = 0; i < info_->getNGlobalMolecules(); i++) {
457 >        int which_node = info_->getMolToProc(i);
458 >        
459 >        if (which_node == worldRank) {
460 >          //molecule with global index i belongs to this processor
461 >          
462 >          mol = info_->getMoleculeByGlobalIndex(i);
463 >          if (mol == NULL) {
464 >            sprintf(painCave.errMsg, "DumpReader Error: Molecule not found on node %d!", worldRank);
465 >            painCave.isFatal = 1;
466 >            simError();
467 >          }
468 >          
469 >          nCurObj = mol->getNIntegrableObjects();
470 >          
471 >          MPI_Send(&nCurObj, 1, MPI_INT, masterNode, TAKE_THIS_TAG_INT,
472 >                   MPI_COMM_WORLD);
473 >          
474 >          for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;  
475 >               integrableObject = mol->nextIntegrableObject(ii)){
476 >            
477 >            MPI_Recv(read_buffer, maxBufferSize, MPI_CHAR, masterNode,
478 >                     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
479 >            
480 >            parseDumpLine(read_buffer, integrableObject);
481 >          }
482 >          
483 >        }
484 >        
485 >      }
486 >      
487 >    }
488 >    
489 > #endif
490 >    
491 >  }
492 >  
493 >  void DumpReader::parseDumpLine(char *line, StuntDouble *integrableObject) {
494 >    
495 >    Vector3d pos;  // position place holders
496 >    Vector3d vel;  // velocity placeholders
497 >    Quat4d q;    // the quaternions
498 >    Vector3d ji;   // angular velocity placeholders;
499 >    StringTokenizer tokenizer(line);
500 >    int nTokens;
501 >    
502 >    nTokens = tokenizer.countTokens();
503 >    
504 >    if (nTokens < 14) {
505 >      sprintf(painCave.errMsg,
506 >              "DumpReader Error: Not enough Tokens.\n%s\n", line);
507 >      painCave.isFatal = 1;
508 >      simError();
509 >    }
510 >    
511 >    std::string name = tokenizer.nextToken();
512 >    
513 >    if (name != integrableObject->getType()) {
514 >      
515 >      sprintf(painCave.errMsg,
516 >              "DumpReader Error: Atom type [%s] in %s does not match Atom Type [%s] in .md file.\n",
517 >              name.c_str(), filename_.c_str(), integrableObject->getType().c_str());
518 >      painCave.isFatal = 1;
519 >      simError();        
520 >    }
521 >    
522 >    pos[0] = tokenizer.nextTokenAsDouble();
523 >    pos[1] = tokenizer.nextTokenAsDouble();
524 >    pos[2] = tokenizer.nextTokenAsDouble();
525 >    if (needPos_) {
526 >      integrableObject->setPos(pos);
527 >    }
528 >    
529 >    vel[0] = tokenizer.nextTokenAsDouble();
530 >    vel[1] = tokenizer.nextTokenAsDouble();
531 >    vel[2] = tokenizer.nextTokenAsDouble();
532 >    if (needVel_) {
533 >      integrableObject->setVel(vel);
534 >    }
535 >    
536 >    if (integrableObject->isDirectional()) {
537 >      
538 >      q[0] = tokenizer.nextTokenAsDouble();
539 >      q[1] = tokenizer.nextTokenAsDouble();
540 >      q[2] = tokenizer.nextTokenAsDouble();
541 >      q[3] = tokenizer.nextTokenAsDouble();
542 >      
543 >      RealType qlen = q.length();
544 >      if (qlen < oopse::epsilon) { //check quaternion is not equal to 0
545 >        
546 >        sprintf(painCave.errMsg,
547 >                "DumpReader Error: initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2) ~ 0\n");
548 >        painCave.isFatal = 1;
549 >        simError();
550 >        
551 >      }  
552 >      
553 >      q.normalize();
554 >      if (needQuaternion_) {            
555 >        integrableObject->setQ(q);
556 >      }
557 >      
558 >      ji[0] = tokenizer.nextTokenAsDouble();
559 >      ji[1] = tokenizer.nextTokenAsDouble();
560 >      ji[2] = tokenizer.nextTokenAsDouble();
561 >      if (needAngMom_) {
562 >        integrableObject->setJ(ji);
563 >      }
564 >    }
565 >    
566 >  }
567 >  
568 >  
569 >  void DumpReader::parseCommentLine(char* line, Snapshot* s) {
570 >    RealType currTime;
571 >    Mat3x3d hmat;
572 >    RealType chi;
573 >    RealType integralOfChiDt;
574 >    Mat3x3d eta;
575 >    
576 >    StringTokenizer tokenizer(line);
577 >    int nTokens;
578 >    
579 >    nTokens = tokenizer.countTokens();
580 >    
581 >    //comment line should at least contain 10 tokens: current time(1 token) and  h-matrix(9 tokens)
582 >    if (nTokens < 10) {
583 >      sprintf(painCave.errMsg,
584 >              "DumpReader Error: Not enough tokens in comment line: %s", line);
585 >      painCave.isFatal = 1;
586 >      simError();    
587 >    }
588 >    
589 >    //read current time
590 >    currTime = tokenizer.nextTokenAsDouble();
591 >    s->setTime(currTime);
592 >    
593 >    //read h-matrix
594 >    hmat(0, 0) = tokenizer.nextTokenAsDouble();
595 >    hmat(0, 1) = tokenizer.nextTokenAsDouble();
596 >    hmat(0, 2) = tokenizer.nextTokenAsDouble();
597 >    hmat(1, 0) = tokenizer.nextTokenAsDouble();
598 >    hmat(1, 1) = tokenizer.nextTokenAsDouble();
599 >    hmat(1, 2) = tokenizer.nextTokenAsDouble();
600 >    hmat(2, 0) = tokenizer.nextTokenAsDouble();
601 >    hmat(2, 1) = tokenizer.nextTokenAsDouble();
602 >    hmat(2, 2) = tokenizer.nextTokenAsDouble();
603 >    s->setHmat(hmat);
604 >    
605 >    //read chi and integralOfChidt, they should apprear in pair
606 >    if (tokenizer.countTokens() >= 2) {
607 >      chi = tokenizer.nextTokenAsDouble();
608 >      integralOfChiDt = tokenizer.nextTokenAsDouble();            
609 >      
610 >      s->setChi(chi);
611 >      s->setIntegralOfChiDt(integralOfChiDt);
612 >    }
613 >    
614 >    //read eta (eta is 3x3 matrix)
615 >    if (tokenizer.countTokens() >= 9) {
616 >      eta(0, 0) = tokenizer.nextTokenAsDouble();
617 >      eta(0, 1) = tokenizer.nextTokenAsDouble();
618 >      eta(0, 2) = tokenizer.nextTokenAsDouble();
619 >      eta(1, 0) = tokenizer.nextTokenAsDouble();
620 >      eta(1, 1) = tokenizer.nextTokenAsDouble();
621 >      eta(1, 2) = tokenizer.nextTokenAsDouble();
622 >      eta(2, 0) = tokenizer.nextTokenAsDouble();
623 >      eta(2, 1) = tokenizer.nextTokenAsDouble();
624 >      eta(2, 2) = tokenizer.nextTokenAsDouble();      
625 >      
626 >      s->setEta(eta);
627 >    }
628 >    
629 >    
630 >  }
631 >  
632 > }//end namespace oopse

Diff Legend

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