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 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 38 | Line 38
38   * University of Notre Dame has been advised of the possibility of
39   * such damages.
40   */
41 <
42 < #include <algorithm>
41 >
42 >
43   #include <iostream>
44 – #include <map>
44  
46 – #include "primitives/Molecule.hpp"
45   #include "io/RestWriter.hpp"
46   #include "utils/simError.h"
47 + #include "brains/SnapshotManager.hpp"
48 + #ifdef IS_MPI
49 + #include <mpi.h>
50 + #endif
51  
50 –
52   namespace oopse {
53 <  RestWriter::RestWriter(SimInfo* info) :
54 <    info_(info) {
53 >  RestWriter::RestWriter(SimInfo* info, const std::string& filename,
54 >                         std::vector<Restraint*> restraints ) :
55 >    info_(info){
56  
57 <    // only the master node writes to the disk
57 >    //use master - slave mode, only master node writes to disk
58   #ifdef IS_MPI
59 <    if (worldRank == 0) {
60 < #endif // is_mpi
61 <
62 <      outName = info_->getRestFileName();
63 <
64 < #ifdef IS_MPI
63 <    }
64 < #endif // is_mpi
65 <  }
66 <  
67 <  RestWriter::~RestWriter() {}
68 <  
69 <  void RestWriter::writeZangle(){
70 <    const int BUFFERSIZE = 2000;
71 <    char tempBuffer[BUFFERSIZE];
72 <    char writeLine[BUFFERSIZE];
73 <    
74 <    std::ofstream finalOut;
75 <    
76 <    Molecule* mol;
77 <    StuntDouble* integrableObject;
78 <    SimInfo::MoleculeIterator mi;
79 <    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 ){
59 >    if(worldRank == 0){
60 > #endif
61 >      
62 >      output_.open(filename.c_str());
63 >      
64 >      if(!output_){
65          sprintf( painCave.errMsg,
66 <                 "Could not open \"%s\" for zAngle output.\n",
67 <                 outName.c_str() );
66 >                 "Could not open %s for restraint output.\n",
67 >                 filename.c_str());
68          painCave.isFatal = 1;
69          simError();
70        }
71 < #ifdef IS_MPI
72 <    }
94 < #endif // is_mpi
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)) {
71 >
72 >      output_ << "#time\t";
73        
74 <      for (integrableObject = mol->beginIntegrableObject(ii);
75 <           integrableObject != NULL;
76 <           integrableObject = mol->nextIntegrableObject(ii)) {    
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 <        sprintf( tempBuffer,
110 <                 "%14.10lf\n",
111 <                 integrableObject->getZangle());
112 <        strcpy( writeLine, tempBuffer );
80 >        output_ << myName << ":";
81          
82 <        finalOut << writeLine;      
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 <      
95 >      output_ << "\n";
96 > #ifdef IS_MPI
97      }
98 <    
99 < #else
100 <    int nproc;
101 <    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
102 <    const int masterNode = 0;
103 <    int myNode = worldRank;
104 <    std::vector<int> tmpNIntObjects(nproc, 0);
105 <    std::vector<int> nIntObjectsInProc(nproc, 0);
106 <    tmpNIntObjects[myNode] = info_->getNGlobalIntegrableObjects();
107 <    
108 <    //do MPI_ALLREDUCE to exchange the total number of atoms, rigidbodies and cutoff groups
109 <    MPI_Allreduce(&tmpNIntObjects[0], &nIntObjectsInProc[0], nproc, MPI_INT,
110 <                  MPI_SUM, MPI_COMM_WORLD);
111 <    
132 <    MPI_Status ierr;
133 <    int intObIndex;
134 <    RealType zAngle;
135 <  
136 <    if (worldRank == masterNode) {
137 <      std::map<int, RealType> zAngData;
138 <      for(int i = 0 ; i < nproc; ++i) {
139 <        if (i == masterNode) {
140 <          for (mol = info_->beginMolecule(mi); mol != NULL;
141 <               mol = info_->nextMolecule(mi)) {
142 <            
143 <            for (integrableObject = mol->beginIntegrableObject(ii);
144 <                 integrableObject != NULL;
145 <                 integrableObject = mol->nextIntegrableObject(ii)) {
146 <              
147 <              intObIndex = integrableObject->getGlobalIndex();
148 <
149 <              zAngle = integrableObject->getZangle();
150 <              zAngData.insert(std::pair<int, RealType>(intObIndex, zAngle));
151 <            }      
152 <          }
153 <        } else {
154 <          for (mol = info_->beginMolecule(mi); mol != NULL;
155 <               mol = info_->nextMolecule(mi)) {
156 <            
157 <            for (integrableObject = mol->beginIntegrableObject(ii);
158 <                 integrableObject != NULL;
159 <                 integrableObject = mol->nextIntegrableObject(ii)) {
160 <              
161 <              MPI_Recv(&intObIndex, 1, MPI_INT, i, 0, MPI_COMM_WORLD,&ierr);
162 <              MPI_Recv(&zAngle, 1, MPI_REALTYPE, i, 0, MPI_COMM_WORLD,&ierr);
163 <              zAngData.insert(std::pair<int, RealType>(intObIndex, zAngle));
164 <            }
165 <          }
166 <        }
167 <      }
98 > #endif      
99 >  }
100 >  
101 >  RestWriter::~RestWriter() {
102 > #ifdef IS_MPI
103 >    if(worldRank == 0 ){
104 > #endif  
105 >      output_.close();  
106 > #ifdef IS_MPI  
107 >    }
108 > #endif
109 >  }
110 >  
111 >  void RestWriter::writeRest(std::vector<std::map<int, Restraint::RealPair> > restInfo){
112        
113 <      finalOut
114 <        << info_->getSnapshotManager()->getCurrentSnapshot()->getTime()
171 <        << " : omega values at this time\n";
172 <      
173 <      std::map<int, RealType>::iterator l;
174 <      for (l = zAngData.begin(); l != zAngData.end(); ++l) {
175 <        sprintf( tempBuffer,
176 <                 "%14.10lf\n",
177 <                 l->second);
178 <        strcpy( writeLine, tempBuffer );
113 >    
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 <
183 <      finalOut.close();
184 <      
185 <    } else {
186 <      for(int j = 1; j < nproc; ++j) {
187 <        for (mol = info_->beginMolecule(mi); mol != NULL;
188 <             mol = info_->nextMolecule(mi)) {
189 <          
190 <          for (integrableObject = mol->beginIntegrableObject(ii);
191 <               integrableObject != NULL;
192 <               integrableObject = mol->nextIntegrableObject(ii)) {
193 <            intObIndex = integrableObject->getGlobalIndex();            
194 <            zAngle = integrableObject->getZangle();
195 <
196 <            MPI_Send(&intObIndex, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
197 <            MPI_Send(&zAngle, 1, MPI_REALTYPE, masterNode, 0, MPI_COMM_WORLD);
198 <          }
199 <        }
200 <      }
123 >      output_ << std::endl;
124      }
202 –
203 – #endif
125    }
126    
127 < }
127 > }// end oopse
128 >  

Diff Legend

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