HGCalTriggerGeometryHexImp1 Class Reference

Inheritance diagram for HGCalTriggerGeometryHexImp1:

Public Member Functions
	HGCalTriggerGeometryHexImp1 (const edm::ParameterSet &conf)
virtual void	initialize (const edm::ESHandle< CaloGeometry > &) override final
Public Member Functions inherited from HGCalTriggerGeometryGenericMapping
bool	disconnectedModule (const unsigned module_id) const final
virtual geom_set	getCellsFromModule (const unsigned cell_det_id) const override final
virtual geom_set	getCellsFromTriggerCell (const unsigned cell_det_id) const override final
virtual unsigned	getModuleFromCell (const unsigned cell_det_id) const override final
virtual unsigned	getModuleFromTriggerCell (const unsigned trigger_cell_det_id) const override final
virtual GlobalPoint	getModulePosition (const unsigned module_det_id) const override final
virtual geom_set	getNeighborsFromTriggerCell (const unsigned trigger_cell_det_id) const override final
virtual geom_ordered_set	getOrderedCellsFromModule (const unsigned cell_det_id) const override final
virtual geom_ordered_set	getOrderedTriggerCellsFromModule (const unsigned trigger_cell_det_id) const override final
virtual unsigned	getTriggerCellFromCell (const unsigned cell_det_id) const override final
virtual GlobalPoint	getTriggerCellPosition (const unsigned trigger_cell_det_id) const override final
virtual geom_set	getTriggerCellsFromModule (const unsigned trigger_cell_det_id) const override final
	HGCalTriggerGeometryGenericMapping (const edm::ParameterSet &conf)
virtual void	reset () override final
unsigned	triggerLayer (const unsigned id) const final
bool	validTriggerCell (const unsigned trigger_cell_det_id) const final
virtual	~HGCalTriggerGeometryGenericMapping ()
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
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 edm::ESHandle< CaloGeometry > &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 29 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 179 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 54 of file HGCalTriggerGeometryHexImp1.cc.

References EnergyCorrector::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(), python.rootplot.argparse::module, HGCalDDDConstants::numberCellsHexagon(), PFRecoTauDiscriminationByIsolation_cfi::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 edm::ESHandle< CaloGeometry > &  calo_geometry )

finaloverridevirtual

Implements HGCalTriggerGeometryBase.

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

}

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