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

Comparing trunk/OOPSE/libmdtools/DumpWriter.cpp (file contents):
Revision 1129 by tim, Thu Apr 22 03:29:30 2004 UTC vs.
Revision 1252 by gezelter, Mon Jun 7 14:26:33 2004 UTC

# Line 170 | Line 170 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
170    char tempBuffer[BUFFERSIZE];  
171    char writeLine[BUFFERSIZE];
172  
173 <  int i, k;
173 >  int i;
174 >  unsigned int k;
175  
176   #ifdef IS_MPI
177    
# Line 216 | Line 217 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
217  
218    int nProc;
219    int j, which_node, done, which_atom, local_index, currentIndex;
220 <  double atomData6[6];
220 <  double atomData13[13];
220 >  double atomData[13];
221    int isDirectional;
222    char* atomTypeString;
223    char MPIatomTypeString[MINIBUFFERSIZE];
224    int nObjects;
225 +  int msgLen; // the length of message actually recieved at master nodes
226   #endif //is_mpi
227  
228    double q[4], ji[3];
# Line 294 | Line 295 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
295        }
296        else
297          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
298 +    
299 +      for(k = 0; k < outFile.size(); k++)
300 +        *outFile[k] << writeLine;      
301      }
302  
299 –    
300 –    for(k = 0; k < outFile.size(); k++)
301 –      *outFile[k] << writeLine;
303   }
304  
305   #else // is_mpi
# Line 325 | Line 326 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
326  
327      // Node 0 needs a list of the magic potatoes for each processor;
328  
329 <    nProc = mpiSim->getNumberProcessors();
329 >    nProc = mpiSim->getNProcessors();
330      potatoes = new int[nProc];
331  
332      //write out the comment lines
# Line 353 | Line 354 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
354  
355      currentIndex = 0;
356  
357 <    for (i = 0 ; i < mpiSim->getTotNmol(); i++ ) {
357 >    for (i = 0 ; i < mpiSim->getNMolGlobal(); i++ ) {
358        
359        // Get the Node number which has this atom;
360        
# Line 379 | Line 380 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
380          
381          for(int l = 0; l < nCurObj; l++){
382  
383 <          if (potatoes[which_node] + 3 >= MAXTAG) {
383 >          if (potatoes[which_node] + 2 >= MAXTAG) {
384              // The potato was going to exceed the maximum value,
385              // so wrap this processor potato back to 0:        
386  
# Line 395 | Line 396 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
396  
397            myPotato++;
398  
399 <          MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
399 <          myPotato, MPI_COMM_WORLD, &istatus);
400 <              
399 >          MPI_Recv(atomData, 13, MPI_DOUBLE, which_node, myPotato, MPI_COMM_WORLD, &istatus);
400            myPotato++;
401  
402 <          if (isDirectional) {          
403 <          MPI_Recv(atomData13, 13, MPI_DOUBLE, which_node,
404 <                   myPotato, MPI_COMM_WORLD, &istatus);
405 <          } else {
406 <          MPI_Recv(atomData6, 6, MPI_DOUBLE, which_node,
407 <                   myPotato, MPI_COMM_WORLD, &istatus);          
402 >          MPI_Get_count(&istatus, MPI_DOUBLE, &msgLen);
403 >
404 >          if(msgLen  == 13)
405 >            isDirectional = 1;
406 >          else
407 >            isDirectional = 0;
408 >          
409 >          // If we've survived to here, format the line:
410 >            
411 >          if (!isDirectional) {
412 >        
413 >            sprintf( writeLine,
414 >                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
415 >                 atomTypeString,
416 >                 atomData[0],
417 >                 atomData[1],
418 >                 atomData[2],
419 >                 atomData[3],
420 >                 atomData[4],
421 >                 atomData[5]);
422 >        
423 >           strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
424 >        
425 >          }
426 >          else {
427 >        
428 >                sprintf( writeLine,
429 >                         "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
430 >                         atomTypeString,
431 >                         atomData[0],
432 >                         atomData[1],
433 >                         atomData[2],
434 >                         atomData[3],
435 >                         atomData[4],
436 >                         atomData[5],
437 >                         atomData[6],
438 >                         atomData[7],
439 >                         atomData[8],
440 >                         atomData[9],
441 >                         atomData[10],
442 >                         atomData[11],
443 >                         atomData[12]);
444 >            
445            }
446 +          
447 +          for(k = 0; k < outFile.size(); k++)
448 +            *outFile[k] << writeLine;            
449  
450 <          myPotato++;
412 <        }
450 >        }// end for(int l =0)
451          potatoes[which_node] = myPotato;
452  
453 <      } else {
453 >      }
454 >      else {
455          
456          haveError = 0;
457          
# Line 427 | Line 466 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
466              sd->getPos(pos);
467              sd->getVel(vel);          
468            
469 <            atomData6[0] = pos[0];
470 <            atomData6[1] = pos[1];
471 <            atomData6[2] = pos[2];
469 >            atomData[0] = pos[0];
470 >            atomData[1] = pos[1];
471 >            atomData[2] = pos[2];
472  
473 <            atomData6[3] = vel[0];
474 <            atomData6[4] = vel[1];
475 <            atomData6[5] = vel[2];
473 >            atomData[3] = vel[0];
474 >            atomData[4] = vel[1];
475 >            atomData[5] = vel[2];
476                
477              isDirectional = 0;
478  
# Line 445 | Line 484 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
484                sd->getJ( ji );
485  
486                for (int j = 0; j < 6 ; j++)
487 <                atomData13[j] = atomData6[j];            
487 >                atomData[j] = atomData[j];            
488                
489 <              atomData13[6] = q[0];
490 <              atomData13[7] = q[1];
491 <              atomData13[8] = q[2];
492 <              atomData13[9] = q[3];
489 >              atomData[6] = q[0];
490 >              atomData[7] = q[1];
491 >              atomData[8] = q[2];
492 >              atomData[9] = q[3];
493                
494 <              atomData13[10] = ji[0];
495 <              atomData13[11] = ji[1];
496 <              atomData13[12] = ji[2];
494 >              atomData[10] = ji[0];
495 >              atomData[11] = ji[1];
496 >              atomData[12] = ji[2];
497              }
498              
499 <        }
499 >            // If we've survived to here, format the line:
500 >            
501 >            if (!isDirectional) {
502 >        
503 >              sprintf( writeLine,
504 >                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
505 >                 atomTypeString,
506 >                 atomData[0],
507 >                 atomData[1],
508 >                 atomData[2],
509 >                 atomData[3],
510 >                 atomData[4],
511 >                 atomData[5]);
512 >        
513 >             strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
514 >        
515 >            }
516 >            else {
517 >        
518 >                sprintf( writeLine,
519 >                         "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
520 >                         atomTypeString,
521 >                         atomData[0],
522 >                         atomData[1],
523 >                         atomData[2],
524 >                         atomData[3],
525 >                         atomData[4],
526 >                         atomData[5],
527 >                         atomData[6],
528 >                         atomData[7],
529 >                         atomData[8],
530 >                         atomData[9],
531 >                         atomData[10],
532 >                         atomData[11],
533 >                         atomData[12]);
534 >              
535 >            }
536 >            
537 >            for(k = 0; k < outFile.size(); k++)
538 >              *outFile[k] << writeLine;
539 >            
540 >            
541 >        }//end for(iter = integrableObject.begin())
542          
543        currentIndex++;
544        }
545 <      // If we've survived to here, format the line:
546 <      
466 <      if (!isDirectional) {
467 <        
468 <        sprintf( writeLine,
469 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
470 <                 atomTypeString,
471 <                 atomData6[0],
472 <                 atomData6[1],
473 <                 atomData6[2],
474 <                 atomData6[3],
475 <                 atomData6[4],
476 <                 atomData6[5]);
477 <        
478 <        strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
479 <        
480 <      } else {
481 <        
482 <        sprintf( writeLine,
483 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
484 <                 atomTypeString,
485 <                 atomData13[0],
486 <                 atomData13[1],
487 <                 atomData13[2],
488 <                 atomData13[3],
489 <                 atomData13[4],
490 <                 atomData13[5],
491 <                 atomData13[6],
492 <                 atomData13[7],
493 <                 atomData13[8],
494 <                 atomData13[9],
495 <                 atomData13[10],
496 <                 atomData13[11],
497 <                 atomData13[12]);
498 <        
499 <      }
500 <      
501 <      for(k = 0; k < outFile.size(); k++)
502 <        *outFile[k] << writeLine;
503 <    }
545 >
546 >    }//end for(i = 0; i < mpiSim->getNmol())
547      
548      for(k = 0; k < outFile.size(); k++)
549        outFile[k]->flush();
# Line 521 | Line 564 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
564      myPotato = 0;
565      currentIndex = 0;
566      
567 <    for (i = 0 ; i < mpiSim->getTotNmol(); i++ ) {
567 >    for (i = 0 ; i < mpiSim->getNMolGlobal(); i++ ) {
568        
569        // Am I the node which has this integrableObject?
570        
# Line 549 | Line 592 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
592  
593            for( iter = integrableObjects.begin(); iter  != integrableObjects.end(); iter++){
594  
595 <            if (myPotato + 3 >= MAXTAG) {
595 >            if (myPotato + 2 >= MAXTAG) {
596            
597                // The potato was going to exceed the maximum value,
598                // so wrap this processor potato back to 0 (and block until
# Line 566 | Line 609 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
609              sd->getPos(pos);
610              sd->getVel(vel);
611  
612 <            atomData6[0] = pos[0];
613 <            atomData6[1] = pos[1];
614 <            atomData6[2] = pos[2];
612 >            atomData[0] = pos[0];
613 >            atomData[1] = pos[1];
614 >            atomData[2] = pos[2];
615  
616 <            atomData6[3] = vel[0];
617 <            atomData6[4] = vel[1];
618 <            atomData6[5] = vel[2];
616 >            atomData[3] = vel[0];
617 >            atomData[4] = vel[1];
618 >            atomData[5] = vel[2];
619                
620              isDirectional = 0;
621  
# Line 583 | Line 626 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
626                  sd->getQ( q );
627                  sd->getJ( ji );
628                  
586 –                for (int j = 0; j < 6 ; j++)
587 –                  atomData13[j] = atomData6[j];
629                  
630 <                atomData13[6] = q[0];
631 <                atomData13[7] = q[1];
632 <                atomData13[8] = q[2];
633 <                atomData13[9] = q[3];
630 >                atomData[6] = q[0];
631 >                atomData[7] = q[1];
632 >                atomData[8] = q[2];
633 >                atomData[9] = q[3];
634        
635 <                atomData13[10] = ji[0];
636 <                atomData13[11] = ji[1];
637 <                atomData13[12] = ji[2];
635 >                atomData[10] = ji[0];
636 >                atomData[11] = ji[1];
637 >                atomData[12] = ji[2];
638                }
639  
640              
# Line 606 | Line 647 | void DumpWriter::writeFrame( vector<ofstream*>& outFil
647                               myPotato, MPI_COMM_WORLD);
648              
649              myPotato++;
609 –
610 –            MPI_Send(&isDirectional, 1, MPI_INT, 0,
611 –                             myPotato, MPI_COMM_WORLD);
650              
613 –            myPotato++;
614 –            
651              if (isDirectional) {
652  
653 <              MPI_Send(atomData13, 13, MPI_DOUBLE, 0,
653 >              MPI_Send(atomData, 13, MPI_DOUBLE, 0,
654                         myPotato, MPI_COMM_WORLD);
655                
656              } else {
657  
658 <              MPI_Send(atomData6, 6, MPI_DOUBLE, 0,
658 >              MPI_Send(atomData, 6, MPI_DOUBLE, 0,
659                         myPotato, MPI_COMM_WORLD);
660              }
661  

Diff Legend

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