ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Static Public Attributes | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
ISF_HitAnalysis Class Reference

#include <ISF_HitAnalysis.h>

Inheritance diagram for ISF_HitAnalysis:

Public Member Functions

 ISF_HitAnalysis (const std::string &name, ISvcLocator *pSvcLocator)
 ~ISF_HitAnalysis ()
virtual StatusCode initialize ATLAS_NOT_THREAD_SAFE () override
virtual StatusCode finalize ATLAS_NOT_THREAD_SAFE () override
virtual StatusCode execute () override
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Static Public Attributes

static const int MAX_LAYER = 25

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

std::vector< Trk::HitInfo > * caloHits (const HepMC::GenParticle &part) const
void extrapolate (const HepMC::ConstGenParticlePtr &part, std::vector< Trk::HitInfo > *hitVector)
void extrapolate_to_ID (const HepMC::ConstGenParticlePtr &part, std::vector< Trk::HitInfo > *hitVector)
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

ServiceHandle< IGeoModelSvc > m_geoModel
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
SG::ReadCondHandleKey< ILArfSampl > m_fSamplKey
SG::ReadCondHandleKey< TileSamplingFraction > m_tileSamplingFractionKey
 Name of TileSamplingFraction in condition store.
ServiceHandle< TileCablingSvc > m_tileCablingSvc
 Name of Tile cabling service.
StringProperty m_ntupleFileName {this, "NtupleFileName", "ISF_HitAnalysis"}
StringProperty m_ntupleTreeName {this, "NtupleTreeName", "CaloHitAna"}
StringProperty m_metadataTreeName {this, "MetadataTreeName", "MetaData"}
StringProperty m_geoFileName {this, "GeoFileName", "ISF_Geometry"}
IntegerProperty m_NtruthParticles {this, "NTruthParticles", 1, "Number of truth particles saved from the truth collection, -1 to save all"}
ServiceHandle< ITHistSvc > m_thistSvc
PublicToolHandle< Trk::ITimedExtrapolator > m_extrapolator {this, "Extrapolator", {}}
PublicToolHandle< ICaloCoordinateTool > m_calo_tb_coord {this, "CaloCoordinateTool", "TBCaloCoordinate"}
StringProperty m_caloEntranceName {this, "CaloEntrance", ""}
PublicToolHandle< IFastCaloSimCaloExtrapolation > m_FastCaloSimCaloExtrapolation {this, "FastCaloSimCaloExtrapolation", {} }
 The FastCaloSimCaloExtrapolation tool.
DoubleProperty m_CaloBoundaryR {this, "CaloBoundaryR", 1148}
DoubleProperty m_CaloBoundaryZ {this, "CaloBoundaryZ", 3550}
DoubleProperty m_calomargin {this, "CaloMargin", 0.0}
BooleanProperty m_saveAllBranches {this,"SaveAllBranches", false}
BooleanProperty m_doAllCells {this, "DoAllCells", false}
BooleanProperty m_doClusterInfo {this, "DoClusterInfo", false}
BooleanProperty m_doLayers {this, "DoLayers", false}
BooleanProperty m_doLayerSums {this, "DoLayerSums", true}
BooleanProperty m_doG4Hits {this, "DoG4Hits", false}
IntegerProperty m_TimingCut {this, "TimingCut", 999999}
StringProperty m_MC_DIGI_PARAM {this, "MetaDataDigi", "/Digitization/Parameters"}
StringProperty m_MC_SIM_PARAM {this, "MetaDataSim", "/Simulation/Parameters"}
const LArEM_ID * m_larEmID {}
const LArFCAL_ID * m_larFcalID {}
const LArHEC_ID * m_larHecID {}
const TileID * m_tileID {}
const TileHWID * m_tileHWID {}
const TileCablingService * m_tileCabling {}
const TileDetDescrManager * m_tileMgr {}
std::vector< float > * m_hit_x {}
 Simple variables by Ketevi.
std::vector< float > * m_hit_y {}
std::vector< float > * m_hit_z {}
std::vector< float > * m_hit_energy {}
std::vector< float > * m_hit_time {}
std::vector< Long64_t > * m_hit_identifier {}
std::vector< Long64_t > * m_hit_cellidentifier {}
std::vector< bool > * m_islarbarrel {}
std::vector< bool > * m_islarendcap {}
std::vector< bool > * m_islarhec {}
std::vector< bool > * m_islarfcal {}
std::vector< bool > * m_istile {}
std::vector< int > * m_hit_sampling {}
std::vector< float > * m_hit_samplingfraction {}
std::vector< float > * m_truth_energy {}
std::vector< float > * m_truth_px {}
std::vector< float > * m_truth_py {}
std::vector< float > * m_truth_pz {}
std::vector< int > * m_truth_pdg {}
std::vector< int > * m_truth_barcode {}
std::vector< int > * m_truth_vtxbarcode {}
std::vector< float > * m_cluster_energy {}
std::vector< float > * m_cluster_eta {}
std::vector< float > * m_cluster_phi {}
std::vector< unsigned > * m_cluster_size {}
std::vector< std::vector< Long64_t > > * m_cluster_cellID {}
std::vector< Long64_t > * m_cell_identifier {}
std::vector< float > * m_cell_energy {}
std::vector< int > * m_cell_sampling {}
std::vector< float > * m_g4hit_energy {}
std::vector< float > * m_g4hit_time {}
std::vector< Long64_t > * m_g4hit_identifier {}
std::vector< Long64_t > * m_g4hit_cellidentifier {}
std::vector< float > * m_g4hit_samplingfraction {}
std::vector< int > * m_g4hit_sampling {}
FCS_matchedcellvector * m_oneeventcells = nullptr
FCS_matchedcellvector * m_layercells [MAX_LAYER] {}
Float_t m_total_cell_e {}
Float_t m_total_hit_e {}
Float_t m_total_g4hit_e {}
std::vector< Float_t > * m_final_cell_energy {}
std::vector< Float_t > * m_final_hit_energy {}
std::vector< Float_t > * m_final_g4hit_energy {}
TTree * m_tree {}
double m_eta_calo_surf {}
double m_phi_calo_surf {}
double m_d_calo_surf {}
double m_ptruth_eta {}
double m_ptruth_phi {}
double m_ptruth_e {}
double m_ptruth_et {}
double m_ptruth_pt {}
double m_ptruth_p {}
int m_pdgid {}
std::vector< std::vector< float > > * m_newTTC_entrance_eta {}
std::vector< std::vector< float > > * m_newTTC_entrance_phi {}
std::vector< std::vector< float > > * m_newTTC_entrance_r {}
std::vector< std::vector< float > > * m_newTTC_entrance_z {}
std::vector< std::vector< float > > * m_newTTC_entrance_detaBorder {}
std::vector< std::vector< bool > > * m_newTTC_entrance_OK {}
std::vector< std::vector< float > > * m_newTTC_back_eta {}
std::vector< std::vector< float > > * m_newTTC_back_phi {}
std::vector< std::vector< float > > * m_newTTC_back_r {}
std::vector< std::vector< float > > * m_newTTC_back_z {}
std::vector< std::vector< float > > * m_newTTC_back_detaBorder {}
std::vector< std::vector< bool > > * m_newTTC_back_OK {}
std::vector< std::vector< float > > * m_newTTC_mid_eta {}
std::vector< std::vector< float > > * m_newTTC_mid_phi {}
std::vector< std::vector< float > > * m_newTTC_mid_r {}
std::vector< std::vector< float > > * m_newTTC_mid_z {}
std::vector< std::vector< float > > * m_newTTC_mid_detaBorder {}
std::vector< std::vector< bool > > * m_newTTC_mid_OK {}
std::vector< float > * m_newTTC_IDCaloBoundary_eta {}
std::vector< float > * m_newTTC_IDCaloBoundary_phi {}
std::vector< float > * m_newTTC_IDCaloBoundary_r {}
std::vector< float > * m_newTTC_IDCaloBoundary_z {}
std::vector< float > * m_newTTC_Angle3D {}
std::vector< float > * m_newTTC_AngleEta {}
std::vector< float > * m_MuonEntryLayer_E {}
std::vector< float > * m_MuonEntryLayer_px {}
std::vector< float > * m_MuonEntryLayer_py {}
std::vector< float > * m_MuonEntryLayer_pz {}
std::vector< float > * m_MuonEntryLayer_x {}
std::vector< float > * m_MuonEntryLayer_y {}
std::vector< float > * m_MuonEntryLayer_z {}
std::vector< int > * m_MuonEntryLayer_pdg {}
CxxUtils::CachedPointer< const Trk::TrackingVolume > m_caloEntrance
 The new Extrapolator setup.
Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis
CaloCell_ID_FCS::CaloSample m_sample_calo_surf {CaloCell_ID_FCS::noSample}
 End new Extrapolator setup.
std::vector< CaloCell_ID_FCS::CaloSample > m_surfacelist
bool m_layerCaloOK [CaloCell_ID_FCS::MaxSample][3] {}
double m_letaCalo [CaloCell_ID_FCS::MaxSample][3] {}
double m_lphiCalo [CaloCell_ID_FCS::MaxSample][3] {}
double m_lrCalo [CaloCell_ID_FCS::MaxSample][3] {}
double m_lzCalo [CaloCell_ID_FCS::MaxSample][3] {}
double m_dCalo [CaloCell_ID_FCS::MaxSample][3] {}
double m_distetaCaloBorder [CaloCell_ID_FCS::MaxSample][3] {}
ServiceHandle< IPartPropSvc > m_partPropSvc {this, "PartPropSvc", "PartPropSvc"}
 Handle on the particle property service.
HepPDT::ParticleDataTable * m_particleDataTable {}
DataObjIDColl m_extendedExtraObjects
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default)
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 65 of file ISF_HitAnalysis.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ISF_HitAnalysis()

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

Definition at line 65 of file ISF_HitAnalysis.cxx.

66: AthAlgorithm(name, pSvcLocator)
67 //Note that m_xxx are pointers to vectors set to 0, not set to empty vector! see note around TBranch
68{
69 m_surfacelist.resize(0);
70 m_surfacelist.push_back(CaloCell_ID_FCS::PreSamplerB);
71 m_surfacelist.push_back(CaloCell_ID_FCS::PreSamplerE);
72 m_surfacelist.push_back(CaloCell_ID_FCS::EME1);
73 m_surfacelist.push_back(CaloCell_ID_FCS::EME2);
74 m_surfacelist.push_back(CaloCell_ID_FCS::FCAL0);
75}
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
ISF_HitAnalysis::m_surfacelist
std::vector< CaloCell_ID_FCS::CaloSample > m_surfacelist
Definition ISF_HitAnalysis.h:244
CaloCell_ID_FCS::PreSamplerE
@ PreSamplerE
Definition FastCaloSim_CaloCell_ID.h:23
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition FastCaloSim_CaloCell_ID.h:19
CaloCell_ID_FCS::FCAL0
@ FCAL0
Definition FastCaloSim_CaloCell_ID.h:40
CaloCell_ID_FCS::EME2
@ EME2
Definition FastCaloSim_CaloCell_ID.h:25
CaloCell_ID_FCS::EME1
@ EME1
Definition FastCaloSim_CaloCell_ID.h:24

◆ ~ISF_HitAnalysis()

ISF_HitAnalysis::~ISF_HitAnalysis ( )
default

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE() [1/2]

virtual StatusCode initialize ISF_HitAnalysis::ATLAS_NOT_THREAD_SAFE ( )
overridevirtual

◆ ATLAS_NOT_THREAD_SAFE() [2/2]

virtual StatusCode finalize ISF_HitAnalysis::ATLAS_NOT_THREAD_SAFE ( )
overridevirtual

◆ caloHits()

std::vector< Trk::HitInfo > * ISF_HitAnalysis::caloHits ( const HepMC::GenParticle & part) const
private

Definition at line 1328 of file ISF_HitAnalysis.cxx.

1329{
1330 // Start calo extrapolation
1331 ATH_MSG_DEBUG ("[ fastCaloSim transport ] processing particle "<<part.pdg_id() );
1332
1333 std::vector<Trk::HitInfo>* hitVector = new std::vector<Trk::HitInfo>;
1334
1335 int pdgId = part.pdg_id();
1336 double charge = HepPDT::ParticleID(pdgId).charge();
1337
1338 // particle Hypothesis for the extrapolation
1339 Trk::ParticleHypothesis pHypothesis = m_pdgToParticleHypothesis.convert(pdgId,charge);
1340
1341 ATH_MSG_DEBUG ("particle hypothesis "<< pHypothesis );
1342
1343 // geantinos not handled by PdgToParticleHypothesis - fix there
1344 if( pdgId == 999 ) pHypothesis = Trk::geantino;
1345
1346 auto vtx = part.production_vertex();
1347 Amg::Vector3D pos(0.,0.,0.); // default
1348
1349 if (vtx)
1350 {
1351 pos = Amg::Vector3D( vtx->position().x(),vtx->position().y(), vtx->position().z());
1352 }
1353
1354 Amg::Vector3D mom(part.momentum().x(),part.momentum().y(),part.momentum().z());
1355 ATH_MSG_DEBUG( "[ fastCaloSim transport ] starting transport from position eta="<<pos.eta()<<" phi="<<pos.phi()<<" d="<<pos.mag()<<" pT="<<mom.perp() );
1356
1357 // input parameters : curvilinear parameters
1358 Trk::CurvilinearParameters inputPar(pos,mom,charge);
1359
1360 // stable vs. unstable check : ADAPT for FASTCALOSIM
1361 //double freepath = ( !m_particleDecayHelper.empty()) ? m_particleDecayHelper->freePath(isp) : - 1.;
1362 double freepath = -1.;
1363 //ATH_MSG_VERBOSE( "[ fatras transport ] Particle free path : " << freepath);
1364 // path limit -> time limit ( TODO : extract life-time directly from decay helper )
1365 double tDec = freepath > 0. ? freepath : -1.;
1366 int decayProc = 0;
1367
1368 /* uncomment if unstable particles used by FastCaloSim
1369 // beta calculated here for further use in validation
1370 double mass = m_particleMasses.mass[pHypothesis];
1371 double mom = isp.momentum().mag();
1372 double beta = mom/sqrt(mom*mom+mass*mass);
1373
1374 if ( tDec>0.)
1375 {
1376 tDec = tDec/beta/CLHEP::c_light + isp.timeStamp();
1377 decayProc = 201;
1378 }
1379 */
1380
1381 Trk::TimeLimit timeLim(tDec,0.,decayProc); // TODO: set vertex time info
1382
1383 // prompt decay ( uncomment if unstable particles used )
1384 //if ( freepath>0. && freepath<0.01 ) {
1385 // if (!m_particleDecayHelper.empty()) {
1386 // ATH_MSG_VERBOSE( "[ fatras transport ] Decay is triggered for input particle.");
1387 // m_particleDecayHelper->decay(isp);
1388 // }
1389 // return 0;
1390 //}
1391
1392 // presample interactions - ADAPT FOR FASTCALOSIM
1393 Trk::PathLimit pathLim(-1.,0);
1394 //if (absPdg!=999 && pHypothesis<99) pathLim = m_samplingTool->sampleProcess(mom,isp.charge(),pHypothesis);
1395
1396 Trk::GeometrySignature nextGeoID=Trk::Calo;
1397
1398 // first extrapolation to reach the ID boundary
1399 ATH_MSG_DEBUG( "[ fastCaloSim transport ] before calo entrance ");
1400
1401 // get CaloEntrance if not done already
1402 if (!m_caloEntrance.get())
1403 {
1404 m_caloEntrance.set(m_extrapolator->trackingGeometry()->trackingVolume(m_caloEntranceName));
1405 if(!m_caloEntrance.get())
1406 ATH_MSG_INFO("CaloEntrance not found ");
1407 else
1408 ATH_MSG_INFO("CaloEntrance found ");
1409 }
1410
1411 ATH_MSG_DEBUG( "[ fastCaloSim transport ] after calo entrance ");
1412
1413 std::unique_ptr<const Trk::TrackParameters> caloEntry = nullptr;
1414
1415 if(m_caloEntrance.get() && m_caloEntrance.get()->inside(pos,0.001) && !m_extrapolator->trackingGeometry()->atVolumeBoundary(pos,m_caloEntrance.get(),0.001))
1416 {
1417 std::vector<Trk::HitInfo>* dummyHitVector = nullptr;
1418 if (charge == 0) {
1419 caloEntry =
1420 m_extrapolator->transportNeutralsWithPathLimit(inputPar,
1421 pathLim,
1422 timeLim,
1423 Trk::alongMomentum,
1424 pHypothesis,
1425 dummyHitVector,
1426 nextGeoID,
1427 m_caloEntrance.get());
1428 } else {
1429 caloEntry = m_extrapolator->extrapolateWithPathLimit(inputPar,
1430 pathLim,
1431 timeLim,
1432 Trk::alongMomentum,
1433 pHypothesis,
1434 dummyHitVector,
1435 nextGeoID,
1436 m_caloEntrance.get());
1437 }
1438 } else{
1439 caloEntry = inputPar.uniqueClone();
1440 }
1441
1442 ATH_MSG_DEBUG( "[ fastCaloSim transport ] after calo caloEntry ");
1443
1444 if(caloEntry)
1445 {
1446 std::unique_ptr<const Trk::TrackParameters> eParameters = nullptr;
1447
1448 // save Calo entry hit (fallback info)
1449 hitVector->push_back(Trk::HitInfo(caloEntry->uniqueClone(),timeLim.time,nextGeoID,0.));
1450
1451 ATH_MSG_DEBUG( "[ fastCaloSim transport ] starting Calo transport from position eta="<<caloEntry->position().eta()<<" phi="<<caloEntry->position().phi()<<" d="<<caloEntry->position().mag() );
1452
1453 if (charge == 0) {
1454 eParameters =
1455 m_extrapolator->transportNeutralsWithPathLimit(*caloEntry,
1456 pathLim,
1457 timeLim,
1458 Trk::alongMomentum,
1459 pHypothesis,
1460 hitVector,
1461 nextGeoID);
1462 } else {
1463 eParameters = m_extrapolator->extrapolateWithPathLimit(*caloEntry,
1464 pathLim,
1465 timeLim,
1466 Trk::alongMomentum,
1467 pHypothesis,
1468 hitVector,
1469 nextGeoID);
1470 }
1471 // save Calo exit hit (fallback info)
1472 if (eParameters) hitVector->push_back(Trk::HitInfo(std::move(eParameters),timeLim.time,nextGeoID,0.));
1473 //delete eParameters; // HitInfo took ownership
1474 }
1475
1476 if(msgLvl(MSG::DEBUG))
1477 {
1478 std::vector<Trk::HitInfo>::iterator it = hitVector->begin();
1479 while (it < hitVector->end() )
1480 {
1481 int sample=(*it).detID;
1482 Amg::Vector3D hitPos = (*it).trackParms->position();
1483 ATH_MSG_DEBUG(" HIT: layer="<<sample<<" sample="<<sample-3000<<" eta="<<hitPos.eta()<<" phi="<<hitPos.phi()<<" d="<<hitPos.mag());
1484 ++it;
1485 }
1486 }
1487
1488 return hitVector;
1489} //caloHits
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
charge
double charge(const T &p)
Definition AtlasPID.h:997
hitVector
std::vector< FPGATrackSimHit > hitVector
Definition FPGATrackSimCluster.h:22
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition AthCommonMsg.h:30
ISF_HitAnalysis::m_caloEntranceName
StringProperty m_caloEntranceName
Definition ISF_HitAnalysis.h:111
ISF_HitAnalysis::m_pdgToParticleHypothesis
Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis
Definition ISF_HitAnalysis.h:240
ISF_HitAnalysis::m_caloEntrance
CxxUtils::CachedPointer< const Trk::TrackingVolume > m_caloEntrance
The new Extrapolator setup.
Definition ISF_HitAnalysis.h:238
ISF_HitAnalysis::m_extrapolator
PublicToolHandle< Trk::ITimedExtrapolator > m_extrapolator
Definition ISF_HitAnalysis.h:109
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:47
FullCPAlgorithmsTest_eljob.sample
sample
Definition FullCPAlgorithmsTest_eljob.py:116
ParticleGun_EoverP_Config.mom
mom
Definition ParticleGun_EoverP_Config.py:63
Trk::alongMomentum
@ alongMomentum
Definition PropDirection.h:20
Trk::CurvilinearParameters
CurvilinearParametersT< TrackParametersDim, Charged, PlaneSurface > CurvilinearParameters
Definition Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:29
Trk::ParticleHypothesis
ParticleHypothesis
Enumeration for Particle hypothesis respecting the interaction with material.
Definition ParticleHypothesis.h:28

◆ declareGaudiProperty()

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

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

Definition at line 156 of file AthCommonDataStore.h.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

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

◆ evtStore()

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

◆ execute()

StatusCode ISF_HitAnalysis::execute ( )
overridevirtual

Definition at line 481 of file ISF_HitAnalysis.cxx.

