Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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:
Collaboration diagram for ISF_HitAnalysis:

Public Member Functions

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

Static Public Attributes

static const int MAX_LAYER = 25
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

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. More...
 
ServiceHandle< TileCablingSvc > m_tileCablingSvc
 Name of Tile cabling service. More...
 
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. More...
 
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. More...
 
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. More...
 
Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis
 
CaloCell_ID_FCS::CaloSample m_sample_calo_surf {CaloCell_ID_FCS::noSample}
 End new Extrapolator setup. More...
 
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. More...
 
HepPDT::ParticleDataTable * m_particleDataTable {}
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 65 of file ISF_HitAnalysis.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ISF_HitAnalysis()

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

Definition at line 65 of file ISF_HitAnalysis.cxx.

66 : AthAlgorithm(name, pSvcLocator)
67  //Note that m_xxx are pointers to vectors set to 0, not set to empty vector! see note around TBranch
68 {
69  m_surfacelist.resize(0);
70  m_surfacelist.push_back(CaloCell_ID_FCS::PreSamplerB);
71  m_surfacelist.push_back(CaloCell_ID_FCS::PreSamplerE);
72  m_surfacelist.push_back(CaloCell_ID_FCS::EME1);
73  m_surfacelist.push_back(CaloCell_ID_FCS::EME2);
74  m_surfacelist.push_back(CaloCell_ID_FCS::FCAL0);
75 }

◆ ~ISF_HitAnalysis()

ISF_HitAnalysis::~ISF_HitAnalysis ( )
default

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE() [1/2]

virtual StatusCode initialize ISF_HitAnalysis::ATLAS_NOT_THREAD_SAFE ( )
overridevirtual

◆ ATLAS_NOT_THREAD_SAFE() [2/2]

virtual StatusCode finalize ISF_HitAnalysis::ATLAS_NOT_THREAD_SAFE ( )
overridevirtual

◆ caloHits()

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

Definition at line 1328 of file ISF_HitAnalysis.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  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  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  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  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode ISF_HitAnalysis::execute ( )
overridevirtual

Definition at line 481 of file ISF_HitAnalysis.cxx.

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

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

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

◆ extrapolate()

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

◆ extrapolate_to_ID()

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

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

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 }

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_calo_tb_coord

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

Definition at line 110 of file ISF_HitAnalysis.h.

◆ m_CaloBoundaryR

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

Definition at line 114 of file ISF_HitAnalysis.h.

◆ m_CaloBoundaryZ

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

Definition at line 115 of file ISF_HitAnalysis.h.

◆ m_caloEntrance

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

The new Extrapolator setup.

Definition at line 238 of file ISF_HitAnalysis.h.

◆ m_caloEntranceName

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

Definition at line 111 of file ISF_HitAnalysis.h.

◆ m_calomargin

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

Definition at line 116 of file ISF_HitAnalysis.h.

◆ m_caloMgrKey

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

Definition at line 86 of file ISF_HitAnalysis.h.

◆ m_cell_energy

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

Definition at line 168 of file ISF_HitAnalysis.h.

◆ m_cell_identifier

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

Definition at line 167 of file ISF_HitAnalysis.h.

◆ m_cell_sampling

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

Definition at line 169 of file ISF_HitAnalysis.h.

◆ m_cluster_cellID

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

Definition at line 164 of file ISF_HitAnalysis.h.

◆ m_cluster_energy

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

Definition at line 160 of file ISF_HitAnalysis.h.

◆ m_cluster_eta

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

Definition at line 161 of file ISF_HitAnalysis.h.

◆ m_cluster_phi

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

Definition at line 162 of file ISF_HitAnalysis.h.

◆ m_cluster_size

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

Definition at line 163 of file ISF_HitAnalysis.h.

◆ m_d_calo_surf

double ISF_HitAnalysis::m_d_calo_surf {}
private

Definition at line 194 of file ISF_HitAnalysis.h.

◆ m_dCalo

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

Definition at line 251 of file ISF_HitAnalysis.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_distetaCaloBorder

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

Definition at line 252 of file ISF_HitAnalysis.h.

◆ m_doAllCells

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

Definition at line 118 of file ISF_HitAnalysis.h.

◆ m_doClusterInfo

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

Definition at line 119 of file ISF_HitAnalysis.h.

◆ m_doG4Hits

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

Definition at line 122 of file ISF_HitAnalysis.h.

◆ m_doLayers

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

Definition at line 120 of file ISF_HitAnalysis.h.

◆ m_doLayerSums

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

Definition at line 121 of file ISF_HitAnalysis.h.

◆ m_eta_calo_surf

double ISF_HitAnalysis::m_eta_calo_surf {}
private

Definition at line 192 of file ISF_HitAnalysis.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_extrapolator

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

Definition at line 109 of file ISF_HitAnalysis.h.

◆ m_FastCaloSimCaloExtrapolation

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

The FastCaloSimCaloExtrapolation tool.

Definition at line 113 of file ISF_HitAnalysis.h.

◆ m_final_cell_energy

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

Definition at line 186 of file ISF_HitAnalysis.h.

◆ m_final_g4hit_energy

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

Definition at line 188 of file ISF_HitAnalysis.h.

