ATLAS Offline Software
Loading...
Searching...
No Matches
Hijing Class Reference

#include <Hijing.h>

Inheritance diagram for Hijing:

Public Member Functions

virtual ~Hijing ()=default
virtual StatusCode genInitialize () override
 For initializing the generator, if required.
virtual StatusCode callGenerator () override
 For calling the generator on each iteration of the event loop.
virtual StatusCode genFinalize () override
 For finalising the generator, if required.
virtual StatusCode fillEvt (HepMC::GenEvent *evt) override
 For filling the HepMC event object.
 GenModule (const std::string &name, ISvcLocator *pSvcLocator)
 Constructor.
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual bool isClonable () const override
 Specify if the algorithm is clonable.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
virtual bool filterPassed (const EventContext &ctx) const
 Get filter decision:
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 Set filter decision:
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const
Event loop algorithm methods: not to be overloaded
StatusCode initialize ()
StatusCode execute (const EventContext &ctx)
 Execute method.
StatusCode finalize ()
Gen-specific event loop methods: to be overloaded
virtual StatusCode genuserInitialize ()
 For initialization of user code, if required. Called after genInitialize.
Event collection accessors (const and non-const)
HepMC::GenEvent *event ATLAS_NOT_CONST_THREAD_SAFE ()
 Access the current signal event (first in the McEventCollection).
McEventCollection *events ATLAS_NOT_CONST_THREAD_SAFE ()
 Access the current event's McEventCollection.
const HepMC::GenEvent * event_const (const EventContext &ctx) const
 Access the current signal event (const).
const McEventCollection * events_const (const EventContext &ctx) const
 Access the current event's McEventCollection (const).

Protected Member Functions

virtual CLHEP::HepLorentzVector randomizeVertex (CLHEP::HepRandomEngine *engine)
void set_user_params (void)
virtual bool isReEntrant () const override final
 Legacy algorithms are not thread-safe.
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Protected Attributes

IntegerProperty m_dsid {this, "Dsid", 999999}
float m_efrm {0.}
std::string m_frame
std::string m_proj
std::string m_targ
int m_iap {0}
int m_iat {0}
int m_izp {0}
int m_izt {0}
float m_bmin {0.}
float m_bmax {0.}
DoubleProperty m_x {this, "x", 0.}
DoubleProperty m_y {this, "y", 0.}
DoubleProperty m_z {this, "z", 0.}
BooleanProperty m_sel {this, "selectVertex", false}
BooleanProperty m_spec {this, "keepSpectators", true}
BooleanProperty m_rand {this, "randomizeVertices", false}
BooleanProperty m_wide {this, "wide", false}
BooleanProperty m_prand {this, "randomizeP", false}
BooleanProperty m_keepAllDecayVertices {this, "keepAllDecayVertices", true}
DoubleProperty m_partonStoreMinPt {this, "partonStoreMinPt", 5.0}
DoubleProperty m_vertexOffsetCut {this, "vertexOffsetCut", 1.0E-7}
int m_randomseed {0}
std::vector< long int > m_seeds
int m_events {0}
StringArrayProperty m_InitializeVector
HiParnt m_hiparnt
RanSeed m_ranseed
HiMain1 m_himain1
HiMain2 m_himain2
HijJet1 m_hijjet1
HijJet2 m_hijjet2
HijJet4 m_hijjet4
HiStrng m_histrng
HijCrdn m_hijcrdn
SG::WriteHandleKey< HijingEventParams > m_event_paramsKey {this, "HijingOutputKey", "Hijing_event_params"}

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Features for derived classes to use internally

IntegerProperty m_randomSeed {this, "RandomSeed", 1234567, "Random seed for the built-in random engine"}
 Seed for random number engine.
BooleanProperty m_isAfterburner {this, "IsAfterburner", false, "Set true if generator modifies existing events rather than creating new ones"}
 Flag for normal vs. afterburner generators.
std::shared_ptr< HepMC3::GenRunInfo > m_runinfo {}
 The run info for HepMC3.
CLHEP::HepRandomEngine * getRandomEngine (const std::string &streamName, const EventContext &ctx) const
CLHEP::HepRandomEngine * getRandomEngine (const std::string &streamName, unsigned long int randomSeedOffset, const EventContext &ctx) const
CLHEP::HepRandomEngine * getRandomEngineDuringInitialize (const std::string &streamName, unsigned long int randomSeedOffset, unsigned int conditionsRun=1, unsigned int lbn=1) const
ServiceHandle< IAthRNGSvc > m_rndmSvc {this, "RndmSvc", "AthRNGSvc"}
 Data members.
ServiceHandle< IIncidentSvc > m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}
 Handle on the incident service.

Properties

std::string m_mcEventKey {}
 StoreGate key for the MC event collection (defaults to GEN_EVENT).
BooleanProperty m_mkMcEvent {this, "MakeMcEvent", false, "Create a new MC event collection if it doesn't exist"}
 Flag to determine if a new MC event collection should be made if it doesn't exist.
SG::ReadHandleKey< McEventCollection > m_mcevents_const { this, "McEventKey", "GEN_EVENT", "StoreGate key of the MC event collection" }
 Const handle to the MC event collection.

Detailed Description

Definition at line 41 of file Hijing.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ~Hijing()

virtual Hijing::~Hijing ( )
virtualdefault

Member Function Documentation

◆ ATLAS_NOT_CONST_THREAD_SAFE() [1/2]

McEventCollection *events GenBase::ATLAS_NOT_CONST_THREAD_SAFE ( )
inherited

Access the current event's McEventCollection.

Note
This function will make a new McEventCollection if there is not already a valid one and MakeMcEvent=True.

◆ ATLAS_NOT_CONST_THREAD_SAFE() [2/2]

HepMC::GenEvent *event GenBase::ATLAS_NOT_CONST_THREAD_SAFE ( )
inlineinherited

Access the current signal event (first in the McEventCollection).

Note
This function will make a new McEventCollection if there is not already a valid one and MakeMcEvent=True.

Definition at line 72 of file GenBase.h.

72 {
73 if (events()->empty())
74 ATH_MSG_ERROR("McEventCollection is empty during first event access");
75 return *(events()->begin());
76 }
#define ATH_MSG_ERROR(x,...)
static const Attributes_t empty

◆ callGenerator()

StatusCode Hijing::callGenerator ( )
overridevirtual

For calling the generator on each iteration of the event loop.

Reimplemented from GenModule.

Definition at line 163 of file Hijing.cxx.

