HGCalTriggerGeometryHexImp1 Class Reference

Inheritance diagram for HGCalTriggerGeometryHexImp1:

Public Member Functions
	HGCalTriggerGeometryHexImp1 (const edm::ParameterSet &conf)
void	initialize (const CaloGeometry *) final
void	initialize (const HGCalGeometry *, const HGCalGeometry *, const HGCalGeometry *) final
Public Member Functions inherited from HGCalTriggerGeometryGenericMapping
bool	disconnectedModule (const unsigned module_id) const final
geom_set	getCellsFromModule (const unsigned cell_det_id) const final
geom_set	getCellsFromTriggerCell (const unsigned cell_det_id) const final
unsigned	getLinksInModule (const unsigned module_id) const final
unsigned	getModuleFromCell (const unsigned cell_det_id) const final
unsigned	getModuleFromTriggerCell (const unsigned trigger_cell_det_id) const final
GlobalPoint	getModulePosition (const unsigned module_det_id) const final
unsigned	getModuleSize (const unsigned module_id) const final
geom_set	getNeighborsFromTriggerCell (const unsigned trigger_cell_det_id) const final
geom_ordered_set	getOrderedCellsFromModule (const unsigned cell_det_id) const final
geom_ordered_set	getOrderedTriggerCellsFromModule (const unsigned trigger_cell_det_id) const final
unsigned	getTriggerCellFromCell (const unsigned cell_det_id) const final
GlobalPoint	getTriggerCellPosition (const unsigned trigger_cell_det_id) const final
geom_set	getTriggerCellsFromModule (const unsigned trigger_cell_det_id) const final
	HGCalTriggerGeometryGenericMapping (const edm::ParameterSet &conf)
unsigned	lastTriggerLayer () const final
void	reset () final
unsigned	triggerLayer (const unsigned id) const final
bool	validTriggerCell (const unsigned trigger_cell_det_id) const final
	~HGCalTriggerGeometryGenericMapping () override
Public Member Functions inherited from HGCalTriggerGeometryBase
const HcalGeometry *	bhGeometry () const
const HcalTopology &	bhTopology () const
const 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
void	buildTriggerCellsAndModules ()
void	fillMaps ()

Private Attributes
edm::FileInPath	l1tCellsMapping_
edm::FileInPath	l1tModulesMapping_

Additional Inherited Members
Public Types inherited from HGCalTriggerGeometryGenericMapping
typedef std::unordered_map< unsigned, std::unique_ptr< const HGCalTriggerGeometry::Module > >	module_map
typedef std::unordered_map< unsigned, std::unique_ptr< const HGCalTriggerGeometry::TriggerCell > >	trigger_cell_map
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 CaloGeometry *geom)
void	setEEGeometry (const HGCalGeometry *geom)
void	setHScGeometry (const HGCalGeometry *geom)
void	setHSiGeometry (const HGCalGeometry *geom)
Protected Attributes inherited from HGCalTriggerGeometryGenericMapping
geom_map	cells_to_trigger_cells_
module_map	modules_
trigger_cell_map	trigger_cells_
geom_map	trigger_cells_to_modules_

Detailed Description

Definition at line 12 of file HGCalTriggerGeometryHexImp1.cc.

Constructor & Destructor Documentation

HGCalTriggerGeometryHexImp1::HGCalTriggerGeometryHexImp1

(

const edm::ParameterSet &

conf

)

Definition at line 28 of file HGCalTriggerGeometryHexImp1.cc.

    : HGCalTriggerGeometryGenericMapping(conf),
      l1tCellsMapping_(conf.getParameter<edm::FileInPath>("L1TCellsMapping")),
      l1tModulesMapping_(conf.getParameter<edm::FileInPath>("L1TModulesMapping"))
/*****************************************************************/
{}

Member Function Documentation

void HGCalTriggerGeometryHexImp1::buildTriggerCellsAndModules ( )

private

Definition at line 213 of file HGCalTriggerGeometryHexImp1.cc.

References HGCalTriggerGeometryGenericMapping::cells_to_trigger_cells_, DEFINE_EDM_PLUGIN, HGCalTriggerGeometryBase::eeGeometry(), HGCalTriggerGeometryBase::fhGeometry(), HGCalGeometry::getPosition(), HGCEE, HGCalTriggerGeometryGenericMapping::modules_, DetId::subdetId(), HGCalTriggerGeometryGenericMapping::trigger_cells_, and HGCalTriggerGeometryGenericMapping::trigger_cells_to_modules_.

Referenced by initialize().

