#include <GEMSimHitValidation.h>

Inheritance diagram for GEMSimHitValidation:

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

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

	GEMSimHitValidation (const edm::ParameterSet &)

	~GEMSimHitValidation () 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 Member Functions
std::tuple< Double_t, Double_t >	getTOFRange (Int_t station_id)

Private Attributes
const Float_t	kEnergyCF_ = 1e9f

MEMap3Ids	me_detail_eloss_

MEMap3Ids	me_detail_eloss_mu_

MEMap3Ids	me_detail_tof_

MEMap3Ids	me_detail_tof_mu_

MEMap1Ids	me_eloss_mu_

MEMap2Ids	me_occ_det_

MEMap3Ids	me_occ_xy_

MEMap1Ids	me_occ_zr_

std::map< Int_t, MonitorElement * >	me_tof_mu_

edm::EDGetTokenT< edm::PSimHitContainer >	simhit_token_

std::vector< Double_t >	tof_range_

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 11 of file GEMSimHitValidation.h.

Constructor & Destructor Documentation

◆ GEMSimHitValidation()

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

explicit

Definition at line 5 of file GEMSimHitValidation.cc.

     : GEMBaseValidation(pset, "GEMSimHitValidation") {
   const auto& simhit_pset = pset.getParameterSet("gemSimHit");
   const auto& simhit_tag = simhit_pset.getParameter<edm::InputTag>("inputTag");
   simhit_token_ = consumes<edm::PSimHitContainer>(simhit_tag);
  
   tof_range_ = pset.getUntrackedParameter<std::vector<Double_t> >("TOFRange");
 }

References muonDTDigis_cfi::pset, simhit_token_, and tof_range_.

◆ ~GEMSimHitValidation()

GEMSimHitValidation::~GEMSimHitValidation ( )

override

Definition at line 14 of file GEMSimHitValidation.cc.

14 {}

Member Function Documentation

◆ analyze()

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

overridevirtual

Implements GEMBaseValidation.

Definition at line 157 of file GEMSimHitValidation.cc.

                                                                                    {
   const GEMGeometry* gem = initGeometry(setup);
  
   edm::Handle<edm::PSimHitContainer> simhit_container;
   event.getByToken(simhit_token_, simhit_container);
   if (not simhit_container.isValid()) {
     edm::LogError(kLogCategory_) << "Cannot get GEMHits by Token simhitLabel" << std::endl;
     return;
   }
  
   for (const auto& simhit : *simhit_container.product()) {
     const GEMDetId gemid(simhit.detUnitId());
  
     if (gem->idToDet(gemid) == nullptr) {
       edm::LogError(kLogCategory_) << "SimHit did not matched with GEM Geometry." << std::endl;
       continue;
     }
  
     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};
  
     GlobalPoint&& simhit_global_pos = gem->idToDet(gemid)->surface().toGlobal(simhit.localPosition());
  
     Float_t simhit_g_r = simhit_global_pos.perp();
     Float_t simhit_g_x = simhit_global_pos.x();
     Float_t simhit_g_y = simhit_global_pos.y();
     Float_t simhit_g_abs_z = std::fabs(simhit_global_pos.z());
  
     Float_t energy_loss = kEnergyCF_ * simhit.energyLoss();
     Float_t tof = simhit.timeOfFlight();
  
     // NOTE Fill MonitorElement
     Int_t bin_x = getDetOccBinX(chamber_id, layer_id);
  
     me_occ_zr_[region_id]->Fill(simhit_g_abs_z, simhit_g_r);
     me_occ_det_[key2]->Fill(bin_x, roll_id);
     me_occ_xy_[key3]->Fill(simhit_g_x, simhit_g_y);
  
     bool is_muon_simhit = isMuonSimHit(simhit);
     if (is_muon_simhit) {
       me_tof_mu_[station_id]->Fill(tof);
       me_eloss_mu_[station_id]->Fill(energy_loss);
     }
  
     if (detail_plot_) {
       me_detail_tof_[key3]->Fill(tof);
       me_detail_eloss_[key3]->Fill(energy_loss);
  
       if (is_muon_simhit) {
         me_detail_tof_mu_[key3]->Fill(tof);
         me_detail_eloss_mu_[key3]->Fill(energy_loss);
       }
  
     }  // detail_plot
   }    // simhit loop
 }

References GEMBaseValidation::detail_plot_, GEMBaseValidation::getDetOccBinX(), GEMBaseValidation::initGeometry(), GEMBaseValidation::isMuonSimHit(), edm::HandleBase::isValid(), kEnergyCF_, GEMBaseValidation::kLogCategory_, me_detail_eloss_, me_detail_eloss_mu_, me_detail_tof_, me_detail_tof_mu_, me_eloss_mu_, me_occ_det_, me_occ_xy_, me_occ_zr_, me_tof_mu_, PV3DBase< T, PVType, FrameType >::perp(), edm::Handle< T >::product(), singleTopDQM_cfi::setup, simhit_token_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

