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

Comparing trunk/OOPSE-4/src/io/DumpReader.cpp (file contents):
Revision 1625 by tim, Thu Oct 21 16:22:01 2004 UTC vs.
Revision 2300 by tim, Thu Sep 15 19:17:04 2005 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  
# Line 11 | Line 52
52   #include <stdlib.h>
53   #include <string.h>
54  
55 <
56 < #include "io/ReadWrite.hpp"
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>
20 – #include "brains/mpiSimulation.hpp"
64   #define TAKE_THIS_TAG_CHAR 0
65   #define TAKE_THIS_TAG_INT 1
66 +
67   #endif // is_mpi
68  
69  
70 < DumpReader :: DumpReader(const char *in_name ){
27 <
28 <  isScanned = false;
29 <
30 < #ifdef IS_MPI
31 <  if (worldRank == 0) {
32 < #endif
33 <
34 <  inFile = fopen(in_name, "r");
35 <  if(inFile == NULL){
36 <    sprintf(painCave.errMsg,
37 <            "Cannot open file: %s\n", in_name);
38 <    painCave.isFatal = 1;
39 <    simError();
40 <  }
70 > namespace oopse {
71    
72 <  inFileName = in_name;
72 >  DumpReader::DumpReader(SimInfo* info, const std::string& filename)
73 >    : info_(info), filename_(filename), isScanned_(false), nframes_(0) {
74 >    
75   #ifdef IS_MPI
76 <  }
77 <  strcpy( checkPointMsg, "Dump file opened for reading successfully." );
46 <  MPIcheckPoint();
76 >    
77 >      if (worldRank == 0) {
78   #endif
79 <  return;  
80 < }
81 <
82 < DumpReader :: ~DumpReader( ){
79 >      
80 >        inFile_ = fopen(filename_.c_str(), "r");
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 >        }
87 >      
88   #ifdef IS_MPI
89 <  if (worldRank == 0) {
89 >      
90 >      }
91 >    
92 >      strcpy(checkPointMsg, "Dump file opened for reading successfully.");
93 >      MPIcheckPoint();
94 >    
95   #endif
96 <  vector<fpos_t*>::iterator i;
97 <
98 <  int error;
58 <  error = fclose( inFile );
59 <  if( error ){
60 <    sprintf( painCave.errMsg,
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();
96 >    
97 >      return;
98 >    }
99    
100 +  DumpReader::~DumpReader() {
101 +    
102   #ifdef IS_MPI
70 –  }
71 –  strcpy( checkPointMsg, "Dump file closed successfully." );
72 –  MPIcheckPoint();
73 – #endif
74 –
75 –  return;
76 – }
77 –
78 – int DumpReader::getNframes( void ){
79 –
80 –  if( !isScanned )
81 –    scanFile();
82 –  return framePos.size();
83 – }
84 –
85 – void DumpReader::scanFile( void ){
86 –
87 –  int i, j;
88 –  int lineNum = 0;
89 –  char readBuffer[2000];
90 –  fpos_t *currPos;
91 –
92 – #ifdef IS_MPI
93 –  if( worldRank == 0 ){
94 – #endif // is_mpi
103      
104 <    rewind( inFile );
105 <    
98 <    currPos = new fpos_t;
99 <    fgetpos( inFile, currPos );
100 <    fgets( readBuffer, sizeof( readBuffer ), inFile );
101 <    lineNum++;
102 <    if( feof( inFile ) ){
103 <      sprintf( painCave.errMsg,
104 <               "File \"%s\" ended unexpectedly at line %d\n",
105 <               inFileName.c_str(),
106 <               lineNum );
107 <      painCave.isFatal = 1;
108 <      simError();
109 <    }
110 <
111 <    while( !feof( inFile ) ){
104 >    if (worldRank == 0) {
105 > #endif
106        
107 <      framePos.push_back(currPos);
108 <
115 <      i = atoi(readBuffer);
107 >      int error;
108 >      error = fclose(inFile_);
109        
110 <      fgets( readBuffer, sizeof( readBuffer ), inFile );
111 <      lineNum++;    
112 <      if( feof( inFile ) ){
113 <        sprintf( painCave.errMsg,
121 <                 "File \"%s\" ended unexpectedly at line %d\n",
122 <                 inFileName.c_str(),
123 <                 lineNum );
124 <        painCave.isFatal = 1;
125 <        simError();
110 >      if (error) {
111 >        sprintf(painCave.errMsg, "DumpReader Error: Error closing %s\n", filename_.c_str());
112 >        painCave.isFatal = 1;            
113 >        simError();
114        }
127 –            
128 –      for(j=0; j<i; j++){
129 –        
130 –        fgets( readBuffer, sizeof( readBuffer ), inFile );
131 –        lineNum++;    
132 –        if( feof( inFile ) ){
133 –          sprintf( painCave.errMsg,
134 –                   "File \"%s\" ended unexpectedly at line %d,"
135 –                   " with atom %d\n",
136 –                   inFileName.c_str(),
137 –                   lineNum,
138 –                   j );
139 –          painCave.isFatal = 1;
140 –          simError();
141 –        }
142 –        
143 –      }
115        
116 <      currPos = new fpos_t;
117 <      fgetpos( inFile, currPos );
118 <      fgets( readBuffer, sizeof( readBuffer ), inFile );
119 <      lineNum++;
116 >      MemoryUtils::deletePointers(framePos_);
117 >      
118 > #ifdef IS_MPI
119 >      
120      }
121      
122 <    delete currPos;
123 <    rewind( inFile );
124 <    
125 <    isScanned = true;
126 <
127 < #ifdef IS_MPI
122 >    strcpy(checkPointMsg, "Dump file closed successfully.");
123 >    MPIcheckPoint();
124 >    
125 > #endif
126 >    
127 >    return;
128    }
129 <  strcpy( checkPointMsg, "Successfully scanned DumpFile\n" );
130 <  MPIcheckPoint();
131 < #endif // is_mpi
132 < }
133 <
134 < void DumpReader :: readFrame( SimInfo* the_simnfo, int whichFrame){
135 <
165 <  simnfo = the_simnfo;
166 <
167 <  this->readSet( whichFrame );
168 < }
169 <
170 <
171 <
172 < void DumpReader :: readSet( int whichFrame ){
173 <
174 <  int i;
175 <  unsigned int j;
176 <
177 < #ifdef IS_MPI
178 <  int done, which_node, which_atom; // loop counter
179 < #endif //is_mpi
180 <
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;
187 <
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 <             inFileName.c_str() );
199 <    painCave.isFatal = 1;
200 <    simError();
129 >  
130 >  int DumpReader::getNFrames(void) {
131 >    
132 >    if (!isScanned_)
133 >      scanFile();
134 >    
135 >    return nframes_;
136    }
137 <
138 <  nTotObjs = atoi( read_buffer );
139 <
140 <  if( nTotObjs != simnfo->getTotIntegrableObjects() ){
141 <    sprintf( painCave.errMsg,
142 <             "DumpReader error. %s nIntegrable, %d, "
143 <             "does not match the meta-data file's nIntegrable, %d.\n",
144 <             inFileName.c_str(), nTotObjs, simnfo->getTotIntegrableObjects());
145 <    painCave.isFatal = 1;
146 <    simError();
147 <  }
148 <
149 <  //read the box mat from the comment line
150 <
151 <  eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
152 <  if(eof_test == NULL){
153 <    sprintf( painCave.errMsg,
154 <             "error in reading commment in %s\n", inFileName.c_str());
155 <    painCave.isFatal = 1;
156 <    simError();
222 <  }
223 <
224 <  parseErr = parseCommentLine( read_buffer, simnfo);
225 <  if( parseErr != NULL ){
226 <    strcpy( painCave.errMsg, parseErr );
227 <    painCave.isFatal = 1;
228 <    simError();
229 <  }
230 <
231 <  //parse dump lines
232 <
233 <  for( i=0; i < simnfo->n_mol; i++){
234 <
235 <    integrableObjects = (simnfo->molecules[i]).getIntegrableObjects();
236 <
237 <    for(j = 0; j < integrableObjects.size(); j++){
238 <
239 <      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
240 <      if(eof_test == NULL){
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 <              "error in reading file %s\n"
159 <              "natoms  = %d; index = %d\n"
160 <              "error reading the line from the file.\n",
245 <              inFileName.c_str(), nTotObjs, i );
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 <      parseErr = parseDumpLine( read_buffer, integrableObjects[j]);
166 <      if( parseErr != NULL ){
167 <        strcpy( painCave.errMsg, parseErr );
168 <        painCave.isFatal = 1;
169 <        simError();
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 <  // MPI Section of code..........
222 < #else //IS_MPI
223 <
224 <  // first thing first, suspend fatalities.
225 <  painCave.isEventLoop = 1;
226 <
227 <  int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
228 <  int haveError;
229 <
230 <  MPI_Status istatus;
269 <  int *MolToProcMap = mpiSim->getMolToProcMap();
270 <  int localIndex;
271 <  int nCurObj;
272 <  int nitems;
273 <
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 %s \n ",inFileName.c_str());
283 <      haveError = 1;
284 <      simError();
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      }
232 <
233 <    nitems = atoi( read_buffer );
234 <
235 <    // Check to see that the number of integrable objects in the
236 <    // intial configuration file is the same as derived from the
237 <    // meta-data file.
238 <
239 <    if( nTotObjs != nitems){
240 <      sprintf( painCave.errMsg,
241 <               "DumpReader Error. %s nIntegrable, %d, "
242 <               "does not match the meta-data file's nIntegrable, %d.\n",
243 <               inFileName.c_str(), nTotObjs, simnfo->getTotIntegrableObjects());
244 <      haveError= 1;
232 >    
233 >    if (storageLayout & DataStorage::dslVelocity) {
234 >      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 >  }
253 >  
254 >  void DumpReader::readSet(int whichFrame) {
255 >    int i;
256 >    int nTotObjs;                  // the number of atoms
257 >    char read_buffer[maxBufferSize];  //the line buffer for reading
258 >    char * eof_test;               // ptr to see when we reach the end of the file
259 >    
260 >    Molecule* mol;
261 >    StuntDouble* integrableObject;
262 >    SimInfo::MoleculeIterator mi;
263 >    Molecule::IntegrableObjectIterator ii;
264 >    
265 > #ifndef IS_MPI
266 >    
267 >    fsetpos(inFile_, framePos_[whichFrame]);
268 >    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
269 >    
270 >    if (eof_test == NULL) {
271 >      sprintf(painCave.errMsg,
272 >              "DumpReader error: error reading 1st line of \"%s\"\n",
273 >              filename_.c_str());
274 >      painCave.isFatal = 1;
275        simError();
276      }
277 <
278 <    //read the boxMat from the comment line
279 <
280 <    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
281 <    if(eof_test == NULL){
282 <      sprintf( painCave.errMsg,
283 <               "error in reading commment in %s\n", inFileName.c_str());
284 <      haveError = 1;
277 >    
278 >    nTotObjs = atoi(read_buffer);
279 >    
280 >    if (nTotObjs != info_->getNGlobalIntegrableObjects()) {
281 >      sprintf(painCave.errMsg,
282 >              "DumpReader error. %s nIntegrable, %d, "
283 >              "does not match the meta-data file's nIntegrable, %d.\n",
284 >              filename_.c_str(),
285 >              nTotObjs,
286 >              info_->getNGlobalIntegrableObjects());
287 >      
288 >      painCave.isFatal = 1;
289        simError();
290      }
291 <
292 <    //Every single processor will parse the comment line by itself
293 <    //By using this way, we might lose some efficiency, but if we want to add
294 <    //more parameters into comment line, we only need to modify function
295 <    //parseCommentLine
296 <
297 <    MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
298 <
299 <    parseErr = parseCommentLine( read_buffer, simnfo);
320 <
321 <    if( parseErr != NULL ){
322 <      strcpy( painCave.errMsg, parseErr );
323 <      haveError = 1;
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 <    for (i=0 ; i < mpiSim->getNMolGlobal(); i++) {
304 <      which_node = MolToProcMap[i];
305 <      if(which_node == 0){
306 <       //molecules belong to master node
307 <
308 <      localIndex = mpiSim->getGlobalToLocalMol(i);
309 <
310 <      if(localIndex == -1) {
311 <        strcpy(painCave.errMsg, "Molecule not found on node 0!");
312 <        haveError = 1;
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 <       integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();
364 <       for(j=0; j < integrableObjects.size(); j++){
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 <          eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
378 <          if(eof_test == NULL){
345 <                sprintf(painCave.errMsg,
346 <                    "error in reading file %s\n"
347 <                    "natoms  = %d; index = %d\n"
348 <                    "error reading the line from the file.\n",
349 <                    inFileName.c_str(), nTotObjs, i );
350 <                haveError= 1;
351 <                simError();
352 <          }
353 <          
354 <          if(haveError) nodeZeroError();
355 <
356 <          parseDumpLine(read_buffer, integrableObjects[j]);
357 <          
358 <       }
359 <
360 <
377 >        painCave.isFatal = 1;
378 >        simError();
379        }
362 –      else{
363 –      //molecule belongs to slave nodes
364 –
365 –        MPI_Recv(&nCurObj, 1, MPI_INT, which_node,
366 –               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
380        
381 <       for(j=0; j < nCurObj; j++){
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 <          eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
404 <          if(eof_test == NULL){
405 <                sprintf(painCave.errMsg,
406 <                    "error in reading file %s\n"
407 <                    "natoms  = %d; index = %d\n"
408 <                    "error reading the line from the file.\n",
409 <                    inFileName.c_str(), nTotObjs, i );
410 <                haveError= 1;
411 <                simError();
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 <          if(haveError) nodeZeroError();
415 <
416 <            MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
417 <                      TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
418 <          
419 <       }
420 <
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 <  else{
505 <  //actions taken at slave nodes
506 <    MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
507 <
508 <    parseErr = parseCommentLine( read_buffer, simnfo);
509 <
510 <    if( parseErr != NULL ){
511 <      strcpy( painCave.errMsg, parseErr );
512 <      haveError = 1;
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 <    for (i=0 ; i < mpiSim->getNMolGlobal(); i++) {
524 <      which_node = MolToProcMap[i];
522 >    
523 >    std::string name = tokenizer.nextToken();
524 >    
525 >    if (name != integrableObject->getType()) {
526        
527 <      if(which_node == worldRank){
528 <      //molecule with global index i belongs to this processor
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 <        localIndex = mpiSim->getGlobalToLocalMol(i);
551 <
552 <        if(localIndex == -1) {
553 <          sprintf(painCave.errMsg, "Molecule not found on node %d\n", worldRank);
554 <          haveError = 1;
555 <          simError();
556 <        }
418 <
419 <        integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();        
420 <
421 <        nCurObj = integrableObjects.size();
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 <        MPI_Send(&nCurObj, 1, MPI_INT, 0,
559 <                        TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
560 <
561 <        for(j = 0; j < integrableObjects.size(); j++){
562 <
563 <          MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
564 <                              TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
565 <
566 <          parseErr = parseDumpLine(read_buffer, integrableObjects[j]);
567 <
433 <          if( parseErr != NULL ){
434 <                strcpy( painCave.errMsg, parseErr );
435 <                simError();
436 <          }
437 <
438 <        }
439 <          
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 >        
563 >      }
564 >      
565 >      q.normalize();
566 >      if (needQuaternion_) {          
567 >        integrableObject->setQ(q);
568        }
569        
570 +      ji[0] = tokenizer.nextTokenAsDouble();
571 +      ji[1] = tokenizer.nextTokenAsDouble();
572 +      ji[2] = tokenizer.nextTokenAsDouble();
573 +      if (needAngMom_) {
574 +        integrableObject->setJ(ji);
575 +      }
576      }
577 <
577 >    
578    }
579 <
580 < #endif
581 < }
582 <
583 < char* DumpReader::parseDumpLine(char* readLine, StuntDouble* sd){
584 <
585 <  char *foo; // the pointer to the current string token
586 <
587 <  double pos[3]; // position place holders
588 <  double vel[3]; // velocity placeholders
589 <  double q[4]; // the quaternions
590 <  double ji[3]; // angular velocity placeholders;
591 <  double qSqr, qLength; // needed to normalize the quaternion vector.
592 <
593 <
594 <  // set the string tokenizer
461 <
462 <  foo = strtok(readLine, " ,;\t");
463 <
464 <  // check the atom name to the current atom
465 <
466 <  if( strcmp( foo, sd->getType() ) ){
467 <    sprintf( painCave.errMsg,
468 <             "DumpReader error.  Does not"
469 <             " match the meta-data atom %s.\n",
470 <             sd->getType() );
471 <    return strdup( painCave.errMsg );
472 <  }
473 <
474 <  // get the positions
475 <
476 <  foo = strtok(NULL, " ,;\t");
477 <  if(foo == NULL){
478 <    sprintf( painCave.errMsg,
479 <             "error in reading postition x from %s\n",
480 <             inFileName.c_str());
481 <    return strdup( painCave.errMsg );
482 <  }
483 <  pos[0] = atof( foo );
484 <
485 <  foo = strtok(NULL, " ,;\t");
486 <  if(foo == NULL){
487 <    sprintf( painCave.errMsg,
488 <             "error in reading postition y from %s\n",
489 <             inFileName.c_str());
490 <    return strdup( painCave.errMsg );
491 <  }
492 <  pos[1] = atof( foo );
493 <
494 <  foo = strtok(NULL, " ,;\t");
495 <  if(foo == NULL){
496 <    sprintf( painCave.errMsg,
497 <             "error in reading postition z from %s\n",
498 <             inFileName.c_str());
499 <    return strdup( painCave.errMsg );
500 <  }
501 <  pos[2] = atof( foo );
502 <
503 <
504 <  // get the velocities
505 <
506 <  foo = strtok(NULL, " ,;\t");
507 <  if(foo == NULL){
508 <    sprintf( painCave.errMsg,
509 <             "error in reading velocity x from %s\n",
510 <             inFileName.c_str() );
511 <    return strdup( painCave.errMsg );
512 <  }
513 <  vel[0] = atof( foo );
514 <
515 <  foo = strtok(NULL, " ,;\t");
516 <  if(foo == NULL){
517 <    sprintf( painCave.errMsg,
518 <             "error in reading velocity x from %s\n",
519 <             inFileName.c_str() );
520 <    return strdup( painCave.errMsg );
521 <  }
522 <  vel[1] = atof( foo );
523 <
524 <  foo = strtok(NULL, " ,;\t");
525 <  if(foo == NULL){
526 <    sprintf( painCave.errMsg,
527 <             "error in reading velocity x from %s\n",
528 <             inFileName.c_str() );
529 <    return strdup( painCave.errMsg );
530 <  }
531 <  vel[2] = atof( foo );
532 <
533 <
534 <  // add the positions and velocities to the atom
535 <
536 <  sd->setPos( pos );
537 <  sd->setVel( vel );
538 <
539 <  if (!sd->isDirectional())
540 <    return NULL;
541 <
542 <  // get the quaternions
543 <
544 <  if( sd->isDirectional() ){
545 <
546 <    foo = strtok(NULL, " ,;\t");
547 <    if(foo == NULL){
548 <      sprintf( painCave.errMsg,
549 <                     "error in reading velocity x from %s\n",
550 <                      inFileName.c_str() );
551 <      return strdup( painCave.errMsg );
552 <    }
553 <    q[0] = atof( foo );
554 <
555 <    foo = strtok(NULL, " ,;\t");
556 <    if(foo == NULL){
557 <      sprintf( painCave.errMsg,
558 <                     "error in reading velocity x from %s\n",
559 <                      inFileName.c_str() );
560 <      return strdup( painCave.errMsg );
561 <    }
562 <    q[1] = atof( foo );
563 <
564 <    foo = strtok(NULL, " ,;\t");
565 <    if(foo == NULL){
566 <      sprintf( painCave.errMsg,
567 <                     "error in reading velocity x from %s\n",
568 <                      inFileName.c_str() );
569 <      return strdup( painCave.errMsg );
570 <    }
571 <    q[2] = atof( foo );
572 <
573 <    foo = strtok(NULL, " ,;\t");
574 <    if(foo == NULL){
575 <      sprintf( painCave.errMsg,
576 <                     "error in reading velocity x from %s\n",
577 <                      inFileName.c_str() );
578 <      return strdup( painCave.errMsg );
579 <    }
580 <    q[3] = atof( foo );
581 <
582 <    // get the angular velocities
583 <
584 <    foo = strtok(NULL, " ,;\t");
585 <    if(foo == NULL){
586 <      sprintf( painCave.errMsg,
587 <                     "error in reading velocity x from %s\n",
588 <                      inFileName.c_str() );
589 <      return strdup( painCave.errMsg );
590 <    }
591 <    ji[0] = atof( foo );
592 <
593 <    foo = strtok(NULL, " ,;\t");
594 <    if(foo == NULL){
595 <      sprintf( painCave.errMsg,
596 <                     "error in reading velocity x from %s\n",
597 <                      inFileName.c_str() );
598 <      return strdup( painCave.errMsg );
599 <    }
600 <    ji[1] = atof(foo );
601 <
602 <    foo = strtok(NULL, " ,;\t");
603 <    if(foo == NULL){
604 <      sprintf( painCave.errMsg,
605 <                     "error in reading velocity x from %s\n",
606 <                      inFileName.c_str() );
607 <      return strdup( painCave.errMsg );
608 <    }
609 <    ji[2] = atof( foo );
610 <
611 <
612 <    // check that the quaternion vector is normalized
613 <
614 <    qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
615 <
616 <    if (fabs(qSqr) < 1e-6) {
579 >  
580 >  
581 >  void DumpReader::parseCommentLine(char* line, Snapshot* s) {
582 >    double currTime;
583 >    Mat3x3d hmat;
584 >    double chi;
585 >    double integralOfChiDt;
586 >    Mat3x3d eta;
587 >    
588 >    StringTokenizer tokenizer(line);
589 >    int nTokens;
590 >    
591 >    nTokens = tokenizer.countTokens();
592 >    
593 >    //comment line should at least contain 10 tokens: current time(1 token) and  h-matrix(9 tokens)
594 >    if (nTokens < 10) {
595        sprintf(painCave.errMsg,
596 <          "initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2 ~ 0).\n");
597 <       return strdup(painCave.errMsg);
596 >              "DumpReader Error: Not enough tokens in comment line: %s", line);
597 >      painCave.isFatal = 1;
598 >      simError();  
599      }
600 <
601 <    qLength = sqrt( qSqr );
602 <    q[0] = q[0] / qLength;
603 <    q[1] = q[1] / qLength;
604 <    q[2] = q[2] / qLength;
605 <    q[3] = q[3] / qLength;
606 <
607 <    // add quaternion and angular velocities
608 <
609 <    sd->setQ( q );
610 <    sd->setJ( ji );
611 <  }
612 <
613 <
614 <
615 <  return NULL;
616 < }
617 <
618 <
619 < char* DumpReader::parseCommentLine(char* readLine, SimInfo* entry_plug){
620 <
642 <  double currTime;
643 <  double boxMat[9];
644 <  double theBoxMat3[3][3];
645 <  double chi;
646 <  double integralOfChidt;
647 <  double eta[9];
648 <
649 <  char *foo; // the pointer to the current string token
650 <
651 <  // set the string tokenizer
652 <
653 <  foo = strtok(readLine, " ,;\t");
654 <  // set the timeToken.
655 <
656 <  if(foo == NULL){
657 <    sprintf( painCave.errMsg,
658 <             "error in reading Time from %s\n",
659 <             inFileName.c_str() );
660 <    return strdup( painCave.errMsg );
661 <  }
662 <
663 <  currTime = atof( foo );
664 <  entry_plug->setTime( currTime );
665 <
666 <  //get H-Matrix
667 <
668 <  for(int i = 0 ; i < 9; i++){
669 <    foo = strtok(NULL, " ,;\t");
670 <    if(foo == NULL){
671 <      sprintf( painCave.errMsg,
672 <               "error in reading H[%d] from %s\n", i, inFileName.c_str() );
673 <      return strdup( painCave.errMsg );
674 <    }
675 <    boxMat[i] = atof( foo );
676 <  }
677 <
678 <  for(int i=0;i<3;i++)
679 <    for(int j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
680 <
681 <  //set H-Matrix
682 <  entry_plug->setBoxM( theBoxMat3 );
683 <
684 <  //get chi and integralOfChidt, they should appear by pair
685 <
686 <  if( entry_plug->useInitXSstate ){
687 <    foo = strtok(NULL, " ,;\t\n");
688 <    if(foo != NULL){
689 <      chi = atof(foo);
600 >    
601 >    //read current time
602 >    currTime = tokenizer.nextTokenAsDouble();
603 >    s->setTime(currTime);
604 >    
605 >    //read h-matrix
606 >    hmat(0, 0) = tokenizer.nextTokenAsDouble();
607 >    hmat(0, 1) = tokenizer.nextTokenAsDouble();
608 >    hmat(0, 2) = tokenizer.nextTokenAsDouble();
609 >    hmat(1, 0) = tokenizer.nextTokenAsDouble();
610 >    hmat(1, 1) = tokenizer.nextTokenAsDouble();
611 >    hmat(1, 2) = tokenizer.nextTokenAsDouble();
612 >    hmat(2, 0) = tokenizer.nextTokenAsDouble();
613 >    hmat(2, 1) = tokenizer.nextTokenAsDouble();
614 >    hmat(2, 2) = tokenizer.nextTokenAsDouble();
615 >    s->setHmat(hmat);
616 >    
617 >    //read chi and integralOfChidt, they should apprear in pair
618 >    if (tokenizer.countTokens() >= 2) {
619 >      chi = tokenizer.nextTokenAsDouble();
620 >      integralOfChiDt = tokenizer.nextTokenAsDouble();            
621        
622 <      foo = strtok(NULL, " ,;\t\n");
623 <      if(foo == NULL){
693 <        sprintf( painCave.errMsg,
694 <                 "chi and integralOfChidt should appear by pair in %s\n", inFileName.c_str() );
695 <        return strdup( painCave.errMsg );
696 <      }
697 <      integralOfChidt = atof( foo );
698 <      
699 <      //push chi and integralOfChidt into SimInfo::properties which can be
700 <      //retrieved by integrator later
701 <      DoubleGenericData* chiValue = new DoubleGenericData();
702 <      chiValue->setID(CHIVALUE_ID);
703 <      chiValue->setData(chi);
704 <      entry_plug->addProperty(chiValue);
705 <      
706 <      DoubleGenericData* integralOfChidtValue = new DoubleGenericData();
707 <      integralOfChidtValue->setID(INTEGRALOFCHIDT_ID);
708 <      integralOfChidtValue->setData(integralOfChidt);
709 <      entry_plug->addProperty(integralOfChidtValue);
710 <      
622 >      s->setChi(chi);
623 >      s->setIntegralOfChiDt(integralOfChiDt);
624      }
712 –    else
713 –      return NULL;
625      
626 <    //get eta
627 <    foo = strtok(NULL, " ,;\t\n");
628 <    if(foo != NULL ){
629 <  
630 <      for(int i = 0 ; i < 9; i++){
631 <        
632 <        if(foo == NULL){
633 <          sprintf( painCave.errMsg,
634 <                   "error in reading eta[%d] from %s\n", i, inFileName.c_str() );
635 <          return strdup( painCave.errMsg );
636 <        }
637 <        eta[i] = atof( foo );
638 <        foo = strtok(NULL, " ,;\t\n");
728 <      }
626 >    //read eta (eta is 3x3 matrix)
627 >    if (tokenizer.countTokens() >= 9) {
628 >      eta(0, 0) = tokenizer.nextTokenAsDouble();
629 >      eta(0, 1) = tokenizer.nextTokenAsDouble();
630 >      eta(0, 2) = tokenizer.nextTokenAsDouble();
631 >      eta(1, 0) = tokenizer.nextTokenAsDouble();
632 >      eta(1, 1) = tokenizer.nextTokenAsDouble();
633 >      eta(1, 2) = tokenizer.nextTokenAsDouble();
634 >      eta(2, 0) = tokenizer.nextTokenAsDouble();
635 >      eta(2, 1) = tokenizer.nextTokenAsDouble();
636 >      eta(2, 2) = tokenizer.nextTokenAsDouble();      
637 >      
638 >      s->setEta(eta);
639      }
730 –    else
731 –      return NULL;
640      
641 <    //push eta into SimInfo::properties which can be
734 <    //retrieved by integrator later
735 <    //entry_plug->setBoxM( theBoxMat3 );
736 <    DoubleVectorGenericData* etaValue = new DoubleVectorGenericData(ETAVALUE_ID);
737 <    etaValue->insert(etaValue->end(), eta, eta+9);
738 <    entry_plug->addProperty(etaValue);
641 >    
642    }
643 <
644 <  return NULL;
742 < }
743 <
744 < #ifdef IS_MPI
745 < void DumpReader::nodeZeroError( void ){
746 <  int j, myStatus;
747 <
748 <  myStatus = 0;
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 <  }
753 <
754 <
755 <  MPI_Finalize();
756 <  exit (0);
757 <
758 < }
759 <
760 < void DumpReader::anonymousNodeDie( void ){
761 <
762 <  MPI_Finalize();
763 <  exit (0);
764 < }
765 < #endif
643 >  
644 > }//end namespace oopse

Diff Legend

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