#include <GEMStripDigiValidation.h>

Inheritance diagram for GEMStripDigiValidation:

Public Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &) override

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

	GEMStripDigiValidation (const edm::ParameterSet &)

	~GEMStripDigiValidation () override

Public Member Functions inherited from GEMBaseValidation
MonitorElement *	BookHistXY (DQMStore::IBooker &, const char name, const char label, unsigned int region_num, unsigned int station_num, unsigned int layer_num=99)

MonitorElement *	BookHistZR (DQMStore::IBooker &, const char name, const char label, unsigned int region_num, unsigned int station_num, unsigned int layer_num=99)

	GEMBaseValidation (const edm::ParameterSet &ps)

MonitorElement *	getDCEta (DQMStore::IBooker &, const GEMStation *, TString, TString)

MonitorElement *	getSimpleZR (DQMStore::IBooker &, TString, TString)

std::string	getStationLabel (int i)

std::string	getSuffixName (int region, int station, int layer)

std::string	getSuffixName (int region, int station)

std::string	getSuffixName (int region)

std::string	getSuffixTitle (int region, int station, int layer)

std::string	getSuffixTitle (int region, int station)

std::string	getSuffixTitle (int region)

const GEMGeometry *	initGeometry (const edm::EventSetup &)

unsigned int	nPart ()

unsigned int	nRegion ()

unsigned int	nStation ()

unsigned int	nStationForLabel ()

void	setNStationForLabel (unsigned int number)

	~GEMBaseValidation () override

Public Member Functions inherited from one::DQMEDAnalyzer< T >
	DQMEDAnalyzer ()=default

	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete

	~DQMEDAnalyzer () override=default

Private Attributes
bool	detailPlot_

edm::EDGetToken	InputTagToken_

int	nBinXY_

MonitorElement *	theStrip [2][3][2]

MonitorElement *	theStrip_bx [2][3][2]

std::unordered_map< UInt_t, MonitorElement * >	theStrip_dcEta

MonitorElement *	theStrip_phistrip [2][3][2]

std::unordered_map< UInt_t, MonitorElement * >	theStrip_simple_zr

MonitorElement *	theStrip_xy [2][3][2]

std::unordered_map< UInt_t, MonitorElement * >	theStrip_xy_ch

MonitorElement *	theStrip_zr [2][3][2]

Additional Inherited Members
Protected Attributes inherited from GEMBaseValidation
int	nBinXY_

std::vector< double >	nBinZR_

std::vector< double >	RangeZR_

Detailed Description

Definition at line 9 of file GEMStripDigiValidation.h.

Constructor & Destructor Documentation

GEMStripDigiValidation::GEMStripDigiValidation ( const edm::ParameterSet & cfg )

explicit

Definition at line 6 of file GEMStripDigiValidation.cc.

References detailPlot_, edm::ParameterSet::getParameter(), and InputTagToken_.

                                                                          : GEMBaseValidation(cfg) {
   InputTagToken_ = consumes<GEMDigiCollection>(cfg.getParameter<edm::InputTag>("stripLabel"));
   detailPlot_ = cfg.getParameter<bool>("detailPlot");
 }

GEMStripDigiValidation::~GEMStripDigiValidation ( )

override

Definition at line 113 of file GEMStripDigiValidation.cc.

113 {}

Member Function Documentation

void GEMStripDigiValidation::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Implements GEMBaseValidation.

Definition at line 115 of file GEMStripDigiValidation.cc.