◆ bookHistograms()

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 16 of file GEMSimHitValidation.cc.

                                                                                                                {
   const GEMGeometry* gem = initGeometry(setup);
  
   // NOTE Time of flight
   booker.setCurrentFolder("MuonGEMHitsV/GEMHitsTask/TimeOfFlight");
  
   TString tof_xtitle = "Time of flight [ns]";
   TString tof_ytitle = "Entries";
  
   const auto& regionsVec = gem->regions();
   if (regionsVec.empty() || regionsVec[0] == nullptr) {
     edm::LogError(kLogCategory_) << "Regions missing or null.";
     return;
   } else {
     for (const auto& station : regionsVec[0]->stations()) {
       Int_t station_id = station->station();
       const auto [tof_min, tof_max] = getTOFRange(station_id);
       auto tof_name = TString::Format("tof_muon_st%d", station_id);
       auto tof_title = TString::Format("SimHit Time Of Flight (Muon only) : Station %d", station_id);
  
       me_tof_mu_[station_id] = booker.book1D(tof_name, tof_title, 40, tof_min, tof_max);
     }  // end for
   }    // end else
  
   if (detail_plot_) {
     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 [tof_min, tof_max] = getTOFRange(station_id);
         const auto& superChamberVec = station->superChambers();
         if (superChamberVec.empty() || superChamberVec.front() == nullptr) {
           edm::LogError(kLogCategory_) << "Super chambers missing or null for region = " << region_id
                                        << " and station = " << station_id;
         } else {
           const GEMSuperChamber* super_chamber = superChamberVec.front();
  
           for (const auto& chamber : super_chamber->chambers()) {
             Int_t layer_id = chamber->id().layer();
             ME3IdsKey key3{region_id, station_id, layer_id};
  
             me_detail_tof_[key3] = bookHist1D(
                 booker, key3, "tof", "Time of Flight of Muon SimHits", 40, tof_min, tof_max, tof_xtitle, tof_ytitle);
  
             me_detail_tof_mu_[key3] = bookHist1D(
                 booker, key3, "tof_muon", "SimHit TOF (Muon only)", 40, tof_min, tof_max, tof_xtitle, tof_ytitle);
           }  // chamber loop
         }    // end else
       }      // station loop
     }        // region loop
   }          // detail plot
  
   // NOTE Energy Loss
   booker.setCurrentFolder("MuonGEMHitsV/GEMHitsTask/EnergyLoss");
  
   TString eloss_xtitle = "Energy loss [eV]";
   TString eloss_ytitle = "Entries / 100 eV";
  
   for (const auto& station : gem->regions()[0]->stations()) {
     Int_t station_id = station->station();
  
     auto eloss_name = TString::Format("eloss_muon_st%d", station_id);
     auto eloss_title = TString::Format("SimHit Energy Loss (Muon only) : Station %d", station_id);
  
     me_eloss_mu_[station_id] =
         booker.book1D(eloss_name, eloss_title + ";" + eloss_xtitle + ";" + eloss_ytitle, 60, 0.0, 6000.0);
   }  // station loop
  
   if (detail_plot_) {
     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() || superChamberVec.front() == nullptr) {
           edm::LogError(kLogCategory_) << "Super chambers missing or null for region = " << region_id
                                        << " and station = " << station_id;
         } else {
           for (const auto& chamber : superChamberVec.front()->chambers()) {
             Int_t layer_id = chamber->id().layer();
             ME3IdsKey key3{region_id, station_id, layer_id};
  
             me_detail_eloss_[key3] =
                 bookHist1D(booker, key3, "eloss", "SimHit Energy Loss", 60, 0.0, 6000.0, eloss_xtitle, eloss_ytitle);
  
             me_detail_eloss_mu_[key3] = bookHist1D(booker,
                                                    key3,
                                                    "eloss_muon",
                                                    "SimHit Energy Loss (Muon Only)",
                                                    60,
                                                    0.0,
                                                    6000.0,
                                                    eloss_xtitle,
                                                    eloss_ytitle);
  
           }  // chamber loop
         }    // end else
       }      // station loop
     }        // region loop
   }          // detail plot
  
   // NOTE Occupancy
   booker.setCurrentFolder("MuonGEMHitsV/GEMHitsTask/Occupancy");
  
   for (const auto& region : gem->regions()) {
     Int_t region_id = region->region();
  
     me_occ_zr_[region_id] = bookZROccupancy(booker, region_id, "simhit", "SimHit");
  
     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, "simhit", "SimHit");
  
       const auto& superChamberVec = station->superChambers();
       if (superChamberVec.empty() || superChamberVec.front() == nullptr) {
         edm::LogError(kLogCategory_) << "Super chambers missing or null for region = " << region_id
                                      << " and station = " << station_id;
       } else {
         const GEMSuperChamber* super_chamber = superChamberVec.front();
         for (const auto& chamber : super_chamber->chambers()) {
           Int_t layer_id = chamber->id().layer();
           ME3IdsKey key3{region_id, station_id, layer_id};
  
           me_occ_xy_[key3] = bookXYOccupancy(booker, key3, "simhit", "SimHit");
         }  // layer loop
       }    // end else
     }      // station loop
   }        // region loop
 }

References dqm::implementation::IBooker::book1D(), GEMBaseValidation::bookDetectorOccupancy(), GEMBaseValidation::bookHist1D(), GEMBaseValidation::bookXYOccupancy(), GEMBaseValidation::bookZROccupancy(), relativeConstraints::chamber, GEMSuperChamber::chambers(), GEMBaseValidation::detail_plot_, getTOFRange(), GEMBaseValidation::initGeometry(), GEMBaseValidation::kLogCategory_, me_detail_eloss_, me_detail_eloss_mu_, me_detail_tof_, me_detail_tof_mu_, me_eloss_mu_, me_occ_det_, me_occ_xy_, me_occ_zr_, me_tof_mu_, HLT_2018_cff::region, dqm::implementation::NavigatorBase::setCurrentFolder(), singleTopDQM_cfi::setup, and relativeConstraints::station.

◆ getTOFRange()

std::tuple< Double_t, Double_t > GEMSimHitValidation::getTOFRange ( Int_t station_id )

private

Definition at line 150 of file GEMSimHitValidation.cc.

                                                                               {
   UInt_t start_index = station_id == 1 ? 0 : 2;
   Double_t tof_min = tof_range_[start_index];
   Double_t tof_max = tof_range_[start_index + 1];
   return std::make_tuple(tof_min, tof_max);
 }