#include <DTCalibValidation.h>

Inheritance diagram for DTCalibValidation:

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...

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

	~DTCalibValidation () 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)

template<typename type >
void	compute (const DTGeometry *dtGeom, const DTRecSegment4D &segment, const std::map< DTWireId, std::vector< type > > &recHitsPerWire, int step)

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

template<typename type >
const type *	findBestRecHit (const DTLayer *layer, DTWireId wireId, const std::vector< type > &recHits, const float simHitDist)

std::map< DTWireId, std::vector< DTRecHit1DPair > >	map1DRecHitsPerWire (const DTRecHitCollection *dt1DRecHitPairs)

std::map< DTWireId, std::vector< DTRecHit1D > >	map1DRecHitsPerWire (const DTRecSegment2DCollection *segment2Ds)

std::map< DTWireId, std::vector< DTRecHit1D > >	map1DRecHitsPerWire (const DTRecSegment4DCollection *segment4Ds)

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

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

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

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

Private Attributes
bool	detailedAnalysis

const DTGeometry *	dtGeom

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

edm::ESGetToken< DTGeometry, MuonGeometryRecord >	muonGeomToken_

int	nevent

edm::ParameterSet	parameters

edm::EDGetTokenT< DTRecHitCollection >	recHits1DToken_

int	rightSegment

edm::EDGetTokenT< DTRecSegment2DCollection >	segment2DToken_

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 40 of file DTCalibValidation.h.

Constructor & Destructor Documentation

◆ DTCalibValidation()

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

Constructor.

Definition at line 30 of file DTCalibValidation.cc.

References detailedAnalysis, edm::ParameterSet::getUntrackedParameter(), ProducerED_cfi::InputTag, nevent, parameters, muonDTDigis_cfi::pset, recHits1DToken_, rightSegment, segment2DToken_, segment4DToken_, and wrongSegment.

     : muonGeomToken_(esConsumes<edm::Transition::BeginRun>()) {
   parameters = pset;
 
   //FR the following was previously in the beginJob
 
   // the name of the rechits collection at step 1
   recHits1DToken_ =
       consumes<DTRecHitCollection>(edm::InputTag(parameters.getUntrackedParameter<string>("recHits1DLabel")));
   // the name of the 2D segments
   segment2DToken_ =
       consumes<DTRecSegment2DCollection>(edm::InputTag(parameters.getUntrackedParameter<string>("segment2DLabel")));
   // the name of the 4D segments
   segment4DToken_ =
       consumes<DTRecSegment4DCollection>(edm::InputTag(parameters.getUntrackedParameter<string>("segment4DLabel")));
   // the counter of segments not used to compute residuals
   wrongSegment = 0;
   // the counter of segments used to compute residuals
   rightSegment = 0;
   // the analysis type
   detailedAnalysis = parameters.getUntrackedParameter<bool>("detailedAnalysis", false);
 
   nevent = 0;
 }

◆ ~DTCalibValidation()

DTCalibValidation::~DTCalibValidation ( )

override

Destructor.

Definition at line 55 of file DTCalibValidation.cc.

References rightSegment, and wrongSegment.

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

Member Function Documentation

◆ analyze()

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

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 67 of file DTCalibValidation.cc.

