Inheritance diagram for AlignmentMonitorMuonVsCurvature:

Public Member Functions
	AlignmentMonitorMuonVsCurvature (const edm::ParameterSet &cfg, edm::ConsumesCollector iC)

void	book () override
	Book or retrieve histograms; MUST be reimplemented. More...

void	event (const edm::Event &iEvent, const edm::EventSetup &iSetup, const ConstTrajTrackPairCollection &iTrajTracks) override
	Called for each event (by "run()"): may be reimplemented. More...

void	processMuonResidualsFromTrack (MuonResidualsFromTrack &mrft, const Trajectory *traj=nullptr)

	~AlignmentMonitorMuonVsCurvature () override

Public Member Functions inherited from AlignmentMonitorBase
virtual void	afterAlignment ()

	AlignmentMonitorBase (const edm::ParameterSet &cfg, const edm::ConsumesCollector &iC, std::string name)
	Constructor. More...

	AlignmentMonitorBase (const AlignmentMonitorBase &)=delete

void	beginOfJob (AlignableTracker pTracker, AlignableMuon pMuon, AlignmentParameterStore *pStore)
	Called at beginning of job: don't reimplement. More...

void	duringLoop (const edm::Event &iEvent, const edm::EventSetup &iSetup, const ConstTrajTrackPairCollection &iTrajTracks)
	Called for each event: don't reimplement. More...

void	endOfJob ()
	Called at end of processing: don't implement. More...

void	endOfLoop ()
	Called at end of loop: don't reimplement. More...

const AlignmentMonitorBase &	operator= (const AlignmentMonitorBase &)=delete

void	startingNewLoop ()
	Called at beginning of loop: don't reimplement. More...

virtual	~AlignmentMonitorBase ()
	Destructor. More...

Private Types
enum	{ kDeltaX = 0, kDeltaDxDz, kNumComponents }

Private Attributes
const edm::EDGetTokenT< reco::BeamSpot >	bsToken_

const bool	m_allowTIDTEC

const bool	m_doCSC

const bool	m_doDT

const MuonResidualsFromTrack::BuilderToken	m_esTokenBuilder

const edm::ESGetToken< DetIdAssociator, DetIdAssociatorRecord >	m_esTokenDetId

const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	m_esTokenGBTGeom

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	m_esTokenMF

const edm::ESGetToken< Propagator, TrackingComponentsRecord >	m_esTokenProp

const int	m_layer

const double	m_maxDxy

const double	m_maxTrackerRedChi2

const int	m_minCSCHits

const int	m_minDT13Hits

const int	m_minDT2Hits

const bool	m_minNCrossedChambers

const int	m_minTrackerHits

const double	m_minTrackP

const double	m_minTrackPt

const edm::InputTag	m_muonCollectionTag

const std::string	m_propagator

const edm::EDGetTokenT< reco::MuonCollection >	muonToken_

TH1F *	th1f_trackerRedChi2

TH1F *	th1f_trackerRedChi2Diff

TH2F *	th2f_st_ring_chamber [8][3][36][kNumComponents]

TH2F *	th2f_wheel_st_sector [5][4][14][kNumComponents]

TProfile *	tprofile_st_ring_chamber [8][3][36][kNumComponents]

TProfile *	tprofile_wheel_st_sector [5][4][14][kNumComponents]

Additional Inherited Members
Public Types inherited from AlignmentMonitorBase
typedef std::pair< const Trajectory , const reco::Track >	ConstTrajTrackPair

typedef std::vector< ConstTrajTrackPair >	ConstTrajTrackPairCollection

Protected Member Functions inherited from AlignmentMonitorBase
TH1F *	book1D (std::string dir, std::string name, std::string title, int nchX, double lowX, double highX)

TH2F *	book2D (std::string dir, std::string name, std::string title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)

TProfile *	bookProfile (std::string dir, std::string name, std::string title, int nchX, double lowX, double highX, int nchY=1, double lowY=0., double highY=0., const char *option="s")

TFileDirectory *	directory (std::string dir)

int	iteration ()

AlignableMuon *	pMuon ()

AlignableNavigator *	pNavigator ()

AlignmentParameterStore *	pStore ()

AlignableTracker *	pTracker ()

Protected Attributes inherited from AlignmentMonitorBase
const edm::InputTag	m_beamSpotTag

