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 (const EventContext &ctx) override
 Execute method.
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual bool isClonable () const override
 Specify if the algorithm is clonable.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
virtual bool filterPassed (const EventContext &ctx) const
 Get filter decision:
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 Set filter decision:
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Static Public Attributes

static const int MAX_LAYER = 25

Protected Member Functions

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

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

Detailed Description

Definition at line 63 of file ISF_HitAnalysis.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::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 64 of file ISF_HitAnalysis.cxx.

65: AthAlgorithm(name, pSvcLocator)
66 //Note that m_xxx are pointers to vectors set to 0, not set to empty vector! see note around TBranch
67{
68 m_surfacelist.resize(0);
69 m_surfacelist.push_back(CaloCell_ID_FCS::PreSamplerB);
70 m_surfacelist.push_back(CaloCell_ID_FCS::PreSamplerE);
71 m_surfacelist.push_back(CaloCell_ID_FCS::EME1);
72 m_surfacelist.push_back(CaloCell_ID_FCS::EME2);
73 m_surfacelist.push_back(CaloCell_ID_FCS::FCAL0);
74}
AthAlgorithm::AthAlgorithm
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition AthAlgorithm.cxx:10
ISF_HitAnalysis::m_surfacelist
std::vector< CaloCell_ID_FCS::CaloSample > m_surfacelist
Definition ISF_HitAnalysis.h:242
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 finalize ISF_HitAnalysis::ATLAS_NOT_THREAD_SAFE ( )
overridevirtual

◆ ATLAS_NOT_THREAD_SAFE() [2/2]

virtual StatusCode initialize ISF_HitAnalysis::ATLAS_NOT_THREAD_SAFE ( )
overridevirtual

◆ caloHits()

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

Definition at line 1315 of file ISF_HitAnalysis.cxx.

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

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

Definition at line 156 of file AthCommonDataStore.h.

158 {
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< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
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< Gaudi::Algorithm > >::detStore ( ) const
inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

◆ evtStore()

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

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

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ execute()

StatusCode ISF_HitAnalysis::execute ( const EventContext & ctx)
overridevirtual

Execute method.

Implements AthAlgorithm.

Definition at line 472 of file ISF_HitAnalysis.cxx.

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

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

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
58 return m_extendedExtraObjects;
59 }
60 return BaseAlg::extraOutputDeps();
61}
AthCommonAlgorithm
Common base class for algorithms.
Definition AthCommonAlgorithm.h:38

◆ 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

◆ filterPassed()

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

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

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

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isClonable()

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

Specify if the algorithm is clonable.

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

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

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

◆ isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const
inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

47{ return false; }

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ renounce()

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

Definition at line 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< Gaudi::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 }

◆ setFilterPassed()

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

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
100 execState( ctx ).setFilterPassed( state );
101 }
AthCommonAlgorithm::setFilterPassed
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:
Definition AthCommonAlgorithm.h:99

◆ sysExecute()

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

Execute an algorithm.

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

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

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

◆ sysInitialize()

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

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

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

Definition at line 60 of file AthCommonAlgorithm.cxx.

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

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 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 }

Member Data Documentation

◆ m_calo_tb_coord

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

Definition at line 108 of file ISF_HitAnalysis.h.

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

◆ m_CaloBoundaryR

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

Definition at line 112 of file ISF_HitAnalysis.h.

112{this, "CaloBoundaryR", 1148};

◆ m_CaloBoundaryZ

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

Definition at line 113 of file ISF_HitAnalysis.h.

113{this, "CaloBoundaryZ", 3550};

◆ m_caloEntrance

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

The new Extrapolator setup.

Definition at line 236 of file ISF_HitAnalysis.h.

◆ m_caloEntranceName

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

Definition at line 109 of file ISF_HitAnalysis.h.

109{this, "CaloEntrance", ""};

◆ m_calomargin

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

Definition at line 114 of file ISF_HitAnalysis.h.

