ATLAS Offline Software
Classes | Functions | Variables
Athena_test Namespace Reference

functions & macros to test the difference between floats More...

Classes

class  DummyRCUSvc
 
class  InitGaudiGoogleTest
 
struct  Leakcheck
 
struct  LeakCheckDisable
 
class  normal_distribution
 
struct  RNG
 Generator compatible with the STL RandomNumberGenerator. More...
 
class  TestAlloc
 To test handling of non-standard memory allocators. More...
 
class  TestedValue
 
class  uniform_real_distribution
 
struct  URNG
 Generator compatible with the C++11 STL UniformRandomNumberGenerator. More...
 

Functions

bool initGaudi (ISvcLocator *&pSvcLoc)
 Minimal Gaudi initialization for unit testing without job options. More...
 
bool initGaudi (const std::string &jobOptsFile, ISvcLocator *&pSvcLoc)
 Minimal Gaudi initialization for unit testing. More...
 
void referenceGaudiSymbols ()
 
template<typename T >
bool cmp_eq (T a, T b)
 
template<>
bool cmp_eq< float > (float a, float b)
 
template<>
bool cmp_eq< double > (double a, double b)
 
bool floatEQ (float lhs, float rhs)
 
bool floatNEQ (float lhs, float rhs)
 
bool isEqual (double x1, double x2, double thresh=1e-6)
 
uint32_t rng_seed (uint32_t &seed)
 Generate a random number between 0 and rngmax. More...
 
float randf_seed (uint32_t &seed, float rmax, float rmin=0)
 Generate a floating-point random number between rmin and rmax. More...
 
int randi_seed (uint32_t &seed, int rmax, int rmin=0)
 Generate an integer random number between rmin and rmax. More...
 
uint32_t rng ATLAS_NOT_REENTRANT ()
 
int randi ATLAS_NOT_REENTRANT (int rmax, int rmin=0)
 
float randf ATLAS_NOT_REENTRANT (float rmax, float rmin=0)
 
bool setupStoreGate (std::string progname, std::string options_file="")
 Helper for setting up StoreGate for regression tests. More...
 
void testCreate (StoreGateSvc &rSG)
 
void testRecord (StoreGateSvc &rSG)
 
void testSymLink (StoreGateSvc &rSG)
 
void test_symlink2 (StoreGateSvc &rSG)
 
void test_symlink3 (StoreGateSvc &rSG)
 
void testContains (StoreGateSvc &rSG)
 
void testFolders (StoreGateSvc &rSG)
 
void testRetrieve (StoreGateSvc &rSG)
 
void testTryRetrieve (StoreGateSvc &rSG)
 
void testReadPrivateCopy (StoreGateSvc &rSG)
 
void testRetrievePrivateCopy (StoreGateSvc &rSG)
 
void testRemove (StoreGateSvc &rSG)
 
void testBind ATLAS_NOT_THREAD_SAFE (StoreGateSvc &rSG)
 
void testClear (StoreGateSvc &rSG)
 
void testTransientSwap (StoreGateSvc &rSG)
 
void testVersionedKey (StoreGateSvc &rSG)
 
void testKeys (StoreGateSvc &rSG)
 
void testRetrieveAux (StoreGateSvc &rSG)
 
void testBoundReset (StoreGateSvc &rSG)
 
void testRecordObject (StoreGateSvc &rSG)
 
void testWriteAux (StoreGateSvc &rSG)
 
void varHandleTest (SGTest::TestStore &)
 
void resetableTest (void)
 
void refCountTest (void)
 
bool initMcEventCollection (ISvcLocator *&pSvcLoc, std::vector< HepMC::GenParticlePtr > &genPartVector, const bool initGaudi=true)
 
void populateGenEvent (HepMC::GenEvent &ge, int pdgid1, int pdgid2, std::vector< HepMC::GenParticlePtr > &genPartVector)
 
void populateFilteredGenEvent (HepMC::GenEvent &ge, std::vector< HepMC::GenParticlePtr > &genPartVector)
 
int maximumBarcode (std::vector< HepMC::GenParticlePtr > &genPartList)
 

Variables

