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 256 by chuckv, Thu Jan 30 20:32:45 2003 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 << 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 < 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 = nodeAtomsStart; i <= nodeAtomsEnd; i++){
212 >          
213 >        mpiErr = MPI_Recv(writeLine,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 +      nodeAtomsStart = mpiSim->getMyAtomStart();
224 +      nodeAtomsEnd = 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 +
286  
287 +  const int BUFFERSIZE = 2000;
288 +  char tempBuffer[500];
289 +  char writeLine[BUFFERSIZE];
290 +  
291    char finalName[500];
92 –  strcpy( finalName, entry_plug->finalName );
292  
94 –  ofstream finalOut( finalName );
95 –  if( !finalOut ){
96 –    sprintf( painCave.errMsg,
97 –             "Could not open \"%s\" for final dump output.\n",
98 –             finalName );
99 –    painCave.isFatal = 1;
100 –    simError();
101 –  }
102 –  
103 – // finalOut.setf( ios::scientific );
104 –    
105 –
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");
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"
333 <          << entry_plug->box_x << "\t"
334 <          << entry_plug->box_y << "\t"
335 <          << entry_plug->box_z << "\n";
119 <
331 >    
332 >  finalOut << entry_plug->box_x << "\t"
333 >           << entry_plug->box_y << "\t"
334 >           << entry_plug->box_z << "\n";
335 >    
336    for( i=0; i<nAtoms; i++ ){
337 +      
338 +    sprintf( tempBuffer,
339 +             "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
340 +             atoms[i]->getType(),
341 +             atoms[i]->getX(),
342 +             atoms[i]->getY(),
343 +             atoms[i]->getZ(),
344 +             atoms[i]->get_vx(),
345 +             atoms[i]->get_vy(),
346 +             atoms[i]->get_vz());
347 +    strcpy( writeLine, tempBuffer );
348  
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 –
349      if( atoms[i]->isDirectional() ){
350 <      
350 >        
351        dAtom = (DirectionalAtom *)atoms[i];
352        dAtom->getQ( q );
353 +        
354 +      sprintf( tempBuffer,
355 +               "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
356 +               q[0],
357 +               q[1],
358 +               q[2],
359 +               q[3],
360 +               dAtom->getJx(),
361 +               dAtom->getJy(),
362 +               dAtom->getJz());
363 +      strcat( writeLine, tempBuffer );
364 +    }
365 +    else
366 +      strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
367        
368 <      finalOut
369 <        << q[0] << "\t"
370 <        << q[1] << "\t"
371 <        << q[2] << "\t"
372 <        << q[3] << "\t"
373 <        << dAtom->getJx() << "\t"
374 <        << dAtom->getJy() << "\t"
375 <        << dAtom->getJz() << "\n";
368 >    finalOut << writeLine;
369 >  }
370 >  finalOut.flush();
371 >
372 > #else // is_mpi
373 >
374 >  int masterIndex;
375 >  int nodeAtomsStart;
376 >  int nodeAtomsEnd;
377 >  int mpiErr;
378 >  int sendError;
379 >  int procIndex;
380 >    
381 >  MPI_Status istatus[MPI_STATUS_SIZE];
382 >
383 >    
384 >  // write out header and node 0's coordinates
385 >
386 >  if( worldRank == 0 ){
387 >    finalOut << mpiSim->getTotAtoms() << "\n";
388 >      
389 >    finalOut << entry_plug->box_x << "\t"
390 >             << entry_plug->box_y << "\t"
391 >             << entry_plug->box_z << "\n";
392 >    
393 >    masterIndex = 0;
394 >    
395 >    std::cerr << "about to write node 0 aztoms. nAtoms = " << nAtoms << "\n";
396 >    
397 >    for( i=0; i<nAtoms; i++ ){
398 >      
399 >      sprintf( tempBuffer,
400 >               "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
401 >               atoms[i]->getType(),
402 >               atoms[i]->getX(),
403 >               atoms[i]->getY(),
404 >               atoms[i]->getZ(),
405 >               atoms[i]->get_vx(),
406 >               atoms[i]->get_vy(),
407 >               atoms[i]->get_vz());
408 >      strcpy( writeLine, tempBuffer );
409 >        
410 >      if( atoms[i]->isDirectional() ){
411 >          
412 >        dAtom = (DirectionalAtom *)atoms[i];
413 >        dAtom->getQ( q );
414 >          
415 >        sprintf( tempBuffer,
416 >                 "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
417 >                 q[0],
418 >                 q[1],
419 >                 q[2],
420 >                 q[3],
421 >                 dAtom->getJx(),
422 >                 dAtom->getJy(),
423 >                 dAtom->getJz());
424 >        strcat( writeLine, tempBuffer );
425 >      }
426 >      else
427 >        strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
428 >        
429 >      finalOut << writeLine;
430 >      masterIndex++;
431      }
432 <    else{
433 <      finalOut
434 <        << 0.0 << "\t"
435 <        << 0.0 << "\t"
436 <        << 0.0 << "\t"
437 <        << 0.0 << "\t"
438 <        << 0.0 << "\t"
439 <        << 0.0 << "\t"
440 <        << 0.0 << "\n";
432 >    finalOut.flush();
433 >  }
434 >    
435 >  for (procIndex = 1; procIndex < mpiSim->getNumberProcessors();
436 >       procIndex++){
437 >
438 >    if( worldRank == 0 ){
439 >        
440 >      mpiErr = MPI_Recv(&nodeAtomsStart,1,MPI_INT,procIndex,
441 >                        MPI_ANY_TAG,MPI_COMM_WORLD,istatus);
442 >
443 >      mpiErr = MPI_Recv(&nodeAtomsEnd,1,MPI_INT,procIndex,
444 >                        MPI_ANY_TAG,MPI_COMM_WORLD, istatus);
445 >        
446 >      // Make sure where node 0 is writing to, matches where the
447 >      // receiving node expects it to be.
448 >        
449 >      if (masterIndex != nodeAtomsStart){
450 >        sendError = 1;
451 >        mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,
452 >                          MPI_COMM_WORLD);
453 >        sprintf(painCave.errMsg,
454 >                "DumpWriter error: atoms start index (%d) for "
455 >                "node %d not equal to master index (%d)",
456 >                nodeAtomsStart,procIndex,masterIndex );
457 >        painCave.isFatal = 1;
458 >        simError();
459 >      }
460 >        
461 >      sendError = 0;
462 >      mpiErr = MPI_Send(&sendError,1,MPI_INT,procIndex,MPI_ANY_TAG,
463 >                        MPI_COMM_WORLD);
464 >
465 >      // recieve the nodes writeLines
466 >
467 >      for ( i = nodeAtomsStart; i <= nodeAtomsEnd; i++){
468 >          
469 >        mpiErr = MPI_Recv(writeLine,BUFFERSIZE,MPI_CHAR,procIndex,
470 >                          MPI_ANY_TAG,MPI_COMM_WORLD,istatus );
471 >
472 >        finalOut << writeLine;
473 >        masterIndex++;
474 >      }
475 >
476 >      finalOut.flush();
477      }
478 +
479 +    else if( worldRank == procIndex ){
480 +
481 +      nodeAtomsStart = mpiSim->getMyAtomStart();
482 +      nodeAtomsEnd = mpiSim->getMyAtomEnd();
483 +        
484 +      mpiErr = MPI_Send(&nodeAtomsStart,1,MPI_INT,0,MPI_ANY_TAG,
485 +                        MPI_COMM_WORLD);
486 +      mpiErr = MPI_Send(&nodeAtomsEnd,1,MPI_INT,0,MPI_ANY_TAG,
487 +                        MPI_COMM_WORLD);
488 +        
489 +      mpiErr = MPI_Recv(&sendError,1,MPI_INT,0,MPI_ANY_TAG,
490 +                        MPI_COMM_WORLD, istatus);
491 +      if (sendError) MPIcheckPoint();
492 +
493 +      // send current node's configuration line by line.
494 +
495 +      for( i=0; i<nAtoms; i++ ){
496 +          
497 +        sprintf( tempBuffer,
498 +                 "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
499 +                 atoms[i]->getType(),
500 +                 atoms[i]->getX(),
501 +                 atoms[i]->getY(),
502 +                 atoms[i]->getZ(),
503 +                 atoms[i]->get_vx(),
504 +                 atoms[i]->get_vy(),
505 +                 atoms[i]->get_vz());
506 +        strcpy( writeLine, tempBuffer );
507 +          
508 +        if( atoms[i]->isDirectional() ){
509 +            
510 +          dAtom = (DirectionalAtom *)atoms[i];
511 +          dAtom->getQ( q );
512 +            
513 +          sprintf( tempBuffer,
514 +                   "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
515 +                   q[0],
516 +                   q[1],
517 +                   q[2],
518 +                   q[3],
519 +                   dAtom->getJx(),
520 +                   dAtom->getJy(),
521 +                   dAtom->getJz());
522 +          strcat( writeLine, tempBuffer );
523 +        }
524 +        else
525 +          strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
526 +          
527 +        mpiErr = MPI_Send(writeLine,BUFFERSIZE,MPI_CHAR,0,MPI_ANY_TAG,
528 +                          MPI_COMM_WORLD);
529 +      }
530 +    }
531 +      
532 +    sprintf(checkPointMsg,"Node %d sent dump configuration.",
533 +            procIndex);
534 +    MPIcheckPoint();
535    }
536 <  finalOut.close();
536 >
537 >  if( worldRank == 0 ) finalOut.close();
538 >
539 >    
540 > #endif // is_mpi
541   }

Diff Legend

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