{
  //
  // Build trigger cells and fill map
  typedef HGCalTriggerGeometry::TriggerCell::list_type list_cells;
  // make list of cells in trigger cells
  std::unordered_map<unsigned, list_cells> trigger_cells_to_cells;
  for (const auto& cell_triggerCell : cells_to_trigger_cells_) {
    unsigned cell = cell_triggerCell.first;
    unsigned triggerCell = cell_triggerCell.second;
    auto itr_exist = trigger_cells_to_cells.emplace(triggerCell, list_cells());
    itr_exist.first->second.emplace(cell);
    //trigger_cells_to_cells.at(triggerCell).emplace(cell);
  }
  for (const auto& triggerCell_cells : trigger_cells_to_cells) {
    unsigned triggerCellId = triggerCell_cells.first;
    list_cells cellIds = triggerCell_cells.second;
    // Position: barycenter of the trigger cell.
    Basic3DVector<float> triggerCellVector(0., 0., 0.);
    for (const auto& cell : cellIds) {
      HGCalDetId cellDetId(cell);
      triggerCellVector += (cellDetId.subdetId() == ForwardSubdetector::HGCEE ? eeGeometry()->getPosition(cellDetId)
                                                                              : fhGeometry()->getPosition(cellDetId))
                               .basicVector();
    }
    GlobalPoint triggerCellPoint(triggerCellVector / cellIds.size());
    const auto& triggerCellToModuleItr = trigger_cells_to_modules_.find(triggerCellId);
    unsigned moduleId = (triggerCellToModuleItr != trigger_cells_to_modules_.end()
                             ? triggerCellToModuleItr->second
                             : 0);  // 0 if the trigger cell doesn't belong to a module
    //unsigned moduleId = trigger_cells_to_modules_.at(triggercellId);
    // FIXME: empty neighbours
    trigger_cells_.emplace(triggerCellId,
                           std::make_unique<const HGCalTriggerGeometry::TriggerCell>(
                               triggerCellId, moduleId, triggerCellPoint, list_cells(), cellIds));
  }
  //
  // Build modules and fill map
  typedef HGCalTriggerGeometry::Module::list_type list_triggerCells;
  typedef HGCalTriggerGeometry::Module::tc_map_type tc_map_to_cells;
  // make list of trigger cells in modules
  std::unordered_map<unsigned, list_triggerCells> modules_to_trigger_cells;
  for (const auto& triggerCell_module : trigger_cells_to_modules_) {
    unsigned triggerCell = triggerCell_module.first;
    unsigned module = triggerCell_module.second;
    auto itr_exist = modules_to_trigger_cells.emplace(module, list_triggerCells());
    itr_exist.first->second.emplace(triggerCell);
    //modules_to_trigger_cells.at(module).emplace(triggerCell);
  }
  for (const auto& module_triggerCell : modules_to_trigger_cells) {
    unsigned moduleId = module_triggerCell.first;
    list_triggerCells triggerCellIds = module_triggerCell.second;
    tc_map_to_cells cellsInTriggerCells;
    // Position: barycenter of the module, from trigger cell positions
    Basic3DVector<float> moduleVector(0., 0., 0.);
    for (const auto& triggerCell : triggerCellIds) {
      const auto& cells_in_tc = trigger_cells_to_cells.at(triggerCell);
      for (const unsigned cell : cells_in_tc) {
        cellsInTriggerCells.emplace(triggerCell, cell);
      }
      moduleVector += trigger_cells_.at(triggerCell)->position().basicVector();
    }
    GlobalPoint modulePoint(moduleVector / triggerCellIds.size());
    // FIXME: empty neighbours
    modules_.emplace(moduleId,
                     std::make_unique<const HGCalTriggerGeometry::Module>(
                         moduleId, modulePoint, list_triggerCells(), triggerCellIds, cellsInTriggerCells));
  }
}

void HGCalTriggerGeometryHexImp1::fillMaps ( )

private

Definition at line 58 of file HGCalTriggerGeometryHexImp1.cc.

References HltBtagPostValidation_cff::c, HGCalTriggerGeometryGenericMapping::cells_to_trigger_cells_, HGCalTopology::dddConstants(), HGCalTriggerGeometryBase::eeGeometry(), HGCalTriggerGeometryBase::eeTopology(), HGCalTriggerGeometryBase::fhGeometry(), HGCalTriggerGeometryBase::fhTopology(), edm::FileInPath::fullPath(), HGCalDetId::kHGCalCellMask, l1tCellsMapping_, l1tModulesMapping_, HGCalDetId::layer(), HGCalDDDConstants::numberCellsHexagon(), hltrates_dqm_sourceclient-live_cfg::offset, DetId::subdetId(), HGCalTriggerGeometryGenericMapping::trigger_cells_to_modules_, HGCalDetId::wafer(), HGCalDetId::waferType(), HGCalDDDConstants::waferTypeT(), and HGCalDetId::zside().