164{
165 ATH_MSG_INFO( " HIJING generating. \n" );
166
167 // Save the random number seeds in the event
168 //Re-seed the random number stream
169 long seeds[7];
170 const EventContext& ctx = Gaudi::Hive::currentContext();
171 ATHRNG::calculateSeedsMC21(seeds, hijing_stream, ctx.eventID().event_number(), m_dsid, m_randomSeed);
172 p_Engine->setSeeds(seeds, 0); // NOT THREAD-SAFE
173 m_seeds.clear();
174 m_seeds.push_back(seeds[0]);
175 m_seeds.push_back(seeds[1]);
176
177 // Generate event
178 ATH_MSG_DEBUG( "Generate event" );
179 const char* frame = m_frame.c_str();
180 hijing_(frame, &m_bmin, &m_bmax, strlen(frame));
181
182
183 ATH_MSG_DEBUG( "Check for error using the new (custom) error return" );
184 // Check for error using the new (custom) error return
185 //
186 int errorStatus = m_himain1.ierrstat();
187 if (errorStatus != 0) {
188 ATH_MSG_ERROR( "Error returned from HIJING, value = " << errorStatus );
189 return StatusCode::FAILURE;
190 }
191
192 // update event counter
193 ++m_events;
194
195 // store hijing event parameters
196 // -----------------------------
197 ATH_MSG_DEBUG( "New HijingEventParams" );
198 int np = m_himain1.np();
199 int nt = m_himain1.nt();
200 int n0 = m_himain1.n0();
201 int n01 = m_himain1.n01();
202 int n10 = m_himain1.n10();
203 int n11 = m_himain1.n11();
204 int natt = m_himain1.natt();
205 int jatt = m_himain1.jatt();
206 float b = m_hiparnt.hint1(19);
207 float bphi = m_hiparnt.hint1(20);
208
209 SG::WriteHandle<HijingEventParams> event_params(m_event_paramsKey);
210 event_params = std::make_unique<HijingEventParams>(np, nt, n0, n01, n10, n11, natt, jatt, b, bphi);
211
212 ATH_MSG_INFO( "\n=================================================\n"
213 << " HIJING event description: \n"
214 << " b = " << b << " fm \n"
215 << " # proj participants = " << np << "\n"
216 << " # targ participants = " << nt << "\n"
217 << " # final particles = " << natt << "\n"
218 << "=================================================\n" );
219
220 ATH_MSG_DEBUG( " HIJING generating done. \n" );
221 return StatusCode::SUCCESS;
222}
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_INFO(x,...)
void hijing_(const char *, float *, float *, long int)
IntegerProperty m_randomSeed
Seed for random number engine.
Definition GenModule.h:84
HiParnt m_hiparnt
Definition Hijing.h:104
float m_bmax
Definition Hijing.h:68
HiMain1 m_himain1
Definition Hijing.h:110
IntegerProperty m_dsid
Definition Hijing.h:55
float m_bmin
Definition Hijing.h:67
int m_events
Definition Hijing.h:94
std::vector< long int > m_seeds
Definition Hijing.h:91
SG::WriteHandleKey< HijingEventParams > m_event_paramsKey
Definition Hijing.h:120
std::string m_frame
Definition Hijing.h:59
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.

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl,
const SG::VarHandleKeyType &  )
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158 {
160 hndl.value(),
161 hndl.documentation());
162
163 }
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

◆ event_const()

const HepMC::GenEvent * GenBase::event_const ( const EventContext & ctx) const
inlineinherited

Access the current signal event (const).

Definition at line 79 of file GenBase.h.

79 {
80 const McEventCollection* coll = events_const(ctx);
81 if (coll->empty())
82 ATH_MSG_ERROR("Const McEventCollection is empty during first event access");
83 return *(coll->begin());
84 }
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
bool empty() const noexcept
Returns true if the collection is empty.
const McEventCollection * events_const(const EventContext &ctx) const
Access the current event's McEventCollection (const).
Definition GenBase.h:93

◆ events_const()

const McEventCollection * GenBase::events_const ( const EventContext & ctx) const
inlineinherited

Access the current event's McEventCollection (const).

Definition at line 93 of file GenBase.h.

93 {
94 SG::ReadHandle<McEventCollection> ret = SG::makeHandle(m_mcevents_const, ctx);
95 if (!ret.isValid())
96 ATH_MSG_ERROR("No McEventCollection found in StoreGate with key " << m_mcevents_const.key());
97 return ret.cptr();
98 }
SG::ReadHandleKey< McEventCollection > m_mcevents_const
Const handle to the MC event collection.
Definition GenBase.h:117
virtual bool isValid() override final
Can the handle be successfully dereferenced?
const_pointer_type cptr()
Dereference the pointer.
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

◆ execute()

StatusCode GenModule::execute ( const EventContext & ctx)
virtualinherited

Execute method.

Todo
Remove hard-coded alg name checking (already incomplete)

Reimplemented from GenBase.

Definition at line 70 of file GenModule.cxx.

70 {
71 // Examples of how to retrieve the random number engine for a given
72 // stream.
73 // NB getRandomEngine should only be called once per event for a
74 // given stream, as it causes the stream to be re-seeded each time
75 // it is called.
76
77 // Example 1 - seeded based on the current event number (+ slot, run, streamName)
78 //CLHEP::HepRandomEngine* rndmEngine = this->getRandomEngine("MyStream", ctx);
79
80 // Example 2 - seeded based on the m_randomSeed property (+ slot, run, streamName)
81 //CLHEP::HepRandomEngine* rndmEngine = this->getRandomEngine("MyStream", m_randomSeed.value(), ctx);
82
83 // Call the code that generates an event
84 CHECK(this->callGenerator());
85
86 // Create the MC event and send the GeneratorEvent stored in it to fillEvt
88 CHECK(this->fillEvt(evt));
90
91 // Add the event to the MC event collection
92 if (events()) {
93 // If this is an "afterburner" generator, replace the last event rather than add a new one
95 if (m_isAfterburner.value() || name() == "Tauola" || name() == "Photos") {
96 events()->pop_back();
97 }
98 // Add the event to the end of the collection
99 events()->push_back(evt);
100 ATH_MSG_DEBUG("MC event added to McEventCollection");
101
102 // remove the empty event in case of ParticleDecayer
103 if (name() == "ParticleDecayer") {
104 events()->pop_back();
105 }
106 }
107
108 // Call the incident service to notify that an event has been made
109 m_incidentSvc->fireIncident( Incident(name(), "McEventGenerated") );
110 return StatusCode::SUCCESS;
111}
#define CHECK(...)
Evaluate an expression and check for errors.
ServiceHandle< IIncidentSvc > m_incidentSvc
Handle on the incident service.
Definition GenModule.h:99
virtual StatusCode callGenerator()
For calling the generator on each iteration of the event loop.
Definition GenModule.h:66
virtual StatusCode fillEvt(HepMC::GenEvent *evt)=0
For filling the HepMC event object.
BooleanProperty m_isAfterburner
Flag for normal vs. afterburner generators.
Definition GenModule.h:87
void fillBarcodesAttribute(GenEvent *e)
Definition GenEvent.h:396
GenEvent * newGenEvent(const int signal_process_id, const int event_number)
Definition GenEvent.h:363
HepMC3::GenEvent GenEvent
Definition GenEvent.h:39

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
59 }
61}
Common base class for algorithms.

◆ fillEvt()

StatusCode Hijing::fillEvt ( HepMC::GenEvent * evt)
overridevirtual

For filling the HepMC event object.

Implements GenModule.

Definition at line 235 of file Hijing.cxx.

