# | Line 72 | Line 72 | void DumpWriter::writeDump( double currentTime ){ | |
---|---|---|
72 | char writeLine[BUFFERSIZE]; | |
73 | ||
74 | int i; | |
75 | + | |
76 | #ifdef IS_MPI | |
77 | + | |
78 | + | int *potatoes; |
79 | + | int myPotato; |
80 | + | |
81 | + | int nProc; |
82 | int j, which_node, done, which_atom, local_index; | |
83 | < | double atomTransData[6]; |
84 | < | double atomOrientData[7]; |
83 | > | double atomData6[6]; |
84 | > | double atomData13[13]; |
85 | int isDirectional; | |
86 | char* atomTypeString; | |
87 | char MPIatomTypeString[MINIBUFFERSIZE]; | |
88 | < | int me; |
83 | < | int atomTypeTag; |
84 | < | int atomIsDirectionalTag; |
85 | < | int atomTransDataTag; |
86 | < | int atomOrientDataTag; |
88 | > | |
89 | #else //is_mpi | |
90 | int nAtoms = entry_plug->n_atoms; | |
91 | #endif //is_mpi | |
# | Line 158 | Line 160 | void DumpWriter::writeDump( double currentTime ){ | |
160 | ||
161 | #else // is_mpi | |
162 | ||
163 | < | // first thing first, suspend fatalities. |
164 | < | painCave.isEventLoop = 1; |
163 | > | /* code to find maximum tag value */ |
164 | > | |
165 | > | int *tagub, flag, MAXTAG; |
166 | > | MPI_Attr_get(MPI_COMM_WORLD, MPI_TAG_UB, &tagub, &flag); |
167 | > | if (flag) { |
168 | > | MAXTAG = *tagub; |
169 | > | } else { |
170 | > | MAXTAG = 32767; |
171 | > | } |
172 | ||
164 | – | int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone |
173 | int haveError; | |
174 | ||
175 | MPI_Status istatus; | |
# | Line 170 | Line 178 | void DumpWriter::writeDump( double currentTime ){ | |
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" | |
# | Line 188 | Line 205 | void DumpWriter::writeDump( double currentTime ){ | |
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 | < | |
212 | > | |
213 | which_node = AtomToProcMap[i]; | |
214 | < | |
214 | > | |
215 | if (which_node != 0) { | |
197 | – | |
198 | – | atomTypeTag = 4*i; |
199 | – | atomIsDirectionalTag = 4*i + 1; |
200 | – | atomTransDataTag = 4*i + 2; |
201 | – | atomOrientDataTag = 4*i + 3; |
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 | < | atomTypeTag, MPI_COMM_WORLD, &istatus); |
229 | > | myPotato, MPI_COMM_WORLD, &istatus); |
230 | ||
231 | < | strncpy(atomTypeString, MPIatomTypeString, MINIBUFFERSIZE); |
231 | > | //strncpy(atomTypeString, MPIatomTypeString, MINIBUFFERSIZE); |
232 | ||
233 | // Null terminate the atomTypeString just in case: | |
234 | ||
235 | < | atomTypeString[strlen(atomTypeString) - 1] = '\0'; |
235 | > | //atomTypeString[strlen(atomTypeString) - 1] = '\0'; |
236 | > | atomTypeString = MPIatomTypeString; |
237 | > | |
238 | > | myPotato++; |
239 | ||
240 | MPI_Recv(&isDirectional, 1, MPI_INT, which_node, | |
241 | < | atomIsDirectionalTag, MPI_COMM_WORLD, &istatus); |
242 | < | |
243 | < | MPI_Recv(atomTransData, 6, MPI_DOUBLE, which_node, |
216 | < | atomTransDataTag, MPI_COMM_WORLD, &istatus); |
241 | > | myPotato, MPI_COMM_WORLD, &istatus); |
242 | > | |
243 | > | myPotato++; |
244 | ||
245 | < | if (isDirectional) { |
246 | < | |
247 | < | MPI_Recv(atomOrientData, 7, MPI_DOUBLE, which_node, |
248 | < | atomOrientDataTag, MPI_COMM_WORLD, &istatus); |
249 | < | |
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 | < | |
261 | > | |
262 | for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) { | |
263 | if (atoms[j]->getGlobalIndex() == which_atom) local_index = j; | |
264 | } | |
265 | < | |
265 | > | |
266 | if (local_index != -1) { | |
267 | < | |
267 | > | |
268 | atomTypeString = atoms[local_index]->getType(); | |
269 | ||
270 | atoms[local_index]->getPos(pos); | |
271 | < | atoms[local_index]->getVel(vel); |
271 | > | atoms[local_index]->getVel(vel); |
272 | ||
273 | < | atomTransData[0] = pos[0]; |
274 | < | atomTransData[1] = pos[1]; |
275 | < | atomTransData[2] = pos[2]; |
273 | > | atomData6[0] = pos[0]; |
274 | > | atomData6[1] = pos[1]; |
275 | > | atomData6[2] = pos[2]; |
276 | ||
277 | < | atomTransData[3] = vel[0]; |
278 | < | atomTransData[4] = vel[1]; |
279 | < | atomTransData[5] = vel[2]; |
277 | > | atomData6[3] = vel[0]; |
278 | > | atomData6[4] = vel[1]; |
279 | > | atomData6[5] = vel[2]; |
280 | ||
281 | isDirectional = 0; | |
282 | ||
# | Line 255 | Line 286 | void DumpWriter::writeDump( double currentTime ){ | |
286 | ||
287 | dAtom = (DirectionalAtom *)atoms[local_index]; | |
288 | dAtom->getQ( q ); | |
258 | – | |
259 | – | atomOrientData[0] = q[0]; |
260 | – | atomOrientData[1] = q[1]; |
261 | – | atomOrientData[2] = q[2]; |
262 | – | atomOrientData[3] = q[3]; |
289 | ||
290 | < | atomOrientData[4] = dAtom->getJx(); |
291 | < | atomOrientData[5] = dAtom->getJy(); |
292 | < | atomOrientData[6] = dAtom->getJz(); |
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 | < | |
302 | > | |
303 | } else { | |
304 | sprintf(painCave.errMsg, | |
305 | "Atom %d not found on processor %d\n", | |
# | Line 273 | Line 307 | void DumpWriter::writeDump( double currentTime ){ | |
307 | haveError= 1; | |
308 | simError(); | |
309 | } | |
310 | < | |
310 | > | |
311 | if(haveError) DieDieDie(); | |
312 | < | |
312 | > | |
313 | // If we've survived to here, format the line: | |
314 | ||
315 | < | sprintf( tempBuffer, |
282 | < | "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t", |
283 | < | atomTypeString, |
284 | < | atomTransData[0], |
285 | < | atomTransData[1], |
286 | < | atomTransData[2], |
287 | < | atomTransData[3], |
288 | < | atomTransData[4], |
289 | < | atomTransData[5]); |
315 | > | if (!isDirectional) { |
316 | ||
317 | < | strcpy( writeLine, tempBuffer ); |
318 | < | |
319 | < | if (isDirectional) { |
317 | > | sprintf( tempBuffer, |
318 | > | "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t", |
319 | > | atomTypeString, |
320 | > | atomData6[0], |
321 | > | atomData6[1], |
322 | > | atomData6[2], |
323 | > | atomData6[3], |
324 | > | atomData6[4], |
325 | > | atomData6[5]); |
326 | > | |
327 | > | strcpy( writeLine, tempBuffer ); |
328 | > | strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" ); |
329 | ||
330 | + | } else { |
331 | + | |
332 | sprintf( tempBuffer, | |
333 | < | "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", |
334 | < | atomOrientData[0], |
335 | < | atomOrientData[1], |
336 | < | atomOrientData[2], |
337 | < | atomOrientData[3], |
338 | < | atomOrientData[4], |
339 | < | atomOrientData[5], |
340 | < | atomOrientData[6]); |
333 | > | "%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", |
334 | > | atomTypeString, |
335 | > | atomData13[0], |
336 | > | atomData13[1], |
337 | > | atomData13[2], |
338 | > | atomData13[3], |
339 | > | atomData13[4], |
340 | > | atomData13[5], |
341 | > | atomData13[6], |
342 | > | atomData13[7], |
343 | > | atomData13[8], |
344 | > | atomData13[9], |
345 | > | atomData13[10], |
346 | > | atomData13[11], |
347 | > | atomData13[12]); |
348 | > | |
349 | strcat( writeLine, tempBuffer ); | |
350 | < | |
306 | < | } else { |
307 | < | strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" ); |
350 | > | |
351 | } | |
352 | < | |
352 | > | |
353 | outFile << writeLine; | |
354 | outFile.flush(); | |
355 | } | |
# | Line 316 | Line 359 | void DumpWriter::writeDump( double currentTime ){ | |
359 | sprintf( checkPointMsg, | |
360 | "Sucessfully took a dump.\n"); | |
361 | MPIcheckPoint(); | |
362 | < | |
362 | > | delete[] potatoes; |
363 | } else { | |
364 | ||
365 | // worldRank != 0, so I'm a remote node. | |
366 | + | |
367 | + | // Set my magic potato to 0: |
368 | + | |
369 | + | myPotato = 0; |
370 | ||
371 | for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) { | |
372 | ||
# | Line 327 | Line 374 | void DumpWriter::writeDump( double currentTime ){ | |
374 | ||
375 | if (AtomToProcMap[i] == worldRank) { | |
376 | ||
377 | < | local_index=-1; |
377 | > | if (myPotato + 3 >= MAXTAG) { |
378 | > | |
379 | > | // The potato was going to exceed the maximum value, |
380 | > | // so wrap this processor potato back to 0 (and block until |
381 | > | // node 0 says we can go: |
382 | > | |
383 | > | MPI_Recv(&myPotato, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &istatus); |
384 | > | |
385 | > | } |
386 | > | which_atom = i; |
387 | > | local_index=-1; |
388 | for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) { | |
389 | if (atoms[j]->getGlobalIndex() == which_atom) local_index = j; | |
390 | } | |
# | Line 338 | Line 395 | void DumpWriter::writeDump( double currentTime ){ | |
395 | atoms[local_index]->getPos(pos); | |
396 | atoms[local_index]->getVel(vel); | |
397 | ||
398 | < | atomTransData[0] = pos[0]; |
399 | < | atomTransData[1] = pos[1]; |
400 | < | atomTransData[2] = pos[2]; |
398 | > | atomData6[0] = pos[0]; |
399 | > | atomData6[1] = pos[1]; |
400 | > | atomData6[2] = pos[2]; |
401 | ||
402 | < | atomTransData[3] = vel[0]; |
403 | < | atomTransData[4] = vel[1]; |
404 | < | atomTransData[5] = vel[2]; |
402 | > | atomData6[3] = vel[0]; |
403 | > | atomData6[4] = vel[1]; |
404 | > | atomData6[5] = vel[2]; |
405 | ||
406 | isDirectional = 0; | |
407 | ||
# | Line 355 | Line 412 | void DumpWriter::writeDump( double currentTime ){ | |
412 | dAtom = (DirectionalAtom *)atoms[local_index]; | |
413 | dAtom->getQ( q ); | |
414 | ||
415 | < | atomOrientData[0] = q[0]; |
416 | < | atomOrientData[1] = q[1]; |
417 | < | atomOrientData[2] = q[2]; |
418 | < | atomOrientData[3] = q[3]; |
415 | > | for (int j = 0; j < 6 ; j++) |
416 | > | atomData13[j] = atomData6[j]; |
417 | > | |
418 | > | atomData13[6] = q[0]; |
419 | > | atomData13[7] = q[1]; |
420 | > | atomData13[8] = q[2]; |
421 | > | atomData13[9] = q[3]; |
422 | ||
423 | < | atomOrientData[4] = dAtom->getJx(); |
424 | < | atomOrientData[5] = dAtom->getJy(); |
425 | < | atomOrientData[6] = dAtom->getJz(); |
423 | > | atomData13[10] = dAtom->getJx(); |
424 | > | atomData13[11] = dAtom->getJy(); |
425 | > | atomData13[12] = dAtom->getJz(); |
426 | } | |
427 | ||
428 | } else { | |
# | Line 373 | Line 433 | void DumpWriter::writeDump( double currentTime ){ | |
433 | simError(); | |
434 | } | |
435 | ||
376 | – | // I've survived this far, so send off the data! |
377 | – | |
378 | – | atomTypeTag = 4*i; |
379 | – | atomIsDirectionalTag = 4*i + 1; |
380 | – | atomTransDataTag = 4*i + 2; |
381 | – | atomOrientDataTag = 4*i + 3; |
382 | – | |
383 | – | |
436 | strncpy(MPIatomTypeString, atomTypeString, MINIBUFFERSIZE); | |
437 | ||
438 | // null terminate the string before sending (just in case): | |
439 | MPIatomTypeString[MINIBUFFERSIZE-1] = '\0'; | |
440 | ||
441 | MPI_Send(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0, | |
442 | < | atomTypeTag, MPI_COMM_WORLD); |
442 | > | myPotato, MPI_COMM_WORLD); |
443 | ||
444 | + | myPotato++; |
445 | + | |
446 | MPI_Send(&isDirectional, 1, MPI_INT, 0, | |
447 | < | atomIsDirectionalTag, MPI_COMM_WORLD); |
447 | > | myPotato, MPI_COMM_WORLD); |
448 | ||
449 | < | MPI_Send(atomTransData, 6, MPI_DOUBLE, 0, |
450 | < | atomTransDataTag, MPI_COMM_WORLD); |
397 | < | |
449 | > | myPotato++; |
450 | > | |
451 | if (isDirectional) { | |
452 | ||
453 | < | MPI_Send(atomOrientData, 7, MPI_DOUBLE, 0, |
454 | < | atomOrientDataTag, MPI_COMM_WORLD); |
453 | > | MPI_Send(atomData13, 13, MPI_DOUBLE, 0, |
454 | > | myPotato, MPI_COMM_WORLD); |
455 | ||
456 | + | } else { |
457 | + | |
458 | + | MPI_Send(atomData6, 6, MPI_DOUBLE, 0, |
459 | + | myPotato, MPI_COMM_WORLD); |
460 | } | |
461 | < | |
461 | > | |
462 | > | myPotato++; |
463 | } | |
464 | } | |
465 | ||
# | Line 409 | Line 467 | void DumpWriter::writeDump( double currentTime ){ | |
467 | "Sucessfully took a dump.\n"); | |
468 | MPIcheckPoint(); | |
469 | ||
470 | < | } |
470 | > | } |
471 | ||
414 | – | painCave.isEventLoop = 0; |
415 | – | |
472 | #endif // is_mpi | |
473 | } | |
474 | ||
# | Line 431 | Line 487 | void DumpWriter::writeFinal(double finalTime){ | |
487 | Atom** atoms = entry_plug->atoms; | |
488 | int i; | |
489 | #ifdef IS_MPI | |
490 | + | |
491 | + | int *potatoes; |
492 | + | int myPotato; |
493 | + | |
494 | + | int nProc; |
495 | int j, which_node, done, which_atom, local_index; | |
496 | < | double atomTransData[6]; |
497 | < | double atomOrientData[7]; |
496 | > | double atomData6[6]; |
497 | > | double atomData13[13]; |
498 | int isDirectional; | |
499 | char* atomTypeString; | |
500 | char MPIatomTypeString[MINIBUFFERSIZE]; | |
501 | < | int atomTypeTag; |
441 | < | int atomIsDirectionalTag; |
442 | < | int atomTransDataTag; |
443 | < | int atomOrientDataTag; |
501 | > | |
502 | #else //is_mpi | |
503 | int nAtoms = entry_plug->n_atoms; | |
504 | #endif //is_mpi | |
# | Line 536 | Line 594 | void DumpWriter::writeFinal(double finalTime){ | |
594 | ||
595 | #else // is_mpi | |
596 | ||
597 | < | // first thing first, suspend fatalities. |
598 | < | painCave.isEventLoop = 1; |
597 | > | /* code to find maximum tag value */ |
598 | > | int *tagub, flag, MAXTAG; |
599 | > | MPI_Attr_get(MPI_COMM_WORLD, MPI_TAG_UB, &tagub, &flag); |
600 | > | if (flag) { |
601 | > | MAXTAG = *tagub; |
602 | > | } else { |
603 | > | MAXTAG = 32767; |
604 | > | } |
605 | ||
542 | – | int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone |
606 | int haveError; | |
607 | ||
608 | MPI_Status istatus; | |
# | Line 548 | Line 611 | void DumpWriter::writeFinal(double finalTime){ | |
611 | // write out header and node 0's coordinates | |
612 | ||
613 | if( worldRank == 0 ){ | |
614 | + | |
615 | + | // Node 0 needs a list of the magic potatoes for each processor; |
616 | + | |
617 | + | nProc = mpiSim->getNumberProcessors(); |
618 | + | potatoes = new int[nProc]; |
619 | + | |
620 | + | for (i = 0; i < nProc; i++) |
621 | + | potatoes[i] = 0; |
622 | + | |
623 | finalOut << mpiSim->getTotAtoms() << "\n"; | |
624 | ||
625 | finalOut << finalTime << ";\t" | |
# | Line 566 | Line 638 | void DumpWriter::writeFinal(double finalTime){ | |
638 | finalOut << entry_plug->the_integrator->getAdditionalParameters(); | |
639 | finalOut << endl; | |
640 | finalOut.flush(); | |
641 | + | |
642 | for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) { | |
643 | + | |
644 | // Get the Node number which has this atom; | |
645 | < | |
645 | > | |
646 | which_node = AtomToProcMap[i]; | |
647 | < | |
647 | > | |
648 | if (which_node != 0) { | |
575 | – | |
576 | – | atomTypeTag = 4*i; |
577 | – | atomIsDirectionalTag = 4*i + 1; |
578 | – | atomTransDataTag = 4*i + 2; |
579 | – | atomOrientDataTag = 4*i + 3; |
649 | ||
650 | + | if (potatoes[which_node] + 3 >= MAXTAG) { |
651 | + | // The potato was going to exceed the maximum value, |
652 | + | // so wrap this processor potato back to 0: |
653 | + | |
654 | + | potatoes[which_node] = 0; |
655 | + | MPI_Send(0, 1, MPI_INT, which_node, 0, MPI_COMM_WORLD); |
656 | + | |
657 | + | } |
658 | + | |
659 | + | myPotato = potatoes[which_node]; |
660 | + | |
661 | MPI_Recv(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, which_node, | |
662 | < | atomTypeTag, MPI_COMM_WORLD, &istatus); |
662 | > | myPotato, MPI_COMM_WORLD, &istatus); |
663 | ||
664 | < | strncpy(atomTypeString, MPIatomTypeString, MINIBUFFERSIZE); |
664 | > | atomTypeString = MPIatomTypeString; |
665 | > | |
666 | > | myPotato++; |
667 | ||
668 | MPI_Recv(&isDirectional, 1, MPI_INT, which_node, | |
669 | < | atomIsDirectionalTag, MPI_COMM_WORLD, &istatus); |
670 | < | |
671 | < | MPI_Recv(atomTransData, 6, MPI_DOUBLE, which_node, |
590 | < | atomTransDataTag, MPI_COMM_WORLD, &istatus); |
669 | > | myPotato, MPI_COMM_WORLD, &istatus); |
670 | > | |
671 | > | myPotato++; |
672 | ||
673 | < | if (isDirectional) { |
674 | < | |
675 | < | MPI_Recv(atomOrientData, 7, MPI_DOUBLE, which_node, |
676 | < | atomOrientDataTag, MPI_COMM_WORLD, &istatus); |
677 | < | |
673 | > | if (isDirectional) { |
674 | > | MPI_Recv(atomData13, 13, MPI_DOUBLE, which_node, |
675 | > | myPotato, MPI_COMM_WORLD, &istatus); |
676 | > | } else { |
677 | > | MPI_Recv(atomData6, 6, MPI_DOUBLE, which_node, |
678 | > | myPotato, MPI_COMM_WORLD, &istatus); |
679 | } | |
680 | + | |
681 | + | myPotato++; |
682 | + | potatoes[which_node] = myPotato; |
683 | ||
684 | } else { | |
685 | ||
686 | haveError = 0; | |
687 | which_atom = i; | |
688 | local_index=-1; | |
689 | < | |
689 | > | |
690 | for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) { | |
691 | if (atoms[j]->getGlobalIndex() == which_atom) local_index = j; | |
692 | } | |
693 | < | |
693 | > | |
694 | if (local_index != -1) { | |
695 | < | |
695 | > | |
696 | atomTypeString = atoms[local_index]->getType(); | |
697 | ||
698 | atoms[local_index]->getPos(pos); | |
699 | < | atoms[local_index]->getVel(vel); |
699 | > | atoms[local_index]->getVel(vel); |
700 | ||
701 | < | atomTransData[0] = pos[0]; |
702 | < | atomTransData[1] = pos[1]; |
703 | < | atomTransData[2] = pos[2]; |
701 | > | atomData6[0] = pos[0]; |
702 | > | atomData6[1] = pos[1]; |
703 | > | atomData6[2] = pos[2]; |
704 | ||
705 | < | atomTransData[3] = vel[0]; |
706 | < | atomTransData[4] = vel[1]; |
707 | < | atomTransData[5] = vel[2]; |
705 | > | atomData6[3] = vel[0]; |
706 | > | atomData6[4] = vel[1]; |
707 | > | atomData6[5] = vel[2]; |
708 | ||
709 | isDirectional = 0; | |
710 | ||
# | Line 629 | Line 714 | void DumpWriter::writeFinal(double finalTime){ | |
714 | ||
715 | dAtom = (DirectionalAtom *)atoms[local_index]; | |
716 | dAtom->getQ( q ); | |
632 | – | |
633 | – | atomOrientData[0] = q[0]; |
634 | – | atomOrientData[1] = q[1]; |
635 | – | atomOrientData[2] = q[2]; |
636 | – | atomOrientData[3] = q[3]; |
717 | ||
718 | < | atomOrientData[4] = dAtom->getJx(); |
719 | < | atomOrientData[5] = dAtom->getJy(); |
720 | < | atomOrientData[6] = dAtom->getJz(); |
718 | > | for (int j = 0; j < 6 ; j++) |
719 | > | atomData13[j] = atomData6[j]; |
720 | > | |
721 | > | atomData13[6] = q[0]; |
722 | > | atomData13[7] = q[1]; |
723 | > | atomData13[8] = q[2]; |
724 | > | atomData13[9] = q[3]; |
725 | > | |
726 | > | atomData13[10] = dAtom->getJx(); |
727 | > | atomData13[11] = dAtom->getJy(); |
728 | > | atomData13[12] = dAtom->getJz(); |
729 | } | |
730 | < | |
730 | > | |
731 | } else { | |
732 | sprintf(painCave.errMsg, | |
733 | "Atom %d not found on processor %d\n", | |
# | Line 647 | Line 735 | void DumpWriter::writeFinal(double finalTime){ | |
735 | haveError= 1; | |
736 | simError(); | |
737 | } | |
738 | < | |
738 | > | |
739 | if(haveError) DieDieDie(); | |
740 | < | |
740 | > | |
741 | // If we've survived to here, format the line: | |
742 | ||
743 | < | sprintf( tempBuffer, |
656 | < | "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t", |
657 | < | atomTypeString, |
658 | < | atomTransData[0], |
659 | < | atomTransData[1], |
660 | < | atomTransData[2], |
661 | < | atomTransData[3], |
662 | < | atomTransData[4], |
663 | < | atomTransData[5]); |
743 | > | if (!isDirectional) { |
744 | ||
745 | < | strcpy( writeLine, tempBuffer ); |
746 | < | |
747 | < | if (isDirectional) { |
745 | > | sprintf( tempBuffer, |
746 | > | "%s\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t", |
747 | > | atomTypeString, |
748 | > | atomData6[0], |
749 | > | atomData6[1], |
750 | > | atomData6[2], |
751 | > | atomData6[3], |
752 | > | atomData6[4], |
753 | > | atomData6[5]); |
754 | > | |
755 | > | strcpy( writeLine, tempBuffer ); |
756 | > | strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" ); |
757 | ||
758 | + | } else { |
759 | + | |
760 | sprintf( tempBuffer, | |
761 | < | "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", |
762 | < | atomOrientData[0], |
763 | < | atomOrientData[1], |
764 | < | atomOrientData[2], |
765 | < | atomOrientData[3], |
766 | < | atomOrientData[4], |
767 | < | atomOrientData[5], |
768 | < | atomOrientData[6]); |
761 | > | "%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", |
762 | > | atomTypeString, |
763 | > | atomData13[0], |
764 | > | atomData13[1], |
765 | > | atomData13[2], |
766 | > | atomData13[3], |
767 | > | atomData13[4], |
768 | > | atomData13[5], |
769 | > | atomData13[6], |
770 | > | atomData13[7], |
771 | > | atomData13[8], |
772 | > | atomData13[9], |
773 | > | atomData13[10], |
774 | > | atomData13[11], |
775 | > | atomData13[12]); |
776 | > | |
777 | strcat( writeLine, tempBuffer ); | |
778 | < | |
680 | < | } else { |
681 | < | strcat( writeLine, "0.0\t0.0\t0.0\t0.0\t0.0\t0.0\t0.0\n" ); |
778 | > | |
779 | } | |
780 | < | |
780 | > | |
781 | finalOut << writeLine; | |
782 | finalOut.flush(); | |
783 | } | |
# | Line 689 | Line 786 | void DumpWriter::writeFinal(double finalTime){ | |
786 | finalOut.flush(); | |
787 | sprintf( checkPointMsg, | |
788 | "Sucessfully took a dump.\n"); | |
789 | + | delete[] potatoes; |
790 | + | |
791 | MPIcheckPoint(); | |
792 | ||
793 | } else { | |
794 | ||
795 | // worldRank != 0, so I'm a remote node. | |
796 | + | |
797 | + | // Set my magic potato to 0: |
798 | + | |
799 | + | myPotato = 0; |
800 | ||
801 | for (i = 0 ; i < mpiSim->getTotAtoms(); i++ ) { | |
802 | ||
# | Line 701 | Line 804 | void DumpWriter::writeFinal(double finalTime){ | |
804 | ||
805 | if (AtomToProcMap[i] == worldRank) { | |
806 | ||
807 | + | if (myPotato + 3 >= MAXTAG) { |
808 | + | |
809 | + | // The potato was going to exceed the maximum value, |
810 | + | // so wrap this processor potato back to 0 (and block until |
811 | + | // node 0 says we can go: |
812 | + | |
813 | + | MPI_Recv(&myPotato, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &istatus); |
814 | + | |
815 | + | } |
816 | + | which_atom = i; |
817 | local_index=-1; | |
818 | for (j=0; (j<mpiSim->getMyNlocal()) && (local_index < 0); j++) { | |
819 | if (atoms[j]->getGlobalIndex() == which_atom) local_index = j; | |
# | Line 712 | Line 825 | void DumpWriter::writeFinal(double finalTime){ | |
825 | atoms[local_index]->getPos(pos); | |
826 | atoms[local_index]->getVel(vel); | |
827 | ||
828 | < | atomTransData[0] = pos[0]; |
829 | < | atomTransData[1] = pos[1]; |
830 | < | atomTransData[2] = pos[2]; |
828 | > | atomData6[0] = pos[0]; |
829 | > | atomData6[1] = pos[1]; |
830 | > | atomData6[2] = pos[2]; |
831 | ||
832 | < | atomTransData[3] = vel[0]; |
833 | < | atomTransData[4] = vel[1]; |
834 | < | atomTransData[5] = vel[2]; |
832 | > | atomData6[3] = vel[0]; |
833 | > | atomData6[4] = vel[1]; |
834 | > | atomData6[5] = vel[2]; |
835 | ||
836 | isDirectional = 0; | |
837 | ||
# | Line 729 | Line 842 | void DumpWriter::writeFinal(double finalTime){ | |
842 | dAtom = (DirectionalAtom *)atoms[local_index]; | |
843 | dAtom->getQ( q ); | |
844 | ||
845 | < | atomOrientData[0] = q[0]; |
846 | < | atomOrientData[1] = q[1]; |
847 | < | atomOrientData[2] = q[2]; |
848 | < | atomOrientData[3] = q[3]; |
845 | > | for (int j = 0; j < 6 ; j++) |
846 | > | atomData13[j] = atomData6[j]; |
847 | > | |
848 | > | atomData13[6] = q[0]; |
849 | > | atomData13[7] = q[1]; |
850 | > | atomData13[8] = q[2]; |
851 | > | atomData13[9] = q[3]; |
852 | ||
853 | < | atomOrientData[4] = dAtom->getJx(); |
854 | < | atomOrientData[5] = dAtom->getJy(); |
855 | < | atomOrientData[6] = dAtom->getJz(); |
853 | > | atomData13[10] = dAtom->getJx(); |
854 | > | atomData13[11] = dAtom->getJy(); |
855 | > | atomData13[12] = dAtom->getJz(); |
856 | } | |
857 | ||
858 | } else { | |
# | Line 747 | Line 863 | void DumpWriter::writeFinal(double finalTime){ | |
863 | simError(); | |
864 | } | |
865 | ||
750 | – | // I've survived this far, so send off the data! |
751 | – | |
752 | – | atomTypeTag = 4*i; |
753 | – | atomIsDirectionalTag = 4*i + 1; |
754 | – | atomTransDataTag = 4*i + 2; |
755 | – | atomOrientDataTag = 4*i + 3; |
756 | – | |
866 | strncpy(MPIatomTypeString, atomTypeString, MINIBUFFERSIZE); | |
867 | ||
868 | + | // null terminate the string before sending (just in case): |
869 | + | MPIatomTypeString[MINIBUFFERSIZE-1] = '\0'; |
870 | + | |
871 | MPI_Send(MPIatomTypeString, MINIBUFFERSIZE, MPI_CHAR, 0, | |
872 | < | atomTypeTag, MPI_COMM_WORLD); |
872 | > | myPotato, MPI_COMM_WORLD); |
873 | ||
874 | + | myPotato++; |
875 | + | |
876 | MPI_Send(&isDirectional, 1, MPI_INT, 0, | |
877 | < | atomIsDirectionalTag, MPI_COMM_WORLD); |
877 | > | myPotato, MPI_COMM_WORLD); |
878 | ||
879 | < | MPI_Send(atomTransData, 6, MPI_DOUBLE, 0, |
880 | < | atomTransDataTag, MPI_COMM_WORLD); |
767 | < | |
879 | > | myPotato++; |
880 | > | |
881 | if (isDirectional) { | |
882 | ||
883 | < | MPI_Send(atomOrientData, 7, MPI_DOUBLE, 0, |
884 | < | atomOrientDataTag, MPI_COMM_WORLD); |
883 | > | MPI_Send(atomData13, 13, MPI_DOUBLE, 0, |
884 | > | myPotato, MPI_COMM_WORLD); |
885 | ||
886 | + | } else { |
887 | + | |
888 | + | MPI_Send(atomData6, 6, MPI_DOUBLE, 0, |
889 | + | myPotato, MPI_COMM_WORLD); |
890 | } | |
891 | < | |
891 | > | |
892 | > | myPotato++; |
893 | } | |
894 | } | |
895 | ||
896 | sprintf( checkPointMsg, | |
897 | < | "Sucessfully wrote final file.\n"); |
897 | > | "Sucessfully took a dump.\n"); |
898 | MPIcheckPoint(); | |
899 | ||
900 | < | } |
900 | > | } |
901 | ||
784 | – | painCave.isEventLoop = 0; |
785 | – | |
902 | if( worldRank == 0 ) finalOut.close(); | |
903 | #endif // is_mpi | |
904 | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |