ATLAS Offline Software
Loading...
Searching...
No Matches
ISF_HitAnalysis Class Reference

#include <ISF_HitAnalysis.h>

Inheritance diagram for ISF_HitAnalysis:

Public Member Functions

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

Static Public Attributes

static const int MAX_LAYER = 25

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

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

Private Attributes

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

Detailed Description

Definition at line 63 of file ISF_HitAnalysis.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 376 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);
75}
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
std::vector< CaloCell_ID_FCS::CaloSample > m_surfacelist

◆ ~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 1316 of file ISF_HitAnalysis.cxx.

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

◆ 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 {
160 hndl.value(),
161 hndl.documentation());
162
163 }
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)

◆ 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;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

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

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

◆ execute()

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

Execute method.

Implements AthAlgorithm.

Definition at line 473 of file ISF_HitAnalysis.cxx.

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

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

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

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
59 }
61}
Common base class for algorithms.

◆ extrapolate()

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

◆ extrapolate_to_ID()

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

◆ filterPassed()

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

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

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

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isClonable()

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

Specify if the algorithm is clonable.

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

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

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

◆ isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const
inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

47{ return false; }

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ renounce()

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

Definition at line 368 of file AthCommonDataStore.h.

369 {
370 h.renounce();
372 }
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)

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
354 }

◆ setFilterPassed()

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

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
101 }
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:

◆ sysExecute()

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

Execute an algorithm.

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

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

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

◆ sysInitialize()

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

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

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

Definition at line 60 of file AthCommonAlgorithm.cxx.

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

