Inheritance diagram for HGCalTriggerGeometryHexLayerBasedImp1:

Public Member Functions
bool	disconnectedModule (const unsigned) const final

geom_set	getCellsFromModule (const unsigned) const final

geom_set	getCellsFromTriggerCell (const unsigned) const final

unsigned	getModuleFromCell (const unsigned) const final

unsigned	getModuleFromTriggerCell (const unsigned) const final

GlobalPoint	getModulePosition (const unsigned) const final

geom_set	getNeighborsFromTriggerCell (const unsigned) const final

geom_ordered_set	getOrderedCellsFromModule (const unsigned) const final

geom_ordered_set	getOrderedTriggerCellsFromModule (const unsigned) const final

unsigned	getTriggerCellFromCell (const unsigned) const final

GlobalPoint	getTriggerCellPosition (const unsigned) const final

geom_set	getTriggerCellsFromModule (const unsigned) const final

	HGCalTriggerGeometryHexLayerBasedImp1 (const edm::ParameterSet &conf)

void	initialize (const edm::ESHandle< CaloGeometry > &) final

void	initialize (const edm::ESHandle< HGCalGeometry > &, const edm::ESHandle< HGCalGeometry > &, const edm::ESHandle< HGCalGeometry > &) final

void	reset () final

unsigned	triggerLayer (const unsigned) const final

bool	validTriggerCell (const unsigned) const final

Public Member Functions inherited from HGCalTriggerGeometryBase
const HcalGeometry *	bhGeometry () const

const HcalTopology &	bhTopology () const

const edm::ESHandle< CaloGeometry > &	caloGeometry () const

const HGCalGeometry *	eeGeometry () const

const HGCalTopology &	eeTopology () const

const HGCalGeometry *	fhGeometry () const

const HGCalTopology &	fhTopology () const

	HGCalTriggerGeometryBase (const edm::ParameterSet &conf)

const HGCalGeometry *	hscGeometry () const

const HGCalTopology &	hscTopology () const

const HGCalGeometry *	hsiGeometry () const

const HGCalTopology &	hsiTopology () const

bool	isV9Geometry () const

const std::string &	name () const

virtual	~HGCalTriggerGeometryBase ()

Private Member Functions
int	detIdWaferType (unsigned subdet, short wafer) const

void	fillInvalidTriggerCells ()

void	fillMaps ()

void	fillNeighborMaps (const edm::FileInPath &, std::unordered_map< int, std::set< std::pair< short, short >>> &)

unsigned	layerWithOffset (unsigned) const

unsigned	packIetaIphi (unsigned ieta, unsigned iphi) const

unsigned	packTriggerCell (unsigned, unsigned) const

unsigned	packWaferCellId (unsigned subdet, unsigned wafer, unsigned cell) const

void	unpackIetaIphi (unsigned ieta_iphi, unsigned &ieta, unsigned &iphi) const

void	unpackWaferCellId (unsigned wafer_cell, unsigned &wafer, unsigned &cell) const

bool	validCellId (unsigned subdet, unsigned cell_id) const

bool	validTriggerCellFromCells (const unsigned) const

Private Attributes
unsigned	bhOffset_

std::unordered_map< unsigned, unsigned >	cells_to_trigger_cells_

std::unordered_map< unsigned, unsigned >	cells_to_trigger_cells_bh_

std::unordered_set< unsigned >	disconnected_layers_

std::unordered_set< unsigned >	disconnected_modules_

unsigned	fhOffset_

std::unordered_set< unsigned >	invalid_triggercells_

edm::FileInPath	l1tCellNeighborsBHMapping_

edm::FileInPath	l1tCellNeighborsMapping_

edm::FileInPath	l1tCellsBHMapping_

edm::FileInPath	l1tCellsMapping_

edm::FileInPath	l1tModulesMapping_

std::unordered_multimap< unsigned, unsigned >	module_to_wafers_

std::unordered_map< unsigned, unsigned short >	number_trigger_cells_in_wafers_

std::unordered_map< unsigned, unsigned short >	number_trigger_cells_in_wafers_bh_

unsigned	totalLayers_

std::unordered_map< int, std::set< std::pair< short, short > > >	trigger_cell_neighbors_

std::unordered_map< int, std::set< std::pair< short, short > > >	trigger_cell_neighbors_bh_

std::unordered_multimap< unsigned, unsigned >	trigger_cells_to_cells_

std::unordered_multimap< unsigned, unsigned >	trigger_cells_to_cells_bh_

std::vector< unsigned >	trigger_layers_

std::unordered_map< unsigned, unsigned >	wafer_to_module_

Additional Inherited Members
Public Types inherited from HGCalTriggerGeometryBase
typedef std::unordered_map< unsigned, unsigned >	geom_map

typedef std::set< unsigned >	geom_ordered_set

typedef std::unordered_set< unsigned >	geom_set

Protected Member Functions inherited from HGCalTriggerGeometryBase
void	setCaloGeometry (const edm::ESHandle< CaloGeometry > &geom)

void	setEEGeometry (const edm::ESHandle< HGCalGeometry > &geom)

void	setHScGeometry (const edm::ESHandle< HGCalGeometry > &geom)

void	setHSiGeometry (const edm::ESHandle< HGCalGeometry > &geom)

Detailed Description

Definition at line 13 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

Constructor & Destructor Documentation

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

Definition at line 97 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References disconnected_layers_, disconnected_modules_, edm::ParameterSet::getParameter(), and eostools::move().

     : HGCalTriggerGeometryBase(conf),
       l1tCellsMapping_(conf.getParameter<edm::FileInPath>("L1TCellsMapping")),
       l1tCellsBHMapping_(conf.getParameter<edm::FileInPath>("L1TCellsBHMapping")),
       l1tModulesMapping_(conf.getParameter<edm::FileInPath>("L1TModulesMapping")),
       l1tCellNeighborsMapping_(conf.getParameter<edm::FileInPath>("L1TCellNeighborsMapping")),
       l1tCellNeighborsBHMapping_(conf.getParameter<edm::FileInPath>("L1TCellNeighborsBHMapping")) {
   std::vector<unsigned> tmp_vector = conf.getParameter<std::vector<unsigned>>("DisconnectedModules");
   std::move(tmp_vector.begin(), tmp_vector.end(), std::inserter(disconnected_modules_, disconnected_modules_.end()));
   tmp_vector = conf.getParameter<std::vector<unsigned>>("DisconnectedLayers");
   std::move(tmp_vector.begin(), tmp_vector.end(), std::inserter(disconnected_layers_, disconnected_layers_.end()));
 }

