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 189 by mmeineke, Tue Nov 26 21:04:43 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   #ifdef IS_MPI
# Line 50 | Line 58 | void DumpWriter::writeDump( double currentTime ){
58   }
59  
60   void DumpWriter::writeDump( double currentTime ){
61 +  
62 +  const int BUFFERSIZE = 2000;
63 +  char tempBuffer[500];
64 +  char writeLine[BUFFERSIZE];
65  
66 < #ifdef IS_MPI
67 <  if(worldRank == 0 ){
68 < #endif // is_mpi
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 <
59 <    int i;
60 <    double q[4];
61 <    DirectionalAtom* dAtom;
62 <    int nAtoms = entry_plug->n_atoms;
63 <    Atom** atoms = entry_plug->atoms;
73 > #ifndef IS_MPI
74      
75 +  outFile << nAtoms << "\n";
76      
77 <    outFile << nAtoms << "\n";
77 >  outFile << currentTime << "\t"
78 >          << entry_plug->box_x << "\t"
79 >          << entry_plug->box_y << "\t"
80 >          << entry_plug->box_z << "\n";
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 +
95 +    if( atoms[i]->isDirectional() ){
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 << 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 <    
139 >
140 >    masterIndex = 0;
141      for( i=0; i<nAtoms; i++ ){
142        
143 <      outFile
144 <        << atoms[i]->getType() << "\t"
145 <        << atoms[i]->getX() << "\t"
146 <        << atoms[i]->getY() << "\t"
147 <        << atoms[i]->getZ() << "\t"
148 <        << atoms[i]->get_vx() << "\t"
149 <        << atoms[i]->get_vy() << "\t"
150 <        << atoms[i]->get_vz() << "\t";
151 <      
152 <      if( atoms[i]->isDirectional() ){
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
174 <          << q[0] << "\t"
175 <          << q[1] << "\t"
176 <          << q[2] << "\t"
177 <          << q[3] << "\t"
178 <          << dAtom->getJx() << "\t"
179 <          << dAtom->getJy() << "\t"
180 <          << dAtom->getJz() << "\n";
173 >      outFile << writeLine;
174 >      masterIndex++;
175 >    }
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 <      else{
205 <        outFile
206 <          << 0.0 << "\t"
207 <          << 0.0 << "\t"
208 <          << 0.0 << "\t"
209 <          << 0.0 << "\t"
210 <          << 0.0 << "\t"
211 <          << 0.0 << "\t"
212 <          << 0.0 << "\n";
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      }
109 –    outFile.flush();
220  
221 < #ifdef IS_MPI
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 +    
279   #endif // is_mpi
280   }
281  
# Line 117 | Line 283 | void DumpWriter::writeFinal(){
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];
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 <
124 <    char finalName[500];
304 >    
305      strcpy( finalName, entry_plug->finalName );
306 <
307 <    ofstream finalOut( 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",
# Line 135 | Line 315 | void DumpWriter::writeFinal(){
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 <    int i;
328 <    double q[4];
141 <    DirectionalAtom* dAtom;
142 <    int nAtoms = entry_plug->n_atoms;
143 <    Atom** atoms = entry_plug->atoms;
327 >
328 > #ifndef IS_MPI
329      
330 +  finalOut << nAtoms << "\n";
331      
332 <    finalOut << nAtoms << "\n";
332 >  finalOut << entry_plug->box_x << "\t"
333 >           << entry_plug->box_y << "\t"
334 >           << entry_plug->box_z << "\n";
335      
336 <    finalOut << 0.0 << "\t"
337 <             << entry_plug->box_x << "\t"
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 >
349 >    if( atoms[i]->isDirectional() ){
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 << 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 <      finalOut
400 <        << atoms[i]->getType() << "\t"
401 <        << atoms[i]->getX() << "\t"
402 <        << atoms[i]->getY() << "\t"
403 <        << atoms[i]->getZ() << "\t"
404 <        << atoms[i]->get_vx() << "\t"
405 <        << atoms[i]->get_vy() << "\t"
406 <        << atoms[i]->get_vz() << "\t";
407 <      
408 <      if( atoms[i]->isDirectional() ){
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
430 <          << q[0] << "\t"
431 <          << q[1] << "\t"
432 <          << q[2] << "\t"
433 <          << q[3] << "\t"
434 <          << dAtom->getJx() << "\t"
435 <          << dAtom->getJy() << "\t"
436 <          << dAtom->getJz() << "\n";
429 >      finalOut << writeLine;
430 >      masterIndex++;
431 >    }
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 <      else{
461 <        finalOut
462 <          << 0.0 << "\t"
463 <          << 0.0 << "\t"
464 <          << 0.0 << "\t"
465 <          << 0.0 << "\t"
466 <          << 0.0 << "\t"
467 <          << 0.0 << "\t"
468 <          << 0.0 << "\n";
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 <    finalOut.close();
479 <    
480 < #ifdef IS_MPI
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 +
537 +  if( worldRank == 0 ) finalOut.close();
538 +
539 +    
540   #endif // is_mpi
541   }

Diff Legend

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