ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/trunk/src/io/RestWriter.cpp

Comparing trunk/src/io/RestWriter.cpp (file contents):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 2020 by gezelter, Mon Sep 22 19:18:35 2014 UTC

#	Line 35 | Line 35
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).
38	>	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).
39	>	* [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	>	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41		*/
42
43	+	#ifdef IS_MPI
44	+	#include <mpi.h>
45	+	#endif
46
47	+	#include <string>
48	+	#include <sstream>
49		#include <iostream>
50
51		#include "io/RestWriter.hpp"
52		#include "utils/simError.h"
53		#include "brains/SnapshotManager.hpp"
48	–	#ifdef IS_MPI
49	–	#include <mpi.h>
50	–	#endif
54
55		namespace OpenMD {
56		RestWriter::RestWriter(SimInfo* info, const std::string& filename,
57		std::vector<Restraint*> restraints ) :
58		info_(info){
59
60	<	//use master - slave mode, only master node writes to disk
60	>	std::vector<Restraint*>::const_iterator resti;
61	>
62	>	createRestFile_ = false;
63	>
64	>	#ifdef IS_MPI
65	>	MPI_Status* istatus;
66	>	#endif
67	>
68	>	int printAny = 0;
69	>	for(resti=restraints.begin(); resti != restraints.end(); ++resti){
70	>	if ((*resti)->getPrintRestraint()) {
71	>	printAny = 1;
72	>	}
73	>	}
74	>
75		#ifdef IS_MPI
76	+	MPI_Allreduce(MPI_IN_PLACE, &printAny, 1, MPI_INT, MPI_SUM,
77	+	MPI_COMM_WORLD);
78	+	#endif
79	+
80	+	if (printAny) createRestFile_ = true;
81	+
82	+	#ifdef IS_MPI
83		if(worldRank == 0){
84		#endif
85	<
86	<	output_.open(filename.c_str());
87	<
88	<	if(!output_){
89	<	sprintf( painCave.errMsg,
90	<	"Could not open %s for restraint output.\n",
91	<	filename.c_str());
92	<	painCave.isFatal = 1;
93	<	simError();
85	>
86	>	if (createRestFile_) {
87	>	output_ = new std::ofstream(filename.c_str());
88	>
89	>	if(!output_){
90	>	sprintf( painCave.errMsg,
91	>	"Could not open %s for restraint output.\n",
92	>	filename.c_str());
93	>	painCave.isFatal = 1;
94	>	simError();
95	>	}
96		}
97	+
98	+	#ifdef IS_MPI
99	+	}
100	+	#endif // is_mpi
101
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){
102
103	<	if ((*resti)->getPrintRestraint()) {
104	<	std::string myName = (*resti)->getRestraintName();
105	<	int myType = (*resti)->getRestraintType();
103	>	#ifndef IS_MPI
104	>
105	>	if (createRestFile_) (*output_) << "#time\t";
106	>
107	>	for(resti=restraints.begin(); resti != restraints.end(); ++resti){
108	>	if ((*resti)->getPrintRestraint()) {
109	>	std::string myName = (*resti)->getRestraintName();
110	>	int myType = (*resti)->getRestraintType();
111	>
112	>	(*output_) << myName << ":";
113	>
114	>	if (myType & Restraint::rtDisplacement)
115	>	(*output_) << "\tPosition(angstroms)\tEnergy(kcal/mol)";
116	>
117	>	if (myType & Restraint::rtTwist)
118	>	(*output_) << "\tTwistAngle(radians)\tEnergy(kcal/mol)";
119	>
120	>	if (myType & Restraint::rtSwingX)
121	>	(*output_) << "\tSwingXAngle(radians)\tEnergy(kcal/mol)";
122
123	<	output_ << myName << ":";
124	<
84	<	if (myType & Restraint::rtDisplacement)
85	<	output_ << "\tPosition(angstroms)\tEnergy(kcal/mol)";
86	<
87	<	if (myType & Restraint::rtTwist)
88	<	output_ << "\tTwistAngle(radians)\tEnergy(kcal/mol)";
89	<
90	<	if (myType & Restraint::rtSwingX)
91	<	output_ << "\tSwingXAngle(radians)\tEnergy(kcal/mol)";
92	<
93	<	if (myType & Restraint::rtSwingY)
94	<	output_ << "\tSwingYAngle(radians)\tEnergy(kcal/mol)";
95	<
96	<	}
123	>	if (myType & Restraint::rtSwingY)
124	>	(*output_) << "\tSwingYAngle(radians)\tEnergy(kcal/mol)";
125		}
98	–	output_ << "\n";
99	–	#ifdef IS_MPI
126		}
127	<	#endif
128	<	}
127	>
128	>	if (createRestFile_) (*output_) << "\n";
129	>	if (createRestFile_) (*output_).flush();
130	>
131	>	#else
132	>
133	>	std::string buffer;
134	>
135	>	for(resti=restraints.begin(); resti != restraints.end(); ++resti){
136	>	if ((*resti)->getPrintRestraint()) {
137	>	std::string myName = (*resti)->getRestraintName();
138	>	int myType = (*resti)->getRestraintType();
139	>
140	>	buffer += (myName + ":");
141	>
142	>	if (myType & Restraint::rtDisplacement)
143	>	buffer += "\tPosition(angstroms)\tEnergy(kcal/mol)";
144	>
145	>	if (myType & Restraint::rtTwist)
146	>	buffer += "\tTwistAngle(radians)\tEnergy(kcal/mol)";
147	>
148	>	if (myType & Restraint::rtSwingX)
149	>	buffer += "\tSwingXAngle(radians)\tEnergy(kcal/mol)";
150	>
151	>	if (myType & Restraint::rtSwingY)
152	>	buffer += "\tSwingYAngle(radians)\tEnergy(kcal/mol)";
153	>
154	>	buffer += "\n";
155	>	}
156	>	}
157	>
158	>	const int masterNode = 0;
159	>
160	>	if (worldRank == masterNode) {
161	>	if (createRestFile_) (*output_) << "#time\t";
162	>	if (createRestFile_) (*output_) << buffer;
163	>
164	>	int nProc;
165	>	MPI_Comm_size( MPI_COMM_WORLD, &nProc);
166	>
167	>	for (int i = 1; i < nProc; ++i) {
168	>
169	>	// receive the length of the string buffer that was
170	>	// prepared by processor i
171	>
172	>	int recvLength;
173	>	MPI_Recv(&recvLength, 1, MPI_INT, i, 0, MPI_COMM_WORLD, istatus);
174	>	char* recvBuffer = new char[recvLength];
175	>	if (recvBuffer == NULL) {
176	>	} else {
177	>	MPI_Recv(recvBuffer, recvLength, MPI_CHAR, i, 0, MPI_COMM_WORLD,
178	>	istatus);
179	>	if (createRestFile_) (*output_) << recvBuffer;
180	>	delete [] recvBuffer;
181	>	}
182	>	}
183	>	if (createRestFile_) (*output_).flush();
184	>	} else {
185	>	int sendBufferLength = buffer.size() + 1;
186	>	MPI_Send(&sendBufferLength, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
187	>	MPI_Send((void *)buffer.c_str(), sendBufferLength, MPI_CHAR,
188	>	masterNode, 0, MPI_COMM_WORLD);
189	>	}
190	>
191	>	#endif // is_mpi
192	>
193	>	}
194
195	<	RestWriter::~RestWriter() {
195	>	void RestWriter::writeRest(std::vector<std::map<int, Restraint::RealPair> > restInfo) {
196	>
197		#ifdef IS_MPI
198	<	if(worldRank == 0 ){
107	<	#endif
108	<	output_.close();
109	<	#ifdef IS_MPI
110	<	}
198	>	MPI_Status* istatus;
199		#endif
112	–	}
113	–
114	–	void RestWriter::writeRest(std::vector<std::map<int, Restraint::RealPair> > restInfo){
115	–
200
201	<	output_ << info_->getSnapshotManager()->getCurrentSnapshot()->getTime();
202	<
201	>	#ifndef IS_MPI
202	>	if (createRestFile_)  (*output_) << info_->getSnapshotManager()->getCurrentSnapshot()->getTime();
203	>
204		// output some information about the molecules
205		std::vector<std::map<int, Restraint::RealPair> >::const_iterator i;
206		std::map<int, Restraint::RealPair>::const_iterator j;
207	<	for( i = restInfo.begin(); i != restInfo.end(); ++i){
208	<	for(j = (*i).begin(); j != (*i).end(); ++j){
209	<	output_ << "\t" << (j->second).first << "\t" << (j->second).second;
207	>
208	>	cerr << "risize = " << restInfo.size() << "\n";
209	>
210	>	if ( createRestFile_ ) {
211	>
212	>	for( i = restInfo.begin(); i != restInfo.end(); ++i){
213	>	for(j = (*i).begin(); j != (*i).end(); ++j){
214	>	(*output_) << "\t" << (j->second).first << "\t" << (j->second).second;
215	>	}
216	>	(*output_) << std::endl;
217	>	}
218	>	(*output_).flush();
219	>	}
220	>	#else
221	>	std::string buffer, first, second;
222	>	std::stringstream ss;
223	>
224	>	std::vector<std::map<int, Restraint::RealPair> >::const_iterator i;
225	>	std::map<int, Restraint::RealPair>::const_iterator j;
226	>
227	>	if ( createRestFile_ ) {
228	>	for( i = restInfo.begin(); i != restInfo.end(); ++i){
229	>
230	>	for(j = (*i).begin(); j != (*i).end(); ++j){
231	>	ss.clear();
232	>	ss << (j->second).first;
233	>	ss >> first;
234	>	ss.clear();
235	>	ss << (j->second).second;
236	>	ss >> second;
237	>	buffer += ("\t" + first + "\t" + second);
238	>	}
239	>	buffer += "\n";
240		}
126	–	output_ << std::endl;
241		}
242	+
243	+	const int masterNode = 0;
244	+
245	+	if (createRestFile_) {
246	+	if (worldRank == masterNode) {
247	+
248	+	(*output_) << info_->getSnapshotManager()->getCurrentSnapshot()->getTime();
249	+	(*output_) << buffer;
250	+
251	+	int nProc;
252	+	MPI_Comm_size( MPI_COMM_WORLD, &nProc);
253	+	for (int i = 1; i < nProc; ++i) {
254	+
255	+	// receive the length of the string buffer that was
256	+	// prepared by processor i
257	+
258	+	int recvLength;
259	+	MPI_Recv(&recvLength, 1, MPI_INT, i, 0, MPI_COMM_WORLD, istatus);
260	+	char* recvBuffer = new char[recvLength];
261	+	if (recvBuffer == NULL) {
262	+	} else {
263	+	MPI_Recv(recvBuffer, recvLength, MPI_CHAR, i, 0, MPI_COMM_WORLD,
264	+	istatus);
265	+	if (createRestFile_) (*output_) << recvBuffer;
266	+
267	+	delete [] recvBuffer;
268	+	}
269	+	}
270	+	(*output_).flush();
271	+	} else {
272	+	int sendBufferLength = buffer.size() + 1;
273	+	MPI_Send(&sendBufferLength, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
274	+	MPI_Send((void *)buffer.c_str(), sendBufferLength,
275	+	MPI_CHAR, masterNode, 0, MPI_COMM_WORLD);
276	+	}
277	+	}
278	+	#endif // is_mpi
279		}
280
130	–	}// end namespace OpenMD
281
282	+	RestWriter::~RestWriter() {
283	+
284	+	#ifdef IS_MPI
285	+
286	+	if (worldRank == 0) {
287	+	#endif // is_mpi
288	+	if (createRestFile_){
289	+	writeClosing(*output_);
290	+	delete output_;
291	+	}
292	+	#ifdef IS_MPI
293	+	}
294	+	#endif // is_mpi
295	+	}
296	+
297	+	void RestWriter::writeClosing(std::ostream& os) {
298	+	os.flush();
299	+	}
300	+
301	+	}// end namespace OpenMD
302	+

Comparing trunk/src/io/RestWriter.cpp (property svn:keywords):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 2020 by gezelter, Mon Sep 22 19:18:35 2014 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

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