ATLAS Offline Software
Hijing.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // -------------------------------------------------------------
6 // Generators/Hijing.cxx Description: Allows the user
7 // to generate hijing events and store the result in the
8 // Transient Store.
9 //
10 // AuthorList:
11 // Georgios Stavropoulos: Initial Code October 2002
12 // Brian Cole, Mikhail Leltchouk, Andrzej Olszewski: 2006, 2007
13 // Modified:
14 // 2007-Feb Alden Stradling: Added vertex shifting and made options settable in jO.
15 // 2007-Sep Aaron Angerami: keepSpectators option.
16 // 2007-Nov Brian Cole, Mikhail Leltchouk: each vertex is added to the event before particles are added to the vertex
17 // - this fixed bug #30991 for release 13.1.0 and for HepMC 2.3.0 where the 'set's comparison operates
18 // on the bcode rather than on the pointer.
19 // 2008-Jul Borut Kersevan: randomizing the left<->right direction by mirroring momenta settable in jobOpts for beamgas
20 // 2023-Aug Aaron Angerami: adding keepAllDecayVertices option to keep decay vertices for strong decays (default=true)
21 
22 #include "Hijing_i/Hijing.h"
23 #include "Hijing_i/VertexShift.h"
24 
25 #include "GaudiKernel/MsgStream.h"
26 
27 #include "CxxUtils/StringParse.h"
28 
29 #include "AtlasHepMC/GenEvent.h"
30 #include "AtlasHepMC/GenVertex.h"
31 #include "AtlasHepMC/GenParticle.h"
32 #include "AtlasHepMC/HeavyIon.h"
33 
34 #include <stdlib.h>
35 
36 #include "CLHEP/Random/RandFlat.h"
37 #include "CLHEP/Geometry/Point3D.h"
38 
39 #include "AthenaKernel/RNGWrapper.h"
40 
41 namespace {
42  static CLHEP::HepRandomEngine *p_Engine;
43  static std::string hijing_stream = "HIJING_INIT";
44 }
45 
46 // calls to fortran routines
47 extern "C"
48 {
49  float atl_ran_( int* )
50  {
51  return (float) CLHEP::RandFlat::shoot(p_Engine);
52  }
53 
54  void hijset_(float*,
55  const char*,
56  const char*,
57  const char*,
58  int*,
59  int*,
60  int*,
61  int*,
62  long int,
63  long int,
64  long int);
65  void hijing_(const char*, float*, float*, long int);
66 }
67 
68 Hijing::Hijing(const std::string& name,
69  ISvcLocator* pSvcLocator): GenModule(name,pSvcLocator)
70 {
71  declareProperty("Initialize", m_InitializeVector);
72  declareProperty("partonStoreMinPt", m_partonStoreMinPt);
73  declareProperty("vertexOffsetCut", m_vertexOffsetCut);
74  declareProperty("randomizeVertices", m_rand); // Randomize for beam gas
75  declareProperty("selectVertex", m_sel); // Select vertex location (off for random)
76  declareProperty("wide", m_wide); // Allow randoms off the beamline (out to the pipe)
77  declareProperty("x", m_x);
78  declareProperty("y", m_y);
79  declareProperty("z", m_z);
80  declareProperty("keepSpectators", m_spec);
81  declareProperty("randomizeP", m_prand); //BPK randomizes the left<->right direction by mirroring momenta for beam gas
82  declareProperty("keepAllDecayVertices", m_keepAllDecayVertices);
83 }
84 
85 StatusCode Hijing::genInitialize()
86 {
87  ATH_CHECK(m_event_paramsKey.initialize());
88 
89  // Initialisation of input parameters
90  std::cout << "MetaData: generator = Hijing "
91  << HIJINGVERSION << std::endl;
92  ATH_MSG_INFO( "===> Hijing initialising \n" );
93  if( m_rand ){
94  ATH_MSG_INFO( "===> Vertex randomization ON." );
95  }
96  if( m_wide ){
97  ATH_MSG_INFO( "===> Vertex rand covers whole beampipe." );
98  }
99  //BPK
100  if( m_prand ) ATH_MSG_INFO( "===> Random Momentum Mirroring enabled" );
101  if( m_keepAllDecayVertices ) ATH_MSG_INFO( "===> Keeping all decay vertices" );
102  else ATH_MSG_INFO( "===> NOT keeping all decay vertices" );
103 
104 #ifdef HEPMC3
105  ATH_MSG_INFO( "===> HEPMC3 is used" );
106 #else
107  ATH_MSG_INFO( "===> HEPMC3 is not used" );
108 #endif
109 
110  //CLHEP::HepRandomEngine* engine
111  p_Engine = getRandomEngineDuringInitialize(hijing_stream, m_randomSeed, m_dsid); // NOT THREAD-SAFE
112  hijing_stream = "HIJING";
113 
114  // Set the users' initialisation parameters choices
115  set_user_params();
116 
117  const char* frame = m_frame.c_str();
118  const char* proj = m_proj.c_str();
119  const char* targ = m_targ.c_str();
120 
121  hijset_( &m_efrm, frame, proj, targ, &m_iap, &m_izp, &m_iat, &m_izt,
122  strlen(frame), strlen(proj), strlen(targ) );
123 
124  ATH_MSG_INFO( "\n=================================================\n"
125  << " HIJING initialization results: \n"
126  << " Total sigma = " << m_hiparnt.hint1(13) << " mb\n"
127  << " Inelastic sigma = " << m_hiparnt.hint1(12) << " mb\n"
128  << " Jet sigma = " << m_hiparnt.hint1(11) << " mb\n"
129  << "=================================================\n" );
130 
131 
132  return StatusCode::SUCCESS;
133 }
134 
135 StatusCode Hijing::callGenerator()
136 {
137  ATH_MSG_INFO( " HIJING generating. \n" );
138 
139  // Save the random number seeds in the event
140  //Re-seed the random number stream
141  long seeds[7];
142  const EventContext& ctx = Gaudi::Hive::currentContext();
143  ATHRNG::calculateSeedsMC21(seeds, hijing_stream, ctx.eventID().event_number(), m_dsid, m_randomSeed);
144  p_Engine->setSeeds(seeds, 0); // NOT THREAD-SAFE
145  m_seeds.clear();
146  m_seeds.push_back(seeds[0]);
147  m_seeds.push_back(seeds[1]);
148 
149  // Generate event
150  const char* frame = m_frame.c_str();
151  hijing_(frame, &m_bmin, &m_bmax, strlen(frame));
152 
153  // Check for error using the new (custom) error return
154  //
155  int errorStatus = m_himain1.ierrstat();
156  if (errorStatus != 0) {
157  ATH_MSG_ERROR( "Error returned from HIJING, value = " << errorStatus );
158  return StatusCode::FAILURE;
159  }
160 
161  // update event counter
162  ++m_events;
163 
164  // store hijing event parameters
165  // -----------------------------
166  ATH_MSG_DEBUG( "New HijingEventParams" );
167  int np = m_himain1.np();
168  int nt = m_himain1.nt();
169  int n0 = m_himain1.n0();
170  int n01 = m_himain1.n01();
171  int n10 = m_himain1.n10();
172  int n11 = m_himain1.n11();
173  int natt = m_himain1.natt();
174  int jatt = m_himain1.jatt();
175  float b = m_hiparnt.hint1(19);
176  float bphi = m_hiparnt.hint1(20);
177 
178  SG::WriteHandle<HijingEventParams> event_params(m_event_paramsKey);
179  event_params = std::make_unique<HijingEventParams>(np, nt, n0, n01, n10, n11, natt, jatt, b, bphi);
180 
181  ATH_MSG_INFO( "\n=================================================\n"
182  << " HIJING event description: \n"
183  << " b = " << b << " fm \n"
184  << " # proj participants = " << np << "\n"
185  << " # targ participants = " << nt << "\n"
186  << " # final particles = " << natt << "\n"
187  << "=================================================\n" );
188 
189  ATH_MSG_DEBUG( " HIJING generating done. \n" );
190  return StatusCode::SUCCESS;
191 }
192 
193 StatusCode
194 Hijing::genFinalize()
195 {
196  ATH_MSG_INFO( " HIJING Ending. \n" );
197  return StatusCode::SUCCESS;
198 }
199 
200 StatusCode
201 Hijing::fillEvt(HepMC::GenEvent* evt)
202 {
203  // These two parameters need to be made user settable (done - AS)
204  //
205  MsgStream log(msgSvc(), name());
206  ATH_MSG_INFO( " HIJING Filing. \n" );
207 
208  // Set the event number
209  evt->set_event_number( m_events );
210 
211  // Set the random generator seeds
212  HepMC::set_random_states(evt,m_seeds);
213 
214  // Set the generator id
215  HepMC::set_signal_process_id(evt,50000000 + m_iap);
216 
217  // Store collision parameters
218  int np = m_himain1.np();
219  int nt = m_himain1.nt();
220  int n0 = m_himain1.n0();
221  int n01 = m_himain1.n01();
222  int n10 = m_himain1.n10();
223  int n11 = m_himain1.n11();
224  //int natt = m_himain1.natt();
225  int jatt = m_himain1.jatt();
226  float b = m_hiparnt.hint1(19);
227  float bphi = m_hiparnt.hint1(20);
228 
229  float sigmainel = m_hiparnt.hint1(12);
230 
231  #ifdef HEPMC3
232  HepMC::GenHeavyIonPtr ion= std::make_shared<HepMC::GenHeavyIon>();
233  ion->Ncoll_hard=static_cast<int>(jatt);
234  ion->Npart_proj=static_cast<int>(np);
235  ion->Npart_targ=static_cast<int>(nt);
236  ion->Ncoll=static_cast<int>(n0+n10+n01+n11);
237  ion->N_Nwounded_collisions=static_cast<int>(n01);
238  ion->Nwounded_N_collisions=static_cast<int>(n10);
239  ion->Nwounded_Nwounded_collisions=static_cast<int>(n11);
240  ion->spectator_neutrons=-1;
241  ion->spectator_protons=-1;
242  ion->impact_parameter= b;
243  ion->event_plane_angle=bphi;
244  ion->event_plane_angle=-1;
245  ion->sigma_inel_NN=sigmainel;
246  evt->set_heavy_ion(std::move(ion));
247 #else
248  HepMC::HeavyIon ion
249  (
250  static_cast<int>(jatt), // Ncoll_hard
251  static_cast<int>(np), // Npart_proj
252  static_cast<int>(nt), // Npart_targ
253  static_cast<int>(n0+n10+n01+n11), // Ncoll
254  static_cast<int>(-1), // spectator_neutrons
255  static_cast<int>(-1), // spectator_protons
256  static_cast<int>(n01), // N_Nwounded_collisions
257  static_cast<int>(n10), // Nwounded_N_collisions
258  static_cast<int>(n11), // Nwounded_Nwounded_collisions
259  b, // impact_parameter
260  bphi, // event_plane_angle
261  -1, // eccentricity
262  sigmainel ); // sigma_inel_NN
263 
264  evt->set_heavy_ion(std::move(ion));
265  std::cout << " heavy ion " << evt->heavy_ion() << std::endl;
266 #endif
267 
268  // Did we keep decay history?
269  //
270  bool keptHistory = (m_hiparnt.ihpr2(21) == 1);
271 
272  // The number of particles in the hijing output
273  //
274  int numHijingPart = m_himain1.natt();
275 
276  // Vectors that will keep track of where particles originate from and die
277  //
278  std::vector<int> partOriginVertex_vec(numHijingPart, 0);
279  std::vector<int> partDecayVertex_vec(numHijingPart, -1);
280  std::vector<HepMC::GenParticlePtr> particleHepPartPtr_vec(numHijingPart, nullptr);
281 
282  // Vector that will keep pointers to generated vertices
283  //
284  std::vector<HepMC::GenVertexPtr> vertexPtrVec;
285 
286  // Create the event vertex
287  //
288  CLHEP::HepLorentzVector newVertex;
289  newVertex = CLHEP::HepLorentzVector(0.,0.,0.,0.);
290 
291  if( m_rand )newVertex = randomizeVertex(p_Engine); // Create a random vertex along the pipe
292  else if(m_sel) newVertex = CLHEP::HepLorentzVector(m_x, m_y, m_z, 0.); // Create vertex at selected point - preempted by m_rand
293 
294  HepMC::GenVertexPtr v1 = HepMC::newGenVertexPtr(HepMC::FourVector(newVertex.x(),newVertex.y(),newVertex.z(),newVertex.t()));
295 
296  HepMC::set_signal_process_vertex(evt,v1);
297  vertexPtrVec.push_back(v1);
298 
299  double eproj = (double) m_efrm;
300  if ( m_frame == "CMS " ) eproj = eproj / 2.;
301 
302  int proj_id = 2212;
303  if ( m_proj == "PBAR " ) {
304  proj_id = -2212;
305  } else if ( m_proj == "N " ) {
306  proj_id = 2112;
307  } else if ( m_proj == "NBAR " ) {
308  proj_id = -2112;
309  } else if ( m_proj == "PI+ " ) {
310  proj_id = 211;
311  } else if ( m_proj == "PI- " ) {
312  proj_id = -211;
313  } else if ( m_proj == "A " ) {
314  proj_id = 3000000 + m_iap;
315  }
316  HepMC::GenParticlePtr part_p = HepMC::newGenParticlePtr(HepMC::FourVector(0., 0., eproj, eproj), proj_id, 101 );
317  v1->add_particle_in( part_p );
318 
319  double etarg = 0.;
320  if ( m_frame == "CMS " ) etarg = ( (double) m_efrm ) / 2.;
321 
322  int targ_id = 2212;
323  if ( m_targ == "PBAR " ) {
324  targ_id = -2212;
325  } else if ( m_targ == "N " ) {
326  targ_id = 2112;
327  } else if ( m_targ == "NBAR " ) {
328  targ_id = -2112;
329  } else if ( m_targ == "PI+ " ) {
330  targ_id = 211;
331  } else if ( m_targ == "PI- " ) {
332  targ_id = -211;
333  } else if ( m_targ == "A " ) {
334  targ_id = 3000000 + m_iat;
335  }
336  HepMC::GenParticlePtr part_t = HepMC::newGenParticlePtr(HepMC::FourVector(0., 0., -etarg, etarg), targ_id, 102 );
337  v1->add_particle_in( part_t );
338 
339  evt->set_beam_particles(std::move(part_p),std::move(part_t));
340 
341  ATH_MSG_DEBUG( "Hijing particles for event # " << m_events << ":\n"
342  << " px, "
343  << " py, "
344  << " pz, "
345  << " Id, "
346  << " Source, "
347  << " Parent, "
348  << " Status, " );
349 
350  bool inconsistency = false;
351 
352  // Loop on all Hijing particles and put them all as outgoing from the event vertex
353  //
354  for (int i = 1; i <= m_himain1.natt(); ++i)
355  {
356  // Skip non-interacting projectile and target nucleons
357  //
358  if (!m_spec && ((m_himain2.katt(i, 2) == 0) || (m_himain2.katt(i, 2)) == 10)) continue;
359 
360  // Find the vertex of the parent particle
361  //
362  int parentIndex = m_himain2.katt(i, 3) - 1;
363  int parentOriginIndex = 0;
364  int parentDecayIndex = -1;
365 
366  // If the particle has a true parent, record its vertex info
367  //
368  if (parentIndex >= 0)
369  {
370  parentOriginIndex = partOriginVertex_vec[parentIndex];
371  parentDecayIndex = partDecayVertex_vec[parentIndex];
372  }
373 
374  // A CLHEP vector containing the particle start point
375  //
376  // If the particle has been shifted, offset the particleStart accordingly
377  //
378  if( m_rand || m_sel ){ // Either way, we need to shift the particle vertex
379  m_himain2.vatt(i,1) += newVertex(0);
380  m_himain2.vatt(i,2) += newVertex(1);
381  m_himain2.vatt(i,3) += newVertex(2);
382  m_himain2.vatt(i,4) += newVertex(3);
383  }
384 
385  ATH_MSG_DEBUG( std::fixed << std::setprecision(2)
386  << std::setw(5) << i << ","
387  << std::setw(7) << m_himain2.patt(i, 1) << ", "
388  << std::setw(7) << m_himain2.patt(i, 2) << ", "
389  << std::setw(7) << m_himain2.patt(i, 3) << ", "
390  << std::setw(7) << m_himain2.katt(i, 1) << ", "
391  << std::setw(7) << m_himain2.katt(i, 2) << ", "
392  << std::setw(7) << m_himain2.katt(i, 3) << ", "
393  << std::setw(7) << m_himain2.katt(i, 4) << ", "
394  << std::setw(7) << m_himain2.vatt(i, 1) << ", "
395  << std::setw(7) << m_himain2.vatt(i, 2) << ", "
396  << std::setw(7) << m_himain2.vatt(i, 3) );
397 
398  CLHEP::HepLorentzVector particleStart(m_himain2.vatt(i, 1), m_himain2.vatt(i, 2),
399  m_himain2.vatt(i, 3), m_himain2.vatt(i, 4));
400 
401  // By default, the particle originates from the primary vertex
402  //
403  int particleVertexIndex = 0;
404 
405  // Have we kept the history?
406  //
407  if (keptHistory)
408  {
409  // Check to see if we've already generated a decay vertex for this parent
410  //
411  // std::cout << "ML-> keptHistory == True" << std::endl;
412  if (parentDecayIndex != -1)
413  {
414  // Make sure it is consistent with this track origin
415  //
416  HepGeom::Point3D<double> vertex_pos(vertexPtrVec[parentDecayIndex]->position().x(),
417  vertexPtrVec[parentDecayIndex]->position().y(),
418  vertexPtrVec[parentDecayIndex]->position().z());
419  double distance = vertex_pos.distance(particleStart.vect());
420 
421  //std::cout << "ML-> distance = " << distance <<" parentDecayIndex = "<<parentDecayIndex<< std::endl;
422  if (distance > m_vertexOffsetCut)
423  {
424  // We have an inconsistency, print a message
425  //
426  ATH_MSG_WARNING( " Inconsistency in Hijing particle vertexing, particle # " << i
427  << " starting point (x,y,z) = ("
428  << particleStart.x() << ", "
429  << particleStart.y() << ", "
430  << particleStart.z() << ") "
431  << " a distance " << distance << " away from parent decay point " );
432 
433 
434  // Dump the parent decay vertex
435  //
436  log << MSG::WARNING << " Parent decay vertex: (x,y,z) = " << vertexPtrVec[parentDecayIndex]->position().x()
437  << ", " << vertexPtrVec[parentDecayIndex]->position().y()
438  << ", " << vertexPtrVec[parentDecayIndex]->position().z()
439  << ", associated daughter IDs = ";
440 
441 #ifdef HEPMC3
442  auto vertexPtrVec_particles_out_const_begin=vertexPtrVec[parentDecayIndex]->particles_out().begin();
443  auto vertexPtrVec_particles_out_const_end=vertexPtrVec[parentDecayIndex]->particles_out().end();
444 #else
445  auto vertexPtrVec_particles_out_const_begin=vertexPtrVec[parentDecayIndex]->particles_out_const_begin();
446  auto vertexPtrVec_particles_out_const_end=vertexPtrVec[parentDecayIndex]->particles_out_const_end();
447 #endif
448  for (auto iter = vertexPtrVec_particles_out_const_begin;
449  iter != vertexPtrVec_particles_out_const_end;
450  iter++)
451  {
452  log << (*iter) << ", ";
453  }
454 
455  log << endmsg;
456  inconsistency = true;
457  }
458 
459  // Nonetheless set the parent decay vertex to be this particle's vertex
460  //
461  particleVertexIndex = parentDecayIndex;
462  }
463  else
464  {
465  // Now compare the distance between the vertex FROM which the parent originates and the
466  // start of this particle
467  //
468  HepGeom::Point3D<double> vertex_pos(vertexPtrVec[parentOriginIndex]->position().x(),
469  vertexPtrVec[parentOriginIndex]->position().y(),
470  vertexPtrVec[parentOriginIndex]->position().z());
471  double distance = vertex_pos.distance(particleStart.vect());
472 
473  if (distance > m_vertexOffsetCut && parentIndex == -1)
474  {
475  // *** Explicitly handle Hijing bug which generates particle with displaced vertex
476  // *** but no parent ????
477  //
478 
479  ATH_MSG_WARNING( "HIJING BUG:: Particle found with displaced vertex but no parent " );
480  ATH_MSG_WARNING( " Particle parameters: " << std::fixed << std::setprecision(2)
481  << std::setw(5) << i << ","
482  << std::setw(7) << m_himain2.patt(i, 1) << ", "
483  << std::setw(7) << m_himain2.patt(i, 2) << ", "
484  << std::setw(7) << m_himain2.patt(i, 3) << ", "
485  << std::setw(7) << m_himain2.katt(i, 1) << ", "
486  << std::setw(7) << m_himain2.katt(i, 2) << ", "
487  << std::setw(7) << m_himain2.katt(i, 3) << ", "
488  << std::setw(7) << m_himain2.katt(i, 4) << ", "
489  << std::setw(7) << m_himain2.vatt(i, 1) << ", "
490  << std::setw(7) << m_himain2.vatt(i, 2) << ", "
491  << std::setw(7) << m_himain2.vatt(i, 3) );
492 
493  // Assign the particle to its parent's vertex
494  //
495  particleVertexIndex = parentOriginIndex;
496  //std::cout << "ML-> case 2 distane = " << distance <<" particleVertexIndex = "<<particleVertexIndex<< std::endl;
497  }
498  if( parentIndex!=-1 && ((distance > m_vertexOffsetCut || parentOriginIndex !=0) || m_keepAllDecayVertices ) )
499  {
500  // We need to create a new vertex
501  //
502  HepMC::GenVertexPtr newVertex_p = HepMC::newGenVertexPtr(HepMC::FourVector(particleStart.x(),particleStart.y(),particleStart.z(),particleStart.t()));
503  evt->add_vertex(newVertex_p);
504  vertexPtrVec.push_back(newVertex_p);
505  particleVertexIndex = vertexPtrVec.size() - 1;
506 
507  // Now we indicate that the parent has a decay vertex
508  //
509  partDecayVertex_vec[parentIndex] = particleVertexIndex;
510 
511  // Now tell the vertex about the particle that created it
512  //
513 
514  newVertex_p->add_particle_in(particleHepPartPtr_vec[parentIndex]);
515  }
516  else {
517  // Assign the particle to its parent's vertex
518  //
519  particleVertexIndex = parentOriginIndex;
520  }
521  }
522  }
523  else
524  {
525  // We have to brute-force search for a vertex that might match this particle
526  //
527  int foundVert = -1;
528  for (unsigned int ivert = 0; ivert < vertexPtrVec.size(); ivert++)
529  {
530 
531  HepGeom::Point3D<double> vertex_pos(vertexPtrVec[ivert]->position().x(),
532  vertexPtrVec[ivert]->position().y(),
533  vertexPtrVec[ivert]->position().z());
534  double distance = vertex_pos.distance(particleStart.vect());
535  if (distance < m_vertexOffsetCut)
536  {
537  foundVert = ivert;
538  break;
539  }
540  }
541 
542  if (foundVert == -1)
543  {
544  // We need to create a new vertex
545  //
546  HepMC::GenVertexPtr newVertex_p = HepMC::newGenVertexPtr(HepMC::FourVector(particleStart.x(),particleStart.y(),particleStart.z(),particleStart.t()));
547 
548  evt->add_vertex(newVertex_p);
549  vertexPtrVec.push_back(std::move(newVertex_p));
550  particleVertexIndex = vertexPtrVec.size() - 1;
551  }
552  else
553  {
554  particleVertexIndex = foundVert;
555  }
556  //std::cout << "ML-> case 3 particleVertexIndex = "<<particleVertexIndex<< std::endl;
557  }
558 
559  // If the Hijing particle has decayed, set the status appropriately
560  //
561  int particleId = m_himain2.katt(i, 1);
562  int particleStatus = 1;
563  if (m_himain2.katt(i, 4) == 11) particleStatus = 2;
564 
565  // Create the new particle
566  //
567  HepMC::FourVector particleP4(m_himain2.patt(i, 1),
568  m_himain2.patt(i, 2),
569  m_himain2.patt(i, 3),
570  m_himain2.patt(i, 4));
571 
572  HepMC::GenParticlePtr newParticle_p = HepMC::newGenParticlePtr(particleP4, particleId,
573  particleStatus);
574 
575  // Record the particle in the vector of pointers
576  // (ostensibly we only need this when we have the
577  // history but for simplicity always do it)
578  //
579  particleHepPartPtr_vec[i-1] = newParticle_p;
580 
581  // Now add the particle to its vertex
582  //
583  vertexPtrVec[particleVertexIndex]->add_particle_out(std::move(newParticle_p));
584  partOriginVertex_vec[i-1] = particleVertexIndex;
585 
586  }
587 
588  if (inconsistency)
589  {
590  for (int i = 1; i <= m_himain1.natt(); ++i)
591  {
592  // Skip non-interacting projectile and target nucleons
593  //
594  if (!m_spec && ((m_himain2.katt(i, 2) == 0) || (m_himain2.katt(i, 2)) == 10)) continue;
595 
596  ATH_MSG_WARNING( " Hijing.cxx inconsistency: " << std::fixed << std::setprecision(2)
597  // std::cout << std::fixed << std::setprecision(2)
598  << std::setw(5) << i << ","
599  << std::setw(7) << m_himain2.patt(i, 1) << ", "
600  << std::setw(7) << m_himain2.patt(i, 2) << ", "
601  << std::setw(7) << m_himain2.patt(i, 3) << ", "
602  << std::setw(7) << m_himain2.katt(i, 1) << ", "
603  << std::setw(7) << m_himain2.katt(i, 2) << ", "
604  << std::setw(7) << m_himain2.katt(i, 3) << ", "
605  << std::setw(7) << m_himain2.katt(i, 4) << ", "
606  << std::setw(7) << m_himain2.vatt(i, 1) << ", "
607  << std::setw(7) << m_himain2.vatt(i, 2) << ", "
608  << std::setw(7) << m_himain2.vatt(i, 3) );
609  }
610  }
611 
612  // Generate documentation lines for high-pt partons
613  //
614  for (int isg = 1; isg <= m_hijjet2.nsg(); isg++)
615  {
616  for (int jparton = 1; jparton <= m_hijjet2.njsg(isg); jparton++)
617  {
618  double px = m_hijjet2.pxsg(isg, jparton);
619  double py = m_hijjet2.pysg(isg, jparton);
620  double pz = m_hijjet2.pzsg(isg, jparton);
621  double mass = m_hijjet2.pmsg(isg, jparton);
622 
623  double ptsq = px*px + py*py;
624  double e = std::sqrt(ptsq + pz*pz + mass*mass);
625  double mt = std::sqrt(ptsq + mass*mass);
626  double pt = std::sqrt(ptsq);
627 
628  double pseud = 0.5*std::log((e + pz)/(e - pz));
629 
630  int partonId = m_hijjet2.k2sg(isg, jparton);
631 
632  if (mt > m_partonStoreMinPt)
633  {
634  ATH_MSG_DEBUG( "hijjet2 entry: isg = " << isg
635  << ", pt = " << pt
636  << ", mt = " << mt
637  << ", eta = " << pseud );
638 
639  // Add aaa non-tracked entry in the hepmc event with status code 103 (temporary)
640  //
641  v1->add_particle_out( HepMC::newGenParticlePtr( HepMC::FourVector(px, py, pz, e), partonId, 103 ) );
642  }
643  }
644  }
645 
646  // Generate documentation lines for high-pt partons
647  //
648  int iap = m_hiparnt.ihnt2(1); // # of projectile nucleons
649  int iat = m_hiparnt.ihnt2(3); // # of target nucleons
650 
651  for (int iproj = 1; iproj <= iap; iproj++)
652  {
653  for (int jparton = 1; jparton <= m_hijjet1.npj(iproj); jparton++)
654  {
655  double px = m_hijjet1.pjpx(iproj, jparton);
656  double py = m_hijjet1.pjpy(iproj, jparton);
657  double pz = m_hijjet1.pjpz(iproj, jparton);
658  double mass = m_hijjet1.pjpm(iproj, jparton);
659 
660  double ptsq = px*px + py*py;
661  double e = std::sqrt(ptsq + pz*pz + mass*mass);
662  double mt = std::sqrt(ptsq + mass*mass);
663  double pt = std::sqrt(ptsq);
664 
665  double pseud = 0.5*std::log((e + pz)/(e - pz));
666 
667  int partonId = m_hijjet1.kfpj(iproj, jparton);
668 
669  if (mt > m_partonStoreMinPt)
670  {
671  ATH_MSG_DEBUG( "hijjet1 entry: iproj = " << iproj
672  << ", pt = " << pt
673  << ", mt = " << mt
674  << ", eta = " << pseud );
675 
676  // Add aaa non-tracked entry in the hepmc event with status code 103 (temporary)
677  //
678  v1->add_particle_out( HepMC::newGenParticlePtr( HepMC::FourVector(px, py, pz, e), partonId, 103 ) );
679  }
680  }
681  }
682 
683  // Now for target nucleons
684  //
685  for (int itarg = 1; itarg <= iat; itarg++)
686  {
687  for (int jparton = 1; jparton <= m_hijjet1.ntj(itarg); jparton++)
688  {
689  double px = m_hijjet1.pjtx(itarg, jparton);
690  double py = m_hijjet1.pjty(itarg, jparton);
691  double pz = m_hijjet1.pjtz(itarg, jparton);
692  double mass = m_hijjet1.pjtm(itarg, jparton);
693 
694  double ptsq = px*px + py*py;
695  double e = std::sqrt(ptsq + pz*pz + mass*mass);
696  double mt = std::sqrt(ptsq + mass*mass);
697  double pt = std::sqrt(ptsq);
698 
699  double pseud = 0.5*std::log((e + pz)/(e - pz));
700 
701  int partonId = m_hijjet1.kftj(itarg, jparton);
702 
703  if (mt > m_partonStoreMinPt)
704  {
705  ATH_MSG_DEBUG( "hijjet1 entry: itarg = " << itarg
706  << ", pt = " << pt
707  << ", mt = " << mt
708  << ", eta = " << pseud );
709 
710  // Add aaa non-tracked entry in the hepmc event with status code 103 (temporary)
711  //
712  v1->add_particle_out( HepMC::newGenParticlePtr( HepMC::FourVector(px, py, pz, e), partonId, 103 ) );
713  }
714  }
715  }
716 
717  // Convert CLHEP::cm->CLHEP::mm and CLHEP::GeV->CLHEP::MeV
718  //
719  GeVToMeV(evt);
720 
721  //BPK-> Loop over the particles in the event, if p needs to be mirrored:
722  if( m_prand ){
723  HepMC::FourVector tmpmom(0.,0.,0.,0.);
724  double ranz = CLHEP::RandFlat::shoot(p_Engine);
725  // std::cout <<"random="<<ranz <<std::endl;
726  if (ranz < 0.5) {
727  // std::cout <<"flip="<<ranz <<std::endl;
728  for(auto pitr: *evt){
729  tmpmom= pitr->momentum();
730  tmpmom.setX(-tmpmom.x());
731  tmpmom.setY(-tmpmom.y());
732  tmpmom.setZ(-tmpmom.z());
733  tmpmom.setT(tmpmom.t());
734  pitr->set_momentum(tmpmom);
735  }
736  }
737  }
738  //BPK-<
739 
740  return StatusCode::SUCCESS;
741 }
742 
743 CLHEP::HepLorentzVector
744 Hijing::randomizeVertex(CLHEP::HepRandomEngine* engine)
745 {
746  // Check the range in Z for the correct pipe diameter
747  // Definitions of constants are in VertexShift.h
748 
749  using namespace VertexShift;
750 
751  double ranx, rany, xmax, ymax;
752  double ranz = CLHEP::RandFlat::shoot(engine, -Zmax, Zmax);
753  if( m_wide ){ // Allow the whole pipe
754  if( std::abs(ranz) < Start1 ) {
755  xmax = Xmin + Delta1;
756  ymax = xmax;
757  } else if( std::abs(ranz) < Start2 ) {
758  xmax = Xmin + Delta2;
759  ymax = xmax;
760  } else if( std::abs(ranz) < Start3 ) {
761  xmax = Xmin + Delta3;
762  ymax = xmax;
763  } else if ( std::abs(ranz) <= Envelope ){
764  xmax = Xmin;
765  ymax = xmax;
766  } else {
767  ATH_MSG_ERROR( "**** Hijing::randomizeVertex() " << ranz << " (z) is outside the detector (units of mm). Returning a centered event." );
768  return CLHEP::HepLorentzVector(0.,0.,0.,0.);
769  }
770  } else {
771  ATH_MSG_INFO( "New Coordinates: x=0., y=0., z=" << ranz );
772  return CLHEP::HepLorentzVector(0., 0., ranz, 0); // Allow distribution just along the beam (no "width", m_wide is false (default))
773  }
774  ranx = CLHEP::RandFlat::shoot(engine, -xmax, xmax);
775  rany = CLHEP::RandFlat::shoot(engine, -ymax, ymax);
776 
777  ATH_MSG_INFO( "New Coordinates: x=" << ranx << ", y=" << rany << ", z=" << ranz );
778 
779  return CLHEP::HepLorentzVector(ranx, rany, ranz, 0);
780 }
781 
782 void
783 Hijing::set_user_params (void)
784 {
785  // set up the DEFAULT input parameters to hijset: these can be changed by the user ...
786  m_efrm = 14000.;
787  m_frame = "CMS ";
788  m_proj = "P ";
789  m_targ = "P ";
790  m_iap = 1;
791  m_iat = 1;
792  m_izp = 1;
793  m_izt = 1;
794  // ... and to hijing
795  m_bmin = 0.;
796  m_bmax = 0.;
797 
798  // Set user Initialization parameters
799  for(CommandVector::iterator i = m_InitializeVector.begin(); i != m_InitializeVector.end(); ++i )
800  {
801  ATH_MSG_INFO( " Hijing init. Command is: " << *i );
802  StringParse mystring(*i);
803  std::string myparam = mystring.piece<std::string>(1);
804  if (myparam == "efrm")
805  {
806  m_efrm = mystring.piece<double>(2);
807  }
808  else if (myparam == "frame")
809  {
810  m_frame = mystring.piece<std::string>(2);
811  if (m_frame.size() < 8)
812  {
813  unsigned nbl = 8 - m_frame.size();
814  for (unsigned i = 0; i < nbl; ++i) m_frame += ' ';
815  }
816  }
817  else if (myparam == "proj")
818  {
819  m_proj = mystring.piece<std::string>(2);
820  if (m_proj.size() < 8)
821  {
822  unsigned nbl = 8 - m_proj.size();
823  for (unsigned i = 0; i < nbl; ++i) m_proj += ' ';
824  }
825  }
826  else if (myparam == "targ")
827  {
828  m_targ = mystring.piece<std::string>(2);
829  if (m_targ.size() < 8)
830  {
831  unsigned nbl = 8 - m_targ.size();
832  for (unsigned i = 0; i < nbl; ++i) m_targ += ' ';
833  }
834  }
835  else if (myparam == "iap")
836  {
837  m_iap = mystring.piece<int>(2);
838  }
839  else if (myparam == "izp")
840  {
841  m_izp = mystring.piece<int>(2);
842  }
843  else if (myparam == "iat")
844  {
845  m_iat = mystring.piece<int>(2);
846  }
847  else if (myparam == "izt")
848  {
849  m_izt = mystring.piece<int>(2);
850  }
851  else if (myparam == "bmin")
852  {
853  m_bmin = mystring.piece<double>(2);
854  }
855  else if (myparam == "bmax")
856  {
857  m_bmax = mystring.piece<double>(2);
858  }
859  else if (myparam == "nseed")
860  {
861  m_ranseed.nseed() = mystring.piece<int>(2);
862  }
863  else if (myparam == "hipr1")
864  {
865  int myelem = mystring.piece<int>(2);
866  m_hiparnt.hipr1(myelem) = mystring.piece<double>(3);
867  }
868  else if (myparam == "ihpr2")
869  {
870  int myelem = mystring.piece<int>(2);
871  m_hiparnt.ihpr2(myelem) = mystring.piece<int>(3);
872  }
873  else if (myparam == "hint1")
874  {
875  int myelem = mystring.piece<int>(2);
876  m_hiparnt.hint1(myelem) = mystring.piece<double>(3);
877  }
878  else if (myparam == "ihnt2")
879  {
880  int myelem = mystring.piece<int>(2);
881  m_hiparnt.ihnt2(myelem) = mystring.piece<int>(3);
882  }
883  else
884  {
885  ATH_MSG_ERROR( " ERROR in HIJING INITIALIZATION PARAMETERS " << myparam << " is an invalid parameter !" );
886  }
887  }
888 }
HepMC::GenVertexPtr
HepMC::GenVertex * GenVertexPtr
Definition: GenVertex.h:59
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Envelope
Definition: IDetectorGeometryTool.h:17
Hijing::m_efrm
float m_efrm
Definition: Hijing.h:60
HijJet1::pjtz
float & pjtz(int i, int j)
Definition: HijJet1.h:201
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
Hijing::m_iap
int m_iap
Definition: Hijing.h:64
createLinkingScheme.iter
iter
Definition: createLinkingScheme.py:62
VertexShift::Zmax
const float Zmax
Definition: VertexShift.h:26
StringParse
Utility object for parsing a string into tokens and returning them as a variety of types.
Definition: StringParse.h:33
Hijing::m_frame
std::string m_frame
Definition: Hijing.h:61
HiMain1::n10
int & n10(void)
Definition: HiMain1.h:139
GenEvent.h
test_pyathena.px
px
Definition: test_pyathena.py:18
HiParnt::hint1
float & hint1(int n)
Definition: HiParnt.h:94
VertexShift::Start1
const float Start1
Definition: VertexShift.h:36
HiMain2::katt
int & katt(int i, int j)
Definition: HiMain2.h:82
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Hijing::m_targ
std::string m_targ
Definition: Hijing.h:63
Hijing::m_bmin
float m_bmin
Definition: Hijing.h:69
VertexShift::Start3
const float Start3
Definition: VertexShift.h:38
Base_Fragment.mass
mass
Definition: Sherpa_i/share/common/Base_Fragment.py:59
VertexShift::Xmin
const float Xmin
Definition: VertexShift.h:25
GenBase::GeVToMeV
void GeVToMeV(HepMC::GenEvent *evt)
Scale event energies/momenta by x 1000.
Definition: GenBase.cxx:58
HijJet2::njsg
int & njsg(int i)
Definition: HijJet2.h:98
VertexShift::Delta3
const float Delta3
Definition: VertexShift.h:31
HeavyIon.h
GenVertex.h
StringParse.h
HepMC::GenParticlePtr
GenParticle * GenParticlePtr
Definition: GenParticle.h:37
HiParnt::hipr1
float & hipr1(int n)
Definition: HiParnt.h:78
Hijing::fillEvt
virtual StatusCode fillEvt(HepMC::GenEvent *evt) override
For filling the HepMC event object.
Definition: Hijing.cxx:201
Hijing::m_proj
std::string m_proj
Definition: Hijing.h:62
HijJet1::pjpz
float & pjpz(int i, int j)
Definition: HijJet1.h:133
test_pyathena.pt
pt
Definition: test_pyathena.py:11
Hijing::m_iat
int m_iat
Definition: Hijing.h:65
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
VertexShift
Definition: VertexShift.h:23
Hijing::m_spec
bool m_spec
Definition: Hijing.h:78
HiMain1::n0
int & n0(void)
Definition: HiMain1.h:125
Hijing::m_event_paramsKey
SG::WriteHandleKey< HijingEventParams > m_event_paramsKey
Definition: Hijing.h:117
PlotPulseshapeFromCool.np
np
Definition: PlotPulseshapeFromCool.py:64
HijJet1::pjty
float & pjty(int i, int j)
Definition: HijJet1.h:191
x
#define x
GenParticle.h
Hijing::m_y
float m_y
Definition: Hijing.h:75
Hijing::m_InitializeVector
CommandVector m_InitializeVector
Definition: Hijing.h:98
HijJet1::pjtx
float & pjtx(int i, int j)
Definition: HijJet1.h:181
Hijing::m_hijjet1
HijJet1 m_hijjet1
Definition: Hijing.h:109
Hijing::genInitialize
virtual StatusCode genInitialize() override
For initializing the generator, if required.
Definition: Hijing.cxx:85
Hijing::genFinalize
virtual StatusCode genFinalize() override
For finalising the generator, if required.
Definition: Hijing.cxx:194
HiMain1::natt
int & natt(void)
Definition: HiMain1.h:90
Hijing::m_wide
bool m_wide
Definition: Hijing.h:82
GenModule
Base class for common behaviour of generator interfaces.
Definition: GenModule.h:39
VertexShift::Delta2
const float Delta2
Definition: VertexShift.h:30
HijJet2::pmsg
float & pmsg(int i, int j)
Definition: HijJet2.h:176
atl_ran_
float atl_ran_(int *)
Definition: Hijing.cxx:49
Hijing::m_events
int m_events
Definition: Hijing.h:95
StringParse::piece
T piece(size_t num) const
Templated function to get the num'th token as any numeric type.
Definition: StringParse.h:44
HepMC::set_signal_process_vertex
void set_signal_process_vertex(GenEvent *e, T v)
Definition: GenEvent.h:651
Hijing::m_rand
bool m_rand
Definition: Hijing.h:81
HijJet1::ntj
int & ntj(int i)
Definition: HijJet1.h:163
RanSeed::nseed
int & nseed(void)
Definition: RanSeed.h:51
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Hijing::randomizeVertex
virtual CLHEP::HepLorentzVector randomizeVertex(CLHEP::HepRandomEngine *engine)
Definition: Hijing.cxx:744
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
HiMain2::patt
float & patt(int i, int j)
Definition: HiMain2.h:92
HijJet2::nsg
int & nsg(void)
Definition: HijJet2.h:91
Hijing::m_hiparnt
HiParnt m_hiparnt
Definition: Hijing.h:101
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
z
#define z
Hijing::m_bmax
float m_bmax
Definition: Hijing.h:70
Hijing::m_prand
bool m_prand
Definition: Hijing.h:83
HijJet1::kftj
int & kftj(int i, int j)
Definition: HijJet1.h:171
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
HijJet2::pxsg
float & pxsg(int i, int j)
Definition: HijJet2.h:136
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
HiMain1::jatt
int & jatt(void)
Definition: HiMain1.h:104
Hijing::m_himain2
HiMain2 m_himain2
Definition: Hijing.h:108
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
HiMain1::ierrstat
int & ierrstat(void)
Definition: HiMain1.h:153
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
Hijing::m_seeds
std::vector< long int > m_seeds
Definition: Hijing.h:92
Hijing::m_sel
bool m_sel
Definition: Hijing.h:77
HijJet1::kfpj
int & kfpj(int i, int j)
Definition: HijJet1.h:103
make_coralServer_rep.proj
proj
Definition: make_coralServer_rep.py:48
Hijing::Hijing
Hijing(const std::string &name, ISvcLocator *pSvcLocator)
Definition: Hijing.cxx:68
Hijing::m_vertexOffsetCut
double m_vertexOffsetCut
Definition: Hijing.h:88
HijJet2::pysg
float & pysg(int i, int j)
Definition: HijJet2.h:146
Amg::py
@ py
Definition: GeoPrimitives.h:39
Hijing::callGenerator
virtual StatusCode callGenerator() override
For calling the generator on each iteration of the event loop.
Definition: Hijing.cxx:135
HiParnt::ihpr2
int & ihpr2(int n)
Definition: HiParnt.h:86
HijJet1::pjpy
float & pjpy(int i, int j)
Definition: HijJet1.h:123
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
VertexShift::Start2
const float Start2
Definition: VertexShift.h:37
HiMain2::vatt
float & vatt(int i, int j)
Definition: HiMain2.h:102
Hijing::m_izt
int m_izt
Definition: Hijing.h:67
RNGWrapper.h
HiMain1::n11
int & n11(void)
Definition: HiMain1.h:146
Hijing::m_keepAllDecayVertices
bool m_keepAllDecayVertices
Definition: Hijing.h:84
SG::WriteHandle< HijingEventParams >
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
HiMain1::nt
int & nt(void)
Definition: HiMain1.h:111
y
#define y
Hijing::m_partonStoreMinPt
double m_partonStoreMinPt
Definition: Hijing.h:87
hijset_
void hijset_(float *, const char *, const char *, const char *, int *, int *, int *, int *, long int, long int, long int)
HijJet1::pjpm
float & pjpm(int i, int j)
Definition: HijJet1.h:153
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Hijing::m_izp
int m_izp
Definition: Hijing.h:66
GenModule::m_randomSeed
IntegerProperty m_randomSeed
Seed for random number engine.
Definition: GenModule.h:84
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
xmax
double xmax
Definition: listroot.cxx:61
HiMain1::np
int & np(void)
Definition: HiMain1.h:118
ATHRNG::calculateSeedsMC21
void calculateSeedsMC21(long *seeds, const std::string &algName, uint64_t ev, uint64_t run, uint64_t offset=0)
Set the random seed using a string (e.g.
Definition: RNGWrapper.cxx:37
Hijing::m_x
float m_x
Definition: Hijing.h:74
Hijing::m_hijjet2
HijJet2 m_hijjet2
Definition: Hijing.h:110
Hijing::m_z
float m_z
Definition: Hijing.h:76
Hijing::m_himain1
HiMain1 m_himain1
Definition: Hijing.h:107
HiParnt::ihnt2
int & ihnt2(int n)
Definition: HiParnt.h:103
beamspotnt.nt
def nt
Definition: bin/beamspotnt.py:1062
VertexShift::Delta1
const float Delta1
Definition: VertexShift.h:29
VertexShift.h
HijJet2::k2sg
int & k2sg(int i, int j)
Definition: HijJet2.h:126
HijJet2::pzsg
float & pzsg(int i, int j)
Definition: HijJet2.h:156
HepMC::set_signal_process_id
void set_signal_process_id(GenEvent *e, const int i)
Definition: GenEvent.h:642
HiMain1::n01
int & n01(void)
Definition: HiMain1.h:132
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
HijJet1::pjtm
float & pjtm(int i, int j)
Definition: HijJet1.h:221
Hijing::m_ranseed
RanSeed m_ranseed
Definition: Hijing.h:104
HijJet1::npj
int & npj(int i)
Definition: HijJet1.h:95
HijJet1::pjpx
float & pjpx(int i, int j)
Definition: HijJet1.h:113
Hijing::set_user_params
void set_user_params(void)
Definition: Hijing.cxx:783
GenModule::getRandomEngineDuringInitialize
CLHEP::HepRandomEngine * getRandomEngineDuringInitialize(const std::string &streamName, unsigned long int randomSeedOffset, unsigned int conditionsRun=1, unsigned int lbn=1) const
Definition: GenModule.cxx:53
hijing_
void hijing_(const char *, float *, float *, long int)
ymax
double ymax
Definition: listroot.cxx:64
Hijing::m_dsid
IntegerProperty m_dsid
Definition: Hijing.h:57
Hijing.h
HepMC::set_random_states
void set_random_states(GenEvent *e, std::vector< T > a)
Definition: GenEvent.h:648
Generated on Thu Oct 30 2025 21:10:59 for ATLAS Offline Software by   doxygen 1.8.18