Referenced by initialize().

{
  //
  // read module mapping file
  std::unordered_map<short, short> wafer_to_module_ee;
  std::unordered_map<short, short> wafer_to_module_fh;
  std::unordered_map<short, std::map<short, short>> module_to_wafers_ee;
  std::unordered_map<short, std::map<short, short>> module_to_wafers_fh;
  std::ifstream l1tModulesMappingStream(l1tModulesMapping_.fullPath());
  if (!l1tModulesMappingStream.is_open())
    edm::LogError("HGCalTriggerGeometry") << "Cannot open L1TModulesMapping file\n";
  short subdet = 0;
  short wafer = 0;
  short module = 0;
  for (; l1tModulesMappingStream >> subdet >> wafer >> module;) {
    if (subdet == 3) {
      wafer_to_module_ee.emplace(wafer, module);
      auto itr_insert = module_to_wafers_ee.emplace(module, std::map<short, short>());
      itr_insert.first->second.emplace(wafer, 0);
    } else if (subdet == 4) {
      wafer_to_module_fh.emplace(wafer, module);
      auto itr_insert = module_to_wafers_fh.emplace(module, std::map<short, short>());
      itr_insert.first->second.emplace(wafer, 0);
    } else
      edm::LogWarning("HGCalTriggerGeometry")
          << "Unsupported subdetector number (" << subdet << ") in L1TModulesMapping file\n";
  }
  if (!l1tModulesMappingStream.eof())
    edm::LogWarning("HGCalTriggerGeometry") << "Error reading L1TModulesMapping '" << wafer << " " << module << "' \n";
  l1tModulesMappingStream.close();
  // read trigger cell mapping file
  std::map<std::pair<short, short>, short> cells_to_trigger_cells;
  std::unordered_map<short, short> number_trigger_cells_in_wafers;  // the map key is the wafer type
  std::ifstream l1tCellsMappingStream(l1tCellsMapping_.fullPath());
  if (!l1tCellsMappingStream.is_open())
    edm::LogError("HGCalTriggerGeometry") << "Cannot open L1TCellsMapping file\n";
  short waferType = 0;
  short cell = 0;
  short triggerCell = 0;
  for (; l1tCellsMappingStream >> waferType >> cell >> triggerCell;) {
    cells_to_trigger_cells.emplace(std::make_pair((waferType ? 1 : -1), cell), triggerCell);
    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();
  // For each wafer compute the trigger cell offset according to the wafer position inside
  // the module. The first wafer will have an offset equal to 0, the second an offset equal to the
  // number of trigger cells in the first wafer, etc.
  short offset = 0;
  for (auto& module_wafers : module_to_wafers_ee) {
    offset = 0;
    for (auto& wafer_offset : module_wafers.second) {
      wafer_offset.second = offset;
      int wafer_type = (eeTopology().dddConstants().waferTypeT(wafer_offset.first) == 1 ? 1 : -1);
      offset += number_trigger_cells_in_wafers.at(wafer_type);
    }
  }
  for (auto& module_wafers : module_to_wafers_fh) {
    offset = 0;
    for (auto& wafer_offset : module_wafers.second) {
      wafer_offset.second = offset;
      int wafer_type = (fhTopology().dddConstants().waferTypeT(wafer_offset.first) == 1 ? 1 : -1);
      offset += number_trigger_cells_in_wafers.at(wafer_type);
    }
  }
  //
  // Loop over HGC cells
  // EE
  for (const auto& id : eeGeometry()->getValidGeomDetIds()) {
    if (id.rawId() == 0)
      continue;
    HGCalDetId waferDetId(id);
    short module = wafer_to_module_ee[waferDetId.wafer()];
    short triggercell_offset = module_to_wafers_ee.at(module).at(waferDetId.wafer());
    int nCells = eeTopology().dddConstants().numberCellsHexagon(waferDetId.wafer());
    for (int c = 0; c < nCells; c++) {
      short triggerCellId = cells_to_trigger_cells[std::make_pair(waferDetId.waferType(), c)];
      // Fill cell -> trigger cell mapping
      HGCalDetId cellDetId(ForwardSubdetector(waferDetId.subdetId()),
                           waferDetId.zside(),
                           waferDetId.layer(),
                           waferDetId.waferType(),
                           waferDetId.wafer(),
                           c);
      // The module id is used instead of the wafer id for the trigger cells
      // Since there are several wafers per module, an offset is applied on the HGCalDetId::cell field
      if (triggercell_offset + triggerCellId >= HGCalDetId::kHGCalCellMask)
        edm::LogError("HGCalTriggerGeometry")
            << "Trigger cell id requested with a cell field larger than available in HGCalDetId ("
            << triggercell_offset + triggerCellId << " >= " << HGCalDetId::kHGCalCellMask << ")\n";
      HGCalDetId triggerCellDetId(ForwardSubdetector(waferDetId.subdetId()),
                                  waferDetId.zside(),
                                  waferDetId.layer(),
                                  waferDetId.waferType(),
                                  module,
                                  triggercell_offset + triggerCellId);
      cells_to_trigger_cells_.emplace(cellDetId, triggerCellDetId);
      // Fill trigger cell -> module mapping
      HGCalDetId moduleDetId(ForwardSubdetector(waferDetId.subdetId()),
                             waferDetId.zside(),
                             waferDetId.layer(),
                             waferDetId.waferType(),
                             module,
                             HGCalDetId::kHGCalCellMask);
      trigger_cells_to_modules_.emplace(triggerCellDetId, moduleDetId);
    }
  }
  // FH
  for (const auto& id : fhGeometry()->getValidGeomDetIds()) {
    if (id.rawId() == 0)
      continue;
    HGCalDetId waferDetId(id);
    short module = wafer_to_module_fh[waferDetId.wafer()];
    short triggercell_offset = module_to_wafers_fh.at(module).at(waferDetId.wafer());
    int nCells = fhTopology().dddConstants().numberCellsHexagon(waferDetId.wafer());
    for (int c = 0; c < nCells; c++) {
      short triggerCellId = cells_to_trigger_cells[std::make_pair(waferDetId.waferType(), c)];
      // Fill cell -> trigger cell mapping
      HGCalDetId cellDetId(ForwardSubdetector(waferDetId.subdetId()),
                           waferDetId.zside(),
                           waferDetId.layer(),
                           waferDetId.waferType(),
                           waferDetId.wafer(),
                           c);
      // The module id is used instead of the wafer id for the trigger cells
      // Since there are several wafers per module, an offset is applied on the HGCalDetId::cell field
      if (triggercell_offset + triggerCellId >= HGCalDetId::kHGCalCellMask)
        edm::LogError("HGCalTriggerGeometry")
            << "Trigger cell id requested with a cell field larger than available in HGCalDetId ("
            << triggercell_offset + triggerCellId << " >= " << HGCalDetId::kHGCalCellMask << ")\n";
      HGCalDetId triggerCellDetId(ForwardSubdetector(waferDetId.subdetId()),
                                  waferDetId.zside(),
                                  waferDetId.layer(),
                                  waferDetId.waferType(),
                                  module,
                                  triggercell_offset + triggerCellId);
      cells_to_trigger_cells_.emplace(cellDetId, triggerCellDetId);
      // Fill trigger cell -> module mapping
      HGCalDetId moduleDetId(ForwardSubdetector(waferDetId.subdetId()),
                             waferDetId.zside(),
                             waferDetId.layer(),
                             waferDetId.waferType(),
                             module,
                             HGCalDetId::kHGCalCellMask);
      trigger_cells_to_modules_.emplace(triggerCellDetId, moduleDetId);
    }
  }
}

void HGCalTriggerGeometryHexImp1::initialize ( const CaloGeometry *  calo_geometry )

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 36 of file HGCalTriggerGeometryHexImp1.cc.

References buildTriggerCellsAndModules(), fillMaps(), and HGCalTriggerGeometryBase::setCaloGeometry().

{
  edm::LogWarning("HGCalTriggerGeometry") << "WARNING: This HGCal trigger geometry is incomplete.\n"
                                          << "WARNING: There is no neighbor information.\n";

  setCaloGeometry(calo_geometry);
  fillMaps();
  buildTriggerCellsAndModules();
}

void HGCalTriggerGeometryHexImp1::initialize ( const HGCalGeometry *  hgc_ee_geometry, const HGCalGeometry *  hgc_hsi_geometry, const HGCalGeometry *  hgc_hsc_geometry  )

finalvirtual

Implements HGCalTriggerGeometryBase.

Definition at line 48 of file HGCalTriggerGeometryHexImp1.cc.

References Exception.

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

Member Data Documentation

edm::FileInPath HGCalTriggerGeometryHexImp1::l1tCellsMapping_

private

Definition at line 20 of file HGCalTriggerGeometryHexImp1.cc.

Referenced by fillMaps().

edm::FileInPath HGCalTriggerGeometryHexImp1::l1tModulesMapping_

private

Definition at line 21 of file HGCalTriggerGeometryHexImp1.cc.

Referenced by fillMaps().