ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/InitializeFromFile.cpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/InitializeFromFile.cpp (file contents):
Revision 586 by mmeineke, Wed Jul 9 22:14:06 2003 UTC vs.
Revision 670 by mmeineke, Thu Aug 7 21:47:18 2003 UTC

# Line 69 | Line 69 | InitializeFromFile :: ~InitializeFromFile( ){
69   }
70  
71  
72 < void InitializeFromFile :: read_xyz( SimInfo* the_simnfo ){
72 > void InitializeFromFile :: readInit( SimInfo* the_simnfo ){
73  
74    int i, j, done, which_node, which_atom; // loop counter
75  
# Line 83 | Line 83 | void InitializeFromFile :: read_xyz( SimInfo* the_simn
83    char *eof_test; // ptr to see when we reach the end of the file
84    char *parseErr;
85    int procIndex;
86 +  double currTime;
87    double boxMat[9];
88 <  
88 >  double theBoxMat3[3][3];
89  
90    simnfo = the_simnfo;
91  
# Line 123 | Line 124 | void InitializeFromFile :: read_xyz( SimInfo* the_simn
124      simError();
125    }
126  
127 <  parseErr = parseBoxLine( read_buffer, boxMat );
127 >  parseErr = parseBoxLine( read_buffer, boxMat, currTime );
128    if( parseErr != NULL ){
129      strcpy( painCave.errMsg, parseErr );
130      painCave.isFatal = 1;
131      simError();
132    }
133  
134 <  simnfo->setBoxM( boxMat );
134 >  for(i=0;i<3;i++)
135 >    for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
136  
137 +  simnfo->setBoxM( theBoxMat3 );
138 +  simnfo->setTime( currTime );
139  
140 +
141    for( i=0; i < n_atoms; i++){
142      
143      eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
# Line 207 | Line 212 | void InitializeFromFile :: read_xyz( SimInfo* the_simn
212        simError();
213      }
214      
215 <    parseErr = parseBoxLine( read_buffer, boxMat );
215 >    parseErr = parseBoxLine( read_buffer, boxMat, currTime );
216      if( parseErr != NULL ){
217        strcpy( painCave.errMsg, parseErr );
218        haveError = 1;
# Line 215 | Line 220 | void InitializeFromFile :: read_xyz( SimInfo* the_simn
220      }
221  
222      MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD );
223 +    MPI_Bcast(&currTime, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD );
224    
225      if(haveError) nodeZeroError();
226  
# Line 269 | Line 275 | void InitializeFromFile :: read_xyz( SimInfo* the_simn
275    } else {
276      
277      MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD);
278 +    MPI_Bcast(&currTime, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
279  
280      done = 0;
281      while (!done) {
# Line 301 | Line 308 | void InitializeFromFile :: read_xyz( SimInfo* the_simn
308      
309   // last  thing last, enable  fatalities.
310    painCave.isEventLoop = 0;
304 –  simnfo->setBoxM( boxMat );
311  
312 +  for(i=0;i<3;i++)
313 +    for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i];
314 +
315 +  simnfo->setBoxM( theBoxMat3 );
316 +  simnfo->setTime( currTime );
317 +
318    
319   #endif
320   }
# Line 311 | Line 323 | char* InitializeFromFile::parseDumpLine(char* readLine
323  
324    char *foo; // the pointer to the current string token
325    
326 <  double rx, ry, rz; // position place holders
327 <  double vx, vy, vz; // velocity placeholders
326 >  double pos[3]; // position place holders
327 >  double vel[3]; // velocity placeholders
328    double q[4]; // the quaternions
329    double jx, jy, jz; // angular velocity placeholders;
330    double qSqr, qLength; // needed to normalize the quaternion vector.
# Line 365 | Line 377 | char* InitializeFromFile::parseDumpLine(char* readLine
377               c_in_name, n_atoms, atomIndex );
378      return strdup( painCave.errMsg );
379    }
380 <  rx = atof( foo );
380 >  pos[0] = atof( foo );
381    
382    foo = strtok(NULL, " ,;\t");
383    if(foo == NULL){
# Line 375 | Line 387 | char* InitializeFromFile::parseDumpLine(char* readLine
387               c_in_name, n_atoms, atomIndex );
388      return strdup( painCave.errMsg );
389    }
390 <  ry = atof( foo );
390 >  pos[1] = atof( foo );
391      
392    foo = strtok(NULL, " ,;\t");
393    if(foo == NULL){
# Line 385 | Line 397 | char* InitializeFromFile::parseDumpLine(char* readLine
397               c_in_name, n_atoms, atomIndex );
398      return strdup( painCave.errMsg );
399    }
400 <  rz = atof( foo );    
400 >  pos[2] = atof( foo );    
401  
402  
403    // get the velocities
# Line 398 | Line 410 | char* InitializeFromFile::parseDumpLine(char* readLine
410               c_in_name, n_atoms, atomIndex );
411      return strdup( painCave.errMsg );
412    }
413 <  vx = atof( foo );
413 >  vel[0] = atof( foo );
414      
415    foo = strtok(NULL, " ,;\t");
416    if(foo == NULL){
# Line 408 | Line 420 | char* InitializeFromFile::parseDumpLine(char* readLine
420               c_in_name, n_atoms, atomIndex );
421      return strdup( painCave.errMsg );
422    }
423 <  vy = atof( foo );
423 >  vel[1] = atof( foo );
424      
425    foo = strtok(NULL, " ,;\t");
426    if(foo == NULL){
# Line 418 | Line 430 | char* InitializeFromFile::parseDumpLine(char* readLine
430               c_in_name, n_atoms, atomIndex );
431      return strdup( painCave.errMsg );
432    }
433 <  vz = atof( foo );
433 >  vel[2] = atof( foo );
434      
435      
436    // get the quaternions
# Line 520 | Line 532 | char* InitializeFromFile::parseDumpLine(char* readLine
532      
533    // add the positions and velocities to the atom
534      
535 <  atoms[atomIndex]->setX( rx );
536 <  atoms[atomIndex]->setY( ry );
525 <  atoms[atomIndex]->setZ( rz );
526 <    
527 <  atoms[atomIndex]->set_vx( vx );
528 <  atoms[atomIndex]->set_vy( vy );
529 <  atoms[atomIndex]->set_vz( vz );
535 >  atoms[atomIndex]->setPos( pos );
536 >  atoms[atomIndex]->setVel( vel );
537  
538    return NULL;
539   }
540  
541  
542 < char* InitializeFromFile::parseBoxLine(char* readLine, double boxMat[9]){
542 > char* InitializeFromFile::parseBoxLine(char* readLine, double boxMat[9],
543 >                                       double &time ){
544  
545    char *foo; // the pointer to the current string token
546    int j;
# Line 540 | Line 548 | char* InitializeFromFile::parseBoxLine(char* readLine,
548    // set the string tokenizer
549    
550    foo = strtok(readLine, " ,;\t");
551 <  // ignore the first token which is the time stamp.
551 >  // set the timeToken.
552  
553 +  if(foo == NULL){
554 +    sprintf( painCave.errMsg,
555 +             "error in reading Time from %s\n",
556 +             c_in_name );
557 +    return strdup( painCave.errMsg );
558 +  }
559 +  time = atof( foo );
560  
561    // get the Hx vector
562  

Diff Legend

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