#include <HGCalTriggerTowerGeometryHelper.h>

Public Member Functions
void	eventSetup (const edm::EventSetup &es)

const std::vector< l1t::HGCalTowerCoord > &	getTowerCoordinates () const

unsigned short	getTriggerTower (const l1t::HGCalTriggerCell &) const

unsigned short	getTriggerTower (const l1t::HGCalTriggerSums &) const

unsigned short	getTriggerTowerFromEtaPhi (const float &eta, const float &phi) const

	HGCalTriggerTowerGeometryHelper (const edm::ParameterSet &conf)

const bool	isNose ()

	~HGCalTriggerTowerGeometryHelper ()

Private Attributes
std::vector< double >	binsEta_

std::vector< double >	binsPhi_

std::unordered_map< unsigned, short >	cells_to_trigger_towers_

bool	doNose_

double	maxEta_

double	maxPhi_

double	minEta_

double	minPhi_

unsigned int	nBinsEta_

unsigned int	nBinsPhi_

std::vector< l1t::HGCalTowerCoord >	tower_coords_

HGCalTriggerTools	triggerTools_

Detailed Description

Handles the mapping between TCs and TTs. The mapping can be provided externally (via a mapping file) or can be derived on the fly based on the TC eta-phi coordinates. The bin boundaries need anyhow to be provided to establish the eta-phi coordinates of the towers (assumed as the Tower Center for the moment)

Definition at line 27 of file HGCalTriggerTowerGeometryHelper.h.

Constructor & Destructor Documentation

◆ HGCalTriggerTowerGeometryHelper()

HGCalTriggerTowerGeometryHelper::HGCalTriggerTowerGeometryHelper ( const edm::ParameterSet & conf )

Definition at line 13 of file HGCalTriggerTowerGeometryHelper.cc.

     : doNose_(conf.getParameter<bool>("doNose")),
       minEta_(conf.getParameter<double>("minEta")),
       maxEta_(conf.getParameter<double>("maxEta")),
       minPhi_(conf.getParameter<double>("minPhi")),
       maxPhi_(conf.getParameter<double>("maxPhi")),
       nBinsEta_(conf.getParameter<int>("nBinsEta")),
       nBinsPhi_(conf.getParameter<int>("nBinsPhi")),
       binsEta_(conf.getParameter<std::vector<double> >("binsEta")),
       binsPhi_(conf.getParameter<std::vector<double> >("binsPhi")) {
   if (!binsEta_.empty() && ((unsigned int)(binsEta_.size()) != nBinsEta_ + 1)) {
     throw edm::Exception(edm::errors::Configuration, "Configuration")
         << "HGCalTriggerTowerGeometryHelper nBinsEta for the tower map not consistent with binsEta size" << std::endl;
   }
  
   if (!binsPhi_.empty() && ((unsigned int)(binsPhi_.size()) != nBinsPhi_ + 1)) {
     throw edm::Exception(edm::errors::Configuration, "Configuration")
         << "HGCalTriggerTowerGeometryHelper nBinsPhi for the tower map not consistent with binsPhi size" << std::endl;
   }
  
   // if the bin vecctor is empty we assume the bins to be regularly spaced
   if (binsEta_.empty()) {
     for (unsigned int bin1 = 0; bin1 != nBinsEta_ + 1; bin1++) {
       binsEta_.push_back(minEta_ + bin1 * ((maxEta_ - minEta_) / nBinsEta_));
     }
   }
  
   // if the bin vecctor is empty we assume the bins to be regularly spaced
   if (binsPhi_.empty()) {
     for (unsigned int bin2 = 0; bin2 != nBinsPhi_ + 1; bin2++) {
       binsPhi_.push_back(minPhi_ + bin2 * ((maxPhi_ - minPhi_) / nBinsPhi_));
     }
   }
  
   for (int zside = -1; zside <= 1; zside += 2) {
     for (unsigned int bin1 = 0; bin1 != nBinsEta_; bin1++) {
       for (unsigned int bin2 = 0; bin2 != nBinsPhi_; bin2++) {
         l1t::HGCalTowerID towerId(doNose_, zside, bin1, bin2);
         tower_coords_.emplace_back(towerId.rawId(),
                                    zside * ((binsEta_[bin1 + 1] + binsEta_[bin1]) / 2),
                                    (binsPhi_[bin2 + 1] + binsPhi_[bin2]) / 2);
       }
     }
   }
  
   if (conf.getParameter<bool>("readMappingFile")) {
     // We read the TC to TT mapping from file,
     // otherwise we derive the TC to TT mapping on the fly from eta-phi coord. of the TCs
     std::ifstream l1tTriggerTowerMappingStream(conf.getParameter<edm::FileInPath>("L1TTriggerTowerMapping").fullPath());
     if (!l1tTriggerTowerMappingStream.is_open()) {
       throw cms::Exception("MissingDataFile") << "Cannot open HGCalTriggerGeometry L1TTriggerTowerMapping file\n";
     }
  
     unsigned trigger_cell_id = 0;
     unsigned short iEta = 0;
     unsigned short iPhi = 0;
  
     for (; l1tTriggerTowerMappingStream >> trigger_cell_id >> iEta >> iPhi;) {
       if (iEta >= nBinsEta_ || iPhi >= nBinsPhi_) {
         throw edm::Exception(edm::errors::Configuration, "Configuration")
             << "HGCalTriggerTowerGeometryHelper warning inconsistent mapping TC : " << trigger_cell_id
             << " to TT iEta: " << iEta << " iPhi: " << iPhi << " when max #bins eta: " << nBinsEta_
             << " phi: " << nBinsPhi_ << std::endl;
       }
       l1t::HGCalTowerID towerId(doNose_, triggerTools_.zside(DetId(trigger_cell_id)), iEta, iPhi);
       cells_to_trigger_towers_[trigger_cell_id] = towerId.rawId();
     }
     l1tTriggerTowerMappingStream.close();
   }
 }

References binsEta_, binsPhi_, cells_to_trigger_towers_, edm::errors::Configuration, doNose_, Exception, edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), L1TowerCalibrationProducer_cfi::iEta, createfilelist::int, maxEta_, maxPhi_, minEta_, minPhi_, nBinsEta_, nBinsPhi_, tower_coords_, ecaldqm::towerId(), triggerTools_, HGCalTriggerTools::zside(), and ecaldqm::zside().

◆ ~HGCalTriggerTowerGeometryHelper()

HGCalTriggerTowerGeometryHelper::~HGCalTriggerTowerGeometryHelper ( )

inline

Definition at line 31 of file HGCalTriggerTowerGeometryHelper.h.

31 {}

Member Function Documentation

◆ eventSetup()

void HGCalTriggerTowerGeometryHelper::eventSetup ( const edm::EventSetup & es )

inline

Definition at line 33 of file HGCalTriggerTowerGeometryHelper.h.

33 { triggerTools_.eventSetup(es); }

References HGCalTriggerTools::eventSetup(), and triggerTools_.

Referenced by HGCalTowerMap2DImpl::eventSetup().

◆ getTowerCoordinates()

const std::vector< l1t::HGCalTowerCoord > & HGCalTriggerTowerGeometryHelper::getTowerCoordinates ( ) const

Definition at line 84 of file HGCalTriggerTowerGeometryHelper.cc.

                                                                                                 {
   return tower_coords_;
 }

References tower_coords_.

Referenced by HGCalTowerMap2DImpl::newTowerMaps().

◆ getTriggerTower() [1/2]

unsigned short HGCalTriggerTowerGeometryHelper::getTriggerTower ( const l1t::HGCalTriggerCell & thecell ) const

Definition at line 123 of file HGCalTriggerTowerGeometryHelper.cc.

                                                                                                         {
   unsigned int trigger_cell_id = thecell.detId();
   // NOTE: if the TC is not found in the map than it is mapped via eta-phi coords.
   // this can be considered dangerous (silent failure of the map) but it actually allows to save
   // memory mapping explicitly only what is actually needed
   auto tower_id_itr = cells_to_trigger_towers_.find(trigger_cell_id);
   if (tower_id_itr != cells_to_trigger_towers_.end())
     return tower_id_itr->second;
  
   return getTriggerTowerFromEtaPhi(thecell.position().eta(), thecell.position().phi());
 }

References cells_to_trigger_towers_, l1t::HGCalTriggerCell::detId(), PV3DBase< T, PVType, FrameType >::eta(), getTriggerTowerFromEtaPhi(), PV3DBase< T, PVType, FrameType >::phi(), and l1t::HGCalTriggerCell::position().

Referenced by HGCalTowerMap2DImpl::buildTowerMap2D().

◆ getTriggerTower() [2/2]

unsigned short HGCalTriggerTowerGeometryHelper::getTriggerTower ( const l1t::HGCalTriggerSums & thesum ) const

Definition at line 135 of file HGCalTriggerTowerGeometryHelper.cc.

                                                                                                        {
   return getTriggerTowerFromEtaPhi(thesum.position().eta(), thesum.position().phi());
 }

References PV3DBase< T, PVType, FrameType >::eta(), getTriggerTowerFromEtaPhi(), PV3DBase< T, PVType, FrameType >::phi(), and l1t::HGCalTriggerSums::position().

◆ getTriggerTowerFromEtaPhi()

unsigned short HGCalTriggerTowerGeometryHelper::getTriggerTowerFromEtaPhi	(	const float &	eta,
		const float &	phi
	)		const

Definition at line 88 of file HGCalTriggerTowerGeometryHelper.cc.

                                                                                                                   {
   auto bin_eta_l = std::lower_bound(binsEta_.begin(), binsEta_.end(), fabs(eta));
   unsigned int bin_eta = 0;
   // we add a protection for TCs in Hadron part which are outside the boundaries and possible rounding effects
   if (bin_eta_l == binsEta_.end()) {
     if (fabs(eta) < minEta_) {
       bin_eta = 0;
     } else if (fabs(eta) >= maxEta_) {
       bin_eta = nBinsEta_;
     } else {
       edm::LogError("HGCalTriggerTowerGeometryHelper")
           << " did not manage to map eta " << eta << " to any Trigger Tower\n";
     }
   } else {
     bin_eta = bin_eta_l - binsEta_.begin() - 1;
   }
  
   auto bin_phi_l = std::lower_bound(binsPhi_.begin(), binsPhi_.end(), phi);
   unsigned int bin_phi = 0;
   if (bin_phi_l == binsPhi_.end()) {
     if (phi < minPhi_) {
       bin_phi = nBinsPhi_;
     } else if (phi >= maxPhi_) {
       bin_phi = 0;
     } else {
       edm::LogError("HGCalTriggerTowerGeometryHelper")
           << " did not manage to map phi " << phi << " to any Trigger Tower\n";
     }
   } else {
     bin_phi = bin_phi_l - binsPhi_.begin() - 1;
   }
   int zside = eta < 0 ? -1 : 1;
   return l1t::HGCalTowerID(doNose_, zside, bin_eta, bin_phi).rawId();
 }