Inheritance diagram for HGCalTriggerGeometryHexImp2:

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

	HGCalTriggerGeometryHexImp2 (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 ()

unsigned	packTriggerCell (unsigned, const std::vector< int > &) const

bool	validCellId (unsigned subdet, unsigned cell_id) const

bool	validTriggerCellFromCells (const unsigned) const

Private Attributes
std::map< std::pair< short, short >, short >	cells_to_trigger_cells_

std::unordered_set< unsigned >	invalid_triggercells_

edm::FileInPath	l1tCellNeighborsMapping_

edm::FileInPath	l1tCellsMapping_

edm::FileInPath	l1tModulesMapping_

edm::FileInPath	l1tWaferNeighborsMapping_

std::unordered_multimap< short, short >	module_to_wafers_ee_

std::unordered_multimap< short, short >	module_to_wafers_fh_

std::unordered_map< short, short >	number_cells_in_wafers_

std::unordered_map< short, short >	number_trigger_cells_in_wafers_

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

std::multimap< std::pair< short, short >, short >	trigger_cells_to_cells_

std::unordered_map< short, std::vector< short > >	wafer_neighbors_ee_

std::unordered_map< short, std::vector< short > >	wafer_neighbors_fh_

std::unordered_map< short, short >	wafer_to_module_ee_

std::unordered_map< short, short >	wafer_to_module_fh_

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 HGCalTriggerGeometryHexImp2.cc.

Constructor & Destructor Documentation

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

Definition at line 90 of file HGCalTriggerGeometryHexImp2.cc.

References reset().

                                                         :
     HGCalTriggerGeometryBase(conf),
     l1tCellsMapping_(conf.getParameter<edm::FileInPath>("L1TCellsMapping")),
     l1tCellNeighborsMapping_(conf.getParameter<edm::FileInPath>("L1TCellNeighborsMapping")),
     l1tWaferNeighborsMapping_(conf.getParameter<edm::FileInPath>("L1TWaferNeighborsMapping")),
     l1tModulesMapping_(conf.getParameter<edm::FileInPath>("L1TModulesMapping"))
 {
 }

Member Function Documentation

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

private

Definition at line 756 of file HGCalTriggerGeometryHexImp2.cc.

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

Referenced by fillInvalidTriggerCells(), fillMaps(), getCellsFromModule(), getNeighborsFromTriggerCell(), getOrderedCellsFromModule(), getOrderedTriggerCellsFromModule(), getTriggerCellsFromModule(), 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 HGCalTriggerGeometryHexImp2::disconnectedModule ( const unsigned module_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 786 of file HGCalTriggerGeometryHexImp2.cc.

References triggerLayer().

Referenced by validTriggerCell().

 {
     return false;
 }

void HGCalTriggerGeometryHexImp2::fillInvalidTriggerCells ( )

private

Definition at line 701 of file HGCalTriggerGeometryHexImp2.cc.

References HGCalTopology::dddConstants(), detIdWaferType(), HGCalTriggerGeometryBase::eeTopology(), HGCalTriggerGeometryBase::fhTopology(), HGCEE, HGCHEF, invalid_triggercells_, HGCalDDDConstants::layers(), number_trigger_cells_in_wafers_, packTriggerCell(), DetId::rawId(), validTriggerCellFromCells(), wafer_to_module_ee_, and wafer_to_module_fh_.

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_ee_)
         {
             unsigned wafer = wafer_module.first;
             int wafer_type = detIdWaferType(ForwardSubdetector::HGCEE, wafer);
             // loop on the trigger cells in each wafer
             for(int trigger_cell=0; trigger_cell<number_trigger_cells_in_wafers_.at(wafer_type); trigger_cell++)
             {
                 HGCalDetId trigger_cell_id_neg(ForwardSubdetector::HGCEE, -1, layer, wafer_type, wafer, trigger_cell);
                 HGCalDetId trigger_cell_id_pos(ForwardSubdetector::HGCEE, 1, layer, wafer_type, wafer, trigger_cell);
                 if(!validTriggerCellFromCells(trigger_cell_id_neg)) invalid_triggercells_.emplace(trigger_cell_id_neg.rawId());
                 if(!validTriggerCellFromCells(trigger_cell_id_pos)) invalid_triggercells_.emplace(trigger_cell_id_pos.rawId());
             }
         }
     }
     unsigned n_layers_fh = fhTopology().dddConstants().layers(true);
     for(unsigned layer=1; layer<=n_layers_fh; layer++)
     {
         for(const auto& wafer_module : wafer_to_module_fh_)
         {
             unsigned wafer = wafer_module.first;
             int wafer_type = detIdWaferType(ForwardSubdetector::HGCHEF, wafer);
             // loop on the trigger cells in each wafer
             for(int trigger_cell=0; trigger_cell<number_trigger_cells_in_wafers_.at(wafer_type); trigger_cell++)
             {
                 HGCalDetId trigger_cell_id_neg(ForwardSubdetector::HGCHEF, -1, layer, wafer_type, wafer, trigger_cell);
                 HGCalDetId trigger_cell_id_pos(ForwardSubdetector::HGCHEF, 1, layer, wafer_type, wafer, trigger_cell);
                 if(!validTriggerCellFromCells(trigger_cell_id_neg)) invalid_triggercells_.emplace(trigger_cell_id_neg.rawId());
                 if(!validTriggerCellFromCells(trigger_cell_id_pos)) invalid_triggercells_.emplace(trigger_cell_id_pos.rawId());
             }
         }
     }
 }

void HGCalTriggerGeometryHexImp2::fillMaps ( )

private

Definition at line 514 of file HGCalTriggerGeometryHexImp2.cc.

References cells_to_trigger_cells_, detIdWaferType(), HGCalTriggerGeometryBase::eeTopology(), Exception, HGCalTriggerGeometryBase::fhTopology(), fillNeighborMaps(), edm::FileInPath::fullPath(), HGCEE, HGCHEF, l1tCellsMapping_, l1tModulesMapping_, module_to_wafers_ee_, module_to_wafers_fh_, number_cells_in_wafers_, number_trigger_cells_in_wafers_, trigger_cells_to_cells_, wafer_to_module_ee_, and wafer_to_module_fh_.

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 subdet  = 0;
     short wafer   = 0;
     short module  = 0;
     for(; l1tModulesMappingStream>>subdet>>wafer>>module; )
     {
         int wafer_type = detIdWaferType(subdet, wafer);
         switch(subdet)
         {
             case ForwardSubdetector::HGCEE:
             {
                 // fill module <-> wafers mappings
                 wafer_to_module_ee_.emplace(wafer,module);
                 module_to_wafers_ee_.emplace(module, wafer);
                 // fill number of cells for a given wafer type
                 number_cells_in_wafers_.emplace(wafer_type, eeTopology().dddConstants().numberCellsHexagon(wafer));
                 break;
             }
             case ForwardSubdetector::HGCHEF:
             {
                 // fill module <-> wafers mappings
                 wafer_to_module_fh_.emplace(wafer,module);
                 module_to_wafers_fh_.emplace(module, wafer);
                 // fill number of cells for a given wafer type
                 number_cells_in_wafers_.emplace(wafer_type, fhTopology().dddConstants().numberCellsHexagon(wafer));
                 break;
             }
             default:
                 edm::LogWarning("HGCalTriggerGeometry") << "Unsupported subdetector number ("<<subdet<<") in L1TModulesMapping file\n";
                 break;
         }
     }
     if(!l1tModulesMappingStream.eof()) edm::LogWarning("HGCalTriggerGeometry") << "Error reading L1TModulesMapping '"<<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 waferType   = 0;
     short cell        = 0;
     short triggerCell = 0;
     for(; l1tCellsMappingStream>>waferType>>cell>>triggerCell; )
     {
         // fill cell <-> trigger cell mappings
         cells_to_trigger_cells_.emplace(std::make_pair((waferType?1:-1),cell), triggerCell);
         trigger_cells_to_cells_.emplace(std::make_pair((waferType?1:-1),triggerCell), cell);
         // fill number of cells for a given wafer type
         auto itr_insert = number_trigger_cells_in_wafers_.emplace((waferType?1:-1), 0);
         if(triggerCell+1 > itr_insert.first->second) itr_insert.first->second = triggerCell+1;
     }
     if(!l1tCellsMappingStream.eof()) edm::LogWarning("HGCalTriggerGeometry") << "Error reading L1TCellsMapping'"<<waferType<<" "<<cell<<" "<<triggerCell<<"' \n";
     l1tCellsMappingStream.close();
 }

void HGCalTriggerGeometryHexImp2::fillNeighborMaps ( )

private

Definition at line 582 of file HGCalTriggerGeometryHexImp2.cc.

References begin, edmScanValgrind::buffer, EnergyCorrector::c, csvReporter::delimiter, end, Exception, fillInvalidTriggerCells(), edm::FileInPath::fullPath(), HGCEE, HGCHEF, l1tCellNeighborsMapping_, l1tWaferNeighborsMapping_, mps_splice::line, packTriggerCell(), findQualityFiles::size, AlCaHLTBitMon_QueryRunRegistry::string, trigger_cell_neighbors_, wafer_neighbors_ee_, and wafer_neighbors_fh_.

