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