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

Comparing trunk/OOPSE/libmdtools/DumpWriter.cpp (file contents):
Revision 927 by tim, Mon Jan 12 22:54:42 2004 UTC vs.
Revision 1097 by gezelter, Mon Apr 12 20:32:20 2004 UTC

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

Diff Legend

Comparing trunk/OOPSE/libmdtools/DumpWriter.cpp (file contents):
Revision 927 by tim, Mon Jan 12 22:54:42 2004 UTC vs.
Revision 1097 by gezelter, Mon Apr 12 20:32:20 2004 UTC