ViewVC Help

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

root/OpenMD/branches/development/src/io/RestWriter.cpp

Comparing:
trunk/src/io/RestWriter.cpp (file contents), Revision 1030 by chrisfen, Fri Sep 1 14:15:05 2006 UTC vs.
branches/development/src/io/RestWriter.cpp (file contents), Revision 1465 by chuckv, Fri Jul 9 23:08:25 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	>

Comparing:
trunk/src/io/RestWriter.cpp (property svn:keywords), Revision 1030 by chrisfen, Fri Sep 1 14:15:05 2006 UTC vs.
branches/development/src/io/RestWriter.cpp (property svn:keywords), Revision 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC

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

Diff Legend

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