Inheritance diagram for AlignmentMonitorMuonSystemMap1D:

Classes
class	MuonSystemMapPlot1D

struct	MyCSCDetId

struct	MyResidual

struct	MyTrack

Public Member Functions
void	afterAlignment () override

	AlignmentMonitorMuonSystemMap1D (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 edm::Event &iEvent)

	~AlignmentMonitorMuonSystemMap1D () override=default

Public Member Functions inherited from AlignmentMonitorBase
	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...

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
std::string	num02d (int num)

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

const bool	m_allowTIDTEC

long	m_counter_13numhits

long	m_counter_2numhits

long	m_counter_csc

long	m_counter_cscnumhits

long	m_counter_dt

long	m_counter_event

long	m_counter_track

long	m_counter_trackdxy

long	m_counter_trackmoment

long	m_counter_trackokay

const bool	m_createNtuple

TTree *	m_cscnt

MuonSystemMapPlot1D *	m_CSCvsphi_me [2][4][3]

MuonSystemMapPlot1D *	m_CSCvsr_me [2][4][36]

const bool	m_doCSC

const bool	m_doDT

MuonSystemMapPlot1D *	m_DTvsphi_station [4][5]

MuonSystemMapPlot1D *	m_DTvsz_station [4][14]

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

MyCSCDetId	m_id

const double	m_maxDxy

const double	m_maxTrackerRedChi2

const double	m_maxTrackP

const double	m_maxTrackPt

const int	m_minCSCHits

const int	m_minDT13Hits

const int	m_minDT2Hits

const int	m_minNCrossedChambers

const int	m_minTrackerHits

const double	m_minTrackP

const double	m_minTrackPt

const edm::InputTag	m_muonCollectionTag

std::vector< MuonSystemMapPlot1D * >	m_plots

MyResidual	m_re

UInt_t	m_run

MyTrack	m_tr

const bool	m_useStubPosition

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

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 35 of file AlignmentMonitorMuonSystemMap1D.cc.

Constructor & Destructor Documentation

◆ AlignmentMonitorMuonSystemMap1D()

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

Definition at line 156 of file AlignmentMonitorMuonSystemMap1D.cc.

References AlignmentMonitorMuonSystemMap1D::MyCSCDetId::e, compareTotals::fs, m_createNtuple, m_cscnt, m_id, m_re, m_run, m_tr, AlignmentMonitorMuonSystemMap1D::MyTrack::q, and AlignmentMonitorMuonSystemMap1D::MyResidual::res.

     : AlignmentMonitorBase(cfg, iC, "AlignmentMonitorMuonSystemMap1D"),
       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_maxTrackPt(cfg.getParameter<double>("maxTrackPt")),
       m_minTrackP(cfg.getParameter<double>("minTrackP")),
       m_maxTrackP(cfg.getParameter<double>("maxTrackP")),
       m_maxDxy(cfg.getParameter<double>("maxDxy")),
       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_minDT13Hits(cfg.getParameter<int>("minDT13Hits")),
       m_minDT2Hits(cfg.getParameter<int>("minDT2Hits")),
       m_minCSCHits(cfg.getParameter<int>("minCSCHits")),
       m_doDT(cfg.getParameter<bool>("doDT")),
       m_doCSC(cfg.getParameter<bool>("doCSC")),
       m_useStubPosition(cfg.getParameter<bool>("useStubPosition")),
       m_createNtuple(cfg.getParameter<bool>("createNtuple")),
       bsToken_(iC.consumes<reco::BeamSpot>(m_beamSpotTag)),
       muonToken_(iC.consumes<reco::MuonCollection>(m_muonCollectionTag)) {
   if (m_createNtuple) {
     edm::Service<TFileService> fs;
     m_cscnt = fs->make<TTree>("mualNtuple", "mualNtuple");
     m_cscnt->Branch("id", &m_id.e, "e/S:s:r:c:t");
     m_cscnt->Branch("tr", &m_tr.q, "q/I:pt/F:pz");
     m_cscnt->Branch("re", &m_re.res, "res/F:slope:rho:phi:z");
     m_cscnt->Branch("run", &m_run, "run/i");
   }
 }

◆ ~AlignmentMonitorMuonSystemMap1D()

AlignmentMonitorMuonSystemMap1D::~AlignmentMonitorMuonSystemMap1D ( )

overridedefault

Member Function Documentation

◆ afterAlignment()

void AlignmentMonitorMuonSystemMap1D::afterAlignment ( )

