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 423 by chrisfen, Thu Mar 10 19:11:02 2005 UTC vs.
Revision 2021 by gezelter, Tue Sep 23 15:25:08 2014 UTC

#	Line 1 | Line 1
1	<	/*
2	<	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
1	>	/*
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, 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	<	#include <algorithm>
42	>
43	>	#ifdef IS_MPI
44	>	#include <mpi.h>
45	>	#endif
46	>
47	>	#include <string>
48	>	#include <sstream>
49		#include <iostream>
44	–	#include <map>
50
46	–	#include "primitives/Molecule.hpp"
51		#include "io/RestWriter.hpp"
52		#include "utils/simError.h"
53	+	#include "brains/SnapshotManager.hpp"
54
55	+	namespace OpenMD {
56	+	RestWriter::RestWriter(SimInfo* info, const std::string& filename,
57	+	std::vector<Restraint*> restraints ) :
58	+	info_(info){
59
60	<	namespace oopse {
61	<	RestWriter::RestWriter(SimInfo* info) :
62	<	info_(info) {
60	>	std::vector<Restraint*>::const_iterator resti;
61	>
62	>	createRestFile_ = false;
63	>
64	>	#ifdef IS_MPI
65	>	MPI_Status* istatus;
66	>	#endif
67
68	<	//we use master - slave mode, only master node writes to disk
69	<	outName = info_->getRestFileName();
70	<	}
71	<
72	<	RestWriter::~RestWriter() {}
73	<
61	<	void RestWriter::writeZangle(){
62	<	const int BUFFERSIZE = 2000;
63	<	char tempBuffer[BUFFERSIZE];
64	<	char writeLine[BUFFERSIZE];
68	>	int printAny = 0;
69	>	for(resti=restraints.begin(); resti != restraints.end(); ++resti){
70	>	if ((*resti)->getPrintRestraint()) {
71	>	printAny = 1;
72	>	}
73	>	}
74
66	–	std::ofstream finalOut;
67	–
68	–	Molecule* mol;
69	–	StuntDouble* integrableObject;
70	–	SimInfo::MoleculeIterator mi;
71	–	Molecule::IntegrableObjectIterator ii;
72	–
75		#ifdef IS_MPI
76	<	if(worldRank == 0 ){
77	<	#endif
78	<	finalOut.open( outName.c_str(), std::ios::out | std::ios::trunc );
79	<	if( !finalOut ){
80	<	sprintf( painCave.errMsg,
81	<	"Could not open \"%s\" for zAngle output.\n",
82	<	outName.c_str() );
83	<	painCave.isFatal = 1;
84	<	simError();
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	>	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	<
101	>
102	>
103		#ifndef IS_MPI
104	<	// first we do output for the single processor version
105	<	finalOut
106	<	<< info_->getSnapshotManager()->getCurrentSnapshot()->getTime()
107	<	<< " : omega values at this time\n";
108	<
109	<	for (mol = info_->beginMolecule(mi); mol != NULL;
110	<	mol = info_->nextMolecule(mi)) {
96	<
97	<	for (integrableObject = mol->beginIntegrableObject(ii);
98	<	integrableObject != NULL;
99	<	integrableObject = mol->nextIntegrableObject(ii)) {
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	<	sprintf( tempBuffer,
102	<	"%14.10lf\n",
103	<	integrableObject->getZangle());
104	<	strcpy( writeLine, tempBuffer );
112	>	(*output_) << myName << ":";
113
114	<	finalOut << writeLine;
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	>	if (myType & Restraint::rtSwingY)
124	>	(*output_) << "\tSwingYAngle(radians)\tEnergy(kcal/mol)";
125		}
108	–
126		}
127	+
128	+	if (createRestFile_) (*output_) << "\n";
129	+	if (createRestFile_) (*output_).flush();
130
131		#else
112	–	int nproc;
113	–	MPI_Comm_size(MPI_COMM_WORLD, &nproc);
114	–	const int masterNode = 0;
115	–	int myNode = worldRank;
116	–	std::vector<int> tmpNIntObjects(nproc, 0);
117	–	std::vector<int> nIntObjectsInProc(nproc, 0);
118	–	tmpNIntObjects[myNode] = info_->getNGlobalIntegrableObjects();
132
133	<	//do MPI_ALLREDUCE to exchange the total number of atoms, rigidbodies and cutoff groups
134	<	MPI_Allreduce(&tmpNIntObjects[0], &nIntObjectsInProc[0], nproc, MPI_INT,
135	<	MPI_SUM, MPI_COMM_WORLD);
136	<
137	<	MPI_Status ierr;
138	<	int intObIndex;
139	<	double zAngle;
140	<
128	<	if (masterNode == 0) {
129	<	std::map<int, double> zAngData;
130	<	for(int i = 0 ; i < nproc; ++i) {
131	<	if (i == masterNode) {
132	<	for (mol = info_->beginMolecule(mi); mol != NULL;
133	<	mol = info_->nextMolecule(mi)) {
134	<
135	<	for (integrableObject = mol->beginIntegrableObject(ii);
136	<	integrableObject != NULL;
137	<	integrableObject = mol->nextIntegrableObject(ii)) {
138	<
139	<	intObIndex = integrableObject->getGlobalIndex() ;
140	<	zAngle = integrableObject->getZangle();
141	<	zAngData.insert(std::pair<int, double>(intObIndex, zAngle));
142	<	}
143	<	}
144	<
145	<	} else {
146	<	for(int k = 0; k < nIntObjectsInProc[i]; ++k) {
147	<	MPI_Recv(&intObIndex, 1, MPI_INT, i, 0, MPI_COMM_WORLD,&ierr);
148	<	MPI_Recv(&zAngle, 1, MPI_DOUBLE, i, 0, MPI_COMM_WORLD,&ierr);
149	<	zAngData.insert(std::pair<int, double>(intObIndex, zAngle));
150	<	}
151	<	}
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	<	finalOut
165	<	<< info_->getSnapshotManager()->getCurrentSnapshot()->getTime()
166	<	<< " : omega values at this time\n";
167	<
168	<	std::map<int, double>::iterator l;
169	<	for (l = zAngData.begin(); l != zAngData.end(); ++l) {
170	<	finalOut << l->second << "\n";
171	<	}
172	<
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	+	void RestWriter::writeRest(std::vector<std::map<int, Restraint::RealPair> > restInfo) {
196	+
197	+	#ifdef IS_MPI
198	+	MPI_Status* istatus;
199	+	#endif
200	+
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	+
208	+	if ( createRestFile_ ) {
209
210	<	for (mol = info_->beginMolecule(mi); mol != NULL;
211	<	mol = info_->nextMolecule(mi)) {
210	>	for( i = restInfo.begin(); i != restInfo.end(); ++i){
211	>	for(j = (*i).begin(); j != (*i).end(); ++j){
212	>	(*output_) << "\t" << (j->second).first << "\t" << (j->second).second;
213	>	}
214	>	(*output_) << std::endl;
215	>	}
216	>	(*output_).flush();
217	>	}
218	>	#else
219	>	std::string buffer, first, second;
220	>	std::stringstream ss;
221	>
222	>	std::vector<std::map<int, Restraint::RealPair> >::const_iterator i;
223	>	std::map<int, Restraint::RealPair>::const_iterator j;
224	>
225	>	if ( createRestFile_ ) {
226	>	for( i = restInfo.begin(); i != restInfo.end(); ++i){
227
228	<	for (integrableObject = mol->beginIntegrableObject(ii);
229	<	integrableObject != NULL;
230	<	integrableObject = mol->nextIntegrableObject(ii)) {
231	<	intObIndex = integrableObject->getGlobalIndex();
232	<	zAngle = integrableObject->getZangle();
233	<	MPI_Send(&intObIndex, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
234	<	MPI_Send(&zAngle, 1, MPI_DOUBLE, masterNode, 0, MPI_COMM_WORLD);
228	>	for(j = (*i).begin(); j != (*i).end(); ++j){
229	>	ss.clear();
230	>	ss << (j->second).first;
231	>	ss >> first;
232	>	ss.clear();
233	>	ss << (j->second).second;
234	>	ss >> second;
235	>	buffer += ("\t" + first + "\t" + second);
236		}
237	+	buffer += "\n";
238		}
239		}
179	–	#endif
240
241	+	const int masterNode = 0;
242	+
243	+	if (createRestFile_) {
244	+	if (worldRank == masterNode) {
245	+
246	+	(*output_) << info_->getSnapshotManager()->getCurrentSnapshot()->getTime();
247	+	(*output_) << buffer;
248	+
249	+	int nProc;
250	+	MPI_Comm_size( MPI_COMM_WORLD, &nProc);
251	+	for (int i = 1; i < nProc; ++i) {
252	+
253	+	// receive the length of the string buffer that was
254	+	// prepared by processor i
255	+
256	+	int recvLength;
257	+	MPI_Recv(&recvLength, 1, MPI_INT, i, 0, MPI_COMM_WORLD, istatus);
258	+	char* recvBuffer = new char[recvLength];
259	+	if (recvBuffer == NULL) {
260	+	} else {
261	+	MPI_Recv(recvBuffer, recvLength, MPI_CHAR, i, 0, MPI_COMM_WORLD,
262	+	istatus);
263	+	if (createRestFile_) (*output_) << recvBuffer;
264	+
265	+	delete [] recvBuffer;
266	+	}
267	+	}
268	+	(*output_).flush();
269	+	} else {
270	+	int sendBufferLength = buffer.size() + 1;
271	+	MPI_Send(&sendBufferLength, 1, MPI_INT, masterNode, 0, MPI_COMM_WORLD);
272	+	MPI_Send((void *)buffer.c_str(), sendBufferLength,
273	+	MPI_CHAR, masterNode, 0, MPI_COMM_WORLD);
274	+	}
275	+	}
276	+	#endif // is_mpi
277	+	}
278	+
279	+
280	+	RestWriter::~RestWriter() {
281	+
282		#ifdef IS_MPI
182	–	finalOut.close();
183	–	#endif
283
284	+	if (worldRank == 0) {
285	+	#endif // is_mpi
286	+	if (createRestFile_){
287	+	writeClosing(*output_);
288	+	delete output_;
289	+	}
290	+	#ifdef IS_MPI
291	+	}
292	+	#endif // is_mpi
293		}
294
295	<	}
295	>	void RestWriter::writeClosing(std::ostream& os) {
296	>	os.flush();
297	>	}
298	>
299	>	}// end namespace OpenMD
300	>

Comparing trunk/src/io/RestWriter.cpp (property svn:keywords):
Revision 423 by chrisfen, Thu Mar 10 19:11:02 2005 UTC vs.
Revision 2021 by gezelter, Tue Sep 23 15:25:08 2014 UTC

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

Diff Legend

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