#include <GEMPadDigiClusterValidation.h>

Inheritance diagram for GEMPadDigiClusterValidation:

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

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

	GEMPadDigiClusterValidation (const edm::ParameterSet &)

	~GEMPadDigiClusterValidation () override

Public Member Functions inherited from GEMBaseValidation
	GEMBaseValidation (const edm::ParameterSet &, std::string)

	~GEMBaseValidation () override=0

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

void	beginStream (edm::StreamID id) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Attributes
MEMap3Ids	me_detail_bx_

MEMap3Ids	me_detail_occ_pad_

MEMap3Ids	me_detail_occ_phi_pad_

MEMap3Ids	me_detail_occ_xy_

MEMap2Ids	me_occ_det_

MEMap1Ids	me_occ_zr_

edm::EDGetTokenT< GEMPadDigiClusterCollection >	pad_cluster_token_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Protected Member Functions inherited from GEMBaseValidation
template<typename T >
dqm::impl::MonitorElement *	bookDetectorOccupancy (DQMStore::IBooker &booker, const T &key, const GEMStation station, const char name_prfix, const char *title_prefix)

template<typename T >
dqm::impl::MonitorElement *	bookHist1D (DQMStore::IBooker &booker, const T &key, const char name, const char title, Int_t nbinsx, Double_t xlow, Double_t xup, const char x_title="", const char y_title="Entries")

template<typename T >
dqm::impl::MonitorElement *	bookHist2D (DQMStore::IBooker &booker, const T &key, const char name, const char title, Int_t nbinsx, Double_t xlow, Double_t xup, Int_t nbinsy, Double_t ylow, Double_t yup, const char x_title="", const char y_title="")

template<typename T >
dqm::impl::MonitorElement *	bookPolarOccupancy (DQMStore::IBooker &booker, const T &key, const char name_prefix, const char title_prefix)

template<typename T >
dqm::impl::MonitorElement *	bookXYOccupancy (DQMStore::IBooker &booker, const T &key, const char name_prefix, const char title_prefix)

template<typename T >
dqm::impl::MonitorElement *	bookZROccupancy (DQMStore::IBooker &booker, const T &key, const char name_prfix, const char title_prefix)

dqm::impl::MonitorElement *	bookZROccupancy (DQMStore::IBooker &booker, Int_t region_id, const char name_prfix, const char title_prefix)

Int_t	getDetOccBinX (Int_t chamber_id, Int_t layer_id)

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

Bool_t	isMuonSimHit (const PSimHit &)

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes inherited from GEMBaseValidation
Bool_t	detail_plot_

std::vector< Double_t >	eta_range_

const std::string	kLogCategory_

const Int_t	kMuonPDGId_ = 13

Int_t	xy_occ_num_bins_

std::vector< Int_t >	zr_occ_num_bins_

std::vector< Double_t >	zr_occ_range_

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 7 of file GEMPadDigiClusterValidation.h.

Constructor & Destructor Documentation

◆ GEMPadDigiClusterValidation()

GEMPadDigiClusterValidation::GEMPadDigiClusterValidation ( const edm::ParameterSet & pset )

explicit

Definition at line 4 of file GEMPadDigiClusterValidation.cc.

     : GEMBaseValidation(pset, "GEMPadDigiClusterValidation") {
   const auto& pad_cluster_pset = pset.getParameterSet("gemPadCluster");
   const auto& pad_cluster_tag = pad_cluster_pset.getParameter<edm::InputTag>("inputTag");
   pad_cluster_token_ = consumes<GEMPadDigiClusterCollection>(pad_cluster_tag);
 }

References pad_cluster_token_, and muonDTDigis_cfi::pset.

◆ ~GEMPadDigiClusterValidation()

GEMPadDigiClusterValidation::~GEMPadDigiClusterValidation ( )

override

Definition at line 109 of file GEMPadDigiClusterValidation.cc.

109 {}

Member Function Documentation

◆ analyze()