482{
483
484 ATH_MSG_DEBUG( "In ISF_HitAnalysis::execute()" );
485
486 if (! m_tree)
487 {
488 ATH_MSG_ERROR( "tree not registered" );
489 return StatusCode::FAILURE;
490 }
491
492 SG::ReadCondHandle<ILArfSampl> fSamplHdl(m_fSamplKey,Gaudi::Hive::currentContext());
493 const ILArfSampl* fSampl=*fSamplHdl;
494
495 SG::ReadCondHandle<TileSamplingFraction> tileSamplingFraction(m_tileSamplingFractionKey,Gaudi::Hive::currentContext());
496 ATH_CHECK( tileSamplingFraction.isValid() );
497
498
499 //now if the branches were created correctly, the pointers point to something and it is possible to clear the vectors
500 TVector3 vectest;
501 vectest.SetPtEtaPhi(1.,1.,1.);
502 m_hit_x->clear();
503 m_hit_y->clear();
504 m_hit_z->clear();
505 m_hit_energy->clear();
506 m_hit_time->clear();
507 m_hit_identifier->clear();
508 m_hit_cellidentifier->clear();
509 m_islarbarrel->clear();
510 m_islarendcap->clear();
511 m_islarhec->clear();
512 m_islarfcal->clear();
513 m_istile->clear();
514 m_hit_sampling->clear();
515 m_hit_samplingfraction->clear();
516 m_truth_energy->clear();
517 m_truth_px->clear();
518 m_truth_py->clear();
519 m_truth_pz->clear();
520 m_truth_pdg->clear();
521 m_truth_barcode->clear();
522 m_truth_vtxbarcode->clear();
523 m_cluster_energy->clear();
524 m_cluster_eta->clear();
525 m_cluster_phi->clear();
526 m_cluster_size->clear();
527 m_cluster_cellID->clear();
528 m_cell_identifier->clear();
529 m_cell_energy->clear();
530 m_cell_sampling->clear();
531 m_g4hit_energy->clear();
532 m_g4hit_time->clear();
533 m_g4hit_identifier->clear();
534 m_g4hit_cellidentifier->clear();
535 m_g4hit_sampling->clear();
536 m_g4hit_samplingfraction->clear();
537 //which fails for this one!!
538 //m_matched_cells->clear();
539 std::map<Long64_t, FCS_cell> cells; //read all objects and collect them by identifier (Long64_t)
540 std::map<Long64_t, std::vector<FCS_g4hit> > g4hits;
541 std::map<Long64_t, std::vector<FCS_hit> > hits;
542
543 cells.clear();
544 g4hits.clear();
545 hits.clear();
546
547 FCS_cell one_cell{}; //note that this is not extra safe if I don't have a clear method!
548 FCS_g4hit one_g4hit{};
549 FCS_hit one_hit{};
550 FCS_matchedcell one_matchedcell;
551
552 m_oneeventcells->m_vector.clear();
553 m_final_g4hit_energy->clear();
554 m_final_hit_energy->clear();
555 m_final_cell_energy->clear();
556
557 m_newTTC_back_eta->clear();
558 m_newTTC_back_phi->clear();
559 m_newTTC_back_r->clear();
560 m_newTTC_back_z->clear();
561 m_newTTC_back_detaBorder->clear();
562 m_newTTC_back_OK->clear();
563 m_newTTC_entrance_eta->clear();
564 m_newTTC_entrance_phi->clear();
565 m_newTTC_entrance_r->clear();
566 m_newTTC_entrance_z->clear();
567 m_newTTC_entrance_detaBorder->clear();
568 m_newTTC_entrance_OK->clear();
569 m_newTTC_mid_eta->clear();
570 m_newTTC_mid_phi->clear();
571 m_newTTC_mid_r->clear();
572 m_newTTC_mid_z->clear();
573 m_newTTC_mid_detaBorder->clear();
574 m_newTTC_mid_OK->clear();
575 m_newTTC_IDCaloBoundary_eta->clear();
576 m_newTTC_IDCaloBoundary_phi->clear();
577 m_newTTC_IDCaloBoundary_r->clear();
578 m_newTTC_IDCaloBoundary_z->clear();
579 m_newTTC_Angle3D->clear();
580 m_newTTC_AngleEta->clear();
581
582
583 m_MuonEntryLayer_E->clear();
584 m_MuonEntryLayer_x->clear();
585 m_MuonEntryLayer_y->clear();
586 m_MuonEntryLayer_z->clear();
587 m_MuonEntryLayer_px->clear();
588 m_MuonEntryLayer_py->clear();
589 m_MuonEntryLayer_pz->clear();
590 m_MuonEntryLayer_pdg->clear();
591
592 //##########################
593
594 SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey,Gaudi::Hive::currentContext()};
595 ATH_CHECK(caloMgrHandle.isValid());
596 const CaloDetDescrManager* calo_dd_man = *caloMgrHandle;
597
598 //Get the FastCaloSim step info collection from store
599 const ISF_FCS_Parametrization::FCS_StepInfoCollection* eventStepsES;
600 StatusCode sc = evtStore()->retrieve(eventStepsES, "MergedEventSteps");
601 if (sc.isFailure()) {
602 ATH_MSG_WARNING( "No FastCaloSim steps read from StoreGate?" );
603 //return StatusCode::FAILURE;
604 } else {
605 ATH_MSG_INFO("Read: "<<eventStepsES->size()<<" position hits");
606 for (ISF_FCS_Parametrization::FCS_StepInfoCollection::const_iterator it = eventStepsES->begin(); it != eventStepsES->end(); ++it) {
607 m_hit_x->push_back( (*it)->x() );
608 m_hit_y->push_back( (*it)->y() );
609 m_hit_z->push_back( (*it)->z() );
610 m_hit_energy->push_back( (*it)->energy() );
611 m_hit_time->push_back( (*it)->time());
612
613 //Try to get the samplings, sampling fractions from identifiers
614 bool larbarrel=false;
615 bool larendcap=false;
616 bool larhec=false;
617 bool larfcal=false;
618 bool tile=false;
619 int sampling=-1;
620 double sampfrac=0.0;
621
622 Identifier id = (*it)->identify();
623 Identifier cell_id = (*it)->identify(); //to be replaced by cell_id in tile
624
625 if(calo_dd_man->get_element(id)) {
626 CaloCell_ID::CaloSample layer = calo_dd_man->get_element(id)->getSampling();
627 sampling = layer; //use CaloCell layer immediately
628 } else {
629 ATH_MSG_WARNING( "Warning no sampling info for "<<id.getString());
630 }
631
632 if(m_larEmID->is_lar_em(id) || m_larHecID->is_lar_hec(id) || m_larFcalID->is_lar_fcal(id)) sampfrac=fSampl->FSAMPL(id);
633 if (m_tileID->is_tile(id)) {
634 HWIdentifier channel_id = m_tileCabling->s2h_channel_id(id);
635 int channel = m_tileHWID->channel(channel_id);
636 int drawerIdx = m_tileHWID->drawerIdx(channel_id);
637 sampfrac = tileSamplingFraction->getSamplingFraction(drawerIdx, channel);
638 }
639 if(m_larEmID->is_lar_em(id)) {
640 //LAr EM cells
641 if (m_larEmID->is_em_barrel(id)) larbarrel=true;
642 else if(m_larEmID->is_em_endcap(id)) larendcap=true;
643 } else if(m_larHecID->is_lar_hec(id)) {
644 //LAr HEC cells
645 larhec = true;
646 } else if(m_larFcalID->is_lar_fcal(id)) {
647 //LAr FCal cells
648 larfcal = true;
649 } else if (m_tileID->is_tile_aux(id)) {
650 // special case for E4'
651 tile = true;
652 cell_id = m_tileID->cell_id(id);
653 sampling = CaloCell_ID::TileGap3;
654 } else if(m_tileID->is_tile_barrel(id) || m_tileID->is_tile_extbarrel(id) || m_tileID->is_tile_gap(id)) {
655 // all other Tile cells
656 tile = true;
657 cell_id = m_tileID->cell_id(id);
658 Int_t tile_sampling = -1;
659 if(calo_dd_man->get_element(cell_id)) {
660 tile_sampling = calo_dd_man->get_element(cell_id)->getSampling();
661 }
662 if(tile_sampling!= -1) sampling = tile_sampling; //calo_dd_man needs to be called with cell_id not pmt_id!!
663 } else {
664 ATH_MSG_WARNING( "This hit is somewhere. Please check!");
665 }
666
667 m_hit_identifier->push_back(id.get_compact());
668 m_hit_cellidentifier->push_back(cell_id.get_compact());
669 //push things into vectors:
670 m_islarbarrel->push_back(larbarrel);
671 m_islarendcap->push_back(larendcap);
672 m_islarhec->push_back(larhec);
673 m_islarfcal->push_back(larfcal);
674 m_istile->push_back(tile);
675 m_hit_sampling->push_back(sampling);
676 m_hit_samplingfraction->push_back(sampfrac);
677
678 } //event steps
679 }//event steps read correctly
680
681 //Get truth particle info
682 //Note that there can be more truth particles, the first one is usually the one we need.
683 const McEventCollection* mcEvent;
684 sc = evtStore()->retrieve(mcEvent,"TruthEvent");
685 if(sc.isFailure()) {
686 ATH_MSG_WARNING( "No truth event!");
687 } else {
688 if(mcEvent) {
689 //std::cout<<"ISF_HitAnalysis: MC event size: "<<mcEvent->size()<<std::endl;
690 if(!mcEvent->empty()) {
691 int particleIndex=0;
692 int loopEnd = m_NtruthParticles;
693 int particles_size=(*mcEvent->begin())->particles_size();
694 if(loopEnd==-1) {
695 loopEnd = particles_size; //is this the correct thing?
696 }
697#ifdef HEPMC3
698 for (const auto& part: *(*mcEvent->begin()))
699#else
700 for (const auto part: *(*mcEvent->begin()))
701#endif
702 {
703
704 ATH_MSG_DEBUG("Number truth particles="<<particles_size<<" loopEnd="<<loopEnd);
705 particleIndex++;
706
707 if (particleIndex>loopEnd) break; //enough particles
708
709 //UPDATE EXTRAPOLATION WITH ALGTOOL***********************************************
710
711 TFCSTruthState truth(part->momentum().px(),part->momentum().py(),part->momentum().pz(),part->momentum().e(),part->pdg_id());
712
713 //calculate the vertex
714 TVector3 moment;
715 moment.SetXYZ(part->momentum().px(),part->momentum().py(),part->momentum().pz());
716 TVector3 direction=moment.Unit();
717
718 //does it hit the barrel or the EC?
719
720 if(std::abs(direction.Z())/m_CaloBoundaryZ < direction.Perp()/m_CaloBoundaryR) {
721 //BARREL
722 direction*=m_CaloBoundaryR/direction.Perp();
723 } else {
724 //EC
725 direction*=m_CaloBoundaryZ/abs(direction.Z());
726 }
727
728 if((part)->production_vertex()) {
729 truth.set_vertex((part)->production_vertex()->position().x(), (part)->production_vertex()->position().y(), (part)->production_vertex()->position().z());
730 } else {
731 truth.set_vertex(direction.X(),direction.Y(),direction.Z());
732 ATH_MSG_WARNING("No particle production vetext, use VERTEX from direction: x "<<direction.X()<<" y "<<direction.Y()<<" z "<<direction.Z());
733 }
734
735 if( std::abs(direction.X()-truth.vertex().X())>0.1 || std::abs(direction.Y()-truth.vertex().Y())>0.1 || std::abs(direction.Z()-truth.vertex().Z())>0.1 ) {
736 ATH_MSG_WARNING("VERTEX from direction: x "<<direction.X()<<" y "<<direction.Y()<<" z "<<direction.Z());
737 ATH_MSG_WARNING("but VERTEX from hepmc: x "<<truth.vertex().X()<<" y "<<truth.vertex().Y()<<" z "<<truth.vertex().Z());
738 }
739
740 TFCSExtrapolationState result;
741 m_FastCaloSimCaloExtrapolation->extrapolate(result,&truth);
742
743 //write the result into the ntuple variables:
744
745 ATH_MSG_DEBUG("IDCaloBoundary_eta() "<<result.IDCaloBoundary_eta());
746 ATH_MSG_DEBUG("IDCaloBoundary_phi() "<<result.IDCaloBoundary_phi());
747 ATH_MSG_DEBUG("IDCaloBoundary_r() "<<result.IDCaloBoundary_r());
748 ATH_MSG_DEBUG("IDCaloBoundary_z() "<<result.IDCaloBoundary_z());
749 ATH_MSG_DEBUG("AngleEta "<<result.IDCaloBoundary_AngleEta());
750 ATH_MSG_DEBUG("Angle3D "<<result.IDCaloBoundary_Angle3D());
751
752 m_newTTC_IDCaloBoundary_eta->push_back(float(result.IDCaloBoundary_eta()));
753 m_newTTC_IDCaloBoundary_phi->push_back(float(result.IDCaloBoundary_phi()));
754 m_newTTC_IDCaloBoundary_r->push_back(float(result.IDCaloBoundary_r()));
755 m_newTTC_IDCaloBoundary_z->push_back(float(result.IDCaloBoundary_z()));
756 m_newTTC_Angle3D ->push_back(float(result.IDCaloBoundary_Angle3D()));
757 m_newTTC_AngleEta->push_back(float(result.IDCaloBoundary_AngleEta()));
758
759 std::vector<float> eta_vec_ENT;
760 std::vector<float> phi_vec_ENT;
761 std::vector<float> r_vec_ENT;
762 std::vector<float> z_vec_ENT;
763 std::vector<float> detaBorder_vec_ENT;
764 std::vector<bool> OK_vec_ENT;
765
766 std::vector<float> eta_vec_EXT;
767 std::vector<float> phi_vec_EXT;
768 std::vector<float> r_vec_EXT;
769 std::vector<float> z_vec_EXT;
770 std::vector<float> detaBorder_vec_EXT;
771 std::vector<bool> OK_vec_EXT;
772
773 std::vector<float> eta_vec_MID;
774 std::vector<float> phi_vec_MID;
775 std::vector<float> r_vec_MID;
776 std::vector<float> z_vec_MID;
777 std::vector<float> detaBorder_vec_MID;
778 std::vector<bool> OK_vec_MID;
779
780 for(int sample=CaloCell_ID_FCS::FirstSample;sample<CaloCell_ID_FCS::MaxSample;++sample) {
781 ATH_MSG_DEBUG("sample "<<sample);
782 ATH_MSG_DEBUG(" eta ENT "<<result.eta(sample,1)<<" eta EXT "<<result.eta(sample,2));
783 ATH_MSG_DEBUG(" phi ENT "<<result.phi(sample,1)<<" phi EXT "<<result.phi(sample,2));
784 ATH_MSG_DEBUG(" r ENT "<<result.r(sample,1) <<" r EXT "<<result.r(sample,2) );
785 ATH_MSG_DEBUG(" z ENT "<<result.z(sample,1) <<" z EXT "<<result.z(sample,2) );
786 ATH_MSG_DEBUG(" detaBorder ENT "<<result.detaBorder(sample,1) <<" detaBorder EXT "<<result.detaBorder(sample,2) );
787 ATH_MSG_DEBUG(" OK ENT "<<result.OK(sample,1) <<" OK EXT "<<result.OK(sample,2) );
788 eta_vec_ENT.push_back(float(result.eta(sample,TFCSExtrapolationState::SUBPOS_ENT)));
789 eta_vec_EXT.push_back(float(result.eta(sample,TFCSExtrapolationState::SUBPOS_EXT)));
790 eta_vec_MID.push_back(float(result.eta(sample,TFCSExtrapolationState::SUBPOS_MID)));
791 phi_vec_ENT.push_back(float(result.phi(sample,TFCSExtrapolationState::SUBPOS_ENT)));
792 phi_vec_EXT.push_back(float(result.phi(sample,TFCSExtrapolationState::SUBPOS_EXT)));
793 phi_vec_MID.push_back(float(result.phi(sample,TFCSExtrapolationState::SUBPOS_MID)));
794 r_vec_ENT.push_back(float(result.r(sample,TFCSExtrapolationState::SUBPOS_ENT)));
795 r_vec_EXT.push_back(float(result.r(sample,TFCSExtrapolationState::SUBPOS_EXT)));
796 r_vec_MID.push_back(float(result.r(sample,TFCSExtrapolationState::SUBPOS_MID)));
797 z_vec_ENT.push_back(float(result.z(sample,TFCSExtrapolationState::SUBPOS_ENT)));
798 z_vec_EXT.push_back(float(result.z(sample,TFCSExtrapolationState::SUBPOS_EXT)));
799 z_vec_MID.push_back(float(result.z(sample,TFCSExtrapolationState::SUBPOS_MID)));
800 detaBorder_vec_ENT.push_back(float(result.detaBorder(sample,TFCSExtrapolationState::SUBPOS_ENT)));
801 detaBorder_vec_EXT.push_back(float(result.detaBorder(sample,TFCSExtrapolationState::SUBPOS_EXT)));
802 detaBorder_vec_MID.push_back(float(result.detaBorder(sample,TFCSExtrapolationState::SUBPOS_MID)));
803 OK_vec_ENT.push_back(result.OK(sample,TFCSExtrapolationState::SUBPOS_ENT));
804 OK_vec_EXT.push_back(result.OK(sample,TFCSExtrapolationState::SUBPOS_EXT));
805 OK_vec_MID.push_back(result.OK(sample,TFCSExtrapolationState::SUBPOS_MID));
806 }
807
808 m_newTTC_back_eta->push_back(eta_vec_EXT);
809 m_newTTC_back_phi->push_back(phi_vec_EXT);
810 m_newTTC_back_r ->push_back(r_vec_EXT);
811 m_newTTC_back_z ->push_back(z_vec_EXT);
812 m_newTTC_back_detaBorder ->push_back(detaBorder_vec_EXT);
813 m_newTTC_back_OK ->push_back(OK_vec_EXT);
814 m_newTTC_entrance_eta->push_back(eta_vec_ENT);
815 m_newTTC_entrance_phi->push_back(phi_vec_ENT);
816 m_newTTC_entrance_r ->push_back(r_vec_ENT);
817 m_newTTC_entrance_z ->push_back(z_vec_ENT);
818 m_newTTC_entrance_detaBorder ->push_back(detaBorder_vec_ENT);
819 m_newTTC_entrance_OK ->push_back(OK_vec_ENT);
820 m_newTTC_mid_eta->push_back(eta_vec_MID);
821 m_newTTC_mid_phi->push_back(phi_vec_MID);
822 m_newTTC_mid_r ->push_back(r_vec_MID);
823 m_newTTC_mid_z ->push_back(z_vec_MID);
824 m_newTTC_mid_detaBorder ->push_back(detaBorder_vec_MID);
825 m_newTTC_mid_OK ->push_back(OK_vec_MID);
826
827 m_truth_energy->push_back((part)->momentum().e());
828 m_truth_px->push_back((part)->momentum().px());
829 m_truth_py->push_back((part)->momentum().py());
830 m_truth_pz->push_back((part)->momentum().pz());
831 m_truth_pdg->push_back((part)->pdg_id());
832 m_truth_barcode->push_back(HepMC::barcode(part));
833
834 } //for mcevent
835 } //mcevent size
836 } //mcEvent
837 }//truth event
838
839 //Retrieve and save MuonEntryLayer information
840 const TrackRecordCollection *MuonEntry = nullptr;
841 sc = evtStore()->retrieve(MuonEntry, "MuonEntryLayer");
842 if (sc.isFailure())
843 {
844 ATH_MSG_WARNING( "Couldn't read MuonEntry from StoreGate");
845 //return NULL;
846 }
847 else{
848 for ( const TrackRecord &record : *MuonEntry){
849 m_MuonEntryLayer_E->push_back((record).GetEnergy());
850 m_MuonEntryLayer_px->push_back((record).GetMomentum().getX());
851 m_MuonEntryLayer_py->push_back((record).GetMomentum().getY());
852 m_MuonEntryLayer_pz->push_back((record).GetMomentum().getZ());
853 m_MuonEntryLayer_x->push_back((record).GetPosition().getX());
854 m_MuonEntryLayer_y->push_back((record).GetPosition().getY());
855 m_MuonEntryLayer_z->push_back((record).GetPosition().getZ());
856 m_MuonEntryLayer_pdg->push_back((record).GetPDGCode());
857 }
858 }
859
860 // Get the reco clusters if available
861// retreiving cluster container
862 const xAOD::CaloClusterContainer* theClusters;
863 std::string clusterContainerName = "CaloCalTopoClusters"; //Local hadron calibrated Topo-clusters , raw is the EM scale
864 sc = evtStore()->retrieve(theClusters, clusterContainerName);
865 if (sc.isFailure()) {
866 ATH_MSG_WARNING(" Couldn't get cluster container '" << clusterContainerName << "'");
867 return StatusCode::SUCCESS;
868 }
869 xAOD::CaloClusterContainer::const_iterator itrClus = theClusters->begin();
870 xAOD::CaloClusterContainer::const_iterator itrLastClus = theClusters->end();
871 for ( ; itrClus!=itrLastClus; ++itrClus){
872 const xAOD::CaloCluster *cluster =(*itrClus);
873 m_cluster_energy->push_back(cluster->e(xAOD::CaloCluster::UNCALIBRATED)); // getRawE, cluster->e() is the Local hadron calibrated topo-clusters
874 m_cluster_eta->push_back(cluster->eta(xAOD::CaloCluster::UNCALIBRATED));
875 m_cluster_phi->push_back(cluster->phi(xAOD::CaloCluster::UNCALIBRATED));
876 ATH_MSG_VERBOSE("Cluster energy: " << cluster->e() << " EMscale: " << cluster->e(xAOD::CaloCluster::UNCALIBRATED) << " cells: " << " links: " << cluster->getCellLinks());
877
878 const CaloClusterCellLink* cellLinks = cluster->getCellLinks();
879 if (!cellLinks) {
880 ATH_MSG_DEBUG( "No cell links for this cluster" );
881 continue;
882 }
883
884 const CaloCellContainer* cellCont=cellLinks->getCellContainer();
885 if (!cellCont) {
886 ATH_MSG_DEBUG( "DataLink to cell container is broken" );
887 continue;
888 }
889 unsigned cellcount = 0;
890 std::vector<Long64_t> cellIDs_in_cluster;
891 xAOD::CaloCluster::const_cell_iterator cellIter =cluster->cell_begin();
892 xAOD::CaloCluster::const_cell_iterator cellIterEnd =cluster->cell_end();
893 for ( ;cellIter !=cellIterEnd;cellIter++) {
894 ++cellcount;
895 const CaloCell* cell= (*cellIter);
896 cellIDs_in_cluster.push_back(cell->ID().get_compact());
897 float EnergyCell=cell->energy(); //ID, time, phi, eta
898 ATH_MSG_DEBUG(" Cell energy: " << EnergyCell);
899 }// end of cells inside cluster loop
900 m_cluster_size->push_back(cellcount);
901 m_cluster_cellID->push_back(cellIDs_in_cluster);
902 }
903
904 //Get reco cells if available
905 const CaloCellContainer *cellColl = nullptr;
906 sc = evtStore()->retrieve(cellColl, "AllCalo");
907
908 if (sc.isFailure())
909 {
910 ATH_MSG_WARNING( "Couldn't read AllCalo cells from StoreGate");
911 }
912 else
913 {
914 ATH_MSG_INFO( "Found: "<<cellColl->size()<<" calorimeter cells");
915 CaloCellContainer::const_iterator itrCell = cellColl->begin();
916 CaloCellContainer::const_iterator itrLastCell = cellColl->end();
917 for ( ; itrCell!=itrLastCell; ++itrCell)
918 {
919 m_cell_energy->push_back((*itrCell)->energy());
920 m_cell_identifier->push_back((*itrCell)->ID().get_compact());
921 if (m_tileID->is_tile_aux((*itrCell)->ID())) {
922 // special case for E4'
923 m_cell_sampling->push_back(CaloCell_ID::TileGap3);
924 }
925 else if (calo_dd_man->get_element((*itrCell)->ID()))
926 {
927 // all other Tile cells
928 CaloCell_ID::CaloSample layer = calo_dd_man->get_element((*itrCell)->ID())->getSampling();
929 m_cell_sampling->push_back(layer);
930 }
931 else
932 m_cell_sampling->push_back(-1);
933 }
934 } //calorimeter cells
935
936 //Get all G4Hits (from CaloHitAnalysis)
937 std::string lArKey [4] = {"LArHitEMB", "LArHitEMEC", "LArHitFCAL", "LArHitHEC"};
938 for (unsigned int i=0;i<4;i++)
939 {
940 const LArHitContainer* iter;
941 ATH_MSG_DEBUG( "Checking G4Hits: "<<lArKey[i]);
942 if(evtStore()->retrieve(iter,lArKey[i])==StatusCode::SUCCESS)
943 {
944 LArHitContainer::const_iterator hi;
945 int hitnumber = 0;
946 for (hi=(*iter).begin();hi!=(*iter).end();++hi) {
947 hitnumber++;
948 const LArHit* larHit = *hi;
949 const CaloDetDescrElement *hitElement = calo_dd_man->get_element(larHit->cellID());
950 if(!hitElement)
951 continue;
952 Identifier larhitid = hitElement->identify();
953 if(calo_dd_man->get_element(larhitid)) {
954 CaloCell_ID::CaloSample larlayer = calo_dd_man->get_element(larhitid)->getSampling();
955
956 float larsampfrac=fSampl->FSAMPL(larhitid);
957 m_g4hit_energy->push_back( larHit->energy() );
958 m_g4hit_time->push_back( larHit->time() );
959 m_g4hit_identifier->push_back( larhitid.get_compact() );
960 m_g4hit_cellidentifier->push_back( larhitid.get_compact() );
961 m_g4hit_sampling->push_back( larlayer);
962 m_g4hit_samplingfraction->push_back( larsampfrac );
963 }
964 } // End while LAr hits
965 ATH_MSG_INFO( "Read "<<hitnumber<<" G4Hits from "<<lArKey[i]);
966 }
967 else
968 {
969 ATH_MSG_INFO( "Can't retrieve LAr hits");
970 }// End statuscode success upon retrieval of hits
971 //std::cout <<"ZH G4Hit size: "<<m_g4hit_e->size()<<std::endl;
972 }// End detector type loop
973
974 const TileHitVector * hitVec = nullptr;
975 if (evtStore()->retrieve(hitVec,"TileHitVec")==StatusCode::SUCCESS && m_tileMgr && m_tileID )
976 {
977 int hitnumber = 0;
978 for(TileHitVecConstIterator i_hit=hitVec->begin() ; i_hit!=hitVec->end() ; ++i_hit)
979 {
980 hitnumber++;
981 Identifier pmt_id = (*i_hit).identify();
982 Identifier cell_id = m_tileID->cell_id(pmt_id);
983
984 if (calo_dd_man->get_element(cell_id)){
985 CaloCell_ID::CaloSample layer = calo_dd_man->get_element(cell_id)->getSampling();
986
987 HWIdentifier channel_id = m_tileCabling->s2h_channel_id(pmt_id);
988 int channel = m_tileHWID->channel(channel_id);
989 int drawerIdx = m_tileHWID->drawerIdx(channel_id);
990 float tilesampfrac = tileSamplingFraction->getSamplingFraction(drawerIdx, channel);
991
992 //could there be more subhits??
993 for (int tilesubhit_i = 0; tilesubhit_i<(*i_hit).size(); tilesubhit_i++)
994 {
995 m_g4hit_energy->push_back( (*i_hit).energy(tilesubhit_i) );
996 m_g4hit_time->push_back( (*i_hit).time(tilesubhit_i) );
997 m_g4hit_identifier->push_back( pmt_id.get_compact() );
998 m_g4hit_cellidentifier->push_back( cell_id.get_compact() );
999 m_g4hit_sampling->push_back( layer );
1000 m_g4hit_samplingfraction->push_back( tilesampfrac );
1001 }
1002 }
1003 }
1004 ATH_MSG_INFO( "Read "<<hitnumber<<" G4Hits from TileHitVec");
1005 }
1006
1007
1008 // CaloHitAna
1009 ATH_MSG_DEBUG("CaloHitAna begin!");
1010
1011 //cells
1012 for (unsigned int cell_i = 0; cell_i < m_cell_identifier->size(); cell_i++){
1013 if (cells.find((*m_cell_identifier)[cell_i]) == cells.end()) { //doesn't exist
1014 one_cell.cell_identifier = (*m_cell_identifier)[cell_i];
1015 one_cell.sampling = (*m_cell_sampling)[cell_i];
1016 one_cell.energy = (*m_cell_energy)[cell_i];
1017 one_cell.center_x = 0.0; //for now
1018 one_cell.center_y = 0.0;
1019 one_cell.center_z = 0.0;
1020 cells.insert(std::pair<Long64_t, FCS_cell>(one_cell.cell_identifier, one_cell));
1021 }
1022 else
1023 {
1024 //there shouldn't be a cell with the same identifier in this event
1025 ATH_MSG_DEBUG("ISF_HitAnalysis: Same cell???? ERROR");
1026 }
1027 }
1028
1029 // g4 hits
1030 if(m_doG4Hits){
1031 for (unsigned int g4hit_i = 0; g4hit_i < m_g4hit_identifier->size(); g4hit_i++)
1032 {
1033 if ((*m_g4hit_sampling)[g4hit_i] >= 0 && (*m_g4hit_sampling)[g4hit_i] <= 25 && (*m_g4hit_time)[g4hit_i] > m_TimingCut)
1034 {
1035 ATH_MSG_DEBUG("Ignoring G4hit, time too large: " << g4hit_i << " time: " << (*m_g4hit_time)[g4hit_i]);
1036 continue;
1037 }
1038
1039 if (g4hits.find((*m_g4hit_cellidentifier)[g4hit_i]) == g4hits.end())
1040 {
1041 //this G4 hit doesn't exist yet
1042 one_g4hit.identifier = (*m_g4hit_identifier)[g4hit_i];
1043 one_g4hit.cell_identifier = (*m_g4hit_cellidentifier)[g4hit_i];
1044 one_g4hit.sampling = (*m_g4hit_sampling)[g4hit_i];
1045 one_g4hit.hit_time = (*m_g4hit_time)[g4hit_i];
1046 //scale the hit energy with the sampling fraction
1047 if (one_g4hit.sampling >= 12 && one_g4hit.sampling <= 20)
1048 { //tile
1049 if ((*m_g4hit_samplingfraction)[g4hit_i])
1050 {
1051 one_g4hit.hit_energy = (*m_g4hit_energy)[g4hit_i] * (*m_g4hit_samplingfraction)[g4hit_i];
1052 }
1053 else one_g4hit.hit_energy = 0.;
1054 }
1055 else
1056 {
1057 one_g4hit.hit_energy = (*m_g4hit_energy)[g4hit_i] / (*m_g4hit_samplingfraction)[g4hit_i];
1058 }
1059 g4hits.insert(std::pair<Long64_t, std::vector<FCS_g4hit> >(one_g4hit.cell_identifier, std::vector<FCS_g4hit>(1, one_g4hit)));
1060 }
1061 else
1062 {
1063 //G4 hit exists in this identifier -> push_back new to the vector //FCS_g4hit one_g4hit;
1064 one_g4hit.identifier = (*m_g4hit_identifier)[g4hit_i];
1065 one_g4hit.cell_identifier = (*m_g4hit_cellidentifier)[g4hit_i];
1066 one_g4hit.sampling = (*m_g4hit_sampling)[g4hit_i];
1067 one_g4hit.hit_time = (*m_g4hit_time)[g4hit_i];
1068 if (one_g4hit.sampling >= 12 && one_g4hit.sampling <= 20)
1069 { //tile
1070 if ((*m_g4hit_samplingfraction)[g4hit_i])
1071 {
1072 one_g4hit.hit_energy = (*m_g4hit_energy)[g4hit_i] * (*m_g4hit_samplingfraction)[g4hit_i];
1073 }
1074 else one_g4hit.hit_energy = 0.;
1075 }
1076 else
1077 {
1078 one_g4hit.hit_energy = (*m_g4hit_energy)[g4hit_i] / (*m_g4hit_samplingfraction)[g4hit_i];
1079 }
1080 g4hits[(*m_g4hit_cellidentifier)[g4hit_i]].push_back(one_g4hit);
1081 }
1082 }
1083 }
1084
1085 //hits
1086 for (unsigned int hit_i = 0; hit_i < m_hit_identifier->size(); hit_i++)
1087 {
1088 if ((*m_hit_sampling)[hit_i] >= 0 && (*m_hit_sampling)[hit_i] <= 25 && (*m_hit_time)[hit_i] > m_TimingCut)
1089 {
1090 ATH_MSG_DEBUG("Ignoring FCS hit, time too large: " << hit_i << " time: " << (*m_hit_time)[hit_i]);
1091 continue;
1092 }
1093 if (hits.find((*m_hit_cellidentifier)[hit_i]) == hits.end())
1094 {
1095 //Detailed hit doesn't exist yet
1096 one_hit.identifier = (*m_hit_identifier)[hit_i];
1097 one_hit.cell_identifier = (*m_hit_cellidentifier)[hit_i];
1098 one_hit.sampling = (*m_hit_sampling)[hit_i];
1099
1100 if (one_hit.sampling >= 12 && one_hit.sampling <= 20)
1101 { //tile
1102 if ((*m_hit_samplingfraction)[hit_i])
1103 {
1104 one_hit.hit_energy = (*m_hit_energy)[hit_i] * (*m_hit_samplingfraction)[hit_i];
1105 }
1106 else one_hit.hit_energy = 0.;
1107 }
1108 else
1109 {
1110 one_hit.hit_energy = (*m_hit_energy)[hit_i] / (*m_hit_samplingfraction)[hit_i];
1111 }
1112 //one_hit.hit_sampfrac = (*m_hit_samplingfraction)[hit_i];
1113 one_hit.hit_time = (*m_hit_time)[hit_i];
1114 one_hit.hit_x = (*m_hit_x)[hit_i];
1115 one_hit.hit_y = (*m_hit_y)[hit_i];
1116 one_hit.hit_z = (*m_hit_z)[hit_i];
1117 hits.insert(std::pair<Long64_t, std::vector<FCS_hit> >(one_hit.cell_identifier, std::vector<FCS_hit>(1, one_hit)));
1118 }
1119 else
1120 {
1121 //Detailed hit exists in this identifier -> push_back new to the vector
1122 one_hit.identifier = (*m_hit_identifier)[hit_i];
1123 one_hit.cell_identifier = (*m_hit_cellidentifier)[hit_i];
1124 one_hit.sampling = (*m_hit_sampling)[hit_i];
1125 //one_hit.hit_energy = (*m_hit_energy)[hit_i];
1126 if (one_hit.sampling >= 12 && one_hit.sampling <= 20)
1127 { //tile
1128 if ((*m_hit_samplingfraction)[hit_i])
1129 {
1130 one_hit.hit_energy = (*m_hit_energy)[hit_i] * (*m_hit_samplingfraction)[hit_i];
1131 }
1132 else one_hit.hit_energy = 0.;
1133 }
1134 else
1135 {
1136 one_hit.hit_energy = (*m_hit_energy)[hit_i] / (*m_hit_samplingfraction)[hit_i];
1137 }
1138 //one_hit.hit_sampfrac = (*m_hit_samplingfraction)[hit_i];
1139 one_hit.hit_time = (*m_hit_time)[hit_i];
1140 one_hit.hit_x = (*m_hit_x)[hit_i];
1141 one_hit.hit_y = (*m_hit_y)[hit_i];
1142 one_hit.hit_z = (*m_hit_z)[hit_i];
1143 hits[(*m_hit_cellidentifier)[hit_i]].push_back(one_hit);
1144 }
1145 }
1146
1147 //Start matching:
1148 for (std::map<Long64_t, FCS_cell>::iterator it = cells.begin(); it != cells.end(); )
1149 {
1150 one_matchedcell.clear(); //maybe not completely necessery, as we're not pushing_back into vectors
1151 //set the cell part
1152 one_matchedcell.cell = it->second;
1153 //now look for FCS detailed hits in this cell
1154 std::map<Long64_t, std::vector<FCS_hit> >::iterator it2 = hits.find(it->first);
1155 if (it2 != hits.end())
1156 {
1157 //std::cout <<"FCS hits found in this cell"<<std::endl;
1158 one_matchedcell.hit = it2->second;
1159 hits.erase(it2); //remove it
1160 }
1161 else
1162 {
1163 //no hit found for this cell
1164 one_matchedcell.hit.clear(); //important!
1165 }
1166 //now look for G4hits in this cell
1167 std::map<Long64_t, std::vector<FCS_g4hit> >::iterator it3 = g4hits.find(it->first);
1168 if (it3 != g4hits.end())
1169 {
1170 one_matchedcell.g4hit = it3->second;
1171 g4hits.erase(it3);
1172 }
1173 else
1174 {
1175 //no g4hit found for this cell
1176 one_matchedcell.g4hit.clear();//important!
1177 }
1178 cells.erase(it++);
1179 //push_back matched cell for event jentry
1180 m_oneeventcells->push_back(one_matchedcell);
1181 }
1182
1183 //ok, cells should be empty, what about hits and g4hits?
1184 //There could be G4hits/FCS hits for which we don't have a cell ->create a dummy empty cell with 0 energy, take the cell identifier from the hit
1185 ATH_MSG_DEBUG("ISF_HitAnalysis Check after cells: " << cells.size() << " " << g4hits.size() << " " << hits.size());
1186
1187 for (std::map<Long64_t, std::vector<FCS_hit> >::iterator it = hits.begin(); it != hits.end();)
1188 {
1189 one_matchedcell.clear();
1190 one_matchedcell.cell.cell_identifier = it->first;
1191 //std::cout <<"This hit didn't exist in cell: "<<it->first<<std::endl;
1192 if (!it->second.empty())
1193 {
1194 one_matchedcell.cell.sampling = (it->second)[0].sampling;
1195 }
1196 else
1197 {
1198 one_matchedcell.cell.sampling = -1; //
1199 //ok, but you really shouldn't be here
1200 ATH_MSG_DEBUG("ERROR: You shouldn't really be here");
1201 }
1202 one_matchedcell.cell.energy = 0.;
1203 one_matchedcell.cell.center_x = 0.0;
1204 one_matchedcell.cell.center_y = 0.0;
1205 one_matchedcell.cell.center_z = 0.0;
1206 one_matchedcell.hit = it->second;
1207 std::map<Long64_t, std::vector<FCS_g4hit> >::iterator it3 = g4hits.find(it->first);
1208 if (it3 != g4hits.end())
1209 {
1210 one_matchedcell.g4hit = it3->second;
1211 g4hits.erase(it3);
1212 }
1213 else
1214 {
1215 //no g4hit found for this cell
1216 one_matchedcell.g4hit.clear(); //important!
1217 }
1218 hits.erase(it++);
1219 m_oneeventcells->push_back(one_matchedcell);
1220
1221 }
1222
1223 //ok, hits should be empty, what about g4hits?
1224 ATH_MSG_DEBUG("ISF_HitAnalysis Check after hits: " << cells.size() << " " << g4hits.size() << " " << hits.size());
1225 for (std::map<Long64_t, std::vector<FCS_g4hit> >::iterator it = g4hits.begin(); it != g4hits.end();)
1226 {
1227 one_matchedcell.clear(); //maybe not so important
1228 one_matchedcell.cell.cell_identifier = it->first;
1229 if (!it->second.empty())
1230 {
1231 one_matchedcell.cell.sampling = (it->second)[0].sampling;
1232 }
1233 else
1234 {
1235 one_matchedcell.cell.sampling = -1; //
1236 //not really
1237 ATH_MSG_DEBUG("ERROR: You shouldn't really be here");
1238 }
1239 one_matchedcell.cell.energy = 0.;
1240 one_matchedcell.cell.center_x = 0.0;
1241 one_matchedcell.cell.center_y = 0.0;
1242 one_matchedcell.cell.center_z = 0.0;
1243 one_matchedcell.g4hit = it->second;
1244 one_matchedcell.hit.clear(); //important!!
1245 g4hits.erase(it++);
1246 m_oneeventcells->push_back(one_matchedcell);
1247 }
1248
1249 //Can fill the output tree already here:
1250 m_total_cell_e = 0;
1251 m_total_hit_e = 0;
1252 m_total_g4hit_e = 0;
1253
1254 for (int j = 0; j < MAX_LAYER - 1; j++)
1255 {
1256 m_layercells[j]->m_vector = m_oneeventcells->GetLayer(j);
1257 }
1258
1259 //this is for invalid cells
1260 m_layercells[MAX_LAYER - 1]->m_vector = m_oneeventcells->GetLayer(-1);
1261 for (int i = 0; i < MAX_LAYER; i++)
1262 {
1263 m_final_cell_energy->push_back(0.0); //zero for each event!
1264 m_final_hit_energy->push_back(0.0);
1265 m_final_g4hit_energy->push_back(0.0);
1266
1267 for (unsigned int cellindex = 0; cellindex < m_layercells[i]->size(); cellindex++)
1268 {
1269 if (i != MAX_LAYER - 1)
1270 {
1271 m_final_cell_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).cell.energy;
1272 m_total_cell_e += m_layercells[i]->m_vector.at(cellindex).cell.energy;
1273 }
1274 else
1275 {
1276 //don't add the energy in the invalid layer to the total energy (if there is any (shouldn't)
1277 m_final_cell_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).cell.energy; //this should be here anyway
1278 }
1279
1280 //sum energy of all FCS detailed hits in this layer/cell
1281 for (unsigned int j = 0; j < m_layercells[i]->m_vector.at(cellindex).hit.size(); j++)
1282 {
1283 if (i != MAX_LAYER - 1)
1284 {
1285 m_total_hit_e += m_layercells[i]->m_vector.at(cellindex).hit[j].hit_energy;
1286 m_final_hit_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).hit[j].hit_energy;
1287 }
1288 else
1289 {
1290 //again, don't add invalid layer energy to the sum
1291 m_final_hit_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).hit[j].hit_energy;
1292 }
1293 }
1294
1295 //sum energy of all G4 hits in this layer/cell
1296 for (unsigned int j = 0; j < m_layercells[i]->m_vector.at(cellindex).g4hit.size(); j++)
1297 {
1298 if (i != MAX_LAYER - 1)
1299 {
1300 m_total_g4hit_e += m_layercells[i]->m_vector.at(cellindex).g4hit[j].hit_energy;
1301 m_final_g4hit_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).g4hit[j].hit_energy;
1302 }
1303 else
1304 {
1305 //don't add invalied layer energy to the sum
1306 m_final_g4hit_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).g4hit[j].hit_energy;
1307 }
1308 }
1309 }
1310 }
1311
1312 // push_back for total energy
1313 m_final_cell_energy->push_back(0.0);
1314 m_final_hit_energy->push_back(0.0);
1315 m_final_g4hit_energy->push_back(0.0);
1316
1317 m_final_cell_energy->at(MAX_LAYER) = m_total_cell_e;
1318 m_final_hit_energy->at(MAX_LAYER) = m_total_hit_e;
1319 m_final_g4hit_energy->at(MAX_LAYER) = m_total_g4hit_e;
1320
1321 //Fill the tree and finish
1322 if (m_tree) m_tree->Fill();
1323
1324 return StatusCode::SUCCESS;
1325
1326} //execute
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
GetEnergy
int GetEnergy()
Definition GetEnergy.cxx:81
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
LArHitContainer
LArHitContainer
Definition LArSimEventTPCnv.cxx:28
TileHitVecConstIterator
AtlasHitsVector< TileHit >::const_iterator TileHitVecConstIterator
Definition TileHitVector.h:30
TileHitVector
AtlasHitsVector< TileHit > TileHitVector
Definition TileHitVector.h:28
TrackRecordCollection
AtlasHitsVector< TrackRecord > TrackRecordCollection
Definition TrackRecordCollection.h:12
y
#define y
x
#define x
z
#define z
AthenaHitsVector< LArHit >::const_iterator
boost::transform_iterator< make_const, typename CONT::const_iterator > const_iterator
Definition AthenaHitsVector.h:66
AtlasHitsVector::begin
const_iterator begin() const
Definition AtlasHitsVector.h:130
AtlasHitsVector::end
const_iterator end() const
Definition AtlasHitsVector.h:133
CaloCell_ID::CaloSample
CaloSampling::CaloSample CaloSample
Definition CaloCell_ID.h:53
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition CaloDetDescrElement.cxx:63
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition CaloDetDescrManager.cxx:159
DataVector< FCS_StepInfo >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
ILArfSampl::FSAMPL
virtual const float & FSAMPL(const HWIdentifier &id) const =0
ISF_HitAnalysis::m_newTTC_entrance_OK
std::vector< std::vector< bool > > * m_newTTC_entrance_OK
Definition ISF_HitAnalysis.h:208
ISF_HitAnalysis::m_newTTC_back_r
std::vector< std::vector< float > > * m_newTTC_back_r
Definition ISF_HitAnalysis.h:211
ISF_HitAnalysis::m_final_hit_energy
std::vector< Float_t > * m_final_hit_energy
Definition ISF_HitAnalysis.h:187
ISF_HitAnalysis::m_MuonEntryLayer_pz
std::vector< float > * m_MuonEntryLayer_pz
Definition ISF_HitAnalysis.h:231
ISF_HitAnalysis::m_newTTC_back_detaBorder
std::vector< std::vector< float > > * m_newTTC_back_detaBorder
Definition ISF_HitAnalysis.h:213
ISF_HitAnalysis::m_newTTC_entrance_phi
std::vector< std::vector< float > > * m_newTTC_entrance_phi
Definition ISF_HitAnalysis.h:204
ISF_HitAnalysis::m_larHecID
const LArHEC_ID * m_larHecID
Definition ISF_HitAnalysis.h:129
ISF_HitAnalysis::m_oneeventcells
FCS_matchedcellvector * m_oneeventcells
Definition ISF_HitAnalysis.h:179
ISF_HitAnalysis::m_newTTC_mid_r
std::vector< std::vector< float > > * m_newTTC_mid_r
Definition ISF_HitAnalysis.h:217
ISF_HitAnalysis::m_g4hit_cellidentifier
std::vector< Long64_t > * m_g4hit_cellidentifier
Definition ISF_HitAnalysis.h:174
ISF_HitAnalysis::m_islarhec
std::vector< bool > * m_islarhec
Definition ISF_HitAnalysis.h:146
ISF_HitAnalysis::m_cluster_cellID
std::vector< std::vector< Long64_t > > * m_cluster_cellID
Definition ISF_HitAnalysis.h:164
ISF_HitAnalysis::m_fSamplKey
SG::ReadCondHandleKey< ILArfSampl > m_fSamplKey
Definition ISF_HitAnalysis.h:90
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_phi
std::vector< float > * m_newTTC_IDCaloBoundary_phi
Definition ISF_HitAnalysis.h:222
ISF_HitAnalysis::m_MuonEntryLayer_py
std::vector< float > * m_MuonEntryLayer_py
Definition ISF_HitAnalysis.h:230
ISF_HitAnalysis::m_cluster_eta
std::vector< float > * m_cluster_eta
Definition ISF_HitAnalysis.h:161
ISF_HitAnalysis::m_truth_barcode
std::vector< int > * m_truth_barcode
Definition ISF_HitAnalysis.h:157
ISF_HitAnalysis::m_newTTC_back_phi
std::vector< std::vector< float > > * m_newTTC_back_phi
Definition ISF_HitAnalysis.h:210
ISF_HitAnalysis::m_truth_pdg
std::vector< int > * m_truth_pdg
Definition ISF_HitAnalysis.h:156
ISF_HitAnalysis::m_larFcalID
const LArFCAL_ID * m_larFcalID
Definition ISF_HitAnalysis.h:128
ISF_HitAnalysis::m_truth_py
std::vector< float > * m_truth_py
Definition ISF_HitAnalysis.h:154
ISF_HitAnalysis::m_newTTC_mid_eta
std::vector< std::vector< float > > * m_newTTC_mid_eta
Definition ISF_HitAnalysis.h:215
ISF_HitAnalysis::m_MuonEntryLayer_x
std::vector< float > * m_MuonEntryLayer_x
Definition ISF_HitAnalysis.h:232
ISF_HitAnalysis::m_g4hit_sampling
std::vector< int > * m_g4hit_sampling
Definition ISF_HitAnalysis.h:176
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_eta
std::vector< float > * m_newTTC_IDCaloBoundary_eta
Definition ISF_HitAnalysis.h:221
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_z
std::vector< float > * m_newTTC_IDCaloBoundary_z
Definition ISF_HitAnalysis.h:224
ISF_HitAnalysis::m_FastCaloSimCaloExtrapolation
PublicToolHandle< IFastCaloSimCaloExtrapolation > m_FastCaloSimCaloExtrapolation
The FastCaloSimCaloExtrapolation tool.
Definition ISF_HitAnalysis.h:113
ISF_HitAnalysis::m_newTTC_mid_detaBorder
std::vector< std::vector< float > > * m_newTTC_mid_detaBorder
Definition ISF_HitAnalysis.h:219
ISF_HitAnalysis::m_newTTC_entrance_z
std::vector< std::vector< float > > * m_newTTC_entrance_z
Definition ISF_HitAnalysis.h:206
ISF_HitAnalysis::m_tileSamplingFractionKey
SG::ReadCondHandleKey< TileSamplingFraction > m_tileSamplingFractionKey
Name of TileSamplingFraction in condition store.
Definition ISF_HitAnalysis.h:95
ISF_HitAnalysis::m_hit_y
std::vector< float > * m_hit_y
Definition ISF_HitAnalysis.h:138
ISF_HitAnalysis::m_TimingCut
IntegerProperty m_TimingCut
Definition ISF_HitAnalysis.h:123
ISF_HitAnalysis::m_newTTC_entrance_eta
std::vector< std::vector< float > > * m_newTTC_entrance_eta
Definition ISF_HitAnalysis.h:203
ISF_HitAnalysis::m_MuonEntryLayer_z
std::vector< float > * m_MuonEntryLayer_z
Definition ISF_HitAnalysis.h:234
ISF_HitAnalysis::m_total_g4hit_e
Float_t m_total_g4hit_e
Definition ISF_HitAnalysis.h:184
ISF_HitAnalysis::m_truth_pz
std::vector< float > * m_truth_pz
Definition ISF_HitAnalysis.h:155
ISF_HitAnalysis::m_cluster_energy
std::vector< float > * m_cluster_energy
Definition ISF_HitAnalysis.h:160
ISF_HitAnalysis::m_newTTC_back_eta
std::vector< std::vector< float > > * m_newTTC_back_eta
Definition ISF_HitAnalysis.h:209
ISF_HitAnalysis::m_newTTC_mid_z
std::vector< std::vector< float > > * m_newTTC_mid_z
Definition ISF_HitAnalysis.h:218
ISF_HitAnalysis::m_hit_z
std::vector< float > * m_hit_z
Definition ISF_HitAnalysis.h:139
ISF_HitAnalysis::m_newTTC_AngleEta
std::vector< float > * m_newTTC_AngleEta
Definition ISF_HitAnalysis.h:226
ISF_HitAnalysis::m_truth_px
std::vector< float > * m_truth_px
Definition ISF_HitAnalysis.h:153
ISF_HitAnalysis::m_hit_x
std::vector< float > * m_hit_x
Simple variables by Ketevi.
Definition ISF_HitAnalysis.h:137
ISF_HitAnalysis::m_newTTC_back_OK
std::vector< std::vector< bool > > * m_newTTC_back_OK
Definition ISF_HitAnalysis.h:214
ISF_HitAnalysis::m_tileHWID
const TileHWID * m_tileHWID
Definition ISF_HitAnalysis.h:131
ISF_HitAnalysis::m_hit_time
std::vector< float > * m_hit_time
Definition ISF_HitAnalysis.h:141
ISF_HitAnalysis::m_doG4Hits
BooleanProperty m_doG4Hits
Definition ISF_HitAnalysis.h:122
ISF_HitAnalysis::m_cluster_phi
std::vector< float > * m_cluster_phi
Definition ISF_HitAnalysis.h:162
ISF_HitAnalysis::m_newTTC_mid_OK
std::vector< std::vector< bool > > * m_newTTC_mid_OK
Definition ISF_HitAnalysis.h:220
ISF_HitAnalysis::m_g4hit_time
std::vector< float > * m_g4hit_time
Definition ISF_HitAnalysis.h:172
ISF_HitAnalysis::m_truth_energy
std::vector< float > * m_truth_energy
Definition ISF_HitAnalysis.h:152
ISF_HitAnalysis::m_hit_samplingfraction
std::vector< float > * m_hit_samplingfraction
Definition ISF_HitAnalysis.h:150
ISF_HitAnalysis::m_cell_identifier
std::vector< Long64_t > * m_cell_identifier
Definition ISF_HitAnalysis.h:167
ISF_HitAnalysis::m_islarbarrel
std::vector< bool > * m_islarbarrel
Definition ISF_HitAnalysis.h:144
ISF_HitAnalysis::m_truth_vtxbarcode
std::vector< int > * m_truth_vtxbarcode
Definition ISF_HitAnalysis.h:158
ISF_HitAnalysis::m_newTTC_Angle3D
std::vector< float > * m_newTTC_Angle3D
Definition ISF_HitAnalysis.h:225
ISF_HitAnalysis::m_tileID
const TileID * m_tileID
Definition ISF_HitAnalysis.h:130
ISF_HitAnalysis::m_hit_identifier
std::vector< Long64_t > * m_hit_identifier
Definition ISF_HitAnalysis.h:142
ISF_HitAnalysis::m_MuonEntryLayer_E
std::vector< float > * m_MuonEntryLayer_E
Definition ISF_HitAnalysis.h:228
ISF_HitAnalysis::m_newTTC_entrance_r
std::vector< std::vector< float > > * m_newTTC_entrance_r
Definition ISF_HitAnalysis.h:205
ISF_HitAnalysis::m_hit_energy
std::vector< float > * m_hit_energy
Definition ISF_HitAnalysis.h:140
ISF_HitAnalysis::m_total_cell_e
Float_t m_total_cell_e
Definition ISF_HitAnalysis.h:182
ISF_HitAnalysis::m_CaloBoundaryR
DoubleProperty m_CaloBoundaryR
Definition ISF_HitAnalysis.h:114
ISF_HitAnalysis::m_MuonEntryLayer_pdg
std::vector< int > * m_MuonEntryLayer_pdg
Definition ISF_HitAnalysis.h:235
ISF_HitAnalysis::m_tileMgr
const TileDetDescrManager * m_tileMgr
Definition ISF_HitAnalysis.h:134
ISF_HitAnalysis::m_total_hit_e
Float_t m_total_hit_e
Definition ISF_HitAnalysis.h:183
ISF_HitAnalysis::m_CaloBoundaryZ
DoubleProperty m_CaloBoundaryZ
Definition ISF_HitAnalysis.h:115
ISF_HitAnalysis::m_tree
TTree * m_tree
Definition ISF_HitAnalysis.h:190
ISF_HitAnalysis::m_cluster_size
std::vector< unsigned > * m_cluster_size
Definition ISF_HitAnalysis.h:163
ISF_HitAnalysis::m_MuonEntryLayer_y
std::vector< float > * m_MuonEntryLayer_y
Definition ISF_HitAnalysis.h:233
ISF_HitAnalysis::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition ISF_HitAnalysis.h:86
ISF_HitAnalysis::m_islarendcap
std::vector< bool > * m_islarendcap
Definition ISF_HitAnalysis.h:145
ISF_HitAnalysis::m_newTTC_mid_phi
std::vector< std::vector< float > > * m_newTTC_mid_phi
Definition ISF_HitAnalysis.h:216
ISF_HitAnalysis::m_cell_sampling
std::vector< int > * m_cell_sampling
Definition ISF_HitAnalysis.h:169
ISF_HitAnalysis::m_hit_cellidentifier
std::vector< Long64_t > * m_hit_cellidentifier
Definition ISF_HitAnalysis.h:143
ISF_HitAnalysis::m_g4hit_samplingfraction
std::vector< float > * m_g4hit_samplingfraction
Definition ISF_HitAnalysis.h:175
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_r
std::vector< float > * m_newTTC_IDCaloBoundary_r
Definition ISF_HitAnalysis.h:223
ISF_HitAnalysis::m_cell_energy
std::vector< float > * m_cell_energy
Definition ISF_HitAnalysis.h:168
ISF_HitAnalysis::m_layercells
FCS_matchedcellvector * m_layercells[MAX_LAYER]
Definition ISF_HitAnalysis.h:180
ISF_HitAnalysis::m_istile
std::vector< bool > * m_istile
Definition ISF_HitAnalysis.h:148
ISF_HitAnalysis::m_newTTC_entrance_detaBorder
std::vector< std::vector< float > > * m_newTTC_entrance_detaBorder
Definition ISF_HitAnalysis.h:207
ISF_HitAnalysis::MAX_LAYER
static const int MAX_LAYER
Definition ISF_HitAnalysis.h:76
ISF_HitAnalysis::m_newTTC_back_z
std::vector< std::vector< float > > * m_newTTC_back_z
Definition ISF_HitAnalysis.h:212
ISF_HitAnalysis::m_larEmID
const LArEM_ID * m_larEmID
Definition ISF_HitAnalysis.h:127
ISF_HitAnalysis::m_hit_sampling
std::vector< int > * m_hit_sampling
Definition ISF_HitAnalysis.h:149
ISF_HitAnalysis::m_g4hit_energy
std::vector< float > * m_g4hit_energy
Definition ISF_HitAnalysis.h:171
ISF_HitAnalysis::m_final_cell_energy
std::vector< Float_t > * m_final_cell_energy
Definition ISF_HitAnalysis.h:186
ISF_HitAnalysis::m_g4hit_identifier
std::vector< Long64_t > * m_g4hit_identifier
Definition ISF_HitAnalysis.h:173
ISF_HitAnalysis::m_MuonEntryLayer_px
std::vector< float > * m_MuonEntryLayer_px
Definition ISF_HitAnalysis.h:229
ISF_HitAnalysis::m_NtruthParticles
IntegerProperty m_NtruthParticles
Definition ISF_HitAnalysis.h:106
ISF_HitAnalysis::m_islarfcal
std::vector< bool > * m_islarfcal
Definition ISF_HitAnalysis.h:147
ISF_HitAnalysis::m_final_g4hit_energy
std::vector< Float_t > * m_final_g4hit_energy
Definition ISF_HitAnalysis.h:188
ISF_HitAnalysis::m_tileCabling
const TileCablingService * m_tileCabling
Definition ISF_HitAnalysis.h:132
Identifier::get_compact
value_type get_compact() const
Get the compact id.
LArHit::energy
double energy() const
Definition LArHit.h:113
LArHit::cellID
Identifier cellID() const
Definition LArHit.h:108
LArHit::time
double time() const
Definition LArHit.h:118
xAOD::CaloCluster_v1::UNCALIBRATED
@ UNCALIBRATED
Definition CaloCluster_v1.h:309
xAOD::CaloCluster_v1::getCellLinks
const CaloClusterCellLink * getCellLinks() const
Get a pointer to the CaloClusterCellLink object (const version)
Definition CaloCluster_v1.cxx:829
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition CaloCluster_v1.cxx:251
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition CaloCluster_v1.cxx:265
xAOD::CaloCluster_v1::const_cell_iterator
CaloClusterCellLink::const_iterator const_cell_iterator
Iterator of the underlying CaloClusterCellLink (explicitly const version)
Definition CaloCluster_v1.h:796
xAOD::CaloCluster_v1::cell_end
const_cell_iterator cell_end() const
Definition CaloCluster_v1.h:816
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition CaloCluster_v1.cxx:256
xAOD::CaloCluster_v1::cell_begin
const_cell_iterator cell_begin() const
Iterator of the underlying CaloClusterCellLink (const version)
Definition CaloCluster_v1.h:815
CaloCell_ID_FCS::MaxSample
@ MaxSample
Definition FastCaloSim_CaloCell_ID.h:47
CaloCell_ID_FCS::FirstSample
@ FirstSample
Definition FastCaloSim_CaloCell_ID.h:18
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
HepMC::barcode
int barcode(const T *p)
Definition Barcode.h:16
ParticleGun_EoverP_Config.momentum
momentum
Definition ParticleGun_EoverP_Config.py:63
TRTCalib_Extractor.hits
hits
Definition TRTCalib_Extractor.py:35
TRT::Hit::layer
@ layer
Definition HitInfo.h:79
get_generator_info.result
result
Definition get_generator_info.py:21
plotting.yearwise_efficiency.channel
channel
Definition yearwise_efficiency.py:24
python.PyKernel.retrieve
retrieve(aClass, aKey=None)
Definition PyKernel.py:110
test_pyathena.px
px
Definition test_pyathena.py:18
xAOD::CaloCluster
CaloCluster_v1 CaloCluster
Define the latest version of the calorimeter cluster class.
Definition Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloCluster.h:19
xAOD::CaloClusterContainer
CaloClusterContainer_v1 CaloClusterContainer
Define the latest version of the calorimeter cluster container.
Definition Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloClusterContainer.h:17
FCS_cell::energy
float energy
Definition FCS_Cell.h:26
FCS_cell::center_x
float center_x
Definition FCS_Cell.h:27
FCS_cell::sampling
int sampling
Definition FCS_Cell.h:25
FCS_cell::center_y
float center_y
Definition FCS_Cell.h:28
FCS_cell::cell_identifier
Long64_t cell_identifier
Definition FCS_Cell.h:24
FCS_cell::center_z
float center_z
Definition FCS_Cell.h:29
FCS_g4hit::sampling
int sampling
Definition FCS_Cell.h:50
FCS_g4hit::hit_time
float hit_time
Definition FCS_Cell.h:52
FCS_g4hit::cell_identifier
Long64_t cell_identifier
Definition FCS_Cell.h:49
FCS_g4hit::identifier
Long64_t identifier
Definition FCS_Cell.h:48
FCS_g4hit::hit_energy
float hit_energy
Definition FCS_Cell.h:51
FCS_hit::hit_time
float hit_time
Definition FCS_Cell.h:39
FCS_hit::hit_z
float hit_z
Definition FCS_Cell.h:42
FCS_hit::hit_x
float hit_x
Definition FCS_Cell.h:40
FCS_hit::identifier
Long64_t identifier
Definition FCS_Cell.h:35
FCS_hit::hit_y
float hit_y
Definition FCS_Cell.h:41
FCS_hit::hit_energy
float hit_energy
Definition FCS_Cell.h:38
FCS_hit::sampling
int sampling
Definition FCS_Cell.h:37
FCS_hit::cell_identifier
Long64_t cell_identifier
Definition FCS_Cell.h:36
FCS_matchedcell::g4hit
std::vector< FCS_g4hit > g4hit
Definition FCS_Cell.h:59
FCS_matchedcell::hit
std::vector< FCS_hit > hit
Definition FCS_Cell.h:60
FCS_matchedcell::cell
FCS_cell cell
Definition FCS_Cell.h:58
FCS_matchedcell::clear
void clear()
Definition FCS_Cell.h:61

