ATLAS Offline Software
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
 
StatusCode updateMetaData (IOVSVC_CALLBACK_ARGS)
 
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 64 of file ISF_HitAnalysis.cxx.

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

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

1367 {
1368  // Start calo extrapolation
1369  ATH_MSG_DEBUG ("[ fastCaloSim transport ] processing particle "<<part.pdg_id() );
1370 
1371  std::vector<Trk::HitInfo>* hitVector = new std::vector<Trk::HitInfo>;
1372 
1373  int pdgId = part.pdg_id();
1374  double charge = HepPDT::ParticleID(pdgId).charge();
1375 
1376  // particle Hypothesis for the extrapolation
1377  Trk::ParticleHypothesis pHypothesis = m_pdgToParticleHypothesis.convert(pdgId,charge);
1378 
1379  ATH_MSG_DEBUG ("particle hypothesis "<< pHypothesis );
1380 
1381  // geantinos not handled by PdgToParticleHypothesis - fix there
1382  if( pdgId == 999 ) pHypothesis = Trk::geantino;
1383 
1384  auto vtx = part.production_vertex();
1385  Amg::Vector3D pos(0.,0.,0.); // default
1386 
1387  if (vtx)
1388  {
1389  pos = Amg::Vector3D( vtx->position().x(),vtx->position().y(), vtx->position().z());
1390  }
1391 
1392  Amg::Vector3D mom(part.momentum().x(),part.momentum().y(),part.momentum().z());
1393  ATH_MSG_DEBUG( "[ fastCaloSim transport ] starting transport from position eta="<<pos.eta()<<" phi="<<pos.phi()<<" d="<<pos.mag()<<" pT="<<mom.perp() );
1394 
1395  // input parameters : curvilinear parameters
1396  Trk::CurvilinearParameters inputPar(pos,mom,charge);
1397 
1398  // stable vs. unstable check : ADAPT for FASTCALOSIM
1399  //double freepath = ( !m_particleDecayHelper.empty()) ? m_particleDecayHelper->freePath(isp) : - 1.;
1400  double freepath = -1.;
1401  //ATH_MSG_VERBOSE( "[ fatras transport ] Particle free path : " << freepath);
1402  // path limit -> time limit ( TODO : extract life-time directly from decay helper )
1403  double tDec = freepath > 0. ? freepath : -1.;
1404  int decayProc = 0;
1405 
1406  /* uncomment if unstable particles used by FastCaloSim
1407  // beta calculated here for further use in validation
1408  double mass = m_particleMasses.mass[pHypothesis];
1409  double mom = isp.momentum().mag();
1410  double beta = mom/sqrt(mom*mom+mass*mass);
1411 
1412  if ( tDec>0.)
1413  {
1414  tDec = tDec/beta/CLHEP::c_light + isp.timeStamp();
1415  decayProc = 201;
1416  }
1417  */
1418 
1419  Trk::TimeLimit timeLim(tDec,0.,decayProc); // TODO: set vertex time info
1420 
1421  // prompt decay ( uncomment if unstable particles used )
1422  //if ( freepath>0. && freepath<0.01 ) {
1423  // if (!m_particleDecayHelper.empty()) {
1424  // ATH_MSG_VERBOSE( "[ fatras transport ] Decay is triggered for input particle.");
1425  // m_particleDecayHelper->decay(isp);
1426  // }
1427  // return 0;
1428  //}
1429 
1430  // presample interactions - ADAPT FOR FASTCALOSIM
1431  Trk::PathLimit pathLim(-1.,0);
1432  //if (absPdg!=999 && pHypothesis<99) pathLim = m_samplingTool->sampleProcess(mom,isp.charge(),pHypothesis);
1433 
1434  Trk::GeometrySignature nextGeoID=Trk::Calo;
1435 
1436  // first extrapolation to reach the ID boundary
1437  ATH_MSG_DEBUG( "[ fastCaloSim transport ] before calo entrance ");
1438 
1439  // get CaloEntrance if not done already
1440  if (!m_caloEntrance.get())
1441  {
1442  m_caloEntrance.set(m_extrapolator->trackingGeometry()->trackingVolume(m_caloEntranceName));
1443  if(!m_caloEntrance.get())
1444  ATH_MSG_INFO("CaloEntrance not found ");
1445  else
1446  ATH_MSG_INFO("CaloEntrance found ");
1447  }
1448 
1449  ATH_MSG_DEBUG( "[ fastCaloSim transport ] after calo entrance ");
1450 
1451  std::unique_ptr<const Trk::TrackParameters> caloEntry = nullptr;
1452 
1453  if(m_caloEntrance.get() && m_caloEntrance.get()->inside(pos,0.001) && !m_extrapolator->trackingGeometry()->atVolumeBoundary(pos,m_caloEntrance.get(),0.001))
1454  {
1455  std::vector<Trk::HitInfo>* dummyHitVector = nullptr;
1456  if (charge == 0) {
1457  caloEntry =
1458  m_extrapolator->transportNeutralsWithPathLimit(inputPar,
1459  pathLim,
1460  timeLim,
1461  Trk::alongMomentum,
1462  pHypothesis,
1463  dummyHitVector,
1464  nextGeoID,
1465  m_caloEntrance.get());
1466  } else {
1467  caloEntry = m_extrapolator->extrapolateWithPathLimit(inputPar,
1468  pathLim,
1469  timeLim,
1470  Trk::alongMomentum,
1471  pHypothesis,
1472  dummyHitVector,
1473  nextGeoID,
1474  m_caloEntrance.get());
1475  }
1476  } else{
1477  caloEntry = inputPar.uniqueClone();
1478  }
1479 
1480  ATH_MSG_DEBUG( "[ fastCaloSim transport ] after calo caloEntry ");
1481 
1482  if(caloEntry)
1483  {
1484  std::unique_ptr<const Trk::TrackParameters> eParameters = nullptr;
1485 
1486  // save Calo entry hit (fallback info)
1487  hitVector->push_back(Trk::HitInfo(caloEntry->uniqueClone(),timeLim.time,nextGeoID,0.));
1488 
1489  ATH_MSG_DEBUG( "[ fastCaloSim transport ] starting Calo transport from position eta="<<caloEntry->position().eta()<<" phi="<<caloEntry->position().phi()<<" d="<<caloEntry->position().mag() );
1490 
1491  if (charge == 0) {
1492  eParameters =
1493  m_extrapolator->transportNeutralsWithPathLimit(*caloEntry,
1494  pathLim,
1495  timeLim,
1496  Trk::alongMomentum,
1497  pHypothesis,
1498  hitVector,
1499  nextGeoID);
1500  } else {
1501  eParameters = m_extrapolator->extrapolateWithPathLimit(*caloEntry,
1502  pathLim,
1503  timeLim,
1504  Trk::alongMomentum,
1505  pHypothesis,
1506  hitVector,
1507  nextGeoID);
1508  }
1509  // save Calo exit hit (fallback info)
1510  if (eParameters) hitVector->push_back(Trk::HitInfo(std::move(eParameters),timeLim.time,nextGeoID,0.));
1511  //delete eParameters; // HitInfo took ownership
1512  }
1513 
1514  if(msgLvl(MSG::DEBUG))
1515  {
1516  std::vector<Trk::HitInfo>::iterator it = hitVector->begin();
1517  while (it < hitVector->end() )
1518  {
1519  int sample=(*it).detID;
1520  Amg::Vector3D hitPos = (*it).trackParms->position();
1521  ATH_MSG_DEBUG(" HIT: layer="<<sample<<" sample="<<sample-3000<<" eta="<<hitPos.eta()<<" phi="<<hitPos.phi()<<" d="<<hitPos.mag());
1522  ++it;
1523  }
1524  }
1525 
1526  return hitVector;
1527 } //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 519 of file ISF_HitAnalysis.cxx.

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

