From 2345a1d2bd9a6d1ff8a0568cd0dc0a71787faf3e Mon Sep 17 00:00:00 2001
From: Chara Kitsaki <chara.kitsaki@cern.ch>
Date: Fri, 2 Oct 2020 13:21:34 +0000
Subject: [PATCH] CSC DQ - CSC Segments
---
.../CscRawDataMonitoring/CSCSegmValMonAlg.h | 69 +++
.../CscClusterValMonAlg.h | 13 +-
.../CscRawDataMonitoring/CscPrdValMonAlg.h | 7 +-
.../python/CscMonitorAlgorithm.py | 151 ++++-
.../python/CscRawMonLabels.py | 4 +-
.../src/CSCSegmValMonAlg.cxx | 542 ++++++++++++++++++
.../src/CscClusterValMonAlg.cxx | 48 +-
.../src/CscPrdValMonAlg.cxx | 24 +-
.../CscRawDataMonitoring_entries.cxx | 3 +-
9 files changed, 797 insertions(+), 64 deletions(-)
create mode 100755 MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CSCSegmValMonAlg.h
create mode 100755 MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CSCSegmValMonAlg.cxx
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CSCSegmValMonAlg.h b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CSCSegmValMonAlg.h
new file mode 100755
index 00000000000..54a68b8bf31
--- /dev/null
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CSCSegmValMonAlg.h
@@ -0,0 +1,69 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef CSCSegmValMonAlg_H
+#define CSCSegmValMonAlg_H
+
+#include "AthenaMonitoring/AthMonitorAlgorithm.h"
+#include "AthenaMonitoring/ManagedMonitorToolBase.h"
+#include "AthenaMonitoringKernel/Monitored.h"
+
+#include "GaudiKernel/ServiceHandle.h"
+#include "GaudiKernel/ToolHandle.h"
+
+#include "MuonSegment/MuonSegment.h"
+#include "TrkSegment/SegmentCollection.h"
+#include "TrkTrack/Track.h"
+
+#include "TrigDecisionTool/TrigDecisionTool.h"
+#include "StoreGate/ReadHandleKey.h"
+#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
+#include "MuonIdHelpers/IMuonIdHelperSvc.h"
+
+#include <vector>
+#include <string>
+
+namespace Trk {
+ class MeasurementBase;
+}
+
+class CSCSegmValMonAlg : public AthMonitorAlgorithm {
+
+ public:
+ /** Constructor */
+ CSCSegmValMonAlg( const std::string& name, ISvcLocator* pSvcLocator );
+ /** Destructor */
+ virtual ~CSCSegmValMonAlg()=default;
+ virtual StatusCode initialize() override;
+ virtual StatusCode fillHistograms( const EventContext& ctx ) const override;
+
+ private:
+
+ typedef std::vector<TH1 *> SegmHistType;
+ typedef std::vector<TH1 *>::const_iterator SegmHistIter;
+
+ typedef std::vector<const Trk::MeasurementBase*> TrkSegmType;
+ typedef std::vector<const Trk::MeasurementBase*>::const_iterator TrkSegmIter;
+
+ typedef enum EndCaps { ECA = 0, ECC } EndCapType;
+
+ bool isCscSegment( const Muon::MuonSegment* seg ) const;
+ unsigned int cscHits( const Muon::MuonSegment* seg ) const;
+ bool segmSlopeCut(const float csc_x, const float csc_ax, const float cut ) const;
+ //Trigger aware monitoring
+ bool evtSelTriggersPassed() const;
+
+ ServiceHandle<Muon::IMuonEDMHelperSvc> m_edmHelperSvc {this, "edmHelper",
+ "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
+ "Handle to the service providing the IMuonEDMHelperSvc interface" };
+ ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
+ SG::ReadHandleKey<Trk::SegmentCollection> m_segmKey{this,"SegmentKey","MuonSegments","muon segments"};
+
+ Gaudi::Property<std::vector<std::string>> m_sampSelTriggers{this,"EventSelTriggers",{}};
+ Gaudi::Property<bool> m_doEvtSel{this,"DoEventSelection",false};
+ Gaudi::Property<double> m_segmSlope{this,"SegmentSlopeCut",0};
+
+};
+
+#endif
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CscClusterValMonAlg.h b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CscClusterValMonAlg.h
index 813613e7159..5a85d20849c 100644
--- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CscClusterValMonAlg.h
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CscClusterValMonAlg.h
@@ -29,7 +29,9 @@ public:
private:
-
+ //Trigger aware monitoring
+ bool evtSelTriggersPassed() const;
+
ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
// Strip fitter.
ToolHandle<ICscStripFitter> m_stripFitter{this, "CSCStripFitter", "CSCStripFitter", "Strip fitter Tool"};
@@ -41,10 +43,9 @@ private:
SG::ReadHandleKey<Muon::CscPrepDataContainer> m_cscClusterKey{this,"CSCClusterKey","CSC_Clusters","CSC clusters"};
SG::ReadHandleKey<Muon::CscStripPrepDataContainer> m_cscPRDKey{this,"CSCPrepRawDataKey", "CSC_Measurements","CSC PRDs"};
- unsigned int m_qmaxADCCut;
-
- bool m_doEvtSel;
- std::vector<std::string> m_sampSelTriggers;
-
+ Gaudi::Property<std::vector<std::string>> m_sampSelTriggers{this,"CSCEventSelTriggers",{}};
+ Gaudi::Property<bool> m_doEvtSel{this,"CSCDoEventSelection",false};
+ Gaudi::Property<double> m_qmaxADCCut{this,"CSCQmaxCutADC",100};
+
};
#endif
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CscPrdValMonAlg.h b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CscPrdValMonAlg.h
index 29b8c74ede3..bad9a1ad686 100755
--- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CscPrdValMonAlg.h
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/CscRawDataMonitoring/CscPrdValMonAlg.h
@@ -30,14 +30,15 @@ public:
private:
ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
-
- size_t m_cscNoiseCut;
+
SG::ReadHandleKey<Muon::CscStripPrepDataContainer> m_cscPrdKey{this,"CSCPrepRawDataKey","CSC_Measurements","CSC PRDs"};
- bool m_mapxyrz;
// Strip fitter
ToolHandle<ICscStripFitter> m_stripFitter{this, "CSCStripFitter", "CSCStripFitter", "Strip fitter Tool"};
+ Gaudi::Property<bool> m_mapxyrz{this,"MapYXandRZ",false};
+ Gaudi::Property<size_t> m_cscNoiseCut{this,"NoiseCutADC",50};
+
};
#endif
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/python/CscMonitorAlgorithm.py b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/python/CscMonitorAlgorithm.py
index cad0836c34f..2162a404b3e 100644
--- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/python/CscMonitorAlgorithm.py
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/python/CscMonitorAlgorithm.py
@@ -42,7 +42,7 @@ def CscMonitoringConfig(inputFlags):
# This uses the new Configurables object system.
cscClusMonAlg = helper.addAlgorithm(CompFactory.CscClusterValMonAlg,'CscClusMonAlg')
cscPrdMonAlg = helper.addAlgorithm(CompFactory.CscPrdValMonAlg,'CscPrdMonAlg')
- # cscSegmMonAlg = helper.addAlgorithm(CompFactory.CscSegmValMonAlg,'CscSegmValMonAlg')
+ cscSegmMonAlg = helper.addAlgorithm(CompFactory.CSCSegmValMonAlg,'CscSegmMonAlg')
### STEP 3 ###
@@ -50,9 +50,12 @@ def CscMonitoringConfig(inputFlags):
# some generic property
# exampleMonAlg.RandomHist = True
cscClusMonAlg.CSCQmaxCutADC = 100
+ cscClusMonAlg.CSCDoEventSelection = False
+ cscClusMonAlg.CSCEventSelTriggers = [ "" ]
cscPrdMonAlg.NoiseCutADC = 50
cscPrdMonAlg.MapYXandRZ = False
-
+ cscSegmMonAlg.DoEventSelection = False
+ cscSegmMonAlg.EventSelTriggers = [ "" ] #[ "L1_MU10", "L1_MU15", "EF_mu20_muCombTag_NoEF", "EF_mu15", "EF_mu15_mu10_EFFS", "EF_2mu10", "EF_2mu10_loose" ]
# to enable a trigger filter, for example:
#exampleMonAlg.TriggerChain = 'HLT_mu26_ivarmedium'
@@ -79,7 +82,7 @@ def CscMonitoringConfig(inputFlags):
# object here is the standard GenericMonitoringTool.
cscClusGroup = helper.addGroup(cscClusMonAlg,'CscClusMonitor','Muon/MuonRawDataMonitoring/CSC/')
cscPrdGroup = helper.addGroup(cscPrdMonAlg,'CscPrdMonitor','Muon/MuonRawDataMonitoring/CSC/')
- # cscSegmGroup = helper.addGroup(cscSegmMonAlg,'CscSegmMonitor','Muon/MuonRawDataMonitoring/CSC/')
+ cscSegmGroup = helper.addGroup(cscSegmMonAlg,'CscSegmMonitor','Muon/MuonSegmentMonitoring/')
@@ -351,6 +354,147 @@ def CscMonitoringConfig(inputFlags):
cscClusGroup.defineHistogram('nPhiClusWidthCnt_mon,nEtaClusWidthCnt_mon;h2csc_prd_eta_vs_phi_cluswidth',type='TH2F',title='Eta vs. Phi Cluster width correlation;#varphi-cluster width;#eta-cluster width',
path='PRD/Expert',xbins=100,xmin=0,xmax=100,ybins=100,ymin=0,ymax=100)
+ #Segments
+
+ cscSegmGroup.defineHistogram('n_clust,segm_sectorNo;Muon_Segm_NumSegments_EA',cutmask='sideA',type='TH2F',title='EndCap A: No. of segments; #segments; [sector] + [0.2 #times layer]',
+ path='EndCapA/Overview/MuonSegments/CSC',xbins=20,xmin=0,xmax=80,ybins=90,ymin=0,ymax=18.)
+
+ cscSegmGroup.defineHistogram('n_clust,segm_sectorNo;Muon_Segm_NumSegments_EC',cutmask='sideC',type='TH2F',title='EndCap C: No. of segments; #segments; [sector] + [0.2 #times layer]',
+ path='EndCapC/Overview/MuonSegments/CSC',xbins=20,xmin=0,xmax=80,ybins=85,ymin=-17,ymax=0.)
+
+ thisLabelx=getCSCLabelx("labels_sgm_status")
+ status_bins = len(thisLabelx)
+ cscSegmGroup.defineHistogram('status_mon;Muon_Segm_EtaClusterStatus_EA',cutmask='sideA_phi0',type='TH1F',title='Endcap A: #eta-cluster status;;entries',
+ path='EndCapA/Detail/CSC',xbins=status_bins,xmin=-0.5,xmax=status_bins-0.5,xlabels=thisLabelx)
+
+ thisLabelx=getCSCLabelx("labels_sgm_status")
+ status_bins = len(thisLabelx)
+ cscSegmGroup.defineHistogram('status_mon;Muon_Segm_EtaClusterStatus_EC',cutmask='sideC_phi0',type='TH1F',title='Endcap C: #eta-cluster status;;entries',
+ path='EndCapC/Detail/CSC',xbins=status_bins,xmin=-0.5,xmax=status_bins-0.5,xlabels=thisLabelx)
+
+ thisLabelx=getCSCLabelx("labels_sgm_status")
+ status_bins = len(thisLabelx)
+ cscSegmGroup.defineHistogram('status_mon;Muon_Segm_PhiClusterStatus_EA',cutmask='sideA_phi',type='TH1F',title='Endcap A: #phi-cluster status;;entries',
+ path='EndCapA/Detail/CSC',xbins=status_bins,xmin=-0.5,xmax=status_bins-0.5,xlabels=thisLabelx)
+
+ thisLabelx=getCSCLabelx("labels_sgm_status")
+ status_bins = len(thisLabelx)
+ cscSegmGroup.defineHistogram('status_mon;Muon_Segm_PhiClusterStatus_EC',cutmask='sideC_phi',type='TH1F',title='Endcap C: #phi-cluster status;;entries',
+ path='EndCapC/Detail/CSC',xbins=status_bins,xmin=-0.5,xmax=status_bins-0.5,xlabels=thisLabelx)
+
+
+ cscSegmGroup.defineHistogram('clus_qsum_mon,clus_secLayer;Muon_Segm_QSumEtaGoodClusPerLayer_EA',cutmask='checkStatusEtaA',type='TH2F',title='EndCap A: #eta-cluster charge per layer;counts;[sector] + [0.2 #times layer]',
+ path='EndCapA/Overview/MuonSegments/CSC',xbins=80,xmin=0.,xmax=4000.,ybins=90,ymin=0.,ymax=18.) #PLEASE CHECk
+
+ cscSegmGroup.defineHistogram('clus_time_mon,clus_secLayer;Muon_Segm_TimeEtaGoodClusPerLayer_EA',cutmask='checkTimeEtaA',type='TH2F',title='EndCap A: #eta-cluster time per layer;time [ns];[sector] + [0.2 #times layer]',
+ path='EndCapA/Overview/MuonSegments/CSC',xbins=40,xmin=-200.,xmax=200.,ybins=90,ymin=0.,ymax=18.) #PLEASE CHECk
+
+ cscSegmGroup.defineHistogram('clus_qsum_mon,clus_secLayer;Muon_Segm_QSumEtaGoodClusPerLayer_EC',cutmask='checkStatusEtaC',type='TH2F',title='EndCap C: #eta-cluster charge per layer;counts;[sector] + [0.2 #times layer]',
+ path='EndCapC/Overview/MuonSegments/CSC',xbins=80,xmin=0.,xmax=4000.,ybins=85,ymin=-17.,ymax=0.)
+
+ cscSegmGroup.defineHistogram('clus_time_mon,clus_secLayer;Muon_Segm_TimeEtaGoodClusPerLayer_EC',cutmask='checkTimeEtaC',type='TH2F',title='EndCap C: #eta-cluster time per layer;time [ns];[sector] + [0.2 #times layer]',
+ path='EndCapC/Overview/MuonSegments/CSC',xbins=40,xmin=-200.,xmax=200.,ybins=85,ymin=-17.,ymax=0.)
+
+ cscSegmGroup.defineHistogram('clus_qsum_mon,clus_secLayer;Muon_Segm_QSumPhiGoodClusPerLayer_EA',cutmask='checkStatusPhiA',type='TH2F',title='EndCap A: #phi-cluster charge per layer;counts;[sector] + [0.2 #times layer]',
+ path='EndCapA/Overview/MuonSegments/CSC',xbins=80,xmin=0.,xmax=4000,ybins=90,ymin=0.,ymax=18.)
+
+ cscSegmGroup.defineHistogram('clus_time_mon,clus_secLayer;Muon_Segm_TimePhiGoodClusPerLayer_EA',cutmask='checkTimePhiA',type='TH2F',title='EndCap A: #phi-cluster time per layer;time [ns];[sector] + [0.2 #times layer]',
+ path='EndCapA/Overview/MuonSegments/CSC',xbins=40,xmin=-200.,xmax=200.,ybins=90, ymin=0.,ymax=18.)
+
+ cscSegmGroup.defineHistogram('clus_qsum_mon,clus_secLayer;Muon_Segm_QSumPhiGoodClusPerLayer_EC',cutmask='checkStatusPhiC',type='TH2F',title='EndCap C: #phi-cluster charge per layer;counts;[sector] + [0.2 #times layer]',
+ path='EndCapC/Overview/MuonSegments/CSC',xbins=80,xmin=0.,xmax=4000,ybins=85,ymin=-17.,ymax=0.)
+
+ cscSegmGroup.defineHistogram('clus_time_mon,clus_secLayer;Muon_Segm_TimePhiGoodClusPerLayer_EC',cutmask='checkTimePhiC',type='TH2F',title='EndCap A: #phi-cluster time per layer;time [ns];[sector] + [0.2 #times layer]',
+ path='EndCapC/Overview/MuonSegments/CSC',xbins=40,xmin=-200.,xmax=200.,ybins=85,ymin=-17.,ymax=0.)
+
+ cscSegmGroup.defineHistogram('tmp_etaClusA;Muon_Segm_NumEtaCluster_EA',cutmask='checkClusEtaA',type='TH1F',title='Endcap A: No. of #eta-clusters on segment;#clusters;entries',
+ path='EndCapA/Detail/CSC',xbins=11,xmin=-0.5,xmax=10.5)
+
+ cscSegmGroup.defineHistogram('tmp_etaClusGoodA;Muon_Segm_NumGoodEtaCluster_EA',cutmask='checkClusEtaGoodA',type='TH1F',title='Endcap A: No. of good #eta-clusters on segment;#good-clusters;entries',
+ path='EndCapA/Detail/CSC',xbins=11,xmin=-0.5,xmax=10.5)
+
+ cscSegmGroup.defineHistogram('tmp_phiClusA;Muon_Segm_NumPhiCluster_EA',cutmask='checkClusPhiA',type='TH1F',title='Endcap A: No. of #phi-clusters on segment;#clusters;entries',
+ path='EndCapA/Detail/CSC',xbins=11,xmin=-0.5,xmax=10.5)
+
+ cscSegmGroup.defineHistogram('tmp_phiClusGoodA;Muon_Segm_NumGoodPhiCluster_EA',cutmask='checkClusPhiGoodA',type='TH1F',title='Endcap A: No. of good #phi-clusters on segment;#good-clusters;entries',
+ path='EndCapA/Detail/CSC',xbins=11,xmin=-0.5,xmax=10.5)
+
+ cscSegmGroup.defineHistogram('tmp_etaClusC;Muon_Segm_NumEtaCluster_EC',cutmask='checkClusEtaC',type='TH1F',title='Endcap C: No. of #eta-clusters on segment;#clusters;entries',
+ path='EndCapC/Detail/CSC',xbins=11,xmin=-0.5,xmax=10.5)
+
+ cscSegmGroup.defineHistogram('tmp_etaClusGoodC;Muon_Segm_NumGoodEtaCluster_EC',cutmask='checkClusEtaGoodC',type='TH1F',title='Endcap C: No. of good #eta-clusters on segment;#good-clusters;entries',
+ path='EndCapC/Detail/CSC',xbins=11,xmin=-0.5,xmax=10.5)
+
+ cscSegmGroup.defineHistogram('tmp_phiClusC;Muon_Segm_NumPhiCluster_EC',cutmask='checkClusPhiC',type='TH1F',title='Endcap C: No. of #phi-clusters on segment;#clusters;entries',
+ path='EndCapC/Detail/CSC',xbins=11,xmin=-0.5,xmax=10.5)
+
+ cscSegmGroup.defineHistogram('tmp_phiClusGoodC;Muon_Segm_NumGoodPhiCluster_EC',cutmask='checkClusPhiGoodC',type='TH1F',title='Endcap C: No. of good #phi-clusters on segment;#good-clusters;entries',
+ path='EndCapC/Detail/CSC',xbins=11,xmin=-0.5,xmax=10.5)
+
+ thisLabelx=getCSCLabelx("labels_sgm_clusCounts")
+ cscSegmGroup.defineHistogram('tmp_layerIndexA_mon,tmp_isectA_mon;Muon_Segm_NumNClusSegments_EA',type='TH2F',title='EndCap A: #eta-number of 3 and 4 cluster segments with each layer;counts;[sector] + [0.2 #times layer]',
+ path='EndCapA/Detail/CSC',xbins=50,xmin=.5,xmax=5.5,ybins=90,ymin=0,ymax=18.,xlabels=thisLabelx)
+
+ thisLabelx=getCSCLabelx("labels_sgm_clusCounts")
+ cscSegmGroup.defineHistogram('tmp_layerIndexC_mon,tmp_isectC_mon;Muon_Segm_NumNClusSegments_EC',type='TH2F',title='EndCap C: #eta-number of 3 and 4 cluster segments with each layer;counts;[sector] + [0.2 #times layer]',
+ path='EndCapC/Detail/CSC',xbins=50,xmin=.5,xmax=5.5,ybins=85,ymin=-17,ymax=0.,xlabels=thisLabelx)
+
+ cscSegmGroup.defineHistogram('etaClusQSumA;Muon_Segm_QSumEtaCluster_EA',type='TH1F',title='Endcap A: #eta-cluster Qsum;counts;entries',
+ path='EndCapA/Detail/CSC',xbins=80,xmin=0.,xmax=4000.)
+
+ cscSegmGroup.defineHistogram('phiClusQSumA;Muon_Segm_QSumPhiCluster_EA',type='TH1F',title='Endcap A: #phi-cluster Qsum;counts;entries',
+ path='EndCapA/Detail/CSC',xbins=80,xmin=0.,xmax=4000.)
+
+ cscSegmGroup.defineHistogram('etaTimeClusA;Muon_Segm_TimeEtaCluster_EA',type='TH1F',title='Endcap A: #eta-cluster Time;time [ns];entries',
+ path='EndCapA/Detail/CSC',xbins=40,xmin=-200.,xmax=200.)
+
+ cscSegmGroup.defineHistogram('phiTimeClusA;Muon_Segm_TimePhiCluster_EA',type='TH1F',title='Endcap A: #phi-cluster Time;time [ns];entries',
+ path='EndCapA/Detail/CSC',xbins=40,xmin=-200.,xmax=200.)
+
+ cscSegmGroup.defineHistogram('etaClusQSumC;Muon_Segm_QSumEtaCluster_EC',type='TH1F',title='Endcap C: #eta-cluster Qsum;counts;entries',
+ path='EndCapC/Detail/CSC',xbins=80,xmin=0.,xmax=4000.)
+
+ cscSegmGroup.defineHistogram('phiClusQSumC;Muon_Segm_QSumPhiCluster_EC',type='TH1F',title='Endcap C: #phi-cluster Qsum;counts;entries',
+ path='EndCapC/Detail/CSC',xbins=80,xmin=0.,xmax=4000.)
+
+ cscSegmGroup.defineHistogram('etaTimeClusC;Muon_Segm_TimeEtaCluster_EC',type='TH1F',title='Endcap C: #eta-cluster Time;time [ns];entries',
+ path='EndCapC/Detail/CSC',xbins=40,xmin=-200.,xmax=200.)
+
+ cscSegmGroup.defineHistogram('phiTimeClusC;Muon_Segm_TimePhiCluster_EC',type='TH1F',title='Endcap C: #phi-cluster Time;time [ns];entries',
+ path='EndCapC/Detail/CSC',xbins=40,xmin=-200.,xmax=200.)
+
+ cscSegmGroup.defineHistogram('etaQSumGoodClusA;Muon_Segm_QSumGoodEtaCluster_EA',type='TH1F',title='Endcap A: Good #eta-cluster Qsum;counts;entries',
+ path='EndCapA/Detail/CSC',xbins=80,xmin=0.,xmax=4000.)
+
+ cscSegmGroup.defineHistogram('phiQSumGoodClusA;Muon_Segm_QSumGoodPhiCluster_EA',type='TH1F',title='Endcap A: Good #phi-cluster Qsum;counts;entries',
+ path='EndCapA/Detail/CSC',xbins=80,xmin=0.,xmax=4000.)
+
+ cscSegmGroup.defineHistogram('etaQSumGoodClusC;Muon_Segm_QSumGoodEtaCluster_EC',type='TH1F',title='Endcap C: Good #eta-cluster Qsum;counts;entries',
+ path='EndCapC/Detail/CSC',xbins=80,xmin=0.,xmax=4000.)
+
+ cscSegmGroup.defineHistogram('phiQSumGoodClusC;Muon_Segm_QSumGoodPhiCluster_EC',type='TH1F',title='Endcap C: Good #phi-cluster Qsum;counts;entries',
+ path='EndCapC/Detail/CSC',xbins=80,xmin=0.,xmax=4000.)
+
+ cscSegmGroup.defineHistogram('etaTimeGoodClusA;Muon_Segm_TimeGoodEtaCluster_EA',type='TH1F',title='Endcap A: Good #eta-cluster Time;time [ns];entries',
+ path='EndCapA/Detail/CSC',xbins=40,xmin=-200.,xmax=200.)
+
+ cscSegmGroup.defineHistogram('etaTimeGoodClusC;Muon_Segm_TimeGoodEtaCluster_EC',type='TH1F',title='Endcap C: Good #eta-cluster Time;time [ns];entries',
+ path='EndCapC/Detail/CSC',xbins=40,xmin=-200.,xmax=200.)
+
+ cscSegmGroup.defineHistogram('phiTimeGoodClusA;Muon_Segm_TimeGoodPhiCluster_EA',type='TH1F',title='Endcap A: Good #phi-cluster Time;time [ns];entries',
+ path='EndCapA/Detail/CSC',xbins=40,xmin=-200.,xmax=200.)
+
+ cscSegmGroup.defineHistogram('phiTimeGoodClusC;Muon_Segm_TimeGoodPhiCluster_EC',type='TH1F',title='Endcap C: Good #phi-cluster Time;time [ns];entries',
+ path='EndCapC/Detail/CSC',xbins=40,xmin=-200.,xmax=200.)
+
+ cscSegmGroup.defineHistogram('etaQSumTot0,phiQSumTot0;Muon_Segm_QSumGoodClusCorrelation_EA',type='TH2F',title='Endcap A: #phi-cluster vs. good #eta-cluster;good #eta-cluster counts;good #phi-cluster counts',
+ path='EndCapA/Detail/CSC',xbins=80,xmin=0.,xmax=4000.,ybins=80,ymin=0.,ymax=4000.)
+
+ cscSegmGroup.defineHistogram('etaQSumTot,phiQSumTot;Muon_Segm_QSumGoodClusCorrelation_EC',type='TH2F',title='Endcap C: #phi-cluster vs. good #eta-cluster;good #eta-cluster counts;good #phi-cluster counts',
+ path='EndCapC/Detail/CSC',xbins=80,xmin=0.,xmax=4000.,ybins=80,ymin=0.,ymax=4000.)
+
+
+
#myGroup.defineHistogram('lb', title='Luminosity Block;lb;Events',
@@ -432,6 +576,7 @@ if __name__=='__main__':
from AthenaConfiguration.TestDefaults import defaultTestFiles
ConfigFlags.Input.Files = defaultTestFiles.ESD
+
ConfigFlags.Output.HISTFileName = 'CscMonitorOutput.root'
ConfigFlags.Muon.doCSCs = True
ConfigFlags.Muon.doRPCs = False
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/python/CscRawMonLabels.py b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/python/CscRawMonLabels.py
index 3fd6aa2d74a..7d02001b3c2 100644
--- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/python/CscRawMonLabels.py
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/python/CscRawMonLabels.py
@@ -3,4 +3,6 @@
#
labels_clus_occupancy_signal_EA=['','','','','','L01:1', 'L01:2', 'L01:3', 'L01:4', '', 'S02:1', 'S02:2', 'S02:3', 'S02:4', '', 'L03:1', 'L03:2', 'L03:3', 'L03:4', '', 'S04:1', 'S04:2', 'S04:3', 'S04:4', '', 'L05:1', 'L05:2', 'L05:3', 'L05:4', '', 'S06:1', 'S06:2', 'S06:3', 'S06:4', '', 'L07:1', 'L07:2', 'L07:3', 'L07:4', '', 'S08:1', 'S08:2', 'S08:3', 'S08:4', '', 'L09:1', 'L09:2', 'L09:3', 'L09:4', '', 'S10:1', 'S10:2', 'S10:3', 'S10:4', '', 'L11:1', 'L11:2', 'L11:3', 'L11:4', '', 'S12:1', 'S12:2', 'S12:3', 'S12:4', '', 'L13:1', 'L13:2', 'L13:3', 'L13:4', '', 'S14:1', 'S14:2', 'S14:3', 'S14:4', '', 'L15:1', 'L15:2', 'L15:3', 'L15:4', '', 'S16:1', 'S16:2', 'S16:3', 'S16:4', '','','','','','']
-labels_clus_occupancy_signal_EC=['','','','','','L15:4', 'L15:3', 'L15:2', 'L15:1', '', 'S14:4', 'S14:3', 'S14:2', 'S14:1', '', 'L13:4', 'L13:3', 'L13:2', 'L13:1', '', 'S12:4', 'S12:3', 'S12:2', 'S12:1', '', 'L11:4', 'L11:3', 'L11:2', 'L11:1', '', 'S10:4', 'S10:3', 'S10:2', 'S10:1', '', 'L09:4', 'L09:3', 'L09:2', 'L09:1', '', 'S08:4', 'S08:3', 'S08:2', 'S08:1', '', 'L07:4', 'L07:3', 'L07:2', 'L07:1', '', 'S06:4', 'S06:3', 'S06:2', 'S06:1', '', 'L05:4', 'L05:3', 'L05:2', 'L05:1', '', 'S04:4', 'S04:3', 'S04:2', 'S04:1', '', 'L03:4', 'L03:3', 'L03:2', 'L03:1', '', 'S02:4', 'S02:3', 'S02:2', 'S02:1', '', 'L01:4', 'L01:3', 'L01:2', 'L01:1', '', 'S00:4', 'S00:3', 'S00:2', 'S00:1', '']
\ No newline at end of file
+labels_clus_occupancy_signal_EC=['','','','','','L15:4', 'L15:3', 'L15:2', 'L15:1', '', 'S14:4', 'S14:3', 'S14:2', 'S14:1', '', 'L13:4', 'L13:3', 'L13:2', 'L13:1', '', 'S12:4', 'S12:3', 'S12:2', 'S12:1', '', 'L11:4', 'L11:3', 'L11:2', 'L11:1', '', 'S10:4', 'S10:3', 'S10:2', 'S10:1', '', 'L09:4', 'L09:3', 'L09:2', 'L09:1', '', 'S08:4', 'S08:3', 'S08:2', 'S08:1', '', 'L07:4', 'L07:3', 'L07:2', 'L07:1', '', 'S06:4', 'S06:3', 'S06:2', 'S06:1', '', 'L05:4', 'L05:3', 'L05:2', 'L05:1', '', 'S04:4', 'S04:3', 'S04:2', 'S04:1', '', 'L03:4', 'L03:3', 'L03:2', 'L03:1', '', 'S02:4', 'S02:3', 'S02:2', 'S02:1', '', 'L01:4', 'L01:3', 'L01:2', 'L01:1', '', 'S00:4', 'S00:3', 'S00:2', 'S00:1', '']
+labels_sgm_status = [ "Unspoiled", "Simple", "Edge", "MultiPeak", "Narrow", "Wide", "Skewed", "QRatInc", "StripFitFailed", "SplitUnspoiled", "SplitSimple", "SplitEdge", "SplitMultiPeak", "SplitNarrow", "SplitWide", "SplitSkewed", "SplitQRatInc", "SplitStripFitFailed", "Undefined" ]
+labels_sgm_clusCounts = [ "234", "134", "124", "123", "All" ]
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CSCSegmValMonAlg.cxx b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CSCSegmValMonAlg.cxx
new file mode 100755
index 00000000000..d4461e6b887
--- /dev/null
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CSCSegmValMonAlg.cxx
@@ -0,0 +1,542 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+#include "AthenaMonitoring/AthenaMonManager.h"
+
+#include "CscRawDataMonitoring/CSCSegmValMonAlg.h"
+
+#include "MuonPrepRawData/CscClusterStatus.h"
+#include "MuonPrepRawData/CscStripPrepDataCollection.h"
+#include "MuonPrepRawData/CscStripPrepDataContainer.h"
+#include "MuonPrepRawData/CscPrepData.h"
+
+// Track
+#include "TrkTrack/TrackCollection.h"
+#include "TrkEventPrimitives/PropDirection.h"
+#include "TrkEventPrimitives/LocalDirection.h"
+#include "TrkSurfaces/PlaneSurface.h"
+
+#include "TrkCompetingRIOsOnTrack/CompetingRIOsOnTrack.h"
+#include "MuonRIO_OnTrack/CscClusterOnTrack.h"
+
+// STL
+#include <sstream>
+#include <utility>
+#include "GaudiKernel/SystemOfUnits.h"
+
+//________________________________________________________________________________________________________
+CSCSegmValMonAlg::CSCSegmValMonAlg( const std::string& name, ISvcLocator* pSvcLocator ) :
+ AthMonitorAlgorithm(name,pSvcLocator)
+ { }
+
+
+//________________________________________________________________________________________________________
+StatusCode CSCSegmValMonAlg::initialize() {
+
+ ATH_MSG_INFO( "in CSCSegmValMonAlg::init()" );
+ if( m_doEvtSel ) ATH_CHECK(m_trigDecTool.retrieve());
+
+ if(m_sampSelTriggers.empty() && m_doEvtSel) {
+ ATH_MSG_WARNING("Event selection triggers not specified. Switching off trigger-aware monitoring");
+ m_doEvtSel = false;
+ }
+
+ StoreGateSvc* detStore = nullptr;
+ ATH_CHECK(service("DetectorStore", detStore));
+ ATH_CHECK(m_edmHelperSvc.retrieve());
+ ATH_CHECK(m_idHelperSvc.retrieve());
+ ATH_CHECK(m_segmKey.initialize());
+
+ return AthMonitorAlgorithm::initialize();
+}
+
+//
+// fillHistograms-----------------------------------------------------------------------------------------
+//
+
+StatusCode CSCSegmValMonAlg::fillHistograms(const EventContext& ctx) const{
+
+ ATH_MSG_DEBUG( "in CSCSegmValMonAlg::fillHistograms() " );
+
+ if( m_environment == AthMonitorAlgorithm::Environment_t::tier0 || m_environment == AthMonitorAlgorithm::Environment_t::tier0ESD || m_environment == AthMonitorAlgorithm::Environment_t::user ) {
+
+ // if required, check if event passed sample-selection triggers
+ if(m_doEvtSel && !evtSelTriggersPassed()) return StatusCode::SUCCESS;
+
+ // Segment Cluster counter
+ int segmClustCount[33];
+
+ // arrays to hold cluster-count
+ // 32 chambers and 8 layers (each has one extra - index '0' is not counted)
+ int clusCount[33][9];
+ for(unsigned int kl = 0; kl < 33; kl++ ) {
+ for(unsigned int cm3 = 0; cm3 < 9; cm3++ ){
+ clusCount[kl][cm3] = 0;
+ }
+ }
+
+ SG::ReadHandle<Trk::SegmentCollection> segments(m_segmKey, ctx);
+
+ if ( segments->empty() ){
+ ATH_MSG_DEBUG( " Segm Collection is Empty, done... ");
+ return StatusCode::SUCCESS;
+ }
+
+ ATH_MSG_DEBUG( " Segm Collection size " );
+ ATH_MSG_DEBUG( "Number of segms found: " << segments->size() );
+
+ if(segments->size() > 0){
+ ATH_MSG_DEBUG( "Number of segms in event is: " << segments->size() );
+ ATH_MSG_DEBUG( "This algorithm is designed to operate for single segm / event only" );
+ ATH_MSG_DEBUG( "Processing only the first segm in the segm collection" );
+ }
+
+ int segnum = 0;
+ int layerindex = 0;
+
+ //Loop over segms
+ for (Trk::SegmentCollection::const_iterator s = segments->begin(); s != segments->end(); ++s) {
+
+ //Get segm
+ const Muon::MuonSegment *segm=dynamic_cast<const Muon::MuonSegment*>(*s);
+
+ if (!segm){
+ ATH_MSG_WARNING( "no pointer to segm!!!" );
+ continue;
+ }
+
+ ATH_MSG_DEBUG( "Looking at segment id" );
+ // Skip segment if there are no csc hits
+ if ( cscHits(segm)<1 ) continue;
+
+ // Get contained measurements
+ const std::vector<const Trk::MeasurementBase*> meas = segm->containedMeasurements();
+
+ // Skip segment if no measurements
+ // Number of clusters on segment
+ auto n_clust = Monitored::Scalar<int>("n_clust", meas.size());
+
+ if ( n_clust < 2 ) continue;
+
+ // Analyze segment if it is a csc segment
+ if ( isCscSegment(segm) ){
+
+ segnum++;
+
+ // Initialize cluster counter
+ for(int sect = 0; sect < 33; sect++) {
+ segmClustCount[sect] = 0;
+ for(unsigned int ilay = 0; ilay < 9; ilay++ ){
+ clusCount[sect][ilay] = 0;
+ }
+ }
+
+ // Print out segment information
+ const Trk::FitQuality* fq = segm->fitQuality();
+ double chi2 = 999.;
+ int ndof = -1;
+ if( fq ) {
+ chi2 = fq->chiSquared();
+ ndof = fq->numberDoF();
+ ATH_MSG_DEBUG( "Chi2 " << chi2 );
+ ATH_MSG_DEBUG( "Ndof " << ndof );
+ }
+
+ // cut on segment angle
+ float segm_ly = segm->localParameters()[Trk::locY];
+ float segm_ayz = segm->localDirection().angleYZ();
+ segm_ayz -= M_PI/2.;
+ float segm_cut = m_segmSlope;
+ bool segmAngle_cut = segmSlopeCut(segm_ly, segm_ayz, segm_cut);
+ ATH_MSG_DEBUG(" local_pos: " << segm_ly << "\tangle_yz: " << segm_ayz << "\tcut: " << segm_cut << "\t pass = " << segmAngle_cut );
+
+ ATH_MSG_DEBUG( "R " << segm->globalPosition().perp() );
+ ATH_MSG_DEBUG( "Z " << segm->globalPosition().z() );
+ ATH_MSG_DEBUG( "Phi " << segm->globalPosition().phi() );
+ ATH_MSG_DEBUG( "Eta " << segm->globalPosition().eta() );
+ ATH_MSG_DEBUG( "Dir Phi " << segm->globalDirection().phi() );
+ ATH_MSG_DEBUG( "Dir Eta " << segm->globalDirection().eta() );
+
+ // ==============================================================================
+ // Field Range Notes
+ // ==============================================================================
+ // StationName unsigned integer maps to "CSS", "CSL", etc.
+ // StationEta [-1,1] -1 for backward, 1 for forward endcap
+ // StationPhi [1,8] increases with Phi
+ // Technology [1] maps to "CSC"
+ // ChamberLayer [1,2] increases with |Z|
+ // WireLayer [1,4] increases with |Z|
+ // MeasuresPhi [0,1] 0 if measures R, 1 if measures Phi
+ // Strip [1,n] increases with R for MeasuresPhi=0
+ // increases with Phi for MeasuresPhi=1
+ // ==============================================================================
+
+ // identify the segment location
+ const Trk::MeasurementBase* rio = meas.at(0);
+ Identifier segmId = m_edmHelperSvc->getIdentifier(*rio);
+
+ int segm_stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(segmId);
+ int segm_stationEta = m_idHelperSvc->cscIdHelper().stationEta(segmId);
+ int segm_stationName = m_idHelperSvc->cscIdHelper().stationName(segmId);
+ std::string segm_stationString = m_idHelperSvc->cscIdHelper().stationNameString(segm_stationName);
+ int segm_chamberType = Muon::MuonStationIndex::CSS == segm_stationName ? 0 : 1;
+ auto segm_sectorNo = Monitored::Scalar<int>("segm_sectorNo", (segm_stationEta * (2 * segm_stationPhi - segm_chamberType)) ); // [-16 -> -1] and [+1 -> +16]
+ int segm_isec = segm_sectorNo < 0 ? segm_sectorNo*(-1) : segm_sectorNo+16; // [-16 -> -1] shifted to [1 -> 16] and [+1 -> +16] shifted to [+17 -> +32]
+ ATH_MSG_DEBUG(" sgsec = " << segm_isec << "\tsec = " << segm_sectorNo);
+ auto sideA = Monitored::Scalar<int>("sideA", (int) (segm_stationEta==1));
+ auto sideC = Monitored::Scalar<int>("sideC",(int)(segm_stationEta==-1));
+ fill("CscSegmMonitor",n_clust,segm_sectorNo,sideA,sideC);
+
+ float clus_kiloele = 1.0e-3; // multiply # of electrons by this number to get kiloElectrons (1 ke = 1 ADC)
+ int eta_clus_count[2][2] = {{0, 0},{0, 0}}, phi_clus_count[2][2] = {{0, 0},{0, 0}}; // no. of prec/trans hits per segment
+ float eta_clus_qsum[2][5] = {{-1., -1.}, {-1., -1., -1., -1., -1.}}, phi_clus_qsum[2][5] = {{-1., -1.}, {-1., -1., -1., -1., -1.}}; // qsum over each prec/trans. layer on segment
+ float eta_clus_time[2][5] = {{-1., -1.}, {-1., -1., -1., -1., -1.}}, phi_clus_time[2][5] = {{-1., -1.}, {-1., -1., -1., -1., -1.}}; // time over each prec/trans. layer on segment
+ int eta_clus_use[2][5] = {{0, 0},{0,0,0,0,0}}, phi_clus_use[2][5] = {{0,0}, {0,0,0,0,0}};
+
+ layerindex = 0;
+
+ for( auto& hit : segm->containedMeasurements()) {
+ const Muon::CscClusterOnTrack* clust_rot = dynamic_cast<const Muon::CscClusterOnTrack*>(hit);
+ if ( clust_rot ) {
+ Identifier clusId = m_edmHelperSvc->getIdentifier(*clust_rot);
+
+ // get the cluster coordinates
+ int clus_stationName = m_idHelperSvc->cscIdHelper().stationName(clusId);
+ int clus_chamberType = Muon::MuonStationIndex::CSS == clus_stationName ? 0 : 1;
+ int clus_stationEta = m_idHelperSvc->cscIdHelper().stationEta(clusId);
+ int clus_stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(clusId);
+ int clus_wireLayer = m_idHelperSvc->cscIdHelper().wireLayer(clusId);
+ int clus_measuresPhi = m_idHelperSvc->cscIdHelper().measuresPhi(clusId);
+
+ // convert to my coordinates
+ int clus_sectorNo = clus_stationEta * (2 * clus_stationPhi - clus_chamberType); // [-16 -> -1] and [+1 -> +16]
+ auto clus_secLayer = Monitored::Scalar<float>("clus_secLayer", clus_sectorNo + 0.2 * (clus_wireLayer - 1) + 0.1);
+ int clus_isec = clus_sectorNo < 0 ? clus_sectorNo*(-1) : clus_sectorNo+16; // [-16 -> -1] shifted to [1 -> 16] and [+1 -> +16] shifted to [+17 -> +32]
+ int clus_ilay = (clus_measuresPhi ? clus_wireLayer : clus_wireLayer+4);
+
+ // check the cluster status; probably need to read status info from jobOptions - not done for the moment
+ Muon::CscClusterStatus status = clust_rot->status();
+ auto status_mon = Monitored::Scalar<int>("status_mon",(int)clust_rot->status());
+ auto sideA_phi0 = Monitored::Scalar<int>("sideA_phi0",(int) (segm_stationEta==1)&& (int)(clus_measuresPhi==0));
+ auto sideC_phi0 = Monitored::Scalar<int>("sideC_phi0",(int) (segm_stationEta==-1) && (int)(clus_measuresPhi == 0));
+ auto sideA_phi = Monitored::Scalar<int>("sideA_phi", (int) (segm_stationEta==1) && (int)(clus_measuresPhi!=0));
+ auto sideC_phi = Monitored::Scalar<int>("sideC_phi", (int) (segm_stationEta==-1) && (int)(clus_measuresPhi!=0));
+
+ fill("CscSegmMonitor",status_mon, sideA_phi0, sideC_phi0, sideA_phi, sideC_phi);
+
+ std::string clus_stat = Muon::toString(status);
+ bool clus_status = ( (int(status)==Muon::CscStatusUnspoiled) || (int(status)==Muon::CscStatusSplitUnspoiled) || (int(status)==Muon::CscStatusSimple)) ? true : false;
+ bool clus_stat_eff = ( (int(status) >= 0 && int(status) < 8 ) || (int(status) > 8 && int(status) < 18) ) ? true : false;
+
+ // get cluster
+ const Muon::CscPrepData* theClus = clust_rot->prepRawData();
+ float clus_qsum = 0, clus_time = -1.;
+
+ if(theClus){
+ clus_qsum = theClus->charge() * clus_kiloele;
+ clus_time = theClus->time();
+
+ if(clus_measuresPhi == 0){
+ if(clus_stationEta == 1) eta_clus_count[0][0]++;
+ else eta_clus_count[1][0]++;
+ } else{
+ if(clus_stationEta == 1) phi_clus_count[0][0]++;
+ else phi_clus_count[1][0]++;
+ }
+ }
+
+ auto clus_qsum_mon = Monitored::Scalar<float>("clus_qsum_mon",clus_qsum);
+ auto clus_time_mon = Monitored::Scalar<float>("clus_time_mon",clus_time);
+
+ // get no. of strips per cluster
+ unsigned int clus_noStrips = theClus->rdoList().size();
+
+ //need at least three strips in an eta-cluster
+ bool clus_eta_status = clus_status && ( clus_noStrips > 2 ) && (clus_measuresPhi == 0);
+ bool clus_eta_eff = clus_stat_eff && ( clus_noStrips > 2 ) && (clus_measuresPhi == 0);
+ if(clus_eta_eff){
+ if(clus_stationEta == 1) eta_clus_count[0][1]++;
+ else phi_clus_count[1][1]++;
+ }
+ if(clus_eta_status){
+ if(clus_stationEta == 1){
+ eta_clus_qsum[0][clus_wireLayer] = clus_qsum;
+ eta_clus_time[0][clus_wireLayer] = clus_time;
+ eta_clus_use[0][clus_wireLayer] = 1;
+ }
+ else{
+ eta_clus_qsum[1][clus_wireLayer] = clus_qsum;
+ eta_clus_time[1][clus_wireLayer] = clus_time;
+ eta_clus_use[1][clus_wireLayer] = 1;
+ }
+ }
+
+ // need at least one strip in a phi-cluster
+ bool clus_phi_status = clus_status && ( clus_noStrips > 0 ) && (clus_measuresPhi == 1);
+ if(clus_phi_status) {
+ if(clus_stationEta==1){
+ phi_clus_qsum[0][clus_wireLayer] = clus_qsum;
+ phi_clus_time[0][clus_wireLayer] = clus_time;
+ phi_clus_use[0][clus_wireLayer] = 1;
+ phi_clus_count[0][1]++;
+ } else {
+ phi_clus_qsum[1][clus_wireLayer] = clus_qsum;
+ phi_clus_time[1][clus_wireLayer] = clus_time;
+ phi_clus_use[1][clus_wireLayer] = 1;
+ phi_clus_count[1][1]++;
+ }
+ }
+
+
+ auto checkStatusEtaA = Monitored::Scalar<int>("checkStatusEtaA", (int)clus_eta_status && (int)(clus_stationEta==1));
+ auto checkStatusEtaC = Monitored::Scalar<int>("checkStatusEtaC", (int)clus_eta_status && (int)(clus_stationEta==-1));
+ auto checkTimeEtaA = Monitored::Scalar<int>("checkTimeEtaA", (int)clus_eta_status && (int)(clus_stationEta==1) && (int) (std::abs(clus_time) <= 200));
+ auto checkTimeEtaC = Monitored::Scalar<int>("checkTimeEtaC", (int)clus_eta_status && (int)(clus_stationEta==-1) && (int) (std::abs(clus_time) <= 200));
+
+ auto checkStatusPhiA = Monitored::Scalar<int>("checkStatusPhiA", (int)clus_phi_status && (int)(clus_stationEta==1));
+ auto checkStatusPhiC = Monitored::Scalar<int>("checkStatusPhiC", (int)clus_phi_status && (int)(clus_stationEta==-1));
+ auto checkTimePhiA = Monitored::Scalar<int>("checkTimePhiA", (int)clus_phi_status && (int)(clus_stationEta==1) && (int) (std::abs(clus_time) <= 200));
+ auto checkTimePhiC = Monitored::Scalar<int>("checkTimePhiC", (int)clus_phi_status && (int)(clus_stationEta==-1) && (int) (std::abs(clus_time) <= 200));
+ fill("CscSegmMonitor", clus_qsum_mon, clus_secLayer, clus_time_mon, checkStatusEtaA, checkStatusEtaC, checkTimeEtaA, checkTimeEtaC, checkStatusPhiA, checkStatusPhiC, checkTimePhiA, checkTimePhiC );
+
+ // increment the cluster-count for this layer
+ if(clus_eta_status || clus_phi_status) clusCount[clus_isec][clus_ilay]++;
+
+ // increment segment cluster count
+ if(clus_eta_status) segmClustCount[clus_isec]++;
+
+ if(clus_eta_status) layerindex+=clus_wireLayer;
+
+ ATH_MSG_DEBUG("status = " << clus_stat << "\tcharge = " << clus_qsum << "\ttime= " << clus_time << "\tnstrips = " << clus_noStrips);
+
+
+ } // if clust_rot
+
+ } // for loop over clusters
+
+ auto tmp_etaClusA = Monitored::Scalar<int>("tmp_etaClusA", eta_clus_count[0][0]);
+ auto tmp_etaClusGoodA = Monitored::Scalar<int>("tmp_etaClusGoodA", eta_clus_count[0][1]);
+
+ auto tmp_phiClusA = Monitored::Scalar<int>("tmp_phiClusA", phi_clus_count[0][0]);
+ auto tmp_phiClusGoodA = Monitored::Scalar<int>("tmp_phiClusGoodA", phi_clus_count[0][1]);
+
+ auto checkClusEtaA = Monitored::Scalar<int>("checkClusEtaA", (int)eta_clus_count[0][0] > 0);
+ auto checkClusEtaGoodA = Monitored::Scalar<int>("checkClusEtaGoodA", (int)eta_clus_count[0][1] > 0);
+
+ auto checkClusPhiA = Monitored::Scalar<int>("checkClusPhiA", (int)phi_clus_count[0][0] > 0);
+ auto checkClusPhiGoodA = Monitored::Scalar<int>("checkClusPhiGoodA", (int)phi_clus_count[0][1] > 0);
+
+ auto tmp_etaClusC = Monitored::Scalar<int>("tmp_etaClusC", eta_clus_count[1][0]);
+ auto tmp_etaClusGoodC = Monitored::Scalar<int>("tmp_etaClusGoodC", eta_clus_count[1][1]);
+
+ auto tmp_phiClusC = Monitored::Scalar<int>("tmp_phiClusC", phi_clus_count[1][0]);
+ auto tmp_phiClusGoodC = Monitored::Scalar<int>("tmp_phiClusGoodC", phi_clus_count[1][1]);
+
+ auto checkClusEtaC = Monitored::Scalar<int>("checkClusEtaC", (int)eta_clus_count[1][0] > 0);
+ auto checkClusEtaGoodC = Monitored::Scalar<int>("checkClusEtaGoodC", (int)eta_clus_count[1][1] > 0);
+
+ auto checkClusPhiC = Monitored::Scalar<int>("checkClusPhiC", (int)phi_clus_count[1][0] > 0);
+ auto checkClusPhiGoodC = Monitored::Scalar<int>("checkClusPhiGoodC", (int)phi_clus_count[1][1] > 0);
+
+ fill("CscSegmMonitor", tmp_etaClusA, checkClusEtaA, tmp_etaClusGoodA, checkClusEtaGoodA, tmp_phiClusA, tmp_phiClusGoodA, checkClusPhiA, checkClusPhiGoodA, tmp_etaClusC, checkClusEtaC, tmp_etaClusGoodC, checkClusEtaGoodC, tmp_phiClusC, tmp_phiClusGoodC, checkClusPhiC, checkClusPhiGoodC);
+
+ // Fill number of 3 and 4 cluster segment histogram
+ std::vector<int> tmp_layerIndexA;
+ std::vector<int> tmp_isectA;
+ std::vector<int> tmp_layerIndexC;
+ std::vector<int> tmp_isectC;
+
+ for( int isect = 1; isect < 17; isect++) {
+
+ if(segmClustCount[isect+16] > 2 ) {
+ tmp_layerIndexA.push_back(layerindex-5);
+ tmp_isectA.push_back(isect);
+ }
+
+ if(segmClustCount[isect+16] > 3){
+ for(int i=1; i<=4; i++) {
+ tmp_layerIndexA.push_back(i);
+ tmp_isectA.push_back(isect);
+ }
+ }
+
+ if(segmClustCount[isect] > 2) {
+ tmp_layerIndexC.push_back(layerindex-5);
+ tmp_isectC.push_back(-1.*isect);
+ }
+
+
+ if(segmClustCount[isect] > 3) {
+ for(int i=1; i<=4; i++) {
+ tmp_layerIndexC.push_back(i);
+ tmp_isectC.push_back(-1.*isect);
+ }
+ }
+ }
+
+ auto tmp_layerIndexA_mon = Monitored::Collection("tmp_layerIndexA_mon", tmp_layerIndexA);
+ auto tmp_isectA_mon = Monitored::Collection("tmp_isectA_mon", tmp_isectA);
+ auto tmp_layerIndexC_mon = Monitored::Collection("tmp_layerIndexC_mon", tmp_layerIndexA);
+ auto tmp_isectC_mon = Monitored::Collection("tmp_isectC_mon", tmp_isectA);
+ fill("CscSegmMonitor", tmp_layerIndexA_mon, tmp_isectA_mon, tmp_layerIndexC_mon, tmp_isectC_mon);
+
+ float eta_clus_qsum_tot = 0., phi_clus_qsum_tot = 0.; // total qsum over all prec. trans. layers on segment
+
+ for(unsigned int i=0; i < 2; i++){
+ eta_clus_qsum_tot = 0; phi_clus_qsum_tot = 0.;
+
+ for(unsigned int j = 1; j <5; j++) {
+ if(i==0){
+ auto etaClusQSumA = Monitored::Scalar<float>("etaClusQSumA", eta_clus_qsum[i][j]);
+ auto phiClusQSumA = Monitored::Scalar<float>("phiClusQSumA", phi_clus_qsum[i][j]);
+ fill("CscSegmMonitor", etaClusQSumA, phiClusQSumA);
+
+ if(std::abs(eta_clus_time[i][j]) <= 200) {
+ auto etaTimeClusA = Monitored::Scalar<float>("etaTimeClusA",eta_clus_time[i][j]);
+ fill("CscSegmMonitor", etaTimeClusA);
+ }
+
+ if(std::abs(phi_clus_time[i][j]) <= 200) {
+ auto phiTimeClusA = Monitored::Scalar<float>("phiTimeClusA",phi_clus_time[i][j]);
+ fill("CscSegmMonitor", phiTimeClusA);
+ }
+ }
+
+ if(i==1){
+ auto etaClusQSumC = Monitored::Scalar<float>("etaClusQSumC", eta_clus_qsum[i][j]);
+ auto phiClusQSumC = Monitored::Scalar<float>("phiClusQSumC", phi_clus_qsum[i][j]);
+ fill("CscSegmMonitor", etaClusQSumC, phiClusQSumC);
+
+ if(std::abs(eta_clus_time[i][j]) <= 200) {
+ auto etaTimeClusC = Monitored::Scalar<float>("etaTimeClusC",eta_clus_time[i][j]);
+ fill("CscSegmMonitor", etaTimeClusC);
+ }
+
+ if(std::abs(phi_clus_time[i][j]) <= 200) {
+ auto phiTimeClusC = Monitored::Scalar<float>("phiTimeClusC",phi_clus_time[i][j]);
+ fill("CscSegmMonitor", phiTimeClusC);
+ }
+ }
+
+
+ if(phi_clus_use[i][j] && eta_clus_use[i][j]){
+ eta_clus_qsum_tot += eta_clus_qsum[i][j];
+ phi_clus_qsum_tot += phi_clus_qsum[i][j];
+
+ if(i==0){
+ auto etaQSumGoodClusA = Monitored::Scalar<float>("etaQSumGoodClusA",eta_clus_qsum[i][j]);
+ auto phiQSumGoodClusA = Monitored::Scalar<float>("phiQSumGoodClusA",phi_clus_qsum[i][j]);
+ fill("CscSegmMonitor", etaQSumGoodClusA, phiQSumGoodClusA);
+ if(std::abs(eta_clus_time[i][j]) <= 200){
+ auto etaTimeGoodClusA = Monitored::Scalar<float>("etaTimeGoodClusA",eta_clus_time[i][j]);
+ fill("CscSegmMonitor", etaTimeGoodClusA);
+ }
+
+ if(std::abs(phi_clus_time[i][j]) <= 200) {
+ auto phiTimeGoodClusA = Monitored::Scalar<float>("phiTimeGoodClusA",phi_clus_time[i][j]);
+ fill("CscSegmMonitor", phiTimeGoodClusA);
+ }
+ }
+
+ if(i==1){
+ auto etaQSumGoodClusC = Monitored::Scalar<float>("etaQSumGoodClusC",eta_clus_qsum[i][j]);
+ auto phiQSumGoodClusC = Monitored::Scalar<float>("phiQSumGoodClusC",phi_clus_qsum[i][j]);
+ fill("CscSegmMonitor", etaQSumGoodClusC, phiQSumGoodClusC);
+ if(std::abs(eta_clus_time[i][j]) <= 200){
+ auto etaTimeGoodClusC = Monitored::Scalar<float>("etaTimeGoodClusC",eta_clus_time[i][j]);
+ fill("CscSegmMonitor", etaTimeGoodClusC);
+ }
+
+ if(std::abs(phi_clus_time[i][j]) <= 200) {
+ auto phiTimeGoodClusC = Monitored::Scalar<float>("phiTimeGoodClusC",phi_clus_time[i][j]);
+ fill("CscSegmMonitor", phiTimeGoodClusC);
+ }
+ }
+ }
+ }
+
+ if(i==0) {
+ auto etaQSumTot0 = Monitored::Scalar<float>("etaQSumTot0", eta_clus_qsum_tot);
+ auto phiQSumTot0 = Monitored::Scalar<float>("phiQSumTot0", phi_clus_qsum_tot);
+ fill("CscSegmMonitor", etaQSumTot0, phiQSumTot0);
+ }
+
+ if(i==1) {
+ auto etaQSumTot = Monitored::Scalar<float>("etaQSumTot", eta_clus_qsum_tot);
+ auto phiQSumTot = Monitored::Scalar<float>("phiQSumTot", phi_clus_qsum_tot);
+ fill("CscSegmMonitor", etaQSumTot, phiQSumTot);
+ }
+ }
+ } // if is csc segment
+ } // loop over segms
+ } // environment if
+
+ return StatusCode::SUCCESS;
+}
+
+//________________________________________________________________________________________________________
+bool CSCSegmValMonAlg::evtSelTriggersPassed() const {
+
+ if(!m_doEvtSel) return true;
+
+ for (const auto& trig : m_sampSelTriggers) {
+ if(m_trigDecTool->isPassed(trig, TrigDefs::eventAccepted)) {
+ return true;
+ }
+ }
+ return false;
+
+} // end evtSelTriggersPassed
+
+//________________________________________________________________________________________________________
+bool CSCSegmValMonAlg::isCscSegment( const Muon::MuonSegment* seg ) const {
+ bool isCsc(false);
+
+ std::vector<const Trk::MeasurementBase*> mbs = seg->containedMeasurements();
+ for( unsigned int i = 0; i< mbs.size(); ++i){
+
+ const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*> (mbs[i]);
+ if (!rot){
+ const Trk::CompetingRIOsOnTrack* crot = dynamic_cast<const Trk::CompetingRIOsOnTrack*> (mbs[i]);
+ if (crot) rot = &(crot->rioOnTrack(0));
+ }
+ if( !rot ) {
+ continue;
+ }
+ if( m_idHelperSvc->isCsc( rot->identify() ) ) isCsc=true;
+ }
+
+ return isCsc;
+}
+
+
+//________________________________________________________________________________________________________
+unsigned int CSCSegmValMonAlg::cscHits( const Muon::MuonSegment* seg ) const {
+ unsigned int nrHits(0);
+
+ std::vector<const Trk::MeasurementBase*> mbs = seg->containedMeasurements();
+ for( unsigned int i = 0; i< mbs.size(); ++i){
+
+ const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*> (mbs[i]);
+ if (!rot){
+ const Trk::CompetingRIOsOnTrack* crot = dynamic_cast<const Trk::CompetingRIOsOnTrack*> (mbs[i]);
+ if (crot) rot = &(crot->rioOnTrack(0));
+ }
+ if( !rot ) {
+ continue;
+ }
+ if( m_idHelperSvc->isCsc( rot->identify() ) ) ++nrHits;
+ }
+
+ return nrHits ;
+}
+
+//________________________________________________________________________________________________________
+bool CSCSegmValMonAlg::segmSlopeCut(const float csc_x, const float csc_ax, const float cut ) const {
+ float s0 = csc_x;
+ float s1 = -std::tan(csc_ax);
+ float s1corr = s1 - 0.000119 * s0;
+ bool good_segm = std::abs(s1corr)<cut ? true : false;
+ return good_segm;
+}
+
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CscClusterValMonAlg.cxx b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CscClusterValMonAlg.cxx
index 3b426847449..77279b9049e 100644
--- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CscClusterValMonAlg.cxx
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CscClusterValMonAlg.cxx
@@ -2,16 +2,6 @@
Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
-/* NAME : CscClusterValMonAlg.cxx
- * PACKAGE : MuonRawDataMonitoring/CscRawDataMonitoring
- * PURPOSE : CSC cluster monitoring
- * AUTHOR : Venkatesh Kaushik <venkat.kaushik@cern.ch> (2009-04-27)
- *
- * MODIFIED: C.Paraskevopoulos, C.Kitsaki
- */
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
-
#include "AthenaMonitoring/AthenaMonManager.h"
// Athena include(s)
@@ -27,13 +17,7 @@ using namespace Muon;
CscClusterValMonAlg::CscClusterValMonAlg( const std::string& name, ISvcLocator* pSvcLocator ) :
AthMonitorAlgorithm(name,pSvcLocator)
- {
- declareProperty("CSCQmaxCutADC", m_qmaxADCCut = 100);
-
- //trigger aware monitoring
- declareProperty("CSCDoEventSelection", m_doEvtSel = false );
- declareProperty("CSCEventSelTriggers", m_sampSelTriggers );
- }
+ { }
StatusCode CscClusterValMonAlg::initialize() {
@@ -63,18 +47,7 @@ StatusCode CscClusterValMonAlg::fillHistograms( const EventContext& ctx ) const
StatusCode sc = StatusCode::SUCCESS;
// check if event passed sample-selection triggers
- //if(m_doEvtSel) { if(!evtSelTriggersPassed()) return sc; }
-
- bool check = false;
-
- if(!m_doEvtSel) check = true;
- std::vector<std::string>::const_iterator
- it = m_sampSelTriggers.begin(), itE = m_sampSelTriggers.end();
- for ( ; it != itE; it++ ) {
- if (m_trigDecTool->isPassed(*it, TrigDefs::eventAccepted)) check = true;
- }
-
- if(m_doEvtSel) { if(!check) return sc; }
+ if(m_doEvtSel) { if(!evtSelTriggersPassed()) return sc; }
// retrieve cluster / strip collection
SG::ReadHandle<CscPrepDataContainer> cscCluster(m_cscClusterKey, ctx);
@@ -453,3 +426,20 @@ StatusCode CscClusterValMonAlg::fillHistograms( const EventContext& ctx ) const
return sc;
}
+
+//
+// evtSelTriggersPassed ----------------------------------------------------------------
+//
+bool CscClusterValMonAlg::evtSelTriggersPassed() const {
+
+ if(!m_doEvtSel) return true;
+
+ for(const auto& trig : m_sampSelTriggers) {
+ if(m_trigDecTool->isPassed(trig,TrigDefs::eventAccepted)){
+ return true;
+ }
+ }
+ return false;
+
+} // end evtSelTriggersPassed
+
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CscPrdValMonAlg.cxx b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CscPrdValMonAlg.cxx
index 30e457638e6..923d7dbf842 100755
--- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CscPrdValMonAlg.cxx
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/CscPrdValMonAlg.cxx
@@ -2,20 +2,6 @@
Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
-/* NAME : CscPrdValMonAlg.cxx
- * PACKAGE : MuonRawDataMonitoring/CscRawDataMonitoring
- * PURPOSE : CSC PrepRawData (PRD) monitoring
- * AUTHOR : Ken Johns, Xiaowen Lei (U.Arizona)
- *
- * MODIFIED: N. Benekos(Illinois)
- * V. Kaushik(U.Arizona) : 2009-05-12
- * J. Veatch(U.Arizona) : 2012-02-08
-
- * MODIFIED: C.Kitsaki, C.Paraskevopoulos
- */
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
-
#include "AthenaMonitoring/AthenaMonManager.h"
// Athena include(s)
@@ -26,13 +12,9 @@
using namespace Muon;
CscPrdValMonAlg::CscPrdValMonAlg( const std::string& name, ISvcLocator* pSvcLocator ) :
- AthMonitorAlgorithm(name,pSvcLocator)
- {
- declareProperty("NoiseCutADC", m_cscNoiseCut = 50);
- declareProperty("MapYXandRZ", m_mapxyrz = false);
- }
-
-
+ AthMonitorAlgorithm(name,pSvcLocator)
+ { }
+
StatusCode CscPrdValMonAlg::initialize() {
ATH_MSG_INFO( "CscPrdValMonAlg: in initialize" );
ATH_CHECK(m_idHelperSvc.retrieve());
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/components/CscRawDataMonitoring_entries.cxx b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/components/CscRawDataMonitoring_entries.cxx
index 366e04e5294..4b633badcd7 100644
--- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/components/CscRawDataMonitoring_entries.cxx
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/CscRawDataMonitoring/src/components/CscRawDataMonitoring_entries.cxx
@@ -4,6 +4,7 @@
#include "CscRawDataMonitoring/CSCSegmValAlg.h"
#include "CscRawDataMonitoring/CscClusterValMonAlg.h"
#include "CscRawDataMonitoring/CscPrdValMonAlg.h"
+#include "CscRawDataMonitoring/CSCSegmValMonAlg.h"
DECLARE_COMPONENT( CscRdoValAlg )
@@ -12,4 +13,4 @@ DECLARE_COMPONENT( CscClusterValAlg )
DECLARE_COMPONENT( CSCSegmValAlg )
DECLARE_COMPONENT( CscClusterValMonAlg )
DECLARE_COMPONENT( CscPrdValMonAlg )
-
+DECLARE_COMPONENT( CSCSegmValMonAlg )
--
GitLab