ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
TauShotFinder Class Reference

#include <TauShotFinder.h>

Inheritance diagram for TauShotFinder:
Collaboration diagram for TauShotFinder:

Classes

struct  ptSort
 

Public Member Functions

 ASG_TOOL_CLASS2 (TauShotFinder, TauRecToolBase, ITauToolBase)
 
 TauShotFinder (const std::string &name)
 
virtual ~TauShotFinder ()=default
 
virtual StatusCode initialize () override
 Tool initializer. More...
 
virtual StatusCode executeShotFinder (xAOD::TauJet &pTau, xAOD::CaloClusterContainer &tauShotCaloClusContainer, xAOD::PFOContainer &tauShotPFOContainer) const override
 
virtual StatusCode eventInitialize () override
 Event initializer - called at the beginning of each event. More...
 
virtual StatusCode execute (xAOD::TauJet &pTau) const override
 Execute - called for each tau candidate. More...
 
virtual StatusCode executePi0CreateROI (xAOD::TauJet &pTau, CaloConstCellContainer &caloCellContainer, boost::dynamic_bitset<> &map) const override
 
virtual StatusCode executeVertexFinder (xAOD::TauJet &pTau, const xAOD::VertexContainer *vertexContainer=nullptr) const override
 
virtual StatusCode executeTrackFinder (xAOD::TauJet &pTau, xAOD::TauTrackContainer &tauTrackContainer) const override
 
virtual StatusCode executeTrackClassifier (xAOD::TauJet &pTau, xAOD::TauTrackContainer &tauTrackContainer) const override
 
virtual StatusCode executePi0ClusterCreator (xAOD::TauJet &pTau, xAOD::PFOContainer &neutralPFOContainer, xAOD::PFOContainer &hadronicPFOContainer, const xAOD::CaloClusterContainer &pCaloClusterContainer) const override
 
virtual StatusCode executeVertexVariables (xAOD::TauJet &pTau, xAOD::VertexContainer &vertexContainer) const override
 
virtual StatusCode executePi0ClusterScaler (xAOD::TauJet &pTau, xAOD::PFOContainer &neutralPFOContainer, xAOD::PFOContainer &chargedPFOContainer) const override
 
virtual StatusCode executePi0nPFO (xAOD::TauJet &pTau, xAOD::PFOContainer &neutralPFOContainer) const override
 
virtual StatusCode executePanTau (xAOD::TauJet &pTau, xAOD::ParticleContainer &particleContainer, xAOD::PFOContainer &neutralPFOContainer) const override
 
virtual StatusCode eventFinalize () override
 Event finalizer - called at the end of each event. More...
 
virtual StatusCode finalize () override
 Finalizer. More...
 
std::string find_file (const std::string &fname) const
 
virtual StatusCode readConfig () override
 
virtual void print () const
 Print the state of the tool. 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 sysInitialize () override
 Perform system initialization for an algorithm. 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, V, H > &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
 

Protected Member Functions

bool inTrigger () const
 
bool inAOD () const
 
bool inEleRM () const
 
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...
 

Protected Attributes

Gaudi::Property< bool > m_in_trigger {this, "inTrigger", false, "Indicate if the tool is running on trigger"}
 
Gaudi::Property< bool > m_in_AOD {this, "inAOD", false, "Indicate if the tool is running on AOD"}
 
Gaudi::Property< bool > m_in_EleRM {this, "inEleRM", false, "Indicate if the tool is running on EleRM routine"}
 
Gaudi::Property< std::string > m_tauRecToolsTag {this, "calibFolder", "tauRecTools/R22_preprod", "CVMFS path to the tau calibration folder"}
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode selectCells (const xAOD::TauJet &tau, const CaloCellContainer &cellContainer, const CaloDetDescrManager *detMgr, std::vector< const CaloCell * > &cells) const
 Apply preselection of the cells Cells within dR < 0.4, in EM1, and pt > 100 MeV are selected. More...
 
StatusCode selectSeedCells (const xAOD::TauJet &tau, const CaloCellContainer &cellContainer, const CaloDetDescrManager *detMgr, std::vector< const CaloCell * > &seedCells) const
 Select the seed cells used to construct the shot Cells must sastisfy: More...
 
bool isPhiNeighbour (IdentifierHash cell1Hash, IdentifierHash cell2Hash) const
 Check whether two cells are neighbours in the phi direction. More...
 
const CaloCell * getPhiNeighbour (const CaloCell &seedCell, const std::vector< const CaloCell * > &seedCells) const
 Get the hottest neighbour cell in the phi direction. More...
 
std::vector< const CaloCell * > getEtaNeighbours (const CaloCell &cell, const CaloCellContainer &cellContainer, int maxDepth) const
 Get neighbour cells in the eta direction. More...
 
void addEtaNeighbours (const CaloCell &cell, const CaloCellContainer &cellContainer, std::vector< const CaloCell * > &cells, int depth, int maxDepth, bool next) const
 Get neighbour cells in the eta direction. More...
 
xAOD::CaloCluster * createShotCluster (const CaloCell *cell, const CaloCell *phiNeighCell, const CaloCellContainer &cellContainer, xAOD::CaloClusterContainer *clusterContainer) const
 Create the shot cluster Shot cluster contains 5x1 cells from the seed cell and hottestneighbour cell in the phi direction. More...
 
int getEtaBin (float eta) const
 Get eta bin. More...
 
int getNPhotons (float eta, float energy) const
 Get NPhotons in shot. More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

Gaudi::Property< int > m_nCellsInEta {this, "NCellsInEta"}
 
Gaudi::Property< std::vector< float > > m_minPtCut {this, "MinPtCut"}
 
Gaudi::Property< std::vector< float > > m_doubleShotCut {this, "AutoDoubleShotCut"}
 
Gaudi::Property< bool > m_removeElectronCells {this, "RemoveElectronCells", false}
 
SG::ReadHandleKey< CaloCellContainer > m_caloCellInputContainer {this,"Key_caloCellInputContainer", "AllCalo", "input vertex container key"}
 
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}
 
ToolHandle< IHadronicCalibrationTool > m_caloWeightTool {this, "CaloWeightTool", "H1WeightToolCSC12Generic"}
 
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_removedClusterInputContainer {this,"Key_RemovedClusterInputContainer", "", "input removed cluster key"}
 
const CaloCell_ID * m_calo_id = nullptr
 calo cell navigation More...
 
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 30 of file TauShotFinder.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TauShotFinder()

TauShotFinder::TauShotFinder ( const std::string &  name)

Definition at line 16 of file TauShotFinder.cxx.

16  :
17  TauRecToolBase(name) {}

◆ ~TauShotFinder()

virtual TauShotFinder::~TauShotFinder ( )
virtualdefault

Member Function Documentation

◆ addEtaNeighbours()

void TauShotFinder::addEtaNeighbours ( const CaloCell &  cell,
const CaloCellContainer &  cellContainer,
std::vector< const CaloCell * > &  cells,
int  depth,
int  maxDepth,
bool  next 
) const
private

Get neighbour cells in the eta direction.