◆ 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}
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition AthAlgorithm.h:79

◆ extrapolate()

void ISF_HitAnalysis::extrapolate ( const HepMC::ConstGenParticlePtr & part,
std::vector< Trk::HitInfo > * hitVector )
private

◆ extrapolate_to_ID()

void ISF_HitAnalysis::extrapolate_to_ID ( const HepMC::ConstGenParticlePtr & part,
std::vector< Trk::HitInfo > * hitVector )
private

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

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

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

◆ 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 }
AthCommonDataStore::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 > renounce(T &h)
Definition AthCommonDataStore.h:380

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

◆ 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, AthHistogramAlgorithm, and PyAthena::Alg.

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}
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition AthAlgorithm.cxx:66
AthCommonDataStore< AthCommonMsg< Algorithm > >::AthCommonDataStore
AthCommonDataStore(const std::string &name, T... args)
Definition AthCommonDataStore.h:55
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override

◆ 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 }
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

Member Data Documentation

◆ m_calo_tb_coord

PublicToolHandle<ICaloCoordinateTool> ISF_HitAnalysis::m_calo_tb_coord {this, "CaloCoordinateTool", "TBCaloCoordinate"}
private

Definition at line 110 of file ISF_HitAnalysis.h.

110{this, "CaloCoordinateTool", "TBCaloCoordinate"};

