ATLAS Offline Software
McEventCollectionCnv_p6.cxx
Go to the documentation of this file.
1 
3 /*
4  Copyright (C) 2002-2023 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
18 #include "GeneratorObjectsTPCnv/McEventCollectionCnv_p6.h"
19 #include "HepMcDataPool.h"
20 #include "GenInterfaces/IHepMCWeightSvc.h"
21 #include "McEventCollectionCnv_utils.h"
22 #include "GaudiKernel/ThreadLocalContext.h"
23 #include "TruthUtils/MagicNumbers.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 
40 McEventCollectionCnv_p6::McEventCollectionCnv_p6() :
41  Base_t( ),
42  m_isPileup(false),m_hepMCWeightSvc("HepMCWeightSvc","McEventCollectionCnv_p6")
43 {}
44 
45 McEventCollectionCnv_p6::McEventCollectionCnv_p6( const McEventCollectionCnv_p6& rhs ) :
46  Base_t( rhs ),
47  m_isPileup(false),m_hepMCWeightSvc("HepMCWeightSvc","McEventCollectionCnv_p6")
48 {}
49 
50 McEventCollectionCnv_p6&
51 McEventCollectionCnv_p6::operator=( const McEventCollectionCnv_p6& rhs )
52 {
53  if ( this != &rhs ) {
54  Base_t::operator=( rhs );
55  m_isPileup=rhs.m_isPileup;m_hepMCWeightSvc = rhs.m_hepMCWeightSvc;
56  }
57  return *this;
58 }
59 
61 // Destructor
63 
64 McEventCollectionCnv_p6::~McEventCollectionCnv_p6()
65 = default;
66 
67 
68 void McEventCollectionCnv_p6::persToTrans( const McEventCollection_p6* persObj,
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(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(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(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] = 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
332  for ( ParticlesMap_t::iterator
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 
364 void McEventCollectionCnv_p6::transToPers( const McEventCollection* transObj,
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");
408  auto signal_process_vertex = HepMC::signal_process_vertex(genEvt);
409  auto A_random_states=genEvt->attribute<HepMC3::VectorLongIntAttribute>("random_states");
410  auto beams=genEvt->beams();
411  persObj->m_genEvents.
412  emplace_back(A_signal_process_id?(A_signal_process_id->value()):-1,
413  genEvt->event_number(),
414  A_mpi?(A_mpi->value()):-1,
415  A_event_scale?(A_event_scale->value()):0.0,
416  A_alphaQCD?(A_alphaQCD->value()):0.0,
417  A_alphaQED?(A_alphaQED->value()):0.0,
418  A_filterWeight?(A_filterWeight->value()):1.0,
419  A_filterHT?(A_filterHT->value()):-13.,
420  A_filterMET?(A_filterMET->value()):-13.0,
421  signal_process_vertex?HepMC::barcode(signal_process_vertex):0,
422  !beams.empty()?HepMC::barcode(beams[0]):0,
423  beams.size()>1?HepMC::barcode(beams[1]):0,
424  genEvt->weights(),
425  A_random_states?(A_random_states->value()):std::vector<long>(),
426  std::vector<double>(), // cross section
427  std::vector<float>(), // heavyion
428  std::vector<double>(), // pdf info
429  genEvt->momentum_unit(),
430  genEvt->length_unit(),
431  nPersVtx,
432  nPersVtx + genEvt->vertices().size(),
433  nPersParts,
434  nPersParts + genEvt->particles().size() );
435  {
436  GenEvent_p6& persEvt = persObj->m_genEvents.back();
437  std::map< std::string, std::map<int, std::shared_ptr<HepMC3::Attribute> > > e_atts = genEvt->attributes();
438  persEvt.m_e_attribute_name.clear();
439  persEvt.m_e_attribute_id.clear();
440  persEvt.m_e_attribute_string.clear();
441  for (auto& attmap: e_atts) {
442  if (attributes_to_ignore.count(attmap.first)) continue;
443  if (attmap.first == "ShadowParticle") continue;
444  if (attmap.first == "ShadowParticleId") continue;
445  for (auto& att: attmap.second) {
446  persEvt.m_e_attribute_name.push_back(attmap.first);
447  persEvt.m_e_attribute_id.push_back(att.first);
448  std::string st;
449  att.second->to_string(st);
452  persEvt.m_e_attribute_string.push_back(st);
453  }
454  }
455  persEvt.m_r_attribute_name.clear();
456  persEvt.m_r_attribute_string.clear();
457  if (ri) {
458  persEvt.m_r_attribute_string = std::move(ri_data.attribute_string);
459  persEvt.m_r_attribute_name = std::move(ri_data.attribute_name);
460  /*** This is for the future
461  persEvt.m_r_tool_name = ri_data.tool_name;
462  persEvt.m_r_tool_version = ri_data.tool_version;
463  persEvt.m_r_tool_description = ri_data.tool_description;
464  */
465  }
466  //Actually, with this piece there is no need to treat the CS and HI separately.
467  }
468  //HepMC::GenCrossSection encoding
469  if (genEvt->cross_section()) {
470  auto cs=genEvt->cross_section();
471  GenEvent_p6& persEvt = persObj->m_genEvents.back();
472  std::vector<double>& crossSection = persEvt.m_crossSection;
473  crossSection.resize(3);
474  crossSection[2] = cs->xsec();
475  crossSection[1] = cs->xsec_err();
476  crossSection[0] = static_cast<double>(cs->is_valid());
479  if (crossSection[2] < 0) {
480  crossSection[2] = 0.0;
481  if (crossSection[1] < 0) {
482  crossSection[1] = 0.0;
483  }
484  crossSection[0] = 0.0;
485  }
486 
487  }
488 
489  //HepMC::HeavyIon encoding
490  if (genEvt->heavy_ion()) {
491  auto hi=genEvt->heavy_ion();
492  GenEvent_p6& persEvt = persObj->m_genEvents.back();
493  std::vector<float>& heavyIon = persEvt.m_heavyIon;
494  heavyIon.resize(13);
495  heavyIon[12] = static_cast<float>(hi->Ncoll_hard);
496  heavyIon[11] = static_cast<float>(hi->Npart_proj);
497  heavyIon[10] = static_cast<float>(hi->Npart_targ);
498  heavyIon[9] = static_cast<float>(hi->Ncoll);
499  heavyIon[8] = static_cast<float>(hi->spectator_neutrons);
500  heavyIon[7] = static_cast<float>(hi->spectator_protons);
501  heavyIon[6] = static_cast<float>(hi->N_Nwounded_collisions);
502  heavyIon[5] = static_cast<float>(hi->Nwounded_N_collisions);
503  heavyIon[4] = static_cast<float>(hi->Nwounded_Nwounded_collisions);
504  heavyIon[3] = hi->impact_parameter;
505  heavyIon[2] = hi->event_plane_angle;
506  heavyIon[1] = hi->eccentricity;
507  heavyIon[0] = hi->sigma_inel_NN;
508  }
509 
510  //PdfInfo encoding
511  if (genEvt->pdf_info()) {
512  auto pi=genEvt->pdf_info();
513  GenEvent_p6& persEvt = persObj->m_genEvents.back();
514  std::vector<double>& pdfinfo = persEvt.m_pdfinfo;
515  pdfinfo.resize(9);
516  pdfinfo[8] = static_cast<double>(pi->parton_id[0]);
517  pdfinfo[7] = static_cast<double>(pi->parton_id[1]);
518  pdfinfo[6] = static_cast<double>(pi->pdf_id[0]);
519  pdfinfo[5] = static_cast<double>(pi->pdf_id[1]);
520  pdfinfo[4] = pi->x[0];
521  pdfinfo[3] = pi->x[1];
522  pdfinfo[2] = pi->scale;
523  pdfinfo[1] = pi->xf[0];
524  pdfinfo[0] = pi->xf[1];
525  }
526 
527  // create vertices
528  for (const auto& v: genEvt->vertices()) {
529  writeGenVertex( v, *persObj );
530  }
531 #else
532  const int signalProcessVtx = genEvt->m_signal_process_vertex
533  ? genEvt->m_signal_process_vertex->barcode()
534  : 0;
535  const int beamParticle1Barcode = genEvt->m_beam_particle_1
536  ? genEvt->m_beam_particle_1->barcode()
537  : 0;
538  const int beamParticle2Barcode = genEvt->m_beam_particle_2
539  ? genEvt->m_beam_particle_2->barcode()
540  : 0;
541 
542  //save the weight names to metadata via the HepMCWeightSvc
543  m_hepMCWeightSvc->setWeightNames( genEvt->m_weights.m_names, ctx ).ignore();
544 
545 
546  persObj->m_genEvents.
547  push_back( GenEvent_p6( genEvt->m_signal_process_id,
548  genEvt->m_event_number,
549  genEvt->mpi(), // number of multi particle interactions
550  genEvt->m_event_scale,
551  genEvt->m_alphaQCD,
552  genEvt->m_alphaQED,
553  1, // dummy value as this does not exist in HepMC2::GenEvent
554  signalProcessVtx,
555  beamParticle1Barcode, // barcodes of beam particles
556  beamParticle2Barcode,
557  genEvt->m_weights.m_weights,
558  genEvt->m_random_states,
559  std::vector<double>(), // cross section
560  std::vector<float>(), // heavyion
561  std::vector<double>(), // pdf info
562  genEvt->m_momentum_unit,
563  genEvt->m_position_unit,
564  nPersVtx,
565  nPersVtx + genEvt->vertices_size(),
566  nPersParts,
567  nPersParts + genEvt->particles_size() ) );
568  //HepMC::GenCrossSection encoding
569  if (genEvt->m_cross_section) {
570  GenEvent_p6& persEvt = persObj->m_genEvents.back();
571  std::vector<double>& crossSection = persEvt.m_crossSection;
572  crossSection.resize(3);
573  crossSection[2] = genEvt->m_cross_section->m_cross_section;
574  crossSection[1] = genEvt->m_cross_section->m_cross_section_error;
575  crossSection[0] = static_cast<double>(genEvt->m_cross_section->m_is_set);
576  }
577 
578  //HepMC::HeavyIon encoding
579  if (genEvt->m_heavy_ion) {
580  GenEvent_p6& persEvt = persObj->m_genEvents.back();
581  std::vector<float>& heavyIon = persEvt.m_heavyIon;
582  heavyIon.resize(13);
583  heavyIon[12] = static_cast<float>(genEvt->m_heavy_ion->m_Ncoll_hard);
584  heavyIon[11] = static_cast<float>(genEvt->m_heavy_ion->m_Npart_proj);
585  heavyIon[10] = static_cast<float>(genEvt->m_heavy_ion->m_Npart_targ);
586  heavyIon[9] = static_cast<float>(genEvt->m_heavy_ion->m_Ncoll);
587  heavyIon[8] = static_cast<float>(genEvt->m_heavy_ion->m_spectator_neutrons);
588  heavyIon[7] = static_cast<float>(genEvt->m_heavy_ion->m_spectator_protons);
589  heavyIon[6] = static_cast<float>(genEvt->m_heavy_ion->m_N_Nwounded_collisions);
590  heavyIon[5] = static_cast<float>(genEvt->m_heavy_ion->m_Nwounded_N_collisions);
591  heavyIon[4] = static_cast<float>(genEvt->m_heavy_ion->m_Nwounded_Nwounded_collisions);
592  heavyIon[3] = genEvt->m_heavy_ion->m_impact_parameter;
593  heavyIon[2] = genEvt->m_heavy_ion->m_event_plane_angle;
594  heavyIon[1] = genEvt->m_heavy_ion->m_eccentricity;
595  heavyIon[0] = genEvt->m_heavy_ion->m_sigma_inel_NN;
596  }
597 
598  //PdfInfo encoding
599  if (genEvt->m_pdf_info) {
600  GenEvent_p6& persEvt = persObj->m_genEvents.back();
601  std::vector<double>& pdfinfo = persEvt.m_pdfinfo;
602  pdfinfo.resize(9);
603  pdfinfo[8] = static_cast<double>(genEvt->m_pdf_info->m_id1);
604  pdfinfo[7] = static_cast<double>(genEvt->m_pdf_info->m_id2);
605  pdfinfo[6] = static_cast<double>(genEvt->m_pdf_info->m_pdf_id1);
606  pdfinfo[5] = static_cast<double>(genEvt->m_pdf_info->m_pdf_id2);
607  pdfinfo[4] = genEvt->m_pdf_info->m_x1;
608  pdfinfo[3] = genEvt->m_pdf_info->m_x2;
609  pdfinfo[2] = genEvt->m_pdf_info->m_scalePDF;
610  pdfinfo[1] = genEvt->m_pdf_info->m_pdf1;
611  pdfinfo[0] = genEvt->m_pdf_info->m_pdf2;
612  }
613 
614  // create vertices
615  const HepMC::GenEvent::vertex_const_iterator endVtx=genEvt->vertices_end();
616  for ( HepMC::GenEvent::vertex_const_iterator i = genEvt->vertices_begin();
617  i != endVtx;
618  ++i ) {
619  writeGenVertex( **i, *persObj );
620  }
621 #endif
622 
623  } //> end loop over GenEvents
624 
625  msg << MSG::DEBUG << "Created persistent state of HepMC::GenEvent [OK]" << endmsg;
626 }
627 
628 
629 HepMC::GenVertexPtr
630 McEventCollectionCnv_p6::createGenVertex( const McEventCollection_p6& persEvt,
631  const GenVertex_p6& persVtx,
632  ParticlesMap_t& partToEndVtx, HepMC::DataPool& datapools
633  ,HepMC::GenEvent* parent
634  ) const
635 {
636  HepMC::GenVertexPtr vtx(nullptr);
637  if(m_isPileup) {
638  vtx=HepMC::newGenVertexPtr();
639  } else {
640  vtx = datapools.getGenVertex();
641  }
642  if (parent ) parent->add_vertex(vtx);
643 #ifdef HEPMC3
644  vtx->set_position(HepMC::FourVector( persVtx.m_x , persVtx.m_y , persVtx.m_z ,persVtx.m_t ));
645  //AV ID cannot be assigned in HepMC3. And its meaning in HepMC2 is not clear.
646  vtx->set_status(HepMC::new_vertex_status_from_old(persVtx.m_id, persVtx.m_barcode)); // UPDATED STATUS VALUE TO NEW SCHEME
647  // cast from std::vector<float> to std::vector<double>
648  std::vector<double> weights( persVtx.m_weights.begin(), persVtx.m_weights.end() );
649  vtx->add_attribute("weights",std::make_shared<HepMC3::VectorDoubleAttribute>(weights));
650  HepMC::suggest_barcode (vtx, persVtx.m_barcode);
651  // handle the in-going (orphans) particles
652  const unsigned int nPartsIn = persVtx.m_particlesIn.size();
653  for ( unsigned int i = 0; i != nPartsIn; ++i ) {
654  createGenParticle( persEvt.m_genParticles[persVtx.m_particlesIn[i]], partToEndVtx, datapools, vtx, false );
655  }
656 
657  // now handle the out-going particles
658  const unsigned int nPartsOut = persVtx.m_particlesOut.size();
659  for ( unsigned int i = 0; i != nPartsOut; ++i ) {
660  createGenParticle( persEvt.m_genParticles[persVtx.m_particlesOut[i]], partToEndVtx, datapools, vtx );
661  }
662 #else
663  vtx->m_position.setX( persVtx.m_x );
664  vtx->m_position.setY( persVtx.m_y );
665  vtx->m_position.setZ( persVtx.m_z );
666  vtx->m_position.setT( persVtx.m_t );
667  vtx->m_particles_in.clear();
668  vtx->m_particles_out.clear();
669  vtx->m_id = HepMC::new_vertex_status_from_old(persVtx.m_id, persVtx.m_barcode); // UPDATED STATUS VALUE TO NEW SCHEME
670  vtx->m_weights.m_weights.reserve( persVtx.m_weights.size() );
671  vtx->m_weights.m_weights.assign ( persVtx.m_weights.begin(),
672  persVtx.m_weights.end() );
673  vtx->m_event = 0;
674  vtx->m_barcode = persVtx.m_barcode;
675 
676  // handle the in-going (orphans) particles
677  const unsigned int nPartsIn = persVtx.m_particlesIn.size();
678  for ( unsigned int i = 0; i != nPartsIn; ++i ) {
679  createGenParticle( persEvt.m_genParticles[persVtx.m_particlesIn[i]],
680  partToEndVtx,
681  datapools );
682  }
683 
684  // now handle the out-going particles
685  const unsigned int nPartsOut = persVtx.m_particlesOut.size();
686  for ( unsigned int i = 0; i != nPartsOut; ++i ) {
687  vtx->add_particle_out( createGenParticle( persEvt.m_genParticles[persVtx.m_particlesOut[i]],
688  partToEndVtx,
689  datapools ) );
690  }
691 #endif
692 
693  return vtx;
694 }
695 
696 HepMC::GenParticlePtr
697 McEventCollectionCnv_p6::createGenParticle( const GenParticle_p6& persPart,
698  ParticlesMap_t& partToEndVtx, HepMC::DataPool& datapools ,const HepMC::GenVertexPtr& parent, bool add_to_output ) const
699 {
700  HepMC::GenParticlePtr p(nullptr);
701  if (m_isPileup) {
702  p = HepMC::newGenParticlePtr();
703  } else {
704  p = datapools.getGenParticle();
705  }
706  if (parent) add_to_output?parent->add_particle_out(p):parent->add_particle_in(p);
707 #ifdef HEPMC3
708  p->set_pdg_id( persPart.m_pdgId);
709  p->set_status(HepMC::new_particle_status_from_old(persPart.m_status, persPart.m_barcode)); // UPDATED STATUS VALUE TO NEW SCHEME
710  p->add_attribute("phi",std::make_shared<HepMC3::DoubleAttribute>(persPart.m_phiPolarization));
711  p->add_attribute("theta",std::make_shared<HepMC3::DoubleAttribute>(persPart.m_thetaPolarization));
712  HepMC::suggest_barcode (p, persPart.m_barcode);
713  p->set_generated_mass(persPart.m_generated_mass);
714 
715  // Note: do the E calculation in extended (long double) precision.
716  // That happens implicitly on x86 with optimization on; saying it
717  // explicitly ensures that we get the same results with and without
718  // optimization. (If this is a performance issue for platforms
719  // other than x86, one could change to double for those platforms.)
720  if ( 0 == persPart.m_recoMethod ) {
721  double temp_e = std::sqrt( (long double)(persPart.m_px)*persPart.m_px +
722  (long double)(persPart.m_py)*persPart.m_py +
723  (long double)(persPart.m_pz)*persPart.m_pz +
724  (long double)(persPart.m_m) *persPart.m_m );
725  p->set_momentum( HepMC::FourVector(persPart.m_px,persPart.m_py,persPart.m_pz,temp_e));
726  } else {
727  const int signM2 = ( persPart.m_m >= 0. ? 1 : -1 );
728  const double persPart_ene =
729  std::sqrt( std::abs((long double)(persPart.m_px)*persPart.m_px +
730  (long double)(persPart.m_py)*persPart.m_py +
731  (long double)(persPart.m_pz)*persPart.m_pz +
732  signM2* (long double)(persPart.m_m)* persPart.m_m));
733  const int signEne = ( persPart.m_recoMethod == 1 ? 1 : -1 );
734  p->set_momentum(HepMC::FourVector( persPart.m_px,
735  persPart.m_py,
736  persPart.m_pz,
737  signEne * persPart_ene ));
738  }
739 
740  // setup flow
741  std::vector<int> flows;
742  const unsigned int nFlow = persPart.m_flow.size();
743  for ( unsigned int iFlow= 0; iFlow != nFlow; ++iFlow ) {
744  flows.push_back(persPart.m_flow[iFlow].second );
745  }
746  //We construct it here as vector w/o gaps.
747  p->add_attribute("flows", std::make_shared<HepMC3::VectorIntAttribute>(flows));
748 #else
749  p->m_pdg_id = persPart.m_pdgId;
750  p->m_status = HepMC::new_particle_status_from_old(persPart.m_status, persPart.m_barcode); // UPDATED STATUS VALUE TO NEW SCHEME
751  p->m_polarization.m_theta= static_cast<double>(persPart.m_thetaPolarization);
752  p->m_polarization.m_phi = static_cast<double>(persPart.m_phiPolarization );
753  p->m_production_vertex = 0;
754  p->m_end_vertex = 0;
755  p->m_barcode = persPart.m_barcode;
756  p->m_generated_mass = static_cast<double>(persPart.m_generated_mass);
757 
758  // Note: do the E calculation in extended (long double) precision.
759  // That happens implicitly on x86 with optimization on; saying it
760  // explicitly ensures that we get the same results with and without
761  // optimization. (If this is a performance issue for platforms
762  // other than x86, one could change to double for those platforms.)
763  if ( 0 == persPart.m_recoMethod ) {
764 
765  p->m_momentum.setPx( persPart.m_px);
766  p->m_momentum.setPy( persPart.m_py);
767  p->m_momentum.setPz( persPart.m_pz);
768  double temp_e = std::sqrt( (long double)(persPart.m_px)*persPart.m_px +
769  (long double)(persPart.m_py)*persPart.m_py +
770  (long double)(persPart.m_pz)*persPart.m_pz +
771  (long double)(persPart.m_m) *persPart.m_m );
772  p->m_momentum.setE( temp_e);
773  } else {
774  const int signM2 = ( persPart.m_m >= 0. ? 1 : -1 );
775  const double persPart_ene =
776  std::sqrt( std::abs((long double)(persPart.m_px)*persPart.m_px +
777  (long double)(persPart.m_py)*persPart.m_py +
778  (long double)(persPart.m_pz)*persPart.m_pz +
779  signM2* (long double)(persPart.m_m)* persPart.m_m));
780  const int signEne = ( persPart.m_recoMethod == 1 ? 1 : -1 );
781  p->m_momentum.set( persPart.m_px,
782  persPart.m_py,
783  persPart.m_pz,
784  signEne * persPart_ene );
785  }
786 
787  // setup flow
788  const unsigned int nFlow = persPart.m_flow.size();
789  p->m_flow.clear();
790  for ( unsigned int iFlow= 0; iFlow != nFlow; ++iFlow ) {
791  p->m_flow.set_icode( persPart.m_flow[iFlow].first,
792  persPart.m_flow[iFlow].second );
793  }
794 #endif
795 
796  if ( persPart.m_endVtx != 0 ) {
797  partToEndVtx[p] = persPart.m_endVtx;
798  }
799 
800  return p;
801 }
802 
803 #ifdef HEPMC3
804 void McEventCollectionCnv_p6::writeGenVertex( const HepMC::ConstGenVertexPtr& vtx,
805  McEventCollection_p6& persEvt )
806 {
807  const HepMC::FourVector& position = vtx->position();
808  auto A_weights=vtx->attribute<HepMC3::VectorDoubleAttribute>("weights");
809  auto A_barcode=vtx->attribute<HepMC3::IntAttribute>("barcode");
810  std::vector<float> weights;
811  if (A_weights) {
812  auto weights_d = A_weights->value();
813  for (auto& w: weights_d) weights.push_back(w);
814  }
815  persEvt.m_genVertices.emplace_back( position.x(),
816  position.y(),
817  position.z(),
818  position.t(),
819  HepMC::old_vertex_status_from_new(vtx->status()), // REVERTED STATUS VALUE TO OLD SCHEME
820  weights.begin(),
821  weights.end(),
822  A_barcode?(A_barcode->value()):vtx->id() );
823  GenVertex_p6& persVtx = persEvt.m_genVertices.back();
824 
825  // we write only the orphans in-coming particles and beams
826  persVtx.m_particlesIn.reserve(vtx->particles_in().size());
827  for (const auto& p: vtx->particles_in()) {
828  if ( !p->production_vertex() || p->production_vertex()->id() == 0 ) {
829  persVtx.m_particlesIn.push_back( writeGenParticle( p, persEvt ) );
830  }
831  }
832 
833  persVtx.m_particlesOut.reserve(vtx->particles_out().size());
834  for (const auto& p: vtx->particles_out()) {
835  persVtx.m_particlesOut.push_back( writeGenParticle( p, persEvt ) );
836  }
837 
838  }
839 #else
840 void McEventCollectionCnv_p6::writeGenVertex( const HepMC::GenVertex& vtx,
841  McEventCollection_p6& persEvt ) const
842 {
843  const HepMC::FourVector& position = vtx.m_position;
844  persEvt.m_genVertices.push_back(
845  GenVertex_p6( position.x(),
846  position.y(),
847  position.z(),
848  position.t(),
849  HepMC::old_vertex_status_from_new(vtx.m_id), // REVERTED STATUS VALUE TO OLD SCHEME
850  vtx.m_weights.m_weights.begin(),
851  vtx.m_weights.m_weights.end(),
852  vtx.m_barcode ) );
853  GenVertex_p6& persVtx = persEvt.m_genVertices.back();
854 
855  // we write only the orphans in-coming particles
856  const std::vector<HepMC::GenParticlePtr>::const_iterator endInVtx = vtx.m_particles_in.end();
857  persVtx.m_particlesIn.reserve(vtx.m_particles_in.size());
858  for ( std::vector<HepMC::GenParticlePtr>::const_iterator p = vtx.m_particles_in.begin();
859  p != endInVtx;
860  ++p ) {
861  if ( 0 == (*p)->production_vertex() ) {
862  persVtx.m_particlesIn.push_back( writeGenParticle( **p, persEvt ) );
863  }
864  }
865 
866  const std::vector<HepMC::GenParticlePtr>::const_iterator endOutVtx = vtx.m_particles_out.end();
867  persVtx.m_particlesOut.reserve(vtx.m_particles_out.size());
868  for ( std::vector<HepMC::GenParticlePtr>::const_iterator p = vtx.m_particles_out.begin();
869  p != endOutVtx;
870  ++p ) {
871  persVtx.m_particlesOut.push_back( writeGenParticle( **p, persEvt ) );
872  }
873 
874  return;
875 }
876 #endif
877 
878 #ifdef HEPMC3
879 int McEventCollectionCnv_p6::writeGenParticle( const HepMC::ConstGenParticlePtr& p,
880  McEventCollection_p6& persEvt )
881 {
882  const HepMC::FourVector mom = p->momentum();
883  const double ene = mom.e();
884  const double m2 = mom.m2();
885 
886  // Definitions of Bool isTimeLilike, isSpacelike and isLightlike according to HepLorentzVector definition
887  const bool useP2M2 = !(m2 > 0) && // !isTimelike
888  (m2 < 0) && // isSpacelike
889  !(std::abs(m2) < 2.0*DBL_EPSILON*ene*ene); // !isLightlike
890  auto A_flows=p->attribute<HepMC3::VectorIntAttribute>("flows");
891  auto A_phi=p->attribute<HepMC3::DoubleAttribute>("phi");
892  auto A_theta=p->attribute<HepMC3::DoubleAttribute>("theta");
893 
894  const short recoMethod = ( !useP2M2 ? 0: ( ene >= 0.? 1: 2 ) );
895  persEvt.m_genParticles.
896  emplace_back( mom.px(),
897  mom.py(),
898  mom.pz(),
899  mom.m(),
900  p->pdg_id(),
901  HepMC::old_particle_status_from_new(p->status()), // REVERTED STATUS VALUE TO OLD SCHEME
902  A_flows?(A_flows->value().size()):0,
903  A_theta?(A_theta->value()):0.0,
904  A_phi?(A_phi->value()):0.0,
905  p->production_vertex()? HepMC::barcode(p->production_vertex()):0,
906  p->end_vertex()? HepMC::barcode(p->end_vertex()):0,
907  HepMC::barcode(p),
908  p->generated_mass(),
909  recoMethod );
910 
911  std::vector< std::pair<int,int> > flow_hepmc2;
912  if(A_flows) flow_hepmc2=vector_to_vector_int_int(A_flows->value());
913  persEvt.m_genParticles.back().m_flow.assign( flow_hepmc2.begin(),flow_hepmc2.end() );
914 
915  // we return the index of the particle in the big vector of particles
916  // (contained by the persistent GenEvent)
917  return (persEvt.m_genParticles.size() - 1);
918 
919 }
920 #else
921 int McEventCollectionCnv_p6::writeGenParticle( const HepMC::GenParticle& p,
922  McEventCollection_p6& persEvt ) const
923 {
924  const HepMC::FourVector& mom = p.m_momentum;
925  const double ene = mom.e();
926  const double m2 = mom.m2();
927 
928  // Definitions of Bool isTimeLilike, isSpacelike and isLightlike according to HepLorentzVector definition
929  const bool useP2M2 = !(m2 > 0) && // !isTimelike
930  (m2 < 0) && // isSpacelike
931  !(std::abs(m2) < 2.0*DBL_EPSILON*ene*ene); // !isLightlike
932 
933  const short recoMethod = ( !useP2M2
934  ? 0
935  : ( ene >= 0. //*GeV
936  ? 1
937  : 2 ) );
938 
939  persEvt.m_genParticles.
940  push_back( GenParticle_p6( mom.px(),
941  mom.py(),
942  mom.pz(),
943  mom.m(),
944  p.m_pdg_id,
945  HepMC::old_particle_status_from_new(p.m_status), // REVERTED STATUS VALUE TO OLD SCHEME
946  p.m_flow.size(),
947  p.m_polarization.theta(),
948  p.m_polarization.phi(),
949  p.m_production_vertex
950  ? p.m_production_vertex->barcode()
951  : 0,
952  p.m_end_vertex
953  ? p.m_end_vertex->barcode()
954  : 0,
955  p.m_barcode,
956  p.m_generated_mass,
957  recoMethod ) );
958  persEvt.m_genParticles.back().m_flow.assign( p.m_flow.begin(),
959  p.m_flow.end() );
960 
961  // we return the index of the particle in the big vector of particles
962  // (contained by the persistent GenEvent)
963  return (persEvt.m_genParticles.size() - 1);
964 }
965 #endif
966 
967 void McEventCollectionCnv_p6::setPileup() {
968  m_isPileup = true;
969 }
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:408
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
python.SystemOfUnits.m2
int m2
Definition: SystemOfUnits.py:92
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
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:697
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:210
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:840
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:399
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
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:402
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:33
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:44
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:921
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:967
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:200
HepMC::DataPool::getGenVertex
HepMC::GenVertexPtr getGenVertex()
Definition: HepMcDataPool.h:155
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:630
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:392
HepMC::signal_process_vertex
GenVertex * signal_process_vertex(const GenEvent *e)
Definition: GenEvent.h:625
Generated on Thu Nov 7 2024 21:20:32 for ATLAS Offline Software by   doxygen 1.8.18