OPAL (Object Oriented Parallel Accelerator Library) 2022.1
OPAL
H5PartWrapperForPT.cpp
Go to the documentation of this file.
1//
2// Class H5PartWrapperForPT
3// A class that manages all calls to H5Part for the Parallel-T tracker.
4//
5// Copyright (c) 200x-2021, Paul Scherrer Institut, Villigen PSI, Switzerland
6// All rights reserved
7//
8// This file is part of OPAL.
9//
10// OPAL is free software: you can redistribute it and/or modify
11// it under the terms of the GNU General Public License as published by
12// the Free Software Foundation, either version 3 of the License, or
13// (at your option) any later version.
14//
15// You should have received a copy of the GNU General Public License
16// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
17//
18#include "Structure/H5PartWrapperForPT.h"
19
20#include "AbstractObjects/OpalData.h"
21#include "Algorithms/PartBunchBase.h"
22#include "Algorithms/Vektor.h"
23#include "OPALconfig.h"
24#include "Physics/Physics.h"
25#include "Physics/Units.h"
26#include "Utilities/Options.h"
27#include "Utilities/Util.h"
28
29#include "h5core/h5_types.h"
30
31#include <cmath>
32#include <sstream>
33#include <set>
34
35H5PartWrapperForPT::H5PartWrapperForPT(const std::string& fileName, h5_int32_t flags):
36 H5PartWrapper(fileName, flags)
37{ }
38
39H5PartWrapperForPT::H5PartWrapperForPT(const std::string& fileName, int restartStep, std::string sourceFile, h5_int32_t flags):
40 H5PartWrapper(fileName, restartStep, sourceFile, flags)
41{
42 if (restartStep == -1) {
43 restartStep = H5GetNumSteps(file_m) - 1 ;
44 OpalData::getInstance()->setRestartStep(restartStep);
45 }
46}
47
48H5PartWrapperForPT::~H5PartWrapperForPT()
49{ }
50
51void H5PartWrapperForPT::readHeader() {
52 h5_int64_t numFileAttributes = H5GetNumFileAttribs(file_m);
53
54 const h5_size_t lengthAttributeName = 256;
55 char attributeName[lengthAttributeName];
56 h5_int64_t attributeType;
57 h5_size_t numAttributeElements;
58 std::set<std::string> attributeNames;
59
60 for (h5_int64_t i = 0; i < numFileAttributes; ++ i) {
61 REPORTONERROR(H5GetFileAttribInfo(file_m,
62 i,
63 attributeName,
64 lengthAttributeName,
65 &attributeType,
66 &numAttributeElements));
67
68 attributeNames.insert(attributeName);
69 }
70
71 if (attributeNames.find("dump frequency") != attributeNames.end()) {
72 h5_int64_t dumpfreq;
73 READFILEATTRIB(Int64, file_m, "dump frequency", &dumpfreq);
74 OpalData::getInstance()->setRestartDumpFreq(dumpfreq);
75 }
76
77 if (attributeNames.find("dPhiGlobal") != attributeNames.end()) {
78 h5_float64_t dphi;
79 READFILEATTRIB(Float64, file_m, "dPhiGlobal", &dphi);
80 OpalData::getInstance()->setGlobalPhaseShift(dphi);
81 }
82
83 if (attributeNames.find("nAutoPhaseCavities") != attributeNames.end()) {
84 auto opal = OpalData::getInstance();
85 h5_float64_t phase;
86 h5_int64_t numAutoPhaseCavities = 0;
87 if (!H5HasFileAttrib(file_m, "nAutoPhaseCavities") ||
88 H5ReadFileAttribInt64(file_m, "nAutoPhaseCavities", &numAutoPhaseCavities) != H5_SUCCESS) {
89 numAutoPhaseCavities = 0;
90 } else {
91 for (long i = 0; i < numAutoPhaseCavities; ++ i) {
92 std::string elementName = "Cav-" + std::to_string(i + 1) + "-name";
93 std::string elementPhase = "Cav-" + std::to_string(i + 1) + "-value";
94
95 char name[128];
96 READFILEATTRIB(String, file_m, elementName.c_str(), name);
97 READFILEATTRIB(Float64, file_m, elementPhase.c_str(), &phase);
98
99 opal->setMaxPhase(name, phase);
100 }
101 }
102 }
103}
104
105void H5PartWrapperForPT::readStep(PartBunchBase<double, 3>* bunch, h5_ssize_t firstParticle, h5_ssize_t lastParticle) {
106 h5_ssize_t numStepsInSource = H5GetNumSteps(file_m);
107 h5_ssize_t readStep = numStepsInSource - 1;
108 REPORTONERROR(H5SetStep(file_m, readStep));
109
110 readStepHeader(bunch);
111 readStepData(bunch, firstParticle, lastParticle);
112}
113
114void H5PartWrapperForPT::readStepHeader(PartBunchBase<double, 3>* bunch) {
115 double actualT;
116 READSTEPATTRIB(Float64, file_m, "TIME", &actualT);
117 bunch->setT(actualT);
118
119 double spos;
120 READSTEPATTRIB(Float64, file_m, "SPOS", &spos);
121 bunch->set_sPos(spos);
122
123 h5_int64_t ltstep;
124 READSTEPATTRIB(Int64, file_m, "LocalTrackStep", &ltstep);
125 bunch->setLocalTrackStep((long long)(ltstep + 1));
126
127 h5_int64_t gtstep;
128 READSTEPATTRIB(Int64, file_m, "GlobalTrackStep", &gtstep);
129 bunch->setGlobalTrackStep((long long)(gtstep + 1));
130
131 Vector_t RefPartR;
132 READSTEPATTRIB(Float64, file_m, "RefPartR", (h5_float64_t *)&RefPartR);
133 bunch->RefPartR_m = RefPartR;
134
135 Vector_t RefPartP;
136 READSTEPATTRIB(Float64, file_m, "RefPartP", (h5_float64_t *)&RefPartP);
137 bunch->RefPartP_m = RefPartP;
138
139 Vector_t TaitBryant;
140 READSTEPATTRIB(Float64, file_m, "TaitBryantAngles", (h5_float64_t *)&TaitBryant);
141 Quaternion rotTheta(std::cos(0.5 * TaitBryant[0]), 0, std::sin(0.5 * TaitBryant[0]), 0);
142 Quaternion rotPhi(std::cos(0.5 * TaitBryant[1]), std::sin(0.5 * TaitBryant[1]), 0, 0);
143 Quaternion rotPsi(std::cos(0.5 * TaitBryant[2]), 0, 0, std::sin(0.5 * TaitBryant[2]));
144 Quaternion rotation = rotTheta * (rotPhi * rotPsi);
145 bunch->toLabTrafo_m = CoordinateSystemTrafo(-rotation.conjugate().rotate(RefPartR), rotation);
146}
147
148void H5PartWrapperForPT::readStepData(PartBunchBase<double, 3>* bunch, h5_ssize_t firstParticle, h5_ssize_t lastParticle) {
149 h5_ssize_t numParticles = getNumParticles();
150 if (lastParticle >= numParticles || firstParticle > lastParticle) {
151 throw OpalException("H5PartWrapperForPT::readStepData",
152 "the provided particle numbers don't match the number of particles in the file");
153 }
154
155 REPORTONERROR(H5PartSetView(file_m, firstParticle, lastParticle));
156
157 numParticles = lastParticle - firstParticle + 1;
158
159 std::vector<char> buffer(numParticles * sizeof(h5_float64_t));
160 char* buffer_ptr = Util::c_data(buffer);
161 h5_float64_t* f64buffer = reinterpret_cast<h5_float64_t*>(buffer_ptr);
162 h5_int32_t* i32buffer = reinterpret_cast<h5_int32_t*>(buffer_ptr);
163
164 READDATA(Float64, file_m, "x", f64buffer);
165 for (long int n = 0; n < numParticles; ++ n) {
166 bunch->R[n](0) = f64buffer[n];
167 bunch->Bin[n] = 0;
168 }
169
170 READDATA(Float64, file_m, "y", f64buffer);
171 for (long int n = 0; n < numParticles; ++ n) {
172 bunch->R[n](1) = f64buffer[n];
173 }
174
175 READDATA(Float64, file_m, "z", f64buffer);
176 for (long int n = 0; n < numParticles; ++ n) {
177 bunch->R[n](2) = f64buffer[n];
178 }
179
180 READDATA(Float64, file_m, "px", f64buffer);
181 for (long int n = 0; n < numParticles; ++ n) {
182 bunch->P[n](0) = f64buffer[n];
183 }
184
185 READDATA(Float64, file_m, "py", f64buffer);
186 for (long int n = 0; n < numParticles; ++ n) {
187 bunch->P[n](1) = f64buffer[n];
188 }
189
190 READDATA(Float64, file_m, "pz", f64buffer);
191 for (long int n = 0; n < numParticles; ++ n) {
192 bunch->P[n](2) = f64buffer[n];
193 }
194
195 READDATA(Float64, file_m, "q", f64buffer);
196 for (long int n = 0; n < numParticles; ++ n) {
197 bunch->Q[n] = f64buffer[n];
198 }
199
200 READDATA(Int32, file_m, "id", i32buffer);
201 for (long int n = 0; n < numParticles; ++ n) {
202 bunch->ID[n] = i32buffer[n];
203 }
204
205 REPORTONERROR(H5PartSetView(file_m, -1, -1));
206}
207
208void H5PartWrapperForPT::writeHeader() {
209 std::stringstream OPAL_version;
210 OPAL_version << OPAL_PROJECT_NAME << " " << OPAL_PROJECT_VERSION << " # git rev. " << Util::getGitRevision();
211 WRITESTRINGFILEATTRIB(file_m, "OPAL_version", OPAL_version.str().c_str());
212
213 WRITESTRINGFILEATTRIB(file_m, "idUnit", "1");
214 WRITESTRINGFILEATTRIB(file_m, "xUnit", "m");
215 WRITESTRINGFILEATTRIB(file_m, "yUnit", "m");
216 WRITESTRINGFILEATTRIB(file_m, "zUnit", "m");
217
218 WRITESTRINGFILEATTRIB(file_m, "pxUnit", "#beta#gamma");
219 WRITESTRINGFILEATTRIB(file_m, "pyUnit", "#beta#gamma");
220 WRITESTRINGFILEATTRIB(file_m, "pzUnit", "#beta#gamma");
221
222 WRITESTRINGFILEATTRIB(file_m, "ptypeUnit", "1");
223 WRITESTRINGFILEATTRIB(file_m, "poriginUnit", "1");
224 WRITESTRINGFILEATTRIB(file_m, "qUnit", "C");
225
226 if (Options::ebDump) {
227 WRITESTRINGFILEATTRIB(file_m, "ExUnit", "MV/m");
228 WRITESTRINGFILEATTRIB(file_m, "EyUnit", "MV/m");
229 WRITESTRINGFILEATTRIB(file_m, "EzUnit", "MV/m");
230
231 WRITESTRINGFILEATTRIB(file_m, "BxUnit", "T");
232 WRITESTRINGFILEATTRIB(file_m, "ByUnit", "T");
233 WRITESTRINGFILEATTRIB(file_m, "BzUnit", "T");
234 }
235
236 if (Options::rhoDump) {
237 WRITESTRINGFILEATTRIB(file_m, "rhoUnit", "C/m^3");
238 }
239
240 WRITESTRINGFILEATTRIB(file_m, "TaitBryantAnglesUnit", "rad");
241
242 WRITESTRINGFILEATTRIB(file_m, "SPOSUnit", "m");
243 WRITESTRINGFILEATTRIB(file_m, "TIMEUnit", "s");
244 WRITESTRINGFILEATTRIB(file_m, "#gammaUnit", "1");
245 WRITESTRINGFILEATTRIB(file_m, "ENERGYUnit", "MeV");
246 WRITESTRINGFILEATTRIB(file_m, "#varepsilonUnit", "m rad");
247 WRITESTRINGFILEATTRIB(file_m, "#varepsilon-geomUnit", "m rad");
248
249 WRITESTRINGFILEATTRIB(file_m, "#sigmaUnit", "1");
250 WRITESTRINGFILEATTRIB(file_m, "RMSXUnit", "m");
251 WRITESTRINGFILEATTRIB(file_m, "centroidUnit", "m");
252 WRITESTRINGFILEATTRIB(file_m, "RMSPUnit", "#beta#gamma");
253 WRITESTRINGFILEATTRIB(file_m, "MEANPUnit", "#beta#gamma");
254
255 WRITESTRINGFILEATTRIB(file_m, "minXUnit", "m");
256 WRITESTRINGFILEATTRIB(file_m, "maxXUnit", "m");
257 WRITESTRINGFILEATTRIB(file_m, "minPUnit", "#beta#gamma");
258 WRITESTRINGFILEATTRIB(file_m, "maxPUnit", "#beta#gamma");
259
260 WRITESTRINGFILEATTRIB(file_m, "dEUnit", "MeV");
261
262 WRITESTRINGFILEATTRIB(file_m, "MASSUnit", "GeV");
263 WRITESTRINGFILEATTRIB(file_m, "CHARGEUnit", "C");
264
265 WRITESTRINGFILEATTRIB(file_m, "E-refUnit", "MV/m");
266 WRITESTRINGFILEATTRIB(file_m, "B-refUnit", "T");
267
268 WRITESTRINGFILEATTRIB(file_m, "StepUnit", "1");
269 WRITESTRINGFILEATTRIB(file_m, "LocalTrackStepUnit", "1");
270 WRITESTRINGFILEATTRIB(file_m, "GlobalTrackStepUnit", "1");
271 WRITESTRINGFILEATTRIB(file_m, "NumBunchUnit", "1");
272 WRITESTRINGFILEATTRIB(file_m, "NumPartUnit", "1");
273
274 WRITESTRINGFILEATTRIB(file_m, "RefPartRUnit", "m");
275 WRITESTRINGFILEATTRIB(file_m, "RefPartPUnit", "#beta#gamma");
276 WRITESTRINGFILEATTRIB(file_m, "SteptoLastInjUnit", "1");
277
278 WRITESTRINGFILEATTRIB(file_m, "dump frequencyUnit", "1")
279 WRITESTRINGFILEATTRIB(file_m, "dPhiGlobalUnit", "rad")
280
281
282 h5_int64_t dumpfreq = Options::psDumpFreq;
283 WRITEFILEATTRIB(Int64, file_m, "dump frequency", &dumpfreq, 1);
284
285
287 h5_float64_t dphi = OpalData::getInstance()->getGlobalPhaseShift();
288 WRITEFILEATTRIB(Float64, file_m, "dPhiGlobal", &dphi, 1);
289}
290
291void H5PartWrapperForPT::writeStep(PartBunchBase<double, 3>* bunch, const std::map<std::string, double>& additionalStepAttributes) {
292 if (bunch->getTotalNum() == 0) return;
293
294 open(H5_O_APPENDONLY);
295 bunch->calcBeamParameters();
296 writeStepHeader(bunch, additionalStepAttributes);
297 writeStepData(bunch);
298 close();
299}
300
301void H5PartWrapperForPT::writeStepHeader(PartBunchBase<double, 3>* bunch, const std::map<std::string, double>& additionalStepAttributes) {
302 double actPos = bunch->get_sPos();
303 double t = bunch->getT();
304 Vector_t rmin = bunch->get_origin();
305 Vector_t rmax = bunch->get_maxExtent();
306 Vector_t centroid = bunch->get_centroid();
307
308 Vector_t maxP(0.0);
309 Vector_t minP(0.0);
310
311 Vector_t xsigma = bunch->get_rrms();
312 Vector_t psigma = bunch->get_prms();
313 Vector_t vareps = bunch->get_norm_emit();
314 Vector_t geomvareps = bunch->get_emit();
315 Vector_t RefPartR = bunch->RefPartR_m;
316 Vector_t RefPartP = bunch->RefPartP_m;
317 Vector_t TaitBryant = Util::getTaitBryantAngles(bunch->toLabTrafo_m.getRotation());
318 Vector_t pmean = bunch->get_pmean();
319
320 double meanEnergy = bunch->get_meanKineticEnergy();
321 double energySpread = bunch->getdE();
322 double I_0 = 4.0 * Physics::pi * Physics::epsilon_0 * Physics::c * bunch->getM() / bunch->getQ();
323 double sigma = ((xsigma[0] * xsigma[0]) + (xsigma[1] * xsigma[1])) /
324 (2.0 * bunch->get_gamma() * I_0 * (geomvareps[0] * geomvareps[0] + geomvareps[1] * geomvareps[1]));
325
326 h5_int64_t localTrackStep = (h5_int64_t)bunch->getLocalTrackStep();
327 h5_int64_t globalTrackStep = (h5_int64_t)bunch->getGlobalTrackStep();
328
329 double mass = Units::eV2GeV * bunch->getM();
330 double charge = bunch->getCharge();
331
332 h5_int64_t numBunch = 1;
333 h5_int64_t SteptoLastInj = 0;
334
335 bunch->get_PBounds(minP, maxP);
336
337 /* ------------------------------------------------------------------------ */
338
339 REPORTONERROR(H5SetStep(file_m, numSteps_m));
340
341 char const* OPALFlavour = "opal-t";
342 WRITESTRINGSTEPATTRIB(file_m, "OPAL_flavour", OPALFlavour);
343 WRITESTEPATTRIB(Float64, file_m, "SPOS", &actPos, 1);
344 WRITESTEPATTRIB(Float64, file_m, "RefPartR", (h5_float64_t*)&RefPartR, 3);
345 WRITESTEPATTRIB(Float64, file_m, "centroid", (h5_float64_t*)&centroid, 3);
346 WRITESTEPATTRIB(Float64, file_m, "RMSX", (h5_float64_t*)&xsigma, 3);
347
348 WRITESTEPATTRIB(Float64, file_m, "RefPartP", (h5_float64_t*)&RefPartP, 3);
349 WRITESTEPATTRIB(Float64, file_m, "MEANP", (h5_float64_t*)&pmean, 3);
350 WRITESTEPATTRIB(Float64, file_m, "RMSP", (h5_float64_t*)&psigma, 3);
351 WRITESTEPATTRIB(Float64, file_m, "TaitBryantAngles", (h5_float64_t*)&TaitBryant, 3);
352
353 WRITESTEPATTRIB(Float64, file_m, "#varepsilon", (h5_float64_t*)&vareps, 3);
354 WRITESTEPATTRIB(Float64, file_m, "#varepsilon-geom", (h5_float64_t*)&geomvareps, 3);
355
356 WRITESTEPATTRIB(Float64, file_m, "minX", (h5_float64_t*)&rmin, 3);
357 WRITESTEPATTRIB(Float64, file_m, "maxX", (h5_float64_t*)&rmax, 3);
358
359 WRITESTEPATTRIB(Float64, file_m, "minP", (h5_float64_t*)&minP, 3);
360 WRITESTEPATTRIB(Float64, file_m, "maxP", (h5_float64_t*)&maxP, 3);
361
362 WRITESTEPATTRIB(Int64, file_m, "Step", &numSteps_m, 1);
363 WRITESTEPATTRIB(Int64, file_m, "LocalTrackStep", &localTrackStep, 1);
364 WRITESTEPATTRIB(Int64, file_m, "GlobalTrackStep", &globalTrackStep, 1);
365
366 WRITESTEPATTRIB(Float64, file_m, "#sigma", &sigma, 1);
367
368 WRITESTEPATTRIB(Float64, file_m, "TIME", &t, 1);
369
370 WRITESTEPATTRIB(Float64, file_m, "ENERGY", &meanEnergy, 1);
371 WRITESTEPATTRIB(Float64, file_m, "dE", &energySpread, 1);
372
374 WRITESTEPATTRIB(Float64, file_m, "MASS", &mass, 1);
375
376 WRITESTEPATTRIB(Float64, file_m, "CHARGE", &charge, 1);
377
378 WRITESTEPATTRIB(Int64, file_m, "NumBunch", &numBunch, 1);
379
380 WRITESTEPATTRIB(Int64, file_m, "SteptoLastInj", &SteptoLastInj, 1);
381
382 try {
383 Vector_t referenceB(additionalStepAttributes.at("B-ref_x"),
384 additionalStepAttributes.at("B-ref_z"),
385 additionalStepAttributes.at("B-ref_y"));
386 Vector_t referenceE(additionalStepAttributes.at("E-ref_x"),
387 additionalStepAttributes.at("E-ref_z"),
388 additionalStepAttributes.at("E-ref_y"));
389
390 WRITESTEPATTRIB(Float64, file_m, "B-ref", (h5_float64_t*)&referenceB, 3);
391 WRITESTEPATTRIB(Float64, file_m, "E-ref", (h5_float64_t*)&referenceE, 3);
392 } catch (std::out_of_range & m) {
393 ERRORMSG(m.what() << endl);
394
395 throw OpalException("H5PartWrapperForPC::writeStepHeader",
396 "some additional step attribute not found");
397 }
398
399 ++ numSteps_m;
400}
401
402void H5PartWrapperForPT::writeStepData(PartBunchBase<double, 3>* bunch) {
403 size_t numLocalParticles = bunch->getLocalNum();
404
405 REPORTONERROR(H5PartSetNumParticles(file_m, numLocalParticles));
406
407 std::vector<char> buffer(numLocalParticles * sizeof(h5_float64_t));
408 char* buffer_ptr = Util::c_data(buffer);
409 h5_float64_t* f64buffer = reinterpret_cast<h5_float64_t*>(buffer_ptr);
410 h5_int64_t* i64buffer = reinterpret_cast<h5_int64_t*>(buffer_ptr);
411 h5_int32_t* i32buffer = reinterpret_cast<h5_int32_t*>(buffer_ptr);
412
413 for (size_t i = 0; i < numLocalParticles; ++ i)
414 f64buffer[i] = bunch->R[i](0);
415 WRITEDATA(Float64, file_m, "x", f64buffer);
416
417 for (size_t i = 0; i < numLocalParticles; ++ i)
418 f64buffer[i] = bunch->R[i](1);
419 WRITEDATA(Float64, file_m, "y", f64buffer);
420
421 for (size_t i = 0; i < numLocalParticles; ++ i)
422 f64buffer[i] = bunch->R[i](2);
423 WRITEDATA(Float64, file_m, "z", f64buffer);
424
425 for (size_t i = 0; i < numLocalParticles; ++ i)
426 f64buffer[i] = bunch->P[i](0);
427 WRITEDATA(Float64, file_m, "px", f64buffer);
428
429 for (size_t i = 0; i < numLocalParticles; ++ i)
430 f64buffer[i] = bunch->P[i](1);
431 WRITEDATA(Float64, file_m, "py", f64buffer);
432
433 for (size_t i = 0; i < numLocalParticles; ++ i)
434 f64buffer[i] = bunch->P[i](2);
435 WRITEDATA(Float64, file_m, "pz", f64buffer);
436
437 for (size_t i = 0; i < numLocalParticles; ++ i)
438 f64buffer[i] = bunch->Q[i];
439 WRITEDATA(Float64, file_m, "q", f64buffer);
440
441 for (size_t i = 0; i < numLocalParticles; ++ i)
442 i64buffer[i] = bunch->ID[i];
443 WRITEDATA(Int64, file_m, "id", i64buffer);
444
445 for (size_t i = 0; i < numLocalParticles; ++ i)
446 i32buffer[i] = (h5_int32_t) bunch->PType[i];
447 WRITEDATA(Int32, file_m, "ptype", i32buffer);
448
449 for (size_t i = 0; i < numLocalParticles; ++ i)
450 i32buffer[i] = (h5_int32_t) bunch->POrigin[i];
451 WRITEDATA(Int32, file_m, "porigin", i32buffer);
452
453 if (Options::ebDump) {
454 for (size_t i = 0; i < numLocalParticles; ++ i)
455 f64buffer[i] = bunch->Ef[i](0);
456 WRITEDATA(Float64, file_m, "Ex", f64buffer);
457
458 for (size_t i = 0; i < numLocalParticles; ++ i)
459 f64buffer[i] = bunch->Ef[i](1);
460 WRITEDATA(Float64, file_m, "Ey", f64buffer);
461
462 for (size_t i = 0; i < numLocalParticles; ++ i)
463 f64buffer[i] = bunch->Ef[i](2);
464 WRITEDATA(Float64, file_m, "Ez", f64buffer);
465
466 for (size_t i = 0; i < numLocalParticles; ++ i)
467 f64buffer[i] = bunch->Bf[i](0);
468 WRITEDATA(Float64, file_m, "Bx", f64buffer);
469
470 for (size_t i = 0; i < numLocalParticles; ++ i)
471 f64buffer[i] = bunch->Bf[i](1);
472 WRITEDATA(Float64, file_m, "By", f64buffer);
473
474 for (size_t i = 0; i < numLocalParticles; ++ i)
475 f64buffer[i] = bunch->Bf[i](2);
476 WRITEDATA(Float64, file_m, "Bz", f64buffer);
477
478 }
479
481 if (Options::rhoDump) {
482 NDIndex<3> idx = bunch->getFieldLayout().getLocalNDIndex();
483 NDIndex<3> elem;
484 h5_err_t herr = H5Block3dSetView(
485 file_m,
486 idx[0].min(), idx[0].max(),
487 idx[1].min(), idx[1].max(),
488 idx[2].min(), idx[2].max());
489 reportOnError(herr, __FILE__, __LINE__);
490
491 std::unique_ptr<h5_float64_t[]> data(new h5_float64_t[(idx[0].max() + 1) * (idx[1].max() + 1) * (idx[2].max() + 1)]);
492
493 int ii = 0;
494 // h5block uses the fortran convention of storing data:
495 // INTEGER, DIMENSION(2,3) :: a
496 // => {a(1,1), a(2,1), a(1,2), a(2,2), a(1,3), a(2,3)}
497 for (int i = idx[2].min(); i <= idx[2].max(); ++ i) {
498 for (int j = idx[1].min(); j <= idx[1].max(); ++ j) {
499 for (int k = idx[0].min(); k <= idx[0].max(); ++ k) {
500 data[ii] = bunch->getRho(k, j, i);
501 ++ ii;
502 }
503 }
504 }
505 herr = H5Block3dWriteScalarFieldFloat64(file_m, "rho", data.get());
506 reportOnError(herr, __FILE__, __LINE__);
507
509 herr = H5Block3dSetFieldOrigin(file_m, "rho",
510 (h5_float64_t)bunch->get_origin()(0),
511 (h5_float64_t)bunch->get_origin()(1),
512 (h5_float64_t)bunch->get_origin()(2));
513 reportOnError(herr, __FILE__, __LINE__);
514
515 herr = H5Block3dSetFieldSpacing(file_m, "rho",
516 (h5_float64_t)bunch->get_hr()(0),
517 (h5_float64_t)bunch->get_hr()(1),
518 (h5_float64_t)bunch->get_hr()(2));
519 reportOnError(herr, __FILE__, __LINE__);
520
521 }
522}
OPAL_PROJECT_VERSION
#define OPAL_PROJECT_VERSION
Definition: OPALconfig.h:5
OPAL_PROJECT_NAME
#define OPAL_PROJECT_NAME
Definition: OPALconfig.h:2
cos
Tps< T > cos(const Tps< T > &x)
Cosine.
Definition: TpsMath.h:129
sin
Tps< T > sin(const Tps< T > &x)
Sine.
Definition: TpsMath.h:111
WRITESTRINGFILEATTRIB
#define WRITESTRINGFILEATTRIB(file, name, value)
Definition: H5PartWrapper.h:24
WRITESTEPATTRIB
#define WRITESTEPATTRIB(type, file, name, value, length)
Definition: H5PartWrapper.h:29
REPORTONERROR
#define REPORTONERROR(rc)
Definition: H5PartWrapper.h:22
READSTEPATTRIB
#define READSTEPATTRIB(type, file, name, value)
Definition: H5PartWrapper.h:27
WRITEDATA
#define WRITEDATA(type, file, name, value)
Definition: H5PartWrapper.h:32
WRITEFILEATTRIB
#define WRITEFILEATTRIB(type, file, name, value, length)
Definition: H5PartWrapper.h:25
WRITESTRINGSTEPATTRIB
#define WRITESTRINGSTEPATTRIB(file, name, value)
Definition: H5PartWrapper.h:28
READDATA
#define READDATA(type, file, name, value)
Definition: H5PartWrapper.h:31
READFILEATTRIB
#define READFILEATTRIB(type, file, name, value)
Definition: H5PartWrapper.h:23
max
T::PETE_Expr_t::PETE_Return_t max(const PETE_Expr< T > &expr, NDIndex< D > &loc)
Definition: ReductionLoc.h:84
min
T::PETE_Expr_t::PETE_Return_t min(const PETE_Expr< T > &expr, NDIndex< D > &loc)
Definition: ReductionLoc.h:76
endl
Inform & endl(Inform &inf)
Definition: Inform.cpp:42
ERRORMSG
#define ERRORMSG(msg)
Definition: IpplInfo.h:350
name
const std::string name
Definition: MaxNormRadialPeak.cpp:32
PyOpal::PyElementNS::attributeName
std::map< AttributeType, std::string > attributeName
Definition: PyElement.cpp:7
Physics::epsilon_0
constexpr double epsilon_0
The permittivity of vacuum in As/Vm.
Definition: Physics.h:51
Physics::c
constexpr double c
The velocity of light in m/s.
Definition: Physics.h:45
Physics::pi
constexpr double pi
The value of.
Definition: Physics.h:30
Units::eV2GeV
constexpr double eV2GeV
Definition: Units.h:71
Options::psDumpFreq
int psDumpFreq
The frequency to dump the phase space, i.e.dump data when steppsDumpFreq==0.
Definition: Options.cpp:39
Options::rhoDump
bool rhoDump
Definition: Options.cpp:63
Options::ebDump
bool ebDump
Definition: Options.cpp:65
Util::getTaitBryantAngles
Vector_t getTaitBryantAngles(Quaternion rotation, const std::string &)
Definition: Util.cpp:116
Util::c_data
T * c_data(std::vector< T, A > &v)
Definition: Util.h:227
Util::getGitRevision
std::string getGitRevision()
Definition: Util.cpp:32
PartBunchBase::Ef
ParticleAttrib< Vector_t > Ef
Definition: PartBunchBase.h:578
PartBunchBase::get_meanKineticEnergy
double get_meanKineticEnergy() const
Definition: PartBunchBase.hpp:1067
PartBunchBase::R
ParticlePos_t & R
Definition: PartBunchBase.h:570
PartBunchBase::Bin
ParticleAttrib< int > Bin
Definition: PartBunchBase.h:582
PartBunchBase::RefPartP_m
Vector_t RefPartP_m
Definition: PartBunchBase.h:591
PartBunchBase::getQ
double getQ() const
Access to reference data.
Definition: PartBunchBase.hpp:1630
PartBunchBase::getLocalNum
size_t getLocalNum() const
Definition: PartBunchBase.hpp:1905
PartBunchBase::set_sPos
void set_sPos(double s)
Definition: PartBunchBase.hpp:1055
PartBunchBase::setLocalTrackStep
void setLocalTrackStep(long long n)
step in a TRACK command
Definition: PartBunchBase.hpp:1395
PartBunchBase::getTotalNum
size_t getTotalNum() const
Definition: PartBunchBase.hpp:1900
PartBunchBase::get_gamma
double get_gamma() const
Definition: PartBunchBase.hpp:1061
PartBunchBase::P
ParticleAttrib< Vector_t > P
Definition: PartBunchBase.h:574
PartBunchBase::PType
ParticleAttrib< ParticleType > PType
Definition: PartBunchBase.h:584
PartBunchBase::POrigin
ParticleAttrib< ParticleOrigin > POrigin
Definition: PartBunchBase.h:585
PartBunchBase::get_rrms
Vector_t get_rrms() const
Definition: PartBunchBase.hpp:1111
PartBunchBase::RefPartR_m
Vector_t RefPartR_m
Definition: PartBunchBase.h:590
PartBunchBase::Q
ParticleAttrib< double > Q
Definition: PartBunchBase.h:575
PartBunchBase::calcBeamParameters
void calcBeamParameters()
Definition: PartBunchBase.hpp:1267
PartBunchBase::getRho
virtual double getRho(int x, int y, int z)=0
PartBunchBase::get_origin
Vector_t get_origin() const
Definition: PartBunchBase.hpp:1093
PartBunchBase::get_prms
Vector_t get_prms() const
Definition: PartBunchBase.hpp:1129
PartBunchBase::getdE
double getdE() const
Definition: PartBunchBase.hpp:1694
PartBunchBase::getCharge
double getCharge() const
get the total charge per simulation particle
Definition: PartBunchBase.hpp:1317
PartBunchBase::toLabTrafo_m
CoordinateSystemTrafo toLabTrafo_m
Definition: PartBunchBase.h:593
PartBunchBase::getLocalTrackStep
long long getLocalTrackStep() const
Definition: PartBunchBase.hpp:1407
PartBunchBase::get_norm_emit
Vector_t get_norm_emit() const
Definition: PartBunchBase.hpp:1157
PartBunchBase::get_maxExtent
Vector_t get_maxExtent() const
Definition: PartBunchBase.hpp:1099
PartBunchBase::get_PBounds
void get_PBounds(Vector_t &min, Vector_t &max) const
Definition: PartBunchBase.hpp:1261
PartBunchBase::setGlobalTrackStep
void setGlobalTrackStep(long long n)
step in multiple TRACK commands
Definition: PartBunchBase.hpp:1383
PartBunchBase::get_centroid
Vector_t get_centroid() const
Definition: PartBunchBase.hpp:1105
PartBunchBase::get_pmean
Vector_t get_pmean() const
Definition: PartBunchBase.hpp:1135
PartBunchBase::Bf
ParticleAttrib< Vector_t > Bf
Definition: PartBunchBase.h:581
PartBunchBase::getGlobalTrackStep
long long getGlobalTrackStep() const
Definition: PartBunchBase.hpp:1389
PartBunchBase::setT
void setT(double t)
Definition: PartBunchBase.hpp:1031
PartBunchBase::get_hr
virtual Vector_t get_hr() const
Definition: PartBunchBase.hpp:1232
PartBunchBase::ID
ParticleIndex_t & ID
Definition: PartBunchBase.h:571
PartBunchBase::get_emit
Vector_t get_emit() const
Definition: PartBunchBase.hpp:1151
PartBunchBase::getFieldLayout
virtual FieldLayout_t & getFieldLayout()=0
PartBunchBase::get_sPos
double get_sPos() const
Definition: PartBunchBase.hpp:1049
PartBunchBase::getM
double getM() const
Definition: PartBunchBase.hpp:1636
PartBunchBase::getT
double getT() const
Definition: PartBunchBase.hpp:1043
OpalData::setRestartDumpFreq
void setRestartDumpFreq(const int &N)
set the dump frequency as found in restart file
Definition: OpalData.cpp:341
OpalData::getGlobalPhaseShift
double getGlobalPhaseShift()
units: (sec)
Definition: OpalData.cpp:452
OpalData::setGlobalPhaseShift
void setGlobalPhaseShift(double shift)
units: (sec)
Definition: OpalData.cpp:447
OpalData::getInstance
static OpalData * getInstance()
Definition: OpalData.cpp:196
OpalData::setRestartStep
void setRestartStep(int s)
store the location where to restart
Definition: OpalData.cpp:320
CoordinateSystemTrafo::getRotation
Quaternion getRotation() const
Definition: CoordinateSystemTrafo.h:65
Quaternion::rotate
Vector_t rotate(const Vector_t &) const
Definition: Quaternion.cpp:122
Quaternion::conjugate
Quaternion conjugate() const
Definition: Quaternion.h:105
H5PartWrapper::getNumParticles
size_t getNumParticles() const
Definition: H5PartWrapper.cpp:525
H5PartWrapper::open
void open(h5_int32_t flags)
Definition: H5PartWrapper.cpp:72
H5PartWrapper::numSteps_m
h5_int64_t numSteps_m
Definition: H5PartWrapper.h:76
H5PartWrapper::file_m
h5_file_t file_m
Definition: H5PartWrapper.h:73
H5PartWrapper::reportOnError
static void reportOnError(h5_int64_t rc, const char *file, int line)
Definition: H5PartWrapper.h:83
H5PartWrapperForPT::writeStepData
void writeStepData(PartBunchBase< double, 3 > *)
Definition: H5PartWrapperForPT.cpp:402
H5PartWrapperForPT::readStepHeader
void readStepHeader(PartBunchBase< double, 3 > *)
Definition: H5PartWrapperForPT.cpp:114
H5PartWrapperForPT::writeHeader
virtual void writeHeader()
Definition: H5PartWrapperForPT.cpp:208
H5PartWrapperForPT::writeStep
virtual void writeStep(PartBunchBase< double, 3 > *, const std::map< std::string, double > &additionalStepAttributes)
Definition: H5PartWrapperForPT.cpp:291
H5PartWrapperForPT::readStepData
void readStepData(PartBunchBase< double, 3 > *, h5_ssize_t, h5_ssize_t)
Definition: H5PartWrapperForPT.cpp:148
H5PartWrapperForPT::H5PartWrapperForPT
H5PartWrapperForPT(const std::string &fileName, h5_int32_t flags=H5_O_WRONLY)
Definition: H5PartWrapperForPT.cpp:35
H5PartWrapperForPT::readHeader
virtual void readHeader()
Definition: H5PartWrapperForPT.cpp:51
H5PartWrapperForPT::readStep
virtual void readStep(PartBunchBase< double, 3 > *, h5_ssize_t firstParticle, h5_ssize_t lastParticle)
Definition: H5PartWrapperForPT.cpp:105
H5PartWrapperForPT::writeStepHeader
void writeStepHeader(PartBunchBase< double, 3 > *, const std::map< std::string, double > &)
Definition: H5PartWrapperForPT.cpp:301
OpalException
The base class for all OPAL exceptions.
Definition: OpalException.h:28
FieldLayout::getLocalNDIndex
NDIndex< Dim > getLocalNDIndex()
Definition: FieldLayout.hpp:1579
Generated on Thu Oct 20 2022 17:40:12 for OPAL (Object Oriented Parallel Accelerator Library) by doxygen 1.9.3