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 906 by mmeineke, Thu Jan 8 15:44:47 2004 UTC vs.
Revision 1108 by tim, Wed Apr 14 15:37:41 2004 UTC

# Line 85 | Line 85 | void InitializeFromFile :: readInit( SimInfo* the_simn
85   #endif //is_mpi
86  
87    const int BUFFERSIZE = 2000; // size of the read buffer
88 <  int n_atoms; // the number of atoms
88 >  int nTotObjs; // the number of atoms
89    char read_buffer[BUFFERSIZE]; //the line buffer for reading
90  
91    char *eof_test; // ptr to see when we reach the end of the file
92    char *parseErr;
93  
94 +  vector<StuntDouble*> integrableObjects;
95 +  vector<StuntDouble*>::iterator iter;
96 +
97    simnfo = the_simnfo;
98  
99  
# Line 104 | Line 107 | void InitializeFromFile :: readInit( SimInfo* the_simn
107      simError();
108    }
109  
110 <  n_atoms = atoi( read_buffer );
110 >  nTotObjs = atoi( read_buffer );
111  
112 <  if( n_atoms != simnfo->n_atoms ){
112 >  if( nTotObjs != simnfo->getTotIntegrableObjects() ){
113      sprintf( painCave.errMsg,
114               "Initialize from File error. %s n_atoms, %d, "
115               "does not match the BASS file's n_atoms, %d.\n",
116 <             c_in_name, n_atoms, simnfo->n_atoms );
116 >             c_in_name, nTotObjs, simnfo->getTotIntegrableObjects());
117      painCave.isFatal = 1;
118      simError();
119    }
# Line 125 | Line 128 | void InitializeFromFile :: readInit( SimInfo* the_simn
128      simError();
129    }
130  
128 –
129 –
131    parseErr = parseCommentLine( read_buffer, simnfo);
132    if( parseErr != NULL ){
133      strcpy( painCave.errMsg, parseErr );
# Line 136 | Line 137 | void InitializeFromFile :: readInit( SimInfo* the_simn
137  
138    //parse dump lines
139  
140 <  for( i=0; i < n_atoms; i++){
140 >  for( i=0; i < simnfo->n_mol; i++){
141  
142 <    eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
142 <    if(eof_test == NULL){
143 <      sprintf(painCave.errMsg,
144 <              "error in reading file %s\n"
145 <              "natoms  = %d; index = %d\n"
146 <              "error reading the line from the file.\n",
147 <              c_in_name, n_atoms, i );
148 <      painCave.isFatal = 1;
149 <      simError();
150 <    }
142 >    integrableObjects = (simnfo->molecules[i]).getIntegrableObjects();
143  
144 +    for(iter = integrableObjects.begin(); iter!= integrableObjects.end(); iter++)
145  
146 <    parseErr = parseDumpLine( read_buffer, i );
147 <    if( parseErr != NULL ){
148 <      strcpy( painCave.errMsg, parseErr );
149 <      painCave.isFatal = 1;
150 <      simError();
151 <    }
146 >      eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
147 >      if(eof_test == NULL){
148 >        sprintf(painCave.errMsg,
149 >              "error in reading file %s\n"
150 >              "natoms  = %d; index = %d\n"
151 >              "error reading the line from the file.\n",
152 >              c_in_name, nTotObjs, i );
153 >        painCave.isFatal = 1;
154 >        simError();
155 >      }
156 >      
157 >      parseErr = parseDumpLine( read_buffer, *iter);
158 >      if( parseErr != NULL ){
159 >        strcpy( painCave.errMsg, parseErr );
160 >        painCave.isFatal = 1;
161 >        simError();
162 >      }
163    }
164  
165  
# Line 169 | Line 173 | void InitializeFromFile :: readInit( SimInfo* the_simn
173    int haveError;
174  
175    MPI_Status istatus;
176 <  int *AtomToProcMap = mpiSim->getAtomToProcMap();
176 >  int *MolToProcMap = mpiSim->getMolToProcMap();
177 >  int localIndex;
178 >  int nCurObj;
179  
174 –
180    haveError = 0;
181    if (worldRank == 0) {
182  
# Line 183 | Line 188 | void InitializeFromFile :: readInit( SimInfo* the_simn
188        simError();
189      }
190  
191 <    n_atoms = atoi( read_buffer );
191 >    nTotObjs = atoi( read_buffer );
192  
193 <    // Check to see that the number of atoms in the intial configuration file is the
193 >    // Check to see that the number of integrable objects  in the intial configuration file is the
194      // same as declared in simBass.
195  
196 <    if( n_atoms != mpiSim->getTotAtoms() ){
196 >    if( nTotObjs != simnfo->getTotIntegrableObjects()){
197        sprintf( painCave.errMsg,
198                 "Initialize from File error. %s n_atoms, %d, "
199                 "does not match the BASS file's n_atoms, %d.\n",
200 <               c_in_name, n_atoms, simnfo->n_atoms );
200 >               c_in_name, nTotObjs, simnfo->getTotIntegrableObjects());
201        haveError= 1;
202        simError();
203      }
# Line 222 | Line 227 | void InitializeFromFile :: readInit( SimInfo* the_simn
227        simError();
228      }
229  
230 <    for (i=0 ; i < mpiSim->getTotAtoms(); i++) {
230 >    for (i=0 ; i < mpiSim->getTotNmol(); i++) {
231 >      which_node = MolToProcMap[i];
232 >      if(which_node == 0){
233 >       //molecules belong to master node
234  
235 <      eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
228 <      if(eof_test == NULL){
229 <        sprintf(painCave.errMsg,
230 <                "error in reading file %s\n"
231 <                "natoms  = %d; index = %d\n"
232 <                "error reading the line from the file.\n",
233 <                c_in_name, n_atoms, i );
234 <        haveError= 1;
235 <        simError();
236 <      }
235 >      localIndex = mpiSim->getGlobalToLocalMol(i);
236  
237 <      if(haveError) nodeZeroError();
238 <
239 <      // Get the Node number which wants this atom:
240 <      which_node = AtomToProcMap[i];
242 <      if (which_node == 0) {
243 <        parseErr = parseDumpLine( read_buffer, i );
244 <        if( parseErr != NULL ){
245 <          strcpy( painCave.errMsg, parseErr );
246 <          haveError = 1;
247 <          simError();
248 <        }
249 <        if(haveError) nodeZeroError();
237 >      if(localIndex == -1) {
238 >        strcpy(painCave.errMsg, "Molecule not found on node 0!");
239 >        haveError = 1;
240 >        simError();
241        }
242  
243 <      else {
244 <
245 <        myStatus = 1;
246 <        MPI_Send(&myStatus, 1, MPI_INT, which_node,
247 <                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
248 <        MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
249 <                 TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
250 <        MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
251 <                 MPI_COMM_WORLD);
252 <        MPI_Recv(&myStatus, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
253 <                 MPI_COMM_WORLD, &istatus);
243 >       integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();
244 >       for(j=0; j < integrableObjects.size(); j++){
245 >        
246 >          eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
247 >          if(eof_test == NULL){
248 >                sprintf(painCave.errMsg,
249 >                    "error in reading file %s\n"
250 >                    "natoms  = %d; index = %d\n"
251 >                    "error reading the line from the file.\n",
252 >                    c_in_name, nTotObjs, i );
253 >                haveError= 1;
254 >                simError();
255 >          }
256 >          
257 >          if(haveError) nodeZeroError();
258  
259 <        if(!myStatus) nodeZeroError();
260 <      }
261 <    }
267 <    myStatus = -1;
268 <    for (j = 1; j < mpiSim->getNumberProcessors(); j++) {
269 <      MPI_Send( &myStatus, 1, MPI_INT, j,
270 <                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
271 <    }
259 >          parseDumpLine(read_buffer, integrableObjects[i]);
260 >          
261 >       }
262  
273 –  } else {
263  
264 <    MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD);
264 >      }
265 >      else{
266 >      //molecule belongs to slave nodes
267  
268 <    parseErr = parseCommentLine( read_buffer, simnfo);
268 >        MPI_Recv(&nCurObj, 1, MPI_INT, 0,
269 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
270 >      
271 >       for(j=0; j < integrableObjects.size(); j++){
272 >        
273 >          eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file);
274 >          if(eof_test == NULL){
275 >                sprintf(painCave.errMsg,
276 >                    "error in reading file %s\n"
277 >                    "natoms  = %d; index = %d\n"
278 >                    "error reading the line from the file.\n",
279 >                    c_in_name, nTotObjs, i );
280 >                haveError= 1;
281 >                simError();
282 >          }
283 >          
284 >          if(haveError) nodeZeroError();
285  
286 <    if( parseErr != NULL ){
287 <      strcpy( painCave.errMsg, parseErr );
288 <      haveError = 1;
289 <      simError();
286 >            MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node,
287 >                      TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
288 >          
289 >       }
290 >
291 >      }
292 >      
293      }
294 +    
295 +  }
296 +  else{
297 +  //actions taken at slave nodes
298 +    for (i=0 ; i < mpiSim->getTotNmol(); i++) {
299 +      which_node = MolToProcMap[i];
300 +      
301 +      if(which_node == worldRank){
302 +      //molecule with global index i belongs to this processor
303 +      
304 +        localIndex = mpiSim->getGlobalToLocalMol(i);
305  
306 +        if(localIndex == -1) {
307 +          sprintf(painCave.errMsg, "Molecule not found on node %d\n", worldRank);
308 +          haveError = 1;
309 +          simError();
310 +        }
311  
312 <    done = 0;
287 <    while (!done) {
312 >        integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects();        
313  
314 <      MPI_Recv(&myStatus, 1, MPI_INT, 0,
315 <               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
314 >        nCurObj = integrableObjects.size();
315 >        
316 >        MPI_Recv(&nCurObj, 1, MPI_INT, 0,
317 >                        TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
318  
319 <      if(!myStatus) anonymousNodeDie();
319 >        for(j = 0; j < integrableObjects.size(); j++){
320 >
321 >          MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
322 >                              TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
323 >
324 >          parseErr = parseDumpLine(read_buffer, integrableObjects[j]);
325 >
326 >          if( parseErr != NULL ){
327 >                strcpy( painCave.errMsg, parseErr );
328 >                simError();
329 >          }
330  
331 <      if(myStatus < 0) break;
332 <
296 <      MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0,
297 <               TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
298 <      MPI_Recv(&which_atom, 1, MPI_INT, 0,
299 <               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
300 <
301 <      myStatus = 1;
302 <      parseErr = parseDumpLine( read_buffer, which_atom );
303 <      if( parseErr != NULL ){
304 <        strcpy( painCave.errMsg, parseErr );
305 <        myStatus = 0;;
306 <        simError();
331 >        }
332 >          
333        }
334 <
309 <      MPI_Send( &myStatus, 1, MPI_INT, 0,
310 <                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
311 <
334 >      
335      }
313 –  }
336  
337 < // last  thing last, enable  fatalities.
316 <  painCave.isEventLoop = 0;
317 <
318 <
319 <
337 >  }
338   #endif
339   }
340  
341 < char* InitializeFromFile::parseDumpLine(char* readLine, int globalIndex){
341 > char* InitializeFromFile::parseDumpLine(char* readLine, StuntDouble* sd){
342  
343    char *foo; // the pointer to the current string token
344  
345    double pos[3]; // position place holders
346    double vel[3]; // velocity placeholders
347    double q[4]; // the quaternions
348 <  double jx, jy, jz; // angular velocity placeholders;
348 >  double ji[3]; // angular velocity placeholders;
349    double qSqr, qLength; // needed to normalize the quaternion vector.
350  
333 –  Atom **atoms = simnfo->atoms;
334 –  DirectionalAtom* dAtom;
351  
336 –  int n_atoms, atomIndex;
337 –
338 – #ifdef IS_MPI
339 –  int j;
340 –
341 –  n_atoms = mpiSim->getTotAtoms();
342 –  atomIndex=-1;
343 –  for (j=0; j < mpiSim->getMyNlocal(); j++) {
344 –    if (atoms[j]->getGlobalIndex() == globalIndex) atomIndex = j;
345 –  }
346 –  if (atomIndex == -1) {
347 –    sprintf( painCave.errMsg,
348 –             "Initialize from file error. Atom at index %d "
349 –             "in file %s does not exist on processor %d .\n",
350 –             globalIndex, c_in_name, mpiSim->getMyNode() );
351 –    return strdup( painCave.errMsg );
352 –  }
353 – #else
354 –  n_atoms = simnfo->n_atoms;
355 –  atomIndex = globalIndex;
356 – #endif // is_mpi
357 –
352    // set the string tokenizer
353  
354    foo = strtok(readLine, " ,;\t");
355  
356    // check the atom name to the current atom
357  
358 <  if( strcmp( foo, atoms[atomIndex]->getType() ) ){
358 >  if( strcmp( foo, sd->getType() ) ){
359      sprintf( painCave.errMsg,
360 <             "Initialize from file error. Atom %s at index %d "
367 <             "in file %s does not"
360 >             "Initialize from file error.  Does not"
361               " match the BASS atom %s.\n",
362 <             foo, atomIndex, c_in_name, atoms[atomIndex]->getType() );
362 >             sd->getType() );
363      return strdup( painCave.errMsg );
364    }
365  
# Line 375 | Line 368 | char* InitializeFromFile::parseDumpLine(char* readLine
368    foo = strtok(NULL, " ,;\t");
369    if(foo == NULL){
370      sprintf( painCave.errMsg,
371 <             "error in reading postition x from %s\n"
372 <             "natoms  = %d, index = %d\n",
380 <             c_in_name, n_atoms, atomIndex );
371 >             "error in reading postition x from %s\n",
372 >             c_in_name);
373      return strdup( painCave.errMsg );
374    }
375    pos[0] = atof( foo );
# Line 385 | Line 377 | char* InitializeFromFile::parseDumpLine(char* readLine
377    foo = strtok(NULL, " ,;\t");
378    if(foo == NULL){
379      sprintf( painCave.errMsg,
380 <             "error in reading postition y from %s\n"
381 <             "natoms  = %d, index = %d\n",
390 <             c_in_name, n_atoms, atomIndex );
380 >             "error in reading postition y from %s\n",
381 >             c_in_name);
382      return strdup( painCave.errMsg );
383    }
384    pos[1] = atof( foo );
# Line 395 | Line 386 | char* InitializeFromFile::parseDumpLine(char* readLine
386    foo = strtok(NULL, " ,;\t");
387    if(foo == NULL){
388      sprintf( painCave.errMsg,
389 <             "error in reading postition z from %s\n"
390 <             "natoms  = %d, index = %d\n",
400 <             c_in_name, n_atoms, atomIndex );
389 >             "error in reading postition z from %s\n",
390 >             c_in_name);
391      return strdup( painCave.errMsg );
392    }
393    pos[2] = atof( foo );
# Line 408 | Line 398 | char* InitializeFromFile::parseDumpLine(char* readLine
398    foo = strtok(NULL, " ,;\t");
399    if(foo == NULL){
400      sprintf( painCave.errMsg,
401 <             "error in reading velocity x from %s\n"
402 <             "natoms  = %d, index = %d\n",
413 <             c_in_name, n_atoms, atomIndex );
401 >             "error in reading velocity x from %s\n",
402 >             c_in_name );
403      return strdup( painCave.errMsg );
404    }
405    vel[0] = atof( foo );
# Line 418 | Line 407 | char* InitializeFromFile::parseDumpLine(char* readLine
407    foo = strtok(NULL, " ,;\t");
408    if(foo == NULL){
409      sprintf( painCave.errMsg,
410 <             "error in reading velocity y from %s\n"
411 <             "natoms  = %d, index = %d\n",
423 <             c_in_name, n_atoms, atomIndex );
410 >             "error in reading velocity x from %s\n",
411 >             c_in_name );
412      return strdup( painCave.errMsg );
413    }
414    vel[1] = atof( foo );
# Line 428 | Line 416 | char* InitializeFromFile::parseDumpLine(char* readLine
416    foo = strtok(NULL, " ,;\t");
417    if(foo == NULL){
418      sprintf( painCave.errMsg,
419 <             "error in reading velocity z from %s\n"
420 <             "natoms  = %d, index = %d\n",
433 <             c_in_name, n_atoms, atomIndex );
419 >             "error in reading velocity x from %s\n",
420 >             c_in_name );
421      return strdup( painCave.errMsg );
422    }
423    vel[2] = atof( foo );
424  
425  
426 +  // add the positions and velocities to the atom
427 +
428 +  sd->setPos( pos );
429 +  sd->setVel( vel );
430 +
431 +  if (!sd->isDirectional())
432 +    return NULL;
433 +
434    // get the quaternions
435  
436 <  if( atoms[atomIndex]->isDirectional() ){
436 >  if( sd->isDirectional() ){
437  
438      foo = strtok(NULL, " ,;\t");
439      if(foo == NULL){
440 <      sprintf(painCave.errMsg,
441 <              "error in reading quaternion 0 from %s\n"
442 <              "natoms  = %d, index = %d\n",
448 <              c_in_name, n_atoms, atomIndex );
440 >      sprintf( painCave.errMsg,
441 >                     "error in reading velocity x from %s\n",
442 >                      c_in_name );
443        return strdup( painCave.errMsg );
444      }
445      q[0] = atof( foo );
# Line 453 | Line 447 | char* InitializeFromFile::parseDumpLine(char* readLine
447      foo = strtok(NULL, " ,;\t");
448      if(foo == NULL){
449        sprintf( painCave.errMsg,
450 <               "error in reading quaternion 1 from %s\n"
451 <               "natoms  = %d, index = %d\n",
458 <               c_in_name, n_atoms, atomIndex );
450 >                     "error in reading velocity x from %s\n",
451 >                      c_in_name );
452        return strdup( painCave.errMsg );
453      }
454      q[1] = atof( foo );
# Line 463 | Line 456 | char* InitializeFromFile::parseDumpLine(char* readLine
456      foo = strtok(NULL, " ,;\t");
457      if(foo == NULL){
458        sprintf( painCave.errMsg,
459 <               "error in reading quaternion 2 from %s\n"
460 <               "natoms  = %d, index = %d\n",
468 <               c_in_name, n_atoms, atomIndex );
459 >                     "error in reading velocity x from %s\n",
460 >                      c_in_name );
461        return strdup( painCave.errMsg );
462      }
463      q[2] = atof( foo );
# Line 473 | Line 465 | char* InitializeFromFile::parseDumpLine(char* readLine
465      foo = strtok(NULL, " ,;\t");
466      if(foo == NULL){
467        sprintf( painCave.errMsg,
468 <               "error in reading quaternion 3 from %s\n"
469 <               "natoms  = %d, index = %d\n",
478 <               c_in_name, n_atoms, atomIndex );
468 >                     "error in reading velocity x from %s\n",
469 >                      c_in_name );
470        return strdup( painCave.errMsg );
471      }
472      q[3] = atof( foo );
# Line 485 | Line 476 | char* InitializeFromFile::parseDumpLine(char* readLine
476      foo = strtok(NULL, " ,;\t");
477      if(foo == NULL){
478        sprintf( painCave.errMsg,
479 <               "error in reading angular momentum jx from %s\n"
480 <               "natoms  = %d, index = %d\n",
490 <               c_in_name, n_atoms, atomIndex );
479 >                     "error in reading velocity x from %s\n",
480 >                      c_in_name );
481        return strdup( painCave.errMsg );
482      }
483 <    jx = atof( foo );
483 >    ji[0] = atof( foo );
484  
485      foo = strtok(NULL, " ,;\t");
486      if(foo == NULL){
487        sprintf( painCave.errMsg,
488 <               "error in reading angular momentum jy from %s\n"
489 <               "natoms  = %d, index = %d\n",
500 <               c_in_name, n_atoms, atomIndex );
488 >                     "error in reading velocity x from %s\n",
489 >                      c_in_name );
490        return strdup( painCave.errMsg );
491      }
492 <    jy = atof(foo );
492 >    ji[1] = atof(foo );
493  
494      foo = strtok(NULL, " ,;\t");
495      if(foo == NULL){
496        sprintf( painCave.errMsg,
497 <               "error in reading angular momentum jz from %s\n"
498 <               "natoms  = %d, index = %d\n",
510 <               c_in_name, n_atoms, atomIndex );
497 >                     "error in reading velocity x from %s\n",
498 >                      c_in_name );
499        return strdup( painCave.errMsg );
500      }
501 <    jz = atof( foo );
501 >    ji[2] = atof( foo );
502  
515 –    dAtom = ( DirectionalAtom* )atoms[atomIndex];
503  
504      // check that the quaternion vector is normalized
505  
# Line 524 | Line 511 | char* InitializeFromFile::parseDumpLine(char* readLine
511      q[2] = q[2] / qLength;
512      q[3] = q[3] / qLength;
513  
514 <    dAtom->setQ( q );
514 >    // add quaternion and angular velocities
515  
516 <    // add the angular velocities
517 <
531 <    dAtom->setJx( jx );
532 <    dAtom->setJy( jy );
533 <    dAtom->setJz( jz );
516 >    sd->setQ( q );
517 >    sd->setJ( ji );
518    }
519  
536 –  // add the positions and velocities to the atom
520  
538 –  atoms[atomIndex]->setPos( pos );
539 –  atoms[atomIndex]->setVel( vel );
521  
522    return NULL;
523   }
# Line 618 | Line 599 | char* InitializeFromFile::parseCommentLine(char* readL
599        return NULL;
600      
601      //get eta
602 <    for(int i = 0 ; i < 9; i++){
603 <      foo = strtok(NULL, " ,;\t");
604 <      if(foo == NULL){
605 <        sprintf( painCave.errMsg,
606 <                 "error in reading eta[%d] from %s\n", i, c_in_name );
607 <        return strdup( painCave.errMsg );
602 >    foo = strtok(NULL, " ,;\t\n");
603 >    if(foo != NULL ){
604 >  
605 >      for(int i = 0 ; i < 9; i++){
606 >        
607 >        if(foo == NULL){
608 >          sprintf( painCave.errMsg,
609 >                   "error in reading eta[%d] from %s\n", i, c_in_name );
610 >          return strdup( painCave.errMsg );
611 >        }
612 >        eta[i] = atof( foo );
613 >        foo = strtok(NULL, " ,;\t\n");
614        }
628 –      eta[i] = atof( foo );
615      }
616 +    else
617 +      return NULL;
618      
619      //push eta into SimInfo::properties which can be
620      //retrieved by integrator later

Diff Legend

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