ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
Pythia8B_i Class Reference

Authors: James Catmore and Maria Smizanska James.nosp@m..Cat.nosp@m.more@.nosp@m.cern.nosp@m..ch / Maria.nosp@m..Smi.nosp@m.zansk.nosp@m.a@ce.nosp@m.rn.ch Inherits from Pythia8_i by James Monk. More...

#include <Pythia8B_i.h>

Inheritance diagram for Pythia8B_i:
Collaboration diagram for Pythia8B_i:

Public Member Functions

 Pythia8B_i (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~Pythia8B_i ()
 
virtual StatusCode genInitialize ()
 For initializing the generator, if required. More...
 
virtual StatusCode genuserInitialize ()
 For initialization of user code, if required. Called after genInitialize. More...
 
virtual StatusCode callGenerator ()
 For calling the generator on each iteration of the event loop. More...
 
virtual StatusCode genFinalize ()
 For finalising the generator, if required. More...
 
virtual StatusCode fillEvt (HepMC::GenEvent *)
 For filling the HepMC event object. More...
 
bool leptonSelect (Pythia8::Event &, const std::vector< double > &, double, const std::vector< int > &, int, double, bool)
 
bool cleanUndecayed (Pythia8::Event &, const std::vector< int > &)
 
bool pairProperties (Pythia8::Event &, const std::vector< int > &, double, bool)
 
void descendThroughDecay (Pythia8::Event &, std::vector< Pythia8::Particle > &, int) const
 
std::vector< int > getCodes (const std::vector< Pythia8::Particle > &) const
 
bool compare (std::vector< int >, std::vector< int >) const
 
bool passesPTCuts (const std::vector< Pythia8::Particle > &) const
 
bool passesEtaCuts (const std::vector< Pythia8::Particle > &) const
 
bool signalAccept (Pythia8::Event &, const std::vector< int > &, unsigned int) const
 
bool userSelection (Pythia8::Event &, std::string, std::vector< double >)
 
void printSignalSelections (const std::vector< int > &, const std::vector< double > &, const std::vector< double > &, unsigned int) const
 
virtual StatusCode fillWeights (HepMC::GenEvent *evt)
 
double pythiaVersion () const
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const std::string & pythia_stream ()
 
static std::string xmlpath ()
 

Static Public Attributes

static CLHEP::HepRandomEngine * p_rndmEngine = nullptr
 

Protected Member Functions

bool useRndmGenSvc () const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

Protected Attributes

std::unique_ptr< Pythia8::Pythia > m_pythia {}
 
HepMC::Pythia8ToHepMC m_pythiaToHepMC
 
UnsignedIntegerProperty m_maxFailures {this, "MaxFailures", 10}
 
BooleanProperty m_useRndmGenSvc {this, "useRndmGenSvc", true, "the max number of consecutive failures"}
 
std::shared_ptr< customRndm > m_atlasRndmEngine {}
 
IntegerProperty m_dsid {this, "Dsid", 999999, "Dataset ID number"}
 
StringArrayProperty m_userHooks {this, "UserHooks", {} }
 
DoubleProperty m_pt0timesMPI {this,"pT0timesMPI", 1.0}
 
DoubleProperty m_numberAlphaS {this,"numberAlphaS", 3.0}
 
BooleanProperty m_sameAlphaSAsMPI {this,"useSameAlphaSasMPI", false}
 

Private Types

enum  PDGID {
  PROTON =2212, ANTIPROTON =-2212, LEAD =1000822080, NEUTRON =2112,
  ANTINEUTRON =-2112, MUON =13, ANTIMUON =-13, ELECTRON =11,
  POSITRON =-11, INVALID =0
}
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void addLHEToHepMC (HepMC::GenEvent *evt)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

static std::string findValue (const std::string &command, const std::string &key)
 
static int s_allowedTunes (double version)
 

Private Attributes

unsigned int m_had
 
unsigned int m_dec
 
int m_trigCode
 
unsigned int m_nSignalRequired
 
std::vector< int > m_bcodes
 
std::vector< int > m_sigCodes
 
std::vector< int > m_cutCount
 
std::vector< double > m_trigPtCut
 
std::vector< double > m_sigPtCuts
 
std::vector< double > m_sigEtaCuts
 
int m_totalPythiaCalls
 
int m_totalBQuark
 
int m_totalCQuark
 
int m_totalBBarQuark
 
int m_totalCBarQuark
 
int m_totalClone
 
int m_passingTriggerCuts
 
int m_internal_event_number
 
int m_totalHard
 
int m_atLeastOneAcc
 
std::map< int, int > m_speciesCount
 
std::vector< long int > m_seeds
 
bool m_and
 
bool m_oppCharges
 
bool m_vetoDoubleB
 
bool m_vetoDoubleC
 
bool m_selectBQuarks
 
bool m_selectCQuarks
 
double m_qPtCut
 
double m_aqPtCut
 
double m_qEtaCut
 
double m_aqEtaCut
 
double m_invMass
 
double m_trigEtaCut
 
std::string m_userString
 
std::vector< double > m_userVar
 
std::vector< Pythia8::Event > m_BEventBuffer
 
std::vector< int > m_internalEventNumbers
 
bool m_doSuppressSmallPT
 
Pythia8::SuppressSmallPT * m_SuppressSmallPT
 
unsigned int m_failureCount
 
double m_version {-1.}
 
StringArrayProperty m_commands {this, "Commands", {} }
 
std::vector< std::string > m_userParams
 
std::vector< std::string > m_userModes
 
DoubleProperty m_collisionEnergy {this, "CollisionEnergy", 14000.0}
 
StringProperty m_beam1 {this, "Beam1", "PROTON"}
 
StringProperty m_beam2 {this, "Beam2", "PROTON"}
 
bool m_override_transform_beamenergy {false}
 
StringProperty m_lheFile {this, "LHEFile", ""}
 
BooleanProperty m_storeLHE {this, "StoreLHE", false}
 
BooleanProperty m_doCKKWLAcceptance {this, "CKKWLAcceptance", false}
 
BooleanProperty m_doFxFxXS {this, "FxFxXS", false}
 
BooleanProperty m_computeEfficiency {this, "computeEfficiency", false}
 
double m_nAccepted {0.}
 
double m_nMerged {0.}
 
double m_sigmaTotal {0.}
 
double m_conversion {1.}
 
std::map< std::string, PDGID > m_particleIDs
 
StringProperty m_userProcess {this, "UserProcess", ""}
 
std::shared_ptr< Pythia8::Sigma2Process > m_procPtr {}
 
std::vector< UserHooksPtrType > m_userHooksPtrs {}
 
StringProperty m_userResonances {this, "UserResonances", ""}
 
std::vector< std::shared_ptr< Pythia8::ResonanceWidths > > m_userResonancePtrs
 
BooleanProperty m_useLHAPDF {this, "UseLHAPDF", true}
 
StringProperty m_particleDataFile {this, "ParticleData", ""}
 
StringProperty m_outputParticleDataFile {this, "OutputParticleData", "ParticleData.local.xml"}
 
double m_mergingWeight {1.0}
 
double m_enhanceWeight {1.0}
 
std::vector< std::string > m_weightIDs {}
 
std::vector< std::string > m_weightNames {}
 
bool m_doLHE3Weights {false}
 
std::vector< std::string > m_weightCommands {}
 
std::vector< std::string > m_showerWeightNames {"nominal"}
 
StringArrayProperty m_showerWeightNamesProp {this, "ShowerWeightNames", {} }
 
PublicToolHandle< IPythia8Custom > m_athenaTool {this, "CustomInterface", ""}
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Utility event-mangling functions

Todo:
Replace with HepMC units when available
ServiceHandle< IPartPropSvc > m_ppSvc {this, "PartPropSvc", "PartPropSvc"}
 Handle on the particle property service. More...
 
SG::ReadHandleKey< McEventCollection > m_mcevents_const { this, "McEventKey", "GEN_EVENT", "StoreGate key of the MC event collection" }
 Const handle to the MC event collection. More...
 
void GeVToMeV (HepMC::GenEvent *evt)
 Scale event energies/momenta by x 1000. More...
 
void MeVToGeV (HepMC::GenEvent *evt)
 Scale event energies/momenta by x 1/1000. More...
 
void cmTomm (HepMC::GenEvent *evt)
 Scale event lengths by x 10. More...
 
void mmTocm (HepMC::GenEvent *evt)
 Scale event lengths by x 1/10. More...
 

Features for derived classes to use internally

ServiceHandle< IAthRNGSvc > m_rndmSvc {this, "RndmSvc", "AthRNGSvc"}
 Data members. More...
 
ServiceHandle< IIncidentSvc > m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}
 Handle on the incident service. More...
 
IntegerProperty m_randomSeed {this, "RandomSeed", 1234567, "Random seed for the built-in random engine"}
 Seed for random number engine. More...
 
BooleanProperty m_isAfterburner {this, "IsAfterburner", false, "Set true if generator modifies existing events rather than creating new ones"}
 Flag for normal vs. afterburner generators. More...
 
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
 

Detailed Description

Authors: James Catmore and Maria Smizanska James.nosp@m..Cat.nosp@m.more@.nosp@m.cern.nosp@m..ch / Maria.nosp@m..Smi.nosp@m.zansk.nosp@m.a@ce.nosp@m.rn.ch Inherits from Pythia8_i by James Monk.

Definition at line 16 of file Pythia8B_i.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ PDGID

enum Pythia8_i::PDGID
privateinherited
Enumerator
PROTON 
ANTIPROTON 
LEAD 
NEUTRON 
ANTINEUTRON 
MUON 
ANTIMUON 
ELECTRON 
POSITRON 
INVALID 

Definition at line 115 of file Pythia8_i.h.

115 {PROTON=2212, ANTIPROTON=-2212, LEAD=1000822080, NEUTRON=2112, ANTINEUTRON=-2112, MUON=13, ANTIMUON=-13, ELECTRON=11, POSITRON=-11, INVALID=0};

Constructor & Destructor Documentation

◆ Pythia8B_i()

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

Definition at line 27 of file Pythia8B_i.cxx.

28  : Pythia8_i(name,pSvcLocator) {
29  declareProperty("NHadronizationLoops", m_had=1);
30  declareProperty("NDecayLoops", m_dec=1);
31  declareProperty("SelectBQuarks",m_selectBQuarks=true);
32  declareProperty("SelectCQuarks",m_selectCQuarks=false);
33  declareProperty("QuarkPtCut", m_qPtCut= 0.0);
34  declareProperty("AntiQuarkPtCut", m_aqPtCut= 0.0);
35  declareProperty("QuarkEtaCut", m_qEtaCut=102.5);
36  declareProperty("AntiQuarkEtaCut", m_aqEtaCut=102.5);
37  declareProperty("RequireBothQuarksPassCuts", m_and=false);
38  declareProperty("VetoDoubleBEvents", m_vetoDoubleB=true);
39  declareProperty("VetoDoubleCEvents", m_vetoDoubleC=true);
40  declareProperty("BPDGCodes", m_bcodes);
41  declareProperty("TriggerPDGCode", m_trigCode=0); // 0 = no selection applied
42  declareProperty("TriggerStatePtCut", m_trigPtCut);
43  declareProperty("TriggerStateEtaCut", m_trigEtaCut=2.5);
44  declareProperty("MinimumCountPerCut", m_cutCount);
45  declareProperty("TriggerInvariantMassCut",m_invMass=0.0);
46  declareProperty("TriggerOppositeCharges",m_oppCharges=false);
47  declareProperty("SignalPDGCodes", m_sigCodes);
48  declareProperty("SignalPtCuts", m_sigPtCuts);
49  declareProperty("SignalEtaCuts", m_sigEtaCuts);
50  declareProperty("NumberOfSignalsRequiredPerEvent", m_nSignalRequired=1);
51  declareProperty("UserSelection", m_userString="NONE");
52  declareProperty("UserSelectionVariables", m_userVar);
53  declareProperty("SuppressSmallPT", m_doSuppressSmallPT=false);
54 
55  m_totalBQuark = 0;
56  m_totalBBarQuark = 0;
57  m_totalCQuark = 0;
58  m_totalCBarQuark = 0;
59  m_totalPythiaCalls = 0;
60  m_totalHard = 0;
61  m_totalClone = 0;
62  m_atLeastOneAcc = 0;
63  m_passingTriggerCuts = 0;
64  m_internal_event_number = 0;
65  m_speciesCount.clear();
66  m_SuppressSmallPT = 0;
67  m_failureCount = 0;
68 
69  for (std::vector<int>::iterator iit=m_bcodes.begin(); iit!=m_bcodes.end(); ++iit) {
70  m_speciesCount[*iit] = 0;
71  }
72 #ifdef HEPMC3
73  m_runinfo = std::make_shared<HepMC3::GenRunInfo>();
74  std::vector<std::string> names = {"Default"};
75  m_runinfo->set_weight_names(names);
76 #endif
77 }

◆ ~Pythia8B_i()

Pythia8B_i::~Pythia8B_i ( )

Definition at line 80 of file Pythia8B_i.cxx.

80  {
81 }

Member Function Documentation

◆ addLHEToHepMC()

void Pythia8_i::addLHEToHepMC ( HepMC::GenEvent *  evt)
privateinherited

Definition at line 685 of file Pythia8_i.cxx.

