#include <DTCalibValidationFromMuons.h>

Inheritance diagram for DTCalibValidationFromMuons:

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

void	dqmBeginRun (const edm::Run &r, const edm::EventSetup &c) override
	BeginRun. More...

	DTCalibValidationFromMuons (const edm::ParameterSet &pset)
	Constructor. More...

	~DTCalibValidationFromMuons () override
	Destructor. More...

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

	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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Private Member Functions
void	bookHistos (DTSuperLayerId slId, int step)

void	compute (const DTGeometry *dtGeom, const DTRecSegment4D &segment)

void	fillHistos (DTSuperLayerId slId, float distance, float residualOnDistance, float position, float residualOnPosition, int step)

float	recHitDistFromWire (const DTRecHit1D &recHit, const DTLayer *layer)

float	recHitDistFromWire (const DTRecHit1DPair &hitPair, const DTLayer *layer)

float	recHitPosition (const DTRecHit1D &recHit, const DTLayer layer, const DTChamber chamber, float segmPos, int sl)

float	recHitPosition (const DTRecHit1DPair &hitPair, const DTLayer layer, const DTChamber chamber, float segmPos, int sl)

Private Attributes
const DTGeometry *	dtGeom

std::map< std::pair< DTSuperLayerId, int >, std::vector< MonitorElement * > >	histosPerSL

edm::ESGetToken< DTGeometry, MuonGeometryRecord >	muonGeomToken_

edm::EDGetTokenT< reco::MuonCollection >	muonToken_

int	nevent

edm::ParameterSet	parameters

int	rightSegment

edm::EDGetTokenT< DTRecSegment4DCollection >	segment4DToken_

int	wrongSegment

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 >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::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 Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Analysis on DT residuals to validate the kFactor

Author: G. Mila - INFN Torino

Definition at line 45 of file DTCalibValidationFromMuons.h.

Constructor & Destructor Documentation

◆ DTCalibValidationFromMuons()

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

Constructor.

Definition at line 31 of file DTCalibValidationFromMuons.cc.

     : muonGeomToken_(esConsumes<edm::Transition::BeginRun>()) {
   parameters = pset;
  
   // the name of the 4D segments
   segment4DToken_ =
       consumes<DTRecSegment4DCollection>(edm::InputTag(parameters.getUntrackedParameter<string>("segment4DLabel")));
   // muon collection for matching 4D segments to muons
   muonToken_ = consumes<reco::MuonCollection>(edm::InputTag(parameters.getUntrackedParameter<string>("muonLabel")));
   // the counter of segments not used to compute residuals
   wrongSegment = 0;
   // the counter of segments used to compute residuals
   rightSegment = 0;
  
   nevent = 0;
 }

References edm::ParameterSet::getUntrackedParameter(), muonToken_, nevent, parameters, muonDTDigis_cfi::pset, rightSegment, segment4DToken_, and wrongSegment.

◆ ~DTCalibValidationFromMuons()

DTCalibValidationFromMuons::~DTCalibValidationFromMuons ( )

override

Destructor.

Definition at line 48 of file DTCalibValidationFromMuons.cc.

                                                         {
   // FR the following was previously in the endJob
  
   LogVerbatim("DTCalibValidationFromMuons") << "Segments used to compute residuals: " << rightSegment;
   LogVerbatim("DTCalibValidationFromMuons") << "Segments not used to compute residuals: " << wrongSegment;
 }

References rightSegment, and wrongSegment.

Member Function Documentation