References compute(), detailedAnalysis, dtGeom, LogTrace, map1DRecHitsPerWire(), nevent, edm::Handle< T >::product(), recHits1DToken_, segment2DToken_, and segment4DToken_.

                                                                                  {
   ++nevent;
   LogTrace("DTCalibValidation") << "[DTCalibValidation] Analyze #Run: " << event.id().run() << " #Event: " << nevent;
 
   // RecHit mapping at Step 1 -------------------------------
   map<DTWireId, vector<DTRecHit1DPair> > recHitsPerWire_1S;
 
   // RecHit mapping at Step 2 ------------------------------
   map<DTWireId, vector<DTRecHit1D> > recHitsPerWire_2S;
 
   if (detailedAnalysis) {
     LogTrace("DTCalibValidation") << "  -- DTRecHit S1: begin analysis:";
     // Get the rechit collection from the event
     Handle<DTRecHitCollection> dtRecHits;
     event.getByToken(recHits1DToken_, dtRecHits);
     recHitsPerWire_1S = map1DRecHitsPerWire(dtRecHits.product());
 
     LogTrace("DTCalibValidation") << "  -- DTRecHit S2: begin analysis:";
     // Get the 2D rechits from the event
     Handle<DTRecSegment2DCollection> segment2Ds;
     event.getByToken(segment2DToken_, segment2Ds);
     recHitsPerWire_2S = map1DRecHitsPerWire(segment2Ds.product());
   }
 
   // RecHit mapping at Step 3 ---------------------------------
   LogTrace("DTCalibValidation") << "  -- DTRecHit S3: begin analysis:";
   // Get the 4D rechits from the event
   Handle<DTRecSegment4DCollection> segment4Ds;
   event.getByToken(segment4DToken_, segment4Ds);
   map<DTWireId, vector<DTRecHit1D> > recHitsPerWire_3S = map1DRecHitsPerWire(segment4Ds.product());
 
   // Loop over all 4D segments
   for (DTRecSegment4DCollection::const_iterator segment = segment4Ds->begin(); segment != segment4Ds->end();
        ++segment) {
     if (detailedAnalysis) {
       LogTrace("DTCalibValidation") << "Anlysis on recHit at step 1";
       compute(dtGeom, (*segment), recHitsPerWire_1S, 1);
 
       LogTrace("DTCalibValidation") << "Anlysis on recHit at step 2";
       compute(dtGeom, (*segment), recHitsPerWire_2S, 2);
     }
 
     LogTrace("DTCalibValidation") << "Anlysis on recHit at step 3";
     compute(dtGeom, (*segment), recHitsPerWire_3S, 3);
   }
 }

◆ bookHistograms()

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 374 of file DTCalibValidation.cc.

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

                                                                     {
   //FR substitute the DQMStore instance by ibooker
   ibooker.setCurrentFolder("DT/DTCalibValidation");
 
   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();
 
       int firstStep = 1;
       if (!detailedAnalysis)
         firstStep = 3;
       // Loop over the 3 steps
       for (int step = firstStep; step <= 3; ++step) {
         LogTrace("DTCalibValidation") << "   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/DTCalibValidation/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));
         if (detailedAnalysis) {
           histos.push_back(ibooker.book1D("hResPos" + slHistoName,
                                           "Residuals on the position from wire (rec_hit - segm_extr) (cm)",
                                           200,
                                           -0.4,
                                           0.4));
           histos.push_back(
               ibooker.book2D("hResPosVsPos" + slHistoName,
                              "Residuals on the position (cm) from wire (rec_hit - segm_extr) vs distance  (cm)",
                              200,
                              -2.5,
                              2.5,
                              200,
                              -0.4,
                              0.4));
         }
 
         histosPerSL[make_pair(slId, step)] = histos;
       }
     }
   }
 }

◆ bookHistos()

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

private

◆ compute()

template<typename type >

void DTCalibValidation::compute	(	const DTGeometry *	dtGeom,
		const DTRecSegment4D &	segment,
		const std::map< DTWireId, std::vector< type > > &	recHitsPerWire,
		int	step
	)

private

Definition at line 241 of file DTCalibValidation.cc.

