OPALX (Object Oriented Parallel Accelerator Library for Exascal) master (dc2a29eed580)
OPALX
Loading...
Searching...
No Matches
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 "PartBunch/PartBunch.h"
22
23#include "BuildInfo.h"
24#include "Physics/Physics.h"
25#include "Physics/Units.h"
26#include "Utilities/OpalException.h"
27#include "Utilities/Options.h"
28#include "Utilities/Util.h"
29#include "h5core/h5_types.h"
30
31#include <cmath>
32#include <set>
33#include <sstream>
34
35H5PartWrapperForPT::H5PartWrapperForPT(const std::string& fileName, h5_int32_t flags)
36 : H5PartWrapper(fileName, flags) {}
37
38H5PartWrapperForPT::H5PartWrapperForPT(
39 const std::string& fileName, int restartStep, std::string sourceFile, h5_int32_t flags)
40 : H5PartWrapper(fileName, restartStep, sourceFile, flags) {
41 if (restartStep == -1) {
42 restartStep = H5GetNumSteps(file_m) - 1;
43 OpalData::getInstance()->setRestartStep(restartStep);
44 }
45}
46
47H5PartWrapperForPT::~H5PartWrapperForPT() {}
48
49void H5PartWrapperForPT::readHeader() {
50 h5_int64_t numFileAttributes = H5GetNumFileAttribs(file_m);
51
52 const h5_size_t lengthAttributeName = 256;
53 char attributeName[lengthAttributeName];
54 h5_int64_t attributeType;
55 h5_size_t numAttributeElements;
56 std::set<std::string> attributeNames;
57
58 for (h5_int64_t i = 0; i < numFileAttributes; ++i) {
59 REPORTONERROR(H5GetFileAttribInfo(
60 file_m, i, attributeName, lengthAttributeName, &attributeType,
61 &numAttributeElements));
62
63 attributeNames.insert(attributeName);
64 }
65
66 if (attributeNames.find("dump frequency") != attributeNames.end()) {
67 h5_int64_t dumpfreq;
68 READFILEATTRIB(Int64, file_m, "dump frequency", &dumpfreq);
69 OpalData::getInstance()->setRestartDumpFreq(dumpfreq);
70 }
71
72 if (attributeNames.find("dPhiGlobal") != attributeNames.end()) {
73 h5_float64_t dphi;
74 READFILEATTRIB(Float64, file_m, "dPhiGlobal", &dphi);
75 OpalData::getInstance()->setGlobalPhaseShift(dphi);
76 }
77
78 if (attributeNames.find("nAutoPhaseCavities") != attributeNames.end()) {
79 auto opal = OpalData::getInstance();
80 h5_float64_t phase;
81 h5_int64_t numAutoPhaseCavities = 0;
82 if (!H5HasFileAttrib(file_m, "nAutoPhaseCavities")
83 || H5ReadFileAttribInt64(file_m, "nAutoPhaseCavities", &numAutoPhaseCavities)
84 != H5_SUCCESS) {
85 numAutoPhaseCavities = 0;
86 } else {
87 for (long i = 0; i < numAutoPhaseCavities; ++i) {
88 std::string elementName = "Cav-" + std::to_string(i + 1) + "-name";
89 std::string elementPhase = "Cav-" + std::to_string(i + 1) + "-value";
90
91 char name[128];
92 READFILEATTRIB(String, file_m, elementName.c_str(), name);
93 READFILEATTRIB(Float64, file_m, elementPhase.c_str(), &phase);
94
95 opal->setMaxPhase(name, phase);
96 }
97 }
98 }
99}
100
101void H5PartWrapperForPT::readStep(
102 PartBunch_t* bunch, h5_ssize_t firstParticle, h5_ssize_t lastParticle) {
103 h5_ssize_t numStepsInSource = H5GetNumSteps(file_m);
104 h5_ssize_t readStep = numStepsInSource - 1;
105 REPORTONERROR(H5SetStep(file_m, readStep));
106
107 readStepHeader(bunch);
108 readStepData(bunch, firstParticle, lastParticle);
109}
110
111void H5PartWrapperForPT::readStepHeader(PartBunch_t* bunch) {
112 auto pc = bunch->getParticleContainer();
113 double actualT;
114 READSTEPATTRIB(Float64, file_m, "TIME", &actualT);
115 bunch->setT(actualT);
116
117 double spos;
118 READSTEPATTRIB(Float64, file_m, "SPOS", &spos);
119 pc->set_sPos(spos);
120
121 // h5_int64_t ltstep;
122 // READSTEPATTRIB(Int64, file_m, "LocalTrackStep", &ltstep);
123 // bunch->setLocalTrackStep((long long)(ltstep + 1));
124
125 h5_int64_t gtstep;
126 READSTEPATTRIB(Int64, file_m, "GlobalTrackStep", &gtstep);
127 bunch->setGlobalTrackStep((long long)(gtstep + 1));
128
129 Vector_t<double, 3> RefPartR;
130 READSTEPATTRIB(Float64, file_m, "RefPartR", (h5_float64_t*)&RefPartR);
131 pc->setRefPartR(RefPartR);
132
133 Vector_t<double, 3> RefPartP;
134 READSTEPATTRIB(Float64, file_m, "RefPartP", (h5_float64_t*)&RefPartP);
135 pc->setRefPartP(RefPartP);
136
137 Vector_t<double, 3> TaitBryant;
138 READSTEPATTRIB(Float64, file_m, "TaitBryantAngles", (h5_float64_t*)&TaitBryant);
139 Quaternion rotTheta(std::cos(0.5 * TaitBryant[0]), 0, std::sin(0.5 * TaitBryant[0]), 0);
140 Quaternion rotPhi(std::cos(0.5 * TaitBryant[1]), std::sin(0.5 * TaitBryant[1]), 0, 0);
141 Quaternion rotPsi(std::cos(0.5 * TaitBryant[2]), 0, 0, std::sin(0.5 * TaitBryant[2]));
142 Quaternion rotation = rotTheta * (rotPhi * rotPsi);
143 // ADA bunch->toLabTrafo_m = CoordinateSystemTrafo(-rotation.conjugate().rotate(RefPartR),
144 // rotation);
145}
146
147void H5PartWrapperForPT::readStepData(
148 PartBunch_t* /*bunch*/, h5_ssize_t firstParticle, h5_ssize_t lastParticle) {
149 h5_ssize_t numParticles = getNumParticles();
150 if (lastParticle >= numParticles || firstParticle > lastParticle) {
151 throw OpalException(
152 "H5PartWrapperForPT::readStepData",
153 "the provided particle numbers don't match the number of particles in the file");
154 }
155
156 REPORTONERROR(H5PartSetView(file_m, firstParticle, lastParticle));
157
158 numParticles = lastParticle - firstParticle + 1;
159
160 std::vector<char> buffer(numParticles * sizeof(h5_float64_t));
161 char* buffer_ptr = Util::c_data(buffer);
162 h5_float64_t* f64buffer = reinterpret_cast<h5_float64_t*>(buffer_ptr);
163 h5_int32_t* i32buffer = reinterpret_cast<h5_int32_t*>(buffer_ptr);
164
165 READDATA(Float64, file_m, "x", f64buffer);
166 for (long int n = 0; n < numParticles; ++n) {
167 // \todo bunch->R(n)(0) = f64buffer[n];
168 // bunch->Bin(n) = 0;
169 }
170
171 READDATA(Float64, file_m, "y", f64buffer);
172 for (long int n = 0; n < numParticles; ++n) {
173 // bunch->R(n)(1) = f64buffer[n];
174 }
175
176 READDATA(Float64, file_m, "z", f64buffer);
177 for (long int n = 0; n < numParticles; ++n) {
178 // bunch->R(n)(2) = f64buffer[n];
179 }
180
181 READDATA(Float64, file_m, "px", f64buffer);
182 for (long int n = 0; n < numParticles; ++n) {
183 // bunch->P(n)(0) = f64buffer[n];
184 }
185
186 READDATA(Float64, file_m, "py", f64buffer);
187 for (long int n = 0; n < numParticles; ++n) {
188 // bunch->P(n)(1) = f64buffer[n];
189 }
190
191 READDATA(Float64, file_m, "pz", f64buffer);
192 for (long int n = 0; n < numParticles; ++n) {
193 // bunch->P(n)(2) = f64buffer[n];
194 }
195
196 READDATA(Float64, file_m, "q", f64buffer);
197 for (long int n = 0; n < numParticles; ++n) {
198 // bunch->Q(n) = f64buffer[n];
199 }
200
201 READDATA(Int32, file_m, "id", i32buffer);
202 for (long int n = 0; n < numParticles; ++n) {
203 // bunch->ID(n) = i32buffer[n];
204 }
205
206 REPORTONERROR(H5PartSetView(file_m, -1, -1));
207 *gmsg << "not implemented:: file: " << __FILE__ << " line: " << __LINE__
208 << " function: " << __func__ << endl;
209}
210
211void H5PartWrapperForPT::writeHeader() {
212 std::stringstream OPAL_version;
213 OPAL_version << buildinfo::project_name << " " << buildinfo::project_version << " # git rev. "
214 << Util::getGitRevision();
215 WRITESTRINGFILEATTRIB(file_m, "OPAL_version", OPAL_version.str().c_str());
216
217 WRITESTRINGFILEATTRIB(file_m, "idUnit", "1");
218 WRITESTRINGFILEATTRIB(file_m, "xUnit", "m");
219 WRITESTRINGFILEATTRIB(file_m, "yUnit", "m");
220 WRITESTRINGFILEATTRIB(file_m, "zUnit", "m");
221
222 WRITESTRINGFILEATTRIB(file_m, "pxUnit", "#beta#gamma");
223 WRITESTRINGFILEATTRIB(file_m, "pyUnit", "#beta#gamma");
224 WRITESTRINGFILEATTRIB(file_m, "pzUnit", "#beta#gamma");
225
226 WRITESTRINGFILEATTRIB(file_m, "ptypeUnit", "1");
227 WRITESTRINGFILEATTRIB(file_m, "poriginUnit", "1");
228 WRITESTRINGFILEATTRIB(file_m, "qUnit", "C");
229
230 if (Options::ebDump) {
231 WRITESTRINGFILEATTRIB(file_m, "ExUnit", "MV/m");
232 WRITESTRINGFILEATTRIB(file_m, "EyUnit", "MV/m");
233 WRITESTRINGFILEATTRIB(file_m, "EzUnit", "MV/m");
234
235 WRITESTRINGFILEATTRIB(file_m, "BxUnit", "T");
236 WRITESTRINGFILEATTRIB(file_m, "ByUnit", "T");
237 WRITESTRINGFILEATTRIB(file_m, "BzUnit", "T");
238 }
239
240 if (Options::rhoDump) {
241 WRITESTRINGFILEATTRIB(file_m, "rhoUnit", "C/m^3");
242 }
243
244 WRITESTRINGFILEATTRIB(file_m, "TaitBryantAnglesUnit", "rad");
245
246 WRITESTRINGFILEATTRIB(file_m, "SPOSUnit", "m");
247 WRITESTRINGFILEATTRIB(file_m, "TIMEUnit", "s");
248 WRITESTRINGFILEATTRIB(file_m, "#gammaUnit", "1");
249 WRITESTRINGFILEATTRIB(file_m, "ENERGYUnit", "MeV");
250 WRITESTRINGFILEATTRIB(file_m, "#varepsilonUnit", "m rad");
251 WRITESTRINGFILEATTRIB(file_m, "#varepsilon-geomUnit", "m rad");
252
253 WRITESTRINGFILEATTRIB(file_m, "#sigmaUnit", "1");
254 WRITESTRINGFILEATTRIB(file_m, "RMSXUnit", "m");
255 WRITESTRINGFILEATTRIB(file_m, "centroidUnit", "m");
256 WRITESTRINGFILEATTRIB(file_m, "RMSPUnit", "#beta#gamma");
257 WRITESTRINGFILEATTRIB(file_m, "MEANPUnit", "#beta#gamma");
258
259 WRITESTRINGFILEATTRIB(file_m, "minXUnit", "m");
260 WRITESTRINGFILEATTRIB(file_m, "maxXUnit", "m");
261 WRITESTRINGFILEATTRIB(file_m, "minPUnit", "#beta#gamma");
262 WRITESTRINGFILEATTRIB(file_m, "maxPUnit", "#beta#gamma");
263
264 WRITESTRINGFILEATTRIB(file_m, "dEUnit", "MeV");
265
266 WRITESTRINGFILEATTRIB(file_m, "MASSUnit", "GeV");
267 WRITESTRINGFILEATTRIB(file_m, "CHARGEUnit", "C");
268
269 WRITESTRINGFILEATTRIB(file_m, "E-refUnit", "MV/m");
270 WRITESTRINGFILEATTRIB(file_m, "B-refUnit", "T");
271
272 WRITESTRINGFILEATTRIB(file_m, "StepUnit", "1");
273 WRITESTRINGFILEATTRIB(file_m, "LocalTrackStepUnit", "1");
274 WRITESTRINGFILEATTRIB(file_m, "GlobalTrackStepUnit", "1");
275 WRITESTRINGFILEATTRIB(file_m, "NumBunchUnit", "1");
276 WRITESTRINGFILEATTRIB(file_m, "NumPartUnit", "1");
277
278 WRITESTRINGFILEATTRIB(file_m, "RefPartRUnit", "m");
279 WRITESTRINGFILEATTRIB(file_m, "RefPartPUnit", "#beta#gamma");
280 WRITESTRINGFILEATTRIB(file_m, "SteptoLastInjUnit", "1");
281
282 WRITESTRINGFILEATTRIB(file_m, "dump frequencyUnit", "1")
283 WRITESTRINGFILEATTRIB(file_m, "dPhiGlobalUnit", "rad")
284
285
286 h5_int64_t dumpfreq = Options::psDumpFreq;
287 WRITEFILEATTRIB(Int64, file_m, "dump frequency", &dumpfreq, 1);
288
290 h5_float64_t dphi = OpalData::getInstance()->getGlobalPhaseShift();
291 WRITEFILEATTRIB(Float64, file_m, "dPhiGlobal", &dphi, 1);
292}
293
294void H5PartWrapperForPT::writeStep(
295 PartBunch_t* bunch, const std::map<std::string, double>& additionalStepAttributes,
296 size_t particleContainerIndex) {
297 auto pc = bunch->getParticleContainer(particleContainerIndex);
298 if (!pc || pc->getTotalNum() == 0) return;
299
300 open(H5_O_APPENDONLY);
301 pc->updateMoments();
302 writeStepHeader(bunch, additionalStepAttributes, particleContainerIndex);
303 writeStepData(bunch, particleContainerIndex);
304 close();
305}
306
307void H5PartWrapperForPT::writeStepHeader(
308 PartBunch_t* bunch, const std::map<std::string, double>& additionalStepAttributes,
309 size_t particleContainerIndex) {
310 auto pc = bunch->getParticleContainer(particleContainerIndex);
311 double actPos = pc->get_sPos();
312 double t = bunch->getT();
313 Vector_t<double, 3> rmin = bunch->get_origin();
314 Vector_t<double, 3> rmax = bunch->get_maxExtent();
315 Vector_t<double, 3> centroid = pc->getCentroid();
316
317 Vector_t<double, 3> maxP(0.0);
318 Vector_t<double, 3> minP(0.0);
319
320 Vector_t<double, 3> xsigma = pc->getRmsR();
321 Vector_t<double, 3> psigma = pc->getRmsP();
322 Vector_t<double, 3> vareps = pc->getNormEmit();
323 Vector_t<double, 3> geomvareps = pc->getGeometricEmit();
324 Vector_t<double, 3> RefPartR = pc->getRefPartR();
325 Vector_t<double, 3> RefPartP = pc->getRefPartP();
326 Vector_t<double, 3>
327 TaitBryant; // ADA = Util::getTaitBryantAngles(bunch->toLabTrafo_m.getRotation());
328 Vector_t<double, 3> pmean = pc->getMeanP();
329
330 double meanEnergy = pc->getMeanKineticEnergy();
331 double energySpread = pc->getStdKineticEnergy();
332 double I_0 = 4.0 * Physics::pi * Physics::epsilon_0 * Physics::c * pc->getTotalMass()
333 / pc->getTotalCharge();
334 double sigma = ((xsigma[0] * xsigma[0]) + (xsigma[1] * xsigma[1]))
335 / (2.0 * pc->getMeanGammaZ() * I_0
336 * (geomvareps[0] * geomvareps[0] + geomvareps[1] * geomvareps[1]));
337
338 // h5_int64_t localTrackStep = (h5_int64_t)bunch->getLocalTrackStep();
339 h5_int64_t globalTrackStep = (h5_int64_t)bunch->getGlobalTrackStep();
340
341 double mass = Units::eV2GeV * pc->getTotalMass();
342 double charge = pc->getTotalCharge();
343
344 h5_int64_t numBunch = 1;
345 h5_int64_t SteptoLastInj = 0;
346
347 // ADA bunch->get_PBounds(minP, maxP);
348
349 /* ------------------------------------------------------------------------ */
350
351 REPORTONERROR(H5SetStep(file_m, numSteps_m));
352
353 char const* OPALFlavour = "opal-t";
354 WRITESTRINGSTEPATTRIB(file_m, "OPAL_flavour", OPALFlavour);
355 WRITESTEPATTRIB(Float64, file_m, "SPOS", &actPos, 1);
356 WRITESTEPATTRIB(Float64, file_m, "RefPartR", (h5_float64_t*)&RefPartR, 3);
357 WRITESTEPATTRIB(Float64, file_m, "centroid", (h5_float64_t*)&centroid, 3);
358 WRITESTEPATTRIB(Float64, file_m, "RMSX", (h5_float64_t*)&xsigma, 3);
359
360 WRITESTEPATTRIB(Float64, file_m, "RefPartP", (h5_float64_t*)&RefPartP, 3);
361 WRITESTEPATTRIB(Float64, file_m, "MEANP", (h5_float64_t*)&pmean, 3);
362 WRITESTEPATTRIB(Float64, file_m, "RMSP", (h5_float64_t*)&psigma, 3);
363 WRITESTEPATTRIB(Float64, file_m, "TaitBryantAngles", (h5_float64_t*)&TaitBryant, 3);
364
365 WRITESTEPATTRIB(Float64, file_m, "#varepsilon", (h5_float64_t*)&vareps, 3);
366 WRITESTEPATTRIB(Float64, file_m, "#varepsilon-geom", (h5_float64_t*)&geomvareps, 3);
367
368 WRITESTEPATTRIB(Float64, file_m, "minX", (h5_float64_t*)&rmin, 3);
369 WRITESTEPATTRIB(Float64, file_m, "maxX", (h5_float64_t*)&rmax, 3);
370
371 WRITESTEPATTRIB(Float64, file_m, "minP", (h5_float64_t*)&minP, 3);
372 WRITESTEPATTRIB(Float64, file_m, "maxP", (h5_float64_t*)&maxP, 3);
373
374 WRITESTEPATTRIB(Int64, file_m, "Step", &numSteps_m, 1);
375 // WRITESTEPATTRIB(Int64, file_m, "LocalTrackStep", &localTrackStep, 1);
376 WRITESTEPATTRIB(Int64, file_m, "GlobalTrackStep", &globalTrackStep, 1);
377
378 WRITESTEPATTRIB(Float64, file_m, "#sigma", &sigma, 1);
379
380 WRITESTEPATTRIB(Float64, file_m, "TIME", &t, 1);
381
382 WRITESTEPATTRIB(Float64, file_m, "ENERGY", &meanEnergy, 1);
383 WRITESTEPATTRIB(Float64, file_m, "dE", &energySpread, 1);
384
386 WRITESTEPATTRIB(Float64, file_m, "MASS", &mass, 1);
387
388 WRITESTEPATTRIB(Float64, file_m, "CHARGE", &charge, 1);
389
390 WRITESTEPATTRIB(Int64, file_m, "NumBunch", &numBunch, 1);
391
392 WRITESTEPATTRIB(Int64, file_m, "SteptoLastInj", &SteptoLastInj, 1);
393
394 try {
395 Vector_t<double, 3> referenceB(
396 additionalStepAttributes.at("B-ref_x"), additionalStepAttributes.at("B-ref_z"),
397 additionalStepAttributes.at("B-ref_y"));
398 Vector_t<double, 3> referenceE(
399 additionalStepAttributes.at("E-ref_x"), additionalStepAttributes.at("E-ref_z"),
400 additionalStepAttributes.at("E-ref_y"));
401
402 WRITESTEPATTRIB(Float64, file_m, "B-ref", (h5_float64_t*)&referenceB, 3);
403 WRITESTEPATTRIB(Float64, file_m, "E-ref", (h5_float64_t*)&referenceE, 3);
404 } catch (std::out_of_range& m) {
405 *ippl::Error << m.what() << endl;
406
407 throw OpalException(
408 "H5PartWrapperForPC::writeStepHeader", "some additional step attribute not found");
409 }
410
411 ++numSteps_m;
412}
413
414void H5PartWrapperForPT::writeStepData(PartBunch_t* bunch, size_t particleContainerIndex) {
415 auto pc = bunch->getParticleContainer(particleContainerIndex);
416 size_t numLocalParticles = pc->getLocalNum();
417
418 auto rViewDevice = pc->R.getView();
419 auto rView = Kokkos::create_mirror_view(rViewDevice);
420 Kokkos::deep_copy(rView, rViewDevice);
421
422 REPORTONERROR(H5PartSetNumParticles(file_m, (h5_size_t)numLocalParticles));
423 std::vector<char> buffer(numLocalParticles * sizeof(h5_float64_t));
424 char* buffer_ptr = Util::c_data(buffer);
425 h5_float64_t* f64buffer = reinterpret_cast<h5_float64_t*>(buffer_ptr);
426 h5_int64_t* i64buffer = reinterpret_cast<h5_int64_t*>(buffer_ptr);
427 h5_int32_t* i32buffer = reinterpret_cast<h5_int32_t*>(buffer_ptr);
428
429 for (size_t i = 0; i < numLocalParticles; ++i)
430 f64buffer[i] = rView(i)(0);
431 WRITEDATA(Float64, file_m, "x", f64buffer);
432
433 for (size_t i = 0; i < numLocalParticles; ++i)
434 f64buffer[i] = rView(i)(1);
435 WRITEDATA(Float64, file_m, "y", f64buffer);
436
437 for (size_t i = 0; i < numLocalParticles; ++i)
438 f64buffer[i] = rView(i)(2);
439 WRITEDATA(Float64, file_m, "z", f64buffer);
440
441 auto pViewDevice = pc->P.getView();
442 auto pView = Kokkos::create_mirror_view(pViewDevice);
443 Kokkos::deep_copy(pView, pViewDevice);
444
445 for (long unsigned i = 0; i < numLocalParticles; i++)
446 f64buffer[i] = pView(i)(0);
447 WRITEDATA(Float64, file_m, "px", f64buffer);
448
449 for (size_t i = 0; i < numLocalParticles; ++i)
450 f64buffer[i] = pView(i)(1);
451 WRITEDATA(Float64, file_m, "py", f64buffer);
452
453 for (size_t i = 0; i < numLocalParticles; ++i)
454 f64buffer[i] = pView(i)(2);
455 WRITEDATA(Float64, file_m, "pz", f64buffer);
456
457 auto qViewDevice = pc->getQView();
458 auto qViewHost = Kokkos::create_mirror_view(qViewDevice);
459 Kokkos::deep_copy(qViewHost, qViewDevice);
460
461 const auto qmMode = pc->getQMStorageMode();
462 if (qmMode == decltype(qmMode)::Attributes) {
463 for (size_t i = 0; i < numLocalParticles; ++i) {
464 f64buffer[i] = qViewHost(i);
465 }
466 } else {
467 for (size_t i = 0; i < numLocalParticles; ++i) {
468 f64buffer[i] = qViewHost(0);
469 }
470 }
471 WRITEDATA(Float64, file_m, "q", f64buffer);
472
473 auto idViewDevice = bunch->getParticleContainer()->ID.getView();
474 auto idView = Kokkos::create_mirror_view(idViewDevice);
475 Kokkos::deep_copy(idView, idViewDevice);
476
477 for (long unsigned i = 0; i < numLocalParticles; i++)
478 i64buffer[i] = idView(i);
479 WRITEDATA(Int64, file_m, "id", i64buffer);
480
481 auto binViewDevice = pc->Bin.getView();
482 auto binView = Kokkos::create_mirror_view(binViewDevice);
483 Kokkos::deep_copy(binView, binViewDevice);
484
485 for (size_t i = 0; i < numLocalParticles; ++i)
486 i32buffer[i] = binView(i);
487 WRITEDATA(Int32, file_m, "bin", i32buffer);
488
489 const int sp = pc->Sp;
490 for (size_t i = 0; i < numLocalParticles; ++i)
491 i32buffer[i] = sp;
492 WRITEDATA(Int32, file_m, "sp", i32buffer);
493
494 if (Options::ebDump) {
495 auto EViewDevice = pc->E.getView();
496 auto EView = Kokkos::create_mirror_view(EViewDevice);
497 Kokkos::deep_copy(EView, EViewDevice);
498
499 for (size_t i = 0; i < numLocalParticles; ++i)
500 f64buffer[i] = EView(i)(0);
501 WRITEDATA(Float64, file_m, "Ex", f64buffer);
502
503 for (size_t i = 0; i < numLocalParticles; ++i)
504 f64buffer[i] = EView(i)(1);
505 WRITEDATA(Float64, file_m, "Ey", f64buffer);
506
507 for (size_t i = 0; i < numLocalParticles; ++i)
508 f64buffer[i] = EView(i)(2);
509 WRITEDATA(Float64, file_m, "Ez", f64buffer);
510
511 auto BViewDevice = pc->B.getView();
512 auto BView = Kokkos::create_mirror_view(BViewDevice);
513 Kokkos::deep_copy(BView, BViewDevice);
514
515 for (size_t i = 0; i < numLocalParticles; ++i)
516 f64buffer[i] = BView(i)(0);
517 WRITEDATA(Float64, file_m, "Bx", f64buffer);
518
519 for (size_t i = 0; i < numLocalParticles; ++i)
520 f64buffer[i] = BView(i)(1);
521 WRITEDATA(Float64, file_m, "By", f64buffer);
522
523 for (size_t i = 0; i < numLocalParticles; ++i)
524 f64buffer[i] = BView(i)(2);
525 WRITEDATA(Float64, file_m, "Bz", f64buffer);
526 }
527
528 /*
530 if (Options::rhoDump) {
531 NDIndex<3> idx = bunch->getFieldLayout().getLocalNDIndex();
532 NDIndex<3> elem;
533 h5_err_t herr = H5Block3dSetView(
534 file_m, idx[0].min(), idx[0].max(), idx[1].min(), idx[1].max(), idx[2].min(),
535 idx[2].max());
536 reportOnError(herr, __FILE__, __LINE__);
537
538 std::unique_ptr<h5_float64_t[]> data(
539 new h5_float64_t[(idx[0].max() + 1) * (idx[1].max() + 1) * (idx[2].max() + 1)]);
540
541 int ii = 0;
542 // h5block uses the fortran convention of storing data:
543 // INTEGER, DIMENSION(2,3) :: a
544 // => {a(1,1), a(2,1), a(1,2), a(2,2), a(1,3), a(2,3)}
545 for (int i = idx[2].min(); i <= idx[2].max(); ++i) {
546 for (int j = idx[1].min(); j <= idx[1].max(); ++j) {
547 for (int k = idx[0].min(); k <= idx[0].max(); ++k) {
548 data[ii] = bunch->getRho(k, j, i);
549 ++ii;
550 }
551 }
552 }
553 herr = H5Block3dWriteScalarFieldFloat64(file_m, "rho", data.get());
554 reportOnError(herr, __FILE__, __LINE__);
555
557 herr = H5Block3dSetFieldOrigin(
558 file_m, "rho", (h5_float64_t)bunch->get_origin()(0),
559 (h5_float64_t)bunch->get_origin()(1), (h5_float64_t)bunch->get_origin()(2));
560 reportOnError(herr, __FILE__, __LINE__);
561
562 herr = H5Block3dSetFieldSpacing(
563 file_m, "rho", (h5_float64_t)bunch->get_hr()(0), (h5_float64_t)bunch->get_hr()(1),
564 (h5_float64_t)bunch->get_hr()(2));
565 reportOnError(herr, __FILE__, __LINE__);
566 }
567 */
568}
gmsg
Inform * gmsg
Definition changes.cpp:7
Vector_t
ippl::Vector< T, Dim > Vector_t
Definition DistributionMoments.h:31
WRITESTRINGFILEATTRIB
#define WRITESTRINGFILEATTRIB(file, name, value)
Definition H5PartWrapper.h:23
WRITESTEPATTRIB
#define WRITESTEPATTRIB(type, file, name, value, length)
Definition H5PartWrapper.h:32
REPORTONERROR
#define REPORTONERROR(rc)
Definition H5PartWrapper.h:20
READSTEPATTRIB
#define READSTEPATTRIB(type, file, name, value)
Definition H5PartWrapper.h:28
WRITEDATA
#define WRITEDATA(type, file, name, value)
Definition H5PartWrapper.h:36
WRITEFILEATTRIB
#define WRITEFILEATTRIB(type, file, name, value, length)
Definition H5PartWrapper.h:25
WRITESTRINGSTEPATTRIB
#define WRITESTRINGSTEPATTRIB(file, name, value)
Definition H5PartWrapper.h:30
READDATA
#define READDATA(type, file, name, value)
Definition H5PartWrapper.h:35
READFILEATTRIB
#define READFILEATTRIB(type, file, name, value)
Definition H5PartWrapper.h:21
PartBunch.h
Template PIC bunch: IPPL PicManager, shared field mesh/solver, and multiple particle containers.
H5PartWrapperForPT::readStep
virtual void readStep(PartBunch_t *, h5_ssize_t firstParticle, h5_ssize_t lastParticle)
Definition H5PartWrapperForPT.cpp:101
H5PartWrapperForPT::writeStep
virtual void writeStep(PartBunch_t *, const std::map< std::string, double > &additionalStepAttributes, size_t particleContainerIndex=0)
Definition H5PartWrapperForPT.cpp:294
H5PartWrapperForPT::writeStepData
void writeStepData(PartBunch_t *, size_t particleContainerIndex)
Definition H5PartWrapperForPT.cpp:414
H5PartWrapperForPT::H5PartWrapperForPT
H5PartWrapperForPT(const std::string &fileName, h5_int32_t flags=H5_O_WRONLY)
Definition H5PartWrapperForPT.cpp:35
H5PartWrapperForPT::writeStepHeader
void writeStepHeader(PartBunch_t *, const std::map< std::string, double > &, size_t particleContainerIndex)
Definition H5PartWrapperForPT.cpp:307
H5PartWrapperForPT::readStepData
void readStepData(PartBunch_t *, h5_ssize_t, h5_ssize_t)
Definition H5PartWrapperForPT.cpp:147
H5PartWrapperForPT::readStepHeader
void readStepHeader(PartBunch_t *)
Definition H5PartWrapperForPT.cpp:111
H5PartWrapper::getNumParticles
size_t getNumParticles() const
Definition H5PartWrapper.cpp:511
H5PartWrapper::open
void open(h5_int32_t flags)
Definition H5PartWrapper.cpp:66
H5PartWrapper::numSteps_m
h5_int64_t numSteps_m
Definition H5PartWrapper.h:81
H5PartWrapper::file_m
h5_file_t file_m
Definition H5PartWrapper.h:78
OpalData::setRestartDumpFreq
void setRestartDumpFreq(const int &N)
set the dump frequency as found in restart file
Definition OpalData.cpp:294
OpalData::getGlobalPhaseShift
double getGlobalPhaseShift()
units: (sec)
Definition OpalData.cpp:370
OpalData::setGlobalPhaseShift
void setGlobalPhaseShift(double shift)
units: (sec)
Definition OpalData.cpp:365
OpalData::getInstance
static OpalData * getInstance()
Definition OpalData.cpp:193
OpalData::setRestartStep
void setRestartStep(int s)
store the location where to restart
Definition OpalData.cpp:281
PartBunch::R
Vector_t< double, Dim > R(size_t)
Do not use; throws (access positions via ParticleContainer::R).
Definition PartBunch.h:611
PartBunch::setT
void setT(double t)
Set the current simulation time.
Definition PartBunch.h:645
PartBunch::getT
double getT() const
Get the current simulation time.
Definition PartBunch.h:651
PartBunch::get_origin
Vector_t< double, Dim > get_origin() const
Cached minimum extent (rmin_m); prefer per-container min/max for multi-beam detail.
Definition PartBunch.h:655
PartBunch::get_maxExtent
Vector_t< double, Dim > get_maxExtent() const
Cached maximum extent (rmax_m).
Definition PartBunch.h:657
PartBunch::setGlobalTrackStep
void setGlobalTrackStep(long long n)
Definition PartBunch.h:670
PartBunch::getGlobalTrackStep
long long getGlobalTrackStep() const
Current global tracking step.
Definition PartBunch.h:673
Quaternion
Quaternion storage and rotation algebra used by OPALX geometry code.
Definition Quaternion.hpp:29
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:65
Options::ebDump
bool ebDump
Definition Options.cpp:67
Physics::epsilon_0
constexpr double epsilon_0
The permittivity of vacuum in As/Vm.
Definition Physics.h:66
Physics::c
constexpr double c
The velocity of light in m/s.
Definition Physics.h:60
Physics::pi
constexpr double pi
The value of.
Definition Physics.h:36
Units::eV2GeV
constexpr double eV2GeV
Definition Units.h:71
Util::c_data
T * c_data(std::vector< T, A > &v)
Definition Util.h:220
Util::getGitRevision
std::string getGitRevision()
Definition Util.cpp:32