Detailed Description

Definition at line 34 of file AlignmentMonitorMuonVsCurvature.cc.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
kDeltaX
kDeltaDxDz
kNumComponents

Definition at line 74 of file AlignmentMonitorMuonVsCurvature.cc.

74 { kDeltaX = 0, kDeltaDxDz, kNumComponents };

AlignmentMonitorMuonVsCurvature::kDeltaX

Definition: AlignmentMonitorMuonVsCurvature.cc:74

AlignmentMonitorMuonVsCurvature::kDeltaDxDz

Definition: AlignmentMonitorMuonVsCurvature.cc:74

AlignmentMonitorMuonVsCurvature::kNumComponents

Definition: AlignmentMonitorMuonVsCurvature.cc:74

Constructor & Destructor Documentation

◆ AlignmentMonitorMuonVsCurvature()

AlignmentMonitorMuonVsCurvature::AlignmentMonitorMuonVsCurvature	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector	iC
	)

Definition at line 88 of file AlignmentMonitorMuonVsCurvature.cc.

     : AlignmentMonitorBase(cfg, iC, "AlignmentMonitorMuonVsCurvature"),
       m_esTokenGBTGeom(iC.esConsumes()),
       m_esTokenDetId(iC.esConsumes(edm::ESInputTag("", "MuonDetIdAssociator"))),
       m_esTokenProp(iC.esConsumes(edm::ESInputTag("", "SteppingHelixPropagatorAny"))),
       m_esTokenMF(iC.esConsumes()),
       m_esTokenBuilder(iC.esConsumes(MuonResidualsFromTrack::builderESInputTag())),
       m_muonCollectionTag(cfg.getParameter<edm::InputTag>("muonCollectionTag")),
       m_minTrackPt(cfg.getParameter<double>("minTrackPt")),
       m_minTrackP(cfg.getParameter<double>("minTrackP")),
       m_minTrackerHits(cfg.getParameter<int>("minTrackerHits")),
       m_maxTrackerRedChi2(cfg.getParameter<double>("maxTrackerRedChi2")),
       m_allowTIDTEC(cfg.getParameter<bool>("allowTIDTEC")),
       m_minNCrossedChambers(cfg.getParameter<int>("minNCrossedChambers")),
       m_maxDxy(cfg.getParameter<double>("maxDxy")),
       m_minDT13Hits(cfg.getParameter<int>("minDT13Hits")),
       m_minDT2Hits(cfg.getParameter<int>("minDT2Hits")),
       m_minCSCHits(cfg.getParameter<int>("minCSCHits")),
       m_layer(cfg.getParameter<int>("layer")),
       m_propagator(cfg.getParameter<std::string>("propagator")),
       m_doDT(cfg.getParameter<bool>("doDT")),
       m_doCSC(cfg.getParameter<bool>("doCSC")),
       bsToken_(iC.consumes<reco::BeamSpot>(m_beamSpotTag)),
       muonToken_(iC.consumes<reco::MuonCollection>(m_muonCollectionTag)) {}

◆ ~AlignmentMonitorMuonVsCurvature()

AlignmentMonitorMuonVsCurvature::~AlignmentMonitorMuonVsCurvature ( )

inlineoverride

Definition at line 37 of file AlignmentMonitorMuonVsCurvature.cc.

37 {}

Member Function Documentation

◆ book()

void AlignmentMonitorMuonVsCurvature::book ( )

overridevirtual

Book or retrieve histograms; MUST be reimplemented.

Implements AlignmentMonitorBase.

Definition at line 114 of file AlignmentMonitorMuonVsCurvature.cc.