Member Function Documentation

int HGCalTriggerGeometryHexLayerBasedImp1::detIdWaferType	(	unsigned	subdet,
		short	wafer
	)		const

private

Definition at line 709 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalTopology::dddConstants(), HGCalTriggerGeometryBase::eeTopology(), HGCalTriggerGeometryBase::fhTopology(), HGCEE, HGCHEF, and HGCalDDDConstants::waferTypeT().

Referenced by getCellsFromTriggerCell().

                                                                                             {
   int wafer_type = 0;
   switch (subdet) {
     // HGCalDDDConstants::waferTypeT() returns 2=coarse, 1=fine
     // HGCalDetId::waferType() returns -1=coarse, 1=fine
     // Convert to HGCalDetId waferType
     case ForwardSubdetector::HGCEE:
       wafer_type = (eeTopology().dddConstants().waferTypeT(wafer) == 2 ? -1 : 1);
       break;
     case ForwardSubdetector::HGCHEF:
       wafer_type = (fhTopology().dddConstants().waferTypeT(wafer) == 2 ? -1 : 1);
       break;
     default:
       break;
   };
   return wafer_type;
 }

bool HGCalTriggerGeometryHexLayerBasedImp1::disconnectedModule ( const unsigned module_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 650 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References disconnected_layers_, disconnected_modules_, and layerWithOffset().

                                                                                              {
   bool disconnected = false;
   if (disconnected_modules_.find(HGCalDetId(module_id).wafer()) != disconnected_modules_.end())
     disconnected = true;
   if (disconnected_layers_.find(layerWithOffset(module_id)) != disconnected_layers_.end())
     disconnected = true;
   return disconnected;
 }

void HGCalTriggerGeometryHexLayerBasedImp1::fillInvalidTriggerCells ( )

private

Definition at line 593 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalTopology::dddConstants(), HGCalTriggerGeometryBase::eeTopology(), getNeighborsFromTriggerCell(), HGCEE, HGCHEF, invalid_triggercells_, HGCalDDDConstants::layers(), number_trigger_cells_in_wafers_, validTriggerCellFromCells(), and wafer_to_module_.

Referenced by initialize().

                                                                     {
   unsigned n_layers_ee = eeTopology().dddConstants().layers(true);
   for (unsigned layer = 1; layer <= n_layers_ee; layer++) {
     for (const auto& wafer_module : wafer_to_module_) {
       unsigned wafer = wafer_module.first;
       // loop on the trigger cells in each wafer
       for (int trigger_cell = 0; trigger_cell < number_trigger_cells_in_wafers_.at(wafer); trigger_cell++) {
         std::set<unsigned> trigger_cell_ids;
         trigger_cell_ids.emplace(HGCalDetId(ForwardSubdetector::HGCEE, -1, layer, 1, wafer, trigger_cell));
         trigger_cell_ids.emplace(HGCalDetId(ForwardSubdetector::HGCEE, 1, layer, 1, wafer, trigger_cell));
         trigger_cell_ids.emplace(HGCalDetId(ForwardSubdetector::HGCHEF, -1, layer, 1, wafer, trigger_cell));
         trigger_cell_ids.emplace(HGCalDetId(ForwardSubdetector::HGCHEF, 1, layer, 1, wafer, trigger_cell));
         for (unsigned trigger_cell : trigger_cell_ids) {
           if (!validTriggerCellFromCells(trigger_cell))
             invalid_triggercells_.emplace(trigger_cell);
           for (unsigned neighbor : getNeighborsFromTriggerCell(trigger_cell)) {
             if (!validTriggerCellFromCells(neighbor))
               invalid_triggercells_.emplace(neighbor);
           }
         }
       }
     }
   }
 }

void HGCalTriggerGeometryHexLayerBasedImp1::fillMaps ( )

private

Definition at line 467 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References cells_to_trigger_cells_, cells_to_trigger_cells_bh_, Exception, edm::FileInPath::fullPath(), HGCHEB, l1tCellsBHMapping_, l1tCellsMapping_, l1tModulesMapping_, module_to_wafers_, number_trigger_cells_in_wafers_, number_trigger_cells_in_wafers_bh_, packIetaIphi(), packWaferCellId(), trigger_cells_to_cells_, trigger_cells_to_cells_bh_, and wafer_to_module_.

Referenced by initialize().

                                                      {
   //
   // read module mapping file
   std::ifstream l1tModulesMappingStream(l1tModulesMapping_.fullPath());
   if (!l1tModulesMappingStream.is_open()) {
     throw cms::Exception("MissingDataFile") << "Cannot open HGCalTriggerGeometry L1TModulesMapping file\n";
   }
   short trigger_wafer = 0;
   short module = 0;
   for (; l1tModulesMappingStream >> trigger_wafer >> module;) {
     wafer_to_module_.emplace(trigger_wafer, module);
     module_to_wafers_.emplace(module, trigger_wafer);
     // Default number of trigger cell in wafer is 0
     number_trigger_cells_in_wafers_.emplace(trigger_wafer, 0);
   }
   if (!l1tModulesMappingStream.eof())
     edm::LogWarning("HGCalTriggerGeometry")
         << "Error reading L1TModulesMapping '" << trigger_wafer << " " << module << "' \n";
   l1tModulesMappingStream.close();
   // read trigger cell mapping file
   std::ifstream l1tCellsMappingStream(l1tCellsMapping_.fullPath());
   if (!l1tCellsMappingStream.is_open()) {
     throw cms::Exception("MissingDataFile") << "Cannot open HGCalTriggerGeometry L1TCellsMapping file\n";
   }
   short subdet = 0;
   short wafer = 0;
   short cell = 0;
   trigger_wafer = 0;
   short trigger_cell = 0;
   for (; l1tCellsMappingStream >> subdet >> wafer >> cell >> trigger_wafer >> trigger_cell;) {
     unsigned cell_key = packWaferCellId(subdet, wafer, cell);
     unsigned trigger_cell_key = packWaferCellId(subdet, trigger_wafer, trigger_cell);
     // fill cell <-> trigger cell mappings
     cells_to_trigger_cells_.emplace(cell_key, trigger_cell_key);
     trigger_cells_to_cells_.emplace(trigger_cell_key, cell_key);
     // fill number of trigger cells in wafers
     auto itr_insert = number_trigger_cells_in_wafers_.emplace(trigger_wafer, 0);
     if (trigger_cell + 1 > itr_insert.first->second)
       itr_insert.first->second = trigger_cell + 1;
   }
   if (!l1tCellsMappingStream.eof())
     edm::LogWarning("HGCalTriggerGeometry") << "Error reading L1TCellsMapping '" << subdet << " " << wafer << " "
                                             << cell << " " << trigger_wafer << " " << trigger_cell << "' \n";
   l1tCellsMappingStream.close();
   // read BH trigger cell mapping file
   std::ifstream l1tCellsBHMappingStream(l1tCellsBHMapping_.fullPath());
   if (!l1tCellsBHMappingStream.is_open()) {
     throw cms::Exception("MissingDataFile") << "Cannot open HGCalTriggerGeometry L1TCellsBHMapping file\n";
   }
   short ieta = 0;
   short iphi = 0;
   trigger_wafer = 0;
   trigger_cell = 0;
   for (; l1tCellsBHMappingStream >> ieta >> iphi >> trigger_wafer >> trigger_cell;) {
     unsigned cell_key = packIetaIphi(ieta, iphi);
     unsigned trigger_cell_key = packWaferCellId(ForwardSubdetector::HGCHEB, trigger_wafer, trigger_cell);
     // fill cell <-> trigger cell mappings
     cells_to_trigger_cells_bh_.emplace(cell_key, trigger_cell_key);
     trigger_cells_to_cells_bh_.emplace(trigger_cell_key, cell_key);
     // fill number of trigger cells in wafers
     auto itr_insert = number_trigger_cells_in_wafers_bh_.emplace(trigger_wafer, 0);
     if (trigger_cell + 1 > itr_insert.first->second)
       itr_insert.first->second = trigger_cell + 1;
   }
   if (!l1tCellsBHMappingStream.eof())
     edm::LogWarning("HGCalTriggerGeometry") << "Error reading L1TCellsBHMapping '" << ieta << " " << iphi << " "
                                             << trigger_wafer << " " << trigger_cell << "' \n";
   l1tCellsBHMappingStream.close();
 }

void HGCalTriggerGeometryHexLayerBasedImp1::fillNeighborMaps	(	const edm::FileInPath &	file,
		std::unordered_map< int, std::set< std::pair< short, short >>> &	neighbors_map
	)

private

Definition at line 537 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References begin, edmScanValgrind::buffer, end, Exception, edm::FileInPath::fullPath(), mps_fire::i, mps_splice::line, packTriggerCell(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by initialize().

                                                                                                     {
   // Fill trigger neighbor map
   std::ifstream l1tCellNeighborsMappingStream(file.fullPath());
   if (!l1tCellNeighborsMappingStream.is_open()) {
     throw cms::Exception("MissingDataFile") << "Cannot open HGCalTriggerGeometry L1TCellNeighborsMapping file\n";
   }
   for (std::array<char, 512> buffer; l1tCellNeighborsMappingStream.getline(&buffer[0], 512);) {
     std::string line(&buffer[0]);
     // Extract keys consisting of the module id
     // and of the trigger cell id
     // Match patterns (X,Y)
     // where X is a number with less than 4 digis
     // and Y is a number with less than 4 digits
     std::regex key_regex("\\(\\s*\\d{1,3}\\s*,\\s*\\d{1,3}\\s*\\)");
     std::vector<std::string> key_tokens{std::sregex_token_iterator(line.begin(), line.end(), key_regex), {}};
     if (key_tokens.empty()) {
       throw cms::Exception("BadGeometry") << "Syntax error in the L1TCellNeighborsMapping:\n"
                                           << "  Cannot find the trigger cell key in line:\n"
                                           << "  '" << &buffer[0] << "'\n";
     }
     std::regex digits_regex("\\d{1,3}");
     std::vector<std::string> module_tc{
         std::sregex_token_iterator(key_tokens[0].begin(), key_tokens[0].end(), digits_regex), {}};
     // get module and cell id
     int module = std::stoi(module_tc[0]);
     int trigger_cell = std::stoi(module_tc[1]);
     unsigned map_key = packTriggerCell(module, trigger_cell);
     // Extract neighbors
     // Match patterns (X,Y)
     // where X is a number with less than 4 digits
     // and Y is a number with less than 4 digits
     std::regex neighbors_regex("\\(\\s*\\d{1,3}\\s*,\\s*\\d{1,3}\\s*\\)");
     std::vector<std::string> neighbors_tokens{std::sregex_token_iterator(line.begin(), line.end(), neighbors_regex),
                                               {}};
     if (neighbors_tokens.size() < 2) {
       throw cms::Exception("BadGeometry") << "Syntax error in the L1TCellNeighborsMapping:\n"
                                           << "  Cannot find any neighbor in line:\n"
                                           << "  '" << &buffer[0] << "'\n";
     }
     auto itr_insert = neighbors_map.emplace(map_key, std::set<std::pair<short, short>>());
     // The first element is the key, so start at index 1
     for (unsigned i = 1; i < neighbors_tokens.size(); i++) {
       const auto& neighbor = neighbors_tokens[i];
       std::vector<std::string> pair_neighbor{std::sregex_token_iterator(neighbor.begin(), neighbor.end(), digits_regex),
                                              {}};
       short neighbor_module(std::stoi(pair_neighbor[0]));
       short neighbor_cell(std::stoi(pair_neighbor[1]));
       itr_insert.first->second.emplace(neighbor_module, neighbor_cell);
     }
   }
   if (!l1tCellNeighborsMappingStream.eof())
     edm::LogWarning("HGCalTriggerGeometry") << "Error reading L1TCellNeighborsMapping'\n";
   l1tCellNeighborsMappingStream.close();
 }

HGCalTriggerGeometryBase::geom_set HGCalTriggerGeometryHexLayerBasedImp1::getCellsFromModule ( const unsigned module_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 279 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References postprocess-scan-build::cells, getCellsFromTriggerCell(), and getTriggerCellsFromModule().

Referenced by getModulePosition().

                                     {
   geom_set cell_det_ids;
   geom_set trigger_cells = getTriggerCellsFromModule(module_id);
   for (auto trigger_cell_id : trigger_cells) {
     geom_set cells = getCellsFromTriggerCell(trigger_cell_id);
     cell_det_ids.insert(cells.begin(), cells.end());
   }
   return cell_det_ids;
 }

HGCalTriggerGeometryBase::geom_set HGCalTriggerGeometryHexLayerBasedImp1::getCellsFromTriggerCell ( const unsigned trigger_cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 233 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalDetId::cell(), detIdWaferType(), HcalEndcap, HGCHEB, HGCalDetId::layer(), packWaferCellId(), DetId::subdetId(), trigger_cells_to_cells_, trigger_cells_to_cells_bh_, unpackIetaIphi(), unpackWaferCellId(), validCellId(), HGCalDetId::wafer(), and HGCalDetId::zside().

Referenced by getCellsFromModule(), getOrderedCellsFromModule(), getTriggerCellPosition(), and validTriggerCellFromCells().

                                           {
   HGCalDetId trigger_cell_det_id(trigger_cell_id);
   geom_set cell_det_ids;
   // BH
   if (trigger_cell_det_id.subdetId() == ForwardSubdetector::HGCHEB) {
     unsigned subdet = trigger_cell_det_id.subdetId();
     unsigned trigger_wafer = trigger_cell_det_id.wafer();
     unsigned trigger_cell = trigger_cell_det_id.cell();
     const auto& cell_range =
         trigger_cells_to_cells_bh_.equal_range(packWaferCellId(subdet, trigger_wafer, trigger_cell));
     for (auto tc_c_itr = cell_range.first; tc_c_itr != cell_range.second; tc_c_itr++) {
       unsigned ieta = 0;
       unsigned iphi = 0;
       unpackIetaIphi(tc_c_itr->second, ieta, iphi);
       unsigned cell_det_id =
           HcalDetId(HcalEndcap, trigger_cell_det_id.zside() * ieta, iphi, trigger_cell_det_id.layer()).rawId();
       if (validCellId(subdet, cell_det_id))
         cell_det_ids.emplace(cell_det_id);
     }
   }
   // EE or FH
   else {
     unsigned subdet = trigger_cell_det_id.subdetId();
     unsigned trigger_wafer = trigger_cell_det_id.wafer();
     unsigned trigger_cell = trigger_cell_det_id.cell();
     const auto& cell_range = trigger_cells_to_cells_.equal_range(packWaferCellId(subdet, trigger_wafer, trigger_cell));
     for (auto tc_c_itr = cell_range.first; tc_c_itr != cell_range.second; tc_c_itr++) {
       unsigned wafer = 0;
       unsigned cell = 0;
       unpackWaferCellId(tc_c_itr->second, wafer, cell);
       unsigned wafer_type = (detIdWaferType(subdet, wafer) == 1 ? 1 : 0);
       unsigned cell_det_id = HGCalDetId((ForwardSubdetector)trigger_cell_det_id.subdetId(),
                                         trigger_cell_det_id.zside(),
                                         trigger_cell_det_id.layer(),
                                         wafer_type,
                                         wafer,
                                         cell)
                                  .rawId();
       if (validCellId(subdet, cell_det_id))
         cell_det_ids.emplace(cell_det_id);
     }
   }
   return cell_det_ids;
 }

unsigned HGCalTriggerGeometryHexLayerBasedImp1::getModuleFromCell ( const unsigned cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 200 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References getModuleFromTriggerCell(), and getTriggerCellFromCell().

                                                                                               {
   return getModuleFromTriggerCell(getTriggerCellFromCell(cell_id));
 }

unsigned HGCalTriggerGeometryHexLayerBasedImp1::getModuleFromTriggerCell ( const unsigned trigger_cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 204 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References Exception, HGCHEB, HGCalDetId::kHGCalCellMask, HGCalDetId::layer(), DetId::rawId(), DetId::subdetId(), HGCalDetId::wafer(), wafer_to_module_, HGCalDetId::waferType(), and HGCalDetId::zside().

Referenced by getModuleFromCell().

                                                                                                              {
   HGCalDetId trigger_cell_det_id(trigger_cell_id);
   unsigned module = 0;
   // BH
   if (trigger_cell_det_id.subdetId() == ForwardSubdetector::HGCHEB) {
     // For BH, the module ID is currently encoded as the wafer in HGCalDetId
     module = trigger_cell_det_id.wafer();
   }
   // EE or FH
   else {
     auto module_itr = wafer_to_module_.find(trigger_cell_det_id.wafer());
     if (module_itr == wafer_to_module_.end()) {
       throw cms::Exception("BadGeometry")
           << trigger_cell_det_id << "HGCalTriggerGeometry: Wafer " << trigger_cell_det_id.wafer()
           << " is not mapped to any trigger module. The module mapping should be modified. See "
              "https://twiki.cern.ch/twiki/bin/viewauth/CMS/HGCALTriggerPrimitivesSimulation#Trigger_geometry for "
              "details.\n";
     }
     module = module_itr->second;
   }
   return HGCalDetId((ForwardSubdetector)trigger_cell_det_id.subdetId(),
                     trigger_cell_det_id.zside(),
                     trigger_cell_det_id.layer(),
                     (trigger_cell_det_id.waferType() == 1 ? 1 : 0),
                     module,
                     HGCalDetId::kHGCalCellMask)
       .rawId();
 }

GlobalPoint HGCalTriggerGeometryHexLayerBasedImp1::getModulePosition ( const unsigned module_det_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 443 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References PV3DBase< T, PVType, FrameType >::basicVector(), HGCalTriggerGeometryBase::bhGeometry(), HGCalTriggerGeometryBase::eeGeometry(), HGCalTriggerGeometryBase::fhGeometry(), getCellsFromModule(), HcalGeometry::getPosition(), HGCalGeometry::getPosition(), HGCEE, HGCHEB, and DetId::subdetId().

                                                                                                        {
   unsigned subdet = HGCalDetId(module_det_id).subdetId();
   // Position: barycenter of the module.
   Basic3DVector<float> moduleVector(0., 0., 0.);
   const auto cell_ids = getCellsFromModule(module_det_id);
   // BH
   if (subdet == ForwardSubdetector::HGCHEB) {
     for (const auto& cell : cell_ids) {
       HcalDetId cellDetId(cell);
       moduleVector += bhGeometry()->getPosition(cellDetId).basicVector();
     }
   }
   // EE or FH
   else {
     for (const auto& cell : cell_ids) {
       HGCalDetId cellDetId(cell);
       moduleVector += (cellDetId.subdetId() == ForwardSubdetector::HGCEE ? eeGeometry()->getPosition(cellDetId)
                                                                          : fhGeometry()->getPosition(cellDetId))
                           .basicVector();
     }
   }
   return GlobalPoint(moduleVector / cell_ids.size());
 }

HGCalTriggerGeometryBase::geom_set HGCalTriggerGeometryHexLayerBasedImp1::getNeighborsFromTriggerCell ( const unsigned trigger_cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 385 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalDetId::cell(), Exception, HGCHEB, HGCalDetId::layer(), packTriggerCell(), DetId::subdetId(), trigger_cell_neighbors_, trigger_cell_neighbors_bh_, validTriggerCell(), HGCalDetId::wafer(), and HGCalDetId::zside().

Referenced by fillInvalidTriggerCells().

                                           {
   HGCalDetId trigger_cell_det_id(trigger_cell_id);
   // Choose scintillator or silicon map
   const auto& neighbors_map = (trigger_cell_det_id.subdetId() == ForwardSubdetector::HGCHEB ? trigger_cell_neighbors_bh_
                                                                                             : trigger_cell_neighbors_);
   unsigned module = trigger_cell_det_id.wafer();
   unsigned trigger_cell = trigger_cell_det_id.cell();
   // retrieve neighbors
   unsigned trigger_cell_key = packTriggerCell(module, trigger_cell);
   geom_set neighbor_detids;
   auto neighbors_itr = neighbors_map.find(trigger_cell_key);
   if (neighbors_itr == neighbors_map.end()) {
     throw cms::Exception("BadGeometry") << "HGCalTriggerGeometry: Neighbors are not defined for trigger cell "
                                         << trigger_cell << " in module " << module
                                         << ". The trigger cell neighbor mapping should be modified. \n";
   }
   const auto& neighbors = neighbors_itr->second;
   // create HGCalDetId of neighbors and check their validity
   neighbor_detids.reserve(neighbors.size());
   for (const auto& module_tc : neighbors) {
     HGCalDetId neighbor_det_id((ForwardSubdetector)trigger_cell_det_id.subdetId(),
                                trigger_cell_det_id.zside(),
                                trigger_cell_det_id.layer(),
                                1,
                                module_tc.first,
                                module_tc.second);
     if (validTriggerCell(neighbor_det_id.rawId())) {
       neighbor_detids.emplace(neighbor_det_id.rawId());
     }
   }
   return neighbor_detids;
 }

HGCalTriggerGeometryBase::geom_ordered_set HGCalTriggerGeometryHexLayerBasedImp1::getOrderedCellsFromModule ( const unsigned module_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 290 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References postprocess-scan-build::cells, getCellsFromTriggerCell(), and getOrderedTriggerCellsFromModule().

                                     {
   geom_ordered_set cell_det_ids;
   geom_ordered_set trigger_cells = getOrderedTriggerCellsFromModule(module_id);
   for (auto trigger_cell_id : trigger_cells) {
     geom_set cells = getCellsFromTriggerCell(trigger_cell_id);
     cell_det_ids.insert(cells.begin(), cells.end());
   }
   return cell_det_ids;
 }

HGCalTriggerGeometryBase::geom_ordered_set HGCalTriggerGeometryHexLayerBasedImp1::getOrderedTriggerCellsFromModule ( const unsigned module_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 343 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCHEB, HGCalDetId::layer(), module_to_wafers_, number_trigger_cells_in_wafers_, number_trigger_cells_in_wafers_bh_, DetId::subdetId(), validTriggerCell(), HGCalDetId::wafer(), and HGCalDetId::zside().

Referenced by getOrderedCellsFromModule().

                                     {
   HGCalDetId module_det_id(module_id);
   geom_ordered_set trigger_cell_det_ids;
   // BH
   if (module_det_id.subdetId() == ForwardSubdetector::HGCHEB) {
     unsigned module = module_det_id.wafer();
     // loop on the trigger cells in each module
     for (int trigger_cell = 0; trigger_cell < number_trigger_cells_in_wafers_bh_.at(module); trigger_cell++) {
       HGCalDetId trigger_cell_id((ForwardSubdetector)module_det_id.subdetId(),
                                  module_det_id.zside(),
                                  module_det_id.layer(),
                                  1,
                                  module,
                                  trigger_cell);
       if (validTriggerCell(trigger_cell_id))
         trigger_cell_det_ids.emplace(trigger_cell_id.rawId());
     }
   }
   // EE or FH
   else {
     unsigned module = module_det_id.wafer();
     auto wafer_itrs = module_to_wafers_.equal_range(module);
     // loop on the wafers included in the module
     for (auto wafer_itr = wafer_itrs.first; wafer_itr != wafer_itrs.second; wafer_itr++) {
       unsigned wafer = wafer_itr->second;
       // loop on the trigger cells in each wafer
       for (int trigger_cell = 0; trigger_cell < number_trigger_cells_in_wafers_.at(wafer); trigger_cell++) {
         HGCalDetId trigger_cell_id((ForwardSubdetector)module_det_id.subdetId(),
                                    module_det_id.zside(),
                                    module_det_id.layer(),
                                    1,
                                    wafer,
                                    trigger_cell);
         if (validTriggerCell(trigger_cell_id))
           trigger_cell_det_ids.emplace(trigger_cell_id.rawId());
       }
     }
   }
   return trigger_cell_det_ids;
 }

unsigned HGCalTriggerGeometryHexLayerBasedImp1::getTriggerCellFromCell ( const unsigned cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 153 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalDetId::cell(), cells_to_trigger_cells_, cells_to_trigger_cells_bh_, HcalDetId::depth(), Exception, DetId::Forward, DetId::Hcal, HcalEndcap, HGCHEB, HcalDetId::ietaAbs(), HcalDetId::iphi(), HGCalDetId::layer(), packIetaIphi(), packWaferCellId(), DetId::rawId(), DetId::subdetId(), unpackWaferCellId(), HGCalDetId::wafer(), HGCalDetId::zside(), HcalDetId::zside(), and ecaldqm::zside().

Referenced by getModuleFromCell().

                                                                                                    {
   unsigned subdet = 0;
   int zside = 0;
   unsigned layer = 0;
   unsigned wafer_trigger_cell = 0;
   unsigned trigger_cell = 0;
   // BH
   if (DetId(cell_id).det() == DetId::Hcal) {
     HcalDetId cell_det_id(cell_id);
     if (cell_det_id.subdetId() != HcalEndcap)
       return 0;
     unsigned ieta = cell_det_id.ietaAbs();
     unsigned iphi = cell_det_id.iphi();
     layer = cell_det_id.depth();
     subdet = ForwardSubdetector::HGCHEB;
     zside = cell_det_id.zside();
     auto trigger_cell_itr = cells_to_trigger_cells_bh_.find(packIetaIphi(ieta, iphi));
     if (trigger_cell_itr == cells_to_trigger_cells_bh_.end()) {
       throw cms::Exception("BadGeometry")
           << "HGCalTriggerGeometry: Hcal  cell ieta=" << ieta << ", iphi=" << iphi
           << " is not mapped to any trigger cell. The trigger cell mapping should be modified.\n";
     }
     trigger_cell = 0;
     wafer_trigger_cell = 0;
     unpackWaferCellId(trigger_cell_itr->second, wafer_trigger_cell, trigger_cell);
   }
   // EE or FH
   else if (DetId(cell_id).det() == DetId::Forward) {
     HGCalDetId cell_det_id(cell_id);
     subdet = cell_det_id.subdetId();
     layer = cell_det_id.layer();
     zside = cell_det_id.zside();
     unsigned wafer = cell_det_id.wafer();
     unsigned cell = cell_det_id.cell();
     auto trigger_cell_itr = cells_to_trigger_cells_.find(packWaferCellId(subdet, wafer, cell));
     if (trigger_cell_itr == cells_to_trigger_cells_.end()) {
       throw cms::Exception("BadGeometry")
           << "HGCalTriggerGeometry: HGCal  cell " << cell << " in wafer " << wafer
           << " is not mapped to any trigger cell. The trigger cell mapping should be modified.\n";
     }
     trigger_cell = 0;
     wafer_trigger_cell = 0;
     unpackWaferCellId(trigger_cell_itr->second, wafer_trigger_cell, trigger_cell);
   }
   return HGCalDetId((ForwardSubdetector)subdet, zside, layer, 1, wafer_trigger_cell, trigger_cell).rawId();
 }

GlobalPoint HGCalTriggerGeometryHexLayerBasedImp1::getTriggerCellPosition ( const unsigned trigger_cell_det_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 419 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References PV3DBase< T, PVType, FrameType >::basicVector(), HGCalTriggerGeometryBase::bhGeometry(), HGCalTriggerGeometryBase::eeGeometry(), HGCalTriggerGeometryBase::fhGeometry(), getCellsFromTriggerCell(), HcalGeometry::getPosition(), HGCalGeometry::getPosition(), HGCEE, HGCHEB, and DetId::subdetId().

                                                                                                                   {
   unsigned subdet = HGCalDetId(trigger_cell_det_id).subdetId();
   // Position: barycenter of the trigger cell.
   Basic3DVector<float> triggerCellVector(0., 0., 0.);
   const auto cell_ids = getCellsFromTriggerCell(trigger_cell_det_id);
   // BH
   if (subdet == ForwardSubdetector::HGCHEB) {
     for (const auto& cell : cell_ids) {
       HcalDetId cellDetId(cell);
       triggerCellVector += bhGeometry()->getPosition(cellDetId).basicVector();
     }
   }
   // EE or FH
   else {
     for (const auto& cell : cell_ids) {
       HGCalDetId cellDetId(cell);
       triggerCellVector += (cellDetId.subdetId() == ForwardSubdetector::HGCEE ? eeGeometry()->getPosition(cellDetId)
                                                                               : fhGeometry()->getPosition(cellDetId))
                                .basicVector();
     }
   }
   return GlobalPoint(triggerCellVector / cell_ids.size());
 }

HGCalTriggerGeometryBase::geom_set HGCalTriggerGeometryHexLayerBasedImp1::getTriggerCellsFromModule ( const unsigned module_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 301 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCHEB, HGCalDetId::layer(), module_to_wafers_, number_trigger_cells_in_wafers_, number_trigger_cells_in_wafers_bh_, DetId::subdetId(), validTriggerCell(), HGCalDetId::wafer(), and HGCalDetId::zside().

Referenced by getCellsFromModule().

                                     {
   HGCalDetId module_det_id(module_id);
   geom_set trigger_cell_det_ids;
   // BH
   if (module_det_id.subdetId() == ForwardSubdetector::HGCHEB) {
     unsigned module = module_det_id.wafer();
     // loop on the trigger cells in each module
     for (int trigger_cell = 0; trigger_cell < number_trigger_cells_in_wafers_bh_.at(module); trigger_cell++) {
       HGCalDetId trigger_cell_id((ForwardSubdetector)module_det_id.subdetId(),
                                  module_det_id.zside(),
                                  module_det_id.layer(),
                                  1,
                                  module,
                                  trigger_cell);
       if (validTriggerCell(trigger_cell_id))
         trigger_cell_det_ids.emplace(trigger_cell_id.rawId());
     }
   }
   // EE or FH
   else {
     unsigned module = module_det_id.wafer();
     auto wafer_itrs = module_to_wafers_.equal_range(module);
     // loop on the wafers included in the module
     for (auto wafer_itr = wafer_itrs.first; wafer_itr != wafer_itrs.second; wafer_itr++) {
       unsigned wafer = wafer_itr->second;
       // loop on the trigger cells in each wafer
       for (int trigger_cell = 0; trigger_cell < number_trigger_cells_in_wafers_.at(wafer); trigger_cell++) {
         HGCalDetId trigger_cell_id((ForwardSubdetector)module_det_id.subdetId(),
                                    module_det_id.zside(),
                                    module_det_id.layer(),
                                    1,
                                    wafer,
                                    trigger_cell);
         if (validTriggerCell(trigger_cell_id))
           trigger_cell_det_ids.emplace(trigger_cell_id.rawId());
       }
     }
   }
   return trigger_cell_det_ids;
 }

void HGCalTriggerGeometryHexLayerBasedImp1::initialize ( const edm::ESHandle< CaloGeometry > & calo_geometry )

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 123 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References bhOffset_, HGCalTriggerGeometryBase::bhTopology(), HGCalTopology::dddConstants(), HcalTopology::dddConstants(), disconnected_layers_, HGCalTriggerGeometryBase::eeTopology(), fhOffset_, HGCalTriggerGeometryBase::fhTopology(), fillInvalidTriggerCells(), fillMaps(), fillNeighborMaps(), HcalDDDRecConstants::getMaxDepth(), l1tCellNeighborsBHMapping_, l1tCellNeighborsMapping_, HGCalDDDConstants::layers(), HGCalTriggerGeometryBase::setCaloGeometry(), totalLayers_, trigger_cell_neighbors_, trigger_cell_neighbors_bh_, and trigger_layers_.

                                                                                                      {
   setCaloGeometry(calo_geometry);
   fhOffset_ = eeTopology().dddConstants().layers(true);
   bhOffset_ = fhOffset_ + fhTopology().dddConstants().layers(true);
   totalLayers_ = bhOffset_ + bhTopology().dddConstants()->getMaxDepth(1);
   trigger_layers_.resize(totalLayers_ + 1);
   trigger_layers_[0] = 0;  // layer number 0 doesn't exist
   unsigned trigger_layer = 1;
   for (unsigned layer = 1; layer < trigger_layers_.size(); layer++) {
     if (disconnected_layers_.find(layer) == disconnected_layers_.end()) {
       // Increase trigger layer number if the layer is not disconnected
       trigger_layers_[layer] = trigger_layer;
       trigger_layer++;
     } else {
       trigger_layers_[layer] = 0;
     }
   }
   fillMaps();
   fillNeighborMaps(l1tCellNeighborsMapping_, trigger_cell_neighbors_);
   fillNeighborMaps(l1tCellNeighborsBHMapping_, trigger_cell_neighbors_bh_);
   fillInvalidTriggerCells();
 }

void HGCalTriggerGeometryHexLayerBasedImp1::initialize	(	const edm::ESHandle< HGCalGeometry > &	hgc_ee_geometry,
		const edm::ESHandle< HGCalGeometry > &	hgc_hsi_geometry,
		const edm::ESHandle< HGCalGeometry > &	hgc_hsc_geometry
	)

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 146 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References Exception.

                                                                                                            {
   throw cms::Exception("BadGeometry")
       << "HGCalTriggerGeometryHexLayerBasedImp1 geometry cannot be initialized with the V9 HGCAL geometry";
 }

unsigned HGCalTriggerGeometryHexLayerBasedImp1::layerWithOffset ( unsigned id ) const

private

Definition at line 727 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References bhOffset_, DEFINE_EDM_PLUGIN, fhOffset_, HGCEE, HGCHEB, HGCHEF, HGCalDetId::layer(), and DetId::subdetId().

Referenced by disconnectedModule(), and triggerLayer().

                                                                                  {
   HGCalDetId detid(id);
   unsigned layer = 0;
   switch (detid.subdetId()) {
     case ForwardSubdetector::HGCEE:
       layer = detid.layer();
       break;
     case ForwardSubdetector::HGCHEF:
       layer = fhOffset_ + detid.layer();
       break;
     case ForwardSubdetector::HGCHEB:
       layer = bhOffset_ + detid.layer();
       break;
   };
   return layer;
 }

unsigned HGCalTriggerGeometryHexLayerBasedImp1::packIetaIphi	(	unsigned	ieta,
		unsigned	iphi
	)		const

private

Definition at line 627 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HcalDetId::kHcalEtaMask2, HcalDetId::kHcalEtaOffset2, and HcalDetId::kHcalPhiMask2.

Referenced by fillMaps(), and getTriggerCellFromCell().

                                                                                                {
   unsigned packed_value = 0;
   packed_value |= (iphi & HcalDetId::kHcalPhiMask2);
   packed_value |= ((ieta & HcalDetId::kHcalEtaMask2) << HcalDetId::kHcalEtaOffset2);
   return packed_value;
 }

unsigned HGCalTriggerGeometryHexLayerBasedImp1::packTriggerCell	(	unsigned	module,
		unsigned	trigger_cell
	)		const

private

Definition at line 702 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalDetId::kHGCalCellMask, HGCalDetId::kHGCalCellOffset, HGCalDetId::kHGCalWaferMask, and HGCalDetId::kHGCalWaferOffset.

Referenced by fillNeighborMaps(), and getNeighborsFromTriggerCell().

                                                                                                             {
   unsigned packed_value = 0;
   packed_value |= ((trigger_cell & HGCalDetId::kHGCalCellMask) << HGCalDetId::kHGCalCellOffset);
   packed_value |= ((module & HGCalDetId::kHGCalWaferMask) << HGCalDetId::kHGCalWaferOffset);
   return packed_value;
 }

unsigned HGCalTriggerGeometryHexLayerBasedImp1::packWaferCellId	(	unsigned	subdet,
		unsigned	wafer,
		unsigned	cell
	)		const

private

Definition at line 618 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalDetId::kHGCalCellMask, HGCalDetId::kHGCalCellOffset, HGCalDetId::kHGCalWaferMask, HGCalDetId::kHGCalWaferOffset, and HGCalDetId::kHGCalWaferTypeOffset.

Referenced by fillMaps(), getCellsFromTriggerCell(), and getTriggerCellFromCell().

                                                                                                                     {
   unsigned packed_value = 0;
   const int kSubdetMask = 0x7;
   packed_value |= ((cell & HGCalDetId::kHGCalCellMask) << HGCalDetId::kHGCalCellOffset);
   packed_value |= ((wafer & HGCalDetId::kHGCalWaferMask) << HGCalDetId::kHGCalWaferOffset);
   packed_value |= ((subdet & kSubdetMask) << (HGCalDetId::kHGCalWaferTypeOffset));
   return packed_value;
 }

void HGCalTriggerGeometryHexLayerBasedImp1::reset ( void )

finalvirtual

Reimplemented from HGCalTriggerGeometryBase.

Definition at line 110 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References cells_to_trigger_cells_, cells_to_trigger_cells_bh_, module_to_wafers_, number_trigger_cells_in_wafers_, number_trigger_cells_in_wafers_bh_, trigger_cell_neighbors_, trigger_cell_neighbors_bh_, trigger_cells_to_cells_, trigger_cells_to_cells_bh_, and wafer_to_module_.

                                                   {
   cells_to_trigger_cells_.clear();
   trigger_cells_to_cells_.clear();
   cells_to_trigger_cells_bh_.clear();
   trigger_cells_to_cells_bh_.clear();
   wafer_to_module_.clear();
   module_to_wafers_.clear();
   number_trigger_cells_in_wafers_.clear();
   number_trigger_cells_in_wafers_bh_.clear();
   trigger_cell_neighbors_.clear();
   trigger_cell_neighbors_bh_.clear();
 }

unsigned HGCalTriggerGeometryHexLayerBasedImp1::triggerLayer ( const unsigned id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 659 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References layerWithOffset(), and trigger_layers_.

                                                                                     {
   unsigned layer = layerWithOffset(id);
   if (layer >= trigger_layers_.size())
     return 0;
   return trigger_layers_[layer];
 }

void HGCalTriggerGeometryHexLayerBasedImp1::unpackIetaIphi	(	unsigned	ieta_iphi,
		unsigned &	ieta,
		unsigned &	iphi
	)		const

private

Definition at line 641 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HcalDetId::kHcalEtaMask2, HcalDetId::kHcalEtaOffset2, and HcalDetId::kHcalPhiMask2.

Referenced by getCellsFromTriggerCell().

                                                                                                                    {
   iphi = ieta_iphi & HcalDetId::kHcalPhiMask2;
   ieta = (ieta_iphi >> HcalDetId::kHcalEtaOffset2) & HcalDetId::kHcalEtaMask2;
 }

void HGCalTriggerGeometryHexLayerBasedImp1::unpackWaferCellId	(	unsigned	wafer_cell,
		unsigned &	wafer,
		unsigned &	cell
	)		const

private

Definition at line 634 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalDetId::kHGCalCellMask, HGCalDetId::kHGCalWaferMask, and HGCalDetId::kHGCalWaferOffset.

Referenced by getCellsFromTriggerCell(), and getTriggerCellFromCell().

                                                                                     {
   cell = wafer_cell & HGCalDetId::kHGCalCellMask;
   wafer = (wafer_cell >> HGCalDetId::kHGCalWaferOffset) & HGCalDetId::kHGCalWaferMask;
 }

bool HGCalTriggerGeometryHexLayerBasedImp1::validCellId	(	unsigned	subdet,
		unsigned	cell_id
	)		const

private

Definition at line 683 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalTriggerGeometryBase::bhTopology(), HGCalTriggerGeometryBase::eeTopology(), HGCalTriggerGeometryBase::fhTopology(), HGCEE, HGCHEB, HGCHEF, matching::is_valid(), HcalTopology::valid(), and HGCalTopology::valid().

Referenced by getCellsFromTriggerCell(), and validTriggerCellFromCells().

                                                                                                {
   bool is_valid = false;
   switch (subdet) {
     case ForwardSubdetector::HGCEE:
       is_valid = eeTopology().valid(cell_id);
       break;
     case ForwardSubdetector::HGCHEF:
       is_valid = fhTopology().valid(cell_id);
       break;
     case ForwardSubdetector::HGCHEB:
       is_valid = bhTopology().valid(cell_id);
       break;
     default:
       is_valid = false;
       break;
   }
   return is_valid;
 }

bool HGCalTriggerGeometryHexLayerBasedImp1::validTriggerCell ( const unsigned trigger_cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 646 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References invalid_triggercells_.

Referenced by getNeighborsFromTriggerCell(), getOrderedTriggerCellsFromModule(), and getTriggerCellsFromModule().

                                                                                                  {
   return invalid_triggercells_.find(trigger_cell_id) == invalid_triggercells_.end();
 }

bool HGCalTriggerGeometryHexLayerBasedImp1::validTriggerCellFromCells ( const unsigned trigger_cell_id ) const

private

Definition at line 666 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References postprocess-scan-build::cells, getCellsFromTriggerCell(), matching::is_valid(), DetId::subdetId(), and validCellId().

Referenced by fillInvalidTriggerCells().

                                                                                                           {
   // Check the validity of a trigger cell with the
   // validity of the cells. One valid cell in the
   // trigger cell is enough to make the trigger cell
   // valid.
   HGCalDetId trigger_cell_det_id(trigger_cell_id);
   unsigned subdet = trigger_cell_det_id.subdetId();
   const geom_set cells = getCellsFromTriggerCell(trigger_cell_id);
   bool is_valid = false;
   for (const auto cell_id : cells) {
     is_valid |= validCellId(subdet, cell_id);
     if (is_valid)
       break;
   }
   return is_valid;
 }