◆ m_CaloBoundaryR

DoubleProperty ISF_HitAnalysis::m_CaloBoundaryR {this, "CaloBoundaryR", 1148}
private

Definition at line 114 of file ISF_HitAnalysis.h.

114{this, "CaloBoundaryR", 1148};

◆ m_CaloBoundaryZ

DoubleProperty ISF_HitAnalysis::m_CaloBoundaryZ {this, "CaloBoundaryZ", 3550}
private

Definition at line 115 of file ISF_HitAnalysis.h.

115{this, "CaloBoundaryZ", 3550};

◆ m_caloEntrance

CxxUtils::CachedPointer<const Trk::TrackingVolume> ISF_HitAnalysis::m_caloEntrance
private

The new Extrapolator setup.

Definition at line 238 of file ISF_HitAnalysis.h.

◆ m_caloEntranceName

StringProperty ISF_HitAnalysis::m_caloEntranceName {this, "CaloEntrance", ""}
private

Definition at line 111 of file ISF_HitAnalysis.h.

111{this, "CaloEntrance", ""};

◆ m_calomargin

DoubleProperty ISF_HitAnalysis::m_calomargin {this, "CaloMargin", 0.0}
private

Definition at line 116 of file ISF_HitAnalysis.h.

116{this, "CaloMargin", 0.0};

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> ISF_HitAnalysis::m_caloMgrKey
private
Initial value:
{ this
, "CaloDetDescrManager"
, "CaloDetDescrManager"
, "SG Key for CaloDetDescrManager in the Condition Store" }

