OPAL (Object Oriented Parallel Accelerator Library) 2024.2
OPAL
H5PartWrapperForPC.cpp
Go to the documentation of this file.
1//
2// Copyright & License: See Copyright.readme in src directory
3//
4
6
9#include "OPALconfig.h"
10#include "Physics/Physics.h"
11#include "Physics/Units.h"
12#include "Utilities/Options.h"
13#include "Utilities/Util.h"
14
15#include <sstream>
16#include <set>
17
18H5PartWrapperForPC::H5PartWrapperForPC(const std::string &fileName, h5_int32_t flags):
19 H5PartWrapper(fileName, flags),
20 previousH5Local_m(false),
21 referenceMomentum_m(0.0),
22 referenceLocation_m(0.0),
23 meanE_m(0.0),
24 meanMomentum_m(0.0),
25 azimuth_m(0.0),
26 elevation_m(0.0)
27{ }
28
29H5PartWrapperForPC::H5PartWrapperForPC(const std::string &fileName,
30 int restartStep,
31 std::string sourceFile,
32 h5_int32_t flags):
33 H5PartWrapper(fileName, restartStep, sourceFile, flags),
34 previousH5Local_m(false),
35 referenceMomentum_m(0.0),
36 referenceLocation_m(0.0),
37 meanE_m(0.0),
38 meanMomentum_m(0.0),
39 azimuth_m(0.0),
40 elevation_m(0.0)
41{ }
42
45
47 h5_int64_t numFileAttributes = H5GetNumFileAttribs(file_m);
48
49 const h5_size_t lengthAttributeName = 256;
50 std::vector<char> attributeName(lengthAttributeName);
51 h5_int64_t attributeType;
52 h5_size_t numAttributeElements;
53 std::set<std::string> attributeNames;
54
55 for (h5_int64_t i = 0; i < numFileAttributes; ++ i) {
56 REPORTONERROR(H5GetFileAttribInfo(file_m,
57 i,
58 attributeName.data(),
59 lengthAttributeName,
60 &attributeType,
61 &numAttributeElements));
62
63 attributeNames.insert(attributeName.data());
64 }
65
66 if (attributeNames.find("dump frequency") != attributeNames.end()) {
67 h5_int64_t dumpfreq;
68 READFILEATTRIB(Int64, file_m, "dump frequency", &dumpfreq);
70 }
71}
72
74 h5_ssize_t firstParticle,
75 h5_ssize_t lastParticle)
76{
77 h5_ssize_t numStepsInSource = H5GetNumSteps(file_m);
78 h5_ssize_t readStep = numStepsInSource - 1;
79 REPORTONERROR(H5SetStep(file_m, readStep));
80
81 readStepHeader(bunch);
82 readStepData(bunch, firstParticle, lastParticle);
83}
84
86 h5_float64_t pathLength;
87 READSTEPATTRIB(Float64, file_m, "SPOS", &pathLength);
88 bunch->set_sPos(pathLength);
89
90 h5_int64_t ltstep;
91 READSTEPATTRIB(Int64, file_m, "LocalTrackStep", &ltstep);
92 bunch->setLocalTrackStep((long long)ltstep);
93
94 h5_int64_t gtstep;
95 READSTEPATTRIB(Int64, file_m, "GlobalTrackStep", &gtstep);
96 bunch->setGlobalTrackStep((long long)gtstep);
97
98 READSTEPATTRIB(Float64, file_m, "ENERGY", &meanE_m);
99
100 double actualT;
101 READSTEPATTRIB(Float64, file_m, "TIME", &actualT);
102 bunch->setT(actualT);
103
104 h5_int64_t SteptoLastInj;
105 READSTEPATTRIB(Int64, file_m, "SteptoLastInj", &SteptoLastInj);
106 bunch->setSteptoLastInj((int)SteptoLastInj);
107
108 h5_int64_t numBunch;
109 READSTEPATTRIB(Int64, file_m, "NumBunch", &numBunch);
110 bunch->setNumBunch((short)numBunch);
111
112 if (predecessorOPALFlavour_m == "opal-cycl") {
113 READSTEPATTRIB(Float64, file_m, "REFPR", (h5_float64_t*) &referenceMomentum_m[0]);
114 READSTEPATTRIB(Float64, file_m, "REFPT", (h5_float64_t*) &referenceMomentum_m[1]);
115 READSTEPATTRIB(Float64, file_m, "REFPZ", (h5_float64_t*) &referenceMomentum_m[2]);
116
117 READSTEPATTRIB(Float64, file_m, "REFR", (h5_float64_t*) &referenceLocation_m[0]);
118 READSTEPATTRIB(Float64, file_m, "REFTHETA", (h5_float64_t*) &referenceLocation_m[1]);
119 READSTEPATTRIB(Float64, file_m, "REFZ", (h5_float64_t*) &referenceLocation_m[2]);
120
121 READSTEPATTRIB(Float64, file_m, "AZIMUTH", &azimuth_m);
122 READSTEPATTRIB(Float64, file_m, "ELEVATION", &elevation_m);
123
124 h5_int64_t localDump = 0;
125 h5_int64_t rc = H5ReadStepAttribInt64(file_m, "LOCAL", &localDump);
126 if(rc != H5_SUCCESS) {
127
128 ERRORMSG("H5 rc= " << rc << " in " << __FILE__ << " @ line " << __LINE__ << endl);
129
130 std::string errormsg =
131 "You are trying to restart from a legacy file that doesn't contain"
132 "information on local/global frame. We are working on legacy support,"
133 "but for now you have to use OPAL 1.3.0!";
134
135 throw OpalException("H5PartWrapperForPC::readStepHeader", errormsg);
136 } else {
137 if (localDump == 1) previousH5Local_m = true;
138 }
139
140 // FIELDSOLVER, MESHFIT=CORE: the mode of the space-charge solve and the solves done
141 // in it, if the file was written with MESHFIT="CORE"
142 if (H5HasStepAttrib(file_m, "SCMODE") > 0 &&
143 H5HasStepAttrib(file_m, "SCMODEDWELL") > 0) {
144 h5_int64_t scMode = 0;
145 h5_int64_t scModeDwell = 0;
146 READSTEPATTRIB(Int64, file_m, "SCMODE", &scMode);
147 READSTEPATTRIB(Int64, file_m, "SCMODEDWELL", &scModeDwell);
149 mode.mode = (scMode == static_cast<h5_int64_t>(CoreFitSC::Mode::FULL) ?
151 mode.dwell = static_cast<unsigned int>(scModeDwell);
152 bunch->setMeshFitMode(mode);
153 }
154 } else {
155 bunch->setT(0.0);
156 bunch->setLocalTrackStep((long long) 0 );
157 }
158
159 double mass = bunch->getM() * Units::eV2MeV;
160 meanMomentum_m = std::sqrt(std::pow(meanE_m,2.0) + 2 * meanE_m * mass) / mass;
161}
162
164 h5_ssize_t firstParticle,
165 h5_ssize_t lastParticle)
166{
167 h5_ssize_t numParticles = getNumParticles();
168 if (lastParticle >= numParticles || firstParticle > lastParticle) {
169 throw OpalException("H5PartWrapperForPC::readStepData",
170 "the provided particle numbers don't match the number of particles in the file");
171 }
172 const unsigned int yIndex = (predecessorOPALFlavour_m == "opal-t"? 2: 1);
173 const unsigned int zIndex = (predecessorOPALFlavour_m == "opal-t"? 1: 2);
174
175 REPORTONERROR(H5PartSetView(file_m, firstParticle, lastParticle));
176
177 numParticles = lastParticle - firstParticle + 1;
178
179 std::vector<char> buffer(numParticles * sizeof(h5_float64_t));
180 char* buffer_ptr = Util::c_data(buffer);
181 h5_float64_t *f64buffer = reinterpret_cast<h5_float64_t*>(buffer_ptr);
182 h5_int64_t *i64buffer = reinterpret_cast<h5_int64_t*>(buffer_ptr);
183
184 READDATA(Float64, file_m, "x", f64buffer);
185 for(long int n = 0; n < numParticles; ++ n) {
186 bunch->R[n](0) = f64buffer[n];
187 bunch->Bin[n] = 0;
188 }
189
190 READDATA(Float64, file_m, "y", f64buffer);
191 for(long int n = 0; n < numParticles; ++ n) {
192 bunch->R[n](yIndex) = f64buffer[n];
193 }
194
195 READDATA(Float64, file_m, "z", f64buffer);
196 for(long int n = 0; n < numParticles; ++ n) {
197 bunch->R[n](zIndex) = f64buffer[n];
198 }
199
200 READDATA(Float64, file_m, "px", f64buffer);
201 for(long int n = 0; n < numParticles; ++ n) {
202 bunch->P[n](0) = f64buffer[n];
203 }
204
205 READDATA(Float64, file_m, "py", f64buffer);
206 for(long int n = 0; n < numParticles; ++ n) {
207 bunch->P[n](yIndex) = f64buffer[n];
208 }
209
210 READDATA(Float64, file_m, "pz", f64buffer);
211 for(long int n = 0; n < numParticles; ++ n) {
212 bunch->P[n](zIndex) = f64buffer[n];
213 }
214
215 READDATA(Float64, file_m, "q", f64buffer);
216 for(long int n = 0; n < numParticles; ++ n) {
217 bunch->Q[n] = f64buffer[n];
218 }
219
220 READDATA(Float64, file_m, "mass", f64buffer);
221 for(long int n = 0; n < numParticles; ++ n) {
222 bunch->M[n] = f64buffer[n];
223 }
224
225 if ( bunch->getNumBunch() > 1 ) {
226 READDATA(Int64, file_m, "bin", i64buffer);
227 for(long int n = 0; n < numParticles; ++ n) {
228 bunch->Bin[n] = i64buffer[n];
229 }
230 }
231
232 READDATA(Int64, file_m, "bunchNumber", i64buffer);
233 for(long int n = 0; n < numParticles; ++ n) {
234 bunch->bunchNum[n] = i64buffer[n];
235 }
236
237 REPORTONERROR(H5PartSetView(file_m, -1, -1));
238}
239
241 std::stringstream OPAL_version;
242 OPAL_version << OPAL_PROJECT_NAME << " " << OPAL_PROJECT_VERSION << " # git rev. " << Util::getGitRevision();
243 WRITESTRINGFILEATTRIB(file_m, "OPAL_version", OPAL_version.str().c_str());
244
245 // Units for the step data
246 WRITESTRINGFILEATTRIB(file_m, "xUnit", "m");
247 WRITESTRINGFILEATTRIB(file_m, "yUnit", "m");
248 WRITESTRINGFILEATTRIB(file_m, "zUnit", "m");
249 WRITESTRINGFILEATTRIB(file_m, "pxUnit", "#beta#gamma");
250 WRITESTRINGFILEATTRIB(file_m, "pyUnit", "#beta#gamma");
251 WRITESTRINGFILEATTRIB(file_m, "pzUnit", "#beta#gamma");
252 WRITESTRINGFILEATTRIB(file_m, "qUnit", "C");
253 WRITESTRINGFILEATTRIB(file_m, "massUnit", "GeV");
254 WRITESTRINGFILEATTRIB(file_m, "idUnit", "1");
255 WRITESTRINGFILEATTRIB(file_m, "binUnit", "1");
256 WRITESTRINGFILEATTRIB(file_m, "bunchNumberUnit", "1");
257 if (Options::ebDump) {
258 WRITESTRINGFILEATTRIB(file_m, "Ex", "MV/m");
259 WRITESTRINGFILEATTRIB(file_m, "Ey", "MV/m");
260 WRITESTRINGFILEATTRIB(file_m, "Ez", "MV/m");
261 WRITESTRINGFILEATTRIB(file_m, "Bx", "T");
262 WRITESTRINGFILEATTRIB(file_m, "By", "T");
263 WRITESTRINGFILEATTRIB(file_m, "Bz", "T");
264 }
265
266 // Units for the step attributes
267 WRITESTRINGFILEATTRIB(file_m, "TIMEUnit", "s");
268 WRITESTRINGFILEATTRIB(file_m, "SPOSUnit", "m");
269
270 WRITESTRINGFILEATTRIB(file_m, "RefPartRUnit", "m");
271 WRITESTRINGFILEATTRIB(file_m, "centroidUnit", "m");
272 WRITESTRINGFILEATTRIB(file_m, "RMSXUnit", "m");
273 WRITESTRINGFILEATTRIB(file_m, "minXUnit", "m");
274 WRITESTRINGFILEATTRIB(file_m, "maxXUnit", "m");
275
276 WRITESTRINGFILEATTRIB(file_m, "RefPartPUnit", "#beta#gamma");
277 WRITESTRINGFILEATTRIB(file_m, "RMSPUnit", "#beta#gamma");
278 WRITESTRINGFILEATTRIB(file_m, "minPUnit", "#beta#gamma");
279 WRITESTRINGFILEATTRIB(file_m, "maxPUnit", "#beta#gamma");
280
281 WRITESTRINGFILEATTRIB(file_m, "#varepsilonUnit", "m rad");
282 WRITESTRINGFILEATTRIB(file_m, "#varepsilon-geomUnit", "m rad");
283
284 WRITESTRINGFILEATTRIB(file_m, "StepUnit", "1");
285 WRITESTRINGFILEATTRIB(file_m, "LocalTrackStepUnit", "1");
286 WRITESTRINGFILEATTRIB(file_m, "GlobalTrackStepUnit", "1");
287
288 WRITESTRINGFILEATTRIB(file_m, "#sigmaUnit", "1");
289
290 WRITESTRINGFILEATTRIB(file_m, "ENERGYUnit", "MeV");
291 WRITESTRINGFILEATTRIB(file_m, "dEUnit", "MeV");
292
293 WRITESTRINGFILEATTRIB(file_m, "MASSUnit", "GeV");
294 WRITESTRINGFILEATTRIB(file_m, "CHARGEUnit", "C");
295
296 WRITESTRINGFILEATTRIB(file_m, "NumBunchUnit", "1");
297 WRITESTRINGFILEATTRIB(file_m, "SteptoLastInjUnit", "1");
298 WRITESTRINGFILEATTRIB(file_m, "LOCALUnit", "1");
299
300 // additional step attributes
301 WRITESTRINGFILEATTRIB(file_m, "REFPRUnit", "#beta#gamma");
302 WRITESTRINGFILEATTRIB(file_m, "REFPTUnit", "#beta#gamma");
303 WRITESTRINGFILEATTRIB(file_m, "REFPZUnit", "#beta#gamma");
304 WRITESTRINGFILEATTRIB(file_m, "REFRUnit", "mm");
305 WRITESTRINGFILEATTRIB(file_m, "REFTHETAUnit", "deg");
306 WRITESTRINGFILEATTRIB(file_m, "REFZUnit", "mm");
307 WRITESTRINGFILEATTRIB(file_m, "REFAZIMUTHUnit", "deg");
308 WRITESTRINGFILEATTRIB(file_m, "REFELEVATIONUnit", "deg");
309 WRITESTRINGFILEATTRIB(file_m, "REFSOURCEUnit", "1");
310
311 WRITESTRINGFILEATTRIB(file_m, "spos-headUnit", "m");
312 WRITESTRINGFILEATTRIB(file_m, "spos-refUnit", "m");
313 WRITESTRINGFILEATTRIB(file_m, "spos-tailUnit", "m");
314
315 WRITESTRINGFILEATTRIB(file_m, "B-refUnit", "T");
316 WRITESTRINGFILEATTRIB(file_m, "E-refUnit", "MV/m");
317 WRITESTRINGFILEATTRIB(file_m, "B-headUnit", "T");
318 WRITESTRINGFILEATTRIB(file_m, "E-headUnit", "MV/m");
319 WRITESTRINGFILEATTRIB(file_m, "B-tailUnit", "T");
320 WRITESTRINGFILEATTRIB(file_m, "E-tailUnit", "MV/m");
321
323 h5_int64_t dumpfreq = Options::psDumpFreq;
324 WRITEFILEATTRIB(Int64, file_m, "dump frequency", &dumpfreq, 1);
325}
326
328 const std::map<std::string, double> &additionalStepAttributes)
329{
330 if (bunch->getTotalNum() == 0) return;
331
332 open(H5_O_APPENDONLY);
333 writeStepHeader(bunch, additionalStepAttributes);
334 writeStepData(bunch);
335 close();
336
337 ++ numSteps_m;
338}
339
341 const std::map<std::string, double> &additionalStepAttributes)
342{
343 bunch->calcBeamParameters();
344
345 double t = bunch->getT();
346 double pathLength = bunch->get_sPos();
347 Vector_t rmin = bunch->get_origin();
348 Vector_t rmax = bunch->get_maxExtent();
349 Vector_t centroid = bunch->get_centroid();
350
351 Vector_t meanR = bunch->get_rmean();
352 Vector_t meanP = bunch->get_pmean();
353 Vector_t xsigma = bunch->get_rrms();
354 Vector_t psigma = bunch->get_prms();
355 Vector_t vareps = bunch->get_norm_emit();
356 Vector_t geomvareps = bunch->get_emit();
357
358 Vector_t RefPartR = bunch->RefPartR_m;
359 Vector_t RefPartP = bunch->RefPartP_m;
360
361 double meanEnergy = bunch->get_meanKineticEnergy();
362 double energySpread = bunch->getdE();
363 double I_0 = 4.0 * Physics::pi * Physics::epsilon_0 * Physics::c * bunch->getM() / bunch->getQ();
364 double sigma = ((xsigma[0] * xsigma[0]) + (xsigma[1] * xsigma[1])) /
365 (2.0 * bunch->get_gamma() * I_0 * (geomvareps[0] * geomvareps[0] + geomvareps[1] * geomvareps[1]));
366
367 h5_int64_t localTrackStep = (h5_int64_t)bunch->getLocalTrackStep();
368 h5_int64_t globalTrackStep = (h5_int64_t)bunch->getGlobalTrackStep();
369
370 h5_int64_t numBunch = (h5_int64_t)bunch->getNumBunch();
371 h5_int64_t SteptoLastInj = (h5_int64_t)bunch->getSteptoLastInj();
372
373 double mass = Units::eV2GeV * bunch->getM();
374 double charge = bunch->getCharge();
375
376 h5_int64_t localFrame = ( Options::psDumpFrame != DumpFrame::GLOBAL );
377
378 double sposHead = 0.0;
379 double sposRef = 0.0;
380 double sposTail = 0.0;
381
382 Vector_t maxP(0.0);
383 Vector_t minP(0.0);
384 bunch->get_PBounds(minP, maxP);
385
386 REPORTONERROR(H5SetStep(file_m, numSteps_m));
387
388 char const *OPALFlavour = "opal-cycl";
389 WRITESTRINGSTEPATTRIB(file_m, "OPAL_flavour", OPALFlavour);
390 WRITESTEPATTRIB(Float64, file_m, "TIME", &t, 1);
391 WRITESTEPATTRIB(Float64, file_m, "SPOS", &pathLength, 1);
392
393 WRITESTEPATTRIB(Float64, file_m, "RefPartR", (h5_float64_t *)&RefPartR, 3);
394 WRITESTEPATTRIB(Float64, file_m, "centroid", (h5_float64_t *)&centroid, 3);
395 WRITESTEPATTRIB(Float64, file_m, "RMSX", (h5_float64_t *)&xsigma, 3);
396 WRITESTEPATTRIB(Float64, file_m, "minX", (h5_float64_t *)&rmin, 3);
397 WRITESTEPATTRIB(Float64, file_m, "maxX", (h5_float64_t *)&rmax, 3);
398
399 WRITESTEPATTRIB(Float64, file_m, "RefPartP", (h5_float64_t *)&RefPartP, 3);
400 WRITESTEPATTRIB(Float64, file_m, "RMSP", (h5_float64_t *)&psigma, 3);
401 WRITESTEPATTRIB(Float64, file_m, "minP", (h5_float64_t *)&minP, 3);
402 WRITESTEPATTRIB(Float64, file_m, "maxP", (h5_float64_t *)&maxP, 3);
403
404 WRITESTEPATTRIB(Float64, file_m, "#varepsilon", (h5_float64_t *)&vareps, 3);
405 WRITESTEPATTRIB(Float64, file_m, "#varepsilon-geom", (h5_float64_t *)&geomvareps, 3);
406
407 WRITESTEPATTRIB(Int64, file_m, "Step", &numSteps_m, 1);
408 WRITESTEPATTRIB(Int64, file_m, "LocalTrackStep", &localTrackStep, 1);
409 WRITESTEPATTRIB(Int64, file_m, "GlobalTrackStep", &globalTrackStep, 1);
410
411 WRITESTEPATTRIB(Float64, file_m, "#sigma", &sigma, 1);
412
413 WRITESTEPATTRIB(Float64, file_m, "ENERGY", &meanEnergy, 1);
414 WRITESTEPATTRIB(Float64, file_m, "dE", &energySpread, 1);
415
417 WRITESTEPATTRIB(Float64, file_m, "MASS", &mass, 1);
418 WRITESTEPATTRIB(Float64, file_m, "CHARGE", &charge, 1);
419
420 WRITESTEPATTRIB(Int64, file_m, "NumBunch", &numBunch, 1);
421 WRITESTEPATTRIB(Int64, file_m, "SteptoLastInj", &SteptoLastInj, 1);
422 WRITESTEPATTRIB(Int64, file_m, "LOCAL", &localFrame, 1);
423
424 // FIELDSOLVER, MESHFIT=CORE: the mode of the space-charge solve (1 CORE, 0 FULL) and the
425 // solves done in it (0 before the first solve), which an H5 restart restores, and the
426 // core bounds (local space-charge frame) and far particles of the last solve, once there
427 // is one
428 if (bunch->getMeshFit().type == MeshFitType::CORE) {
429 const CoreFitSC::ModeState& mode = bunch->getMeshFitMode();
430 const CoreFitSC::CoreSelection& core = bunch->getMeshFitCore();
431 h5_int64_t scMode = static_cast<h5_int64_t>(mode.mode);
432 h5_int64_t scModeDwell = static_cast<h5_int64_t>(mode.dwell);
433 WRITESTEPATTRIB(Int64, file_m, "SCMODE", &scMode, 1);
434 WRITESTEPATTRIB(Int64, file_m, "SCMODEDWELL", &scModeDwell, 1);
435 if (core.numLive > 0) {
436 h5_int64_t scNumFar = static_cast<h5_int64_t>(core.numFar);
437 Vector_t scBoxMin = core.boundsMin;
438 Vector_t scBoxMax = core.boundsMax;
439 WRITESTEPATTRIB(Float64, file_m, "SCBOXMIN", (h5_float64_t *)&scBoxMin, 3);
440 WRITESTEPATTRIB(Float64, file_m, "SCBOXMAX", (h5_float64_t *)&scBoxMax, 3);
441 WRITESTEPATTRIB(Int64, file_m, "SCNFAR", &scNumFar, 1);
442 }
443 }
444
445 try {
446 h5_float64_t refpr = additionalStepAttributes.at("REFPR");
447 h5_float64_t refpt = additionalStepAttributes.at("REFPT");
448 h5_float64_t refpz = additionalStepAttributes.at("REFPZ");
449 h5_float64_t refr = additionalStepAttributes.at("REFR");
450 h5_float64_t reft = additionalStepAttributes.at("REFTHETA");
451 h5_float64_t refz = additionalStepAttributes.at("REFZ");
452 h5_float64_t azimuth = additionalStepAttributes.at("AZIMUTH");
453 h5_float64_t elevation = additionalStepAttributes.at("ELEVATION");
454 // 0: REF* describe the reference particle (ID 0); 1: the bunch centroid (BUNCH_MEAN
455 // frame, multi-bunch); 2: the bunch centroid because ID 0 has been lost
456 h5_int64_t refsource = static_cast<h5_int64_t>(additionalStepAttributes.at("REFSOURCE"));
457
458 Vector_t referenceB({additionalStepAttributes.at("B-ref_x"),
459 additionalStepAttributes.at("B-ref_z"),
460 additionalStepAttributes.at("B-ref_y")});
461 Vector_t referenceE({additionalStepAttributes.at("E-ref_x"),
462 additionalStepAttributes.at("E-ref_z"),
463 additionalStepAttributes.at("E-ref_y")});
464 Vector_t headB({additionalStepAttributes.at("B-head_x"),
465 additionalStepAttributes.at("B-head_z"),
466 additionalStepAttributes.at("B-head_y")});
467 Vector_t headE({additionalStepAttributes.at("E-head_x"),
468 additionalStepAttributes.at("E-head_z"),
469 additionalStepAttributes.at("E-head_y")});
470 Vector_t tailB({additionalStepAttributes.at("B-tail_x"),
471 additionalStepAttributes.at("B-tail_z"),
472 additionalStepAttributes.at("B-tail_y")});
473 Vector_t tailE({additionalStepAttributes.at("E-tail_x"),
474 additionalStepAttributes.at("E-tail_z"),
475 additionalStepAttributes.at("E-tail_y")});
476
477 WRITESTEPATTRIB(Float64, file_m, "REFPR", &refpr, 1);
478 WRITESTEPATTRIB(Float64, file_m, "REFPT", &refpt, 1);
479 WRITESTEPATTRIB(Float64, file_m, "REFPZ", &refpz, 1);
480 WRITESTEPATTRIB(Float64, file_m, "REFR", &refr, 1);
481 WRITESTEPATTRIB(Float64, file_m, "REFTHETA", &reft, 1);
482 WRITESTEPATTRIB(Float64, file_m, "REFZ", &refz, 1);
483 WRITESTEPATTRIB(Float64, file_m, "AZIMUTH", &azimuth, 1);
484 WRITESTEPATTRIB(Float64, file_m, "ELEVATION", &elevation, 1);
485 WRITESTEPATTRIB(Int64, file_m, "REFSOURCE", &refsource, 1);
486
487 WRITESTEPATTRIB(Float64, file_m, "spos-head", &sposHead, 1);
488 WRITESTEPATTRIB(Float64, file_m, "spos-ref", &sposRef, 1);
489 WRITESTEPATTRIB(Float64, file_m, "spos-tail", &sposTail, 1);
490
491 WRITESTEPATTRIB(Float64, file_m, "B-ref", (h5_float64_t *)&referenceB, 3);
492 WRITESTEPATTRIB(Float64, file_m, "E-ref", (h5_float64_t *)&referenceE, 3);
493 WRITESTEPATTRIB(Float64, file_m, "B-head", (h5_float64_t *)&headB, 3);
494 WRITESTEPATTRIB(Float64, file_m, "E-head", (h5_float64_t *)&headE, 3);
495 WRITESTEPATTRIB(Float64, file_m, "B-tail", (h5_float64_t *)&tailB, 3);
496 WRITESTEPATTRIB(Float64, file_m, "E-tail", (h5_float64_t *)&tailE, 3);
497 } catch (std::out_of_range & m) {
498 ERRORMSG(m.what() << endl);
499
500 throw OpalException("H5PartWrapperForPC::writeStepHeader",
501 "some additional step attribute not found");
502 }
503}
504
506 /*
507 find particle with ID==0
508 and save index in zID
509
510 FIXME After issue 287 is resolved this shouldn't be
511 necessary anymore!
512 */
513
514 size_t IDZero = bunch->getLocalNum();
515 bool found = false;
516#ifndef ENABLE_AMR
517 for(size_t k = 0; k < IDZero; ++ k) {
518 if (bunch->ID[k] == 0) {
519 found = true;
520 IDZero = k;
521 }
522 }
523#endif
524
525 const size_t numLocalParticles = (found? bunch->getLocalNum() - 1: bunch->getLocalNum());
526 const size_t skipID = IDZero;
527
528 std::vector<char> buffer(numLocalParticles * sizeof(h5_float64_t));
529 char* buffer_ptr = Util::c_data(buffer);
530 h5_float64_t *f64buffer = reinterpret_cast<h5_float64_t*>(buffer_ptr);
531 h5_int64_t *i64buffer = reinterpret_cast<h5_int64_t*> (buffer_ptr);
532
533
534 REPORTONERROR(H5PartSetNumParticles(file_m, numLocalParticles));
535
536 for(size_t i = 0; i < skipID; ++ i)
537 f64buffer[i] = bunch->R[i](0);
538 for (size_t i = skipID; i < numLocalParticles; ++ i)
539 f64buffer[i] = bunch->R[i + 1](0);
540
541 WRITEDATA(Float64, file_m, "x", f64buffer);
542
543 for(size_t i = 0; i < skipID; ++ i)
544 f64buffer[i] = bunch->R[i](1);
545 for (size_t i = skipID; i < numLocalParticles; ++ i)
546 f64buffer[i] = bunch->R[i + 1](1);
547
548 WRITEDATA(Float64, file_m, "y", f64buffer);
549
550 for(size_t i = 0; i < skipID; ++ i)
551 f64buffer[i] = bunch->R[i](2);
552 for (size_t i = skipID; i < numLocalParticles; ++ i)
553 f64buffer[i] = bunch->R[i + 1](2);
554
555 WRITEDATA(Float64, file_m, "z", f64buffer);
556
557 for(size_t i = 0; i < skipID; ++ i)
558 f64buffer[i] = bunch->P[i](0);
559 for (size_t i = skipID; i < numLocalParticles; ++ i)
560 f64buffer[i] = bunch->P[i + 1](0);
561
562 WRITEDATA(Float64, file_m, "px", f64buffer);
563
564 for(size_t i = 0; i < skipID; ++ i)
565 f64buffer[i] = bunch->P[i](1);
566 for (size_t i = skipID; i < numLocalParticles; ++ i)
567 f64buffer[i] = bunch->P[i + 1](1);
568
569 WRITEDATA(Float64, file_m, "py", f64buffer);
570
571 for(size_t i = 0; i < skipID; ++ i)
572 f64buffer[i] = bunch->P[i](2);
573 for (size_t i = skipID; i < numLocalParticles; ++ i)
574 f64buffer[i] = bunch->P[i + 1](2);
575
576 WRITEDATA(Float64, file_m, "pz", f64buffer);
577
578 for(size_t i = 0; i < skipID; ++ i)
579 f64buffer[i] = bunch->Q[i];
580 for (size_t i = skipID; i < numLocalParticles; ++ i)
581 f64buffer[i] = bunch->Q[i + 1];
582
583 WRITEDATA(Float64, file_m, "q", f64buffer);
584
585 for(size_t i = 0; i < skipID; ++ i)
586 f64buffer[i] = bunch->M[i];
587 for (size_t i = skipID; i < numLocalParticles; ++ i)
588 f64buffer[i] = bunch->M[i + 1];
589
590 WRITEDATA(Float64, file_m, "mass", f64buffer);
591
592 for(size_t i = 0; i < skipID; ++ i)
593 i64buffer[i] = bunch->ID[i];
594 for (size_t i = skipID; i < numLocalParticles; ++ i)
595 i64buffer[i] = bunch->ID[i + 1];
596
597 WRITEDATA(Int64, file_m, "id", i64buffer);
598
599 if ( bunch->hasBinning() ) {
600 for(size_t i = 0; i < skipID; ++ i)
601 i64buffer[i] = bunch->Bin[i];
602 for (size_t i = skipID; i < numLocalParticles; ++ i)
603 i64buffer[i] = bunch->Bin[i + 1];
604
605 WRITEDATA(Int64, file_m, "bin", i64buffer);
606 }
607
608 for (size_t i = 0; i < skipID; ++ i)
609 i64buffer[i] = bunch->bunchNum[i];
610 for (size_t i = skipID; i < numLocalParticles; ++ i)
611 i64buffer[i] = bunch->bunchNum[i + 1];
612 WRITEDATA(Int64, file_m, "bunchNumber", i64buffer);
613
614 if (Options::ebDump) {
615 for(size_t i = 0; i < skipID; ++ i)
616 f64buffer[i] = bunch->Ef[i](0);
617 for (size_t i = skipID; i < numLocalParticles; ++ i)
618 f64buffer[i] = bunch->Ef[i + 1](0);
619
620 WRITEDATA(Float64, file_m, "Ex", f64buffer);
621
622 for(size_t i = 0; i < skipID; ++ i)
623 f64buffer[i] = bunch->Ef[i](1);
624 for (size_t i = skipID; i < numLocalParticles; ++ i)
625 f64buffer[i] = bunch->Ef[i + 1](1);
626
627 WRITEDATA(Float64, file_m, "Ey", f64buffer);
628
629 for(size_t i = 0; i < skipID; ++ i)
630 f64buffer[i] = bunch->Ef[i](2);
631 for (size_t i = skipID; i < numLocalParticles; ++ i)
632 f64buffer[i] = bunch->Ef[i + 1](2);
633
634 WRITEDATA(Float64, file_m, "Ez", f64buffer);
635
636 for(size_t i = 0; i < skipID; ++ i)
637 f64buffer[i] = bunch->Bf[i](0);
638 for (size_t i = skipID; i < numLocalParticles; ++ i)
639 f64buffer[i] = bunch->Bf[i + 1](0);
640
641 WRITEDATA(Float64, file_m, "Bx", f64buffer);
642
643 for(size_t i = 0; i < skipID; ++ i)
644 f64buffer[i] = bunch->Bf[i](1);
645 for (size_t i = skipID; i < numLocalParticles; ++ i)
646 f64buffer[i] = bunch->Bf[i + 1](1);
647
648 WRITEDATA(Float64, file_m, "By", f64buffer);
649
650 for(size_t i = 0; i < skipID; ++ i)
651 f64buffer[i] = bunch->Bf[i](2);
652 for (size_t i = skipID; i < numLocalParticles; ++ i)
653 f64buffer[i] = bunch->Bf[i + 1](2);
654
655 WRITEDATA(Float64, file_m, "Bz", f64buffer);
656
657 }
658
660 if(Options::rhoDump) {
662 NDIndex<3> elem;
663 REPORTONERROR(H5Block3dSetView(file_m,
664 idx[0].min(), idx[0].max(),
665 idx[1].min(), idx[1].max(),
666 idx[2].min(), idx[2].max()));
667
668 std::unique_ptr<h5_float64_t[]> data(new h5_float64_t[(idx[0].max() + 1) * (idx[1].max() + 1) * (idx[2].max() + 1)]);
669
670 int ii = 0;
671 // h5block uses the fortran convention of storing data:
672 // INTEGER, DIMENSION(2,3) :: a
673 // => {a(1,1), a(2,1), a(1,2), a(2,2), a(1,3), a(2,3)}
674 for(int i = idx[2].min(); i <= idx[2].max(); ++ i) {
675 for(int j = idx[1].min(); j <= idx[1].max(); ++ j) {
676 for(int k = idx[0].min(); k <= idx[0].max(); ++ k) {
677 data[ii] = bunch->getRho(k, j, i);
678 ++ ii;
679 }
680 }
681 }
682 REPORTONERROR(H5Block3dWriteScalarFieldFloat64(file_m, "rho", data.get()));
683
685 REPORTONERROR(H5Block3dSetFieldOrigin(file_m, "rho",
686 (h5_float64_t)bunch->get_origin()(0),
687 (h5_float64_t)bunch->get_origin()(1),
688 (h5_float64_t)bunch->get_origin()(2)));
689
690 REPORTONERROR(H5Block3dSetFieldSpacing(file_m, "rho",
691 (h5_float64_t)bunch->get_hr()(0),
692 (h5_float64_t)bunch->get_hr()(1),
693 (h5_float64_t)bunch->get_hr()(2)));
694 }
695}
#define WRITESTRINGFILEATTRIB(file, name, value)
#define WRITESTEPATTRIB(type, file, name, value, length)
#define REPORTONERROR(rc)
#define READSTEPATTRIB(type, file, name, value)
#define WRITEDATA(type, file, name, value)
#define WRITEFILEATTRIB(type, file, name, value, length)
#define WRITESTRINGSTEPATTRIB(file, name, value)
#define READDATA(type, file, name, value)
#define READFILEATTRIB(type, file, name, value)
T::PETE_Expr_t::PETE_Return_t max(const PETE_Expr< T > &expr, NDIndex< D > &loc)
T::PETE_Expr_t::PETE_Return_t min(const PETE_Expr< T > &expr, NDIndex< D > &loc)
#define ERRORMSG(msg)
Definition IpplInfo.h:350
Inform & endl(Inform &inf)
Definition Inform.cpp:42
constexpr double epsilon_0
The permittivity of vacuum in As/Vm.
Definition Physics.h:51
constexpr double c
The velocity of light in m/s.
Definition Physics.h:45
constexpr double pi
The value of.
Definition Physics.h:30
constexpr double eV2GeV
Definition Units.h:71
constexpr double eV2MeV
Definition Units.h:77
int psDumpFreq
The frequency to dump the phase space, i.e.dump data when steppsDumpFreq==0.
Definition Options.cpp:37
bool rhoDump
Definition Options.cpp:61
bool ebDump
Definition Options.cpp:63
DumpFrame psDumpFrame
flag to decide in which coordinate frame the phase space will be dumped for OPAL-cycl
Definition Options.cpp:43
T * c_data(std::vector< T, A > &v)
Definition Util.h:317
std::string getGitRevision()
Definition Util.cpp:38
ParticleAttrib< Vector_t > Ef
double get_meanKineticEnergy() const
ParticlePos_t & R
ParticleAttrib< int > Bin
Vector_t RefPartP_m
int getSteptoLastInj() const
void setNumBunch(short n)
const MeshFitParameters & getMeshFit() const
double getQ() const
Access to reference data.
size_t getLocalNum() const
void set_sPos(double s)
void setLocalTrackStep(long long n)
step in a TRACK command
ParticleAttrib< double > M
size_t getTotalNum() const
double get_gamma() const
ParticleAttrib< Vector_t > P
Vector_t get_rrms() const
void setMeshFitMode(const CoreFitSC::ModeState &mode)
MESHFIT=CORE: restores the mode, from the step attributes of an H5 restart.
Vector_t RefPartR_m
ParticleAttrib< double > Q
void setSteptoLastInj(int n)
virtual double getRho(int x, int y, int z)=0
Vector_t get_origin() const
Vector_t get_prms() const
double getdE() const
const CoreFitSC::CoreSelection & getMeshFitCore() const
double getCharge() const
get the total charge per simulation particle
long long getLocalTrackStep() const
short getNumBunch() const
Vector_t get_norm_emit() const
Vector_t get_maxExtent() const
void get_PBounds(Vector_t &min, Vector_t &max) const
void setGlobalTrackStep(long long n)
step in multiple TRACK commands
Vector_t get_centroid() const
ParticleAttrib< short > bunchNum
Vector_t get_pmean() const
bool hasBinning() const
ParticleAttrib< Vector_t > Bf
const CoreFitSC::ModeState & getMeshFitMode() const
long long getGlobalTrackStep() const
void setT(double t)
virtual Vector_t get_hr() const
ParticleIndex_t & ID
Vector_t get_emit() const
virtual FieldLayout_t & getFieldLayout()=0
double get_sPos() const
double getM() const
double getT() const
Vector_t get_rmean() const
void setRestartDumpFreq(const int &N)
set the dump frequency as found in restart file
Definition OpalData.cpp:341
static OpalData * getInstance()
Definition OpalData.cpp:196
Result of selectCore(), the same on every rank.
Definition CoreFitSC.h:117
std::size_t numLive
particles with Bin >= 0
Definition CoreFitSC.h:123
Vector_t boundsMin
minimum over the core particles [m]
Definition CoreFitSC.h:120
std::size_t numFar
the other live particles
Definition CoreFitSC.h:125
unsigned int dwell
Definition CoreFitSC.h:313
MeshFitType type
Definition FieldSolver.h:67
size_t getNumParticles() const
void open(h5_int32_t flags)
h5_int64_t numSteps_m
std::string predecessorOPALFlavour_m
h5_file_t file_m
virtual void writeStep(PartBunchBase< double, 3 > *, const std::map< std::string, double > &additionalStepAttributes)
void readStepData(PartBunchBase< double, 3 > *, h5_ssize_t, h5_ssize_t)
void readStepHeader(PartBunchBase< double, 3 > *)
H5PartWrapperForPC(const std::string &fileName, h5_int32_t flags=H5_O_WRONLY)
void writeStepData(PartBunchBase< double, 3 > *)
h5_float64_t meanMomentum_m
void writeStepHeader(PartBunchBase< double, 3 > *, const std::map< std::string, double > &)
virtual void readStep(PartBunchBase< double, 3 > *, h5_ssize_t firstParticle, h5_ssize_t lastParticle)
The base class for all OPAL exceptions.
NDIndex< Dim > getLocalNDIndex()