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 635 by gezelter, Wed Sep 28 16:32:30 2005 UTC vs.
Revision 1790 by gezelter, Thu Aug 30 17:18:22 2012 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 {
71 <  
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 <      if (worldRank == 0) {
78 < #endif
79 <      
80 <      inFile_ = new std::ifstream(filename_.c_str());
81 <      
82 <        if (inFile_->fail()) {
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 <      
90 <      }
91 <    
92 <      strcpy(checkPointMsg, "Dump file opened for reading successfully.");
93 <      MPIcheckPoint();
94 <    
95 < #endif
96 <    
97 <      return;
98 <    }
99 <  
100 <  DumpReader::~DumpReader() {
101 <    
102 < #ifdef IS_MPI
103 <    
104 <    if (worldRank == 0) {
105 < #endif
106 <      
107 <      delete inFile_;
108 <      
109 < #ifdef IS_MPI
110 <      
111 <    }
112 <    
113 <    strcpy(checkPointMsg, "Dump file closed successfully.");
114 <    MPIcheckPoint();
115 <    
116 < #endif
117 <    
118 <    return;
119 <  }
120 <  
121 <  int DumpReader::getNFrames(void) {
122 <    
123 <    if (!isScanned_)
124 <      scanFile();
125 <    
126 <    return nframes_;
127 <  }
128 <  
129 <  void DumpReader::scanFile(void) {
130 <    int i, j;
131 <    int lineNum = 0;
132 <    char readBuffer[maxBufferSize];
133 <    std::streampos  currPos;
134 <    
135 < #ifdef IS_MPI
136 <    
137 <    if (worldRank == 0) {
138 < #endif // is_mpi
139 <      
140 <      inFile_->seekg (0, std::ios::beg);
141 <      
142 <
143 <      currPos = inFile_->tellg();
144 <      inFile_->getline(readBuffer, sizeof(readBuffer));
145 <      lineNum++;
146 <      
147 <      if (inFile_->eof()) {
148 <        sprintf(painCave.errMsg,
149 <                "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
150 <                filename_.c_str(),
151 <                lineNum);
152 <        painCave.isFatal = 1;
153 <        simError();
154 <      }
155 <      
156 <      while (!inFile_->eof()) {
157 <        framePos_.push_back(currPos);
158 <        
159 <        i = atoi(readBuffer);
160 <        
161 <        inFile_->getline(readBuffer, sizeof(readBuffer));
162 <        lineNum++;
163 <        
164 <        if (inFile_->eof()) {
165 <          sprintf(painCave.errMsg,
166 <                  "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
167 <                  filename_.c_str(),
168 <                  lineNum);
169 <          painCave.isFatal = 1;
170 <          simError();
171 <        }
172 <        
173 <        for(j = 0; j < i; j++) {
174 <          inFile_->getline(readBuffer, sizeof(readBuffer));
175 <          lineNum++;
176 <          
177 <          if (inFile_->eof()) {
178 <            sprintf(painCave.errMsg,
179 <                    "DumpReader Error: File \"%s\" ended unexpectedly at line %d,"
180 <                    " with atom %d\n", filename_.c_str(),
181 <                    lineNum,
182 <                    j);
183 <            
184 <            painCave.isFatal = 1;
185 <            simError();
186 <          }
187 <        }
188 <        
189 <        currPos = inFile_->tellg();
190 <        inFile_->getline(readBuffer, sizeof(readBuffer));
191 <        lineNum++;
192 <      }
193 <
194 <      inFile_->seekg (0, std::ios::beg);
195 <      
196 <      nframes_ = framePos_.size();
197 < #ifdef IS_MPI
198 <    }
199 <    
200 <    MPI_Bcast(&nframes_, 1, MPI_INT, 0, MPI_COMM_WORLD);
201 <    
202 <    strcpy(checkPointMsg, "Successfully scanned DumpFile\n");
203 <    MPIcheckPoint();
204 <    
205 < #endif // is_mpi
206 <    
207 <    isScanned_ = true;
208 <  }
209 <  
210 <  void DumpReader::readFrame(int whichFrame) {
211 <    if (!isScanned_)
212 <      scanFile();
213 <        
214 <    int storageLayout = info_->getSnapshotManager()->getStorageLayout();
215 <    
216 <    if (storageLayout & DataStorage::dslPosition) {
217 <      needPos_ = true;
218 <    } else {
219 <      needPos_ = false;
220 <    }
221 <    
222 <    if (storageLayout & DataStorage::dslVelocity) {
223 <      needVel_ = true;
224 <    } else {
225 <      needVel_ = false;
226 <    }
227 <    
228 <    if (storageLayout & DataStorage::dslAmat || storageLayout & DataStorage::dslElectroFrame) {
229 <      needQuaternion_ = true;
230 <    } else {
231 <      needQuaternion_ = false;
232 <    }
233 <    
234 <    if (storageLayout & DataStorage::dslAngularMomentum) {
235 <      needAngMom_ = true;
236 <    } else {
237 <      needAngMom_ = false;    
238 <    }
239 <    
240 <    readSet(whichFrame);
241 <  }
242 <  
243 <  void DumpReader::readSet(int whichFrame) {
244 <    int i;
245 <    int nTotObjs;                  // the number of atoms
246 <    char read_buffer[maxBufferSize];  //the line buffer for reading
247 <    char * eof_test;               // ptr to see when we reach the end of the file
248 <    
249 <    Molecule* mol;
250 <    StuntDouble* integrableObject;
251 <    SimInfo::MoleculeIterator mi;
252 <    Molecule::IntegrableObjectIterator ii;
253 <    
254 < #ifndef IS_MPI
255 <    inFile_->clear();
256 <    inFile_->seekg(framePos_[whichFrame]);
257 <        
258 <    if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
259 <      sprintf(painCave.errMsg,
260 <              "DumpReader error: error reading 1st line of \"%s\"\n",
261 <              filename_.c_str());
262 <      painCave.isFatal = 1;
263 <      simError();
264 <    }
265 <    
266 <    nTotObjs = atoi(read_buffer);
267 <    
268 <    if (nTotObjs != info_->getNGlobalIntegrableObjects()) {
269 <      sprintf(painCave.errMsg,
270 <              "DumpReader error. %s nIntegrable, %d, "
271 <              "does not match the meta-data file's nIntegrable, %d.\n",
272 <              filename_.c_str(),
273 <              nTotObjs,
274 <              info_->getNGlobalIntegrableObjects());
275 <      
276 <      painCave.isFatal = 1;
277 <      simError();
278 <    }
279 <    
280 <    //read the box mat from the comment line
281 <    
282 <    
283 <    if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
284 <      sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
285 <              filename_.c_str());
286 <      painCave.isFatal = 1;
287 <      simError();
288 <    }
289 <    
290 <    parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
291 <    
292 <    //parse dump lines
293 <    
294 <    i = 0;
295 <    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
296 <      
297 <      for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
298 <           integrableObject = mol->nextIntegrableObject(ii)) {          
299 <        
300 <        
301 <        
302 <        if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
303 <          sprintf(painCave.errMsg,
304 <                  "DumpReader Error: error in reading file %s\n"
305 <                  "natoms  = %d; index = %d\n"
306 <                  "error reading the line from the file.\n",
307 <                  filename_.c_str(),
308 <                  nTotObjs,
309 <                  i);
310 <          
311 <          painCave.isFatal = 1;
312 <          simError();
313 <        }
314 <        
315 <        parseDumpLine(read_buffer, integrableObject);
316 <        i++;
317 <      }
318 <    }
319 <    
320 <    // MPI Section of code..........
321 <    
322 < #else //IS_MPI
323 <    
324 <    // first thing first, suspend fatalities.
325 <    int masterNode = 0;
326 <    int nCurObj;
327 <    painCave.isEventLoop = 1;
328 <    
329 <    int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
330 <    int haveError;
331 <    
332 <    MPI_Status istatus;
333 <    int nitems;
334 <    
335 <    nTotObjs = info_->getNGlobalIntegrableObjects();
336 <    haveError = 0;
337 <    
338 <    if (worldRank == masterNode) {
339 <      inFile_->clear();            
340 <      inFile_->seekg(framePos_[whichFrame]);
341 <      
342 <      if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
343 <        sprintf(painCave.errMsg, "DumpReader Error: Error reading 1st line of %s \n ",
344 <                filename_.c_str());
345 <        painCave.isFatal = 1;
346 <        simError();
347 <      }
348 <      
349 <      nitems = atoi(read_buffer);
350 <      
351 <      // Check to see that the number of integrable objects in the
352 <      // intial configuration file is the same as derived from the
353 <      // meta-data file.
354 <      
355 <      if (nTotObjs != nitems) {
356 <        sprintf(painCave.errMsg,
357 <                "DumpReader Error. %s nIntegrable, %d, "
358 <                "does not match the meta-data file's nIntegrable, %d.\n",
359 <                filename_.c_str(),
360 <                nTotObjs,
361 <                info_->getNGlobalIntegrableObjects());
362 <        
363 <        painCave.isFatal = 1;
364 <        simError();
365 <      }
366 <      
367 <      //read the boxMat from the comment line
368 <      
369 <      
370 <      
371 <      if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
372 <        sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
373 <                filename_.c_str());
374 <        painCave.isFatal = 1;
375 <        simError();
376 <      }
377 <      
378 <      //Every single processor will parse the comment line by itself
379 <      //By using this way, we might lose some efficiency, but if we want to add
380 <      //more parameters into comment line, we only need to modify function
381 <      //parseCommentLine
382 <      
383 <      MPI_Bcast(read_buffer, maxBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
384 <      parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
385 <      
386 <      for(i = 0; i < info_->getNGlobalMolecules(); i++) {
387 <        int which_node = info_->getMolToProc(i);
388 <        
389 <        if (which_node == masterNode) {
390 <          //molecules belong to master node
391 <          
392 <          mol = info_->getMoleculeByGlobalIndex(i);
393 <          
394 <          if (mol == NULL) {
395 <            sprintf(painCave.errMsg, "DumpReader Error: Molecule not found on node %d!", worldRank);
396 <            painCave.isFatal = 1;
397 <            simError();
398 <          }
399 <          
400 <          for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
401 <               integrableObject = mol->nextIntegrableObject(ii)){
402 <            
403 <            
404 <            
405 <            if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
406 <              sprintf(painCave.errMsg,
407 <                      "DumpReader Error: error in reading file %s\n"
408 <                      "natoms  = %d; index = %d\n"
409 <                      "error reading the line from the file.\n",
410 <                      filename_.c_str(),
411 <                      nTotObjs,
412 <                      i);
413 <              
414 <              painCave.isFatal = 1;
415 <              simError();
416 <            }
417 <            
418 <            parseDumpLine(read_buffer, integrableObject);
419 <          }
420 <        } else {
421 <          //molecule belongs to slave nodes
422 <          
423 <          MPI_Recv(&nCurObj, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
424 <                   MPI_COMM_WORLD, &istatus);
425 <          
426 <          for(int j = 0; j < nCurObj; j++) {
427 <            
428 <            
429 <            if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
430 <              sprintf(painCave.errMsg,
431 <                      "DumpReader Error: error in reading file %s\n"
432 <                      "natoms  = %d; index = %d\n"
433 <                      "error reading the line from the file.\n",
434 <                      filename_.c_str(),
435 <                      nTotObjs,
436 <                      i);
437 <              
438 <              painCave.isFatal = 1;
439 <              simError();
440 <            }
441 <            
442 <            MPI_Send(read_buffer, maxBufferSize, MPI_CHAR, which_node,
443 <                     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
444 <          }
445 <        }
446 <      }
447 <    } else {
448 <      //actions taken at slave nodes
449 <      MPI_Bcast(read_buffer, maxBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
450 <      
451 <      /**@todo*/
452 <      parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
453 <      
454 <      for(i = 0; i < info_->getNGlobalMolecules(); i++) {
455 <        int which_node = info_->getMolToProc(i);
456 <        
457 <        if (which_node == worldRank) {
458 <          //molecule with global index i belongs to this processor
459 <          
460 <          mol = info_->getMoleculeByGlobalIndex(i);
461 <          if (mol == NULL) {
462 <            sprintf(painCave.errMsg, "DumpReader Error: Molecule not found on node %d!", worldRank);
463 <            painCave.isFatal = 1;
464 <            simError();
465 <          }
466 <          
467 <          nCurObj = mol->getNIntegrableObjects();
468 <          
469 <          MPI_Send(&nCurObj, 1, MPI_INT, masterNode, TAKE_THIS_TAG_INT,
470 <                   MPI_COMM_WORLD);
471 <          
472 <          for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
473 <               integrableObject = mol->nextIntegrableObject(ii)){
474 <            
475 <            MPI_Recv(read_buffer, maxBufferSize, MPI_CHAR, masterNode,
476 <                     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
477 <            
478 <            parseDumpLine(read_buffer, integrableObject);
479 <          }
480 <          
481 <        }
482 <        
483 <      }
484 <      
485 <    }
486 <    
487 < #endif
488 <    
489 <  }
490 <  
491 <  void DumpReader::parseDumpLine(char *line, StuntDouble *integrableObject) {
492 <    
493 <    Vector3d pos;  // position place holders
494 <    Vector3d vel;  // velocity placeholders
495 <    Quat4d q;    // the quaternions
496 <    Vector3d ji;   // angular velocity placeholders;
497 <    StringTokenizer tokenizer(line);
498 <    int nTokens;
499 <    
500 <    nTokens = tokenizer.countTokens();
501 <    
502 <    if (nTokens < 14) {
503 <      sprintf(painCave.errMsg,
504 <              "DumpReader Error: Not enough Tokens.\n%s\n", line);
505 <      painCave.isFatal = 1;
506 <      simError();
507 <    }
508 <    
509 <    std::string name = tokenizer.nextToken();
510 <    
511 <    if (name != integrableObject->getType()) {
512 <      
513 <      sprintf(painCave.errMsg,
514 <              "DumpReader Error: Atom type [%s] in %s does not match Atom Type [%s] in .md file.\n",
515 <              name.c_str(), filename_.c_str(), integrableObject->getType().c_str());
516 <      painCave.isFatal = 1;
517 <      simError();        
518 <    }
519 <    
520 <    pos[0] = tokenizer.nextTokenAsDouble();
521 <    pos[1] = tokenizer.nextTokenAsDouble();
522 <    pos[2] = tokenizer.nextTokenAsDouble();
523 <    if (needPos_) {
524 <      integrableObject->setPos(pos);
525 <    }
526 <    
527 <    vel[0] = tokenizer.nextTokenAsDouble();
528 <    vel[1] = tokenizer.nextTokenAsDouble();
529 <    vel[2] = tokenizer.nextTokenAsDouble();
530 <    if (needVel_) {
531 <      integrableObject->setVel(vel);
532 <    }
533 <    
534 <    if (integrableObject->isDirectional()) {
535 <      
536 <      q[0] = tokenizer.nextTokenAsDouble();
537 <      q[1] = tokenizer.nextTokenAsDouble();
538 <      q[2] = tokenizer.nextTokenAsDouble();
539 <      q[3] = tokenizer.nextTokenAsDouble();
540 <      
541 <      double qlen = q.length();
542 <      if (qlen < oopse::epsilon) { //check quaternion is not equal to 0
543 <        
544 <        sprintf(painCave.errMsg,
545 <                "DumpReader Error: initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2 ~ 0\n");
546 <        painCave.isFatal = 1;
547 <        simError();
548 <        
549 <      }
550 <      
551 <      q.normalize();
552 <      if (needQuaternion_) {          
553 <        integrableObject->setQ(q);
554 <      }
555 <      
556 <      ji[0] = tokenizer.nextTokenAsDouble();
557 <      ji[1] = tokenizer.nextTokenAsDouble();
558 <      ji[2] = tokenizer.nextTokenAsDouble();
559 <      if (needAngMom_) {
560 <        integrableObject->setJ(ji);
561 <      }
562 <    }
563 <    
564 <  }
565 <  
566 <  
567 <  void DumpReader::parseCommentLine(char* line, Snapshot* s) {
568 <    double currTime;
569 <    Mat3x3d hmat;
570 <    double chi;
571 <    double integralOfChiDt;
572 <    Mat3x3d eta;
573 <    
574 <    StringTokenizer tokenizer(line);
575 <    int nTokens;
576 <    
577 <    nTokens = tokenizer.countTokens();
578 <    
579 <    //comment line should at least contain 10 tokens: current time(1 token) and  h-matrix(9 tokens)
580 <    if (nTokens < 10) {
581 <      sprintf(painCave.errMsg,
582 <              "DumpReader Error: Not enough tokens in comment line: %s", line);
583 <      painCave.isFatal = 1;
584 <      simError();  
585 <    }
586 <    
587 <    //read current time
588 <    currTime = tokenizer.nextTokenAsDouble();
589 <    s->setTime(currTime);
590 <    
591 <    //read h-matrix
592 <    hmat(0, 0) = tokenizer.nextTokenAsDouble();
593 <    hmat(0, 1) = tokenizer.nextTokenAsDouble();
594 <    hmat(0, 2) = tokenizer.nextTokenAsDouble();
595 <    hmat(1, 0) = tokenizer.nextTokenAsDouble();
596 <    hmat(1, 1) = tokenizer.nextTokenAsDouble();
597 <    hmat(1, 2) = tokenizer.nextTokenAsDouble();
598 <    hmat(2, 0) = tokenizer.nextTokenAsDouble();
599 <    hmat(2, 1) = tokenizer.nextTokenAsDouble();
600 <    hmat(2, 2) = tokenizer.nextTokenAsDouble();
601 <    s->setHmat(hmat);
602 <    
603 <    //read chi and integralOfChidt, they should apprear in pair
604 <    if (tokenizer.countTokens() >= 2) {
605 <      chi = tokenizer.nextTokenAsDouble();
606 <      integralOfChiDt = tokenizer.nextTokenAsDouble();            
607 <      
608 <      s->setChi(chi);
609 <      s->setIntegralOfChiDt(integralOfChiDt);
610 <    }
611 <    
612 <    //read eta (eta is 3x3 matrix)
613 <    if (tokenizer.countTokens() >= 9) {
614 <      eta(0, 0) = tokenizer.nextTokenAsDouble();
615 <      eta(0, 1) = tokenizer.nextTokenAsDouble();
616 <      eta(0, 2) = tokenizer.nextTokenAsDouble();
617 <      eta(1, 0) = tokenizer.nextTokenAsDouble();
618 <      eta(1, 1) = tokenizer.nextTokenAsDouble();
619 <      eta(1, 2) = tokenizer.nextTokenAsDouble();
620 <      eta(2, 0) = tokenizer.nextTokenAsDouble();
621 <      eta(2, 1) = tokenizer.nextTokenAsDouble();
622 <      eta(2, 2) = tokenizer.nextTokenAsDouble();      
623 <      
624 <      s->setEta(eta);
625 <    }
626 <    
627 <    
628 <  }
629 <  
630 < }//end namespace oopse
1 > /*
2 > * Copyright (c) 2009 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. Redistributions of source code must retain the above copyright
10 > *    notice, this list of conditions and the following disclaimer.
11 > *
12 > * 2. Redistributions in binary form must reproduce the above copyright
13 > *    notice, this list of conditions and the following disclaimer in the
14 > *    documentation and/or other materials provided with the
15 > *    distribution.
16 > *
17 > * This software is provided "AS IS," without a warranty of any
18 > * kind. All express or implied conditions, representations and
19 > * warranties, including any implied warranty of merchantability,
20 > * fitness for a particular purpose or non-infringement, are hereby
21 > * excluded.  The University of Notre Dame and its licensors shall not
22 > * be liable for any damages suffered by licensee as a result of
23 > * using, modifying or distributing the software or its
24 > * derivatives. In no event will the University of Notre Dame or its
25 > * licensors be liable for any lost revenue, profit or data, or for
26 > * direct, indirect, special, consequential, incidental or punitive
27 > * damages, however caused and regardless of the theory of liability,
28 > * arising out of the use of or inability to use software, even if the
29 > * University of Notre Dame has been advised of the possibility of
30 > * such damages.
31 > *
32 > * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 > * research, please cite the appropriate papers when you publish your
34 > * work.  Good starting points are:
35 > *                                                                      
36 > * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 > * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 > * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 > * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40 > * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41 > */
42 >  
43 > #define _LARGEFILE_SOURCE64
44 > #define _FILE_OFFSET_BITS 64
45 >
46 > #include <sys/types.h>
47 > #include <sys/stat.h>
48 >
49 > #include <iostream>
50 > #include <math.h>
51 >
52 > #include <stdio.h>
53 > #include <stdlib.h>
54 > #include <string.h>
55 >
56 > #include "io/DumpReader.hpp"
57 > #include "primitives/Molecule.hpp"
58 > #include "utils/simError.h"
59 > #include "utils/MemoryUtils.hpp"
60 > #include "utils/StringTokenizer.hpp"
61 > #include "brains/Thermo.hpp"
62 >
63 > #ifdef IS_MPI
64 > #include <mpi.h>
65 > #endif
66 >
67 >
68 > namespace OpenMD {
69 >  
70 >  DumpReader::DumpReader(SimInfo* info, const std::string& filename)
71 >    : info_(info), filename_(filename), isScanned_(false), nframes_(0), needCOMprops_(false) {
72 >    
73 > #ifdef IS_MPI
74 >    
75 >    if (worldRank == 0) {
76 > #endif
77 >      
78 >      inFile_ = new std::ifstream(filename_.c_str(),  
79 >                                  ifstream::in | ifstream::binary);
80 >      
81 >      if (inFile_->fail()) {
82 >        sprintf(painCave.errMsg,
83 >                "DumpReader: Cannot open file: %s\n",
84 >                filename_.c_str());
85 >        painCave.isFatal = 1;
86 >        simError();
87 >      }
88 >      
89 > #ifdef IS_MPI
90 >      
91 >    }
92 >    
93 >    strcpy(checkPointMsg, "Dump file opened for reading successfully.");
94 >    errorCheckPoint();
95 >    
96 > #endif
97 >    
98 >    return;
99 >  }
100 >  
101 >  DumpReader::~DumpReader() {
102 >    
103 > #ifdef IS_MPI
104 >    
105 >    if (worldRank == 0) {
106 > #endif
107 >      
108 >      delete inFile_;
109 >      
110 > #ifdef IS_MPI
111 >      
112 >    }
113 >    
114 >    strcpy(checkPointMsg, "Dump file closed successfully.");
115 >    errorCheckPoint();
116 >    
117 > #endif
118 >    
119 >    return;
120 >  }
121 >  
122 >  int DumpReader::getNFrames(void) {
123 >    
124 >    if (!isScanned_)
125 >      scanFile();
126 >    
127 >    return nframes_;
128 >  }
129 >  
130 >  void DumpReader::scanFile(void) {
131 >    int lineNo = 0;
132 >    std::streampos prevPos;
133 >    std::streampos  currPos;
134 >    
135 > #ifdef IS_MPI
136 >    
137 >    if (worldRank == 0) {
138 > #endif // is_mpi
139 >      
140 >      currPos = inFile_->tellg();
141 >      prevPos = currPos;
142 >      bool foundOpenSnapshotTag = false;
143 >      bool foundClosedSnapshotTag = false;
144 >      bool foundOpenSiteDataTag = 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:<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 >          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 >    
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 >    if (needCOMprops_) {
245 >      Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
246 >      Thermo thermo(info_);
247 >      Vector3d com;
248 >
249 >      if (needPos_ && needVel_) {
250 >        Vector3d comvel;
251 >        Vector3d comw;
252 >        thermo.getComAll(com, comvel);
253 >        comw = thermo.getAngularMomentum();
254 >      } else {
255 >        com = thermo.getCom();
256 >      }                    
257 >    }
258 >  }
259 >  
260 >  void DumpReader::readSet(int whichFrame) {    
261 >    std::string line;
262 >
263 > #ifndef IS_MPI
264 >    inFile_->clear();  
265 >    inFile_->seekg(framePos_[whichFrame]);
266 >
267 >    std::istream& inputStream = *inFile_;    
268 >
269 > #else
270 >    int masterNode = 0;
271 >    std::stringstream sstream;
272 >    if (worldRank == masterNode) {
273 >      std::string sendBuffer;
274 >
275 >      inFile_->clear();  
276 >      inFile_->seekg(framePos_[whichFrame]);
277 >      
278 >      while (inFile_->getline(buffer, bufferSize)) {
279 >
280 >        line = buffer;
281 >        sendBuffer += line;
282 >        sendBuffer += '\n';
283 >        if (line.find("</Snapshot>") != std::string::npos) {
284 >          break;
285 >        }        
286 >      }
287 >
288 >      int sendBufferSize = sendBuffer.size();
289 >      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);    
290 >      MPI_Bcast((void *)sendBuffer.c_str(), sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);    
291 >      
292 >      sstream.str(sendBuffer);
293 >    } else {
294 >      int sendBufferSize;
295 >      MPI_Bcast(&sendBufferSize, 1, MPI_INT, masterNode, MPI_COMM_WORLD);    
296 >      char * recvBuffer = new char[sendBufferSize+1];
297 >      assert(recvBuffer);
298 >      recvBuffer[sendBufferSize] = '\0';
299 >      MPI_Bcast(recvBuffer, sendBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);    
300 >      sstream.str(recvBuffer);
301 >      delete [] recvBuffer;
302 >    }      
303 >
304 >    std::istream& inputStream = sstream;  
305 > #endif
306 >
307 >    inputStream.getline(buffer, bufferSize);
308 >
309 >    line = buffer;
310 >    if (line.find("<Snapshot>") == std::string::npos) {
311 >      sprintf(painCave.errMsg,
312 >              "DumpReader Error: can not find <Snapshot>\n");
313 >      painCave.isFatal = 1;
314 >      simError();
315 >    }
316 >    
317 >    //read frameData
318 >    readFrameProperties(inputStream);
319 >
320 >    //read StuntDoubles
321 >    readStuntDoubles(inputStream);    
322 >
323 >    inputStream.getline(buffer, bufferSize);
324 >    line = buffer;
325 >
326 >    if (line.find("<SiteData>") != std::string::npos) {
327 >      //read SiteData
328 >      readSiteData(inputStream);        
329 >    } else {
330 >      if (line.find("</Snapshot>") == std::string::npos) {
331 >        sprintf(painCave.errMsg,
332 >                "DumpReader Error: can not find </Snapshot>\n");
333 >        painCave.isFatal = 1;
334 >        simError();
335 >      }        
336 >    }
337 >  }
338 >  
339 >  void DumpReader::parseDumpLine(const std::string& line) {
340 >
341 >      
342 >    StringTokenizer tokenizer(line);
343 >    int nTokens;
344 >    
345 >    nTokens = tokenizer.countTokens();
346 >    
347 >    if (nTokens < 2) {  
348 >      sprintf(painCave.errMsg,
349 >              "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
350 >      painCave.isFatal = 1;
351 >      simError();
352 >    }
353 >
354 >    int index = tokenizer.nextTokenAsInt();
355 >
356 >    StuntDouble* sd = info_->getIOIndexToIntegrableObject(index);
357 >
358 >    if (sd == NULL) {
359 >      return;
360 >    }
361 >    std::string type = tokenizer.nextToken();
362 >    int size = type.size();
363 >
364 >    size_t found;
365 >    
366 >    if (needPos_) {
367 >      found = type.find("p");      
368 >      if (found == std::string::npos) {
369 >        sprintf(painCave.errMsg,
370 >                "DumpReader Error: StuntDouble %d has no Position\n"
371 >                "\tField (\"p\") specified.\n%s\n", index,
372 >                line.c_str());  
373 >        painCave.isFatal = 1;
374 >        simError();
375 >      }
376 >    }
377 >    
378 >    if (sd->isDirectional()) {
379 >      if (needQuaternion_) {
380 >        found = type.find("q");      
381 >        if (found == std::string::npos) {
382 >          sprintf(painCave.errMsg,
383 >                  "DumpReader Error: Directional StuntDouble %d has no\n"
384 >                  "\tQuaternion Field (\"q\") specified.\n%s\n", index,
385 >                  line.c_str());  
386 >          painCave.isFatal = 1;
387 >          simError();
388 >        }
389 >      }      
390 >    }
391 >
392 >    for(int i = 0; i < size; ++i) {
393 >      switch(type[i]) {
394 >        
395 >        case 'p': {
396 >            Vector3d pos;
397 >            pos[0] = tokenizer.nextTokenAsDouble();
398 >            pos[1] = tokenizer.nextTokenAsDouble();
399 >            pos[2] = tokenizer.nextTokenAsDouble();
400 >            if (needPos_) {
401 >              sd->setPos(pos);
402 >            }            
403 >            break;
404 >        }
405 >        case 'v' : {
406 >            Vector3d vel;
407 >            vel[0] = tokenizer.nextTokenAsDouble();
408 >            vel[1] = tokenizer.nextTokenAsDouble();
409 >            vel[2] = tokenizer.nextTokenAsDouble();
410 >            if (needVel_) {
411 >              sd->setVel(vel);
412 >            }
413 >            break;
414 >        }
415 >
416 >        case 'q' : {
417 >           Quat4d q;
418 >           if (sd->isDirectional()) {
419 >              
420 >             q[0] = tokenizer.nextTokenAsDouble();
421 >             q[1] = tokenizer.nextTokenAsDouble();
422 >             q[2] = tokenizer.nextTokenAsDouble();
423 >             q[3] = tokenizer.nextTokenAsDouble();
424 >              
425 >             RealType qlen = q.length();
426 >             if (qlen < OpenMD::epsilon) { //check quaternion is not equal to 0
427 >                
428 >               sprintf(painCave.errMsg,
429 >                       "DumpReader Error: initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2) ~ 0\n");
430 >               painCave.isFatal = 1;
431 >               simError();
432 >                
433 >             }  
434 >              
435 >             q.normalize();
436 >             if (needQuaternion_) {            
437 >               sd->setQ(q);
438 >             }              
439 >           }            
440 >           break;
441 >        }  
442 >        case 'j' : {
443 >          Vector3d ji;
444 >          if (sd->isDirectional()) {
445 >             ji[0] = tokenizer.nextTokenAsDouble();
446 >             ji[1] = tokenizer.nextTokenAsDouble();
447 >             ji[2] = tokenizer.nextTokenAsDouble();
448 >             if (needAngMom_) {
449 >               sd->setJ(ji);
450 >             }
451 >          }
452 >          break;
453 >        }  
454 >        case 'f': {
455 >
456 >          Vector3d force;
457 >          force[0] = tokenizer.nextTokenAsDouble();
458 >          force[1] = tokenizer.nextTokenAsDouble();
459 >          force[2] = tokenizer.nextTokenAsDouble();          
460 >          sd->setFrc(force);
461 >          break;
462 >        }
463 >        case 't' : {
464 >
465 >           Vector3d torque;
466 >           torque[0] = tokenizer.nextTokenAsDouble();
467 >           torque[1] = tokenizer.nextTokenAsDouble();
468 >           torque[2] = tokenizer.nextTokenAsDouble();          
469 >           sd->setTrq(torque);          
470 >           break;
471 >        }
472 >        case 'u' : {
473 >
474 >           RealType particlePot;
475 >           particlePot = tokenizer.nextTokenAsDouble();
476 >           sd->setParticlePot(particlePot);          
477 >           break;
478 >        }
479 >        case 'c' : {
480 >
481 >           RealType flucQPos;
482 >           flucQPos = tokenizer.nextTokenAsDouble();
483 >           sd->setFlucQPos(flucQPos);          
484 >           break;
485 >        }
486 >        case 'w' : {
487 >
488 >           RealType flucQVel;
489 >           flucQVel = tokenizer.nextTokenAsDouble();
490 >           sd->setFlucQVel(flucQVel);          
491 >           break;
492 >        }
493 >        case 'g' : {
494 >
495 >           RealType flucQFrc;
496 >           flucQFrc = tokenizer.nextTokenAsDouble();
497 >           sd->setFlucQFrc(flucQFrc);          
498 >           break;
499 >        }
500 >        case 'e' : {
501 >
502 >           Vector3d eField;
503 >           eField[0] = tokenizer.nextTokenAsDouble();
504 >           eField[1] = tokenizer.nextTokenAsDouble();
505 >           eField[2] = tokenizer.nextTokenAsDouble();          
506 >           sd->setElectricField(eField);          
507 >           break;
508 >        }
509 >        default: {
510 >               sprintf(painCave.errMsg,
511 >                       "DumpReader Error: %s is an unrecognized type\n", type.c_str());
512 >               painCave.isFatal = 1;
513 >               simError();
514 >          break;  
515 >        }
516 >
517 >      }
518 >    }
519 >    
520 >  }
521 >  
522 >
523 >  void DumpReader::parseSiteLine(const std::string& line) {
524 >
525 >    StringTokenizer tokenizer(line);
526 >    int nTokens;
527 >    
528 >    nTokens = tokenizer.countTokens();
529 >    
530 >    if (nTokens < 2) {  
531 >      sprintf(painCave.errMsg,
532 >              "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
533 >      painCave.isFatal = 1;
534 >      simError();
535 >    }
536 >
537 >    /**
538 >     * The first token is the global integrable object index.
539 >     */
540 >
541 >    int index = tokenizer.nextTokenAsInt();
542 >    StuntDouble* sd = info_->getIOIndexToIntegrableObject(index);
543 >    if (sd == NULL) {
544 >      return;
545 >    }
546 >
547 >    /**
548 >     * Test to see if the next token is an integer or not.  If not,
549 >     * we've got data on the integrable object itself.  If there is an
550 >     * integer, we're parsing data for a site on a rigid body.
551 >     */
552 >
553 >    std::string indexTest = tokenizer.peekNextToken();
554 >    std::istringstream i(indexTest);
555 >    int siteIndex;
556 >    if (i >> siteIndex) {
557 >      // chew up this token and parse as an int:
558 >      siteIndex = tokenizer.nextTokenAsInt();
559 >      RigidBody* rb = static_cast<RigidBody*>(sd);
560 >      sd = rb->getAtoms()[siteIndex];
561 >    }
562 >
563 >    /**
564 >     * The next token contains information on what follows.
565 >     */
566 >    std::string type = tokenizer.nextToken();
567 >    int size = type.size();
568 >    
569 >    for(int i = 0; i < size; ++i) {
570 >      switch(type[i]) {
571 >        
572 >      case 'u' : {
573 >        
574 >        RealType particlePot;
575 >        particlePot = tokenizer.nextTokenAsDouble();
576 >        sd->setParticlePot(particlePot);
577 >        break;
578 >      }
579 >      case 'c' : {
580 >        
581 >        RealType flucQPos;
582 >        flucQPos = tokenizer.nextTokenAsDouble();
583 >        sd->setFlucQPos(flucQPos);
584 >        break;
585 >      }
586 >      case 'w' : {
587 >        
588 >        RealType flucQVel;
589 >        flucQVel = tokenizer.nextTokenAsDouble();
590 >        sd->setFlucQVel(flucQVel);
591 >        break;
592 >      }
593 >      case 'g' : {
594 >        
595 >        RealType flucQFrc;
596 >        flucQFrc = tokenizer.nextTokenAsDouble();
597 >        sd->setFlucQFrc(flucQFrc);
598 >        break;
599 >      }
600 >      case 'e' : {
601 >        
602 >        Vector3d eField;
603 >        eField[0] = tokenizer.nextTokenAsDouble();
604 >        eField[1] = tokenizer.nextTokenAsDouble();
605 >        eField[2] = tokenizer.nextTokenAsDouble();  
606 >        sd->setElectricField(eField);          
607 >        break;
608 >      }
609 >      default: {
610 >        sprintf(painCave.errMsg,
611 >                "DumpReader Error: %s is an unrecognized type\n", type.c_str());
612 >        painCave.isFatal = 1;
613 >        simError();
614 >        break;  
615 >      }
616 >      }
617 >    }    
618 >  }
619 >  
620 >  
621 >  void  DumpReader::readStuntDoubles(std::istream& inputStream) {
622 >    
623 >    inputStream.getline(buffer, bufferSize);
624 >    std::string line(buffer);
625 >    
626 >    if (line.find("<StuntDoubles>") == std::string::npos) {
627 >      sprintf(painCave.errMsg,
628 >              "DumpReader Error: Missing <StuntDoubles>\n");
629 >      painCave.isFatal = 1;
630 >      simError();
631 >    }
632 >
633 >    while(inputStream.getline(buffer, bufferSize)) {
634 >      line = buffer;
635 >      
636 >      if(line.find("</StuntDoubles>") != std::string::npos) {
637 >        break;
638 >      }
639 >
640 >      parseDumpLine(line);
641 >    }
642 >  
643 >  }
644 >
645 >  void  DumpReader::readSiteData(std::istream& inputStream) {
646 >
647 >    inputStream.getline(buffer, bufferSize);
648 >    std::string line(buffer);
649 >    
650 >    if (line.find("<SiteData>") == std::string::npos) {
651 >      // site data isn't required for a simulation, so skip
652 >      return;
653 >    }
654 >
655 >    while(inputStream.getline(buffer, bufferSize)) {
656 >      line = buffer;
657 >      
658 >      if(line.find("</SiteData>") != std::string::npos) {
659 >        break;
660 >      }
661 >
662 >      parseSiteLine(line);
663 >    }
664 >  
665 >  }
666 >
667 >  void DumpReader::readFrameProperties(std::istream& inputStream) {
668 >
669 >    Snapshot* s = info_->getSnapshotManager()->getCurrentSnapshot();
670 >    inputStream.getline(buffer, bufferSize);
671 >    std::string line(buffer);
672 >
673 >    if (line.find("<FrameData>") == std::string::npos) {
674 >      sprintf(painCave.errMsg,
675 >              "DumpReader Error: Missing <FrameData>\n");
676 >      painCave.isFatal = 1;
677 >      simError();
678 >    }
679 >
680 >    while(inputStream.getline(buffer, bufferSize)) {
681 >      line = buffer;
682 >      
683 >      if(line.find("</FrameData>") != std::string::npos) {
684 >        break;
685 >      }
686 >      
687 >      StringTokenizer tokenizer(line, " ;\t\n\r{}:,");
688 >      if (!tokenizer.hasMoreTokens()) {
689 >        sprintf(painCave.errMsg,
690 >                "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
691 >        painCave.isFatal = 1;
692 >        simError();      
693 >      }
694 >
695 >      std::string propertyName = tokenizer.nextToken();
696 >      if (propertyName == "Time") {
697 >        RealType currTime = tokenizer.nextTokenAsDouble();
698 >        s->setTime(currTime);
699 >      } else if (propertyName == "Hmat"){
700 >        Mat3x3d hmat;
701 >        hmat(0, 0) = tokenizer.nextTokenAsDouble();
702 >        hmat(0, 1) = tokenizer.nextTokenAsDouble();
703 >        hmat(0, 2) = tokenizer.nextTokenAsDouble();
704 >        hmat(1, 0) = tokenizer.nextTokenAsDouble();
705 >        hmat(1, 1) = tokenizer.nextTokenAsDouble();
706 >        hmat(1, 2) = tokenizer.nextTokenAsDouble();
707 >        hmat(2, 0) = tokenizer.nextTokenAsDouble();
708 >        hmat(2, 1) = tokenizer.nextTokenAsDouble();
709 >        hmat(2, 2) = tokenizer.nextTokenAsDouble();
710 >        s->setHmat(hmat);      
711 >      } else if (propertyName == "Thermostat") {
712 >        pair<RealType, RealType> thermostat;
713 >        thermostat.first = tokenizer.nextTokenAsDouble();
714 >        thermostat.second = tokenizer.nextTokenAsDouble();
715 >        s->setThermostat(thermostat);
716 >     } else if (propertyName == "Barostat") {
717 >        Mat3x3d eta;
718 >        eta(0, 0) = tokenizer.nextTokenAsDouble();
719 >        eta(0, 1) = tokenizer.nextTokenAsDouble();
720 >        eta(0, 2) = tokenizer.nextTokenAsDouble();
721 >        eta(1, 0) = tokenizer.nextTokenAsDouble();
722 >        eta(1, 1) = tokenizer.nextTokenAsDouble();
723 >        eta(1, 2) = tokenizer.nextTokenAsDouble();
724 >        eta(2, 0) = tokenizer.nextTokenAsDouble();
725 >        eta(2, 1) = tokenizer.nextTokenAsDouble();
726 >        eta(2, 2) = tokenizer.nextTokenAsDouble();
727 >        s->setBarostat(eta);
728 >      } else {
729 >        sprintf(painCave.errMsg,
730 >                "DumpReader Error: %s is an invalid property in <FrameData>\n", propertyName.c_str());
731 >        painCave.isFatal = 0;
732 >        simError();        
733 >      }
734 >      
735 >    }
736 >
737 >  }
738 >
739 >  
740 > }//end namespace OpenMD

Comparing trunk/src/io/DumpReader.cpp (property svn:keywords):
Revision 635 by gezelter, Wed Sep 28 16:32:30 2005 UTC vs.
Revision 1790 by gezelter, Thu Aug 30 17:18:22 2012 UTC

# Line 0 | Line 1
1 + Author Id Revision Date

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines