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 440 by mmeineke, Tue Apr 1 16:49:17 2003 UTC vs.
Revision 723 by mmeineke, Tue Aug 26 20:12:51 2003 UTC

# Line 1 | Line 1
1 + #define _FILE_OFFSET_BITS 64
2 +
3   #include <cstring>
4   #include <iostream>
5   #include <fstream>
6  
7   #ifdef IS_MPI
8   #include <mpi.h>
7 – #include <mpi++.h>
9   #include "mpiSimulation.hpp"
10   #define TAKE_THIS_TAG_CHAR 1
11   #define TAKE_THIS_TAG_INT 2
# Line 28 | Line 29 | DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
29    if(worldRank == 0 ){
30   #endif // is_mpi
31      
31 –
32 –    
32      strcpy( outName, entry_plug->sampleName );
33      
34      outFile.open(outName, ios::out | ios::trunc );
# Line 42 | Line 41 | DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
41        painCave.isFatal = 1;
42        simError();
43      }
44 <  
44 >
45      //outFile.setf( ios::scientific );
46  
47   #ifdef IS_MPI
# Line 73 | Line 72 | void DumpWriter::writeDump( double currentTime ){
72    char tempBuffer[BUFFERSIZE];
73    char writeLine[BUFFERSIZE];
74  
75 <  int i, j, which_node, done, game_over, which_atom, local_index;
75 >  int i, j, which_node, done, which_atom, local_index;
76    double q[4];
77    DirectionalAtom* dAtom;
78    int nAtoms = entry_plug->n_atoms;
79    Atom** atoms = entry_plug->atoms;
80 +
81 +  double pos[3], vel[3];
82      
83  
84   #ifndef IS_MPI
85      
86    outFile << nAtoms << "\n";
87      
88 <  outFile << currentTime << "\t"
89 <          << entry_plug->box_x << "\t"
90 <          << entry_plug->box_y << "\t"
91 <          << entry_plug->box_z << "\n";
88 >  outFile << currentTime << ";\t"
89 >          << entry_plug->Hmat[0][0] << "\t"
90 >          << entry_plug->Hmat[1][0] << "\t"
91 >          << entry_plug->Hmat[2][0] << ";\t"
92 >
93 >          << entry_plug->Hmat[0][1] << "\t"
94 >          << entry_plug->Hmat[1][1] << "\t"
95 >          << entry_plug->Hmat[2][1] << ";\t"
96 >
97 >          << entry_plug->Hmat[0][2] << "\t"
98 >          << entry_plug->Hmat[1][2] << "\t"
99 >          << entry_plug->Hmat[2][2] << ";\n";
100      
101    for( i=0; i<nAtoms; i++ ){
102        
103 +    atoms[i]->getPos(pos);
104 +    atoms[i]->getVel(vel);
105  
106      sprintf( tempBuffer,
107               "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
108               atoms[i]->getType(),
109 <             atoms[i]->getX(),
110 <             atoms[i]->getY(),
111 <             atoms[i]->getZ(),
112 <             atoms[i]->get_vx(),
113 <             atoms[i]->get_vy(),
114 <             atoms[i]->get_vz());
109 >             pos[0],
110 >             pos[1],
111 >             pos[2],
112 >             vel[0],
113 >             vel[1],
114 >             vel[2]);
115      strcpy( writeLine, tempBuffer );
116  
117      if( atoms[i]->isDirectional() ){
# Line 134 | Line 145 | void DumpWriter::writeDump( double currentTime ){
145    int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
146    int haveError;
147  
148 <  MPI::Status istatus;
148 >  MPI_Status istatus;
149    int *AtomToProcMap = mpiSim->getAtomToProcMap();
150    
151    // write out header and node 0's coordinates
152    
153    if( worldRank == 0 ){
154      outFile << mpiSim->getTotAtoms() << "\n";
155 +  
156 +    outFile << currentTime << ";\t"
157 +            << entry_plug->Hmat[0][0] << "\t"
158 +            << entry_plug->Hmat[1][0] << "\t"
159 +            << entry_plug->Hmat[2][0] << ";\t"
160 +      
161 +            << entry_plug->Hmat[0][1] << "\t"
162 +            << entry_plug->Hmat[1][1] << "\t"
163 +            << entry_plug->Hmat[2][1] << ";\t"
164 +      
165 +            << entry_plug->Hmat[0][2] << "\t"
166 +            << entry_plug->Hmat[1][2] << "\t"
167 +            << entry_plug->Hmat[2][2] << ";\n";
168      
145 –    outFile << currentTime << "\t"
146 –            << entry_plug->box_x << "\t"
147 –            << entry_plug->box_y << "\t"
148 –            << entry_plug->box_z << "\n";
169      outFile.flush();
170      for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
171        // Get the Node number which has this atom;
# Line 162 | Line 182 | void DumpWriter::writeDump( double currentTime ){
182          }
183          if (local_index != -1) {
184            //format the line
185 +          
186 +          atoms[local_index]->getPos(pos);
187 +          atoms[local_index]->getVel(vel);
188 +
189            sprintf( tempBuffer,
190                     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
191                     atoms[local_index]->getType(),
192 <                   atoms[local_index]->getX(),
193 <                   atoms[local_index]->getY(),
194 <                   atoms[local_index]->getZ(),
195 <                   atoms[local_index]->get_vx(),
196 <                   atoms[local_index]->get_vy(),
197 <                   atoms[local_index]->get_vz()); // check here.
192 >                   pos[0],
193 >                   pos[1],
194 >                   pos[2],
195 >                   vel[0],
196 >                   vel[1],
197 >                   vel[2]); // check here.
198            strcpy( writeLine, tempBuffer );
199            
200            if( atoms[local_index]->isDirectional() ){
# Line 206 | Line 230 | void DumpWriter::writeDump( double currentTime ){
230        }
231        else {
232          myStatus = 1;
233 <        MPI::COMM_WORLD.Send(&myStatus, 1, MPI_INT, which_node,
234 <                             TAKE_THIS_TAG_INT);
235 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT);
236 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
237 <                             TAKE_THIS_TAG_CHAR, istatus);
238 <        MPI::COMM_WORLD.Recv(&myStatus, 1, MPI_INT, which_node,
239 <                             TAKE_THIS_TAG_INT, istatus);
233 >        MPI_Send(&myStatus, 1, MPI_INT, which_node,
234 >                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
235 >        MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
236 >                 MPI_COMM_WORLD);
237 >        MPI_Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
238 >                 TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
239 >        MPI_Recv(&myStatus, 1, MPI_INT, which_node,
240 >                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
241          
242          if(!myStatus) nodeZeroError();
243  
# Line 225 | Line 250 | void DumpWriter::writeDump( double currentTime ){
250      // kill everyone off:
251      myStatus = -1;
252      for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
253 <      MPI::COMM_WORLD.Send(&myStatus, 1, MPI_INT, j,
254 <                           TAKE_THIS_TAG_INT);
253 >      MPI_Send(&myStatus, 1, MPI_INT, j,
254 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
255      }
256  
257    } else {
# Line 234 | Line 259 | void DumpWriter::writeDump( double currentTime ){
259      done = 0;
260      while (!done) {
261        
262 <      MPI::COMM_WORLD.Recv(&myStatus, 1, MPI_INT, 0,
263 <                           TAKE_THIS_TAG_INT, istatus);
262 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
263 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
264  
265        if(!myStatus) anonymousNodeDie();
266        
267        if(myStatus < 0) break;
268  
269 <      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
270 <                           TAKE_THIS_TAG_INT, istatus);
269 >      MPI_Recv(&which_atom, 1, MPI_INT, 0,
270 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
271        
272        myStatus = 1;
273        local_index=-1;        
# Line 251 | Line 276 | void DumpWriter::writeDump( double currentTime ){
276        }
277        if (local_index != -1) {
278          //format the line
279 +
280 +        atoms[local_index]->getPos(pos);
281 +        atoms[local_index]->getVel(vel);
282 +
283          sprintf( tempBuffer,
284                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
285                   atoms[local_index]->getType(),
286 <                 atoms[local_index]->getX(),
287 <                 atoms[local_index]->getY(),
288 <                 atoms[local_index]->getZ(),
289 <                 atoms[local_index]->get_vx(),
290 <                 atoms[local_index]->get_vy(),
291 <                 atoms[local_index]->get_vz()); // check here.
286 >                 pos[0],
287 >                 pos[1],
288 >                 pos[2],
289 >                 vel[0],
290 >                 vel[1],
291 >                 vel[2]); // check here.
292          strcpy( writeLine, tempBuffer );
293          
294          if( atoms[local_index]->isDirectional() ){
# Line 292 | Line 321 | void DumpWriter::writeDump( double currentTime ){
321          strcpy( writeLine, "Hello, I'm an error.\n");
322        }
323  
324 <      MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
325 <                           TAKE_THIS_TAG_CHAR);
326 <      MPI::COMM_WORLD.Send( &myStatus, 1, MPI_INT, 0,
327 <                            TAKE_THIS_TAG_INT);
324 >      MPI_Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
325 >               TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
326 >      MPI_Send( &myStatus, 1, MPI_INT, 0,
327 >                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
328      }
329    }  
330    outFile.flush();
# Line 309 | Line 338 | void DumpWriter::writeFinal(){
338   #endif // is_mpi
339   }
340  
341 < void DumpWriter::writeFinal(){
341 > void DumpWriter::writeFinal(double finalTime){
342  
343    char finalName[500];
344    ofstream finalOut;
# Line 324 | Line 353 | void DumpWriter::writeFinal(){
353    Atom** atoms = entry_plug->atoms;
354    int i, j, which_node, done, game_over, which_atom, local_index;
355    
356 +  double pos[3], vel[3];
357    
358   #ifdef IS_MPI
359    if(worldRank == 0 ){
# Line 355 | Line 385 | void DumpWriter::writeFinal(){
385      
386    finalOut << nAtoms << "\n";
387      
388 <  finalOut << entry_plug->box_x << "\t"
389 <           << entry_plug->box_y << "\t"
390 <           << entry_plug->box_z << "\n";
388 >  finalOut << finalTime << ";\t"
389 >           << entry_plug->Hmat[0][0] << "\t"
390 >           << entry_plug->Hmat[1][0] << "\t"
391 >           << entry_plug->Hmat[2][0] << ";\t"
392 >    
393 >           << entry_plug->Hmat[0][1] << "\t"
394 >           << entry_plug->Hmat[1][1] << "\t"
395 >           << entry_plug->Hmat[2][1] << ";\t"
396 >    
397 >           << entry_plug->Hmat[0][2] << "\t"
398 >           << entry_plug->Hmat[1][2] << "\t"
399 >           << entry_plug->Hmat[2][2] << ";\n";
400    
401    for( i=0; i<nAtoms; i++ ){
402        
403 +    atoms[i]->getPos(pos);
404 +    atoms[i]->getVel(vel);
405 +    
406      sprintf( tempBuffer,
407               "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
408               atoms[i]->getType(),
409 <             atoms[i]->getX(),
410 <             atoms[i]->getY(),
411 <             atoms[i]->getZ(),
412 <             atoms[i]->get_vx(),
413 <             atoms[i]->get_vy(),
414 <             atoms[i]->get_vz());
409 >             pos[0],
410 >             pos[1],
411 >             pos[2],
412 >             vel[0],
413 >             vel[1],
414 >             vel[2]);
415      strcpy( writeLine, tempBuffer );
416  
417      if( atoms[i]->isDirectional() ){
# Line 404 | Line 446 | void DumpWriter::writeFinal(){
446    int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
447    int haveError;
448  
449 <  MPI::Status istatus;
449 >  MPI_Status istatus;
450    int *AtomToProcMap = mpiSim->getAtomToProcMap();
451  
452    // write out header and node 0's coordinates
# Line 413 | Line 455 | void DumpWriter::writeFinal(){
455    if( worldRank == 0 ){
456      finalOut << mpiSim->getTotAtoms() << "\n";
457      
458 <    finalOut << entry_plug->box_x << "\t"
459 <            << entry_plug->box_y << "\t"
460 <            << entry_plug->box_z << "\n";
458 >    finalOut << finalTime << ";\t"
459 >             << entry_plug->Hmat[0][0] << "\t"
460 >             << entry_plug->Hmat[1][0] << "\t"
461 >             << entry_plug->Hmat[2][0] << ";\t"
462 >      
463 >             << entry_plug->Hmat[0][1] << "\t"
464 >             << entry_plug->Hmat[1][1] << "\t"
465 >             << entry_plug->Hmat[2][1] << ";\t"
466 >      
467 >             << entry_plug->Hmat[0][2] << "\t"
468 >             << entry_plug->Hmat[1][2] << "\t"
469 >             << entry_plug->Hmat[2][2] << ";\n";
470      
471      for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
472        // Get the Node number which has this molecule:
# Line 429 | Line 480 | void DumpWriter::writeFinal(){
480          for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
481            if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
482          }
483 <        if (local_index != -1) {        
483 >        if (local_index != -1) {    
484 >
485 >          atoms[local_index]->getPos(pos);
486 >          atoms[local_index]->getVel(vel);
487 >          
488            sprintf( tempBuffer,
489                     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
490                     atoms[local_index]->getType(),
491 <                   atoms[local_index]->getX(),
492 <                   atoms[local_index]->getY(),
493 <                   atoms[local_index]->getZ(),
494 <                   atoms[local_index]->get_vx(),
495 <                   atoms[local_index]->get_vy(),
496 <                   atoms[local_index]->get_vz());
491 >                   pos[0],
492 >                   pos[1],
493 >                   pos[2],
494 >                   vel[0],
495 >                   vel[1],
496 >                   vel[2]);
497            strcpy( writeLine, tempBuffer );
498            
499            if( atoms[local_index]->isDirectional() ){
# Line 474 | Line 529 | void DumpWriter::writeFinal(){
529        else {
530          
531          myStatus = 1;
532 <        MPI::COMM_WORLD.Send(&myStatus, 1, MPI_INT, which_node,
533 <                             TAKE_THIS_TAG_INT);
534 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT);
535 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
536 <                             TAKE_THIS_TAG_CHAR, istatus);
537 <        MPI::COMM_WORLD.Recv(&myStatus, 1, MPI_INT, which_node,
538 <                             TAKE_THIS_TAG_INT, istatus);
532 >        MPI_Send(&myStatus, 1, MPI_INT, which_node,
533 >                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
534 >        MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
535 >                 MPI_COMM_WORLD);
536 >        MPI_Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
537 >                 TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
538 >        MPI_Recv(&myStatus, 1, MPI_INT, which_node,
539 >                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
540          
541          if(!myStatus) nodeZeroError();
542        }
# Line 491 | Line 547 | void DumpWriter::writeFinal(){
547      // kill everyone off:
548      myStatus = -1;
549      for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
550 <      MPI::COMM_WORLD.Send(&myStatus, 1, MPI_INT, j,
551 <                           TAKE_THIS_TAG_INT);
550 >      MPI_Send(&myStatus, 1, MPI_INT, j,
551 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
552      }
553  
554    } else {
# Line 500 | Line 556 | void DumpWriter::writeFinal(){
556      done = 0;
557      while (!done) {
558  
559 <      MPI::COMM_WORLD.Recv(&myStatus, 1, MPI_INT, 0,
560 <                           TAKE_THIS_TAG_INT, istatus);
559 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
560 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
561        
562        if(!myStatus) anonymousNodeDie();
563        
564        if(myStatus < 0) break;
565        
566 <      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
567 <                           TAKE_THIS_TAG_INT, istatus);
566 >      MPI_Recv(&which_atom, 1, MPI_INT, 0,
567 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
568        
569        myStatus = 1;
570        local_index=-1;        
# Line 517 | Line 573 | void DumpWriter::writeFinal(){
573        }
574        if (local_index != -1) {
575  
576 +        atoms[local_index]->getPos(pos);
577 +        atoms[local_index]->getVel(vel);
578 +
579          //format the line
580          sprintf( tempBuffer,
581                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
582                   atoms[local_index]->getType(),
583 <                 atoms[local_index]->getX(),
584 <                 atoms[local_index]->getY(),
585 <                 atoms[local_index]->getZ(),
586 <                 atoms[local_index]->get_vx(),
587 <                 atoms[local_index]->get_vy(),
588 <                 atoms[local_index]->get_vz()); // check here.
583 >                 pos[0],
584 >                 pos[1],
585 >                 pos[2],
586 >                 vel[0],
587 >                 vel[1],
588 >                 vel[2]); // check here.
589          strcpy( writeLine, tempBuffer );
590          
591          if( atoms[local_index]->isDirectional() ){
# Line 559 | Line 618 | void DumpWriter::writeFinal(){
618          strcpy( writeLine, "Hello, I'm an error.\n");
619        }
620  
621 <      MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
622 <                           TAKE_THIS_TAG_CHAR);
623 <      MPI::COMM_WORLD.Send( &myStatus, 1, MPI_INT, 0,
624 <                            TAKE_THIS_TAG_INT);
621 >      MPI_Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
622 >               TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
623 >      MPI_Send( &myStatus, 1, MPI_INT, 0,
624 >                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
625      }
626    }
627    finalOut.flush();
# Line 585 | Line 644 | void dWrite::nodeZeroError( void ){
644    
645    myStatus = 0;
646    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
647 <    MPI::COMM_WORLD.Send( &myStatus, 1, MPI_INT, j,
648 <                          TAKE_THIS_TAG_INT);
647 >    MPI_Send( &myStatus, 1, MPI_INT, j,
648 >              TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
649    }  
650    
651  

Diff Legend

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