overridevirtual

Called after updating AlignableTracker and AlignableMuon (by "endOfLoop()"): may be reimplemented

Reimplemented from AlignmentMonitorBase.

Definition at line 517 of file AlignmentMonitorMuonSystemMap1D.cc.

References m_counter_13numhits, m_counter_2numhits, m_counter_csc, m_counter_cscnumhits, m_counter_dt, m_counter_event, m_counter_track, m_counter_trackdxy, m_counter_trackmoment, and m_counter_trackokay.

                                                      {
   edm::LogVerbatim("AlignmentMuonSystemMap") << "AlignmentMonitorMuonSystemMap1D counters:";
   edm::LogVerbatim("AlignmentMuonSystemMap") << " monitor m_counter_event      = " << m_counter_event;
   edm::LogVerbatim("AlignmentMuonSystemMap") << " monitor m_counter_track      = " << m_counter_track;
   edm::LogVerbatim("AlignmentMuonSystemMap") << " monitor m_counter_trackppt   = " << m_counter_trackmoment;
   edm::LogVerbatim("AlignmentMuonSystemMap") << " monitor m_counter_trackdxy   = " << m_counter_trackdxy;
   edm::LogVerbatim("AlignmentMuonSystemMap") << " monitor m_counter_trackokay  = " << m_counter_trackokay;
   edm::LogVerbatim("AlignmentMuonSystemMap") << " monitor m_counter_dt         = " << m_counter_dt;
   edm::LogVerbatim("AlignmentMuonSystemMap") << " monitor m_counter_13numhits  = " << m_counter_13numhits;
   edm::LogVerbatim("AlignmentMuonSystemMap") << " monitor m_counter_2numhits   = " << m_counter_2numhits;
   edm::LogVerbatim("AlignmentMuonSystemMap") << " monitor m_counter_csc        = " << m_counter_csc;
   edm::LogVerbatim("AlignmentMuonSystemMap") << " monitor m_counter_cscnumhits = " << m_counter_cscnumhits;
 }

◆ book()

void AlignmentMonitorMuonSystemMap1D::book ( )

overridevirtual

Book or retrieve histograms; MUST be reimplemented.

Implements AlignmentMonitorBase.

Definition at line 223 of file AlignmentMonitorMuonSystemMap1D.cc.

References relativeConstraints::chamber, makeMuonMisalignmentScenario::endcap, m_counter_13numhits, m_counter_2numhits, m_counter_csc, m_counter_cscnumhits, m_counter_dt, m_counter_event, m_counter_track, m_counter_trackdxy, m_counter_trackmoment, m_counter_trackokay, m_CSCvsphi_me, m_CSCvsr_me, m_doCSC, m_doDT, m_DTvsphi_station, m_DTvsz_station, M_PI, m_plots, num02d(), relativeConstraints::ring, relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, cond::impl::to_string(), and makeMuonMisalignmentScenario::wheel.

                                            {
   std::string wheel_label[5] = {"A", "B", "C", "D", "E"};
 
   for (unsigned char station = 1; station <= 4; station++) {
     std::string s_station = std::to_string(station);
 
     bool do_y = true;
     if (station == 4)
       do_y = false;
 
     // *** DT ***
     if (m_doDT)
       for (int sector = 1; sector <= 14; sector++) {
         if ((station < 4 && sector <= 12) || station == 4) {
           m_DTvsz_station[station - 1][sector - 1] = new MuonSystemMapPlot1D(
               "DTvsz_st" + s_station + "sec" + num02d(sector), this, 60, -660., 660., do_y, false);
           m_plots.push_back(m_DTvsz_station[station - 1][sector - 1]);
         }
       }
 
     if (m_doDT)
       for (int wheel = -2; wheel <= 2; wheel++) {
         m_DTvsphi_station[station - 1][wheel + 2] = new MuonSystemMapPlot1D(
             "DTvsphi_st" + s_station + "wh" + wheel_label[wheel + 2], this, 180, -M_PI, M_PI, do_y, false);
         m_plots.push_back(m_DTvsphi_station[station - 1][wheel + 2]);
       }
 
     // *** CSC ***
     if (m_doCSC)
       for (int endcap = 1; endcap <= 2; endcap++) {
         std::string s_endcap("m");
         if (endcap == 1)
           s_endcap = "p";
 
         for (int chamber = 1; chamber <= 36; chamber++) {
           m_CSCvsr_me[endcap - 1][station - 1][chamber - 1] = new MuonSystemMapPlot1D(
               "CSCvsr_me" + s_endcap + s_station + "ch" + num02d(chamber), this, 60, 100., 700., false, false);
           m_plots.push_back(m_CSCvsr_me[endcap - 1][station - 1][chamber - 1]);
         }
 
         for (int ring = 1; ring <= 3; ring++)  // the ME1/a (ring4) is not independent from ME1/b (ring1)
         {
           std::string s_ring = std::to_string(ring);
           if ((station > 1 && ring <= 2) || station == 1) {
             m_CSCvsphi_me[endcap - 1][station - 1][ring - 1] =
                 new MuonSystemMapPlot1D("CSCvsphi_me" + s_endcap + s_station + s_ring,
                                         this,
                                         180,
                                         -M_PI / 180. * 5.,
                                         M_PI * (2. - 5. / 180.),
                                         false,
                                         true);
             m_plots.push_back(m_CSCvsphi_me[endcap - 1][station - 1][ring - 1]);
           }
         }
       }  // endcaps
   }      // stations
 
   m_counter_event = 0;
   m_counter_track = 0;
   m_counter_trackmoment = 0;
   m_counter_trackdxy = 0;
   m_counter_trackokay = 0;
   m_counter_dt = 0;
   m_counter_13numhits = 0;
   m_counter_2numhits = 0;
   m_counter_csc = 0;
   m_counter_cscnumhits = 0;
 }

