CaloTopoTowerFromClusterMaker.h

Go to the documentation of this file.

// -*- c++ -*- 
/* Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration */
#ifndef CALOREC_CALOTOPOTOWERFROMCLUSTERMAKER_H
#define CALOREC_CALOTOPOTOWERFROMCLUSTERMAKER_H
 
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
 
#include "GaudiKernel/ServiceHandle.h"
 
#include "AthenaBaseComps/AthAlgTool.h" 
 
#include "CaloTowerCollectionProcessor.h"
#include "CaloProtoCluster.h"
 
#include "CaloEvent/CaloCell.h"
#include "CaloEvent/CaloClusterCellLink.h"
#include "CaloEvent/CaloCellClusterWeights.h"
#include "CaloEvent/CaloCellContainer.h"
 
#include "CaloGeoHelpers/CaloSampling.h"
 
#include "CaloDetDescr/CaloTowerGeometry.h"
 
#include "xAODCaloEvent/CaloClusterContainer.h"
 
#include <string>
#include <vector>
#include <bitset>
#include <map>
 
#ifndef _CALOTOPOTOWERFROMCLUSTERMAKER_BITSET_SIZE
#define _CALOTOPOTOWERFROMCLUSTERMAKER_BITSET_SIZE 28
#endif
 
class CaloTopoTowerFromClusterMaker : public AthAlgTool, virtual public CaloTowerCollectionProcessor
{
public:

  CaloTopoTowerFromClusterMaker(const std::string& type,const std::string& name,const IInterface* pParent);
  virtual StatusCode initialize() override;                   
  virtual StatusCode execute(const EventContext& ctx,
                             xAOD::CaloClusterContainer* pClusCont,
                             CaloCellClusterWeights*     cellWeights) const override; 
  virtual StatusCode finalize() override;                        
  
 
private:

  typedef std::vector<CaloProtoCluster> protocont_t; 
  typedef std::size_t                   uint_t;      


  SG::ReadCondHandleKey<CaloTowerGeometry>      m_towerGeoKey{this,"TowerGeometry","CaloTowerGeometry"};
  SG::ReadCondHandleKey<CaloDetDescrManager>    m_caloMgrKey{this,"CaloDetDescrManager", "CaloDetDescrManager"};
 
  SG::ReadHandleKey<xAOD::CaloClusterContainer> m_clusterContainerKey{this, "CaloTopoClusterContainerKey", "CaloTopoClusters", "SG Key for CaloClusterContainer (input)"}; 
  SG::ReadHandleKey<CaloCellContainer>          m_cellContainerKey{this, "CaloCellContainerKey", "AllCalo", "SG Key for CaloCellContainer (input)"}; 
  Gaudi::Property<bool>                         m_orderByPt{this, "OrderClusterByPt", false, "Turn on/off pT-ordering of CaloClusterContainer (output)"}; 
  Gaudi::Property<bool>                         m_prepareLCW{this, "PrepareLCW", false, "Prepare data structure to apply LCW"}; 
  Gaudi::Property<bool>                         m_useCellsFromClusters{this, "BuildTopoTowers", true, "Turn on/off topo-tower formation"}; 
  Gaudi::Property<bool>                         m_applyCellEnergyThreshold{this, "ApplyCellEnergyThreshold", false, "Turn on/off cell energy thresholds"}; 
  Gaudi::Property<bool>                         m_doCellIndexCheck{this, "DoCellIndexCheck", false, "Check cell hash indices for consistency"}; 
  Gaudi::Property<bool>                         m_buildCombinedSignal{this, "BuildCombinedTopoSignal", false, "Build topo-clusters and topo-towers"}; 
  Gaudi::Property<double>                       m_energyThreshold{this, "CellEnergyThreshold", m_energyThresholdDef-1., "Energy threshold for cells filled in clusters"}; 
  Gaudi::Property<double>                       m_clusterRange{this, "TopoClusterRange", m_clusterRangeDef, "Rapidity range for using topo-clusters in combined signal mode"}; 
  Gaudi::Property<bool>                         m_removeSamplingData{this, "RemoveSamplingData", true, "Remove the associated sampling data"}; 

  //uint_t             m_numberOfCells;          ///< Number of cells (highest cell index + 1)
  //uint_t             m_maxCellHash;            ///< Maximum hash index of cell ( number of cells - 1)
  uint_t             m_numberOfSamplings{static_cast<uint_t>(CaloSampling::Unknown)}; 
  //uint_t             m_numberOfTowers;         ///< Number of towers
  static const double      m_energyThresholdDef;     
  static const double      m_clusterRangeDef;        
  static const uint_t      m_errorValueUINT;         

  static xAOD::CaloCluster::ClusterSize getClusterSize(uint_t etaBins,uint_t phiBins) ; 
  static xAOD::CaloCluster::ClusterSize getClusterSize(uint_t towerBins) ;              
  int cleanupCells(const CaloTowerGeometry* towerGeo, CaloClusterCellLink* clk,uint_t nclus) const;                      

  uint_t buildInclTowers(const CaloTowerGeometry* towerGeo, const CaloCellContainer& pCellCont,protocont_t& pProtoCont)const;            
  uint_t buildExclTowers(const CaloTowerGeometry* towerGeo, const CaloCellContainer& pCellCont,protocont_t& pProtoCont)const;            
  uint_t buildEMTopoTowers(const CaloTowerGeometry* towerGeo, const xAOD::CaloClusterContainer& clusCont,protocont_t& protoCont)const;   
  uint_t buildLCWTopoTowers(const CaloTowerGeometry* towerGeo, const xAOD::CaloClusterContainer& clusCont,protocont_t& protoCont,CaloCellClusterWeights* cellWeights) const;  
  bool addCellToProtoCluster(const CaloTowerGeometry* towerGeo, const CaloCell* cptr,protocont_t& pProtoCont,double weight=1.) const;
  
  static bool   filterProtoCluster(const CaloClusterCellLink& clnk)  ; 
  bool   checkCellIndices(const CaloTowerGeometry* towerGeo, const CaloDetDescrManager* caloDDM,
                          const CaloCellContainer* pCellCont) const; 
  bool   isValidIndex(uint_t idx)                             const; 
  uint_t badIndexValue()                                      const; 

  std::vector<CaloSampling::CaloSample>                       m_excludedSamplings;         
  Gaudi::Property<std::vector<std::string>>                   m_excludedSamplingsName{this, "ExcludedSamplings", {}, "Excluded samplings by name"}; 
  std::bitset< _CALOTOPOTOWERFROMCLUSTERMAKER_BITSET_SIZE >   m_excludedSamplingsPattern;  

};
 
inline CaloTopoTowerFromClusterMaker::uint_t CaloTopoTowerFromClusterMaker::badIndexValue()          const { return m_errorValueUINT;       } 
inline bool                                  CaloTopoTowerFromClusterMaker::isValidIndex(uint_t idx) const { return idx != badIndexValue(); }

#endif