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.
void	event (const edm::Event &iEvent, const edm::EventSetup &iSetup, const ConstTrajTrackPairCollection &iTrajTracks)
	Called for each event (by "run()"): may be reimplemented.
void	processMuonResidualsFromTrack (MuonResidualsFromTrack &mrft, const edm::Event &iEvent)
virtual	~AlignmentMonitorMuonSystemMap1D ()
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

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, 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 ( ) [inline, virtual]

Definition at line 32 of file AlignmentMonitorMuonSystemMap1D.cc.

{}

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
}