#include <CSCRecHit2DValidation.h>

Inheritance diagram for CSCRecHit2DValidation:

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

void	bookHistograms (DQMStore::IBooker &)

	CSCRecHit2DValidation (const edm::ParameterSet &ps, edm::ConsumesCollector &&iC)

	~CSCRecHit2DValidation () 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 Member Functions
void	plotResolution (const PSimHit &simHit, const CSCRecHit2D &recHit, const CSCLayer *layer, int chamberType)

Private Attributes
edm::InputTag	inputTag_

edm::EDGetTokenT< CSCRecHit2DCollection >	rechits_Token_

MonitorElement *	theNPerEventPlot

MonitorElement *	thePullPlots [10]

MonitorElement *	theRecHitPosInStrip [10]

MonitorElement *	theResolutionPlots [10]

MonitorElement *	theScatterPlots [10]

MonitorElement *	theSimHitPosInStrip [10]

MonitorElement *	theSimHitScatterPlots [10]

MonitorElement *	theTPeaks [10]

MonitorElement *	theYPullPlots [10]

MonitorElement *	theYResolutionPlots [10]

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

Protected Attributes inherited from CSCBaseValidation
bool	doSim_

const CSCGeometry *	theCSCGeometry

const PSimHitMap *	theSimHitMap

Detailed Description

Definition at line 8 of file CSCRecHit2DValidation.h.

Constructor & Destructor Documentation

◆ CSCRecHit2DValidation()

CSCRecHit2DValidation::CSCRecHit2DValidation	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector &&	iC
	)

Definition at line 5 of file CSCRecHit2DValidation.cc.

     : CSCBaseValidation(ps), theNPerEventPlot(nullptr) {
   const auto &pset = ps.getParameterSet("cscRecHit");
   inputTag_ = pset.getParameter<edm::InputTag>("inputTag");
   rechits_Token_ = iC.consumes<CSCRecHit2DCollection>(inputTag_);
 }

References edm::ParameterSet::getParameterSet(), inputTag_, muonDTDigis_cfi::pset, and rechits_Token_.

◆ ~CSCRecHit2DValidation()

CSCRecHit2DValidation::~CSCRecHit2DValidation ( )

override

Definition at line 12 of file CSCRecHit2DValidation.cc.

12 {}

Member Function Documentation

◆ analyze()

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

overridevirtual

Implements CSCBaseValidation.

Definition at line 44 of file CSCRecHit2DValidation.cc.

                                                                                       {
   // get the collection of CSCRecHrecHitItrD
   edm::Handle<CSCRecHit2DCollection> hRecHits;
   e.getByToken(rechits_Token_, hRecHits);
   const CSCRecHit2DCollection *cscRecHits = hRecHits.product();
  
   unsigned nPerEvent = 0;
  
   for (auto recHitItr = cscRecHits->begin(); recHitItr != cscRecHits->end(); recHitItr++) {
     ++nPerEvent;
     int detId = (*recHitItr).cscDetId().rawId();
     edm::PSimHitContainer simHits = theSimHitMap->hits(detId);
     const CSCLayer *layer = findLayer(detId);
     int chamberType = layer->chamber()->specs()->chamberType();
     theTPeaks[chamberType - 1]->Fill(recHitItr->tpeak());
     if (simHits.size() == 1) {
       plotResolution(simHits[0], *recHitItr, layer, chamberType);
     }
     float localX = recHitItr->localPosition().x();
     float localY = recHitItr->localPosition().y();
     // find a local phi
     float globalR = layer->toGlobal(LocalPoint(0., 0., 0.)).perp();
     GlobalPoint axisThruChamber(globalR + localY, localX, 0.);
     float localPhi = axisThruChamber.phi().degrees();
     theScatterPlots[chamberType - 1]->Fill(localPhi, localY);
   }
   theNPerEventPlot->Fill(nPerEvent);
  
   if (doSim_) {
     // fill sim hits
     std::vector<int> layersWithSimHits = theSimHitMap->detsWithHits();
     for (unsigned i = 0; i < layersWithSimHits.size(); ++i) {
       edm::PSimHitContainer simHits = theSimHitMap->hits(layersWithSimHits[i]);
       for (auto hitItr = simHits.begin(); hitItr != simHits.end(); ++hitItr) {
         const CSCLayer *layer = findLayer(layersWithSimHits[i]);
         int chamberType = layer->chamber()->specs()->chamberType();
         float localX = hitItr->localPosition().x();
         float localY = hitItr->localPosition().y();
         // find a local phi
         float globalR = layer->toGlobal(LocalPoint(0., 0., 0.)).perp();
         GlobalPoint axisThruChamber(globalR + localY, localX, 0.);
         float localPhi = axisThruChamber.phi().degrees();
         theSimHitScatterPlots[chamberType - 1]->Fill(localPhi, localY);
       }
     }
   }
 }

