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 416 by gezelter, Wed Mar 26 23:14:02 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;
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 molecule:
185 <      
186 <      which_node = AtomToProcMap[i];    
187 <      
188 <      if (which_node == mpiSim->getMyNode()) {
189 <        
190 <        sprintf( tempBuffer,
191 <                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
192 <                 atoms[i]->getType(),
193 <                 atoms[i]->getX(),
194 <                 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 );
184 >      // Get the Node number which has this atom;
185 >
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 <        else
197 <          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );      
198 <        
199 <      } else {
200 <        
201 <        MPI::COMM_WORLD.Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG);
202 <        MPI::COMM_WORLD.Recv(writeLine, BUFFERSIZE, MPI_CHAR, which_node,
203 <                                TAKE_THIS_TAG, istatus);
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 >                   pos[0],
206 >                   pos[1],
207 >                   pos[2],
208 >                   vel[0],
209 >                   vel[1],
210 >                   vel[2]); // check here.
211 >          strcpy( writeLine, tempBuffer );
212 >
213 >          if( atoms[local_index]->isDirectional() ){
214 >
215 >            dAtom = (DirectionalAtom *)atoms[local_index];
216 >            dAtom->getQ( q );
217 >
218 >            sprintf( tempBuffer,
219 >                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
220 >                     q[0],
221 >                     q[1],
222 >                     q[2],
223 >                     q[3],
224 >                     dAtom->getJx(),
225 >                     dAtom->getJy(),
226 >                     dAtom->getJz());
227 >            strcat( writeLine, tempBuffer );
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 <      
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 <    game_over = -1;
265 <    for (j = 0; j < mpiSim->getNumberProcessors(); j++) {      
266 <      MPI::COMM_WORLD.Send(&game_over, 1, MPI_INT, j, TAKE_THIS_TAG);
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 <    
271 >
272      done = 0;
273      while (!done) {
193 –      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
194 –                              TAKE_THIS_TAG, istatus);
274  
275 <      if (which_atom == -1) {
276 <        done=1;
198 <        continue;
199 <      } else {
275 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
276 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
277  
278 <        //format the line
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[which_atom]->getType(),
299 <                 atoms[which_atom]->getX(),
300 <                 atoms[which_atom]->getY(),
301 <                 atoms[which_atom]->getZ(),
302 <                 atoms[which_atom]->get_vx(),
303 <                 atoms[which_atom]->get_vy(),
304 <                 atoms[which_atom]->get_vz()); // check here.
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[which_atom]->isDirectional() ){
308 <            
309 <          dAtom = (DirectionalAtom *)atoms[which_atom];
306 >
307 >        if( atoms[local_index]->isDirectional() ){
308 >
309 >          dAtom = (DirectionalAtom *)atoms[local_index];
310            dAtom->getQ( q );
311 <            
311 >
312            sprintf( tempBuffer,
313                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
314                     q[0],
# Line 226 | Line 320 | void DumpWriter::writeDump( double currentTime ){
320                     dAtom->getJz());
321            strcat( writeLine, tempBuffer );
322          }
323 <        else
323 >        else{
324            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
325 <        
232 <        MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
233 <                             TAKE_THIS_TAG);
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 <  }  
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;
255 –  int nAtoms = entry_plug->n_atoms;
365    Atom** atoms = entry_plug->atoms;
366 <  int i, j, which_node, done, game_over, which_atom;
258 <  
259 <  
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 271 | 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 322 | 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(),
356 <                 atoms[i]->getY(),
357 <                 atoms[i]->getZ(),
358 <                 atoms[i]->get_vx(),
359 <                 atoms[i]->get_vy(),
360 <                 atoms[i]->get_vz());
361 <        strcpy( writeLine, tempBuffer );
362 <        
363 <        if( atoms[i]->isDirectional() ){
364 <          
365 <          dAtom = (DirectionalAtom *)atoms[i];
366 <          dAtom->getQ( q );
367 <          
368 <          sprintf( tempBuffer,
369 <                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
370 <                   q[0],
371 <                   q[1],
372 <                   q[2],
373 <                   q[3],
374 <                   dAtom->getJx(),
375 <                   dAtom->getJy(),
376 <                   dAtom->getJz());
377 <          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) {
402 –      MPI::COMM_WORLD.Recv(&which_atom, 1, MPI_INT, 0,
403 –                           TAKE_THIS_TAG, istatus);
583  
584 <      if (which_atom == -1) {
585 <        done=1;
407 <        continue;
408 <      } else {
584 >      MPI_Recv(&myStatus, 1, MPI_INT, 0,
585 >               TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus);
586  
587 <        //format the line
587 >      if(!myStatus) anonymousNodeDie();
588 >
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[which_atom]->getType(),
608 <                 atoms[which_atom]->getX(),
609 <                 atoms[which_atom]->getY(),
610 <                 atoms[which_atom]->getZ(),
611 <                 atoms[which_atom]->get_vx(),
612 <                 atoms[which_atom]->get_vy(),
613 <                 atoms[which_atom]->get_vz()); // check here.
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[which_atom]->isDirectional() ){
617 <            
618 <          dAtom = (DirectionalAtom *)atoms[which_atom];
615 >
616 >        if( atoms[local_index]->isDirectional() ){
617 >
618 >          dAtom = (DirectionalAtom *)atoms[local_index];
619            dAtom->getQ( q );
620 <            
620 >
621            sprintf( tempBuffer,
622                     "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
623                     q[0],
# Line 435 | Line 629 | void DumpWriter::writeFinal(){
629                     dAtom->getJz());
630            strcat( writeLine, tempBuffer );
631          }
632 <        else
632 >        else{
633            strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
634 <        
441 <        MPI::COMM_WORLD.Send(writeLine, BUFFERSIZE, MPI_CHAR, 0,
442 <                             TAKE_THIS_TAG);
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 <  }  
651 >  }
652    finalOut.flush();
653    sprintf( checkPointMsg,
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