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 > &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 > &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

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 23 of file TauShotFinder.cxx.

23  :
24  TauRecToolBase(name) {
25 }

◆ ~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 350 of file TauShotFinder.cxx.

355  {
356  ++depth;
357 
358  if (depth > maxDepth) return;
359 
360  const IdentifierHash cellHash = cell.caloDDE()->calo_hash();
361 
362  std::vector<IdentifierHash> neigHashes;
363  if (next) {
364  m_calo_id->get_neighbours(cellHash,LArNeighbours::nextInEta,neigHashes);
365  }
366  else {
367  m_calo_id->get_neighbours(cellHash,LArNeighbours::prevInEta,neigHashes);
368  }
369 
370  for (const IdentifierHash& hash : neigHashes) {
371  const CaloCell* newCell = cellContainer.findCell(hash);
372 
373  if (!newCell) continue;
374 
375  cells.push_back(newCell);
376  this->addEtaNeighbours(*newCell, cellContainer, cells, depth, maxDepth, next);
377 
378  if (neigHashes.size() > 1) {
379  ATH_MSG_DEBUG(cellHash << " has " << neigHashes.size() << " neighbours in the eta direction !");
380  break;
381  }
382  }
383 }

◆ 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 387 of file TauShotFinder.cxx.

390  {
391 
392  xAOD::CaloCluster* shotCluster = CaloClusterStoreHelper::makeCluster(clusterContainer,&cellContainer);
393 
394  int maxDepth = (m_nCellsInEta - 1) / 2;
395 
396  std::vector<const CaloCell*> windowNeighbours = this->getEtaNeighbours(*cell, cellContainer, maxDepth);
397  if (phiNeigCell) {
398  std::vector<const CaloCell*> mergeCells = this->getEtaNeighbours(*phiNeigCell, cellContainer, maxDepth);
399  windowNeighbours.push_back(phiNeigCell);
400  windowNeighbours.insert(windowNeighbours.end(), mergeCells.begin(), mergeCells.end());
401  }
402 
403  shotCluster->getOwnCellLinks()->reserve(windowNeighbours.size()+1);
404  const IdentifierHash seedHash = cell->caloDDE()->calo_hash();
405  shotCluster->addCell(cellContainer.findIndex(seedHash), 1.);
406 
407  for (const CaloCell* cell : windowNeighbours) {
408  shotCluster->addCell(cellContainer.findIndex(cell->caloDDE()->calo_hash()), 1.0);
409  }
410 
411  CaloClusterKineHelper::calculateKine(shotCluster,true,true);
412 
413  return shotCluster;
414 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< 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 > &  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, MvaTESVariableDecorator, TauCombinedTES, MvaTESEvaluator, TauWPDecorator, TauAxisSetter, TauEleOverlapChecker, TauJetRNNEvaluator, TauClusterFinder, TauCalibrateLC, TauGNNEvaluator, TauSubstructureVariables, TauVertexedClusterDecorator, TauAODSelector, TauElectronVetoVariables, JetSeedBuilder, TauCellVariables, TauCommonCalcVars, TauIDVarCalculator, and TauAODLeptonRemovalTool.

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 42 of file TauShotFinder.cxx.

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

◆ 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 146 of file TauShotFinder.cxx.

146  {
147  float absEta=std::abs(eta);
148 
149  if (absEta < 0.80) {
150  return 0; // Central Barrel
151  }
152  if (absEta<1.39) {
153  return 1; // Outer Barrel
154  }
155  if (absEta<1.51) {
156  return 2; // Crack region
157  }
158  if (absEta<1.80) {
159  return 3; // Endcap, fine granularity
160  }
161  return 4; // Endcap, coarse granularity
162 }

◆ 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 335 of file TauShotFinder.cxx.

337  {
338  std::vector<const CaloCell*> cells;
339 
340  // Add neighbours in next eta direction
341  this->addEtaNeighbours(cell, cellContainer, cells, 0, maxDepth, true);
342  // Add neighbours in previous eta direction
343  this->addEtaNeighbours(cell, cellContainer, cells, 0, maxDepth, false);
344 
345  return cells;
346 }

◆ 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 166 of file TauShotFinder.cxx.

166  {
167  int etaBin = getEtaBin(eta);
168 
169  // No photons in crack region
170  if(etaBin==2) return 0;
171 
172  const std::vector<float>& minPtCut = m_minPtCut.value();
173  const std::vector<float>& doubleShotCut = m_doubleShotCut.value();
174  ATH_MSG_DEBUG("etaBin = " << etaBin << ", energy = " << energy);
175  ATH_MSG_DEBUG("MinPtCut: " << minPtCut.at(etaBin) << "DoubleShotCut: " << doubleShotCut.at(etaBin));
176 
177  if (energy < minPtCut.at(etaBin)) return 0;
178  if (energy > doubleShotCut.at(etaBin)) return 2;
179  return 1;
180 }

◆ 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 307 of file TauShotFinder.cxx.

308  {
309 
310  const IdentifierHash seedHash = seedCell.caloDDE()->calo_hash();
311 
312  // Obtain the neighbour cells in the phi direction
313  std::vector<const CaloCell*> neighCells;
314  for (const CaloCell* neighCell : seedCells) {
315  if (neighCell == &seedCell) continue;
316 
317  IdentifierHash neighHash = neighCell->caloDDE()->calo_hash();
318  if (this->isPhiNeighbour(seedHash, neighHash)) {
319  neighCells.push_back(neighCell);
320  }
321  }
322  std::sort(neighCells.begin(),neighCells.end(),ptSort(*this));
323 
324  // Select the one with largest pt
325  const CaloCell* phiNeigCell = nullptr;
326  if (!neighCells.empty()) {
327  phiNeigCell = neighCells[0];
328  }
329 
330  return phiNeigCell;
331 }

◆ 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 29 of file TauShotFinder.cxx.

29  {
30 
31  ATH_CHECK(m_caloWeightTool.retrieve());
32  ATH_CHECK(m_caloCellInputContainer.initialize());
33  ATH_CHECK(m_removedClusterInputContainer.initialize(SG::AllowEmpty));
34  ATH_CHECK(detStore()->retrieve (m_calo_id, "CaloCell_ID"));
35  ATH_CHECK(m_caloMgrKey.initialize());
36  ATH_MSG_INFO("Find TauShot in context: " << (inEleRM() ? "`EleRM`" : "`Standard`") << ", with Electron cell removal Flag: " << m_removeElectronCells);
37  return StatusCode::SUCCESS;
38 }

◆ 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 285 of file TauShotFinder.cxx.

285  {
286  std::vector<IdentifierHash> neigHashes;
287 
288  // Next cell in phi direction
289  m_calo_id->get_neighbours(cell1Hash,LArNeighbours::nextInPhi,neigHashes);
290  if (neigHashes.size() > 1) {
291  ATH_MSG_DEBUG(cell1Hash << " has " << neigHashes.size() << " neighbours in the next phi direction !");
292  }
293  if (std::find(neigHashes.begin(), neigHashes.end(), cell2Hash) != neigHashes.end()) {
294  return true;
295  }
296 
297  // Previous cell in phi direction
298  m_calo_id->get_neighbours(cell1Hash,LArNeighbours::prevInPhi,neigHashes);
299  if (neigHashes.size() > 1) {
300  ATH_MSG_DEBUG(cell1Hash << " has " << neigHashes.size() << " neighbours in the previous phi direction !");
301  }
302  return std::find(neigHashes.begin(), neigHashes.end(), cell2Hash) != neigHashes.end();
303 }

◆ 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, top::TopObjectSelection, 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 184 of file TauShotFinder.cxx.

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

◆ 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 230 of file TauShotFinder.cxx.

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

◆ 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:271
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:359
CaloCellList
Definition: CaloCellList.h:40
constants.EMB1
int EMB1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:53
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
Property::STRING
@ STRING
Definition: Property.h:33
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
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:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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:387
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:307
Phi_mpi_pi
__HOSTDEV__ double Phi_mpi_pi(double)
Definition: GeoRegion.cxx:7
LArNeighbours::prevInPhi
@ prevInPhi
Definition: LArNeighbours.h:12
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
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:350
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
TauShotFinder::m_nCellsInEta
Gaudi::Property< int > m_nCellsInEta
Definition: TauShotFinder.h:100
Property::DOUBLE
@ DOUBLE
Definition: Property.h:32
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.
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
xAOD::etaBin
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap etaBin
Definition: L2StandAloneMuon_v1.cxx:148
TauShotFinder::getNPhotons
int getNPhotons(float eta, float energy) const
Get NPhotons in shot.
Definition: TauShotFinder.cxx:166
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:92
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
CaloCell::caloDDE
const CaloDetDescrElement * caloDDE() const
get pointer to CaloDetDescrElement (data member)
Definition: CaloCell.h:305
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:530
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
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
python.xAODType.dummy
dummy
Definition: xAODType.py:4
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:581
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:285
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:192
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:184
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:190
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TauShotFinder::getEtaBin
int getEtaBin(float eta) const
Get eta bin.
Definition: TauShotFinder.cxx:146
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
TauShotFinder::m_removeElectronCells
Gaudi::Property< bool > m_removeElectronCells
Definition: TauShotFinder.h:103
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:67
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:335
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
h
python.compareTCTs.ratio
ratio
Definition: compareTCTs.py:295
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:109
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:230
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
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:762
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:771
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TauGNNUtils::Variables::absEta
bool absEta(const xAOD::TauJet &tau, double &out)
Definition: TauGNNUtils.cxx:232
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:616
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
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
LArNeighbours::prevInEta
@ prevInEta
Definition: LArNeighbours.h:14
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
merge.status
status
Definition: merge.py:17
IdentifierHash
Definition: IdentifierHash.h:38
CaloCell_Base_ID::LAREM
@ LAREM
Definition: CaloCell_Base_ID.h:46
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:44
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
TauShotFinder::m_doubleShotCut
Gaudi::Property< std::vector< float > > m_doubleShotCut
Definition: TauShotFinder.h:102
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TauRecToolBase::m_in_EleRM
Gaudi::Property< bool > m_in_EleRM
Definition: TauRecToolBase.h:78
readCCLHist.float
float
Definition: readCCLHist.py:83
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 Jun 28 2024 22:00:24 for ATLAS Offline Software by   doxygen 1.8.18