References AlignmentMonitorBase::book1D(), AlignmentMonitorBase::book2D(), AlignmentMonitorBase::bookProfile(), relativeConstraints::chamber, kDeltaDxDz, kDeltaX, kNumComponents, m_doCSC, m_doDT, m_minTrackPt, relativeConstraints::ring, nano_mu_digi_cff::sector, relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, th1f_trackerRedChi2, th1f_trackerRedChi2Diff, th2f_st_ring_chamber, th2f_wheel_st_sector, tprofile_st_ring_chamber, tprofile_wheel_st_sector, and makeMuonMisalignmentScenario::wheel.

                                            {
   // DT
   std::string wheelname[5] = {"wheelm2_", "wheelm1_", "wheelz_", "wheelp1_", "wheelp2_"};
   if (m_doDT)
     for (int wheel = -2; wheel <= 2; wheel++)
       for (int station = 1; station <= 4; station++)
         for (int sector = 1; sector <= 14; sector++) {
           if (station != 4 && sector > 12)
             continue;
 
           char stationname[20];
           sprintf(stationname, "st%d_", station);
 
           char sectorname[20];
           sprintf(sectorname, "sector%02d_", sector);
 
           for (int component = 0; component < kNumComponents; component++) {
             std::stringstream th2f_name, tprofile_name;
             th2f_name << "th2f_" << wheelname[wheel + 2] << stationname << sectorname;
             tprofile_name << "tprofile_" << wheelname[wheel + 2] << stationname << sectorname;
 
             double yminmax = 50., xminmax = 0.05;
             if (m_minTrackPt > 0.)
               xminmax = 1. / m_minTrackPt;
             int ynbins = 50;
             if (component == kDeltaX) {
               th2f_name << "deltax";
               tprofile_name << "deltax";
             } else if (component == kDeltaDxDz) {
               th2f_name << "deltadxdz";
               tprofile_name << "deltadxdz";
             }
 
             th2f_wheel_st_sector[wheel + 2][station - 1][sector - 1][component] =
                 book2D("/iterN/", th2f_name.str(), "", 30, -xminmax, xminmax, ynbins, -yminmax, yminmax);
             tprofile_wheel_st_sector[wheel + 2][station - 1][sector - 1][component] =
                 bookProfile("/iterN/", tprofile_name.str(), "", 30, -xminmax, xminmax);
           }
         }
 
   // CSC
   std::string stname[8] = {"Ep_S1_", "Ep_S2_", "Ep_S3_", "Ep_S4_", "Em_S1_", "Em_S2_", "Em_S3_", "Em_S4_"};
   if (m_doCSC)
     for (int station = 0; station < 8; station++)
       for (int ring = 1; ring <= 3; ring++)
         for (int chamber = 1; chamber <= 36; chamber++) {
           int st = station % 4 + 1;
           if (st > 1 && ring > 2)
             continue;  // only station 1 has more then 2 rings
           if (st > 1 && ring == 1 && chamber > 18)
             continue;  // ring 1 stations 1,2,3 have 18 chambers
 
           char ringname[20];
           sprintf(ringname, "R%d_", ring);
 
           char chname[20];
           sprintf(chname, "C%02d_", chamber);
 
           for (int component = 0; component < kNumComponents; component++) {
             std::stringstream componentname;
             double yminmax = 50., xminmax = 0.05;
             if (m_minTrackPt > 0.)
               xminmax = 1. / m_minTrackPt;
             if (ring == 1)
               xminmax *= 0.5;
             if (component == kDeltaX) {
               componentname << "deltax";
             } else if (component == kDeltaDxDz) {
               componentname << "deltadxdz";
             }
 
             std::stringstream th2f_name, tprofile_name;
             th2f_name << "th2f_" << stname[station] << ringname << chname << componentname.str();
             tprofile_name << "tprofile_" << stname[station] << ringname << chname << componentname.str();
 
             th2f_st_ring_chamber[station][ring - 1][chamber - 1][component] =
                 book2D("/iterN/", th2f_name.str(), "", 30, -xminmax, xminmax, 100, -yminmax, yminmax);
             tprofile_st_ring_chamber[station][ring - 1][chamber - 1][component] =
                 bookProfile("/iterN/", tprofile_name.str(), "", 30, -xminmax, xminmax);
           }
         }
 
   th1f_trackerRedChi2 = book1D("/iterN/", "trackerRedChi2", "Refit tracker reduced chi^2", 100, 0., 30.);
   th1f_trackerRedChi2Diff =
       book1D("/iterN/", "trackerRedChi2Diff", "Fit-minus-refit tracker reduced chi^2", 100, -5., 5.);
 }

◆ event()

void AlignmentMonitorMuonVsCurvature::event	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const ConstTrajTrackPairCollection &	iTrajTracks
	)

overridevirtual

Called for each event (by "run()"): may be reimplemented.

Reimplemented from AlignmentMonitorBase.

Definition at line 201 of file AlignmentMonitorMuonVsCurvature.cc.

