HcalTopology.h

Go to the documentation of this file.

#ifndef GEOMETRY_CALOTOPOLOGY_HCALTOPOLOGY_H
#define GEOMETRY_CALOTOPOLOGY_HCALTOPOLOGY_H 1

#include <vector>
#include <map>
#include "DataFormats/HcalDetId/interface/HcalDetId.h"
#include "DataFormats/HcalDetId/interface/HcalTrigTowerDetId.h"
#include "Geometry/CaloTopology/interface/CaloSubdetectorTopology.h"
#include "Geometry/HcalCommonData/interface/HcalTopologyMode.h"
#include "Geometry/HcalCommonData/interface/HcalDDDRecConstants.h"

class HcalTopology : public CaloSubdetectorTopology {
public:

  HcalTopology(const HcalDDDRecConstants* hcons, const bool mergePosition=false);
  HcalTopology(HcalTopologyMode::Mode mode, int maxDepthHB, int maxDepthHE, HcalTopologyMode::TriggerMode tmode=HcalTopologyMode::TriggerMode_2009);
    
  HcalTopologyMode::Mode mode() const {return mode_;}
  HcalTopologyMode::TriggerMode triggerMode() const { return triggerMode_; }
  void exclude(const HcalDetId& id);
  void excludeSubdetector(HcalSubdetector subdet);
  int exclude(HcalSubdetector subdet, int ieta1, int ieta2, int iphi1, int iphi2, int depth1=1, int depth2=4);

  static std::string producerTag() { return "HCAL" ; }

  unsigned int detId2denseId(const DetId& id) const override;
  DetId denseId2detId(unsigned int /*denseid*/) const override;
  unsigned int ncells() const override;
  int topoVersion() const override;

  bool valid(const DetId& id) const override;
  bool validHcal(const HcalDetId& id) const;
  bool validDetId(HcalSubdetector subdet, int ieta, int iphi, int depth) const;
  bool validHT(const HcalTrigTowerDetId& id) const;
  bool validHcal(const HcalDetId& id, const unsigned int flag) const;
  std::vector<DetId> east(const DetId& id) const override;
  std::vector<DetId> west(const DetId& id) const override;
  std::vector<DetId> north(const DetId& id) const override;
  std::vector<DetId> south(const DetId& id) const override;
  std::vector<DetId> up(const DetId& id) const override;
  std::vector<DetId> down(const DetId& id) const override;

  int incIEta(const HcalDetId& id, HcalDetId neighbors[2]) const;
  int decIEta(const HcalDetId& id, HcalDetId neighbors[2]) const;
  bool incIPhi(const HcalDetId& id, HcalDetId &neighbor) const;
  bool decIPhi(const HcalDetId& id, HcalDetId &neighbor) const;
  bool incrementDepth(HcalDetId& id) const;
  bool decrementDepth(HcalDetId& id) const;

  int firstHBRing() const {return firstHBRing_;}
  int lastHBRing()  const {return lastHBRing_;}
  int firstHERing() const {return firstHERing_;}
  int lastHERing()  const {return lastHERing_;}
  int firstHFRing() const {return firstHFRing_;}
  int lastHFRing()  const {return lastHFRing_;}
  int firstHORing() const {return firstHORing_;}
  int lastHORing()  const {return lastHORing_;}

  int firstHEDoublePhiRing()   const {return firstHEDoublePhiRing_;} 
  int firstHEQuadPhiRing()     const {return firstHEQuadPhiRing_;} 
  int firstHFQuadPhiRing()     const {return firstHFQuadPhiRing_;}
  int firstHETripleDepthRing() const {return firstHETripleDepthRing_;}
  int singlePhiBins()          const {return singlePhiBins_;}
  int doublePhiBins()          const {return doublePhiBins_;}

  void depthBinInformation(HcalSubdetector subdet, int etaRing,
               int iphi, int zside, int & nDepthBins,
               int & startingBin) const;
  bool mergedDepth29(HcalDetId id) const {
    return hcons_->mergedDepthList29(id.ieta(), id.iphi(), id.depth());
  }
  std::vector<int> mergedDepthList29(HcalDetId id) const {
    return hcons_->mergedDepthList29(id.ieta(), id.iphi());
  }

  int nPhiBins(int etaRing) const;
  int nPhiBins(HcalSubdetector subdet, int etaRing) const;

  int etaRing(HcalSubdetector subdet, double eta) const;
  int phiBin(HcalSubdetector subdet, int etaRing, double phi) const;

  void getDepthSegmentation(const unsigned ring, 
                std::vector<int> & readoutDepths,
                const bool flag=false) const;
  void setDepthSegmentation(const unsigned ring, 
                const std::vector<int> & readoutDepths,
                const bool flag);
  std::pair<int, int> segmentBoundaries(const unsigned ring,
                    const unsigned depth,
                    const bool flag=false) const;
  int getPhiZOne(std::vector<std::pair<int,int> >& phiz) const {return hcons_->getPhiZOne(phiz);}