685  {
686 
687 #ifdef HEPMC3
688  HepMC::GenEvent *procEvent = new HepMC::GenEvent();
689 
690  // Adding the LHE event to the HepMC results in undecayed partons in the event record.
691  // Pythia's HepMC converter throws up undecayed partons, so we ignore that
692  // (expected) exception this time
693  m_pythiaToHepMC.fill_next_event(m_pythia->process, procEvent, evt->event_number(), &m_pythia->info, &m_pythia->settings);
694 
695  for(auto p: *procEvent){
696  p->set_status(HepMC::PYTHIA8LHESTATUS);
697  }
698 
699  //This code and the HepMC2 version below assume a correct input, e.g. beams[0]->end_vertex() exists.
700  for(auto& v: procEvent->vertices()) v->set_status(1);
701  auto beams=evt->beams();
702  auto procBeams=procEvent->beams();
703  if(beams[0]->momentum().pz() * procBeams[0]->momentum().pz() < 0.) std::swap(procBeams[0],procBeams[1]);
704  for (auto p: procBeams[0]->end_vertex()->particles_out()) beams[0]->end_vertex()->add_particle_out(p);
705  for (auto p: procBeams[1]->end_vertex()->particles_out()) beams[1]->end_vertex()->add_particle_out(p);
706 
707  HepMC::fillBarcodesAttribute(procEvent);
708 #else
709  HepMC::GenEvent *procEvent = new HepMC::GenEvent(evt->momentum_unit(), evt->length_unit());
710 
711  // Adding the LHE event to the HepMC results in undecayed partons in the event record.
712  // Pythia's HepMC converter throws up undecayed partons, so we ignore that
713  // (expected) exception this time
714  try{
715  m_pythiaToHepMC.fill_next_event(m_pythia->process, procEvent, evt->event_number(), &m_pythia->info, &m_pythia->settings);
716  }catch(HepMC::PartonEndVertexException &ignoreIt){}
717 
718  for(HepMC::GenEvent::particle_iterator p = procEvent->particles_begin();
719  p != procEvent->particles_end(); ++p){
720  (*p)->set_status(HepMC::PYTHIA8LHESTATUS);
721  }
722 
723  std::vector<HepMC::GenParticle*> beams;
724  std::vector<HepMC::GenParticle*> procBeams;
725  beams.push_back(evt->beam_particles().first);
726  beams.push_back(evt->beam_particles().second);
727 
728  if(beams[0]->momentum().pz() * procEvent->beam_particles().first->momentum().pz() > 0.){
729  procBeams.push_back(procEvent->beam_particles().first);
730  procBeams.push_back(procEvent->beam_particles().second);
731  }else{
732  procBeams.push_back(procEvent->beam_particles().second);
733  procBeams.push_back(procEvent->beam_particles().first);
734  }
735 
736  std::map<const HepMC::GenVertex*, HepMC::GenVertex*> vtxCopies;
737 
738  for(HepMC::GenEvent::vertex_const_iterator v = procEvent->vertices_begin();
739  v != procEvent->vertices_end(); ++v ) {
740  if(*v == procBeams[0]->end_vertex() || *v == procBeams[1]->end_vertex()) continue;
741  HepMC::GenVertex* vCopy = new HepMC::GenVertex((*v)->position(), (*v)->id(), (*v)->weights());
742  vCopy->suggest_barcode(-(evt->vertices_size()));
743  vCopy->set_id(1);
744  vtxCopies[*v] = vCopy;
745  evt->add_vertex(vCopy);
746  }
747 
748  for(HepMC::GenEvent::particle_const_iterator p = procEvent->particles_begin();
749  p != procEvent->particles_end(); ++p ){
750  if((*p)->is_beam()) continue;
751 
752  HepMC::GenParticle *pCopy = new HepMC::GenParticle(*(*p));
753  pCopy->suggest_barcode(evt->particles_size());
754 
755  std::map<const HepMC::GenVertex*, HepMC::GenVertex*>::iterator vit;
756  for(size_t ii =0; ii != 2; ++ii){
757  if((*p)->production_vertex() == procBeams[ii]->end_vertex()){
758  beams[ii]->end_vertex()->add_particle_out(pCopy);
759  break;
760  }
761 
762  if(ii == 1){
763  vit = vtxCopies.find((*p)->production_vertex());
764  if(vit != vtxCopies.end()) vit->second->add_particle_out(pCopy);
765  }
766  }
767 
768  vit = vtxCopies.find((*p)->end_vertex());
769  if(vit != vtxCopies.end()) vit->second->add_particle_in(pCopy);
770  }
771 #endif
772 
773  return;
774 }