◆ updateMetaData()

StatusCode ISF_HitAnalysis::updateMetaData ( IOVSVC_CALLBACK_ARGS  )

Definition at line 79 of file ISF_HitAnalysis.cxx.

80 {
81  ATH_MSG_INFO( "Updating the Sim+Digi MetaData" );
82 
83  // Reset the internal settings:
84  bool run_update = false;
85 
86  // Check what kind of keys we got. In principle the function should only
87  // receive the "/Digitization/Parameters" and "/Simulation/Parameters" key.
88  ATH_MSG_DEBUG("Update called with " <<I<< " folder " << keys.size() << " keys:");
89  std::list< std::string >::const_iterator itr = keys.begin();
90  std::list< std::string >::const_iterator end = keys.end();
91  for( ; itr != end; ++itr )
92  {
93  if( *itr == m_MC_DIGI_PARAM ) run_update = true;
94  if( *itr == m_MC_SIM_PARAM ) run_update = true;
95  }
96  // If that's not the key that we received after all, let's just return
97  // silently...
98  if( ! run_update ) return StatusCode::SUCCESS;
99 
100  const AthenaAttributeList* simParam;
101  if( detStore()->retrieve( simParam, m_MC_SIM_PARAM ).isFailure() )
102  {
103  ATH_MSG_WARNING("Retrieving MC SIM metadata failed");
104  }
105  else
106  {
107  AthenaAttributeList::const_iterator attr_itr = simParam->begin();
108  AthenaAttributeList::const_iterator attr_end = simParam->end();
109  for( ; attr_itr != attr_end; ++attr_itr )
110  {
111  std::stringstream outstr;
112  attr_itr->toOutputStream(outstr);
113  ATH_MSG_INFO("MetaData: " << outstr.str());
114  }
115  }
116 
117  return StatusCode::SUCCESS;
118 }

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