Definition at line 86 of file ISF_HitAnalysis.h.

86 { this
87 , "CaloDetDescrManager"
88 , "CaloDetDescrManager"
89 , "SG Key for CaloDetDescrManager in the Condition Store" };

◆ m_cell_energy

std::vector<float>* ISF_HitAnalysis::m_cell_energy {}
private

Definition at line 168 of file ISF_HitAnalysis.h.

168{};

◆ m_cell_identifier

std::vector<Long64_t>* ISF_HitAnalysis::m_cell_identifier {}
private

Definition at line 167 of file ISF_HitAnalysis.h.

167{};

◆ m_cell_sampling

std::vector<int>* ISF_HitAnalysis::m_cell_sampling {}
private

Definition at line 169 of file ISF_HitAnalysis.h.

169{};

◆ m_cluster_cellID

std::vector<std::vector<Long64_t > >* ISF_HitAnalysis::m_cluster_cellID {}
private

Definition at line 164 of file ISF_HitAnalysis.h.

164{};

◆ m_cluster_energy

std::vector<float>* ISF_HitAnalysis::m_cluster_energy {}
private

Definition at line 160 of file ISF_HitAnalysis.h.

160{};

◆ m_cluster_eta

std::vector<float>* ISF_HitAnalysis::m_cluster_eta {}
private

