OPAL (Object Oriented Parallel Accelerator Library) 2024.2
OPAL
MultiBunchHandler.cpp
Go to the documentation of this file.
1//
2// Class MultiBunchHandler
3// Helper class that stores bunch injection
4// information like azimuth, radius etc. of first
5// bunch in multi-bunch mode of ParallelCyclotronTracker.
6//
7// Copyright (c) 2007 - 2014, Jianjun Yang, Paul Scherrer Institut, Villigen PSI, Switzerland
8// Copyright (c) 2012 - 2023, Paul Scherrer Institut, Villigen PSI, Switzerland
9// All rights reserved
10//
11// Implemented as part of the PhD thesis
12// "Beam dynamics in high intensity cyclotrons including neighboring bunch effects"
13// and the paper
14// "Beam dynamics in high intensity cyclotrons including neighboring bunch effects:
15// Model, implementation, and application"
16// (https://journals.aps.org/prab/pdf/10.1103/PhysRevSTAB.13.064201)
17//
18// This file is part of OPAL.
19//
20// OPAL is free software: you can redistribute it and/or modify
21// it under the terms of the GNU General Public License as published by
22// the Free Software Foundation, either version 3 of the License, or
23// (at your option) any later version.
24//
25// You should have received a copy of the GNU General Public License
26// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
27//
29
31#ifdef ENABLE_AMR
33#endif
35#include "Algorithms/PartBins.h"
39#include "Algorithms/Vektor.h"
42#include "Physics/Units.h"
45#include "Utility/Inform.h"
46#include "Utility/IpplInfo.h"
47#include "Utility/IpplTimings.h"
48
49#include <h5core/h5_types.h>
50
51#include <algorithm>
52#include <cmath>
53#include <cstddef>
54#include <functional>
55#include <map>
56#include <memory>
57#include <utility>
58
59class PartData;
60
61extern Inform *gmsg;
62
64 const int& numBunch,
65 const double& eta,
66 const double& para,
67 const std::string& mode,
68 const std::string& binning)
69 : onebunch_m(OpalData::getInstance()->getInputBasename() + "-onebunch.h5")
70 , numBunch_m(numBunch)
71 , eta_m(eta)
72 , coeffDBunches_m(para)
73 , radiusLastTurn_m(0.0)
74 , radiusThisTurn_m(0.0)
75 , bunchCount_m(1)
76{
77 PAssert_GT(numBunch, 1);
78
79 binfo_m.reserve(numBunch);
80 for (int i = 0; i < beam->getNumBunch(); ++i) {
81 binfo_m.push_back(beaminfo_t());
82 }
83
84 this->setBinning(binning);
85
86 // mode of generating new bunches:
87 // "FORCE" means generating one bunch after each revolution, until get "TURNS" bunches.
88 // "AUTO" means only when the distance between two neighbor bunches is below the limitation,
89 // then starts to generate new bunches after each revolution,until get "TURNS" bunches;
90 // otherwise, run single bunch track
91
92 *gmsg << "***-------------------- MULTI-BUNCHES MULTI-ENERGY-BINS MODE --------------------*** " << endl;
93
94 // only for regular run of multi bunches, instantiate the PartBins class
95 // note that for restart run of multi bunches, PartBins class is instantiated in function
96 // Distribution::doRestartOpalCycl()
97 if (!OpalData::getInstance()->inRestartRun()) {
98
99 // already exist bins number initially
100 const int BinCount = 1;
101 //allowed maximal bin
102 const int MaxBinNum = 1000;
103
104 // initialize particles number for each bin (both existed and not yet emmitted)
105 size_t partInBin[MaxBinNum] = {0};
106 partInBin[0] = beam->getTotalNum();
107
108 beam->setPBins(new PartBinsCyc(MaxBinNum, BinCount, partInBin));
109 // the allowed maximal bin number is set to 100
110 //beam->setPBins(new PartBins(100));
111
112 this->setMode(mode);
113
114 } else {
115 if (beam->pbin_m->getLastemittedBin() < 2) {
116 *gmsg << "In this restart job, the multi-bunches mode is forcely set to AUTO mode." << endl;
118 } else {
119 *gmsg << "In this restart job, the multi-bunches mode is forcely set to FORCE mode." << endl
120 << "If the existing bunch number is less than the specified number of TURN, "
121 << "readin the phase space of STEP#0 from h5 file consecutively" << endl;
123 }
124 }
125}
126
127
129
130 static IpplTimings::TimerRef saveBunchTimer = IpplTimings::getTimer("Save Bunch H5");
131 IpplTimings::startTimer(saveBunchTimer);
132 *gmsg << endl;
133 *gmsg << "* Store beam to H5 file for multibunch simulation ... ";
134
135 Ppos_t coord, momentum;
136 ParticleAttrib<double> mass, charge;
138
139 std::size_t localNum = beam->getLocalNum();
140
141 coord.create(localNum);
142 coord = beam->R;
143
144 momentum.create(localNum);
145 momentum = beam->P;
146
147 mass.create(localNum);
148 mass = beam->M;
149
150 charge.create(localNum);
151 charge = beam->Q;
152
153 porigin.create(localNum);
154 porigin = beam->POrigin;
155
156 std::map<std::string, double> additionalAttributes = {
157 std::make_pair("REFPR", 0.0),
158 std::make_pair("REFPT", 0.0),
159 std::make_pair("REFPZ", 0.0),
160 std::make_pair("REFR", 0.0),
161 std::make_pair("REFTHETA", 0.0),
162 std::make_pair("REFZ", 0.0),
163 std::make_pair("AZIMUTH", 0.0),
164 std::make_pair("ELEVATION", 0.0),
165 std::make_pair("REFSOURCE", 0.0),
166 std::make_pair("B-ref_x", 0.0),
167 std::make_pair("B-ref_z", 0.0),
168 std::make_pair("B-ref_y", 0.0),
169 std::make_pair("E-ref_x", 0.0),
170 std::make_pair("E-ref_z", 0.0),
171 std::make_pair("E-ref_y", 0.0),
172 std::make_pair("B-head_x", 0.0),
173 std::make_pair("B-head_z", 0.0),
174 std::make_pair("B-head_y", 0.0),
175 std::make_pair("E-head_x", 0.0),
176 std::make_pair("E-head_z", 0.0),
177 std::make_pair("E-head_y", 0.0),
178 std::make_pair("B-tail_x", 0.0),
179 std::make_pair("B-tail_z", 0.0),
180 std::make_pair("B-tail_y", 0.0),
181 std::make_pair("E-tail_x", 0.0),
182 std::make_pair("E-tail_z", 0.0),
183 std::make_pair("E-tail_y", 0.0)
184 };
185
186 H5PartWrapperForPC h5wrapper(onebunch_m, H5_O_WRONLY);
187 h5wrapper.writeHeader();
188 h5wrapper.writeStep(beam, additionalAttributes);
189 h5wrapper.close();
190
191 *gmsg << "Done." << endl;
192 IpplTimings::stopTimer(saveBunchTimer);
193}
194
195
197
198 static IpplTimings::TimerRef readBunchTimer = IpplTimings::getTimer("Read Bunch H5");
199 IpplTimings::startTimer(readBunchTimer);
200 *gmsg << endl;
201 *gmsg << "* Read beam from H5 file for multibunch simulation ... ";
202
203 std::size_t localNum = beam->getLocalNum();
204
205 /*
206 * 2nd argument: 0 --> step zero is fine since the file has only this step
207 * 3rd argument: "" --> onebunch_m is used
208 * 4th argument: H5_O_RDONLY does not work with this constructor
209 */
210 H5PartWrapperForPC h5wrapper(onebunch_m, 0, "", H5_O_WRONLY);
211
212 size_t numParticles = h5wrapper.getNumParticles();
213
214 const int bunchNum = bunchCount_m - 1;
215
216 beam->setTotalNumPerBunch(numParticles, bunchNum);
217
218 if ( numParticles == 0 ) {
219 throw OpalException("MultiBunchHandler::readBunch()",
220 "No particles in file " + onebunch_m + ".");
221 }
222
223 size_t numParticlesPerNode = numParticles / Ippl::getNodes();
224
225 size_t firstParticle = numParticlesPerNode * Ippl::myNode();
226 size_t lastParticle = firstParticle + numParticlesPerNode - 1;
227 if (Ippl::myNode() == Ippl::getNodes() - 1)
228 lastParticle = numParticles - 1;
229
230 PAssert_LT(firstParticle, lastParticle +1);
231
232 numParticles = lastParticle - firstParticle + 1;
233
234 beam->setLocalNumPerBunch(numParticles, bunchNum);
235
236 //FIXME
237 std::unique_ptr<PartBunchBase<double, 3> > tmpBunch = nullptr;
238#ifdef ENABLE_AMR
239 AmrPartBunch* amrbunch_p = dynamic_cast<AmrPartBunch*>(beam);
240 if ( amrbunch_p != nullptr ) {
241 tmpBunch.reset(new AmrPartBunch(&ref,
242 amrbunch_p->getAmrParticleBase()));
243 } else
244#endif
245 tmpBunch.reset(new PartBunch(&ref));
246
247 tmpBunch->create(numParticles);
248
249 h5wrapper.readStep(tmpBunch.get(), firstParticle, lastParticle);
250 h5wrapper.close();
251
252 beam->create(numParticles);
253
254 for(size_t ii = 0; ii < numParticles; ++ ii, ++ localNum) {
255 beam->R[localNum] = tmpBunch->R[ii];
256 beam->P[localNum] = tmpBunch->P[ii];
257 beam->M[localNum] = tmpBunch->M[ii];
258 beam->Q[localNum] = tmpBunch->Q[ii];
259 beam->POrigin[localNum] = ParticleOrigin::REGULAR;
260 beam->Bin[localNum] = bunchNum;
261 beam->bunchNum[localNum] = bunchNum;
262 }
263
264 beam->boundp();
265
266 binfo_m.push_back(beaminfo_t(injection_m));
267
268 *gmsg << "Done." << endl;
269
270 IpplTimings::stopTimer(readBunchTimer);
271 return true;
272}
273
274
276 const PartData& ref,
277 bool& flagTransition) {
278 short result = 0;
279 if ((bunchCount_m == 1) && (mode_m == MultiBunchMode::AUTO) && (!flagTransition)) {
280
281 // we have still a single bunch
282 beam->setTotalNumPerBunch(beam->getTotalNum(), 0);
283 beam->setLocalNumPerBunch(beam->getLocalNum(), 0);
284
285 // If all of the following conditions are met, this code will be executed
286 // to check the distance between two neighboring bunches:
287 // 1. Only one bunch exists (bunchCount_m == 1)
288 // 2. We are in multi-bunch mode, AUTO sub-mode (mode_m == 2)
289 // 3. It has been a full revolution since the last check (stepsNextCheck)
290
291 *gmsg << "* MBM: Checking for automatically injecting new bunch ..." << endl;
292
293 beam->calcBeamParameters();
294
295 Vector_t Rmean = beam->get_centroid(); // m
296
297 radiusThisTurn_m = std::hypot(Rmean[0],Rmean[1]);
298
299 Vector_t Rrms = beam->get_rrms(); // m
300
301 double XYrms = std::hypot(Rrms[0], Rrms[1]);
302
303 // If the distance between two neighboring bunches is less than 5 times of its 2D rms size
304 // start multi-bunch simulation, fill current phase space to initialR and initialP arrays
306 // since next turn, start multi-bunches
307 saveBunch(beam);
308 flagTransition = true;
309 }
310
311 *gmsg << "* MBM: RLastTurn = " << radiusLastTurn_m << " [m]" << endl;
312 *gmsg << "* MBM: RThisTurn = " << radiusThisTurn_m << " [m]" << endl;
313 *gmsg << "* MBM: XYrms = " << XYrms << " [m]" << endl;
314
316 result = 1;
317
318 } else if (bunchCount_m < numBunch_m) {
319 // Matthias: SteptoLastInj was used in MtsTracker, removed by DW in GenericTracker
320
321 // If all of the following conditions are met, this code will be executed
322 // to read new bunch from hdf5 format file:
323 // 1. We are in multi-bunch mode (numBunch_m > 1)
324 // 2. It has been a full revolution since the last check
325 // 3. Number of existing bunches is less than the desired number of bunches
326 // 4. FORCE mode, or AUTO mode with flagTransition = true
327 // Note: restart from 1 < BunchCount < numBunch_m must be avoided.
328 *gmsg << "* MBM: Injecting a new bunch ..." << endl;
329
330 bunchCount_m++;
331
333
334 // read initial distribution from h5 file
335 switch ( mode_m ) {
338 readBunch(beam, ref);
339 updateParticleBins(beam);
341 break;
342 default:
343 throw OpalException("MultiBunchHandler::injectBunch()",
344 "We shouldn't be here in single bunch mode.");
345 }
346
348
349 *gmsg << "* MBM: Bunch " << bunchCount_m
350 << " injected, total particle number = "
351 << beam->getTotalNum() << endl;
352 result = 2;
353 }
354 return result;
355}
356
357
359 if (bunchCount_m < 2)
360 return;
361
362 static IpplTimings::TimerRef binningTimer = IpplTimings::getTimer("Particle Binning");
363 IpplTimings::startTimer(binningTimer);
364 switch (binning_m) {
366 beam->resetPartBinID2(eta_m);
367 break;
369 beam->resetPartBinBunch();
370 break;
371 default:
372 beam->resetPartBinID2(eta_m);
373 }
374 IpplTimings::stopTimer(binningTimer);
375}
376
377
378void MultiBunchHandler::setMode(const std::string& mbmode) {
379
380 static const std::map<std::string, MultiBunchMode> stringMBMode_s = {
381 {"FORCE", MultiBunchMode::FORCE},
382 {"AUTO", MultiBunchMode::AUTO},
383 };
384 mode_m = stringMBMode_s.at(mbmode);
385
386 switch (mode_m) {
388 *gmsg << "FORCE mode: The multi bunches will be injected consecutively" << endl
389 << " after each revolution, until get \"TURNS\" bunches." << endl;
390 break;
392 *gmsg << "AUTO mode: The multi bunches will be injected only when the" << endl
393 << " distance between two neighboring bunches is below" << endl
394 << " the limitation. The control parameter is set to "
395 << coeffDBunches_m << endl;
396 break;
397 default:
398 throw OpalException("MultiBunchHandler::setMode",
399 "Unknown \"MBMODE\" multi-bunch mode for OPAL-cycl");
400 }
401}
402
403
404void MultiBunchHandler::setBinning(const std::string& binning) {
405
406 static const std::map<std::string, MultiBunchBinning> stringMBBinning_s = {
407 {"BUNCH_BINNING", MultiBunchBinning::BUNCH},
408 {"GAMMA_BINNING", MultiBunchBinning::GAMMA},
409 };
410 binning_m = stringMBBinning_s.at(binning);
411
412 switch (binning_m) {
414 *gmsg << "\nUse 'BUNCH_BINNING' injection for binnning.\n" << endl;
415 break;
417 *gmsg << "\nUse 'GAMMA_BINNING' injection for binnning.\n" << endl;
418 break;
419 default:
420 throw OpalException("MultiBunchHandler::setBinning",
421 "Unknown \"MB_BINNING\" type of energy binning in multi-bunch mode");
422 }
423}
424
425
426void MultiBunchHandler::setRadiusTurns(const double& radius) {
428 return;
429
430 radiusLastTurn_m = radius;
432
433 if (OpalData::getInstance()->inRestartRun()) {
434 *gmsg << "Radial position at restart position = ";
435 } else {
436 *gmsg << "Initial radial position = ";
437 }
438 *gmsg << radiusThisTurn_m << " m" << endl;
439}
440
441
443 short bunchNr) {
444
445 if (!OpalData::getInstance()->isInOPALCyclMode()) {
446 return false;
447 }
448
449 const unsigned long localNum = beam->getLocalNum();
450
451 long int bunchTotalNum = 0;
452 unsigned long bunchLocalNum = 0;
453
454 /* container:
455 *
456 * ekin, <x>, <y>, <z>, <p_x>, <p_y>, <p_z>,
457 * <x^2>, <y^2>, <z^2>, <p_x^2>, <p_y^2>, <p_z^2>,
458 * <xp_x>, <y_py>, <zp_z>,
459 * <x^3>, <y^3>, <z^3>, <x^4>, <y^4>, <z^4>
460 */
461 const unsigned int dim = PartBunchBase<double, 3>::Dimension;
462 std::vector<double> local(7 * dim + 1);
463
464 beaminfo_t& binfo = getBunchInfo(bunchNr);
465
466 for(unsigned long k = 0; k < localNum; ++k) {
467 if ( beam->bunchNum[k] != bunchNr ) { //|| ID[k] == 0 ) {
468 continue;
469 }
470
471 ++bunchTotalNum;
472 ++bunchLocalNum;
473
474 // ekin
475 local[0] += std::sqrt(dot(beam->P[k], beam->P[k]) + 1.0);
476
477 for (unsigned int i = 0; i < dim; ++i) {
478
479 double r = beam->R[k](i);
480 double p = beam->P[k](i);
481
482 // <x>, <y>, <z>
483 local[i + 1] += r;
484
485 // <p_x>, <p_y, <p_z>
486 local[i + dim + 1] += p;
487
488 // <x^2>, <y^2>, <z^2>
489 double r2 = r * r;
490 local[i + 2 * dim + 1] += r2;
491
492 // <p_x^2>, <p_y^2>, <p_z^2>
493 local[i + 3 * dim + 1] += p * p;
494
495 // <xp_x>, <y_py>, <zp_z>
496 local[i + 4 * dim + 1] += r * p;
497
498 // <x^3>, <y^3>, <z^3>
499 local[i + 5 * dim + 1] += r2 * r;
500
501 // <x^4>, <y^4>, <z^4>
502 local[i + 6 * dim + 1] += r2 * r2;
503 }
504 }
505
506 // inefficient
507 allreduce(bunchTotalNum, 1, std::plus<long int>());
508
509 // here we also update the number of particles of *this* bunch
510 if (bunchNr >= (short)beam->getNumBunch()) {
511 throw OpalException("MultiBunchHandler::calcBunchBeamParameters()",
512 "Bunch number " + std::to_string(bunchNr) +
513 " exceeds bunch index " + std::to_string(beam->getNumBunch() - 1));
514 }
515 beam->setTotalNumPerBunch(bunchTotalNum, bunchNr);
516 beam->setLocalNumPerBunch(bunchLocalNum, bunchNr);
517
518 if (bunchTotalNum == 0) {
519 return false;
520 }
521
522 // ekin
523 const double m0 = beam->getM() * Units::eV2MeV;
524 local[0] -= bunchLocalNum;
525 local[0] *= m0;
526
527 allreduce(local.data(), local.size(), std::plus<double>());
528
529 double invN = 1.0 / double(bunchTotalNum);
530 binfo.ekin = local[0] * invN;
531
532 binfo.time = beam->getT();
533 binfo.nParticles = bunchTotalNum;
534
535 for (unsigned int i = 0; i < dim; ++i) {
536
537 double w = local[i + 1] * invN;
538 double pw = local[i + dim + 1] * invN;
539 double w2 = local[i + 2 * dim + 1] * invN;
540 double pw2 = local[i + 3 * dim + 1] * invN;
541 double wpw = local[i + 4 * dim + 1] * invN;
542 double w3 = local[i + 5 * dim + 1] * invN;
543 double w4 = local[i + 6 * dim + 1] * invN;
544
545 // <x>, <y>, <z>
546 binfo.mean[i] = w;
547
548 // central: <p_w^2> - <p_w>^2 (w = x, y, z)
549 binfo.prms[i] = pw2 - pw * pw;
550 if ( binfo.prms[i] < 0 ) {
551 binfo.prms[i] = 0.0;
552 }
553
554 // central: <wp_w> - <w><p_w>
555 wpw = wpw - w * pw;
556
557 // central: <w^2> - <w>^2 (w = x, y, z)
558 binfo.rrms[i] = w2 - w * w;
559
560 // central: normalized emittance
561 binfo.emit[i] = (binfo.rrms[i] * binfo.prms[i] - wpw * wpw);
562 binfo.emit[i] = std::sqrt(std::max(binfo.emit[i], 0.0));
563
564 // central: <w^4> - 4 * <w> * <w^3> + 6 * <w>^2 * <w^2> - 3 * <w>^4
565 double tmp = w4
566 - 4.0 * w * w3
567 + 6.0 * w * w * w2
568 - 3.0 * w * w * w * w;
569 binfo.halo[i] = tmp / ( binfo.rrms[i] * binfo.rrms[i] );
570
571 // central: sqrt(<w^2> - <w>^2) (w = x, y, z)
572 binfo.rrms[i] = std::sqrt(binfo.rrms[i]);
573
574 // central: sqrt(<p_w^2> - <p_w>^2)
575 binfo.prms[i] = std::sqrt(binfo.prms[i]);
576
577 // central: rms correlation --> (<wp_w> - <w><p_w>) / sqrt(<w^2> * <p_w^2>)
578 double denom = 1.0 / (binfo.rrms[i] * binfo.prms[i]);
579 binfo.correlation[i] = (std::isfinite(denom)) ? wpw * denom : 0.0;
580 }
581
582 double tmp = 1.0 / std::pow(binfo.ekin / m0 + 1.0, 2.0);
583 binfo.dEkin = binfo.prms[1] * m0 * std::sqrt(1.0 - tmp);
584
585 return true;
586}
587
588
589void MultiBunchHandler::updateTime(const double& dt) {
590 for (short b = 0; b < bunchCount_m; ++b) {
591 binfo_m[b].time += dt;
592 }
593}
594
595
596void MultiBunchHandler::updatePathLength(const std::vector<double>& lpaths) {
597 PAssert_EQ(bunchCount_m, (short)lpaths.size() - 1);
598 for (short b = 0; b < bunchCount_m; ++b) {
599 binfo_m[b].pathlength += lpaths[b];
600 }
601}
Inform * gmsg
Definition Main.cpp:70
double dot(const Vector3D &lhs, const Vector3D &rhs)
Vector dot product.
Definition Vector3D.cpp:118
Inform * gmsg
Definition Main.cpp:70
void allreduce(const T *input, T *output, int count, Op op)
Inform & endl(Inform &inf)
Definition Inform.cpp:42
#define PAssert_LT(a, b)
Definition PAssert.h:106
#define PAssert_EQ(a, b)
Definition PAssert.h:104
#define PAssert_GT(a, b)
Definition PAssert.h:108
constexpr double eV2MeV
Definition Units.h:77
ParticlePos_t & R
ParticleAttrib< int > Bin
bool resetPartBinID2(const double eta)
reset Bin[] for each particle according to the method given in paper PAST-AB(064402) by G....
void setNumBunch(short n)
size_t getLocalNum() const
ParticleAttrib< double > M
size_t getTotalNum() const
ParticleAttrib< Vector_t > P
void setLocalNumPerBunch(size_t numpart, short n)
ParticleAttrib< ParticleOrigin > POrigin
Vector_t get_rrms() const
ParticleAttrib< double > Q
PartBins * pbin_m
short getNumBunch() const
Vector_t get_centroid() const
ParticleAttrib< short > bunchNum
void setTotalNumPerBunch(size_t numpart, short n)
void setPBins(PartBins *pbin)
virtual void boundp()
void create(size_t M)
double getM() const
double getT() const
The global OPAL structure.
Definition OpalData.h:49
static OpalData * getInstance()
Definition OpalData.cpp:196
void saveBunch(PartBunchBase< double, 3 > *beam)
bool calcBunchBeamParameters(PartBunchBase< double, 3 > *beam, short bunchNr)
MultiBunchHandler(PartBunchBase< double, 3 > *beam, const int &numBunch, const double &eta, const double &para, const std::string &mode, const std::string &binning)
MultiBunchBinning binning_m
beaminfo_t & getBunchInfo(short bunchNr)
void setMode(const std::string &mbmode)
void updateTime(const double &dt)
void setBinning(const std::string &binning)
MultiBunchMode mode_m
void setRadiusTurns(const double &radius)
short numBunch_m
The number of bunches specified in TURNS of RUN command.
bool readBunch(PartBunchBase< double, 3 > *beam, const PartData &ref)
void updatePathLength(const std::vector< double > &lpaths)
short injectBunch(PartBunchBase< double, 3 > *beam, const PartData &ref, bool &flagTransition)
std::vector< beaminfo_t > binfo_m
void updateParticleBins(PartBunchBase< double, 3 > *beam)
virtual void create(size_t)
pbase_t * getAmrParticleBase()
int getLastemittedBin()
Definition PartBins.h:136
size_t getNumParticles() const
virtual void writeStep(PartBunchBase< double, 3 > *, const std::map< std::string, double > &additionalStepAttributes)
virtual void readStep(PartBunchBase< double, 3 > *, h5_ssize_t firstParticle, h5_ssize_t lastParticle)
The base class for all OPAL exceptions.
void barrier(void)
static int getNodes()
Definition IpplInfo.cpp:689
static int myNode()
Definition IpplInfo.cpp:710
static Communicate * Comm
Definition IpplInfo.h:84
Timing::TimerRef TimerRef
static TimerRef getTimer(const char *nm)
static void stopTimer(TimerRef t)
static void startTimer(TimerRef t)