References pwdgSkimBPark_cfi::beamSpot, bsToken_, edm::EventSetup::getData(), edm::EventSetup::getHandle(), iEvent, edm::InputTag::label(), m_esTokenBuilder, m_esTokenDetId, m_esTokenGBTGeom, m_esTokenMF, m_esTokenProp, m_maxDxy, m_minTrackP, m_minTrackPt, m_muonCollectionTag, HLT_2023v12_cff::magneticField, HLT_2023v12_cff::muon, DiMuonV_cfg::muons, muonToken_, AlignmentMonitorBase::pNavigator(), processMuonResidualsFromTrack(), DiDispStaMuonMonitor_cfi::pt, and HLT_2023v12_cff::track.

Referenced by Types.EventID::cppID().

                                                                                             {
   const edm::Handle<reco::BeamSpot> &beamSpot = iEvent.getHandle(bsToken_);
 
   const GlobalTrackingGeometry *globalGeometry = &iSetup.getData(m_esTokenGBTGeom);
   const DetIdAssociator *muonDetIdAssociator_ = &iSetup.getData(m_esTokenDetId);
   const Propagator *prop = &iSetup.getData(m_esTokenProp);
   const MagneticField *magneticField = &iSetup.getData(m_esTokenMF);
   auto builder = iSetup.getHandle(m_esTokenBuilder);
 
   if (m_muonCollectionTag.label().empty())  // use trajectories
   {
     for (ConstTrajTrackPairCollection::const_iterator trajtrack = trajtracks.begin(); trajtrack != trajtracks.end();
          ++trajtrack) {
       const Trajectory *traj = (*trajtrack).first;
       const reco::Track *track = (*trajtrack).second;
 
       if (track->pt() > m_minTrackPt && track->p() > m_minTrackP && fabs(track->dxy(beamSpot->position())) < m_maxDxy) {
         MuonResidualsFromTrack muonResidualsFromTrack(
             builder, magneticField, globalGeometry, muonDetIdAssociator_, prop, traj, track, pNavigator(), 1000.);
         processMuonResidualsFromTrack(muonResidualsFromTrack, traj);
       }  // end if track pT is within range
     }    // end loop over tracks
   } else {
     const edm::Handle<reco::MuonCollection> &muons = iEvent.getHandle(muonToken_);
 
     for (reco::MuonCollection::const_iterator muon = muons->begin(); muon != muons->end(); ++muon) {
       if (!(muon->isTrackerMuon() && muon->innerTrack().isNonnull()))
         continue;
 
       if (m_minTrackPt < muon->pt() && m_minTrackP < muon->p() &&
           fabs(muon->innerTrack()->dxy(beamSpot->position())) < m_maxDxy) {
         MuonResidualsFromTrack muonResidualsFromTrack(globalGeometry, &(*muon), pNavigator(), 100.);
         processMuonResidualsFromTrack(muonResidualsFromTrack);
       }
     }
   }
 }

◆ processMuonResidualsFromTrack()

void AlignmentMonitorMuonVsCurvature::processMuonResidualsFromTrack	(	MuonResidualsFromTrack &	mrft,
		const Trajectory *	traj = `nullptr`
	)

Definition at line 241 of file AlignmentMonitorMuonVsCurvature.cc.

References relativeConstraints::chamber, MuonResidualsFromTrack::chamberIds(), MuonResidualsFromTrack::chamberResidual(), reco::TrackBase::charge(), MuonResidualsFromTrack::contains_TIDTEC(), MuonSubdetId::CSC, MuonSubdetId::DT, MuonResidualsFromTrack::getTrack(), MuonChamberResidual::kCSC, kDeltaDxDz, kDeltaX, MuonChamberResidual::kDT13, m_allowTIDTEC, m_doCSC, m_doDT, m_maxTrackerRedChi2, m_minCSCHits, m_minDT13Hits, m_minNCrossedChambers, m_minTrackerHits, DetId::Muon, MuonResidualsFromTrack::normalizedChi2(), reco::TrackBase::normalizedChi2(), reco::TrackBase::pt(), reco::TrackBase::pz(), relativeConstraints::ring, nano_mu_digi_cff::sector, relativeConstraints::station, th1f_trackerRedChi2, th1f_trackerRedChi2Diff, th2f_st_ring_chamber, th2f_wheel_st_sector, tprofile_st_ring_chamber, tprofile_wheel_st_sector, MuonResidualsFromTrack::trackerNumHits(), MuonResidualsFromTrack::trackerRedChi2(), and makeMuonMisalignmentScenario::wheel.

