MissingCellListTool.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef JETMOMENTTOOLS_MISSINGCALOCELLLISTTOOL_H
#define JETMOMENTTOOLS_MISSINGCALOCELLLISTTOOL_H 1
 
// STL includes
#include <string>
#include <list>
#include <unordered_set>
 
// FrameWork includes
//#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
//
#include "CaloIdentifier/CaloCell_ID.h"
#include "CaloEvent/CaloCellContainer.h"
#include "CaloDetDescr/CaloDetDescrManager.h"
#include "TileConditions/TileCablingSvc.h"
#include "LArRecConditions/LArBadChannelCont.h"
//
#include "JetUtils/TiledEtaPhiMap.h"
//
#include "xAODCore/CLASS_DEF.h"
#include "AsgTools/AsgTool.h"
#include "JetInterface/IJetExecuteTool.h"
 
// Forward declaration
 
class ITileBadChanTool ;
 
namespace jet {
  struct CellPosition {
    typedef CaloCell_ID::CaloSample CaloSample;
    
    CellPosition(){};
    CellPosition(double eta, double phi): m_eta(eta),m_phi(phi),m_sampling(),m_id(){};
    CellPosition(double eta, double phi, Identifier id, CaloSample samp): m_eta(eta),m_phi(phi), m_sampling(samp),m_id(id){};
 
    double x()const {return m_eta;}
    double y()const {return m_phi;}
    void setX(double x){m_eta=x;}
    void setY(double x){m_phi=x;}
 
    double eta()const {return m_eta;}
    double phi()const {return m_phi;}
    CaloSample sampling() const {return m_sampling;}
    // define a distance.
    struct DR2 {
      double operator()(const CellPosition &p1,const CellPosition &p2) const {
        return JetTiledMap::utils::DR2(p1.x(),p1.y(), p2.x(), p2.y() );
      }
    };
 
    double m_eta = 0;
    double m_phi = 0;
    CaloSample m_sampling = CaloSampling::Unknown;
    Identifier m_id;
  };
 
  typedef std::unordered_set<Identifier> cellset_t;
 
 
  class CaloCellFastMap : public JetTiledMap::TiledEtaPhiMap<CellPosition> {
  public:
    virtual ~CaloCellFastMap() {}
    std::vector<CellPosition> cellsInDeltaR(double eta,double phi, double r) const {
      CellPosition p(eta,phi,Identifier(), (CellPosition::CaloSample) 0);
      return pointsInDr( p , r);
    }
    
    const cellset_t & cells() const {return m_allCells;}
    cellset_t & cells()  {return m_allCells;}
  protected:
    cellset_t m_allCells;
  };
 
 
}
 
CLASS_DEF(  jet::CaloCellFastMap , 35228686 , 1 )
 
 
 
class MissingCellListTool
  : public asg::AsgTool,
    virtual public IJetExecuteTool
    
//virtual public IIncidentListener // allows to detect begining of events
{ 
  ASG_TOOL_CLASS(MissingCellListTool, IJetExecuteTool)
 public: 
 
 
 
  // Copy constructor: 

  MissingCellListTool(const std::string& name);
 

  virtual ~MissingCellListTool(); 
  
  // Athena algtool's Hooks
  virtual StatusCode  initialize();
  virtual StatusCode  finalize();
 
 
  // Interface implementation
  // virtual StatusCode prepareCellList();
  // virtual const_iterator begin() ;
  // virtual const_iterator end()   ;
  // virtual size_t size() ;
 
 
  // virtual const list_t & missingCellList() {return m_missingCells;};  
  // virtual const list_t & extendedList() {return m_badandmissingCells;};  
 
  virtual int execute() const;
 
  // /// returns all bad cells within r of (eta,phi).
  // std::vector<CellPosition> cellsInDeltaR(double eta,double phi, double r);
  
  // /// Implementation of IIncidentListener::handle
  // virtual void handle(const Incident&);
 

  // PRIVATE data: 
 private: 
  
 
 
  typedef std::vector<unsigned int> cellidvec_t;
  cellidvec_t m_userRemovedCells;
  cellidvec_t m_userAddedCells;
 
 
  double m_rmax;
  //bool m_needSetup;
  bool m_addBadCells;
  bool m_addCellFromTool;
  unsigned int m_larMaskBit;
  unsigned int m_tileMaskBit;
 
  ServiceHandle<TileCablingSvc> m_tileCabling;
  ToolHandle<ITileBadChanTool> m_tileTool;
  SG::ReadCondHandleKey<LArBadChannelCont> m_BCKey{ this,
                                                    "BadChanKey",
                                                    "LArBadChannel",
                                                    "SG bad channels key" };
  SG::ReadCondHandleKey<CaloDetDescrManager> m_caloDetDescrMgrKey{
    this,
    "CaloDetDescrManager",
    "CaloDetDescrManager",
    "SG Key for CaloDetDescrManager in the Condition Store"
  };
 
  SG::ReadHandleKey<CaloCellContainer> m_cells_name{ this,
                                                     "cells_name",
                                                     "AllCalo",
                                                     "" };
 
  SG::WriteHandleKey<jet::CaloCellFastMap> m_badCellMap_key{
    this,
    "MissingCellMapName",
    "MissingCaloCellsMap",
    "SG key for missing cell map"
  };
};
 
// I/O operators

// Inline methods: 
 
 
#endif //> !JETMOMENTTOOLS_BADCALOCELLLISTTOOL_H
// DoxygenDocumentation