◆ m_CaloBoundaryR

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

Definition at line 116 of file ISF_HitAnalysis.h.

◆ m_CaloBoundaryZ

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

Definition at line 117 of file ISF_HitAnalysis.h.

◆ m_caloEntrance

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

The new Extrapolator setup.

Definition at line 240 of file ISF_HitAnalysis.h.

◆ m_caloEntranceName

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

Definition at line 113 of file ISF_HitAnalysis.h.

◆ m_calomargin

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

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

◆ m_cell_energy

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

Definition at line 170 of file ISF_HitAnalysis.h.

◆ m_cell_identifier

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

Definition at line 169 of file ISF_HitAnalysis.h.

◆ m_cell_sampling

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

Definition at line 171 of file ISF_HitAnalysis.h.

◆ m_cluster_cellID

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

Definition at line 166 of file ISF_HitAnalysis.h.

◆ m_cluster_energy

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

Definition at line 162 of file ISF_HitAnalysis.h.

◆ m_cluster_eta

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

Definition at line 163 of file ISF_HitAnalysis.h.

◆ m_cluster_phi

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

Definition at line 164 of file ISF_HitAnalysis.h.

◆ m_cluster_size

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

Definition at line 165 of file ISF_HitAnalysis.h.

◆ m_d_calo_surf

double ISF_HitAnalysis::m_d_calo_surf {}
private

Definition at line 196 of file ISF_HitAnalysis.h.

◆ m_dCalo

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

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

◆ m_doAllCells

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

Definition at line 120 of file ISF_HitAnalysis.h.

◆ m_doClusterInfo

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

Definition at line 121 of file ISF_HitAnalysis.h.

◆ m_doG4Hits

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

Definition at line 124 of file ISF_HitAnalysis.h.

◆ m_doLayers

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

Definition at line 122 of file ISF_HitAnalysis.h.

◆ m_doLayerSums

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

Definition at line 123 of file ISF_HitAnalysis.h.

◆ m_eta_calo_surf

double ISF_HitAnalysis::m_eta_calo_surf {}
private

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

◆ m_FastCaloSimCaloExtrapolation

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

The FastCaloSimCaloExtrapolation tool.

Definition at line 115 of file ISF_HitAnalysis.h.

◆ m_final_cell_energy

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

Definition at line 188 of file ISF_HitAnalysis.h.

◆ m_final_g4hit_energy

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

Definition at line 190 of file ISF_HitAnalysis.h.

