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 3 by tim, Fri Sep 24 16:27:58 2004 UTC vs.
Revision 721 by chrisfen, Tue Nov 8 13:32:27 2005 UTC

# Line 1 | Line 1
1 < #define _LARGEFILE_SOURCE64
2 < #define _FILE_OFFSET_BITS 64
3 <
4 < #include <sys/types.h>
5 < #include <sys/stat.h>
6 <
7 < #include <iostream>
8 < #include <math.h>
9 <
10 < #include <stdio.h>
11 < #include <stdlib.h>
12 < #include <string.h>
13 <
14 <
15 < #include "io/ReadWrite.hpp"
16 < #include "utils/simError.h"
17 <
18 < #ifdef IS_MPI
19 < #include <mpi.h>
20 < #include "brains/mpiSimulation.hpp"
21 < #define TAKE_THIS_TAG_CHAR 0
22 < #define TAKE_THIS_TAG_INT 1
23 < #endif // is_mpi
24 <
25 <
26 < DumpReader :: DumpReader(const char *in_name ){
27 <
28 <  isScanned = false;
29 <
30 < #ifdef IS_MPI
31 <  if (worldRank == 0) {
32 < #endif
33 <
34 <  inFile = fopen(in_name, "r");
35 <  if(inFile == NULL){
36 <    sprintf(painCave.errMsg,
37 <            "Cannot open file: %s\n", in_name);
38 <    painCave.isFatal = 1;
39 <    simError();
40 <  }
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 <  inFileName = in_name;
43 < #ifdef IS_MPI
44 <  }
45 <  strcpy( checkPointMsg, "Dump file opened for reading successfully." );
46 <  MPIcheckPoint();
47 < #endif
48 <  return;  
49 < }
50 <
51 < DumpReader :: ~DumpReader( ){
52 < #ifdef IS_MPI
53 <  if (worldRank == 0) {
54 < #endif
55 <  vector<fpos_t*>::iterator i;
56 <
57 <  int error;
58 <  error = fclose( inFile );
59 <  if( error ){
60 <    sprintf( painCave.errMsg,
61 <             "Error closing %s\n", inFileName.c_str());
62 <    simError();
63 <  }
64 <
65 <  for(i = framePos.begin(); i != framePos.end(); ++i)
66 <    delete *i;
67 <  framePos.clear();
68 <  
69 < #ifdef IS_MPI
70 <  }
71 <  strcpy( checkPointMsg, "Dump file closed successfully." );
72 <  MPIcheckPoint();
73 < #endif
74 <
75 <  return;
76 < }
77 <
78 < int DumpReader::getNframes( void ){
79 <
80 <  if( !isScanned )
81 <    scanFile();
82 <  return framePos.size();
83 < }
84 <
85 < void DumpReader::scanFile( void ){
86 <
87 <  int i, j;
88 <  int lineNum = 0;
89 <  char readBuffer[2000];
90 <  fpos_t *currPos;
91 <
92 < #ifdef IS_MPI
93 <  if( worldRank == 0 ){
94 < #endif // is_mpi
95 <    
96 <    rewind( inFile );
97 <    
98 <    currPos = new fpos_t;
99 <    fgetpos( inFile, currPos );
100 <    fgets( readBuffer, sizeof( readBuffer ), inFile );
101 <    lineNum++;
102 <    if( feof( inFile ) ){
103 <      sprintf( painCave.errMsg,
104 <               "File \"%s\" ended unexpectedly at line %d\n",
105 <               inFileName.c_str(),
106 <               lineNum );
107 <      painCave.isFatal = 1;
108 <      simError();
109 <    }
110 <
111 <    while( !feof( inFile ) ){
112 <      
113 <      framePos.push_back(currPos);
114 <
115 <      i = atoi(readBuffer);
116 <      
117 <      fgets( readBuffer, sizeof( readBuffer ), inFile );
118 <      lineNum++;    
119 <      if( feof( inFile ) ){
120 <        sprintf( painCave.errMsg,
121 <                 "File \"%s\" ended unexpectedly at line %d\n",
122 <                 inFileName.c_str(),
123 <                 lineNum );
124 <        painCave.isFatal = 1;
125 <        simError();
126 <      }
127 <            
128 <      for(j=0; j<i; j++){
129 <        
130 <        fgets( readBuffer, sizeof( readBuffer ), inFile );
131 <        lineNum++;    
132 <        if( feof( inFile ) ){
133 <          sprintf( painCave.errMsg,
134 <                   "File \"%s\" ended unexpectedly at line %d,"
135 <                   " with atom %d\n",
136 <                   inFileName.c_str(),
137 <                   lineNum,
138 <                   j );
139 <          painCave.isFatal = 1;
140 <          simError();
141 <        }
142 <        
143 <      }
144 <      
145 <      currPos = new fpos_t;
146 <      fgetpos( inFile, currPos );
147 <      fgets( readBuffer, sizeof( readBuffer ), inFile );
148 <      lineNum++;
149 <    }
150 <    
151 <    delete currPos;
152 <    rewind( inFile );
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 <    isScanned = true;
76 <
77 < #ifdef IS_MPI
78 <  }
79 <  strcpy( checkPointMsg, "Successfully scanned DumpFile\n" );
80 <  MPIcheckPoint();
81 < #endif // is_mpi
82 < }
83 <
84 < void DumpReader :: readFrame( SimInfo* the_simnfo, int whichFrame){
85 <
86 <  simnfo = the_simnfo;
87 <
88 <  this->readSet( whichFrame );
89 < }
90 <
91 <
92 <
93 < void DumpReader :: readSet( int whichFrame ){
94 <
95 <  int i;
96 <  unsigned int j;
97 <
98 < #ifdef IS_MPI
99 <  int done, which_node, which_atom; // loop counter
100 < #endif //is_mpi
101 <
102 <  const int BUFFERSIZE = 2000; // size of the read buffer
103 <  int nTotObjs; // the number of atoms
104 <  char read_buffer[BUFFERSIZE]; //the line buffer for reading
105 <
106 <  char *eof_test; // ptr to see when we reach the end of the file
107 <  char *parseErr;
108 <
109 <  vector<StuntDouble*> integrableObjects;
110 <
111 <
112 < #ifndef IS_MPI
113 <
114 <  fsetpos(inFile, framePos[whichFrame]);
115 <  eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
116 <  if( eof_test == NULL ){
117 <    sprintf( painCave.errMsg,
118 <             "DumpReader error: error reading 1st line of \"%s\"\n",
119 <             inFileName.c_str() );
120 <    painCave.isFatal = 1;
121 <    simError();
122 <  }
123 <
124 <  nTotObjs = atoi( read_buffer );
125 <
126 <  if( nTotObjs != simnfo->getTotIntegrableObjects() ){
127 <    sprintf( painCave.errMsg,
128 <             "DumpReader error. %s nIntegrable, %d, "
129 <             "does not match the meta-data file's nIntegrable, %d.\n",
130 <             inFileName.c_str(), nTotObjs, simnfo->getTotIntegrableObjects());
131 <    painCave.isFatal = 1;
132 <    simError();
133 <  }
134 <
135 <  //read the box mat from the comment line
136 <
137 <  eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
138 <  if(eof_test == NULL){
139 <    sprintf( painCave.errMsg,
140 <             "error in reading commment in %s\n", inFileName.c_str());
141 <    painCave.isFatal = 1;
142 <    simError();
143 <  }
144 <
145 <  parseErr = parseCommentLine( read_buffer, simnfo);
146 <  if( parseErr != NULL ){
147 <    strcpy( painCave.errMsg, parseErr );
148 <    painCave.isFatal = 1;
149 <    simError();
150 <  }
151 <
152 <  //parse dump lines
153 <
154 <  for( i=0; i < simnfo->n_mol; i++){
155 <
156 <    integrableObjects = (simnfo->molecules[i]).getIntegrableObjects();
157 <
158 <    for(j = 0; j < integrableObjects.size(); j++){
159 <
160 <      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
161 <      if(eof_test == NULL){
162 <        sprintf(painCave.errMsg,
163 <              "error in reading file %s\n"
164 <              "natoms  = %d; index = %d\n"
165 <              "error reading the line from the file.\n",
166 <              inFileName.c_str(), nTotObjs, i );
167 <        painCave.isFatal = 1;
168 <        simError();
169 <      }
170 <      
171 <      parseErr = parseDumpLine( read_buffer, integrableObjects[j]);
172 <      if( parseErr != NULL ){
173 <        strcpy( painCave.errMsg, parseErr );
174 <        painCave.isFatal = 1;
175 <        simError();
255 <      }
256 <    }
257 <  }
258 <
259 <  // MPI Section of code..........
260 < #else //IS_MPI
261 <
262 <  // first thing first, suspend fatalities.
263 <  painCave.isEventLoop = 1;
264 <
265 <  int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
266 <  int haveError;
267 <
268 <  MPI_Status istatus;
269 <  int *MolToProcMap = mpiSim->getMolToProcMap();
270 <  int localIndex;
271 <  int nCurObj;
272 <  int nitems;
273 <
274 <  nTotObjs = simnfo->getTotIntegrableObjects();
275 <  haveError = 0;
276 <  if (worldRank == 0) {
277 <     fsetpos(inFile,  framePos[whichFrame]);
278 <
279 <    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
280 <    if( eof_test == NULL ){
281 <      sprintf( painCave.errMsg,
282 <               "Error reading 1st line of %s \n ",inFileName.c_str());
283 <      haveError = 1;
284 <      simError();
285 <    }
286 <
287 <    nitems = atoi( read_buffer );
288 <
289 <    // Check to see that the number of integrable objects in the
290 <    // intial configuration file is the same as derived from the
291 <    // meta-data file.
292 <
293 <    if( nTotObjs != nitems){
294 <      sprintf( painCave.errMsg,
295 <               "DumpReader Error. %s nIntegrable, %d, "
296 <               "does not match the meta-data file's nIntegrable, %d.\n",
297 <               inFileName.c_str(), nTotObjs, simnfo->getTotIntegrableObjects());
298 <      haveError= 1;
299 <      simError();
300 <    }
301 <
302 <    //read the boxMat from the comment line
303 <
304 <    eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
305 <    if(eof_test == NULL){
306 <      sprintf( painCave.errMsg,
307 <               "error in reading commment in %s\n", inFileName.c_str());
308 <      haveError = 1;
309 <      simError();
310 <    }
311 <
312 <    //Every single processor will parse the comment line by itself
313 <    //By using this way, we might lose some efficiency, but if we want to add
314 <    //more parameters into comment line, we only need to modify function
315 <    //parseCommentLine
316 <
317 <    MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
318 <
319 <    parseErr = parseCommentLine( read_buffer, simnfo);
320 <
321 <    if( parseErr != NULL ){
322 <      strcpy( painCave.errMsg, parseErr );
323 <      haveError = 1;
324 <      simError();
325 <    }
326 <
327 <    for (i=0 ; i < mpiSim->getNMolGlobal(); i++) {
328 <      which_node = MolToProcMap[i];
329 <      if(which_node == 0){
330 <       //molecules belong to master node
331 <
332 <      localIndex = mpiSim->getGlobalToLocalMol(i);
333 <
334 <      if(localIndex == -1) {
335 <        strcpy(painCave.errMsg, "Molecule not found on node 0!");
336 <        haveError = 1;
337 <        simError();
338 <      }
339 <
340 <       integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();
341 <       for(j=0; j < integrableObjects.size(); j++){
342 <        
343 <          eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
344 <          if(eof_test == NULL){
345 <                sprintf(painCave.errMsg,
346 <                    "error in reading file %s\n"
347 <                    "natoms  = %d; index = %d\n"
348 <                    "error reading the line from the file.\n",
349 <                    inFileName.c_str(), nTotObjs, i );
350 <                haveError= 1;
351 <                simError();
352 <          }
353 <          
354 <          if(haveError) nodeZeroError();
355 <
356 <          parseDumpLine(read_buffer, integrableObjects[j]);
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 <       }
178 <
179 <
180 <      }
181 <      else{
182 <      //molecule belongs to slave nodes
183 <
184 <        MPI_Recv(&nCurObj, 1, MPI_INT, which_node,
185 <               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
186 <      
187 <       for(j=0; j < nCurObj; j++){
188 <        
189 <          eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
190 <          if(eof_test == NULL){
191 <                sprintf(painCave.errMsg,
192 <                    "error in reading file %s\n"
193 <                    "natoms  = %d; index = %d\n"
194 <                    "error reading the line from the file.\n",
195 <                    inFileName.c_str(), nTotObjs, i );
196 <                haveError= 1;
197 <                simError();
198 <          }
199 <          
200 <          if(haveError) nodeZeroError();
201 <
202 <            MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
203 <                      TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
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 <       }
312 <
313 <      }
314 <      
315 <    }
316 <    
317 <  }
318 <  else{
319 <  //actions taken at slave nodes
320 <    MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
321 <
322 <    parseErr = parseCommentLine( read_buffer, simnfo);
323 <
324 <    if( parseErr != NULL ){
325 <      strcpy( painCave.errMsg, parseErr );
326 <      haveError = 1;
327 <      simError();
328 <    }
329 <  
330 <    for (i=0 ; i < mpiSim->getNMolGlobal(); i++) {
331 <      which_node = MolToProcMap[i];
332 <      
333 <      if(which_node == worldRank){
334 <      //molecule with global index i belongs to this processor
335 <      
336 <        localIndex = mpiSim->getGlobalToLocalMol(i);
337 <
338 <        if(localIndex == -1) {
339 <          sprintf(painCave.errMsg, "Molecule not found on node %d\n", worldRank);
340 <          haveError = 1;
341 <          simError();
342 <        }
343 <
344 <        integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();        
345 <
346 <        nCurObj = integrableObjects.size();
347 <        
348 <        MPI_Send(&nCurObj, 1, MPI_INT, 0,
349 <                        TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
350 <
351 <        for(j = 0; j < integrableObjects.size(); j++){
352 <
353 <          MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
354 <                              TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
355 <
356 <          parseErr = parseDumpLine(read_buffer, integrableObjects[j]);
357 <
358 <          if( parseErr != NULL ){
359 <                strcpy( painCave.errMsg, parseErr );
360 <                simError();
361 <          }
362 <
363 <        }
364 <          
365 <      }
366 <      
367 <    }
368 <
369 <  }
370 <
371 < #endif
372 < }
373 <
374 < char* DumpReader::parseDumpLine(char* readLine, StuntDouble* sd){
375 <
376 <  char *foo; // the pointer to the current string token
377 <
378 <  double pos[3]; // position place holders
379 <  double vel[3]; // velocity placeholders
380 <  double q[4]; // the quaternions
381 <  double ji[3]; // angular velocity placeholders;
382 <  double qSqr, qLength; // needed to normalize the quaternion vector.
383 <
384 <
385 <  // set the string tokenizer
386 <
387 <  foo = strtok(readLine, " ,;\t");
388 <
389 <  // check the atom name to the current atom
390 <
391 <  if( strcmp( foo, sd->getType() ) ){
392 <    sprintf( painCave.errMsg,
393 <             "DumpReader error.  Does not"
394 <             " match the meta-data atom %s.\n",
395 <             sd->getType() );
396 <    return strdup( painCave.errMsg );
397 <  }
398 <
399 <  // get the positions
400 <
401 <  foo = strtok(NULL, " ,;\t");
402 <  if(foo == NULL){
403 <    sprintf( painCave.errMsg,
404 <             "error in reading postition x from %s\n",
405 <             inFileName.c_str());
406 <    return strdup( painCave.errMsg );
407 <  }
408 <  pos[0] = atof( foo );
409 <
410 <  foo = strtok(NULL, " ,;\t");
411 <  if(foo == NULL){
412 <    sprintf( painCave.errMsg,
413 <             "error in reading postition y from %s\n",
414 <             inFileName.c_str());
415 <    return strdup( painCave.errMsg );
416 <  }
417 <  pos[1] = atof( foo );
418 <
419 <  foo = strtok(NULL, " ,;\t");
420 <  if(foo == NULL){
421 <    sprintf( painCave.errMsg,
422 <             "error in reading postition z from %s\n",
423 <             inFileName.c_str());
424 <    return strdup( painCave.errMsg );
425 <  }
426 <  pos[2] = atof( foo );
427 <
428 <
429 <  // get the velocities
430 <
431 <  foo = strtok(NULL, " ,;\t");
432 <  if(foo == NULL){
433 <    sprintf( painCave.errMsg,
434 <             "error in reading velocity x from %s\n",
435 <             inFileName.c_str() );
436 <    return strdup( painCave.errMsg );
437 <  }
438 <  vel[0] = atof( foo );
439 <
440 <  foo = strtok(NULL, " ,;\t");
441 <  if(foo == NULL){
442 <    sprintf( painCave.errMsg,
443 <             "error in reading velocity x from %s\n",
444 <             inFileName.c_str() );
445 <    return strdup( painCave.errMsg );
446 <  }
447 <  vel[1] = atof( foo );
448 <
449 <  foo = strtok(NULL, " ,;\t");
450 <  if(foo == NULL){
451 <    sprintf( painCave.errMsg,
452 <             "error in reading velocity x from %s\n",
453 <             inFileName.c_str() );
454 <    return strdup( painCave.errMsg );
455 <  }
456 <  vel[2] = atof( foo );
457 <
458 <
459 <  // add the positions and velocities to the atom
460 <
461 <  sd->setPos( pos );
462 <  sd->setVel( vel );
463 <
464 <  if (!sd->isDirectional())
465 <    return NULL;
466 <
467 <  // get the quaternions
468 <
469 <  if( sd->isDirectional() ){
470 <
471 <    foo = strtok(NULL, " ,;\t");
472 <    if(foo == NULL){
473 <      sprintf( painCave.errMsg,
474 <                     "error in reading velocity x from %s\n",
475 <                      inFileName.c_str() );
476 <      return strdup( painCave.errMsg );
477 <    }
478 <    q[0] = atof( foo );
479 <
480 <    foo = strtok(NULL, " ,;\t");
481 <    if(foo == NULL){
482 <      sprintf( painCave.errMsg,
483 <                     "error in reading velocity x from %s\n",
484 <                      inFileName.c_str() );
485 <      return strdup( painCave.errMsg );
486 <    }
487 <    q[1] = atof( foo );
488 <
489 <    foo = strtok(NULL, " ,;\t");
490 <    if(foo == NULL){
491 <      sprintf( painCave.errMsg,
492 <                     "error in reading velocity x from %s\n",
493 <                      inFileName.c_str() );
494 <      return strdup( painCave.errMsg );
495 <    }
496 <    q[2] = atof( foo );
497 <
498 <    foo = strtok(NULL, " ,;\t");
499 <    if(foo == NULL){
500 <      sprintf( painCave.errMsg,
501 <                     "error in reading velocity x from %s\n",
502 <                      inFileName.c_str() );
503 <      return strdup( painCave.errMsg );
504 <    }
505 <    q[3] = atof( foo );
506 <
507 <    // get the angular velocities
508 <
509 <    foo = strtok(NULL, " ,;\t");
510 <    if(foo == NULL){
511 <      sprintf( painCave.errMsg,
512 <                     "error in reading velocity x from %s\n",
513 <                      inFileName.c_str() );
514 <      return strdup( painCave.errMsg );
515 <    }
516 <    ji[0] = atof( foo );
517 <
518 <    foo = strtok(NULL, " ,;\t");
519 <    if(foo == NULL){
520 <      sprintf( painCave.errMsg,
521 <                     "error in reading velocity x from %s\n",
522 <                      inFileName.c_str() );
523 <      return strdup( painCave.errMsg );
524 <    }
525 <    ji[1] = atof(foo );
526 <
527 <    foo = strtok(NULL, " ,;\t");
528 <    if(foo == NULL){
529 <      sprintf( painCave.errMsg,
530 <                     "error in reading velocity x from %s\n",
531 <                      inFileName.c_str() );
532 <      return strdup( painCave.errMsg );
533 <    }
534 <    ji[2] = atof( foo );
535 <
536 <
537 <    // check that the quaternion vector is normalized
538 <
539 <    qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
540 <
541 <    if (fabs(qSqr) < 1e-6) {
542 <      sprintf(painCave.errMsg,
543 <          "initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2 ~ 0).\n");
544 <       return strdup(painCave.errMsg);
545 <    }
546 <
547 <    qLength = sqrt( qSqr );
548 <    q[0] = q[0] / qLength;
549 <    q[1] = q[1] / qLength;
550 <    q[2] = q[2] / qLength;
551 <    q[3] = q[3] / qLength;
552 <
553 <    // add quaternion and angular velocities
554 <
555 <    sd->setQ( q );
556 <    sd->setJ( ji );
557 <  }
558 <
559 <
560 <
561 <  return NULL;
562 < }
563 <
564 <
565 < char* DumpReader::parseCommentLine(char* readLine, SimInfo* entry_plug){
566 <
567 <  double currTime;
568 <  double boxMat[9];
569 <  double theBoxMat3[3][3];
570 <  double chi;
571 <  double integralOfChidt;
572 <  double eta[9];
573 <
574 <  char *foo; // the pointer to the current string token
575 <
576 <  // set the string tokenizer
577 <
578 <  foo = strtok(readLine, " ,;\t");
579 <  // set the timeToken.
580 <
581 <  if(foo == NULL){
582 <    sprintf( painCave.errMsg,
583 <             "error in reading Time from %s\n",
584 <             inFileName.c_str() );
585 <    return strdup( painCave.errMsg );
586 <  }
587 <
588 <  currTime = atof( foo );
589 <  entry_plug->setTime( currTime );
590 <
591 <  //get H-Matrix
592 <
593 <  for(int i = 0 ; i < 9; i++){
594 <    foo = strtok(NULL, " ,;\t");
595 <    if(foo == NULL){
596 <      sprintf( painCave.errMsg,
597 <               "error in reading H[%d] from %s\n", i, inFileName.c_str() );
598 <      return strdup( painCave.errMsg );
599 <    }
600 <    boxMat[i] = atof( foo );
601 <  }
602 <
603 <  for(int i=0;i<3;i++)
604 <    for(int j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
605 <
606 <  //set H-Matrix
607 <  entry_plug->setBoxM( theBoxMat3 );
608 <
609 <  //get chi and integralOfChidt, they should appear by pair
610 <
611 <  if( entry_plug->useInitXSstate ){
612 <    foo = strtok(NULL, " ,;\t\n");
613 <    if(foo != NULL){
614 <      chi = atof(foo);
615 <      
616 <      foo = strtok(NULL, " ,;\t\n");
617 <      if(foo == NULL){
618 <        sprintf( painCave.errMsg,
619 <                 "chi and integralOfChidt should appear by pair in %s\n", inFileName.c_str() );
620 <        return strdup( painCave.errMsg );
621 <      }
622 <      integralOfChidt = atof( foo );
623 <      
624 <      //push chi and integralOfChidt into SimInfo::properties which can be
625 <      //retrieved by integrator later
626 <      DoubleData* chiValue = new DoubleData();
627 <      chiValue->setID(CHIVALUE_ID);
628 <      chiValue->setData(chi);
629 <      entry_plug->addProperty(chiValue);
630 <      
706 <      DoubleData* integralOfChidtValue = new DoubleData();
707 <      integralOfChidtValue->setID(INTEGRALOFCHIDT_ID);
708 <      integralOfChidtValue->setData(integralOfChidt);
709 <      entry_plug->addProperty(integralOfChidtValue);
710 <      
711 <    }
712 <    else
713 <      return NULL;
714 <    
715 <    //get eta
716 <    foo = strtok(NULL, " ,;\t\n");
717 <    if(foo != NULL ){
718 <  
719 <      for(int i = 0 ; i < 9; i++){
720 <        
721 <        if(foo == NULL){
722 <          sprintf( painCave.errMsg,
723 <                   "error in reading eta[%d] from %s\n", i, inFileName.c_str() );
724 <          return strdup( painCave.errMsg );
725 <        }
726 <        eta[i] = atof( foo );
727 <        foo = strtok(NULL, " ,;\t\n");
728 <      }
729 <    }
730 <    else
731 <      return NULL;
732 <    
733 <    //push eta into SimInfo::properties which can be
734 <    //retrieved by integrator later
735 <    //entry_plug->setBoxM( theBoxMat3 );
736 <    DoubleArrayData* etaValue = new DoubleArrayData();
737 <    etaValue->setID(ETAVALUE_ID);
738 <    etaValue->setData(eta, 9);
739 <    entry_plug->addProperty(etaValue);
740 <  }
741 <
742 <  return NULL;
743 < }
744 <
745 < #ifdef IS_MPI
746 < void DumpReader::nodeZeroError( void ){
747 <  int j, myStatus;
748 <
749 <  myStatus = 0;
750 <  for (j = 0; j < mpiSim->getNProcessors(); j++) {
751 <    MPI_Send( &myStatus, 1, MPI_INT, j,
752 <              TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
753 <  }
754 <
755 <
756 <  MPI_Finalize();
757 <  exit (0);
758 <
759 < }
760 <
761 < void DumpReader::anonymousNodeDie( void ){
762 <
763 <  MPI_Finalize();
764 <  exit (0);
765 < }
766 < #endif
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

Diff Legend

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