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

Comparing trunk/src/io/RestWriter.cpp (file contents):
Revision 1030 by chrisfen, Fri Sep 1 14:15:05 2006 UTC vs.
Revision 1407 by cli2, Wed Jan 20 16:04:40 2010 UTC

# Line 1 | Line 1
1   /*
2 < * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
2 > * Copyright (c) 2009 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
5   * non-exclusive, royalty free, license to use, modify and
6   * redistribute this software in source and binary code form, provided
7   * that the following conditions are met:
8   *
9 < * 1. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
12 > * 2. Redistributions in binary form must reproduce the above copyright
13   *    notice, this list of conditions and the following disclaimer in the
14   *    documentation and/or other materials provided with the
15   *    distribution.
# Line 37 | Line 28
28   * arising out of the use of or inability to use software, even if the
29   * University of Notre Dame has been advised of the possibility of
30   * such damages.
31 + *
32 + * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 + * research, please cite the appropriate papers when you publish your
34 + * work.  Good starting points are:
35 + *                                                                      
36 + * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 + * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 + * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 + * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41  
42 +
43 + #include <string>
44 + #include <sstream>
45 + #include <iostream>
46 +
47   #include "io/RestWriter.hpp"
43 – #include "primitives/Molecule.hpp"
48   #include "utils/simError.h"
49 < #include "io/basic_teebuf.hpp"
46 <
49 > #include "brains/SnapshotManager.hpp"
50   #ifdef IS_MPI
51   #include <mpi.h>
52 < #define TAKE_THIS_TAG_INT 1
50 < #define TAKE_THIS_TAG_REAL 2
51 < #endif //is_mpi
52 > #endif
53  
54 < namespace oopse {
55 <  RestWriter::RestWriter(SimInfo* info) :
56 <    info_(info), outName_(info_->getRestFileName()) {
57 <  }
58 <  
58 <  RestWriter::~RestWriter() {}
59 <  
60 <  void RestWriter::writeZAngFile() {
61 <    std::ostream* zangStream;
54 > namespace OpenMD {
55 >  RestWriter::RestWriter(SimInfo* info, const std::string& filename,
56 >                         std::vector<Restraint*> restraints ) :
57 >    info_(info){
58 >    createRestFile_ = true;
59      
60   #ifdef IS_MPI
61 <    if (worldRank == 0) {
62 < #endif // is_mpi
63 <      
64 <      zangStream = new std::ofstream(outName_.c_str());
65 <      
61 >    if(worldRank == 0){
62 > #endif
63 >  
64 >      output_ = new std::ofstream(filename.c_str());
65 >
66 >      if(!output_){
67 >        sprintf( painCave.errMsg,
68 >                 "Could not open %s for restraint output.\n",
69 >                 filename.c_str());
70 >        painCave.isFatal = 1;
71 >        simError();
72 >      }
73 >
74   #ifdef IS_MPI
75      }
71 – #endif // is_mpi    
72 –    
73 –    writeZangle(*zangStream);
74 –    
75 – #ifdef IS_MPI
76 –    if (worldRank == 0) {
76   #endif // is_mpi
77 <      delete zangStream;
78 <      
77 >
78 >
79   #ifdef IS_MPI
80 <    }
81 < #endif // is_mpi  
80 >    MPI_Status istatus;
81 > #endif
82      
83 <  }
83 > #ifndef IS_MPI
84 >        
85 >    (*output_) << "#time\t";
86  
87 <  void RestWriter::writeZangle(std::ostream& finalOut){
88 <    const int BUFFERSIZE = 2000;
89 <    char tempBuffer[BUFFERSIZE];
90 <    char writeLine[BUFFERSIZE];
87 >    std::vector<Restraint*>::const_iterator resti;
88 >
89 >    for(resti=restraints.begin(); resti != restraints.end(); ++resti){
90 >      if ((*resti)->getPrintRestraint()) {
91 >        
92 >        std::string myName = (*resti)->getRestraintName();
93 >        int myType = (*resti)->getRestraintType();
94 >        
95 >        (*output_) << myName << ":";
96 >        
97 >        if (myType & Restraint::rtDisplacement)
98 >          (*output_) << "\tPosition(angstroms)\tEnergy(kcal/mol)";
99 >        
100 >        if (myType & Restraint::rtTwist)
101 >          (*output_) << "\tTwistAngle(radians)\tEnergy(kcal/mol)";
102 >        
103 >        if (myType & Restraint::rtSwingX)
104 >          (*output_) << "\tSwingXAngle(radians)\tEnergy(kcal/mol)";
105 >          
106 >        if (myType & Restraint::rtSwingY)
107 >          (*output_) << "\tSwingYAngle(radians)\tEnergy(kcal/mol)";
108 >      }
109 >    }
110 >
111 >    (*output_) << "\n";
112 >    (*output_).flush();
113      
114 <    Molecule* mol;
92 <    StuntDouble* integrableObject;
93 <    SimInfo::MoleculeIterator mi;
94 <    Molecule::IntegrableObjectIterator ii;
114 > #else
115      
116 < #ifndef IS_MPI
117 <    // first we do output for the single processor version
118 <    finalOut
119 <      << info_->getSnapshotManager()->getCurrentSnapshot()->getTime()
120 <      << " : omega values at this time\n";
121 <    
102 <    for (mol = info_->beginMolecule(mi); mol != NULL;
103 <         mol = info_->nextMolecule(mi)) {
104 <      
105 <      for (integrableObject = mol->beginIntegrableObject(ii);
106 <           integrableObject != NULL;
107 <           integrableObject = mol->nextIntegrableObject(ii)) {    
116 >    std::string buffer;
117 >
118 >    std::vector<Restraint*>::const_iterator resti;
119 >
120 >    for(resti=restraints.begin(); resti != restraints.end(); ++resti){
121 >      if ((*resti)->getPrintRestraint()) {
122          
123 <        sprintf( tempBuffer,
124 <                 "%14.10lf\n",
111 <                 integrableObject->getZangle());
112 <        strcpy( writeLine, tempBuffer );    
113 <        
114 <        finalOut << writeLine;
123 >        std::string myName = (*resti)->getRestraintName();
124 >        int myType = (*resti)->getRestraintType();
125  
126 +        buffer += (myName + ":");
127 +        
128 +        if (myType & Restraint::rtDisplacement)
129 +          buffer += "\tPosition(angstroms)\tEnergy(kcal/mol)";
130 +        
131 +        if (myType & Restraint::rtTwist)
132 +          buffer += "\tTwistAngle(radians)\tEnergy(kcal/mol)";
133 +        
134 +        if (myType & Restraint::rtSwingX)
135 +          buffer += "\tSwingXAngle(radians)\tEnergy(kcal/mol)";
136 +        
137 +        if (myType & Restraint::rtSwingY)
138 +          buffer += "\tSwingYAngle(radians)\tEnergy(kcal/mol)";
139 +        
140 +        buffer += "\n";
141        }
142      }
143      
119 – #else
120 –    int nproc;
121 –    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
144      const int masterNode = 0;
145      
124 –    MPI_Status ierr;
125 –    int intObIndex;
126 –    int vecLength;
127 –    RealType zAngle;
128 –    std::vector<int> gIndex;
129 –    std::vector<RealType> zValues;
130 –
146      if (worldRank == masterNode) {
147 <      std::map<int, RealType> zAngData;
148 <      for(int i = 0 ; i < nproc; ++i) {
149 <        if (i == masterNode) {
150 <          for (mol = info_->beginMolecule(mi); mol != NULL;
151 <               mol = info_->nextMolecule(mi)) {
152 <            
153 <            for (integrableObject = mol->beginIntegrableObject(ii);
154 <                 integrableObject != NULL;
155 <                 integrableObject = mol->nextIntegrableObject(ii)) {
156 <              
157 <              intObIndex = integrableObject->getGlobalIntegrableObjectIndex();
158 <
159 <              zAngle = integrableObject->getZangle();
160 <              zAngData.insert(std::pair<int, RealType>(intObIndex, zAngle));
146 <            }      
147 <          }
147 >      (*output_) << "#time\t";
148 >      (*output_) << buffer;
149 >      
150 >      int nProc;
151 >      MPI_Comm_size(MPI_COMM_WORLD, &nProc);
152 >      for (int i = 1; i < nProc; ++i) {
153 >        
154 >        // receive the length of the string buffer that was
155 >        // prepared by processor i
156 >        
157 >        int recvLength;
158 >        MPI_Recv(&recvLength, 1, MPI_INT, i, 0, MPI_COMM_WORLD, &istatus);
159 >        char* recvBuffer = new char[recvLength];
160 >        if (recvBuffer == NULL) {
161          } else {
162 <          MPI_Recv(&vecLength, 1, MPI_INT, i,
163 <                   TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &ierr);
164 <          // make sure the vectors are the right size for the incoming data
165 <          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();
162 >          MPI_Recv(recvBuffer, recvLength, MPI_CHAR, i, 0, MPI_COMM_WORLD,
163 >                   &istatus);
164 >          (*output_) << recvBuffer;
165 >          delete [] recvBuffer;
166          }
167 +      }
168 +      (*output_).flush();
169 +    } else {
170 +      int sendBufferLength = buffer.size() + 1;
171 +      MPI_Send(&sendBufferLength, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
172 +      MPI_Send((void *)buffer.c_str(), sendBufferLength, MPI_CHAR, masterNode,
173 +               0, MPI_COMM_WORLD);
174 +    }
175 +    
176 + #endif // is_mpi    
177 +    
178 +  }    
179 +  
180 +  void RestWriter::writeRest(std::vector<std::map<int, Restraint::RealPair> > restInfo) {
181 +    
182 + #ifdef IS_MPI
183 +    MPI_Status istatus;
184 + #endif
185 +    
186 + #ifndef IS_MPI
187 +    (*output_) << info_->getSnapshotManager()->getCurrentSnapshot()->getTime();
188 +    
189 +    // output some information about the molecules
190 +    std::vector<std::map<int, Restraint::RealPair> >::const_iterator i;
191 +    std::map<int, Restraint::RealPair>::const_iterator j;
192 +    
193 +    for( i = restInfo.begin(); i != restInfo.end(); ++i){
194 +      for(j = (*i).begin(); j != (*i).end(); ++j){                
195 +        (*output_) << "\t" << (j->second).first << "\t" << (j->second).second;
196        }
197 <      
198 <      finalOut << info_->getSnapshotManager()->getCurrentSnapshot()->getTime()
199 <               << " : omega values at this time\n";
200 <      
201 <      std::map<int, RealType>::iterator l;
202 <      for (l = zAngData.begin(); l != zAngData.end(); ++l) {
203 <
204 <        sprintf( tempBuffer,
205 <                 "%14.10lf\n",
206 <                 l->second);
207 <        strcpy( writeLine, tempBuffer );
208 <        
209 <        finalOut << writeLine;      
197 >      (*output_) << std::endl;
198 >    }
199 >    (*output_).flush();
200 > #else
201 >    std::string buffer, first, second;
202 >    std::stringstream ss;
203 >    
204 >    std::vector<std::map<int, Restraint::RealPair> >::const_iterator i;
205 >    std::map<int, Restraint::RealPair>::const_iterator j;
206 >    
207 >    for( i = restInfo.begin(); i != restInfo.end(); ++i){
208 >      for(j = (*i).begin(); j != (*i).end(); ++j){
209 >        ss.clear();
210 >        ss << (j->second).first;
211 >        ss >> first;
212 >        ss.clear();
213 >        ss << (j->second).second;
214 >        ss >> second;
215 >        buffer += ("\t" + first + "\t" + second);      
216        }
217 +      buffer += "\n";    
218 +    }
219 +    
220 +    const int masterNode = 0;
221 +    
222 +    if (worldRank == masterNode) {
223 +      (*output_) << info_->getSnapshotManager()->getCurrentSnapshot()->getTime();
224 +      (*output_) << buffer;
225        
226 +      int nProc;
227 +      MPI_Comm_size(MPI_COMM_WORLD, &nProc);
228 +      for (int i = 1; i < nProc; ++i) {
229 +        
230 +        // receive the length of the string buffer that was
231 +        // prepared by processor i
232 +        
233 +        int recvLength;
234 +        MPI_Recv(&recvLength, 1, MPI_INT, i, 0, MPI_COMM_WORLD, &istatus);
235 +        char* recvBuffer = new char[recvLength];
236 +        if (recvBuffer == NULL) {
237 +        } else {
238 +          MPI_Recv(recvBuffer, recvLength, MPI_CHAR, i, 0, MPI_COMM_WORLD,
239 +                   &istatus);
240 +          (*output_) << recvBuffer;
241 +          
242 +          delete [] recvBuffer;
243 +        }
244 +      }
245 +      (*output_).flush();
246      } else {
247 <      // pack up and send the appropriate info to the master node
248 <      for(int j = 1; j < nproc; ++j) {
249 <        if (worldRank == j) {
250 <          for (mol = info_->beginMolecule(mi); mol != NULL;
251 <               mol = info_->nextMolecule(mi)) {
252 <            
253 <            for (integrableObject = mol->beginIntegrableObject(ii);
254 <                 integrableObject != NULL;
255 <                 integrableObject = mol->nextIntegrableObject(ii)) {
256 <              
257 <              // build a vector of the indicies
258 <              intObIndex = integrableObject->getGlobalIntegrableObjectIndex();
259 <              gIndex.push_back(intObIndex);
260 <                    
261 <              // build a vector of the zAngle values
262 <              zAngle = integrableObject->getZangle();
263 <              zValues.push_back(zAngle);
264 <
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 <        }
247 >      int sendBufferLength = buffer.size() + 1;
248 >      MPI_Send(&sendBufferLength, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
249 >      MPI_Send((void *)buffer.c_str(), sendBufferLength, MPI_CHAR, masterNode,
250 >               0, MPI_COMM_WORLD);
251 >    }
252 > #endif // is_mpi
253 >  }
254 >  
255 >  
256 >  RestWriter::~RestWriter() {
257 >    
258 > #ifdef IS_MPI
259 >    
260 >    if (worldRank == 0) {
261 > #endif // is_mpi
262 >      if (createRestFile_){
263 >        writeClosing(*output_);
264 >        delete output_;
265        }
266 + #ifdef IS_MPI
267      }
268 <
219 < #endif
268 > #endif // is_mpi
269    }
270    
271 < }
271 >  void RestWriter::writeClosing(std::ostream& os) {
272 >    os.flush();
273 >  }
274 >  
275 > }// end namespace OpenMD
276 >

Diff Legend

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