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 1359 by chrisfen, Fri Sep 1 14:15:05 2006 UTC vs.
Revision 1360 by cli2, Mon Sep 7 16:31:51 2009 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
# Line 39 | Line 39
39   * such damages.
40   */
41  
42 +
43 + #include <iostream>
44 +
45   #include "io/RestWriter.hpp"
43 – #include "primitives/Molecule.hpp"
46   #include "utils/simError.h"
47 < #include "io/basic_teebuf.hpp"
46 <
47 > #include "brains/SnapshotManager.hpp"
48   #ifdef IS_MPI
49   #include <mpi.h>
50 < #define TAKE_THIS_TAG_INT 1
50 < #define TAKE_THIS_TAG_REAL 2
51 < #endif //is_mpi
50 > #endif
51  
52   namespace oopse {
53 <  RestWriter::RestWriter(SimInfo* info) :
54 <    info_(info), outName_(info_->getRestFileName()) {
55 <  }
56 <  
57 <  RestWriter::~RestWriter() {}
59 <  
60 <  void RestWriter::writeZAngFile() {
61 <    std::ostream* zangStream;
62 <    
53 >  RestWriter::RestWriter(SimInfo* info, const std::string& filename,
54 >                         std::vector<Restraint*> restraints ) :
55 >    info_(info){
56 >
57 >    //use master - slave mode, only master node writes to disk
58   #ifdef IS_MPI
59 <    if (worldRank == 0) {
60 < #endif // is_mpi
59 >    if(worldRank == 0){
60 > #endif
61        
62 <      zangStream = new std::ofstream(outName_.c_str());
62 >      output_.open(filename.c_str());
63        
64 +      if(!output_){
65 +        sprintf( painCave.errMsg,
66 +                 "Could not open %s for restraint output.\n",
67 +                 filename.c_str());
68 +        painCave.isFatal = 1;
69 +        simError();
70 +      }
71 +
72 +      output_ << "#time\t";
73 +      
74 +      // TODO:  get Restraint info from slave nodes:
75 +      std::vector<Restraint*>::const_iterator resti;
76 +      for(resti=restraints.begin(); resti != restraints.end(); ++resti){
77 +        std::string myName = (*resti)->getRestraintName();
78 +        int myType = (*resti)->getRestraintType();
79 +        
80 +        output_ << myName << ":";
81 +        
82 +        if (myType & Restraint::rtDisplacement)
83 +          output_ << "\tPosition(angstroms)\tEnergy(kcal/mol)";
84 +        
85 +        if (myType & Restraint::rtTwist)
86 +          output_ << "\tTwistAngle(radians)\tEnergy(kcal/mol)";
87 +        
88 +        if (myType & Restraint::rtSwingX)
89 +          output_ << "\tSwingXAngle(radians)\tEnergy(kcal/mol)";
90 +        
91 +        if (myType & Restraint::rtSwingY)
92 +          output_ << "\tSwingYAngle(radians)\tEnergy(kcal/mol)";
93 +        
94 +      }
95 +      output_ << "\n";
96   #ifdef IS_MPI
97      }
98 < #endif // is_mpi    
99 <    
100 <    writeZangle(*zangStream);
101 <    
98 > #endif      
99 >  }
100 >  
101 >  RestWriter::~RestWriter() {
102   #ifdef IS_MPI
103 <    if (worldRank == 0) {
104 < #endif // is_mpi
105 <      delete zangStream;
106 <      
80 < #ifdef IS_MPI
103 >    if(worldRank == 0 ){
104 > #endif  
105 >      output_.close();  
106 > #ifdef IS_MPI  
107      }
108 < #endif // is_mpi  
83 <    
108 > #endif
109    }
110 <
111 <  void RestWriter::writeZangle(std::ostream& finalOut){
87 <    const int BUFFERSIZE = 2000;
88 <    char tempBuffer[BUFFERSIZE];
89 <    char writeLine[BUFFERSIZE];
90 <    
91 <    Molecule* mol;
92 <    StuntDouble* integrableObject;
93 <    SimInfo::MoleculeIterator mi;
94 <    Molecule::IntegrableObjectIterator ii;
95 <    
96 < #ifndef IS_MPI
97 <    // first we do output for the single processor version
98 <    finalOut
99 <      << info_->getSnapshotManager()->getCurrentSnapshot()->getTime()
100 <      << " : omega values at this time\n";
101 <    
102 <    for (mol = info_->beginMolecule(mi); mol != NULL;
103 <         mol = info_->nextMolecule(mi)) {
110 >  
111 >  void RestWriter::writeRest(std::vector<std::map<int, Restraint::RealPair> > restInfo){
112        
105 –      for (integrableObject = mol->beginIntegrableObject(ii);
106 –           integrableObject != NULL;
107 –           integrableObject = mol->nextIntegrableObject(ii)) {    
108 –        
109 –        sprintf( tempBuffer,
110 –                 "%14.10lf\n",
111 –                 integrableObject->getZangle());
112 –        strcpy( writeLine, tempBuffer );    
113 –        
114 –        finalOut << writeLine;
115 –
116 –      }
117 –    }
113      
114 < #else
120 <    int nproc;
121 <    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
122 <    const int masterNode = 0;
123 <    
124 <    MPI_Status ierr;
125 <    int intObIndex;
126 <    int vecLength;
127 <    RealType zAngle;
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) {
134 <        if (i == masterNode) {
135 <          for (mol = info_->beginMolecule(mi); mol != NULL;
136 <               mol = info_->nextMolecule(mi)) {
137 <            
138 <            for (integrableObject = mol->beginIntegrableObject(ii);
139 <                 integrableObject != NULL;
140 <                 integrableObject = mol->nextIntegrableObject(ii)) {
141 <              
142 <              intObIndex = integrableObject->getGlobalIntegrableObjectIndex();
143 <
144 <              zAngle = integrableObject->getZangle();
145 <              zAngData.insert(std::pair<int, RealType>(intObIndex, zAngle));
146 <            }      
147 <          }
148 <        } else {
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 << 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);
177 <        strcpy( writeLine, tempBuffer );
114 >    output_ << info_->getSnapshotManager()->getCurrentSnapshot()->getTime();
115          
116 <        finalOut << writeLine;      
116 >    // output some information about the molecules
117 >    std::vector<std::map<int, Restraint::RealPair> >::const_iterator i;
118 >    std::map<int, Restraint::RealPair>::const_iterator j;
119 >    for( i = restInfo.begin(); i != restInfo.end(); ++i){
120 >      for(j = (*i).begin(); j != (*i).end(); ++j){                
121 >        output_ << "\t" << (j->second).first << "\t" << (j->second).second;
122        }
123 <      
182 <    } else {
183 <      // pack up and send the appropriate info to the master node
184 <      for(int j = 1; j < nproc; ++j) {
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 <            }      
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 <      }
123 >      output_ << std::endl;
124      }
218 –
219 – #endif
125    }
126    
127 < }
127 > }// end oopse
128 >  

Diff Legend

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