References Geom::Phi< T1, Range >::degrees(), PSimHitMap::detsWithHits(), CSCBaseValidation::doSim_, MillePedeFileConverter_cfg::e, dqm::impl::MonitorElement::Fill(), CSCBaseValidation::findLayer(), PSimHitMap::hits(), mps_fire::i, phase1PixelTopology::layer, phase1PixelTopology::localX(), phase1PixelTopology::localY(), PV3DBase< T, PVType, FrameType >::phi(), plotResolution(), edm::Handle< T >::product(), rechits_Token_, FastTrackerRecHitCombiner_cfi::simHits, theNPerEventPlot, theScatterPlots, CSCBaseValidation::theSimHitMap, theSimHitScatterPlots, and theTPeaks.

◆ bookHistograms()

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

Definition at line 14 of file CSCRecHit2DValidation.cc.

                                                                    {
   theNPerEventPlot = iBooker.book1D("CSCRecHitsPerEvent", "Number of CSC Rec Hits per event", 100, 0, 500);
   // 10 chamber types, if you consider ME1/a and ME1/b separate
   for (int i = 1; i <= 10; ++i) {
     const std::string cn(CSCDetId::chamberName(i));
     const std::string t1("CSCRecHitResolution_" + cn);
     const std::string t2("CSCRecHitPull_" + cn);
     const std::string t3("CSCRecHitYResolution_" + cn);
  
     const std::string t4("CSCRecHitYPull_" + cn);
     const std::string t5("CSCRecHitPosInStrip_" + cn);
     const std::string t6("CSCSimHitPosInStrip_" + cn);
  
     const std::string t7("CSCRecHit_" + cn);
     const std::string t8("CSCSimHit_" + cn);
     const std::string t9("CSCTPeak_" + cn);
  
     theResolutionPlots[i - 1] = iBooker.book1D(t1, t1 + ";R*dPhi Resolution [cm];Entries", 100, -0.2, 0.2);
     thePullPlots[i - 1] = iBooker.book1D(t2, t2 + ";dPhi Pull;Entries", 100, -3, 3);
     theYResolutionPlots[i - 1] = iBooker.book1D(t3, t3 + ";Local Y Resolution [cm];Entries", 100, -5, 5);
     theYPullPlots[i - 1] = iBooker.book1D(t4, t4 + ";Local Y Pull;Entries", 100, -3, 3);
     theRecHitPosInStrip[i - 1] = iBooker.book1D(t5, t5 + ";Position in Strip;Entries", 100, -2, 2);
     theSimHitPosInStrip[i - 1] = iBooker.book1D(t6, t6 + ";Position in Strip;Entries", 100, -2, 2);
  
     theScatterPlots[i - 1] = iBooker.book2D(t7, t7 + ";Local Phi;Local Y [cm]", 200, -20, 20, 200, -250, 250);
     theSimHitScatterPlots[i - 1] = iBooker.book2D(t8, t8 + ";Local Phi;Local Y [cm]", 200, -20, 20, 200, -250, 250);
     theTPeaks[i - 1] = iBooker.book1D(t9, t9 + ";Peak Time [ns];Entries", 200, 0, 400);
   }
 }

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), CSCDetId::chamberName(), mps_fire::i, AlCaHLTBitMon_QueryRunRegistry::string, RandomServiceHelper::t1, RandomServiceHelper::t2, RandomServiceHelper::t3, theNPerEventPlot, thePullPlots, theRecHitPosInStrip, theResolutionPlots, theScatterPlots, theSimHitPosInStrip, theSimHitScatterPlots, theTPeaks, theYPullPlots, and theYResolutionPlots.

◆ plotResolution()

void CSCRecHit2DValidation::plotResolution	(	const PSimHit &	simHit,
		const CSCRecHit2D &	recHit,
		const CSCLayer *	layer,
		int	chamberType
	)

private

Definition at line 92 of file CSCRecHit2DValidation.cc.

                                                             {
   GlobalPoint simHitPos = layer->toGlobal(simHit.localPosition());
   GlobalPoint recHitPos = layer->toGlobal(recHit.localPosition());
  
   double dphi = recHitPos.phi() - simHitPos.phi();
   double rdphi = recHitPos.perp() * dphi;
   theResolutionPlots[chamberType - 1]->Fill(rdphi);
   thePullPlots[chamberType - 1]->Fill(rdphi / sqrt(recHit.localPositionError().xx()));
   double dy = recHit.localPosition().y() - simHit.localPosition().y();
   theYResolutionPlots[chamberType - 1]->Fill(dy);
   theYPullPlots[chamberType - 1]->Fill(dy / sqrt(recHit.localPositionError().yy()));
  
   const CSCLayerGeometry *layerGeometry = layer->geometry();
   float recStrip = layerGeometry->strip(recHit.localPosition());
   float simStrip = layerGeometry->strip(simHit.localPosition());
   theRecHitPosInStrip[chamberType - 1]->Fill(recStrip - int(recStrip));
   theSimHitPosInStrip[chamberType - 1]->Fill(simStrip - int(simStrip));
 }