Definition at line 340 of file TauShotFinder.cxx.

345  {
346  ++depth;
347 
348  if (depth > maxDepth) return;
349 
350  const IdentifierHash cellHash = cell.caloDDE()->calo_hash();
351 
352  std::vector<IdentifierHash> neigHashes;
353  if (next) {
354  m_calo_id->get_neighbours(cellHash,LArNeighbours::nextInEta,neigHashes);
355  }
356  else {
357  m_calo_id->get_neighbours(cellHash,LArNeighbours::prevInEta,neigHashes);
358  }
359 
360  for (const IdentifierHash& hash : neigHashes) {
361  const CaloCell* newCell = cellContainer.findCell(hash);
362 
363  if (!newCell) continue;
364 
365  cells.push_back(newCell);
366  this->addEtaNeighbours(*newCell, cellContainer, cells, depth, maxDepth, next);
367 
368  if (neigHashes.size() > 1) {
369  ATH_MSG_DEBUG(cellHash << " has " << neigHashes.size() << " neighbours in the eta direction !");
370  break;
371  }
372  }
373 }

◆ ASG_TOOL_CLASS2()

TauShotFinder::ASG_TOOL_CLASS2 ( TauShotFinder  ,
TauRecToolBase  ,
ITauToolBase   
)

◆ createShotCluster()

xAOD::CaloCluster * TauShotFinder::createShotCluster ( const CaloCell *  cell,
const CaloCell *  phiNeighCell,
const CaloCellContainer &  cellContainer,
xAOD::CaloClusterContainer *  clusterContainer 
) const
private

Create the shot cluster Shot cluster contains 5x1 cells from the seed cell and hottestneighbour cell in the phi direction.

Definition at line 377 of file TauShotFinder.cxx.