References GEMEtaPartition::centreOfStrip(), relativeConstraints::chamber, gather_cfg::cout, detailPlot_, GEMGeometry::etaPartition(), MonitorElement::Fill(), edm::EventSetup::get(), GEMBaseValidation::getSuffixName(), runTauDisplay::gp, GEMGeometry::idToDet(), InputTagToken_, edm::HandleBase::isValid(), PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), AlCaHLTBitMon_QueryRunRegistry::string, digitizers_cfi::strip, GeomDet::surface(), theStrip, theStrip_bx, theStrip_dcEta, theStrip_phistrip, theStrip_simple_zr, theStrip_xy, theStrip_xy_ch, theStrip_zr, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                    {
   const GEMGeometry *GEMGeometry_;
   try {
     edm::ESHandle<GEMGeometry> hGeom;
     iSetup.get<MuonGeometryRecord>().get(hGeom);
     GEMGeometry_ = &*hGeom;
   } catch (edm::eventsetup::NoProxyException<GEMGeometry> &e) {
     edm::LogError("GEMStripDigiValidation") << "+++ Error : GEM geometry is unavailable on event loop. +++\n";
     return;
   }
 
   edm::Handle<GEMDigiCollection> gem_digis;
   e.getByToken(this->InputTagToken_, gem_digis);
   if (!gem_digis.isValid()) {
     edm::LogError("GEMStripDigiValidation") << "Cannot get strips by Token stripToken.\n";
     return;
   }
   for (GEMDigiCollection::DigiRangeIterator cItr = gem_digis->begin(); cItr != gem_digis->end(); cItr++) {
     GEMDetId id = (*cItr).first;
 
     const GeomDet *gdet = GEMGeometry_->idToDet(id);
     if (gdet == nullptr) {
       std::cout << "Getting DetId failed. Discard this gem strip hit.Maybe it "
                    "comes from unmatched geometry."
                 << std::endl;
       continue;
     }
     const BoundPlane &surface = gdet->surface();
     const GEMEtaPartition *roll = GEMGeometry_->etaPartition(id);
 
     int re = id.region();
     int la = id.layer();
     int st = id.station();
     Short_t chamber = (Short_t)id.chamber();
     Short_t nroll = (Short_t)id.roll();
 
     GEMDigiCollection::const_iterator digiItr;
     for (digiItr = (*cItr).second.first; digiItr != (*cItr).second.second; ++digiItr) {
       Short_t strip = (Short_t)digiItr->strip();
       Short_t bx = (Short_t)digiItr->bx();
 
       LocalPoint lp = roll->centreOfStrip(digiItr->strip());
 
       GlobalPoint gp = surface.toGlobal(lp);
       Float_t g_r = (Float_t)gp.perp();
       // Float_t g_eta = (Float_t) gp.eta();
       Float_t g_phi = (Float_t)gp.phi();
       Float_t g_x = (Float_t)gp.x();
       Float_t g_y = (Float_t)gp.y();
       Float_t g_z = (Float_t)gp.z();
 
       int region_num = (re + 1) / 2;
       int station_num = st - 1;
       int layer_num = la - 1;
 
       int binX = (chamber - 1) * 2 + layer_num;
       int binY = nroll;
 
       // Fill normal plots.
       TString histname_suffix = getSuffixName(re);
       TString simple_zr_histname = TString::Format("strip_simple_zr%s", histname_suffix.Data());
       theStrip_simple_zr[simple_zr_histname.Hash()]->Fill(fabs(g_z), g_r);
 
       histname_suffix = getSuffixName(re, st);
       TString dcEta_histname = TString::Format("strip_dcEta%s", histname_suffix.Data());
       theStrip_dcEta[dcEta_histname.Hash()]->Fill(binX, binY);
 
       // Fill detail plots.
       if (detailPlot_) {
         if (theStrip_xy[region_num][station_num][layer_num] != nullptr) {
           theStrip_xy[region_num][station_num][layer_num]->Fill(g_x, g_y);
           theStrip_phistrip[region_num][station_num][layer_num]->Fill(g_phi, strip);
           theStrip[region_num][station_num][layer_num]->Fill(strip);
           theStrip_bx[region_num][station_num][layer_num]->Fill(bx);
           theStrip_zr[region_num][station_num][layer_num]->Fill(g_z, g_r);
 
           std::string name_prefix = getSuffixName(re, st, la);
           TString hname;
           if (chamber % 2 == 0) {
             hname = TString::Format("strip_dg_xy%s_even", name_prefix.c_str());
           } else {
             hname = TString::Format("strip_dg_xy%s_odd", name_prefix.c_str());
           }
           theStrip_xy_ch[hname.Hash()]->Fill(g_x, g_y);
         } else {
           std::cout << "Error is occued when histograms is called." << std::endl;
         }
       }
     }
   }
 }

void GEMStripDigiValidation::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	Run,
		edm::EventSetup const &	iSetup
	)

override

