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 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   #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 << 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 <    
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 < 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 <      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 = 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      }
109 –    outFile.flush();
220  
221 < #ifdef IS_MPI
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 +    
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",procIndex);
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 << currentTime << "\t"
333 >          << entry_plug->box_x << "\t"
334 >          << entry_plug->box_y << "\t"
335 >          << entry_plug->box_z << "\n";
336      
337 <    finalOut << 0.0 << "\t"
338 <             << entry_plug->box_x << "\t"
339 <             << entry_plug->box_y << "\t"
340 <             << entry_plug->box_z << "\n";
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 >
350 >    if( atoms[i]->isDirectional() ){
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 << 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 <      finalOut
399 <        << atoms[i]->getType() << "\t"
400 <        << atoms[i]->getX() << "\t"
401 <        << atoms[i]->getY() << "\t"
402 <        << atoms[i]->getZ() << "\t"
403 <        << atoms[i]->get_vx() << "\t"
404 <        << atoms[i]->get_vy() << "\t"
405 <        << atoms[i]->get_vz() << "\t";
406 <      
407 <      if( atoms[i]->isDirectional() ){
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 <        finalOut
429 <          << q[0] << "\t"
430 <          << q[1] << "\t"
431 <          << q[2] << "\t"
432 <          << q[3] << "\t"
433 <          << dAtom->getJx() << "\t"
434 <          << dAtom->getJy() << "\t"
435 <          << dAtom->getJz() << "\n";
428 >      outfile << writeLine;
429 >      masterIndex++;
430 >    }
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 <      else{
460 <        finalOut
461 <          << 0.0 << "\t"
462 <          << 0.0 << "\t"
463 <          << 0.0 << "\t"
464 <          << 0.0 << "\t"
465 <          << 0.0 << "\t"
466 <          << 0.0 << "\t"
467 <          << 0.0 << "\n";
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 <    finalOut.close();
478 <    
479 < #ifdef IS_MPI
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 +
536 +  if( worldRank == 0 ) finalOut.close();
537 +
538 +    
539   #endif // is_mpi
540   }

Diff Legend

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