236{
237 // These two parameters need to be made user settable (done - AS)
238 //
239 MsgStream log(msgSvc(), name());
240 ATH_MSG_INFO( " HIJING Filing. \n" );
241
242 // Set the event number
243 evt->set_event_number( m_events );
244
245 // Set the random generator seeds
247
248 // Set the generator id
249 HepMC::set_signal_process_id(evt,50000000 + m_iap);
250
251 // Store collision parameters
252 int np = m_himain1.np();
253 int nt = m_himain1.nt();
254 int n0 = m_himain1.n0();
255 int n01 = m_himain1.n01();
256 int n10 = m_himain1.n10();
257 int n11 = m_himain1.n11();
258 //int natt = m_himain1.natt();
259 int jatt = m_himain1.jatt();
260 float b = m_hiparnt.hint1(19);
261 float bphi = m_hiparnt.hint1(20);
262
263 float sigmainel = m_hiparnt.hint1(12);
264
265 HepMC::GenHeavyIonPtr ion= std::make_shared<HepMC::GenHeavyIon>();
266 ion->Ncoll_hard=static_cast<int>(jatt);
267 ion->Npart_proj=static_cast<int>(np);
268 ion->Npart_targ=static_cast<int>(nt);
269 ion->Ncoll=static_cast<int>(n0+n10+n01+n11);
270 ion->N_Nwounded_collisions=static_cast<int>(n01);
271 ion->Nwounded_N_collisions=static_cast<int>(n10);
272 ion->Nwounded_Nwounded_collisions=static_cast<int>(n11);
273 ion->spectator_neutrons=-1;
274 ion->spectator_protons=-1;
275 ion->impact_parameter= b;
276 ion->event_plane_angle=bphi;
277 ion->sigma_inel_NN=sigmainel;
278 evt->set_heavy_ion(std::move(ion));
279
280 // Did we keep decay history?
281 //
282 bool keptHistory = (m_hiparnt.ihpr2(21) == 1);
283
284 // The number of particles in the hijing output
285 //
286 int numHijingPart = m_himain1.natt();
287
288 // Vectors that will keep track of where particles originate from and die
289 //
290 std::vector<int> partOriginVertex_vec(numHijingPart, 0);
291 std::vector<int> partDecayVertex_vec(numHijingPart, -1);
292 std::vector<HepMC::GenParticlePtr> particleHepPartPtr_vec(numHijingPart, nullptr);
293
294 // Vector that will keep pointers to generated vertices
295 //
296 std::vector<HepMC::GenVertexPtr> vertexPtrVec;
297
298 // Create the event vertex
299 //
300 CLHEP::HepLorentzVector newVertex;
301 newVertex = CLHEP::HepLorentzVector(0.,0.,0.,0.);
302
303 if( m_rand )newVertex = randomizeVertex(p_Engine); // Create a random vertex along the pipe
304 else if(m_sel) newVertex = CLHEP::HepLorentzVector(m_x, m_y, m_z, 0.); // Create vertex at selected point - preempted by m_rand
305
306 HepMC::GenVertexPtr v1 = HepMC::newGenVertexPtr(HepMC::FourVector(newVertex.x(),newVertex.y(),newVertex.z(),newVertex.t()));
307
309 vertexPtrVec.push_back(v1);
310
311 double eproj = (double) m_efrm;
312 if ( m_frame == "CMS " ) eproj = eproj / 2.;
313
314 int proj_id = 2212;
315 if ( m_proj == "PBAR " ) {
316 proj_id = -2212;
317 } else if ( m_proj == "N " ) {
318 proj_id = 2112;
319 } else if ( m_proj == "NBAR " ) {
320 proj_id = -2112;
321 } else if ( m_proj == "PI+ " ) {
322 proj_id = 211;
323 } else if ( m_proj == "PI- " ) {
324 proj_id = -211;
325 } else if ( m_proj == "A " ) {
326 proj_id = 3000000 + m_iap;
327 }
328 HepMC::GenParticlePtr part_p = HepMC::newGenParticlePtr(HepMC::FourVector(0., 0., eproj, eproj), proj_id, 101 );
329 v1->add_particle_in( part_p );
330
331 double etarg = 0.;
332 if ( m_frame == "CMS " ) etarg = ( (double) m_efrm ) / 2.;
333
334 int targ_id = 2212;
335 if ( m_targ == "PBAR " ) {
336 targ_id = -2212;
337 } else if ( m_targ == "N " ) {
338 targ_id = 2112;
339 } else if ( m_targ == "NBAR " ) {
340 targ_id = -2112;
341 } else if ( m_targ == "PI+ " ) {
342 targ_id = 211;
343 } else if ( m_targ == "PI- " ) {
344 targ_id = -211;
345 } else if ( m_targ == "A " ) {
346 targ_id = 3000000 + m_iat;
347 }
348 HepMC::GenParticlePtr part_t = HepMC::newGenParticlePtr(HepMC::FourVector(0., 0., -etarg, etarg), targ_id, 102 );
349 v1->add_particle_in( part_t );
350
351 evt->set_beam_particles(std::move(part_p),std::move(part_t));
352
353 ATH_MSG_DEBUG( "Hijing particles for event # " << m_events << ":\n"
354 << " px, "
355 << " py, "
356 << " pz, "
357 << " Id, "
358 << " Source, "
359 << " Parent, "
360 << " Status, " );
361
362 bool inconsistency = false;
363
364 // Loop on all Hijing particles and put them all as outgoing from the event vertex
365 //
366 for (int i = 1; i <= m_himain1.natt(); ++i)
367 {
368 // Skip non-interacting projectile and target nucleons
369 //
370 if (!m_spec && ((m_himain2.katt(i, 2) == 0) || (m_himain2.katt(i, 2)) == 10)) continue;
371
372 // Find the vertex of the parent particle
373 //
374 int parentIndex = m_himain2.katt(i, 3) - 1;
375 int parentOriginIndex = 0;
376 int parentDecayIndex = -1;
377
378 // If the particle has a true parent, record its vertex info
379 //
380 if (parentIndex >= 0)
381 {
382 parentOriginIndex = partOriginVertex_vec[parentIndex];
383 parentDecayIndex = partDecayVertex_vec[parentIndex];
384 }
385
386 // A CLHEP vector containing the particle start point
387 //
388 // If the particle has been shifted, offset the particleStart accordingly
389 //
390 if( m_rand || m_sel ){ // Either way, we need to shift the particle vertex
391 m_himain2.vatt(i,1) += newVertex(0);
392 m_himain2.vatt(i,2) += newVertex(1);
393 m_himain2.vatt(i,3) += newVertex(2);
394 m_himain2.vatt(i,4) += newVertex(3);
395 }
396
397 ATH_MSG_DEBUG( std::fixed << std::setprecision(2)
398 << std::setw(5) << i << ","
399 << std::setw(7) << m_himain2.patt(i, 1) << ", "
400 << std::setw(7) << m_himain2.patt(i, 2) << ", "
401 << std::setw(7) << m_himain2.patt(i, 3) << ", "
402 << std::setw(7) << m_himain2.katt(i, 1) << ", "
403 << std::setw(7) << m_himain2.katt(i, 2) << ", "
404 << std::setw(7) << m_himain2.katt(i, 3) << ", "
405 << std::setw(7) << m_himain2.katt(i, 4) << ", "
406 << std::setw(7) << m_himain2.vatt(i, 1) << ", "
407 << std::setw(7) << m_himain2.vatt(i, 2) << ", "
408 << std::setw(7) << m_himain2.vatt(i, 3) );
409
410 CLHEP::HepLorentzVector particleStart(m_himain2.vatt(i, 1), m_himain2.vatt(i, 2),
411 m_himain2.vatt(i, 3), m_himain2.vatt(i, 4));
412
413 // By default, the particle originates from the primary vertex
414 //
415 int particleVertexIndex = 0;
416
417 // Have we kept the history?
418 //
419 if (keptHistory)
420 {
421 // Check to see if we've already generated a decay vertex for this parent
422 //
423 // std::cout << "ML-> keptHistory == True" << std::endl;
424 if (parentDecayIndex != -1)
425 {
426 // Make sure it is consistent with this track origin
427 //
428 HepGeom::Point3D<double> vertex_pos(vertexPtrVec[parentDecayIndex]->position().x(),
429 vertexPtrVec[parentDecayIndex]->position().y(),
430 vertexPtrVec[parentDecayIndex]->position().z());
431 double distance = vertex_pos.distance(particleStart.vect());
432
433 //std::cout << "ML-> distance = " << distance <<" parentDecayIndex = "<<parentDecayIndex<< std::endl;
434 if (distance > m_vertexOffsetCut)
435 {
436 // We have an inconsistency, print a message
437 //
438 ATH_MSG_WARNING( " Inconsistency in Hijing particle vertexing, particle # " << i
439 << " starting point (x,y,z) = ("
440 << particleStart.x() << ", "
441 << particleStart.y() << ", "
442 << particleStart.z() << ") "
443 << " a distance " << distance << " away from parent decay point " );
444
445
446 // Dump the parent decay vertex
447 //
448 log << MSG::WARNING << " Parent decay vertex: (x,y,z) = " << vertexPtrVec[parentDecayIndex]->position().x()
449 << ", " << vertexPtrVec[parentDecayIndex]->position().y()
450 << ", " << vertexPtrVec[parentDecayIndex]->position().z()
451 << ", associated daughter IDs = ";
452
453 auto vertexPtrVec_particles_out_const_begin=vertexPtrVec[parentDecayIndex]->particles_out().begin();
454 auto vertexPtrVec_particles_out_const_end=vertexPtrVec[parentDecayIndex]->particles_out().end();
455 for (auto iter = vertexPtrVec_particles_out_const_begin;
456 iter != vertexPtrVec_particles_out_const_end;
457 iter++)
458 {
459 log << (*iter) << ", ";
460 }
461
462 log << endmsg;
463 inconsistency = true;
464 }
465
466 // Nonetheless set the parent decay vertex to be this particle's vertex
467 //
468 particleVertexIndex = parentDecayIndex;
469 }
470 else
471 {
472 // Now compare the distance between the vertex FROM which the parent originates and the
473 // start of this particle
474 //
475 HepGeom::Point3D<double> vertex_pos(vertexPtrVec[parentOriginIndex]->position().x(),
476 vertexPtrVec[parentOriginIndex]->position().y(),
477 vertexPtrVec[parentOriginIndex]->position().z());
478 double distance = vertex_pos.distance(particleStart.vect());
479
480 if (distance > m_vertexOffsetCut && parentIndex == -1)
481 {
482 // *** Explicitly handle Hijing bug which generates particle with displaced vertex
483 // *** but no parent ????
484 //
485
486 ATH_MSG_WARNING( "HIJING BUG:: Particle found with displaced vertex but no parent " );
487 ATH_MSG_WARNING( " Particle parameters: " << std::fixed << std::setprecision(2)
488 << std::setw(5) << i << ","
489 << std::setw(7) << m_himain2.patt(i, 1) << ", "
490 << std::setw(7) << m_himain2.patt(i, 2) << ", "
491 << std::setw(7) << m_himain2.patt(i, 3) << ", "
492 << std::setw(7) << m_himain2.katt(i, 1) << ", "
493 << std::setw(7) << m_himain2.katt(i, 2) << ", "
494 << std::setw(7) << m_himain2.katt(i, 3) << ", "
495 << std::setw(7) << m_himain2.katt(i, 4) << ", "
496 << std::setw(7) << m_himain2.vatt(i, 1) << ", "
497 << std::setw(7) << m_himain2.vatt(i, 2) << ", "
498 << std::setw(7) << m_himain2.vatt(i, 3) );
499
500 // Assign the particle to its parent's vertex
501 //
502 particleVertexIndex = parentOriginIndex;
503 //std::cout << "ML-> case 2 distane = " << distance <<" particleVertexIndex = "<<particleVertexIndex<< std::endl;
504 }
505 if( parentIndex!=-1 && ((distance > m_vertexOffsetCut || parentOriginIndex !=0) || m_keepAllDecayVertices ) )
506 {
507 // We need to create a new vertex
508 //
509 HepMC::GenVertexPtr newVertex_p = HepMC::newGenVertexPtr(HepMC::FourVector(particleStart.x(),particleStart.y(),particleStart.z(),particleStart.t()));
510 evt->add_vertex(newVertex_p);
511 vertexPtrVec.push_back(newVertex_p);
512 particleVertexIndex = vertexPtrVec.size() - 1;
513
514 // Now we indicate that the parent has a decay vertex
515 //
516 partDecayVertex_vec[parentIndex] = particleVertexIndex;
517
518 // Now tell the vertex about the particle that created it
519 //
520
521 newVertex_p->add_particle_in(particleHepPartPtr_vec[parentIndex]);
522 }
523 else {
524 // Assign the particle to its parent's vertex
525 //
526 particleVertexIndex = parentOriginIndex;
527 }
528 }
529 }
530 else
531 {
532 // We have to brute-force search for a vertex that might match this particle
533 //
534 int foundVert = -1;
535 for (unsigned int ivert = 0; ivert < vertexPtrVec.size(); ivert++)
536 {
537
538 HepGeom::Point3D<double> vertex_pos(vertexPtrVec[ivert]->position().x(),
539 vertexPtrVec[ivert]->position().y(),
540 vertexPtrVec[ivert]->position().z());
541 double distance = vertex_pos.distance(particleStart.vect());
542 if (distance < m_vertexOffsetCut)
543 {
544 foundVert = ivert;
545 break;
546 }
547 }
548
549 if (foundVert == -1)
550 {
551 // We need to create a new vertex
552 //
553 HepMC::GenVertexPtr newVertex_p = HepMC::newGenVertexPtr(HepMC::FourVector(particleStart.x(),particleStart.y(),particleStart.z(),particleStart.t()));
554
555 evt->add_vertex(newVertex_p);
556 vertexPtrVec.push_back(std::move(newVertex_p));
557 particleVertexIndex = vertexPtrVec.size() - 1;
558 }
559 else
560 {
561 particleVertexIndex = foundVert;
562 }
563 //std::cout << "ML-> case 3 particleVertexIndex = "<<particleVertexIndex<< std::endl;
564 }
565
566 // If the Hijing particle has decayed, set the status appropriately
567 //
568 int particleId = m_himain2.katt(i, 1);
569 int particleStatus = 1;
570 if (m_himain2.katt(i, 4) == 11) particleStatus = 2;
571
572 // Create the new particle
573 //
574 HepMC::FourVector particleP4(m_himain2.patt(i, 1),
575 m_himain2.patt(i, 2),
576 m_himain2.patt(i, 3),
577 m_himain2.patt(i, 4));
578
579 HepMC::GenParticlePtr newParticle_p = HepMC::newGenParticlePtr(particleP4, particleId,
580 particleStatus);
581
582 // Record the particle in the vector of pointers
583 // (ostensibly we only need this when we have the
584 // history but for simplicity always do it)
585 //
586 particleHepPartPtr_vec[i-1] = newParticle_p;
587
588 // Now add the particle to its vertex
589 //
590 vertexPtrVec[particleVertexIndex]->add_particle_out(std::move(newParticle_p));
591 partOriginVertex_vec[i-1] = particleVertexIndex;
592
593 }
594
595 if (inconsistency)
596 {
597 for (int i = 1; i <= m_himain1.natt(); ++i)
598 {
599 // Skip non-interacting projectile and target nucleons
600 //
601 if (!m_spec && ((m_himain2.katt(i, 2) == 0) || (m_himain2.katt(i, 2)) == 10)) continue;
602
603 ATH_MSG_WARNING( " Hijing.cxx inconsistency: " << std::fixed << std::setprecision(2)
604 // std::cout << std::fixed << std::setprecision(2)
605 << std::setw(5) << i << ","
606 << std::setw(7) << m_himain2.patt(i, 1) << ", "
607 << std::setw(7) << m_himain2.patt(i, 2) << ", "
608 << std::setw(7) << m_himain2.patt(i, 3) << ", "
609 << std::setw(7) << m_himain2.katt(i, 1) << ", "
610 << std::setw(7) << m_himain2.katt(i, 2) << ", "
611 << std::setw(7) << m_himain2.katt(i, 3) << ", "
612 << std::setw(7) << m_himain2.katt(i, 4) << ", "
613 << std::setw(7) << m_himain2.vatt(i, 1) << ", "
614 << std::setw(7) << m_himain2.vatt(i, 2) << ", "
615 << std::setw(7) << m_himain2.vatt(i, 3) );
616 }
617 }
618
619 // Generate documentation lines for high-pt partons
620 //
621 for (int isg = 1; isg <= m_hijjet2.nsg(); isg++)
622 {
623 for (int jparton = 1; jparton <= m_hijjet2.njsg(isg); jparton++)
624 {
625 double px = m_hijjet2.pxsg(isg, jparton);
626 double py = m_hijjet2.pysg(isg, jparton);
627 double pz = m_hijjet2.pzsg(isg, jparton);
628 double mass = m_hijjet2.pmsg(isg, jparton);
629
630 double ptsq = px*px + py*py;
631 double e = std::sqrt(ptsq + pz*pz + mass*mass);
632 double mt = std::sqrt(ptsq + mass*mass);
633 double pt = std::sqrt(ptsq);
634
635 double pseud = 0.5*std::log((e + pz)/(e - pz));
636
637 int partonId = m_hijjet2.k2sg(isg, jparton);
638
639 if (mt > m_partonStoreMinPt)
640 {
641 ATH_MSG_DEBUG( "hijjet2 entry: isg = " << isg
642 << ", pt = " << pt
643 << ", mt = " << mt
644 << ", eta = " << pseud );
645
646 // Add aaa non-tracked entry in the hepmc event with status code 103 (temporary)
647 //
648 v1->add_particle_out( HepMC::newGenParticlePtr( HepMC::FourVector(px, py, pz, e), partonId, 103 ) );
649 }
650 }
651 }
652
653 // Generate documentation lines for high-pt partons
654 //
655 int iap = m_hiparnt.ihnt2(1); // # of projectile nucleons
656 int iat = m_hiparnt.ihnt2(3); // # of target nucleons
657
658 for (int iproj = 1; iproj <= iap; iproj++)
659 {
660 for (int jparton = 1; jparton <= m_hijjet1.npj(iproj); jparton++)
661 {
662 double px = m_hijjet1.pjpx(iproj, jparton);
663 double py = m_hijjet1.pjpy(iproj, jparton);
664 double pz = m_hijjet1.pjpz(iproj, jparton);
665 double mass = m_hijjet1.pjpm(iproj, jparton);
666
667 double ptsq = px*px + py*py;
668 double e = std::sqrt(ptsq + pz*pz + mass*mass);
669 double mt = std::sqrt(ptsq + mass*mass);
670 double pt = std::sqrt(ptsq);
671
672 double pseud = 0.5*std::log((e + pz)/(e - pz));
673
674 int partonId = m_hijjet1.kfpj(iproj, jparton);
675
676 if (mt > m_partonStoreMinPt)
677 {
678 ATH_MSG_DEBUG( "hijjet1 entry: iproj = " << iproj
679 << ", pt = " << pt
680 << ", mt = " << mt
681 << ", eta = " << pseud );
682
683 // Add aaa non-tracked entry in the hepmc event with status code 103 (temporary)
684 //
685 v1->add_particle_out( HepMC::newGenParticlePtr( HepMC::FourVector(px, py, pz, e), partonId, 103 ) );
686 }
687 }
688 }
689
690 // Now for target nucleons
691 //
692 for (int itarg = 1; itarg <= iat; itarg++)
693 {
694 for (int jparton = 1; jparton <= m_hijjet1.ntj(itarg); jparton++)
695 {
696 double px = m_hijjet1.pjtx(itarg, jparton);
697 double py = m_hijjet1.pjty(itarg, jparton);
698 double pz = m_hijjet1.pjtz(itarg, jparton);
699 double mass = m_hijjet1.pjtm(itarg, jparton);
700
701 double ptsq = px*px + py*py;
702 double e = std::sqrt(ptsq + pz*pz + mass*mass);
703 double mt = std::sqrt(ptsq + mass*mass);
704 double pt = std::sqrt(ptsq);
705
706 double pseud = 0.5*std::log((e + pz)/(e - pz));
707
708 int partonId = m_hijjet1.kftj(itarg, jparton);
709
710 if (mt > m_partonStoreMinPt)
711 {
712 ATH_MSG_DEBUG( "hijjet1 entry: itarg = " << itarg
713 << ", pt = " << pt
714 << ", mt = " << mt
715 << ", eta = " << pseud );
716
717 // Add aaa non-tracked entry in the hepmc event with status code 103 (temporary)
718 //
719 v1->add_particle_out( HepMC::newGenParticlePtr( HepMC::FourVector(px, py, pz, e), partonId, 103 ) );
720 }
721 }
722 }
723
724 // Convert GeV -> MeV to ensure correct units
725 evt->set_units(HepMC3::Units::MEV, HepMC3::Units::MM);
726
727 //BPK-> Loop over the particles in the event, if p needs to be mirrored:
728 if( m_prand ){
729 HepMC::FourVector tmpmom(0.,0.,0.,0.);
730 double ranz = CLHEP::RandFlat::shoot(p_Engine);
731 // std::cout <<"random="<<ranz <<std::endl;
732 if (ranz < 0.5) {
733 // std::cout <<"flip="<<ranz <<std::endl;
734 for(auto pitr: *evt){
735 tmpmom= pitr->momentum();
736 tmpmom.setX(-tmpmom.x());
737 tmpmom.setY(-tmpmom.y());
738 tmpmom.setZ(-tmpmom.z());
739 tmpmom.setT(tmpmom.t());
740 pitr->set_momentum(tmpmom);
741 }
742 }
743 }
744 //BPK-<
745
746 double totalCsc = m_hiparnt.hint1(13) * Gaudi::Units::millibarn; // Get total cross-section in mb
747 auto csc = std::make_shared<HepMC3::GenCrossSection>();
748 csc->set_cross_section(totalCsc/Gaudi::Units::picobarn, 0.0); // Write cross-section in pb to HepMC
749 evt->set_cross_section(std::move(csc));
750
751 return StatusCode::SUCCESS;
752}
#define endmsg
#define ATH_MSG_WARNING(x,...)
#define y
#define x
#define z
std::string m_targ
Definition Hijing.h:61
std::string m_proj
Definition Hijing.h:60
int m_iat
Definition Hijing.h:63
HijJet1 m_hijjet1
Definition Hijing.h:112
DoubleProperty m_x
Definition Hijing.h:72
HijJet2 m_hijjet2
Definition Hijing.h:113
HiMain2 m_himain2
Definition Hijing.h:111
DoubleProperty m_vertexOffsetCut
Definition Hijing.h:87
BooleanProperty m_sel
Definition Hijing.h:75
float m_efrm
Definition Hijing.h:58
int m_iap
Definition Hijing.h:62
DoubleProperty m_y
Definition Hijing.h:73
BooleanProperty m_rand
Definition Hijing.h:79
DoubleProperty m_partonStoreMinPt
Definition Hijing.h:86
BooleanProperty m_keepAllDecayVertices
Definition Hijing.h:83
DoubleProperty m_z
Definition Hijing.h:74
virtual CLHEP::HepLorentzVector randomizeVertex(CLHEP::HepRandomEngine *engine)
Definition Hijing.cxx:755
BooleanProperty m_spec
Definition Hijing.h:76
BooleanProperty m_prand
Definition Hijing.h:82
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
HepMC3::FourVector FourVector
HepMC3::GenHeavyIonPtr GenHeavyIonPtr
Definition HeavyIon.h:11
void set_signal_process_vertex(GenEvent *e, T &v)
Definition GenEvent.h:594
void set_signal_process_id(GenEvent *e, const int i=0)
Definition GenEvent.h:583
void set_random_states(GenEvent *e, std::vector< long int > &a)
Definition GenEvent.h:591
GenParticlePtr newGenParticlePtr(const HepMC3::FourVector &mom=HepMC3::FourVector::ZERO_VECTOR(), int pid=0, int status=0)
Definition GenParticle.h:21
HepMC3::GenParticlePtr GenParticlePtr
Definition GenParticle.h:19
GenVertexPtr newGenVertexPtr(const HepMC3::FourVector &pos=HepMC3::FourVector::ZERO_VECTOR(), const int i=0)
Definition GenVertex.h:25
HepMC3::GenVertexPtr GenVertexPtr
Definition GenVertex.h:23
const Amg::Vector3D & position() const
Method to retrieve the position of the Intersection.

