#include <CSCStubResolutionValidation.h>

Inheritance diagram for CSCStubResolutionValidation:

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

void	bookHistograms (DQMStore::IBooker &)

	CSCStubResolutionValidation (const edm::ParameterSet &pset, edm::ConsumesCollector &&iC)

	~CSCStubResolutionValidation () override

Public Member Functions inherited from CSCBaseValidation
	CSCBaseValidation (const edm::ParameterSet &ps)

void	setGeometry (const CSCGeometry *geom)

void	setSimHitMap (const PSimHitMap *simHitMap)

virtual	~CSCBaseValidation ()

Private Attributes
MonitorElement *	bendresCLCT [10]

std::unique_ptr< CSCStubMatcher >	cscStubMatcher_

MonitorElement *	posresCLCT_es [10]

MonitorElement *	posresCLCT_hs [10]

MonitorElement *	posresCLCT_qs [10]

edm::EDGetTokenT< edm::SimTrackContainer >	simTrackInput_

edm::EDGetTokenT< edm::SimVertexContainer >	simVertexInput_

Additional Inherited Members
Public Types inherited from CSCBaseValidation
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Protected Member Functions inherited from CSCBaseValidation
const CSCLayer *	findLayer (int detId) const

bool	isSimTrackGood (const SimTrack &t) const

Protected Attributes inherited from CSCBaseValidation
bool	doSim_

double	simTrackMaxEta_

double	simTrackMinEta_

double	simTrackMinPt_

const CSCGeometry *	theCSCGeometry

const PSimHitMap *	theSimHitMap

Detailed Description

Definition at line 10 of file CSCStubResolutionValidation.h.

Constructor & Destructor Documentation

◆ CSCStubResolutionValidation()

CSCStubResolutionValidation::CSCStubResolutionValidation	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector &&	iC
	)

Definition at line 6 of file CSCStubResolutionValidation.cc.

References cscStubMatcher_, eostools::move(), muonDTDigis_cfi::pset, cscDigiValidation_cfi::simTrack, simTrackInput_, ecalDetailedTimeRecHit_cfi::simVertex, and simVertexInput_.

     : CSCBaseValidation(pset) {
   const auto& simVertex = pset.getParameter<edm::ParameterSet>("simVertex");
   simVertexInput_ = iC.consumes<edm::SimVertexContainer>(simVertex.getParameter<edm::InputTag>("inputTag"));
   const auto& simTrack = pset.getParameter<edm::ParameterSet>("simTrack");
   simTrackInput_ = iC.consumes<edm::SimTrackContainer>(simTrack.getParameter<edm::InputTag>("inputTag"));
 
   // Initialize stub matcher
   cscStubMatcher_ = std::make_unique<CSCStubMatcher>(pset, std::move(iC));
 }

◆ ~CSCStubResolutionValidation()

CSCStubResolutionValidation::~CSCStubResolutionValidation ( )

override

Definition at line 17 of file CSCStubResolutionValidation.cc.

17 {}

Member Function Documentation

◆ analyze()

void CSCStubResolutionValidation::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	eventSetup
	)

overridevirtual

Implements CSCBaseValidation.

Definition at line 46 of file CSCStubResolutionValidation.cc.