References relativeConstraints::chamber, DTGeometry::chamber(), filterCSVwithJSON::copy, funct::cos(), DTRecSegment4D::dimension(), dtGeom, fillHistos(), findBestRecHit(), nano_mu_digi_cff::layer, DTGeometry::layer(), DTRecSegment4D::localDirection(), DTRecSegment4D::localPosition(), LogTrace, DTRecSegment4D::phiSegment(), recHitDistFromWire(), recHitPosition(), FastTrackerRecHitMaskProducer_cfi::recHits, rightSegment, DTRecSegment2D::specificRecHits(), DTSuperLayerId::superlayer(), 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().

                                           {
   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
   // 8 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() != 8) {
       LogTrace("DTCalibValidation") << "[DTCalibValidation] Phi segments has: " << phiRecHits.size()
                                     << " hits, skipping";  // FIXME: info output
       computeResidual = false;
     }
     copy(phiRecHits.begin(), phiRecHits.end(), back_inserter(recHits1D_S3));
   }
   if (!phiSeg) {
     LogTrace("DTCalibValidation") << " [DTCalibValidation] 4D segment has not the 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("DTCalibValidation") << "[DTCalibValidation] Theta segments has: " << zRecHits.size()
                                       << " hits, skipping";  // FIXME: info output
         computeResidual = false;
       }
       copy(zRecHits.begin(), zRecHits.end(), back_inserter(recHits1D_S3));
     }
     if (!zSeg) {
       LogTrace("DTCalibValidation") << " [DTCalibValidation] 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("DTCalibValidation") << "SegmDistance: " << SegmDistance;
       } else if (sl == 2) {
         // RZ SL
         SegmDistance = fabs(segPosAtZWire.y() - wirePosInChamber.y());
         LogTrace("DTCalibValidation") << "SegmDistance: " << SegmDistance;
       }
       if (SegmDistance > 2.1)
         LogTrace("DTCalibValidation") << "  Warning: dist segment-wire: " << SegmDistance;
 
       // Look for RecHits in the same cell
       if (recHitsPerWire.find(wireId) == recHitsPerWire.end()) {
         LogTrace("DTCalibValidation") << "   No RecHit found at Step: " << step << " in cell: " << wireId;
       } else {
         const vector<type>& recHits = recHitsPerWire.at(wireId);
         LogTrace("DTCalibValidation") << "   " << recHits.size() << " RecHits, Step " << step
                                       << " in channel: " << wireId;
 
         // Get the layer
         const DTLayer* layer = dtGeom->layer(wireId);
         // Find the best RecHits
         const type* theBestRecHit = findBestRecHit(layer, wireId, recHits, SegmDistance);
         // Compute the distance of the recHit from the wire
         float recHitWireDist = recHitDistFromWire(*theBestRecHit, layer);
         LogTrace("DTCalibValidation") << "recHitWireDist: " << recHitWireDist;
 
         // Compute the residuals
         float residualOnDistance = recHitWireDist - SegmDistance;
         LogTrace("DTCalibValidation") << "WireId: " << wireId << "  ResidualOnDistance: " << residualOnDistance;
         float residualOnPosition = -1;
         float recHitPos = -1;
         if (sl == 1 || sl == 3) {
           recHitPos = recHitPosition(*theBestRecHit, layer, chamber, segPosAtZWire.x(), sl);
           residualOnPosition = recHitPos - segPosAtZWire.x();
         } else {
           recHitPos = recHitPosition(*theBestRecHit, layer, chamber, segPosAtZWire.y(), sl);
           residualOnPosition = recHitPos - segPosAtZWire.y();
         }
         LogTrace("DTCalibValidation") << "WireId: " << wireId << "  ResidualOnPosition: " << residualOnPosition;
 
         // Fill the histos
         if (sl == 1 || sl == 3)
           fillHistos(wireId.superlayerId(),
                      SegmDistance,
                      residualOnDistance,
                      (wirePosInChamber.x() - segPosAtZWire.x()),
                      residualOnPosition,
                      step);
         else
           fillHistos(wireId.superlayerId(),
                      SegmDistance,
                      residualOnDistance,
                      (wirePosInChamber.y() - segPosAtZWire.y()),
                      residualOnPosition,
                      step);
       }
     }
   }
 }

◆ dqmBeginRun()

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

overridevirtual

BeginRun.

Reimplemented from DQMEDAnalyzer.

Definition at line 62 of file DTCalibValidation.cc.

References dtGeom, muonGeomToken_, and singleTopDQM_cfi::setup.

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

◆ fillHistos()

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

private

Definition at line 455 of file DTCalibValidation.cc.

References detailedAnalysis, HLT_2023v12_cff::distance, combine::histos, histosPerSL, and position.

Referenced by compute().

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

◆ findBestRecHit()

template<typename type >

const type * DTCalibValidation::findBestRecHit	(	const DTLayer *	layer,
		DTWireId	wireId,
		const std::vector< type > &	recHits,
		const float	simHitDist
	)

private

Definition at line 170 of file DTCalibValidation.cc.

References nano_mu_digi_cff::layer, rpcPointValidation_cfi::recHit, recHitDistFromWire(), and FastTrackerRecHitMaskProducer_cfi::recHits.

