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

Comparing trunk/mdtools/md_code/DumpWriter.cpp (file contents):
Revision 162 by mmeineke, Thu Oct 31 21:20:49 2002 UTC vs.
Revision 215 by chuckv, Thu Dec 19 21:59:51 2002 UTC

# Line 2 | Line 2
2   #include <iostream>
3   #include <fstream>
4  
5 + #ifdef IS_MPI
6 + #include <mpi.h>
7 + #include "mpiSimulation.hpp"
8 + #endif //is_mpi
9 +
10   #include "ReadWrite.hpp"
11   #include "simError.h"
12  
13  
14 +
15 +
16 +
17   DumpWriter::DumpWriter( SimInfo* the_entry_plug ){
18  
19 <  entry_plug = the_entry_plug;
20 <  
21 <  strcpy( outName, entry_plug->sampleName );
14 <  outFile.open(outName, ios::out | ios::trunc );
15 <  
16 <  if( !outFile ){
19 > #ifdef IS_MPI
20 >  if(worldRank == 0 ){
21 > #endif // is_mpi
22      
23 <    sprintf( painCave.errMsg,
24 <             "Could not open \"%s\" for dump output.\n",
25 <             outName);
26 <    painCave.isFatal = 1;
27 <    simError();
28 <  }
23 >    entry_plug = the_entry_plug;
24 >    
25 >    strcpy( outName, entry_plug->sampleName );
26 >    
27 >    std::cerr << "Opening " << outName << " for dumping.\n";
28 >
29 >    outFile.open(outName, ios::out | ios::trunc );
30 >    
31 >    if( !outFile ){
32 >      
33 >      sprintf( painCave.errMsg,
34 >               "Could not open \"%s\" for dump output.\n",
35 >               outName);
36 >      painCave.isFatal = 1;
37 >      simError();
38 >    }
39    
40 <  //outFile.setf( ios::scientific );
40 >    //outFile.setf( ios::scientific );
41 >
42 > #ifdef IS_MPI
43 >  }
44 > #endif // is_mpi
45   }
46  
47   DumpWriter::~DumpWriter( ){
48  
49 <  outFile.close();
49 > #ifdef IS_MPI
50 >  if(worldRank == 0 ){
51 > #endif // is_mpi
52 >
53 >    outFile.close();
54 >
55 > #ifdef IS_MPI
56 >  }
57 > #endif // is_mpi
58   }
59  
60   void DumpWriter::writeDump( double currentTime ){
61 +  
62 +  const int BUFFERSIZE = 2000;
63 +  char tempBuffer[500];
64 +  char writeLine[BUFFERSIZE];
65  
66    int i;
67    double q[4];
68    DirectionalAtom* dAtom;
69    int nAtoms = entry_plug->n_atoms;
70    Atom** atoms = entry_plug->atoms;
71 +    
72  
73 <
73 > #ifndef IS_MPI
74 >    
75    outFile << nAtoms << "\n";
76 <  
76 >    
77    outFile << currentTime << "\t"
78            << entry_plug->box_x << "\t"
79            << entry_plug->box_y << "\t"
80            << entry_plug->box_z << "\n";
81 <
81 >    
82    for( i=0; i<nAtoms; i++ ){
83 +      
84 +    sprintf( tempBuffer,
85 +             "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
86 +             atoms[i]->getType(),
87 +             atoms[i]->getX(),
88 +             atoms[i]->getY(),
89 +             atoms[i]->getZ(),
90 +             atoms[i]->get_vx(),
91 +             atoms[i]->get_vy(),
92 +             atoms[i]->get_vz());
93 +    strcpy( writeLine, tempBuffer );
94  
51 –    outFile
52 –      << atoms[i]->getType() << "\t"
53 –      << atoms[i]->getX() << "\t"
54 –      << atoms[i]->getY() << "\t"
55 –      << atoms[i]->getZ() << "\t"
56 –      << atoms[i]->get_vx() << "\t"
57 –      << atoms[i]->get_vy() << "\t"
58 –      << atoms[i]->get_vz() << "\t";
59 –
95      if( atoms[i]->isDirectional() ){
96 <      
96 >        
97        dAtom = (DirectionalAtom *)atoms[i];
98        dAtom->getQ( q );
99 +        
100 +      sprintf( tempBuffer,
101 +               "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
102 +               q[0],
103 +               q[1],
104 +               q[2],
105 +               q[3],
106 +               dAtom->getJx(),
107 +               dAtom->getJy(),
108 +               dAtom->getJz());
109 +      strcat( writeLine, tempBuffer );
110 +    }
111 +    else
112 +      strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
113        
114 <      outFile
115 <        << q[0] << "\t"
116 <        << q[1] << "\t"
117 <        << q[2] << "\t"
118 <        << q[3] << "\t"
119 <        << dAtom->getJx() << "\t"
120 <        << dAtom->getJy() << "\t"
121 <        << dAtom->getJz() << "\n";
114 >    outFile << writeLine;
115 >  }
116 >  outFile.flush();
117 >
118 > #else // is_mpi
119 >
120 >  int masterIndex;
121 >  int nodeAtomsStart;
122 >  int nodeAtomsEnd;
123 >  int mpiErr;
124 >  int sendError;
125 >  int procIndex;
126 >    
127 >  MPI_Status istatus[MPI_STATUS_SIZE];
128 >
129 >    
130 >  // write out header and node 0's coordinates
131 >
132 >  if( worldRank == 0 ){
133 >    outFile << entry_plug->mpiSim->getTotAtoms() << "\n";
134 >      
135 >    outFile << currentTime << "\t"
136 >            << entry_plug->box_x << "\t"
137 >            << entry_plug->box_y << "\t"
138 >            << entry_plug->box_z << "\n";
139 >
140 >    masterIndex = 0;
141 >    for( i=0; i<nAtoms; i++ ){
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 >      outfile << writeLine;
174 >      masterIndex++;
175      }
176 <    else{
177 <      outFile
178 <        << 0.0 << "\t"
179 <        << 0.0 << "\t"
180 <        << 0.0 << "\t"
181 <        << 0.0 << "\t"
182 <        << 0.0 << "\t"
183 <        << 0.0 << "\t"
184 <        << 0.0 << "\n";
176 >    outFile.flush();
177 >  }
178 >    
179 >  for (procIndex = 1; procIndex < entry_plug->mpiSim->getNumberProcessors();
180 >       procIndex++){
181 >
182 >    if( worldRank == 0 ){
183 >        
184 >      mpiErr = MPI_Recv(&nodeAtomsStart,1,MPI_INT,procIndex,
185 >                        MPI_ANY_TAG,MPI_COMM_WORLD,istatus);
186 >
187 >      mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,
188 >                        MPI_ANY_TAG,MPI_COMM_WORLD, istatus);
189 >        
190 >      // Make sure where node 0 is writing to, matches where the
191 >      // receiving node expects it to be.
192 >        
193 >      if (masterIndex != nodeAtomsStart){
194 >        sendError = 1;
195 >        mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,
196 >                          MPI_COMM_WORLD);
197 >        sprintf(painCave.errMsg,
198 >                "DumpWriter error: atoms start index (%d) for "
199 >                "node %d not equal to master index (%d)",
200 >                nodeAtomsStart,procIndex,masterIndex );
201 >        painCave.isFatal = 1;
202 >        simError();
203 >      }
204 >        
205 >      sendError = 0;
206 >      mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,
207 >                        MPI_COMM_WORLD);
208 >
209 >      // recieve the nodes writeLines
210 >
211 >      for ( i = nodeAtomStart; i <= nodeAtomEnd, i++){
212 >          
213 >        mpiErr = MPI_Recv(&read_buffer,BUFFERSIZE,MPI_CHAR,procIndex,
214 >                          MPI_ANY_TAG,MPI_COMM_WORLD,istatus );
215 >
216 >        outFile << writeLine;
217 >        masterIndex++;
218 >      }
219      }
220 +
221 +    else if( worldRank == procIndex ){
222 +
223 +      nodeAtomStart = entry_plug->mpiSim->getMyAtomStart();
224 +      nodeAtomEnd = entry_plug->mpiSim->getMyAtomEnd();
225 +        
226 +      mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,MPI_ANY_TAG,
227 +                        MPI_COMM_WORLD);
228 +      mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,MPI_ANY_TAG,
229 +                        MPI_COMM_WORLD);
230 +        
231 +      mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,MPI_ANY_TAG,
232 +                        MPI_COMM_WORLD, istatus);
233 +      if (sendError) mpiCheckpoint();
234 +
235 +      // send current node's configuration line by line.
236 +
237 +      for( i=0; i<nAtoms; i++ ){
238 +          
239 +        sprintf( tempBuffer,
240 +                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
241 +                 atoms[i]->getType(),
242 +                 atoms[i]->getX(),
243 +                 atoms[i]->getY(),
244 +                 atoms[i]->getZ(),
245 +                 atoms[i]->get_vx(),
246 +                 atoms[i]->get_vy(),
247 +                 atoms[i]->get_vz());
248 +        strcpy( writeLine, tempBuffer );
249 +          
250 +        if( atoms[i]->isDirectional() ){
251 +            
252 +          dAtom = (DirectionalAtom *)atoms[i];
253 +          dAtom->getQ( q );
254 +            
255 +          sprintf( tempBuffer,
256 +                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
257 +                   q[0],
258 +                   q[1],
259 +                   q[2],
260 +                   q[3],
261 +                   dAtom->getJx(),
262 +                   dAtom->getJy(),
263 +                   dAtom->getJz());
264 +          strcat( writeLine, tempBuffer );
265 +        }
266 +        else
267 +          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
268 +          
269 +        mpiErr = MPI_Send(writeLine,BUFFERSIZE,MPI_CHAR,0,MPI_ANY_TAG,
270 +                          MPI_COMM_WORLD);
271 +      }
272 +    }
273 +      
274 +    sprintf(checkPointMsg,"Node %d sent dump configuration.",
275 +            procIndex);
276 +    mpiCheckPoint();
277    }
278 <  outFile.flush();
278 >    
279 > #endif // is_mpi
280   }
281  
282  
283 +
284   void DumpWriter::writeFinal(){
285  
91 –  char finalName[500];
92 –  strcpy( finalName, entry_plug->finalName );
286  
287 <  ofstream finalOut( finalName );
288 <  if( !finalOut ){
289 <    sprintf( painCave.errMsg,
97 <             "Could not open \"%s\" for final dump output.\n",
98 <             finalName );
99 <    painCave.isFatal = 1;
100 <    simError();
101 <  }
287 >  const int BUFFERSIZE = 2000;
288 >  char tempBuffer[500];
289 >  char writeLine[BUFFERSIZE];
290    
291 < // finalOut.setf( ios::scientific );
104 <    
291 >  char finalName[500];
292  
293    int i;
294    double q[4];
295    DirectionalAtom* dAtom;
296    int nAtoms = entry_plug->n_atoms;
297    Atom** atoms = entry_plug->atoms;
298 +  
299 +  ofstream finalOut;
300 +  
301 + #ifdef IS_MPI
302 +  if(worldRank == 0 ){
303 + #endif // is_mpi
304 +    
305 +    strcpy( finalName, entry_plug->finalName );
306 +    
307 +    finalOut.open( finalName, ios::out | ios::trunc );
308 +    if( !finalOut ){
309 +      sprintf( painCave.errMsg,
310 +               "Could not open \"%s\" for final dump output.\n",
311 +               finalName );
312 +      painCave.isFatal = 1;
313 +      simError();
314 +    }
315 +    
316 +    // finalOut.setf( ios::scientific );
317 +    
318 + #ifdef IS_MPI
319 +  }
320 +  
321 +  sprintf(checkPointMsg,"Opened file for final configuration\n",procIndex);
322 +  mpiCheckPoint();  
323 +  
324 + #endif //is_mpi
325  
326 +    
327  
328 + #ifndef IS_MPI
329 +    
330    finalOut << nAtoms << "\n";
331 <  
332 <  finalOut << 0.0 << "\t"
331 >    
332 >  finalOut << currentTime << "\t"
333            << entry_plug->box_x << "\t"
334            << entry_plug->box_y << "\t"
335            << entry_plug->box_z << "\n";
336 <
336 >    
337    for( i=0; i<nAtoms; i++ ){
338 +      
339 +    sprintf( tempBuffer,
340 +             "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
341 +             atoms[i]->getType(),
342 +             atoms[i]->getX(),
343 +             atoms[i]->getY(),
344 +             atoms[i]->getZ(),
345 +             atoms[i]->get_vx(),
346 +             atoms[i]->get_vy(),
347 +             atoms[i]->get_vz());
348 +    strcpy( writeLine, tempBuffer );
349  
122 –    finalOut
123 –      << atoms[i]->getType() << "\t"
124 –      << atoms[i]->getX() << "\t"
125 –      << atoms[i]->getY() << "\t"
126 –      << atoms[i]->getZ() << "\t"
127 –      << atoms[i]->get_vx() << "\t"
128 –      << atoms[i]->get_vy() << "\t"
129 –      << atoms[i]->get_vz() << "\t";
130 –
350      if( atoms[i]->isDirectional() ){
351 <      
351 >        
352        dAtom = (DirectionalAtom *)atoms[i];
353        dAtom->getQ( q );
354 +        
355 +      sprintf( tempBuffer,
356 +               "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
357 +               q[0],
358 +               q[1],
359 +               q[2],
360 +               q[3],
361 +               dAtom->getJx(),
362 +               dAtom->getJy(),
363 +               dAtom->getJz());
364 +      strcat( writeLine, tempBuffer );
365 +    }
366 +    else
367 +      strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
368        
369 <      finalOut
370 <        << q[0] << "\t"
371 <        << q[1] << "\t"
372 <        << q[2] << "\t"
373 <        << q[3] << "\t"
374 <        << dAtom->getJx() << "\t"
375 <        << dAtom->getJy() << "\t"
376 <        << dAtom->getJz() << "\n";
369 >    finalOut << writeLine;
370 >  }
371 >  finalOut.flush();
372 >
373 > #else // is_mpi
374 >
375 >  int masterIndex;
376 >  int nodeAtomsStart;
377 >  int nodeAtomsEnd;
378 >  int mpiErr;
379 >  int sendError;
380 >  int procIndex;
381 >    
382 >  MPI_Status istatus[MPI_STATUS_SIZE];
383 >
384 >    
385 >  // write out header and node 0's coordinates
386 >
387 >  if( worldRank == 0 ){
388 >    finalOut << entry_plug->mpiSim->getTotAtoms() << "\n";
389 >      
390 >    finalOut << currentTime << "\t"
391 >            << entry_plug->box_x << "\t"
392 >            << entry_plug->box_y << "\t"
393 >            << entry_plug->box_z << "\n";
394 >
395 >    masterIndex = 0;
396 >    for( i=0; i<nAtoms; i++ ){
397 >      
398 >      sprintf( tempBuffer,
399 >               "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
400 >               atoms[i]->getType(),
401 >               atoms[i]->getX(),
402 >               atoms[i]->getY(),
403 >               atoms[i]->getZ(),
404 >               atoms[i]->get_vx(),
405 >               atoms[i]->get_vy(),
406 >               atoms[i]->get_vz());
407 >      strcpy( writeLine, tempBuffer );
408 >        
409 >      if( atoms[i]->isDirectional() ){
410 >          
411 >        dAtom = (DirectionalAtom *)atoms[i];
412 >        dAtom->getQ( q );
413 >          
414 >        sprintf( tempBuffer,
415 >                 "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
416 >                 q[0],
417 >                 q[1],
418 >                 q[2],
419 >                 q[3],
420 >                 dAtom->getJx(),
421 >                 dAtom->getJy(),
422 >                 dAtom->getJz());
423 >        strcat( writeLine, tempBuffer );
424 >      }
425 >      else
426 >        strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
427 >        
428 >      outfile << writeLine;
429 >      masterIndex++;
430      }
431 <    else{
432 <      finalOut
433 <        << 0.0 << "\t"
434 <        << 0.0 << "\t"
435 <        << 0.0 << "\t"
436 <        << 0.0 << "\t"
437 <        << 0.0 << "\t"
438 <        << 0.0 << "\t"
439 <        << 0.0 << "\n";
431 >    finalOut.flush();
432 >  }
433 >    
434 >  for (procIndex = 1; procIndex < entry_plug->mpiSim->getNumberProcessors();
435 >       procIndex++){
436 >
437 >    if( worldRank == 0 ){
438 >        
439 >      mpiErr = MPI_Recv(&nodeAtomsStart,1,MPI_INT,procIndex,
440 >                        MPI_ANY_TAG,MPI_COMM_WORLD,istatus);
441 >
442 >      mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,
443 >                        MPI_ANY_TAG,MPI_COMM_WORLD, istatus);
444 >        
445 >      // Make sure where node 0 is writing to, matches where the
446 >      // receiving node expects it to be.
447 >        
448 >      if (masterIndex != nodeAtomsStart){
449 >        sendError = 1;
450 >        mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,
451 >                          MPI_COMM_WORLD);
452 >        sprintf(painCave.errMsg,
453 >                "DumpWriter error: atoms start index (%d) for "
454 >                "node %d not equal to master index (%d)",
455 >                nodeAtomsStart,procIndex,masterIndex );
456 >        painCave.isFatal = 1;
457 >        simError();
458 >      }
459 >        
460 >      sendError = 0;
461 >      mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,
462 >                        MPI_COMM_WORLD);
463 >
464 >      // recieve the nodes writeLines
465 >
466 >      for ( i = nodeAtomStart; i <= nodeAtomEnd, i++){
467 >          
468 >        mpiErr = MPI_Recv(&read_buffer,BUFFERSIZE,MPI_CHAR,procIndex,
469 >                          MPI_ANY_TAG,MPI_COMM_WORLD,istatus );
470 >
471 >        finalOut << writeLine;
472 >        masterIndex++;
473 >      }
474 >
475 >      finalOut.flush();
476      }
477 +
478 +    else if( worldRank == procIndex ){
479 +
480 +      nodeAtomStart = entry_plug->mpiSim->getMyAtomStart();
481 +      nodeAtomEnd = entry_plug->mpiSim->getMyAtomEnd();
482 +        
483 +      mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,MPI_ANY_TAG,
484 +                        MPI_COMM_WORLD);
485 +      mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,MPI_ANY_TAG,
486 +                        MPI_COMM_WORLD);
487 +        
488 +      mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,MPI_ANY_TAG,
489 +                        MPI_COMM_WORLD, istatus);
490 +      if (sendError) mpiCheckpoint();
491 +
492 +      // send current node's configuration line by line.
493 +
494 +      for( i=0; i<nAtoms; i++ ){
495 +          
496 +        sprintf( tempBuffer,
497 +                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
498 +                 atoms[i]->getType(),
499 +                 atoms[i]->getX(),
500 +                 atoms[i]->getY(),
501 +                 atoms[i]->getZ(),
502 +                 atoms[i]->get_vx(),
503 +                 atoms[i]->get_vy(),
504 +                 atoms[i]->get_vz());
505 +        strcpy( writeLine, tempBuffer );
506 +          
507 +        if( atoms[i]->isDirectional() ){
508 +            
509 +          dAtom = (DirectionalAtom *)atoms[i];
510 +          dAtom->getQ( q );
511 +            
512 +          sprintf( tempBuffer,
513 +                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
514 +                   q[0],
515 +                   q[1],
516 +                   q[2],
517 +                   q[3],
518 +                   dAtom->getJx(),
519 +                   dAtom->getJy(),
520 +                   dAtom->getJz());
521 +          strcat( writeLine, tempBuffer );
522 +        }
523 +        else
524 +          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
525 +          
526 +        mpiErr = MPI_Send(writeLine,BUFFERSIZE,MPI_CHAR,0,MPI_ANY_TAG,
527 +                          MPI_COMM_WORLD);
528 +      }
529 +    }
530 +      
531 +    sprintf(checkPointMsg,"Node %d sent dump configuration.",
532 +            procIndex);
533 +    mpiCheckPoint();
534    }
535 <  finalOut.close();
535 >
536 >  if( worldRank == 0 ) finalOut.close();
537 >
538 >    
539 > #endif // is_mpi
540   }

Diff Legend

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