◆ filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx) const
inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

93 {
94 return execState( ctx ).filterPassed();
95 }
virtual bool filterPassed(const EventContext &ctx) const
Get filter decision:

◆ finalize()

StatusCode GenModule::finalize ( )
inlineinherited

Definition at line 55 of file GenModule.h.

55{ return genFinalize(); }
virtual StatusCode genFinalize()
For finalising the generator, if required.
Definition GenModule.h:70

◆ genFinalize()

StatusCode Hijing::genFinalize ( )
overridevirtual

For finalising the generator, if required.

Reimplemented from GenModule.

Definition at line 225 of file Hijing.cxx.

226{
227 ATH_MSG_INFO( "Adding HIJING cross-section to MetaData.\n" );
228 ATH_MSG_INFO( "MetaData: cross-section (mb) = " << m_hiparnt.hint1(13) );
229
230 ATH_MSG_INFO( " HIJING Ending. \n" );
231 return StatusCode::SUCCESS;
232}

◆ genInitialize()

StatusCode Hijing::genInitialize ( )
overridevirtual

For initializing the generator, if required.

Reimplemented from GenModule.

Definition at line 120 of file Hijing.cxx.

121{
122 ATH_CHECK(m_event_paramsKey.initialize());
123
124 // Initialisation of input parameters
125 ATH_MSG_INFO( "MetaData: generator = Hijing " << HIJINGVER );
126 ATH_MSG_INFO( "===> Hijing initialising \n" );
127 if( m_rand ){
128 ATH_MSG_INFO( "===> Vertex randomization ON." );
129 }
130 if( m_wide ){
131 ATH_MSG_INFO( "===> Vertex rand covers whole beampipe." );
132 }
133 //BPK
134 if( m_prand ) ATH_MSG_INFO( "===> Random Momentum Mirroring enabled" );
135 if( m_keepAllDecayVertices ) ATH_MSG_INFO( "===> Keeping all decay vertices" );
136 else ATH_MSG_INFO( "===> NOT keeping all decay vertices" );
137
138 //CLHEP::HepRandomEngine* engine
139 p_Engine = getRandomEngineDuringInitialize(hijing_stream, m_randomSeed, m_dsid); // NOT THREAD-SAFE
140 hijing_stream = "HIJING";
141
142 // Set the users' initialisation parameters choices
144
145 const char* frame = m_frame.c_str();
146 const char* proj = m_proj.c_str();
147 const char* targ = m_targ.c_str();
148
149 hijset_( &m_efrm, frame, proj, targ, &m_iap, &m_izp, &m_iat, &m_izt,
150 strlen(frame), strlen(proj), strlen(targ) );
151
152 ATH_MSG_INFO( "\n=================================================\n"
153 << " HIJING initialization results: \n"
154 << " Total sigma = " << m_hiparnt.hint1(13) << " mb\n"
155 << " Inelastic sigma = " << m_hiparnt.hint1(12) << " mb\n"
156 << " Jet sigma = " << m_hiparnt.hint1(11) << " mb\n"
157 << "=================================================\n" );
158
159
160 return StatusCode::SUCCESS;
161}
#define ATH_CHECK
Evaluate an expression and check for errors.
void hijset_(float *, const char *, const char *, const char *, int *, int *, int *, int *, long int, long int, long int)
CLHEP::HepRandomEngine * getRandomEngineDuringInitialize(const std::string &streamName, unsigned long int randomSeedOffset, unsigned int conditionsRun=1, unsigned int lbn=1) const
Definition GenModule.cxx:53
BooleanProperty m_wide
Definition Hijing.h:81
void set_user_params(void)
Definition Hijing.cxx:794
int m_izt
Definition Hijing.h:65
int m_izp
Definition Hijing.h:64
const ClassName & targ(size_t i) const
Return one template argument.