  unsigned int getHBSize() const {return HBSize_;}
  unsigned int getHESize() const {return HESize_;}
  unsigned int getHOSize() const {return HOSize_;}
  unsigned int getHFSize() const {return HFSize_;}
  unsigned int getHTSize() const {return HTSize_;}
  unsigned int getCALIBSize() const {return CALIBSize_;}

  int maxDepthHB() const { return maxDepthHB_;}
  int maxDepthHE() const { return maxDepthHE_;}
  int maxDepth(HcalSubdetector subdet) const;
  double etaMax(HcalSubdetector subdet) const;
  std::pair<double,double> etaRange(HcalSubdetector subdet, int ieta) const;

  unsigned int detId2denseIdHB(const DetId& id) const;
  unsigned int detId2denseIdHE(const DetId& id) const;
  unsigned int detId2denseIdHO(const DetId& id) const;
  unsigned int detId2denseIdHF(const DetId& id) const;
  unsigned int detId2denseIdHT(const DetId& id) const;
  unsigned int detId2denseIdCALIB(const DetId& id) const;

  unsigned int getNumberOfShapes() const { return numberOfShapes_; }
  bool isBH() const { return ((hcons_ == nullptr) ? false : hcons_->isBH()); }

  const HcalDDDRecConstants* dddConstants () const {return hcons_;}
  bool  withSpecialRBXHBHE() const {return hcons_->withSpecialRBXHBHE();}
  HcalDetId mergedDepthDetId(const HcalDetId& id) const {return hcons_->mergedDepthDetId(id); }
  bool  getMergePositionFlag() const {return mergePosition_;}
  void  unmergeDepthDetId(const HcalDetId& id,
              std::vector<HcalDetId>& ids) const {
    hcons_->unmergeDepthDetId(id, ids);
  }
  // Returns the DetId of the front Id if it is a merged RecHit in "Plan 1"
  HcalDetId idFront(const HcalDetId& id) const {return hcons_->idFront(id);}
  HcalDetId idBack (const HcalDetId& id) const {return hcons_->idBack(id);}

private:
  int incAIEta(const HcalDetId& id, HcalDetId neighbors[2]) const;
  int decAIEta(const HcalDetId& id, HcalDetId neighbors[2]) const;

  bool validDetIdPreLS1(const HcalDetId& id) const;
  bool validRaw(const HcalDetId& id) const;
  unsigned int detId2denseIdPreLS1 (const DetId& id) const;
  bool isExcluded(const HcalDetId& id) const;

  const HcalDDDRecConstants *hcons_;
  bool                       mergePosition_;
  std::vector<HcalDetId> exclusionList_;
  bool excludeHB_, excludeHE_, excludeHO_, excludeHF_;

  HcalTopologyMode::Mode mode_;
  HcalTopologyMode::TriggerMode triggerMode_;

  int firstHBRing_, lastHBRing_;
  int firstHERing_, lastHERing_;
  int firstHFRing_, lastHFRing_;
  int firstHORing_, lastHORing_;

  std::vector<HcalDDDRecConstants::HcalEtaBin> etaBinsHB_, etaBinsHE_;
  int nEtaHB_, nEtaHE_;

  int firstHEDoublePhiRing_, firstHEQuadPhiRing_, firstHFQuadPhiRing_;
  int firstHETripleDepthRing_;
  int singlePhiBins_, doublePhiBins_;
  int maxDepthHB_, maxDepthHE_, maxDepthHF_;
  int etaHE2HF_, etaHF2HE_;
  int maxEta_, maxPhiHE_;

  unsigned int HBSize_;
  unsigned int HESize_;
  unsigned int HOSize_;
  unsigned int HFSize_;
  unsigned int HTSize_;
  unsigned int CALIBSize_;
  unsigned int numberOfShapes_;

  std::vector<double> etaTable, etaTableHF, dPhiTable, dPhiTableHF;
  std::vector<double> phioff;
  std::vector<int>    unitPhi, unitPhiHF;

  int topoVersion_;
    
  // index is ring;
  typedef std::map<unsigned, std::vector<int> > SegmentationMap;
  SegmentationMap depthSegmentation_;
  SegmentationMap depthSegmentationOne_;

  enum { kHBhalf = 1296 ,
     kHEhalf = 1296 ,
     kHOhalf = 1080 ,
     kHFhalf = 864  ,
     kHThalf = 2088,
     kZDChalf = 11,
     kCASTORhalf = 224,
     kCALIBhalf = 693,
         kHThalfPhase1 = 2520 ,
     kHcalhalf = kHBhalf + kHEhalf + kHOhalf + kHFhalf } ;
  enum { kSizeForDenseIndexingPreLS1 = 2*kHcalhalf } ;
  enum { kHBSizePreLS1 = 2*kHBhalf } ;
  enum { kHESizePreLS1 = 2*kHEhalf } ;
  enum { kHOSizePreLS1 = 2*kHOhalf } ;
  enum { kHFSizePreLS1 = 2*kHFhalf } ;
  enum { kHTSizePreLS1 = 2*kHThalf } ;
  enum { kHTSizePhase1 = 2*kHThalfPhase1 } ;
  enum { kCALIBSizePreLS1 = 2*kCALIBhalf };
};


#endif