◆ m_final_hit_energy

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

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

◆ m_g4hit_cellidentifier

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

Definition at line 176 of file ISF_HitAnalysis.h.

◆ m_g4hit_energy

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

Definition at line 173 of file ISF_HitAnalysis.h.

◆ m_g4hit_identifier

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

Definition at line 175 of file ISF_HitAnalysis.h.

◆ m_g4hit_sampling

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

Definition at line 178 of file ISF_HitAnalysis.h.

◆ m_g4hit_samplingfraction

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

Definition at line 177 of file ISF_HitAnalysis.h.

◆ m_g4hit_time

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

Definition at line 174 of file ISF_HitAnalysis.h.

◆ m_geoFileName

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

Definition at line 107 of file ISF_HitAnalysis.h.

◆ m_geoModel

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

Definition at line 86 of file ISF_HitAnalysis.h.

◆ m_hit_cellidentifier

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

Definition at line 145 of file ISF_HitAnalysis.h.

◆ m_hit_energy

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

Definition at line 142 of file ISF_HitAnalysis.h.

◆ m_hit_identifier

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

Definition at line 144 of file ISF_HitAnalysis.h.

◆ m_hit_sampling

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

Definition at line 151 of file ISF_HitAnalysis.h.

◆ m_hit_samplingfraction

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

Definition at line 152 of file ISF_HitAnalysis.h.

◆ m_hit_time

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

Definition at line 143 of file ISF_HitAnalysis.h.

◆ m_hit_x

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

Simple variables by Ketevi.

Definition at line 139 of file ISF_HitAnalysis.h.

◆ m_hit_y

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

Definition at line 140 of file ISF_HitAnalysis.h.

◆ m_hit_z

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

Definition at line 141 of file ISF_HitAnalysis.h.

◆ m_islarbarrel

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

Definition at line 146 of file ISF_HitAnalysis.h.

◆ m_islarendcap

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

Definition at line 147 of file ISF_HitAnalysis.h.

◆ m_islarfcal

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

Definition at line 149 of file ISF_HitAnalysis.h.

◆ m_islarhec

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

Definition at line 148 of file ISF_HitAnalysis.h.

◆ m_istile

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

Definition at line 150 of file ISF_HitAnalysis.h.

◆ m_larEmID

const LArEM_ID* ISF_HitAnalysis::m_larEmID {}
private

Definition at line 129 of file ISF_HitAnalysis.h.

◆ m_larFcalID

const LArFCAL_ID* ISF_HitAnalysis::m_larFcalID {}
private

Definition at line 130 of file ISF_HitAnalysis.h.

◆ m_larHecID

const LArHEC_ID* ISF_HitAnalysis::m_larHecID {}
private

Definition at line 131 of file ISF_HitAnalysis.h.

◆ m_layerCaloOK

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

Definition at line 248 of file ISF_HitAnalysis.h.

◆ m_layercells

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

Definition at line 182 of file ISF_HitAnalysis.h.

◆ m_letaCalo

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

Definition at line 249 of file ISF_HitAnalysis.h.

◆ m_lphiCalo

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

Definition at line 250 of file ISF_HitAnalysis.h.

◆ m_lrCalo

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

Definition at line 251 of file ISF_HitAnalysis.h.

◆ m_lzCalo

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

Definition at line 252 of file ISF_HitAnalysis.h.

◆ m_MC_DIGI_PARAM

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

Definition at line 126 of file ISF_HitAnalysis.h.

◆ m_MC_SIM_PARAM

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

Definition at line 127 of file ISF_HitAnalysis.h.

◆ m_metadataTreeName

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

Definition at line 106 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_E

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

Definition at line 230 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_pdg

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

Definition at line 237 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_px

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

Definition at line 231 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_py

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

Definition at line 232 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_pz

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

Definition at line 233 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_x

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

Definition at line 234 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_y

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

Definition at line 235 of file ISF_HitAnalysis.h.

◆ m_MuonEntryLayer_z

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

Definition at line 236 of file ISF_HitAnalysis.h.

◆ m_newTTC_Angle3D

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