◆ m_final_hit_energy

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

Definition at line 187 of file ISF_HitAnalysis.h.

◆ m_fSamplKey

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

Definition at line 90 of file ISF_HitAnalysis.h.

◆ m_g4hit_cellidentifier

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

Definition at line 174 of file ISF_HitAnalysis.h.

◆ m_g4hit_energy

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

Definition at line 171 of file ISF_HitAnalysis.h.

◆ m_g4hit_identifier

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

Definition at line 173 of file ISF_HitAnalysis.h.

◆ m_g4hit_sampling

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

Definition at line 176 of file ISF_HitAnalysis.h.

◆ m_g4hit_samplingfraction

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

Definition at line 175 of file ISF_HitAnalysis.h.

◆ m_g4hit_time

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

Definition at line 172 of file ISF_HitAnalysis.h.

◆ m_geoFileName

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

Definition at line 105 of file ISF_HitAnalysis.h.

◆ m_geoModel

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

Definition at line 84 of file ISF_HitAnalysis.h.

◆ m_hit_cellidentifier

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

Definition at line 143 of file ISF_HitAnalysis.h.

◆ m_hit_energy

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

Definition at line 140 of file ISF_HitAnalysis.h.

◆ m_hit_identifier

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

Definition at line 142 of file ISF_HitAnalysis.h.

◆ m_hit_sampling

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

Definition at line 149 of file ISF_HitAnalysis.h.

◆ m_hit_samplingfraction

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

Definition at line 150 of file ISF_HitAnalysis.h.

◆ m_hit_time

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

Definition at line 141 of file ISF_HitAnalysis.h.

◆ m_hit_x

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

Simple variables by Ketevi.

Definition at line 137 of file ISF_HitAnalysis.h.

◆ m_hit_y

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

Definition at line 138 of file ISF_HitAnalysis.h.

◆ m_hit_z

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

Definition at line 139 of file ISF_HitAnalysis.h.

◆ m_islarbarrel

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

Definition at line 144 of file ISF_HitAnalysis.h.

◆ m_islarendcap

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

Definition at line 145 of file ISF_HitAnalysis.h.

◆ m_islarfcal

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

Definition at line 147 of file ISF_HitAnalysis.h.

◆ m_islarhec

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

Definition at line 146 of file ISF_HitAnalysis.h.

◆ m_istile

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

Definition at line 148 of file ISF_HitAnalysis.h.

◆ m_larEmID

const LArEM_ID* ISF_HitAnalysis::m_larEmID {}
private

Definition at line 127 of file ISF_HitAnalysis.h.

◆ m_larFcalID

const LArFCAL_ID* ISF_HitAnalysis::m_larFcalID {}
private

Definition at line 128 of file ISF_HitAnalysis.h.

◆ m_larHecID

const LArHEC_ID* ISF_HitAnalysis::m_larHecID {}
private

Definition at line 129 of file ISF_HitAnalysis.h.

◆ m_layerCaloOK

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

Definition at line 246 of file ISF_HitAnalysis.h.

◆ m_layercells

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

Definition at line 180 of file ISF_HitAnalysis.h.

◆ m_letaCalo

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

Definition at line 247 of file ISF_HitAnalysis.h.

◆ m_lphiCalo

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

Definition at line 248 of file ISF_HitAnalysis.h.

◆ m_lrCalo

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

Definition at line 249 of file ISF_HitAnalysis.h.

◆ m_lzCalo

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

Definition at line 250 of file ISF_HitAnalysis.h.

◆ m_MC_DIGI_PARAM

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

Definition at line 124 of file ISF_HitAnalysis.h.

◆ m_MC_SIM_PARAM

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

Definition at line 125 of file ISF_HitAnalysis.h.

◆ m_metadataTreeName

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

Definition at line 104 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_E

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

Definition at line 228 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_pdg

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

Definition at line 235 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_px

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

Definition at line 229 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_py

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

Definition at line 230 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_pz

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

Definition at line 231 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_x

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

Definition at line 232 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_y

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

Definition at line 233 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_z

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

Definition at line 234 of file ISF_HitAnalysis.h.

◆ m_newTTC_Angle3D

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

Definition at line 225 of file ISF_HitAnalysis.h.

◆ m_newTTC_AngleEta

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

Definition at line 226 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_detaBorder

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

Definition at line 213 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_eta

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

Definition at line 209 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_OK

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

Definition at line 214 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_phi

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

Definition at line 210 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_r

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

Definition at line 211 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_z

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

Definition at line 212 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_detaBorder

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

Definition at line 207 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_eta

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

Definition at line 203 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_OK

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

Definition at line 208 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_phi

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

Definition at line 204 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_r

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

Definition at line 205 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_z

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

Definition at line 206 of file ISF_HitAnalysis.h.

◆ m_newTTC_IDCaloBoundary_eta

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

Definition at line 221 of file ISF_HitAnalysis.h.

◆ m_newTTC_IDCaloBoundary_phi

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

Definition at line 222 of file ISF_HitAnalysis.h.

◆ m_newTTC_IDCaloBoundary_r

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

Definition at line 223 of file ISF_HitAnalysis.h.

◆ m_newTTC_IDCaloBoundary_z

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

