ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/io/RestWriter.cpp
(Generate patch)

Comparing trunk/src/io/RestWriter.cpp (file contents):
Revision 990 by chrisfen, Mon Jun 19 01:36:06 2006 UTC vs.
Revision 1030 by chrisfen, Fri Sep 1 14:15:05 2006 UTC

# Line 38 | Line 38
38   * University of Notre Dame has been advised of the possibility of
39   * such damages.
40   */
41 –
42 – #include <algorithm>
43 – #include <iostream>
44 – #include <map>
41  
46 – #include "primitives/Molecule.hpp"
42   #include "io/RestWriter.hpp"
43 + #include "primitives/Molecule.hpp"
44   #include "utils/simError.h"
45 + #include "io/basic_teebuf.hpp"
46  
47 + #ifdef IS_MPI
48 + #include <mpi.h>
49 + #define TAKE_THIS_TAG_INT 1
50 + #define TAKE_THIS_TAG_REAL 2
51 + #endif //is_mpi
52  
53   namespace oopse {
54    RestWriter::RestWriter(SimInfo* info) :
55 <    info_(info) {
56 <
57 <    // only the master node writes to the disk
55 >    info_(info), outName_(info_->getRestFileName()) {
56 >  }
57 >  
58 >  RestWriter::~RestWriter() {}
59 >  
60 >  void RestWriter::writeZAngFile() {
61 >    std::ostream* zangStream;
62 >    
63   #ifdef IS_MPI
64      if (worldRank == 0) {
65   #endif // is_mpi
66 <
67 <      outName = info_->getRestFileName();
68 <
66 >      
67 >      zangStream = new std::ofstream(outName_.c_str());
68 >      
69   #ifdef IS_MPI
70      }
71 + #endif // is_mpi    
72 +    
73 +    writeZangle(*zangStream);
74 +    
75 + #ifdef IS_MPI
76 +    if (worldRank == 0) {
77   #endif // is_mpi
78 +      delete zangStream;
79 +      
80 + #ifdef IS_MPI
81 +    }
82 + #endif // is_mpi  
83 +    
84    }
85 <  
86 <  RestWriter::~RestWriter() {}
68 <  
69 <  void RestWriter::writeZangle(){
85 >
86 >  void RestWriter::writeZangle(std::ostream& finalOut){
87      const int BUFFERSIZE = 2000;
88      char tempBuffer[BUFFERSIZE];
89      char writeLine[BUFFERSIZE];
90      
74 –    std::ofstream finalOut;
75 –    
91      Molecule* mol;
92      StuntDouble* integrableObject;
93      SimInfo::MoleculeIterator mi;
94      Molecule::IntegrableObjectIterator ii;
80 –
81 – #ifdef IS_MPI
82 –    if(worldRank == 0 ){
83 – #endif    
84 –      finalOut.open( outName.c_str(), std::ios::out | std::ios::trunc );
85 –      if( !finalOut ){
86 –        sprintf( painCave.errMsg,
87 –                 "Could not open \"%s\" for zAngle output.\n",
88 –                 outName.c_str() );
89 –        painCave.isFatal = 1;
90 –        simError();
91 –      }
92 – #ifdef IS_MPI
93 –    }
94 – #endif // is_mpi
95      
96   #ifndef IS_MPI
97      // first we do output for the single processor version
# Line 109 | Line 109 | namespace oopse {
109          sprintf( tempBuffer,
110                   "%14.10lf\n",
111                   integrableObject->getZangle());
112 <        strcpy( writeLine, tempBuffer );
113 <        
114 <        finalOut << writeLine;      
112 >        strcpy( writeLine, tempBuffer );    
113 >        
114 >        finalOut << writeLine;
115 >
116        }
116 –      
117      }
118      
119   #else
120      int nproc;
121      MPI_Comm_size(MPI_COMM_WORLD, &nproc);
122      const int masterNode = 0;
123 –    int myNode = worldRank;
124 –    std::vector<int> tmpNIntObjects(nproc, 0);
125 –    std::vector<int> nIntObjectsInProc(nproc, 0);
126 –    tmpNIntObjects[myNode] = info_->getNGlobalIntegrableObjects();
123      
128 –    //do MPI_ALLREDUCE to exchange the total number of atoms, rigidbodies and cutoff groups
129 –    MPI_Allreduce(&tmpNIntObjects[0], &nIntObjectsInProc[0], nproc, MPI_INT,
130 –                  MPI_SUM, MPI_COMM_WORLD);
131 –    
124      MPI_Status ierr;
125      int intObIndex;
126 +    int vecLength;
127      RealType zAngle;
128 <  
128 >    std::vector<int> gIndex;
129 >    std::vector<RealType> zValues;
130 >
131      if (worldRank == masterNode) {
132        std::map<int, RealType> zAngData;
133        for(int i = 0 ; i < nproc; ++i) {
# Line 144 | Line 139 | namespace oopse {
139                   integrableObject != NULL;
140                   integrableObject = mol->nextIntegrableObject(ii)) {
141                
142 <              intObIndex = integrableObject->getGlobalIndex();
142 >              intObIndex = integrableObject->getGlobalIntegrableObjectIndex();
143  
144                zAngle = integrableObject->getZangle();
145                zAngData.insert(std::pair<int, RealType>(intObIndex, zAngle));
146              }      
147            }
148          } else {
149 <          for (mol = info_->beginMolecule(mi); mol != NULL;
150 <               mol = info_->nextMolecule(mi)) {
151 <            
152 <            for (integrableObject = mol->beginIntegrableObject(ii);
153 <                 integrableObject != NULL;
154 <                 integrableObject = mol->nextIntegrableObject(ii)) {
155 <              
156 <              MPI_Recv(&intObIndex, 1, MPI_INT, i, 0, MPI_COMM_WORLD,&ierr);
157 <              MPI_Recv(&zAngle, 1, MPI_REALTYPE, i, 0, MPI_COMM_WORLD,&ierr);
158 <              zAngData.insert(std::pair<int, RealType>(intObIndex, zAngle));
159 <            }
149 >          MPI_Recv(&vecLength, 1, MPI_INT, i,
150 >                   TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &ierr);
151 >          // make sure the vectors are the right size for the incoming data
152 >          gIndex.resize(vecLength);
153 >          zValues.resize(vecLength);
154 >
155 >          MPI_Recv(&gIndex[0], vecLength, MPI_INT, i,
156 >                   TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &ierr);
157 >          MPI_Recv(&zValues[0], vecLength, MPI_REALTYPE, i,
158 >                   TAKE_THIS_TAG_REAL, MPI_COMM_WORLD, &ierr);
159 >          
160 >          for (int k = 0; k < vecLength; k++){
161 >            zAngData.insert(std::pair<int, RealType>(gIndex[k], zValues[k]));
162            }
163 +          gIndex.clear();
164 +          zValues.clear();
165          }
166        }
167        
168 <      finalOut
169 <        << info_->getSnapshotManager()->getCurrentSnapshot()->getTime()
171 <        << " : omega values at this time\n";
168 >      finalOut << info_->getSnapshotManager()->getCurrentSnapshot()->getTime()
169 >               << " : omega values at this time\n";
170        
171        std::map<int, RealType>::iterator l;
172        for (l = zAngData.begin(); l != zAngData.end(); ++l) {
173 +
174          sprintf( tempBuffer,
175                   "%14.10lf\n",
176                   l->second);
# Line 179 | Line 178 | namespace oopse {
178          
179          finalOut << writeLine;      
180        }
182 –
183 –      finalOut.close();
181        
182      } else {
183 +      // pack up and send the appropriate info to the master node
184        for(int j = 1; j < nproc; ++j) {
185 <        for (mol = info_->beginMolecule(mi); mol != NULL;
186 <             mol = info_->nextMolecule(mi)) {
187 <          
188 <          for (integrableObject = mol->beginIntegrableObject(ii);
189 <               integrableObject != NULL;
190 <               integrableObject = mol->nextIntegrableObject(ii)) {
191 <            intObIndex = integrableObject->getGlobalIndex();            
192 <            zAngle = integrableObject->getZangle();
185 >        if (worldRank == j) {
186 >          for (mol = info_->beginMolecule(mi); mol != NULL;
187 >               mol = info_->nextMolecule(mi)) {
188 >            
189 >            for (integrableObject = mol->beginIntegrableObject(ii);
190 >                 integrableObject != NULL;
191 >                 integrableObject = mol->nextIntegrableObject(ii)) {
192 >              
193 >              // build a vector of the indicies
194 >              intObIndex = integrableObject->getGlobalIntegrableObjectIndex();
195 >              gIndex.push_back(intObIndex);
196 >                    
197 >              // build a vector of the zAngle values
198 >              zAngle = integrableObject->getZangle();
199 >              zValues.push_back(zAngle);
200  
201 <            MPI_Send(&intObIndex, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
197 <            MPI_Send(&zAngle, 1, MPI_REALTYPE, masterNode, 0, MPI_COMM_WORLD);
201 >            }      
202            }
203 +
204 +          // let's send these vectors to the master node so that it
205 +          // can sort them and write to the disk
206 +          vecLength = gIndex.size();
207 +
208 +          MPI_Send(&vecLength, 1, MPI_INT, masterNode,
209 +                   TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
210 +          MPI_Send(&gIndex[0], vecLength, MPI_INT, masterNode,
211 +                   TAKE_THIS_TAG_INT, MPI_COMM_WORLD);
212 +          MPI_Send(&zValues[0], vecLength, MPI_REALTYPE, masterNode,
213 +                   TAKE_THIS_TAG_REAL, MPI_COMM_WORLD);
214 +        
215          }
216        }
217      }

Diff Legend

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