std::unordered_set< void * > * allocs = nullptr
 

Detailed Description

functions & macros to test the difference between floats

Function Documentation

◆ ATLAS_NOT_REENTRANT() [1/3]

uint32_t rng Athena_test::ATLAS_NOT_REENTRANT ( )
inline

Definition at line 90 of file random.h.

90 { return rng_seed(seed); }

◆ ATLAS_NOT_REENTRANT() [2/3]

float randf Athena_test::ATLAS_NOT_REENTRANT ( float  rmax,
float  rmin = 0 
)
inline

Definition at line 94 of file random.h.

94 { return randf_seed (seed, rmax, rmin); }

◆ ATLAS_NOT_REENTRANT() [3/3]

int randi Athena_test::ATLAS_NOT_REENTRANT ( int  rmax,
int  rmin = 0 
)
inline

Definition at line 92 of file random.h.

92 { return randi_seed (seed, rmax, rmin); }

◆ ATLAS_NOT_THREAD_SAFE()

void testBind Athena_test::ATLAS_NOT_THREAD_SAFE ( StoreGateSvc &  rSG)

◆ cmp_eq()

template<typename T >
bool Athena_test::cmp_eq ( T  a,
T  b 
)

Definition at line 18 of file expect.h.

18 { return a == b; }

◆ cmp_eq< double >()

template<>
bool Athena_test::cmp_eq< double > ( double  a,
double  b 
)

Definition at line 22 of file expect.h.

22 { return std::abs(a - b) < 1.e-6; }

◆ cmp_eq< float >()

template<>
bool Athena_test::cmp_eq< float > ( float  a,
float  b 
)

Definition at line 20 of file expect.h.

20 { return std::abs(a - b) < 1.e-4; }

◆ floatEQ()

bool Athena_test::floatEQ ( float  lhs,
float  rhs 
)
inline

Definition at line 17 of file FLOATassert.h.

17  {
18  return fabs(lhs-rhs)<=FLT_EPSILON;
19  }

◆ floatNEQ()

bool Athena_test::floatNEQ ( float  lhs,
float  rhs 
)
inline

Definition at line 21 of file FLOATassert.h.

21  {
22  return fabs(lhs-rhs)>FLT_EPSILON;
23  }

◆ initGaudi() [1/2]

bool Athena_test::initGaudi ( const std::string &  jobOptsFile,
ISvcLocator *&  pSvcLoc 
)

Minimal Gaudi initialization for unit testing.

Parameters
jobOptsFilejob options file name
pSvcLocreturns a pointer to the Gaudi ServiceLocator
Returns
true on success, false on failure

Definition at line 33 of file initGaudi.cxx.

34  {
35  std::cout << "\n\nCannot find job opts " << jobOptsFile << std::endl;
36  }
37  else {
38  std::cout << "\n\nInitializing Gaudi ApplicationMgr using job opts " << jobOptsPath << std::endl;
39  }
40  }
41 
42  // Create an instance of ApplicationMgr
43  SmartIF<IAppMgrUI> appMgr = Gaudi::createApplicationMgr();
44  if(!appMgr.isValid()) {
45  std::cout << "Fatal error while creating the ApplicationMgr " << std::endl;
46  return false;
47  }
48 
49  SmartIF<IProperty> propMgr(appMgr);
50  SmartIF<ISvcLocator> svcLoc(appMgr);
51  if(!svcLoc.isValid() || !propMgr.isValid()) {
52  std::cout << "Fatal error while retrieving AppMgr interfaces " << std::endl;
53  return false;
54  }
55 
56  // Return pointer to ISvcLocator
57  pSvcLoc = svcLoc.get();
58 
59  propMgr->setProperty( "EvtSel", "NONE" ).
60  orThrow("Cannnot set EvtSel property", "initGaudi");
61  if (jobOptsFile.empty()) {
62  propMgr->setProperty( "JobOptionsType", "NONE" ).
63  orThrow("Cannnot set JobOptionsType property", "initGaudi");
64  } else {
65  propMgr->setProperty( "JobOptionsType", "FILE" ).
66  orThrow("Cannnot set JobOptionsType property", "initGaudi");
67  propMgr->setProperty( "JobOptionsPath", jobOptsPath ).
68  orThrow("Cannnot set JobOptionsPath property", "initGaudi");
69  }
70 
71  if (appMgr->configure().isSuccess() && appMgr->initialize().isSuccess()) {
72  std::cout<<"ApplicationMgr Ready"<<std::endl;
73  return true;
74  } else {
75  std::cout << "Fatal error while initializing the AppMgr" << std::endl;
76  return false;
77  }
78  }
79 
80 
81  // This is for the benefit of the tests in CLIDComps.
82  // By default, a dynamic symbol is not exported from a binary unless