◆ event()

void AlignmentMonitorMuonSystemMap1D::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 293 of file AlignmentMonitorMuonSystemMap1D.cc.

References pwdgSkimBPark_cfi::beamSpot, bsToken_, edm::EventSetup::getData(), edm::EventSetup::getHandle(), iEvent, edm::InputTag::label(), m_counter_event, m_counter_track, m_counter_trackdxy, m_counter_trackmoment, m_esTokenBuilder, m_esTokenDetId, m_esTokenGBTGeom, m_esTokenMF, m_esTokenProp, m_maxDxy, m_maxTrackP, m_maxTrackPt, m_minTrackP, m_muonCollectionTag, HLT_2022v15_cff::magneticField, HLT_2022v15_cff::muon, PDWG_BPHSkim_cff::muons, muonToken_, AlignmentMonitorBase::pNavigator(), processMuonResidualsFromTrack(), DiDispStaMuonMonitor_cfi::pt, and HLT_2022v15_cff::track.

Referenced by Types.EventID::cppID().

                                                                                             {
   m_counter_event++;
 
   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) {
       m_counter_track++;
       const Trajectory *traj = (*trajtrack).first;
       const reco::Track *track = (*trajtrack).second;
 
       if (m_minTrackPt < track->pt() && track->pt() < m_maxTrackPt && m_minTrackP < track->p() &&
           track->p() < m_maxTrackP) {
         m_counter_trackmoment++;
         if (fabs(track->dxy(beamSpot->position())) < m_maxDxy) {
           m_counter_trackdxy++;
 
           MuonResidualsFromTrack muonResidualsFromTrack(
               builder, magneticField, globalGeometry, muonDetIdAssociator_, prop, traj, track, pNavigator(), 1000.);
           processMuonResidualsFromTrack(muonResidualsFromTrack, iEvent);
         }
       }  // end if track has acceptable momentum
     }    // 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;
 
       m_counter_track++;
 
       if (m_minTrackPt < muon->pt() && muon->pt() < m_maxTrackPt && m_minTrackP < muon->p() &&
           muon->p() < m_maxTrackP) {
         m_counter_trackmoment++;
         if (fabs(muon->innerTrack()->dxy(beamSpot->position())) < m_maxDxy) {
           m_counter_trackdxy++;
 
           MuonResidualsFromTrack muonResidualsFromTrack(globalGeometry, &(*muon), pNavigator(), 100.);
           processMuonResidualsFromTrack(muonResidualsFromTrack, iEvent);
         }
       }
     }
   }
 }

◆ fillDescriptions()

