OPAL (Object Oriented Parallel Accelerator Library)  2024.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 
35 H5PartWrapperForPT::H5PartWrapperForPT(const std::string& fileName, h5_int32_t flags):
36  H5PartWrapper(fileName, flags)
37 { }
38 
39 H5PartWrapperForPT::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 
48 H5PartWrapperForPT::~H5PartWrapperForPT()
49 { }
50 
51 void 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 
105 void 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 
114 void 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 
148 void 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 
208 void 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 
291 void 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 
301 void 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 
402 void 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 }
OpalData::getInstance
static OpalData * getInstance()
Definition: OpalData.cpp:196
Physics::c
constexpr double c
The velocity of light in m/s.
Definition: Physics.h:45
Quaternion::conjugate
Quaternion conjugate() const
Definition: Quaternion.h:103
H5PartWrapper::getNumParticles
size_t getNumParticles() const
Definition: H5PartWrapper.cpp:524
Quaternion::rotate
Vector_t rotate(const Vector_t &) const
Definition: Quaternion.cpp:122
Util::getTaitBryantAngles
Vector_t getTaitBryantAngles(Quaternion rotation, const std::string &)
Definition: Util.cpp:117
WRITEFILEATTRIB
#define WRITEFILEATTRIB(type, file, name, value, length)
Definition: H5PartWrapper.h:25
PartBunchBase::POrigin
ParticleAttrib< ParticleOrigin > POrigin
Definition: PartBunchBase.h:587
OpalData::getGlobalPhaseShift
double getGlobalPhaseShift()
units: (sec)
Definition: OpalData.cpp:452
H5PartWrapperForPT::readStepData
void readStepData(PartBunchBase< double, 3 > *, h5_ssize_t, h5_ssize_t)
Definition: H5PartWrapperForPT.cpp:148
OpalData::setGlobalPhaseShift
void setGlobalPhaseShift(double shift)
units: (sec)
Definition: OpalData.cpp:447
PartBunchBase::setLocalTrackStep
void setLocalTrackStep(long long n)
step in a TRACK command
Definition: PartBunchBase.hpp:1395
H5PartWrapperForPT::writeStep
virtual void writeStep(PartBunchBase< double, 3 > *, const std::map< std::string, double > &additionalStepAttributes)
Definition: H5PartWrapperForPT.cpp:291
OPAL_PROJECT_VERSION
#define OPAL_PROJECT_VERSION
Definition: config.h.in:5
PartBunchBase::setGlobalTrackStep
void setGlobalTrackStep(long long n)
step in multiple TRACK commands
Definition: PartBunchBase.hpp:1383
PartBunchBase::get_emit
Vector_t get_emit() const
Definition: PartBunchBase.hpp:1151
H5PartWrapperForPT::writeStepData
void writeStepData(PartBunchBase< double, 3 > *)
Definition: H5PartWrapperForPT.cpp:402
PyOpal::PyOpalObjectNS::attributeName
std::map< AttributeType, std::string > attributeName
Definition: PyOpalObject.cpp:22
PartBunchBase::P
ParticleAttrib< Vector_t > P
Definition: PartBunchBase.h:576
Physics::epsilon_0
constexpr double epsilon_0
The permittivity of vacuum in As/Vm.
Definition: Physics.h:51
PartBunchBase::PType
ParticleAttrib< ParticleType > PType
Definition: PartBunchBase.h:586
PartBunchBase::setT
void setT(double t)
Definition: PartBunchBase.hpp:1031
Util::getGitRevision
std::string getGitRevision()
Definition: Util.cpp:33
PartBunchBase::Ef
ParticleAttrib< Vector_t > Ef
Definition: PartBunchBase.h:580
ERRORMSG
#define ERRORMSG(msg)
Definition: IpplInfo.h:350
PartBunchBase::get_centroid
Vector_t get_centroid() const
Definition: PartBunchBase.hpp:1105
H5PartWrapperForPT::writeStepHeader
void writeStepHeader(PartBunchBase< double, 3 > *, const std::map< std::string, double > &)
Definition: H5PartWrapperForPT.cpp:301
PartBunchBase::getRho
virtual double getRho(int x, int y, int z)=0
OPAL_PROJECT_NAME
#define OPAL_PROJECT_NAME
Definition: config.h.in:2
PartBunchBase::getLocalTrackStep
long long getLocalTrackStep() const
Definition: PartBunchBase.hpp:1407
H5PartWrapper::reportOnError
static void reportOnError(h5_int64_t rc, const char *file, int line)
Definition: H5PartWrapper.h:83
PartBunchBase::get_pmean
Vector_t get_pmean() const
Definition: PartBunchBase.hpp:1135
OpalData::setRestartStep
void setRestartStep(int s)
store the location where to restart
Definition: OpalData.cpp:320
PartBunchBase::calcBeamParameters
void calcBeamParameters()
Definition: PartBunchBase.hpp:1267
WRITESTRINGSTEPATTRIB
#define WRITESTRINGSTEPATTRIB(file, name, value)
Definition: H5PartWrapper.h:28
PartBunchBase::get_sPos
double get_sPos() const
Definition: PartBunchBase.hpp:1049
PartBunchBase::getdE
double getdE() const
Definition: PartBunchBase.hpp:1700
PartBunchBase::get_rrms
Vector_t get_rrms() const
Definition: PartBunchBase.hpp:1111
PartBunchBase::getQ
double getQ() const
Access to reference data.
Definition: PartBunchBase.hpp:1630
PartBunchBase::get_hr
virtual Vector_t get_hr() const
Definition: PartBunchBase.hpp:1232
Physics::pi
constexpr double pi
The value of .
Definition: Physics.h:30
Util::c_data
T * c_data(std::vector< T, A > &v)
Definition: Util.h:247
endl
Inform & endl(Inform &inf)
Definition: Inform.cpp:42
REPORTONERROR
#define REPORTONERROR(rc)
Definition: H5PartWrapper.h:22
PartBunchBase::getM
double getM() const
Definition: PartBunchBase.hpp:1636
PartBunchBase::get_prms
Vector_t get_prms() const
Definition: PartBunchBase.hpp:1129
min
T::PETE_Expr_t::PETE_Return_t min(const PETE_Expr< T > &expr, NDIndex< D > &loc)
Definition: ReductionLoc.h:76
Options::ebDump
bool ebDump
Definition: Options.cpp:65
PartBunchBase::toLabTrafo_m
CoordinateSystemTrafo toLabTrafo_m
Definition: PartBunchBase.h:595
max
T::PETE_Expr_t::PETE_Return_t max(const PETE_Expr< T > &expr, NDIndex< D > &loc)
Definition: ReductionLoc.h:84
PartBunchBase::Bf
ParticleAttrib< Vector_t > Bf
Definition: PartBunchBase.h:583
PartBunchBase::get_gamma
double get_gamma() const
Definition: PartBunchBase.hpp:1061
PartBunchBase::set_sPos
void set_sPos(double s)
Definition: PartBunchBase.hpp:1055
READDATA
#define READDATA(type, file, name, value)
Definition: H5PartWrapper.h:31
H5PartWrapper::file_m
h5_file_t file_m
Definition: H5PartWrapper.h:73
WRITEDATA
#define WRITEDATA(type, file, name, value)
Definition: H5PartWrapper.h:32
PartBunchBase::getT
double getT() const
Definition: PartBunchBase.hpp:1043
PartBunchBase::getTotalNum
size_t getTotalNum() const
Definition: PartBunchBase.hpp:1906
OpalException
The base class for all OPAL exceptions.
Definition: OpalException.h:28
H5PartWrapperForPT::writeHeader
virtual void writeHeader()
Definition: H5PartWrapperForPT.cpp:208
H5PartWrapperForPT::H5PartWrapperForPT
H5PartWrapperForPT(const std::string &fileName, h5_int32_t flags=H5_O_WRONLY)
Definition: H5PartWrapperForPT.cpp:35
PartBunchBase::get_origin
Vector_t get_origin() const
Definition: PartBunchBase.hpp:1093
FieldLayout::getLocalNDIndex
NDIndex< Dim > getLocalNDIndex()
Definition: FieldLayout.hpp:1579
PartBunchBase::getLocalNum
size_t getLocalNum() const
Definition: PartBunchBase.hpp:1911
Options::psDumpFreq
int psDumpFreq
The frequency to dump the phase space, i.e.dump data when steppsDumpFreq==0.
Definition: Options.cpp:39
OpalData::setRestartDumpFreq
void setRestartDumpFreq(const int &N)
set the dump frequency as found in restart file
Definition: OpalData.cpp:341
PartBunchBase::getGlobalTrackStep
long long getGlobalTrackStep() const
Definition: PartBunchBase.hpp:1389
PartBunchBase::Q
ParticleAttrib< double > Q
Definition: PartBunchBase.h:577
PartBunchBase::getFieldLayout
virtual FieldLayout_t & getFieldLayout()=0
cos
Tps< T > cos(const Tps< T > &x)
Cosine.
Definition: TpsMath.h:129
PartBunchBase::get_PBounds
void get_PBounds(Vector_t &min, Vector_t &max) const
Definition: PartBunchBase.hpp:1261
READFILEATTRIB
#define READFILEATTRIB(type, file, name, value)
Definition: H5PartWrapper.h:23
READSTEPATTRIB
#define READSTEPATTRIB(type, file, name, value)
Definition: H5PartWrapper.h:27
name
const std::string name
Definition: MaxNormRadialPeak.cpp:32
PartBunchBase::R
ParticlePos_t & R
Definition: PartBunchBase.h:572
WRITESTRINGFILEATTRIB
#define WRITESTRINGFILEATTRIB(file, name, value)
Definition: H5PartWrapper.h:24
PartBunchBase::get_norm_emit
Vector_t get_norm_emit() const
Definition: PartBunchBase.hpp:1157
PartBunchBase::ID
ParticleIndex_t & ID
Definition: PartBunchBase.h:573
WRITESTEPATTRIB
#define WRITESTEPATTRIB(type, file, name, value, length)
Definition: H5PartWrapper.h:29
PartBunchBase::RefPartR_m
Vector_t RefPartR_m
Definition: PartBunchBase.h:592
Units::eV2GeV
constexpr double eV2GeV
Definition: Units.h:71
PartBunchBase::getCharge
double getCharge() const
get the total charge per simulation particle
Definition: PartBunchBase.hpp:1317
Options::rhoDump
bool rhoDump
Definition: Options.cpp:63
PartBunchBase::get_meanKineticEnergy
double get_meanKineticEnergy() const
Definition: PartBunchBase.hpp:1067
CoordinateSystemTrafo::getRotation
Quaternion getRotation() const
Definition: CoordinateSystemTrafo.h:65
PartBunchBase::Bin
ParticleAttrib< int > Bin
Definition: PartBunchBase.h:584
PartBunchBase::get_maxExtent
Vector_t get_maxExtent() const
Definition: PartBunchBase.hpp:1099
PartBunchBase::RefPartP_m
Vector_t RefPartP_m
Definition: PartBunchBase.h:593
sin
Tps< T > sin(const Tps< T > &x)
Sine.
Definition: TpsMath.h:111
H5PartWrapper::open
void open(h5_int32_t flags)
Definition: H5PartWrapper.cpp:71
H5PartWrapperForPT::readStep
virtual void readStep(PartBunchBase< double, 3 > *, h5_ssize_t firstParticle, h5_ssize_t lastParticle)
Definition: H5PartWrapperForPT.cpp:105
H5PartWrapperForPT::readHeader
virtual void readHeader()
Definition: H5PartWrapperForPT.cpp:51
H5PartWrapper::numSteps_m
h5_int64_t numSteps_m
Definition: H5PartWrapper.h:76
H5PartWrapperForPT::readStepHeader
void readStepHeader(PartBunchBase< double, 3 > *)
Definition: H5PartWrapperForPT.cpp:114
Generated on Tue Jul 2 2024 15:05:26 for OPAL (Object Oriented Parallel Accelerator Library) by   doxygen 1.8.5