ATLAS Offline Software
McEventCollectionCnv_p6.cxx
Go to the documentation of this file.
1 
3 /*
4  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
5 */
6 
7 // McEventCollectionCnv_p6.cxx
8 // Implementation file for class McEventCollectionCnv_p6
9 // Author: S.Binet<binet@cern.ch>
11 
12 // STL includes
13 #include <utility>
14 #include <cmath>
15 #include <cfloat> // for DBL_EPSILON
16 
17 // GeneratorObjectsTPCnv includes
19 #include "HepMcDataPool.h"
22 #include "GaudiKernel/ThreadLocalContext.h"
24 
25 static const std::set<std::string> attributes_to_ignore {
26  "barcodes","barcode",
27  "flows","flow1","flow2","flow3",
28  "theta", "phi",
29  "mpi",
30  "signal_process_id",
31  "signal_vertex_id",
32  "filterWeight", "filterHT", "filterMET",
33  "event_scale","alphaQCD","alphaQED","random_states","weights",
34  "GenCrossSection","GenPdfInfo","GenHeavyIon"};
35 
37 // Constructors
39 
41  Base_t( ),
42  m_isPileup(false),m_hepMCWeightSvc("HepMCWeightSvc","McEventCollectionCnv_p6")
43 {}
44 
46  Base_t( rhs ),
47  m_isPileup(false),m_hepMCWeightSvc("HepMCWeightSvc","McEventCollectionCnv_p6")
48 {}
49 
52 {
53  if ( this != &rhs ) {
54  Base_t::operator=( rhs );
56  }
57  return *this;
58 }
59 
61 // Destructor
63 
65 = default;
66 
67 
69  McEventCollection* transObj,
70  MsgStream& msg )
71 {
72  const EventContext& ctx = Gaudi::Hive::currentContext();
73 
74  msg << MSG::DEBUG << "Loading McEventCollection from persistent state..."
75  << endmsg;
76 
77  // elements are managed by DataPool
78  if (!m_isPileup) {
79  transObj->clear(SG::VIEW_ELEMENTS);
80  }
81  HepMC::DataPool datapools;
82  const unsigned int nVertices = persObj->m_genVertices.size();
83  datapools.vtx.prepareToAdd(nVertices);
84  const unsigned int nParts = persObj->m_genParticles.size();
85  datapools.part.prepareToAdd(nParts);
86  const unsigned int nEvts = persObj->m_genEvents.size();
87  datapools.evt.prepareToAdd(nEvts);
88 
89  transObj->reserve( nEvts );
90  for ( std::vector<GenEvent_p6>::const_iterator
91  itr = persObj->m_genEvents.begin(),
92  itrEnd = persObj->m_genEvents.end();
93  itr != itrEnd;
94  ++itr ) {
95  const GenEvent_p6& persEvt = *itr;
96  HepMC::GenEvent * genEvt(nullptr);
97  if(m_isPileup) {
98  genEvt = new HepMC::GenEvent();
99  } else {
100  genEvt = datapools.getGenEvent();
101  }
102 #ifdef HEPMC3
103  genEvt->add_attribute ("barcodes", std::make_shared<HepMC::GenEventBarcodes>());
104  for (unsigned int i = 0; i < persEvt.m_e_attribute_id.size(); ++i) {
105  if (attributes_to_ignore.count(persEvt.m_e_attribute_name[i])) continue;
106  genEvt->add_attribute(persEvt.m_e_attribute_name[i], std::make_shared<HepMC3::StringAttribute>(persEvt.m_e_attribute_string[i]), persEvt.m_e_attribute_id[i]);
107  }
109 
110  genEvt->add_attribute("signal_process_id", std::make_shared<HepMC3::IntAttribute>(persEvt.m_signalProcessId));
111  genEvt->set_event_number(persEvt.m_eventNbr);
112  genEvt->add_attribute("mpi", std::make_shared<HepMC3::IntAttribute>(persEvt.m_mpi));
113  genEvt->add_attribute("event_scale", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_eventScale));
114  genEvt->add_attribute("alphaQCD", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_alphaQCD));
115  genEvt->add_attribute("alphaQED", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_alphaQED));
116  genEvt->add_attribute("filterWeight", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_filterWeight));
117  genEvt->add_attribute("filterHT", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_filterHT));
118  genEvt->add_attribute("filterMET", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_filterMET));
119  genEvt->weights()= persEvt.m_weights;
120  genEvt->add_attribute("random_states", std::make_shared<HepMC3::VectorLongIntAttribute>(persEvt.m_randomStates));
121 
122  genEvt->set_units(static_cast<HepMC3::Units::MomentumUnit>(persEvt.m_momentumUnit),
123  static_cast<HepMC3::Units::LengthUnit>(persEvt.m_lengthUnit));
124 
125  //restore weight names from the dedicated svc (which was keeping them in metadata for efficiency)
126  if(!genEvt->run_info()) {
127  HepMC3::GenRunInfoData ri_read;
128  ri_read.weight_names = m_hepMCWeightSvc->weightNameVec(ctx);
129  ri_read.tool_name = std::vector<std::string>();
130  ri_read.tool_version = std::vector<std::string>();
131  ri_read.tool_description = std::vector<std::string>();
132  ri_read.attribute_name = persEvt.m_r_attribute_name;
133  ri_read.attribute_string = persEvt.m_r_attribute_string;
134  auto ri = std::make_shared<HepMC3::GenRunInfo>();
135  ri->read_data(ri_read);
136  genEvt->set_run_info(std::move(ri));
137  }
138  // cross-section restore
139 
140  if (!persEvt.m_crossSection.empty()) {
141  auto cs = std::make_shared<HepMC3::GenCrossSection>();
142  const std::vector<double>& xsection = persEvt.m_crossSection;
143  genEvt->set_cross_section(cs);
144  if( static_cast<bool>(xsection[0]) )
145  cs->set_cross_section(xsection[2],xsection[1]);
146  else
147  cs->set_cross_section(-1.0, -1.0);
148  }
149 
150  // heavyIon restore
151  if (!persEvt.m_heavyIon.empty()) {
152  auto hi = std::make_shared<HepMC3::GenHeavyIon>();
153  const std::vector<float>& hIon = persEvt.m_heavyIon;
154  //AV NOTE THE ORDER
155  hi->set(
156  static_cast<int>(hIon[12]), // Ncoll_hard
157  static_cast<int>(hIon[11]), // Npart_proj
158  static_cast<int>(hIon[10]), // Npart_targ
159  static_cast<int>(hIon[9]), // Ncoll
160  static_cast<int>(hIon[8]), // spectator_neutrons
161  static_cast<int>(hIon[7]), // spectator_protons
162  static_cast<int>(hIon[6]), // N_Nwounded_collisions
163  static_cast<int>(hIon[5]), // Nwounded_N_collisions
164  static_cast<int>(hIon[4]), // Nwounded_Nwounded_collisions
165  hIon[3], // impact_parameter
166  hIon[2], // event_plane_angle
167  hIon[1], // eccentricity
168  hIon[0] ); // sigma_inel_NN
169  genEvt->set_heavy_ion(std::move(hi));
170  }
171 
172 
173 
174  // pdfinfo restore
175  if (!persEvt.m_pdfinfo.empty())
176  {
177  const std::vector<double>& pdf = persEvt.m_pdfinfo;
178  HepMC3::GenPdfInfoPtr pi = std::make_shared<HepMC3::GenPdfInfo>();
179  pi->set(static_cast<int>(pdf[8]), // id1
180  static_cast<int>(pdf[7]), // id2
181  pdf[4], // x1
182  pdf[3], // x2
183  pdf[2], // scalePDF
184  pdf[1], // pdf1
185  pdf[0], // pdf2
186  static_cast<int>(pdf[6]), // pdf_id1
187  static_cast<int>(pdf[5]));// pdf_id2
188  genEvt->set_pdf_info(std::move(pi));
189  }
190  transObj->push_back( genEvt );
191 
192  // create a temporary map associating the barcode of an end-vtx to its
193  // particle.
194  // As not all particles are stable (d'oh!) we take 50% of the number of
195  // particles as an initial size of the hash-map (to prevent re-hash)
196  ParticlesMap_t partToEndVtx( (persEvt.m_particlesEnd - persEvt.m_particlesBegin)/2 );
197  // This is faster than the HepMC::barcode_to_vertex
198  std::map<int, HepMC::GenVertexPtr> brc_to_vertex;
199 
200  // create the vertices
201  const unsigned int endVtx = persEvt.m_verticesEnd;
202  for ( unsigned int iVtx = persEvt.m_verticesBegin; iVtx != endVtx; ++iVtx ) {
203  auto vtx = createGenVertex( *persObj, persObj->m_genVertices[iVtx], partToEndVtx, datapools, genEvt );
204  brc_to_vertex[persObj->m_genVertices[iVtx].m_barcode] = std::move(vtx);
205  } //> end loop over vertices
206 
207  // set the signal process vertex
208  const int sigProcVtx = persEvt.m_signalProcessVtx;
209  if ( sigProcVtx != 0 && brc_to_vertex.count(sigProcVtx) ) {
210  HepMC::set_signal_process_vertex(genEvt, brc_to_vertex[sigProcVtx] );
211  }
212 
213  // connect particles to their end vertices
214  for (auto & p : partToEndVtx) {
215  if ( brc_to_vertex.count(p.second) ) {
216  auto decayVtx = brc_to_vertex[p.second];
217  decayVtx->add_particle_in( p.first );
218  } else {
219  msg << MSG::ERROR << "GenParticle points to null end vertex !!" << endmsg;
220  }
221  }
222  // set the beam particles
223  const int beamPart1 = persEvt.m_beamParticle1;
224  const int beamPart2 = persEvt.m_beamParticle2;
225  if ( beamPart1 != 0 && beamPart2 != 0 ) {
226  genEvt->set_beam_particles(HepMC::barcode_to_particle(genEvt, beamPart1),
227  HepMC::barcode_to_particle(genEvt, beamPart2));
228  }
229 
230 #else
231  genEvt->m_signal_process_id = persEvt.m_signalProcessId;
232  genEvt->m_event_number = persEvt.m_eventNbr;
233  genEvt->m_mpi = persEvt.m_mpi;
234  genEvt->m_event_scale = persEvt.m_eventScale;
235  genEvt->m_alphaQCD = persEvt.m_alphaQCD;
236  genEvt->m_alphaQED = persEvt.m_alphaQED;
237  genEvt->m_signal_process_vertex = 0;
238  genEvt->m_beam_particle_1 = 0;
239  genEvt->m_beam_particle_2 = 0;
240  genEvt->m_weights = persEvt.m_weights;
241  genEvt->m_random_states = persEvt.m_randomStates;
242  genEvt->m_vertex_barcodes.clear();
243  genEvt->m_particle_barcodes.clear();
244  genEvt->m_momentum_unit = static_cast<HepMC::Units::MomentumUnit>(persEvt.m_momentumUnit);
245  genEvt->m_position_unit = static_cast<HepMC::Units::LengthUnit>(persEvt.m_lengthUnit);
246 
247  //restore weight names from the dedicated svc (which was keeping them in metadata for efficiency)
248  genEvt->m_weights.m_names = m_hepMCWeightSvc->weightNames(ctx);
249 
250  // cross-section restore
251  if( genEvt->m_cross_section )
252  delete genEvt->m_cross_section;
253  genEvt->m_cross_section = 0;
254 
255  if (!persEvt.m_crossSection.empty()) {
256  genEvt->m_cross_section = new HepMC::GenCrossSection();
257  const std::vector<double>& xsection = persEvt.m_crossSection;
258  if( static_cast<bool>(xsection[0]) )
259  genEvt->m_cross_section->set_cross_section(xsection[2],xsection[1]);
260  }
261 
262  // heavyIon restore
263  if(genEvt->m_heavy_ion )
264  delete genEvt->m_heavy_ion;
265  genEvt->m_heavy_ion = 0;
266  if (!persEvt.m_heavyIon.empty()) {
267  const std::vector<float>& hIon = persEvt.m_heavyIon;
268  genEvt->m_heavy_ion = new HepMC::HeavyIon
269  (
270  static_cast<int>(hIon[12]), // Ncoll_hard
271  static_cast<int>(hIon[11]), // Npart_proj
272  static_cast<int>(hIon[10]), // Npart_targ
273  static_cast<int>(hIon[9]), // Ncoll
274  static_cast<int>(hIon[8]), // spectator_neutrons
275  static_cast<int>(hIon[7]), // spectator_protons
276  static_cast<int>(hIon[6]), // N_Nwounded_collisions
277  static_cast<int>(hIon[5]), // Nwounded_N_collisions
278  static_cast<int>(hIon[4]), // Nwounded_Nwounded_collisions
279  hIon[3], // impact_parameter
280  hIon[2], // event_plane_angle
281  hIon[1], // eccentricity
282  hIon[0] ); // sigma_inel_NN
283  }
284 
285 
286 
287  // pdfinfo restore
288  if(genEvt->m_pdf_info)
289  delete genEvt->m_pdf_info;
290  genEvt->m_pdf_info = 0;
291  if (!persEvt.m_pdfinfo.empty()) {
292  const std::vector<double>& pdf = persEvt.m_pdfinfo;
293  genEvt->m_pdf_info = new HepMC::PdfInfo
294  (
295  static_cast<int>(pdf[8]), // id1
296  static_cast<int>(pdf[7]), // id2
297  pdf[4], // x1
298  pdf[3], // x2
299  pdf[2], // scalePDF
300  pdf[1], // pdf1
301  pdf[0], // pdf2
302  static_cast<int>(pdf[6]), // pdf_id1
303  static_cast<int>(pdf[5]) // pdf_id2
304  );
305  }
306 
307  transObj->push_back( genEvt );
308 
309  // create a temporary map associating the barcode of an end-vtx to its
310  // particle.
311  // As not all particles are stable (d'oh!) we take 50% of the number of
312  // particles as an initial size of the hash-map (to prevent re-hash)
313  ParticlesMap_t partToEndVtx( (persEvt.m_particlesEnd-
314  persEvt.m_particlesBegin)/2 );
315 
316  // create the vertices
317  const unsigned int endVtx = persEvt.m_verticesEnd;
318  for ( unsigned int iVtx= persEvt.m_verticesBegin; iVtx != endVtx; ++iVtx ) {
319  genEvt->add_vertex( createGenVertex( *persObj,
320  persObj->m_genVertices[iVtx],
321  partToEndVtx,
322  datapools ) );
323  } //> end loop over vertices
324 
325  // set the signal process vertex
326  const int sigProcVtx = persEvt.m_signalProcessVtx;
327  if ( sigProcVtx != 0 ) {
328  genEvt->set_signal_process_vertex( genEvt->barcode_to_vertex( sigProcVtx ) );
329  }
330 
331  // connect particles to their end vertices
333  p = partToEndVtx.begin(),
334  endItr = partToEndVtx.end();
335  p != endItr;
336  ++p ) {
337  auto decayVtx = HepMC::barcode_to_vertex(genEvt, p->second );
338  if ( decayVtx ) {
339  decayVtx->add_particle_in( p->first );
340  } else {
341  msg << MSG::ERROR
342  << "GenParticle points to null end vertex !!"
343  << endmsg;
344  }
345  }
346 
347  // set the beam particles
348  const int beamPart1 = persEvt.m_beamParticle1;
349  const int beamPart2 = persEvt.m_beamParticle2;
350  if ( beamPart1 != 0 && beamPart2 !=0 ) {
351  genEvt->set_beam_particles(genEvt->barcode_to_particle(beamPart1),
352  genEvt->barcode_to_particle(beamPart2));
353  }
354 
355 #endif
356 
357 
358  } //> end loop over m_genEvents
359 
360  msg << MSG::DEBUG << "Loaded McEventCollection from persistent state [OK]"
361  << endmsg;
362 }
363 
365  McEventCollection_p6* persObj,
366  MsgStream& msg )
367 {
368  const EventContext& ctx = Gaudi::Hive::currentContext();
369 
370  msg << MSG::DEBUG << "Creating persistent state of McEventCollection..."
371  << endmsg;
372  persObj->m_genEvents.reserve( transObj->size() );
373 
374  const std::pair<unsigned int,unsigned int> stats = nbrParticlesAndVertices( transObj );
375  persObj->m_genParticles.reserve( stats.first );
376  persObj->m_genVertices.reserve ( stats.second );
377 
378  const McEventCollection::const_iterator itrEnd = transObj->end();
379  for ( McEventCollection::const_iterator itr = transObj->begin();
380  itr != itrEnd;
381  ++itr ) {
382  const unsigned int nPersVtx = persObj->m_genVertices.size();
383  const unsigned int nPersParts = persObj->m_genParticles.size();
384  const HepMC::GenEvent* genEvt = *itr;
385 #ifdef HEPMC3
386  //save the weight names to metadata via the HepMCWeightSvc
387  auto ri = genEvt->run_info();
388  HepMC3::GenRunInfoData ri_data;
389  if (ri) {
390  ri->write_data(ri_data);
391  if (!ri_data.weight_names.empty()) {
392  m_hepMCWeightSvc->setWeightNames( names_to_name_index_map(ri_data.weight_names), ctx ).ignore();
393  } else {
394  //AV : This to be decided if one would like to have default names.
395  //std::vector<std::string> names{"0"};
396  //m_hepMCWeightSvc->setWeightNames( names_to_name_index_map(names), ctx );
397  }
398  }
399 
400  auto A_mpi=genEvt->attribute<HepMC3::IntAttribute>("mpi");
401  auto A_signal_process_id=genEvt->attribute<HepMC3::IntAttribute>("signal_process_id");
402  auto A_event_scale=genEvt->attribute<HepMC3::DoubleAttribute>("event_scale");
403  auto A_alphaQCD=genEvt->attribute<HepMC3::DoubleAttribute>("alphaQCD");
404  auto A_alphaQED=genEvt->attribute<HepMC3::DoubleAttribute>("alphaQED");
405  auto A_filterWeight=genEvt->attribute<HepMC3::DoubleAttribute>("filterWeight");
406  auto A_filterHT=genEvt->attribute<HepMC3::DoubleAttribute>("filterHT");
407  auto A_filterMET=genEvt->attribute<HepMC3::DoubleAttribute>("filterMET");
409 
410  // If signal vertex not found on the vertices, look on the event (Sherpa)
411  if (!signal_process_vertex) {
412  auto event_spv = genEvt->attribute<HepMC3::IntAttribute>("signal_process_vertex");
413 
414  // If the attribute exists, get the vertex
415  if (event_spv) signal_process_vertex = genEvt->vertices().at(-event_spv->value()-1);
416  }
417 
418  auto A_random_states=genEvt->attribute<HepMC3::VectorLongIntAttribute>("random_states");
419  auto beams=genEvt->beams();
420  persObj->m_genEvents.
421  emplace_back(A_signal_process_id?(A_signal_process_id->value()):-1,
422  genEvt->event_number(),
423  A_mpi?(A_mpi->value()):-1,
424  A_event_scale?(A_event_scale->value()):0.0,
425  A_alphaQCD?(A_alphaQCD->value()):0.0,
426  A_alphaQED?(A_alphaQED->value()):0.0,
427  A_filterWeight?(A_filterWeight->value()):1.0,
428  A_filterHT?(A_filterHT->value()):-13.,
429  A_filterMET?(A_filterMET->value()):-13.0,
431  !beams.empty()?HepMC::barcode(beams[0]):0,
432  beams.size()>1?HepMC::barcode(beams[1]):0,
433  genEvt->weights(),
434  A_random_states?(A_random_states->value()):std::vector<long>(),
435  std::vector<double>(), // cross section
436  std::vector<float>(), // heavyion
437  std::vector<double>(), // pdf info
438  genEvt->momentum_unit(),
439  genEvt->length_unit(),
440  nPersVtx,
441  nPersVtx + genEvt->vertices().size(),
442  nPersParts,
443  nPersParts + genEvt->particles().size() );
444  {
445  GenEvent_p6& persEvt = persObj->m_genEvents.back();
446  std::map< std::string, std::map<int, std::shared_ptr<HepMC3::Attribute> > > e_atts = genEvt->attributes();
447  persEvt.m_e_attribute_name.clear();
448  persEvt.m_e_attribute_id.clear();
449  persEvt.m_e_attribute_string.clear();
450  for (auto& attmap: e_atts) {
451  if (attributes_to_ignore.count(attmap.first)) continue;
452  if (attmap.first == "ShadowParticle") continue;
453  if (attmap.first == "ShadowParticleId") continue;
454  for (auto& att: attmap.second) {
455  persEvt.m_e_attribute_name.push_back(attmap.first);
456  persEvt.m_e_attribute_id.push_back(att.first);
457  std::string st;
458  att.second->to_string(st);
461  persEvt.m_e_attribute_string.push_back(std::move(st));
462  }
463  }
464  persEvt.m_r_attribute_name.clear();
465  persEvt.m_r_attribute_string.clear();
466  if (ri) {
467  persEvt.m_r_attribute_string = std::move(ri_data.attribute_string);
468  persEvt.m_r_attribute_name = std::move(ri_data.attribute_name);
469  /*** This is for the future
470  persEvt.m_r_tool_name = ri_data.tool_name;
471  persEvt.m_r_tool_version = ri_data.tool_version;
472  persEvt.m_r_tool_description = ri_data.tool_description;
473  */
474  }
475  //Actually, with this piece there is no need to treat the CS and HI separately.
476  }
477  //HepMC::GenCrossSection encoding
478  if (genEvt->cross_section()) {
479  auto cs=genEvt->cross_section();
480  GenEvent_p6& persEvt = persObj->m_genEvents.back();
481  std::vector<double>& crossSection = persEvt.m_crossSection;
482  crossSection.resize(3);
483  crossSection[2] = cs->xsec();
484  crossSection[1] = cs->xsec_err();
485  crossSection[0] = static_cast<double>(cs->is_valid());
488  if (crossSection[2] < 0) {
489  crossSection[2] = 0.0;
490  if (crossSection[1] < 0) {
491  crossSection[1] = 0.0;
492  }
493  crossSection[0] = 0.0;
494  }
495 
496  }
497 
498  //HepMC::HeavyIon encoding
499  if (genEvt->heavy_ion()) {
500  auto hi=genEvt->heavy_ion();
501  GenEvent_p6& persEvt = persObj->m_genEvents.back();
502  std::vector<float>& heavyIon = persEvt.m_heavyIon;
503  heavyIon.resize(13);
504  heavyIon[12] = static_cast<float>(hi->Ncoll_hard);
505  heavyIon[11] = static_cast<float>(hi->Npart_proj);
506  heavyIon[10] = static_cast<float>(hi->Npart_targ);
507  heavyIon[9] = static_cast<float>(hi->Ncoll);
508  heavyIon[8] = static_cast<float>(hi->spectator_neutrons);
509  heavyIon[7] = static_cast<float>(hi->spectator_protons);
510  heavyIon[6] = static_cast<float>(hi->N_Nwounded_collisions);
511  heavyIon[5] = static_cast<float>(hi->Nwounded_N_collisions);
512  heavyIon[4] = static_cast<float>(hi->Nwounded_Nwounded_collisions);
513  heavyIon[3] = hi->impact_parameter;
514  heavyIon[2] = hi->event_plane_angle;
515  heavyIon[1] = hi->eccentricity;
516  heavyIon[0] = hi->sigma_inel_NN;
517  }
518 
519  //PdfInfo encoding
520  if (genEvt->pdf_info()) {
521  auto pi=genEvt->pdf_info();
522  GenEvent_p6& persEvt = persObj->m_genEvents.back();
523  std::vector<double>& pdfinfo = persEvt.m_pdfinfo;
524  pdfinfo.resize(9);
525  pdfinfo[8] = static_cast<double>(pi->parton_id[0]);
526  pdfinfo[7] = static_cast<double>(pi->parton_id[1]);
527  pdfinfo[6] = static_cast<double>(pi->pdf_id[0]);
528  pdfinfo[5] = static_cast<double>(pi->pdf_id[1]);
529  pdfinfo[4] = pi->x[0];
530  pdfinfo[3] = pi->x[1];
531  pdfinfo[2] = pi->scale;
532  pdfinfo[1] = pi->xf[0];
533  pdfinfo[0] = pi->xf[1];
534  }
535 
536  // create vertices
537  for (const auto& v: genEvt->vertices()) {
538  writeGenVertex( v, *persObj );
539  }
540 #else
541  const int signalProcessVtx = genEvt->m_signal_process_vertex
542  ? genEvt->m_signal_process_vertex->barcode()
543  : 0;
544  const int beamParticle1Barcode = genEvt->m_beam_particle_1
545  ? genEvt->m_beam_particle_1->barcode()
546  : 0;
547  const int beamParticle2Barcode = genEvt->m_beam_particle_2
548  ? genEvt->m_beam_particle_2->barcode()
549  : 0;
550 
551  //save the weight names to metadata via the HepMCWeightSvc
552  m_hepMCWeightSvc->setWeightNames( genEvt->m_weights.m_names, ctx ).ignore();
553 
554 
555  persObj->m_genEvents.
556  push_back( GenEvent_p6( genEvt->m_signal_process_id,
557  genEvt->m_event_number,
558  genEvt->mpi(), // number of multi particle interactions
559  genEvt->m_event_scale,
560  genEvt->m_alphaQCD,
561  genEvt->m_alphaQED,
562  1, // dummy value as this does not exist in HepMC2::GenEvent
563  signalProcessVtx,
564  beamParticle1Barcode, // barcodes of beam particles
565  beamParticle2Barcode,
566  genEvt->m_weights.m_weights,
567  genEvt->m_random_states,
568  std::vector<double>(), // cross section
569  std::vector<float>(), // heavyion
570  std::vector<double>(), // pdf info
571  genEvt->m_momentum_unit,
572  genEvt->m_position_unit,
573  nPersVtx,
574  nPersVtx + genEvt->vertices_size(),
575  nPersParts,
576  nPersParts + genEvt->particles_size() ) );
577  //HepMC::GenCrossSection encoding
578  if (genEvt->m_cross_section) {
579  GenEvent_p6& persEvt = persObj->m_genEvents.back();
580  std::vector<double>& crossSection = persEvt.m_crossSection;
581  crossSection.resize(3);
582  crossSection[2] = genEvt->m_cross_section->m_cross_section;
583  crossSection[1] = genEvt->m_cross_section->m_cross_section_error;
584  crossSection[0] = static_cast<double>(genEvt->m_cross_section->m_is_set);
585  }
586 
587  //HepMC::HeavyIon encoding
588  if (genEvt->m_heavy_ion) {
589  GenEvent_p6& persEvt = persObj->m_genEvents.back();
590  std::vector<float>& heavyIon = persEvt.m_heavyIon;
591  heavyIon.resize(13);
592  heavyIon[12] = static_cast<float>(genEvt->m_heavy_ion->m_Ncoll_hard);
593  heavyIon[11] = static_cast<float>(genEvt->m_heavy_ion->m_Npart_proj);
594  heavyIon[10] = static_cast<float>(genEvt->m_heavy_ion->m_Npart_targ);
595  heavyIon[9] = static_cast<float>(genEvt->m_heavy_ion->m_Ncoll);
596  heavyIon[8] = static_cast<float>(genEvt->m_heavy_ion->m_spectator_neutrons);
597  heavyIon[7] = static_cast<float>(genEvt->m_heavy_ion->m_spectator_protons);
598  heavyIon[6] = static_cast<float>(genEvt->m_heavy_ion->m_N_Nwounded_collisions);
599  heavyIon[5] = static_cast<float>(genEvt->m_heavy_ion->m_Nwounded_N_collisions);
600  heavyIon[4] = static_cast<float>(genEvt->m_heavy_ion->m_Nwounded_Nwounded_collisions);
601  heavyIon[3] = genEvt->m_heavy_ion->m_impact_parameter;
602  heavyIon[2] = genEvt->m_heavy_ion->m_event_plane_angle;
603  heavyIon[1] = genEvt->m_heavy_ion->m_eccentricity;
604  heavyIon[0] = genEvt->m_heavy_ion->m_sigma_inel_NN;
605  }
606 
607  //PdfInfo encoding
608  if (genEvt->m_pdf_info) {
609  GenEvent_p6& persEvt = persObj->m_genEvents.back();
610  std::vector<double>& pdfinfo = persEvt.m_pdfinfo;
611  pdfinfo.resize(9);
612  pdfinfo[8] = static_cast<double>(genEvt->m_pdf_info->m_id1);
613  pdfinfo[7] = static_cast<double>(genEvt->m_pdf_info->m_id2);
614  pdfinfo[6] = static_cast<double>(genEvt->m_pdf_info->m_pdf_id1);
615  pdfinfo[5] = static_cast<double>(genEvt->m_pdf_info->m_pdf_id2);
616  pdfinfo[4] = genEvt->m_pdf_info->m_x1;
617  pdfinfo[3] = genEvt->m_pdf_info->m_x2;
618  pdfinfo[2] = genEvt->m_pdf_info->m_scalePDF;
619  pdfinfo[1] = genEvt->m_pdf_info->m_pdf1;
620  pdfinfo[0] = genEvt->m_pdf_info->m_pdf2;
621  }
622 
623  // create vertices
624  const HepMC::GenEvent::vertex_const_iterator endVtx=genEvt->vertices_end();
625  for ( HepMC::GenEvent::vertex_const_iterator i = genEvt->vertices_begin();
626  i != endVtx;
627  ++i ) {
628  writeGenVertex( **i, *persObj );
629  }
630 #endif
631 
632  } //> end loop over GenEvents
633 
634  msg << MSG::DEBUG << "Created persistent state of HepMC::GenEvent [OK]" << endmsg;
635 }
636 
637 
640  const GenVertex_p6& persVtx,
641  ParticlesMap_t& partToEndVtx, HepMC::DataPool& datapools
642  ,HepMC::GenEvent* parent
643  ) const
644 {
645  HepMC::GenVertexPtr vtx(nullptr);
646  if(m_isPileup) {
648  } else {
649  vtx = datapools.getGenVertex();
650  }
651  if (parent ) parent->add_vertex(vtx);
652 #ifdef HEPMC3
653  vtx->set_position(HepMC::FourVector( persVtx.m_x , persVtx.m_y , persVtx.m_z ,persVtx.m_t ));
654  //AV ID cannot be assigned in HepMC3. And its meaning in HepMC2 is not clear.
655  vtx->set_status(HepMC::new_vertex_status_from_old(persVtx.m_id, persVtx.m_barcode)); // UPDATED STATUS VALUE TO NEW SCHEME
656  // cast from std::vector<float> to std::vector<double>
657  std::vector<double> weights( persVtx.m_weights.begin(), persVtx.m_weights.end() );
658  vtx->add_attribute("weights",std::make_shared<HepMC3::VectorDoubleAttribute>(weights));
659  HepMC::suggest_barcode (vtx, persVtx.m_barcode);
660  // handle the in-going (orphans) particles
661  const unsigned int nPartsIn = persVtx.m_particlesIn.size();
662  for ( unsigned int i = 0; i != nPartsIn; ++i ) {
663  createGenParticle( persEvt.m_genParticles[persVtx.m_particlesIn[i]], partToEndVtx, datapools, vtx, false );
664  }
665 
666  // now handle the out-going particles
667  const unsigned int nPartsOut = persVtx.m_particlesOut.size();
668  for ( unsigned int i = 0; i != nPartsOut; ++i ) {
669  createGenParticle( persEvt.m_genParticles[persVtx.m_particlesOut[i]], partToEndVtx, datapools, vtx );
670  }
671 #else
672  vtx->m_position.setX( persVtx.m_x );
673  vtx->m_position.setY( persVtx.m_y );
674  vtx->m_position.setZ( persVtx.m_z );
675  vtx->m_position.setT( persVtx.m_t );
676  vtx->m_particles_in.clear();
677  vtx->m_particles_out.clear();
678  vtx->m_id = HepMC::new_vertex_status_from_old(persVtx.m_id, persVtx.m_barcode); // UPDATED STATUS VALUE TO NEW SCHEME
679  vtx->m_weights.m_weights.reserve( persVtx.m_weights.size() );
680  vtx->m_weights.m_weights.assign ( persVtx.m_weights.begin(),
681  persVtx.m_weights.end() );
682  vtx->m_event = 0;
683  vtx->m_barcode = persVtx.m_barcode;
684 
685  // handle the in-going (orphans) particles
686  const unsigned int nPartsIn = persVtx.m_particlesIn.size();
687  for ( unsigned int i = 0; i != nPartsIn; ++i ) {
688  createGenParticle( persEvt.m_genParticles[persVtx.m_particlesIn[i]],
689  partToEndVtx,
690  datapools );
691  }
692 
693  // now handle the out-going particles
694  const unsigned int nPartsOut = persVtx.m_particlesOut.size();
695  for ( unsigned int i = 0; i != nPartsOut; ++i ) {
696  vtx->add_particle_out( createGenParticle( persEvt.m_genParticles[persVtx.m_particlesOut[i]],
697  partToEndVtx,
698  datapools ) );
699  }
700 #endif
701 
702  return vtx;
703 }
704 
707  ParticlesMap_t& partToEndVtx, HepMC::DataPool& datapools ,const HepMC::GenVertexPtr& parent, bool add_to_output ) const
708 {
709  HepMC::GenParticlePtr p(nullptr);
710  if (m_isPileup) {
712  } else {
713  p = datapools.getGenParticle();
714  }
715  if (parent) add_to_output?parent->add_particle_out(p):parent->add_particle_in(p);
716 #ifdef HEPMC3
717  p->set_pdg_id( persPart.m_pdgId);
718  p->set_status(HepMC::new_particle_status_from_old(persPart.m_status, persPart.m_barcode)); // UPDATED STATUS VALUE TO NEW SCHEME
719  p->add_attribute("phi",std::make_shared<HepMC3::DoubleAttribute>(persPart.m_phiPolarization));
720  p->add_attribute("theta",std::make_shared<HepMC3::DoubleAttribute>(persPart.m_thetaPolarization));
721  HepMC::suggest_barcode (p, persPart.m_barcode);
722  p->set_generated_mass(persPart.m_generated_mass);
723 
724  // Note: do the E calculation in extended (long double) precision.
725  // That happens implicitly on x86 with optimization on; saying it
726  // explicitly ensures that we get the same results with and without
727  // optimization. (If this is a performance issue for platforms
728  // other than x86, one could change to double for those platforms.)
729  if ( 0 == persPart.m_recoMethod ) {
730  double temp_e = std::sqrt( (long double)(persPart.m_px)*persPart.m_px +
731  (long double)(persPart.m_py)*persPart.m_py +
732  (long double)(persPart.m_pz)*persPart.m_pz +
733  (long double)(persPart.m_m) *persPart.m_m );
734  p->set_momentum( HepMC::FourVector(persPart.m_px,persPart.m_py,persPart.m_pz,temp_e));
735  } else {
736  const int signM2 = ( persPart.m_m >= 0. ? 1 : -1 );
737  const double persPart_ene =
738  std::sqrt( std::abs((long double)(persPart.m_px)*persPart.m_px +
739  (long double)(persPart.m_py)*persPart.m_py +
740  (long double)(persPart.m_pz)*persPart.m_pz +
741  signM2* (long double)(persPart.m_m)* persPart.m_m));
742  const int signEne = ( persPart.m_recoMethod == 1 ? 1 : -1 );
743  p->set_momentum(HepMC::FourVector( persPart.m_px,
744  persPart.m_py,
745  persPart.m_pz,
746  signEne * persPart_ene ));
747  }
748 
749  // setup flow
750  std::vector<int> flows;
751  const unsigned int nFlow = persPart.m_flow.size();
752  for ( unsigned int iFlow= 0; iFlow != nFlow; ++iFlow ) {
753  flows.push_back(persPart.m_flow[iFlow].second );
754  }
755  //We construct it here as vector w/o gaps.
756  p->add_attribute("flows", std::make_shared<HepMC3::VectorIntAttribute>(flows));
757 #else
758  p->m_pdg_id = persPart.m_pdgId;
759  p->m_status = HepMC::new_particle_status_from_old(persPart.m_status, persPart.m_barcode); // UPDATED STATUS VALUE TO NEW SCHEME
760  p->m_polarization.m_theta= static_cast<double>(persPart.m_thetaPolarization);
761  p->m_polarization.m_phi = static_cast<double>(persPart.m_phiPolarization );
762  p->m_production_vertex = 0;
763  p->m_end_vertex = 0;
764  p->m_barcode = persPart.m_barcode;
765  p->m_generated_mass = static_cast<double>(persPart.m_generated_mass);
766 
767  // Note: do the E calculation in extended (long double) precision.
768  // That happens implicitly on x86 with optimization on; saying it
769  // explicitly ensures that we get the same results with and without
770  // optimization. (If this is a performance issue for platforms
771  // other than x86, one could change to double for those platforms.)
772  if ( 0 == persPart.m_recoMethod ) {
773 
774  p->m_momentum.setPx( persPart.m_px);
775  p->m_momentum.setPy( persPart.m_py);
776  p->m_momentum.setPz( persPart.m_pz);
777  double temp_e = std::sqrt( (long double)(persPart.m_px)*persPart.m_px +
778  (long double)(persPart.m_py)*persPart.m_py +
779  (long double)(persPart.m_pz)*persPart.m_pz +
780  (long double)(persPart.m_m) *persPart.m_m );
781  p->m_momentum.setE( temp_e);
782  } else {
783  const int signM2 = ( persPart.m_m >= 0. ? 1 : -1 );
784  const double persPart_ene =
785  std::sqrt( std::abs((long double)(persPart.m_px)*persPart.m_px +
786  (long double)(persPart.m_py)*persPart.m_py +
787  (long double)(persPart.m_pz)*persPart.m_pz +
788  signM2* (long double)(persPart.m_m)* persPart.m_m));
789  const int signEne = ( persPart.m_recoMethod == 1 ? 1 : -1 );
790  p->m_momentum.set( persPart.m_px,
791  persPart.m_py,
792  persPart.m_pz,
793  signEne * persPart_ene );
794  }
795 
796  // setup flow
797  const unsigned int nFlow = persPart.m_flow.size();
798  p->m_flow.clear();
799  for ( unsigned int iFlow= 0; iFlow != nFlow; ++iFlow ) {
800  p->m_flow.set_icode( persPart.m_flow[iFlow].first,
801  persPart.m_flow[iFlow].second );
802  }
803 #endif
804 
805  if ( persPart.m_endVtx != 0 ) {
806  partToEndVtx[p] = persPart.m_endVtx;
807  }
808 
809  return p;
810 }
811 
812 #ifdef HEPMC3
814  McEventCollection_p6& persEvt )
815 {
816  const HepMC::FourVector& position = vtx->position();
817  auto A_weights=vtx->attribute<HepMC3::VectorDoubleAttribute>("weights");
818  auto A_barcode=vtx->attribute<HepMC3::IntAttribute>("barcode");
819  std::vector<float> weights;
820  if (A_weights) {
821  auto weights_d = A_weights->value();
822  for (auto& w: weights_d) weights.push_back(w);
823  }
824  persEvt.m_genVertices.emplace_back( position.x(),
825  position.y(),
826  position.z(),
827  position.t(),
828  HepMC::old_vertex_status_from_new(vtx->status()), // REVERTED STATUS VALUE TO OLD SCHEME
829  weights.begin(),
830  weights.end(),
831  A_barcode?(A_barcode->value()):vtx->id() );
832  GenVertex_p6& persVtx = persEvt.m_genVertices.back();
833 
834  // we write only the orphans in-coming particles and beams
835  persVtx.m_particlesIn.reserve(vtx->particles_in().size());
836  for (const auto& p: vtx->particles_in()) {
837  if ( !p->production_vertex() || p->production_vertex()->id() == 0 ) {
838  persVtx.m_particlesIn.push_back( writeGenParticle( p, persEvt ) );
839  }
840  }
841 
842  persVtx.m_particlesOut.reserve(vtx->particles_out().size());
843  for (const auto& p: vtx->particles_out()) {
844  persVtx.m_particlesOut.push_back( writeGenParticle( p, persEvt ) );
845  }
846 
847  }
848 #else
849 void McEventCollectionCnv_p6::writeGenVertex( const HepMC::GenVertex& vtx,
850  McEventCollection_p6& persEvt ) const
851 {
852  const HepMC::FourVector& position = vtx.m_position;
853  persEvt.m_genVertices.push_back(
854  GenVertex_p6( position.x(),
855  position.y(),
856  position.z(),
857  position.t(),
858  HepMC::old_vertex_status_from_new(vtx.m_id), // REVERTED STATUS VALUE TO OLD SCHEME
859  vtx.m_weights.m_weights.begin(),
860  vtx.m_weights.m_weights.end(),
861  vtx.m_barcode ) );
862  GenVertex_p6& persVtx = persEvt.m_genVertices.back();
863 
864  // we write only the orphans in-coming particles
865  const std::vector<HepMC::GenParticlePtr>::const_iterator endInVtx = vtx.m_particles_in.end();
866  persVtx.m_particlesIn.reserve(vtx.m_particles_in.size());
867  for ( std::vector<HepMC::GenParticlePtr>::const_iterator p = vtx.m_particles_in.begin();
868  p != endInVtx;
869  ++p ) {
870  if ( 0 == (*p)->production_vertex() ) {
871  persVtx.m_particlesIn.push_back( writeGenParticle( **p, persEvt ) );
872  }
873  }
874 
875  const std::vector<HepMC::GenParticlePtr>::const_iterator endOutVtx = vtx.m_particles_out.end();
876  persVtx.m_particlesOut.reserve(vtx.m_particles_out.size());
877  for ( std::vector<HepMC::GenParticlePtr>::const_iterator p = vtx.m_particles_out.begin();
878  p != endOutVtx;
879  ++p ) {
880  persVtx.m_particlesOut.push_back( writeGenParticle( **p, persEvt ) );
881  }
882 
883  return;
884 }
885 #endif
886 
887 #ifdef HEPMC3
889  McEventCollection_p6& persEvt )
890 {
891  const HepMC::FourVector mom = p->momentum();
892  const double ene = mom.e();
893  const double m2 = mom.m2();
894 
895  // Definitions of Bool isTimeLilike, isSpacelike and isLightlike according to HepLorentzVector definition
896  const bool useP2M2 = !(m2 > 0) && // !isTimelike
897  (m2 < 0) && // isSpacelike
898  !(std::abs(m2) < 2.0*DBL_EPSILON*ene*ene); // !isLightlike
899  auto A_flows=p->attribute<HepMC3::VectorIntAttribute>("flows");
900  auto A_phi=p->attribute<HepMC3::DoubleAttribute>("phi");
901  auto A_theta=p->attribute<HepMC3::DoubleAttribute>("theta");
902 
903  const short recoMethod = ( !useP2M2 ? 0: ( ene >= 0.? 1: 2 ) );
904  persEvt.m_genParticles.
905  emplace_back( mom.px(),
906  mom.py(),
907  mom.pz(),
908  mom.m(),
909  p->pdg_id(),
910  HepMC::old_particle_status_from_new(p->status()), // REVERTED STATUS VALUE TO OLD SCHEME
911  A_flows?(A_flows->value().size()):0,
912  A_theta?(A_theta->value()):0.0,
913  A_phi?(A_phi->value()):0.0,
914  p->production_vertex()? HepMC::barcode(p->production_vertex()):0,
915  p->end_vertex()? HepMC::barcode(p->end_vertex()):0,
916  HepMC::barcode(p),
917  p->generated_mass(),
918  recoMethod );
919 
920  std::vector< std::pair<int,int> > flow_hepmc2;
921  if(A_flows) flow_hepmc2=vector_to_vector_int_int(A_flows->value());
922  persEvt.m_genParticles.back().m_flow.assign( flow_hepmc2.begin(),flow_hepmc2.end() );
923 
924  // we return the index of the particle in the big vector of particles
925  // (contained by the persistent GenEvent)
926  return (persEvt.m_genParticles.size() - 1);
927 
928 }
929 #else
931  McEventCollection_p6& persEvt ) const
932 {
933  const HepMC::FourVector& mom = p.m_momentum;
934  const double ene = mom.e();
935  const double m2 = mom.m2();
936 
937  // Definitions of Bool isTimeLilike, isSpacelike and isLightlike according to HepLorentzVector definition
938  const bool useP2M2 = !(m2 > 0) && // !isTimelike
939  (m2 < 0) && // isSpacelike
940  !(std::abs(m2) < 2.0*DBL_EPSILON*ene*ene); // !isLightlike
941 
942  const short recoMethod = ( !useP2M2
943  ? 0
944  : ( ene >= 0. //*GeV
945  ? 1
946  : 2 ) );
947 
948  persEvt.m_genParticles.
949  push_back( GenParticle_p6( mom.px(),
950  mom.py(),
951  mom.pz(),
952  mom.m(),
953  p.m_pdg_id,
954  HepMC::old_particle_status_from_new(p.m_status), // REVERTED STATUS VALUE TO OLD SCHEME
955  p.m_flow.size(),
956  p.m_polarization.theta(),
957  p.m_polarization.phi(),
958  p.m_production_vertex
959  ? p.m_production_vertex->barcode()
960  : 0,
961  p.m_end_vertex
962  ? p.m_end_vertex->barcode()
963  : 0,
964  p.m_barcode,
965  p.m_generated_mass,
966  recoMethod ) );
967  persEvt.m_genParticles.back().m_flow.assign( p.m_flow.begin(),
968  p.m_flow.end() );
969 
970  // we return the index of the particle in the big vector of particles
971  // (contained by the persistent GenEvent)
972  return (persEvt.m_genParticles.size() - 1);
973 }
974 #endif
975 
977  m_isPileup = true;
978 }
DataVector::reserve
void reserve(size_type n)
Attempt to preallocate enough memory for a specified number of elements.
HepMC::GenVertexPtr
HepMC::GenVertex * GenVertexPtr
Definition: GenVertex.h:59
GenEvent_p6::m_alphaQED
double m_alphaQED
value of the QED coupling.
Definition: GenEvent_p6.h:101
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
GenParticle_p6::m_px
float m_px
x-component of the 4-momentum of this particle
Definition: GenParticle_p6.h:64
IHepMCWeightSvc.h
HepMC::suggest_barcode
bool suggest_barcode(T &p, int i)
Definition: GenEvent.h:670
McEventCollection_p6
Definition: McEventCollection_p6.h:27
HepMC::old_vertex_status_from_new
int old_vertex_status_from_new(const int newStatus)
Get vertex status in the old scheme from the status in the new scheme.
Definition: MagicNumbers.h:420
McEventCollection_p6::m_genEvents
std::vector< GenEvent_p6 > m_genEvents
The vector of persistent representation of GenEvents.
Definition: McEventCollection_p6.h:51
GenParticle_p6::m_status
int m_status
Status of this particle, as defined for HEPEVT.
Definition: GenParticle_p6.h:84
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
GenParticle_p6::m_pz
float m_pz
z-component of the 4-momentum of this particle
Definition: GenParticle_p6.h:72
NSWL1::nVertices
int nVertices(const Polygon &p)
Definition: GeoUtils.cxx:35
GenEvent_p6::m_lengthUnit
int m_lengthUnit
HepMC::Units::LengthUnit casted to int.
Definition: GenEvent_p6.h:152
HepMC::DataPool
Definition: HepMcDataPool.h:81
GenEvent_p6::m_mpi
int m_mpi
Number of multi particle interactions.
Definition: GenEvent_p6.h:89
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
McEventCollection_p6::m_genParticles
std::vector< GenParticle_p6 > m_genParticles
The vector of persistent representation of GenParticles.
Definition: McEventCollection_p6.h:59
HepMC::GenParticlePtr
GenParticle * GenParticlePtr
Definition: GenParticle.h:37
GenEvent_p6::m_filterWeight
double m_filterWeight
value of the extra weight introduced during reweighting events in filter and value of some variables ...
Definition: GenEvent_p6.h:105
GenEvent_p6::m_momentumUnit
int m_momentumUnit
HepMC::Units::MomentumUnit casted to int.
Definition: GenEvent_p6.h:148
TPConverterBase
Definition: TPConverter.h:738
HepMC::GenPdfInfoPtr
HepMC::PdfInfo * GenPdfInfoPtr
Definition: PdfInfo.h:17
GenEvent_p6::m_particlesBegin
unsigned int m_particlesBegin
Begin position in the vector of particles composing this event.
Definition: GenEvent_p6.h:164
McEventCollectionCnv_p6
Definition: McEventCollectionCnv_p6.h:58
HepMcDataPool.h
columnar::operator=
AccessorTemplate & operator=(AccessorTemplate &&that)
Definition: VectorColumn.h:88
McEventCollection_p6::m_genVertices
std::vector< GenVertex_p6 > m_genVertices
The vector of persistent representation of GenVertices.
Definition: McEventCollection_p6.h:55
GenParticle_p6::m_thetaPolarization
float m_thetaPolarization
polarization
Definition: GenParticle_p6.h:96
trigbs_dumpHLTContentInBS.stats
stats
Definition: trigbs_dumpHLTContentInBS.py:91
GenVertex_p6::m_t
float m_t
t-coordinate of the vertex
Definition: GenVertex_p6.h:65
GenParticle_p6::m_m
float m_m
m-component of the 4-momentum of this particle
Definition: GenParticle_p6.h:76
GenEvent_p6::m_signalProcessId
int m_signalProcessId
Id of the processus being generated.
Definition: GenEvent_p6.h:81
McEventCollectionCnv_p6::persToTrans
virtual void persToTrans(const McEventCollection_p6 *persObj, McEventCollection *transObj, MsgStream &log)
Method creating the transient representation of McEventCollection from its persistent representation ...
Definition: McEventCollectionCnv_p6.cxx:68
McEventCollectionCnv_p6::createGenParticle
HepMC::GenParticlePtr createGenParticle(const GenParticle_p6 &p, ParticlesMap_t &partToEndVtx, HepMC::DataPool &datapools, const HepMC::GenVertexPtr &parent=nullptr, bool add_to_output=true) const
Create a transient GenParticle from a persistent one (vers.1) It returns the new GenParticle.
Definition: McEventCollectionCnv_p6.cxx:706
GenParticle_p6::m_endVtx
int m_endVtx
Barcode of the decay vertex of this particle.
Definition: GenParticle_p6.h:110
pi
#define pi
Definition: TileMuonFitter.cxx:65
GenEvent_p6::m_signalProcessVtx
int m_signalProcessVtx
Barcode of the GenVertex holding the signal process.
Definition: GenEvent_p6.h:114
HepMC::DataPool::getGenParticle
HepMC::GenParticlePtr getGenParticle()
Definition: HepMcDataPool.h:160
GenEvent_p6::m_verticesEnd
unsigned int m_verticesEnd
End position in the vector of vertices composing this event.
Definition: GenEvent_p6.h:160
GenEvent_p6::m_e_attribute_id
std::vector< int > m_e_attribute_id
We define those exactly as in the HepMC3::GenEvent.
Definition: GenEvent_p6.h:171
GenParticle_p6::m_phiPolarization
float m_phiPolarization
phi polarization
Definition: GenParticle_p6.h:100
GenVertex_p6::m_y
float m_y
y-coordinate of the vertex
Definition: GenVertex_p6.h:57
HepMC::set_signal_process_vertex
void set_signal_process_vertex(GenEvent *e, T v)
Definition: GenEvent.h:650
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
ParticleGun_EoverP_Config.mom
mom
Definition: ParticleGun_EoverP_Config.py:63
McEventCollectionCnv_p6::writeGenVertex
void writeGenVertex(const HepMC::GenVertex &vtx, McEventCollection_p6 &persEvt) const
Method to write a persistent GenVertex object.
Definition: McEventCollectionCnv_p6.cxx:849
GenEvent_p6::m_crossSection
std::vector< double > m_crossSection
Container of HepMC::GenCrossSection object translated to vector<double>
Definition: GenEvent_p6.h:135
HepMC::barcode_to_particle
GenParticle * barcode_to_particle(const GenEvent *e, int id)
Definition: GenEvent.h:628
HepMC::DataPool::evt
GenEvtPool_t evt
an arena of HepMC::GenEvent for efficient object instantiation
Definition: HepMcDataPool.h:140
HepMC::old_particle_status_from_new
int old_particle_status_from_new(const int newStatus)
Get particle status in the old scheme from the status in the new scheme.
Definition: MagicNumbers.h:411
HepMC::newGenVertexPtr
GenVertexPtr newGenVertexPtr(const HepMC::FourVector &pos=HepMC::FourVector(0.0, 0.0, 0.0, 0.0), const int i=0)
Definition: GenVertex.h:64
lumiFormat.i
int i
Definition: lumiFormat.py:85
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
python.getProblemFolderFromLogs.st
st
Definition: getProblemFolderFromLogs.py:68
HepMC::barcode
int barcode(const T *p)
Definition: Barcode.h:16
HepMC::new_vertex_status_from_old
int new_vertex_status_from_old(const int oldStatus, const int barcode)
Get vertex status in the new scheme from the barcode and status in the old scheme.
Definition: MagicNumbers.h:414
GenEvent_p6::m_particlesEnd
unsigned int m_particlesEnd
End position in the vector of particles composing this event.
Definition: GenEvent_p6.h:168
test_pyathena.parent
parent
Definition: test_pyathena.py:15
GenEvent_p6::m_randomStates
std::vector< long int > m_randomStates
Container of random numbers for the generator states.
Definition: GenEvent_p6.h:131
McEventCollectionCnv_p6.h
HepMC::DataPool::vtx
GenVtxPool_t vtx
an arena of HepMC::GenVertex for efficient object instantiation
Definition: HepMcDataPool.h:144
McEventCollection
This defines the McEventCollection, which is really just an ObjectVector of McEvent objects.
Definition: McEventCollection.h:32
McEventCollectionCnv_p6::ParticlesMap_t
std::unordered_map< HepMC::GenParticlePtr, int > ParticlesMap_t
Definition: McEventCollectionCnv_p6.h:102
McEventCollectionCnv_p6::~McEventCollectionCnv_p6
virtual ~McEventCollectionCnv_p6()
Destructor.
GenVertex_p6::m_barcode
int m_barcode
barcode of this vertex (uniquely identifying a vertex within an event)
Definition: GenVertex_p6.h:85
GenParticle_p6::m_barcode
int m_barcode
barcode of this particles (uniquely identifying this particle within a given GenEvent)
Definition: GenParticle_p6.h:115
DataVector::clear
void clear()
Erase all the elements in the collection.
McEventCollectionCnv_p6::transToPers
virtual void transToPers(const McEventCollection *transObj, McEventCollection_p6 *persObj, MsgStream &log)
Method creating the persistent representation McEventCollection_p6 from its transient representation ...
Definition: McEventCollectionCnv_p6.cxx:364
GenParticle_p6::m_recoMethod
short m_recoMethod
switch to know which method to chose to better recover the original HepLorentzVector.
Definition: GenParticle_p6.h:129
GenVertex_p6::m_x
float m_x
x-coordinate of the vertex
Definition: GenVertex_p6.h:53
GenVertex_p6
Definition: GenVertex_p6.h:24
McEventCollectionCnv_p6::m_hepMCWeightSvc
ServiceHandle< IHepMCWeightSvc > m_hepMCWeightSvc
Definition: McEventCollectionCnv_p6.h:151
GenEvent_p6::m_beamParticle1
int m_beamParticle1
Barcode of the beam particle 1.
Definition: GenEvent_p6.h:118
GenParticle_p6
Definition: GenParticle_p6.h:22
HepMC::ConstGenParticlePtr
const GenParticle * ConstGenParticlePtr
Definition: GenParticle.h:38
GenVertex_p6::m_particlesOut
std::vector< int > m_particlesOut
collection of barcodes of out-going particles connected to this vertex
Definition: GenVertex_p6.h:73
GenEvent_p6::m_eventScale
double m_eventScale
Energy scale.
Definition: GenEvent_p6.h:93
GenParticle_p6::m_generated_mass
float m_generated_mass
mass of this particle when it was generated
Definition: GenParticle_p6.h:119
GenVertex_p6::m_weights
std::vector< float > m_weights
Weights for this vertex.
Definition: GenVertex_p6.h:81
McEventCollectionCnv_utils.h
GenEvent_p6
Definition: GenEvent_p6.h:23
GenEvent_p6::m_eventNbr
int m_eventNbr
Event number.
Definition: GenEvent_p6.h:85
McEventCollectionCnv_p6::McEventCollectionCnv_p6
McEventCollectionCnv_p6()
Default constructor:
Definition: McEventCollectionCnv_p6.cxx:40
MagicNumbers.h
GenParticle_p6::m_pdgId
int m_pdgId
identity of this particle, according to the Particle Data Group notation
Definition: GenParticle_p6.h:80
xAOD::crossSection
crossSection
Definition: TruthEvent_v1.cxx:33
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
weights
Definition: herwig7_interface.h:38
McEventCollectionCnv_p6::writeGenParticle
int writeGenParticle(const HepMC::GenParticle &p, McEventCollection_p6 &persEvt) const
Method to write a persistent GenParticle object It returns the index of the persistent GenParticle in...
Definition: McEventCollectionCnv_p6.cxx:930
McEventCollectionCnv_p6::operator=
McEventCollectionCnv_p6 & operator=(const McEventCollectionCnv_p6 &rhs)
Assignement operator.
Definition: McEventCollectionCnv_p6.cxx:51
McEventCollectionCnv_p6::m_isPileup
bool m_isPileup
Definition: McEventCollectionCnv_p6.h:150
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
python.PyAthena.v
v
Definition: PyAthena.py:154
McEventCollectionCnv_p6::setPileup
void setPileup()
Definition: McEventCollectionCnv_p6.cxx:976
GenParticle_p6::m_flow
std::vector< std::pair< int, int > > m_flow
Flow for this particle.
Definition: GenParticle_p6.h:88
HepMC::newGenParticlePtr
GenParticlePtr newGenParticlePtr(const HepMC::FourVector &mom=HepMC::FourVector(0.0, 0.0, 0.0, 0.0), int pid=0, int status=0)
Definition: GenParticle.h:39
GenEvent_p6::m_r_attribute_name
std::vector< std::string > m_r_attribute_name
Attribute name for run info.
Definition: GenEvent_p6.h:174
GenEvent_p6::m_e_attribute_name
std::vector< std::string > m_e_attribute_name
Attribute name for event.
Definition: GenEvent_p6.h:172
DEBUG
#define DEBUG
Definition: page_access.h:11
GenEvent_p6::m_verticesBegin
unsigned int m_verticesBegin
Begin position in the vector of vertices composing this event.
Definition: GenEvent_p6.h:156
PowhegPythia8EvtGen_jetjet.pdf
pdf
Definition: PowhegPythia8EvtGen_jetjet.py:4
GenEvent_p6::m_weights
std::vector< double > m_weights
Weights for this event.
Definition: GenEvent_p6.h:127
HepMC::DataPool::getGenEvent
HepMC::GenEvent * getGenEvent()
Definition: HepMcDataPool.h:150
GenParticle_p6::m_py
float m_py
y-component of the 4-momentum of this particle
Definition: GenParticle_p6.h:68
HepMC::barcode_to_vertex
GenVertex * barcode_to_vertex(const GenEvent *e, int id)
Definition: GenEvent.h:627
GenEvent_p6::m_e_attribute_string
std::vector< std::string > m_e_attribute_string
Attribute serialized as string for event.
Definition: GenEvent_p6.h:173
GenVertex_p6::m_particlesIn
std::vector< int > m_particlesIn
collection of barcodes of in-going particles connected to this vertex
Definition: GenVertex_p6.h:69
GenEvent_p6::m_heavyIon
std::vector< float > m_heavyIon
Container of HepMC::HeavyIon object translated to vector<double>
Definition: GenEvent_p6.h:139
GenVertex_p6::m_id
int m_id
Id of this vertex.
Definition: GenVertex_p6.h:77
HepMC::ConstGenVertexPtr
const HepMC::GenVertex * ConstGenVertexPtr
Definition: GenVertex.h:60
GenEvent_p6::m_beamParticle2
int m_beamParticle2
Barcode of the beam particle 2.
Definition: GenEvent_p6.h:122
GenEvent_p6::m_alphaQCD
double m_alphaQCD
value of the QCD coupling.
Definition: GenEvent_p6.h:97
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:198
HepMC::DataPool::getGenVertex
HepMC::GenVertexPtr getGenVertex()
Definition: HepMcDataPool.h:155
python.SystemOfUnits.m2
float m2
Definition: SystemOfUnits.py:107
McEventCollectionCnv_p6::createGenVertex
HepMC::GenVertexPtr createGenVertex(const McEventCollection_p6 &persEvts, const GenVertex_p6 &vtx, ParticlesMap_t &bcToPart, HepMC::DataPool &datapools, HepMC::GenEvent *parent=nullptr) const
Create a transient GenVertex from a persistent one (version 1) It returns the new GenVertex.
Definition: McEventCollectionCnv_p6.cxx:639
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
GenVertex_p6::m_z
float m_z
z-coordinate of the vertex
Definition: GenVertex_p6.h:61
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
GenEvent_p6::m_r_attribute_string
std::vector< std::string > m_r_attribute_string
Attribute serialized as string for run info.
Definition: GenEvent_p6.h:175
GenEvent_p6::m_pdfinfo
std::vector< double > m_pdfinfo
Container of HepMC::PdfInfo object translated to vector<double> for simplicity.
Definition: GenEvent_p6.h:144
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
GenParticle
@ GenParticle
Definition: TruthClasses.h:30
HepMC::DataPool::part
GenPartPool_t part
an arena of HepMC::GenParticle for efficient object instantiation
Definition: HepMcDataPool.h:148
HepMC::new_particle_status_from_old
int new_particle_status_from_old(const int oldStatus, const int barcode)
Get particle status in the new scheme from the barcode and status in the old scheme.
Definition: MagicNumbers.h:404
HepMC::signal_process_vertex
GenVertex * signal_process_vertex(const GenEvent *e)
Definition: GenEvent.h:625