◆ ATLAS_NOT_CONST_THREAD_SAFE() [1/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 76 of file GenBase.h.

76  {
77  if (events()->empty())
78  ATH_MSG_ERROR("McEventCollection is empty during first event access");
79  return *(events()->begin());
80  }

◆ ATLAS_NOT_CONST_THREAD_SAFE() [2/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.

◆ callGenerator()

StatusCode Pythia8B_i::callGenerator ( )
virtual

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

Reimplemented from Pythia8_i.

Definition at line 150 of file Pythia8B_i.cxx.

150  {
151 
152  ATH_MSG_DEBUG(">>> Pythia8B_i from callGenerator");
153 
154  // Check the buffers are empty - if not return so that the GenModule
155  // calls fillEvt again and takes another event from the buffer
156  if (m_BEventBuffer.size()!=0) {
157  ATH_MSG_DEBUG("BEventBuffer not empty; skipping callGenerator");
158  return StatusCode::SUCCESS;
159  }
160 
161  if(m_useRndmGenSvc && Pythia8B_i::p_rndmEngine){
162  //Re-seed the random number stream
163  long seeds[7];
164  const EventContext& ctx = Gaudi::Hive::currentContext();
165  ATHRNG::calculateSeedsMC21(seeds, "PYTHIA8B", ctx.eventID().event_number(), m_dsid, m_randomSeed);
166  m_atlasRndmEngine->getEngine()->setSeeds(seeds, 0); // NOT THREAD-SAFE
167  m_seeds.clear();
168  m_seeds.push_back(seeds[0]);
169  m_seeds.push_back(seeds[1]);
170  }
171 
172  // Generator. Shorthand for event.
173  Pythia8::Event& event = Pythia8_i::m_pythia->event;
174 
175  // Begin event loop.
176  int iEvent(0);
177  while (iEvent < 1) { // keep going until an event is accepted
178 
179  ATH_MSG_DEBUG("Throwing the dice....");
180 // if (!Pythia8_i::m_pythia->next()) continue;
181  if ( !Pythia8_i::m_pythia->next() ) {
182  // First check if it failed because it ran out of events.
183  if ( Pythia8_i::m_pythia->info.atEndOfFile() ) {
184  return StatusCode::FAILURE;
185  }
186 
187  // Otherwise, just make sure that it's not failing too many times in a row.
188  ++m_failureCount;
189  if ( m_failureCount >= m_maxFailures ) {
190  ATH_MSG_ERROR("Exceeded the max number of consecutive event failures.");
191  return StatusCode::FAILURE;
192  } else {
193  ATH_MSG_INFO("Event generation failed - re-trying.");
194  continue;
195  }
196  }
197  // Reset failure counter and increment event counter after a successful event
198  m_failureCount = 0;
199  ++m_totalPythiaCalls;
200 
201  // Find b(c)/antib(c) quarks and enforce cuts as required
202  int nbBeforeSelection(0);
203  int nbbarBeforeSelection(0);
204  int ncBeforeSelection(0);
205  int ncbarBeforeSelection(0);
206  int nbQuark(0);
207  int nbbarQuark(0);
208  int ncQuark(0);
209  int ncbarQuark(0);
210  int stat;
211  for (int i = 0; i < event.size(); ++i) {
212  stat = event[i].statusAbs();
213  bool isBQuark(false);
214  bool isCQuark(false);
215  bool isAntiBQuark(false);
216  bool isAntiCQuark(false);
217  // b-quarks (=anti-B hadrons)
218  if (event[i].id() == 5 && (stat == 62 || stat == 63)) {isBQuark=true; ++nbBeforeSelection;}
219  if (event[i].id() == 4 && (stat == 62 || stat == 63)) {isCQuark=true; ++ncBeforeSelection;}
220  if ( (isBQuark && m_selectBQuarks) || ((isCQuark && m_selectCQuarks)) ) {
221  bool passesPtCut(false); bool passesEtaCut(false);
222  std::string accString = " : REJECTED";
223  double qpt = event[i].pT(); double qeta = std::abs(event[i].eta());
224  if (qpt>m_qPtCut) passesPtCut=true;
225  if (qeta<m_qEtaCut) passesEtaCut=true;
226  if (passesPtCut && passesEtaCut) {
227  if (isBQuark) ++nbQuark;
228  if (isCQuark) ++ncQuark;
229  accString = " : ACCEPTED";
230  }
231  if (isBQuark) ATH_MSG_DEBUG("bQuark pt/eta = " << qpt << "/" << qeta << accString);
232  if (isCQuark) ATH_MSG_DEBUG("cQuark pt/eta = " << qpt << "/" << qeta << accString);
233  }
234  // anti-b quarks (=B-hadrons)
235  if (event[i].id() == -5 && (stat == 62 || stat == 63)) {isAntiBQuark=true; ++nbbarBeforeSelection;}
236  if (event[i].id() == -4 && (stat == 62 || stat == 63)) {isAntiCQuark=true; ++ncbarBeforeSelection;}
237  if ( (isAntiBQuark && m_selectBQuarks) || ((isAntiCQuark && m_selectCQuarks)) ) {
238  bool passesPtCut(false); bool passesEtaCut(false);
239  std::string accString = " : REJECTED";
240  double aqpt = event[i].pT(); double aqeta = std::abs(event[i].eta());
241  if (aqpt>m_aqPtCut) passesPtCut=true;
242  if (aqeta<m_aqEtaCut) passesEtaCut=true;
243  if (passesPtCut && passesEtaCut) {
244  if (isAntiBQuark) ++nbbarQuark;
245  if (isAntiCQuark) ++ncbarQuark;
246  accString = " : ACCEPTED";
247  }
248  if (isAntiBQuark) ATH_MSG_DEBUG("bbarQuark pt/eta = " << aqpt << "/" << aqeta << accString);
249  if (isAntiCQuark) ATH_MSG_DEBUG("ccbarQuark pt/eta = " << aqpt << "/" << aqeta << accString);
250  }
251  }
252  if (nbBeforeSelection+nbbarBeforeSelection>=4 && m_vetoDoubleB) {
253  ATH_MSG_DEBUG("At user request, rejecting double b-bbar event; throwing dice again");
254  continue;
255  }
256  if (ncBeforeSelection+ncbarBeforeSelection>=4 && m_vetoDoubleC) {
257  ATH_MSG_DEBUG("At user request, rejecting double c-cbar event; throwing dice again");
258  continue;
259  }
260  bool rejectBBbar(false);
261  bool rejectCCbar(false);
262  // Enforce user selections
263  if (!m_and && (nbbarQuark==0 && nbQuark==0) && m_selectBQuarks) rejectBBbar=true;
264  if (m_and && (nbbarQuark==0 || nbQuark==0) && m_selectBQuarks) rejectBBbar=true;
265  if (!m_and && (ncbarQuark==0 && ncQuark==0) && m_selectCQuarks) rejectCCbar=true;
266  if (m_and && (ncbarQuark==0 || ncQuark==0) && m_selectCQuarks) rejectCCbar=true;
267  if (m_selectBQuarks && m_selectCQuarks && rejectBBbar && rejectCCbar) {
268  ATH_MSG_DEBUG("No b- or c- quarks accepted; throwing the dice again");
269  continue;
270  }
271  if (m_selectBQuarks && !m_selectCQuarks && rejectBBbar) {
272  ATH_MSG_DEBUG("No b-quarks accepted; throwing the dice again");
273  continue;
274  }
275  if (!m_selectBQuarks && m_selectCQuarks && rejectCCbar) {
276  ATH_MSG_DEBUG("No c-quarks accepted; throwing the dice again");
277  continue;
278  }
279  m_totalBQuark += nbQuark;
280  m_totalBBarQuark += nbbarQuark;
281  m_totalCQuark += ncQuark;
282  m_totalCBarQuark += ncbarQuark;
283  ++m_totalHard;
284 
285  // Switch off decays of species of interest if requested (only for repeated decays)
286  bool doRepeatedDecays(false); if (m_dec>1) doRepeatedDecays=true;
287  if (doRepeatedDecays) {
288  for (unsigned int iC = 0; iC < m_bcodes.size(); ++iC) Pythia8_i::m_pythia->particleData.mayDecay( m_bcodes[iC], false);
289  }
290 
291  // REPEATED HADRONIZATION LOOP
292  // Make a spare copy of event
293  Pythia8::Event eventCopy;
294  std::vector<Pythia8::Event> repeatHadronizedEvents;
295  std::vector<Pythia8::Event>::iterator eventItr;
296  eventCopy = event;
297  // Begin loop over rounds of hadronization for same event.
298  for (unsigned int iRepeat = 0; iRepeat < m_had; ++iRepeat) {
299  ++m_totalClone;
300  // Repeated hadronization: restore saved event record.
301  if (iRepeat > 0) event = eventCopy;
302  // Repeated hadronization: do HadronLevel (repeatedly).
303  if (!Pythia8_i::m_pythia->forceHadronLevel()) continue;
304  repeatHadronizedEvents.push_back(event); // save the events for selections
305  }
306 
307  // REPEATED DECAY LOOP
308  std::vector<Pythia8::Event> savedEvents;
309  if (doRepeatedDecays) {
310  // switch decays back on
311  for (unsigned int iC = 0; iC < m_bcodes.size(); ++iC) Pythia8_i::m_pythia->particleData.mayDecay( m_bcodes[iC], true);
312  // Loop over repeatedly hadronized events
313  for (eventItr=repeatHadronizedEvents.begin(); eventItr!=repeatHadronizedEvents.end(); ++eventItr) {
314  for (unsigned int iRepeat = 0; iRepeat < m_dec; ++iRepeat) {
315  event = (*eventItr);
316  if (!Pythia8_i::m_pythia->moreDecays()) break;
317  savedEvents.push_back(event);
318  }
319  }
320  }
321  if (!doRepeatedDecays) savedEvents = std::move(repeatHadronizedEvents);
322 
323  //event.list();
324 
325  // Make final selections on savedEvents
326  std::vector<Pythia8::Event> finalEvents;
327  bool signalSelect(false);
328  if (m_sigCodes.size()>0) signalSelect=true;
329  for (eventItr=savedEvents.begin(); eventItr!=savedEvents.end(); ++eventItr) {
330  // Does event contain basic leptons needed to fire triggers?
331  if (!leptonSelect(*eventItr,m_trigPtCut,m_trigEtaCut,m_cutCount,m_trigCode,m_invMass,m_oppCharges)) continue;
332  ++m_passingTriggerCuts;
333  // Does the events contain a signal decay as required by the user
334  if (signalSelect) {
335  if (!cleanUndecayed(*eventItr,m_bcodes)) continue;
336  if (!signalAccept(*eventItr,m_sigCodes,m_nSignalRequired)) continue;
337  }
338  // User-defined selections if any
339  if (!m_userString.empty()) {
340  if (!userSelection(*eventItr,m_userString,m_userVar)) continue;
341  }
342  finalEvents.push_back(*eventItr);
343  ++iEvent;
344  }
345  savedEvents.clear();
346  if (finalEvents.size()>0) ++m_atLeastOneAcc;
347 
348  // Species counting and preparing vector for filling
349  for (eventItr=finalEvents.begin(); eventItr!=finalEvents.end(); ++eventItr) {
350  for (int i = 0; i < (*eventItr).size(); ++i) {
351  int id = (*eventItr)[i].id();
352  std::map<int,int>::iterator it;
353  it = m_speciesCount.find(id);
354  if (it != m_speciesCount.end()) {
355  it->second++;
356  }
357  }
358  m_BEventBuffer.push_back(*eventItr);
359  ++m_internal_event_number;
360  m_internalEventNumbers.push_back(m_internal_event_number);
361  //(*eventItr).list();
362  }
363 
364  // End of event loop.
365  }
366 
367  StatusCode returnCode = StatusCode::SUCCESS;
368 
369  return returnCode;
370 }

◆ cleanUndecayed()

bool Pythia8B_i::cleanUndecayed ( Pythia8::Event &  theEvent,
const std::vector< int > &  bCodes 
)

Definition at line 554 of file Pythia8B_i.cxx.

554  {
555 
556  bool cleanEvent(true);
557  std::string accString(" : ACCEPTED");
558  for (int i = 0; i<theEvent.size(); ++i) {
559  const Pythia8::Particle &theParticle = theEvent[i];
560  int id = theParticle.id();
561  int status = theParticle.status();
562  for (auto iItr = bCodes.begin(); iItr!=bCodes.end(); ++iItr) {
563  if ( (id == *iItr) && (status>0) ) {accString=" : REJECTED"; cleanEvent = false;}
564  }
565  }
566  ATH_MSG_DEBUG("Check event for undecayed signal particles" << accString);
567 
568  return cleanEvent;
569 
570 }

◆ cmTomm()

void GenBase::cmTomm ( HepMC::GenEvent *  evt)
protectedinherited

Scale event lengths by x 10.

Definition at line 81 of file GenBase.cxx.

81  {
82  for (HepMC::GenEvent::vertex_iterator vtx = evt->vertices_begin(); vtx != evt->vertices_end(); ++vtx) {
83  const HepMC::FourVector fv((*vtx)->position().x() * 10,
84  (*vtx)->position().y() * 10,
85  (*vtx)->position().z() * 10,
86  (*vtx)->position().t() * 10);
87  (*vtx)->set_position(fv);
88  }
89 }

◆ compare()

bool Pythia8B_i::compare ( std::vector< int >  vect1,
std::vector< int >  vect2 
) const

Definition at line 646 of file Pythia8B_i.cxx.

646  {
647 
648  if (vect1.size()!=vect2.size()) return false;
649 
650  bool isTheSame(true);
651  int size = vect1.size();
652  std::sort(vect1.rbegin(), vect1.rend());
653  std::sort(vect2.rbegin(), vect2.rend());
654  for (int i=0; i<size; ++i) {
655  if (vect1[i] != vect2[i]) {isTheSame = false; break;}
656  }
657  return isTheSame;
658 
659 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ descendThroughDecay()

void Pythia8B_i::descendThroughDecay ( Pythia8::Event &  theEvent,
std::vector< Pythia8::Particle > &  list,
int  i 
) const

Definition at line 617 of file Pythia8B_i.cxx.

617  {
618 
619  list.push_back(theEvent[i]);
620  std::vector<int> childrenIndices = theEvent.daughterList(i);
621  std::vector<int>::iterator iItr;
622  for (iItr = childrenIndices.begin(); iItr != childrenIndices.end(); ++iItr) {
623  descendThroughDecay(theEvent,list,*iItr);
624  }
625 
626  return;
627 
628 }

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ event_const()

const HepMC::GenEvent* GenBase::event_const ( ) const
inlineinherited

Access the current signal event (const)

Definition at line 83 of file GenBase.h.

83  {
84  if (events_const()->empty())
85  ATH_MSG_ERROR("Const McEventCollection is empty during first event access");
86  return *(events_const()->begin());
87  }

◆ events_const() [1/2]

const McEventCollection* GenBase::events_const ( ) const
inlineinherited

Access the current event's McEventCollection (const)

Definition at line 96 of file GenBase.h.

96  {
97  return events_const( getContext() );
98  }

◆ events_const() [2/2]

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

Definition at line 99 of file GenBase.h.

99  {
100  SG::ReadHandle<McEventCollection> ret = SG::makeHandle(m_mcevents_const, ctx);
101  if (!ret.isValid())
102  ATH_MSG_ERROR("No McEventCollection found in StoreGate with key " << m_mcevents_const.key());
103  return ret.cptr();
104  }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode GenModule::execute ( )
virtualinherited
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  //const EventContext& ctx = Gaudi::Hive::currentContext();
79  //CLHEP::HepRandomEngine* rndmEngine = this->getRandomEngine("MyStream", ctx);
80 
81  // Example 2 - seeded based on the m_randomSeed property (+ slot, run, streamName)
82  //const EventContext& ctx = Gaudi::Hive::currentContext();
83  //CLHEP::HepRandomEngine* rndmEngine = this->getRandomEngine("MyStream", m_randomSeed.value(), ctx);
84 
85  // Call the code that generates an event
86  CHECK(this->callGenerator());
87 
88  // Create the MC event and send the GeneratorEvent stored in it to fillEvt
89  HepMC::GenEvent* evt = HepMC::newGenEvent(1,1);
90  CHECK(this->fillEvt(evt));
91  HepMC::fillBarcodesAttribute(evt);
92 
93  // Add the event to the MC event collection
94  if (events()) {
95  // If this is an "afterburner" generator, replace the last event rather than add a new one
97  if (m_isAfterburner.value() || name() == "Tauola" || name() == "Photos") {
98  events()->pop_back();
99  }
100  // Add the event to the end of the collection
101  events()->push_back(evt);
102  ATH_MSG_DEBUG("MC event added to McEventCollection");
103 
104  // remove the empty event in case of ParticleDecayer
105  if (name() == "ParticleDecayer") {
106  events()->pop_back();
107  }
108  }
109 
110  // Call the incident service to notify that an event has been made
111  m_incidentSvc->fireIncident( Incident(name(), "McEventGenerated") );
112  return StatusCode::SUCCESS;
113 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< 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 & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ fillEvt()

StatusCode Pythia8B_i::fillEvt ( HepMC::GenEvent *  evt)
virtual

For filling the HepMC event object.

Reimplemented from Pythia8_i.

Definition at line 373 of file Pythia8B_i.cxx.

373  {
374 
375  ATH_MSG_DEBUG(">>> Pythia8B_i from fillEvt");
376  ATH_MSG_DEBUG("BEventBuffer contains " << m_BEventBuffer.size() << " events ");
377  if (m_BEventBuffer.size()==0 ) {
378  ATH_MSG_DEBUG("BEventBuffer now empty - going to next Pythia event");
379  return StatusCode::SUCCESS;
380  }
381 
382  Pythia8::Event &pyev = *(m_BEventBuffer.begin());
383  evt->set_event_number(*(m_internalEventNumbers.begin()));
384  m_pythiaToHepMC.fill_next_event(pyev, evt, 1, &Pythia8_i::m_pythia->info);
385 
386 
387  // set the randomseeds
388  if(useRndmGenSvc() && Pythia8B_i::p_rndmEngine)
389  HepMC::set_random_states(evt,m_seeds);
390 
391  // set the event weight
392 #ifdef HEPMC3
393  if (!evt->run_info()) evt->set_run_info(m_runinfo);
394  evt->set_units(HepMC3::Units::MEV, HepMC3::Units::MM);
395 #else
396  evt->weights().push_back(m_pythia->info.weight());
397 #endif
398 
399 //uncomment to list HepMC events
400 //#ifdef HEPMC3
401 // std::cout << " print::listing Pythia8B " << std::endl;
402 // HepMC3::Print::listing(std::cout, *evt);
403 //#else
404 // std::cout << " print::printing Pythia8B " << std::endl;
405 // evt->print();
406 //#endif
407 
408  // Remove event/number from buffer
409  m_BEventBuffer.erase(m_BEventBuffer.begin());
410  m_internalEventNumbers.erase(m_internalEventNumbers.begin());
411 
412 
413  return StatusCode::SUCCESS;
414 }

◆ fillWeights()

StatusCode Pythia8_i::fillWeights ( HepMC::GenEvent *  evt)
virtualinherited

mismatch in weight name!

Definition at line 478 of file Pythia8_i.cxx.

478  {
479 
480  // reset
481  m_mergingWeight = m_pythia->info.mergingWeightNLO(); // first initialisation, good for the nominal weight in any case (see Merging:includeWeightInXsection).
482  m_enhanceWeight = 1.0; // better to keep the enhancement from UserHooks in a separate variable, to keep the code clear
483 
484 #ifndef PYTHIA8_304SERIES
485  // include Enhance userhook weight
486  for(const auto &hook: m_userHooksPtrs) {
487  if (hook->canEnhanceEmission()) {
488  m_enhanceWeight *= hook->getEnhancedEventWeight();
489  }
490  }
491 #endif // not PYTHIA8_304SERIES
492 
493  // DO NOT try to distinguish between phase space and merging contributions: only their product contains both, so always multiply them in order to be robust
494  double eventWeight = m_pythia->info.weight() * m_mergingWeight * m_enhanceWeight;
495 
496  std::map<std::string,double> fWeights; // temporary weight vector, needed while managing hepmc2 and 3 simultaneously
497 
498  // save as Default the usual pythia8 weight, including enhancements
499  // NB: info.weight() is built upon info.eventWeightLHEF (but includes shower "decorations"), not from the rwgt LHE vector.
500  size_t atlas_specific_weights = 1;
501  fWeights["Default"]=eventWeight;
502  if(m_internal_event_number == 1) {
503  ATH_MSG_INFO("found LHEF version "<< m_pythia->info.LHEFversion() );
504  if (m_pythia->info.LHEFversion() > 1) m_doLHE3Weights = true;
505  m_weightIDs.clear();
506  m_weightIDs.push_back("Default"); // notice that we are assigning a weightname = weightID
507  }
508 
509  // Now systematic weights: a) generator and b) shower variations
510  // merging implies reading from lhe files (while the opposite is not true, ok, but still works)
511  if (m_lheFile!="") {
512  // remember that the true merging component can be disentangled only when there are LHE input events
513 
514  // make sure to get the merging weight correctly: this is needed -only- for systematic weights (generator and parton shower variations)
515  // NB: most robust way, regardless of the specific value of Merging:includeWeightInXsection (if on, info.mergingWeight() is always 1.0 ! )
516  m_mergingWeight *= ( m_pythia->info.weight() / m_pythia->info.eventWeightLHEF ); // this is the actual merging component, regardless of conventions,
517  // needed by systematic variation weights
518  // this includes rare compensation or selection-biased weights
519  }
520 
521 
522  ATH_MSG_DEBUG("Event weights: enhancing weight, merging weight, total weight = "<<m_enhanceWeight<<", "<<m_mergingWeight<<", "<<eventWeight);
523 
524  // we already filled the "Default" weight
525  std::vector<std::string>::const_iterator id = m_weightIDs.begin()+atlas_specific_weights;
526 
527  // a) fill generator weights
528  if(m_pythia->info.getWeightsDetailedSize() != 0){
529  for(std::map<std::string, Pythia8::LHAwgt>::const_iterator wgt = m_pythia->info.rwgt->wgts.begin();
530  wgt != m_pythia->info.rwgt->wgts.end(); ++wgt){
531 
532  if(m_internal_event_number == 1){
533  m_weightIDs.push_back(wgt->first);
534  }else{
535  if(*id != wgt->first){
536  ATH_MSG_ERROR("Mismatch in LHE3 weight id. Found "<<wgt->first<<", expected "<<*id);
537  return StatusCode::FAILURE;
538  }
539  ++id;
540  }
541 
542  std::map<std::string, Pythia8::LHAweight>::const_iterator weightName = m_pythia->info.init_weights->find(wgt->first);
543  if(weightName != m_pythia->info.init_weights->end()){
544  fWeights[weightName->second.contents] = m_mergingWeight * m_enhanceWeight * wgt->second.contents;
545  }else{
546  // if no name was assigned/found, assign a weightname = weightid
547  fWeights[wgt->first] = m_mergingWeight * m_enhanceWeight * wgt->second.contents;
548  }
549 
550  }
551  }
552 
553  // b) shower weight variations
554  // always start from second shower weight: the first was saved already as "Default"
555 
556  for(int iw = 1; iw < m_pythia->info.PYTHIA8_NWEIGHTS(); ++iw){
557 
558  std::string wtName = ((int)m_showerWeightNames.size() == m_pythia->info.PYTHIA8_NWEIGHTS())? m_showerWeightNames[iw]: "ShowerWt_" +std::to_string(iw);
559 
560  fWeights[wtName] = m_mergingWeight * m_enhanceWeight * m_pythia->info.PYTHIA8_WEIGHT(iw)*m_conversion;
561 
562  if(m_internal_event_number == 1) {
563  m_weightIDs.push_back(wtName);
564  ATH_MSG_DEBUG("Shower weight name, value, conversion: "<<wtName<<", "<< fWeights[wtName] <<","<<m_conversion );
565  }
566  }
567 
568  // Now save, as a backup, also the LHEF weight without enhancements (useful for possible, rare, non-default cases)
569  // to make clear that it should not be used in analyses, save it always with a -10 factor (so that its goal is clear even if not checking its name)
570  if (m_lheFile!="")
571  {
572  fWeights["AUX_bare_not_for_analyses"]=(-10.0)*m_pythia->info.eventWeightLHEF;
573  if(m_internal_event_number == 1) m_weightIDs.push_back("AUX_bare_not_for_analyses");
574  }
575 
576  // Sad, but needed: create a string vector with acceptable order of weight names
577  if(m_internal_event_number == 1){
578  m_weightNames.clear();
579  for(const std::string &id : m_weightIDs){
580  if(m_doLHE3Weights) {
581  std::map<std::string, Pythia8::LHAweight>::const_iterator weight = m_pythia->info.init_weights->find(id);
582  if(weight != m_pythia->info.init_weights->end()) m_weightNames.push_back(weight->second.contents);
583  else m_weightNames.push_back(id);
584  }
585  else {
586  m_weightNames.push_back(id);
587  }
588  }
589  if (m_weightNames.size() != fWeights.size() ) {
590  ATH_MSG_ERROR("Something wrong when building list of weight names: " << m_weightNames.size() << " vs "<< fWeights.size() << ", exiting ...");
591  return StatusCode::FAILURE;
592  }
593  }
594 
595  // The following depends on the specific hepmc2/3 implementation
596 #ifdef HEPMC3
597  if (!evt->run_info()) {
598  evt->set_run_info(m_runinfo);
599  }
600  evt->run_info()->set_weight_names(m_weightNames);
601 
602  // for the first event, weight AUX_bare_not_for_analyses is not present in evt->weights(), so we need to book a place for it by hand
603  if (m_internal_event_number == 1 && evt->run_info()->weight_names().size() == evt->weights().size()+1 ) {
604  evt->weights().push_back(1.0);
605  }
606 
607  // added conversion GeV -> MeV to ensure correct units
608  evt->set_units(HepMC3::Units::MEV, HepMC3::Units::MM);
609 
610  evt->weights().resize(fWeights.size(), 1.0);
611  for (auto w: fWeights) {
612  evt->weight(w.first)=w.second;
613  }
614 
615  auto beams=evt->beams();
616  ATH_MSG_DEBUG( " Energy of the beams " << beams[0]->momentum().e() );
617 
618 //uncomment to list HepMC events
619 // std::cout << " print::listing Pythia8 " << std::endl;
620 // HepMC3::Print::listing(std::cout, *evt);
621 
622 #else
623  evt->weights().clear();
624  for (auto w: m_weightNames ) {evt->weights()[w]=fWeights[w];}
625  auto beams=evt->beam_particles();
626  ATH_MSG_DEBUG( " Energy of the beams " << beams.first->momentum().e() );
627 
628 //uncomment to list HepMC events
629 // std::cout << " print::listing Pythia8 " << std::endl;
630 // evt->print();
631 #endif
632 
633  return StatusCode::SUCCESS;
634 }

◆ finalize()

StatusCode GenModule::finalize ( )
inlineinherited

Definition at line 55 of file GenModule.h.

55 { return genFinalize(); }

◆ findValue()

static std::string Pythia8_i::findValue ( const std::string &  command,
const std::string &  key 
)
staticprivateinherited

◆ genFinalize()

StatusCode Pythia8B_i::genFinalize ( )
virtual

For finalising the generator, if required.

Reimplemented from Pythia8_i.

Definition at line 418 of file Pythia8B_i.cxx.

418  {
419 
420  ATH_MSG_INFO(">>> Pythia8B_i from genFinalize");
421 
422  Pythia8_i::m_pythia->stat();
423 
424  Pythia8::Info info = Pythia8_i::m_pythia->info;
425  double xs = info.sigmaGen();// in mb
426  xs *= 1000. * 1000.;//convert to nb
427 
428  std::cout << "MetaData: cross-section (nb)= " << xs << std::endl;
429  std::cout << "Total events from Pythia = " << m_totalPythiaCalls<< std::endl;
430  std::cout << "Number of accepted b quarks = " << m_totalBQuark<< std::endl;
431  std::cout << "Number of accepted bbar quarks = " << m_totalBBarQuark<< std::endl;
432  std::cout << "Number of accepted c quarks = " << m_totalCQuark<< std::endl;
433  std::cout << "Number of accepted cbar quarks = " << m_totalCBarQuark<< std::endl;
434  std::cout << "Number of accepted b/c events before hadronization = " << m_totalHard<< std::endl;
435  std::cout << "Number of hadronization loops per b/c-event = " << m_had<< std::endl;
436  std::cout << "Total number of hadronization loops = " << m_totalClone<< std::endl;
437  std::cout << "Number of accepted b/c events yielding at least one finally accepted event = " << m_atLeastOneAcc<< std::endl;
438  std::cout << "Average number of accepted events per hard event = " << static_cast<float>(m_internal_event_number)/static_cast<float>(m_atLeastOneAcc)<< std::endl;
439  std::cout << "Number of events passing trigger cuts = " << m_passingTriggerCuts<< std::endl;
440  std::cout << "Number of accepted events = " << m_internal_event_number<< std::endl;
441  std::cout << "Summary of cuts: " << std::endl;
442  if (m_selectBQuarks || m_selectCQuarks) {
443  if (m_selectBQuarks) std::cout << "Quarks cuts apply to b-quarks" << std::endl;
444  if (m_selectCQuarks) std::cout << "Quarks cuts apply to c-quarks" << std::endl;
445  std::cout << "Quark pt > " << m_qPtCut << std::endl;
446  std::cout << "Antiquark pt > " << m_aqPtCut << std::endl;
447  std::cout << "Quark eta < " << m_qEtaCut << std::endl;
448  std::cout << "Antiquark eta < " << m_aqEtaCut << std::endl;
449  if (m_and) std::cout << "Require quark and anti-quark pass cuts" << std::endl;
450  }
451  std::cout << "Trigger lepton type = " << m_trigCode << std::endl;
452  std::cout << "Trigger lepton pt cuts: ";
453  for (unsigned int prCntr=0; prCntr<m_trigPtCut.size(); ++prCntr) {std::cout << m_trigPtCut[prCntr] << " ";}
454  std::cout << std::endl;
455  std::cout << "Trigger lepton eta cut: " << m_trigEtaCut << std::endl;
456  std::cout << "Required number of leptons passing each trigger cut = ";
457  for (unsigned int prCntr=0; prCntr<m_cutCount.size(); ++prCntr) {std::cout << m_cutCount[prCntr] << " ";}
458  std::cout << std::endl;
459  std::cout << "Invariant mass of trigger leptons > " << m_invMass << std::endl;
460  if (m_oppCharges) std::cout << "Trigger leptons required to have opposite charges" << std::endl;
461  if (m_sigCodes.size() > 0) printSignalSelections(m_sigCodes,m_sigPtCuts,m_sigEtaCuts,m_nSignalRequired);
462  if (!m_userString.empty()) std::cout << "User selection: " << m_userString << std::endl;
463 
464  if (m_speciesCount.size()>0) {
465  std::cout <<"\nSpecies\tCount\n"<< std::endl;
466  for ( std::map<int,int>::iterator iter = m_speciesCount.begin();
467  iter != m_speciesCount.end(); ++iter )
468  std::cout << iter->first << '\t' << iter->second << '\n'<< std::endl;
469  }
470  if (m_dec>1) std::cout << "Number of times each of these states were copied and decayed: " << m_dec << std::endl;
471 
472  float cloningFactor = (float)(m_internal_event_number)/(float)(m_atLeastOneAcc);
473  float finalXS = ((float)xs*((float)m_internal_event_number/(float)m_totalPythiaCalls))/(float)m_had;
474 
475  std::cout << " I===================================================================================== " << std::endl;
476  std::cout << " I CROSSSECTION OF YOUR B-CHANNEL IS I " << std::endl;
477  std::cout << " I BX= PX*NB/AC/MHAD= I " << finalXS << " nb" << std::endl;
478  std::cout << " I I " << std::endl;
479  std::cout << " I IN CASE YOU FORCED ANY DECAY YOU SHOULD I " << std::endl;
480  std::cout << " I CORRECT CROSS SECTION BX FURTHER, MULTIPLYING I " << std::endl;
481  std::cout << " I BX BY BRANCHING RATIO(S) OF YOUR FORCED I " << std::endl;
482  std::cout << " I DECAY(S) AND BY A FACTOR OF 2 FOR SYMMETRY I " << std::endl;
483  std::cout << " I I " << std::endl;
484  std::cout << " I MORE DETAILS ON CROSS SECTION I " << std::endl;
485  std::cout << " I PYTHIA CROSS SECTION IS PX= I " << xs <<" nb" << std::endl;
486  std::cout << " I NUMBER OF ACCEPTED HARD EVENTS AC= I " << m_totalPythiaCalls << std::endl;
487  std::cout << " I NUMBER OF ACCEPTED B-EVENTS IS NB= I " << m_internal_event_number<< std::endl;
488  std::cout << " I REPEATED HADRONIZATIONS IN EACH EVENT MHAD= I " << m_had << std::endl;
489  std::cout << " I AVERAGE NUM OF ACCEPTED EVTS IN HADRONIZATION LOOP I " << cloningFactor << std::endl;
490  std::cout << " I IN CASE YOU FORCED ANY DECAY YOU SHOULD I " << std::endl;
491  std::cout << " I CORRECT CROSS SECTION BX FURTHER, MULTIPLYING I " << std::endl;
492  std::cout << " I BX BY BRANCHING RATIO(S) OF YOUR FORCED I " << std::endl;
493  std::cout << " I DECAY(S) AND BY A FACTOR OF 2 FOR SYMMETRY I " << std::endl;
494  std::cout << " I I " << std::endl;
495  std::cout << " I===================================================================================== " << std::endl;
496  std::cout << "" << std::endl;
497  std::cout << "MetaData: cross-section (nb)= " << finalXS << std::endl;
498 
499  return StatusCode::SUCCESS;
500 }

◆ genInitialize()

StatusCode Pythia8B_i::genInitialize ( )
virtual

For initializing the generator, if required.

Reimplemented from Pythia8_i.

Definition at line 84 of file Pythia8B_i.cxx.

84  {
85 
86  // Logic checks
87  unsigned int trigPtCutsSize = m_trigPtCut.size();
88  if (trigPtCutsSize!=m_cutCount.size()) {
89  ATH_MSG_ERROR("You are requesting " << trigPtCutsSize << " trigger-like pt cuts but are providing required counts for " << m_cutCount.size() << " cuts. This doesn't make sense.");
90  return StatusCode::FAILURE;
91  }
92 
93  // This over-rides the genInitialize in the base class Pythia8_i, but then calls it
94  // Sets the built-in UserHook called SuppressLowPT
95  // FOR ONIA USE ONLY
96  ATH_MSG_INFO("genInitialize() from Pythia8B_i");
97 
98  bool canSetHook=true;
99  if (m_doSuppressSmallPT) {
100  Pythia8_i::m_userHooks=std::vector<std::string>(1, "SuppressSmallPT");
101  }
102 
103  if (!canSetHook) {
104  ATH_MSG_ERROR(" *** Unable to initialise PythiaB !! ***");
105  return StatusCode::FAILURE;
106  }
107 
108  if(m_userString == "NONE") m_userString.clear();
109  // Call the base class genInitialize()
110  CHECK(Pythia8_i::genInitialize());
111 
112  ATH_MSG_DEBUG("... seeding Athena random number generator");
113  if (m_useRndmGenSvc){
114  p_rndmEngine = m_atlasRndmEngine->getEngine(); // NOT THREAD-SAFE
115  if (!p_rndmEngine) {
116  ATH_MSG_FATAL("Unable to retrieve HepRandomEngine. Bailing out.");
117  return StatusCode::FAILURE;
118  }
119  }
120  return StatusCode::SUCCESS;
121 }

◆ genuserInitialize()

StatusCode Pythia8B_i::genuserInitialize ( )
virtual

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

Reimplemented from GenModule.

Definition at line 125 of file Pythia8B_i.cxx.

125  {
126 
127  // Just counter setting
128  ATH_MSG_INFO("Pythia8B_i from genuserInitialize()");
129 
130  // Initialize global counters
131  m_totalBQuark = 0;
132  m_totalBBarQuark = 0;
133  m_totalCQuark = 0;
134  m_totalCBarQuark = 0;
135  m_totalPythiaCalls = 0;
136  m_totalHard = 0;
137  m_totalClone = 0;
138  m_atLeastOneAcc = 0;
139  m_passingTriggerCuts = 0;
140  m_internal_event_number = 0;
141  m_speciesCount.clear();
142  for (std::vector<int>::iterator iit=m_bcodes.begin(); iit!=m_bcodes.end(); ++iit) {
143  m_speciesCount[*iit] = 0;
144  }
145 
146  return StatusCode::SUCCESS;
147 }

◆ getCodes()

std::vector< int > Pythia8B_i::getCodes ( const std::vector< Pythia8::Particle > &  theParticles) const

Definition at line 632 of file Pythia8B_i.cxx.

632  {
633 
634  std::vector<int> codes;
635  codes.reserve(theParticles.size());
636  for (auto pItr = theParticles.begin(); pItr!=theParticles.end(); ++pItr ) {
637  codes.push_back( (*pItr).id() );
638  }
639  return codes;
640 
641 }

◆ 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 }

◆ 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));
63  Atlas::setExtendedEventContext(ctx,
64  Atlas::ExtendedEventContext( evtStore()->hiveProxyDict(),
65  conditionsRun) );
66  return getRandomEngine(streamName, randomSeedOffset, ctx);
67 }

