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 const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
bool filterPassed (const EventContext &ctx) const
void setFilterPassed (bool state, const EventContext &ctx) const
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
const EventContext & getContext () const
 Deprecated methods (use the ones with EventContext).
bool filterPassed () const
void setFilterPassed (bool state) 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] {}
ServiceHandle< IPartPropSvc > m_partPropSvc {this, "PartPropSvc", "PartPropSvc"}
 Handle on the particle property service.
HepPDT::ParticleDataTable * m_particleDataTable {}
DataObjIDColl m_extendedExtraObjects
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 64 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 65 of file ISF_HitAnalysis.cxx.

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

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

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< 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.

Provides access to the EventContext if needed but is non-const as opposed to AthReentrantAlgorithm.

Implements AthAlgorithm.

Definition at line 481 of file ISF_HitAnalysis.cxx.

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

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

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

◆ 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() [1/2]

bool AthAlgorithm::filterPassed ( ) const
inherited

Definition at line 94 of file AthAlgorithm.cxx.

94 {
95 return filterPassed( Gaudi::Hive::currentContext() );
96}
AthAlgorithm::filterPassed
bool filterPassed() const
Definition AthAlgorithm.cxx:94

◆ filterPassed() [2/2]

bool AthAlgorithm::filterPassed ( const EventContext & ctx) const
inherited

Definition at line 98 of file AthAlgorithm.cxx.

98 {
99 return execState( ctx ).filterPassed();
100}

◆ getContext()

const EventContext & AthAlgorithm::getContext ( ) const
inherited

Deprecated methods (use the ones with EventContext).

Definition at line 90 of file AthAlgorithm.cxx.

90 {
91 return Gaudi::Hive::currentContext();
92}

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

◆ isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const
inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 111 of file AthAlgorithm.h.