Definition at line 161 of file ISF_HitAnalysis.h.

161{};

◆ m_cluster_phi

std::vector<float>* ISF_HitAnalysis::m_cluster_phi {}
private

Definition at line 162 of file ISF_HitAnalysis.h.

162{};

◆ m_cluster_size

std::vector<unsigned>* ISF_HitAnalysis::m_cluster_size {}
private

Definition at line 163 of file ISF_HitAnalysis.h.

163{};

◆ m_d_calo_surf

double ISF_HitAnalysis::m_d_calo_surf {}
private

Definition at line 194 of file ISF_HitAnalysis.h.

194{};

◆ m_dCalo

double ISF_HitAnalysis::m_dCalo[CaloCell_ID_FCS::MaxSample][3] {}
private

Definition at line 251 of file ISF_HitAnalysis.h.

251{};

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

double ISF_HitAnalysis::m_distetaCaloBorder[CaloCell_ID_FCS::MaxSample][3] {}
private

Definition at line 252 of file ISF_HitAnalysis.h.

252{};

◆ m_doAllCells

BooleanProperty ISF_HitAnalysis::m_doAllCells {this, "DoAllCells", false}
private

Definition at line 118 of file ISF_HitAnalysis.h.

118{this, "DoAllCells", false};

◆ m_doClusterInfo

BooleanProperty ISF_HitAnalysis::m_doClusterInfo {this, "DoClusterInfo", false}
private

Definition at line 119 of file ISF_HitAnalysis.h.

119{this, "DoClusterInfo", false};

◆ m_doG4Hits

BooleanProperty ISF_HitAnalysis::m_doG4Hits {this, "DoG4Hits", false}
private

Definition at line 122 of file ISF_HitAnalysis.h.

122{this, "DoG4Hits", false};

◆ m_doLayers

BooleanProperty ISF_HitAnalysis::m_doLayers {this, "DoLayers", false}
private

Definition at line 120 of file ISF_HitAnalysis.h.

120{this, "DoLayers", false};

◆ m_doLayerSums

BooleanProperty ISF_HitAnalysis::m_doLayerSums {this, "DoLayerSums", true}
private

Definition at line 121 of file ISF_HitAnalysis.h.

121{this, "DoLayerSums", true};

◆ m_eta_calo_surf

double ISF_HitAnalysis::m_eta_calo_surf {}
private

Definition at line 192 of file ISF_HitAnalysis.h.

192{};

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

PublicToolHandle<Trk::ITimedExtrapolator> ISF_HitAnalysis::m_extrapolator {this, "Extrapolator", {}}
private

Definition at line 109 of file ISF_HitAnalysis.h.

109{this, "Extrapolator", {}};

◆ m_FastCaloSimCaloExtrapolation

PublicToolHandle<IFastCaloSimCaloExtrapolation> ISF_HitAnalysis::m_FastCaloSimCaloExtrapolation {this, "FastCaloSimCaloExtrapolation", {} }
private

The FastCaloSimCaloExtrapolation tool.

Definition at line 113 of file ISF_HitAnalysis.h.

113{this, "FastCaloSimCaloExtrapolation", {} };

◆ m_final_cell_energy

std::vector<Float_t>* ISF_HitAnalysis::m_final_cell_energy {}
private

Definition at line 186 of file ISF_HitAnalysis.h.

186{};

◆ m_final_g4hit_energy

std::vector<Float_t>* ISF_HitAnalysis::m_final_g4hit_energy {}
private

Definition at line 188 of file ISF_HitAnalysis.h.

188{};

◆ m_final_hit_energy

std::vector<Float_t>* ISF_HitAnalysis::m_final_hit_energy {}
private

Definition at line 187 of file ISF_HitAnalysis.h.

187{};

◆ m_fSamplKey

SG::ReadCondHandleKey<ILArfSampl> ISF_HitAnalysis::m_fSamplKey
private
Initial value:
{this,
"fSamplKey", "LArfSamplSym", "SG Key of LArfSampl object"}

Definition at line 90 of file ISF_HitAnalysis.h.

90 {this,
91 "fSamplKey", "LArfSamplSym", "SG Key of LArfSampl object"};

◆ m_g4hit_cellidentifier

std::vector<Long64_t>* ISF_HitAnalysis::m_g4hit_cellidentifier {}
private

Definition at line 174 of file ISF_HitAnalysis.h.

174{};

◆ m_g4hit_energy

std::vector<float>* ISF_HitAnalysis::m_g4hit_energy {}
private

Definition at line 171 of file ISF_HitAnalysis.h.

171{};

◆ m_g4hit_identifier

std::vector<Long64_t>* ISF_HitAnalysis::m_g4hit_identifier {}
private

Definition at line 173 of file ISF_HitAnalysis.h.

173{};

◆ m_g4hit_sampling

std::vector<int>* ISF_HitAnalysis::m_g4hit_sampling {}
private

Definition at line 176 of file ISF_HitAnalysis.h.

176{};

◆ m_g4hit_samplingfraction

std::vector<float>* ISF_HitAnalysis::m_g4hit_samplingfraction {}
private

Definition at line 175 of file ISF_HitAnalysis.h.

175{};

◆ m_g4hit_time

std::vector<float>* ISF_HitAnalysis::m_g4hit_time {}
private

Definition at line 172 of file ISF_HitAnalysis.h.

172{};

◆ m_geoFileName

StringProperty ISF_HitAnalysis::m_geoFileName {this, "GeoFileName", "ISF_Geometry"}
private

Definition at line 105 of file ISF_HitAnalysis.h.

105{this, "GeoFileName", "ISF_Geometry"};

◆ m_geoModel

ServiceHandle<IGeoModelSvc> ISF_HitAnalysis::m_geoModel
private
Initial value:
{this,
"GeoModelSvc", "GeoModelSvc", "GeoModel service"}

Definition at line 84 of file ISF_HitAnalysis.h.

84 {this,
85 "GeoModelSvc", "GeoModelSvc", "GeoModel service"};

◆ m_hit_cellidentifier

std::vector<Long64_t>* ISF_HitAnalysis::m_hit_cellidentifier {}
private

Definition at line 143 of file ISF_HitAnalysis.h.

143{};

◆ m_hit_energy

std::vector<float>* ISF_HitAnalysis::m_hit_energy {}
private

Definition at line 140 of file ISF_HitAnalysis.h.

140{};

◆ m_hit_identifier

std::vector<Long64_t>* ISF_HitAnalysis::m_hit_identifier {}
private

Definition at line 142 of file ISF_HitAnalysis.h.

142{};

◆ m_hit_sampling

std::vector<int>* ISF_HitAnalysis::m_hit_sampling {}
private

Definition at line 149 of file ISF_HitAnalysis.h.

149{};

◆ m_hit_samplingfraction

std::vector<float>* ISF_HitAnalysis::m_hit_samplingfraction {}
private

Definition at line 150 of file ISF_HitAnalysis.h.

150{};

◆ m_hit_time

std::vector<float>* ISF_HitAnalysis::m_hit_time {}
private

Definition at line 141 of file ISF_HitAnalysis.h.

141{};

◆ m_hit_x

std::vector<float>* ISF_HitAnalysis::m_hit_x {}
private

Simple variables by Ketevi.

Definition at line 137 of file ISF_HitAnalysis.h.

137{};

◆ m_hit_y

std::vector<float>* ISF_HitAnalysis::m_hit_y {}
private

Definition at line 138 of file ISF_HitAnalysis.h.

138{};

◆ m_hit_z

std::vector<float>* ISF_HitAnalysis::m_hit_z {}
private

Definition at line 139 of file ISF_HitAnalysis.h.

139{};

◆ m_islarbarrel

std::vector<bool>* ISF_HitAnalysis::m_islarbarrel {}
private

Definition at line 144 of file ISF_HitAnalysis.h.

144{};

◆ m_islarendcap

std::vector<bool>* ISF_HitAnalysis::m_islarendcap {}
private

Definition at line 145 of file ISF_HitAnalysis.h.

145{};

◆ m_islarfcal

std::vector<bool>* ISF_HitAnalysis::m_islarfcal {}
private

Definition at line 147 of file ISF_HitAnalysis.h.

147{};

◆ m_islarhec

std::vector<bool>* ISF_HitAnalysis::m_islarhec {}
private

Definition at line 146 of file ISF_HitAnalysis.h.

146{};

◆ m_istile

std::vector<bool>* ISF_HitAnalysis::m_istile {}
private

Definition at line 148 of file ISF_HitAnalysis.h.

148{};

◆ m_larEmID

const LArEM_ID* ISF_HitAnalysis::m_larEmID {}
private

Definition at line 127 of file ISF_HitAnalysis.h.

127{};

◆ m_larFcalID

const LArFCAL_ID* ISF_HitAnalysis::m_larFcalID {}
private

Definition at line 128 of file ISF_HitAnalysis.h.

128{};

◆ m_larHecID

const LArHEC_ID* ISF_HitAnalysis::m_larHecID {}
private

Definition at line 129 of file ISF_HitAnalysis.h.

129{};

◆ m_layerCaloOK

bool ISF_HitAnalysis::m_layerCaloOK[CaloCell_ID_FCS::MaxSample][3] {}
private

Definition at line 246 of file ISF_HitAnalysis.h.

246{};

◆ m_layercells

FCS_matchedcellvector* ISF_HitAnalysis::m_layercells[MAX_LAYER] {}
private

Definition at line 180 of file ISF_HitAnalysis.h.

180{}; //these are all matched cells in a given layer in a given event

◆ m_letaCalo

double ISF_HitAnalysis::m_letaCalo[CaloCell_ID_FCS::MaxSample][3] {}
private

Definition at line 247 of file ISF_HitAnalysis.h.

247{};

◆ m_lphiCalo

double ISF_HitAnalysis::m_lphiCalo[CaloCell_ID_FCS::MaxSample][3] {}
private

Definition at line 248 of file ISF_HitAnalysis.h.

248{};

◆ m_lrCalo

double ISF_HitAnalysis::m_lrCalo[CaloCell_ID_FCS::MaxSample][3] {}
private

Definition at line 249 of file ISF_HitAnalysis.h.

249{};

◆ m_lzCalo

double ISF_HitAnalysis::m_lzCalo[CaloCell_ID_FCS::MaxSample][3] {}
private

Definition at line 250 of file ISF_HitAnalysis.h.

250{};

◆ m_MC_DIGI_PARAM

StringProperty ISF_HitAnalysis::m_MC_DIGI_PARAM {this, "MetaDataDigi", "/Digitization/Parameters"}
private

Definition at line 124 of file ISF_HitAnalysis.h.

124{this, "MetaDataDigi", "/Digitization/Parameters"};

◆ m_MC_SIM_PARAM

StringProperty ISF_HitAnalysis::m_MC_SIM_PARAM {this, "MetaDataSim", "/Simulation/Parameters"}
private

Definition at line 125 of file ISF_HitAnalysis.h.

125{this, "MetaDataSim", "/Simulation/Parameters"};

◆ m_metadataTreeName