Definition at line 227 of file ISF_HitAnalysis.h.

◆ m_newTTC_AngleEta

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

Definition at line 228 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_detaBorder

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

Definition at line 215 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_eta

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

Definition at line 211 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_OK

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

Definition at line 216 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_phi

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

Definition at line 212 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_r

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

Definition at line 213 of file ISF_HitAnalysis.h.

◆ m_newTTC_back_z

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

Definition at line 214 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_detaBorder

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

Definition at line 209 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_eta

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

Definition at line 205 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_OK

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

Definition at line 210 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_phi

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

Definition at line 206 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_r

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

Definition at line 207 of file ISF_HitAnalysis.h.

◆ m_newTTC_entrance_z

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

Definition at line 208 of file ISF_HitAnalysis.h.

◆ m_newTTC_IDCaloBoundary_eta

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

Definition at line 223 of file ISF_HitAnalysis.h.

◆ m_newTTC_IDCaloBoundary_phi

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

Definition at line 224 of file ISF_HitAnalysis.h.

◆ m_newTTC_IDCaloBoundary_r

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

Definition at line 225 of file ISF_HitAnalysis.h.

◆ m_newTTC_IDCaloBoundary_z

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

Definition at line 226 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_detaBorder

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

Definition at line 221 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_eta

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

Definition at line 217 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_OK

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

Definition at line 222 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_phi

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

Definition at line 218 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_r

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

Definition at line 219 of file ISF_HitAnalysis.h.

◆ m_newTTC_mid_z

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

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

◆ m_ntupleFileName

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

Definition at line 104 of file ISF_HitAnalysis.h.

◆ m_ntupleTreeName

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

Definition at line 105 of file ISF_HitAnalysis.h.

◆ m_oneeventcells

FCS_matchedcellvector* ISF_HitAnalysis::m_oneeventcells = nullptr
private

Definition at line 181 of file ISF_HitAnalysis.h.

◆ m_particleDataTable

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

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

◆ m_pdgid

int ISF_HitAnalysis::m_pdgid {}
private

Definition at line 203 of file ISF_HitAnalysis.h.

◆ m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis ISF_HitAnalysis::m_pdgToParticleHypothesis
private

Definition at line 242 of file ISF_HitAnalysis.h.

◆ m_phi_calo_surf

double ISF_HitAnalysis::m_phi_calo_surf {}
private

Definition at line 195 of file ISF_HitAnalysis.h.

◆ m_ptruth_e

double ISF_HitAnalysis::m_ptruth_e {}
private

Definition at line 199 of file ISF_HitAnalysis.h.

◆ m_ptruth_et

double ISF_HitAnalysis::m_ptruth_et {}
private

Definition at line 200 of file ISF_HitAnalysis.h.

◆ m_ptruth_eta

double ISF_HitAnalysis::m_ptruth_eta {}
private

Definition at line 197 of file ISF_HitAnalysis.h.

◆ m_ptruth_p

double ISF_HitAnalysis::m_ptruth_p {}
private

Definition at line 202 of file ISF_HitAnalysis.h.

◆ m_ptruth_phi

double ISF_HitAnalysis::m_ptruth_phi {}
private

Definition at line 198 of file ISF_HitAnalysis.h.

◆ m_ptruth_pt

double ISF_HitAnalysis::m_ptruth_pt {}
private

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

◆ m_saveAllBranches

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

Definition at line 119 of file ISF_HitAnalysis.h.

◆ m_surfacelist

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

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

◆ m_tileCabling

const TileCablingService* ISF_HitAnalysis::m_tileCabling {}
private

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

◆ m_tileHWID

const TileHWID* ISF_HitAnalysis::m_tileHWID {}
private

Definition at line 133 of file ISF_HitAnalysis.h.

◆ m_tileID

const TileID* ISF_HitAnalysis::m_tileID {}
private

Definition at line 132 of file ISF_HitAnalysis.h.

◆ m_tileMgr

const TileDetDescrManager* ISF_HitAnalysis::m_tileMgr {}
private

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

◆ m_TimingCut

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

Definition at line 125 of file ISF_HitAnalysis.h.

◆ m_total_cell_e

Float_t ISF_HitAnalysis::m_total_cell_e {}
private

Definition at line 184 of file ISF_HitAnalysis.h.

◆ m_total_g4hit_e

Float_t ISF_HitAnalysis::m_total_g4hit_e {}
private

Definition at line 186 of file ISF_HitAnalysis.h.

◆ m_total_hit_e

Float_t ISF_HitAnalysis::m_total_hit_e {}
private

Definition at line 185 of file ISF_HitAnalysis.h.

◆ m_tree

TTree* ISF_HitAnalysis::m_tree {}
private

Definition at line 192 of file ISF_HitAnalysis.h.

◆ m_truth_barcode

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

Definition at line 159 of file ISF_HitAnalysis.h.

◆ m_truth_energy

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

Definition at line 154 of file ISF_HitAnalysis.h.

◆ m_truth_pdg

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

Definition at line 158 of file ISF_HitAnalysis.h.

◆ m_truth_px

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

Definition at line 155 of file ISF_HitAnalysis.h.

◆ m_truth_py

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

Definition at line 156 of file ISF_HitAnalysis.h.

◆ m_truth_pz

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

Definition at line 157 of file ISF_HitAnalysis.h.

◆ m_truth_vtxbarcode

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

Definition at line 160 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 77 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:160
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
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
ISF_HitAnalysis::m_MuonEntryLayer_E
std::vector< float > * m_MuonEntryLayer_E
Definition: ISF_HitAnalysis.h:230
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ISF_HitAnalysis::m_MC_DIGI_PARAM
StringProperty m_MC_DIGI_PARAM
Definition: ISF_HitAnalysis.h:126
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:242
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:271
ISF_HitAnalysis::m_newTTC_back_detaBorder
std::vector< std::vector< float > > * m_newTTC_back_detaBorder
Definition: ISF_HitAnalysis.h:215
ISF_HitAnalysis::m_truth_pz
std::vector< float > * m_truth_pz
Definition: ISF_HitAnalysis.h:157
ISF_HitAnalysis::m_FastCaloSimCaloExtrapolation
PublicToolHandle< IFastCaloSimCaloExtrapolation > m_FastCaloSimCaloExtrapolation
The FastCaloSimCaloExtrapolation tool.
Definition: ISF_HitAnalysis.h:115
xAOD::CaloCluster_v1::cell_begin
const_cell_iterator cell_begin() const
Iterator of the underlying CaloClusterCellLink (const version)
Definition: CaloCluster_v1.h:812
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:205
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:189
ISF_HitAnalysis::m_cluster_phi
std::vector< float > * m_cluster_phi
Definition: ISF_HitAnalysis.h:164
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:170
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ISF_HitAnalysis::m_cluster_energy
std::vector< float > * m_cluster_energy
Definition: ISF_HitAnalysis.h:162
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ISF_HitAnalysis::m_CaloBoundaryZ
DoubleProperty m_CaloBoundaryZ
Definition: ISF_HitAnalysis.h:117
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:227
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:219
ISF_HitAnalysis::m_newTTC_entrance_r
std::vector< std::vector< float > > * m_newTTC_entrance_r
Definition: ISF_HitAnalysis.h:207
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:132
ISF_HitAnalysis::m_oneeventcells
FCS_matchedcellvector * m_oneeventcells
Definition: ISF_HitAnalysis.h:181
ISF_HitAnalysis::m_TimingCut
IntegerProperty m_TimingCut
Definition: ISF_HitAnalysis.h:125
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:233
ISF_HitAnalysis::m_MC_SIM_PARAM
StringProperty m_MC_SIM_PARAM
Definition: ISF_HitAnalysis.h:127
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:159
hitVector
std::vector< FPGATrackSimHit > hitVector
Definition: FPGATrackSimCluster.h:22
ISF_HitAnalysis::MAX_LAYER
static const int MAX_LAYER
Definition: ISF_HitAnalysis.h:77
AtlasHitsVector
Definition: AtlasHitsVector.h:33
skel.it
it
Definition: skel.GENtoEVGEN.py:396
ISF_HitAnalysis::m_caloEntranceName
StringProperty m_caloEntranceName
Definition: ISF_HitAnalysis.h:113
ISF_HitAnalysis::m_islarendcap
std::vector< bool > * m_islarendcap
Definition: ISF_HitAnalysis.h:147
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_eta
std::vector< float > * m_newTTC_IDCaloBoundary_eta
Definition: ISF_HitAnalysis.h:223
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:152
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:188
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
ISF_HitAnalysis::m_cell_sampling
std::vector< int > * m_cell_sampling
Definition: ISF_HitAnalysis.h:171
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_z
std::vector< float > * m_newTTC_IDCaloBoundary_z
Definition: ISF_HitAnalysis.h:226
ISF_HitAnalysis::m_hit_x
std::vector< float > * m_hit_x
Simple variables by Ketevi.
Definition: ISF_HitAnalysis.h:139
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:151
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:144
ISF_HitAnalysis::m_MuonEntryLayer_x
std::vector< float > * m_MuonEntryLayer_x
Definition: ISF_HitAnalysis.h:234
ISF_HitAnalysis::m_islarbarrel
std::vector< bool > * m_islarbarrel
Definition: ISF_HitAnalysis.h:146
ISF_HitAnalysis::m_istile
std::vector< bool > * m_istile
Definition: ISF_HitAnalysis.h:150
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:175
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:210
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
ISF_HitAnalysis::m_newTTC_mid_z
std::vector< std::vector< float > > * m_newTTC_mid_z
Definition: ISF_HitAnalysis.h:220
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:225
ReadCellNoiseFromCool.tile
tile
Definition: ReadCellNoiseFromCool.py:92
ISF_HitAnalysis::m_tileHWID
const TileHWID * m_tileHWID
Definition: ISF_HitAnalysis.h:133
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
ISF_HitAnalysis::m_hit_energy
std::vector< float > * m_hit_energy
Definition: ISF_HitAnalysis.h:142
Trk::ParticleHypothesis
ParticleHypothesis
Definition: ParticleHypothesis.h:25
ISF_HitAnalysis::m_cluster_size
std::vector< unsigned > * m_cluster_size
Definition: ISF_HitAnalysis.h:165
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:206
ISF_HitAnalysis::m_total_g4hit_e
Float_t m_total_g4hit_e
Definition: ISF_HitAnalysis.h:186
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition: CaloDetDescrElement.cxx:64
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
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:182
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:163
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:140
FCS_matchedcell
Definition: FCS_Cell.h:59
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:113
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
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_phi
std::vector< float > * m_newTTC_IDCaloBoundary_phi
Definition: ISF_HitAnalysis.h:224
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:178
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:184
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:237
ISF_HitAnalysis::m_newTTC_back_z
std::vector< std::vector< float > > * m_newTTC_back_z
Definition: ISF_HitAnalysis.h:214
jobOptions.ParticleID
ParticleID
Definition: jobOptions.decayer.py:85
ISF_HitAnalysis::m_larFcalID
const LArFCAL_ID * m_larFcalID
Definition: ISF_HitAnalysis.h:130
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FCS_cell::center_z
float center_z
Definition: FCS_Cell.h:37
AthenaAttributeList
An AttributeList represents a logical row of attributes in a metadata table. The name and type of eac...
Definition: PersistentDataModel/PersistentDataModel/AthenaAttributeList.h:45
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:190
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:108
ISF_HitAnalysis::m_g4hit_cellidentifier
std::vector< Long64_t > * m_g4hit_cellidentifier
Definition: ISF_HitAnalysis.h:176
ISF_HitAnalysis::m_tileCabling
const TileCablingService * m_tileCabling
Definition: ISF_HitAnalysis.h:134
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:211
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:97
ISF_HitAnalysis::m_newTTC_entrance_detaBorder
std::vector< std::vector< float > > * m_newTTC_entrance_detaBorder
Definition: ISF_HitAnalysis.h:209
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
FCS_matchedcellvector::size
unsigned int size()
Definition: FCS_Cell.h:79
xAOD::CaloCluster_v1::getCellLinks
const CaloClusterCellLink * getCellLinks() const
Get a pointer to the CaloClusterCellLink object (const version)
Definition: CaloCluster_v1.cxx:905
ISF_HitAnalysis::m_newTTC_back_phi
std::vector< std::vector< float > > * m_newTTC_back_phi
Definition: ISF_HitAnalysis.h:212
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
ISF_HitAnalysis::m_MuonEntryLayer_y
std::vector< float > * m_MuonEntryLayer_y
Definition: ISF_HitAnalysis.h:235
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:169
LArHit::cellID
Identifier cellID() const
Definition: LArHit.h:108
xAOD::CaloCluster_v1::UNCALIBRATED
@ UNCALIBRATED
Definition: CaloCluster_v1.h:306
ISF_HitAnalysis::m_total_hit_e
Float_t m_total_hit_e
Definition: ISF_HitAnalysis.h:185
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:228
ISF_HitAnalysis::m_islarfcal
std::vector< bool > * m_islarfcal
Definition: ISF_HitAnalysis.h:149
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:124
ISF_HitAnalysis::m_CaloBoundaryR
DoubleProperty m_CaloBoundaryR
Definition: ISF_HitAnalysis.h:116
ISF_HitAnalysis::m_newTTC_entrance_z
std::vector< std::vector< float > > * m_newTTC_entrance_z
Definition: ISF_HitAnalysis.h:208
charge
double charge(const T &p)
Definition: AtlasPID.h:756
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:141
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:228
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:236
TrackRecord
Definition: TrackRecord.h:12
ISF_HitAnalysis::m_fSamplKey
SG::ReadCondHandleKey< ILArfSampl > m_fSamplKey
Definition: ISF_HitAnalysis.h:92
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:192
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:154
ISF_HitAnalysis::m_hit_cellidentifier
std::vector< Long64_t > * m_hit_cellidentifier
Definition: ISF_HitAnalysis.h:145
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:231
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:218
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:111
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:222
ISF_HitAnalysis::m_cluster_cellID
std::vector< std::vector< Long64_t > > * m_cluster_cellID
Definition: ISF_HitAnalysis.h:166
DEBUG
#define DEBUG
Definition: page_access.h:11
xAOD::CaloCluster_v1::cell_end
const_cell_iterator cell_end() const
Definition: CaloCluster_v1.h:813
ISF_HitAnalysis::m_hit_time
std::vector< float > * m_hit_time
Definition: ISF_HitAnalysis.h:143
ISF_HitAnalysis::m_tileMgr
const TileDetDescrManager * m_tileMgr
Definition: ISF_HitAnalysis.h:136
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:623
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:216
ISF_HitAnalysis::m_islarhec
std::vector< bool > * m_islarhec
Definition: ISF_HitAnalysis.h:148
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:158
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:221
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:213
I
#define I(x, y, z)
Definition: MD5.cxx:116
GetEnergy
int GetEnergy()
Definition: GetEnergy.cxx:81
ISF_HitAnalysis::m_larEmID
const LArEM_ID * m_larEmID
Definition: ISF_HitAnalysis.h:129
ISF_HitAnalysis::m_surfacelist
std::vector< CaloCell_ID_FCS::CaloSample > m_surfacelist
Definition: ISF_HitAnalysis.h:246
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:173
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:174
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:240
ISF_HitAnalysis::m_truth_py
std::vector< float > * m_truth_py
Definition: ISF_HitAnalysis.h:156
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
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
ISF_HitAnalysis::m_truth_px
std::vector< float > * m_truth_px
Definition: ISF_HitAnalysis.h:155
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:131
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:217
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:177
ServiceHandle< ICondSvc >
ISF_HitAnalysis::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: ISF_HitAnalysis.h:88
ISF_HitAnalysis::m_MuonEntryLayer_py
std::vector< float > * m_MuonEntryLayer_py
Definition: ISF_HitAnalysis.h:232
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Dec 22 2024 21:34:57 for ATLAS Offline Software by   doxygen 1.8.18