◆ GenModule()

GenModule::GenModule ( const std::string & name,
ISvcLocator * pSvcLocator )

Constructor.

Definition at line 45 of file GenModule.cxx.

15 : GenBase(name, pSvcLocator)
16{
17 m_mkMcEvent = true;
18}
GenBase(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition GenBase.cxx:11
BooleanProperty m_mkMcEvent
Flag to determine if a new MC event collection should be made if it doesn't exist.
Definition GenBase.h:110

◆ genuserInitialize()

virtual StatusCode GenModule::genuserInitialize ( )
inlinevirtualinherited

For initialization of user code, if required. Called after genInitialize.

Reimplemented in Pythia8B_i.

Definition at line 64 of file GenModule.h.

64{ return StatusCode::SUCCESS; }

◆ getRandomEngine() [1/2]

CLHEP::HepRandomEngine * GenModule::getRandomEngine ( const std::string & streamName,
const EventContext & ctx ) const
protectedinherited

Definition at line 34 of file GenModule.cxx.

36{
37 ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, streamName);
38 std::string rngName = name()+streamName;
39 rngWrapper->setSeed( rngName, ctx );
40 return rngWrapper->getEngine(ctx);
41}
void setSeed(const std::string &algName, const EventContext &ctx)
Set the random seed using a string (e.g.
Definition RNGWrapper.h:154
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
Definition RNGWrapper.h:108
ServiceHandle< IAthRNGSvc > m_rndmSvc
Data members.
Definition GenModule.h:97

◆ getRandomEngine() [2/2]

CLHEP::HepRandomEngine * GenModule::getRandomEngine ( const std::string & streamName,
unsigned long int randomSeedOffset,
const EventContext & ctx ) const
protectedinherited

Definition at line 44 of file GenModule.cxx.

46{
47 ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, streamName);
48 rngWrapper->setSeed( streamName, ctx.slot(), randomSeedOffset, ctx.eventID().run_number() );
49 return rngWrapper->getEngine(ctx);
50}