◆ GeVToMeV()

void GenBase::GeVToMeV ( HepMC::GenEvent *  evt)
protectedinherited

Scale event energies/momenta by x 1000.

Todo:
Add HepMC units awareness and do it differently when HepMC provides this functionality directly (and reference-based FourVector accessors)

Definition at line 61 of file GenBase.cxx.

61  {
62  for (HepMC::GenEvent::particle_iterator p = evt->particles_begin(); p != evt->particles_end(); ++p) {
63  const HepMC::FourVector fv((*p)->momentum().px() * 1000,
64  (*p)->momentum().py() * 1000,
65  (*p)->momentum().pz() * 1000,
66  (*p)->momentum().e() * 1000);
67  (*p)->set_momentum(fv);
68  (*p)->set_generated_mass(1000 * (*p)->generated_mass());
69  }
70 }

◆ initialize()

StatusCode GenModule::initialize ( )
virtualinherited

Reimplemented from GenBase.

Definition at line 21 of file GenModule.cxx.

21  {
22  // Base class initializations
23  CHECK(GenBase::initialize());
24  // Get the random number service
25  CHECK(m_rndmSvc.retrieve());
26  // Get the incident service
27  CHECK(m_incidentSvc.retrieve());
28  CHECK(genInitialize());
29  CHECK(genuserInitialize());
30  return StatusCode::SUCCESS;
31 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< 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.

◆ leptonSelect()

bool Pythia8B_i::leptonSelect ( Pythia8::Event &  theEvent,
const std::vector< double > &  ptCut,
double  etaCut,
const std::vector< int > &  counts,
int  type_id,
double  massCut,
bool  opposite 
)

Definition at line 508 of file Pythia8B_i.cxx.

508  {
509 
510  if (type_id==0) return true;
511  bool passed(false);
512  std::string accString(" : REJECTED");
513 
514  std::vector<int> leptonIDs;
515  int nCuts=ptCut.size();
516  std::vector<int> countGood(nCuts, 0);
517 
518  for (int i = 0; i<theEvent.size(); ++i) {
519  const Pythia8::Particle &theParticle = theEvent[i];
520  int id = theParticle.idAbs();
521  if ( id == type_id ) { // find lepton flavour requested by user
522  double pt = theParticle.pT();
523  double eta = theParticle.eta();
524  ATH_MSG_DEBUG("Lepton of type " << id << " with pt/eta " << pt << "/" << eta);
525  for (int cutCntr=0; cutCntr<nCuts; ++cutCntr) {
526  if ( (pt>ptCut[cutCntr]) && (std::abs(eta)<etaCut) ) {
527  countGood[cutCntr] += 1;
528  leptonIDs.push_back(i); // remember leptons
529  }
530  }
531  }
532  // can the loop stop?
533  int nPassed(0);
534  for (int cutCntr=0; cutCntr<nCuts; ++cutCntr) {
535  if (countGood[cutCntr] >= counts[cutCntr]) ++nPassed;
536  }
537  if (nPassed==nCuts) break;
538  } // end of loop over particles
539 
540  // Check the accumulated counts
541  int nPassed(0);
542  for (int cutCntr=0; cutCntr<nCuts; ++cutCntr) {
543  if (countGood[cutCntr] >= counts[cutCntr]) ++nPassed;
544  }
545  if (nPassed >= nCuts && nCuts==1) {accString=" : ACCEPTED"; passed = true;} // only 1 lepton required so no pair properties
546  if (nPassed >= nCuts && nCuts>1 && pairProperties(theEvent,leptonIDs,massCut,opposite)) {accString=" : ACCEPTED"; passed = true;}
547  ATH_MSG_DEBUG("Trigger-like selection" << accString);
548  return passed;
549 }

◆ MeVToGeV()

void GenBase::MeVToGeV ( HepMC::GenEvent *  evt)
protectedinherited

Scale event energies/momenta by x 1/1000.

Definition at line 71 of file GenBase.cxx.

71  {
72  for (HepMC::GenEvent::particle_iterator p = evt->particles_begin(); p != evt->particles_end(); ++p) {
73  const HepMC::FourVector fv((*p)->momentum().px() / 1000,
74  (*p)->momentum().py() / 1000,
75  (*p)->momentum().pz() / 1000,
76  (*p)->momentum().e() / 1000);
77  (*p)->set_momentum(fv);
78  (*p)->set_generated_mass((*p)->generated_mass() / 1000);
79  }
80 }

◆ mmTocm()

void GenBase::mmTocm ( HepMC::GenEvent *  evt)
protectedinherited

Scale event lengths by x 1/10.

Definition at line 90 of file GenBase.cxx.

90  {
91  for (HepMC::GenEvent::vertex_iterator vtx = evt->vertices_begin(); vtx != evt->vertices_end(); ++vtx) {
92  const HepMC::FourVector fv((*vtx)->position().x() / 10,
93  (*vtx)->position().y() / 10,
94  (*vtx)->position().z() / 10,
95  (*vtx)->position().t() / 10);
96  (*vtx)->set_position(fv);
97  }
98 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< 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< 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.

◆ pairProperties()

bool Pythia8B_i::pairProperties ( Pythia8::Event &  theEvent,
const std::vector< int > &  leptonIDs,
double  massCut,
bool  opposite 
)

Definition at line 578 of file Pythia8B_i.cxx.

578  {
579 
580  bool passesCuts(false);
581  std::string accString(" : REJECTED");
582  for (auto iit = leptonIDs.begin(); iit!=leptonIDs.end(); ++iit) {
583  for (auto iit2 = iit+1; iit2!=leptonIDs.end(); ++iit2) {
584  int q1=theEvent[*iit].charge();
585  int q2=theEvent[*iit2].charge();
586  if (opposite && (q1*q2>0)) continue;
587  double px1=theEvent[*iit].px();
588  double py1=theEvent[*iit].py();
589  double pz1=theEvent[*iit].pz();
590  double mass1=theEvent[*iit].mSel();
591  double e1=std::sqrt(px1*px1+py1*py1+pz1*pz1+mass1*mass1);
592  double px2=theEvent[*iit2].px();
593  double py2=theEvent[*iit2].py();
594  double pz2=theEvent[*iit2].pz();
595  double mass2=theEvent[*iit2].mSel();
596  double e2=std::sqrt(px2*px2+py2*py2+pz2*pz2+mass2*mass2);
597  double eSum=e1+e2;
598  double pxSum=px1+px2;
599  double pySum=py1+py2;
600  double pzSum=pz1+pz2;
601  double M=std::sqrt(eSum*eSum-pxSum*pxSum-pySum*pySum-pzSum*pzSum);
602  if (M>massCut) {
603  passesCuts=true;
604  ATH_MSG_DEBUG("Acceptable lepton pair with invariant mass : " << M);
605  break;
606  }
607  }
608  if (passesCuts) {accString=" : ACCEPTED"; break;}
609  }
610  ATH_MSG_DEBUG("Dilepton selection" << accString);
611  return passesCuts;
612 }

◆ particleData()

const HepPDT::ParticleData* GenBase::particleData ( int  pid) const
inlineinherited

Access an element in the particle data table.

Definition at line 126 of file GenBase.h.

126  {
127  return pdt().particle(HepPDT::ParticleID(std::abs(pid)));
128  }

◆ particleTable()

const HepPDT::ParticleDataTable& GenBase::particleTable ( ) const
inlineinherited

Get a particle data table.

Definition at line 118 of file GenBase.h.

118  {
119  return *(m_ppSvc->PDT());
120  }

◆ partPropSvc()

const ServiceHandle<IPartPropSvc> GenBase::partPropSvc ( ) const
inlineinherited

Access the particle property service.

Definition at line 113 of file GenBase.h.

113  {
114  return m_ppSvc;
115  }

◆ passesEtaCuts()

bool Pythia8B_i::passesEtaCuts ( const std::vector< Pythia8::Particle > &  theParticles) const

Definition at line 677 of file Pythia8B_i.cxx.

677  {
678 
679  bool pass(true);
680  unsigned int i(0);
681  for (auto pItr=theParticles.cbegin(); pItr!=theParticles.cend(); ++pItr,++i) {
682  if (std::abs((*pItr).eta()) > m_sigEtaCuts[i]) pass = false;
683  if (!pass) break;
684  }
685 
686  return pass;
687 
688 }

◆ passesPTCuts()

bool Pythia8B_i::passesPTCuts ( const std::vector< Pythia8::Particle > &  theParticles) const

Definition at line 665 of file Pythia8B_i.cxx.

665  {
666 
667  bool pass(true);
668  unsigned int i(0);
669  for (auto pItr=theParticles.cbegin(); pItr!=theParticles.cend(); ++pItr,++i) {
670  if ((*pItr).pT() < m_sigPtCuts[i]) pass = false;
671  if (!pass) break;
672  }
673  return pass;
674 
675 }

◆ pdt()

const HepPDT::ParticleDataTable& GenBase::pdt ( ) const
inlineinherited

Shorter alias to get a particle data table.

Definition at line 123 of file GenBase.h.

123 { return particleTable(); }

◆ printSignalSelections()

void Pythia8B_i::printSignalSelections ( const std::vector< int > &  signalProcess,
const std::vector< double > &  ptCuts,
const std::vector< double > &  etaCuts,
unsigned int  nRequired 
) const

Definition at line 760 of file Pythia8B_i.cxx.

760  {
761  std::cout << "Signal PDG codes required: ";
762  for (unsigned int k=0; k<m_sigCodes.size(); ++k) std::cout << signalProcess[k] << " ";
763  if (signalProcess.size()==ptCuts.size()) {
764  std::cout << "Cuts on the pt of the signal states: " << std::endl;
765  for (unsigned int l=0; l<ptCuts.size(); ++l) std::cout << ptCuts[l] << " ";
766  }
767  if (signalProcess.size()==etaCuts.size()) {
768  std::cout << "Cuts on the eta of the signal states: " << std::endl;
769  for (unsigned int l=0; l<etaCuts.size(); ++l) std::cout << etaCuts[l] << " ";
770  }
771  std::cout << "Number of such decays required per event: " << nRequired << std::endl;
772  std::cout << std::endl;
773 }

◆ pythia_stream()

const std::string & Pythia8_i::pythia_stream ( )
staticinherited

Definition at line 782 of file Pythia8_i.cxx.

782  {
783  return s_pythia_stream;
784 }

◆ pythiaVersion()

double Pythia8_i::pythiaVersion ( ) const
inherited

Definition at line 777 of file Pythia8_i.cxx.

777  {
778  return m_version;
779 }

◆ 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< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ s_allowedTunes()

static int Pythia8_i::s_allowedTunes ( double  version)
staticprivateinherited

◆ signalAccept()

bool Pythia8B_i::signalAccept ( Pythia8::Event &  theEvent,
const std::vector< int > &  requiredDecay,
unsigned int  nRequired 
) const

Definition at line 693 of file Pythia8B_i.cxx.

694  {
695 
696  bool acceptEvent(false);
697  std::vector<int> parentsIndices;
698  for (int i = 0; i<theEvent.size(); ++i) {
699  const Pythia8::Particle &theParticle = theEvent[i];
700  int id = theParticle.id();
701  if (id==requiredDecay[0]) parentsIndices.push_back(i);
702  }
703 
704  // For the special case where the user merely requires a particular
705  // species to be in the event (mainly for EvtGen use)
706  if ( (requiredDecay.size()==1) && (parentsIndices.size()>0) ) {
707  acceptEvent = true;
708  return acceptEvent;
709  }
710 
711  unsigned int goodDecayCounter(0);
712  for (std::vector<int>::iterator iItr = parentsIndices.begin(); iItr!=parentsIndices.end(); ++iItr) {
713  std::vector<Pythia8::Particle> decayMembers;
714  descendThroughDecay(theEvent,decayMembers,*iItr);
715  std::vector<int> pdgCodes = getCodes(decayMembers);
716  if (!compare(requiredDecay,pdgCodes)) {
717  ATH_MSG_DEBUG("Signal event REJECTED as does not contain required decay chain");
718  continue;
719  }
720  ATH_MSG_DEBUG("Event contains required signal decay chain");
721 
722  if (decayMembers.size()==m_sigPtCuts.size()) {
723  if (!passesPTCuts(decayMembers)) {
724  ATH_MSG_DEBUG("Signal event REJECTED as signal chain does not pass pt cuts");
725  continue;
726  }
727  }
728 
729  if (decayMembers.size()==m_sigEtaCuts.size()) {
730  if (!passesEtaCuts(decayMembers)) {
731  ATH_MSG_DEBUG("Signal event REJECTED as signal chain does not pass eta cuts");
732  continue;
733  }
734  }
735  if (nRequired==1) {
736  ATH_MSG_DEBUG("Signal decay good; event ACCEPTED");
737  acceptEvent = true;
738  break;
739  }
740  else {++goodDecayCounter;}
741  }
742  if (nRequired>1) {
743  if (goodDecayCounter>=nRequired) {
744  ATH_MSG_DEBUG(nRequired << "signal decays required; " << goodDecayCounter << " found; event ACCEPTED");
745  acceptEvent = true;
746  }
747  else if (goodDecayCounter<nRequired) {
748  ATH_MSG_DEBUG(nRequired << "signal decays required; " << goodDecayCounter << " found; event REJECTED");
749  acceptEvent = false;
750  }
751  }
752 
753  return acceptEvent;
754 
755 }

◆ sysInitialize()

StatusCode AthAlgorithm::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< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< 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< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

◆ useRndmGenSvc()

bool Pythia8_i::useRndmGenSvc ( ) const
inlineprotectedinherited

Definition at line 86 of file Pythia8_i.h.

86 { return m_useRndmGenSvc; }

◆ userSelection()

bool Pythia8B_i::userSelection ( Pythia8::Event &  event,
std::string  userString,
std::vector< double >  userVars 
)

Definition at line 236 of file UserSelections.h.

237  {
238 
239  using CLHEP::HepLorentzVector;
240  bool accept(false);
241 
242  // ==================================================
243  // code up your selection here; as many blocks as
244  // needed can be inserted
245  if (userString == "EXAMPLE" && event.size() > 0 && userVars.size() > 0) {
246 
247  accept = true;
248 
249  }
250 
251  // ==================================================
252  // selects decays where a B-hadron decays to a J/psi
253  // by any route
254  // Accepts event if event contains a B which (eventually)
255  // goes to a J/psi
256 
257  else if (userString == "BJPSIINCLUSIVE" && event.size() > 0) {
258  int chargeConj = 1;
259  if (userVars.size()==0) {
260  ATH_MSG_INFO("User selection BJPSIINCLUSIVE with B-state");
261  }
262  if (userVars.size()>0) {
263  if (userVars.size()>1) ATH_MSG_WARNING("User selection BJPSIINCLUSIVE with more than one argument! Check job options");
264  if (userVars.at(0)>0) ATH_MSG_DEBUG("User selection BJPSIINCLUSIVE with B-state");
265  if (userVars.at(0)<0) {ATH_MSG_DEBUG("User selection BJPSIINCLUSIVE with anti-B-state"); chargeConj = -1;}
266  }
267 
268  // B-decay codes which can go to charmonium
269  std::vector<int> bToCharmoniaCodes;
270  bToCharmoniaCodes.push_back(511*chargeConj);
271  bToCharmoniaCodes.push_back(521*chargeConj);
272  bToCharmoniaCodes.push_back(531*chargeConj);
273  bToCharmoniaCodes.push_back(541*chargeConj);
274  bToCharmoniaCodes.push_back(-5122*chargeConj);
275  bToCharmoniaCodes.push_back(-5132*chargeConj);
276  bToCharmoniaCodes.push_back(-5232*chargeConj);
277  bToCharmoniaCodes.push_back(-5332*chargeConj);
278 
279  int eventSize = event.size();
280 
281  bool isBtoJpsi(false);
282  bool containsB(false);
283  // loop over all particles in the event
284  for (int i = 0; i < eventSize; i++) {
285  int pdgID = event[i].id();
286  std::vector < Pythia8::Particle > decayMembers;
287  bool isB(false);
288  // Does event contain B which can go to J/psi?
289  for (unsigned int k = 0; k < bToCharmoniaCodes.size(); ++k) {
290  if (pdgID == bToCharmoniaCodes[k]) {
291  containsB = true;
292  isB = true;
293  break;
294  }
295  }
296  // Get decay chain of the B; see if there is a J/psi
297  if (isB) {
298  descendThroughDecay(event, decayMembers, i);
299  std::vector<int> pdgCodes = getCodes(decayMembers);
300  for (unsigned int k = 0; k < pdgCodes.size(); ++k) {
301  if (pdgCodes[k] == 443)
302  isBtoJpsi = true;
303  }
304  }
305  if (isBtoJpsi)
306  break;
307  }
308  if (containsB && isBtoJpsi)
309  accept = true;
310  if (containsB && !isBtoJpsi)
311  accept = false;
312  if (!containsB)
313  accept = false;
314 
315  }
316 
317  // ==================================================
318  // prototype for Bs->J/psi phi angular distribution
319  // (Adam Barton)
320 
321  else if ((userString == "BJPSIPHI_TRANS" || userString == "BJPSIPHI_HEL")
322  && event.size() > 0) {
323 
324  const bool debug = false;
325  bool flat;
326 
327  //Read
328  //userVars[0] 0(flat)/1(angle)
329  //[1] prob_limit
330  //[2] tag mode
331  //[3] A0
332  //[4] Al
333  //[5] As
334  //[6] GammaS
335  //[7] DeltaGamma
336  //[8] DeltaM
337  //[9] phiS
338  //[10] delta_p
339  //[11] delta_l
340  //[12]delta_s
341 
342  if (userVars.size() < 13) {
343  ATH_MSG_WARNING(
344  "REQUIRED userVARs not provided for BsJpsiPhi pdf defaulting to flat");
345  flat = true;
346  } else {
347  flat = userVars[0] == 0.0;
348 
349  }
350 
351  // for(int i=0; i<10;i++){
352  // ATH_MSG_INFO("BJPSIPHI_TRANS: " << i << " random number: " << Rdmengine->flat());
353  //
354  // }
355 
356  // std::vector<Pythia8::Particle> decayMembers;
357 
358  int i_Bs = 0;
359  int i_Muplus = 0;
360  int i_Muminus = 0;
361  int i_Kplus = 0;
362  int i_Kminus = 0;
363  int i_Phi = 0;
364  int i_Jpsi = 0;
365 
366  bool isBsJpsiPhi = false;
367  int eventSize = event.size();
368  for (int i = 0; i < eventSize; i++) {
369 
370  int pID = event[i].id();
371  if (std::abs(pID) == 531) { //NOTE THIS WILL FIND BS AND ANTIBS
372  i_Bs = i;
373  std::vector<int> daughterlist = event.daughterList(i);
374 
375  if (daughterlist.size() != 2)
376  continue;
377  bool isjpsi = false;
378  bool isphi = false;
379  if (event[daughterlist[0]].id() == 443) {
380  isjpsi = true;
381  i_Jpsi = daughterlist[0];
382  }
383  if (event[daughterlist[1]].id() == 443) {
384  isjpsi = true;
385  i_Jpsi = daughterlist[1];
386  }
387  if (event[daughterlist[0]].id() == 333) {
388  isphi = true;
389  i_Phi = daughterlist[0];
390  }
391  if (event[daughterlist[1]].id() == 333) {
392  isphi = true;
393  i_Phi = daughterlist[1];
394  }
395  if (!isphi || !isjpsi)
396  continue;
397  std::vector<int> daughterlistJpsi = event.daughterList(i_Jpsi);
398  std::vector<int> daughterlistPhi = event.daughterList(i_Phi);
399  if (daughterlistJpsi.size() != 2 || daughterlistPhi.size() != 2)
400  continue;
401  //resets values to avoid possible bug
402 
403  if (event[daughterlistJpsi[0]].id() == 13)
404  i_Muminus = daughterlistJpsi[0];
405  else if (event[daughterlistJpsi[1]].id() == 13)
406  i_Muminus = daughterlistJpsi[1];
407  else
408  i_Muminus = 0;
409 
410  if (event[daughterlistJpsi[0]].id() == -13)
411  i_Muplus = daughterlistJpsi[0];
412  else if (event[daughterlistJpsi[1]].id() == -13)
413  i_Muplus = daughterlistJpsi[1];
414  else
415  i_Muplus = 0;
416 
417  if (event[daughterlistPhi[0]].id() == 321)
418  i_Kplus = daughterlistPhi[0];
419  else if (event[daughterlistPhi[1]].id() == 321)
420  i_Kplus = daughterlistPhi[1];
421  else
422  i_Kplus = 0;
423 
424  if (event[daughterlistPhi[0]].id() == -321)
425  i_Kminus = daughterlistPhi[0];
426  else if (event[daughterlistPhi[1]].id() == -321)
427  i_Kminus = daughterlistPhi[1];
428  else
429  i_Kminus = 0;
430  if (i_Muminus == 0 || i_Muplus == 0 || i_Kminus == 0 || i_Kplus
431  == 0)
432  continue;
433  else {
434  if (debug)
435  ATH_MSG_INFO(
436  "found entire Bs->Jpsi(mumu)phi(KK) decay ");
437  isBsJpsiPhi = true;
438  break;
439  }
440  }
441  }
442 
443  if (!isBsJpsiPhi)
444  return false;
445  if (flat)
446  return true;
447 
448  Pythia8::Particle &p_Bs = event[i_Bs];
449  Pythia8::Particle &p_Muplus = event[i_Muplus];
450  Pythia8::Particle &p_Muminus = event[i_Muminus];
451  Pythia8::Particle &p_Kplus = event[i_Kplus];
452  Pythia8::Particle &p_Kminus = event[i_Kminus];
453  Pythia8::Particle &p_Phi = event[i_Phi];
454  Pythia8::Particle &p_Jpsi = event[i_Jpsi];
455 
456  // cout << "Bs " << p_Bs.id() << endl;
457  // cout << "|> " << p_Jpsi.id() << " + " << p_Phi.id() << endl;
458  // cout << "|> " << p_Muplus.id() << " + " << p_Muminus.id() << " + " << p_Kplus.id() << " + " << p_Kminus.id() << endl;
459 
460 
461  HepLorentzVector v_Bs = convertVector(p_Bs.p());
462  HepLorentzVector v_Muplus = convertVector(p_Muplus.p());
463  HepLorentzVector v_Muminus = convertVector(p_Muminus.p());
464  HepLorentzVector v_Kplus = convertVector(p_Kplus.p());
465  HepLorentzVector v_Kminus = convertVector(p_Kminus.p());
466  HepLorentzVector v_Phi = convertVector(p_Phi.p());
467  HepLorentzVector v_Jpsi = convertVector(p_Jpsi.p());
468 
469  BsJpsiPhiAngles angles(v_Kplus, v_Muplus, v_Phi, v_Jpsi, v_Bs);
470 
471  CLHEP::HepRandomEngine* Rdmengine = Pythia8B_i::p_rndmEngine;
472  const double gentau = Pythia8_i::m_pythia->particleData.tau0(531);
473  const double correctionfactor = 0.299792458;
474  const double gentauCorrect = gentau / correctionfactor;
475  if (debug) {
476  ATH_MSG_INFO("Lifetime for 531: " << gentau);
477  ATH_MSG_INFO("correct lifetime " << gentauCorrect);
478  }
479  const double Bstau = p_Bs.tau() / correctionfactor;
480  double prob1 = 1000;
481 
482  //PUT PDFS HERE
483  if (userString == "BJPSIPHI_TRANS") {
484  double x[5];
485  x[0] = Bstau;
486  x[1] = angles.thetatrfix();
487  x[2] = angles.thetaKfix();
488  x[3] = angles.phitrfix();
489  x[4] = userVars[2];
490 
491  prob1 = BsJpsiPhi_PDF(&userVars[3], x, false);
492  } else if (userString == "BJPSIPHI_HEL") {
493  double x[5];
494  x[0] = Bstau;
495  x[1] = angles.thetaLfix();
496  x[2] = angles.thetaKfix();
497  x[3] = angles.chifix();
498  x[4] = userVars[2];
499 
500  prob1 = BsJpsiPhi_PDF(&userVars[3], x, true);
501  }
502 
503  const double prob2 = exp(Bstau / gentauCorrect) * gentauCorrect;
504  if (Bstau > 20)
505  ATH_MSG_WARNING("Warning Bstau > 20 ps, this could indicate a bug");
506  const double prob_norm = userVars[1];
507  if (debug) {
508  ATH_MSG_INFO("prob limit set to " << prob_norm);
509  ATH_MSG_INFO("This Bs has lifetime " << Bstau);
510  }
511  double rand = Rdmengine->flat() * prob_norm;
512  if (prob1 * prob2 > prob_norm) {
513  ATH_MSG_WARNING(
514  "Max prob exceeded, too many of these indicates a problem, a few is fine");
515  }
516  if (debug)
517  std::cout << "totalprob " << prob1 * prob2 << std::endl;
518  if (rand < (prob1 * prob2)) {
519 
520  if (debug)
521  ATH_MSG_INFO("Passed PDF filter");
522  accept = true;
523  } else {
524  if (debug)
525  ATH_MSG_INFO("Rejected PDF filter");
526  accept = false;
527  }
528 
529  } // end of Bs->J/psiphi
530  else if(userString == "BD_BPLUS_TAUCUT"){
531  const double correctionfactor = 0.299792458;
532  bool pass = true;
533  int eventSize = event.size();
534  int foundcount=0;
535  for (int i = 0; i < eventSize; i++) {
536  int pID = event[i].id();
537  if (pID == 511) {
538  const double Bdtau = event[i].tau() / correctionfactor;
539  pass &= Bdtau > userVars[0] && Bdtau < userVars[1];
540  foundcount++;
541  }
542  if (pID == 521) {
543  const double Bptau = event[i].tau() / correctionfactor;
544  pass &= Bptau > userVars[0] && Bptau < userVars[1];
545  foundcount++;
546  }
547  }
548  accept = (foundcount > 0) & pass;
549  }
550 
551  else if ((userString == "BDJPSIKSTAR_TRANS") && event.size() > 0) {
552  const bool debug = false;
553  bool flat;
554  if (userVars.size() < 13) {
555  ATH_MSG_WARNING(
556  "REQUIRED userVARs not provided for BdJpsiKstar pdf defaulting to flat");
557  flat = true;
558  } else {
559  flat = userVars[0] == 0.0;
560  }
561 
562  int i_Bd = 0;
563  int i_Muplus = 0;
564  int i_Muminus = 0;
565  int i_Kplus = 0;
566  int i_piminus = 0;
567  int i_Kstar = 0;
568  int i_Jpsi = 0;
569 
570  bool isBsJpsiKstar = false;
571  const int eventSize = event.size();
572  for (int i = 0; i < eventSize; i++) {
573 
574  const int pID = event[i].id();
575  if (std::abs(pID) == 511) { //NOTE THIS FIND BD and Anti-Bd
576  i_Bd = i;
577  std::vector<int> daughterlist = event.daughterList(i);
578 
579  if (daughterlist.size() != 2)
580  continue;
581  bool isjpsi = false;
582  bool iskstar = false;
583  if (event[daughterlist[0]].id() == 443) {
584  isjpsi = true;
585  i_Jpsi = daughterlist[0];
586  }
587  if (event[daughterlist[1]].id() == 443) {
588  isjpsi = true;
589  i_Jpsi = daughterlist[1];
590  }
591  if (std::abs(event[daughterlist[0]].id()) == 313) { //This will find kstar or KstarBar
592  iskstar = true;
593  i_Kstar = daughterlist[0];
594  }
595  if (std::abs(event[daughterlist[1]].id()) == 313) { //This will find kstar or KstarBar
596  iskstar = true;
597  i_Kstar = daughterlist[1];
598  }
599  if (!iskstar || !isjpsi)
600  continue;
601  std::vector<int> daughterlistJpsi = event.daughterList(i_Jpsi);
602  std::vector<int> daughterlistKstar = event.daughterList(i_Kstar);
603  if (daughterlistJpsi.size() != 2 || daughterlistKstar.size() != 2)
604  continue;
605  //resets values to avoid possible bug
606 
607  if (event[daughterlistJpsi[0]].id() == 13)
608  i_Muminus = daughterlistJpsi[0];
609  else if (event[daughterlistJpsi[1]].id() == 13)
610  i_Muminus = daughterlistJpsi[1];
611  else
612  i_Muminus = 0;
613 
614  if (event[daughterlistJpsi[0]].id() == -13)
615  i_Muplus = daughterlistJpsi[0];
616  else if (event[daughterlistJpsi[1]].id() == -13)
617  i_Muplus = daughterlistJpsi[1];
618  else
619  i_Muplus = 0;
620 
621  if (std::abs(event[daughterlistKstar[0]].id()) == 321)
622  i_Kplus = daughterlistKstar[0];
623  else if (std::abs(event[daughterlistKstar[1]].id()) == 321)
624  i_Kplus = daughterlistKstar[1];
625  else
626  i_Kplus = 0;
627 
628  if (std::abs(event[daughterlistKstar[0]].id()) == 211)
629  i_piminus = daughterlistKstar[0];
630  else if (std::abs(event[daughterlistKstar[1]].id()) == 211)
631  i_piminus = daughterlistKstar[1];
632  else
633  i_piminus = 0;
634 
635  if (i_Muminus == 0 || i_Muplus == 0 || i_piminus == 0 || i_Kplus
636  == 0)
637  continue;
638 
639  if (debug)
640  ATH_MSG_INFO(
641  "found entire Bd->Jpsi(mumu)Kstar(KPi) decay ");
642  isBsJpsiKstar = true;
643  break;
644 
645  }
646  }
647 
648  if (!isBsJpsiKstar)
649  return false;
650  if (flat)
651  return true;
652 
653  Pythia8::Particle &p_Bd = event[i_Bd];
654  Pythia8::Particle &p_Muplus = event[i_Muplus];
655  Pythia8::Particle &p_Muminus = event[i_Muminus];
656  Pythia8::Particle &p_Kplus = event[i_Kplus];
657  //Pythia8::Particle &p_piminus = event[i_piminus];
658  Pythia8::Particle &p_Kstar = event[i_Kstar];
659  Pythia8::Particle &p_Jpsi = event[i_Jpsi];
660 
661  // cout << "Bs " << p_Bs.id() << endl;
662  // cout << "|> " << p_Jpsi.id() << " + " << p_Phi.id() << endl;
663  // cout << "|> " << p_Muplus.id() << " + " << p_Muminus.id() << " + " << p_Kplus.id() << " + " << p_Kminus.id() << endl;
664 
665 
666  HepLorentzVector v_Bd = convertVector(p_Bd.p());
667  HepLorentzVector v_Muplus = convertVector(p_Muplus.p());
668  HepLorentzVector v_Muminus = convertVector(p_Muminus.p());
669  HepLorentzVector v_Kplus = convertVector(p_Kplus.p());
670  //HepLorentzVector v_piminus = convertVector(p_piminus.p());
671  HepLorentzVector v_Kstar = convertVector(p_Kstar.p());
672  HepLorentzVector v_Jpsi = convertVector(p_Jpsi.p());
673 
674  BsJpsiPhiAngles angles(v_Kplus, v_Muplus, v_Kstar, v_Jpsi, v_Bd);
675 
676  CLHEP::HepRandomEngine* Rdmengine = Pythia8B_i::p_rndmEngine;
677  const double gentau = Pythia8_i::m_pythia->particleData.tau0(511);
678  const double correctionfactor = 0.299792458;
679  const double gentauCorrect = gentau / correctionfactor;
680  if (debug) {
681  ATH_MSG_INFO("Lifetime for 511: " << gentau);
682  ATH_MSG_INFO("correct lifetime " << gentauCorrect);
683  }
684  const double Bdtau = p_Bd.tau() / correctionfactor;
685  double prob1;
686 
687  //PUT PDFS HERE
688 
689  double x[5];
690  x[0] = Bdtau;
691  x[1] = angles.thetatrfix();
692  x[2] = angles.thetaKfix();
693  x[3] = angles.phitrfix();
694  x[4] = userVars[2];
695  prob1 = BsJpsiPhi_PDF(&userVars[3], x, false);
696 
697 
698  const double prob2 = exp(Bdtau / gentauCorrect) * gentauCorrect;
699  if (Bdtau > 20)
700  ATH_MSG_WARNING("Warning Bdtau > 20 ps, this could indicate a bug");
701  const double prob_norm = userVars[1];
702  if (debug) {
703  ATH_MSG_INFO("prob limit set to " << prob_norm);
704  ATH_MSG_INFO("This Bd has lifetime " << Bdtau);
705  }
706  const double rand = Rdmengine->flat() * prob_norm;
707  if (prob1 * prob2 > prob_norm) {
708  ATH_MSG_WARNING(
709  "Max prob exceeded, too many of these indicates a problem, a few is fine");
710  }
711  if (debug)
712  std::cout << "totalprob " << prob1 * prob2 << std::endl;
713  if (rand < (prob1 * prob2)) {
714  if (debug)
715  ATH_MSG_INFO("Passed PDF filter");
716  accept = true;
717  } else {
718  if (debug)
719  ATH_MSG_INFO("Rejected PDF filter");
720  accept = false;
721  }
722  }
723 
724  return (accept);
725 
726 }

◆ xmlpath()

std::string Pythia8_i::xmlpath ( )
staticinherited

Definition at line 787 of file Pythia8_i.cxx.

787  {
788 
789 
790  std::string foundpath = "";
791 
792 // Try to find the xmldoc directory using PathResolver:
793  foundpath = PathResolverFindCalibDirectory( "Pythia8/xmldoc" );
794 
795  return foundpath;
796 }

Member Data Documentation

◆ m_and

bool Pythia8B_i::m_and
private

Definition at line 54 of file Pythia8B_i.h.

◆ m_aqEtaCut

double Pythia8B_i::m_aqEtaCut
private

Definition at line 55 of file Pythia8B_i.h.

◆ m_aqPtCut

double Pythia8B_i::m_aqPtCut
private

Definition at line 55 of file Pythia8B_i.h.

◆ m_athenaTool

PublicToolHandle<IPythia8Custom> Pythia8_i::m_athenaTool {this, "CustomInterface", ""}
privateinherited

Definition at line 166 of file Pythia8_i.h.

◆ m_atlasRndmEngine

std::shared_ptr<customRndm> Pythia8_i::m_atlasRndmEngine {}
protectedinherited

Definition at line 93 of file Pythia8_i.h.

◆ m_atLeastOneAcc

int Pythia8B_i::m_atLeastOneAcc
private

Definition at line 51 of file Pythia8B_i.h.

◆ m_bcodes

std::vector<int> Pythia8B_i::m_bcodes
private

Definition at line 48 of file Pythia8B_i.h.

◆ m_beam1

StringProperty Pythia8_i::m_beam1 {this, "Beam1", "PROTON"}
privateinherited

Definition at line 120 of file Pythia8_i.h.

◆ m_beam2

StringProperty Pythia8_i::m_beam2 {this, "Beam2", "PROTON"}
privateinherited

Definition at line 121 of file Pythia8_i.h.

◆ m_BEventBuffer

std::vector<Pythia8::Event> Pythia8B_i::m_BEventBuffer
private

Definition at line 58 of file Pythia8B_i.h.

◆ m_collisionEnergy

DoubleProperty Pythia8_i::m_collisionEnergy {this, "CollisionEnergy", 14000.0}
privateinherited

Definition at line 117 of file Pythia8_i.h.

◆ m_commands

StringArrayProperty Pythia8_i::m_commands {this, "Commands", {} }
privateinherited

Definition at line 111 of file Pythia8_i.h.

◆ m_computeEfficiency

BooleanProperty Pythia8_i::m_computeEfficiency {this, "computeEfficiency", false}
privateinherited

Definition at line 129 of file Pythia8_i.h.

◆ m_conversion

double Pythia8_i::m_conversion {1.}
privateinherited

Definition at line 133 of file Pythia8_i.h.

◆ m_cutCount

std::vector<int> Pythia8B_i::m_cutCount
private

Definition at line 48 of file Pythia8B_i.h.

◆ m_dec

unsigned int Pythia8B_i::m_dec
private

Definition at line 45 of file Pythia8B_i.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doCKKWLAcceptance

BooleanProperty Pythia8_i::m_doCKKWLAcceptance {this, "CKKWLAcceptance", false}
privateinherited

Definition at line 127 of file Pythia8_i.h.

◆ m_doFxFxXS

BooleanProperty Pythia8_i::m_doFxFxXS {this, "FxFxXS", false}
privateinherited

Definition at line 128 of file Pythia8_i.h.

◆ m_doLHE3Weights

bool Pythia8_i::m_doLHE3Weights {false}
privateinherited

Definition at line 161 of file Pythia8_i.h.

◆ m_doSuppressSmallPT

bool Pythia8B_i::m_doSuppressSmallPT
private

Definition at line 60 of file Pythia8B_i.h.

◆ m_dsid

IntegerProperty Pythia8_i::m_dsid {this, "Dsid", 999999, "Dataset ID number"}
protectedinherited

Definition at line 95 of file Pythia8_i.h.

◆ m_enhanceWeight

double Pythia8_i::m_enhanceWeight {1.0}
privateinherited

Definition at line 158 of file Pythia8_i.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_failureCount

unsigned int Pythia8B_i::m_failureCount
private

Definition at line 62 of file Pythia8B_i.h.

◆ m_had

unsigned int Pythia8B_i::m_had
private

Definition at line 45 of file Pythia8B_i.h.

◆ m_incidentSvc

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

Handle on the incident service.

Definition at line 101 of file GenModule.h.

◆ m_internal_event_number

int Pythia8B_i::m_internal_event_number
private

Definition at line 51 of file Pythia8B_i.h.

◆ m_internalEventNumbers

std::vector<int> Pythia8B_i::m_internalEventNumbers
private

Definition at line 59 of file Pythia8B_i.h.

◆ m_invMass

double Pythia8B_i::m_invMass
private

Definition at line 55 of file Pythia8B_i.h.

◆ 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.

◆ m_lheFile

StringProperty Pythia8_i::m_lheFile {this, "LHEFile", ""}
privateinherited

Definition at line 124 of file Pythia8_i.h.

◆ m_maxFailures

UnsignedIntegerProperty Pythia8_i::m_maxFailures {this, "MaxFailures", 10}
protectedinherited

Definition at line 90 of file Pythia8_i.h.

◆ m_mcEventKey

std::string GenBase::m_mcEventKey {}
protectedinherited

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

Definition at line 137 of file GenBase.h.

◆ 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 163 of file GenBase.h.

◆ m_mergingWeight

double Pythia8_i::m_mergingWeight {1.0}
privateinherited

Definition at line 157 of file Pythia8_i.h.

◆ 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 139 of file GenBase.h.

◆ m_nAccepted

double Pythia8_i::m_nAccepted {0.}
privateinherited

Definition at line 130 of file Pythia8_i.h.

◆ m_nMerged

double Pythia8_i::m_nMerged {0.}
privateinherited

Definition at line 131 of file Pythia8_i.h.

◆ m_nSignalRequired

unsigned int Pythia8B_i::m_nSignalRequired
private

Definition at line 47 of file Pythia8B_i.h.

◆ m_numberAlphaS

DoubleProperty Pythia8_i::m_numberAlphaS {this,"numberAlphaS", 3.0}
protectedinherited

Definition at line 99 of file Pythia8_i.h.

◆ m_oppCharges

bool Pythia8B_i::m_oppCharges
private

Definition at line 54 of file Pythia8B_i.h.

◆ m_outputParticleDataFile

StringProperty Pythia8_i::m_outputParticleDataFile {this, "OutputParticleData", "ParticleData.local.xml"}
privateinherited

Definition at line 155 of file Pythia8_i.h.

◆ m_override_transform_beamenergy

bool Pythia8_i::m_override_transform_beamenergy {false}
privateinherited

Definition at line 122 of file Pythia8_i.h.

◆ m_particleDataFile

StringProperty Pythia8_i::m_particleDataFile {this, "ParticleData", ""}
privateinherited

Definition at line 154 of file Pythia8_i.h.

◆ m_particleIDs

std::map<std::string, PDGID> Pythia8_i::m_particleIDs
privateinherited

Definition at line 137 of file Pythia8_i.h.

◆ m_passingTriggerCuts

int Pythia8B_i::m_passingTriggerCuts
private

Definition at line 51 of file Pythia8B_i.h.

◆ m_ppSvc

ServiceHandle<IPartPropSvc> GenBase::m_ppSvc {this, "PartPropSvc", "PartPropSvc"}
privateinherited

Handle on the particle property service.

Definition at line 160 of file GenBase.h.

◆ m_procPtr

std::shared_ptr<Pythia8::Sigma2Process> Pythia8_i::m_procPtr {}
privateinherited

Definition at line 144 of file Pythia8_i.h.

◆ m_pt0timesMPI

DoubleProperty Pythia8_i::m_pt0timesMPI {this,"pT0timesMPI", 1.0}
protectedinherited

Definition at line 98 of file Pythia8_i.h.

◆ m_pythia

std::unique_ptr<Pythia8::Pythia> Pythia8_i::m_pythia {}
protectedinherited

Definition at line 88 of file Pythia8_i.h.

◆ m_pythiaToHepMC

HepMC::Pythia8ToHepMC Pythia8_i::m_pythiaToHepMC
protectedinherited

Definition at line 89 of file Pythia8_i.h.

◆ m_qEtaCut

double Pythia8B_i::m_qEtaCut
private

Definition at line 55 of file Pythia8B_i.h.

◆ m_qPtCut

double Pythia8B_i::m_qPtCut
private

Definition at line 55 of file Pythia8B_i.h.

◆ 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.

◆ m_rndmSvc

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

Data members.

Definition at line 99 of file GenModule.h.

◆ m_sameAlphaSAsMPI

BooleanProperty Pythia8_i::m_sameAlphaSAsMPI {this,"useSameAlphaSasMPI", false}
protectedinherited

Definition at line 100 of file Pythia8_i.h.

◆ m_seeds

std::vector<long int> Pythia8B_i::m_seeds
private

Definition at line 53 of file Pythia8B_i.h.

◆ m_selectBQuarks

bool Pythia8B_i::m_selectBQuarks
private

Definition at line 54 of file Pythia8B_i.h.

◆ m_selectCQuarks

bool Pythia8B_i::m_selectCQuarks
private

Definition at line 54 of file Pythia8B_i.h.

◆ m_showerWeightNames

std::vector<std::string> Pythia8_i::m_showerWeightNames {"nominal"}
privateinherited

Definition at line 163 of file Pythia8_i.h.

◆ m_showerWeightNamesProp

StringArrayProperty Pythia8_i::m_showerWeightNamesProp {this, "ShowerWeightNames", {} }
privateinherited

Definition at line 164 of file Pythia8_i.h.

◆ m_sigCodes

std::vector<int> Pythia8B_i::m_sigCodes
private

Definition at line 48 of file Pythia8B_i.h.

◆ m_sigEtaCuts

std::vector<double> Pythia8B_i::m_sigEtaCuts
private

Definition at line 50 of file Pythia8B_i.h.

◆ m_sigmaTotal

double Pythia8_i::m_sigmaTotal {0.}
privateinherited

Definition at line 132 of file Pythia8_i.h.

◆ m_sigPtCuts

std::vector<double> Pythia8B_i::m_sigPtCuts
private

Definition at line 50 of file Pythia8B_i.h.

◆ m_speciesCount

std::map<int,int> Pythia8B_i::m_speciesCount
private

Definition at line 52 of file Pythia8B_i.h.

◆ m_storeLHE

BooleanProperty Pythia8_i::m_storeLHE {this, "StoreLHE", false}
privateinherited

Definition at line 126 of file Pythia8_i.h.

◆ m_SuppressSmallPT

Pythia8::SuppressSmallPT* Pythia8B_i::m_SuppressSmallPT
private

Definition at line 61 of file Pythia8B_i.h.

◆ m_totalBBarQuark

int Pythia8B_i::m_totalBBarQuark
private

Definition at line 51 of file Pythia8B_i.h.

◆ m_totalBQuark

int Pythia8B_i::m_totalBQuark
private

Definition at line 51 of file Pythia8B_i.h.

◆ m_totalCBarQuark

int Pythia8B_i::m_totalCBarQuark
private

Definition at line 51 of file Pythia8B_i.h.

◆ m_totalClone

int Pythia8B_i::m_totalClone
private

Definition at line 51 of file Pythia8B_i.h.

◆ m_totalCQuark

int Pythia8B_i::m_totalCQuark
private

Definition at line 51 of file Pythia8B_i.h.

◆ m_totalHard

int Pythia8B_i::m_totalHard
private

Definition at line 51 of file Pythia8B_i.h.

◆ m_totalPythiaCalls

int Pythia8B_i::m_totalPythiaCalls
private

Definition at line 51 of file Pythia8B_i.h.

◆ m_trigCode

int Pythia8B_i::m_trigCode
private

Definition at line 46 of file Pythia8B_i.h.

◆ m_trigEtaCut

double Pythia8B_i::m_trigEtaCut
private

Definition at line 55 of file Pythia8B_i.h.

◆ m_trigPtCut

std::vector<double> Pythia8B_i::m_trigPtCut
private

Definition at line 49 of file Pythia8B_i.h.

◆ m_useLHAPDF

BooleanProperty Pythia8_i::m_useLHAPDF {this, "UseLHAPDF", true}
privateinherited

Definition at line 152 of file Pythia8_i.h.

◆ m_userHooks

StringArrayProperty Pythia8_i::m_userHooks {this, "UserHooks", {} }
protectedinherited

Definition at line 96 of file Pythia8_i.h.

◆ m_userHooksPtrs

std::vector<UserHooksPtrType> Pythia8_i::m_userHooksPtrs {}
privateinherited

Definition at line 146 of file Pythia8_i.h.

◆ m_userModes

std::vector<std::string> Pythia8_i::m_userModes
privateinherited

Definition at line 113 of file Pythia8_i.h.

◆ m_useRndmGenSvc

BooleanProperty Pythia8_i::m_useRndmGenSvc {this, "useRndmGenSvc", true, "the max number of consecutive failures"}
protectedinherited

Definition at line 92 of file Pythia8_i.h.

◆ m_userParams

std::vector<std::string> Pythia8_i::m_userParams
privateinherited

Definition at line 112 of file Pythia8_i.h.

◆ m_userProcess

StringProperty Pythia8_i::m_userProcess {this, "UserProcess", ""}
privateinherited

Definition at line 141 of file Pythia8_i.h.

◆ m_userResonancePtrs

std::vector<std::shared_ptr<Pythia8::ResonanceWidths> > Pythia8_i::m_userResonancePtrs
privateinherited

Definition at line 150 of file Pythia8_i.h.

◆ m_userResonances

StringProperty Pythia8_i::m_userResonances {this, "UserResonances", ""}
privateinherited

Definition at line 148 of file Pythia8_i.h.

◆ m_userString

std::string Pythia8B_i::m_userString
private

Definition at line 56 of file Pythia8B_i.h.

◆ m_userVar

std::vector<double> Pythia8B_i::m_userVar
private

Definition at line 57 of file Pythia8B_i.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_version

double Pythia8_i::m_version {-1.}
privateinherited

Definition at line 109 of file Pythia8_i.h.

◆ m_vetoDoubleB

bool Pythia8B_i::m_vetoDoubleB
private

Definition at line 54 of file Pythia8B_i.h.

◆ m_vetoDoubleC

bool Pythia8B_i::m_vetoDoubleC
private

Definition at line 54 of file Pythia8B_i.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_weightCommands

std::vector<std::string> Pythia8_i::m_weightCommands {}
privateinherited

Definition at line 162 of file Pythia8_i.h.

◆ m_weightIDs

std::vector<std::string> Pythia8_i::m_weightIDs {}
privateinherited

Definition at line 159 of file Pythia8_i.h.

◆ m_weightNames

std::vector<std::string> Pythia8_i::m_weightNames {}
privateinherited

Definition at line 160 of file Pythia8_i.h.

◆ p_rndmEngine

CLHEP::HepRandomEngine * Pythia8B_i::p_rndmEngine = nullptr
static

Definition at line 41 of file Pythia8B_i.h.

The documentation for this class was generated from the following files:
grepfile.info
info
Definition: grepfile.py:38
Pythia8_i::NEUTRON
@ NEUTRON
Definition: Pythia8_i.h:115
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Pythia8B_i::m_seeds
std::vector< long int > m_seeds
Definition: Pythia8B_i.h:53
Pythia8B_i::m_totalHard
int m_totalHard
Definition: Pythia8B_i.h:51
ATHRNG::RNGWrapper::setSeed
void setSeed(const std::string &algName, const EventContext &ctx)
Set the random seed using a string (e.g.
Definition: RNGWrapper.h:169
Pythia8_i::m_maxFailures
UnsignedIntegerProperty m_maxFailures
Definition: Pythia8_i.h:90
Pythia8_i::m_enhanceWeight
double m_enhanceWeight
Definition: Pythia8_i.h:158
Pythia8B_i::m_passingTriggerCuts
int m_passingTriggerCuts
Definition: Pythia8B_i.h:51
Pythia8B_i::m_userString
std::string m_userString
Definition: Pythia8B_i.h:56
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
Pythia8B_i::m_aqPtCut
double m_aqPtCut
Definition: Pythia8B_i.h:55
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
Pythia8B_i::m_BEventBuffer
std::vector< Pythia8::Event > m_BEventBuffer
Definition: Pythia8B_i.h:58
Pythia8_i::m_version
double m_version
Definition: Pythia8_i.h:109
Pythia8B_i::m_bcodes
std::vector< int > m_bcodes
Definition: Pythia8B_i.h:48
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Pythia8B_i::m_trigPtCut
std::vector< double > m_trigPtCut
Definition: Pythia8B_i.h:49
Pythia8B_i::passesPTCuts
bool passesPTCuts(const std::vector< Pythia8::Particle > &) const
Definition: Pythia8B_i.cxx:665
Pythia8_i::m_weightNames
std::vector< std::string > m_weightNames
Definition: Pythia8_i.h:160
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
GenModule::fillEvt
virtual StatusCode fillEvt(HepMC::GenEvent *evt)=0
For filling the HepMC event object.
Pythia8B_i::m_had
unsigned int m_had
Definition: Pythia8B_i.h:45
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
GenModule::callGenerator
virtual StatusCode callGenerator()
For calling the generator on each iteration of the event loop.
Definition: GenModule.h:66
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
GenBase::events_const
const McEventCollection * events_const() const
Access the current event's McEventCollection (const)
Definition: GenBase.h:96
SG::ReadHandle< McEventCollection >
Pythia8B_i::passesEtaCuts
bool passesEtaCuts(const std::vector< Pythia8::Particle > &) const
Definition: Pythia8B_i.cxx:677
Pythia8B_i::m_internalEventNumbers
std::vector< int > m_internalEventNumbers
Definition: Pythia8B_i.h:59
Pythia8B_i::m_sigCodes
std::vector< int > m_sigCodes
Definition: Pythia8B_i.h:48
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Pythia8_i::ELECTRON
@ ELECTRON
Definition: Pythia8_i.h:115
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition: CutsMETMaker.cxx:18
Pythia8B_i::m_vetoDoubleC
bool m_vetoDoubleC
Definition: Pythia8B_i.h:54
JiveXML::Event
struct Event_t Event
Definition: ONCRPCServer.h:65
Pythia8B_i::m_totalPythiaCalls
int m_totalPythiaCalls
Definition: Pythia8B_i.h:51
BsJpsiPhiAngles
Definition: BsJpsiPhiAngles.h:9
skel.it
it
Definition: skel.GENtoEVGEN.py:423
GenModule::m_incidentSvc
ServiceHandle< IIncidentSvc > m_incidentSvc
Handle on the incident service.
Definition: GenModule.h:101
test_pyathena.pt
pt
Definition: test_pyathena.py:11
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
HepMC::PYTHIA8LHESTATUS
constexpr int PYTHIA8LHESTATUS
Definition: MagicNumbers.h:43
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
MM
@ MM
Definition: RegSelEnums.h:38
Pythia8B_i::m_failureCount
unsigned int m_failureCount
Definition: Pythia8B_i.h:62
Pythia8B_i::m_speciesCount
std::map< int, int > m_speciesCount
Definition: Pythia8B_i.h:52
HepMC::newGenEvent
GenEvent * newGenEvent(const int a, const int b)
Definition: GenEvent.h:502
Pythia8B_i::m_totalCBarQuark
int m_totalCBarQuark
Definition: Pythia8B_i.h:51
Pythia8B_i::m_doSuppressSmallPT
bool m_doSuppressSmallPT
Definition: Pythia8B_i.h:60
Pythia8_i::m_userHooks
StringArrayProperty m_userHooks
Definition: Pythia8_i.h:96
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
Pythia8B_i::m_internal_event_number
int m_internal_event_number
Definition: Pythia8B_i.h:51
Pythia8B_i::m_invMass
double m_invMass
Definition: Pythia8B_i.h:55
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
Pythia8B_i::m_selectBQuarks
bool m_selectBQuarks
Definition: Pythia8B_i.h:54
convertVector
CLHEP::HepLorentzVector convertVector(const Pythia8::Vec4 v)
Definition: UserSelections.h:17
Pythia8B_i::getCodes
std::vector< int > getCodes(const std::vector< Pythia8::Particle > &) const
Definition: Pythia8B_i.cxx:632
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
BsJpsiPhi_PDF
double BsJpsiPhi_PDF(double *params, double *x, bool useHelicity)
Definition: UserSelections.h:26
x
#define x
HepMC::fillBarcodesAttribute
void fillBarcodesAttribute(GenEvent *)
Definition: GenEvent.h:504
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
python.DataFormatRates.events
events
Definition: DataFormatRates.py:105
Pythia8_i::ANTIPROTON
@ ANTIPROTON
Definition: Pythia8_i.h:115
xAOD::Particle
Particle_v1 Particle
Define the latest version of the particle class.
Definition: Event/xAOD/xAODParticleEvent/xAODParticleEvent/Particle.h:17
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
GenModule::getRandomEngine
CLHEP::HepRandomEngine * getRandomEngine(const std::string &streamName, const EventContext &ctx) const
Definition: GenModule.cxx:34
Pythia8_i::ANTINEUTRON
@ ANTINEUTRON
Definition: Pythia8_i.h:115
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Pythia8B_i::userSelection
bool userSelection(Pythia8::Event &, std::string, std::vector< double >)
Definition: UserSelections.h:236
Pythia8_i::m_userHooksPtrs
std::vector< UserHooksPtrType > m_userHooksPtrs
Definition: Pythia8_i.h:146
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
PathResolverFindCalibDirectory
std::string PathResolverFindCalibDirectory(const std::string &logical_file_name)
Definition: PathResolver.cxx:432
Pythia8B_i::m_sigPtCuts
std::vector< double > m_sigPtCuts
Definition: Pythia8B_i.h:50
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:200
Pythia8_i::m_doLHE3Weights
bool m_doLHE3Weights
Definition: Pythia8_i.h:161
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
Pythia8B_i::m_aqEtaCut
double m_aqEtaCut
Definition: Pythia8B_i.h:55
GenModule::genuserInitialize
virtual StatusCode genuserInitialize()
For initialization of user code, if required. Called after genInitialize.
Definition: GenModule.h:64
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
GenModule::m_rndmSvc
ServiceHandle< IAthRNGSvc > m_rndmSvc
Data members.
Definition: GenModule.h:99
GenBase::m_ppSvc
ServiceHandle< IPartPropSvc > m_ppSvc
Handle on the particle property service.
Definition: GenBase.h:160
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
python.ExitCodes.codes
dictionary codes
helper to get a human-readable string
Definition: ExitCodes.py:49
Pythia8B_i::m_totalBBarQuark
int m_totalBBarQuark
Definition: Pythia8B_i.h:51
GenModule::genInitialize
virtual StatusCode genInitialize()
For initializing the generator, if required.
Definition: GenModule.h:62
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Pythia8B_i::m_qEtaCut
double m_qEtaCut
Definition: Pythia8B_i.h:55
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Pythia8B_i::m_totalClone
int m_totalClone
Definition: Pythia8B_i.h:51
LArG4FSStartPointFilter.rand
rand
Definition: LArG4FSStartPointFilter.py:80
Pythia8B_i::descendThroughDecay
void descendThroughDecay(Pythia8::Event &, std::vector< Pythia8::Particle > &, int) const
Definition: Pythia8B_i.cxx:617
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
Pythia8B_i::signalAccept
bool signalAccept(Pythia8::Event &, const std::vector< int > &, unsigned int) const
Definition: Pythia8B_i.cxx:693
lumiFormat.i
int i
Definition: lumiFormat.py:92
Pythia8_i::m_showerWeightNames
std::vector< std::string > m_showerWeightNames
Definition: Pythia8_i.h:163
ret
T ret(T t)
Definition: rootspy.cxx:260
Atlas::ExtendedEventContext
Definition: ExtendedEventContext.h:23
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Pythia8_i::m_atlasRndmEngine
std::shared_ptr< customRndm > m_atlasRndmEngine
Definition: Pythia8_i.h:93
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
python.subdetectors.mmg.names
names
Definition: mmg.py:8
Pythia8B_i::m_oppCharges
bool m_oppCharges
Definition: Pythia8B_i.h:54
GenBase::m_mcevents_const
SG::ReadHandleKey< McEventCollection > m_mcevents_const
Const handle to the MC event collection.
Definition: GenBase.h:163
GenModule::m_isAfterburner
BooleanProperty m_isAfterburner
Flag for normal vs. afterburner generators.
Definition: GenModule.h:87
Pythia8B_i::m_dec
unsigned int m_dec
Definition: Pythia8B_i.h:45
Pythia8B_i::m_userVar
std::vector< double > m_userVar
Definition: Pythia8B_i.h:57
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
jobOptions.ParticleID
ParticleID
Definition: jobOptions.decayer.py:85
GenModule::genFinalize
virtual StatusCode genFinalize()
For finalising the generator, if required.
Definition: GenModule.h:70
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
Pythia8B_i::m_cutCount
std::vector< int > m_cutCount
Definition: Pythia8B_i.h:48
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
Pythia8B_i::leptonSelect
bool leptonSelect(Pythia8::Event &, const std::vector< double > &, double, const std::vector< int > &, int, double, bool)
Definition: Pythia8B_i.cxx:508
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Pythia8B_i::m_nSignalRequired
unsigned int m_nSignalRequired
Definition: Pythia8B_i.h:47
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
Pythia8B_i::m_trigEtaCut
double m_trigEtaCut
Definition: Pythia8B_i.h:55
beamspotman.stat
stat
Definition: beamspotman.py:266
Pythia8_i::m_lheFile
StringProperty m_lheFile
Definition: Pythia8_i.h:124
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
GenBase::particleTable
const HepPDT::ParticleDataTable & particleTable() const
Get a particle data table.
Definition: GenBase.h:118
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:191
Pythia8_i::m_weightIDs
std::vector< std::string > m_weightIDs
Definition: Pythia8_i.h:159
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
ATHRNG::RNGWrapper
A wrapper class for event-slot-local random engines.
Definition: RNGWrapper.h:56
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
Pythia8B_i::m_sigEtaCuts
std::vector< double > m_sigEtaCuts
Definition: Pythia8B_i.h:50
Pythia8B_i::compare
bool compare(std::vector< int >, std::vector< int >) const
Definition: Pythia8B_i.cxx:646
Pythia8B_i::m_and
bool m_and
Definition: Pythia8B_i.h:54
Pythia8_i::LEAD
@ LEAD
Definition: Pythia8_i.h:115
Pythia8B_i::p_rndmEngine
static CLHEP::HepRandomEngine * p_rndmEngine
Definition: Pythia8B_i.h:41
Pythia8B_i::m_selectCQuarks
bool m_selectCQuarks
Definition: Pythia8B_i.h:54
Pythia8B_i::m_SuppressSmallPT
Pythia8::SuppressSmallPT * m_SuppressSmallPT
Definition: Pythia8B_i.h:61
ATHRNG::RNGWrapper::getEngine
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
Definition: RNGWrapper.h:134
Pythia8_i::INVALID
@ INVALID
Definition: Pythia8_i.h:115
Pythia8_i::Pythia8_i
Pythia8_i(const std::string &name, ISvcLocator *pSvcLocator)
Definition: Pythia8_i.cxx:68
python.PyAthena.v
v
Definition: PyAthena.py:157
Pythia8_i::POSITRON
@ POSITRON
Definition: Pythia8_i.h:115
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
AthenaPoolExample_Copy.streamName
string streamName
Definition: AthenaPoolExample_Copy.py:39
Pythia8_i::m_mergingWeight
double m_mergingWeight
Definition: Pythia8_i.h:157
Pythia8B_i::m_atLeastOneAcc
int m_atLeastOneAcc
Definition: Pythia8B_i.h:51
Pythia8B_i::m_totalBQuark
int m_totalBQuark
Definition: Pythia8B_i.h:51
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
Pythia8_i::ANTIMUON
@ ANTIMUON
Definition: Pythia8_i.h:115
a
TList * a
Definition: liststreamerinfos.cxx:10
Pythia8_i::useRndmGenSvc
bool useRndmGenSvc() const
Definition: Pythia8_i.h:86
h
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Pythia8B_i::printSignalSelections
void printSignalSelections(const std::vector< int > &, const std::vector< double > &, const std::vector< double > &, unsigned int) const
Definition: Pythia8B_i.cxx:760
GenModule::m_randomSeed
IntegerProperty m_randomSeed
Seed for random number engine.
Definition: GenModule.h:84
Pythia8B_i::cleanUndecayed
bool cleanUndecayed(Pythia8::Event &, const std::vector< int > &)
Definition: Pythia8B_i.cxx:554
Pythia8B_i::m_trigCode
int m_trigCode
Definition: Pythia8B_i.h:46
Pythia8B_i::m_vetoDoubleB
bool m_vetoDoubleB
Definition: Pythia8B_i.h:54
GenBase::pdt
const HepPDT::ParticleDataTable & pdt() const
Shorter alias to get a particle data table.
Definition: GenBase.h:123
Pythia8_i::m_conversion
double m_conversion
Definition: Pythia8_i.h:133
Pythia8_i::m_dsid
IntegerProperty m_dsid
Definition: Pythia8_i.h:95
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
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
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
merge.status
status
Definition: merge.py:17
Pythia8B_i::m_qPtCut
double m_qPtCut
Definition: Pythia8B_i.h:55
CI_EMPFlowData22test.returnCode
returnCode
Definition: CI_EMPFlowData22test.py:16
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Pythia8_i::m_useRndmGenSvc
BooleanProperty m_useRndmGenSvc
Definition: Pythia8_i.h:92
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
Pythia8B_i::m_totalCQuark
int m_totalCQuark
Definition: Pythia8B_i.h:51
Pythia8B_i::pairProperties
bool pairProperties(Pythia8::Event &, const std::vector< int > &, double, bool)
Definition: Pythia8B_i.cxx:578
Pythia8_i::PROTON
@ PROTON
Definition: Pythia8_i.h:115
GenBase::particleData
const HepPDT::ParticleData * particleData(int pid) const
Access an element in the particle data table.
Definition: GenBase.h:126
Pythia8_i::genInitialize
virtual StatusCode genInitialize()
For initializing the generator, if required.
Definition: Pythia8_i.cxx:96
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
readCCLHist.float
float
Definition: readCCLHist.py:83
Atlas::setExtendedEventContext
void setExtendedEventContext(EventContext &ctx, ExtendedEventContext &&ectx)
Move an extended context into a context object.
Definition: ExtendedEventContext.cxx:50
GenBase::initialize
virtual StatusCode initialize() override
Definition: GenBase.cxx:17
Pythia8_i::m_internal_event_number
int m_internal_event_number
Definition: Pythia8_i.h:107
Pythia8_i::m_pythia
std::unique_ptr< Pythia8::Pythia > m_pythia
Definition: Pythia8_i.h:88
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
Pythia8_i::m_pythiaToHepMC
HepMC::Pythia8ToHepMC m_pythiaToHepMC
Definition: Pythia8_i.h:89
GenParticle
@ GenParticle
Definition: TruthClasses.h:30
HepMC::set_random_states
void set_random_states(GenEvent *e, std::vector< T > a)
Definition: GenEvent.h:525
LB_AnalMapSplitter.lbn
lbn
Definition: LB_AnalMapSplitter.py:28
ServiceHandle< ICondSvc >
Generated on Sun Jun 30 2024 21:56:11 for ATLAS Offline Software by   doxygen 1.8.18