◆ analyze()

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

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 60 of file DTCalibValidationFromMuons.cc.

                                                                                           {
   ++nevent;
   LogTrace("DTCalibValidationFromMuons") << "[DTCalibValidationFromMuons] Analyze #Run: " << event.id().run()
                                          << " #Event: " << nevent;
  
   // RecHit mapping at Step 3 ---------------------------------
   LogTrace("DTCalibValidationFromMuons") << "  -- DTRecHit S3: begin analysis:";
   // Get the 4D rechits from the event
   Handle<reco::MuonCollection> muonH;
   event.getByToken(muonToken_, muonH);
   const vector<reco::Muon> *muons = muonH.product();
  
   // Get the 4D rechits from the event
   Handle<DTRecSegment4DCollection> segment4Ds;
   event.getByToken(segment4DToken_, segment4Ds);
  
   vector<const DTRecSegment4D *> selectedSegment4Ds;
  
   for (auto &imuon : *muons) {
     for (const auto &ch : imuon.matches()) {
       DetId chId(ch.id.rawId());
       if (chId.det() != DetId::Muon)
         continue;
       if (chId.subdetId() != MuonSubdetId::DT)
         continue;
       if (imuon.pt() < 15)
         continue;
       if (!imuon.isGlobalMuon())
         continue;
  
       int nsegs = ch.segmentMatches.size();
       if (!nsegs)
         continue;
  
       // get the DT segments that were used to construct the muon
       DTChamberId matchId = ch.id();
       DTRecSegment4DCollection::range segs = segment4Ds->get(matchId);
       for (DTRecSegment4DCollection::const_iterator segment = segs.first; segment != segs.second; ++segment) {
         LocalPoint posHit = segment->localPosition();
         float dx = (posHit.x() ? posHit.x() - ch.x : 0);
         float dy = (posHit.y() ? posHit.y() - ch.y : 0);
         float dr = sqrt(dx * dx + dy * dy);
         if (dr < 5)
           selectedSegment4Ds.push_back(&(*segment));
       }
     }
   }
  
   // Loop over all 4D segments
   for (auto segment : selectedSegment4Ds) {
     LogTrace("DTCalibValidationFromMuons") << "Anlysis on recHit at step 3";
     compute(dtGeom, *segment);
   }
 }

References compute(), flavorHistoryFilter_cfi::dr, MuonSubdetId::DT, dtGeom, PVValHelper::dx, PVValHelper::dy, LogTrace, DetId::Muon, PDWG_BPHSkim_cff::muons, muonToken_, nevent, edm::Handle< T >::product(), segment4DToken_, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

◆ bookHistograms()

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 288 of file DTCalibValidationFromMuons.cc.

                                                                              {
   // FR substitute the DQMStore instance by ibooker
   ibooker.setCurrentFolder("DT/DTCalibValidationFromMuons");
  
   DTSuperLayerId slId;
  
   // Loop over all the chambers
   vector<const DTChamber *>::const_iterator ch_it = dtGeom->chambers().begin();
   vector<const DTChamber *>::const_iterator ch_end = dtGeom->chambers().end();
   for (; ch_it != ch_end; ++ch_it) {
     vector<const DTSuperLayer *>::const_iterator sl_it = (*ch_it)->superLayers().begin();
     vector<const DTSuperLayer *>::const_iterator sl_end = (*ch_it)->superLayers().end();
     // Loop over the SLs
     for (; sl_it != sl_end; ++sl_it) {
       slId = (*sl_it)->id();
  
       // TODO! fix this is a leftover
       int firstStep = 3;
       // Loop over the 3 steps
       for (int step = firstStep; step <= 3; ++step) {
         LogTrace("DTCalibValidationFromMuons") << "   Booking histos for SL: " << slId;
  
         // Compose the chamber name
         stringstream wheel;
         wheel << slId.wheel();
         stringstream station;
         station << slId.station();
         stringstream sector;
         sector << slId.sector();
         stringstream superLayer;
         superLayer << slId.superlayer();
         // Define the step
         stringstream Step;
         Step << step;
  
         string slHistoName = "_STEP" + Step.str() + "_W" + wheel.str() + "_St" + station.str() + "_Sec" + sector.str() +
                              "_SL" + superLayer.str();
  
         ibooker.setCurrentFolder("DT/DTCalibValidationFromMuons/Wheel" + wheel.str() + "/Station" + station.str() +
                                  "/Sector" + sector.str());
         // Create the monitor elements
         vector<MonitorElement *> histos;
         // Note the order matters
         histos.push_back(ibooker.book1D(
             "hResDist" + slHistoName, "Residuals on the distance from wire (rec_hit - segm_extr) (cm)", 200, -0.4, 0.4));
         histos.push_back(ibooker.book2D("hResDistVsDist" + slHistoName,
                                         "Residuals on the distance (cm) from wire (rec_hit "
                                         "- segm_extr) vs distance  (cm)",
                                         100,
                                         0,
                                         2.5,
                                         200,
                                         -0.4,
                                         0.4));
  
         histosPerSL[make_pair(slId, step)] = histos;
       }
     }
   }
 }

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), DTGeometry::chambers(), dtGeom, combine::histos, histosPerSL, LogTrace, DTChamberId::sector(), dqm::implementation::NavigatorBase::setCurrentFolder(), DTChamberId::station(), relativeConstraints::station, DTSuperLayerId::superlayer(), DTChamberId::wheel(), and makeMuonMisalignmentScenario::wheel.

◆ bookHistos()

void DTCalibValidationFromMuons::bookHistos	(	DTSuperLayerId	slId,
		int	step
	)

private

◆ compute()

void DTCalibValidationFromMuons::compute	(	const DTGeometry *	dtGeom,
		const DTRecSegment4D &	segment
	)

private

Definition at line 167 of file DTCalibValidationFromMuons.cc.

                                                                                                 {
   bool computeResidual = true;
  
   // Get all 1D RecHits at step 3 within the 4D segment
   vector<DTRecHit1D> recHits1D_S3;
  
   // Get 1D RecHits at Step 3 and select only events with
   // >=7 hits in phi and 4 hits in theta (if any)
   const DTChamberRecSegment2D *phiSeg = segment.phiSegment();
   if (phiSeg) {
     vector<DTRecHit1D> phiRecHits = phiSeg->specificRecHits();
     if (phiRecHits.size() < 7) {
       LogTrace("DTCalibValidationFromMuons") << "[DTCalibValidationFromMuons] Phi segments has: " << phiRecHits.size()
                                              << " hits, skipping";  // FIXME: info output
       computeResidual = false;
     }
     copy(phiRecHits.begin(), phiRecHits.end(), back_inserter(recHits1D_S3));
   }
   if (!phiSeg) {
     LogTrace("DTCalibValidationFromMuons") << " [DTCalibValidationFromMuons] 4D segment has no phi segment! ";
     computeResidual = false;
   }
  
   if (segment.dimension() == 4) {
     const DTSLRecSegment2D *zSeg = segment.zSegment();
     if (zSeg) {
       vector<DTRecHit1D> zRecHits = zSeg->specificRecHits();
       if (zRecHits.size() != 4) {
         LogTrace("DTCalibValidationFromMuons") << "[DTCalibValidationFromMuons] Theta segments has: " << zRecHits.size()
                                                << " hits, skipping";  // FIXME: info output
         computeResidual = false;
       }
       copy(zRecHits.begin(), zRecHits.end(), back_inserter(recHits1D_S3));
     }
     if (!zSeg) {
       LogTrace("DTCalibValidationFromMuons") << " [DTCalibValidationFromMuons] 4D segment has not the z segment! ";
       computeResidual = false;
     }
   }
  
   if (!computeResidual)
     ++wrongSegment;
  
   if (computeResidual) {
     ++rightSegment;
  
     // Loop over 1D RecHit inside 4D segment
     for (vector<DTRecHit1D>::const_iterator recHit1D = recHits1D_S3.begin(); recHit1D != recHits1D_S3.end();
          ++recHit1D) {
       const DTWireId wireId = (*recHit1D).wireId();
  
       // Get the layer and the wire position
       const DTLayer *layer = dtGeom->layer(wireId);
       float wireX = layer->specificTopology().wirePosition(wireId.wire());
  
       // Extrapolate the segment to the z of the wire
       // Get wire position in chamber RF
       // (y and z must be those of the hit to be coherent in the transf. of RF
       // in case of rotations of the layer alignment)
       LocalPoint wirePosInLay(wireX, (*recHit1D).localPosition().y(), (*recHit1D).localPosition().z());
       GlobalPoint wirePosGlob = layer->toGlobal(wirePosInLay);
       const DTChamber *chamber = dtGeom->chamber((*recHit1D).wireId().layerId().chamberId());
       LocalPoint wirePosInChamber = chamber->toLocal(wirePosGlob);
  
       // Segment position at Wire z in chamber local frame
       LocalPoint segPosAtZWire = segment.localPosition() + segment.localDirection() * wirePosInChamber.z() /
                                                                cos(segment.localDirection().theta());
  
       // Compute the distance of the segment from the wire
       int sl = wireId.superlayer();
       float SegmDistance = -1;
       if (sl == 1 || sl == 3) {
         // RPhi SL
         SegmDistance = fabs(wirePosInChamber.x() - segPosAtZWire.x());
         LogTrace("DTCalibValidationFromMuons") << "SegmDistance: " << SegmDistance;
       } else if (sl == 2) {
         // RZ SL
         SegmDistance = fabs(segPosAtZWire.y() - wirePosInChamber.y());
         LogTrace("DTCalibValidationFromMuons") << "SegmDistance: " << SegmDistance;
       }
  
       if (SegmDistance > 2.1)
         LogTrace("DTCalibValidationFromMuons") << "  Warning: dist segment-wire: " << SegmDistance;
  
       // Compute the distance of the recHit from the wire
       float recHitWireDist = recHitDistFromWire(*recHit1D, layer);
       LogTrace("DTCalibValidationFromMuons") << "recHitWireDist: " << recHitWireDist;
  
       // Compute the residuals
       float residualOnDistance = recHitWireDist - SegmDistance;
       LogTrace("DTCalibValidationFromMuons") << "WireId: " << wireId << "  ResidualOnDistance: " << residualOnDistance;
       float residualOnPosition = -1;
       float recHitPos = -1;
       if (sl == 1 || sl == 3) {
         recHitPos = recHitPosition(*recHit1D, layer, chamber, segPosAtZWire.x(), sl);
         residualOnPosition = recHitPos - segPosAtZWire.x();
       } else {
         recHitPos = recHitPosition(*recHit1D, layer, chamber, segPosAtZWire.y(), sl);
         residualOnPosition = recHitPos - segPosAtZWire.y();
       }
       LogTrace("DTCalibValidationFromMuons") << "WireId: " << wireId << "  ResidualOnPosition: " << residualOnPosition;
  
       // Fill the histos
       if (sl == 1 || sl == 3)
         fillHistos(wireId.superlayerId(),
                    SegmDistance,
                    residualOnDistance,
                    (wirePosInChamber.x() - segPosAtZWire.x()),
                    residualOnPosition,
                    3);
       else
         fillHistos(wireId.superlayerId(),
                    SegmDistance,
                    residualOnDistance,
                    (wirePosInChamber.y() - segPosAtZWire.y()),
                    residualOnPosition,
                    3);
     }
   }
 }

References relativeConstraints::chamber, DTGeometry::chamber(), filterCSVwithJSON::copy, funct::cos(), DTRecSegment4D::dimension(), dtGeom, fillHistos(), DTGeometry::layer(), phase1PixelTopology::layer, DTRecSegment4D::localDirection(), DTRecSegment4D::localPosition(), LogTrace, DTRecSegment4D::phiSegment(), recHitDistFromWire(), recHitPosition(), rightSegment, DTRecSegment2D::specificRecHits(), DTSuperLayerId::superlayer(), DTLayerId::superlayerId(), PV3DBase< T, PVType, FrameType >::theta(), DTWireId::wire(), wrongSegment, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::z(), and DTRecSegment4D::zSegment().

Referenced by analyze().

◆ dqmBeginRun()

void DTCalibValidationFromMuons::dqmBeginRun	(	const edm::Run &	r,
		const edm::EventSetup &	c
	)

overridevirtual

BeginRun.

Reimplemented from DQMEDAnalyzer.

Definition at line 55 of file DTCalibValidationFromMuons.cc.

                                                                                           {
   // get the geometry
   dtGeom = &setup.getData(muonGeomToken_);
 }

References dtGeom, muonGeomToken_, and singleTopDQM_cfi::setup.

◆ fillHistos()

void DTCalibValidationFromMuons::fillHistos	(	DTSuperLayerId	slId,
		float	distance,
		float	residualOnDistance,
		float	position,
		float	residualOnPosition,
		int	step
	)

private

Definition at line 352 of file DTCalibValidationFromMuons.cc.

                                                                                                                        {
   // FIXME: optimization of the number of searches
   vector<MonitorElement *> histos = histosPerSL[make_pair(slId, step)];
   histos[0]->Fill(residualOnDistance);
   histos[1]->Fill(distance, residualOnDistance);
 }

References HLT_FULL_cff::distance, combine::histos, and histosPerSL.

Referenced by compute().

◆ recHitDistFromWire() [1/2]

float DTCalibValidationFromMuons::recHitDistFromWire	(	const DTRecHit1D &	recHit,
		const DTLayer *	layer
	)

private

Definition at line 121 of file DTCalibValidationFromMuons.cc.

                                                                                                    {
   return fabs(recHit.localPosition().x() - layer->specificTopology().wirePosition(recHit.wireId().wire()));
 }

References phase1PixelTopology::layer, and rpcPointValidation_cfi::recHit.

◆ recHitDistFromWire() [2/2]

float DTCalibValidationFromMuons::recHitDistFromWire	(	const DTRecHit1DPair &	hitPair,
		const DTLayer *	layer
	)

private

Definition at line 116 of file DTCalibValidationFromMuons.cc.

                                                                                                         {
   return fabs(hitPair.localPosition(DTEnums::Left).x() - hitPair.localPosition(DTEnums::Right).x()) / 2.;
 }

References DTEnums::Left, DTRecHit1DPair::localPosition(), DTEnums::Right, and PV3DBase< T, PVType, FrameType >::x().

Referenced by compute().

◆ recHitPosition() [1/2]

float DTCalibValidationFromMuons::recHitPosition	(	const DTRecHit1D &	recHit,
		const DTLayer *	layer,
		const DTChamber *	chamber,
		float	segmPos,
		int	sl
	)

private

Definition at line 151 of file DTCalibValidationFromMuons.cc.

                                                                                                         {
   // Get the layer and the wire position
   GlobalPoint recHitPosGlob = layer->toGlobal(recHit.localPosition());
   LocalPoint recHitPosInChamber = chamber->toLocal(recHitPosGlob);
  
   float recHitPos = -1;
   if (sl != 2)
     recHitPos = recHitPosInChamber.x();
   else
     recHitPos = recHitPosInChamber.y();
  
   return recHitPos;
 }

References relativeConstraints::chamber, phase1PixelTopology::layer, rpcPointValidation_cfi::recHit, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

◆ recHitPosition() [2/2]

float DTCalibValidationFromMuons::recHitPosition	(	const DTRecHit1DPair &	hitPair,
		const DTLayer *	layer,
		const DTChamber *	chamber,
		float	segmPos,
		int	sl
	)

private

Definition at line 126 of file DTCalibValidationFromMuons.cc.

                                                                                                              {
   // Get the layer and the wire position
   GlobalPoint hitPosGlob_right = layer->toGlobal(hitPair.localPosition(DTEnums::Right));
   LocalPoint hitPosInChamber_right = chamber->toLocal(hitPosGlob_right);
   GlobalPoint hitPosGlob_left = layer->toGlobal(hitPair.localPosition(DTEnums::Left));
   LocalPoint hitPosInChamber_left = chamber->toLocal(hitPosGlob_left);
  
   float recHitPos = -1;
   if (sl != 2) {
     if (fabs(hitPosInChamber_left.x() - segmentPos) < fabs(hitPosInChamber_right.x() - segmentPos))
       recHitPos = hitPosInChamber_left.x();
     else
       recHitPos = hitPosInChamber_right.x();
   } else {
     if (fabs(hitPosInChamber_left.y() - segmentPos) < fabs(hitPosInChamber_right.y() - segmentPos))
       recHitPos = hitPosInChamber_left.y();
     else
       recHitPos = hitPosInChamber_right.y();
   }
  
   return recHitPos;
 }