CaloTopoTowerFromClusterMaker.h

Go to the documentation of this file.

// -*- c++ -*- 
/* Copyright (C) 2002-2022 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;                      
  SG::ReadHandleKey<CaloCellContainer>          m_cellContainerKey;                         
  bool                                          m_orderByPt = { false  };                   
  bool                                          m_prepareLCW = { false  };                  
  bool                                          m_useCellsFromClusters = { true  };         
  bool                                          m_applyCellEnergyThreshold = { false  };    
  bool                                          m_doCellIndexCheck = { false  };            
  bool                                          m_buildCombinedSignal = { false  };         
  double                                        m_energyThreshold;                          
  double                                        m_clusterRange;                             
  bool                                          m_removeSamplingData = { true };            

  //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;      
  //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;         
  std::vector<std::string>                                    m_excludedSamplingsName;     
  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