Referenced by fillMaps(), and initialize().

 {
     // Fill trigger neighbor map
     std::ifstream l1tCellNeighborsMappingStream(l1tCellNeighborsMapping_.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 wafer configuration
         // and of the trigger cell id
         // Match patterns (X,Y) 
         // where X is a set of 7 bits
         // and Y is a number with less than 4 digits
         std::regex key_regex("\\(\\s*[01]{7}\\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("([01]{7})|(\\d{1,3})");
         std::vector<std::string>  type_tc {
             std::sregex_token_iterator(key_tokens[0].begin(), key_tokens[0].end(), digits_regex), {}
         };
         // get cell id and wafer configuration
         int trigger_cell = std::stoi(type_tc[1]);
         std::vector<int> wafer_types;
         wafer_types.reserve(type_tc[0].size());
         // Convert waferType coarse=0, fine=1 to coarse=-1, fine=1
         for(const char c : type_tc[0]) wafer_types.emplace_back( (std::stoi(std::string(&c))?1:-1) );
         unsigned map_key = packTriggerCell(trigger_cell, wafer_types);
         // Extract neighbors
         // Match patterns (X,Y) 
         // where X is a number with less than 4 digits
         // and Y is one single digit (the neighbor wafer, between 0 and 6)
         std::regex neighbors_regex("\\(\\s*\\d{1,3}\\s*,\\s*\\d\\s*\\)");
         std::vector<std::string> neighbors_tokens {
             std::sregex_token_iterator(line.begin(), line.end(), neighbors_regex), {}
         };
         if(neighbors_tokens.empty())
         {
             throw cms::Exception("BadGeometry")
                 << "Syntax error in the L1TCellNeighborsMapping:\n"
                 << "  Cannot find any neighbor in line:\n"
                 << "  '"<<&buffer[0]<<"'\n";
         }
         auto itr_insert = trigger_cell_neighbors_.emplace(map_key, std::set<std::pair<short,short>>());
         for(const auto& neighbor : neighbors_tokens)
         {
             std::vector<std::string>  pair_neighbor {
                 std::sregex_token_iterator(neighbor.begin(), neighbor.end(), digits_regex), {}
             };
             short neighbor_wafer(std::stoi(pair_neighbor[1]));
             short neighbor_cell(std::stoi(pair_neighbor[0]));
             itr_insert.first->second.emplace(neighbor_wafer, neighbor_cell);
         }
     }
     if(!l1tCellNeighborsMappingStream.eof()) edm::LogWarning("HGCalTriggerGeometry") << "Error reading L1TCellNeighborsMapping'\n";
     l1tCellNeighborsMappingStream.close();
 
     // Fill wafer neighbor map
     std::ifstream l1tWaferNeighborsMappingStream(l1tWaferNeighborsMapping_.fullPath());
     if(!l1tWaferNeighborsMappingStream.is_open())
     {
         throw cms::Exception("MissingDataFile")
             << "Cannot open HGCalTriggerGeometry L1TWaferNeighborsMapping file\n";
     }
     for(std::array<char,512> buffer; l1tWaferNeighborsMappingStream.getline(&buffer[0], 512); )
     {
         std::string line(&buffer[0]);
         // split line using spaces as delimiter
         std::regex delimiter("\\s+");
         std::vector<std::string>  tokens {
             std::sregex_token_iterator(line.begin(), line.end(), delimiter, -1), {}
         };
         if(tokens.size()!=8)
         {
             throw cms::Exception("BadGeometry")
                 << "Syntax error in the L1TWaferNeighborsMapping in line:\n"
                 << "  '"<<&buffer[0]<<"'\n"
                 << "  A line should be composed of 8 integers separated by spaces:\n"
                 << "  subdet waferid neighbor1 neighbor2 neighbor3 neighbor4 neighbor5 neighbor6\n";
         }
         short subdet(std::stoi(tokens[0]));
         short wafer(std::stoi(tokens[1]));
 
         std::unordered_map<short, std::vector<short>>* wafer_neighbors;
         switch(subdet)
         {
             case ForwardSubdetector::HGCEE:
                 wafer_neighbors = &wafer_neighbors_ee_;
                 break;
             case ForwardSubdetector::HGCHEF:
                 wafer_neighbors = &wafer_neighbors_fh_;
                 break;
             default:
                 throw cms::Exception("BadGeometry")
                     << "Unknown subdet " << subdet << " in L1TWaferNeighborsMapping:\n"
                     << "  '"<<&buffer[0]<<"'\n";
         };
         auto wafer_itr = wafer_neighbors->emplace(wafer, std::vector<short>());
         for(auto neighbor_itr=tokens.cbegin()+2; neighbor_itr!=tokens.cend(); ++neighbor_itr)
         {
             wafer_itr.first->second.emplace_back(std::stoi(*neighbor_itr));
         }
     }
 }

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

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 244 of file HGCalTriggerGeometryHexImp2.cc.

References detIdWaferType(), getOrderedCellsFromModule(), HGCEE, HGCHEB, HGCHEF, HGCalDetId::layer(), module_to_wafers_ee_, module_to_wafers_fh_, number_cells_in_wafers_, DetId::subdetId(), validCellId(), HGCalDetId::wafer(), HGCalDetId::waferType(), and HGCalDetId::zside().

Referenced by getCellsFromTriggerCell(), and getModulePosition().

 {
 
     HGCalDetId module_det_id(module_id);
     unsigned subdet = module_det_id.subdetId();
     if(subdet==ForwardSubdetector::HGCHEB) return geom_set();
     unsigned module = module_det_id.wafer();
     std::pair<std::unordered_multimap<short, short>::const_iterator,
         std::unordered_multimap<short, short>::const_iterator> wafer_itrs;
     switch(subdet)
     {
         case ForwardSubdetector::HGCEE:
             wafer_itrs = module_to_wafers_ee_.equal_range(module);
             break;
         case ForwardSubdetector::HGCHEF:
             wafer_itrs = module_to_wafers_fh_.equal_range(module);
             break;
         default:
             edm::LogError("HGCalTriggerGeometry") << "Unknown module->wafers mapping for subdet "<<subdet<<"\n";
             return geom_set();
     };
     geom_set cell_det_ids;
     for(auto wafer_itr=wafer_itrs.first; wafer_itr!=wafer_itrs.second; wafer_itr++)
     {
         int wafer_type = detIdWaferType(subdet, wafer_itr->second);
         if(wafer_type==0) wafer_type = module_det_id.waferType();
         // loop on the cells in each wafer and return valid ones
         for(int cell=0; cell<number_cells_in_wafers_.at(wafer_type); cell++)
         {
             HGCalDetId cell_id((ForwardSubdetector)module_det_id.subdetId(), module_det_id.zside(), module_det_id.layer(), wafer_type, wafer_itr->second, cell);
             if(validCellId(subdet, cell_id)) cell_det_ids.emplace(cell_id.rawId());
         }
     }
     return cell_det_ids;
 }

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

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 225 of file HGCalTriggerGeometryHexImp2.cc.

References HGCalDetId::cell(), getCellsFromModule(), HGCHEB, HGCalDetId::layer(), DetId::subdetId(), trigger_cells_to_cells_, HGCalDetId::wafer(), HGCalDetId::waferType(), and HGCalDetId::zside().

Referenced by getModuleFromTriggerCell(), getTriggerCellPosition(), and validTriggerCellFromCells().

 {
     HGCalDetId trigger_cell_det_id(trigger_cell_id);
     unsigned subdet = trigger_cell_det_id.subdetId();
     if(subdet==ForwardSubdetector::HGCHEB) return geom_set();
     int wafer_type = trigger_cell_det_id.waferType();
     unsigned trigger_cell = trigger_cell_det_id.cell();
     // FIXME: better way to do this TC->cell mapping?
     const auto& cell_range = trigger_cells_to_cells_.equal_range(std::make_pair(wafer_type,trigger_cell));
     geom_set cell_det_ids;
     for(auto tc_c_itr=cell_range.first; tc_c_itr!=cell_range.second; tc_c_itr++)
     {
         cell_det_ids.emplace(HGCalDetId((ForwardSubdetector)trigger_cell_det_id.subdetId(), trigger_cell_det_id.zside(), trigger_cell_det_id.layer(), trigger_cell_det_id.waferType(), trigger_cell_det_id.wafer(), tc_c_itr->second).rawId());
     }
     return cell_det_ids;
 }

unsigned HGCalTriggerGeometryHexImp2::getModuleFromCell ( const unsigned cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 157 of file HGCalTriggerGeometryHexImp2.cc.

References Exception, getModuleFromTriggerCell(), DetId::Hcal, HGCEE, HGCHEF, HGCalDetId::kHGCalCellMask, HGCalDetId::layer(), DetId::subdetId(), HGCalDetId::wafer(), wafer_to_module_ee_, wafer_to_module_fh_, HGCalDetId::waferType(), and HGCalDetId::zside().

Referenced by getTriggerCellFromCell().

 {
     if(DetId(cell_id).det() == DetId::Hcal) return 0;
     HGCalDetId cell_det_id(cell_id);
     unsigned wafer = cell_det_id.wafer();
     unsigned subdet = cell_det_id.subdetId();
     std::unordered_map<short, short>::const_iterator module_itr;
     bool out_of_range_error = false;
     switch(subdet)
     {
         case ForwardSubdetector::HGCEE:
             module_itr = wafer_to_module_ee_.find(wafer);
             if(module_itr==wafer_to_module_ee_.end()) out_of_range_error = true;
             break;
         case ForwardSubdetector::HGCHEF:
             module_itr = wafer_to_module_fh_.find(wafer);
             if(module_itr==wafer_to_module_fh_.end()) out_of_range_error = true;
             break;
         default:
             edm::LogError("HGCalTriggerGeometry") << "Unknown wafer->module mapping for subdet "<<subdet<<"\n";
             return 0;
     };
     if(out_of_range_error)
     {
         throw cms::Exception("BadGeometry")
             << "HGCalTriggerGeometry: Wafer " << wafer << " is not mapped to any trigger module for subdetector " << subdet
             << ". The module mapping should be modified. See https://twiki.cern.ch/twiki/bin/viewauth/CMS/HGCALTriggerPrimitivesSimulation#Trigger_geometry for details.\n";
     }
     unsigned module = module_itr->second;
     return HGCalDetId((ForwardSubdetector)cell_det_id.subdetId(), cell_det_id.zside(), cell_det_id.layer(), cell_det_id.waferType(), module, HGCalDetId::kHGCalCellMask).rawId();
 }

unsigned HGCalTriggerGeometryHexImp2::getModuleFromTriggerCell ( const unsigned trigger_cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 191 of file HGCalTriggerGeometryHexImp2.cc.

References Exception, getCellsFromTriggerCell(), HGCEE, HGCHEB, HGCHEF, HGCalDetId::kHGCalCellMask, HGCalDetId::layer(), DetId::subdetId(), HGCalDetId::wafer(), wafer_to_module_ee_, wafer_to_module_fh_, HGCalDetId::waferType(), and HGCalDetId::zside().

Referenced by getModuleFromCell().

 {
     HGCalDetId trigger_cell_det_id(trigger_cell_id);
     unsigned wafer = trigger_cell_det_id.wafer();
     unsigned subdet = trigger_cell_det_id.subdetId();
     if(subdet==ForwardSubdetector::HGCHEB) return 0;
     std::unordered_map<short, short>::const_iterator module_itr;
     bool out_of_range_error = false;
     switch(subdet)
     {
         case ForwardSubdetector::HGCEE:
             module_itr = wafer_to_module_ee_.find(wafer);
             if(module_itr==wafer_to_module_ee_.end()) out_of_range_error = true;
             break;
         case ForwardSubdetector::HGCHEF:
             module_itr = wafer_to_module_fh_.find(wafer);
             if(module_itr==wafer_to_module_fh_.end()) out_of_range_error = true;
             break;
         default:
             edm::LogError("HGCalTriggerGeometry") << "Unknown wafer->module mapping for subdet "<<subdet<<"\n";
             return 0;
     };
     if(out_of_range_error)
     {
         throw cms::Exception("BadGeometry")
             << "HGCalTriggerGeometry: Wafer " << wafer << " is not mapped to any trigger module for subdetector " << subdet
             << ". The module mapping should be modified. See https://twiki.cern.ch/twiki/bin/viewauth/CMS/HGCALTriggerPrimitivesSimulation#Trigger_geometry for details.\n";
     }
     unsigned 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 HGCalTriggerGeometryHexImp2::getModulePosition ( const unsigned module_det_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 497 of file HGCalTriggerGeometryHexImp2.cc.

References HGCalTriggerGeometryBase::eeGeometry(), HGCalTriggerGeometryBase::fhGeometry(), fillMaps(), getCellsFromModule(), HGCalGeometry::getPosition(), HGCEE, and DetId::subdetId().

Referenced by getTriggerCellPosition().

 {
     // Position: barycenter of the module.
     Basic3DVector<float> moduleVector(0.,0.,0.);
     const auto cell_ids = getCellsFromModule(module_det_id);
     if(cell_ids.empty()) return GlobalPoint(0,0,0);
     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 HGCalTriggerGeometryHexImp2::getNeighborsFromTriggerCell ( const unsigned trigger_cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 397 of file HGCalTriggerGeometryHexImp2.cc.

References HGCalDetId::cell(), detIdWaferType(), Exception, getTriggerCellPosition(), HGCEE, HGCHEB, HGCHEF, HGCalDetId::layer(), packTriggerCell(), DetId::subdetId(), trigger_cell_neighbors_, validTriggerCell(), w, HGCalDetId::wafer(), wafer_neighbors_ee_, wafer_neighbors_fh_, HGCalDetId::waferType(), and HGCalDetId::zside().

Referenced by getOrderedTriggerCellsFromModule().

 {
     HGCalDetId trigger_cell_det_id(trigger_cell_id);
     unsigned wafer = trigger_cell_det_id.wafer();
     int wafer_type = trigger_cell_det_id.waferType();
     unsigned subdet = trigger_cell_det_id.subdetId();
     unsigned trigger_cell = trigger_cell_det_id.cell();
     if(subdet==ForwardSubdetector::HGCHEB) return geom_set();
     // Retrieve surrounding wafers (around the wafer containing
     // the trigger cell)
     std::unordered_map<short, std::vector<short>>::const_iterator surrounding_wafers_itr;
     bool out_of_range_error = false;
     switch(subdet)
     {
         case ForwardSubdetector::HGCEE:
             surrounding_wafers_itr = wafer_neighbors_ee_.find(wafer);
             if(surrounding_wafers_itr==wafer_neighbors_ee_.end()) out_of_range_error = true;
             break;
         case ForwardSubdetector::HGCHEF:
             surrounding_wafers_itr = wafer_neighbors_fh_.find(wafer);
             if(surrounding_wafers_itr==wafer_neighbors_fh_.end()) out_of_range_error = true;
             break;
         default:
             edm::LogError("HGCalTriggerGeometry") << "Unknown wafer neighbours for subdet "<<subdet<<"\n";
             return geom_set();
     } 
     if(out_of_range_error)
     {
         throw cms::Exception("BadGeometry")
             << "HGCalTriggerGeometry: Neighbors are not defined for wafer " << wafer << " in subdetector " << subdet
             << ". The wafer neighbor mapping should be modified. \n";
     };
     const std::vector<short>& surrounding_wafers = surrounding_wafers_itr->second;
     // Find the types of the surrounding wafers
     std::vector<int> types;
     types.reserve(surrounding_wafers.size()+1); // includes the central wafer -> +1
     types.emplace_back(wafer_type);
     for(const auto w : surrounding_wafers)
     {
         // if no neighbor, use the same type as the central one
         // to create the wafer configuration
         int wt = wafer_type;
         if(w!=-1) wt = detIdWaferType(subdet, w);
         if(wt==0) return geom_set(); // invalid wafer type
         types.emplace_back(wt);
     }
     // retrieve neighbors
     unsigned trigger_cell_key = packTriggerCell(trigger_cell, types);
     geom_set neighbor_detids;
     auto neighbors_itr = trigger_cell_neighbors_.find(trigger_cell_key);
     if(neighbors_itr==trigger_cell_neighbors_.end())
     {
         throw cms::Exception("BadGeometry")
             << "HGCalTriggerGeometry: Neighbors are not defined for trigger cell " << trigger_cell << " with  wafer configuration "
             << std::bitset<7>(trigger_cell_key >> 8) << ". 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& wafer_tc : neighbors)
     {
         if(wafer_tc.first-1>=(int)surrounding_wafers.size())
         {
             throw cms::Exception("BadGeometry")
                 << "HGCalTriggerGeometry: Undefined wafer neighbor number "<<wafer_tc.first
                 << " for wafer " << wafer << " and trigger cell " << trigger_cell
                 << ". The neighbor mapping files should be modified.";
         }
         int neighbor_wafer = (wafer_tc.first==0 ? wafer : surrounding_wafers.at(wafer_tc.first-1));
         if(neighbor_wafer==-1) continue; // non-existing wafer
         int type = types.at(wafer_tc.first);
         HGCalDetId neighbor_det_id((ForwardSubdetector)trigger_cell_det_id.subdetId(), trigger_cell_det_id.zside(), trigger_cell_det_id.layer(), type, neighbor_wafer, wafer_tc.second);
         if(validTriggerCell(neighbor_det_id.rawId()))
         {
             neighbor_detids.emplace(neighbor_det_id.rawId());
         }
     }
     return neighbor_detids;
 }

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

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 282 of file HGCalTriggerGeometryHexImp2.cc.

References detIdWaferType(), getTriggerCellsFromModule(), HGCEE, HGCHEB, HGCHEF, HGCalDetId::layer(), module_to_wafers_ee_, module_to_wafers_fh_, number_cells_in_wafers_, DetId::subdetId(), validCellId(), HGCalDetId::wafer(), HGCalDetId::waferType(), and HGCalDetId::zside().

Referenced by getCellsFromModule().

 {
     HGCalDetId module_det_id(module_id);
     unsigned subdet = module_det_id.subdetId();
     if(subdet==ForwardSubdetector::HGCHEB) return geom_ordered_set();
     unsigned module = module_det_id.wafer();
     std::pair<std::unordered_multimap<short, short>::const_iterator,
         std::unordered_multimap<short, short>::const_iterator> wafer_itrs;
     switch(subdet)
     {
         case ForwardSubdetector::HGCEE:
             wafer_itrs = module_to_wafers_ee_.equal_range(module);
             break;
         case ForwardSubdetector::HGCHEF:
             wafer_itrs = module_to_wafers_fh_.equal_range(module);
             break;
         default:
             edm::LogError("HGCalTriggerGeometry") << "Unknown module->wafers mapping for subdet "<<subdet<<"\n";
             return geom_ordered_set();
     };
     geom_ordered_set cell_det_ids;
     for(auto wafer_itr=wafer_itrs.first; wafer_itr!=wafer_itrs.second; wafer_itr++)
     {
         int wafer_type = detIdWaferType(subdet, wafer_itr->second);
         if(wafer_type==0) wafer_type = module_det_id.waferType();
         // loop on the cells in each wafer
         for(int cell=0; cell<number_cells_in_wafers_.at(wafer_type); cell++)
         {
             HGCalDetId cell_id((ForwardSubdetector)module_det_id.subdetId(), module_det_id.zside(), module_det_id.layer(), wafer_type, wafer_itr->second, cell);
             if(validCellId(subdet, cell_id)) cell_det_ids.emplace(cell_id.rawId());
         }
     }
     return cell_det_ids;
 }

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

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 357 of file HGCalTriggerGeometryHexImp2.cc.

References detIdWaferType(), getNeighborsFromTriggerCell(), HGCEE, HGCHEB, HGCHEF, HGCalDetId::layer(), module_to_wafers_ee_, module_to_wafers_fh_, number_trigger_cells_in_wafers_, DetId::subdetId(), validTriggerCell(), HGCalDetId::wafer(), HGCalDetId::waferType(), and HGCalDetId::zside().

Referenced by getTriggerCellsFromModule().

 {
     HGCalDetId module_det_id(module_id);
     unsigned subdet = module_det_id.subdetId();
     if(subdet==ForwardSubdetector::HGCHEB) return geom_ordered_set();
     unsigned module = module_det_id.wafer();
     std::pair<std::unordered_multimap<short, short>::const_iterator,
         std::unordered_multimap<short, short>::const_iterator> wafer_itrs;
     switch(subdet)
     {
         case ForwardSubdetector::HGCEE:
             wafer_itrs = module_to_wafers_ee_.equal_range(module);
             break;
         case ForwardSubdetector::HGCHEF:
             wafer_itrs = module_to_wafers_fh_.equal_range(module);
             break;
         default:
             edm::LogError("HGCalTriggerGeometry") << "Unknown module->wafers mapping for subdet "<<subdet<<"\n";
             return geom_ordered_set();
     };
     geom_ordered_set trigger_cell_det_ids;
     // loop on the wafers included in the module
     for(auto wafer_itr=wafer_itrs.first; wafer_itr!=wafer_itrs.second; wafer_itr++)
     {
         int wafer_type = detIdWaferType(subdet, wafer_itr->second);
         if(wafer_type==0) wafer_type = module_det_id.waferType();
         // loop on the trigger cells in each wafer
         for(int trigger_cell=0; trigger_cell<number_trigger_cells_in_wafers_.at(wafer_type); trigger_cell++)
         {
             HGCalDetId trigger_cell_id((ForwardSubdetector)module_det_id.subdetId(), module_det_id.zside(), module_det_id.layer(), wafer_type, wafer_itr->second, trigger_cell);
             if(validTriggerCell(trigger_cell_id)) trigger_cell_det_ids.emplace(trigger_cell_id.rawId());
         }
     }
     return trigger_cell_det_ids;
 }

unsigned HGCalTriggerGeometryHexImp2::getTriggerCellFromCell ( const unsigned cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 137 of file HGCalTriggerGeometryHexImp2.cc.

References HGCalDetId::cell(), cells_to_trigger_cells_, Exception, getModuleFromCell(), DetId::Hcal, HGCalDetId::layer(), DetId::subdetId(), HGCalDetId::wafer(), HGCalDetId::waferType(), and HGCalDetId::zside().

Referenced by initialize().

 {
     if(DetId(cell_id).det() == DetId::Hcal) return 0;
     HGCalDetId cell_det_id(cell_id);
     int wafer_type = cell_det_id.waferType();
     unsigned cell = cell_det_id.cell();
     // FIXME: better way to do this cell->TC mapping?
     auto trigger_cell_itr = cells_to_trigger_cells_.find(std::make_pair(wafer_type,cell));
     if(trigger_cell_itr==cells_to_trigger_cells_.end())
     {
         throw cms::Exception("BadGeometry")
             << "HGCalTriggerGeometry: HGCal  cell " << cell << " is not mapped to any trigger cell for the wafer type " << wafer_type
             << ". The trigger cell mapping should be modified.\n";
     }
     unsigned trigger_cell = trigger_cell_itr->second;
     return HGCalDetId((ForwardSubdetector)cell_det_id.subdetId(), cell_det_id.zside(), cell_det_id.layer(), cell_det_id.waferType(), cell_det_id.wafer(), trigger_cell).rawId();
 }

GlobalPoint HGCalTriggerGeometryHexImp2::getTriggerCellPosition ( const unsigned trigger_cell_det_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 480 of file HGCalTriggerGeometryHexImp2.cc.

References HGCalTriggerGeometryBase::eeGeometry(), HGCalTriggerGeometryBase::fhGeometry(), getCellsFromTriggerCell(), getModulePosition(), HGCalGeometry::getPosition(), HGCEE, and DetId::subdetId().

Referenced by getNeighborsFromTriggerCell().

 {
     // Position: barycenter of the trigger cell.
     Basic3DVector<float> triggerCellVector(0.,0.,0.);
     const auto cell_ids = getCellsFromTriggerCell(trigger_cell_det_id);
     if(cell_ids.empty()) return GlobalPoint(0,0,0);
     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 HGCalTriggerGeometryHexImp2::getTriggerCellsFromModule ( const unsigned module_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 319 of file HGCalTriggerGeometryHexImp2.cc.

References detIdWaferType(), getOrderedTriggerCellsFromModule(), HGCEE, HGCHEB, HGCHEF, HGCalDetId::layer(), module_to_wafers_ee_, module_to_wafers_fh_, number_trigger_cells_in_wafers_, DetId::subdetId(), validTriggerCell(), HGCalDetId::wafer(), HGCalDetId::waferType(), and HGCalDetId::zside().

Referenced by getOrderedCellsFromModule().

 {
     HGCalDetId module_det_id(module_id);
     unsigned subdet = module_det_id.subdetId();
     if(subdet==ForwardSubdetector::HGCHEB) return geom_set();
     unsigned module = module_det_id.wafer();
     std::pair<std::unordered_multimap<short, short>::const_iterator,
         std::unordered_multimap<short, short>::const_iterator> wafer_itrs;
     switch(subdet)
     {
         case ForwardSubdetector::HGCEE:
             wafer_itrs = module_to_wafers_ee_.equal_range(module);
             break;
         case ForwardSubdetector::HGCHEF:
             wafer_itrs = module_to_wafers_fh_.equal_range(module);
             break;
         default:
             edm::LogError("HGCalTriggerGeometry") << "Unknown module->wafers mapping for subdet "<<subdet<<"\n";
             return geom_set();
     };
     geom_set trigger_cell_det_ids;
     // loop on the wafers included in the module
     for(auto wafer_itr=wafer_itrs.first; wafer_itr!=wafer_itrs.second; wafer_itr++)
     {
         int wafer_type = detIdWaferType(subdet, wafer_itr->second);
         if(wafer_type==0) wafer_type = module_det_id.waferType();
         // loop on the trigger cells in each wafer
         for(int trigger_cell=0; trigger_cell<number_trigger_cells_in_wafers_.at(wafer_type); trigger_cell++)
         {
             HGCalDetId trigger_cell_id((ForwardSubdetector)module_det_id.subdetId(), module_det_id.zside(), module_det_id.layer(), wafer_type, wafer_itr->second, trigger_cell);
             if(validTriggerCell(trigger_cell_id)) trigger_cell_det_ids.emplace(trigger_cell_id.rawId());
         }
     }
     return trigger_cell_det_ids;
 }

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

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 115 of file HGCalTriggerGeometryHexImp2.cc.

References fillInvalidTriggerCells(), fillMaps(), fillNeighborMaps(), and HGCalTriggerGeometryBase::setCaloGeometry().

Referenced by reset().

 {
     setCaloGeometry(calo_geometry);
     fillMaps();
     fillNeighborMaps();
     fillInvalidTriggerCells();
 
 }

void HGCalTriggerGeometryHexImp2::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 126 of file HGCalTriggerGeometryHexImp2.cc.

References Exception, and getTriggerCellFromCell().

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

unsigned HGCalTriggerGeometryHexImp2::packTriggerCell	(	unsigned	trigger_cell,
		const std::vector< int > &	wafer_types
	)		const

private

Definition at line 741 of file HGCalTriggerGeometryHexImp2.cc.

References detIdWaferType(), mps_fire::i, and globals_cff::x1.

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

 {
     unsigned packed_value = trigger_cell;
     for(unsigned i=0; i<wafer_types.size(); i++)
     {
         // trigger cell id on 8 bits
         // wafer configuration bits: 0=coarse, 1=fine
         if(wafer_types.at(i)==1) packed_value += (0x1<<(8+i));
     }
     return packed_value;
 }

void HGCalTriggerGeometryHexImp2::reset ( void )

finalvirtual

Reimplemented from HGCalTriggerGeometryBase.

Definition at line 101 of file HGCalTriggerGeometryHexImp2.cc.

References cells_to_trigger_cells_, initialize(), module_to_wafers_ee_, module_to_wafers_fh_, number_cells_in_wafers_, number_trigger_cells_in_wafers_, trigger_cells_to_cells_, wafer_to_module_ee_, and wafer_to_module_fh_.

Referenced by HGCalTriggerGeometryHexImp2().

 {
     wafer_to_module_ee_.clear();
     wafer_to_module_fh_.clear();
     module_to_wafers_ee_.clear();
     module_to_wafers_fh_.clear();
     cells_to_trigger_cells_.clear();
     trigger_cells_to_cells_.clear();
     number_trigger_cells_in_wafers_.clear();
     number_cells_in_wafers_.clear();
 }

unsigned HGCalTriggerGeometryHexImp2::triggerLayer ( const unsigned id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 794 of file HGCalTriggerGeometryHexImp2.cc.

References HGCalDetId::layer(), and validTriggerCellFromCells().

Referenced by disconnectedModule().

 {
     return HGCalDetId(id).layer();
 }

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

private

Definition at line 821 of file HGCalTriggerGeometryHexImp2.cc.

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

Referenced by getCellsFromModule(), getOrderedCellsFromModule(), 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;
         default:
             is_valid = false;
             break;
     } 
     return is_valid;
 }

bool HGCalTriggerGeometryHexImp2::validTriggerCell ( const unsigned trigger_cell_id ) const

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 778 of file HGCalTriggerGeometryHexImp2.cc.

References disconnectedModule(), and invalid_triggercells_.

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

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

bool HGCalTriggerGeometryHexImp2::validTriggerCellFromCells ( const unsigned trigger_cell_id ) const

private

Definition at line 801 of file HGCalTriggerGeometryHexImp2.cc.

References postprocess-scan-build::cells, 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;
 }