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 419 by gezelter, Thu Mar 27 15:07:29 2003 UTC vs.
Revision 837 by tim, Wed Oct 29 00:19:10 2003 UTC

# Line 1 | Line 1
1 < #include <cstring>
1 > #define _FILE_OFFSET_BITS 64
2 >
3 > #include <string.h>
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 0
10 > #define TAKE_THIS_TAG_CHAR 1
11 > #define TAKE_THIS_TAG_INT 2
12 >
13 > namespace dWrite{
14 >  void nodeZeroError( void );
15 >  void anonymousNodeDie( void );
16 > }
17 >
18 > using namespace dWrite;
19   #endif //is_mpi
20  
21   #include "ReadWrite.hpp"
# Line 19 | Line 28 | DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
28   #ifdef IS_MPI
29    if(worldRank == 0 ){
30   #endif // is_mpi
31 <    
23 <
24 <    
31 >
32      strcpy( outName, entry_plug->sampleName );
33 <    
33 >
34      outFile.open(outName, ios::out | ios::trunc );
35 <    
35 >
36      if( !outFile ){
37 <      
37 >
38        sprintf( painCave.errMsg,
39                 "Could not open \"%s\" for dump output.\n",
40                 outName);
41        painCave.isFatal = 1;
42        simError();
43      }
44 <  
44 >
45      //outFile.setf( ios::scientific );
46  
47   #ifdef IS_MPI
# Line 60 | Line 67 | void DumpWriter::writeDump( double currentTime ){
67   }
68  
69   void DumpWriter::writeDump( double currentTime ){
70 <  
70 >
71    const int BUFFERSIZE = 2000;
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;
76 > #ifdef IS_MPI
77 >  int j, which_node, done, which_atom, local_index;
78 > #else //is_mpi
79 >  int nAtoms = entry_plug->n_atoms;
80 > #endif //is_mpi
81 >
82    double q[4];
83    DirectionalAtom* dAtom;
71 –  int nAtoms = entry_plug->n_atoms;
84    Atom** atoms = entry_plug->atoms;
85 <    
85 >  double pos[3], vel[3];
86  
87 +
88 +  // write current frame to the eor file
89 +
90 +  this->writeFinal( currentTime );
91 +
92   #ifndef IS_MPI
93 <    
93 >
94    outFile << nAtoms << "\n";
95 <    
96 <  outFile << currentTime << "\t"
97 <          << entry_plug->box_x << "\t"
98 <          << entry_plug->box_y << "\t"
99 <          << entry_plug->box_z << "\n";
100 <    
95 >
96 >  outFile << currentTime << ";\t"
97 >          << entry_plug->Hmat[0][0] << "\t"
98 >          << entry_plug->Hmat[1][0] << "\t"
99 >          << entry_plug->Hmat[2][0] << ";\t"
100 >
101 >          << entry_plug->Hmat[0][1] << "\t"
102 >          << entry_plug->Hmat[1][1] << "\t"
103 >          << entry_plug->Hmat[2][1] << ";\t"
104 >
105 >          << entry_plug->Hmat[0][2] << "\t"
106 >          << entry_plug->Hmat[1][2] << "\t"
107 >          << entry_plug->Hmat[2][2] << ";";
108 >  //write out additional parameters, such as chi and eta
109 >  outFile << entry_plug->the_integrator->getAdditionalParameters();
110 >  outFile << endl;
111 >
112    for( i=0; i<nAtoms; i++ ){
85 –      
113  
114 +    atoms[i]->getPos(pos);
115 +    atoms[i]->getVel(vel);
116 +
117      sprintf( tempBuffer,
118               "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
119               atoms[i]->getType(),
120 <             atoms[i]->getX(),
121 <             atoms[i]->getY(),
122 <             atoms[i]->getZ(),
123 <             atoms[i]->get_vx(),
124 <             atoms[i]->get_vy(),
125 <             atoms[i]->get_vz());
120 >             pos[0],
121 >             pos[1],
122 >             pos[2],
123 >             vel[0],
124 >             vel[1],
125 >             vel[2]);
126      strcpy( writeLine, tempBuffer );
127  
128      if( atoms[i]->isDirectional() ){
129 <        
129 >
130        dAtom = (DirectionalAtom *)atoms[i];
131        dAtom->getQ( q );
132 <        
132 >
133        sprintf( tempBuffer,
134                 "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
135                 q[0],
# Line 113 | Line 143 | void DumpWriter::writeDump( double currentTime ){
143      }
144      else
145        strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
146 <      
146 >
147      outFile << writeLine;
148    }
149    outFile.flush();
150  
151   #else // is_mpi
152  
153 <  MPI::Status istatus;
153 >  // first thing first, suspend fatalities.
154 >  painCave.isEventLoop = 1;
155 >
156 >  int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
157 >  int haveError;
158 >
159 >  MPI_Status istatus;
160    int *AtomToProcMap = mpiSim->getAtomToProcMap();
161 <  
161 >
162    // write out header and node 0's coordinates
163 <  
163 >
164    if( worldRank == 0 ){
165      outFile << mpiSim->getTotAtoms() << "\n";
166 <    
167 <    outFile << currentTime << "\t"
168 <            << entry_plug->box_x << "\t"
169 <            << entry_plug->box_y << "\t"
170 <            << entry_plug->box_z << "\n";
171 <    
166 >
167 >    outFile << currentTime << ";\t"
168 >            << entry_plug->Hmat[0][0] << "\t"
169 >            << entry_plug->Hmat[1][0] << "\t"
170 >            << entry_plug->Hmat[2][0] << ";\t"
171 >
172 >            << entry_plug->Hmat[0][1] << "\t"
173 >            << entry_plug->Hmat[1][1] << "\t"
174 >            << entry_plug->Hmat[2][1] << ";\t"
175 >
176 >            << entry_plug->Hmat[0][2] << "\t"
177 >            << entry_plug->Hmat[1][2] << "\t"
178 >            << entry_plug->Hmat[2][2] << ";";
179 >
180 >    outFile << entry_plug->the_integrator->getAdditionalParameters();
181 >    outFile << endl;
182 >    outFile.flush();
183      for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
184        // Get the Node number which has this atom;
138 –      
139 –      which_node = AtomToProcMap[i];    
140 –      
141 –      if (which_node == mpiSim->getMyNode()) {
142 –        
143 –        sprintf( tempBuffer,
144 –                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
145 –                 atoms[i]->getType(),
146 –                 atoms[i]->getX(),
147 –                 atoms[i]->getY(),
148 –                 atoms[i]->getZ(),
149 –                 atoms[i]->get_vx(),
150 –                 atoms[i]->get_vy(),
151 –                 atoms[i]->get_vz());
152 –        strcpy( writeLine, tempBuffer );
153 –        
154 –        if( atoms[i]->isDirectional() ){
155 –          
156 –          dAtom = (DirectionalAtom *)atoms[i];
157 –          dAtom->getQ( q );
158 –          
159 –          sprintf( tempBuffer,
160 –                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
161 –                   q[0],
162 –                   q[1],
163 –                   q[2],
164 –                   q[3],
165 –                   dAtom->getJx(),
166 –                   dAtom->getJy(),
167 –                   dAtom->getJz());
168 –          strcat( writeLine, tempBuffer );
169 –        }
170 –        else
171 –          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
172 –        
173 –      } else {
174 –        
175 –        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG);
176 –        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
177 –                                TAKE_THIS_TAG, istatus);
178 –      }
179 –      
180 –      outFile << writeLine;
181 –    }
182 –    
183 –    // kill everyone off:
184 –    game_over = -1;
185 –    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
186 –      MPI::COMM_WORLD.Send(&game_over, 1, MPI_INT, j, TAKE_THIS_TAG);
187 –    }
185  
186 <  } else {
187 <    
188 <    done = 0;
189 <    while (!done) {
190 <      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
191 <                           TAKE_THIS_TAG, istatus);
192 <      
193 <      if (which_atom == -1) {
197 <        done=1;
198 <        continue;
199 <      } else {
200 <        local_index=-1;        
201 <        for (j=0; j < mpiSim->getMyNlocal(); j++) {
186 >      which_node = AtomToProcMap[i];
187 >
188 >      if (which_node == 0 ) {
189 >
190 >        haveError = 0;
191 >        which_atom = i;
192 >        local_index=-1;
193 >        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
194            if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
195          }
196          if (local_index != -1) {
197            //format the line
198 +
199 +          atoms[local_index]->getPos(pos);
200 +          atoms[local_index]->getVel(vel);
201 +
202            sprintf( tempBuffer,
203                     "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
204                     atoms[local_index]->getType(),
205 <                   atoms[local_index]->getX(),
206 <                   atoms[local_index]->getY(),
207 <                   atoms[local_index]->getZ(),
208 <                   atoms[local_index]->get_vx(),
209 <                   atoms[local_index]->get_vy(),
210 <                   atoms[local_index]->get_vz()); // check here.
205 >                   pos[0],
206 >                   pos[1],
207 >                   pos[2],
208 >                   vel[0],
209 >                   vel[1],
210 >                   vel[2]); // check here.
211            strcpy( writeLine, tempBuffer );
212 <          
212 >
213            if( atoms[local_index]->isDirectional() ){
214 <            
214 >
215              dAtom = (DirectionalAtom *)atoms[local_index];
216              dAtom->getQ( q );
217 <            
217 >
218              sprintf( tempBuffer,
219                       "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
220                       q[0],
# Line 229 | Line 225 | void DumpWriter::writeDump( double currentTime ){
225                       dAtom->getJy(),
226                       dAtom->getJz());
227              strcat( writeLine, tempBuffer );
228 <          }
229 <          else
230 <            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
231 <          
232 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
233 <                               TAKE_THIS_TAG);
234 <        } else {
235 <          strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
236 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
237 <                               TAKE_THIS_TAG);
238 <        }
228 >
229 >          }
230 >          else
231 >            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
232 >        }
233 >        else {
234 >          sprintf(painCave.errMsg,
235 >                  "Atom %d not found on processor %d\n",
236 >                  i, worldRank );
237 >          haveError= 1;
238 >          simError();
239 >        }
240 >
241 >        if(haveError) nodeZeroError();
242 >
243        }
244 +      else {
245 +        myStatus = 1;
246 +        MPI_Send(&myStatus, 1, MPI_INT, which_node,
247 +                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
248 +        MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
249 +                 MPI_COMM_WORLD);
250 +        MPI_Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
251 +                 TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
252 +        MPI_Recv(&myStatus, 1, MPI_INT, which_node,
253 +                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
254 +
255 +        if(!myStatus) nodeZeroError();
256 +
257 +      }
258 +
259 +      outFile << writeLine;
260 +      outFile.flush();
261      }
262 <  }  
262 >
263 >    // kill everyone off:
264 >    myStatus = -1;
265 >    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
266 >      MPI_Send(&myStatus, 1, MPI_INT, j,
267 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
268 >    }
269 >
270 >  } else {
271 >
272 >    done = 0;
273 >    while (!done) {
274 >
275 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
276 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
277 >
278 >      if(!myStatus) anonymousNodeDie();
279 >
280 >      if(myStatus < 0) break;
281 >
282 >      MPI_Recv(&which_atom, 1, MPI_INT, 0,
283 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
284 >
285 >      myStatus = 1;
286 >      local_index=-1;
287 >      for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
288 >        if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
289 >      }
290 >      if (local_index != -1) {
291 >        //format the line
292 >
293 >        atoms[local_index]->getPos(pos);
294 >        atoms[local_index]->getVel(vel);
295 >
296 >        sprintf( tempBuffer,
297 >                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
298 >                 atoms[local_index]->getType(),
299 >                 pos[0],
300 >                 pos[1],
301 >                 pos[2],
302 >                 vel[0],
303 >                 vel[1],
304 >                 vel[2]); // check here.
305 >        strcpy( writeLine, tempBuffer );
306 >
307 >        if( atoms[local_index]->isDirectional() ){
308 >
309 >          dAtom = (DirectionalAtom *)atoms[local_index];
310 >          dAtom->getQ( q );
311 >
312 >          sprintf( tempBuffer,
313 >                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
314 >                   q[0],
315 >                   q[1],
316 >                   q[2],
317 >                   q[3],
318 >                   dAtom->getJx(),
319 >                   dAtom->getJy(),
320 >                   dAtom->getJz());
321 >          strcat( writeLine, tempBuffer );
322 >        }
323 >        else{
324 >          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
325 >        }
326 >      }
327 >      else {
328 >        sprintf(painCave.errMsg,
329 >                "Atom %d not found on processor %d\n",
330 >                which_atom, worldRank );
331 >        myStatus = 0;
332 >        simError();
333 >
334 >        strcpy( writeLine, "Hello, I'm an error.\n");
335 >      }
336 >
337 >      MPI_Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
338 >               TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
339 >      MPI_Send( &myStatus, 1, MPI_INT, 0,
340 >                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
341 >    }
342 >  }
343    outFile.flush();
344    sprintf( checkPointMsg,
345             "Sucessfully took a dump.\n");
346    MPIcheckPoint();
347 +
348 + // last  thing last, enable  fatalities.
349 +  painCave.isEventLoop = 0;
350 +
351   #endif // is_mpi
352   }
353  
354 < void DumpWriter::writeFinal(){
354 > void DumpWriter::writeFinal(double finalTime){
355  
356    char finalName[500];
357    ofstream finalOut;
358  
359    const int BUFFERSIZE = 2000;
360    char tempBuffer[BUFFERSIZE];
361 <  char writeLine[BUFFERSIZE];  
361 >  char writeLine[BUFFERSIZE];
362  
363    double q[4];
364    DirectionalAtom* dAtom;
264 –  int nAtoms = entry_plug->n_atoms;
365    Atom** atoms = entry_plug->atoms;
366 <  int i, j, which_node, done, game_over, which_atom, local_index;
267 <  
268 <  
366 >  int i;
367   #ifdef IS_MPI
368 +  int j, which_node, done, which_atom, local_index;
369 + #else //is_mpi
370 +  int nAtoms = entry_plug->n_atoms;
371 + #endif //is_mpi
372 +
373 +  double pos[3], vel[3];
374 +
375 + #ifdef IS_MPI
376    if(worldRank == 0 ){
377   #endif // is_mpi
378 <    
378 >
379      strcpy( finalName, entry_plug->finalName );
380 <    
380 >
381      finalOut.open( finalName, ios::out | ios::trunc );
382      if( !finalOut ){
383        sprintf( painCave.errMsg,
# Line 280 | Line 386 | void DumpWriter::writeFinal(){
386        painCave.isFatal = 1;
387        simError();
388      }
389 <    
389 >
390      // finalOut.setf( ios::scientific );
391 <    
391 >
392   #ifdef IS_MPI
393    }
394 <  
394 >
395    sprintf(checkPointMsg,"Opened file for final configuration\n");
396 <  MPIcheckPoint();  
397 <  
396 >  MPIcheckPoint();
397 >
398   #endif //is_mpi
399  
400 <  
400 >
401   #ifndef IS_MPI
402 <    
402 >
403    finalOut << nAtoms << "\n";
404 <    
405 <  finalOut << entry_plug->box_x << "\t"
406 <           << entry_plug->box_y << "\t"
407 <           << entry_plug->box_z << "\n";
408 <  
404 >
405 >  finalOut << finalTime << ";\t"
406 >           << entry_plug->Hmat[0][0] << "\t"
407 >           << entry_plug->Hmat[1][0] << "\t"
408 >           << entry_plug->Hmat[2][0] << ";\t"
409 >
410 >           << entry_plug->Hmat[0][1] << "\t"
411 >           << entry_plug->Hmat[1][1] << "\t"
412 >           << entry_plug->Hmat[2][1] << ";\t"
413 >
414 >           << entry_plug->Hmat[0][2] << "\t"
415 >           << entry_plug->Hmat[1][2] << "\t"
416 >           << entry_plug->Hmat[2][2] << ";";
417 >
418 >  //write out additional parameters, such as chi and eta
419 >  finalOut << entry_plug->the_integrator->getAdditionalParameters();
420 >  finalOut << endl;
421 >
422    for( i=0; i<nAtoms; i++ ){
423 <      
423 >
424 >    atoms[i]->getPos(pos);
425 >    atoms[i]->getVel(vel);
426 >
427      sprintf( tempBuffer,
428               "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
429               atoms[i]->getType(),
430 <             atoms[i]->getX(),
431 <             atoms[i]->getY(),
432 <             atoms[i]->getZ(),
433 <             atoms[i]->get_vx(),
434 <             atoms[i]->get_vy(),
435 <             atoms[i]->get_vz());
430 >             pos[0],
431 >             pos[1],
432 >             pos[2],
433 >             vel[0],
434 >             vel[1],
435 >             vel[2]);
436      strcpy( writeLine, tempBuffer );
437  
438      if( atoms[i]->isDirectional() ){
439 <        
439 >
440        dAtom = (DirectionalAtom *)atoms[i];
441        dAtom->getQ( q );
442 <        
442 >
443        sprintf( tempBuffer,
444                 "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
445                 q[0],
# Line 331 | Line 453 | void DumpWriter::writeFinal(){
453      }
454      else
455        strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
456 <      
456 >
457      finalOut << writeLine;
458    }
459    finalOut.flush();
460    finalOut.close();
461  
462   #else // is_mpi
463 <  
464 <  MPI::Status istatus;
463 >
464 >  // first thing first, suspend fatalities.
465 >  painCave.isEventLoop = 1;
466 >
467 >  int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone
468 >  int haveError;
469 >
470 >  MPI_Status istatus;
471    int *AtomToProcMap = mpiSim->getAtomToProcMap();
472  
473    // write out header and node 0's coordinates
474 <  
474 >
475 >  haveError = 0;
476    if( worldRank == 0 ){
477      finalOut << mpiSim->getTotAtoms() << "\n";
478 <    
479 <    finalOut << entry_plug->box_x << "\t"
480 <            << entry_plug->box_y << "\t"
481 <            << entry_plug->box_z << "\n";
482 <    
478 >
479 >    finalOut << finalTime << ";\t"
480 >             << entry_plug->Hmat[0][0] << "\t"
481 >             << entry_plug->Hmat[1][0] << "\t"
482 >             << entry_plug->Hmat[2][0] << ";\t"
483 >
484 >             << entry_plug->Hmat[0][1] << "\t"
485 >             << entry_plug->Hmat[1][1] << "\t"
486 >             << entry_plug->Hmat[2][1] << ";\t"
487 >
488 >             << entry_plug->Hmat[0][2] << "\t"
489 >             << entry_plug->Hmat[1][2] << "\t"
490 >             << entry_plug->Hmat[2][2] << ";";
491 >
492 >    //write out additional parameters, such as chi and eta
493 >    finalOut << entry_plug->the_integrator->getAdditionalParameters();
494 >    finalOut << endl;
495 >
496      for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
497        // Get the Node number which has this molecule:
498 <      
499 <      which_node = AtomToProcMap[i];    
500 <      
498 >
499 >      which_node = AtomToProcMap[i];
500 >
501        if (which_node == mpiSim->getMyNode()) {
502 <        
503 <        sprintf( tempBuffer,
504 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
505 <                 atoms[i]->getType(),
506 <                 atoms[i]->getX(),
365 <                 atoms[i]->getY(),
366 <                 atoms[i]->getZ(),
367 <                 atoms[i]->get_vx(),
368 <                 atoms[i]->get_vy(),
369 <                 atoms[i]->get_vz());
370 <        strcpy( writeLine, tempBuffer );
371 <        
372 <        if( atoms[i]->isDirectional() ){
373 <          
374 <          dAtom = (DirectionalAtom *)atoms[i];
375 <          dAtom->getQ( q );
376 <          
377 <          sprintf( tempBuffer,
378 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
379 <                   q[0],
380 <                   q[1],
381 <                   q[2],
382 <                   q[3],
383 <                   dAtom->getJx(),
384 <                   dAtom->getJy(),
385 <                   dAtom->getJz());
386 <          strcat( writeLine, tempBuffer );
502 >
503 >        which_atom = i;
504 >        local_index=-1;
505 >        for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
506 >          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
507          }
508 <        else
509 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
510 <        
511 <      } else {
512 <        
513 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG);
514 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
515 <                                TAKE_THIS_TAG, istatus);
508 >        if (local_index != -1) {
509 >
510 >          atoms[local_index]->getPos(pos);
511 >          atoms[local_index]->getVel(vel);
512 >
513 >          sprintf( tempBuffer,
514 >                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
515 >                   atoms[local_index]->getType(),
516 >                   pos[0],
517 >                   pos[1],
518 >                   pos[2],
519 >                   vel[0],
520 >                   vel[1],
521 >                   vel[2]);
522 >          strcpy( writeLine, tempBuffer );
523 >
524 >          if( atoms[local_index]->isDirectional() ){
525 >
526 >            dAtom = (DirectionalAtom *)atoms[local_index];
527 >            dAtom->getQ( q );
528 >
529 >            sprintf( tempBuffer,
530 >                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
531 >                     q[0],
532 >                     q[1],
533 >                     q[2],
534 >                     q[3],
535 >                     dAtom->getJx(),
536 >                     dAtom->getJy(),
537 >                     dAtom->getJz());
538 >            strcat( writeLine, tempBuffer );
539 >          }
540 >          else
541 >            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
542 >        }
543 >        else {
544 >          sprintf(painCave.errMsg,
545 >                  "Atom %d not found on processor %d\n",
546 >                  i, worldRank );
547 >          haveError= 1;
548 >          simError();
549 >        }
550 >
551 >        if(haveError) nodeZeroError();
552 >
553        }
554 <      
554 >      else {
555 >
556 >        myStatus = 1;
557 >        MPI_Send(&myStatus, 1, MPI_INT, which_node,
558 >                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
559 >        MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT,
560 >                 MPI_COMM_WORLD);
561 >        MPI_Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
562 >                 TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus);
563 >        MPI_Recv(&myStatus, 1, MPI_INT, which_node,
564 >                 TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
565 >
566 >        if(!myStatus) nodeZeroError();
567 >      }
568 >
569        finalOut << writeLine;
570      }
571 <    
571 >
572      // kill everyone off:
573 <    game_over = -1;
573 >    myStatus = -1;
574      for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
575 <      MPI::COMM_WORLD.Send(&game_over, 1, MPI_INT, j, TAKE_THIS_TAG);
575 >      MPI_Send(&myStatus, 1, MPI_INT, j,
576 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
577      }
578  
579    } else {
580 <    
580 >
581      done = 0;
582      while (!done) {
411 –      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
412 –                           TAKE_THIS_TAG, istatus);
583  
584 <      if (which_atom == -1) {
585 <        done=1;
416 <        continue;
417 <      } else {
584 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
585 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
586  
587 <        local_index=-1;        
420 <        for (j=0; j < mpiSim->getMyNlocal(); j++) {
421 <          if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
422 <        }
423 <        if (local_index != -1) {
587 >      if(!myStatus) anonymousNodeDie();
588  
589 <          //format the line
590 <          sprintf( tempBuffer,
591 <                   "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
592 <                   atoms[local_index]->getType(),
593 <                   atoms[local_index]->getX(),
594 <                   atoms[local_index]->getY(),
595 <                   atoms[local_index]->getZ(),
596 <                   atoms[local_index]->get_vx(),
597 <                   atoms[local_index]->get_vy(),
434 <                   atoms[local_index]->get_vz()); // check here.
435 <          strcpy( writeLine, tempBuffer );
436 <          
437 <          if( atoms[local_index]->isDirectional() ){
438 <            
439 <            dAtom = (DirectionalAtom *)atoms[local_index];
440 <            dAtom->getQ( q );
441 <            
442 <            sprintf( tempBuffer,
443 <                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
444 <                     q[0],
445 <                     q[1],
446 <                     q[2],
447 <                     q[3],
448 <                     dAtom->getJx(),
449 <                     dAtom->getJy(),
450 <                     dAtom->getJz());
451 <            strcat( writeLine, tempBuffer );
452 <          }
453 <          else
454 <            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
455 <          
456 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
457 <                               TAKE_THIS_TAG);
458 <        } else {
459 <          strcpy( writeLine, "ATOM NOT FOUND ON THIS PROCESSOR");
460 <          MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
461 <                               TAKE_THIS_TAG);
462 <        }
589 >      if(myStatus < 0) break;
590 >
591 >      MPI_Recv(&which_atom, 1, MPI_INT, 0,
592 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
593 >
594 >      myStatus = 1;
595 >      local_index=-1;
596 >      for (j=0; j < mpiSim->getMyNlocal(); j++) {
597 >        if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
598        }
599 +      if (local_index != -1) {
600 +
601 +        atoms[local_index]->getPos(pos);
602 +        atoms[local_index]->getVel(vel);
603 +
604 +        //format the line
605 +        sprintf( tempBuffer,
606 +                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
607 +                 atoms[local_index]->getType(),
608 +                 pos[0],
609 +                 pos[1],
610 +                 pos[2],
611 +                 vel[0],
612 +                 vel[1],
613 +                 vel[2]); // check here.
614 +        strcpy( writeLine, tempBuffer );
615 +
616 +        if( atoms[local_index]->isDirectional() ){
617 +
618 +          dAtom = (DirectionalAtom *)atoms[local_index];
619 +          dAtom->getQ( q );
620 +
621 +          sprintf( tempBuffer,
622 +                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
623 +                   q[0],
624 +                   q[1],
625 +                   q[2],
626 +                   q[3],
627 +                   dAtom->getJx(),
628 +                   dAtom->getJy(),
629 +                   dAtom->getJz());
630 +          strcat( writeLine, tempBuffer );
631 +        }
632 +        else{
633 +          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
634 +        }
635 +      }
636 +      else {
637 +        sprintf(painCave.errMsg,
638 +                "Atom %d not found on processor %d\n",
639 +                which_atom, worldRank );
640 +        myStatus = 0;
641 +        simError();
642 +
643 +        strcpy( writeLine, "Hello, I'm an error.\n");
644 +      }
645 +
646 +      MPI_Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
647 +               TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD);
648 +      MPI_Send( &myStatus, 1, MPI_INT, 0,
649 +                TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
650      }
651    }
652    finalOut.flush();
# Line 468 | Line 654 | void DumpWriter::writeFinal(){
654             "Sucessfully took a dump.\n");
655    MPIcheckPoint();
656  
657 <  if( worldRank == 0 ) finalOut.close();    
657 >  if( worldRank == 0 ) finalOut.close();
658   #endif // is_mpi
659   }
660 +
661 +
662 +
663 + #ifdef IS_MPI
664 +
665 + // a couple of functions to let us escape the write loop
666 +
667 + void dWrite::nodeZeroError( void ){
668 +  int j, myStatus;
669 +
670 +  myStatus = 0;
671 +  for (j = 0; j < mpiSim->getNumberProcessors(); j++) {
672 +    MPI_Send( &myStatus, 1, MPI_INT, j,
673 +              TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
674 +  }
675 +
676 +
677 +  MPI_Finalize();
678 +  exit (0);
679 +
680 + }
681 +
682 + void dWrite::anonymousNodeDie( void ){
683 +
684 +  MPI_Finalize();
685 +  exit (0);
686 + }
687 +
688 + #endif //is_mpi

Diff Legend

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