void AlignmentMonitorMuonSystemMap1D::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 193 of file AlignmentMonitorMuonSystemMap1D.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and HLT_2022v15_cff::InputTag.

                                                                                                  {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("muonCollectionTag", edm::InputTag(""));
   desc.addUntracked<edm::InputTag>("beamSpotTag", edm::InputTag("offlineBeamSpot"));
   desc.add<double>("minTrackPt", 100.);
   desc.add<double>("maxTrackPt", 200.);
   desc.add<double>("minTrackP", 0.);
   desc.add<double>("maxTrackP", 99999.);
   desc.add<double>("maxDxy", 100.);
   desc.add<int>("minTrackerHits", 15);
   desc.add<double>("maxTrackerRedChi2", 10.);
   desc.add<bool>("allowTIDTEC", true);
   desc.add<int>("minNCrossedChambers", 3);
   desc.add<int>("minDT13Hits", 8);
   desc.add<int>("minDT2Hits", 4);
   desc.add<int>("minCSCHits", 6);
   desc.add<bool>("doDT", true);
   desc.add<bool>("doCSC", true);
   desc.add<bool>("useStubPosition", false);
   desc.add<bool>("createNtuple", false);
   descriptions.add("alignmentMonitorMuonSystemMap1D", desc);
 }

◆ num02d()

std::string AlignmentMonitorMuonSystemMap1D::num02d ( int num )

private

Definition at line 216 of file AlignmentMonitorMuonSystemMap1D.cc.

References cms::cuda::assert(), EgammaValidation_cff::num, AlCaHLTBitMon_QueryRunRegistry::string, and createJobs::tmp.

Referenced by book().

                                                          {
   assert(num >= 0 && num < 100);
   char tmp[4];
   sprintf(tmp, "%02d", num);
   return std::string(tmp);
 }

◆ processMuonResidualsFromTrack()

void AlignmentMonitorMuonSystemMap1D::processMuonResidualsFromTrack	(	MuonResidualsFromTrack &	mrft,
		const edm::Event &	iEvent
	)

Definition at line 349 of file AlignmentMonitorMuonSystemMap1D.cc.