380  {
381 
382  xAOD::CaloCluster* shotCluster = CaloClusterStoreHelper::makeCluster(clusterContainer,&cellContainer);
383 
384  int maxDepth = (m_nCellsInEta - 1) / 2;
385 
386  std::vector<const CaloCell*> windowNeighbours = this->getEtaNeighbours(*cell, cellContainer, maxDepth);
387  if (phiNeigCell) {
388  std::vector<const CaloCell*> mergeCells = this->getEtaNeighbours(*phiNeigCell, cellContainer, maxDepth);
389  windowNeighbours.push_back(phiNeigCell);
390  windowNeighbours.insert(windowNeighbours.end(), mergeCells.begin(), mergeCells.end());
391  }
392 
393  shotCluster->getOwnCellLinks()->reserve(windowNeighbours.size()+1);
394  const IdentifierHash seedHash = cell->caloDDE()->calo_hash();
395  shotCluster->addCell(cellContainer.findIndex(seedHash), 1.);
396 
397  for (const CaloCell* cell : windowNeighbours) {
398  shotCluster->addCell(cellContainer.findIndex(cell->caloDDE()->calo_hash()), 1.0);
399  }
400 
401  CaloClusterKineHelper::calculateKine(shotCluster,true,true);
402 
403  return shotCluster;
404 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

◆ eventFinalize()

StatusCode TauRecToolBase::eventFinalize ( )
overridevirtualinherited

Event finalizer - called at the end of each event.

Implements ITauToolBase.

Definition at line 202 of file TauRecToolBase.cxx.

202  {
203  return StatusCode::SUCCESS;
204 }

◆ eventInitialize()

StatusCode TauRecToolBase::eventInitialize ( )
overridevirtualinherited

Event initializer - called at the beginning of each event.

Implements ITauToolBase.

Definition at line 133 of file TauRecToolBase.cxx.

133  {
134  return StatusCode::SUCCESS;
135 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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 TauRecToolBase::execute ( xAOD::TauJet &  pTau) const
overridevirtualinherited

Execute - called for each tau candidate.

Implements ITauToolBase.

Reimplemented in TauDecayModeNNClassifier, TauCombinedTES, MvaTESVariableDecorator, MvaTESEvaluator, TauWPDecorator, TauAxisSetter, TauGNNEvaluator, TauEleOverlapChecker, TauJetRNNEvaluator, TauCalibrateLC, TauClusterFinder, TauSubstructureVariables, TauVertexedClusterDecorator, TauAODSelector, TauElectronVetoVariables, JetSeedBuilder, TauCellVariables, TauCommonCalcVars, TauIDVarCalculator, and TauAODMuonRemovalTool.

Definition at line 138 of file TauRecToolBase.cxx.

138  {
139  ATH_MSG_ERROR("function not implemented");
140  return StatusCode::FAILURE;
141 }

◆ executePanTau()

StatusCode TauRecToolBase::executePanTau ( xAOD::TauJet &  pTau,
xAOD::ParticleContainer &  particleContainer,
xAOD::PFOContainer &  neutralPFOContainer 
) const
overridevirtualinherited

Implements ITauToolBase.

Reimplemented in PanTau::PanTauProcessor.

Definition at line 197 of file TauRecToolBase.cxx.

197  {
198  ATH_MSG_ERROR("function not implemented");
199  return StatusCode::FAILURE;
200 }

◆ executePi0ClusterCreator()

StatusCode TauRecToolBase::executePi0ClusterCreator ( xAOD::TauJet &  pTau,
xAOD::PFOContainer &  neutralPFOContainer,
xAOD::PFOContainer &  hadronicPFOContainer,
const xAOD::CaloClusterContainer &  pCaloClusterContainer 
) const
overridevirtualinherited

Implements ITauToolBase.

Reimplemented in TauPi0ClusterCreator.

Definition at line 175 of file TauRecToolBase.cxx.

177  {
178  ATH_MSG_ERROR("function not implemented");
179  return StatusCode::FAILURE;
180 }

◆ executePi0ClusterScaler()

StatusCode TauRecToolBase::executePi0ClusterScaler ( xAOD::TauJet &  pTau,
xAOD::PFOContainer &  neutralPFOContainer,
xAOD::PFOContainer &  chargedPFOContainer 
) const
overridevirtualinherited

Implements ITauToolBase.

Reimplemented in TauPi0ClusterScaler.

Definition at line 187 of file TauRecToolBase.cxx.

187  {
188  ATH_MSG_ERROR("function not implemented");
189  return StatusCode::FAILURE;
190 }

◆ executePi0CreateROI()

StatusCode TauRecToolBase::executePi0CreateROI ( xAOD::TauJet &  pTau,
CaloConstCellContainer &  caloCellContainer,
boost::dynamic_bitset<> &  map 
) const
overridevirtualinherited

Implements ITauToolBase.

Reimplemented in TauPi0CreateROI.

Definition at line 149 of file TauRecToolBase.cxx.

149  {
150  ATH_MSG_ERROR("function not implemented");
151  return StatusCode::FAILURE;
152 }

◆ executePi0nPFO()

StatusCode TauRecToolBase::executePi0nPFO ( xAOD::TauJet &  pTau,
xAOD::PFOContainer &  neutralPFOContainer 
) const
overridevirtualinherited

Implements ITauToolBase.

Reimplemented in TauPi0ScoreCalculator, and TauPi0Selector.

Definition at line 192 of file TauRecToolBase.cxx.

192  {
193  ATH_MSG_ERROR("function not implemented");
194  return StatusCode::FAILURE;
195 }

◆ executeShotFinder()

StatusCode TauShotFinder::executeShotFinder ( xAOD::TauJet &  pTau,
xAOD::CaloClusterContainer &  tauShotCaloClusContainer,
xAOD::PFOContainer &  tauShotPFOContainer 
) const
overridevirtual

Reimplemented from TauRecToolBase.

Definition at line 32 of file TauShotFinder.cxx.

33  {
34 
35  // Any tau needs to have shot PFO vectors. Set empty vectors before nTrack cut
36  std::vector<ElementLink<xAOD::PFOContainer>> empty;
37  tau.setShotPFOLinks(empty);
38 
39  // Only run on 0-5 prong taus
40  if (!tauRecTools::doPi0andShots(tau)) {
41  return StatusCode::SUCCESS;
42  }
43 
44  SG::ReadHandle<CaloCellContainer> caloCellInHandle( m_caloCellInputContainer );
45  if (!caloCellInHandle.isValid()) {
46  ATH_MSG_ERROR ("Could not retrieve HiveDataObj with key " << caloCellInHandle.key());
47  return StatusCode::FAILURE;
48  }
49  const CaloCellContainer *cellContainer = caloCellInHandle.cptr();
50 
51  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
52  const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
53  // Select seed cells:
54  // -- dR < 0.4, EM1, pt > 100
55  // -- largest pt among the neighbours in eta direction
56  // -- no other seed cell as neighbour in eta direction
57  std::vector<const CaloCell*> seedCells;
58  ATH_CHECK(selectSeedCells(tau, *cellContainer, caloDDMgr, seedCells));
59  ATH_MSG_DEBUG("seedCells.size() = " << seedCells.size());
60 
61  // Construt shot by merging neighbour cells in phi direction
62  while (!seedCells.empty()) {
63  // Find the neighbour in phi direction, and choose the one with highest pt
64  const CaloCell* cell = seedCells.front();
65  const CaloCell* phiNeigCell = getPhiNeighbour(*cell, seedCells);
66 
67  // Construct shot PFO candidate
68  xAOD::PFO* shot = new xAOD::PFO();
69  shotPFOContainer.push_back(shot);
70 
71  // -- Construct the shot cluster
72  xAOD::CaloCluster* shotCluster = createShotCluster(cell, phiNeigCell, *cellContainer, &shotClusterContainer);
73 
74  ElementLink<xAOD::CaloClusterContainer> clusElementLink;
75  clusElementLink.toContainedElement( shotClusterContainer, shotCluster );
76  shot->setClusterLink( clusElementLink );
77 
78  // -- Calculate the four momentum
79  // TODO: simplify the calculation
80  if (phiNeigCell) {
81  // interpolate position
82  double dPhi = TVector2::Phi_mpi_pi( phiNeigCell->phi() - cell->phi());
83  double ratio = phiNeigCell->pt()*m_caloWeightTool->wtCell(phiNeigCell)/(cell->pt()*m_caloWeightTool->wtCell(cell) + phiNeigCell->pt()*m_caloWeightTool->wtCell(phiNeigCell));
84  float phi = cell->phi()+dPhi*ratio;
85  float pt = cell->pt()*m_caloWeightTool->wtCell(cell)+phiNeigCell->pt()*m_caloWeightTool->wtCell(phiNeigCell);
86 
87  shot->setP4( static_cast<float>(pt), static_cast<float>(cell->eta()), static_cast<float>(phi), static_cast<float>(cell->m()));
88  }
89  else {
90  shot->setP4( static_cast<float>(cell->pt()*m_caloWeightTool->wtCell(cell)), static_cast<float>(cell->eta()), static_cast<float>(cell->phi()), static_cast<float>(cell->m()));
91  }
92 
93  // -- Set the Attribute
94  shot->setBDTPi0Score(-9999.);
95  shot->setCharge(0);
96  shot->setCenterMag(0.0);
97 
98  shot->setAttribute<int>(xAOD::PFODetails::PFOAttributes::tauShots_nCellsInEta, m_nCellsInEta);
99 
100  const IdentifierHash seedHash = cell->caloDDE()->calo_hash();
101  shot->setAttribute<int>(xAOD::PFODetails::PFOAttributes::tauShots_seedHash, seedHash);
102 
103  std::vector<std::vector<const CaloCell*>> cellBlock = TauShotVariableHelpers::getCellBlock(*shot, m_calo_id);
104 
105  float pt1 = TauShotVariableHelpers::ptWindow(cellBlock, 1, m_caloWeightTool);
106  shot->setAttribute<float>(xAOD::PFODetails::PFOAttributes::tauShots_pt1, pt1);
107 
108  float pt3 = TauShotVariableHelpers::ptWindow(cellBlock, 3, m_caloWeightTool);
109  shot->setAttribute<float>(xAOD::PFODetails::PFOAttributes::tauShots_pt3, pt3);
110 
111  float pt5 = TauShotVariableHelpers::ptWindow(cellBlock, 5, m_caloWeightTool);
112  shot->setAttribute<float>(xAOD::PFODetails::PFOAttributes::tauShots_pt5, pt5);
113 
114  int nPhotons = getNPhotons(cell->eta(), pt1);
115  shot->setAttribute<int>(xAOD::PFODetails::PFOAttributes::tauShots_nPhotons, nPhotons);
116 
117  // Add Element link to the shot PFO container
118  ElementLink<xAOD::PFOContainer> PFOElementLink;
119  PFOElementLink.toContainedElement(shotPFOContainer, shot);
120  tau.addShotPFOLink(PFOElementLink);
121 
122  // Remove used cells from list
123  auto cellIndex = std::find(seedCells.begin(), seedCells.end(), cell);
124  seedCells.erase(cellIndex);
125  if (phiNeigCell) {
126  cellIndex = std::find(seedCells.begin(), seedCells.end(), phiNeigCell);
127  seedCells.erase(cellIndex);
128  }
129  } // Loop over seed cells
130 
131  return StatusCode::SUCCESS;
132 }

◆ executeTrackClassifier()

StatusCode TauRecToolBase::executeTrackClassifier ( xAOD::TauJet &  pTau,
xAOD::TauTrackContainer &  tauTrackContainer 
) const
overridevirtualinherited

Implements ITauToolBase.

Reimplemented in tauRecTools::TauTrackRNNClassifier.

Definition at line 165 of file TauRecToolBase.cxx.

165  {
166  ATH_MSG_ERROR("function not implemented");
167  return StatusCode::FAILURE;
168 }

◆ executeTrackFinder()

StatusCode TauRecToolBase::executeTrackFinder ( xAOD::TauJet &  pTau,
xAOD::TauTrackContainer &  tauTrackContainer 
) const
overridevirtualinherited

Implements ITauToolBase.

Reimplemented in TauTrackFinder.

Definition at line 160 of file TauRecToolBase.cxx.

160  {
161  ATH_MSG_ERROR("function not implemented");
162  return StatusCode::FAILURE;
163 }

◆ executeVertexFinder()

StatusCode TauRecToolBase::executeVertexFinder ( xAOD::TauJet &  pTau,
const xAOD::VertexContainer *  vertexContainer = nullptr 
) const
overridevirtualinherited

Implements ITauToolBase.

Reimplemented in TauVertexFinder.

Definition at line 155 of file TauRecToolBase.cxx.

155  {
156  ATH_MSG_ERROR("function not implemented");
157  return StatusCode::FAILURE;
158 }

◆ executeVertexVariables()

StatusCode TauRecToolBase::executeVertexVariables ( xAOD::TauJet &  pTau,
xAOD::VertexContainer &  vertexContainer 
) const
overridevirtualinherited

Implements ITauToolBase.

Reimplemented in TauVertexVariables.

Definition at line 182 of file TauRecToolBase.cxx.

182  {
183  ATH_MSG_ERROR("function not implemented");
184  return StatusCode::FAILURE;
185 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

◆ finalize()

StatusCode TauRecToolBase::finalize ( )
overridevirtualinherited

Finalizer.

Implements ITauToolBase.

Reimplemented in PanTau::PanTauProcessor.

Definition at line 206 of file TauRecToolBase.cxx.

206  {
207  return StatusCode::SUCCESS;
208 }

◆ find_file()

std::string TauRecToolBase::find_file ( const std::string &  fname) const
inherited

Definition at line 19 of file TauRecToolBase.cxx.

19  {
20  std::string full_path;
21  //offline calib files are in GroupData
22  //online calib files are in release
23  full_path = PathResolverFindCalibFile(m_tauRecToolsTag+"/"+fname);
24  if(full_path.empty()) full_path = PathResolverFindCalibFile(fname);
25  return full_path;
26 }

◆ getEtaBin()

int TauShotFinder::getEtaBin ( float  eta) const
private

Get eta bin.

Definition at line 136 of file TauShotFinder.cxx.

136  {
137  float absEta=std::abs(eta);
138 
139  if (absEta < 0.80) {
140  return 0; // Central Barrel
141  }
142  if (absEta<1.39) {
143  return 1; // Outer Barrel
144  }
145  if (absEta<1.51) {
146  return 2; // Crack region
147  }
148  if (absEta<1.80) {
149  return 3; // Endcap, fine granularity
150  }
151  return 4; // Endcap, coarse granularity
152 }

◆ getEtaNeighbours()

std::vector< const CaloCell * > TauShotFinder::getEtaNeighbours ( const CaloCell &  cell,
const CaloCellContainer &  cellContainer,
int  maxDepth 
) const
private

Get neighbour cells in the eta direction.

Definition at line 325 of file TauShotFinder.cxx.

327  {
328  std::vector<const CaloCell*> cells;
329 
330  // Add neighbours in next eta direction
331  this->addEtaNeighbours(cell, cellContainer, cells, 0, maxDepth, true);
332  // Add neighbours in previous eta direction
333  this->addEtaNeighbours(cell, cellContainer, cells, 0, maxDepth, false);
334 
335  return cells;
336 }

◆ getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void *  ptr) const
inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getName
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

119  {
120 
121 #ifdef XAOD_STANDALONE
122  // In case we use @c xAOD::TEvent, we have a direct function call
123  // for this.
124  return evtStore()->event()->getKey( ptr );
125 #else
126  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
127  return ( proxy == nullptr ? 0 : proxy->sgkey() );
128 #endif // XAOD_STANDALONE
129  }

◆ getName()

const std::string & asg::AsgTool::getName ( const void *  ptr) const
inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getKey
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

106  {
107 
108 #ifdef XAOD_STANDALONE
109  // In case we use @c xAOD::TEvent, we have a direct function call
110  // for this.
111  return evtStore()->event()->getName( ptr );
112 #else
113  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
114  static const std::string dummy = "";
115  return ( proxy == nullptr ? dummy : proxy->name() );
116 #endif // XAOD_STANDALONE
117  }

◆ getNPhotons()

int TauShotFinder::getNPhotons ( float  eta,
float  energy 
) const
private

Get NPhotons in shot.

Definition at line 156 of file TauShotFinder.cxx.

156  {
157  int etaBin = getEtaBin(eta);
158 
159  // No photons in crack region
160  if(etaBin==2) return 0;
161 
162  const std::vector<float>& minPtCut = m_minPtCut.value();
163  const std::vector<float>& doubleShotCut = m_doubleShotCut.value();
164  ATH_MSG_DEBUG("etaBin = " << etaBin << ", energy = " << energy);
165  ATH_MSG_DEBUG("MinPtCut: " << minPtCut.at(etaBin) << "DoubleShotCut: " << doubleShotCut.at(etaBin));
166 
167  if (energy < minPtCut.at(etaBin)) return 0;
168  if (energy > doubleShotCut.at(etaBin)) return 2;
169  return 1;
170 }

◆ getPhiNeighbour()

const CaloCell * TauShotFinder::getPhiNeighbour ( const CaloCell &  seedCell,
const std::vector< const CaloCell * > &  seedCells 
) const
private

Get the hottest neighbour cell in the phi direction.

Definition at line 297 of file TauShotFinder.cxx.

298  {
299 
300  const IdentifierHash seedHash = seedCell.caloDDE()->calo_hash();
301 
302  // Obtain the neighbour cells in the phi direction
303  std::vector<const CaloCell*> neighCells;
304  for (const CaloCell* neighCell : seedCells) {
305  if (neighCell == &seedCell) continue;
306 
307  IdentifierHash neighHash = neighCell->caloDDE()->calo_hash();
308  if (this->isPhiNeighbour(seedHash, neighHash)) {
309  neighCells.push_back(neighCell);
310  }
311  }
312  std::sort(neighCells.begin(),neighCells.end(),ptSort(*this));
313 
314  // Select the one with largest pt
315  const CaloCell* phiNeigCell = nullptr;
316  if (!neighCells.empty()) {
317  phiNeigCell = neighCells[0];
318  }
319 
320  return phiNeigCell;
321 }

◆ getProperty()

template<class T >
const T* asg::AsgTool::getProperty ( const std::string &  name) const
inherited

Get one of the tool's properties.

◆ inAOD()

bool TauRecToolBase::inAOD ( ) const
inlineprotectedinherited

Definition at line 88 of file TauRecToolBase.h.

88 { return m_in_AOD; }

◆ inEleRM()

bool TauRecToolBase::inEleRM ( ) const
inlineprotectedinherited

Definition at line 89 of file TauRecToolBase.h.

89 { return m_in_EleRM; }

◆ initialize()

StatusCode TauShotFinder::initialize ( )
overridevirtual

Tool initializer.

Reimplemented from TauRecToolBase.

Definition at line 19 of file TauShotFinder.cxx.

19  {
20 
21  ATH_CHECK(m_caloWeightTool.retrieve());
22  ATH_CHECK(m_caloCellInputContainer.initialize());
23  ATH_CHECK(m_removedClusterInputContainer.initialize(SG::AllowEmpty));
24  ATH_CHECK(detStore()->retrieve (m_calo_id, "CaloCell_ID"));
25  ATH_CHECK(m_caloMgrKey.initialize());
26  ATH_MSG_INFO("Find TauShot in context: " << (inEleRM() ? "`EleRM`" : "`Standard`") << ", with Electron cell removal Flag: " << m_removeElectronCells);
27  return StatusCode::SUCCESS;
28 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ inTrigger()

bool TauRecToolBase::inTrigger ( ) const
inlineprotectedinherited

Definition at line 87 of file TauRecToolBase.h.

87 { return m_in_trigger; }

◆ isPhiNeighbour()

bool TauShotFinder::isPhiNeighbour ( IdentifierHash  cell1Hash,
IdentifierHash  cell2Hash 
) const
private

Check whether two cells are neighbours in the phi direction.

Definition at line 275 of file TauShotFinder.cxx.

275  {
276  std::vector<IdentifierHash> neigHashes;
277 
278  // Next cell in phi direction
279  m_calo_id->get_neighbours(cell1Hash,LArNeighbours::nextInPhi,neigHashes);
280  if (neigHashes.size() > 1) {
281  ATH_MSG_DEBUG(cell1Hash << " has " << neigHashes.size() << " neighbours in the next phi direction !");
282  }
283  if (std::find(neigHashes.begin(), neigHashes.end(), cell2Hash) != neigHashes.end()) {
284  return true;
285  }
286 
287  // Previous cell in phi direction
288  m_calo_id->get_neighbours(cell1Hash,LArNeighbours::prevInPhi,neigHashes);
289  if (neigHashes.size() > 1) {
290  ATH_MSG_DEBUG(cell1Hash << " has " << neigHashes.size() << " neighbours in the previous phi direction !");
291  }
292  return std::find(neigHashes.begin(), neigHashes.end(), cell2Hash) != neigHashes.end();
293 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const
inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns
The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

101  {
102 
103  return MSG::name( msg().level() );
104  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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.

◆ print()

void asg::AsgTool::print ( ) const
virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, LundVariablesTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

131  {
132 
133  ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134  return;
135  }

◆ readConfig()

StatusCode TauRecToolBase::readConfig ( )
overridevirtualinherited

Implements ITauToolBase.

Definition at line 27 of file TauRecToolBase.cxx.

27  {
28  // Sanity check to see if property ConfigPath is declared for a tool. Might be
29  // removed once all tools are updated to have a config path declared.
30  // in athena getProperties returns std::vector<Gaudi::Details::PropertyBase*>
31  // in rc getProperties returns std::map<std::string,Property*>
32 #ifndef XAOD_STANDALONE
33  bool configPathDeclared = false;
34  for (Gaudi::Details::PropertyBase* property : getProperties())
35  {
36  if (property->name() == "ConfigPath")
37  {
38  configPathDeclared = true;
39  break;
40  }
41  }
42  if (!configPathDeclared)
43 #elif defined(XAOD_STANDALONE)
44  PropertyMgr::PropMap_t property_map = getPropertyMgr()->getProperties();
45  if (property_map.find("ConfigPath") == property_map.end())
46 #else
47 # error "What environment are we in?!?"
48 #endif // XAOD_STANDALONE
49  {
50  ATH_MSG_INFO("No config file path property declared yet, this is not recommended");
51  return StatusCode::SUCCESS;
52  }
53 
54  // get configured config path and load file via TEnv
55  const std::string* config_file_path_property;
56  // if (getProperty("ConfigPath", config_file_path).isFailure())
57  // return StatusCode::FAILURE;
58  config_file_path_property = getProperty<std::string>("ConfigPath");
59  std::string config_file_path = find_file(*config_file_path_property);
60  TEnv env;
61  env.ReadFile(PathResolverFindCalibFile(config_file_path).c_str(),kEnvAll);
62 
63  THashList* lList = env.GetTable();
64  for( Int_t i = 0; lList && i < lList->GetEntries(); ++i )
65  {
66  StatusCode sc;
67  // types of properties are handled differently as well
68 #ifndef XAOD_STANDALONE
69  // get type of variable with the entry name
70  const std::type_info* type = getProperty(lList->At( i )->GetName()).type_info();
71 
72  // search for type is needed by env.GetValue function (needs a variable of the correct type as 2nd argument)
73  if (*type == typeid(bool))
74  sc = this->setProperty(lList->At( i )->GetName(),
75  bool(env.GetValue(lList->At( i )->GetName(),bool(true))));
76  else if (*type == typeid(int))
77  sc = this->setProperty(lList->At( i )->GetName(),
78  env.GetValue(lList->At( i )->GetName(),int(0)));
79  else if (*type == typeid(float))
80  sc = this->setProperty(lList->At( i )->GetName(),
81  env.GetValue(lList->At( i )->GetName(),float(0)));
82  else if (*type == typeid(double))
83  sc = this->setProperty(lList->At( i )->GetName(),
84  env.GetValue(lList->At( i )->GetName(),double(0)));
85  else if (*type == typeid(std::string))
86  sc = this->setProperty(lList->At( i )->GetName(),
87  env.GetValue(lList->At( i )->GetName(),""));
88 #else
89  // get type of variable with the entry name
90  Property::Type type = getPropertyMgr()->getProperty(lList->At( i )->GetName())->type();
91 
92  if (type == Property::BOOL)
93  sc = this->setProperty(lList->At( i )->GetName(),
94  bool(env.GetValue(lList->At( i )->GetName(),bool(true))));
95  else if (type == Property::INT)
96  sc = this->setProperty(lList->At( i )->GetName(),
97  env.GetValue(lList->At( i )->GetName(),int(0)));
98  else if (type == Property::FLOAT)
99  sc = this->setProperty(lList->At( i )->GetName(),
100  env.GetValue(lList->At( i )->GetName(),float(0)));
101  else if (type == Property::DOUBLE)
102  sc = this->setProperty(lList->At( i )->GetName(),
103  env.GetValue(lList->At( i )->GetName(),double(0)));
104  else if (type == Property::STRING)
105  sc = this->setProperty(lList->At( i )->GetName(),
106  env.GetValue(lList->At( i )->GetName(),""));
107 #endif // XAOD_STANDALONE
108  else
109  {
110 #ifndef XAOD_STANDALONE
111  ATH_MSG_FATAL("there was a problem to find the correct type enum: "<<type->name());
112 #else
113  ATH_MSG_FATAL("there was a problem to find the correct type enum: "<<type);
114 #endif // XAOD_STANDALONE
115  return StatusCode::FAILURE;
116  }
117  if (!sc.isSuccess()) {
118  ATH_MSG_FATAL("failed to set property: " << lList->At( i )->GetName());
119  return StatusCode::FAILURE;
120  }
121  }
122  return StatusCode::SUCCESS;
123 }

◆ 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< AlgTool > >::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< AlgTool > >::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  }

◆ selectCells()

StatusCode TauShotFinder::selectCells ( const xAOD::TauJet &  tau,
const CaloCellContainer &  cellContainer,
const CaloDetDescrManager *  detMgr,
std::vector< const CaloCell * > &  cells 
) const
private

Apply preselection of the cells Cells within dR < 0.4, in EM1, and pt > 100 MeV are selected.

Definition at line 174 of file TauShotFinder.cxx.

177  {
178  // if in EleRM tau reco, do electron cell removal
179  std::vector<const CaloCell*> removed_cells;
180  if (m_removeElectronCells && inEleRM()){
181  SG::ReadHandle<xAOD::CaloClusterContainer> removedClustersHandle( m_removedClusterInputContainer );
182  if (!removedClustersHandle.isValid()){
183  ATH_MSG_ERROR ("Could not retrieve HiveDataObj with key " << removedClustersHandle.key());
184  return StatusCode::FAILURE;
185  }
186  const xAOD::CaloClusterContainer *removed_clusters_cont = removedClustersHandle.cptr();
187 
188  for (auto cluster : *removed_clusters_cont){
189  for(auto cell_it = cluster->cell_cbegin(); cell_it != cluster->cell_cend(); cell_it++){
190  removed_cells.push_back(*cell_it);
191  }
192  }
193  }
194  // Get only cells within dR < 0.4
195  // -- TODO: change the hardcoded 0.4
196  std::vector<CaloCell_ID::SUBCALO> emSubCaloBlocks;
197  emSubCaloBlocks.push_back(CaloCell_ID::LAREM);
198  std::unique_ptr<CaloCellList> cellList = std::make_unique<CaloCellList>(detMgr, &cellContainer, emSubCaloBlocks);
199  // -- FIXME: tau p4 is corrected to point at tau vertex, but the cells are not
200  cellList->select(tau.eta(), tau.phi(), 0.4);
201 
202  for (const CaloCell* cell : *cellList) {
203  // Require cells above 100 MeV
204  // FIXME: cells are not corrected to point at tau vertex
205  if (cell->pt() * m_caloWeightTool->wtCell(cell) < 100.) continue;
206  // if in EleRM, check the clusters do not include electron activities
207  if (m_removeElectronCells && inEleRM() && std::find(removed_cells.cbegin(), removed_cells.cend(), cell) != removed_cells.cend()) continue;
208 
209  // Require cells in EM1
210  int sampling = cell->caloDDE()->getSampling();
211  if( !( sampling == CaloCell_ID::EMB1 || sampling == CaloCell_ID::EME1 ) ) continue;
212 
213  cells.push_back(cell);
214  }
215  return StatusCode::SUCCESS;
216 }

◆ selectSeedCells()

StatusCode TauShotFinder::selectSeedCells ( const xAOD::TauJet &  tau,
const CaloCellContainer &  cellContainer,
const CaloDetDescrManager *  detMgr,
std::vector< const CaloCell * > &  seedCells 
) const
private

Select the seed cells used to construct the shot Cells must sastisfy:

  1. pre-selction: dR < 0.4, in EM1, and pt > 100 MeV
  2. have largest pt among the neighbours in the eta direction
  3. no other seed cells as neighbors in the eta direction

Definition at line 220 of file TauShotFinder.cxx.

223  {
224 
225  // Apply pre-selection of the cells
226  assert(seedCells.empty());
227  std::vector<const CaloCell*> cells;
228  ATH_CHECK(selectCells(tau, cellContainer,detMgr, cells));
229  std::sort(cells.begin(),cells.end(),ptSort(*this));
230 
231  std::set<IdentifierHash> seedCellHashes;
232 
233  // Loop the pt sorted cells, and select the seed cells
234  for (const CaloCell* cell: cells) {
235  const IdentifierHash cellHash = cell->caloDDE()->calo_hash();
236 
237  std::vector<IdentifierHash> nextEtaHashes;
238  m_calo_id->get_neighbours(cellHash, LArNeighbours::nextInEta, nextEtaHashes);
239  std::vector<IdentifierHash> prevEtaHashes;
240  m_calo_id->get_neighbours(cellHash, LArNeighbours::prevInEta, prevEtaHashes);
241 
242  std::vector<IdentifierHash> neighHashes = nextEtaHashes;
243  neighHashes.insert(neighHashes.end(),prevEtaHashes.begin(),prevEtaHashes.end());
244 
245  // Check whether it is a seed cell
246  bool status = true;
247  for (const IdentifierHash& neighHash : neighHashes) {
248  // Seed cells must not have seed cells as neighbours
249  // TODO: maybe this requirement can be removed
250  if (seedCellHashes.find(neighHash) != seedCellHashes.end()) {
251  status = false;
252  break;
253  }
254 
255  // Pt of seed cells must be larger than neighbours'
256  const CaloCell* neighCell = cellContainer.findCell(neighHash);
257  if (!neighCell) continue;
258  if (neighCell->pt() * m_caloWeightTool->wtCell(neighCell) >= cell->pt() * m_caloWeightTool->wtCell(cell)) {
259  status = false;
260  break;
261  }
262  } // End of the loop of neighbour cells
263 
264  if (!status) continue;
265 
266  seedCells.push_back(cell);
267  seedCellHashes.insert(cellHash);
268  } // End of the loop of cells
269 
270  return StatusCode::SUCCESS;
271 }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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_id

const CaloCell_ID* TauShotFinder::m_calo_id = nullptr
private

calo cell navigation

Definition at line 111 of file TauShotFinder.h.

◆ m_caloCellInputContainer

SG::ReadHandleKey<CaloCellContainer> TauShotFinder::m_caloCellInputContainer {this,"Key_caloCellInputContainer", "AllCalo", "input vertex container key"}
private

Definition at line 105 of file TauShotFinder.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> TauShotFinder::m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}
private

Definition at line 106 of file TauShotFinder.h.

◆ m_caloWeightTool

ToolHandle<IHadronicCalibrationTool> TauShotFinder::m_caloWeightTool {this, "CaloWeightTool", "H1WeightToolCSC12Generic"}
private

Definition at line 107 of file TauShotFinder.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doubleShotCut

Gaudi::Property<std::vector<float> > TauShotFinder::m_doubleShotCut {this, "AutoDoubleShotCut"}
private

Definition at line 102 of file TauShotFinder.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_in_AOD

Gaudi::Property<bool> TauRecToolBase::m_in_AOD {this, "inAOD", false, "Indicate if the tool is running on AOD"}
protectedinherited

Definition at line 77 of file TauRecToolBase.h.

◆ m_in_EleRM

Gaudi::Property<bool> TauRecToolBase::m_in_EleRM {this, "inEleRM", false, "Indicate if the tool is running on EleRM routine"}
protectedinherited

Definition at line 78 of file TauRecToolBase.h.

◆ m_in_trigger

Gaudi::Property<bool> TauRecToolBase::m_in_trigger {this, "inTrigger", false, "Indicate if the tool is running on trigger"}
protectedinherited

Definition at line 76 of file TauRecToolBase.h.

◆ m_minPtCut

Gaudi::Property<std::vector<float> > TauShotFinder::m_minPtCut {this, "MinPtCut"}
private

Definition at line 101 of file TauShotFinder.h.

◆ m_nCellsInEta

Gaudi::Property<int> TauShotFinder::m_nCellsInEta {this, "NCellsInEta"}
private

Definition at line 100 of file TauShotFinder.h.

◆ m_removedClusterInputContainer

SG::ReadHandleKey<xAOD::CaloClusterContainer> TauShotFinder::m_removedClusterInputContainer {this,"Key_RemovedClusterInputContainer", "", "input removed cluster key"}
private

Definition at line 108 of file TauShotFinder.h.

◆ m_removeElectronCells

Gaudi::Property<bool> TauShotFinder::m_removeElectronCells {this, "RemoveElectronCells", false}
private

Definition at line 103 of file TauShotFinder.h.

◆ m_tauRecToolsTag

Gaudi::Property<std::string> TauRecToolBase::m_tauRecToolsTag {this, "calibFolder", "tauRecTools/R22_preprod", "CVMFS path to the tau calibration folder"}
protectedinherited

Definition at line 79 of file TauRecToolBase.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
CaloClusterStoreHelper::makeCluster
static std::unique_ptr< xAOD::CaloCluster > makeCluster(const CaloCellContainer *cellCont)
Creates a valid CaloCluster with a private Aux-Store and CellLink container.
Definition: CaloClusterStoreHelper.cxx:13
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
Property::BOOL
@ BOOL
Definition: Property.h:29
TauShotFinder::m_caloCellInputContainer
SG::ReadHandleKey< CaloCellContainer > m_caloCellInputContainer
Definition: TauShotFinder.h:105
P4EEtaPhiMBase::pt
virtual double pt() const
transverse momentum
Definition: P4EEtaPhiMBase.cxx:101
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:281
Property::Type
Type
Property type enumeration.
Definition: Property.h:27
TauShotFinder::m_minPtCut
Gaudi::Property< std::vector< float > > m_minPtCut
Definition: TauShotFinder.h:101
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
egammaParameters::depth
@ depth
pointing depth of the shower as calculated in egammaqgcld
Definition: egammaParamDefs.h:276
TauShotVariableHelpers::getCellBlock
std::vector< std::vector< const CaloCell * > > getCellBlock(const xAOD::PFO &shot, const CaloCell_ID *calo_id)
Get cell block with (currently) 2 x 5 cells in correct order for variable calculations.
Definition: TauShotVariableHelpers.cxx:48
CaloCell::phi
virtual double phi() const override final
get phi (through CaloDetDescrElement)
Definition: CaloCell.h:375
constants.EMB1
int EMB1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:53
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:407
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
Property::STRING
@ STRING
Definition: Property.h:33
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloCellList::select
void select(double eta, double phi, double deta, double dphi)
Definition: CaloCellList.cxx:78
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
xAOD::TauJet_v3::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
TauShotFinder::createShotCluster
xAOD::CaloCluster * createShotCluster(const CaloCell *cell, const CaloCell *phiNeighCell, const CaloCellContainer &cellContainer, xAOD::CaloClusterContainer *clusterContainer) const
Create the shot cluster Shot cluster contains 5x1 cells from the seed cell and hottestneighbour cell ...
Definition: TauShotFinder.cxx:377
xAOD::PFODetails::tauShots_pt1
@ tauShots_pt1
Definition: Event/xAOD/xAODPFlow/xAODPFlow/PFODefs.h:144
test_pyathena.pt
pt
Definition: test_pyathena.py:11
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TauRecToolBase::m_tauRecToolsTag
Gaudi::Property< std::string > m_tauRecToolsTag
Definition: TauRecToolBase.h:79
asg::AsgTool::getProperty
const T * getProperty(const std::string &name) const
Get one of the tool's properties.
TauShotFinder::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: TauShotFinder.h:106
xAOD::PFODetails::tauShots_pt3
@ tauShots_pt3
Definition: Event/xAOD/xAODPFlow/xAODPFlow/PFODefs.h:145
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
TauShotFinder::getPhiNeighbour
const CaloCell * getPhiNeighbour(const CaloCell &seedCell, const std::vector< const CaloCell * > &seedCells) const
Get the hottest neighbour cell in the phi direction.
Definition: TauShotFinder.cxx:297
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
TauClusterVars::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, float &out)
Definition: ConstituentLoaderTauCluster.cxx:119
Phi_mpi_pi
__HOSTDEV__ double Phi_mpi_pi(double)
Definition: GeoRegion.cxx:10
LArNeighbours::prevInPhi
@ prevInPhi
Definition: LArNeighbours.h:12
TauShotFinder::addEtaNeighbours
void addEtaNeighbours(const CaloCell &cell, const CaloCellContainer &cellContainer, std::vector< const CaloCell * > &cells, int depth, int maxDepth, bool next) const
Get neighbour cells in the eta direction.
Definition: TauShotFinder.cxx:340
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
TauRecToolBase::inEleRM
bool inEleRM() const
Definition: TauRecToolBase.h:89
TauShotFinder::m_caloWeightTool
ToolHandle< IHadronicCalibrationTool > m_caloWeightTool
Definition: TauShotFinder.h:107
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
xAOD::PFODetails::tauShots_nPhotons
@ tauShots_nPhotons
Definition: Event/xAOD/xAODPFlow/xAODPFlow/PFODefs.h:162
xAOD::PFO_v1::setClusterLink
bool setClusterLink(const ElementLink< xAOD::CaloClusterContainer > &theCluster)
Set a cluster constituent - does NOT append to existing container
Definition: PFO_v1.cxx:549
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TauShotFinder::m_nCellsInEta
Gaudi::Property< int > m_nCellsInEta
Definition: TauShotFinder.h:100
Property::DOUBLE
@ DOUBLE
Definition: Property.h:32
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
LArNeighbours::nextInPhi
@ nextInPhi
Definition: LArNeighbours.h:13
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
xAOD::TauJet_v3::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
setProperty
void setProperty(columnar::PythonToolHandle &self, const std::string &key, nb::object value)
Definition: NanobindBindings.cxx:67
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
xAOD::etaBin
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap etaBin
Definition: L2StandAloneMuon_v1.cxx:149
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
TauShotFinder::getNPhotons
int getNPhotons(float eta, float energy) const
Get NPhotons in shot.
Definition: TauShotFinder.cxx:156
CaloDetDescrElement::calo_hash
IdentifierHash calo_hash() const
cell calo hash
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:412
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
lumiFormat.i
int i
Definition: lumiFormat.py:85
xAOD::PFO
PFO_v1 PFO
Definition of the current "pfo version".
Definition: PFO.h:17
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
CaloCell::caloDDE
const CaloDetDescrElement * caloDDE() const
get pointer to CaloDetDescrElement (data member)
Definition: CaloCell.h:321
tauRecTools::doPi0andShots
bool doPi0andShots(const xAOD::TauJet &tau)
Determines whether pi0s and shots should be built for a tau candidate.
Definition: Reconstruction/tauRecTools/Root/HelperFunctions.cxx:93
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
xAOD::PFODetails::tauShots_seedHash
@ tauShots_seedHash
Definition: Event/xAOD/xAODPFlow/xAODPFlow/PFODefs.h:163
TauRecToolBase::m_in_AOD
Gaudi::Property< bool > m_in_AOD
Definition: TauRecToolBase.h:77
constants.EME1
int EME1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:55
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TauRecToolBase::TauRecToolBase
TauRecToolBase(const std::string &name)
Definition: TauRecToolBase.cxx:125
xAOD::PFO_v1::setBDTPi0Score
void setBDTPi0Score(float BDTPi0Score)
set BDT Score used to classify clusters as Pi0 like or not
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
WriteCellNoiseToCool.cellHash
cellHash
Definition: WriteCellNoiseToCool.py:433
TauShotVariableHelpers::ptWindow
float ptWindow(const std::vector< std::vector< const CaloCell * >> &shotCells, int windowSize, const ToolHandle< IHadronicCalibrationTool > &caloWeightTool)
pt in a window of (currently) 2 x windowSize cells
Definition: TauShotVariableHelpers.cxx:158
TauRecToolBase::m_in_trigger
Gaudi::Property< bool > m_in_trigger
Definition: TauRecToolBase.h:76
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
CaloCellContainer::findCell
const CaloCell * findCell(const IdentifierHash theHash) const
fast find method given identifier hash.
Definition: CaloCellContainer.cxx:345
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TauShotFinder::isPhiNeighbour
bool isPhiNeighbour(IdentifierHash cell1Hash, IdentifierHash cell2Hash) const
Check whether two cells are neighbours in the phi direction.
Definition: TauShotFinder.cxx:275
Property::INT
@ INT
Definition: Property.h:30
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
xAOD::PFO_v1
Class describing a particle flow object.
Definition: PFO_v1.h:35
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
TauShotFinder::selectCells
StatusCode selectCells(const xAOD::TauJet &tau, const CaloCellContainer &cellContainer, const CaloDetDescrManager *detMgr, std::vector< const CaloCell * > &cells) const
Apply preselection of the cells Cells within dR < 0.4, in EM1, and pt > 100 MeV are selected.
Definition: TauShotFinder.cxx:174
Property::FLOAT
@ FLOAT
Definition: Property.h:31
TauRecToolBase::find_file
std::string find_file(const std::string &fname) const
Definition: TauRecToolBase.cxx:19
CaloCell_Base_ID::get_neighbours
int get_neighbours(const IdentifierHash caloHash, const LArNeighbours::neighbourOption &option, std::vector< IdentifierHash > &neighbourList) const
access to hashes for neighbours return == 0 for neighbours found
Definition: CaloCell_Base_ID.cxx:191
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TauShotFinder::getEtaBin
int getEtaBin(float eta) const
Get eta bin.
Definition: TauShotFinder.cxx:136
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:321
TauShotFinder::m_removeElectronCells
Gaudi::Property< bool > m_removeElectronCells
Definition: TauShotFinder.h:103
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:66
TauShotFinder::getEtaNeighbours
std::vector< const CaloCell * > getEtaNeighbours(const CaloCell &cell, const CaloCellContainer &cellContainer, int maxDepth) const
Get neighbour cells in the eta direction.
Definition: TauShotFinder.cxx:325
xAOD::PFO_v1::setP4
void setP4(const FourMom_t &vec)
set the 4-vec
Definition: PFO_v1.cxx:107
xAOD::PFO_v1::setCharge
void setCharge(float charge)
set charge of PFO
TauShotFinder::m_calo_id
const CaloCell_ID * m_calo_id
calo cell navigation
Definition: TauShotFinder.h:111
a
TList * a
Definition: liststreamerinfos.cxx:10
columnar::empty
bool empty() const noexcept
Definition: ObjectRange.h:163
h
python.compareTCTs.ratio
ratio
Definition: compareTCTs.py:294
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:108
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
xAOD::PFODetails::tauShots_nCellsInEta
@ tauShots_nCellsInEta
These are the variables describing Tau Shot objects, which are built from EM1 cells.
Definition: Event/xAOD/xAODPFlow/xAODPFlow/PFODefs.h:143
TauShotFinder::selectSeedCells
StatusCode selectSeedCells(const xAOD::TauJet &tau, const CaloCellContainer &cellContainer, const CaloDetDescrManager *detMgr, std::vector< const CaloCell * > &seedCells) const
Select the seed cells used to construct the shot Cells must sastisfy:
Definition: TauShotFinder.cxx:220
LArNeighbours::nextInEta
@ nextInEta
Definition: LArNeighbours.h:15
xAOD::CaloCluster_v1::getOwnCellLinks
CaloClusterCellLink * getOwnCellLinks()
Get a pointer to the owned CaloClusterCellLink object (non-const version)
Definition: CaloCluster_v1.h:765
xAOD::CaloCluster_v1::addCell
bool addCell(const unsigned index, const double weight)
Method to add a cell to the cluster (Beware: Kinematics not updated!)
Definition: CaloCluster_v1.h:774
TauScalarVars::absEta
bool absEta(const xAOD::TauJet &tau, float &out)
Definition: TauGNNDataLoader.cxx:118
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CaloCellContainer::findIndex
int findIndex(const IdentifierHash theHash) const
Return index of the cell with a given hash.
Definition: CaloCellContainer.cxx:363
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
CaloClusterKineHelper::calculateKine
static void calculateKine(xAOD::CaloCluster *clu, const bool useweight=true, const bool updateLayers=true, const bool useGPUCriteria=false)
Helper class to calculate cluster kinematics based on cells.
Definition: CaloClusterKineHelper.cxx:223
LArNeighbours::prevInEta
@ prevInEta
Definition: LArNeighbours.h:14
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
merge.status
status
Definition: merge.py:16
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
CaloCell_Base_ID::LAREM
@ LAREM
Definition: CaloCell_Base_ID.h:43
python.DataFormatRates.env
env
Definition: DataFormatRates.py:32
xAOD::PFO_v1::setAttribute
void setAttribute(PFODetails::PFOAttributes AttributeType, const T &anAttribute)
Set a PFO Variable via enum - overwrite is allowed.
TauShotFinder::m_removedClusterInputContainer
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_removedClusterInputContainer
Definition: TauShotFinder.h:108
SG::DataProxy
Definition: DataProxy.h:45
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:27
TauShotFinder::m_doubleShotCut
Gaudi::Property< std::vector< float > > m_doubleShotCut
Definition: TauShotFinder.h:102
TauRecToolBase::m_in_EleRM
Gaudi::Property< bool > m_in_EleRM
Definition: TauRecToolBase.h:78
xAOD::PFODetails::tauShots_pt5
@ tauShots_pt5
Definition: Event/xAOD/xAODPFlow/xAODPFlow/PFODefs.h:146
fitman.k
k
Definition: fitman.py:528
xAOD::PFO_v1::setCenterMag
void setCenterMag(float CenterMag)
set CenterMag moment needed for vertex correction
Generated on Fri Oct 24 2025 21:47:06 for ATLAS Offline Software by   doxygen 1.8.18