Inheritance diagram for HGCalTriggerGeometryHexLayerBasedImp1:

Public Member Functions
virtual bool	disconnectedModule (const unsigned) const override final

virtual geom_set	getCellsFromModule (const unsigned) const override final

virtual geom_set	getCellsFromTriggerCell (const unsigned) const override final

virtual unsigned	getModuleFromCell (const unsigned) const override final

virtual unsigned	getModuleFromTriggerCell (const unsigned) const override final

virtual GlobalPoint	getModulePosition (const unsigned) const override final

virtual geom_set	getNeighborsFromTriggerCell (const unsigned) const override final

virtual geom_ordered_set	getOrderedCellsFromModule (const unsigned) const override final

virtual geom_ordered_set	getOrderedTriggerCellsFromModule (const unsigned) const override final

virtual unsigned	getTriggerCellFromCell (const unsigned) const override final

virtual GlobalPoint	getTriggerCellPosition (const unsigned) const override final

virtual geom_set	getTriggerCellsFromModule (const unsigned) const override final

	HGCalTriggerGeometryHexLayerBasedImp1 (const edm::ParameterSet &conf)

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

virtual void	reset () override final

virtual unsigned	triggerLayer (const unsigned) const override final

virtual bool	validTriggerCell (const unsigned) const override 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 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)

Detailed Description

Definition at line 14 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

Constructor & Destructor Documentation

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

Definition at line 98 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

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

                                                                   :
     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 785 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

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

Referenced by getCellsFromTriggerCell(), and packTriggerCell().

 {
     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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 712 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References disconnected_layers_, disconnected_modules_, layerWithOffset(), and triggerLayer().

Referenced by validTriggerCell().

 {
     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 634 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

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

Referenced by fillNeighborMaps(), and 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 486 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References cells_to_trigger_cells_, cells_to_trigger_cells_bh_, Exception, fillNeighborMaps(), edm::FileInPath::fullPath(), HGCHEB, l1tCellsBHMapping_, l1tCellsMapping_, l1tModulesMapping_, python.rootplot.argparse::module, 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 getModulePosition(), and 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 561 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

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

Referenced by fillMaps(), and 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.size()<1)
         {
             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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 288 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References getCellsFromTriggerCell(), getOrderedCellsFromModule(), and getTriggerCellsFromModule().

Referenced by getCellsFromTriggerCell(), and 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 246 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalDetId::cell(), detIdWaferType(), getCellsFromModule(), 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(), getModuleFromTriggerCell(), 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);
             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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 212 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References getModuleFromTriggerCell(), and getTriggerCellFromCell().

Referenced by getTriggerCellFromCell().

 {
     return getModuleFromTriggerCell(getTriggerCellFromCell(cell_id));
 }

unsigned HGCalTriggerGeometryHexLayerBasedImp1::getModuleFromTriggerCell ( const unsigned trigger_cell_id ) const

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 219 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References Exception, getCellsFromTriggerCell(), HGCHEB, HGCalDetId::kHGCalCellMask, HGCalDetId::layer(), python.rootplot.argparse::module, 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(), module, HGCalDetId::kHGCalCellMask).rawId();
 }

GlobalPoint HGCalTriggerGeometryHexLayerBasedImp1::getModulePosition ( const unsigned module_det_id ) const

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 456 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

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

Referenced by getTriggerCellPosition().

 {
     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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 392 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

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

Referenced by fillInvalidTriggerCells(), and getOrderedTriggerCellsFromModule().

 {
     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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 302 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References getCellsFromTriggerCell(), getOrderedTriggerCellsFromModule(), and getTriggerCellsFromModule().

Referenced by getCellsFromModule().

 {
     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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 353 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References getNeighborsFromTriggerCell(), HGCHEB, HGCalDetId::layer(), python.rootplot.argparse::module, 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(), and getTriggerCellsFromModule().

 {
     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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 160 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

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

Referenced by getModuleFromCell(), and initialize().

 {
     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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 426 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

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

Referenced by getNeighborsFromTriggerCell().

 {
     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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 316 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References getOrderedTriggerCellsFromModule(), HGCHEB, HGCalDetId::layer(), python.rootplot.argparse::module, 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(), and getOrderedCellsFromModule().

 {
     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 )

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 130 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

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

Referenced by reset().

 {
     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);
     unsigned trigger_layer = 0;
     for(unsigned layer=0; 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();
 
 }

unsigned HGCalTriggerGeometryHexLayerBasedImp1::layerWithOffset ( unsigned id ) const

private

Definition at line 808 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

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

Referenced by detIdWaferType(), 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 678 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HcalDetId::kHcalEtaMask2, HcalDetId::kHcalEtaOffset2, HcalDetId::kHcalPhiMask2, and unpackWaferCellId().

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

 {
     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 775 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References detIdWaferType(), HGCalDetId::kHGCalCellMask, HGCalDetId::kHGCalCellOffset, HGCalDetId::kHGCalWaferMask, and HGCalDetId::kHGCalWaferOffset.

Referenced by fillNeighborMaps(), getNeighborsFromTriggerCell(), and validCellId().

 {
     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 665 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalDetId::kHGCalCellMask, HGCalDetId::kHGCalCellOffset, HGCalDetId::kHGCalWaferMask, HGCalDetId::kHGCalWaferOffset, HGCalDetId::kHGCalWaferTypeOffset, and packIetaIphi().

Referenced by fillInvalidTriggerCells(), 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 )

finaloverridevirtual

Reimplemented from HGCalTriggerGeometryBase.

Definition at line 114 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References cells_to_trigger_cells_, cells_to_trigger_cells_bh_, initialize(), 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_.

Referenced by HGCalTriggerGeometryHexLayerBasedImp1().

 {
     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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 722 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References layerWithOffset(), trigger_layers_, and validTriggerCellFromCells().

Referenced by disconnectedModule().

 {
     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 697 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HcalDetId::kHcalEtaMask2, HcalDetId::kHcalEtaOffset2, HcalDetId::kHcalPhiMask2, and validTriggerCell().

Referenced by getCellsFromTriggerCell(), and unpackWaferCellId().

 {
     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 688 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalDetId::kHGCalCellMask, HGCalDetId::kHGCalWaferMask, HGCalDetId::kHGCalWaferOffset, and unpackIetaIphi().

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

 {
     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 751 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References HGCalTriggerGeometryBase::bhTopology(), HGCalTriggerGeometryBase::eeTopology(), HGCalTriggerGeometryBase::fhTopology(), HGCEE, HGCHEB, HGCHEF, matching::is_valid(), packTriggerCell(), 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 705 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References disconnectedModule(), and invalid_triggercells_.

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

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

bool HGCalTriggerGeometryHexLayerBasedImp1::validTriggerCellFromCells ( const unsigned trigger_cell_id ) const

private

Definition at line 731 of file HGCalTriggerGeometryHexLayerBasedImp1.cc.

References getCellsFromTriggerCell(), matching::is_valid(), DetId::subdetId(), and validCellId().

Referenced by fillInvalidTriggerCells(), and triggerLayer().

 {
     // 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;
 }