Referenced by event().

                                                                                             {
   if (mrft.trackerNumHits() < m_minTrackerHits)
     return;
   if (!m_allowTIDTEC && mrft.contains_TIDTEC())
     return;
   if (mrft.normalizedChi2() > m_maxTrackerRedChi2)
     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;
 
   char charge = (mrft.getTrack()->charge() > 0 ? 1 : -1);
   // double qoverpt = track->charge() / track->pt();
   // double qoverpz = track->charge() / track->pz();
 
   m_counter_trackokay++;
 
   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) {
       MuonChamberResidual *dt13 = mrft.chamberResidual(*chamberId, MuonChamberResidual::kDT13);
       MuonChamberResidual *dt2 = mrft.chamberResidual(*chamberId, MuonChamberResidual::kDT2);
       DTChamberId id(chamberId->rawId());
 
       m_counter_dt++;
 
       if (id.station() < 4 && dt13 != nullptr && dt13->numHits() >= m_minDT13Hits && dt2 != nullptr &&
           dt2->numHits() >= m_minDT2Hits && (dt2->chi2() / double(dt2->ndof())) < 2.0) {
         m_counter_13numhits++;
 
         double residual = dt13->global_residual();
         double resslope = dt13->global_resslope();
         double chi2 = dt13->chi2();
         int dof = dt13->ndof();
 
         align::GlobalPoint gpos;
         if (m_useStubPosition)
           gpos = dt13->global_stubpos();
         else
           gpos = dt13->global_trackpos();
         double phi = atan2(gpos.y(), gpos.x());
         double z = gpos.z();
 
         assert(1 <= id.sector() && id.sector() <= 14);
 
         m_DTvsz_station[id.station() - 1][id.sector() - 1]->fill_x(charge, z, residual, chi2, dof);
         m_DTvsz_station[id.station() - 1][id.sector() - 1]->fill_dxdz(charge, z, resslope, chi2, dof);
         m_DTvsphi_station[id.station() - 1][id.wheel() + 2]->fill_x(charge, phi, residual, chi2, dof);
         m_DTvsphi_station[id.station() - 1][id.wheel() + 2]->fill_dxdz(charge, phi, resslope, chi2, dof);
 
         m_counter_2numhits++;
 
         residual = dt2->global_residual();
         resslope = dt2->global_resslope();
         chi2 = dt2->chi2();
         dof = dt2->ndof();
 
         if (m_useStubPosition)
           gpos = dt2->global_stubpos();
         else
           gpos = dt2->global_trackpos();
         phi = atan2(gpos.y(), gpos.x());
         z = gpos.z();
 
         assert(1 <= id.sector() && id.sector() <= 14);
 
         m_DTvsz_station[id.station() - 1][id.sector() - 1]->fill_y(charge, z, residual, chi2, dof);
         m_DTvsz_station[id.station() - 1][id.sector() - 1]->fill_dydz(charge, z, resslope, chi2, dof);
         m_DTvsphi_station[id.station() - 1][id.wheel() + 2]->fill_y(charge, phi, residual, chi2, dof);
         m_DTvsphi_station[id.station() - 1][id.wheel() + 2]->fill_dydz(charge, phi, resslope, chi2, dof);
       }
 
       if (id.station() == 4 && dt13 != nullptr && dt13->numHits() >= m_minDT13Hits) {
         m_counter_13numhits++;
 
         double residual = dt13->global_residual();
         double resslope = dt13->global_resslope();
         double chi2 = dt13->chi2();
         int dof = dt13->ndof();
 
         align::GlobalPoint gpos;
         if (m_useStubPosition)
           gpos = dt13->global_stubpos();
         else
           gpos = dt13->global_trackpos();
         double phi = atan2(gpos.y(), gpos.x());
         double z = gpos.z();
 
         assert(1 <= id.sector() && id.sector() <= 14);
 
         m_DTvsz_station[id.station() - 1][id.sector() - 1]->fill_x(charge, z, residual, chi2, dof);
         m_DTvsz_station[id.station() - 1][id.sector() - 1]->fill_dxdz(charge, z, resslope, chi2, dof);
         m_DTvsphi_station[id.station() - 1][id.wheel() + 2]->fill_x(charge, phi, residual, chi2, dof);
         m_DTvsphi_station[id.station() - 1][id.wheel() + 2]->fill_dxdz(charge, phi, resslope, chi2, dof);
       }
     }
 
     else if (m_doCSC && chamberId->subdetId() == MuonSubdetId::CSC) {
       MuonChamberResidual *csc = mrft.chamberResidual(*chamberId, MuonChamberResidual::kCSC);
       CSCDetId id(chamberId->rawId());
 
       int ring = id.ring();
       if (id.ring() == 4)
         ring = 1;  // combine ME1/a + ME1/b
 
       m_counter_csc++;
 
       if (csc != nullptr && csc->numHits() >= m_minCSCHits) {
         m_counter_cscnumhits++;
 
         double residual = csc->global_residual();
         double resslope = csc->global_resslope();
         double chi2 = csc->chi2();
         int dof = csc->ndof();
 
         align::GlobalPoint gpos;
         if (m_useStubPosition)
           gpos = csc->global_stubpos();
         else
           gpos = csc->global_trackpos();
         double phi = atan2(gpos.y(), gpos.x());
         // start phi from -5deg
         if (phi < -M_PI / 180. * 5.)
           phi += 2. * M_PI;
         double R = sqrt(pow(gpos.x(), 2) + pow(gpos.y(), 2));
 
         int chamber = id.chamber() - 1;
         if (id.station() > 1 && ring == 1)
           chamber *= 2;
 
         assert(1 <= id.endcap() && id.endcap() <= 2 && 0 <= chamber && chamber <= 35);
 
         if (R > 0.)
           m_CSCvsphi_me[id.endcap() - 1][id.station() - 1][ring - 1]->fill_x_1d(residual / R, chi2, dof);
 
         m_CSCvsr_me[id.endcap() - 1][id.station() - 1][chamber]->fill_x(charge, R, residual, chi2, dof);
         m_CSCvsr_me[id.endcap() - 1][id.station() - 1][chamber]->fill_dxdz(charge, R, resslope, chi2, dof);
         m_CSCvsphi_me[id.endcap() - 1][id.station() - 1][ring - 1]->fill_x(charge, phi, residual, chi2, dof);
         m_CSCvsphi_me[id.endcap() - 1][id.station() - 1][ring - 1]->fill_dxdz(charge, phi, resslope, chi2, dof);
 
         if (m_createNtuple && chi2 > 0.) {  //  &&  TMath::Prob(chi2, dof) < 0.95)
           m_id.init(id);
           m_tr.q = charge;
           m_tr.pt = mrft.getTrack()->pt();
           m_tr.pz = mrft.getTrack()->pz();
           m_re.res = residual;
           m_re.slope = resslope;
           m_re.rho = R;
           m_re.phi = phi;
           m_re.z = gpos.z();
           m_run = iEvent.id().run();
           m_cscnt->Fill();
         }
       }
     }
 
     //else { assert(false); }
   }  // end loop over chambers
 }