Inheritance diagram for AlignmentMonitorMuonSystemMap1D:

Classes
class	MuonSystemMapPlot1D

struct	MyCSCDetId

struct	MyResidual

struct	MyTrack

Public Member Functions
void	afterAlignment (const edm::EventSetup &iSetup)

	AlignmentMonitorMuonSystemMap1D (const edm::ParameterSet &cfg)

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

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

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

virtual	~AlignmentMonitorMuonSystemMap1D ()

Public Member Functions inherited from AlignmentMonitorBase
	AlignmentMonitorBase (const edm::ParameterSet &cfg, std::string name)
	Constructor. More...

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 (const edm::EventSetup &iSetup)
	Called at end of loop: don't reimplement. More...

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

virtual	~AlignmentMonitorBase ()
	Destructor. More...

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

Private Attributes
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

bool	m_createNtuple

TTree *	m_cscnt

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

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

bool	m_doCSC

bool	m_doDT

MuonSystemMapPlot1D *	m_DTvsphi_station [4][5]

MuonSystemMapPlot1D *	m_DTvsz_station [4][14]

MyCSCDetId	m_id

double	m_maxDxy

double	m_maxTrackerRedChi2

double	m_maxTrackP

double	m_maxTrackPt

int	m_minCSCHits

int	m_minDT13Hits

int	m_minDT2Hits

int	m_minNCrossedChambers

int	m_minTrackerHits

double	m_minTrackP

double	m_minTrackPt

edm::InputTag	m_muonCollectionTag

std::vector < MuonSystemMapPlot1D * >	m_plots

MyResidual	m_re

UInt_t	m_run

MyTrack	m_tr

bool	m_useStubPosition

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

Constructor & Destructor Documentation

AlignmentMonitorMuonSystemMap1D::AlignmentMonitorMuonSystemMap1D ( const edm::ParameterSet & cfg )

Definition at line 140 of file AlignmentMonitorMuonSystemMap1D.cc.

References AlignmentMonitorMuonSystemMap1D::MyCSCDetId::e, m_createNtuple, m_cscnt, m_id, m_re, m_run, m_tr, TFileDirectory::make(), AlignmentMonitorMuonSystemMap1D::MyTrack::q, and AlignmentMonitorMuonSystemMap1D::MyResidual::res.

    : AlignmentMonitorBase(cfg, "AlignmentMonitorMuonSystemMap1D")
    , 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"))
 {
   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");
   }
 }

virtual AlignmentMonitorMuonSystemMap1D::~AlignmentMonitorMuonSystemMap1D ( )

inlinevirtual

Definition at line 32 of file AlignmentMonitorMuonSystemMap1D.cc.

32 {}

Member Function Documentation

void AlignmentMonitorMuonSystemMap1D::afterAlignment ( const edm::EventSetup & iSetup )

virtual

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

Reimplemented from AlignmentMonitorBase.

Definition at line 468 of file AlignmentMonitorMuonSystemMap1D.cc.

References gather_cfg::cout, 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.

 {
   std::cout << "AlignmentMonitorMuonSystemMap1D counters:"<<std::endl;
   std::cout << " monitor m_counter_event      = " << m_counter_event << std::endl;
   std::cout << " monitor m_counter_track      = " << m_counter_track << std::endl;
   std::cout << " monitor m_counter_trackppt   = " << m_counter_trackmoment << std::endl;
   std::cout << " monitor m_counter_trackdxy   = " << m_counter_trackdxy  << std::endl;
   std::cout << " monitor m_counter_trackokay  = " << m_counter_trackokay << std::endl;
   std::cout << " monitor m_counter_dt         = " << m_counter_dt << std::endl;
   std::cout << " monitor m_counter_13numhits  = " << m_counter_13numhits << std::endl;
   std::cout << " monitor m_counter_2numhits   = " << m_counter_2numhits << std::endl;
   std::cout << " monitor m_counter_csc        = " << m_counter_csc << std::endl;
   std::cout << " monitor m_counter_cscnumhits = " << m_counter_cscnumhits << std::endl;
 }

void AlignmentMonitorMuonSystemMap1D::book ( )

virtual

Book or retrieve histograms; MUST be reimplemented.

Implements AlignmentMonitorBase.

Definition at line 181 of file AlignmentMonitorMuonSystemMap1D.cc.

References Reference_intrackfit_cff::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, and relativeConstraints::station.

 {
   std::string wheel_label[5]={"A","B","C","D","E"};
 
   for (int station = 1; station<=4; station++)
   {
     char c_station[4];
     sprintf(c_station, "%d", station);
     std::string s_station(c_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)
       {
     char c_ring[4];
     sprintf(c_ring, "%d", ring);
     std::string s_ring(c_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;
 }

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

virtual

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

Reimplemented from AlignmentMonitorBase.

Definition at line 253 of file AlignmentMonitorMuonSystemMap1D.cc.

References SiPixelRawToDigiRegional_cfi::beamSpot, reco::TrackBase::dxy(), edm::EventSetup::get(), edm::Event::getByLabel(), edm::InputTag::label(), AlignmentMonitorBase::m_beamSpotTag, m_counter_event, m_counter_track, m_counter_trackdxy, m_counter_trackmoment, m_maxDxy, m_maxTrackP, m_maxTrackPt, m_minTrackP, m_muonCollectionTag, metsig::muon, patZpeak::muons, reco::TrackBase::p(), AlignmentMonitorBase::pNavigator(), processMuonResidualsFromTrack(), and reco::TrackBase::pt().

 {
   m_counter_event++;
 
   edm::ESHandle<GlobalTrackingGeometry> globalGeometry;
   iSetup.get<GlobalTrackingGeometryRecord>().get(globalGeometry);
 
   edm::Handle<reco::BeamSpot> beamSpot;
   iEvent.getByLabel(m_beamSpotTag, beamSpot);
 
   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(globalGeometry, traj, track, pNavigator(), 1000.);
           processMuonResidualsFromTrack(muonResidualsFromTrack, iEvent);
         }
       } // end if track has acceptable momentum
     } // end loop over tracks
   }
   else
   {
     edm::Handle<reco::MuonCollection> muons;
     iEvent.getByLabel(m_muonCollectionTag, muons);
 
     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);
         }
       }
     }
   }
 }

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

private

Definition at line 172 of file AlignmentMonitorMuonSystemMap1D.cc.

References tmp.

Referenced by book().

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

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

Definition at line 311 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 != NULL  &&  dt13->numHits() >= m_minDT13Hits && dt2 != NULL  &&  dt2->numHits() >= m_minDT2Hits)
       {
         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 != NULL  &&  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 != NULL  &&  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
 }