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 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 996 by chrisfen, Wed Jun 28 14:35:14 2006 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 "ReadWrite.hpp"
16 < #include "simError.h"
17 <
18 < #ifdef IS_MPI
19 < #include <mpi.h>
20 < #include "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
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 <    rewind( inFile );
75 > #ifdef IS_MPI
76      
77 <    currPos = new fpos_t;
78 <    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 ) ){
77 >    if (worldRank == 0) {
78 > #endif
79        
80 <      framePos.push_back(currPos);
114 <
115 <      i = atoi(readBuffer);
80 >      inFile_ = new std::ifstream(filename_.c_str());
81        
82 <      fgets( readBuffer, sizeof( readBuffer ), inFile );
83 <      lineNum++;    
84 <      if( feof( inFile ) ){
85 <        sprintf( painCave.errMsg,
86 <                 "File \"%s\" ended unexpectedly at line %d\n",
87 <                 inFileName.c_str(),
88 <                 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 <      }
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 <      currPos = new fpos_t;
91 <      fgetpos( inFile, currPos );
92 <      fgets( readBuffer, sizeof( readBuffer ), inFile );
148 <      lineNum++;
149 <    }
90 > #ifdef IS_MPI
91 >      
92 >    }
93      
94 <    delete currPos;
95 <    rewind( inFile );
96 <    
97 <    isScanned = true;
98 <
99 < #ifdef IS_MPI
100 <  }
101 <  strcpy( checkPointMsg, "Successfully scanned DumpFile\n" );
102 <  MPIcheckPoint();
103 < #endif // is_mpi
104 < }
105 <
106 < void DumpReader :: readFrame( SimInfo* the_simnfo, int whichFrame){
107 <
165 <  simnfo = the_simnfo;
166 <
167 <  this->readSet( whichFrame );
168 < }
169 <
170 <
171 <
172 < void DumpReader :: readSet( int whichFrame ){
173 <
174 <  int i;
175 <  unsigned int j;
176 <
177 < #ifdef IS_MPI
178 <  int done, which_node, which_atom; // loop counter
179 < #endif //is_mpi
180 <
181 <  const int BUFFERSIZE = 2000; // size of the read buffer
182 <  int nTotObjs; // the number of atoms
183 <  char read_buffer[BUFFERSIZE]; //the line buffer for reading
184 <
185 <  char *eof_test; // ptr to see when we reach the end of the file
186 <  char *parseErr;
187 <
188 <  vector<StuntDouble*> integrableObjects;
189 <
190 <
191 < #ifndef IS_MPI
192 <
193 <  fsetpos(inFile, framePos[whichFrame]);
194 <  eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
195 <  if( eof_test == NULL ){
196 <    sprintf( painCave.errMsg,
197 <             "DumpReader error: error reading 1st line of \"%s\"\n",
198 <             inFileName.c_str() );
199 <    painCave.isFatal = 1;
200 <    simError();
201 <  }
202 <
203 <  nTotObjs = atoi( read_buffer );
204 <
205 <  if( nTotObjs != simnfo->getTotIntegrableObjects() ){
206 <    sprintf( painCave.errMsg,
207 <             "DumpReader error. %s nIntegrable, %d, "
208 <             "does not match the meta-data file's nIntegrable, %d.\n",
209 <             inFileName.c_str(), nTotObjs, simnfo->getTotIntegrableObjects());
210 <    painCave.isFatal = 1;
211 <    simError();
212 <  }
213 <
214 <  //read the box mat from the comment line
215 <
216 <  eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
217 <  if(eof_test == NULL){
218 <    sprintf( painCave.errMsg,
219 <             "error in reading commment in %s\n", inFileName.c_str());
220 <    painCave.isFatal = 1;
221 <    simError();
222 <  }
223 <
224 <  parseErr = parseCommentLine( read_buffer, simnfo);
225 <  if( parseErr != NULL ){
226 <    strcpy( painCave.errMsg, parseErr );
227 <    painCave.isFatal = 1;
228 <    simError();
229 <  }
230 <
231 <  //parse dump lines
232 <
233 <  for( i=0; i < simnfo->n_mol; i++){
234 <
235 <    integrableObjects = (simnfo->molecules[i]).getIntegrableObjects();
236 <
237 <    for(j = 0; j < integrableObjects.size(); j++){
238 <
239 <      eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
240 <      if(eof_test == NULL){
241 <        sprintf(painCave.errMsg,
242 <              "error in reading file %s\n"
243 <              "natoms  = %d; index = %d\n"
244 <              "error reading the line from the file.\n",
245 <              inFileName.c_str(), nTotObjs, i );
246 <        painCave.isFatal = 1;
247 <        simError();
248 <      }
94 >    strcpy(checkPointMsg, "Dump file opened for reading successfully.");
95 >    MPIcheckPoint();
96 >    
97 > #endif
98 >    
99 >    return;
100 >  }
101 >  
102 >  DumpReader::~DumpReader() {
103 >    
104 > #ifdef IS_MPI
105 >    
106 >    if (worldRank == 0) {
107 > #endif
108        
109 <      parseErr = parseDumpLine( read_buffer, integrableObjects[j]);
251 <      if( parseErr != NULL ){
252 <        strcpy( painCave.errMsg, parseErr );
253 <        painCave.isFatal = 1;
254 <        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]);
357 <          
358 <       }
359 <
360 <
361 <      }
362 <      else{
363 <      //molecule belongs to slave nodes
364 <
365 <        MPI_Recv(&nCurObj, 1, MPI_INT, which_node,
366 <               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
109 >      delete inFile_;
110        
111 <       for(j=0; j < nCurObj; j++){
369 <        
370 <          eof_test = fgets(read_buffer, sizeof(read_buffer), inFile);
371 <          if(eof_test == NULL){
372 <                sprintf(painCave.errMsg,
373 <                    "error in reading file %s\n"
374 <                    "natoms  = %d; index = %d\n"
375 <                    "error reading the line from the file.\n",
376 <                    inFileName.c_str(), nTotObjs, i );
377 <                haveError= 1;
378 <                simError();
379 <          }
380 <          
381 <          if(haveError) nodeZeroError();
382 <
383 <            MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
384 <                      TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
385 <          
386 <       }
387 <
388 <      }
111 > #ifdef IS_MPI
112        
113 <    }
391 <    
392 <  }
393 <  else{
394 <  //actions taken at slave nodes
395 <    MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
396 <
397 <    parseErr = parseCommentLine( read_buffer, simnfo);
398 <
399 <    if( parseErr != NULL ){
400 <      strcpy( painCave.errMsg, parseErr );
401 <      haveError = 1;
402 <      simError();
403 <    }
404 <  
405 <    for (i=0 ; i < mpiSim->getNMolGlobal(); i++) {
406 <      which_node = MolToProcMap[i];
407 <      
408 <      if(which_node == worldRank){
409 <      //molecule with global index i belongs to this processor
410 <      
411 <        localIndex = mpiSim->getGlobalToLocalMol(i);
412 <
413 <        if(localIndex == -1) {
414 <          sprintf(painCave.errMsg, "Molecule not found on node %d\n", worldRank);
415 <          haveError = 1;
416 <          simError();
417 <        }
418 <
419 <        integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();        
420 <
421 <        nCurObj = integrableObjects.size();
422 <        
423 <        MPI_Send(&nCurObj, 1, MPI_INT, 0,
424 <                        TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
425 <
426 <        for(j = 0; j < integrableObjects.size(); j++){
427 <
428 <          MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
429 <                              TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
430 <
431 <          parseErr = parseDumpLine(read_buffer, integrableObjects[j]);
432 <
433 <          if( parseErr != NULL ){
434 <                strcpy( painCave.errMsg, parseErr );
435 <                simError();
436 <          }
437 <
438 <        }
439 <          
440 <      }
441 <      
442 <    }
443 <
444 <  }
445 <
446 < #endif
447 < }
448 <
449 < char* DumpReader::parseDumpLine(char* readLine, StuntDouble* sd){
450 <
451 <  char *foo; // the pointer to the current string token
452 <
453 <  double pos[3]; // position place holders
454 <  double vel[3]; // velocity placeholders
455 <  double q[4]; // the quaternions
456 <  double ji[3]; // angular velocity placeholders;
457 <  double qSqr, qLength; // needed to normalize the quaternion vector.
458 <
459 <
460 <  // set the string tokenizer
461 <
462 <  foo = strtok(readLine, " ,;\t");
463 <
464 <  // check the atom name to the current atom
465 <
466 <  if( strcmp( foo, sd->getType() ) ){
467 <    sprintf( painCave.errMsg,
468 <             "DumpReader error.  Does not"
469 <             " match the meta-data atom %s.\n",
470 <             sd->getType() );
471 <    return strdup( painCave.errMsg );
472 <  }
473 <
474 <  // get the positions
475 <
476 <  foo = strtok(NULL, " ,;\t");
477 <  if(foo == NULL){
478 <    sprintf( painCave.errMsg,
479 <             "error in reading postition x from %s\n",
480 <             inFileName.c_str());
481 <    return strdup( painCave.errMsg );
482 <  }
483 <  pos[0] = atof( foo );
484 <
485 <  foo = strtok(NULL, " ,;\t");
486 <  if(foo == NULL){
487 <    sprintf( painCave.errMsg,
488 <             "error in reading postition y from %s\n",
489 <             inFileName.c_str());
490 <    return strdup( painCave.errMsg );
491 <  }
492 <  pos[1] = atof( foo );
493 <
494 <  foo = strtok(NULL, " ,;\t");
495 <  if(foo == NULL){
496 <    sprintf( painCave.errMsg,
497 <             "error in reading postition z from %s\n",
498 <             inFileName.c_str());
499 <    return strdup( painCave.errMsg );
500 <  }
501 <  pos[2] = atof( foo );
502 <
503 <
504 <  // get the velocities
505 <
506 <  foo = strtok(NULL, " ,;\t");
507 <  if(foo == NULL){
508 <    sprintf( painCave.errMsg,
509 <             "error in reading velocity x from %s\n",
510 <             inFileName.c_str() );
511 <    return strdup( painCave.errMsg );
512 <  }
513 <  vel[0] = atof( foo );
514 <
515 <  foo = strtok(NULL, " ,;\t");
516 <  if(foo == NULL){
517 <    sprintf( painCave.errMsg,
518 <             "error in reading velocity x from %s\n",
519 <             inFileName.c_str() );
520 <    return strdup( painCave.errMsg );
521 <  }
522 <  vel[1] = atof( foo );
523 <
524 <  foo = strtok(NULL, " ,;\t");
525 <  if(foo == NULL){
526 <    sprintf( painCave.errMsg,
527 <             "error in reading velocity x from %s\n",
528 <             inFileName.c_str() );
529 <    return strdup( painCave.errMsg );
530 <  }
531 <  vel[2] = atof( foo );
532 <
533 <
534 <  // add the positions and velocities to the atom
535 <
536 <  sd->setPos( pos );
537 <  sd->setVel( vel );
538 <
539 <  if (!sd->isDirectional())
540 <    return NULL;
541 <
542 <  // get the quaternions
543 <
544 <  if( sd->isDirectional() ){
545 <
546 <    foo = strtok(NULL, " ,;\t");
547 <    if(foo == NULL){
548 <      sprintf( painCave.errMsg,
549 <                     "error in reading velocity x from %s\n",
550 <                      inFileName.c_str() );
551 <      return strdup( painCave.errMsg );
552 <    }
553 <    q[0] = atof( foo );
554 <
555 <    foo = strtok(NULL, " ,;\t");
556 <    if(foo == NULL){
557 <      sprintf( painCave.errMsg,
558 <                     "error in reading velocity x from %s\n",
559 <                      inFileName.c_str() );
560 <      return strdup( painCave.errMsg );
561 <    }
562 <    q[1] = atof( foo );
563 <
564 <    foo = strtok(NULL, " ,;\t");
565 <    if(foo == NULL){
566 <      sprintf( painCave.errMsg,
567 <                     "error in reading velocity x from %s\n",
568 <                      inFileName.c_str() );
569 <      return strdup( painCave.errMsg );
570 <    }
571 <    q[2] = atof( foo );
572 <
573 <    foo = strtok(NULL, " ,;\t");
574 <    if(foo == NULL){
575 <      sprintf( painCave.errMsg,
576 <                     "error in reading velocity x from %s\n",
577 <                      inFileName.c_str() );
578 <      return strdup( painCave.errMsg );
579 <    }
580 <    q[3] = atof( foo );
581 <
582 <    // get the angular velocities
583 <
584 <    foo = strtok(NULL, " ,;\t");
585 <    if(foo == NULL){
586 <      sprintf( painCave.errMsg,
587 <                     "error in reading velocity x from %s\n",
588 <                      inFileName.c_str() );
589 <      return strdup( painCave.errMsg );
590 <    }
591 <    ji[0] = atof( foo );
592 <
593 <    foo = strtok(NULL, " ,;\t");
594 <    if(foo == NULL){
595 <      sprintf( painCave.errMsg,
596 <                     "error in reading velocity x from %s\n",
597 <                      inFileName.c_str() );
598 <      return strdup( painCave.errMsg );
599 <    }
600 <    ji[1] = atof(foo );
601 <
602 <    foo = strtok(NULL, " ,;\t");
603 <    if(foo == NULL){
604 <      sprintf( painCave.errMsg,
605 <                     "error in reading velocity x from %s\n",
606 <                      inFileName.c_str() );
607 <      return strdup( painCave.errMsg );
608 <    }
609 <    ji[2] = atof( foo );
610 <
611 <
612 <    // check that the quaternion vector is normalized
613 <
614 <    qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
615 <
616 <    if (fabs(qSqr) < 1e-6) {
617 <      sprintf(painCave.errMsg,
618 <          "initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2 ~ 0).\n");
619 <       return strdup(painCave.errMsg);
620 <    }
621 <
622 <    qLength = sqrt( qSqr );
623 <    q[0] = q[0] / qLength;
624 <    q[1] = q[1] / qLength;
625 <    q[2] = q[2] / qLength;
626 <    q[3] = q[3] / qLength;
627 <
628 <    // add quaternion and angular velocities
629 <
630 <    sd->setQ( q );
631 <    sd->setJ( ji );
632 <  }
633 <
634 <
635 <
636 <  return NULL;
637 < }
638 <
639 <
640 < char* DumpReader::parseCommentLine(char* readLine, SimInfo* entry_plug){
641 <
642 <  double currTime;
643 <  double boxMat[9];
644 <  double theBoxMat3[3][3];
645 <  double chi;
646 <  double integralOfChidt;
647 <  double eta[9];
648 <
649 <  char *foo; // the pointer to the current string token
650 <
651 <  // set the string tokenizer
652 <
653 <  foo = strtok(readLine, " ,;\t");
654 <  // set the timeToken.
655 <
656 <  if(foo == NULL){
657 <    sprintf( painCave.errMsg,
658 <             "error in reading Time from %s\n",
659 <             inFileName.c_str() );
660 <    return strdup( painCave.errMsg );
661 <  }
662 <
663 <  currTime = atof( foo );
664 <  entry_plug->setTime( currTime );
665 <
666 <  //get H-Matrix
667 <
668 <  for(int i = 0 ; i < 9; i++){
669 <    foo = strtok(NULL, " ,;\t");
670 <    if(foo == NULL){
671 <      sprintf( painCave.errMsg,
672 <               "error in reading H[%d] from %s\n", i, inFileName.c_str() );
673 <      return strdup( painCave.errMsg );
674 <    }
675 <    boxMat[i] = atof( foo );
676 <  }
677 <
678 <  for(int i=0;i<3;i++)
679 <    for(int j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
680 <
681 <  //set H-Matrix
682 <  entry_plug->setBoxM( theBoxMat3 );
683 <
684 <  //get chi and integralOfChidt, they should appear by pair
685 <
686 <  if( entry_plug->useInitXSstate ){
687 <    foo = strtok(NULL, " ,;\t\n");
688 <    if(foo != NULL){
689 <      chi = atof(foo);
690 <      
691 <      foo = strtok(NULL, " ,;\t\n");
692 <      if(foo == NULL){
693 <        sprintf( painCave.errMsg,
694 <                 "chi and integralOfChidt should appear by pair in %s\n", inFileName.c_str() );
695 <        return strdup( painCave.errMsg );
696 <      }
697 <      integralOfChidt = atof( foo );
698 <      
699 <      //push chi and integralOfChidt into SimInfo::properties which can be
700 <      //retrieved by integrator later
701 <      DoubleData* chiValue = new DoubleData();
702 <      chiValue->setID(CHIVALUE_ID);
703 <      chiValue->setData(chi);
704 <      entry_plug->addProperty(chiValue);
705 <      
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;
113 >    }
114      
115 <    //get eta
116 <    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;
115 >    strcpy(checkPointMsg, "Dump file closed successfully.");
116 >    MPIcheckPoint();
117      
118 <    //push eta into SimInfo::properties which can be
119 <    //retrieved by integrator later
120 <    //entry_plug->setBoxM( theBoxMat3 );
121 <    DoubleArrayData* etaValue = new DoubleArrayData();
122 <    etaValue->setID(ETAVALUE_ID);
123 <    etaValue->setData(eta, 9);
124 <    entry_plug->addProperty(etaValue);
125 <  }
126 <
127 <  return NULL;
128 < }
129 <
130 < #ifdef IS_MPI
131 < void DumpReader::nodeZeroError( void ){
132 <  int j, myStatus;
133 <
134 <  myStatus = 0;
135 <  for (j = 0; j < mpiSim->getNProcessors(); j++) {
136 <    MPI_Send( &myStatus, 1, MPI_INT, j,
137 <              TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
138 <  }
139 <
140 <
141 <  MPI_Finalize();
142 <  exit (0);
143 <
144 < }
145 <
146 < void DumpReader::anonymousNodeDie( void ){
147 <
148 <  MPI_Finalize();
149 <  exit (0);
150 < }
151 < #endif
118 > #endif
119 >    
120 >    return;
121 >  }
122 >  
123 >  int DumpReader::getNFrames(void) {
124 >    
125 >    if (!isScanned_)
126 >      scanFile();
127 >    
128 >    return nframes_;
129 >  }
130 >  
131 >  void DumpReader::scanFile(void) {
132 >    int i, j;
133 >    int lineNum = 0;
134 >    char readBuffer[maxBufferSize];
135 >    std::streampos  currPos;
136 >    
137 > #ifdef IS_MPI
138 >    
139 >    if (worldRank == 0) {
140 > #endif // is_mpi
141 >      
142 >      inFile_->seekg (0, std::ios::beg);
143 >      
144 >
145 >      currPos = inFile_->tellg();
146 >      inFile_->getline(readBuffer, sizeof(readBuffer));
147 >      lineNum++;
148 >      
149 >      if (inFile_->eof()) {
150 >        sprintf(painCave.errMsg,
151 >                "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
152 >                filename_.c_str(),
153 >                lineNum);
154 >        painCave.isFatal = 1;
155 >        simError();
156 >      }
157 >      
158 >      while (!inFile_->eof()) {
159 >        framePos_.push_back(currPos);
160 >        
161 >        i = atoi(readBuffer);
162 >        
163 >        inFile_->getline(readBuffer, sizeof(readBuffer));
164 >        lineNum++;
165 >        
166 >        if (inFile_->eof()) {
167 >          sprintf(painCave.errMsg,
168 >                  "DumpReader Error: File \"%s\" ended unexpectedly at line %d\n",
169 >                  filename_.c_str(),
170 >                  lineNum);
171 >          painCave.isFatal = 1;
172 >          simError();
173 >        }
174 >        
175 >        for(j = 0; j < i; j++) {
176 >          inFile_->getline(readBuffer, sizeof(readBuffer));
177 >          lineNum++;
178 >          
179 >          if (inFile_->eof()) {
180 >            sprintf(painCave.errMsg,
181 >                    "DumpReader Error: File \"%s\" ended unexpectedly at line %d,"
182 >                    " with atom %d\n", filename_.c_str(),
183 >                    lineNum,
184 >                    j);
185 >            
186 >            painCave.isFatal = 1;
187 >            simError();
188 >          }
189 >        }
190 >        
191 >        currPos = inFile_->tellg();
192 >        inFile_->getline(readBuffer, sizeof(readBuffer));
193 >        lineNum++;
194 >      }
195 >
196 >      inFile_->seekg (0, std::ios::beg);
197 >      
198 >      nframes_ = framePos_.size();
199 > #ifdef IS_MPI
200 >    }
201 >    
202 >    MPI_Bcast(&nframes_, 1, MPI_INT, 0, MPI_COMM_WORLD);
203 >    
204 >    strcpy(checkPointMsg, "Successfully scanned DumpFile\n");
205 >    MPIcheckPoint();
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 >  
245 >  void DumpReader::readSet(int whichFrame) {
246 >    int i;
247 >    int nTotObjs;                  // the number of atoms
248 >    char read_buffer[maxBufferSize];  //the line buffer for reading
249 >    char * eof_test;               // ptr to see when we reach the end of the file
250 >    
251 >    Molecule* mol;
252 >    StuntDouble* integrableObject;
253 >    SimInfo::MoleculeIterator mi;
254 >    Molecule::IntegrableObjectIterator ii;
255 >    
256 > #ifndef IS_MPI
257 >    inFile_->clear();  
258 >    inFile_->seekg(framePos_[whichFrame]);
259 >        
260 >    if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
261 >      sprintf(painCave.errMsg,
262 >              "DumpReader error: error reading 1st line of \"%s\"\n",
263 >              filename_.c_str());
264 >      painCave.isFatal = 1;
265 >      simError();
266 >    }
267 >    
268 >    nTotObjs = atoi(read_buffer);
269 >    
270 >    if (nTotObjs != info_->getNGlobalIntegrableObjects()) {
271 >      sprintf(painCave.errMsg,
272 >              "DumpReader error. %s nIntegrable, %d, "
273 >              "does not match the meta-data file's nIntegrable, %d.\n",
274 >              filename_.c_str(),
275 >              nTotObjs,
276 >              info_->getNGlobalIntegrableObjects());
277 >      
278 >      painCave.isFatal = 1;
279 >      simError();
280 >    }
281 >    
282 >    //read the box mat from the comment line
283 >    
284 >    
285 >    if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
286 >      sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
287 >              filename_.c_str());
288 >      painCave.isFatal = 1;
289 >      simError();
290 >    }
291 >    
292 >    parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
293 >    
294 >    //parse dump lines
295 >    
296 >    i = 0;
297 >    for (mol = info_->beginMolecule(mi); mol != NULL; mol = info_->nextMolecule(mi)) {
298 >      
299 >      for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;  
300 >           integrableObject = mol->nextIntegrableObject(ii)) {            
301 >        
302 >        
303 >        
304 >        if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
305 >          sprintf(painCave.errMsg,
306 >                  "DumpReader Error: error in reading file %s\n"
307 >                  "natoms  = %d; index = %d\n"
308 >                  "error reading the line from the file.\n",
309 >                  filename_.c_str(),
310 >                  nTotObjs,
311 >                  i);
312 >          
313 >          painCave.isFatal = 1;
314 >          simError();
315 >        }
316 >        
317 >        parseDumpLine(read_buffer, integrableObject);
318 >        i++;
319 >      }
320 >    }
321 >    
322 >    // MPI Section of code..........
323 >    
324 > #else //IS_MPI
325 >    
326 >    // first thing first, suspend fatalities.
327 >    int masterNode = 0;
328 >    int nCurObj;
329 >    painCave.isEventLoop = 1;
330 >    
331 >    int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
332 >    int haveError;
333 >    
334 >    MPI_Status istatus;
335 >    int nitems;
336 >    
337 >    nTotObjs = info_->getNGlobalIntegrableObjects();
338 >    haveError = 0;
339 >    
340 >    if (worldRank == masterNode) {
341 >      inFile_->clear();            
342 >      inFile_->seekg(framePos_[whichFrame]);
343 >      
344 >      if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
345 >        sprintf(painCave.errMsg, "DumpReader Error: Error reading 1st line of %s \n ",
346 >                filename_.c_str());
347 >        painCave.isFatal = 1;
348 >        simError();
349 >      }
350 >      
351 >      nitems = atoi(read_buffer);
352 >      
353 >      // Check to see that the number of integrable objects in the
354 >      // intial configuration file is the same as derived from the
355 >      // meta-data file.
356 >      
357 >      if (nTotObjs != nitems) {
358 >        sprintf(painCave.errMsg,
359 >                "DumpReader Error. %s nIntegrable, %d, "
360 >                "does not match the meta-data file's nIntegrable, %d.\n",
361 >                filename_.c_str(),
362 >                nTotObjs,
363 >                info_->getNGlobalIntegrableObjects());
364 >        
365 >        painCave.isFatal = 1;
366 >        simError();
367 >      }
368 >      
369 >      //read the boxMat from the comment line
370 >      
371 >      
372 >      
373 >      if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
374 >        sprintf(painCave.errMsg, "DumpReader Error: error in reading commment in %s\n",
375 >                filename_.c_str());
376 >        painCave.isFatal = 1;
377 >        simError();
378 >      }
379 >      
380 >      //Every single processor will parse the comment line by itself
381 >      //By using this way, we might lose some efficiency, but if we want to add
382 >      //more parameters into comment line, we only need to modify function
383 >      //parseCommentLine
384 >      
385 >      MPI_Bcast(read_buffer, maxBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
386 >      parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
387 >      
388 >      for(i = 0; i < info_->getNGlobalMolecules(); i++) {
389 >        int which_node = info_->getMolToProc(i);
390 >        
391 >        if (which_node == masterNode) {
392 >          //molecules belong to master node
393 >          
394 >          mol = info_->getMoleculeByGlobalIndex(i);
395 >          
396 >          if (mol == NULL) {
397 >            sprintf(painCave.errMsg, "DumpReader Error: Molecule not found on node %d!", worldRank);
398 >            painCave.isFatal = 1;
399 >            simError();
400 >          }
401 >          
402 >          for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;  
403 >               integrableObject = mol->nextIntegrableObject(ii)){
404 >            
405 >            
406 >            
407 >            if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
408 >              sprintf(painCave.errMsg,
409 >                      "DumpReader Error: error in reading file %s\n"
410 >                      "natoms  = %d; index = %d\n"
411 >                      "error reading the line from the file.\n",
412 >                      filename_.c_str(),
413 >                      nTotObjs,
414 >                      i);
415 >              
416 >              painCave.isFatal = 1;
417 >              simError();
418 >            }
419 >            
420 >            parseDumpLine(read_buffer, integrableObject);
421 >          }
422 >        } else {
423 >          //molecule belongs to slave nodes
424 >          
425 >          MPI_Recv(&nCurObj, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
426 >                   MPI_COMM_WORLD, &istatus);
427 >          
428 >          for(int j = 0; j < nCurObj; j++) {
429 >            
430 >            
431 >            if (!inFile_->getline(read_buffer, sizeof(read_buffer))) {
432 >              sprintf(painCave.errMsg,
433 >                      "DumpReader Error: error in reading file %s\n"
434 >                      "natoms  = %d; index = %d\n"
435 >                      "error reading the line from the file.\n",
436 >                      filename_.c_str(),
437 >                      nTotObjs,
438 >                      i);
439 >              
440 >              painCave.isFatal = 1;
441 >              simError();
442 >            }
443 >            
444 >            MPI_Send(read_buffer, maxBufferSize, MPI_CHAR, which_node,
445 >                     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
446 >          }
447 >        }
448 >      }
449 >    } else {
450 >      //actions taken at slave nodes
451 >      MPI_Bcast(read_buffer, maxBufferSize, MPI_CHAR, masterNode, MPI_COMM_WORLD);
452 >      
453 >      /**@todo*/
454 >      parseCommentLine(read_buffer, info_->getSnapshotManager()->getCurrentSnapshot());
455 >      
456 >      for(i = 0; i < info_->getNGlobalMolecules(); i++) {
457 >        int which_node = info_->getMolToProc(i);
458 >        
459 >        if (which_node == worldRank) {
460 >          //molecule with global index i belongs to this processor
461 >          
462 >          mol = info_->getMoleculeByGlobalIndex(i);
463 >          if (mol == NULL) {
464 >            sprintf(painCave.errMsg, "DumpReader Error: Molecule not found on node %d!", worldRank);
465 >            painCave.isFatal = 1;
466 >            simError();
467 >          }
468 >          
469 >          nCurObj = mol->getNIntegrableObjects();
470 >          
471 >          MPI_Send(&nCurObj, 1, MPI_INT, masterNode, TAKE_THIS_TAG_INT,
472 >                   MPI_COMM_WORLD);
473 >          
474 >          for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;  
475 >               integrableObject = mol->nextIntegrableObject(ii)){
476 >            
477 >            MPI_Recv(read_buffer, maxBufferSize, MPI_CHAR, masterNode,
478 >                     TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
479 >            
480 >            parseDumpLine(read_buffer, integrableObject);
481 >          }
482 >          
483 >        }
484 >        
485 >      }
486 >      
487 >    }
488 >    
489 > #endif
490 >    
491 >  }
492 >  
493 >  void DumpReader::parseDumpLine(char *line, StuntDouble *integrableObject) {
494 >    
495 >    Vector3d pos;  // position place holders
496 >    Vector3d vel;  // velocity placeholders
497 >    Quat4d q;    // the quaternions
498 >    Vector3d ji;   // angular velocity placeholders;
499 >    StringTokenizer tokenizer(line);
500 >    int nTokens;
501 >    
502 >    nTokens = tokenizer.countTokens();
503 >    
504 >    if (nTokens < 14) {
505 >      sprintf(painCave.errMsg,
506 >              "DumpReader Error: Not enough Tokens.\n%s\n", line);
507 >      painCave.isFatal = 1;
508 >      simError();
509 >    }
510 >    
511 >    std::string name = tokenizer.nextToken();
512 >    
513 >    if (name != integrableObject->getType()) {
514 >      
515 >      sprintf(painCave.errMsg,
516 >              "DumpReader Error: Atom type [%s] in %s does not match Atom Type [%s] in .md file.\n",
517 >              name.c_str(), filename_.c_str(), integrableObject->getType().c_str());
518 >      painCave.isFatal = 1;
519 >      simError();        
520 >    }
521 >    
522 >    pos[0] = tokenizer.nextTokenAsDouble();
523 >    pos[1] = tokenizer.nextTokenAsDouble();
524 >    pos[2] = tokenizer.nextTokenAsDouble();
525 >    if (needPos_) {
526 >      integrableObject->setPos(pos);
527 >    }
528 >    
529 >    vel[0] = tokenizer.nextTokenAsDouble();
530 >    vel[1] = tokenizer.nextTokenAsDouble();
531 >    vel[2] = tokenizer.nextTokenAsDouble();
532 >    if (needVel_) {
533 >      integrableObject->setVel(vel);
534 >    }
535 >    
536 >    if (integrableObject->isDirectional()) {
537 >      
538 >      q[0] = tokenizer.nextTokenAsDouble();
539 >      q[1] = tokenizer.nextTokenAsDouble();
540 >      q[2] = tokenizer.nextTokenAsDouble();
541 >      q[3] = tokenizer.nextTokenAsDouble();
542 >      
543 >      RealType qlen = q.length();
544 >      if (qlen < oopse::epsilon) { //check quaternion is not equal to 0
545 >        
546 >        sprintf(painCave.errMsg,
547 >                "DumpReader Error: initial quaternion error (q0^2 + q1^2 + q2^2 + q3^2) ~ 0\n");
548 >        painCave.isFatal = 1;
549 >        simError();
550 >        
551 >      }  
552 >      
553 >      q.normalize();
554 >      if (needQuaternion_) {            
555 >        integrableObject->setQ(q);
556 >      }
557 >      
558 >      ji[0] = tokenizer.nextTokenAsDouble();
559 >      ji[1] = tokenizer.nextTokenAsDouble();
560 >      ji[2] = tokenizer.nextTokenAsDouble();
561 >      if (needAngMom_) {
562 >        integrableObject->setJ(ji);
563 >      }
564 >    }
565 >    
566 >  }
567 >  
568 >  
569 >  void DumpReader::parseCommentLine(char* line, Snapshot* s) {
570 >    RealType currTime;
571 >    Mat3x3d hmat;
572 >    RealType chi;
573 >    RealType integralOfChiDt;
574 >    Mat3x3d eta;
575 >    
576 >    StringTokenizer tokenizer(line);
577 >    int nTokens;
578 >    
579 >    nTokens = tokenizer.countTokens();
580 >    
581 >    //comment line should at least contain 10 tokens: current time(1 token) and  h-matrix(9 tokens)
582 >    if (nTokens < 10) {
583 >      sprintf(painCave.errMsg,
584 >              "DumpReader Error: Not enough tokens in comment line: %s", line);
585 >      painCave.isFatal = 1;
586 >      simError();    
587 >    }
588 >    
589 >    //read current time
590 >    currTime = tokenizer.nextTokenAsDouble();
591 >    s->setTime(currTime);
592 >    
593 >    //read h-matrix
594 >    hmat(0, 0) = tokenizer.nextTokenAsDouble();
595 >    hmat(0, 1) = tokenizer.nextTokenAsDouble();
596 >    hmat(0, 2) = tokenizer.nextTokenAsDouble();
597 >    hmat(1, 0) = tokenizer.nextTokenAsDouble();
598 >    hmat(1, 1) = tokenizer.nextTokenAsDouble();
599 >    hmat(1, 2) = tokenizer.nextTokenAsDouble();
600 >    hmat(2, 0) = tokenizer.nextTokenAsDouble();
601 >    hmat(2, 1) = tokenizer.nextTokenAsDouble();
602 >    hmat(2, 2) = tokenizer.nextTokenAsDouble();
603 >    s->setHmat(hmat);
604 >    
605 >    //read chi and integralOfChidt, they should apprear in pair
606 >    if (tokenizer.countTokens() >= 2) {
607 >      chi = tokenizer.nextTokenAsDouble();
608 >      integralOfChiDt = tokenizer.nextTokenAsDouble();            
609 >      
610 >      s->setChi(chi);
611 >      s->setIntegralOfChiDt(integralOfChiDt);
612 >    }
613 >    
614 >    //read eta (eta is 3x3 matrix)
615 >    if (tokenizer.countTokens() >= 9) {
616 >      eta(0, 0) = tokenizer.nextTokenAsDouble();
617 >      eta(0, 1) = tokenizer.nextTokenAsDouble();
618 >      eta(0, 2) = tokenizer.nextTokenAsDouble();
619 >      eta(1, 0) = tokenizer.nextTokenAsDouble();
620 >      eta(1, 1) = tokenizer.nextTokenAsDouble();
621 >      eta(1, 2) = tokenizer.nextTokenAsDouble();
622 >      eta(2, 0) = tokenizer.nextTokenAsDouble();
623 >      eta(2, 1) = tokenizer.nextTokenAsDouble();
624 >      eta(2, 2) = tokenizer.nextTokenAsDouble();      
625 >      
626 >      s->setEta(eta);
627 >    }
628 >    
629 >    
630 >  }
631 >  
632 > }//end namespace oopse

Diff Legend

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