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

Comparing trunk/src/io/DumpReader.cpp (file contents):
Revision 601 by tim, Thu Sep 15 19:17:04 2005 UTC vs.
Revision 1104 by gezelter, Fri Dec 29 21:43:18 2006 UTC

# Line 1 | Line 1
1 < /*
2 < * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 < *
4 < * The University of Notre Dame grants you ("Licensee") a
5 < * non-exclusive, royalty free, license to use, modify and
6 < * redistribute this software in source and binary code form, provided
7 < * that the following conditions are met:
8 < *
9 < * 1. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
19 < *    notice, this list of conditions and the following disclaimer.
20 < *
21 < * 3. Redistributions in binary form must reproduce the above copyright
22 < *    notice, this list of conditions and the following disclaimer in the
23 < *    documentation and/or other materials provided with the
24 < *    distribution.
25 < *
26 < * This software is provided "AS IS," without a warranty of any
27 < * kind. All express or implied conditions, representations and
28 < * warranties, including any implied warranty of merchantability,
29 < * fitness for a particular purpose or non-infringement, are hereby
30 < * excluded.  The University of Notre Dame and its licensors shall not
31 < * be liable for any damages suffered by licensee as a result of
32 < * using, modifying or distributing the software or its
33 < * derivatives. In no event will the University of Notre Dame or its
34 < * licensors be liable for any lost revenue, profit or data, or for
35 < * direct, indirect, special, consequential, incidental or punitive
36 < * damages, however caused and regardless of the theory of liability,
37 < * arising out of the use of or inability to use software, even if the
38 < * University of Notre Dame has been advised of the possibility of
39 < * such damages.
40 < */
41 <
42 < #define _LARGEFILE_SOURCE64
43 < #define _FILE_OFFSET_BITS 64
44 <
45 < #include <sys/types.h>
46 < #include <sys/stat.h>
47 <
48 < #include <iostream>
49 < #include <math.h>
50 <
51 < #include <stdio.h>
52 < #include <stdlib.h>
53 < #include <string.h>
54 <
55 < #include "io/DumpReader.hpp"
56 < #include "primitives/Molecule.hpp"
57 < #include "utils/simError.h"
58 < #include "utils/MemoryUtils.hpp"
59 < #include "utils/StringTokenizer.hpp"
60 <
61 < #ifdef IS_MPI
62 <
63 < #include <mpi.h>
64 < #define TAKE_THIS_TAG_CHAR 0
65 < #define TAKE_THIS_TAG_INT 1
66 <
67 < #endif // is_mpi
68 <
69 <
70 < namespace oopse {
1 > /*
2 > * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 > *
4 > * The University of Notre Dame grants you ("Licensee") a
5 > * non-exclusive, royalty free, license to use, modify and
6 > * redistribute this software in source and binary code form, provided
7 > * that the following conditions are met:
8 > *
9 > * 1. Acknowledgement of the program authors must be made in any
10 > *    publication of scientific results based in part on use of the
11 > *    program.  An acceptable form of acknowledgement is citation of
12 > *    the article in which the program was described (Matthew
13 > *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 > *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 > *    Parallel Simulation Engine for Molecular Dynamics,"
16 > *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 > *
18 > * 2. Redistributions of source code must retain the above copyright
19 > *    notice, this list of conditions and the following disclaimer.
20 > *
21 > * 3. Redistributions in binary form must reproduce the above copyright
22 > *    notice, this list of conditions and the following disclaimer in the
23 > *    documentation and/or other materials provided with the
24 > *    distribution.
25 > *
26 > * This software is provided "AS IS," without a warranty of any
27 > * kind. All express or implied conditions, representations and
28 > * warranties, including any implied warranty of merchantability,
29 > * fitness for a particular purpose or non-infringement, are hereby
30 > * excluded.  The University of Notre Dame and its licensors shall not
31 > * be liable for any damages suffered by licensee as a result of
32 > * using, modifying or distributing the software or its
33 > * derivatives. In no event will the University of Notre Dame or its
34 > * licensors be liable for any lost revenue, profit or data, or for
35 > * direct, indirect, special, consequential, incidental or punitive
36 > * damages, however caused and regardless of the theory of liability,
37 > * arising out of the use of or inability to use software, even if the
38 > * University of Notre Dame has been advised of the possibility of
39 > * such damages.
40 > */
41    
42 <  DumpReader::DumpReader(SimInfo* info, const std::string& filename)
43 <    : info_(info), filename_(filename), isScanned_(false), nframes_(0) {
42 > #define _LARGEFILE_SOURCE64
43 > #define _FILE_OFFSET_BITS 64
44 >
45 > #include <sys/types.h>
46 > #include <sys/stat.h>
47 >
48 > #include <iostream>
49 > #include <math.h>
50 >
51 > #include <stdio.h>
52 > #include <stdlib.h>
53 > #include <string.h>
54 >
55 > #include "io/DumpReader.hpp"
56 > #include "primitives/Molecule.hpp"
57 > #include "utils/simError.h"
58 > #include "utils/MemoryUtils.hpp"
59 > #include "utils/StringTokenizer.hpp"
60 >
61 > #ifdef IS_MPI
62 >
63 > #include <mpi.h>
64 > #define TAKE_THIS_TAG_CHAR 0
65 > #define TAKE_THIS_TAG_INT 1
66 >
67 > #endif // is_mpi
68 >
69 >
70 > namespace oopse {
71 >  
72 >  DumpReader::DumpReader(SimInfo* info, const std::string& filename)
73 >    : info_(info), filename_(filename), isScanned_(false), nframes_(0), needCOMprops_(false) {
74      
75 < #ifdef IS_MPI
75 > #ifdef IS_MPI
76      
77 <      if (worldRank == 0) {
78 < #endif
77 >    if (worldRank == 0) {
78 > #endif
79        
80 <        inFile_ = fopen(filename_.c_str(), "r");
80 >      inFile_ = new std::ifstream(filename_.c_str());
81        
82 <        if (inFile_ == NULL) {
83 <          sprintf(painCave.errMsg, "DumpReader: Cannot open file: %s\n", filename_.c_str());
84 <          painCave.isFatal = 1;
85 <          simError();
86 <        }
82 >      if (inFile_->fail()) {
83 >        sprintf(painCave.errMsg,
84 >                "DumpReader: Cannot open file: %s\n",
85 >                filename_.c_str());
86 >        painCave.isFatal = 1;
87 >        simError();
88 >      }
89        
90 < #ifdef IS_MPI
90 > #ifdef IS_MPI
91        
92 <      }
92 >    }
93      
94 <      strcpy(checkPointMsg, "Dump file opened for reading successfully.");
95 <      MPIcheckPoint();
94 >    strcpy(checkPointMsg, "Dump file opened for reading successfully.");
95 >    MPIcheckPoint();
96      
97 < #endif
97 > #endif
98      
99 <      return;
100 <    }
99 >    return;
100 >  }
101    
102 <  DumpReader::~DumpReader() {
102 >  DumpReader::~DumpReader() {
103      
104 < #ifdef IS_MPI
104 > #ifdef IS_MPI
105      
106 <    if (worldRank == 0) {
107 < #endif
106 >    if (worldRank == 0) {
107 > #endif
108        
109 <      int error;
108 <      error = fclose(inFile_);
109 >      delete inFile_;
110        
111 <      if (error) {
111 <        sprintf(painCave.errMsg, "DumpReader Error: Error closing %s\n", filename_.c_str());
112 <        painCave.isFatal = 1;            
113 <        simError();
114 <      }
111 > #ifdef IS_MPI
112        
113 <      MemoryUtils::deletePointers(framePos_);
117 <      
118 < #ifdef IS_MPI
119 <      
120 <    }
113 >    }
114      
115 <    strcpy(checkPointMsg, "Dump file closed successfully.");
116 <    MPIcheckPoint();
115 >    strcpy(checkPointMsg, "Dump file closed successfully.");
116 >    MPIcheckPoint();
117      
118 < #endif
118 > #endif
119      
120 <    return;
121 <  }
120 >    return;
121 >  }
122    
123 <  int DumpReader::getNFrames(void) {
123 >  int DumpReader::getNFrames(void) {
124 >    
125 >    if (!isScanned_)
126 >      scanFile();
127 >    
128 >    return nframes_;
129 >  }
130 >  
131 >  void DumpReader::scanFile(void) {
132 >    int lineNo = 0;
133 >    std::streampos prevPos;
134 >    std::streampos  currPos;
135      
136 <    if (!isScanned_)
133 <      scanFile();
136 > #ifdef IS_MPI
137      
138 <    return nframes_;
139 <  }
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
138 >    if (worldRank == 0) {
139 > #endif // is_mpi
140        
141 <      rewind(inFile_);
142 <      
143 <      currPos = new fpos_t;
144 <      fgetpos(inFile_, currPos);
145 <      fgets(readBuffer, sizeof(readBuffer), inFile_);
146 <      lineNum++;
155 <      
156 <      if (feof(inFile_)) {
157 <        sprintf(painCave.errMsg,
158 <                "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
159 <                filename_.c_str(),
160 <                lineNum);
161 <        painCave.isFatal = 1;
162 <        simError();
163 <      }
164 <      
165 <      while (!feof(inFile_)) {
166 <        framePos_.push_back(currPos);
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 <        i = atoi(readBuffer);
149 <        
150 <        fgets(readBuffer, sizeof(readBuffer), inFile_);
151 <        lineNum++;
152 <        
153 <        if (feof(inFile_)) {
154 <          sprintf(painCave.errMsg,
155 <                  "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
156 <                  filename_.c_str(),
157 <                  lineNum);
158 <          painCave.isFatal = 1;
159 <          simError();
160 <        }
181 <        
182 <        for(j = 0; j < i; j++) {
183 <          fgets(readBuffer, sizeof(readBuffer), inFile_);
184 <          lineNum++;
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 <          if (feof(inFile_)) {
163 <            sprintf(painCave.errMsg,
164 <                    "DumpReader Error: File \"%s\" ended unexpectedly at line %d,"
165 <                    " with atom %d\n", filename_.c_str(),
166 <                    lineNum,
167 <                    j);
168 <            
193 <            painCave.isFatal = 1;
194 <            simError();
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 <        
198 <        currPos = new fpos_t;
199 <        fgetpos(inFile_, currPos);
200 <        fgets(readBuffer, sizeof(readBuffer), inFile_);
201 <        lineNum++;
181 >        prevPos = currPos;
182        }
183        
184 <      delete currPos;
185 <      rewind(inFile_);
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();
208 < #ifdef IS_MPI
209 <    }
210 <    
211 <    MPI_Bcast(&nframes_, 1, MPI_INT, 0, MPI_COMM_WORLD);
212 <    
213 <    strcpy(checkPointMsg, "Successfully scanned DumpFile\n");
214 <    MPIcheckPoint();
215 <    
216 < #endif // is_mpi
217 <    
218 <    isScanned_ = true;
219 <  }
220 <  
221 <  void DumpReader::readFrame(int whichFrame) {
222 <    if (!isScanned_)
223 <      scanFile();
224 <        
225 <    int storageLayout = info_->getSnapshotManager()->getStorageLayout();
226 <    
227 <    if (storageLayout & DataStorage::dslPosition) {
228 <      needPos_ = true;
229 <    } else {
230 <      needPos_ = false;
231 <    }
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 <    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());
194 >      nframes_ = framePos_.size();
195        
196 <      painCave.isFatal = 1;
197 <      simError();
198 <    }
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 <    //read the box mat from the comment line
207 > #endif // is_mpi
208      
209 <    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
210 <    
211 <    if (eof_test == NULL) {
212 <      sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
213 <              filename_.c_str());
214 <      painCave.isFatal = 1;
215 <      simError();
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 >      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 <    parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
255 <    
256 <    //parse dump lines
257 <    
258 <    i = 0;
259 <    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
253 >
254 >  }
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 >    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 <      for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
276 <           integrableObject = mol->nextIntegrableObject(ii)) {          
277 <        
278 <        eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
279 <        
280 <        if (eof_test == NULL) {
281 <          sprintf(painCave.errMsg,
282 <                  "DumpReader Error: error in reading file %s\n"
283 <                  "natoms  = %d; index = %d\n"
284 <                  "error reading the line from the file.\n",
285 <                  filename_.c_str(),
286 <                  nTotObjs,
287 <                  i);
288 <          
289 <          painCave.isFatal = 1;
290 <          simError();
291 <        }
292 <        
293 <        parseDumpLine(read_buffer, integrableObject);
294 <        i++;
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: can not find <Snapshot>\n");
307 >      painCave.isFatal = 1;
308 >      simError();
309 >    }
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 >  
326 >  }
327 >  
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 < 2) {
337 >      sprintf(painCave.errMsg,
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 +  }
445 +  
446 +
447 +  void  DumpReader::readStuntDoubles(std::istream& inputStream) {
448 +
449 +    inputStream.getline(buffer, bufferSize);
450 +    std::string line(buffer);
451      
452 <    // MPI Section of code..........
453 <    
454 < #else //IS_MPI
455 <    
456 <    // first thing first, suspend fatalities.
457 <    int masterNode = 0;
458 <    int nCurObj;
459 <    painCave.isEventLoop = 1;
460 <    
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]);
452 >    if (line.find("<StuntDoubles>") == std::string::npos) {
453 >      sprintf(painCave.errMsg,
454 >              "DumpReader Error: Missing <StuntDoubles>\n");
455 >      painCave.isFatal = 1;
456 >      simError();
457 >    }
458 >
459 >    while(inputStream.getline(buffer, bufferSize)) {
460 >      line = buffer;
461        
462 <      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
463 <      
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();
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 <      nitems = atoi(read_buffer);
488 <      
365 <      // Check to see that the number of integrable objects in the
366 <      // intial configuration file is the same as derived from the
367 <      // meta-data file.
368 <      
369 <      if (nTotObjs != nitems) {
370 <        sprintf(painCave.errMsg,
371 <                "DumpReader Error. %s nIntegrable, %d, "
372 <                "does not match the meta-data file's nIntegrable, %d.\n",
373 <                filename_.c_str(),
374 <                nTotObjs,
375 <                info_->getNGlobalIntegrableObjects());
376 <        
377 <        painCave.isFatal = 1;
378 <        simError();
487 >      if(line.find("</FrameData>") != std::string::npos) {
488 >        break;
489        }
490        
491 <      //read the boxMat from the comment line
492 <      
493 <      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
494 <      
495 <      if (eof_test == NULL) {
496 <        sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
387 <                filename_.c_str());
388 <        painCave.isFatal = 1;
389 <        simError();
491 >      StringTokenizer tokenizer(line, " ;\t\n\r{}:,");
492 >      if (!tokenizer.hasMoreTokens()) {
493 >        sprintf(painCave.errMsg,
494 >                "DumpReader Error: Not enough Tokens.\n%s\n", line.c_str());
495 >        painCave.isFatal = 1;
496 >        simError();      
497        }
498 <      
499 <      //Every single processor will parse the comment line by itself
500 <      //By using this way, we might lose some efficiency, but if we want to add
501 <      //more parameters into comment line, we only need to modify function
502 <      //parseCommentLine
503 <      
504 <      MPI_Bcast(read_buffer, maxBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
505 <      parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
506 <      
507 <      for(i = 0; i < info_->getNGlobalMolecules(); i++) {
508 <        int which_node = info_->getMolToProc(i);
509 <        
510 <        if (which_node == masterNode) {
511 <          //molecules belong to master node
512 <          
513 <          mol = info_->getMoleculeByGlobalIndex(i);
514 <          
515 <          if (mol == NULL) {
516 <            sprintf(painCave.errMsg, "DumpReader Error: Molecule not found on node %d!", worldRank);
517 <            painCave.isFatal = 1;
518 <            simError();
519 <          }
520 <          
521 <          for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
522 <               integrableObject = mol->nextIntegrableObject(ii)){
523 <            
524 <            eof_test = fgets(read_buffer, sizeof(read_buffer), inFile_);
525 <            
526 <            if (eof_test == NULL) {
527 <              sprintf(painCave.errMsg,
528 <                      "DumpReader Error: error in reading file %s\n"
529 <                      "natoms  = %d; index = %d\n"
530 <                      "error reading the line from the file.\n",
531 <                      filename_.c_str(),
532 <                      nTotObjs,
533 <                      i);
534 <              
535 <              painCave.isFatal = 1;
536 <              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 <        }
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        }
461 –    } else {
462 –      //actions taken at slave nodes
463 –      MPI_Bcast(read_buffer, maxBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
538        
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 –      
539      }
540 <    
501 < #endif
502 <    
540 >
541    }
542 <  
543 <  void DumpReader::parseDumpLine(char *line, StuntDouble *integrableObject) {
544 <    
507 <    Vector3d pos;  // position place holders
508 <    Vector3d vel;  // velocity placeholders
509 <    Quat4d q;    // the quaternions
510 <    Vector3d ji;   // angular velocity placeholders;
511 <    StringTokenizer tokenizer(line);
512 <    int nTokens;
513 <    
514 <    nTokens = tokenizer.countTokens();
515 <    
516 <    if (nTokens < 14) {
517 <      sprintf(painCave.errMsg,
518 <              "DumpReader Error: Not enough Tokens.\n%s\n", line);
519 <      painCave.isFatal = 1;
520 <      simError();
521 <    }
522 <    
523 <    std::string name = tokenizer.nextToken();
524 <    
525 <    if (name != integrableObject->getType()) {
526 <      
527 <      sprintf(painCave.errMsg,
528 <              "DumpReader Error: Atom type [%s] in %s does not match Atom Type [%s] in .md file.\n",
529 <              name.c_str(), filename_.c_str(), integrableObject->getType().c_str());
530 <      painCave.isFatal = 1;
531 <      simError();        
532 <    }
533 <    
534 <    pos[0] = tokenizer.nextTokenAsDouble();
535 <    pos[1] = tokenizer.nextTokenAsDouble();
536 <    pos[2] = tokenizer.nextTokenAsDouble();
537 <    if (needPos_) {
538 <      integrableObject->setPos(pos);
539 <    }
540 <    
541 <    vel[0] = tokenizer.nextTokenAsDouble();
542 <    vel[1] = tokenizer.nextTokenAsDouble();
543 <    vel[2] = tokenizer.nextTokenAsDouble();
544 <    if (needVel_) {
545 <      integrableObject->setVel(vel);
546 <    }
547 <    
548 <    if (integrableObject->isDirectional()) {
549 <      
550 <      q[0] = tokenizer.nextTokenAsDouble();
551 <      q[1] = tokenizer.nextTokenAsDouble();
552 <      q[2] = tokenizer.nextTokenAsDouble();
553 <      q[3] = tokenizer.nextTokenAsDouble();
554 <      
555 <      double qlen = q.length();
556 <      if (qlen < oopse::epsilon) { //check quaternion is not equal to 0
557 <        
558 <        sprintf(painCave.errMsg,
559 <                "DumpReader Error: initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2 ~ 0).\n");
560 <        painCave.isFatal = 1;
561 <        simError();
562 <        
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 <    
578 <  }
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 <              "DumpReader Error: Not enough tokens in comment line: %s", line);
597 <      painCave.isFatal = 1;
598 <      simError();  
599 <    }
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 <      s->setChi(chi);
623 <      s->setIntegralOfChiDt(integralOfChiDt);
624 <    }
625 <    
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 <    }
640 <    
641 <    
642 <  }
643 <  
644 < }//end namespace oopse
542 >
543 >  
544 > }//end namespace oopse

Diff Legend

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