Referenced by compute().

                                                                     {
   float res = 99999;
   const type* theBestRecHit = nullptr;
   // Loop over RecHits within the cell
   for (typename vector<type>::const_iterator recHit = recHits.begin(); recHit != recHits.end(); ++recHit) {
     float distTmp = recHitDistFromWire(*recHit, layer);
     if (fabs(distTmp - segmDist) < res) {
       res = fabs(distTmp - segmDist);
       theBestRecHit = &(*recHit);
     }
   }  // End of loop over RecHits within the cell
 
   return theBestRecHit;
 }

◆ map1DRecHitsPerWire() [1/3]

map< DTWireId, vector< DTRecHit1DPair > > DTCalibValidation::map1DRecHitsPerWire ( const DTRecHitCollection * dt1DRecHitPairs )

private

Definition at line 115 of file DTCalibValidation.cc.

References runTheMatrix::ret.

Referenced by analyze().

                                                {
   map<DTWireId, vector<DTRecHit1DPair> > ret;
 
   for (DTRecHitCollection::const_iterator rechit = dt1DRecHitPairs->begin(); rechit != dt1DRecHitPairs->end();
        ++rechit) {
     ret[(*rechit).wireId()].push_back(*rechit);
   }
 
   return ret;
 }

◆ map1DRecHitsPerWire() [2/3]

map< DTWireId, vector< DTRecHit1D > > DTCalibValidation::map1DRecHitsPerWire ( const DTRecSegment2DCollection * segment2Ds )

private

Definition at line 128 of file DTCalibValidation.cc.

References runTheMatrix::ret.

                                                                                                                     {
   map<DTWireId, vector<DTRecHit1D> > ret;
 
   // Loop over all 2D segments
   for (DTRecSegment2DCollection::const_iterator segment = segment2Ds->begin(); segment != segment2Ds->end();
        ++segment) {
     vector<DTRecHit1D> component1DHits = (*segment).specificRecHits();
     // Loop over all component 1D hits
     for (vector<DTRecHit1D>::const_iterator hit = component1DHits.begin(); hit != component1DHits.end(); ++hit) {
       ret[(*hit).wireId()].push_back(*hit);
     }
   }
   return ret;
 }

◆ map1DRecHitsPerWire() [3/3]

map< DTWireId, std::vector< DTRecHit1D > > DTCalibValidation::map1DRecHitsPerWire ( const DTRecSegment4DCollection * segment4Ds )

private

Definition at line 144 of file DTCalibValidation.cc.

References hfClusterShapes_cfi::hits, runTheMatrix::ret, and DTRecHit1D::wireId().

                                                 {
   map<DTWireId, vector<DTRecHit1D> > ret;
   // Loop over all 4D segments
   for (DTRecSegment4DCollection::const_iterator segment = segment4Ds->begin(); segment != segment4Ds->end();
        ++segment) {
     // Get component 2D segments
     vector<const TrackingRecHit*> segment2Ds = (*segment).recHits();
     // Loop over 2D segments:
     for (vector<const TrackingRecHit*>::const_iterator segment2D = segment2Ds.begin(); segment2D != segment2Ds.end();
          ++segment2D) {
       // Get 1D component rechits
       vector<const TrackingRecHit*> hits = (*segment2D)->recHits();
       // Loop over them
       for (vector<const TrackingRecHit*>::const_iterator hit = hits.begin(); hit != hits.end(); ++hit) {
         const DTRecHit1D* hit1D = dynamic_cast<const DTRecHit1D*>(*hit);
         ret[hit1D->wireId()].push_back(*hit1D);
       }
     }
   }
 
   return ret;
 }

◆ recHitDistFromWire() [1/2]

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

private

Definition at line 189 of file DTCalibValidation.cc.

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

Referenced by compute(), and findBestRecHit().

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

◆ recHitDistFromWire() [2/2]

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

private

Definition at line 194 of file DTCalibValidation.cc.

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

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

◆ recHitPosition() [1/2]

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

private

Definition at line 199 of file DTCalibValidation.cc.

References relativeConstraints::chamber, nano_mu_digi_cff::layer, DTEnums::Left, DTRecHit1DPair::localPosition(), DTEnums::Right, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by compute().

                                                                                                              {
   // 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;
 }

◆ recHitPosition() [2/2]

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

private

Definition at line 224 of file DTCalibValidation.cc.

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

                                                                                                         {
   // 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;
 }