Referenced by event().

                                                                                             {
   if (mrft.trackerNumHits() < m_minTrackerHits)
     return;
   if (!m_allowTIDTEC && mrft.contains_TIDTEC())
     return;
 
   int nMuChambers = 0;
   std::vector<DetId> chamberIds = mrft.chamberIds();
   for (unsigned ch = 0; ch < chamberIds.size(); ch++)
     if (chamberIds[ch].det() == DetId::Muon)
       nMuChambers++;
   if (nMuChambers < m_minNCrossedChambers)
     return;
 
   th1f_trackerRedChi2->Fill(mrft.trackerRedChi2());
   th1f_trackerRedChi2Diff->Fill(mrft.getTrack()->normalizedChi2() - mrft.trackerRedChi2());
 
   if (mrft.normalizedChi2() > m_maxTrackerRedChi2)
     return;
 
   double qoverpt = mrft.getTrack()->charge() / mrft.getTrack()->pt();
   double qoverpz = 0.;
   if (fabs(mrft.getTrack()->pz()) > 0.01)
     qoverpz = mrft.getTrack()->charge() / fabs(mrft.getTrack()->pz());
 
   for (std::vector<DetId>::const_iterator chamberId = chamberIds.begin(); chamberId != chamberIds.end(); ++chamberId) {
     if (chamberId->det() != DetId::Muon)
       continue;
 
     if (m_doDT && chamberId->subdetId() == MuonSubdetId::DT) {
       DTChamberId dtid(chamberId->rawId());
       MuonChamberResidual *dt13 = mrft.chamberResidual(*chamberId, MuonChamberResidual::kDT13);
 
       if (dt13 != nullptr && dt13->numHits() >= m_minDT13Hits) {
         int wheel = dtid.wheel() + 2;
         int station = dtid.station() - 1;
         int sector = dtid.sector() - 1;
 
         double resid_x = 10. * dt13->global_residual();
         double resid_dxdz = 1000. * dt13->global_resslope();
 
         if (fabs(resid_x) < 100. && fabs(resid_dxdz) < 100.) {
           th2f_wheel_st_sector[wheel][station][sector][kDeltaX]->Fill(qoverpt, resid_x);
           tprofile_wheel_st_sector[wheel][station][sector][kDeltaX]->Fill(qoverpt, resid_x);
           th2f_wheel_st_sector[wheel][station][sector][kDeltaDxDz]->Fill(qoverpt, resid_dxdz);
           tprofile_wheel_st_sector[wheel][station][sector][kDeltaDxDz]->Fill(qoverpt, resid_dxdz);
         }
       }  // if it's a good segment
     }    // if DT
 
     if (m_doCSC && chamberId->subdetId() == MuonSubdetId::CSC) {
       CSCDetId cscid(chamberId->rawId());
       MuonChamberResidual *csc = mrft.chamberResidual(*chamberId, MuonChamberResidual::kCSC);
 
       if (csc != nullptr && csc->numHits() >= m_minCSCHits) {
         int station = 4 * cscid.endcap() + cscid.station() - 5;
         int ring = cscid.ring() - 1;
         if (cscid.station() == 1 && cscid.ring() == 4)
           ring = 0;  // join ME1/a to ME1/b
         int chamber = cscid.chamber() - 1;
 
         double resid_x = 10. * csc->global_residual();
         double resid_dxdz = 1000. * csc->global_resslope();
 
         if (fabs(resid_x) < 100. && fabs(resid_dxdz) < 100.) {
           th2f_st_ring_chamber[station][ring][chamber][kDeltaX]->Fill(qoverpz, resid_x);
           tprofile_st_ring_chamber[station][ring][chamber][kDeltaX]->Fill(qoverpz, resid_x);
           th2f_st_ring_chamber[station][ring][chamber][kDeltaDxDz]->Fill(qoverpz, resid_dxdz);
           tprofile_st_ring_chamber[station][ring][chamber][kDeltaDxDz]->Fill(qoverpz, resid_dxdz);
         }
       }  // if it's a good segment
     }    // if CSC
 
   }  // end loop over chamberIds
 }