114{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 84 of file ISF_HitAnalysis.h.

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

◆ m_cell_energy

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

Definition at line 166 of file ISF_HitAnalysis.h.

166{};

◆ m_cell_identifier

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

Definition at line 165 of file ISF_HitAnalysis.h.

165{};

◆ m_cell_sampling

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

Definition at line 167 of file ISF_HitAnalysis.h.

167{};

◆ m_cluster_cellID

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

Definition at line 162 of file ISF_HitAnalysis.h.

162{};

◆ m_cluster_energy

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

Definition at line 158 of file ISF_HitAnalysis.h.

158{};

◆ m_cluster_eta

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

Definition at line 159 of file ISF_HitAnalysis.h.

159{};

◆ m_cluster_phi

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

Definition at line 160 of file ISF_HitAnalysis.h.

160{};

◆ m_cluster_size

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

Definition at line 161 of file ISF_HitAnalysis.h.

161{};

◆ m_d_calo_surf

double ISF_HitAnalysis::m_d_calo_surf {}
private

Definition at line 192 of file ISF_HitAnalysis.h.

192{};

◆ m_dCalo

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

Definition at line 249 of file ISF_HitAnalysis.h.

249{};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::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 250 of file ISF_HitAnalysis.h.

250{};

◆ m_doAllCells

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

Definition at line 116 of file ISF_HitAnalysis.h.

116{this, "DoAllCells", false};

◆ m_doClusterInfo

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

Definition at line 117 of file ISF_HitAnalysis.h.

117{this, "DoClusterInfo", false};

◆ m_doG4Hits

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

Definition at line 120 of file ISF_HitAnalysis.h.

120{this, "DoG4Hits", false};

◆ m_doLayers

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

Definition at line 118 of file ISF_HitAnalysis.h.

118{this, "DoLayers", false};

◆ m_doLayerSums

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

Definition at line 119 of file ISF_HitAnalysis.h.

119{this, "DoLayerSums", true};

◆ m_eta_calo_surf

double ISF_HitAnalysis::m_eta_calo_surf {}
private

Definition at line 190 of file ISF_HitAnalysis.h.

190{};

◆ m_evtStore

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

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

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

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_extrapolator

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

Definition at line 107 of file ISF_HitAnalysis.h.

107{this, "Extrapolator", {}};

◆ m_FastCaloSimCaloExtrapolation

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

The FastCaloSimCaloExtrapolation tool.

Definition at line 111 of file ISF_HitAnalysis.h.

111{this, "FastCaloSimCaloExtrapolation", {} };

◆ m_final_cell_energy

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

Definition at line 184 of file ISF_HitAnalysis.h.

184{};

◆ m_final_g4hit_energy

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

Definition at line 186 of file ISF_HitAnalysis.h.

186{};

◆ m_final_hit_energy

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

Definition at line 185 of file ISF_HitAnalysis.h.

185{};

◆ m_fSamplKey

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

Definition at line 88 of file ISF_HitAnalysis.h.

88 {this,
89 "fSamplKey", "LArfSamplSym", "SG Key of LArfSampl object"};

◆ m_g4hit_cellidentifier

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

Definition at line 172 of file ISF_HitAnalysis.h.

172{};

◆ m_g4hit_energy

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

Definition at line 169 of file ISF_HitAnalysis.h.

169{};

◆ m_g4hit_identifier

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

Definition at line 171 of file ISF_HitAnalysis.h.

171{};

◆ m_g4hit_sampling

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

Definition at line 174 of file ISF_HitAnalysis.h.

174{};

◆ m_g4hit_samplingfraction

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

Definition at line 173 of file ISF_HitAnalysis.h.

173{};

◆ m_g4hit_time

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

Definition at line 170 of file ISF_HitAnalysis.h.

170{};

◆ m_geoFileName

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

Definition at line 103 of file ISF_HitAnalysis.h.

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

◆ m_geoModel

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

Definition at line 82 of file ISF_HitAnalysis.h.

82 {this,
83 "GeoModelSvc", "GeoModelSvc", "GeoModel service"};

◆ m_hit_cellidentifier

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

Definition at line 141 of file ISF_HitAnalysis.h.

141{};

◆ m_hit_energy

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

Definition at line 138 of file ISF_HitAnalysis.h.

138{};

◆ m_hit_identifier

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

Definition at line 140 of file ISF_HitAnalysis.h.

140{};

◆ m_hit_sampling

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

Definition at line 147 of file ISF_HitAnalysis.h.

147{};

◆ m_hit_samplingfraction

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

Definition at line 148 of file ISF_HitAnalysis.h.

148{};

◆ m_hit_time

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

Definition at line 139 of file ISF_HitAnalysis.h.

139{};

◆ m_hit_x

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

Simple variables by Ketevi.

Definition at line 135 of file ISF_HitAnalysis.h.

135{};

◆ m_hit_y

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

Definition at line 136 of file ISF_HitAnalysis.h.

136{};

◆ m_hit_z

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

Definition at line 137 of file ISF_HitAnalysis.h.

137{};

◆ m_islarbarrel

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

Definition at line 142 of file ISF_HitAnalysis.h.

142{};

◆ m_islarendcap

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

Definition at line 143 of file ISF_HitAnalysis.h.

143{};

◆ m_islarfcal

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

Definition at line 145 of file ISF_HitAnalysis.h.

145{};

◆ m_islarhec

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

Definition at line 144 of file ISF_HitAnalysis.h.

144{};

◆ m_istile

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

Definition at line 146 of file ISF_HitAnalysis.h.

146{};

◆ m_larEmID

const LArEM_ID* ISF_HitAnalysis::m_larEmID {}
private

Definition at line 125 of file ISF_HitAnalysis.h.

125{};

◆ m_larFcalID

const LArFCAL_ID* ISF_HitAnalysis::m_larFcalID {}
private

Definition at line 126 of file ISF_HitAnalysis.h.

126{};

◆ m_larHecID

const LArHEC_ID* ISF_HitAnalysis::m_larHecID {}
private

Definition at line 127 of file ISF_HitAnalysis.h.

127{};

◆ m_layerCaloOK

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

Definition at line 244 of file ISF_HitAnalysis.h.

244{};

◆ m_layercells

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

Definition at line 178 of file ISF_HitAnalysis.h.

178{}; //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 245 of file ISF_HitAnalysis.h.

245{};

◆ m_lphiCalo

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

Definition at line 246 of file ISF_HitAnalysis.h.

246{};

◆ m_lrCalo

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

Definition at line 247 of file ISF_HitAnalysis.h.

247{};

◆ m_lzCalo

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

Definition at line 248 of file ISF_HitAnalysis.h.

248{};

◆ m_MC_DIGI_PARAM

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

Definition at line 122 of file ISF_HitAnalysis.h.

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

◆ m_MC_SIM_PARAM

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

Definition at line 123 of file ISF_HitAnalysis.h.

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

◆ m_metadataTreeName

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

Definition at line 102 of file ISF_HitAnalysis.h.

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

◆ m_MuonEntryLayer_E

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

Definition at line 226 of file ISF_HitAnalysis.h.

226{};

◆ m_MuonEntryLayer_pdg

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

Definition at line 233 of file ISF_HitAnalysis.h.

233{};

◆ m_MuonEntryLayer_px

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

Definition at line 227 of file ISF_HitAnalysis.h.

227{};

◆ m_MuonEntryLayer_py

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

Definition at line 228 of file ISF_HitAnalysis.h.

228{};

◆ m_MuonEntryLayer_pz

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

Definition at line 229 of file ISF_HitAnalysis.h.

229{};

◆ m_MuonEntryLayer_x

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

Definition at line 230 of file ISF_HitAnalysis.h.

230{};

◆ m_MuonEntryLayer_y

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

Definition at line 231 of file ISF_HitAnalysis.h.

231{};

◆ m_MuonEntryLayer_z

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

Definition at line 232 of file ISF_HitAnalysis.h.

232{};

◆ m_newTTC_Angle3D

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

Definition at line 223 of file ISF_HitAnalysis.h.

223{};

◆ m_newTTC_AngleEta

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

Definition at line 224 of file ISF_HitAnalysis.h.

224{};

◆ m_newTTC_back_detaBorder

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

Definition at line 211 of file ISF_HitAnalysis.h.

211{};

◆ m_newTTC_back_eta

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

Definition at line 207 of file ISF_HitAnalysis.h.

207{};

◆ m_newTTC_back_OK

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

Definition at line 212 of file ISF_HitAnalysis.h.

212{};

◆ m_newTTC_back_phi

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

Definition at line 208 of file ISF_HitAnalysis.h.

208{};

◆ m_newTTC_back_r

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

Definition at line 209 of file ISF_HitAnalysis.h.

209{};

◆ m_newTTC_back_z

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

Definition at line 210 of file ISF_HitAnalysis.h.

210{};

◆ m_newTTC_entrance_detaBorder

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

Definition at line 205 of file ISF_HitAnalysis.h.

205{};

◆ m_newTTC_entrance_eta

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

Definition at line 201 of file ISF_HitAnalysis.h.

201{};

◆ m_newTTC_entrance_OK

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

Definition at line 206 of file ISF_HitAnalysis.h.

206{};

◆ m_newTTC_entrance_phi

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

Definition at line 202 of file ISF_HitAnalysis.h.

202{};

◆ m_newTTC_entrance_r

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

Definition at line 203 of file ISF_HitAnalysis.h.

203{};

◆ m_newTTC_entrance_z

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

Definition at line 204 of file ISF_HitAnalysis.h.

204{};

◆ m_newTTC_IDCaloBoundary_eta

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

Definition at line 219 of file ISF_HitAnalysis.h.

219{};

◆ m_newTTC_IDCaloBoundary_phi

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

Definition at line 220 of file ISF_HitAnalysis.h.

220{};

◆ m_newTTC_IDCaloBoundary_r

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

Definition at line 221 of file ISF_HitAnalysis.h.

221{};

◆ m_newTTC_IDCaloBoundary_z

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

Definition at line 222 of file ISF_HitAnalysis.h.

222{};

◆ m_newTTC_mid_detaBorder

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

Definition at line 217 of file ISF_HitAnalysis.h.

217{};

◆ m_newTTC_mid_eta

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

Definition at line 213 of file ISF_HitAnalysis.h.

213{};

◆ m_newTTC_mid_OK

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

Definition at line 218 of file ISF_HitAnalysis.h.

218{};

◆ m_newTTC_mid_phi

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

Definition at line 214 of file ISF_HitAnalysis.h.

214{};

◆ m_newTTC_mid_r

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

Definition at line 215 of file ISF_HitAnalysis.h.

215{};

◆ m_newTTC_mid_z

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

Definition at line 216 of file ISF_HitAnalysis.h.

216{};

◆ 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 104 of file ISF_HitAnalysis.h.

104{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 100 of file ISF_HitAnalysis.h.

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

◆ m_ntupleTreeName

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

Definition at line 101 of file ISF_HitAnalysis.h.

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

◆ m_oneeventcells

FCS_matchedcellvector* ISF_HitAnalysis::m_oneeventcells = nullptr
private

Definition at line 177 of file ISF_HitAnalysis.h.

◆ m_pdgid

int ISF_HitAnalysis::m_pdgid {}
private

Definition at line 199 of file ISF_HitAnalysis.h.

199{};

◆ m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis ISF_HitAnalysis::m_pdgToParticleHypothesis
private

Definition at line 238 of file ISF_HitAnalysis.h.

◆ m_phi_calo_surf

double ISF_HitAnalysis::m_phi_calo_surf {}
private

Definition at line 191 of file ISF_HitAnalysis.h.

191{};

◆ m_ptruth_e

double ISF_HitAnalysis::m_ptruth_e {}
private

Definition at line 195 of file ISF_HitAnalysis.h.

195{};

◆ m_ptruth_et

double ISF_HitAnalysis::m_ptruth_et {}
private

Definition at line 196 of file ISF_HitAnalysis.h.

196{};

◆ m_ptruth_eta

double ISF_HitAnalysis::m_ptruth_eta {}
private

Definition at line 193 of file ISF_HitAnalysis.h.

193{};

◆ m_ptruth_p

double ISF_HitAnalysis::m_ptruth_p {}
private

Definition at line 198 of file ISF_HitAnalysis.h.

198{};

◆ m_ptruth_phi

double ISF_HitAnalysis::m_ptruth_phi {}
private

Definition at line 194 of file ISF_HitAnalysis.h.

194{};

◆ m_ptruth_pt

double ISF_HitAnalysis::m_ptruth_pt {}
private

Definition at line 197 of file ISF_HitAnalysis.h.

197{};

◆ 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 241 of file ISF_HitAnalysis.h.

241{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 115 of file ISF_HitAnalysis.h.

115{this,"SaveAllBranches", false};

◆ m_surfacelist

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

Definition at line 242 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 105 of file ISF_HitAnalysis.h.

105 { this,
106 "THistSvc", "THistSvc", "Tile histogramming service"};

◆ m_tileCabling

const TileCablingService* ISF_HitAnalysis::m_tileCabling {}
private

Definition at line 130 of file ISF_HitAnalysis.h.

130{};

◆ 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 98 of file ISF_HitAnalysis.h.

98 { this,
99 "TileCablingSvc", "TileCablingSvc", "Tile cabling service"};

◆ m_tileHWID

const TileHWID* ISF_HitAnalysis::m_tileHWID {}
private

Definition at line 129 of file ISF_HitAnalysis.h.

129{};

◆ m_tileID

const TileID* ISF_HitAnalysis::m_tileID {}
private

Definition at line 128 of file ISF_HitAnalysis.h.

128{};

◆ m_tileMgr

const TileDetDescrManager* ISF_HitAnalysis::m_tileMgr {}
private

Definition at line 132 of file ISF_HitAnalysis.h.

132{};

◆ 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 93 of file ISF_HitAnalysis.h.

93 {this,
94 "TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"};

◆ m_TimingCut

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

Definition at line 121 of file ISF_HitAnalysis.h.

121{this, "TimingCut", 999999};

◆ m_total_cell_e

Float_t ISF_HitAnalysis::m_total_cell_e {}
private

Definition at line 180 of file ISF_HitAnalysis.h.

180{};

◆ m_total_g4hit_e

Float_t ISF_HitAnalysis::m_total_g4hit_e {}
private

Definition at line 182 of file ISF_HitAnalysis.h.

182{};

◆ m_total_hit_e

Float_t ISF_HitAnalysis::m_total_hit_e {}
private

Definition at line 181 of file ISF_HitAnalysis.h.

181{};

◆ m_tree

TTree* ISF_HitAnalysis::m_tree {}
private

Definition at line 188 of file ISF_HitAnalysis.h.

188{};

◆ m_truth_barcode

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

Definition at line 155 of file ISF_HitAnalysis.h.

155{};

◆ m_truth_energy

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

Definition at line 150 of file ISF_HitAnalysis.h.

150{};

◆ m_truth_pdg

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

Definition at line 154 of file ISF_HitAnalysis.h.

154{};

◆ m_truth_px

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

Definition at line 151 of file ISF_HitAnalysis.h.

151{};

◆ m_truth_py

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

Definition at line 152 of file ISF_HitAnalysis.h.

152{};

◆ m_truth_pz

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

Definition at line 153 of file ISF_HitAnalysis.h.

153{};

◆ m_truth_vtxbarcode

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

Definition at line 156 of file ISF_HitAnalysis.h.

156{}; //production vertex barcode

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::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 74 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.16.1