◆ getRandomEngineDuringInitialize()

CLHEP::HepRandomEngine * GenModule::getRandomEngineDuringInitialize ( const std::string & streamName,
unsigned long int randomSeedOffset,
unsigned int conditionsRun = 1,
unsigned int lbn = 1 ) const
protectedinherited

Definition at line 53 of file GenModule.cxx.

54{
55 const size_t slot=0;
56 EventContext ctx;
57 ctx.setSlot( slot );
58 ctx.setEventID (EventIDBase (conditionsRun,
59 EventIDBase::UNDEFEVT, // event
60 EventIDBase::UNDEFNUM, // timestamp
61 EventIDBase::UNDEFNUM, // timestamp ns
62 lbn));
64 Atlas::ExtendedEventContext( evtStore()->hiveProxyDict(),
65 conditionsRun) );
66 return getRandomEngine(streamName, randomSeedOffset, ctx);
67}
ServiceHandle< StoreGateSvc > & evtStore()
CLHEP::HepRandomEngine * getRandomEngine(const std::string &streamName, const EventContext &ctx) const
Definition GenModule.cxx:34
void setExtendedEventContext(EventContext &ctx, ExtendedEventContext &&ectx)
Move an extended context into a context object.

◆ initialize()

StatusCode GenModule::initialize ( )
virtualinherited

Reimplemented from GenBase.

Definition at line 21 of file GenModule.cxx.

21 {
22 // Base class initializations
24 // Get the random number service
25 CHECK(m_rndmSvc.retrieve());
26 // Get the incident service
27 CHECK(m_incidentSvc.retrieve());
30 return StatusCode::SUCCESS;
31}
virtual StatusCode initialize() override
Definition GenBase.cxx:17
virtual StatusCode genuserInitialize()
For initialization of user code, if required. Called after genInitialize.
Definition GenModule.h:64
virtual StatusCode genInitialize()
For initializing the generator, if required.
Definition GenModule.h:62

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const
inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

