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

Comparing trunk/mdtools/md_code/InitializeFromFile.cpp (file contents):
Revision 206 by chuckv, Thu Dec 12 21:21:59 2002 UTC vs.
Revision 209 by mmeineke, Fri Dec 13 17:59:52 2002 UTC

# Line 59 | Line 59 | void InitializeFromFile :: read_xyz( SimInfo* the_entr
59  
60    int i; // loop counter
61  
62 +  const int BUFFERSIZE = 2000; // size of the read buffer
63    int n_atoms; // the number of atoms
64 <  char read_buffer[2000]; //the line buffer for reading
64 >  char read_buffer[BUFFERSIZE]; //the line buffer for reading
65   #ifdef IS_MPI
66 <  char send_buffer[2000];
66 >  char send_buffer[BUFFERSIZE];
67   #endif
68  
69    char *eof_test; // ptr to see when we reach the end of the file
70 <  char *foo; // the pointer to the current string token
70 >  char *parseErr;
71  
71 –  double rx, ry, rz; // position place holders
72 –  double vx, vy, vz; // velocity placeholders
73 –  double q[4]; // the quaternions
74 –  double jx, jy, jz; // angular velocity placeholders;
75 –  double qSqr, qLength; // needed to normalize the quaternion vector.
72  
73    entry_plug = the_entry_plug
74  
# Line 80 | Line 76 | void InitializeFromFile :: read_xyz( SimInfo* the_entr
76   #ifndef IS_MPI
77    eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
78    if( eof_test == NULL ){
79 <    std::cerr << "error reading 1st line of" << c_in_name << "\n";
79 >    sprintf( painCave.errMsg,
80 >             "InitializeFromFile error: error reading 1st line of \"%s\"\n",
81 >             c_in_name );
82 >    painCave.isFatal = 1;
83 >    simError();
84    }
85  
86 <  (void)sscanf(read_buffer, "%d", &n_atoms);
86 >  n_atoms = atoi( read_buffer );
87  
88    Atom **atoms = entry_plug->atoms;
89    DirectionalAtom* dAtom;
# Line 120 | Line 120 | void InitializeFromFile :: read_xyz( SimInfo* the_entr
120        simError();
121      }
122  
123 –    foo = strtok(read_buffer, " ,;\t");
123      
124 <    // check the atom name to the current atom
125 <
126 <    if( strcmp( foo, atoms[i]->getType() ) ){
128 <      sprintf( painCave.errMsg,
129 <               "Initialize from file error. Atom %s at index %d "
130 <               "in file %s does not"
131 <               " match the BASS atom %s.\n",
132 <               foo, i, c_in_name, atoms[i]->getType() );
124 >    parseErr = parseDumpLine( read_buffer, i );
125 >    if( parseErr != NULL ){
126 >      strcpy( painCave.errMsg, parseErr );
127        painCave.isFatal = 1;
128        simError();
129 <    }
136 <    
137 <    // get the positions
138 <
139 <    foo = strtok(NULL, " ,;\t");
140 <    if(foo == NULL){
141 <      sprintf( painCave.errMsg,
142 <               "error in reading postition x from %s\n"
143 <               "natoms  = %d, index = %d\n",
144 <               c_in_name, n_atoms, i );
145 <      painCave.isFatal = 1;
146 <      simError();
147 <    }
148 <    (void)sscanf( foo, "%lf", &rx );
149 <  
150 <    foo = strtok(NULL, " ,;\t");
151 <    if(foo == NULL){
152 <      sprintf( painCave.errMsg,
153 <               "error in reading postition y from %s\n"
154 <               "natoms  = %d, index = %d\n",
155 <               c_in_name, n_atoms, i );
156 <      painCave.isFatal = 1;
157 <      simError();
158 <    }
159 <    (void)sscanf( foo, "%lf", &ry );
160 <    
161 <    foo = strtok(NULL, " ,;\t");
162 <    if(foo == NULL){
163 <      sprintf( painCave.errMsg,
164 <               "error in reading postition z from %s\n"
165 <               "natoms  = %d, index = %d\n",
166 <               c_in_name, n_atoms, i );
167 <      painCave.isFatal = 1;
168 <      simError();
169 <    }
170 <    (void)sscanf( foo, "%lf", &rz );
171 <    
172 <    // get the velocities
173 <
174 <    foo = strtok(NULL, " ,;\t");
175 <    if(foo == NULL){
176 <      sprintf( painCave.errMsg,
177 <               "error in reading velocity x from %s\n"
178 <               "natoms  = %d, index = %d\n",
179 <               c_in_name, n_atoms, i );
180 <      painCave.isFatal = 1;
181 <      simError();
182 <    }
183 <    (void)sscanf( foo, "%lf", &vx );
184 <    
185 <    foo = strtok(NULL, " ,;\t");
186 <    if(foo == NULL){
187 <      sprintf( painCave.errMsg,
188 <               "error in reading velocity y from %s\n"
189 <               "natoms  = %d, index = %d\n",
190 <               c_in_name, n_atoms, i );
191 <      painCave.isFatal = 1;
192 <      simError();
193 <    }
194 <    (void)sscanf( foo, "%lf", &vy );
195 <    
196 <    foo = strtok(NULL, " ,;\t");
197 <    if(foo == NULL){
198 <      sprintf( painCave.errMsg,
199 <               "error in reading velocity z from %s\n"
200 <               "natoms  = %d, index = %d\n",
201 <               c_in_name, n_atoms, i );
202 <      painCave.isFatal = 1;
203 <      simError();
204 <    }
205 <    (void)sscanf( foo, "%lf", &vz );
206 <    
207 <    
208 <    // get the quaternions
209 <    
210 <    if( atoms[i]->isDirectional() ){
211 <      
212 <      foo = strtok(NULL, " ,;\t");
213 <      if(foo == NULL){
214 <        sprintf(painCave.errMsg,
215 <                "error in reading quaternion 0 from %s\n"
216 <                "natoms  = %d, index = %d\n",
217 <                c_in_name, n_atoms, i );
218 <        painCave.isFatal = 1;
219 <        simError();
220 <      }
221 <      (void)sscanf( foo, "%lf", &q[0] );
222 <      
223 <      foo = strtok(NULL, " ,;\t");
224 <      if(foo == NULL){
225 <        sprintf( painCave.errMsg,
226 <                 "error in reading quaternion 1 from %s\n"
227 <                 "natoms  = %d, index = %d\n",
228 <                 c_in_name, n_atoms, i );
229 <        painCave.isFatal = 1;
230 <        simError();
231 <      }
232 <      (void)sscanf( foo, "%lf", &q[1] );
233 <      
234 <      foo = strtok(NULL, " ,;\t");
235 <      if(foo == NULL){
236 <        sprintf( painCave.errMsg,
237 <                 "error in reading quaternion 2 from %s\n"
238 <                 "natoms  = %d, index = %d\n",
239 <                 c_in_name, n_atoms, i );
240 <        painCave.isFatal = 1;
241 <        simError();
242 <      }
243 <      (void)sscanf( foo, "%lf", &q[2] );
244 <      
245 <      foo = strtok(NULL, " ,;\t");
246 <      if(foo == NULL){
247 <        sprintf( painCave.errMsg,
248 <                 "error in reading quaternion 3 from %s\n"
249 <                 "natoms  = %d, index = %d\n",
250 <                 c_in_name, n_atoms, i );
251 <        painCave.isFatal = 1;
252 <        simError();
253 <      }
254 <      (void)sscanf( foo, "%lf", &q[3] );
255 <      
256 <      // get the angular velocities
257 <      
258 <      foo = strtok(NULL, " ,;\t");
259 <      if(foo == NULL){
260 <        sprintf( painCave.errMsg,
261 <                 "error in reading angular momentum jx from %s\n"
262 <                 "natoms  = %d, index = %d\n",
263 <                 c_in_name, n_atoms, i );
264 <        painCave.isFatal = 1;
265 <        simError();
266 <      }
267 <      (void)sscanf( foo, "%lf", &jx );
268 <      
269 <      foo = strtok(NULL, " ,;\t");
270 <      if(foo == NULL){
271 <        sprintf( painCave.errMsg,
272 <                 "error in reading angular momentum jy from %s\n"
273 <                 "natoms  = %d, index = %d\n",
274 <                 c_in_name, n_atoms, i );
275 <        painCave.isFatal = 1;
276 <        simError();
277 <      }
278 <      (void)sscanf( foo, "%lf", &jy );
279 <      
280 <      foo = strtok(NULL, " ,;\t");
281 <      if(foo == NULL){
282 <        sprintf( painCave.errMsg,
283 <                 "error in reading angular momentum jz from %s\n"
284 <                 "natoms  = %d, index = %d\n",
285 <                 c_in_name, n_atoms, i );
286 <        painCave.isFatal = 1;
287 <        simError();
288 <      }
289 <      (void)sscanf( foo, "%lf", &jz );
290 <      
291 <      dAtom = ( DirectionalAtom* )atoms[i];
292 <
293 <      // check that the quaternion vector is normalized
294 <
295 <      qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
296 <      
297 <      qLength = sqrt( qSqr );
298 <      q[0] = q[0] / qLength;
299 <      q[1] = q[1] / qLength;
300 <      q[2] = q[2] / qLength;
301 <      q[3] = q[3] / qLength;
302 <      
303 <      dAtom->setQ( q );
304 <      
305 <      // add the angular velocities
306 <
307 <      dAtom->setJx( jx );
308 <      dAtom->setJy( jy );
309 <      dAtom->setJz( jz );
310 <    }
311 <    
312 <    // add the positions and velocities to the atom
313 <    
314 <    atoms[i]->setX( rx );
315 <    atoms[i]->setY( ry );
316 <    atoms[i]->setZ( rz );
317 <    
318 <    atoms[i]->set_vx( vx );
319 <    atoms[i]->set_vy( vy );
320 <    atoms[i]->set_vz( vz );
321 <    
129 >    }    
130    }
131  
132  
# Line 337 | Line 145 | void InitializeFromFile :: read_xyz( SimInfo* the_entr
145        simError();
146      }
147      
148 <    (void)sscanf(read_buffer, "%d", &n_atoms);
148 >    n_atoms = atoi( read_buffer );
149      
150      Atom **atoms = entry_plug->atoms;
151      DirectionalAtom* dAtom;
152      
153 <    if( n_atoms != entry_plug->n_atoms ){
153 >    if( n_atoms != entry_plug->mpiSim->getTotAtoms() ){
154        sprintf( painCave.errMsg,
155                 "Initialize from File error. %s n_atoms, %d, "
156                 "does not match the BASS file's n_atoms, %d.\n",
# Line 361 | Line 169 | void InitializeFromFile :: read_xyz( SimInfo* the_entr
169        simError();
170      }
171    }
172 +
173    for( i=0; i < n_atoms; i++){
174      
175      eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
# Line 373 | Line 182 | void InitializeFromFile :: read_xyz( SimInfo* the_entr
182        painCave.isFatal = 1;
183        simError();
184      }
376 –
377 –    foo = strtok(read_buffer, " ,;\t");
185      
186 <    // check the atom name to the current atom
187 <
188 <    if( strcmp( foo, atoms[i]->getType() ) ){
382 <      sprintf( painCave.errMsg,
383 <               "Initialize from file error. Atom %s at index %d "
384 <               "in file %s does not"
385 <               " match the BASS atom %s.\n",
386 <               foo, i, c_in_name, atoms[i]->getType() );
186 >    parseErr = parseDumpLine( read_buffer, i );
187 >    if( parseErr != NULL ){
188 >      strcpy( painCave.errMsg, parseErr );
189        painCave.isFatal = 1;
190        simError();
191 <    }
191 >    }    
192 >  }
193 > #endif
194 > }
195 >
196 >
197 > char* IntitializeFromFile::parseDumpLine(char* readLine, int atomIndex){
198 >
199 >  char *foo; // the pointer to the current string token
200 >  
201 >  double rx, ry, rz; // position place holders
202 >  double vx, vy, vz; // velocity placeholders
203 >  double q[4]; // the quaternions
204 >  double jx, jy, jz; // angular velocity placeholders;
205 >  double qSqr, qLength; // needed to normalize the quaternion vector.
206 >  
207 >  Atom **atoms = entry_plug->atoms;
208 >  DirectionalAtom* dAtom;
209 >  
210 >  int n_atoms;
211 >
212 > #ifdef IS_MPI
213 >  n_atoms = entry_plug->mpiSim->getTotAtoms();
214 > #else
215 >  n_atoms = entry_plug->n_atoms;
216 > #endi // is_mpi
217 >
218 >
219 >  // set the string tokenizer
220 >  
221 >  foo = strtok(readLine, " ,;\t");
222 >  
223 >  // check the atom name to the current atom
224 >  
225 >  if( strcmp( foo, atoms[atomIndex]->getType() ) ){
226 >    sprintf( painCave.errMsg,
227 >             "Initialize from file error. Atom %s at index %d "
228 >             "in file %s does not"
229 >             " match the BASS atom %s.\n",
230 >             foo, atomIndex, c_in_name, atoms[atomIndex]->getType() );
231 >    return strdup( painCave.errMsg );
232 >  }
233      
234 <    // get the positions
234 >  // get the positions
235 >
236 >  foo = strtok(NULL, " ,;\t");
237 >  if(foo == NULL){
238 >    sprintf( painCave.errMsg,
239 >             "error in reading postition x from %s\n"
240 >             "natoms  = %d, index = %d\n",
241 >             c_in_name, n_atoms, atomIndex );
242 >    return strdup( painCave.errMsg );
243 >  }
244 >  rx = atof( foo );
245 >  
246 >  foo = strtok(NULL, " ,;\t");
247 >  if(foo == NULL){
248 >    sprintf( painCave.errMsg,
249 >             "error in reading postition y from %s\n"
250 >             "natoms  = %d, index = %d\n",
251 >             c_in_name, n_atoms, atomIndex );
252 >    return strdup( painCave.errMsg );
253 >  }
254 >  ry = atof( foo );
255 >    
256 >  foo = strtok(NULL, " ,;\t");
257 >  if(foo == NULL){
258 >    sprintf( painCave.errMsg,
259 >             "error in reading postition z from %s\n"
260 >             "natoms  = %d, index = %d\n",
261 >             c_in_name, n_atoms, atomIndex );
262 >    return strdup( painCave.errMsg );
263 >  }
264 >  rz = atof( foo );    
265  
266 +
267 +  // get the velocities
268 +
269 +  foo = strtok(NULL, " ,;\t");
270 +  if(foo == NULL){
271 +    sprintf( painCave.errMsg,
272 +             "error in reading velocity x from %s\n"
273 +             "natoms  = %d, index = %d\n",
274 +             c_in_name, n_atoms, atomIndex );
275 +    return strdup( painCave.errMsg );
276 +  }
277 +  vx = atof( foo );
278 +    
279 +  foo = strtok(NULL, " ,;\t");
280 +  if(foo == NULL){
281 +    sprintf( painCave.errMsg,
282 +             "error in reading velocity y from %s\n"
283 +             "natoms  = %d, index = %d\n",
284 +             c_in_name, n_atoms, atomIndex );
285 +    return strdup( painCave.errMsg );
286 +  }
287 +  vy = atof( foo );
288 +    
289 +  foo = strtok(NULL, " ,;\t");
290 +  if(foo == NULL){
291 +    sprintf( painCave.errMsg,
292 +             "error in reading velocity z from %s\n"
293 +             "natoms  = %d, index = %d\n",
294 +             c_in_name, n_atoms, atomIndex );
295 +    return strdup( painCave.errMsg );
296 +  }
297 +  vz = atof( foo );
298 +    
299 +    
300 +  // get the quaternions
301 +    
302 +  if( atoms[atomIndex]->isDirectional() ){
303 +      
304      foo = strtok(NULL, " ,;\t");
305      if(foo == NULL){
306 +      sprintf(painCave.errMsg,
307 +              "error in reading quaternion 0 from %s\n"
308 +              "natoms  = %d, index = %d\n",
309 +              c_in_name, n_atoms, atomIndex );
310 +      return strdup( painCave.errMsg );
311 +    }
312 +    q[0] = atof( foo );
313 +      
314 +    foo = strtok(NULL, " ,;\t");
315 +    if(foo == NULL){
316        sprintf( painCave.errMsg,
317 <               "error in reading postition x from %s\n"
317 >               "error in reading quaternion 1 from %s\n"
318                 "natoms  = %d, index = %d\n",
319 <               c_in_name, n_atoms, i );
320 <      painCave.isFatal = 1;
400 <      simError();
319 >               c_in_name, n_atoms, atomIndex );
320 >      return strdup( painCave.errMsg );
321      }
322 <    (void)sscanf( foo, "%lf", &rx );
323 <  
322 >    q[1] = atof( foo );
323 >      
324      foo = strtok(NULL, " ,;\t");
325      if(foo == NULL){
326        sprintf( painCave.errMsg,
327 <               "error in reading postition y from %s\n"
327 >               "error in reading quaternion 2 from %s\n"
328                 "natoms  = %d, index = %d\n",
329 <               c_in_name, n_atoms, i );
330 <      painCave.isFatal = 1;
411 <      simError();
329 >               c_in_name, n_atoms, atomIndex );
330 >      return strdup( painCave.errMsg );
331      }
332 <    (void)sscanf( foo, "%lf", &ry );
333 <    
332 >    q[2] = atof( foo );
333 >      
334      foo = strtok(NULL, " ,;\t");
335      if(foo == NULL){
336        sprintf( painCave.errMsg,
337 <               "error in reading postition z from %s\n"
337 >               "error in reading quaternion 3 from %s\n"
338                 "natoms  = %d, index = %d\n",
339 <               c_in_name, n_atoms, i );
340 <      painCave.isFatal = 1;
422 <      simError();
339 >               c_in_name, n_atoms, atomIndex );
340 >      return strdup( painCave.errMsg );
341      }
342 <    (void)sscanf( foo, "%lf", &rz );
343 <    
344 <    // get the velocities
345 <
342 >    q[3] = atof( foo );
343 >      
344 >    // get the angular velocities
345 >      
346      foo = strtok(NULL, " ,;\t");
347      if(foo == NULL){
348        sprintf( painCave.errMsg,
349 <               "error in reading velocity x from %s\n"
349 >               "error in reading angular momentum jx from %s\n"
350                 "natoms  = %d, index = %d\n",
351 <               c_in_name, n_atoms, i );
352 <      painCave.isFatal = 1;
435 <      simError();
351 >               c_in_name, n_atoms, atomIndex );
352 >      return strdup( painCave.errMsg );
353      }
354 <    (void)sscanf( foo, "%lf", &vx );
355 <    
354 >    jx = atof( foo );
355 >      
356      foo = strtok(NULL, " ,;\t");
357      if(foo == NULL){
358        sprintf( painCave.errMsg,
359 <               "error in reading velocity y from %s\n"
359 >               "error in reading angular momentum jy from %s\n"
360                 "natoms  = %d, index = %d\n",
361 <               c_in_name, n_atoms, i );
362 <      painCave.isFatal = 1;
446 <      simError();
361 >               c_in_name, n_atoms, atomIndex );
362 >      return strdup( painCave.errMsg );
363      }
364 <    (void)sscanf( foo, "%lf", &vy );
365 <    
364 >    jy = atof(foo );
365 >      
366      foo = strtok(NULL, " ,;\t");
367      if(foo == NULL){
368        sprintf( painCave.errMsg,
369 <               "error in reading velocity z from %s\n"
369 >               "error in reading angular momentum jz from %s\n"
370                 "natoms  = %d, index = %d\n",
371 <               c_in_name, n_atoms, i );
372 <      painCave.isFatal = 1;
457 <      simError();
371 >               c_in_name, n_atoms, atomIndex );
372 >      return strdup( painCave.errMsg );
373      }
374 <    (void)sscanf( foo, "%lf", &vz );
460 <    
461 <    
462 <    // get the quaternions
463 <    
464 <    if( atoms[i]->isDirectional() ){
374 >    jz = atof( foo );
375        
376 <      foo = strtok(NULL, " ,;\t");
467 <      if(foo == NULL){
468 <        sprintf(painCave.errMsg,
469 <                "error in reading quaternion 0 from %s\n"
470 <                "natoms  = %d, index = %d\n",
471 <                c_in_name, n_atoms, i );
472 <        painCave.isFatal = 1;
473 <        simError();
474 <      }
475 <      (void)sscanf( foo, "%lf", &q[0] );
476 <      
477 <      foo = strtok(NULL, " ,;\t");
478 <      if(foo == NULL){
479 <        sprintf( painCave.errMsg,
480 <                 "error in reading quaternion 1 from %s\n"
481 <                 "natoms  = %d, index = %d\n",
482 <                 c_in_name, n_atoms, i );
483 <        painCave.isFatal = 1;
484 <        simError();
485 <      }
486 <      (void)sscanf( foo, "%lf", &q[1] );
487 <      
488 <      foo = strtok(NULL, " ,;\t");
489 <      if(foo == NULL){
490 <        sprintf( painCave.errMsg,
491 <                 "error in reading quaternion 2 from %s\n"
492 <                 "natoms  = %d, index = %d\n",
493 <                 c_in_name, n_atoms, i );
494 <        painCave.isFatal = 1;
495 <        simError();
496 <      }
497 <      (void)sscanf( foo, "%lf", &q[2] );
498 <      
499 <      foo = strtok(NULL, " ,;\t");
500 <      if(foo == NULL){
501 <        sprintf( painCave.errMsg,
502 <                 "error in reading quaternion 3 from %s\n"
503 <                 "natoms  = %d, index = %d\n",
504 <                 c_in_name, n_atoms, i );
505 <        painCave.isFatal = 1;
506 <        simError();
507 <      }
508 <      (void)sscanf( foo, "%lf", &q[3] );
509 <      
510 <      // get the angular velocities
511 <      
512 <      foo = strtok(NULL, " ,;\t");
513 <      if(foo == NULL){
514 <        sprintf( painCave.errMsg,
515 <                 "error in reading angular momentum jx from %s\n"
516 <                 "natoms  = %d, index = %d\n",
517 <                 c_in_name, n_atoms, i );
518 <        painCave.isFatal = 1;
519 <        simError();
520 <      }
521 <      (void)sscanf( foo, "%lf", &jx );
522 <      
523 <      foo = strtok(NULL, " ,;\t");
524 <      if(foo == NULL){
525 <        sprintf( painCave.errMsg,
526 <                 "error in reading angular momentum jy from %s\n"
527 <                 "natoms  = %d, index = %d\n",
528 <                 c_in_name, n_atoms, i );
529 <        painCave.isFatal = 1;
530 <        simError();
531 <      }
532 <      (void)sscanf( foo, "%lf", &jy );
533 <      
534 <      foo = strtok(NULL, " ,;\t");
535 <      if(foo == NULL){
536 <        sprintf( painCave.errMsg,
537 <                 "error in reading angular momentum jz from %s\n"
538 <                 "natoms  = %d, index = %d\n",
539 <                 c_in_name, n_atoms, i );
540 <        painCave.isFatal = 1;
541 <        simError();
542 <      }
543 <      (void)sscanf( foo, "%lf", &jz );
544 <      
545 <      dAtom = ( DirectionalAtom* )atoms[i];
376 >    dAtom = ( DirectionalAtom* )atoms[atomIndex];
377  
378 <      // check that the quaternion vector is normalized
378 >    // check that the quaternion vector is normalized
379  
380 <      qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
380 >    qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]);
381        
382 <      qLength = sqrt( qSqr );
383 <      q[0] = q[0] / qLength;
384 <      q[1] = q[1] / qLength;
385 <      q[2] = q[2] / qLength;
386 <      q[3] = q[3] / qLength;
382 >    qLength = sqrt( qSqr );
383 >    q[0] = q[0] / qLength;
384 >    q[1] = q[1] / qLength;
385 >    q[2] = q[2] / qLength;
386 >    q[3] = q[3] / qLength;
387        
388 <      dAtom->setQ( q );
388 >    dAtom->setQ( q );
389        
390 <      // add the angular velocities
390 >    // add the angular velocities
391  
392 <      dAtom->setJx( jx );
393 <      dAtom->setJy( jy );
394 <      dAtom->setJz( jz );
395 <    }
392 >    dAtom->setJx( jx );
393 >    dAtom->setJy( jy );
394 >    dAtom->setJz( jz );
395 >  }
396      
397 <    // add the positions and velocities to the atom
397 >  // add the positions and velocities to the atom
398      
399 <    atoms[i]->setX( rx );
400 <    atoms[i]->setY( ry );
401 <    atoms[i]->setZ( rz );
399 >  atoms[atomIndex]->setX( rx );
400 >  atoms[atomIndex]->setY( ry );
401 >  atoms[atomIndex]->setZ( rz );
402      
403 <    atoms[i]->set_vx( vx );
404 <    atoms[i]->set_vy( vy );
405 <    atoms[i]->set_vz( vz );
575 <    
576 <  }
577 < #endif
578 < }
403 >  atoms[atomIndex]->set_vx( vx );
404 >  atoms[atomIndex]->set_vy( vy );
405 >  atoms[atomIndex]->set_vz( vz );
406  
407 < char* IntitializeFromFile::parseDumpLine(char* readLine);
407 >  return NULL;
408 > }

Diff Legend

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