Definition at line 224 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_detaBorder

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

Definition at line 219 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_eta

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

Definition at line 215 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_OK

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

Definition at line 220 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_phi

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

Definition at line 216 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_r

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

Definition at line 217 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_z

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

Definition at line 218 of file ISF_HitAnalysis.h.

◆ m_NtruthParticles

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

Definition at line 106 of file ISF_HitAnalysis.h.

◆ m_ntupleFileName

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

Definition at line 102 of file ISF_HitAnalysis.h.

◆ m_ntupleTreeName

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

Definition at line 103 of file ISF_HitAnalysis.h.

◆ m_oneeventcells

FCS_matchedcellvector* ISF_HitAnalysis::m_oneeventcells = nullptr
private

Definition at line 179 of file ISF_HitAnalysis.h.

◆ m_particleDataTable

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

Definition at line 257 of file ISF_HitAnalysis.h.

◆ m_partPropSvc

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

Handle on the particle property service.

Definition at line 255 of file ISF_HitAnalysis.h.

◆ m_pdgid

int ISF_HitAnalysis::m_pdgid {}
private

Definition at line 201 of file ISF_HitAnalysis.h.

◆ m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis ISF_HitAnalysis::m_pdgToParticleHypothesis
private

Definition at line 240 of file ISF_HitAnalysis.h.

◆ m_phi_calo_surf

double ISF_HitAnalysis::m_phi_calo_surf {}
private

Definition at line 193 of file ISF_HitAnalysis.h.

◆ m_ptruth_e

double ISF_HitAnalysis::m_ptruth_e {}
private

Definition at line 197 of file ISF_HitAnalysis.h.

◆ m_ptruth_et

double ISF_HitAnalysis::m_ptruth_et {}
private

Definition at line 198 of file ISF_HitAnalysis.h.

◆ m_ptruth_eta

double ISF_HitAnalysis::m_ptruth_eta {}
private

Definition at line 195 of file ISF_HitAnalysis.h.

◆ m_ptruth_p

double ISF_HitAnalysis::m_ptruth_p {}
private

Definition at line 200 of file ISF_HitAnalysis.h.

◆ m_ptruth_phi

double ISF_HitAnalysis::m_ptruth_phi {}
private

Definition at line 196 of file ISF_HitAnalysis.h.

◆ m_ptruth_pt

double ISF_HitAnalysis::m_ptruth_pt {}
private

Definition at line 199 of file ISF_HitAnalysis.h.

◆ m_sample_calo_surf

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

End new Extrapolator setup.

Definition at line 243 of file ISF_HitAnalysis.h.

◆ m_saveAllBranches

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

Definition at line 117 of file ISF_HitAnalysis.h.

◆ m_surfacelist

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

Definition at line 244 of file ISF_HitAnalysis.h.

◆ m_thistSvc

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

Definition at line 107 of file ISF_HitAnalysis.h.

◆ m_tileCabling

const TileCablingService* ISF_HitAnalysis::m_tileCabling {}
private

Definition at line 132 of file ISF_HitAnalysis.h.

◆ m_tileCablingSvc

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

Name of Tile cabling service.

Definition at line 100 of file ISF_HitAnalysis.h.

◆ m_tileHWID

const TileHWID* ISF_HitAnalysis::m_tileHWID {}
private

Definition at line 131 of file ISF_HitAnalysis.h.

◆ m_tileID

const TileID* ISF_HitAnalysis::m_tileID {}
private

Definition at line 130 of file ISF_HitAnalysis.h.

◆ m_tileMgr

const TileDetDescrManager* ISF_HitAnalysis::m_tileMgr {}
private

Definition at line 134 of file ISF_HitAnalysis.h.

◆ m_tileSamplingFractionKey

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

Name of TileSamplingFraction in condition store.

Definition at line 95 of file ISF_HitAnalysis.h.

◆ m_TimingCut

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

Definition at line 123 of file ISF_HitAnalysis.h.

◆ m_total_cell_e

Float_t ISF_HitAnalysis::m_total_cell_e {}
private

Definition at line 182 of file ISF_HitAnalysis.h.

◆ m_total_g4hit_e

Float_t ISF_HitAnalysis::m_total_g4hit_e {}
private

Definition at line 184 of file ISF_HitAnalysis.h.

◆ m_total_hit_e

Float_t ISF_HitAnalysis::m_total_hit_e {}
private

Definition at line 183 of file ISF_HitAnalysis.h.

◆ m_tree

TTree* ISF_HitAnalysis::m_tree {}
private

Definition at line 190 of file ISF_HitAnalysis.h.

◆ m_truth_barcode

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

Definition at line 157 of file ISF_HitAnalysis.h.

◆ m_truth_energy

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

Definition at line 152 of file ISF_HitAnalysis.h.

◆ m_truth_pdg

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

Definition at line 156 of file ISF_HitAnalysis.h.

◆ m_truth_px

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

Definition at line 153 of file ISF_HitAnalysis.h.

◆ m_truth_py

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

Definition at line 154 of file ISF_HitAnalysis.h.

◆ m_truth_pz

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

Definition at line 155 of file ISF_HitAnalysis.h.

◆ m_truth_vtxbarcode

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

Definition at line 158 of file ISF_HitAnalysis.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ MAX_LAYER

const int ISF_HitAnalysis::MAX_LAYER = 25
static

Definition at line 76 of file ISF_HitAnalysis.h.

The documentation for this class was generated from the following files:
ISF_HitAnalysis::m_truth_vtxbarcode
std::vector< int > * m_truth_vtxbarcode
Definition: ISF_HitAnalysis.h:158
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
ISF_HitAnalysis::m_MuonEntryLayer_E
std::vector< float > * m_MuonEntryLayer_E
Definition: ISF_HitAnalysis.h:228
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
Tile_Base_ID::is_tile_aux
bool is_tile_aux(const Identifier &id) const
Definition: Tile_Base_ID.cxx:232
ISF_HitAnalysis::m_pdgToParticleHypothesis
Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis
Definition: ISF_HitAnalysis.h:240
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:280
ISF_HitAnalysis::m_newTTC_back_detaBorder
std::vector< std::vector< float > > * m_newTTC_back_detaBorder
Definition: ISF_HitAnalysis.h:213
ISF_HitAnalysis::m_truth_pz
std::vector< float > * m_truth_pz
Definition: ISF_HitAnalysis.h:155
ISF_HitAnalysis::m_FastCaloSimCaloExtrapolation
PublicToolHandle< IFastCaloSimCaloExtrapolation > m_FastCaloSimCaloExtrapolation
The FastCaloSimCaloExtrapolation tool.
Definition: ISF_HitAnalysis.h:113
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
ISF_HitAnalysis::m_newTTC_entrance_eta
std::vector< std::vector< float > > * m_newTTC_entrance_eta
Definition: ISF_HitAnalysis.h:203
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
get_generator_info.result
result
Definition: get_generator_info.py:21
test_pyathena.px
px
Definition: test_pyathena.py:18
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
ISF_HitAnalysis::m_final_hit_energy
std::vector< Float_t > * m_final_hit_energy
Definition: ISF_HitAnalysis.h:187
ISF_HitAnalysis::m_cluster_phi
std::vector< float > * m_cluster_phi
Definition: ISF_HitAnalysis.h:162
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
ISF_HitAnalysis::m_cell_energy
std::vector< float > * m_cell_energy
Definition: ISF_HitAnalysis.h:168
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ISF_HitAnalysis::m_cluster_energy
std::vector< float > * m_cluster_energy
Definition: ISF_HitAnalysis.h:160
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ISF_HitAnalysis::m_CaloBoundaryZ
DoubleProperty m_CaloBoundaryZ
Definition: ISF_HitAnalysis.h:115
Trk::PdgToParticleHypothesis::convert
Trk::ParticleHypothesis convert(int pdg, bool &stable, bool &exiting, double charge=1.) const
Converter method : PDG -> Particle Hyptothesis.
ISF_HitAnalysis::m_newTTC_Angle3D
std::vector< float > * m_newTTC_Angle3D
Definition: ISF_HitAnalysis.h:225
CaloCell_ID_FCS::FirstSample
@ FirstSample
Definition: FastCaloSim_CaloCell_ID.h:18
ISF_HitAnalysis::m_newTTC_mid_r
std::vector< std::vector< float > > * m_newTTC_mid_r
Definition: ISF_HitAnalysis.h:217
ISF_HitAnalysis::m_newTTC_entrance_r
std::vector< std::vector< float > > * m_newTTC_entrance_r
Definition: ISF_HitAnalysis.h:205
AtlasDetectorID::is_lar_fcal
bool is_lar_fcal(Identifier id) const
Definition: AtlasDetectorID.h:839
Tile_Base_ID::is_tile_gap
bool is_tile_gap(const Identifier &id) const
Definition: Tile_Base_ID.cxx:223
FCS_matchedcell::clear
void clear()
Definition: FCS_Cell.h:63
TileHitVecConstIterator
AtlasHitsVector< TileHit >::const_iterator TileHitVecConstIterator
Definition: TileHitVector.h:30
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
FCS_matchedcell::cell
FCS_cell cell
Definition: FCS_Cell.h:60
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::ParametersBase::uniqueClone
std::unique_ptr< ParametersBase< DIM, T > > uniqueClone() const
clone method for polymorphic deep copy returning unique_ptr; it is not overriden, but uses the existi...
Definition: ParametersBase.h:97
ISF_HitAnalysis::m_tileID
const TileID * m_tileID
Definition: ISF_HitAnalysis.h:130
ISF_HitAnalysis::m_oneeventcells
FCS_matchedcellvector * m_oneeventcells
Definition: ISF_HitAnalysis.h:179
ISF_HitAnalysis::m_TimingCut
IntegerProperty m_TimingCut
Definition: ISF_HitAnalysis.h:123
FCS_g4hit
Definition: FCS_Cell.h:48
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
ISF_HitAnalysis::m_MuonEntryLayer_pz
std::vector< float > * m_MuonEntryLayer_pz
Definition: ISF_HitAnalysis.h:231
FCS_hit
Definition: FCS_Cell.h:34
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition: CaloDetDescrManager.cxx:159
ISF_HitAnalysis::m_truth_barcode
std::vector< int > * m_truth_barcode
Definition: ISF_HitAnalysis.h:157
hitVector
std::vector< FPGATrackSimHit > hitVector
Definition: FPGATrackSimCluster.h:22
ISF_HitAnalysis::MAX_LAYER
static const int MAX_LAYER
Definition: ISF_HitAnalysis.h:76
AtlasHitsVector
Definition: AtlasHitsVector.h:33
skel.it
it
Definition: skel.GENtoEVGEN.py:407
ISF_HitAnalysis::m_caloEntranceName
StringProperty m_caloEntranceName
Definition: ISF_HitAnalysis.h:111
ISF_HitAnalysis::m_islarendcap
std::vector< bool > * m_islarendcap
Definition: ISF_HitAnalysis.h:145
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_eta
std::vector< float > * m_newTTC_IDCaloBoundary_eta
Definition: ISF_HitAnalysis.h:221
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
CaloCell_ID_FCS::EME1
@ EME1
Definition: FastCaloSim_CaloCell_ID.h:24
Identifier::get_compact
value_type get_compact() const
Get the compact id.
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
Tile_Base_ID::is_tile_extbarrel
bool is_tile_extbarrel(const Identifier &id) const
Definition: Tile_Base_ID.cxx:214
ISF_HitAnalysis::m_hit_samplingfraction
std::vector< float > * m_hit_samplingfraction
Definition: ISF_HitAnalysis.h:150
LArHit::energy
double energy() const
Definition: LArHit.h:113
LArHitContainer
Hit collection.
Definition: LArHitContainer.h:26
TFCSExtrapolationState::SUBPOS_ENT
@ SUBPOS_ENT
Definition: TFCSExtrapolationState.h:21
ISF_HitAnalysis::m_final_cell_energy
std::vector< Float_t > * m_final_cell_energy
Definition: ISF_HitAnalysis.h:186
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
ISF_HitAnalysis::m_cell_sampling
std::vector< int > * m_cell_sampling
Definition: ISF_HitAnalysis.h:169
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_z
std::vector< float > * m_newTTC_IDCaloBoundary_z
Definition: ISF_HitAnalysis.h:224
ISF_HitAnalysis::m_hit_x
std::vector< float > * m_hit_x
Simple variables by Ketevi.
Definition: ISF_HitAnalysis.h:137
TFCSExtrapolationState
Definition: TFCSExtrapolationState.h:13
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
TFCSExtrapolationState::SUBPOS_MID
@ SUBPOS_MID
Definition: TFCSExtrapolationState.h:20
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
CaloCell_ID_FCS::EME2
@ EME2
Definition: FastCaloSim_CaloCell_ID.h:25
HWIdentifier
Definition: HWIdentifier.h:13
Trk::Calo
@ Calo
Definition: GeometrySignature.h:28
AtlasHitsVector::begin
const_iterator begin() const
Definition: AtlasHitsVector.h:131
x
#define x
ISF_HitAnalysis::m_hit_sampling
std::vector< int > * m_hit_sampling
Definition: ISF_HitAnalysis.h:149
TFCSExtrapolationState::SUBPOS_EXT
@ SUBPOS_EXT
Definition: TFCSExtrapolationState.h:22
ISF_HitAnalysis::m_hit_identifier
std::vector< Long64_t > * m_hit_identifier
Definition: ISF_HitAnalysis.h:142
ISF_HitAnalysis::m_MuonEntryLayer_x
std::vector< float > * m_MuonEntryLayer_x
Definition: ISF_HitAnalysis.h:232
ISF_HitAnalysis::m_islarbarrel
std::vector< bool > * m_islarbarrel
Definition: ISF_HitAnalysis.h:144
ISF_HitAnalysis::m_istile
std::vector< bool > * m_istile
Definition: ISF_HitAnalysis.h:148
FCS_matchedcell::g4hit
std::vector< FCS_g4hit > g4hit
Definition: FCS_Cell.h:61
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
ISF_HitAnalysis::m_g4hit_identifier
std::vector< Long64_t > * m_g4hit_identifier
Definition: ISF_HitAnalysis.h:173
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
ISF_HitAnalysis::m_newTTC_entrance_OK
std::vector< std::vector< bool > > * m_newTTC_entrance_OK
Definition: ISF_HitAnalysis.h:208
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
CxxUtils::CachedPointer::set
void set(pointer_t elt) const
Set the element, assuming it is currently null.
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
ISF_HitAnalysis::m_newTTC_mid_z
std::vector< std::vector< float > > * m_newTTC_mid_z
Definition: ISF_HitAnalysis.h:218
AthenaHitsVector< LArHit >::const_iterator
boost::transform_iterator< make_const, typename CONT::const_iterator > const_iterator
Definition: AthenaHitsVector.h:58
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_r
std::vector< float > * m_newTTC_IDCaloBoundary_r
Definition: ISF_HitAnalysis.h:223
ReadCellNoiseFromCool.tile
tile
Definition: ReadCellNoiseFromCool.py:92
ISF_HitAnalysis::m_tileHWID
const TileHWID * m_tileHWID
Definition: ISF_HitAnalysis.h:131
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
ISF_HitAnalysis::m_hit_energy
std::vector< float > * m_hit_energy
Definition: ISF_HitAnalysis.h:140
Trk::ParticleHypothesis
ParticleHypothesis
Definition: ParticleHypothesis.h:25
ISF_HitAnalysis::m_cluster_size
std::vector< unsigned > * m_cluster_size
Definition: ISF_HitAnalysis.h:163
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ISF_HitAnalysis::m_newTTC_entrance_phi
std::vector< std::vector< float > > * m_newTTC_entrance_phi
Definition: ISF_HitAnalysis.h:204
ISF_HitAnalysis::m_total_g4hit_e
Float_t m_total_g4hit_e
Definition: ISF_HitAnalysis.h:184
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition: CaloDetDescrElement.cxx:63
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
CaloCell_ID_FCS::MaxSample
@ MaxSample
Definition: FastCaloSim_CaloCell_ID.h:47
Trk::GeometrySignature
GeometrySignature
Definition: GeometrySignature.h:24
ISF_HitAnalysis::m_layercells
FCS_matchedcellvector * m_layercells[MAX_LAYER]
Definition: ISF_HitAnalysis.h:180
FCS_cell::center_x
float center_x
Definition: FCS_Cell.h:35
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
ParticleGun_EoverP_Config.mom
mom
Definition: ParticleGun_EoverP_Config.py:63
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ISF_HitAnalysis::m_cluster_eta
std::vector< float > * m_cluster_eta
Definition: ISF_HitAnalysis.h:161
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ISF_HitAnalysis::m_hit_y
std::vector< float > * m_hit_y
Definition: ISF_HitAnalysis.h:138
FCS_matchedcell
Definition: FCS_Cell.h:59
columnar::ContainerId::cluster
@ cluster
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:116
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
FCS_cell::sampling
int sampling
Definition: FCS_Cell.h:33
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_phi
std::vector< float > * m_newTTC_IDCaloBoundary_phi
Definition: ISF_HitAnalysis.h:222
lumiFormat.i
int i
Definition: lumiFormat.py:85
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
z
#define z
ISF_HitAnalysis::m_g4hit_sampling
std::vector< int > * m_g4hit_sampling
Definition: ISF_HitAnalysis.h:176
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ILArfSampl::FSAMPL
virtual const float & FSAMPL(const HWIdentifier &id) const =0
FCS_matchedcellvector::push_back
void push_back(FCS_matchedcell cell)
Definition: FCS_Cell.h:80
HepMC::barcode
int barcode(const T *p)
Definition: Barcode.h:16
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
LArHit::time
double time() const
Definition: LArHit.h:118
ISF_HitAnalysis::m_total_cell_e
Float_t m_total_cell_e
Definition: ISF_HitAnalysis.h:182
createCoolChannelIdFile.channel_id
channel_id
Definition: createCoolChannelIdFile.py:52
Trk::geantino
@ geantino
Definition: ParticleHypothesis.h:26
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
ISF_HitAnalysis::m_MuonEntryLayer_pdg
std::vector< int > * m_MuonEntryLayer_pdg
Definition: ISF_HitAnalysis.h:235
ISF_HitAnalysis::m_newTTC_back_z
std::vector< std::vector< float > > * m_newTTC_back_z
Definition: ISF_HitAnalysis.h:212
jobOptions.ParticleID
ParticleID
Definition: jobOptions.decayer.py:85
ISF_HitAnalysis::m_larFcalID
const LArFCAL_ID * m_larFcalID
Definition: ISF_HitAnalysis.h:128
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FCS_cell::center_z
float center_z
Definition: FCS_Cell.h:37
AtlasDetectorID::is_tile
bool is_tile(Identifier id) const
Definition: AtlasDetectorID.h:695
ISF_HitAnalysis::m_final_g4hit_energy
std::vector< Float_t > * m_final_g4hit_energy
Definition: ISF_HitAnalysis.h:188
AtlasDetectorID::is_lar_hec
bool is_lar_hec(Identifier id) const
Definition: AtlasDetectorID.h:829
FCS_cell::cell_identifier
Long64_t cell_identifier
Definition: FCS_Cell.h:32
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
ISF_HitAnalysis::m_NtruthParticles
IntegerProperty m_NtruthParticles
Definition: ISF_HitAnalysis.h:106
ISF_HitAnalysis::m_g4hit_cellidentifier
std::vector< Long64_t > * m_g4hit_cellidentifier
Definition: ISF_HitAnalysis.h:174
ISF_HitAnalysis::m_tileCabling
const TileCablingService * m_tileCabling
Definition: ISF_HitAnalysis.h:132
Trk::CurvilinearParametersT
Definition: CurvilinearParametersT.h:48
ISF_HitAnalysis::m_newTTC_back_eta
std::vector< std::vector< float > > * m_newTTC_back_eta
Definition: ISF_HitAnalysis.h:209
McEventCollection
This defines the McEventCollection, which is really just an ObjectVector of McEvent objects.
Definition: McEventCollection.h:33
Trk::TimeLimit
Definition: HelperStructs.h:58
ISF_HitAnalysis::m_tileSamplingFractionKey
SG::ReadCondHandleKey< TileSamplingFraction > m_tileSamplingFractionKey
Name of TileSamplingFraction in condition store.
Definition: ISF_HitAnalysis.h:95
ISF_HitAnalysis::m_newTTC_entrance_detaBorder
std::vector< std::vector< float > > * m_newTTC_entrance_detaBorder
Definition: ISF_HitAnalysis.h:207
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
FCS_matchedcellvector::size
unsigned int size()
Definition: FCS_Cell.h:79
ISF_HitAnalysis::m_newTTC_back_phi
std::vector< std::vector< float > > * m_newTTC_back_phi
Definition: ISF_HitAnalysis.h:210
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
ISF_HitAnalysis::m_MuonEntryLayer_y
std::vector< float > * m_MuonEntryLayer_y
Definition: ISF_HitAnalysis.h:233
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
ISF_HitAnalysis::m_cell_identifier
std::vector< Long64_t > * m_cell_identifier
Definition: ISF_HitAnalysis.h:167
LArHit::cellID
Identifier cellID() const
Definition: LArHit.h:108
xAOD::CaloCluster_v1::UNCALIBRATED
@ UNCALIBRATED
Definition: CaloCluster_v1.h:309
ISF_HitAnalysis::m_total_hit_e
Float_t m_total_hit_e
Definition: ISF_HitAnalysis.h:183
Amg::py
@ py
Definition: GeoPrimitives.h:39
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ISF_HitAnalysis::m_islarfcal
std::vector< bool > * m_islarfcal
Definition: ISF_HitAnalysis.h:147
TileHWID::drawerIdx
int drawerIdx(const HWIdentifier &id) const
construct drawer index from HW identifier
Definition: TileHWID.h:175
ISF_HitAnalysis::m_doG4Hits
BooleanProperty m_doG4Hits
Definition: ISF_HitAnalysis.h:122
ISF_HitAnalysis::m_CaloBoundaryR
DoubleProperty m_CaloBoundaryR
Definition: ISF_HitAnalysis.h:114
ISF_HitAnalysis::m_newTTC_entrance_z
std::vector< std::vector< float > > * m_newTTC_entrance_z
Definition: ISF_HitAnalysis.h:206
charge
double charge(const T &p)
Definition: AtlasPID.h:931
FCS_cell::energy
float energy
Definition: FCS_Cell.h:34
Trk::PathLimit
Definition: HelperStructs.h:34
ISF_HitAnalysis::m_hit_z
std::vector< float > * m_hit_z
Definition: ISF_HitAnalysis.h:139
LArHit
Class to store hit energy and time in LAr cell from G4 simulation.
Definition: LArHit.h:25
ISF_HitAnalysis::m_newTTC_AngleEta
std::vector< float > * m_newTTC_AngleEta
Definition: ISF_HitAnalysis.h:226
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
ISF_HitAnalysis::m_MuonEntryLayer_z
std::vector< float > * m_MuonEntryLayer_z
Definition: ISF_HitAnalysis.h:234
TrackRecord
Definition: TrackRecord.h:12
ISF_HitAnalysis::m_fSamplKey
SG::ReadCondHandleKey< ILArfSampl > m_fSamplKey
Definition: ISF_HitAnalysis.h:90
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
ISF_HitAnalysis::m_tree
TTree * m_tree
Definition: ISF_HitAnalysis.h:190
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
ISF_HitAnalysis::m_truth_energy
std::vector< float > * m_truth_energy
Definition: ISF_HitAnalysis.h:152
ISF_HitAnalysis::m_hit_cellidentifier
std::vector< Long64_t > * m_hit_cellidentifier
Definition: ISF_HitAnalysis.h:143
a
TList * a
Definition: liststreamerinfos.cxx:10
y
#define y
h
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
FCS_matchedcellvector::GetLayer
std::vector< FCS_matchedcell > GetLayer(int layer)
Definition: FCS_Cell.h:77
ISF_HitAnalysis::m_MuonEntryLayer_px
std::vector< float > * m_MuonEntryLayer_px
Definition: ISF_HitAnalysis.h:229
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
ISF_HitAnalysis::m_newTTC_mid_phi
std::vector< std::vector< float > > * m_newTTC_mid_phi
Definition: ISF_HitAnalysis.h:216
FCS_cell
Definition: FCS_Cell.h:23
LArEM_Base_ID::is_em_barrel
bool is_em_barrel(const Identifier id) const
test if the id belongs to the EM barrel
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ISF_HitAnalysis::m_extrapolator
PublicToolHandle< Trk::ITimedExtrapolator > m_extrapolator
Definition: ISF_HitAnalysis.h:109
CaloCell_ID_FCS::PreSamplerE
@ PreSamplerE
Definition: FastCaloSim_CaloCell_ID.h:23
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
AtlasHitsVector::end
const_iterator end() const
Definition: AtlasHitsVector.h:134
ISF_HitAnalysis::m_newTTC_mid_OK
std::vector< std::vector< bool > > * m_newTTC_mid_OK
Definition: ISF_HitAnalysis.h:220
ISF_HitAnalysis::m_cluster_cellID
std::vector< std::vector< Long64_t > > * m_cluster_cellID
Definition: ISF_HitAnalysis.h:164
DEBUG
#define DEBUG
Definition: page_access.h:11
ISF_HitAnalysis::m_hit_time
std::vector< float > * m_hit_time
Definition: ISF_HitAnalysis.h:141
ISF_HitAnalysis::m_tileMgr
const TileDetDescrManager * m_tileMgr
Definition: ISF_HitAnalysis.h:134
FCS_cell::center_y
float center_y
Definition: FCS_Cell.h:36
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
CxxUtils::CachedPointer::get
pointer_t get() const
Return the current value of the element.
ISF_HitAnalysis::m_newTTC_back_OK
std::vector< std::vector< bool > > * m_newTTC_back_OK
Definition: ISF_HitAnalysis.h:214
ISF_HitAnalysis::m_islarhec
std::vector< bool > * m_islarhec
Definition: ISF_HitAnalysis.h:146
FCS_matchedcellvector::m_vector
std::vector< FCS_matchedcell > m_vector
Definition: FCS_Cell.h:76
ISF_FCS_Parametrization::FCS_StepInfoCollection
Class for collection of StepInfo class (G4 hits) copied and modified version to ISF.
Definition: FCS_StepInfoCollection.h:30
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
Trk::HitInfo
Definition: HelperStructs.h:12
ISF_HitAnalysis::m_truth_pdg
std::vector< int > * m_truth_pdg
Definition: ISF_HitAnalysis.h:156
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
ISF_HitAnalysis::m_newTTC_mid_detaBorder
std::vector< std::vector< float > > * m_newTTC_mid_detaBorder
Definition: ISF_HitAnalysis.h:219
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
ISF_HitAnalysis::m_newTTC_back_r
std::vector< std::vector< float > > * m_newTTC_back_r
Definition: ISF_HitAnalysis.h:211
GetEnergy
int GetEnergy()
Definition: GetEnergy.cxx:81
ISF_HitAnalysis::m_larEmID
const LArEM_ID * m_larEmID
Definition: ISF_HitAnalysis.h:127
ISF_HitAnalysis::m_surfacelist
std::vector< CaloCell_ID_FCS::CaloSample > m_surfacelist
Definition: ISF_HitAnalysis.h:244
Tile_Base_ID::is_tile_barrel
bool is_tile_barrel(const Identifier &id) const
Test of an Identifier to see if it belongs to a particular part of the calorimeter.
Definition: Tile_Base_ID.cxx:205
ISF_HitAnalysis::m_g4hit_energy
std::vector< float > * m_g4hit_energy
Definition: ISF_HitAnalysis.h:171
Tile_Base_ID::cell_id
Identifier cell_id(const Identifier &any_id) const
Definition: Tile_Base_ID.cxx:581
ISF_HitAnalysis::m_g4hit_time
std::vector< float > * m_g4hit_time
Definition: ISF_HitAnalysis.h:172
FCS_matchedcell::hit
std::vector< FCS_hit > hit
Definition: FCS_Cell.h:62
CaloCell_ID_FCS::FCAL0
@ FCAL0
Definition: FastCaloSim_CaloCell_ID.h:40
CaloClusterCellLink::const_iterator
const_iterator to loop over cells belonging to a cluster
Definition: CaloClusterCellLink.h:57
ISF_HitAnalysis::m_caloEntrance
CxxUtils::CachedPointer< const Trk::TrackingVolume > m_caloEntrance
The new Extrapolator setup.
Definition: ISF_HitAnalysis.h:238
ISF_HitAnalysis::m_truth_py
std::vector< float > * m_truth_py
Definition: ISF_HitAnalysis.h:154
TFCSTruthState
Definition: TFCSTruthState.h:13
AtlasDetectorID::is_lar_em
bool is_lar_em(Identifier id) const
Definition: AtlasDetectorID.h:818
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
ISF_HitAnalysis::m_truth_px
std::vector< float > * m_truth_px
Definition: ISF_HitAnalysis.h:153
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
ISF_HitAnalysis::m_larHecID
const LArHEC_ID * m_larHecID
Definition: ISF_HitAnalysis.h:129
LArEM_Base_ID::is_em_endcap
bool is_em_endcap(const Identifier id) const
test if the id belongs to the EM Endcap
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
ISF_HitAnalysis::m_newTTC_mid_eta
std::vector< std::vector< float > > * m_newTTC_mid_eta
Definition: ISF_HitAnalysis.h:215
fitman.k
k
Definition: fitman.py:528
ILArfSampl
Definition: ILArfSampl.h:14
TileCablingService::s2h_channel_id
HWIdentifier s2h_channel_id(const Identifier &id) const
Definition: TileCablingService.cxx:1076
ISF_HitAnalysis::m_g4hit_samplingfraction
std::vector< float > * m_g4hit_samplingfraction
Definition: ISF_HitAnalysis.h:175
ServiceHandle< ICondSvc >
ISF_HitAnalysis::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: ISF_HitAnalysis.h:86
ISF_HitAnalysis::m_MuonEntryLayer_py
std::vector< float > * m_MuonEntryLayer_py
Definition: ISF_HitAnalysis.h:230
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Apr 14 2025 21:34:21 for ATLAS Offline Software by   doxygen 1.8.18