◆ isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const
inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

47{ return false; }

◆ msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ randomizeVertex()

CLHEP::HepLorentzVector Hijing::randomizeVertex ( CLHEP::HepRandomEngine * engine)
protectedvirtual

Definition at line 755 of file Hijing.cxx.

756{
757 // Check the range in Z for the correct pipe diameter
758 // Definitions of constants are in VertexShift.h
759
760 using namespace VertexShift;
761
762 double ranx, rany, xmax, ymax;
763 double ranz = CLHEP::RandFlat::shoot(engine, -Zmax, Zmax);
764 if( m_wide ){ // Allow the whole pipe
765 if( std::abs(ranz) < Start1 ) {
766 xmax = Xmin + Delta1;
767 ymax = xmax;
768 } else if( std::abs(ranz) < Start2 ) {
769 xmax = Xmin + Delta2;
770 ymax = xmax;
771 } else if( std::abs(ranz) < Start3 ) {
772 xmax = Xmin + Delta3;
773 ymax = xmax;
774 } else if ( std::abs(ranz) <= Envelope ){
775 xmax = Xmin;
776 ymax = xmax;
777 } else {
778 ATH_MSG_ERROR( "**** Hijing::randomizeVertex() " << ranz << " (z) is outside the detector (units of mm). Returning a centered event." );
779 return CLHEP::HepLorentzVector(0.,0.,0.,0.);
780 }
781 } else {
782 ATH_MSG_INFO( "New Coordinates: x=0., y=0., z=" << ranz );
783 return CLHEP::HepLorentzVector(0., 0., ranz, 0); // Allow distribution just along the beam (no "width", m_wide is false (default))
784 }
785 ranx = CLHEP::RandFlat::shoot(engine, -xmax, xmax);
786 rany = CLHEP::RandFlat::shoot(engine, -ymax, ymax);
787
788 ATH_MSG_INFO( "New Coordinates: x=" << ranx << ", y=" << rany << ", z=" << ranz );
789
790 return CLHEP::HepLorentzVector(ranx, rany, ranz, 0);
791}
double xmax
Definition listroot.cxx:61
double ymax
Definition listroot.cxx:64
const float Delta1
Definition VertexShift.h:29
const float Xmin
Definition VertexShift.h:25
const float Delta2
Definition VertexShift.h:30
const float Delta3
Definition VertexShift.h:31

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

369 {
370 h.renounce();
372 }
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
354 }

◆ set_user_params()

void Hijing::set_user_params ( void )
protected

Definition at line 794 of file Hijing.cxx.

795{
796 // set up the DEFAULT input parameters to hijset: these can be changed by the user ...
797 m_efrm = 14000.;
798 m_frame = "CMS ";
799 m_proj = "P ";
800 m_targ = "P ";
801 m_iap = 1;
802 m_iat = 1;
803 m_izp = 1;
804 m_izt = 1;
805 // ... and to hijing
806 m_bmin = 0.;
807 m_bmax = 0.;
808
809 // Set user Initialization parameters
810 for(CommandVector::iterator i = m_InitializeVector.begin(); i != m_InitializeVector.end(); ++i )
811 {
812 ATH_MSG_INFO( " Hijing init. Command is: " << *i );
813 StringParse mystring(*i);
814 std::string myparam = mystring.piece<std::string>(1);
815 if (myparam == "efrm")
816 {
817 m_efrm = mystring.piece<double>(2);
818 }
819 else if (myparam == "frame")
820 {
821 m_frame = mystring.piece<std::string>(2);
822 if (m_frame.size() < 8)
823 {
824 unsigned nbl = 8 - m_frame.size();
825 for (unsigned i = 0; i < nbl; ++i) m_frame += ' ';
826 }
827 }
828 else if (myparam == "proj")
829 {
830 m_proj = mystring.piece<std::string>(2);
831 if (m_proj.size() < 8)
832 {
833 unsigned nbl = 8 - m_proj.size();
834 for (unsigned i = 0; i < nbl; ++i) m_proj += ' ';
835 }
836 }
837 else if (myparam == "targ")
838 {
839 m_targ = mystring.piece<std::string>(2);
840 if (m_targ.size() < 8)
841 {
842 unsigned nbl = 8 - m_targ.size();
843 for (unsigned i = 0; i < nbl; ++i) m_targ += ' ';
844 }
845 }
846 else if (myparam == "iap")
847 {
848 m_iap = mystring.piece<int>(2);
849 }
850 else if (myparam == "izp")
851 {
852 m_izp = mystring.piece<int>(2);
853 }
854 else if (myparam == "iat")
855 {
856 m_iat = mystring.piece<int>(2);
857 }
858 else if (myparam == "izt")
859 {
860 m_izt = mystring.piece<int>(2);
861 }
862 else if (myparam == "bmin")
863 {
864 m_bmin = mystring.piece<double>(2);
865 }
866 else if (myparam == "bmax")
867 {
868 m_bmax = mystring.piece<double>(2);
869 }
870 else if (myparam == "nseed")
871 {
872 m_ranseed.nseed() = mystring.piece<int>(2);
873 }
874 else if (myparam == "hipr1")
875 {
876 int myelem = mystring.piece<int>(2);
877 m_hiparnt.hipr1(myelem) = mystring.piece<double>(3);
878 }
879 else if (myparam == "ihpr2")
880 {
881 int myelem = mystring.piece<int>(2);
882 m_hiparnt.ihpr2(myelem) = mystring.piece<int>(3);
883 }
884 else if (myparam == "hint1")
885 {
886 int myelem = mystring.piece<int>(2);
887 m_hiparnt.hint1(myelem) = mystring.piece<double>(3);
888 }
889 else if (myparam == "ihnt2")
890 {
891 int myelem = mystring.piece<int>(2);
892 m_hiparnt.ihnt2(myelem) = mystring.piece<int>(3);
893 }
894 else
895 {
896 ATH_MSG_ERROR( " ERROR in HIJING INITIALIZATION PARAMETERS " << myparam << " is an invalid parameter !" );
897 }
898 }
899}
RanSeed m_ranseed
Definition Hijing.h:107
StringArrayProperty m_InitializeVector
Definition Hijing.h:97

◆ setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state,
const EventContext & ctx ) const
inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
101 }
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:

◆ sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

41{
42 return BaseAlg::sysExecute (ctx);
43}

◆ sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

71 {
73
74 if (sc.isFailure()) {
75 return sc;
76 }
77
78 ServiceHandle<ICondSvc> cs("CondSvc",name());
79 for (auto h : outputHandles()) {
80 if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
81 // do this inside the loop so we don't create the CondSvc until needed
82 if ( cs.retrieve().isFailure() ) {
83 ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
85 }
86 if (cs->regHandle(this,*h).isFailure()) {
88 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
89 << " with CondSvc");
90 }
91 }
92 }
93 return sc;
94}
virtual StatusCode sysInitialize() override
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

