HGCalTriggerNtupleHGCPanels.cc

Go to the documentation of this file.

#include "DataFormats/L1THGCal/interface/HGCalTriggerCell.h"
#include "DataFormats/ForwardDetId/interface/HGCalDetId.h"
#include "Geometry/Records/interface/CaloGeometryRecord.h"
#include "L1Trigger/L1THGCal/interface/HGCalTriggerGeometryBase.h"
#include "L1Trigger/L1THGCal/interface/HGCalTriggerNtupleBase.h"



class HGCalTriggerNtupleHGCPanels : public HGCalTriggerNtupleBase
{

  public:
    HGCalTriggerNtupleHGCPanels(const edm::ParameterSet& conf);
    ~HGCalTriggerNtupleHGCPanels() override{};   
    void initialize(TTree&, const edm::ParameterSet&, edm::ConsumesCollector&&) final;
    void fill(const edm::Event& e, const edm::EventSetup& es) final;

  private:
    void clear() final;


    edm::EDGetToken trigger_cells_token_;
    edm::ESHandle<HGCalTriggerGeometryBase> geometry_;

    int panel_n_ ;
    std::vector<uint32_t> panel_id_;
    std::vector<int> panel_zside_;
    std::vector<int> panel_layer_;
    std::vector<int> panel_sector_;
    std::vector<int> panel_number_;
    std::vector<unsigned> panel_tc_n_;
    std::vector<std::vector<uint32_t> > panel_tc_id_;
    std::vector<std::vector<uint32_t> > panel_tc_mod_;
    std::vector<std::vector<uint32_t> > panel_tc_third_;
    std::vector<std::vector<uint32_t> > panel_tc_cell_;
    std::vector<std::vector<float> > panel_tc_mipPt_;
    std::vector<std::vector<float> > panel_tc_pt_;

  private:
    static const unsigned kPanel_offset_ = 0;
    static const unsigned kPanel_mask_ = 0x1F;
    static const unsigned kSector_offset_ = 5;
    static const unsigned kSector_mask_ = 0x7;
    static const unsigned kThird_offset_ = 4;
    static const unsigned kThird_mask_ = 0x3;
    static const unsigned kCell_mask_ = 0xF;

};

DEFINE_EDM_PLUGIN(HGCalTriggerNtupleFactory,
    HGCalTriggerNtupleHGCPanels,
    "HGCalTriggerNtupleHGCPanels" );


HGCalTriggerNtupleHGCPanels::
HGCalTriggerNtupleHGCPanels(const edm::ParameterSet& conf):HGCalTriggerNtupleBase(conf)
{
}

void
HGCalTriggerNtupleHGCPanels::
initialize(TTree& tree, const edm::ParameterSet& conf, edm::ConsumesCollector&& collector)
{
  trigger_cells_token_ = collector.consumes<l1t::HGCalTriggerCellBxCollection>(conf.getParameter<edm::InputTag>("TriggerCells"));

  tree.Branch("panel_n", &panel_n_, "panel_n/I");  
  tree.Branch("panel_id", &panel_id_);           
  tree.Branch("panel_zside", &panel_zside_);
  tree.Branch("panel_layer", &panel_layer_);
  tree.Branch("panel_sector", &panel_sector_);
  tree.Branch("panel_number", &panel_number_);
  tree.Branch("panel_tc_n", &panel_tc_n_);         
  tree.Branch("panel_tc_id", &panel_tc_id_); 
  tree.Branch("panel_tc_mod", &panel_tc_mod_); 
  tree.Branch("panel_tc_third", &panel_tc_third_); 
  tree.Branch("panel_tc_cell", &panel_tc_cell_); 
  tree.Branch("panel_tc_mipPt", &panel_tc_mipPt_); 
  tree.Branch("panel_tc_pt", &panel_tc_pt_); 

}

void
HGCalTriggerNtupleHGCPanels::
fill(const edm::Event& e, const edm::EventSetup& es)
{

  // retrieve trigger cells
  edm::Handle<l1t::HGCalTriggerCellBxCollection> trigger_cells_h;
  e.getByToken(trigger_cells_token_, trigger_cells_h);
  const l1t::HGCalTriggerCellBxCollection& trigger_cells = *trigger_cells_h;

  // retrieve geometry
  es.get<CaloGeometryRecord>().get(geometry_);

  clear();

  // Regroup trigger cells by panel
  std::unordered_map< uint32_t,vector<l1t::HGCalTriggerCellBxCollection::const_iterator> > panelids_tcs;
  for(auto tc_itr=trigger_cells.begin(0); tc_itr!=trigger_cells.end(0); tc_itr++)
  {
    if(tc_itr->hwPt()>0 && tc_itr->subdetId()!=ForwardSubdetector::HGCHEB)
    {
      HGCalDetId id(tc_itr->detId());
      HGCalDetId panelid(geometry_->getModuleFromTriggerCell(id));
      panelids_tcs[panelid].push_back(tc_itr);
    }
  }
    for (const auto& panelid_tcs : panelids_tcs)
  {
    panel_n_++;
    HGCalDetId panelid(panelid_tcs.first);
    int panel_sector = (panelid.wafer()>>kSector_offset_) & kSector_mask_ ;
    int panel_number = (panelid.wafer()>>kPanel_offset_) & kPanel_mask_ ;
    const auto& tcs = panelid_tcs.second;
    panel_id_.emplace_back(panelid);
    panel_zside_.emplace_back(panelid.zside());
    panel_layer_.emplace_back(geometry_->triggerLayer(panelid));
    panel_sector_.emplace_back(panel_sector);
    panel_number_.emplace_back(panel_number);
    panel_tc_n_.emplace_back(tcs.size());
    panel_tc_id_.emplace_back();
    panel_tc_mod_.emplace_back();
    panel_tc_third_.emplace_back();
    panel_tc_cell_.emplace_back();
    panel_tc_mipPt_.emplace_back();
    panel_tc_pt_.emplace_back();

    for (const auto& tc : tcs)
    {
      panel_tc_id_.back().push_back(tc->detId());
      panel_tc_mipPt_.back().push_back(tc->mipPt());
      panel_tc_pt_.back().push_back(tc->pt());
      HGCalDetId tc_detid(tc->detId());
      unsigned module_id = tc_detid.wafer();
      unsigned third_id = (tc_detid.cell()>>kThird_offset_) & kThird_mask_;
      unsigned cell_id = tc_detid.cell() & kCell_mask_;
      panel_tc_mod_.back().push_back(module_id);
      panel_tc_third_.back().push_back(third_id);
      panel_tc_cell_.back().push_back(cell_id);
    }
  }
}


void
HGCalTriggerNtupleHGCPanels::
clear()
{
  panel_n_ = 0;
  panel_id_.clear();
  panel_zside_.clear();
  panel_layer_.clear();
  panel_sector_.clear();
  panel_number_.clear();
  panel_tc_n_.clear();
  panel_tc_id_.clear();
  panel_tc_mod_.clear();
  panel_tc_third_.clear();
  panel_tc_cell_.clear();
  panel_tc_mipPt_.clear();
  panel_tc_pt_.clear();
}