StringProperty ISF_HitAnalysis::m_metadataTreeName {this, "MetadataTreeName", "MetaData"}
private

Definition at line 104 of file ISF_HitAnalysis.h.

104{this, "MetadataTreeName", "MetaData"};

◆ m_MuonEntryLayer_E

std::vector<float>* ISF_HitAnalysis::m_MuonEntryLayer_E {}
private

Definition at line 228 of file ISF_HitAnalysis.h.

228{};

◆ m_MuonEntryLayer_pdg

std::vector<int>* ISF_HitAnalysis::m_MuonEntryLayer_pdg {}
private

Definition at line 235 of file ISF_HitAnalysis.h.

235{};

◆ m_MuonEntryLayer_px

std::vector<float>* ISF_HitAnalysis::m_MuonEntryLayer_px {}
private

Definition at line 229 of file ISF_HitAnalysis.h.

229{};

◆ m_MuonEntryLayer_py

std::vector<float>* ISF_HitAnalysis::m_MuonEntryLayer_py {}
private

Definition at line 230 of file ISF_HitAnalysis.h.

230{};

◆ m_MuonEntryLayer_pz

std::vector<float>* ISF_HitAnalysis::m_MuonEntryLayer_pz {}
private

Definition at line 231 of file ISF_HitAnalysis.h.

231{};

◆ m_MuonEntryLayer_x

std::vector<float>* ISF_HitAnalysis::m_MuonEntryLayer_x {}
private

Definition at line 232 of file ISF_HitAnalysis.h.

232{};

◆ m_MuonEntryLayer_y

std::vector<float>* ISF_HitAnalysis::m_MuonEntryLayer_y {}
private

Definition at line 233 of file ISF_HitAnalysis.h.

233{};

◆ m_MuonEntryLayer_z

std::vector<float>* ISF_HitAnalysis::m_MuonEntryLayer_z {}
private

Definition at line 234 of file ISF_HitAnalysis.h.

234{};

◆ m_newTTC_Angle3D

std::vector<float>* ISF_HitAnalysis::m_newTTC_Angle3D {}
private

Definition at line 225 of file ISF_HitAnalysis.h.

225{};

◆ m_newTTC_AngleEta

std::vector<float>* ISF_HitAnalysis::m_newTTC_AngleEta {}
private

Definition at line 226 of file ISF_HitAnalysis.h.

226{};

◆ m_newTTC_back_detaBorder

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_back_detaBorder {}
private

Definition at line 213 of file ISF_HitAnalysis.h.

213{};

◆ m_newTTC_back_eta

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_back_eta {}
private

Definition at line 209 of file ISF_HitAnalysis.h.

209{};

◆ m_newTTC_back_OK

std::vector<std::vector<bool> >* ISF_HitAnalysis::m_newTTC_back_OK {}
private

Definition at line 214 of file ISF_HitAnalysis.h.

214{};

◆ m_newTTC_back_phi

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_back_phi {}
private

Definition at line 210 of file ISF_HitAnalysis.h.

210{};

◆ m_newTTC_back_r

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_back_r {}
private

Definition at line 211 of file ISF_HitAnalysis.h.

211{};

◆ m_newTTC_back_z

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_back_z {}
private

Definition at line 212 of file ISF_HitAnalysis.h.

212{};

◆ m_newTTC_entrance_detaBorder

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_entrance_detaBorder {}
private

Definition at line 207 of file ISF_HitAnalysis.h.

207{};

◆ m_newTTC_entrance_eta

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_entrance_eta {}
private

Definition at line 203 of file ISF_HitAnalysis.h.

203{};

◆ m_newTTC_entrance_OK

std::vector<std::vector<bool> >* ISF_HitAnalysis::m_newTTC_entrance_OK {}
private

Definition at line 208 of file ISF_HitAnalysis.h.

208{};

◆ m_newTTC_entrance_phi

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_entrance_phi {}
private

Definition at line 204 of file ISF_HitAnalysis.h.

204{};

◆ m_newTTC_entrance_r

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_entrance_r {}
private

Definition at line 205 of file ISF_HitAnalysis.h.

205{};

◆ m_newTTC_entrance_z

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_entrance_z {}
private

Definition at line 206 of file ISF_HitAnalysis.h.

206{};

◆ m_newTTC_IDCaloBoundary_eta

std::vector<float>* ISF_HitAnalysis::m_newTTC_IDCaloBoundary_eta {}
private

Definition at line 221 of file ISF_HitAnalysis.h.

221{};

◆ m_newTTC_IDCaloBoundary_phi

std::vector<float>* ISF_HitAnalysis::m_newTTC_IDCaloBoundary_phi {}
private

Definition at line 222 of file ISF_HitAnalysis.h.

222{};

◆ m_newTTC_IDCaloBoundary_r

std::vector<float>* ISF_HitAnalysis::m_newTTC_IDCaloBoundary_r {}
private

Definition at line 223 of file ISF_HitAnalysis.h.

223{};

◆ m_newTTC_IDCaloBoundary_z

std::vector<float>* ISF_HitAnalysis::m_newTTC_IDCaloBoundary_z {}
private

Definition at line 224 of file ISF_HitAnalysis.h.

224{};

◆ m_newTTC_mid_detaBorder

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_mid_detaBorder {}
private

Definition at line 219 of file ISF_HitAnalysis.h.

219{};

◆ m_newTTC_mid_eta

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_mid_eta {}
private

Definition at line 215 of file ISF_HitAnalysis.h.

215{};

◆ m_newTTC_mid_OK

std::vector<std::vector<bool> >* ISF_HitAnalysis::m_newTTC_mid_OK {}
private

Definition at line 220 of file ISF_HitAnalysis.h.

220{};

◆ m_newTTC_mid_phi

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_mid_phi {}
private

Definition at line 216 of file ISF_HitAnalysis.h.

216{};

◆ m_newTTC_mid_r

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_mid_r {}
private

Definition at line 217 of file ISF_HitAnalysis.h.

217{};

◆ m_newTTC_mid_z

std::vector<std::vector<float> >* ISF_HitAnalysis::m_newTTC_mid_z {}
private

Definition at line 218 of file ISF_HitAnalysis.h.

218{};

◆ m_NtruthParticles

IntegerProperty ISF_HitAnalysis::m_NtruthParticles {this, "NTruthParticles", 1, "Number of truth particles saved from the truth collection, -1 to save all"}
private

Definition at line 106 of file ISF_HitAnalysis.h.

106{this, "NTruthParticles", 1, "Number of truth particles saved from the truth collection, -1 to save all"};

◆ m_ntupleFileName

StringProperty ISF_HitAnalysis::m_ntupleFileName {this, "NtupleFileName", "ISF_HitAnalysis"}
private

Definition at line 102 of file ISF_HitAnalysis.h.

102{this, "NtupleFileName", "ISF_HitAnalysis"};

◆ m_ntupleTreeName

StringProperty ISF_HitAnalysis::m_ntupleTreeName {this, "NtupleTreeName", "CaloHitAna"}
private

Definition at line 103 of file ISF_HitAnalysis.h.

103{this, "NtupleTreeName", "CaloHitAna"};

◆ m_oneeventcells

FCS_matchedcellvector* ISF_HitAnalysis::m_oneeventcells = nullptr
private

Definition at line 179 of file ISF_HitAnalysis.h.

◆ m_particleDataTable

HepPDT::ParticleDataTable* ISF_HitAnalysis::m_particleDataTable {}
private

Definition at line 257 of file ISF_HitAnalysis.h.

257{};

◆ m_partPropSvc

ServiceHandle<IPartPropSvc> ISF_HitAnalysis::m_partPropSvc {this, "PartPropSvc", "PartPropSvc"}
private

Handle on the particle property service.

Definition at line 255 of file ISF_HitAnalysis.h.

255{this, "PartPropSvc", "PartPropSvc"};

◆ m_pdgid

int ISF_HitAnalysis::m_pdgid {}
private

Definition at line 201 of file ISF_HitAnalysis.h.

201{};

◆ m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis ISF_HitAnalysis::m_pdgToParticleHypothesis
private

Definition at line 240 of file ISF_HitAnalysis.h.

◆ m_phi_calo_surf

double ISF_HitAnalysis::m_phi_calo_surf {}
private

Definition at line 193 of file ISF_HitAnalysis.h.

193{};

◆ m_ptruth_e

double ISF_HitAnalysis::m_ptruth_e {}
private

Definition at line 197 of file ISF_HitAnalysis.h.

197{};

◆ m_ptruth_et

double ISF_HitAnalysis::m_ptruth_et {}
private

Definition at line 198 of file ISF_HitAnalysis.h.

198{};

◆ m_ptruth_eta

double ISF_HitAnalysis::m_ptruth_eta {}
private

Definition at line 195 of file ISF_HitAnalysis.h.

195{};

◆ m_ptruth_p

double ISF_HitAnalysis::m_ptruth_p {}
private

Definition at line 200 of file ISF_HitAnalysis.h.

200{};

◆ m_ptruth_phi

double ISF_HitAnalysis::m_ptruth_phi {}
private

Definition at line 196 of file ISF_HitAnalysis.h.

196{};

◆ m_ptruth_pt

double ISF_HitAnalysis::m_ptruth_pt {}
private

Definition at line 199 of file ISF_HitAnalysis.h.

199{};

◆ m_sample_calo_surf

CaloCell_ID_FCS::CaloSample ISF_HitAnalysis::m_sample_calo_surf {CaloCell_ID_FCS::noSample}
private

End new Extrapolator setup.

Definition at line 243 of file ISF_HitAnalysis.h.

243{CaloCell_ID_FCS::noSample};
CaloCell_ID_FCS::noSample
@ noSample
Definition FastCaloSim_CaloCell_ID.h:48

◆ m_saveAllBranches

BooleanProperty ISF_HitAnalysis::m_saveAllBranches {this,"SaveAllBranches", false}
private

Definition at line 117 of file ISF_HitAnalysis.h.

117{this,"SaveAllBranches", false};

◆ m_surfacelist

std::vector< CaloCell_ID_FCS::CaloSample > ISF_HitAnalysis::m_surfacelist
private

Definition at line 244 of file ISF_HitAnalysis.h.

◆ m_thistSvc

ServiceHandle<ITHistSvc> ISF_HitAnalysis::m_thistSvc
private
Initial value:
{ this,
"THistSvc", "THistSvc", "Tile histogramming service"}

Definition at line 107 of file ISF_HitAnalysis.h.

107 { this,
108 "THistSvc", "THistSvc", "Tile histogramming service"};

◆ m_tileCabling

const TileCablingService* ISF_HitAnalysis::m_tileCabling {}
private

Definition at line 132 of file ISF_HitAnalysis.h.

132{};

◆ m_tileCablingSvc

ServiceHandle<TileCablingSvc> ISF_HitAnalysis::m_tileCablingSvc
private
Initial value:
{ this,
"TileCablingSvc", "TileCablingSvc", "Tile cabling service"}

Name of Tile cabling service.

Definition at line 100 of file ISF_HitAnalysis.h.

100 { this,
101 "TileCablingSvc", "TileCablingSvc", "Tile cabling service"};

◆ m_tileHWID

const TileHWID* ISF_HitAnalysis::m_tileHWID {}
private

Definition at line 131 of file ISF_HitAnalysis.h.

131{};

◆ m_tileID

const TileID* ISF_HitAnalysis::m_tileID {}
private

Definition at line 130 of file ISF_HitAnalysis.h.

130{};

◆ m_tileMgr

const TileDetDescrManager* ISF_HitAnalysis::m_tileMgr {}
private

Definition at line 134 of file ISF_HitAnalysis.h.

134{};

◆ m_tileSamplingFractionKey

SG::ReadCondHandleKey<TileSamplingFraction> ISF_HitAnalysis::m_tileSamplingFractionKey
private
Initial value:
{this,
"TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"}

Name of TileSamplingFraction in condition store.

Definition at line 95 of file ISF_HitAnalysis.h.

95 {this,
96 "TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"};

◆ m_TimingCut

IntegerProperty ISF_HitAnalysis::m_TimingCut {this, "TimingCut", 999999}
private

Definition at line 123 of file ISF_HitAnalysis.h.

123{this, "TimingCut", 999999};

◆ m_total_cell_e

Float_t ISF_HitAnalysis::m_total_cell_e {}
private

Definition at line 182 of file ISF_HitAnalysis.h.

182{};

◆ m_total_g4hit_e

Float_t ISF_HitAnalysis::m_total_g4hit_e {}
private

Definition at line 184 of file ISF_HitAnalysis.h.

184{};

◆ m_total_hit_e

Float_t ISF_HitAnalysis::m_total_hit_e {}
private

Definition at line 183 of file ISF_HitAnalysis.h.

183{};

◆ m_tree

TTree* ISF_HitAnalysis::m_tree {}
private

Definition at line 190 of file ISF_HitAnalysis.h.

190{};

◆ m_truth_barcode

std::vector<int>* ISF_HitAnalysis::m_truth_barcode {}
private

Definition at line 157 of file ISF_HitAnalysis.h.

157{};

◆ m_truth_energy

std::vector<float>* ISF_HitAnalysis::m_truth_energy {}
private

Definition at line 152 of file ISF_HitAnalysis.h.

152{};

◆ m_truth_pdg

std::vector<int>* ISF_HitAnalysis::m_truth_pdg {}
private

Definition at line 156 of file ISF_HitAnalysis.h.

156{};

◆ m_truth_px

std::vector<float>* ISF_HitAnalysis::m_truth_px {}
private

Definition at line 153 of file ISF_HitAnalysis.h.

153{};

◆ m_truth_py

std::vector<float>* ISF_HitAnalysis::m_truth_py {}
private

Definition at line 154 of file ISF_HitAnalysis.h.

154{};

◆ m_truth_pz

std::vector<float>* ISF_HitAnalysis::m_truth_pz {}
private

Definition at line 155 of file ISF_HitAnalysis.h.

155{};

◆ m_truth_vtxbarcode

std::vector<int>* ISF_HitAnalysis::m_truth_vtxbarcode {}
private

Definition at line 158 of file ISF_HitAnalysis.h.

158{}; //production vertex barcode

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ MAX_LAYER

const int ISF_HitAnalysis::MAX_LAYER = 25
static

Definition at line 76 of file ISF_HitAnalysis.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0