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 996 by chrisfen, Wed Jun 28 14:35:14 2006 UTC vs.
Revision 1104 by gezelter, Fri Dec 29 21:43:18 2006 UTC

# Line 70 | Line 70 | namespace oopse {
70   namespace oopse {
71    
72    DumpReader::DumpReader(SimInfo* info, const std::string& filename)
73 <    : info_(info), filename_(filename), isScanned_(false), nframes_(0) {
73 >    : info_(info), filename_(filename), isScanned_(false), nframes_(0), needCOMprops_(false) {
74      
75   #ifdef IS_MPI
76      
# Line 129 | Line 129 | namespace oopse {
129    }
130    
131    void DumpReader::scanFile(void) {
132 <    int i, j;
133 <    int lineNum = 0;
134 <    char readBuffer[maxBufferSize];
132 >    int lineNo = 0;
133 >    std::streampos prevPos;
134      std::streampos  currPos;
135 <    
135 >    
136   #ifdef IS_MPI
137 <    
137 >    
138      if (worldRank == 0) {
139   #endif // is_mpi
140 <      
141 <      inFile_->seekg (0, std::ios::beg);
142 <      
143 <
144 <      currPos = inFile_->tellg();
145 <      inFile_->getline(readBuffer, sizeof(readBuffer));
146 <      lineNum++;
147 <      
148 <      if (inFile_->eof()) {
149 <        sprintf(painCave.errMsg,
150 <                "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
151 <                filename_.c_str(),
153 <                lineNum);
154 <        painCave.isFatal = 1;
155 <        simError();
156 <      }
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()) {
140 >      
141 >      currPos = inFile_->tellg();
142 >      prevPos = currPos;
143 >      bool foundOpenSnapshotTag = false;
144 >      bool foundClosedSnapshotTag = false;
145 >      while(inFile_->getline(buffer, bufferSize)) {
146 >        ++lineNo;
147 >        
148 >        std::string line = buffer;
149 >        currPos = inFile_->tellg();
150 >        if (line.find("<Snapshot>")!= std::string::npos) {
151 >          if (foundOpenSnapshotTag) {
152              sprintf(painCave.errMsg,
153 <                    "DumpReader Error: File \"%s\" ended unexpectedly at line %d,"
154 <                    " with atom %d\n", filename_.c_str(),
183 <                    lineNum,
184 <                    j);
185 <            
153 >                    "DumpReader:<Snapshot> is multiply nested at line %d in %s \n", lineNo,
154 >                    filename_.c_str());
155              painCave.isFatal = 1;
156 +            simError();          
157 +          }
158 +          foundOpenSnapshotTag = true;
159 +          foundClosedSnapshotTag = false;
160 +          framePos_.push_back(prevPos);
161 +          
162 +        } else if (line.find("</Snapshot>") != std::string::npos){
163 +          if (!foundOpenSnapshotTag) {
164 +            sprintf(painCave.errMsg,
165 +                    "DumpReader:</Snapshot> appears before <Snapshot> at line %d in %s \n", lineNo,
166 +                    filename_.c_str());
167 +            painCave.isFatal = 1;
168              simError();
169 <          }
170 <        }
171 <        
172 <        currPos = inFile_->tellg();
173 <        inFile_->getline(readBuffer, sizeof(readBuffer));
174 <        lineNum++;
175 <      }
176 <
177 <      inFile_->seekg (0, std::ios::beg);
178 <      
169 >          }
170 >          
171 >          if (foundClosedSnapshotTag) {
172 >            sprintf(painCave.errMsg,
173 >                    "DumpReader:</Snapshot> appears multiply nested at line %d in %s \n", lineNo,
174 >                    filename_.c_str());
175 >            painCave.isFatal = 1;
176 >            simError();
177 >          }
178 >          foundClosedSnapshotTag = true;
179 >          foundOpenSnapshotTag = false;
180 >        }
181 >        prevPos = currPos;
182 >      }
183 >      
184 >      // only found <Snapshot> for the last frame means the file is corrupted, we should discard
185 >      // it and give a warning message
186 >      if (foundOpenSnapshotTag) {
187 >        sprintf(painCave.errMsg,
188 >                "DumpReader: last frame in %s is invalid\n", filename_.c_str());
189 >        painCave.isFatal = 0;
190 >        simError();      
191 >        framePos_.pop_back();
192 >      }
193 >      
194        nframes_ = framePos_.size();
195 +      
196 +      if (nframes_ == 0) {
197 +        sprintf(painCave.errMsg,
198 +                "DumpReader: %s does not contain a valid frame\n", filename_.c_str());
199 +        painCave.isFatal = 1;
200 +        simError();      
201 +      }
202   #ifdef IS_MPI
203      }
204      
205      MPI_Bcast(&nframes_, 1, MPI_INT, 0, MPI_COMM_WORLD);
206 <    
204 <    strcpy(checkPointMsg, "Successfully scanned DumpFile\n");
205 <    MPIcheckPoint();
206 <    
206 >    
207   #endif // is_mpi
208 <    
208 >    
209      isScanned_ = true;
210    }
211    
# Line 240 | Line 240 | namespace oopse {
240      }
241      
242      readSet(whichFrame);
243 +
244 +    if (needCOMprops_) {
245 +      Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
246 +      Vector3d com;
247 +      Vector3d comvel;
248 +      Vector3d comw;
249 +      info_->getComAll(com, comvel);
250 +      comw = info_->getAngularMomentum();
251 +      s->setCOMprops(com, comvel, comw);      
252 +    }
253 +
254    }
255    
256 <  void DumpReader::readSet(int whichFrame) {
257 <    int i;
258 <    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 >  void DumpReader::readSet(int whichFrame) {    
257 >    std::string line;
258 >
259   #ifndef IS_MPI
260 +
261      inFile_->clear();  
262      inFile_->seekg(framePos_[whichFrame]);
263 <        
264 <    if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
265 <      sprintf(painCave.errMsg,
266 <              "DumpReader error: error reading 1st line of \"%s\"\n",
267 <              filename_.c_str());
268 <      painCave.isFatal = 1;
269 <      simError();
270 <    }
271 <    
272 <    nTotObjs = atoi(read_buffer);
273 <    
274 <    if (nTotObjs != info_->getNGlobalIntegrableObjects()) {
263 >
264 >    std::istream& inputStream = *inFile_;    
265 >
266 > #else
267 >    int masterNode = 0;
268 >    std::stringstream sstream;
269 >    if (worldRank == masterNode) {
270 >      std::string sendBuffer;
271 >
272 >      inFile_->clear();  
273 >      inFile_->seekg(framePos_[whichFrame]);
274 >      
275 >      while (inFile_->getline(buffer, bufferSize)) {
276 >
277 >        line = buffer;
278 >        sendBuffer += line;
279 >        sendBuffer += '\n';
280 >        if (line.find("</Snapshot>") != std::string::npos) {
281 >          break;
282 >        }        
283 >      }
284 >
285 >      int sendBufferSize = sendBuffer.size();
286 >      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);    
287 >      MPI_Bcast((void *)sendBuffer.c_str(), sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);    
288 >      
289 >      sstream.str(sendBuffer);
290 >    } else {
291 >      int sendBufferSize;
292 >      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);    
293 >      char * recvBuffer = new char[sendBufferSize+1];
294 >      MPI_Bcast(recvBuffer, sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);    
295 >      sstream.str(recvBuffer);
296 >    }      
297 >
298 >    std::istream& inputStream = sstream;  
299 > #endif
300 >
301 >    inputStream.getline(buffer, bufferSize);
302 >
303 >    line = buffer;
304 >    if (line.find("<Snapshot>") == std::string::npos) {
305        sprintf(painCave.errMsg,
306 <              "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 <      
306 >              "DumpReader Error: can not find <Snapshot>\n");
307        painCave.isFatal = 1;
308        simError();
309      }
310 <    
311 <    //read the box mat from the comment line
312 <    
313 <    
314 <    if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
315 <      sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
316 <              filename_.c_str());
310 >    
311 >    //read frameData
312 >    readFrameProperties(inputStream);
313 >
314 >    //read StuntDoubles
315 >    readStuntDoubles(inputStream);    
316 >
317 >    inputStream.getline(buffer, bufferSize);
318 >    line = buffer;
319 >    if (line.find("</Snapshot>") == std::string::npos) {
320 >      sprintf(painCave.errMsg,
321 >              "DumpReader Error: can not find </Snapshot>\n");
322        painCave.isFatal = 1;
323        simError();
324 <    }
325 <    
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 <    
324 >    }        
325 >  
326    }
327    
328 <  void DumpReader::parseDumpLine(char *line, StuntDouble *integrableObject) {
329 <    
330 <    Vector3d pos;  // position place holders
496 <    Vector3d vel;  // velocity placeholders
497 <    Quat4d q;    // the quaternions
498 <    Vector3d ji;   // angular velocity placeholders;
328 >  void DumpReader::parseDumpLine(const std::string& line) {
329 >
330 >      
331      StringTokenizer tokenizer(line);
332      int nTokens;
333      
334      nTokens = tokenizer.countTokens();
335      
336 <    if (nTokens < 14) {
336 >    if (nTokens < 2) {
337        sprintf(painCave.errMsg,
338 <              "DumpReader Error: Not enough Tokens.\n%s\n", line);
338 >              "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
339        painCave.isFatal = 1;
340        simError();
341      }
342 +
343 +    int index = tokenizer.nextTokenAsInt();
344 +
345 +    StuntDouble* integrableObject = info_->getIOIndexToIntegrableObject(index);
346 +
347 +    if (integrableObject == NULL) {
348 +      return;
349 +    }
350 +    std::string type = tokenizer.nextToken();
351 +    int size = type.size();
352 +
353 +    for(int i = 0; i < size; ++i) {
354 +      switch(type[i]) {
355 +        
356 +        case 'p': {
357 +            Vector3d pos;
358 +            pos[0] = tokenizer.nextTokenAsDouble();
359 +            pos[1] = tokenizer.nextTokenAsDouble();
360 +            pos[2] = tokenizer.nextTokenAsDouble();
361 +            if (needPos_) {
362 +              integrableObject->setPos(pos);
363 +            }            
364 +            break;
365 +        }
366 +        case 'v' : {
367 +            Vector3d vel;
368 +            vel[0] = tokenizer.nextTokenAsDouble();
369 +            vel[1] = tokenizer.nextTokenAsDouble();
370 +            vel[2] = tokenizer.nextTokenAsDouble();
371 +            if (needVel_) {
372 +              integrableObject->setVel(vel);
373 +            }
374 +            break;
375 +        }
376 +
377 +        case 'q' : {
378 +           Quat4d q;
379 +           if (integrableObject->isDirectional()) {
380 +              
381 +             q[0] = tokenizer.nextTokenAsDouble();
382 +             q[1] = tokenizer.nextTokenAsDouble();
383 +             q[2] = tokenizer.nextTokenAsDouble();
384 +             q[3] = tokenizer.nextTokenAsDouble();
385 +              
386 +             RealType qlen = q.length();
387 +             if (qlen < oopse::epsilon) { //check quaternion is not equal to 0
388 +                
389 +               sprintf(painCave.errMsg,
390 +                       "DumpReader Error: initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2) ~ 0\n");
391 +               painCave.isFatal = 1;
392 +               simError();
393 +                
394 +             }  
395 +              
396 +             q.normalize();
397 +             if (needQuaternion_) {            
398 +               integrableObject->setQ(q);
399 +             }              
400 +           }            
401 +           break;
402 +        }  
403 +        case 'j' : {
404 +          Vector3d ji;
405 +          if (integrableObject->isDirectional()) {
406 +             ji[0] = tokenizer.nextTokenAsDouble();
407 +             ji[1] = tokenizer.nextTokenAsDouble();
408 +             ji[2] = tokenizer.nextTokenAsDouble();
409 +             if (needAngMom_) {
410 +               integrableObject->setJ(ji);
411 +             }
412 +          }
413 +          break;
414 +        }  
415 +        case 'f': {
416 +
417 +          Vector3d force;
418 +          force[0] = tokenizer.nextTokenAsDouble();
419 +          force[1] = tokenizer.nextTokenAsDouble();
420 +          force[2] = tokenizer.nextTokenAsDouble();          
421 +          integrableObject->setFrc(force);
422 +          break;
423 +        }
424 +        case 't' : {
425 +
426 +           Vector3d torque;
427 +           torque[0] = tokenizer.nextTokenAsDouble();
428 +           torque[1] = tokenizer.nextTokenAsDouble();
429 +           torque[2] = tokenizer.nextTokenAsDouble();          
430 +           integrableObject->setTrq(torque);          
431 +           break;
432 +        }
433 +        default: {
434 +               sprintf(painCave.errMsg,
435 +                       "DumpReader Error: %s is an unrecognized type\n", type.c_str());
436 +               painCave.isFatal = 1;
437 +               simError();
438 +          break;  
439 +        }
440 +
441 +      }
442 +    }
443      
444 <    std::string name = tokenizer.nextToken();
445 <    
446 <    if (name != integrableObject->getType()) {
447 <      
444 >  }
445 >  
446 >
447 >  void  DumpReader::readStuntDoubles(std::istream& inputStream) {
448 >
449 >    inputStream.getline(buffer, bufferSize);
450 >    std::string line(buffer);
451 >    
452 >    if (line.find("<StuntDoubles>") == std::string::npos) {
453        sprintf(painCave.errMsg,
454 <              "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());
454 >              "DumpReader Error: Missing <StuntDoubles>\n");
455        painCave.isFatal = 1;
456 <      simError();        
457 <    }
458 <    
459 <    pos[0] = tokenizer.nextTokenAsDouble();
460 <    pos[1] = tokenizer.nextTokenAsDouble();
461 <    pos[2] = tokenizer.nextTokenAsDouble();
462 <    if (needPos_) {
463 <      integrableObject->setPos(pos);
464 <    }
465 <    
466 <    vel[0] = tokenizer.nextTokenAsDouble();
467 <    vel[1] = tokenizer.nextTokenAsDouble();
468 <    vel[2] = tokenizer.nextTokenAsDouble();
469 <    if (needVel_) {
470 <      integrableObject->setVel(vel);
471 <    }
472 <    
473 <    if (integrableObject->isDirectional()) {
474 <      
475 <      q[0] = tokenizer.nextTokenAsDouble();
476 <      q[1] = tokenizer.nextTokenAsDouble();
477 <      q[2] = tokenizer.nextTokenAsDouble();
478 <      q[3] = tokenizer.nextTokenAsDouble();
479 <      
480 <      RealType qlen = q.length();
481 <      if (qlen < oopse::epsilon) { //check quaternion is not equal to 0
482 <        
456 >      simError();
457 >    }
458 >
459 >    while(inputStream.getline(buffer, bufferSize)) {
460 >      line = buffer;
461 >      
462 >      if(line.find("</StuntDoubles>") != std::string::npos) {
463 >        break;
464 >      }
465 >
466 >      parseDumpLine(line);
467 >    }
468 >  
469 >  }
470 >
471 >  void DumpReader::readFrameProperties(std::istream& inputStream) {
472 >
473 >    Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
474 >    inputStream.getline(buffer, bufferSize);
475 >    std::string line(buffer);
476 >
477 >    if (line.find("<FrameData>") == std::string::npos) {
478 >      sprintf(painCave.errMsg,
479 >              "DumpReader Error: Missing <FrameData>\n");
480 >      painCave.isFatal = 1;
481 >      simError();
482 >    }
483 >
484 >    while(inputStream.getline(buffer, bufferSize)) {
485 >      line = buffer;
486 >      
487 >      if(line.find("</FrameData>") != std::string::npos) {
488 >        break;
489 >      }
490 >      
491 >      StringTokenizer tokenizer(line, " ;\t\n\r{}:,");
492 >      if (!tokenizer.hasMoreTokens()) {
493          sprintf(painCave.errMsg,
494 <                "DumpReader Error: initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2) ~ 0\n");
494 >                "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
495          painCave.isFatal = 1;
496 <        simError();
497 <        
498 <      }  
499 <      
500 <      q.normalize();
501 <      if (needQuaternion_) {            
502 <        integrableObject->setQ(q);
503 <      }
504 <      
505 <      ji[0] = tokenizer.nextTokenAsDouble();
506 <      ji[1] = tokenizer.nextTokenAsDouble();
507 <      ji[2] = tokenizer.nextTokenAsDouble();
508 <      if (needAngMom_) {
509 <        integrableObject->setJ(ji);
510 <      }
511 <    }
512 <    
513 <  }
496 >        simError();      
497 >      }
498 >
499 >      std::string propertyName = tokenizer.nextToken();
500 >      if (propertyName == "Time") {
501 >        RealType currTime = tokenizer.nextTokenAsDouble();
502 >        s->setTime(currTime);
503 >      } else if (propertyName == "Hmat"){
504 >        Mat3x3d hmat;
505 >        hmat(0, 0) = tokenizer.nextTokenAsDouble();
506 >        hmat(0, 1) = tokenizer.nextTokenAsDouble();
507 >        hmat(0, 2) = tokenizer.nextTokenAsDouble();
508 >        hmat(1, 0) = tokenizer.nextTokenAsDouble();
509 >        hmat(1, 1) = tokenizer.nextTokenAsDouble();
510 >        hmat(1, 2) = tokenizer.nextTokenAsDouble();
511 >        hmat(2, 0) = tokenizer.nextTokenAsDouble();
512 >        hmat(2, 1) = tokenizer.nextTokenAsDouble();
513 >        hmat(2, 2) = tokenizer.nextTokenAsDouble();
514 >        s->setHmat(hmat);      
515 >      } else if (propertyName == "Thermostat") {
516 >        RealType chi = tokenizer.nextTokenAsDouble();
517 >        RealType integralOfChiDt = tokenizer.nextTokenAsDouble();
518 >        s->setChi(chi);
519 >        s->setIntegralOfChiDt(integralOfChiDt);        
520 >     } else if (propertyName == "Barostat") {
521 >        Mat3x3d eta;
522 >        eta(0, 0) = tokenizer.nextTokenAsDouble();
523 >        eta(0, 1) = tokenizer.nextTokenAsDouble();
524 >        eta(0, 2) = tokenizer.nextTokenAsDouble();
525 >        eta(1, 0) = tokenizer.nextTokenAsDouble();
526 >        eta(1, 1) = tokenizer.nextTokenAsDouble();
527 >        eta(1, 2) = tokenizer.nextTokenAsDouble();
528 >        eta(2, 0) = tokenizer.nextTokenAsDouble();
529 >        eta(2, 1) = tokenizer.nextTokenAsDouble();
530 >        eta(2, 2) = tokenizer.nextTokenAsDouble();
531 >        s->setEta(eta);
532 >      } else {
533 >        sprintf(painCave.errMsg,
534 >                "DumpReader Error: %s is an invalid property in <FrameData>\n", propertyName.c_str());
535 >        painCave.isFatal = 0;
536 >        simError();        
537 >      }
538 >      
539 >    }
540 >
541 >  }
542 >
543    
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 –  
544   }//end namespace oopse

Diff Legend

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