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