111{ 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() [1/2]

void AthAlgorithm::setFilterPassed ( bool state) const
inherited

Definition at line 102 of file AthAlgorithm.cxx.

102 {
103 setFilterPassed( state, Gaudi::Hive::currentContext() );
104}
AthAlgorithm::setFilterPassed
void setFilterPassed(bool state) const
Definition AthAlgorithm.cxx:102

◆ setFilterPassed() [2/2]

void AthAlgorithm::setFilterPassed ( bool state,
const EventContext & ctx ) const
inherited

Definition at line 106 of file AthAlgorithm.cxx.

106 {
107 execState( ctx ).setFilterPassed(state);
108}

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

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

Definition at line 66 of file AthAlgorithm.cxx.

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

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

◆ m_CaloBoundaryR

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

Definition at line 113 of file ISF_HitAnalysis.h.

113{this, "CaloBoundaryR", 1148};

◆ m_CaloBoundaryZ

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

Definition at line 114 of file ISF_HitAnalysis.h.

114{this, "CaloBoundaryZ", 3550};

◆ m_caloEntrance

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

The new Extrapolator setup.

Definition at line 237 of file ISF_HitAnalysis.h.

◆ m_caloEntranceName

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

Definition at line 110 of file ISF_HitAnalysis.h.

110{this, "CaloEntrance", ""};

◆ m_calomargin

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

Definition at line 115 of file ISF_HitAnalysis.h.

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

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

◆ m_cell_energy

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

Definition at line 167 of file ISF_HitAnalysis.h.

167{};

◆ m_cell_identifier

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

Definition at line 166 of file ISF_HitAnalysis.h.

166{};

◆ m_cell_sampling

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

Definition at line 168 of file ISF_HitAnalysis.h.

168{};

◆ m_cluster_cellID

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

Definition at line 163 of file ISF_HitAnalysis.h.

163{};

◆ m_cluster_energy

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

Definition at line 159 of file ISF_HitAnalysis.h.

159{};

◆ m_cluster_eta

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

Definition at line 160 of file ISF_HitAnalysis.h.

160{};

◆ m_cluster_phi

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

Definition at line 161 of file ISF_HitAnalysis.h.

161{};

◆ m_cluster_size

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

Definition at line 162 of file ISF_HitAnalysis.h.

162{};

◆ m_d_calo_surf

double ISF_HitAnalysis::m_d_calo_surf {}
private

Definition at line 193 of file ISF_HitAnalysis.h.

193{};

◆ m_dCalo

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

Definition at line 250 of file ISF_HitAnalysis.h.

250{};

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

251{};

◆ m_doAllCells

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

Definition at line 117 of file ISF_HitAnalysis.h.

117{this, "DoAllCells", false};

◆ m_doClusterInfo

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

Definition at line 118 of file ISF_HitAnalysis.h.

118{this, "DoClusterInfo", false};

◆ m_doG4Hits

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

Definition at line 121 of file ISF_HitAnalysis.h.

121{this, "DoG4Hits", false};

◆ m_doLayers

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

Definition at line 119 of file ISF_HitAnalysis.h.

119{this, "DoLayers", false};

◆ m_doLayerSums

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

Definition at line 120 of file ISF_HitAnalysis.h.

120{this, "DoLayerSums", true};

◆ m_eta_calo_surf

double ISF_HitAnalysis::m_eta_calo_surf {}
private

Definition at line 191 of file ISF_HitAnalysis.h.

191{};

◆ 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 AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 114 of file AthAlgorithm.h.

◆ m_extrapolator

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

Definition at line 108 of file ISF_HitAnalysis.h.

108{this, "Extrapolator", {}};

◆ m_FastCaloSimCaloExtrapolation

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

The FastCaloSimCaloExtrapolation tool.

Definition at line 112 of file ISF_HitAnalysis.h.

112{this, "FastCaloSimCaloExtrapolation", {} };

◆ m_final_cell_energy

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

Definition at line 185 of file ISF_HitAnalysis.h.

185{};

◆ m_final_g4hit_energy

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

Definition at line 187 of file ISF_HitAnalysis.h.

187{};

◆ m_final_hit_energy

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

Definition at line 186 of file ISF_HitAnalysis.h.

186{};

◆ m_fSamplKey

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

Definition at line 89 of file ISF_HitAnalysis.h.

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

◆ m_g4hit_cellidentifier

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

Definition at line 173 of file ISF_HitAnalysis.h.

173{};

◆ m_g4hit_energy

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

Definition at line 170 of file ISF_HitAnalysis.h.

170{};

◆ m_g4hit_identifier

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

Definition at line 172 of file ISF_HitAnalysis.h.

172{};

◆ m_g4hit_sampling

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

Definition at line 175 of file ISF_HitAnalysis.h.

175{};

◆ m_g4hit_samplingfraction

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

Definition at line 174 of file ISF_HitAnalysis.h.

174{};

◆ m_g4hit_time

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

Definition at line 171 of file ISF_HitAnalysis.h.

171{};

◆ m_geoFileName

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

Definition at line 104 of file ISF_HitAnalysis.h.

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

◆ m_geoModel

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

Definition at line 83 of file ISF_HitAnalysis.h.

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

◆ m_hit_cellidentifier

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

Definition at line 142 of file ISF_HitAnalysis.h.

142{};

◆ m_hit_energy

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

Definition at line 139 of file ISF_HitAnalysis.h.

139{};

◆ m_hit_identifier

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

Definition at line 141 of file ISF_HitAnalysis.h.

141{};

◆ m_hit_sampling

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

Definition at line 148 of file ISF_HitAnalysis.h.

148{};

◆ m_hit_samplingfraction

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

Definition at line 149 of file ISF_HitAnalysis.h.

149{};

◆ m_hit_time

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

Definition at line 140 of file ISF_HitAnalysis.h.

140{};

◆ m_hit_x

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

Simple variables by Ketevi.

Definition at line 136 of file ISF_HitAnalysis.h.

136{};

◆ m_hit_y

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

Definition at line 137 of file ISF_HitAnalysis.h.

137{};

◆ m_hit_z

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

Definition at line 138 of file ISF_HitAnalysis.h.

138{};

◆ m_islarbarrel

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

Definition at line 143 of file ISF_HitAnalysis.h.

143{};

◆ m_islarendcap

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

Definition at line 144 of file ISF_HitAnalysis.h.

144{};

◆ m_islarfcal

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

Definition at line 146 of file ISF_HitAnalysis.h.

146{};

◆ m_islarhec

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

Definition at line 145 of file ISF_HitAnalysis.h.

145{};

◆ m_istile

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

Definition at line 147 of file ISF_HitAnalysis.h.

147{};

◆ m_larEmID

const LArEM_ID* ISF_HitAnalysis::m_larEmID {}
private

Definition at line 126 of file ISF_HitAnalysis.h.

126{};

◆ m_larFcalID

const LArFCAL_ID* ISF_HitAnalysis::m_larFcalID {}
private

Definition at line 127 of file ISF_HitAnalysis.h.

127{};

◆ m_larHecID

const LArHEC_ID* ISF_HitAnalysis::m_larHecID {}
private

Definition at line 128 of file ISF_HitAnalysis.h.

128{};

◆ m_layerCaloOK

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

Definition at line 245 of file ISF_HitAnalysis.h.

245{};

◆ m_layercells

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

Definition at line 179 of file ISF_HitAnalysis.h.

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

246{};

◆ m_lphiCalo

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

Definition at line 247 of file ISF_HitAnalysis.h.

247{};

◆ m_lrCalo

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

Definition at line 248 of file ISF_HitAnalysis.h.

248{};

◆ m_lzCalo

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

Definition at line 249 of file ISF_HitAnalysis.h.

249{};

◆ m_MC_DIGI_PARAM

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

Definition at line 123 of file ISF_HitAnalysis.h.

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

◆ m_MC_SIM_PARAM

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

Definition at line 124 of file ISF_HitAnalysis.h.

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

◆ m_metadataTreeName

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

Definition at line 103 of file ISF_HitAnalysis.h.

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

◆ m_MuonEntryLayer_E

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

Definition at line 227 of file ISF_HitAnalysis.h.

227{};

◆ m_MuonEntryLayer_pdg

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

Definition at line 234 of file ISF_HitAnalysis.h.

234{};

◆ m_MuonEntryLayer_px

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

Definition at line 228 of file ISF_HitAnalysis.h.

228{};

◆ m_MuonEntryLayer_py

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

Definition at line 229 of file ISF_HitAnalysis.h.

229{};

◆ m_MuonEntryLayer_pz

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

Definition at line 230 of file ISF_HitAnalysis.h.

230{};

◆ m_MuonEntryLayer_x

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

Definition at line 231 of file ISF_HitAnalysis.h.

231{};

◆ m_MuonEntryLayer_y

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

Definition at line 232 of file ISF_HitAnalysis.h.

232{};

◆ m_MuonEntryLayer_z

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

Definition at line 233 of file ISF_HitAnalysis.h.

233{};

◆ m_newTTC_Angle3D

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

Definition at line 224 of file ISF_HitAnalysis.h.

224{};

◆ m_newTTC_AngleEta

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

Definition at line 225 of file ISF_HitAnalysis.h.

225{};

◆ m_newTTC_back_detaBorder

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

Definition at line 212 of file ISF_HitAnalysis.h.

212{};

◆ m_newTTC_back_eta

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

Definition at line 208 of file ISF_HitAnalysis.h.

208{};

◆ m_newTTC_back_OK

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

Definition at line 213 of file ISF_HitAnalysis.h.

213{};

◆ m_newTTC_back_phi

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

Definition at line 209 of file ISF_HitAnalysis.h.

209{};

◆ m_newTTC_back_r

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

Definition at line 210 of file ISF_HitAnalysis.h.

210{};

◆ m_newTTC_back_z

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

Definition at line 211 of file ISF_HitAnalysis.h.

211{};

◆ m_newTTC_entrance_detaBorder

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

Definition at line 206 of file ISF_HitAnalysis.h.

206{};

◆ m_newTTC_entrance_eta

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

Definition at line 202 of file ISF_HitAnalysis.h.

202{};

◆ m_newTTC_entrance_OK

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

Definition at line 207 of file ISF_HitAnalysis.h.

207{};

◆ m_newTTC_entrance_phi

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

Definition at line 203 of file ISF_HitAnalysis.h.

203{};

◆ m_newTTC_entrance_r

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

Definition at line 204 of file ISF_HitAnalysis.h.

204{};

◆ m_newTTC_entrance_z

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

Definition at line 205 of file ISF_HitAnalysis.h.

205{};

◆ m_newTTC_IDCaloBoundary_eta

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

Definition at line 220 of file ISF_HitAnalysis.h.

220{};

◆ m_newTTC_IDCaloBoundary_phi

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

Definition at line 221 of file ISF_HitAnalysis.h.

221{};

◆ m_newTTC_IDCaloBoundary_r

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

Definition at line 222 of file ISF_HitAnalysis.h.

222{};

◆ m_newTTC_IDCaloBoundary_z

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

Definition at line 223 of file ISF_HitAnalysis.h.

223{};

◆ m_newTTC_mid_detaBorder

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

Definition at line 218 of file ISF_HitAnalysis.h.

218{};

◆ m_newTTC_mid_eta

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

Definition at line 214 of file ISF_HitAnalysis.h.

214{};

◆ m_newTTC_mid_OK

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

Definition at line 219 of file ISF_HitAnalysis.h.

219{};

◆ m_newTTC_mid_phi

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

Definition at line 215 of file ISF_HitAnalysis.h.

215{};

◆ m_newTTC_mid_r

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

Definition at line 216 of file ISF_HitAnalysis.h.

216{};

◆ m_newTTC_mid_z

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

Definition at line 217 of file ISF_HitAnalysis.h.

217{};

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

105{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 101 of file ISF_HitAnalysis.h.

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

◆ m_ntupleTreeName

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

Definition at line 102 of file ISF_HitAnalysis.h.

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

◆ m_oneeventcells

FCS_matchedcellvector* ISF_HitAnalysis::m_oneeventcells = nullptr
private

Definition at line 178 of file ISF_HitAnalysis.h.

◆ m_particleDataTable

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

Definition at line 256 of file ISF_HitAnalysis.h.

256{};

◆ m_partPropSvc

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

Handle on the particle property service.

Definition at line 254 of file ISF_HitAnalysis.h.

254{this, "PartPropSvc", "PartPropSvc"};

◆ m_pdgid

int ISF_HitAnalysis::m_pdgid {}
private

Definition at line 200 of file ISF_HitAnalysis.h.

200{};

◆ m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis ISF_HitAnalysis::m_pdgToParticleHypothesis
private

Definition at line 239 of file ISF_HitAnalysis.h.

◆ m_phi_calo_surf

double ISF_HitAnalysis::m_phi_calo_surf {}
private

Definition at line 192 of file ISF_HitAnalysis.h.

192{};

◆ m_ptruth_e

double ISF_HitAnalysis::m_ptruth_e {}
private

Definition at line 196 of file ISF_HitAnalysis.h.

196{};

◆ m_ptruth_et

double ISF_HitAnalysis::m_ptruth_et {}
private

Definition at line 197 of file ISF_HitAnalysis.h.

197{};

◆ m_ptruth_eta

double ISF_HitAnalysis::m_ptruth_eta {}
private

Definition at line 194 of file ISF_HitAnalysis.h.

194{};

◆ m_ptruth_p

double ISF_HitAnalysis::m_ptruth_p {}
private

Definition at line 199 of file ISF_HitAnalysis.h.

199{};

◆ m_ptruth_phi

double ISF_HitAnalysis::m_ptruth_phi {}
private

Definition at line 195 of file ISF_HitAnalysis.h.

195{};

◆ m_ptruth_pt

double ISF_HitAnalysis::m_ptruth_pt {}
private

Definition at line 198 of file ISF_HitAnalysis.h.

198{};

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

242{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 116 of file ISF_HitAnalysis.h.

116{this,"SaveAllBranches", false};

◆ m_surfacelist

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

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

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

◆ m_tileCabling

const TileCablingService* ISF_HitAnalysis::m_tileCabling {}
private

Definition at line 131 of file ISF_HitAnalysis.h.

131{};

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

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

◆ m_tileHWID

const TileHWID* ISF_HitAnalysis::m_tileHWID {}
private

Definition at line 130 of file ISF_HitAnalysis.h.

130{};

◆ m_tileID

const TileID* ISF_HitAnalysis::m_tileID {}
private

Definition at line 129 of file ISF_HitAnalysis.h.

129{};

◆ m_tileMgr

const TileDetDescrManager* ISF_HitAnalysis::m_tileMgr {}
private

Definition at line 133 of file ISF_HitAnalysis.h.

133{};

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

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

◆ m_TimingCut

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

Definition at line 122 of file ISF_HitAnalysis.h.

122{this, "TimingCut", 999999};

◆ m_total_cell_e

Float_t ISF_HitAnalysis::m_total_cell_e {}
private

Definition at line 181 of file ISF_HitAnalysis.h.

181{};

◆ m_total_g4hit_e

Float_t ISF_HitAnalysis::m_total_g4hit_e {}
private

Definition at line 183 of file ISF_HitAnalysis.h.

183{};

◆ m_total_hit_e

Float_t ISF_HitAnalysis::m_total_hit_e {}
private

Definition at line 182 of file ISF_HitAnalysis.h.

182{};

◆ m_tree

TTree* ISF_HitAnalysis::m_tree {}
private

Definition at line 189 of file ISF_HitAnalysis.h.

189{};

◆ m_truth_barcode

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

Definition at line 156 of file ISF_HitAnalysis.h.

156{};

◆ m_truth_energy

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

Definition at line 151 of file ISF_HitAnalysis.h.

151{};

◆ m_truth_pdg

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

Definition at line 155 of file ISF_HitAnalysis.h.

155{};

◆ m_truth_px

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

Definition at line 152 of file ISF_HitAnalysis.h.

152{};

◆ m_truth_py

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

Definition at line 153 of file ISF_HitAnalysis.h.

153{};

◆ m_truth_pz

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

Definition at line 154 of file ISF_HitAnalysis.h.

154{};

◆ m_truth_vtxbarcode

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

Definition at line 157 of file ISF_HitAnalysis.h.

157{}; //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 75 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