Inheritance diagram for HGCalTriggerGeometryHexImp2:

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

	HGCalTriggerGeometryHexImp2 (const edm::ParameterSet &conf)

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

virtual void	reset () 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 ()

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)

Detailed Description

Definition at line 13 of file HGCalTriggerGeometryHexImp2.cc.

Constructor & Destructor Documentation

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

Definition at line 86 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 741 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 771 of file HGCalTriggerGeometryHexImp2.cc.

References validTriggerCellFromCells().

Referenced by validTriggerCell().

 {
     return false;
 }

void HGCalTriggerGeometryHexImp2::fillInvalidTriggerCells ( )

private

Definition at line 686 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 499 of file HGCalTriggerGeometryHexImp2.cc.

References cells_to_trigger_cells_, detIdWaferType(), HGCalTriggerGeometryBase::eeTopology(), Exception, HGCalTriggerGeometryBase::fhTopology(), fillNeighborMaps(), edm::FileInPath::fullPath(), HGCEE, HGCHEF, l1tCellsMapping_, l1tModulesMapping_, python.rootplot.argparse::module, 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 567 of file HGCalTriggerGeometryHexImp2.cc.

References begin, edmScanValgrind::buffer, EnergyCorrector::c, csvReporter::delimiter, end, Exception, fillInvalidTriggerCells(), edm::FileInPath::fullPath(), HGCEE, HGCHEF, l1tCellNeighborsMapping_, l1tWaferNeighborsMapping_, geometryCSVtoXML::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.size()==0)
         {
             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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 229 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 210 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 142 of file HGCalTriggerGeometryHexImp2.cc.

References Exception, getModuleFromTriggerCell(), DetId::Hcal, HGCEE, HGCHEF, HGCalDetId::kHGCalCellMask, HGCalDetId::layer(), python.rootplot.argparse::module, 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 176 of file HGCalTriggerGeometryHexImp2.cc.

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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 482 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.size()==0) 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 382 of file HGCalTriggerGeometryHexImp2.cc.

References HGCalDetId::cell(), detIdWaferType(), Exception, getTriggerCellPosition(), HGCEE, HGCHEB, HGCHEF, HGCalDetId::layer(), packTriggerCell(), DetId::subdetId(), trigger_cell_neighbors_, cutBasedMuonId_MuonPOG_V0_cff::types, 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 267 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 342 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 122 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 465 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.size()==0) 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 304 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 )

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 111 of file HGCalTriggerGeometryHexImp2.cc.

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

Referenced by reset().

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

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

private

Definition at line 726 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 )

finaloverridevirtual

Reimplemented from HGCalTriggerGeometryBase.

Definition at line 97 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();
 }

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

private

Definition at line 798 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

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

Definition at line 763 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 778 of file HGCalTriggerGeometryHexImp2.cc.

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

Referenced by disconnectedModule(), and 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;
 }