298 {
299 for (auto &a : m_vhka) {
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }

Member Data Documentation

◆ m_bmax

float Hijing::m_bmax {0.}
protected

Definition at line 68 of file Hijing.h.

68{0.};

◆ m_bmin

float Hijing::m_bmin {0.}
protected

Definition at line 67 of file Hijing.h.

67{0.};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

◆ m_dsid

IntegerProperty Hijing::m_dsid {this, "Dsid", 999999}
protected

Definition at line 55 of file Hijing.h.

55{this, "Dsid", 999999};

◆ m_efrm

float Hijing::m_efrm {0.}
protected

Definition at line 58 of file Hijing.h.

58{0.};

◆ m_event_paramsKey

SG::WriteHandleKey<HijingEventParams> Hijing::m_event_paramsKey {this, "HijingOutputKey", "Hijing_event_params"}
protected

Definition at line 120 of file Hijing.h.

120{this, "HijingOutputKey", "Hijing_event_params"};

◆ m_events

int Hijing::m_events {0}
protected

Definition at line 94 of file Hijing.h.

94{0};

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_frame

std::string Hijing::m_frame
protected

Definition at line 59 of file Hijing.h.

◆ m_hijcrdn

HijCrdn Hijing::m_hijcrdn
protected

Definition at line 116 of file Hijing.h.

◆ m_hijjet1

HijJet1 Hijing::m_hijjet1
protected

Definition at line 112 of file Hijing.h.

◆ m_hijjet2

HijJet2 Hijing::m_hijjet2
protected

Definition at line 113 of file Hijing.h.

◆ m_hijjet4

HijJet4 Hijing::m_hijjet4
protected

Definition at line 114 of file Hijing.h.

◆ m_himain1

HiMain1 Hijing::m_himain1
protected

Definition at line 110 of file Hijing.h.

◆ m_himain2

HiMain2 Hijing::m_himain2
protected

Definition at line 111 of file Hijing.h.

◆ m_hiparnt

HiParnt Hijing::m_hiparnt
protected

Definition at line 104 of file Hijing.h.

◆ m_histrng

HiStrng Hijing::m_histrng
protected

Definition at line 115 of file Hijing.h.

◆ m_iap

int Hijing::m_iap {0}
protected

Definition at line 62 of file Hijing.h.

62{0};

◆ m_iat

int Hijing::m_iat {0}
protected

Definition at line 63 of file Hijing.h.

63{0};

◆ m_incidentSvc

ServiceHandle<IIncidentSvc> GenModule::m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}
privateinherited

Handle on the incident service.

Definition at line 99 of file GenModule.h.

99{this, "IncidentSvc", "IncidentSvc"};

◆ m_InitializeVector

StringArrayProperty Hijing::m_InitializeVector
protected
Initial value:
{this,
"Initialize",
{},
"List of parameters for Hijing initialization",
"GeneratorSettings<std::string>"}

Definition at line 97 of file Hijing.h.

97 {this,
98 "Initialize",
99 {},
100 "List of parameters for Hijing initialization",
101 "GeneratorSettings<std::string>"};

◆ m_isAfterburner

BooleanProperty GenModule::m_isAfterburner {this, "IsAfterburner", false, "Set true if generator modifies existing events rather than creating new ones"}
protectedinherited

Flag for normal vs. afterburner generators.

Definition at line 87 of file GenModule.h.

87{this, "IsAfterburner", false, "Set true if generator modifies existing events rather than creating new ones"};

◆ m_izp

int Hijing::m_izp {0}
protected

Definition at line 64 of file Hijing.h.

64{0};

◆ m_izt

int Hijing::m_izt {0}
protected

Definition at line 65 of file Hijing.h.

65{0};

◆ m_keepAllDecayVertices

BooleanProperty Hijing::m_keepAllDecayVertices {this, "keepAllDecayVertices", true}
protected

Definition at line 83 of file Hijing.h.

83{this, "keepAllDecayVertices", true};

◆ m_mcEventKey

std::string GenBase::m_mcEventKey {}
protectedinherited

StoreGate key for the MC event collection (defaults to GEN_EVENT).

Definition at line 108 of file GenBase.h.

108{};

◆ m_mcevents_const

SG::ReadHandleKey<McEventCollection> GenBase::m_mcevents_const { this, "McEventKey", "GEN_EVENT", "StoreGate key of the MC event collection" }
privateinherited

Const handle to the MC event collection.

Definition at line 117 of file GenBase.h.

117{ this, "McEventKey", "GEN_EVENT", "StoreGate key of the MC event collection" };

◆ m_mkMcEvent

BooleanProperty GenBase::m_mkMcEvent {this, "MakeMcEvent", false, "Create a new MC event collection if it doesn't exist"}
protectedinherited

Flag to determine if a new MC event collection should be made if it doesn't exist.

Definition at line 110 of file GenBase.h.

110{this, "MakeMcEvent", false, "Create a new MC event collection if it doesn't exist"};

◆ m_partonStoreMinPt

DoubleProperty Hijing::m_partonStoreMinPt {this, "partonStoreMinPt", 5.0}
protected

Definition at line 86 of file Hijing.h.

86{this, "partonStoreMinPt", 5.0};

◆ m_prand

BooleanProperty Hijing::m_prand {this, "randomizeP", false}
protected

Definition at line 82 of file Hijing.h.

82{this, "randomizeP", false}; // BPK randomizes the left<->right direction by mirroring momenta for beam gas

◆ m_proj

std::string Hijing::m_proj
protected

Definition at line 60 of file Hijing.h.

◆ m_rand

BooleanProperty Hijing::m_rand {this, "randomizeVertices", false}
protected

Definition at line 79 of file Hijing.h.

79{this, "randomizeVertices", false};

◆ m_randomSeed

IntegerProperty GenModule::m_randomSeed {this, "RandomSeed", 1234567, "Random seed for the built-in random engine"}
protectedinherited

Seed for random number engine.

Definition at line 84 of file GenModule.h.

84{this, "RandomSeed", 1234567, "Random seed for the built-in random engine"}; // FIXME make this into an unsigned long int?

◆ m_randomseed

int Hijing::m_randomseed {0}
protected

Definition at line 90 of file Hijing.h.

90{0};

◆ m_ranseed

RanSeed Hijing::m_ranseed
protected

Definition at line 107 of file Hijing.h.

◆ m_rndmSvc

ServiceHandle<IAthRNGSvc> GenModule::m_rndmSvc {this, "RndmSvc", "AthRNGSvc"}
privateinherited

Data members.

Definition at line 97 of file GenModule.h.

97{this, "RndmSvc", "AthRNGSvc"};

◆ m_runinfo

std::shared_ptr<HepMC3::GenRunInfo> GenModule::m_runinfo {}
protectedinherited

The run info for HepMC3.

Definition at line 90 of file GenModule.h.

90{};

◆ m_seeds

std::vector<long int> Hijing::m_seeds
protected

Definition at line 91 of file Hijing.h.

◆ m_sel

BooleanProperty Hijing::m_sel {this, "selectVertex", false}
protected

Definition at line 75 of file Hijing.h.

75{this, "selectVertex", false}; // Select vertex location (off for random)

◆ m_spec

BooleanProperty Hijing::m_spec {this, "keepSpectators", true}
protected

Definition at line 76 of file Hijing.h.

76{this, "keepSpectators", true}; // TRUE will keep specator information (default)

◆ m_targ

std::string Hijing::m_targ
protected

Definition at line 61 of file Hijing.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 387 of file AthCommonDataStore.h.

◆ m_vertexOffsetCut

DoubleProperty Hijing::m_vertexOffsetCut {this, "vertexOffsetCut", 1.0E-7}
protected

Definition at line 87 of file Hijing.h.

87{this, "vertexOffsetCut", 1.0E-7};

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
privateinherited

Definition at line 386 of file AthCommonDataStore.h.

◆ m_wide

BooleanProperty Hijing::m_wide {this, "wide", false}
protected

Definition at line 81 of file Hijing.h.

81{this, "wide", false}; // True allows particles with x,y distributions

◆ m_x

DoubleProperty Hijing::m_x {this, "x", 0.}
protected

Definition at line 72 of file Hijing.h.

72{this, "x", 0.};

◆ m_y

DoubleProperty Hijing::m_y {this, "y", 0.}
protected

Definition at line 73 of file Hijing.h.

73{this, "y", 0.};

◆ m_z

DoubleProperty Hijing::m_z {this, "z", 0.}
protected

Definition at line 74 of file Hijing.h.

74{this, "z", 0.};

The documentation for this class was generated from the following files: