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