Definition at line 11 of file GEMStripDigiValidation.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), GEMBaseValidation::BookHistXY(), GEMBaseValidation::BookHistZR(), detailPlot_, GEMBaseValidation::getDCEta(), GEMBaseValidation::getSimpleZR(), GEMBaseValidation::getSuffixName(), GEMBaseValidation::getSuffixTitle(), GEMBaseValidation::initGeometry(), LogDebug, Pi, GEMGeometry::regions(), DQMStore::IBooker::setCurrentFolder(), relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, theStrip, theStrip_bx, theStrip_dcEta, theStrip_phistrip, theStrip_simple_zr, theStrip_xy, theStrip_xy_ch, and theStrip_zr.

                                                                          {
   const GEMGeometry *GEMGeometry_ = initGeometry(iSetup);
   if (GEMGeometry_ == nullptr)
     return;
   LogDebug("GEMStripDigiValidation") << "Geometry is acquired from MuonGeometryRecord\n";
   ibooker.setCurrentFolder("MuonGEMDigisV/GEMDigisTask");
   LogDebug("GEMStripDigiValidation") << "ibooker set current folder\n";
 
   LogDebug("GEMStripDigiValidation") << "nregions set.\n";
   LogDebug("GEMStripDigiValidation") << "nstations set.\n";
   int nstripsGE11 = 384;
   int nstripsGE21 = 768;
 
   LogDebug("GEMStripDigiValidation") << "Successfully binning set.\n";
 
   int nstrips = 0;
 
   for (auto &region : GEMGeometry_->regions()) {
     int re = region->region();
     TString title_suffix = getSuffixTitle(re);
     TString histname_suffix = getSuffixName(re);
     TString simpleZR_title = TString::Format("ZR Occupancy%s; |Z|(cm) ; R(cm)", title_suffix.Data());
     TString simpleZR_histname = TString::Format("strip_simple_zr%s", histname_suffix.Data());
 
     auto *simpleZR = getSimpleZR(ibooker, simpleZR_title, simpleZR_histname);
     if (simpleZR != nullptr) {
       theStrip_simple_zr[simpleZR_histname.Hash()] = simpleZR;
     }
 
     for (auto &station : region->stations()) {
       int st = station->station();
       TString title_suffix2 = getSuffixTitle(re, st);
       TString histname_suffix2 = getSuffixName(re, st);
 
       TString dcEta_title =
           TString::Format("Occupancy for detector component %s;;#eta-partition", title_suffix2.Data());
       TString dcEta_histname = TString::Format("strip_dcEta%s", histname_suffix2.Data());
 
       auto *dcEta = getDCEta(ibooker, station, dcEta_title, dcEta_histname);
       if (dcEta != nullptr) {
         theStrip_dcEta[dcEta_histname.Hash()] = dcEta;
       }
     }
   }
 
   // Booking detail plot.
   if (detailPlot_) {
     for (auto &region : GEMGeometry_->regions()) {
       for (auto &station : region->stations()) {
         for (int la = 1; la <= 2; la++) {
           int re = region->region();
           int st = station->station();
           int region_num = (re + 1) / 2;
           int station_num = st - 1;
           int layer_num = la - 1;
 
           if (st == 1)
             nstrips = nstripsGE11;
           else
             nstrips = nstripsGE21;
           std::string name_prefix = getSuffixName(re, st, la);
           std::string label_prefix = getSuffixTitle(re, st, la);
           theStrip_phistrip[region_num][station_num][layer_num] =
               ibooker.book2D(("strip_dg_phistrip" + name_prefix).c_str(),
                              ("Digi occupancy: " + label_prefix + "; phi [rad];strip number").c_str(),
                              280,
                              -TMath::Pi(),
                              TMath::Pi(),
                              nstrips / 2,
                              0,
                              nstrips);
           theStrip[region_num][station_num][layer_num] =
               ibooker.book1D(("strip_dg" + name_prefix).c_str(),
                              ("Digi occupancy per stip number: " + label_prefix + ";strip number; entries").c_str(),
                              nstrips,
                              0.5,
                              nstrips + 0.5);
           theStrip_bx[region_num][station_num][layer_num] =
               ibooker.book1D(("strip_dg_bx" + name_prefix).c_str(),
                              ("Bunch crossing: " + label_prefix + "; bunch crossing ; entries").c_str(),
                              11,
                              -5.5,
                              5.5);
           theStrip_zr[region_num][station_num][layer_num] =
               BookHistZR(ibooker, "strip_dg", "Strip Digi", region_num, station_num, layer_num);
           theStrip_xy[region_num][station_num][layer_num] =
               BookHistXY(ibooker, "strip_dg", "Strip Digi", region_num, station_num, layer_num);
           TString xy_name = TString::Format("strip_dg_xy%s_odd", name_prefix.c_str());
           TString xy_title = TString::Format("Digi XY occupancy %s at odd chambers", label_prefix.c_str());
           theStrip_xy_ch[xy_name.Hash()] = ibooker.book2D(xy_name, xy_title, 360, -360, 360, 360, -360, 360);
           xy_name = TString::Format("strip_dg_xy%s_even", name_prefix.c_str());
           xy_title = TString::Format("Digi XY occupancy %s at even chambers", label_prefix.c_str());
           theStrip_xy_ch[xy_name.Hash()] = ibooker.book2D(xy_name, xy_title, 360, -360, 360, 360, -360, 360);
         }
       }
     }
   }
   LogDebug("GEMStripDigiValidation") << "Booking End.\n";
 }