298 {
299 for (auto &a : m_vhka) {
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }

Member Data Documentation

◆ m_calo_tb_coord

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

Definition at line 108 of file ISF_HitAnalysis.h.

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

◆ m_CaloBoundaryR

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

Definition at line 112 of file ISF_HitAnalysis.h.

112{this, "CaloBoundaryR", 1148};

◆ m_CaloBoundaryZ

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

Definition at line 113 of file ISF_HitAnalysis.h.

113{this, "CaloBoundaryZ", 3550};

◆ m_caloEntrance

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

The new Extrapolator setup.

Definition at line 236 of file ISF_HitAnalysis.h.

◆ m_caloEntranceName

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

Definition at line 109 of file ISF_HitAnalysis.h.

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

◆ m_calomargin

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

Definition at line 114 of file ISF_HitAnalysis.h.

114{this, "CaloMargin", 0.0};

◆ m_caloMgrKey

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

Definition at line 84 of file ISF_HitAnalysis.h.

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

◆ m_cell_energy

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

Definition at line 166 of file ISF_HitAnalysis.h.

166{};

◆ m_cell_identifier

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

Definition at line 165 of file ISF_HitAnalysis.h.

165{};

◆ m_cell_sampling

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

Definition at line 167 of file ISF_HitAnalysis.h.

167{};

◆ m_cluster_cellID

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

Definition at line 162 of file ISF_HitAnalysis.h.

162{};

◆ m_cluster_energy

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

Definition at line 158 of file ISF_HitAnalysis.h.

158{};

◆ m_cluster_eta

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

Definition at line 159 of file ISF_HitAnalysis.h.

159{};

◆ m_cluster_phi

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

Definition at line 160 of file ISF_HitAnalysis.h.

160{};

◆ m_cluster_size

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

Definition at line 161 of file ISF_HitAnalysis.h.

161{};

◆ m_d_calo_surf

double ISF_HitAnalysis::m_d_calo_surf {}
private

Definition at line 192 of file ISF_HitAnalysis.h.

192{};

◆ m_dCalo

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

Definition at line 249 of file ISF_HitAnalysis.h.

249{};

◆ m_detStore

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

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

◆ m_distetaCaloBorder

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

Definition at line 250 of file ISF_HitAnalysis.h.

250{};

◆ m_doAllCells

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

Definition at line 116 of file ISF_HitAnalysis.h.

116{this, "DoAllCells", false};

◆ m_doClusterInfo

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

Definition at line 117 of file ISF_HitAnalysis.h.

117{this, "DoClusterInfo", false};

◆ m_doG4Hits

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

Definition at line 120 of file ISF_HitAnalysis.h.

120{this, "DoG4Hits", false};

◆ m_doLayers

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

Definition at line 118 of file ISF_HitAnalysis.h.

118{this, "DoLayers", false};

◆ m_doLayerSums

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

Definition at line 119 of file ISF_HitAnalysis.h.

119{this, "DoLayerSums", true};

◆ m_eta_calo_surf

double ISF_HitAnalysis::m_eta_calo_surf {}
private

Definition at line 190 of file ISF_HitAnalysis.h.

190{};

◆ m_evtStore

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

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

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

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_extrapolator

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

Definition at line 107 of file ISF_HitAnalysis.h.

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

◆ m_FastCaloSimCaloExtrapolation

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

The FastCaloSimCaloExtrapolation tool.

Definition at line 111 of file ISF_HitAnalysis.h.

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

◆ m_final_cell_energy

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

Definition at line 184 of file ISF_HitAnalysis.h.

184{};

◆ m_final_g4hit_energy

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

Definition at line 186 of file ISF_HitAnalysis.h.

186{};

◆ m_final_hit_energy

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

Definition at line 185 of file ISF_HitAnalysis.h.

185{};

◆ m_fSamplKey

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

Definition at line 88 of file ISF_HitAnalysis.h.

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

◆ m_g4hit_cellidentifier

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

Definition at line 172 of file ISF_HitAnalysis.h.

172{};

◆ m_g4hit_energy

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

Definition at line 169 of file ISF_HitAnalysis.h.

169{};

◆ m_g4hit_identifier

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

Definition at line 171 of file ISF_HitAnalysis.h.

171{};

◆ m_g4hit_sampling

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

Definition at line 174 of file ISF_HitAnalysis.h.

174{};

◆ m_g4hit_samplingfraction

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

Definition at line 173 of file ISF_HitAnalysis.h.

173{};

◆ m_g4hit_time

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

Definition at line 170 of file ISF_HitAnalysis.h.

170{};

◆ m_geoFileName

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

Definition at line 103 of file ISF_HitAnalysis.h.

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

◆ m_geoModel

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

Definition at line 82 of file ISF_HitAnalysis.h.

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

◆ m_hit_cellidentifier

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

Definition at line 141 of file ISF_HitAnalysis.h.

141{};

◆ m_hit_energy

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

Definition at line 138 of file ISF_HitAnalysis.h.

138{};

◆ m_hit_identifier

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

Definition at line 140 of file ISF_HitAnalysis.h.

140{};

◆ m_hit_sampling

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

Definition at line 147 of file ISF_HitAnalysis.h.

147{};

◆ m_hit_samplingfraction

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

Definition at line 148 of file ISF_HitAnalysis.h.

148{};

◆ m_hit_time

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

Definition at line 139 of file ISF_HitAnalysis.h.

139{};

◆ m_hit_x

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

Simple variables by Ketevi.

Definition at line 135 of file ISF_HitAnalysis.h.

135{};

◆ m_hit_y

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

Definition at line 136 of file ISF_HitAnalysis.h.

136{};

◆ m_hit_z

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

Definition at line 137 of file ISF_HitAnalysis.h.

137{};

◆ m_islarbarrel

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

Definition at line 142 of file ISF_HitAnalysis.h.

142{};

◆ m_islarendcap

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

Definition at line 143 of file ISF_HitAnalysis.h.

143{};

◆ m_islarfcal

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

Definition at line 145 of file ISF_HitAnalysis.h.

145{};

◆ m_islarhec

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

Definition at line 144 of file ISF_HitAnalysis.h.

144{};

◆ m_istile

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

Definition at line 146 of file ISF_HitAnalysis.h.

146{};

◆ m_larEmID

const LArEM_ID* ISF_HitAnalysis::m_larEmID {}
private

Definition at line 125 of file ISF_HitAnalysis.h.

125{};

◆ m_larFcalID

const LArFCAL_ID* ISF_HitAnalysis::m_larFcalID {}
private

Definition at line 126 of file ISF_HitAnalysis.h.

126{};

◆ m_larHecID

const LArHEC_ID* ISF_HitAnalysis::m_larHecID {}
private

Definition at line 127 of file ISF_HitAnalysis.h.

127{};

◆ m_layerCaloOK

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

Definition at line 244 of file ISF_HitAnalysis.h.

244{};

◆ m_layercells

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

Definition at line 178 of file ISF_HitAnalysis.h.

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

◆ m_letaCalo

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

Definition at line 245 of file ISF_HitAnalysis.h.

245{};

◆ m_lphiCalo

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

Definition at line 246 of file ISF_HitAnalysis.h.

246{};

◆ m_lrCalo

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

Definition at line 247 of file ISF_HitAnalysis.h.

247{};

◆ m_lzCalo

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

Definition at line 248 of file ISF_HitAnalysis.h.

248{};

◆ m_MC_DIGI_PARAM

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

Definition at line 122 of file ISF_HitAnalysis.h.

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

◆ m_MC_SIM_PARAM

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

Definition at line 123 of file ISF_HitAnalysis.h.

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

◆ m_metadataTreeName

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

Definition at line 102 of file ISF_HitAnalysis.h.

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

◆ m_MuonEntryLayer_E

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

Definition at line 226 of file ISF_HitAnalysis.h.

226{};

◆ m_MuonEntryLayer_pdg

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

Definition at line 233 of file ISF_HitAnalysis.h.

233{};

◆ m_MuonEntryLayer_px

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

Definition at line 227 of file ISF_HitAnalysis.h.

227{};

◆ m_MuonEntryLayer_py

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

Definition at line 228 of file ISF_HitAnalysis.h.

228{};

◆ m_MuonEntryLayer_pz

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

Definition at line 229 of file ISF_HitAnalysis.h.

229{};

◆ m_MuonEntryLayer_x

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

Definition at line 230 of file ISF_HitAnalysis.h.

230{};

◆ m_MuonEntryLayer_y

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

Definition at line 231 of file ISF_HitAnalysis.h.

231{};

◆ m_MuonEntryLayer_z

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

Definition at line 232 of file ISF_HitAnalysis.h.

232{};

◆ m_newTTC_Angle3D

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

Definition at line 223 of file ISF_HitAnalysis.h.

223{};

◆ m_newTTC_AngleEta

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

Definition at line 224 of file ISF_HitAnalysis.h.

224{};

◆ m_newTTC_back_detaBorder

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

Definition at line 211 of file ISF_HitAnalysis.h.

211{};

◆ m_newTTC_back_eta

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

Definition at line 207 of file ISF_HitAnalysis.h.

207{};

◆ m_newTTC_back_OK

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

Definition at line 212 of file ISF_HitAnalysis.h.

212{};

◆ m_newTTC_back_phi

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

Definition at line 208 of file ISF_HitAnalysis.h.

208{};

◆ m_newTTC_back_r

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

Definition at line 209 of file ISF_HitAnalysis.h.

209{};

◆ m_newTTC_back_z

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

Definition at line 210 of file ISF_HitAnalysis.h.

210{};

◆ m_newTTC_entrance_detaBorder

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

Definition at line 205 of file ISF_HitAnalysis.h.

205{};

◆ m_newTTC_entrance_eta

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

Definition at line 201 of file ISF_HitAnalysis.h.

201{};

◆ m_newTTC_entrance_OK

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

Definition at line 206 of file ISF_HitAnalysis.h.

206{};

◆ m_newTTC_entrance_phi

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

Definition at line 202 of file ISF_HitAnalysis.h.

202{};

◆ m_newTTC_entrance_r

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

Definition at line 203 of file ISF_HitAnalysis.h.

203{};

◆ m_newTTC_entrance_z

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

Definition at line 204 of file ISF_HitAnalysis.h.

204{};

◆ m_newTTC_IDCaloBoundary_eta

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

Definition at line 219 of file ISF_HitAnalysis.h.

219{};

◆ m_newTTC_IDCaloBoundary_phi

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

Definition at line 220 of file ISF_HitAnalysis.h.

220{};

◆ m_newTTC_IDCaloBoundary_r

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

Definition at line 221 of file ISF_HitAnalysis.h.

221{};

◆ m_newTTC_IDCaloBoundary_z

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

Definition at line 222 of file ISF_HitAnalysis.h.

222{};

◆ m_newTTC_mid_detaBorder

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

Definition at line 217 of file ISF_HitAnalysis.h.

217{};

◆ m_newTTC_mid_eta

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

Definition at line 213 of file ISF_HitAnalysis.h.

213{};

◆ m_newTTC_mid_OK

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

Definition at line 218 of file ISF_HitAnalysis.h.

218{};

◆ m_newTTC_mid_phi

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

Definition at line 214 of file ISF_HitAnalysis.h.

214{};

◆ m_newTTC_mid_r

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

Definition at line 215 of file ISF_HitAnalysis.h.

215{};

◆ m_newTTC_mid_z

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

Definition at line 216 of file ISF_HitAnalysis.h.

216{};

◆ m_NtruthParticles

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

Definition at line 104 of file ISF_HitAnalysis.h.

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

◆ m_ntupleFileName

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

Definition at line 100 of file ISF_HitAnalysis.h.

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

◆ m_ntupleTreeName

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

Definition at line 101 of file ISF_HitAnalysis.h.

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

◆ m_oneeventcells

FCS_matchedcellvector* ISF_HitAnalysis::m_oneeventcells = nullptr
private

Definition at line 177 of file ISF_HitAnalysis.h.

◆ m_pdgid

int ISF_HitAnalysis::m_pdgid {}
private

Definition at line 199 of file ISF_HitAnalysis.h.

199{};

◆ m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis ISF_HitAnalysis::m_pdgToParticleHypothesis
private

Definition at line 238 of file ISF_HitAnalysis.h.

◆ m_phi_calo_surf

double ISF_HitAnalysis::m_phi_calo_surf {}
private

Definition at line 191 of file ISF_HitAnalysis.h.

191{};

◆ m_ptruth_e

double ISF_HitAnalysis::m_ptruth_e {}
private

Definition at line 195 of file ISF_HitAnalysis.h.

195{};

◆ m_ptruth_et

double ISF_HitAnalysis::m_ptruth_et {}
private

Definition at line 196 of file ISF_HitAnalysis.h.

196{};

◆ m_ptruth_eta

double ISF_HitAnalysis::m_ptruth_eta {}
private

Definition at line 193 of file ISF_HitAnalysis.h.

193{};

◆ m_ptruth_p

double ISF_HitAnalysis::m_ptruth_p {}
private

Definition at line 198 of file ISF_HitAnalysis.h.

198{};

◆ m_ptruth_phi

double ISF_HitAnalysis::m_ptruth_phi {}
private

Definition at line 194 of file ISF_HitAnalysis.h.

194{};

◆ m_ptruth_pt

double ISF_HitAnalysis::m_ptruth_pt {}
private

Definition at line 197 of file ISF_HitAnalysis.h.

197{};

◆ m_sample_calo_surf

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

End new Extrapolator setup.

Definition at line 241 of file ISF_HitAnalysis.h.

◆ m_saveAllBranches

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

Definition at line 115 of file ISF_HitAnalysis.h.

115{this,"SaveAllBranches", false};

◆ m_surfacelist

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

Definition at line 242 of file ISF_HitAnalysis.h.

◆ m_thistSvc

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

Definition at line 105 of file ISF_HitAnalysis.h.

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

◆ m_tileCabling

const TileCablingService* ISF_HitAnalysis::m_tileCabling {}
private

Definition at line 130 of file ISF_HitAnalysis.h.

130{};

◆ m_tileCablingSvc

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

Name of Tile cabling service.

Definition at line 98 of file ISF_HitAnalysis.h.

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

◆ m_tileHWID

const TileHWID* ISF_HitAnalysis::m_tileHWID {}
private

Definition at line 129 of file ISF_HitAnalysis.h.

129{};

◆ m_tileID

const TileID* ISF_HitAnalysis::m_tileID {}
private

Definition at line 128 of file ISF_HitAnalysis.h.

128{};

◆ m_tileMgr

const TileDetDescrManager* ISF_HitAnalysis::m_tileMgr {}
private

Definition at line 132 of file ISF_HitAnalysis.h.

132{};

◆ m_tileSamplingFractionKey

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

Name of TileSamplingFraction in condition store.

Definition at line 93 of file ISF_HitAnalysis.h.

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

◆ m_TimingCut

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

Definition at line 121 of file ISF_HitAnalysis.h.

121{this, "TimingCut", 999999};

◆ m_total_cell_e

Float_t ISF_HitAnalysis::m_total_cell_e {}
private

Definition at line 180 of file ISF_HitAnalysis.h.

180{};

◆ m_total_g4hit_e

Float_t ISF_HitAnalysis::m_total_g4hit_e {}
private

Definition at line 182 of file ISF_HitAnalysis.h.

182{};

◆ m_total_hit_e

Float_t ISF_HitAnalysis::m_total_hit_e {}
private

Definition at line 181 of file ISF_HitAnalysis.h.

181{};

◆ m_tree

TTree* ISF_HitAnalysis::m_tree {}
private

Definition at line 188 of file ISF_HitAnalysis.h.

188{};

◆ m_truth_barcode

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

Definition at line 155 of file ISF_HitAnalysis.h.

155{};

◆ m_truth_energy

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

Definition at line 150 of file ISF_HitAnalysis.h.

150{};

◆ m_truth_pdg

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

Definition at line 154 of file ISF_HitAnalysis.h.

154{};

◆ m_truth_px

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

Definition at line 151 of file ISF_HitAnalysis.h.

151{};

◆ m_truth_py

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

Definition at line 152 of file ISF_HitAnalysis.h.

152{};

◆ m_truth_pz

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

Definition at line 153 of file ISF_HitAnalysis.h.

153{};

◆ m_truth_vtxbarcode

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

Definition at line 156 of file ISF_HitAnalysis.h.

156{}; //production vertex barcode

◆ m_varHandleArraysDeclared

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

Definition at line 387 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 386 of file AthCommonDataStore.h.

◆ MAX_LAYER

const int ISF_HitAnalysis::MAX_LAYER = 25
static

Definition at line 74 of file ISF_HitAnalysis.h.


The documentation for this class was generated from the following files: