Adding in Muon Efficiency Maps

DQM/TrackingMonitor/interface/TrackEfficiencyClient.h

@@ -73,6 +73,6 @@ class TrackEfficiencyClient: public DQMEDHarvester
   MonitorElement * effPhi;
   MonitorElement * effD0; 
   MonitorElement * effCompatibleLayers; 
-
+  MonitorElement * effPtPhiLowPt,*effPtPhiHighPt;
 };
 #endif

DQM/TrackingMonitor/interface/TrackEfficiencyMonitor.h

@@ -29,6 +29,8 @@ Monitoring source to measure the track efficiency
 #include "RecoMuon/TrackingTools/interface/MuonServiceProxy.h"
 #include "RecoTracker/MeasurementDet/interface/MeasurementTracker.h"
 #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
+#include "DataFormats/MuonReco/interface/MuonFwd.h"
+#include "DataFormats/MuonReco/interface/MuonSelectors.h"
 
 
 
@@ -46,8 +48,8 @@ class TrackEfficiencyMonitor : public DQMEDAnalyzer {
       typedef reco::TrackCollection TrackCollection;
       explicit TrackEfficiencyMonitor(const edm::ParameterSet&);
       ~TrackEfficiencyMonitor() override;
-      void beginJob(void) override;
-      void endJob(void) override;
+      virtual void beginJob(void);
+      virtual void endJob(void);
       void analyze(const edm::Event&, const edm::EventSetup&) override;
 
       void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override;
@@ -108,10 +110,14 @@ class TrackEfficiencyMonitor : public DQMEDAnalyzer {
   MonitorElement * deltaY    ;
   MonitorElement * signDeltaX;
   MonitorElement * signDeltaY;
-
+  MonitorElement * GlobalMuonPtEtaPhiLowPt; 
+  MonitorElement * StandaloneMuonPtEtaPhiLowPt;
+  MonitorElement * GlobalMuonPtEtaPhiHighPt;
+  MonitorElement * StandaloneMuonPtEtaPhiHighPt;
   const DirectTrackerNavigation* theNavigation;  
   MuonServiceProxy *theMuonServiceProxy;
-
+  //edm::EDGetTokenT<reco::MuonCollection> muonToken_;
+  edm::EDGetTokenT<edm::View<reco::Muon> > muonToken_;
   edm::ESHandle<GeometricSearchTracker> theGeometricSearchTracker;  
   edm::ESHandle<Propagator> thePropagator;
   edm::ESHandle<Propagator> thePropagatorCyl;

DQM/TrackingMonitor/python/TrackEfficiencyMonitor_cfi.py

@@ -13,12 +13,12 @@
     TKTrackCollection = cms.InputTag("rsWithMaterialTracksP5"),
     STATrackCollection = cms.InputTag("cosmicMuons"),
     trackEfficiency  = cms.bool(True),    
-    OutputMEsInRootFile = cms.bool(False),
+    OutputMEsInRootFile = cms.bool(True),
     OutputFileName = cms.string('MonitorTrackEfficiency.root'),
 
     FolderName = cms.string('Track/Efficiencies'),
     AlgoName = cms.string('CTF'),
-
+    muoncoll = cms.InputTag('muons'),        
     muonXBin =  cms.int32(50),
     muonXMin = cms.double(-100),
     muonXMax = cms.double(100),
@@ -90,7 +90,7 @@
     signDeltaYBin = cms.int32(50),
     signDeltaYMin = cms.double(-5),
     signDeltaYMax = cms.double(5),
-
+    SkipEvent = cms.untracked.vstring('ProductNotFound')
 
 )   
 

DQM/TrackingMonitor/src/TrackEfficiencyClient.cc

@@ -138,6 +138,15 @@ void TrackEfficiencyClient::bookMEs(DQMStore::IBooker & ibooker_)
   if (effCompatibleLayers->getTH1F()) effCompatibleLayers->getTH1F()->Sumw2();
   effCompatibleLayers->setAxisTitle("");
 
+  histName = "MuonEffPtPhi_LowPt";
+  effPtPhiLowPt = ibooker_.book2D(histName+algoName_, histName+algoName_, 20,-2.4,2.4,20,-3.25,3.25);
+  if (effPtPhiLowPt->getTH2F()) effPtPhiLowPt->getTH2F()->Sumw2();
+  effPtPhiLowPt->setAxisTitle("");
+
+  histName = "MuonEffPtPhi_HighPt";
+  effPtPhiHighPt = ibooker_.book2D(histName+algoName_, histName+algoName_, 20,-2.4,2.4,20,-3.25,3.25);
+  if (effPtPhiHighPt->getTH2F()) effPtPhiHighPt->getTH2F()->Sumw2();
+  effPtPhiHighPt->setAxisTitle("");
 } 
 
 //----------------------------------------------------------------------------------- 
@@ -147,10 +156,15 @@ void TrackEfficiencyClient::dqmEndJob(DQMStore::IBooker & ibooker_, DQMStore::IG
  edm::LogInfo( "TrackEfficiencyClient") << "TrackEfficiencyClient::endLuminosityBlock"; 
 
  bookMEs(ibooker_);
+ FolderName_ = "Tracking/TrackParameters";
+ std::vector<std::string>  s1 = igetter_.getSubdirs();
+
+ igetter_.cd("Tracking");
+
 
  histName = "/trackX_";
  MonitorElement* trackX = igetter_.get(FolderName_+histName+algoName_);
- 
+
  histName = "/muonX_";
  MonitorElement* muonX  = igetter_.get(FolderName_+histName+algoName_);
 
@@ -184,9 +198,40 @@ void TrackEfficiencyClient::dqmEndJob(DQMStore::IBooker & ibooker_, DQMStore::IG
  histName = "/muonCompatibleLayers_";
  MonitorElement* muonCompatibleLayers  = igetter_.get(FolderName_+histName+algoName_);
 
- if(trackX && muonX && trackY && muonY && trackZ && muonZ && trackEta && muonEta && trackPhi && muonPhi && trackD0 && muonD0 && trackCompatibleLayers && muonCompatibleLayers){
+  histName = "/StandaloneMuonPtEtaPhi_";
+  MonitorElement* StandAloneMuonPtEtaPhi  = igetter_.get(FolderName_+histName+algoName_);
+
+
+  histName = "/GlobalMuonPtEtaPhi_";
+  MonitorElement* GlobalMuonPtEtaPhi  = igetter_.get(FolderName_+histName+algoName_);
+
+  histName = "/StandaloneMuonPtEtaPhi_LowPt_";
+  MonitorElement* StandAloneMuonPtEtaPhiLowPt  = igetter_.get(FolderName_+histName+algoName_);
+  histName = "/GlobalMuonPtEtaPhi_LowPt_";
+  MonitorElement* GlobalMuonPtEtaPhiLowPt  = igetter_.get(FolderName_+histName+algoName_);
+
+  histName = "/StandaloneMuonPtEtaPhi_HighPt_";
+  MonitorElement* StandAloneMuonPtEtaPhiHighPt  = igetter_.get(FolderName_+histName+algoName_);
+  histName = "/GlobalMuonPtEtaPhi_HighPt_";
+  MonitorElement* GlobalMuonPtEtaPhiHighPt  = igetter_.get(FolderName_+histName+algoName_);
+
+
+  if (StandAloneMuonPtEtaPhiLowPt && GlobalMuonPtEtaPhiLowPt && effPtPhiLowPt){
+    if ( StandAloneMuonPtEtaPhiLowPt->getTH2F() && GlobalMuonPtEtaPhiLowPt->getTH2F() && effPtPhiLowPt->getTH2F() ){
+      effPtPhiLowPt->getTH2F()->Divide(GlobalMuonPtEtaPhiLowPt->getTH2F(),StandAloneMuonPtEtaPhiLowPt->getTH2F(), 1.,1.,"");
+    }
+  }
+  if (StandAloneMuonPtEtaPhiHighPt && GlobalMuonPtEtaPhiHighPt && effPtPhiHighPt){
+    if ( StandAloneMuonPtEtaPhiHighPt->getTH2F() && GlobalMuonPtEtaPhiHighPt->getTH2F() && effPtPhiHighPt->getTH2F() ){
+      effPtPhiHighPt->getTH2F()->Divide(GlobalMuonPtEtaPhiHighPt->getTH2F(),StandAloneMuonPtEtaPhiHighPt->getTH2F(), 1.,1.,"");
+    } 
+  }
+ if(trackX && muonX && trackY && muonY && trackZ && muonZ && trackEta && muonEta && trackPhi && muonPhi && trackD0 && muonD0 && trackCompatibleLayers && muonCompatibleLayers){// && StandAloneMuonPtEtaPhi && GlobalMuonPtEtaPhi){
+
    if (trackEfficiency_)
      { 
+
+
        if (effX  ->getTH1F() && trackX  ->getTH1F() && muonX  ->getTH1F()) { effX	-> getTH1F()->Divide(trackX->getTH1F(),muonX->getTH1F(),1.,1.,"");}
        if (effY  ->getTH1F() && trackY  ->getTH1F() && muonY  ->getTH1F()) { effY	-> getTH1F()->Divide(trackY->getTH1F(),muonY->getTH1F(),1.,1.,"");}
        if (effZ  ->getTH1F() && trackZ  ->getTH1F() && muonZ  ->getTH1F()) { effZ	-> getTH1F()->Divide(trackZ->getTH1F(),muonZ->getTH1F(),1.,1.,"");}

DQM/TrackingMonitor/src/TrackEfficiencyMonitor.cc

@@ -57,7 +57,9 @@ TrackEfficiencyMonitor::TrackEfficiencyMonitor(const edm::ParameterSet& iConfig)
   trackEfficiency_     = iConfig.getParameter<bool>("trackEfficiency");
   theTKTracksLabel_    = iConfig.getParameter<edm::InputTag>("TKTrackCollection");
   theSTATracksLabel_   = iConfig.getParameter<edm::InputTag>("STATrackCollection");
-
+  muonToken_     =  consumes<edm::View<reco::Muon> >(iConfig.getParameter<edm::InputTag>("muoncoll"));
+
+
   theTKTracksToken_  = consumes<reco::TrackCollection>(theTKTracksLabel_);
   theSTATracksToken_ = consumes<reco::TrackCollection>(theSTATracksLabel_);
 
@@ -249,14 +251,34 @@ void TrackEfficiencyMonitor::bookHistograms(DQMStore::IBooker & ibooker,
   signDeltaY = ibooker.book1D(histname+AlgoName, histname+AlgoName, signDeltaYBin, signDeltaYMin, signDeltaYMax);
   signDeltaY->setAxisTitle("");
 
+
+  histname = "GlobalMuonPtEtaPhi_LowPt_";
+  GlobalMuonPtEtaPhiLowPt = ibooker.book2D(histname+AlgoName, histname+AlgoName, 20,-2.4,2.4,20,-3.25,3.25);
+  GlobalMuonPtEtaPhiLowPt->setAxisTitle("");
+
+
+  histname = "StandaloneMuonPtEtaPhi_LowPt_";
+  StandaloneMuonPtEtaPhiLowPt = ibooker.book2D(histname+AlgoName, histname+AlgoName, 20,-2.4,2.4,20,-3.25,3.25);
+  StandaloneMuonPtEtaPhiLowPt->setAxisTitle("");
+
+  histname = "GlobalMuonPtEtaPhi_HighPt_";
+  GlobalMuonPtEtaPhiHighPt = ibooker.book2D(histname+AlgoName, histname+AlgoName, 20,-2.4,2.4,20,-3.25,3.25);
+  GlobalMuonPtEtaPhiHighPt->setAxisTitle("");
+
+
+  histname = "StandaloneMuonPtEtaPhi_HighPt_";
+  StandaloneMuonPtEtaPhiHighPt = ibooker.book2D(histname+AlgoName, histname+AlgoName, 20,-2.4,2.4,20,-3.25,3.25);
+  StandaloneMuonPtEtaPhiHighPt->setAxisTitle("");
+
+
 }
 
 
 //-----------------------------------------------------------------------------------
 void TrackEfficiencyMonitor::beginJob(void) 
 //-----------------------------------------------------------------------------------
 {
-  
+
 }
 
 
@@ -265,7 +287,6 @@ void TrackEfficiencyMonitor::beginJob(void)
 void TrackEfficiencyMonitor::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) 
 //-----------------------------------------------------------------------------------
 {
-
 
   edm::Handle<reco::TrackCollection> tkTracks;
   iEvent.getByToken(theTKTracksToken_, tkTracks);
@@ -282,8 +303,22 @@ void TrackEfficiencyMonitor::analyze(const edm::Event& iEvent, const edm::EventS
   iSetup.get<IdealMagneticFieldRecord>().get(bField); 
   iSetup.get<TrackerRecoGeometryRecord>().get(theTracker);
   theNavigation = new DirectTrackerNavigation(theTracker);
-
-
+
+  edm::Handle<edm::View<reco::Muon> > muons; 
+  iEvent.getByToken(muonToken_,muons);
+  for (edm::View<reco::Muon>::const_iterator muon = muons->begin(); muon != muons->end(); ++muon){
+    if( (*muon).pt() < 5) continue;
+    if( fabs((*muon).eta()) > 2.4) continue;
+    if( (*muon).vertexNormalizedChi2() > 10) continue;
+    if ( (*muon).isStandAloneMuon() and (*muon).isGlobalMuon()){
+      if ( (*muon).pt() < 20) GlobalMuonPtEtaPhiLowPt->Fill((*muon).eta(),(*muon).phi());
+      else GlobalMuonPtEtaPhiHighPt->Fill((*muon).eta(),(*muon).phi());
+    }
+    if ( (*muon).isStandAloneMuon()){
+      if ( (*muon).pt() < 20) StandaloneMuonPtEtaPhiLowPt->Fill((*muon).eta(),(*muon).phi());
+      else StandaloneMuonPtEtaPhiHighPt->Fill((*muon).eta(),(*muon).phi());
+    }
+  } 
   if(trackEfficiency_){
   //---------------------------------------------------
   // Select muons with good quality
@@ -353,7 +388,6 @@ void TrackEfficiencyMonitor::endJob(void)
 void TrackEfficiencyMonitor::testTrackerTracks(edm::Handle<reco::TrackCollection> tkTracks, edm::Handle<reco::TrackCollection> staTracks, const NavigationSchool& navigationSchool)
 //-----------------------------------------------------------------------------------
 {
-
   const std::string metname = "testStandAloneMuonTracks";
 
   //---------------------------------------------------
@@ -493,8 +527,6 @@ void TrackEfficiencyMonitor::testTrackerTracks(edm::Handle<reco::TrackCollection
 void TrackEfficiencyMonitor::testSTATracks(edm::Handle<reco::TrackCollection> tkTracks, edm::Handle<reco::TrackCollection> staTracks)
 //-----------------------------------------------------------------------------------
 {
-
-
    reco::TransientTrack tkTT = theTTrackBuilder->build(tkTracks->front());
    double ipX   = tkTT.impactPointState().globalPosition().x();
    double ipY   = tkTT.impactPointState().globalPosition().y();
@@ -593,7 +625,6 @@ TrackEfficiencyMonitor::SemiCylinder TrackEfficiencyMonitor::checkSemiCylinder(c
 bool TrackEfficiencyMonitor::trackerAcceptance( TrajectoryStateOnSurface theTSOS, double theRadius, double theMaxZ)
 //-----------------------------------------------------------------------------------
 {
-
   //---------------------------------------------------  
   // check if the muon is in the tracker acceptance    
   // check the compatibility with a cylinder of radius "theRadius"
@@ -645,7 +676,7 @@ int TrackEfficiencyMonitor::compatibleLayers(const NavigationSchool& navigationS
   //---------------------------------------------------   
   // check the number of compatible layers
   //---------------------------------------------------   
-  
+
   std::vector< const BarrelDetLayer*> barrelTOBLayers = measurementTrackerHandle->geometricSearchTracker()->tobLayers() ;
 
   unsigned int layers = 0;
@@ -721,8 +752,7 @@ std::pair<TrajectoryStateOnSurface,  const DetLayer*>  TrackEfficiencyMonitor::f
 {
 
   //Propagator*  theTmpPropagator = new SteppingHelixPropagator(&*bField,anyDirection);
-
-
+
   Propagator* theTmpPropagator = &*thePropagator->clone();
   theTmpPropagator->setPropagationDirection(alongMomentum); 
 

DQM/TrackingMonitorClient/python/TrackingClientConfig_Tier0_cff.py

@@ -71,6 +71,17 @@
 from DQM.TrackingMonitorClient.V0MonitoringClient_cff import *
 from DQM.TrackingMonitorClient.primaryVertexResolutionClient_cfi import *
 # Sequence
-TrackingOfflineDQMClient = cms.Sequence(trackingQTester*trackingOfflineAnalyser*trackingEffFromHitPattern*voMonitoringClientSequence*primaryVertexResolutionClient)
+
+#import DQM.TrackingMonitor.TrackEfficiencyMonitor_cfi
+#TrackEffMon_ckf = DQM.TrackingMonitor.TrackEfficiencyMonitor_cfi.TrackEffMon.clone()
+#TrackEffMon_ckf.TKTrackCollection                  = 'ctfWithMaterialTracksP5'
+#TrackEffMon_ckf.AlgoName                           = 'CKFTk'
+#TrackEffMon_ckf.FolderName                         = 'Tracking/TrackParameters/TrackEfficiency'
+
+from DQM.TrackingMonitor.TrackEfficiencyClient_cfi import *
+TrackEffClient.FolderName = 'Tracking/TrackParameters/TrackEfficiency'
+TrackEffClient.AlgoName   = 'CKFTk'
+
+TrackingOfflineDQMClient = cms.Sequence(trackingQTester*trackingOfflineAnalyser*trackingEffFromHitPattern*voMonitoringClientSequence*primaryVertexResolutionClient*TrackEffClient)
 
 

DQM/TrackingMonitorSource/python/TrackingSourceConfig_Tier0_cff.py

@@ -8,6 +8,38 @@
 ### load the different flavour of settings of the TrackingMonitor module
 from DQM.TrackingMonitorSource.TrackerCollisionTrackingMonitor_cff import *
 
+#import DQM.TrackingMonitor.TrackerCosmicsTrackingMonitor_cfi
+import DQM.TrackingMonitor.TrackEfficiencyMonitor_cfi
+TrackMon_ckf 					   = DQM.TrackingMonitor.TrackEfficiencyMonitor_cfi.TrackEffMon.clone()
+TrackMon_ckf.TKTrackCollection                     = 'generalTracks'#ctfWithMaterialTracksBeamHaloMuon'#rsWithMaterialTracksP5'#muons'#globalCosmicMuons'#ctfWithMaterialTracksP5'
+TrackMon_ckf.AlgoName                              = 'CKFTk'
+TrackMon_ckf.FolderName                            = 'Tracking/TrackParameters'
+
+# Clone for RS Tracks
+#import DQM.TrackingMonitor.TrackEfficiencyMonitor_cfi
+#TrackEffMon_rs = DQM.TrackingMonitor.TrackEfficiencyMonitor_cfi.TrackEffMon.clone()
+#TrackEffMon_rs.TKTrackCollection                   = 'rsWithMaterialTracksP5'
+#TrackEffMon_rs.AlgoName                            = 'RSTk'
+#TrackEffMon_rs.FolderName                          = 'Tracking/TrackParameters/TrackEfficiency'
+
+# Clone for Beam Halo  Tracks
+#import DQM.TrackingMonitor.TrackEfficiencyMonitor_cfi
+#TrackEffMon_bhmuon = DQM.TrackingMonitor.TrackEfficiencyMonitor_cfi.TrackEffMon.clone()
+#TrackEffMon_bhmuon.TKTrackCollection               = 'ctfWithMaterialTracksBeamHaloMuon'
+#TrackEffMon_bhmuon.AlgoName                        = 'BHMuonTk'
+#TrackEffMon_bhmuon.FolderName                      = 'Tracking/TrackParameters/TrackEfficiency'
+
+# Split Tracking
+from  DQM.TrackingMonitor.TrackSplittingMonitor_cfi import *
+TrackSplitMonitor.FolderName = 'Tracking/TrackParameters/SplitTracks'
+
+
+# DQM Services
+from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
+dqmInfoTracking = DQMEDAnalyzer('DQMEventInfo',
+     subSystemFolder = cms.untracked.string('Tracking')
+)
+
 
 ### define one EDAnalyzer per each track collection
 ### following suggestion 2. in
@@ -315,7 +347,8 @@ def _copyIfExists(mod, pset, name):
 # Sequence
 TrackingDQMSourceTier0 = cms.Sequence(cms.ignore(trackingDQMgoodOfflinePrimaryVertices))
 # dEdx monitoring
-TrackingDQMSourceTier0 += dedxHarmonicSequence * dEdxMonCommon * dEdxHitMonCommon   
+TrackingDQMSourceTier0 += dedxHarmonicSequence * dEdxMonCommon * dEdxHitMonCommon   * TrackMon_ckf * TrackSplitMonitor * dqmInfoTracking
+#TrackMon_cosmicTk*TrackMon_ckf*TrackEffMon_ckf*TrackSplitMonitor*dqmInfoTracking
 #    # temporary patch in order to have BXlumi
 #    * lumiProducer
 # track collections
@@ -352,7 +385,8 @@ def _copyIfExists(mod, pset, name):
 
 TrackingDQMSourceTier0Common = cms.Sequence(cms.ignore(trackingDQMgoodOfflinePrimaryVertices))
 # dEdx monitoring
-TrackingDQMSourceTier0Common += (dedxHarmonicSequence * dEdxMonCommon * dEdxHitMonCommon)    
+TrackingDQMSourceTier0Common += (dedxHarmonicSequence * dEdxMonCommon * dEdxHitMonCommon * TrackMon_ckf * TrackSplitMonitor * dqmInfoTracking)
+#TrackEffMon_ckf*TrackSplitMonitor*dqmInfoTracking)    
 ## monitor track collections
 for tracks in selectedTracks :
     if tracks != 'generalTracks':
@@ -372,7 +406,8 @@ def _copyIfExists(mod, pset, name):
 
 TrackingDQMSourceTier0MinBias = cms.Sequence(cms.ignore(trackingDQMgoodOfflinePrimaryVertices))
 # dEdx monitoring
-TrackingDQMSourceTier0MinBias += dedxHarmonicSequence * dEdxMonCommon * dEdxHitMonCommon    
+TrackingDQMSourceTier0MinBias += dedxHarmonicSequence * dEdxMonCommon * dEdxHitMonCommon * TrackMon_ckf * TrackSplitMonitor * dqmInfoTracking
+#TrackMon_cosmicTk*TrackMon_ckf*TrackEffMon_ckf*TrackSplitMonitor*dqmInfoTracking#TrackMon_ckf*TrackEffMon_ckf 
 #    * lumiProducer
 # monitor track collections
 for tracks in selectedTracks :