References bendresCLCT, CSCDetId::chamber(), nano_mu_digi_cff::chamberType, cscStubMatcher_, MillePedeFileConverter_cfg::e, CSCDetId::endcap(), options_cfi::eventSetup, dqm::impl::MonitorElement::Fill(), mps_fire::i, globals_cff::id2, CSCBaseValidation::isSimTrackGood(), CSCConstants::MAX_HALF_STRIP_ME1B, CSCConstants::NUM_STRIPS_ME1B, or, posresCLCT_es, posresCLCT_hs, posresCLCT_qs, edm::Handle< T >::product(), CSCDetId::ring(), relativeConstraints::ring, simTrackInput_, simVertexInput_, CSCDetId::station(), and submitPVValidationJobs::t.

                                                                                             {
   // Define handles
   edm::Handle<edm::SimTrackContainer> sim_tracks;
   edm::Handle<edm::SimVertexContainer> sim_vertices;
 
   // Use token to retreive event information
   e.getByToken(simTrackInput_, sim_tracks);
   e.getByToken(simVertexInput_, sim_vertices);
 
   // Initialize StubMatcher
   cscStubMatcher_->init(e, eventSetup);
 
   const edm::SimTrackContainer& sim_track = *sim_tracks.product();
   const edm::SimVertexContainer& sim_vert = *sim_vertices.product();
 
   // select simtracks for true muons
   edm::SimTrackContainer sim_track_selected;
   for (const auto& t : sim_track) {
     if (!isSimTrackGood(t))
       continue;
     sim_track_selected.push_back(t);
   }
 
   // Skip events with no selected simtracks
   if (sim_track_selected.empty())
     return;
 
   // Loop through good tracks, use corresponding vertex to match stubs, then fill hists of chambers where the stub appears.
   for (const auto& t : sim_track_selected) {
     std::vector<bool> hitCLCT(10);
 
     std::vector<float> delta_fhs_clct(10);
     std::vector<float> delta_fqs_clct(10);
     std::vector<float> delta_fes_clct(10);
 
     std::vector<float> dslope_clct(10);
 
     // Match track to stubs with appropriate vertex
     cscStubMatcher_->match(t, sim_vert[t.vertIndex()]);
 
     // Store matched stubs.
     // Key: ChamberID, Value : CSCStubDigiContainer
     const auto& clcts = cscStubMatcher_->clcts();
 
     // CLCTs
     for (auto& [id, container] : clcts) {
       const CSCDetId cscId(id);
 
       // get the best clct in chamber
       const auto& clct = cscStubMatcher_->bestClctInChamber(id);
       if (!clct.isValid())
         continue;
 
       // ME1a CLCTs are saved in ME1b container. So the DetId need to be specified
       const bool isME11(cscId.station() == 1 and (cscId.ring() == 4 or cscId.ring() == 1));
       const bool isME1a(isME11 and clct.getKeyStrip() > CSCConstants::MAX_HALF_STRIP_ME1B);
       int ring = cscId.ring();
       if (isME1a)
         ring = 4;
       else if (isME11)
         ring = 1;
       CSCDetId cscId2(cscId.endcap(), cscId.station(), ring, cscId.chamber(), 0);
       auto id2 = cscId2.rawId();
 
       // calculate deltastrip for ME1/a. Basically, we need to subtract 64 from the CLCT key strip to
       // compare with key strip as obtained through the fit to simhits positions.
       int deltaStrip = 0;
       if (isME1a)
         deltaStrip = CSCConstants::NUM_STRIPS_ME1B;
 
       // fractional strip
       const float fhs_clct = clct.getFractionalStrip(2);
       const float fqs_clct = clct.getFractionalStrip(4);
       const float fes_clct = clct.getFractionalStrip(8);
 
       // in half-strips per layer
       const float slopeHalfStrip(clct.getFractionalSlope());
       const float slopeStrip(slopeHalfStrip / 2.);
 
       // get the fit hits in chamber for true value
       float stripIntercept, stripSlope;
       cscStubMatcher_->cscDigiMatcher()->muonSimHitMatcher()->fitHitsInChamber(id2, stripIntercept, stripSlope);
 
       // add offset of +0.25 strips for non-ME1/1 chambers
       if (!isME11) {
         stripIntercept -= 0.25;
       }
 
       const float strip_csc_sh = stripIntercept;
       const float bend_csc_sh = stripSlope;
 
       const unsigned chamberType(cscId2.iChamberType());
       hitCLCT[chamberType - 1] = true;
 
       delta_fhs_clct[chamberType - 1] = fhs_clct - deltaStrip - strip_csc_sh;
       delta_fqs_clct[chamberType - 1] = fqs_clct - deltaStrip - strip_csc_sh;
       delta_fes_clct[chamberType - 1] = fes_clct - deltaStrip - strip_csc_sh;
 
       dslope_clct[chamberType - 1] = slopeStrip - bend_csc_sh;
     }
 
     for (int i = 0; i < 10; i++) {
       if (hitCLCT[i]) {
         //fill histograms
         posresCLCT_hs[i]->Fill(delta_fhs_clct[i]);
         posresCLCT_qs[i]->Fill(delta_fqs_clct[i]);
         posresCLCT_es[i]->Fill(delta_fes_clct[i]);
 
         bendresCLCT[i]->Fill(dslope_clct[i]);
       }
     }
   }
 }

◆ bookHistograms()

void CSCStubResolutionValidation::bookHistograms ( DQMStore::IBooker & iBooker )

Definition at line 20 of file CSCStubResolutionValidation.cc.

References bendresCLCT, dqm::implementation::IBooker::book1D(), CSCDetId::chamberName(), mps_fire::i, dqmiolumiharvest::j, posresCLCT_es, posresCLCT_hs, posresCLCT_qs, dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, RandomServiceHelper::t1, RandomServiceHelper::t2, and RandomServiceHelper::t3.

                                                                          {
   for (int i = 1; i <= 10; ++i) {
     int j = i - 1;
     const std::string cn(CSCDetId::chamberName(i));
 
     //Position resolution; CLCT
     std::string t1 = "CLCTPosRes_hs_" + cn;
     std::string t2 = "CLCTPosRes_qs_" + cn;
     std::string t3 = "CLCTPosRes_es_" + cn;
 
     iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/CLCT/Resolution/");
     posresCLCT_hs[j] = iBooker.book1D(
         t1, cn + " CLCT Position Resolution (1/2-strip prec.); Strip_{L1T} - Strip_{SIM}; Entries", 50, -1, 1);
     posresCLCT_qs[j] = iBooker.book1D(
         t2, cn + " CLCT Position Resolution (1/4-strip prec.); Strip_{L1T} - Strip_{SIM}; Entries", 50, -1, 1);
     posresCLCT_es[j] = iBooker.book1D(
         t3, cn + " CLCT Position Resolution (1/8-strip prec.); Strip_{L1T} - Strip_{SIM}; Entries", 50, -1, 1);
 
     //Slope resolution; CLCT
     std::string t4 = "CLCTBendRes_" + cn;
 
     bendresCLCT[j] =
         iBooker.book1D(t4, cn + " CLCT Bend Resolution; Slope_{L1T} - Slope_{SIM}; Entries", 50, -0.5, 0.5);
   }
 }