◆ initGaudi() [2/2]

bool Athena_test::initGaudi ( ISvcLocator *&  pSvcLoc)

Minimal Gaudi initialization for unit testing without job options.

Parameters
pSvcLocreturns a pointer to the Gaudi ServiceLocator
Returns
true on success, false on failure

Definition at line 28 of file initGaudi.cxx.

29  {
30 

◆ initMcEventCollection()

bool Athena_test::initMcEventCollection ( ISvcLocator *&  pSvcLoc,
std::vector< HepMC::GenParticlePtr > &  genPartVector,
const bool  initGaudi = true 
)

Definition at line 23 of file initMcEventCollection.cxx.

24  {
25  if (initGaudi && !Athena_test::initGaudi(pSvcLoc)) {
26  std::cerr << "This test can not be run" << std::endl;
27  return false;
28  }
29  // create dummy input McEventCollection with a name that
30  // HepMcParticleLink knows about
31  SG::WriteHandle<McEventCollection> inputTestDataHandle{"TruthEvent"};
32  inputTestDataHandle = std::make_unique<McEventCollection>();
33 
34  // create a dummy EventContext
35  EventContext ctx;
36  ctx.setExtension( Atlas::ExtendedEventContext( SG::CurrentEventStore::store() ) );
37  Gaudi::Hive::setCurrentContext( ctx );
38 
39  // Add a dummy GenEvent
40  const int process_id1(20);
41  const int event_number1(17);
42  inputTestDataHandle->push_back(HepMC::newGenEvent(process_id1, event_number1));
43  HepMC::GenEvent& ge1 = *(inputTestDataHandle->at(0));
44  populateGenEvent(ge1,-11,11,genPartList);
45  populateGenEvent(ge1,-13,13,genPartList);
46  populateGenEvent(ge1,-11,11,genPartList);
47  populateGenEvent(ge1,-13,13,genPartList);
48  populateGenEvent(ge1,-11,11,genPartList);
49  populateGenEvent(ge1,22,22,genPartList);
50  inputTestDataHandle->push_back(new HepMC::GenEvent(ge1));
51  HepMC::GenEvent& ge2 = *(inputTestDataHandle->at(1));
52  const int event_number2(89);
53  ge2.set_event_number(event_number2);
54  populateFilteredGenEvent(ge2,genPartList);
55  return true;
56  }

◆ isEqual()

bool Athena_test::isEqual ( double  x1,
double  x2,
double  thresh = 1e-6 
)
inline

Definition at line 26 of file FLOATassert.h.

27  {
28  double den = std::abs(x1+x2);
29  if (den < thresh) return true;
30  double diff = std::abs (x1-x2) / den;
31  if (diff < thresh)
32  return true;
33  std::cout << "Match failure: " << x1 << " " << x2 << " (" << diff << ")\n";
34  return false;
35  }

◆ maximumBarcode()

int Athena_test::maximumBarcode ( std::vector< HepMC::GenParticlePtr > &  genPartList)

Definition at line 58 of file initMcEventCollection.cxx.

59  {
60  int maxBarcode{0};
61  if (genPartList.empty()) { return maxBarcode; }
62  for (HepMC::GenParticlePtr genPart : genPartList)
63  {
64  maxBarcode = std::max(maxBarcode, HepMC::barcode(genPart));
65  }
66  return maxBarcode;
67  }

◆ populateFilteredGenEvent()

void Athena_test::populateFilteredGenEvent ( HepMC::GenEvent &  ge,
std::vector< HepMC::GenParticlePtr > &  genPartVector 
)

< set decay status

< set decay status

Definition at line 97 of file initMcEventCollection.cxx.

98  {
99  //.......Create new particle (geantino) to link hits from pileup
100  HepMC::GenParticlePtr genPart=HepMC::newGenParticlePtr();
101  genPart->set_pdg_id(999); //Geantino
102  genPart->set_status(1);
103  HepMC::suggest_barcode(genPart, HepMC::SUPPRESSED_PILEUP_BARCODE );
104 
105  HepMC::GenVertexPtr genVertex=HepMC::newGenVertexPtr();
106  genVertex->add_particle_out(genPart);
107  genPartVector.push_back(genPart);
108 
109  //to set geantino vertex as a truth primary vertex
110  HepMC::GenVertexPtr hScatVx = HepMC::barcode_to_vertex(&ge,-3);
111  if (hScatVx!=nullptr) {
112  HepMC::FourVector pmvxpos=hScatVx->position();
113  genVertex->set_position(pmvxpos);
114  //to set geantino kinematic phi=eta=0, E=p=E_hard_scat
115 #ifdef HEPMC3
116  auto itrp =hScatVx->particles_in().cbegin();
117  if (hScatVx->particles_in().size()==2) {
118  HepMC::FourVector mom1=(*itrp)->momentum();
119  HepMC::FourVector mom2=(*(++itrp))->momentum();
120  HepMC::FourVector vxmom;
121  vxmom.setPx(mom1.e()+mom2.e());
122  vxmom.setPy(0.);
123  vxmom.setPz(0.);
124  vxmom.setE(mom1.e()+mom2.e());
125  genPart->set_momentum(vxmom);
126  }
127 #else
128  HepMC::GenVertex::particles_in_const_iterator itrp =hScatVx->particles_in_const_begin();
129  if (hScatVx->particles_in_size()==2) {
130  HepMC::FourVector mom1=(*itrp)->momentum();
131  HepMC::FourVector mom2=(*(++itrp))->momentum();
132  HepMC::FourVector vxmom;
133  vxmom.setPx(mom1.e()+mom2.e());
134  vxmom.setPy(0.);
135  vxmom.setPz(0.);
136  vxmom.setE(mom1.e()+mom2.e());
137  genPart->set_momentum(vxmom);
138  }
139 #endif
140  }
141 
142 #ifdef HEPMC3
143  if (!ge.vertices().empty()) {
144  std::vector<HepMC::GenVertexPtr> vtxvec;
145  for (const auto& vtx: ge.vertices()) {
146  vtxvec.push_back(vtx);
147  ge.remove_vertex(vtx);
148  }
149  vtxvec.clear();
150  }
151 #else
152  if (!ge.vertices_empty()) {
153  HepMC::GenEvent::vertex_iterator itvtx = ge.vertices_begin();
154  while (itvtx != ge.vertices_end()) {
155  HepMC::GenVertexPtr pvtx = *itvtx;
156  ++itvtx;
157  ge.remove_vertex(pvtx);
158  delete pvtx;
159  }
160  }
161 #endif
162 
163  //.....add new vertex with geantino
164  ge.add_vertex(genVertex);
165  HepMC::suggest_barcode(genPart, HepMC::SUPPRESSED_PILEUP_BARCODE );
166  }

◆ populateGenEvent()

void Athena_test::populateGenEvent ( HepMC::GenEvent &  ge,
int  pdgid1,
int  pdgid2,
std::vector< HepMC::GenParticlePtr > &  genPartVector 
)

Definition at line 69 of file initMcEventCollection.cxx.

70  {
71  int maxBarcode = maximumBarcode(genPartList);
72  HepMC::FourVector myPos( 0.0, 0.0, 0.0, 0.0);
73  HepMC::GenVertexPtr myVertex = HepMC::newGenVertexPtr( myPos, -1 );
74  HepMC::FourVector fourMomentum1( 0.0, 0.0, 1.0, 1.0*CLHEP::TeV);
75  HepMC::GenParticlePtr inParticle1 = HepMC::newGenParticlePtr(fourMomentum1, pdgid1, 2);
76  myVertex->add_particle_in(inParticle1);
77  HepMC::FourVector fourMomentum2( 0.0, 0.0, -1.0, 1.0*CLHEP::TeV);
78  HepMC::GenParticlePtr inParticle2 = HepMC::newGenParticlePtr(fourMomentum2, pdgid2, 2);
79  myVertex->add_particle_in(inParticle2);
80  HepMC::FourVector fourMomentum3( 0.0, 1.0, 0.0, 1.0*CLHEP::TeV);
81  HepMC::GenParticlePtr inParticle3 = HepMC::newGenParticlePtr(fourMomentum3, pdgid1, 1);
82  myVertex->add_particle_out(inParticle3);
83  genPartList.push_back(inParticle3);
84  HepMC::FourVector fourMomentum4( 0.0, -1.0, 0.0, 1.0*CLHEP::TeV);
85  HepMC::GenParticlePtr inParticle4 = HepMC::newGenParticlePtr(fourMomentum4, pdgid2, 1);
86  myVertex->add_particle_out(inParticle4);
87  genPartList.push_back(inParticle4);
88  ge.add_vertex( myVertex );
89  HepMC::suggest_barcode(inParticle1,maxBarcode+1);
90  HepMC::suggest_barcode(inParticle2,maxBarcode+2);
91  HepMC::suggest_barcode(inParticle3,maxBarcode+3);
92  HepMC::suggest_barcode(inParticle4,maxBarcode+4);
93  HepMC::set_signal_process_vertex(&ge, myVertex );
94  ge.set_beam_particles(inParticle1,inParticle2);
95  }

◆ randf_seed()

float Athena_test::randf_seed ( uint32_t &  seed,
float  rmax,
float  rmin = 0 
)
inline

Generate a floating-point random number between rmin and rmax.

Definition at line 53 of file random.h.

54 {
55  return static_cast<float>(rng_seed(seed)) / static_cast<float>(rngmax) * (rmax-rmin) + rmin;
56 }

◆ randi_seed()

int Athena_test::randi_seed ( uint32_t &  seed,
int  rmax,
int  rmin = 0 
)
inline

Generate an integer random number between rmin and rmax.

Definition at line 61 of file random.h.

62 {
63  return static_cast<int> (randf_seed (seed, rmax, rmin));
64 }

◆ refCountTest()

void Athena_test::refCountTest ( void  )

◆ referenceGaudiSymbols()

void Athena_test::referenceGaudiSymbols ( )

Definition at line 98 of file initGaudi.cxx.

◆ resetableTest()

void Athena_test::resetableTest ( void  )

◆ rng_seed()

uint32_t Athena_test::rng_seed ( uint32_t &  seed)
inline

Generate a random number between 0 and rngmax.

Definition at line 44 of file random.h.

45 {
46  seed = (1664525*seed + 1013904223);
47  return seed;
48 }

◆ setupStoreGate()

bool Athena_test::setupStoreGate ( std::string  progname,
std::string  options_file = "" 
)

Helper for setting up StoreGate for regression tests.

Parameters
prognameProgram name (argv[0]).
options_fileName of the JO text file to read. If defaulted, one will be generated.

Get StoreGateSvc

Definition at line 28 of file setupStoreGate.cxx.

30 {
31  // Build job options file if CppUnit_jobOptions.txt is unavailable
32  if (options_file.empty()) {
33  std::string::size_type pos = progname.rfind ("/");
34  if (pos != std::string::npos)
35  progname.erase (0, pos+1);
36  pos = progname.rfind (".");
37  if (pos != std::string::npos)
38  progname.erase (pos, std::string::npos);
39  options_file = "./" + progname + "_generated.txt";
40  (void)remove (options_file.c_str());
41  std::ofstream jobopt(options_file.c_str());
42 
43  // Build a default list of options.
44  {
45  std::list<std::string> opts;
46  opts.push_back("#pragma print off");
47  opts.push_back("ApplicationMgr.Dlls += { \"StoreGate\" };");
48  //opts.push_back("ApplicationMgr.Dlls += { \"CLIDSvc\" };");
49  opts.push_back("ApplicationMgr.ExtSvc += { \"ClassIDSvc\" };");
50  opts.push_back("ApplicationMgr.ExtSvc += { \"StoreGateSvc\", \"StoreGateSvc/DetectorStore\", \"StoreGateSvc/ConditionStore\", \"StoreGateSvc/HistoryStore\" };");
51  opts.push_back("ApplicationMgr.ExtSvc += { \"ActiveStoreSvc\" };");
52  opts.push_back("AuditorSvc.Auditors += { \"AlgContextAuditor\"};");
53  opts.push_back("StoreGateSvc.OutputLevel = 2;");
54  opts.push_back("StoreGateSvc.ActivateHistory = false;");
55  //opts.push_back("CLIDSvc.OutputLevel = 2;");
56  opts.push_back("MessageSvc.useColors = false;");
57  opts.push_back("MessageSvc.OutputLevel = 3;");
58  // Build job options file from list.
59  for ( std::list<std::string>::const_iterator iopt=opts.begin();
60  iopt!=opts.end(); ++iopt )
61  {
62  jobopt << *iopt << std::endl;
63  }
64  }
65  jobopt.close();
66  }
67 
68  try {
70  ISvcLocator* svcLoc = 0;
71  if (!Athena_test::initGaudi(options_file, svcLoc)) {
72  std::cerr << "This test can not be run" << std::endl;
73  return false;
74  }
75  assert( 0 != svcLoc);
76 
77  SmartIF<StoreGateSvc> storeGate{svcLoc->service( "StoreGateSvc" )};
78  assert( storeGate );
79 
80  if ( !storeGate ) {
81  std::string error = "No valid pointer to StoreGateSvc !!";
82  std::cerr << error << std::endl;
83  return false;
84  } else {
85  return true;
86  }
87  } catch ( std::exception& e ) {
88  std::cerr << "Caught : " << e.what() << std::endl;
89  return false;
90  }
91 }

◆ test_symlink2()

void Athena_test::test_symlink2 ( StoreGateSvc &  rSG)

◆ test_symlink3()

void Athena_test::test_symlink3 ( StoreGateSvc &  rSG)

◆ testBoundReset()

void Athena_test::testBoundReset ( StoreGateSvc &  rSG)

◆ testClear()

void Athena_test::testClear ( StoreGateSvc &  rSG)

◆ testContains()

void Athena_test::testContains ( StoreGateSvc &  rSG)

◆ testCreate()

void Athena_test::testCreate ( StoreGateSvc &  rSG)

◆ testFolders()

void Athena_test::testFolders ( StoreGateSvc &  rSG)

◆ testKeys()

void Athena_test::testKeys ( StoreGateSvc &  rSG)

◆ testReadPrivateCopy()

void Athena_test::testReadPrivateCopy ( StoreGateSvc &  rSG)

◆ testRecord()

void Athena_test::testRecord ( StoreGateSvc &  rSG)

◆ testRecordObject()

void Athena_test::testRecordObject ( StoreGateSvc &  rSG)

◆ testRemove()

void Athena_test::testRemove ( StoreGateSvc &  rSG)

◆ testRetrieve()

void Athena_test::testRetrieve ( StoreGateSvc &  rSG)

◆ testRetrieveAux()

void Athena_test::testRetrieveAux ( StoreGateSvc &  rSG)

◆ testRetrievePrivateCopy()

void Athena_test::testRetrievePrivateCopy ( StoreGateSvc &  rSG)

◆ testSymLink()

void Athena_test::testSymLink ( StoreGateSvc &  rSG)

◆ testTransientSwap()

void Athena_test::testTransientSwap ( StoreGateSvc &  rSG)

◆ testTryRetrieve()

void Athena_test::testTryRetrieve ( StoreGateSvc &  rSG)

◆ testVersionedKey()

void Athena_test::testVersionedKey ( StoreGateSvc &  rSG)

◆ testWriteAux()

void Athena_test::testWriteAux ( StoreGateSvc &  rSG)

◆ varHandleTest()

void Athena_test::varHandleTest ( SGTest::TestStore &  )

Variable Documentation

◆ allocs

std::unordered_set<void*>* Athena_test::allocs = nullptr

Definition at line 51 of file leakcheck.h.

HepMC::GenVertexPtr
HepMC::GenVertex * GenVertexPtr
Definition: GenVertex.h:59
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
HepMC::suggest_barcode
bool suggest_barcode(T &p, int i)
Definition: GenEvent.h:670
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
initGaudi
IAppMgrUI * initGaudi(const std::string &options, bool verbose, ISvcLocator *&svcLocator)
Definition: genCLIDDB.cxx:31
physval_make_web_display.thresh
thresh
Definition: physval_make_web_display.py:36
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
Athena_test::randi_seed
int randi_seed(uint32_t &seed, int rmax, int rmin=0)
Generate an integer random number between rmin and rmax.
Definition: random.h:61
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
HepMC::GenParticlePtr
GenParticle * GenParticlePtr
Definition: GenParticle.h:37
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
HepMC::newGenEvent
GenEvent * newGenEvent(const int a, const int b)
Definition: GenEvent.h:624
SG::CurrentEventStore::store
static IProxyDict * store()
Fetch the current store.
python.SystemOfUnits.TeV
int TeV
Definition: SystemOfUnits.py:158
Athena_test::populateFilteredGenEvent
void populateFilteredGenEvent(HepMC::GenEvent &ge, std::vector< HepMC::GenParticlePtr > &genPartVector)
Definition: initMcEventCollection.cxx:97
PixelModuleFeMask_create_db.remove
string remove
Definition: PixelModuleFeMask_create_db.py:83
HepMC::SUPPRESSED_PILEUP_BARCODE
constexpr int SUPPRESSED_PILEUP_BARCODE(std::numeric_limits< int32_t >::max())
This barcode is used by objects matched to particles from pile-up interactions in standard MC Product...
HepMC::set_signal_process_vertex
void set_signal_process_vertex(GenEvent *e, T v)
Definition: GenEvent.h:650
HepMC::newGenVertexPtr
GenVertexPtr newGenVertexPtr(const HepMC::FourVector &pos=HepMC::FourVector(0.0, 0.0, 0.0, 0.0), const int i=0)
Definition: GenVertex.h:64
Atlas::ExtendedEventContext
Definition: ExtendedEventContext.h:23
HepMC::barcode
int barcode(const T *p)
Definition: Barcode.h:16
calibdata.exception
exception
Definition: calibdata.py:496
Athena_test::initGaudi
bool initGaudi(ISvcLocator *&pSvcLoc)
Minimal Gaudi initialization for unit testing without job options.
Definition: initGaudi.cxx:28
Athena_test::populateGenEvent
void populateGenEvent(HepMC::GenEvent &ge, int pdgid1, int pdgid2, std::vector< HepMC::GenParticlePtr > &genPartVector)
Definition: initMcEventCollection.cxx:69
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
SG::WriteHandle< McEventCollection >
a
TList * a
Definition: liststreamerinfos.cxx:10
HepMC::newGenParticlePtr
GenParticlePtr newGenParticlePtr(const HepMC::FourVector &mom=HepMC::FourVector(0.0, 0.0, 0.0, 0.0), int pid=0, int status=0)
Definition: GenParticle.h:39
HepMC::barcode_to_vertex
GenVertex * barcode_to_vertex(const GenEvent *e, int id)
Definition: GenEvent.h:627
Athena_test::rng_seed
uint32_t rng_seed(uint32_t &seed)
Generate a random number between 0 and rngmax.
Definition: random.h:44
athena.opts
opts
Definition: athena.py:88
Athena_test::maximumBarcode
int maximumBarcode(std::vector< HepMC::GenParticlePtr > &genPartList)
Definition: initMcEventCollection.cxx:58
error
Definition: IImpactPoint3dEstimator.h:70
python.PyKernel.storeGate
storeGate
Definition: PyKernel.py:40
Athena_test::randf_seed
float randf_seed(uint32_t &seed, float rmax, float rmin=0)
Generate a floating-point random number between rmin and rmax.
Definition: random.h:53
Generated on Sun Dec 22 2024 21:56:28 for ATLAS Offline Software by   doxygen 1.8.18