void GEMPadDigiClusterValidation::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

overridevirtual

Implements GEMBaseValidation.

Definition at line 111 of file GEMPadDigiClusterValidation.cc.

                                                                                            {
   const GEMGeometry* gem = initGeometry(setup);
  
   edm::Handle<GEMPadDigiClusterCollection> collection;
   event.getByToken(pad_cluster_token_, collection);
   if (not collection.isValid()) {
     edm::LogError(kLogCategory_) << "Cannot get pads by label GEMPadToken.";
     return;
   }
  
   for (auto range_iter = collection->begin(); range_iter != collection->end(); range_iter++) {
     GEMDetId gemid = (*range_iter).first;
     const auto& range = (*range_iter).second;
  
     if (gem->idToDet(gemid) == nullptr) {
       edm::LogError(kLogCategory_) << "Getting DetId failed. Discard this gem pad hit. "
                                    << "Maybe it comes from unmatched geometry." << std::endl;
       continue;
     }
  
     const GEMEtaPartition* roll = gem->etaPartition(gemid);
     const BoundPlane& surface = roll->surface();
  
     Int_t region_id = gemid.region();
     Int_t station_id = gemid.station();
     Int_t layer_id = gemid.layer();
     Int_t chamber_id = gemid.chamber();
     Int_t roll_id = gemid.roll();
  
     ME2IdsKey key2(region_id, station_id);
     ME3IdsKey key3(region_id, station_id, layer_id);
  
     for (auto digi = range.first; digi != range.second; ++digi) {
       const auto& padsVec = digi->pads();
       if (padsVec.empty()) {
         edm::LogError(kLogCategory_) << "Pads missing for digi from GEM ID = " << gemid;
         continue;
       }
       Int_t pad = padsVec[0];
  
       // bunch crossing
       Int_t bx = digi->bx();
  
       const LocalPoint& local_pos = roll->centreOfPad(pad);
       const GlobalPoint& global_pos = surface.toGlobal(local_pos);
  
       Float_t g_r = global_pos.perp();
       Float_t g_phi = global_pos.phi();
       Float_t g_x = global_pos.x();
       Float_t g_y = global_pos.y();
       Float_t g_abs_z = std::fabs(global_pos.z());
  
       me_occ_zr_[region_id]->Fill(g_abs_z, g_r);
  
       Int_t bin_x = getDetOccBinX(chamber_id, layer_id);
       me_occ_det_[key2]->Fill(bin_x, roll_id);
  
       if (detail_plot_) {
         me_detail_occ_xy_[key3]->Fill(g_x, g_y);
         me_detail_occ_phi_pad_[key3]->Fill(g_phi, pad);
         me_detail_occ_pad_[key3]->Fill(pad);
         me_detail_bx_[key3]->Fill(bx);
       }  // detail_plot_
     }
   }  // end loop over range iters
 }

References l1GtPatternGenerator_cfi::bx, GEMEtaPartition::centreOfPad(), GEMDetId::chamber(), universalConfigTemplate::collection, GEMBaseValidation::detail_plot_, GEMBaseValidation::getDetOccBinX(), GEMBaseValidation::initGeometry(), GEMBaseValidation::kLogCategory_, GEMDetId::layer(), me_detail_bx_, me_detail_occ_pad_, me_detail_occ_phi_pad_, me_detail_occ_xy_, me_occ_det_, me_occ_zr_, pad_cluster_token_, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), FastTimerService_cff::range, GEMDetId::region(), GEMDetId::roll(), singleTopDQM_cfi::setup, GEMDetId::station(), GeomDet::surface(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

◆ bookHistograms()

void GEMPadDigiClusterValidation::bookHistograms	(	DQMStore::IBooker &	booker,
		edm::Run const &	Run,
		edm::EventSetup const &	setup
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 11 of file GEMPadDigiClusterValidation.cc.

                                                                              {
   const GEMGeometry* gem = initGeometry(setup);
  
   // NOTE Occupancy
   booker.setCurrentFolder("MuonGEMDigisV/GEMDigisTask/PadCluster/Occupancy");
   for (const auto& region : gem->regions()) {
     Int_t region_id = region->region();
  
     me_occ_zr_.emplace(region_id, bookZROccupancy(booker, region_id, "pad", "Pad Cluster"));
  
     for (const auto& station : region->stations()) {
       Int_t station_id = station->station();
       ME2IdsKey key2{region_id, station_id};
  
       me_occ_det_[key2] = bookDetectorOccupancy(booker, key2, station, "pad", "Pad Cluster");
  
       const auto& superChamberVec = station->superChambers();
       if (superChamberVec.empty()) {
         edm::LogError(kLogCategory_) << "Super chambers missing for region = " << region_id
                                      << " and station = " << station_id;
         continue;
       }
       const GEMSuperChamber* super_chamber = superChamberVec.front();
       if (super_chamber == nullptr) {
         edm::LogError(kLogCategory_) << "Failed to find super chamber for region = " << region_id
                                      << " and station = " << station_id;
         continue;
       }
       for (const auto& chamber : super_chamber->chambers()) {
         Int_t layer_id = chamber->id().layer();
         ME3IdsKey key3{region_id, station_id, layer_id};
  
         const auto& etaPartitionVec = chamber->etaPartitions();
         if (etaPartitionVec.empty() || etaPartitionVec.front() == nullptr) {
           edm::LogError(kLogCategory_)
               << "Eta partition missing or null for region, station, super chamber, chamber = (" << region_id << ", "
               << station_id << ", " << super_chamber->id() << ", " << chamber->id() << ")";
           continue;
         }
         Int_t num_pads = etaPartitionVec.front()->npads();
  
         if (detail_plot_) {
           me_detail_occ_xy_[key3] = bookXYOccupancy(booker, key3, "pad", "Pad Cluster");
  
           me_detail_occ_phi_pad_[key3] = bookHist2D(booker,
                                                     key3,
                                                     "occ_phi_pad",
                                                     "Pad Cluster Occupancy",
                                                     280,
                                                     -M_PI,
                                                     M_PI,
                                                     num_pads / 2,
                                                     0,
                                                     num_pads,
                                                     "#phi [rad]",
                                                     "Pad number");
  
           me_detail_occ_pad_[key3] =
               bookHist1D(booker, key3, "occ_pad", "Pad Cluster Occupancy", num_pads, 0.5, num_pads + 0.5, "Pad number");
         }
       }  // end loop over layer ids
     }    // end loop over station ids
   }      // end loop over region ids
  
   // NOTE Bunch Crossing
   if (detail_plot_) {
     booker.setCurrentFolder("MuonGEMDigisV/GEMDigisTask/PadCluster/BunchCrossing");
  
     for (const auto& region : gem->regions()) {
       Int_t region_id = region->region();
       for (const auto& station : region->stations()) {
         Int_t station_id = station->station();
  
         const auto& superChamberVec = station->superChambers();
         if (superChamberVec.empty()) {
           edm::LogError(kLogCategory_) << "Super chambers missing for region = " << region_id
                                        << " and station = " << station_id;
           continue;
         }
         const GEMSuperChamber* super_chamber = superChamberVec.front();
         if (super_chamber == nullptr) {
           edm::LogError(kLogCategory_) << "Failed to find super chamber for region = " << region_id
                                        << " and station = " << station_id;
           continue;
         }
         for (const auto& chamber : super_chamber->chambers()) {
           Int_t layer_id = chamber->id().layer();
           ME3IdsKey key3(region_id, station_id, layer_id);
           me_detail_bx_[key3] =
               bookHist1D(booker, key3, "bx", "Pad Cluster Bunch Crossing", 5, -2.5, 2.5, "Bunch crossing");
         }  // chamber loop
       }    // station loop
     }      // region loop
   }        // detail plot
 }