#include <HGCalTriggerTowerGeometryHelper.h>

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

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

unsigned short	getTriggerTowerFromTriggerCell (const unsigned tcId, const float &eta, const float &phi) const

	HGCalTriggerTowerGeometryHelper (const edm::ParameterSet &conf)

	~HGCalTriggerTowerGeometryHelper ()

Private Attributes
std::vector< double >	binsEta_

std::vector< double >	binsPhi_

std::unordered_map< unsigned, short >	cells_to_trigger_towers_

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 25 of file HGCalTriggerTowerGeometryHelper.h.

Constructor & Destructor Documentation

◆ HGCalTriggerTowerGeometryHelper()

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

Definition at line 13 of file HGCalTriggerTowerGeometryHelper.cc.

     : 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(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(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, 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 29 of file HGCalTriggerTowerGeometryHelper.h.

29 {}

Member Function Documentation

◆ eventSetup()

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

inline

Definition at line 31 of file HGCalTriggerTowerGeometryHelper.h.

31 { triggerTools_.eventSetup(es); }

References HGCalTriggerTools::eventSetup(), and triggerTools_.

Referenced by HGCalTowerMap2DImpl::eventSetup().

◆ getTowerCoordinates()

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

Definition at line 83 of file HGCalTriggerTowerGeometryHelper.cc.

                                                                                                 {
   return tower_coords_;
 }

References tower_coords_.

Referenced by HGCalTowerMap2DImpl::newTowerMaps().

◆ getTriggerTowerFromTriggerCell()

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

Definition at line 87 of file HGCalTriggerTowerGeometryHelper.cc.

                                                                                                        {
   // 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;
  
   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 TC " << trigger_cell_id << " (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 TC " << trigger_cell_id << " (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(zside, bin_eta, bin_phi).rawId();
 }