[ViewVC] Diff of: group/trunk/OOPSE/libmdtools/DumpWriter.cpp

Comparing trunk/OOPSE/libmdtools/DumpWriter.cpp (file contents):
Revision 916 by gezelter, Fri Jan 9 20:29:32 2004 UTC vs.
Revision 1000 by tim, Fri Jan 30 21:47:22 2004 UTC

#	Line 3 \| Line 3
3		#include <string.h>
4		#include <iostream>
5		#include <fstream>
6	+	#include <algorithm>
7	+	#include <utility>
8
9		#ifdef IS_MPI
10		#include <mpi.h>
#	Line 26 \| Line 28 \| *DumpWriter::DumpWriter( SimInfo the_entry_plug ){**
28		if(worldRank == 0 ){
29		#endif // is_mpi
30
31	<	strcpy( outName, entry_plug->sampleName );
31	>	dumpFile.open(entry_plug->sampleName, ios::out \| ios::trunc );
32
33	<	outFile.open(outName, ios::out \| ios::trunc );
33	>	if( !dumpFile ){
34
33	–	if( !outFile ){
34	–
35		sprintf( painCave.errMsg,
36		"Could not open \"%s\" for dump output.\n",
37	<	outName);
37	>	entry_plug->sampleName);
38		painCave.isFatal = 1;
39		simError();
40		}
41
42	–	//outFile.setf( ios::scientific );
43	–
42		#ifdef IS_MPI
43		}
44
45	+	//sort the local atoms by global index
46	+	sortByGlobalIndex();
47	+
48		sprintf( checkPointMsg,
49		"Sucessfully opened output file for dumping.\n");
50		MPIcheckPoint();
#	Line 56 \| Line 57 \| DumpWriter::~DumpWriter( ){
57		if(worldRank == 0 ){
58		#endif // is_mpi
59
60	<	outFile.close();
60	>	dumpFile.close();
61
62		#ifdef IS_MPI
63		}
64		#endif // is_mpi
65		}
66
67	<	void DumpWriter::writeDump( double currentTime ){
67	>	#ifdef IS_MPI
68
69	<	const int BUFFERSIZE = 2000;
70	<	const int MINIBUFFERSIZE = 100;
69	>	/**
70	>	* A hook function to load balancing
71	>	*/
72
73	<	char tempBuffer[BUFFERSIZE];
74	<	char writeLine[BUFFERSIZE];
75	<
74	<	int i;
75	<
76	<	#ifdef IS_MPI
73	>	void DumpWriter::update(){
74	>	sortByGlobalIndex();
75	>	}
76
77	<	int *potatoes;
78	<	int myPotato;
77	>	/**
78	>	* Auxiliary sorting function
79	>	*/
80	>
81	>	bool indexSortingCriterion(const pair<int, int>& p1, const pair<int, int>& p2){
82	>	return p1.second < p2.second;
83	>	}
84
85	<	int nProc;
86	<	int j, which_node, done, which_atom, local_index;
87	<	double atomData6[6];
88	<	double atomData13[13];
89	<	int isDirectional;
86	<	char* atomTypeString;
87	<	char MPIatomTypeString[MINIBUFFERSIZE];
88	<
89	<	#else //is_mpi
90	<	int nAtoms = entry_plug->n_atoms;
91	<	#endif //is_mpi
92	<
93	<	double q[4];
94	<	DirectionalAtom* dAtom;
85	>	/**
86	>	* Sorting the local index by global index
87	>	*/
88	>
89	>	void DumpWriter::sortByGlobalIndex(){
90		Atom** atoms = entry_plug->atoms;
91	<	double pos[3], vel[3];
91	>
92	>	indexArray.clear();
93	>
94	>	for(int i = 0; i < mpiSim->getMyNlocal();i++)
95	>	indexArray.push_back(make_pair(i, atoms[i]->getGlobalIndex()));
96	>
97	>	sort(indexArray.begin(), indexArray.end(), indexSortingCriterion);
98	>	}
99
100	<	// write current frame to the eor file
100	>	#endif
101
102	<	this->writeFinal( currentTime );
102	>	void DumpWriter::writeDump(double currentTime){
103
104	<	#ifndef IS_MPI
104	>	ofstream finalOut;
105	>	vector<ofstream*> fileStreams;
106
107	<	outFile << nAtoms << "\n";
108	<
109	<	outFile << currentTime << ";\t"
110	<	<< entry_plug->Hmat[0][0] << "\t"
111	<	<< entry_plug->Hmat[1][0] << "\t"
112	<	<< entry_plug->Hmat[2][0] << ";\t"
113	<
114	<	<< entry_plug->Hmat[0][1] << "\t"
115	<	<< entry_plug->Hmat[1][1] << "\t"
116	<	<< entry_plug->Hmat[2][1] << ";\t"
114	<
115	<	<< entry_plug->Hmat[0][2] << "\t"
116	<	<< entry_plug->Hmat[1][2] << "\t"
117	<	<< entry_plug->Hmat[2][2] << ";";
118	<	//write out additional parameters, such as chi and eta
119	<	outFile << entry_plug->the_integrator->getAdditionalParameters();
120	<	outFile << endl;
121	<
122	<	for( i=0; i<nAtoms; i++ ){
123	<
124	<	atoms[i]->getPos(pos);
125	<	atoms[i]->getVel(vel);
126	<
127	<	sprintf( tempBuffer,
128	<	"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
129	<	atoms[i]->getType(),
130	<	pos[0],
131	<	pos[1],
132	<	pos[2],
133	<	vel[0],
134	<	vel[1],
135	<	vel[2]);
136	<	strcpy( writeLine, tempBuffer );
137	<
138	<	if( atoms[i]->isDirectional() ){
139	<
140	<	dAtom = (DirectionalAtom *)atoms[i];
141	<	dAtom->getQ( q );
142	<
143	<	sprintf( tempBuffer,
144	<	"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
145	<	q[0],
146	<	q[1],
147	<	q[2],
148	<	q[3],
149	<	dAtom->getJx(),
150	<	dAtom->getJy(),
151	<	dAtom->getJz());
152	<	strcat( writeLine, tempBuffer );
107	>	#ifdef IS_MPI
108	>	if(worldRank == 0 ){
109	>	#endif
110	>	finalOut.open( entry_plug->finalName, ios::out \| ios::trunc );
111	>	if( !finalOut ){
112	>	sprintf( painCave.errMsg,
113	>	"Could not open \"%s\" for final dump output.\n",
114	>	entry_plug->finalName );
115	>	painCave.isFatal = 1;
116	>	simError();
117		}
118	<	else
155	<	strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
156	<
157	<	outFile << writeLine;
118	>	#ifdef IS_MPI
119		}
120	<	outFile.flush();
120	>	#endif // is_mpi
121
122	<	#else // is_mpi
122	>	fileStreams.push_back(&finalOut);
123	>	fileStreams.push_back(&dumpFile);
124
125	<	/* code to find maximum tag value */
164	<	int *tagub, flag, MAXTAG;
165	<	MPI_Attr_get(MPI_COMM_WORLD, MPI_TAG_UB, &tagub, &flag);
166	<	if (flag) {
167	<	MAXTAG = *tagub;
168	<	} else {
169	<	MAXTAG = 32767;
170	<	}
125	>	writeFrame(fileStreams, currentTime);
126
127	<	int haveError;
127	>	#ifdef IS_MPI
128	>	finalOut.close();
129	>	#endif
130	>
131	>	}
132
133	<	MPI_Status istatus;
175	<	int *AtomToProcMap = mpiSim->getAtomToProcMap();
133	>	void DumpWriter::writeFinal(double currentTime){
134
135	<	// write out header and node 0's coordinates
135	>	ofstream finalOut;
136	>	vector<ofstream*> fileStreams;
137
138	<	if( worldRank == 0 ){
138	>	#ifdef IS_MPI
139	>	if(worldRank == 0 ){
140	>	#endif // is_mpi
141
142	<	// Node 0 needs a list of the magic potatoes for each processor;
142	>	finalOut.open( entry_plug->finalName, ios::out \| ios::trunc );
143
144	<	nProc = mpiSim->getNumberProcessors();
145	<	potatoes = new int[nProc];
146	<
147	<	for (i = 0; i < nProc; i++)
148	<	potatoes[i] = 0;
149	<
189	<	outFile << mpiSim->getTotAtoms() << "\n";
190	<
191	<	outFile << currentTime << ";\t"
192	<	<< entry_plug->Hmat[0][0] << "\t"
193	<	<< entry_plug->Hmat[1][0] << "\t"
194	<	<< entry_plug->Hmat[2][0] << ";\t"
195	<
196	<	<< entry_plug->Hmat[0][1] << "\t"
197	<	<< entry_plug->Hmat[1][1] << "\t"
198	<	<< entry_plug->Hmat[2][1] << ";\t"
199	<
200	<	<< entry_plug->Hmat[0][2] << "\t"
201	<	<< entry_plug->Hmat[1][2] << "\t"
202	<	<< entry_plug->Hmat[2][2] << ";";
203	<
204	<	outFile << entry_plug->the_integrator->getAdditionalParameters();
205	<	outFile << endl;
206	<	outFile.flush();
207	<
208	<	for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
209	<
210	<	// Get the Node number which has this atom;
211	<
212	<	which_node = AtomToProcMap[i];
213	<
214	<	if (which_node != 0) {
215	<
216	<	if (potatoes[which_node] + 3 >= MAXTAG) {
217	<	// The potato was going to exceed the maximum value,
218	<	// so wrap this processor potato back to 0:
219	<
220	<	potatoes[which_node] = 0;
221	<	MPI_Send(0, 1, MPI_INT, which_node, 0, MPI_COMM_WORLD);
222	<
223	<	}
224	<
225	<	myPotato = potatoes[which_node];
226	<
227	<	MPI_Recv(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node,
228	<	myPotato, MPI_COMM_WORLD, &istatus);
229	<
230	<	strncpy(atomTypeString, MPIatomTypeString, MINIBUFFERSIZE);
231	<
232	<	// Null terminate the atomTypeString just in case:
233	<
234	<	atomTypeString[strlen(atomTypeString) - 1] = '\0';
235	<
236	<	myPotato++;
237	<
238	<	MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
239	<	myPotato, MPI_COMM_WORLD, &istatus);
240	<
241	<	myPotato++;
242	<
243	<	if (isDirectional) {
244	<	MPI_Recv(atomData13, 13, MPI_DOUBLE, which_node,
245	<	myPotato, MPI_COMM_WORLD, &istatus);
246	<	} else {
247	<	MPI_Recv(atomData6, 6, MPI_DOUBLE, which_node,
248	<	myPotato, MPI_COMM_WORLD, &istatus);
249	<	}
250	<
251	<	myPotato++;
252	<	potatoes[which_node] = myPotato;
253	<
254	<	} else {
255	<
256	<	haveError = 0;
257	<	which_atom = i;
258	<	local_index=-1;
259	<
260	<	for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
261	<	if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
262	<	}
263	<
264	<	if (local_index != -1) {
265	<
266	<	atomTypeString = atoms[local_index]->getType();
267	<
268	<	atoms[local_index]->getPos(pos);
269	<	atoms[local_index]->getVel(vel);
270	<
271	<	atomData6[0] = pos[0];
272	<	atomData6[1] = pos[1];
273	<	atomData6[2] = pos[2];
274	<
275	<	atomData6[3] = vel[0];
276	<	atomData6[4] = vel[1];
277	<	atomData6[5] = vel[2];
278	<
279	<	isDirectional = 0;
280	<
281	<	if( atoms[local_index]->isDirectional() ){
282	<
283	<	isDirectional = 1;
284	<
285	<	dAtom = (DirectionalAtom *)atoms[local_index];
286	<	dAtom->getQ( q );
287	<
288	<	for (int j = 0; j < 6 ; j++)
289	<	atomData13[j] = atomData6[j];
290	<
291	<	atomData13[6] = q[0];
292	<	atomData13[7] = q[1];
293	<	atomData13[8] = q[2];
294	<	atomData13[9] = q[3];
295	<
296	<	atomData13[10] = dAtom->getJx();
297	<	atomData13[11] = dAtom->getJy();
298	<	atomData13[12] = dAtom->getJz();
299	<	}
300	<
301	<	} else {
302	<	sprintf(painCave.errMsg,
303	<	"Atom %d not found on processor %d\n",
304	<	i, worldRank );
305	<	haveError= 1;
306	<	simError();
307	<	}
308	<
309	<	if(haveError) DieDieDie();
310	<
311	<	// If we've survived to here, format the line:
312	<
313	<	if (!isDirectional) {
314	<
315	<	sprintf( tempBuffer,
316	<	"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
317	<	atomTypeString,
318	<	atomData6[0],
319	<	atomData6[1],
320	<	atomData6[2],
321	<	atomData6[3],
322	<	atomData6[4],
323	<	atomData6[5]);
324	<
325	<	strcpy( writeLine, tempBuffer );
326	<	strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
327	<
328	<	} else {
329	<
330	<	sprintf( tempBuffer,
331	<	"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
332	<	atomTypeString,
333	<	atomData13[0],
334	<	atomData13[1],
335	<	atomData13[2],
336	<	atomData13[3],
337	<	atomData13[4],
338	<	atomData13[5],
339	<	atomData13[6],
340	<	atomData13[7],
341	<	atomData13[8],
342	<	atomData13[9],
343	<	atomData13[10],
344	<	atomData13[11],
345	<	atomData13[12]);
346	<
347	<	strcat( writeLine, tempBuffer );
348	<
349	<	}
350	<
351	<	outFile << writeLine;
352	<	outFile.flush();
353	<	}
144	>	if( !finalOut ){
145	>	sprintf( painCave.errMsg,
146	>	"Could not open \"%s\" for final dump output.\n",
147	>	entry_plug->finalName );
148	>	painCave.isFatal = 1;
149	>	simError();
150		}
151
152	<	outFile.flush();
153	<	sprintf( checkPointMsg,
154	<	"Sucessfully took a dump.\n");
155	<	MPIcheckPoint();
156	<
157	<	} else {
362	<
363	<	// worldRank != 0, so I'm a remote node.
364	<
365	<	// Set my magic potato to 0:
366	<
367	<	myPotato = 0;
368	<
369	<	for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
370	<
371	<	// Am I the node which has this atom?
372	<
373	<	if (AtomToProcMap[i] == worldRank) {
374	<
375	<	if (myPotato + 3 >= MAXTAG) {
376	<
377	<	// The potato was going to exceed the maximum value,
378	<	// so wrap this processor potato back to 0 (and block until
379	<	// node 0 says we can go:
380	<
381	<	MPI_Recv(&myPotato, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &istatus);
382	<
383	<	}
384	<
385	<	local_index=-1;
386	<	for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
387	<	if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
388	<	}
389	<	if (local_index != -1) {
390	<
391	<	atomTypeString = atoms[local_index]->getType();
392	<
393	<	atoms[local_index]->getPos(pos);
394	<	atoms[local_index]->getVel(vel);
395	<
396	<	atomData6[0] = pos[0];
397	<	atomData6[1] = pos[1];
398	<	atomData6[2] = pos[2];
399	<
400	<	atomData6[3] = vel[0];
401	<	atomData6[4] = vel[1];
402	<	atomData6[5] = vel[2];
403	<
404	<	isDirectional = 0;
405	<
406	<	if( atoms[local_index]->isDirectional() ){
152	>	#ifdef IS_MPI
153	>	}
154	>	#endif // is_mpi
155	>
156	>	fileStreams.push_back(&finalOut);
157	>	writeFrame(fileStreams, currentTime);
158
159	<	isDirectional = 1;
160	<
161	<	dAtom = (DirectionalAtom *)atoms[local_index];
411	<	dAtom->getQ( q );
412	<
413	<	for (int j = 0; j < 6 ; j++)
414	<	atomData13[j] = atomData6[j];
415	<
416	<	atomData13[6] = q[0];
417	<	atomData13[7] = q[1];
418	<	atomData13[8] = q[2];
419	<	atomData13[9] = q[3];
420	<
421	<	atomData13[10] = dAtom->getJx();
422	<	atomData13[11] = dAtom->getJy();
423	<	atomData13[12] = dAtom->getJz();
424	<	}
425	<
426	<	} else {
427	<	sprintf(painCave.errMsg,
428	<	"Atom %d not found on processor %d\n",
429	<	i, worldRank );
430	<	haveError= 1;
431	<	simError();
432	<	}
433	<
434	<	strncpy(MPIatomTypeString, atomTypeString, MINIBUFFERSIZE);
435	<
436	<	// null terminate the string before sending (just in case):
437	<	MPIatomTypeString[MINIBUFFERSIZE-1] = '\0';
438	<
439	<	MPI_Send(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0,
440	<	myPotato, MPI_COMM_WORLD);
441	<
442	<	myPotato++;
443	<
444	<	MPI_Send(&isDirectional, 1, MPI_INT, 0,
445	<	myPotato, MPI_COMM_WORLD);
446	<
447	<	myPotato++;
448	<
449	<	if (isDirectional) {
450	<
451	<	MPI_Send(atomData13, 13, MPI_DOUBLE, 0,
452	<	myPotato, MPI_COMM_WORLD);
453	<
454	<	} else {
455	<
456	<	MPI_Send(atomData6, 6, MPI_DOUBLE, 0,
457	<	myPotato, MPI_COMM_WORLD);
458	<	}
459	<
460	<	myPotato++;
461	<	}
462	<	}
463	<
464	<	sprintf( checkPointMsg,
465	<	"Sucessfully took a dump.\n");
466	<	MPIcheckPoint();
467	<
468	<	}
159	>	#ifdef IS_MPI
160	>	finalOut.close();
161	>	#endif
162
470	–	#endif // is_mpi
163		}
164
165	<	void DumpWriter::writeFinal(double finalTime){
165	>	void DumpWriter::writeFrame( vector<ofstream*>& outFile, double currentTime ){
166
475	–	char finalName[500];
476	–	ofstream finalOut;
477	–
167		const int BUFFERSIZE = 2000;
168		const int MINIBUFFERSIZE = 100;
169	<	char tempBuffer[BUFFERSIZE];
169	>
170	>	char tempBuffer[BUFFERSIZE];
171		char writeLine[BUFFERSIZE];
172
173	<	double q[4];
174	<	DirectionalAtom* dAtom;
485	<	Atom** atoms = entry_plug->atoms;
486	<	int i;
173	>	int i, k;
174	>
175		#ifdef IS_MPI
176
177	+	/*********************************************************************
178	+	* Documentation? You want DOCUMENTATION?
179	+	*
180	+	* Why all the potatoes below?
181	+	*
182	+	* To make a long story short, the original version of DumpWriter
183	+	* worked in the most inefficient way possible. Node 0 would
184	+	* poke each of the node for an individual atom's formatted data
185	+	* as node 0 worked its way down the global index. This was particularly
186	+	* inefficient since the method blocked all processors at every atom
187	+	* (and did it twice!).
188	+	*
189	+	* An intermediate version of DumpWriter could be described from Node
190	+	* zero's perspective as follows:
191	+	*
192	+	* 1) Have 100 of your friends stand in a circle.
193	+	* 2) When you say go, have all of them start tossing potatoes at
194	+	* you (one at a time).
195	+	* 3) Catch the potatoes.
196	+	*
197	+	* It was an improvement, but MPI has buffers and caches that could
198	+	* best be described in this analogy as "potato nets", so there's no
199	+	* need to block the processors atom-by-atom.
200	+	*
201	+	* This new and improved DumpWriter works in an even more efficient
202	+	* way:
203	+	*
204	+	* 1) Have 100 of your friend stand in a circle.
205	+	* 2) When you say go, have them start tossing 5-pound bags of
206	+	* potatoes at you.
207	+	* 3) Once you've caught a friend's bag of potatoes,
208	+	* toss them a spud to let them know they can toss another bag.
209	+	*
210	+	* How's THAT for documentation?
211	+	*
212	+	*********************************************************************/
213	+
214		int *potatoes;
215		int myPotato;
216
217		int nProc;
218	<	int j, which_node, done, which_atom, local_index;
218	>	int j, which_node, done, which_atom, local_index, currentIndex;
219		double atomData6[6];
220		double atomData13[13];
221		int isDirectional;
#	Line 501 \| Line 226 \| void DumpWriter::writeFinal(double finalTime){
226		int nAtoms = entry_plug->n_atoms;
227		#endif //is_mpi
228
229	+	double q[4];
230	+	DirectionalAtom* dAtom;
231	+	Atom** atoms = entry_plug->atoms;
232		double pos[3], vel[3];
233
506	–	#ifdef IS_MPI
507	–	if(worldRank == 0 ){
508	–	#endif // is_mpi
509	–
510	–	strcpy( finalName, entry_plug->finalName );
511	–
512	–	finalOut.open( finalName, ios::out \| ios::trunc );
513	–	if( !finalOut ){
514	–	sprintf( painCave.errMsg,
515	–	"Could not open \"%s\" for final dump output.\n",
516	–	finalName );
517	–	painCave.isFatal = 1;
518	–	simError();
519	–	}
520	–
521	–	// finalOut.setf( ios::scientific );
522	–
523	–	#ifdef IS_MPI
524	–	}
525	–
526	–	sprintf(checkPointMsg,"Opened file for final configuration\n");
527	–	MPIcheckPoint();
528	–
529	–	#endif //is_mpi
530	–
531	–
234		#ifndef IS_MPI
235	+
236	+	for(k = 0; k < outFile.size(); k++){
237	+	*outFile[k] << nAtoms << "\n";
238
239	<	finalOut << nAtoms << "\n";
239	>	*outFile[k] << currentTime << ";\t"
240	>	<< entry_plug->Hmat[0][0] << "\t"
241	>	<< entry_plug->Hmat[1][0] << "\t"
242	>	<< entry_plug->Hmat[2][0] << ";\t"
243	>
244	>	<< entry_plug->Hmat[0][1] << "\t"
245	>	<< entry_plug->Hmat[1][1] << "\t"
246	>	<< entry_plug->Hmat[2][1] << ";\t"
247
248	<	finalOut << finalTime << ";\t"
249	<	<< entry_plug->Hmat[0][0] << "\t"
250	<	<< entry_plug->Hmat[1][0] << "\t"
539	<	<< entry_plug->Hmat[2][0] << ";\t"
248	>	<< entry_plug->Hmat[0][2] << "\t"
249	>	<< entry_plug->Hmat[1][2] << "\t"
250	>	<< entry_plug->Hmat[2][2] << ";";
251
252	<	<< entry_plug->Hmat[0][1] << "\t"
253	<	<< entry_plug->Hmat[1][1] << "\t"
254	<	<< entry_plug->Hmat[2][1] << ";\t"
255	<
545	<	<< entry_plug->Hmat[0][2] << "\t"
546	<	<< entry_plug->Hmat[1][2] << "\t"
547	<	<< entry_plug->Hmat[2][2] << ";";
548	<
549	<	//write out additional parameters, such as chi and eta
550	<	finalOut << entry_plug->the_integrator->getAdditionalParameters();
551	<	finalOut << endl;
552	<
252	>	//write out additional parameters, such as chi and eta
253	>	*outFile[k] << entry_plug->the_integrator->getAdditionalParameters() << endl;
254	>	}
255	>
256		for( i=0; i<nAtoms; i++ ){
257
258		atoms[i]->getPos(pos);
#	Line 585 \| Line 288 \| void DumpWriter::writeFinal(double finalTime){
288		else
289		strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
290
291	<	finalOut << writeLine;
291	>	for(k = 0; k < outFile.size(); k++)
292	>	*outFile[k] << writeLine;
293		}
590	–	finalOut.flush();
591	–	finalOut.close();
294
295		#else // is_mpi
296
297		/* code to find maximum tag value */
298	+
299		int *tagub, flag, MAXTAG;
300		MPI_Attr_get(MPI_COMM_WORLD, MPI_TAG_UB, &tagub, &flag);
301		if (flag) {
#	Line 615 \| Line 318 \| void DumpWriter::writeFinal(double finalTime){
318		nProc = mpiSim->getNumberProcessors();
319		potatoes = new int[nProc];
320
321	+	//write out the comment lines
322		for (i = 0; i < nProc; i++)
323		potatoes[i] = 0;
324
325	<	finalOut << mpiSim->getTotAtoms() << "\n";
325	>	for(k = 0; k < outFile.size(); k++){
326	>	*outFile[k] << mpiSim->getTotAtoms() << "\n";
327
328	<	finalOut << finalTime << ";\t"
329	<	<< entry_plug->Hmat[0][0] << "\t"
330	<	<< entry_plug->Hmat[1][0] << "\t"
331	<	<< entry_plug->Hmat[2][0] << ";\t"
328	>	*outFile[k] << currentTime << ";\t"
329	>	<< entry_plug->Hmat[0][0] << "\t"
330	>	<< entry_plug->Hmat[1][0] << "\t"
331	>	<< entry_plug->Hmat[2][0] << ";\t"
332
333	<	<< entry_plug->Hmat[0][1] << "\t"
334	<	<< entry_plug->Hmat[1][1] << "\t"
335	<	<< entry_plug->Hmat[2][1] << ";\t"
333	>	<< entry_plug->Hmat[0][1] << "\t"
334	>	<< entry_plug->Hmat[1][1] << "\t"
335	>	<< entry_plug->Hmat[2][1] << ";\t"
336
337	<	<< entry_plug->Hmat[0][2] << "\t"
338	<	<< entry_plug->Hmat[1][2] << "\t"
339	<	<< entry_plug->Hmat[2][2] << ";";
337	>	<< entry_plug->Hmat[0][2] << "\t"
338	>	<< entry_plug->Hmat[1][2] << "\t"
339	>	<< entry_plug->Hmat[2][2] << ";";
340	>
341	>	*outFile[k] << entry_plug->the_integrator->getAdditionalParameters() << endl;
342	>	}
343
344	<	finalOut << entry_plug->the_integrator->getAdditionalParameters();
637	<	finalOut << endl;
638	<	finalOut.flush();
344	>	currentIndex = 0;
345
346		for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
347
#	Line 659 \| Line 365 \| void DumpWriter::writeFinal(double finalTime){
365		MPI_Recv(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node,
366		myPotato, MPI_COMM_WORLD, &istatus);
367
368	<	strncpy(atomTypeString, MPIatomTypeString, MINIBUFFERSIZE);
369	<
664	<	// Null terminate the atomTypeString just in case:
665	<
666	<	atomTypeString[strlen(atomTypeString) - 1] = '\0';
667	<
368	>	atomTypeString = MPIatomTypeString;
369	>
370		myPotato++;
371
372		MPI_Recv(&isDirectional, 1, MPI_INT, which_node,
#	Line 685 \| Line 387 \| void DumpWriter::writeFinal(double finalTime){
387
388		} else {
389
390	<	haveError = 0;
390	>	haveError = 0;
391		which_atom = i;
690	–	local_index=-1;
392
393	<	for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
693	<	if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
694	<	}
695	<
696	<	if (local_index != -1) {
393	>	local_index = indexArray[currentIndex].first;
394
395	<	atomTypeString = atoms[local_index]->getType();
396	<
395	>	if (which_atom == indexArray[currentIndex].second) {
396	>
397	>	atomTypeString = atoms[local_index]->getType();
398	>
399		atoms[local_index]->getPos(pos);
400		atoms[local_index]->getVel(vel);
401	<
401	>
402		atomData6[0] = pos[0];
403		atomData6[1] = pos[1];
404		atomData6[2] = pos[2];
#	Line 732 \| Line 431 \| void DumpWriter::writeFinal(double finalTime){
431
432		} else {
433		sprintf(painCave.errMsg,
434	<	"Atom %d not found on processor %d\n",
435	<	i, worldRank );
434	>	"Atom %d not found on processor %d, currentIndex = %d, local_index = %d\n",
435	>	which_atom, worldRank, currentIndex, local_index );
436		haveError= 1;
437		simError();
438		}
439
440	<	if(haveError) DieDieDie();
440	>	if(haveError) DieDieDie();
441
442	<	// If we've survived to here, format the line:
443	<
444	<	if (!isDirectional) {
445	<
446	<	sprintf( tempBuffer,
447	<	"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
448	<	atomTypeString,
449	<	atomData6[0],
450	<	atomData6[1],
451	<	atomData6[2],
452	<	atomData6[3],
453	<	atomData6[4],
454	<	atomData6[5]);
455	<
456	<	strcpy( writeLine, tempBuffer );
457	<	strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
458	<
459	<	} else {
460	<
461	<	sprintf( tempBuffer,
462	<	"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
463	<	atomTypeString,
464	<	atomData13[0],
465	<	atomData13[1],
466	<	atomData13[2],
467	<	atomData13[3],
468	<	atomData13[4],
469	<	atomData13[5],
470	<	atomData13[6],
471	<	atomData13[7],
472	<	atomData13[8],
473	<	atomData13[9],
474	<	atomData13[10],
475	<	atomData13[11],
476	<	atomData13[12]);
477	<
779	<	strcat( writeLine, tempBuffer );
780	<
781	<	}
442	>	currentIndex++;
443	>	}
444	>	// If we've survived to here, format the line:
445	>
446	>	if (!isDirectional) {
447	>
448	>	sprintf( writeLine,
449	>	"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t",
450	>	atomTypeString,
451	>	atomData6[0],
452	>	atomData6[1],
453	>	atomData6[2],
454	>	atomData6[3],
455	>	atomData6[4],
456	>	atomData6[5]);
457	>
458	>	strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" );
459	>
460	>	} else {
461	>
462	>	sprintf( writeLine,
463	>	"%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",
464	>	atomTypeString,
465	>	atomData13[0],
466	>	atomData13[1],
467	>	atomData13[2],
468	>	atomData13[3],
469	>	atomData13[4],
470	>	atomData13[5],
471	>	atomData13[6],
472	>	atomData13[7],
473	>	atomData13[8],
474	>	atomData13[9],
475	>	atomData13[10],
476	>	atomData13[11],
477	>	atomData13[12]);
478
783	–	finalOut << writeLine;
784	–	finalOut.flush();
479		}
480	+
481	+	for(k = 0; k < outFile.size(); k++)
482	+	*outFile[k] << writeLine;
483		}
484	<
485	<	finalOut.flush();
484	>
485	>	for(k = 0; k < outFile.size(); k++)
486	>	outFile[k]->flush();
487	>
488		sprintf( checkPointMsg,
489		"Sucessfully took a dump.\n");
490	+
491		MPIcheckPoint();
492
493	+	delete[] potatoes;
494	+
495		} else {
496
497		// worldRank != 0, so I'm a remote node.
#	Line 797 \| Line 499 \| void DumpWriter::writeFinal(double finalTime){
499		// Set my magic potato to 0:
500
501		myPotato = 0;
502	+	currentIndex = 0;
503
504		for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) {
505
#	Line 805 \| Line 508 \| void DumpWriter::writeFinal(double finalTime){
508		if (AtomToProcMap[i] == worldRank) {
509
510		if (myPotato + 3 >= MAXTAG) {
511	<
511	>
512		// The potato was going to exceed the maximum value,
513		// so wrap this processor potato back to 0 (and block until
514		// node 0 says we can go:
515	<
515	>
516		MPI_Recv(&myPotato, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &istatus);
517
518		}
519	+	which_atom = i;
520
521	<	local_index=-1;
522	<	for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) {
523	<	if (atoms[j]->getGlobalIndex() == which_atom) local_index = j;
820	<	}
821	<	if (local_index != -1) {
521	>	local_index = indexArray[currentIndex].first;
522	>
523	>	if (which_atom == indexArray[currentIndex].second) {
524
525		atomTypeString = atoms[local_index]->getType();
526	<
526	>
527		atoms[local_index]->getPos(pos);
528		atoms[local_index]->getVel(vel);
529	<
529	>
530		atomData6[0] = pos[0];
531		atomData6[1] = pos[1];
532		atomData6[2] = pos[2];
#	Line 849 \| Line 551 \| void DumpWriter::writeFinal(double finalTime){
551		atomData13[7] = q[1];
552		atomData13[8] = q[2];
553		atomData13[9] = q[3];
554	<
554	>
555		atomData13[10] = dAtom->getJx();
556		atomData13[11] = dAtom->getJy();
557		atomData13[12] = dAtom->getJz();
#	Line 857 \| Line 559 \| void DumpWriter::writeFinal(double finalTime){
559
560		} else {
561		sprintf(painCave.errMsg,
562	<	"Atom %d not found on processor %d\n",
563	<	i, worldRank );
562	>	"Atom %d not found on processor %d, currentIndex = %d, local_index = %d\n",
563	>	which_atom, worldRank, currentIndex, local_index );
564		haveError= 1;
565		simError();
566		}
567	<
567	>
568		strncpy(MPIatomTypeString, atomTypeString, MINIBUFFERSIZE);
569
570		// null terminate the string before sending (just in case):
571		MPIatomTypeString[MINIBUFFERSIZE-1] = '\0';
572
573		MPI_Send(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0,
574	<	myPotato, MPI_COMM_WORLD);
574	>	myPotato, MPI_COMM_WORLD);
575
576		myPotato++;
577
578		MPI_Send(&isDirectional, 1, MPI_INT, 0,
579	<	myPotato, MPI_COMM_WORLD);
579	>	myPotato, MPI_COMM_WORLD);
580
581		myPotato++;
582
#	Line 889 \| Line 591 \| void DumpWriter::writeFinal(double finalTime){
591		myPotato, MPI_COMM_WORLD);
592		}
593
594	<	myPotato++;
594	>	myPotato++;
595	>	currentIndex++;
596		}
597		}
598
#	Line 899 \| Line 602 \| void DumpWriter::writeFinal(double finalTime){
602
603		}
604
902	–	if( worldRank == 0 ) finalOut.close();
605		#endif // is_mpi
606		}
607
906	–
907	–
608		#ifdef IS_MPI
609
610		// a couple of functions to let us escape the write loop

Diff Legend

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

Comparing trunk/OOPSE/libmdtools/DumpWriter.cpp (file contents): Revision 916 by gezelter, Fri Jan 9 20:29:32 2004 UTC vs. Revision 1000 by tim, Fri Jan 30 21:47:22 2004 UTC

Diff Legend

Comparing trunk/OOPSE/libmdtools/DumpWriter.cpp (file contents):
Revision 916 by gezelter, Fri Jan 9 20:29:32 2004 UTC vs.
Revision 1000 by tim, Fri Jan 30 21:47:22 2004 UTC