ATLAS Offline Software
CSCSegmValAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 /* **********************************************************************
6  * Program : CSCSegmValAlg
7  * Package : MuonSegmMonitoring
8  * Authors : Venkat Kaushik <Venkat.Kaushik@CERN.CH> Jason Veatch <jason.veatch@cern.ch>
9  * Purpose : CSC segment monitoring source code
10  *----------------------------------------------------------------------
11  */
12 
13 #include "CSCSegmValAlg.h"
14 
15 #include "MuonPrepRawData/CscClusterStatus.h"
16 #include "MuonPrepRawData/CscStripPrepDataCollection.h"
17 #include "MuonPrepRawData/CscStripPrepDataContainer.h"
18 #include "MuonPrepRawData/CscPrepData.h"
19 
20 // Track
21 #include "TrkTrack/TrackCollection.h"
22 #include "TrkEventPrimitives/PropDirection.h"
23 #include "TrkEventPrimitives/LocalDirection.h"
24 #include "TrkSurfaces/PlaneSurface.h"
25 
26 
27 #include "TrkCompetingRIOsOnTrack/CompetingRIOsOnTrack.h"
28 #include "MuonRIO_OnTrack/CscClusterOnTrack.h"
29 
30 // ROOT
31 #include "TH1F.h"
32 #include "TH2F.h"
33 
34 // STL
35 #include <sstream>
36 #include <utility>
37 using CLHEP::cm3;
38 
39 //________________________________________________________________________________________________________
40 CSCSegmValAlg::CSCSegmValAlg( const std::string & type, const std::string & name, const IInterface* parent )
41  : ManagedMonitorToolBase( type, name, parent ),
42  m_trigDec( "" ),
43  m_debuglevel(false),
44  m_bookedhistos(false) {
45 
46  declareProperty( "SegmentSlopeCut", m_segmSlope);
47  declareProperty( "ClusterStatus", m_clusStatWord);
48 
49  //trigger aware monitoring
50  declareProperty("DoEventSelection", m_doEvtSel = false );
51  declareProperty("EventSelTriggers", m_sampSelTriggers );
52 
53  ATH_MSG_INFO( " in CSCSegmValAlg::CSCSegmValAlg() " );
54 }
55 
56 //________________________________________________________________________________________________________
57 StatusCode CSCSegmValAlg::initialize() {
58 
59  m_bookedhistos=false;
60 
61  ATH_CHECK(ManagedMonitorToolBase::initialize());
62 
63  ATH_MSG_INFO( "in CSCSegmValAlg::init()" );
64  if( m_doEvtSel ) {
65  if (m_trigDec.retrieve().isFailure()) {
66  ATH_MSG_WARNING ( "CSCSegmValAlg: Unable to retrieve trigger decision tool");
67  m_doEvtSel = false;
68  } else {
69  ATH_MSG_INFO ( "TrigDecisionTool : " << "Using TDT \"" << m_trigDec->name() << "\"" );
70  }
71  }
72 
73  if(m_sampSelTriggers.empty() && m_doEvtSel) {
74  ATH_MSG_WARNING("Event selection triggers not specified. Switching off trigger-aware monitoring");
75  m_doEvtSel = false;
76  }
77 
78 
79  // load defaults if items are empty or inconsistent
80  if(m_clusStatWord.empty()) {
81  m_clusStatWord.push_back("Unspoiled"); m_clusStatWord.push_back("Simple");
82  m_clusStatWord.push_back("Edge"); m_clusStatWord.push_back("MultiPeak");
83  m_clusStatWord.push_back("Narrow"); m_clusStatWord.push_back("Wide");
84  m_clusStatWord.push_back("Skewed"); m_clusStatWord.push_back("QRatInc");
85  m_clusStatWord.push_back("StripFitFailed"); m_clusStatWord.push_back("SplitUnspoiled");
86  m_clusStatWord.push_back("SplitSimple"); m_clusStatWord.push_back("SplitEdge");
87  m_clusStatWord.push_back("SplitMultiPeak"); m_clusStatWord.push_back("SplitNarrow");
88  m_clusStatWord.push_back("SplitWide"); m_clusStatWord.push_back("SplitSkewed");
89  m_clusStatWord.push_back("SplitQRatInc"); m_clusStatWord.push_back("SplitStripFitFailed");
90  }
91 
92  m_NClusWord.clear();
93  m_NClusWord.push_back("234");
94  m_NClusWord.push_back("134");
95  m_NClusWord.push_back("124");
96  m_NClusWord.push_back("123");
97  m_NClusWord.push_back("All");
98 
99  StoreGateSvc* detStore = nullptr;
100  ATH_CHECK(service("DetectorStore", detStore));
101  ATH_CHECK(m_edmHelperSvc.retrieve());
102  ATH_CHECK(m_idHelperSvc.retrieve());
103  ATH_CHECK(m_segmKey.initialize());
104  return StatusCode::SUCCESS;
105 }
106 
107 
108 //________________________________________________________________________________________________________
109 void CSCSegmValAlg::bookSegmentHistograms() {
110 
111 
112  // Book histograms
113 
114  int nybinsEA = 90; // 16 chambers (x 5 layers per chamber) + 1 set extra
115  float nyminEA = 0.; //
116  float nymaxEA = 18.; //
117 
118  int nybinsEC = 85; // 16 chambers (x 5 layers per chamber) + 1 set extra
119  float nyminEC = -17.; //
120  float nymaxEC = 0.; //
121 
122 
123  int nsegbins = 20;
124  float nsegmin = 0;
125  float nsegmax = 80;
126 
127  int nclustbins = 50;
128  float nclustmin = .5;
129  float nclustmax = 5.5;
130 
131  // (1ke = 1ADC = 1 count) 80, 0, 4000.
132  int nqbins = 80;
133  float nqmin = 0.;
134  float nqmax = 4000.;
135 
136  int ntbins = 40;
137  float ntmin = -200.;
138  float ntmax = 200.;
139 
140 
141  int nsbins = 11;
142  float nsmin = -0.5;
143  float nsmax = 10.5;
144 
145  std::string segm_detailA = "Muon/MuonSegmentMonitoring/EndCapA/Detail/";
146  std::string segm_detailC = "Muon/MuonSegmentMonitoring/EndCapC/Detail/";
147  std::string segm_oviewA = "Muon/MuonSegmentMonitoring/EndCapA/Overview/";
148  std::string segm_oviewC = "Muon/MuonSegmentMonitoring/EndCapC/Overview/";
149 
150  std::string theKey = m_segmKey.key();
151 
152  if (m_debuglevel) ATH_MSG_DEBUG("Finished booking histos for " << theKey );
153 
154  float binmin = -0.5;
155  int nbins = m_clusStatWord.size();
156  float binmax = float(nbins) + binmin;
157 
158  MgmtAttr_t attr = ATTRIB_MANAGED;
159  m_segmDetail_EA=std::unique_ptr<MonGroup>(new MonGroup(this, segm_detailA+theKey+"/CSC", run, attr ));
160  m_segmDetail_EC=std::unique_ptr<MonGroup>(new MonGroup(this, segm_detailC+theKey+"/CSC", run, attr ));
161  m_segmOview_EA=std::unique_ptr<MonGroup>(new MonGroup(this, segm_oviewA+theKey+"/CSC", run, attr ));
162  m_segmOview_EC=std::unique_ptr<MonGroup>(new MonGroup(this, segm_oviewC+theKey+"/CSC", run, attr ));
163 
164  // segment hists
165  m_h2CSC_Segm_NumOfSegs_EA= new TH2F("Muon_Segm_NumSegments_EA",
166  Form("EndCap A: No. of segments; #segments;[sector] + [0.2 #times layer]"),
167  nsegbins,nsegmin,nsegmax,nybinsEA,nyminEA,nymaxEA);
168  m_h2CSC_Segm_NumOfSegs_EC= new TH2F("Muon_Segm_NumSegments_EC",
169  Form("EndCap C: No. of segments; #segments;[sector] + [0.2 #times layer]"),
170  nsegbins,nsegmin,nsegmax,nybinsEC,nyminEC,nymaxEC);
171  regCSCHist(m_h2CSC_Segm_NumOfSegs_EA, m_segmOview_EA.get());
172  regCSCHist(m_h2CSC_Segm_NumOfSegs_EC, m_segmOview_EC.get());
173 
174  // precision clusters on segment
175 
176  m_h2CSC_Segm_NumOfNClusSegs_Eta_EA=new TH2F("Muon_Segm_NumNClusSegments_EA",
177  Form("EndCap A: #eta-number of 3 and 4 cluster segments with each layer;counts;[sector] + [0.2 #times layer]"),
178  nclustbins,nclustmin,nclustmax,nybinsEA,nyminEA,nymaxEA);
179  setCSCLayerLabels(m_h2CSC_Segm_NumOfNClusSegs_Eta_EA, 1);
180  m_h2CSC_Segm_NumOfNClusSegs_Eta_EC=new TH2F("Muon_Segm_NumNClusSegments_EC",
181  Form("EndCap C: #eta-number of 3 and 4 cluster segments with each layer;counts;[sector] + [0.2 #times layer]"),
182  nclustbins,nclustmin,nclustmax,nybinsEC,nyminEC,nymaxEC);
183  setCSCLayerLabels(m_h2CSC_Segm_NumOfNClusSegs_Eta_EC, -1);
184  regCSCHist(m_h2CSC_Segm_NumOfNClusSegs_Eta_EA, m_segmDetail_EA.get());
185  regCSCHist(m_h2CSC_Segm_NumOfNClusSegs_Eta_EC, m_segmDetail_EC.get());
186 
187  for (size_t j = 0; j < m_NClusWord.size(); j++) {
188  m_h2CSC_Segm_NumOfNClusSegs_Eta_EA->GetXaxis()->SetBinLabel(j*10+5, m_NClusWord[j].c_str());
189  m_h2CSC_Segm_NumOfNClusSegs_Eta_EC->GetXaxis()->SetBinLabel(j*10+5, m_NClusWord[j].c_str());
190  }
191 
192  m_h1CSC_Segm_Efficiency_Eta_EA=new TH1F("Muon_Segm_Efficiency_EA",
193  Form("EndCap A: #eta-segment efficiency per sector;[sector] + [0.2 #times layer];efficiency"),
194  nybinsEA,nyminEA,nymaxEA);
195  setCSCLayerLabels(m_h1CSC_Segm_Efficiency_Eta_EA, 1);
196  m_h1CSC_Segm_Efficiency_Eta_EC=new TH1F("Muon_Segm_Efficiency_EC",
197  Form("EndCap C: #eta-segment efficiency per sector;[sector] + [0.2 #times layer];efficiency"),
198  nybinsEC,nyminEC,nymaxEC);
199  setCSCLayerLabels(m_h1CSC_Segm_Efficiency_Eta_EC, -1);
200 
201  regCSCHist(m_h1CSC_Segm_Efficiency_Eta_EA, m_segmOview_EA.get());
202  regCSCHist(m_h1CSC_Segm_Efficiency_Eta_EC, m_segmOview_EC.get());
203 
204  m_h2CSC_Segm_QsumOfGoodClusMap_Eta_EA=new TH2F("Muon_Segm_QSumEtaGoodClusPerLayer_EA",
205  Form("EndCap A: #eta-cluster charge per layer;counts;[sector] + [0.2 #times layer]"),
206  nqbins,nqmin,nqmax,nybinsEA,nyminEA,nymaxEA);
207 
208  m_h2CSC_Segm_QsumOfGoodClusMap_Eta_EC=new TH2F("Muon_Segm_QSumEtaGoodClusPerLayer_EC",
209  Form("EndCap C: #eta-cluster charge per layer;counts;[sector] + [0.2 #times layer]"),
210  nqbins,nqmin,nqmax,nybinsEC,nyminEC,nymaxEC);
211 
212  regCSCHist(m_h2CSC_Segm_QsumOfGoodClusMap_Eta_EA, m_segmOview_EA.get());
213  regCSCHist(m_h2CSC_Segm_QsumOfGoodClusMap_Eta_EC, m_segmOview_EC.get());
214 
215  m_h2CSC_Segm_TimeOfGoodClusMap_Eta_EA=new TH2F("Muon_Segm_TimeEtaGoodClusPerLayer_EA",
216  Form("EndCap A: #eta-cluster time per layer;time [ns];[sector] + [0.2 #times layer]"),
217  ntbins,ntmin,ntmax,nybinsEA,nyminEA,nymaxEA);
218 
219  m_h2CSC_Segm_TimeOfGoodClusMap_Eta_EC=new TH2F("Muon_Segm_TimeEtaGoodClusPerLayer_EC",
220  Form("EndCap C: #eta-cluster time per layer;time [ns];[sector] + [0.2 #times layer]"),
221  ntbins,ntmin,ntmax,nybinsEC,nyminEC,nymaxEC);
222 
223  regCSCHist(m_h2CSC_Segm_TimeOfGoodClusMap_Eta_EA, m_segmOview_EA.get());
224  regCSCHist(m_h2CSC_Segm_TimeOfGoodClusMap_Eta_EC, m_segmOview_EC.get());
225 
226 
227  m_h1CSC_Segm_StatOfClus_Eta_EA= new TH1F("Muon_Segm_EtaClusterStatus_EA",
228  "Endcap A: #eta-cluster status;;entries",nbins,binmin,binmax);
229 
230  m_h1CSC_Segm_StatOfClus_Eta_EC= new TH1F("Muon_Segm_EtaClusterStatus_EC",
231  "Endcap C: #eta-cluster status;;entries",nbins,binmin,binmax);
232  for (size_t j = 0; j < m_clusStatWord.size(); j++) {
233  m_h1CSC_Segm_StatOfClus_Eta_EA->GetXaxis()->SetBinLabel(j+1, m_clusStatWord[j].c_str());
234  m_h1CSC_Segm_StatOfClus_Eta_EC->GetXaxis()->SetBinLabel(j+1, m_clusStatWord[j].c_str());
235  }
236  regCSCHist(m_h1CSC_Segm_StatOfClus_Eta_EA, m_segmDetail_EA.get());
237  regCSCHist(m_h1CSC_Segm_StatOfClus_Eta_EC, m_segmDetail_EC.get());
238 
239  m_h1CSC_Segm_NumOfClus_Eta_EA= new TH1F("Muon_Segm_NumEtaCluster_EA",
240  "Endcap A: No. of #eta-clusters on segment;#clusters;entries", nsbins,nsmin,nsmax);
241  m_h1CSC_Segm_NumOfClus_Eta_EC= new TH1F("Muon_Segm_NumEtaCluster_EC",
242  "Endcap C: No. of #eta-clusters on segment;#clusters;entries", nsbins,nsmin,nsmax);
243  regCSCHist(m_h1CSC_Segm_NumOfClus_Eta_EA, m_segmDetail_EA.get());
244  regCSCHist(m_h1CSC_Segm_NumOfClus_Eta_EC, m_segmDetail_EC.get());
245 
246  m_h1CSC_Segm_NumOfGoodClus_Eta_EA= new TH1F("Muon_Segm_NumGoodEtaCluster_EA",
247  "Endcap A: No. of good #eta-clusters on segment;#good-clusters;entries", nsbins,nsmin,nsmax);
248  m_h1CSC_Segm_NumOfGoodClus_Eta_EC= new TH1F("Muon_Segm_NumGoodEtaCluster_EC",
249  "Endcap C: No. of good #eta-clusters on segment;#good-clusters;entries", nsbins,nsmin,nsmax);
250  regCSCHist(m_h1CSC_Segm_NumOfGoodClus_Eta_EA, m_segmDetail_EA.get());
251  regCSCHist(m_h1CSC_Segm_NumOfGoodClus_Eta_EC, m_segmDetail_EC.get());
252 
253  m_h1CSC_Segm_QsumOfClus_Eta_EA= new TH1F("Muon_Segm_QSumEtaCluster_EA",
254  "Endcap A: #eta-cluster Qsum;counts;entries", nqbins,nqmin,nqmax );
255  m_h1CSC_Segm_QsumOfClus_Eta_EC= new TH1F("Muon_Segm_QSumEtaCluster_EC",
256  "Endcap C: #eta-cluster Qsum;counts;entries", nqbins,nqmin,nqmax );
257  regCSCHist(m_h1CSC_Segm_QsumOfClus_Eta_EA, m_segmDetail_EA.get());
258  regCSCHist(m_h1CSC_Segm_QsumOfClus_Eta_EC, m_segmDetail_EC.get());
259 
260  m_h1CSC_Segm_TimeOfClus_Eta_EA= new TH1F("Muon_Segm_TimeEtaCluster_EA",
261  "Endcap A: #eta-cluster Time;time [ns];entries", ntbins,ntmin,ntmax );
262  m_h1CSC_Segm_TimeOfClus_Eta_EC= new TH1F("Muon_Segm_TimeEtaCluster_EC",
263  "Endcap C: #eta-cluster Time;time [ns];entries", ntbins,ntmin,ntmax );
264  regCSCHist(m_h1CSC_Segm_TimeOfClus_Eta_EA, m_segmDetail_EA.get());
265  regCSCHist(m_h1CSC_Segm_TimeOfClus_Eta_EC, m_segmDetail_EC.get());
266 
267  m_h1CSC_Segm_QsumOfGoodClus_Eta_EA= new TH1F("Muon_Segm_QSumGoodEtaCluster_EA",
268  "Endcap A: Good #eta-cluster Qsum;counts;entries", nqbins,nqmin,nqmax );
269  m_h1CSC_Segm_QsumOfGoodClus_Eta_EC= new TH1F("Muon_Segm_QSumGoodEtaCluster_EC",
270  "Endcap C: Good #eta-cluster Qsum;counts;entries", nqbins,nqmin,nqmax );
271  regCSCHist(m_h1CSC_Segm_QsumOfGoodClus_Eta_EA, m_segmDetail_EA.get());
272  regCSCHist(m_h1CSC_Segm_QsumOfGoodClus_Eta_EC, m_segmDetail_EC.get());
273 
274  m_h1CSC_Segm_TimeOfGoodClus_Eta_EA= new TH1F("Muon_Segm_TimeGoodEtaCluster_EA",
275  "Endcap A: Good #eta-cluster Time;time [ns];entries", ntbins,ntmin,ntmax );
276  m_h1CSC_Segm_TimeOfGoodClus_Eta_EC= new TH1F("Muon_Segm_TimeGoodEtaCluster_EC",
277  "Endcap C: Good #eta-cluster Time;time [ns];entries", ntbins,ntmin,ntmax );
278  regCSCHist(m_h1CSC_Segm_TimeOfGoodClus_Eta_EA, m_segmDetail_EA.get());
279  regCSCHist(m_h1CSC_Segm_TimeOfGoodClus_Eta_EC, m_segmDetail_EC.get());
280 
281 
282  // transverse clusters on segment
283  m_h2CSC_Segm_QsumOfGoodClusMap_Phi_EA=new TH2F("Muon_Segm_QSumPhiGoodClusPerLayer_EA",
284  Form("EndCap A: #phi-cluster charge per layer;counts;[sector] + [0.2 #times layer]"),
285  nqbins,nqmin,nqmax,nybinsEA,nyminEA,nymaxEA);
286 
287  m_h2CSC_Segm_QsumOfGoodClusMap_Phi_EC=new TH2F("Muon_Segm_QSumPhiGoodClusPerLayer_EC",
288  Form("EndCap C: #phi-cluster charge per layer;counts;[sector] + [0.2 #times layer]"),
289  nqbins,nqmin,nqmax,nybinsEC,nyminEC,nymaxEC);
290 
291  regCSCHist(m_h2CSC_Segm_QsumOfGoodClusMap_Phi_EA, m_segmOview_EA.get());
292  regCSCHist(m_h2CSC_Segm_QsumOfGoodClusMap_Phi_EC, m_segmOview_EC.get());
293 
294  m_h2CSC_Segm_TimeOfGoodClusMap_Phi_EA=new TH2F("Muon_Segm_TimePhiGoodClusPerLayer_EA",
295  Form("EndCap A: #phi-cluster time per layer;time [ns];[sector] + [0.2 #times layer]"),
296  ntbins,ntmin,ntmax,nybinsEA,nyminEA,nymaxEA);
297 
298  m_h2CSC_Segm_TimeOfGoodClusMap_Phi_EC=new TH2F("Muon_Segm_TimePhiGoodClusPerLayer_EC",
299  Form("EndCap C: #phi-cluster time per layer;time [ns];[sector] + [0.2 #times layer]"),
300  ntbins,ntmin,ntmax,nybinsEC,nyminEC,nymaxEC);
301 
302  regCSCHist(m_h2CSC_Segm_TimeOfGoodClusMap_Phi_EA, m_segmOview_EA.get());
303  regCSCHist(m_h2CSC_Segm_TimeOfGoodClusMap_Phi_EC, m_segmOview_EC.get());
304 
305  m_h1CSC_Segm_StatOfClus_Phi_EA= new TH1F("Muon_Segm_PhiClusterStatus_EA",
306  "Endcap A: #phi-cluster status;;entries",nbins,binmin,binmax);
307 
308  m_h1CSC_Segm_StatOfClus_Phi_EC= new TH1F("Muon_Segm_PhiClusterStatus_EC",
309  "Endcap C: #phi-cluster status;;entries",nbins,binmin,binmax);
310 
311  for (size_t j = 0; j < m_clusStatWord.size(); j++) {
312  m_h1CSC_Segm_StatOfClus_Phi_EA->GetXaxis()->SetBinLabel(j+1, m_clusStatWord[j].c_str());
313  m_h1CSC_Segm_StatOfClus_Phi_EC->GetXaxis()->SetBinLabel(j+1, m_clusStatWord[j].c_str());
314  }
315  regCSCHist(m_h1CSC_Segm_StatOfClus_Phi_EA, m_segmDetail_EA.get());
316  regCSCHist(m_h1CSC_Segm_StatOfClus_Phi_EC, m_segmDetail_EC.get());
317 
318  m_h1CSC_Segm_NumOfClus_Phi_EA= new TH1F("Muon_Segm_NumPhiCluster_EA",
319  "Endcap A: No. of #phi-clusters on segment;#clusters;entries", nsbins,nsmin,nsmax);
320  m_h1CSC_Segm_NumOfClus_Phi_EC= new TH1F("Muon_Segm_NumPhiCluster_EC",
321  "Endcap C: No. of #phi-clusters on segment;#clusters;entries", nsbins,nsmin,nsmax);
322  regCSCHist(m_h1CSC_Segm_NumOfClus_Phi_EA, m_segmDetail_EA.get());
323  regCSCHist(m_h1CSC_Segm_NumOfClus_Phi_EC, m_segmDetail_EC.get());
324 
325  m_h1CSC_Segm_NumOfGoodClus_Phi_EA= new TH1F("Muon_Segm_NumGoodPhiCluster_EA",
326  "Endcap A: No. of good #phi-clusters on segment;#good-clusters;entries", nsbins,nsmin,nsmax);
327  m_h1CSC_Segm_NumOfGoodClus_Phi_EC= new TH1F("Muon_Segm_NumGoodPhiCluster_EC",
328  "Endcap C: No. of good #phi-clusters on segment;#good-clusters;entries", nsbins,nsmin,nsmax);
329  regCSCHist(m_h1CSC_Segm_NumOfGoodClus_Phi_EA, m_segmDetail_EA.get());
330  regCSCHist(m_h1CSC_Segm_NumOfGoodClus_Phi_EC, m_segmDetail_EC.get());
331 
332  m_h1CSC_Segm_QsumOfClus_Phi_EA= new TH1F("Muon_Segm_QSumPhiCluster_EA",
333  "Endcap A: #phi-cluster Qsum;counts;entries", nqbins,nqmin,nqmax );
334  m_h1CSC_Segm_QsumOfClus_Phi_EC= new TH1F("Muon_Segm_QSumPhiCluster_EC",
335  "Endcap C: #phi-cluster Qsum;counts;entries", nqbins,nqmin,nqmax );
336  regCSCHist(m_h1CSC_Segm_QsumOfClus_Phi_EA, m_segmDetail_EA.get());
337  regCSCHist(m_h1CSC_Segm_QsumOfClus_Phi_EC, m_segmDetail_EC.get());
338 
339  m_h1CSC_Segm_TimeOfClus_Phi_EA= new TH1F("Muon_Segm_TimePhiCluster_EA",
340  "Endcap A: #phi-cluster Time;time [ns];entries", ntbins,ntmin,ntmax );
341  m_h1CSC_Segm_TimeOfClus_Phi_EC= new TH1F("Muon_Segm_TimePhiCluster_EC",
342  "Endcap C: #phi-cluster Time;time [ns];entries", ntbins,ntmin,ntmax );
343  regCSCHist(m_h1CSC_Segm_TimeOfClus_Phi_EA, m_segmDetail_EA.get());
344  regCSCHist(m_h1CSC_Segm_TimeOfClus_Phi_EC, m_segmDetail_EC.get());
345 
346  m_h1CSC_Segm_QsumOfGoodClus_Phi_EA= new TH1F("Muon_Segm_QSumGoodPhiCluster_EA",
347  "Endcap A: Good #phi-cluster Qsum;counts;entries", nqbins,nqmin,nqmax );
348  m_h1CSC_Segm_QsumOfGoodClus_Phi_EC= new TH1F("Muon_Segm_QSumGoodPhiCluster_EC",
349  "Endcap C: Good #phi-cluster Qsum;counts;entries", nqbins,nqmin,nqmax );
350  regCSCHist(m_h1CSC_Segm_QsumOfGoodClus_Phi_EA, m_segmDetail_EA.get());
351  regCSCHist(m_h1CSC_Segm_QsumOfGoodClus_Phi_EC, m_segmDetail_EC.get());
352 
353  m_h1CSC_Segm_TimeOfGoodClus_Phi_EA= new TH1F("Muon_Segm_TimeGoodPhiCluster_EA",
354  "Endcap A: Good #phi-cluster Time;time [ns];entries", ntbins,ntmin,ntmax );
355  m_h1CSC_Segm_TimeOfGoodClus_Phi_EC= new TH1F("Muon_Segm_TimeGoodPhiCluster_EC",
356  "Endcap C: Good #phi-cluster Time;time [ns];entries", ntbins,ntmin,ntmax );
357  regCSCHist(m_h1CSC_Segm_TimeOfGoodClus_Phi_EA, m_segmDetail_EA.get());
358  regCSCHist(m_h1CSC_Segm_TimeOfGoodClus_Phi_EC, m_segmDetail_EC.get());
359 
360  // eta vs. phi correlation
361  m_h2CSC_Segm_QsumOfGoodClus_PhiVsEta_EA= new TH2F("Muon_Segm_QSumGoodClusCorrelation_EA",
362  "Endcap A: #phi-cluster vs. good #eta-cluster;good #eta-cluster counts;good #phi-cluster counts", nqbins,nqmin,nqmax, nqbins,nqmin,nqmax);
363  m_h2CSC_Segm_QsumOfGoodClus_PhiVsEta_EC= new TH2F("Muon_Segm_QSumGoodClusCorrelation_EC",
364  "Endcap A: #phi-cluster vs. good #eta-cluster;good #eta-cluster counts;good #phi-cluster counts", nqbins,nqmin,nqmax, nqbins,nqmin,nqmax);
365  regCSCHist(m_h2CSC_Segm_QsumOfGoodClus_PhiVsEta_EA, m_segmDetail_EA.get());
366  regCSCHist(m_h2CSC_Segm_QsumOfGoodClus_PhiVsEta_EC, m_segmDetail_EC.get());
367 
368  m_bookedhistos=true;
369 }
370 
371 
372 //________________________________________________________________________________________________________
373 StatusCode CSCSegmValAlg::bookHistograms() {
374 
375  if (m_debuglevel) ATH_MSG_DEBUG( "CSCSegmValAlg::bookHistograms() to setup tools/services" );
376  StatusCode sc = StatusCode::SUCCESS;
377 
378  if( m_environment == AthenaMonManager::tier0 || m_environment == AthenaMonManager::tier0ESD ) {
379 
380  if(!m_bookedhistos) bookSegmentHistograms();
381 
382  } // environment if
383  return sc;
384 }
385 
386 
387 //________________________________________________________________________________________________________
388 StatusCode CSCSegmValAlg::fillHistograms() {
389 
390  ATH_MSG_DEBUG( "in CSCSegmValAlg::fillHistograms() " );
391 
392  if( m_environment == AthenaMonManager::tier0 || m_environment == AthenaMonManager::tier0ESD || m_environment == AthenaMonManager::user ) {
393 
394  // if required, check if event passed sample-selection triggers
395  if(m_doEvtSel) { if(!evtSelTriggersPassed()) return StatusCode::SUCCESS; }
396 
397  // Segment Cluster counter
398  int segmClustCount[33];
399 
400  // arrays to hold cluster-count
401  // 32 chambers and 8 layers (each has one extra - index '0' is not counted)
402  int clusCount[33][9];
403  for(unsigned int kl = 0; kl < 33; kl++ ) {
404  for(unsigned int cm3 = 0; cm3 < 9; cm3++ ) {
405  clusCount[kl][cm3] = 0;
406  }
407  }
408 
409 
410  SG::ReadHandle<Trk::SegmentCollection> segments(m_segmKey);
411 
412  if ( segments->empty() ){
413 
414  if (m_debuglevel){
415  ATH_MSG_DEBUG( " Segm Collection is Empty, done... ");
416  }
417  return StatusCode::SUCCESS;
418  }
419 
420  if (m_debuglevel){
421  ATH_MSG_DEBUG( " Segm Collection size " );
422  ATH_MSG_DEBUG( "Number of segms found: " << segments->size() );
423  }
424 
425  if ( segments->size() > 0 ){
426  ATH_MSG_DEBUG( "Number of segms in event is: " << segments->size() );
427  ATH_MSG_DEBUG( "This algorithm is designed to operate for single segm / event only" );
428  ATH_MSG_DEBUG( "Processing only the first segm in the segm collection" );
429  }
430 
431  int layerindex = 0;
432 
433  //Loop over segms
434  for (Trk::SegmentCollection::const_iterator s = segments->begin();s != segments->end(); ++s) {
435 
436  // Get segm
437  const Muon::MuonSegment *segm=dynamic_cast<const Muon::MuonSegment*>(*s);
438 
439  if (segm == nullptr) {
440  ATH_MSG_ERROR( "no pointer to segm!!!" );
441  continue;
442  }
443 
444  // Loop over segment ROTs - not necessary 03-23
445  // for(unsigned int i =0; i < segm->numberOfContainedROTs(); ++i) {
446  ATH_MSG_DEBUG( "Looking at segment id" );
447 
448  // Skip segment if there are no csc hits
449  if ( cscHits(segm)<1 ) continue;
450 
451  // Get contained measurements
452  const std::vector<const Trk::MeasurementBase*> meas = segm->containedMeasurements();
453 
454  // Skip segment if no measurements
455  // Number of clusters on segment
456  int n_clust=meas.size();
457  if ( n_clust < 2 ) continue;
458 
459  // Analyze segment if it is a csc segment
460  if ( isCscSegment(segm) ) {
461 
462  // Initialize cluster counter
463  for(int sect = 0; sect < 33; sect++) {
464  segmClustCount[sect] = 0;
465  for(unsigned int ilay = 0; ilay < 9; ilay++ ) {
466  clusCount[sect][ilay] = 0;
467  }
468 
469  }
470 
471  // Print out segment information
472  const Trk::FitQuality* fq = segm->fitQuality();
473  double chi2 = 999.;
474  int ndof = -1;
475  if( fq ) {
476  chi2 = fq->chiSquared();
477  ndof = fq->numberDoF();
478  ATH_MSG_DEBUG( "Chi2 " << chi2 );
479  ATH_MSG_DEBUG( "Ndof " << ndof );
480  }
481 
482  // cut on segment angle
483  float segm_ly = segm->localParameters()[Trk::locY];
484  float segm_ayz = segm->localDirection().angleYZ();
485  segm_ayz -= M_PI/2.;
486  float segm_cut = m_segmSlope;
487  bool segmAngle_cut = segmSlopeCut(segm_ly, segm_ayz, segm_cut);
488  ATH_MSG_DEBUG(" local_pos: " << segm_ly <<
489  "\tangle_yz: " << segm_ayz << "\tcut: " << segm_cut << "\t pass = " << segmAngle_cut );
490 
491 
492  ATH_MSG_DEBUG( "R " << segm->globalPosition().perp() );
493  ATH_MSG_DEBUG( "Z " << segm->globalPosition().z() );
494  ATH_MSG_DEBUG( "Phi " << segm->globalPosition().phi() );
495  ATH_MSG_DEBUG( "Eta " << segm->globalPosition().eta() );
496  ATH_MSG_DEBUG( "Dir Phi " << segm->globalDirection().phi() );
497  ATH_MSG_DEBUG( "Dir Eta " << segm->globalDirection().eta() );
498 
499 
500  // ==============================================================================
501  // Field Range Notes
502  // ==============================================================================
503  // StationName unsigned integer maps to "CSS", "CSL", etc.
504  // StationEta [-1,1] -1 for backward, 1 for forward endcap
505  // StationPhi [1,8] increases with Phi
506  // Technology [1] maps to "CSC"
507  // ChamberLayer [1,2] increases with |Z|
508  // WireLayer [1,4] increases with |Z|
509  // MeasuresPhi [0,1] 0 if measures R, 1 if measures Phi
510  // Strip [1,n] increases with R for MeasuresPhi=0
511  // increases with Phi for MeasuresPhi=1
512  // ==============================================================================
513 
514  // identify the segment location
515  const Trk::MeasurementBase* rio = meas.at(0);
516  Identifier segmId = m_edmHelperSvc->getIdentifier(*rio);
517 
518  int segm_stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(segmId);
519  int segm_stationEta = m_idHelperSvc->cscIdHelper().stationEta(segmId);
520  int segm_stationName = m_idHelperSvc->cscIdHelper().stationName(segmId);
521  std::string segm_stationString = m_idHelperSvc->cscIdHelper().stationNameString(segm_stationName);
522  int segm_chamberType = segm_stationString == "CSS" ? 0 : 1;
523  int segm_sectorNo = segm_stationEta * (2 * segm_stationPhi - segm_chamberType); // [-16 -> -1] and [+1 -> +16]
524  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]
525  ATH_MSG_DEBUG(" sgsec = " << segm_isec << "\tsec = " << segm_sectorNo);
526  if(segm_stationEta == 1) m_h2CSC_Segm_NumOfSegs_EA->Fill(n_clust, segm_sectorNo);
527  else m_h2CSC_Segm_NumOfSegs_EC->Fill(n_clust, segm_sectorNo);
528 
529  // Loop over clusters
530  float clus_kiloele = 1.0e-3; // multiply # of electrons by this number to get kiloElectrons (1 ke = 1 ADC)
531  int eta_clus_count[2][2] = {{0},{0}}, phi_clus_count[2][2] = {{0},{0}}; // no. of prec/trans hits per segment
532  float eta_clus_qsum[2][5] = {{-1.}, {-1.}}, phi_clus_qsum[2][5] = {{-1.}, {-1.}}; // qsum over each prec/trans. layer on segment
533  float eta_clus_time[2][5] = {{-1.}, {-1.}}, phi_clus_time[2][5] = {{-1.}, {-1.}}; // time over each prec/trans. layer on segment
534  int eta_clus_use[2][5] = {{0},{0}}, phi_clus_use[2][5] = {{0}, {0}};
535 
536  layerindex = 0;
537 
538  for(TrkSegmIter hit = segm->containedMeasurements().begin();
539  hit != segm->containedMeasurements().end(); ++hit ) {
540  const Muon::CscClusterOnTrack* clust_rot = dynamic_cast<const Muon::CscClusterOnTrack*>(*hit);
541  if( clust_rot ) {
542  Identifier clusId = m_edmHelperSvc->getIdentifier(*clust_rot);
543 
544  // get the cluster coordinates
545  int clus_stationName = m_idHelperSvc->cscIdHelper().stationName(clusId);
546  std::string clus_stationString = m_idHelperSvc->cscIdHelper().stationNameString(clus_stationName);
547  int clus_chamberType = clus_stationString == "CSS" ? 0 : 1;
548  int clus_stationEta = m_idHelperSvc->cscIdHelper().stationEta(clusId);
549  int clus_stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(clusId);
550  int clus_wireLayer = m_idHelperSvc->cscIdHelper().wireLayer(clusId);
551  int clus_measuresPhi = m_idHelperSvc->cscIdHelper().measuresPhi(clusId);
552 
553  // convert to my coordinates
554  int clus_sectorNo = clus_stationEta * (2 * clus_stationPhi - clus_chamberType); // [-16 -> -1] and [+1 -> +16]
555  float clus_secLayer = clus_sectorNo + 0.2 * (clus_wireLayer - 1) + 0.1;
556  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]
557  int clus_ilay = (clus_measuresPhi ? clus_wireLayer : clus_wireLayer+4);
558 
559  // check the cluster status; probably need to read status info from jobOptions - not done for the moment
560  Muon::CscClusterStatus status = clust_rot->status();
561  if(segm_stationEta == 1) {
562  if(clus_measuresPhi == 0) m_h1CSC_Segm_StatOfClus_Eta_EA->Fill(status);
563  else m_h1CSC_Segm_StatOfClus_Phi_EA->Fill(status);
564  } else {
565  if(clus_measuresPhi == 0) m_h1CSC_Segm_StatOfClus_Eta_EC->Fill(status);
566  else m_h1CSC_Segm_StatOfClus_Phi_EC->Fill(status);
567  }
568 
569  std::string clus_stat = Muon::toString(status);
570  bool clus_status = ( (clus_stat == "unspoiled") ||
571  (clus_stat == "unspoiled with split") ||
572  (clus_stat == "simple")
573  ) ? true : false;
574  bool clus_stat_eff = ( (int(status) >= 0 && int(status) < 8) ||
575  (int(status) > 8 && int(status) < 18) ) ? true : false;
576 
577  // get cluster
578  const Muon::CscPrepData* theClus = clust_rot->prepRawData();
579  float clus_qsum = 0, clus_time = -1.;
580  unsigned int clus_noStrips=0;
581  if(theClus) {
582  clus_qsum = theClus->charge() * clus_kiloele;
583  clus_time = theClus->time();
584 
585  if(clus_measuresPhi == 0) {
586  if(clus_stationEta == 1) eta_clus_count[0][0]++;
587  else eta_clus_count[1][0]++;
588  } else {
589  if(clus_stationEta == 1) phi_clus_count[0][0]++;
590  else phi_clus_count[1][0]++;
591  }
592  // get no. of strips per cluster
593  clus_noStrips = theClus->rdoList().size();
594  }
595 
596 
597  // need at least three strips in an eta-cluster
598  bool clus_eta_status = clus_status && ( clus_noStrips > 2 ) && (clus_measuresPhi == 0);
599  bool clus_eta_eff = clus_stat_eff && ( clus_noStrips > 2 ) && (clus_measuresPhi == 0);
600  if(clus_eta_eff) {
601  if(clus_stationEta == 1) {
602  eta_clus_count[0][1]++;
603  } else {
604  eta_clus_count[1][1]++;
605  }
606  }
607  if(clus_eta_status) {
608  if(clus_stationEta == 1) {
609  eta_clus_qsum[0][clus_wireLayer] = clus_qsum;
610  eta_clus_time[0][clus_wireLayer] = clus_time;
611  eta_clus_use[0][clus_wireLayer] = 1;
612  m_h2CSC_Segm_QsumOfGoodClusMap_Eta_EA->Fill(clus_qsum, clus_secLayer);
613  if(std::abs(clus_time) <= 200) m_h2CSC_Segm_TimeOfGoodClusMap_Eta_EA->Fill(clus_time, clus_secLayer);
614  } else {
615  eta_clus_qsum[1][clus_wireLayer] = clus_qsum;
616  eta_clus_time[1][clus_wireLayer] = clus_time;
617  eta_clus_use[1][clus_wireLayer] = 1;
618  m_h2CSC_Segm_QsumOfGoodClusMap_Eta_EC->Fill(clus_qsum, clus_secLayer);
619  if(std::abs(clus_time) <= 200) m_h2CSC_Segm_TimeOfGoodClusMap_Eta_EC->Fill(clus_time, clus_secLayer);
620  }
621  }
622 
623  // need at least one strip in a phi-cluster
624  bool clus_phi_status = clus_status && ( clus_noStrips > 0 ) && (clus_measuresPhi == 1);
625  if(clus_phi_status) {
626  if(clus_stationEta == 1) {
627  phi_clus_qsum[0][clus_wireLayer] = clus_qsum;
628  phi_clus_time[0][clus_wireLayer] = clus_time;
629  phi_clus_use[0][clus_wireLayer] = 1;
630  phi_clus_count[0][1]++;
631  m_h2CSC_Segm_QsumOfGoodClusMap_Phi_EA->Fill(clus_qsum, clus_secLayer);
632  if(std::abs(clus_time) <= 200) m_h2CSC_Segm_TimeOfGoodClusMap_Phi_EA->Fill(clus_time, clus_secLayer);
633  } else {
634  phi_clus_qsum[1][clus_wireLayer] = clus_qsum;
635  phi_clus_time[1][clus_wireLayer] = clus_time;
636  phi_clus_use[1][clus_wireLayer] = 1;
637  phi_clus_count[1][1]++;
638  m_h2CSC_Segm_QsumOfGoodClusMap_Phi_EC->Fill(clus_qsum, clus_secLayer);
639  if(std::abs(clus_time) <= 200) m_h2CSC_Segm_TimeOfGoodClusMap_Phi_EC->Fill(clus_time, clus_secLayer);
640  }
641  }
642 
643  // increment the cluster-count for this layer
644  if(clus_eta_status || clus_phi_status) clusCount[clus_isec][clus_ilay]++;
645 
646  // increment segment cluster count
647  if(clus_eta_status) segmClustCount[clus_isec]++;
648 
649  if(clus_eta_status) layerindex+=clus_wireLayer;
650 
651  ATH_MSG_DEBUG("status = " << clus_stat << "\tcharge = " << clus_qsum << "\ttime= " << clus_time << "\tnstrips = " << clus_noStrips);
652 
653  } else {
654  } // if cluster found
655  } // for loop over clusters
656 
657  if(eta_clus_count[0][0] > 0) m_h1CSC_Segm_NumOfClus_Eta_EA->Fill(eta_clus_count[0][0]);
658  if(phi_clus_count[0][0] > 0) m_h1CSC_Segm_NumOfClus_Phi_EA->Fill(phi_clus_count[0][0]);
659  if(eta_clus_count[0][1] > 0) m_h1CSC_Segm_NumOfGoodClus_Eta_EA->Fill(eta_clus_count[0][1]);
660  if(phi_clus_count[0][1] > 0) m_h1CSC_Segm_NumOfGoodClus_Phi_EA->Fill(phi_clus_count[0][1]);
661  if(eta_clus_count[1][0] > 0) m_h1CSC_Segm_NumOfClus_Eta_EC->Fill(eta_clus_count[1][0]);
662  if(phi_clus_count[1][0] > 0) m_h1CSC_Segm_NumOfClus_Phi_EC->Fill(phi_clus_count[1][0]);
663  if(eta_clus_count[1][1] > 0) m_h1CSC_Segm_NumOfGoodClus_Eta_EC->Fill(eta_clus_count[1][1]);
664  if(phi_clus_count[1][1] > 0) m_h1CSC_Segm_NumOfGoodClus_Phi_EC->Fill(phi_clus_count[1][1]);
665 
666  // Fill number of 3 and 4 cluster segment histogram
667  for (int isect = 1; isect < 17; isect++) {
668  if(segmClustCount[isect+16] > 2){
669  m_h2CSC_Segm_NumOfNClusSegs_Eta_EA->Fill(layerindex-5, isect);
670  }
671  if(segmClustCount[isect] > 2){
672  m_h2CSC_Segm_NumOfNClusSegs_Eta_EC->Fill(layerindex-5, (-1.)*isect);
673  }
674  if(segmClustCount[isect+16] > 3){
675  m_h2CSC_Segm_NumOfNClusSegs_Eta_EA->Fill(1, isect);
676  m_h2CSC_Segm_NumOfNClusSegs_Eta_EA->Fill(2, isect);
677  m_h2CSC_Segm_NumOfNClusSegs_Eta_EA->Fill(3, isect);
678  m_h2CSC_Segm_NumOfNClusSegs_Eta_EA->Fill(4, isect);
679  }
680  if(segmClustCount[isect] > 3){
681  m_h2CSC_Segm_NumOfNClusSegs_Eta_EC->Fill(1, -1.*isect);
682  m_h2CSC_Segm_NumOfNClusSegs_Eta_EC->Fill(2, -1.*isect);
683  m_h2CSC_Segm_NumOfNClusSegs_Eta_EC->Fill(3, -1.*isect);
684  m_h2CSC_Segm_NumOfNClusSegs_Eta_EC->Fill(4, -1.*isect);
685  }
686  }
687 
688  float eta_clus_qsum_tot = 0., phi_clus_qsum_tot = 0.; // total qsum over all prec. trans. layers on segment
689  for(unsigned int i = 0; i < 2; i++) {
690  eta_clus_qsum_tot = 0; phi_clus_qsum_tot = 0.;
691  for(unsigned int j = 1; j < 5; j++) {
692  if(i==0) m_h1CSC_Segm_QsumOfClus_Eta_EA->Fill(eta_clus_qsum[i][j]);
693  if(i==1) m_h1CSC_Segm_QsumOfClus_Eta_EC->Fill(eta_clus_qsum[i][j]);
694  if(i==0) m_h1CSC_Segm_QsumOfClus_Phi_EA->Fill(phi_clus_qsum[i][j]);
695  if(i==1) m_h1CSC_Segm_QsumOfClus_Phi_EC->Fill(phi_clus_qsum[i][j]);
696  if(i==0 && std::abs(eta_clus_time[i][j]) <= 200) m_h1CSC_Segm_TimeOfClus_Eta_EA->Fill(eta_clus_time[i][j]);
697  if(i==1 && std::abs(eta_clus_time[i][j]) <= 200) m_h1CSC_Segm_TimeOfClus_Eta_EC->Fill(eta_clus_time[i][j]);
698  if(i==0 && std::abs(phi_clus_time[i][j]) <= 200) m_h1CSC_Segm_TimeOfClus_Phi_EA->Fill(phi_clus_time[i][j]);
699  if(i==1 && std::abs(phi_clus_time[i][j]) <= 200) m_h1CSC_Segm_TimeOfClus_Phi_EC->Fill(phi_clus_time[i][j]);
700  if(phi_clus_use[i][j] && eta_clus_use[i][j]) {
701  eta_clus_qsum_tot += eta_clus_qsum[i][j];
702  if(i==0) m_h1CSC_Segm_QsumOfGoodClus_Eta_EA->Fill(eta_clus_qsum[i][j]);
703  if(i==1) m_h1CSC_Segm_QsumOfGoodClus_Eta_EC->Fill(eta_clus_qsum[i][j]);
704  if(i==0 && std::abs(eta_clus_time[i][j]) <= 200) m_h1CSC_Segm_TimeOfGoodClus_Eta_EA->Fill(eta_clus_time[i][j]);
705  if(i==1 && std::abs(eta_clus_time[i][j]) <= 200) m_h1CSC_Segm_TimeOfGoodClus_Eta_EC->Fill(eta_clus_time[i][j]);
706  phi_clus_qsum_tot += phi_clus_qsum[i][j];
707  if(i==0) m_h1CSC_Segm_QsumOfGoodClus_Phi_EA->Fill(phi_clus_qsum[i][j]);
708  if(i==1) m_h1CSC_Segm_QsumOfGoodClus_Phi_EC->Fill(phi_clus_qsum[i][j]);
709  if(i==0 && std::abs(phi_clus_time[i][j]) <= 200) m_h1CSC_Segm_TimeOfGoodClus_Phi_EA->Fill(phi_clus_time[i][j]);
710  if(i==1 && std::abs(phi_clus_time[i][j]) <= 200) m_h1CSC_Segm_TimeOfGoodClus_Phi_EC->Fill(phi_clus_time[i][j]);
711  }
712  }
713  if(i==0) m_h2CSC_Segm_QsumOfGoodClus_PhiVsEta_EA->Fill(eta_clus_qsum_tot,phi_clus_qsum_tot);
714  if(i==1) m_h2CSC_Segm_QsumOfGoodClus_PhiVsEta_EC->Fill(eta_clus_qsum_tot,phi_clus_qsum_tot);
715  }
716 
717  } // if is csc segment
718 
719  } // loop over segms
720 
721  } // environment if
722 
723  if (m_debuglevel) ATH_MSG_DEBUG( " done with CSCSegmValAlg::fillHistograms()" );
724 
725  return StatusCode::SUCCESS;
726 }
727 
728 
729 //________________________________________________________________________________________________________
730 StatusCode CSCSegmValAlg::procHistograms() {
731 
732  if( m_environment == AthenaMonManager::tier0 || m_environment == AthenaMonManager::tier0ESD ) {
733 
734  if (m_debuglevel) ATH_MSG_DEBUG( "in CSCSegmValAlg::procHistograms()" );
735  } // environment if
736 
737  return StatusCode::SUCCESS;
738 }
739 
740 //________________________________________________________________________________________________________
741 bool CSCSegmValAlg::evtSelTriggersPassed() {
742 
743  if(!m_doEvtSel) return true;
744  std::vector<std::string>::const_iterator
745  it = m_sampSelTriggers.begin(), itE = m_sampSelTriggers.end();
746  for ( ; it != itE; ++it ) {
747  if (m_trigDec->isPassed(*it, TrigDefs::eventAccepted)) {
748  return true;
749  }
750  }
751  return false;
752 
753 } // end evtSelTriggersPassed
754 
755 //________________________________________________________________________________________________________
756 bool CSCSegmValAlg::isCscSegment( const Muon::MuonSegment* seg ) const {
757  bool isCsc(false);
758 
759  std::vector<const Trk::MeasurementBase*> mbs = seg->containedMeasurements();
760  for( unsigned int i = 0; i< mbs.size(); ++i){
761 
762  const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*> (mbs[i]);
763  if (!rot){
764  const Trk::CompetingRIOsOnTrack* crot = dynamic_cast<const Trk::CompetingRIOsOnTrack*> (mbs[i]);
765  if (crot) rot = &(crot->rioOnTrack(0));
766  }
767  if( !rot ) {
768  continue;
769  }
770  if( m_idHelperSvc->isCsc( rot->identify() ) ) isCsc=true;
771  }
772 
773  return isCsc;
774 }
775 
776 
777 //________________________________________________________________________________________________________
778 unsigned int CSCSegmValAlg::cscHits( const Muon::MuonSegment* seg ) const {
779  unsigned int nrHits(0);
780  if( !isCscSegment(seg) ) return nrHits;
781 
782  std::vector<const Trk::MeasurementBase*> mbs = seg->containedMeasurements();
783  for( unsigned int i = 0; i< mbs.size(); ++i){
784 
785  const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*> (mbs[i]);
786  if (!rot){
787  const Trk::CompetingRIOsOnTrack* crot = dynamic_cast<const Trk::CompetingRIOsOnTrack*> (mbs[i]);
788  if (crot) rot = &(crot->rioOnTrack(0));
789  }
790  if( !rot ) {
791  continue;
792  }
793  if( m_idHelperSvc->isCsc( rot->identify() ) ) ++nrHits;
794  }
795 
796  return nrHits ;
797 }
798 
799 //________________________________________________________________________________________________________
800 void CSCSegmValAlg::setCSCLayerLabels(TH1 *h, int side) {
801 
802  if(!h) return;
803  if(!(side == 1 || side == -1)) return;
804  if(h->GetNbinsX() < 85) return;
805 
806  h->GetXaxis()->SetTitle("");
807  h->GetXaxis()->SetLabelSize(0.03);
808  if(side == -1) {
809  for(unsigned int j=6; j<86; j++) {
810  if( j%5 != 0 ) {
811  float xmid = h->GetBinLowEdge(j) + h->GetBinWidth(j);
812  xmid -= 1.0; xmid *= -1.0;
813  int seclay = int(ceil(xmid*10)); // get sector/layer
814  int sec = seclay/10;
815  int lay = (seclay%10)/2 ;
816  lay = (4 - lay) + 1;
817  h->GetXaxis()->SetBinLabel(j,Form("%c%02d:%d",(sec%2==0?'S':'L'),sec,lay));
818  } // end for
819  } // end if
820  } else if (side == 1) {
821  for(unsigned int j=6; j<86; j++) {
822  if( j%5 != 0 ) {
823  float xmid = h->GetBinLowEdge(j) + h->GetBinWidth(j);
824  int seclay = int(ceil(xmid*10)); // get sector/layer
825  int sec = seclay/10;
826  int lay = (seclay%10)/2 ;
827  h->GetXaxis()->SetBinLabel(j,Form("%c%02d:%d",(sec%2==0?'S':'L'),sec,lay));
828  }
829  } // end for
830  } // end else
831 
832 } // setCSCLayerLabels
833 
834 
835 //________________________________________________________________________________________________________
836 void CSCSegmValAlg::regCSCHist(TH1 *h, MonGroup *cm3 ) {
837  StatusCode sc = StatusCode::SUCCESS;
838  if(!cm3 || !h) return;
839 
840  ATH_MSG_INFO ( "registering histogram: " << h->GetName() << " with group: " << cm3->system() );
841  sc = cm3->regHist(h);
842  if ( sc.isFailure() ) {
843  ATH_MSG_ERROR ( "Failed to register histogram: " << h->GetName() << " with group: " << cm3->system() );
844  }
845  ATH_MSG_VERBOSE ( "registered histogram: " << h->GetName() << " with group: " << cm3->system() );
846 }
847 
848 //________________________________________________________________________________________________________
849 bool CSCSegmValAlg::segmSlopeCut(float& csc_x, float& csc_ax, float& cut ) {
850  float s0 = csc_x;
851  float s1 = -tan(csc_ax);
852  float s1corr = s1 - 0.000119 * s0;
853  bool good_segm = std::abs(s1corr)<cut ? true : false;
854  return good_segm;
855 }
856 
IDTPM::ndof
float ndof(const U &p)
Definition: TrackParametersHelper.h:142
CSCSegmValAlg::m_debuglevel
bool m_debuglevel
private member to control debug messages
Definition: CSCSegmValAlg.h:96
CSCSegmValAlg::m_h1CSC_Segm_TimeOfClus_Phi_EA
TH1F * m_h1CSC_Segm_TimeOfClus_Phi_EA
Definition: CSCSegmValAlg.h:146
ReadCellNoiseFromCoolCompare.s1
s1
Definition: ReadCellNoiseFromCoolCompare.py:378
CscStripPrepDataContainer.h
CSCSegmValAlg::m_h1CSC_Segm_NumOfGoodClus_Phi_EC
TH1F * m_h1CSC_Segm_NumOfGoodClus_Phi_EC
Definition: CSCSegmValAlg.h:151
CSCSegmValAlg::regCSCHist
void regCSCHist(TH1 *h, MonGroup *mg)
Definition: CSCSegmValAlg.cxx:836
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
CSCSegmValAlg::m_segmKey
SG::ReadHandleKey< Trk::SegmentCollection > m_segmKey
Definition: CSCSegmValAlg.h:93
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
CSCSegmValAlg::m_clusStatWord
std::vector< std::string > m_clusStatWord
Definition: CSCSegmValAlg.h:104
CSCSegmValAlg::m_h2CSC_Segm_NumOfNClusSegs_Eta_EC
TH2F * m_h2CSC_Segm_NumOfNClusSegs_Eta_EC
Definition: CSCSegmValAlg.h:108
CSCSegmValAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: CSCSegmValAlg.h:163
CSCSegmValAlg::segmSlopeCut
bool segmSlopeCut(float &csc_x, float &csc_ax, float &cut)
Definition: CSCSegmValAlg.cxx:849
CSCSegmValAlg::m_h1CSC_Segm_StatOfClus_Phi_EC
TH1F * m_h1CSC_Segm_StatOfClus_Phi_EC
Definition: CSCSegmValAlg.h:149
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CSCSegmValAlg::m_h1CSC_Segm_StatOfClus_Eta_EC
TH1F * m_h1CSC_Segm_StatOfClus_Eta_EC
Definition: CSCSegmValAlg.h:127
CSCSegmValAlg::m_h2CSC_Segm_NumOfNClusSegs_Eta_EA
TH2F * m_h2CSC_Segm_NumOfNClusSegs_Eta_EA
Definition: CSCSegmValAlg.h:107
CompetingRIOsOnTrack.h
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:44
CSCSegmValAlg::m_h1CSC_Segm_NumOfClus_Phi_EA
TH1F * m_h1CSC_Segm_NumOfClus_Phi_EA
Definition: CSCSegmValAlg.h:142
ManagedMonitorToolBase::MgmtAttr_t
MgmtAttr_t
An enumeration describing how the class handles the histogram.
Definition: ManagedMonitorToolBase.h:131
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
CSCSegmValAlg::bookSegmentHistograms
void bookSegmentHistograms()
Definition: CSCSegmValAlg.cxx:109
Muon::CscPrepData::charge
int charge() const
Returns the charge.
Definition: CscPrepData.h:153
CaloLCWConfig.theKey
string theKey
Definition: CaloLCWConfig.py:68
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:74
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
CSCSegmValAlg::m_h2CSC_Segm_QsumOfGoodClusMap_Phi_EC
TH2F * m_h2CSC_Segm_QsumOfGoodClusMap_Phi_EC
Definition: CSCSegmValAlg.h:136
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CSCSegmValAlg::evtSelTriggersPassed
bool evtSelTriggersPassed()
TDT handle.
Definition: CSCSegmValAlg.cxx:741
skel.it
it
Definition: skel.GENtoEVGEN.py:423
cm3
#define cm3
M_PI
#define M_PI
Definition: ActiveFraction.h:11
CscStripPrepDataCollection.h
CSCSegmValAlg::m_h1CSC_Segm_QsumOfClus_Phi_EA
TH1F * m_h1CSC_Segm_QsumOfClus_Phi_EA
Definition: CSCSegmValAlg.h:144
Trk::PrepRawData::rdoList
const std::vector< Identifier > & rdoList() const
return the List of rdo identifiers (pointers)
CSCSegmValAlg::m_h2CSC_Segm_QsumOfGoodClus_PhiVsEta_EA
TH2F * m_h2CSC_Segm_QsumOfGoodClus_PhiVsEta_EA
Definition: CSCSegmValAlg.h:157
PropDirection.h
CSCSegmValAlg::m_h1CSC_Segm_Efficiency_Eta_EA
TH1F * m_h1CSC_Segm_Efficiency_Eta_EA
Definition: CSCSegmValAlg.h:110
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
CSCSegmValAlg::m_h2CSC_Segm_NumOfSegs_EA
TH2F * m_h2CSC_Segm_NumOfSegs_EA
Definition: CSCSegmValAlg.h:101
CSCSegmValAlg::TrkSegmIter
std::vector< const Trk::MeasurementBase * >::const_iterator TrkSegmIter
Definition: CSCSegmValAlg.h:68
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
CSCSegmValAlg.h
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
CSCSegmValAlg::m_edmHelperSvc
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
Definition: CSCSegmValAlg.h:160
TruthTest.itE
itE
Definition: TruthTest.py:25
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
Trk::LocalDirection::angleYZ
double angleYZ() const
access method for angle of local YZ projection
Definition: LocalDirection.h:106
TRT::Hit::side
@ side
Definition: HitInfo.h:83
CSCSegmValAlg::cscHits
unsigned int cscHits(const Muon::MuonSegment *seg) const
Definition: CSCSegmValAlg.cxx:778
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
CSCSegmValAlg::m_sampSelTriggers
std::vector< std::string > m_sampSelTriggers
Definition: CSCSegmValAlg.h:90
CSCSegmValAlg::initialize
StatusCode initialize()
Definition: CSCSegmValAlg.cxx:57
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:138
Trk::CompetingRIOsOnTrack::rioOnTrack
virtual const RIO_OnTrack & rioOnTrack(unsigned int) const =0
returns the RIO_OnTrack (also known as ROT) objects depending on the integer.
CSCSegmValAlg::CSCSegmValAlg
CSCSegmValAlg(const std::string &type, const std::string &name, const IInterface *parent)
Constructor.
Definition: CSCSegmValAlg.cxx:40
StoreGateSvc
The Athena Transient Store API.
Definition: StoreGateSvc.h:128
AthenaMonManager::tier0ESD
@ tier0ESD
Definition: AthenaMonManager.h:49
keylayer_zslicemap.kl
kl
Definition: keylayer_zslicemap.py:109
Muon::toString
std::string toString(CscStripStatus cstat)
Return a string description of a CSC cluster status flag.
Definition: CscStripStatus.h:48
CSCSegmValAlg::m_bookedhistos
bool m_bookedhistos
Definition: CSCSegmValAlg.h:97
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CSCSegmValAlg::bookHistograms
virtual StatusCode bookHistograms()
Histogram booking method.
Definition: CSCSegmValAlg.cxx:373
CscPrepData.h
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
lumiFormat.i
int i
Definition: lumiFormat.py:92
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
CSCSegmValAlg::m_h1CSC_Segm_StatOfClus_Phi_EA
TH1F * m_h1CSC_Segm_StatOfClus_Phi_EA
Definition: CSCSegmValAlg.h:141
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
Muon::CscPrepData
Class representing clusters from the CSC.
Definition: CscPrepData.h:39
CSCSegmValAlg::m_segmOview_EC
std::unique_ptr< MonGroup > m_segmOview_EC
Definition: CSCSegmValAlg.h:73
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CSCSegmValAlg::m_h1CSC_Segm_TimeOfGoodClus_Phi_EA
TH1F * m_h1CSC_Segm_TimeOfGoodClus_Phi_EA
Definition: CSCSegmValAlg.h:147
Muon::MuonSegment::localDirection
const Trk::LocalDirection & localDirection() const
local direction
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:169
Trk::Segment::containedMeasurements
const std::vector< const Trk::MeasurementBase * > & containedMeasurements() const
returns the vector of Trk::MeasurementBase objects
Definition: TrkEvent/TrkSegment/TrkSegment/Segment.h:166
TrackCollection.h
CscClusterOnTrack.h
Trk::CompetingRIOsOnTrack
Base class for all CompetingRIOsOnTack implementations, extends the common MeasurementBase.
Definition: CompetingRIOsOnTrack.h:64
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:522
BindingsTest.cut
cut
This script demonstrates how to call a C++ class from Python Also how to use PyROOT is shown.
Definition: BindingsTest.py:13
test_pyathena.parent
parent
Definition: test_pyathena.py:15
CSCSegmValAlg::isCscSegment
bool isCscSegment(const Muon::MuonSegment *seg) const
Definition: CSCSegmValAlg.cxx:756
CSCSegmValAlg::m_h1CSC_Segm_TimeOfGoodClus_Eta_EC
TH1F * m_h1CSC_Segm_TimeOfGoodClus_Eta_EC
Definition: CSCSegmValAlg.h:133
CSCSegmValAlg::m_h2CSC_Segm_QsumOfGoodClusMap_Eta_EA
TH2F * m_h2CSC_Segm_QsumOfGoodClusMap_Eta_EA
Definition: CSCSegmValAlg.h:113
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Muon::CscPrepData::time
double time() const
Returns the time.
Definition: CscPrepData.h:158
AthenaMonManager::user
@ user
Definition: AthenaMonManager.h:49
CSCSegmValAlg::m_h1CSC_Segm_NumOfGoodClus_Eta_EA
TH1F * m_h1CSC_Segm_NumOfGoodClus_Eta_EA
Definition: CSCSegmValAlg.h:121
run
Definition: run.py:1
ManagedMonitorToolBase::ATTRIB_MANAGED
@ ATTRIB_MANAGED
Definition: ManagedMonitorToolBase.h:131
CSCSegmValAlg::m_h1CSC_Segm_QsumOfGoodClus_Eta_EC
TH1F * m_h1CSC_Segm_QsumOfGoodClus_Eta_EC
Definition: CSCSegmValAlg.h:131
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
Trk::FitQuality
Class to represent and store fit qualities from track reconstruction in terms of and number of degre...
Definition: FitQuality.h:97
CSCSegmValAlg::m_h2CSC_Segm_QsumOfGoodClusMap_Phi_EA
TH2F * m_h2CSC_Segm_QsumOfGoodClusMap_Phi_EA
Definition: CSCSegmValAlg.h:135
CSCSegmValAlg::m_h1CSC_Segm_QsumOfGoodClus_Phi_EC
TH1F * m_h1CSC_Segm_QsumOfGoodClus_Phi_EC
Definition: CSCSegmValAlg.h:153
CSCSegmValAlg::m_h1CSC_Segm_TimeOfClus_Eta_EC
TH1F * m_h1CSC_Segm_TimeOfClus_Eta_EC
Definition: CSCSegmValAlg.h:132
CSCSegmValAlg::m_h1CSC_Segm_TimeOfClus_Phi_EC
TH1F * m_h1CSC_Segm_TimeOfClus_Phi_EC
Definition: CSCSegmValAlg.h:154
CscClusterStatus.h
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:902
CSCSegmValAlg::m_NClusWord
std::vector< std::string > m_NClusWord
Definition: CSCSegmValAlg.h:105
CSCSegmValAlg::m_h2CSC_Segm_TimeOfGoodClusMap_Phi_EC
TH2F * m_h2CSC_Segm_TimeOfGoodClusMap_Phi_EC
Definition: CSCSegmValAlg.h:139
Trk::MeasurementBase
Definition: MeasurementBase.h:58
CSCSegmValAlg::m_h1CSC_Segm_QsumOfClus_Eta_EC
TH1F * m_h1CSC_Segm_QsumOfClus_Eta_EC
Definition: CSCSegmValAlg.h:130
CSCSegmValAlg::m_h1CSC_Segm_QsumOfGoodClus_Eta_EA
TH1F * m_h1CSC_Segm_QsumOfGoodClus_Eta_EA
Definition: CSCSegmValAlg.h:123
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
CSCSegmValAlg::m_h1CSC_Segm_NumOfClus_Eta_EA
TH1F * m_h1CSC_Segm_NumOfClus_Eta_EA
Definition: CSCSegmValAlg.h:120
CSCSegmValAlg::m_h1CSC_Segm_NumOfGoodClus_Eta_EC
TH1F * m_h1CSC_Segm_NumOfGoodClus_Eta_EC
Definition: CSCSegmValAlg.h:129
CSCSegmValAlg::m_segmSlope
double m_segmSlope
Definition: CSCSegmValAlg.h:94
CSCSegmValAlg::m_doEvtSel
bool m_doEvtSel
Definition: CSCSegmValAlg.h:91
CSCSegmValAlg::m_h1CSC_Segm_TimeOfClus_Eta_EA
TH1F * m_h1CSC_Segm_TimeOfClus_Eta_EA
Definition: CSCSegmValAlg.h:124
CSCSegmValAlg::m_segmDetail_EC
std::unique_ptr< MonGroup > m_segmDetail_EC
Definition: CSCSegmValAlg.h:71
Muon::CscClusterOnTrack::prepRawData
virtual const CscPrepData * prepRawData() const override final
Returns the CscPrepData - is a CscPrepData in this scope.
Definition: CscClusterOnTrack.h:154
CSCSegmValAlg::fillHistograms
virtual StatusCode fillHistograms()
Histogram filling method.
Definition: CSCSegmValAlg.cxx:388
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
CSCSegmValAlg::m_h1CSC_Segm_Efficiency_Eta_EC
TH1F * m_h1CSC_Segm_Efficiency_Eta_EC
Definition: CSCSegmValAlg.h:111
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
CSCSegmValAlg::m_h2CSC_Segm_QsumOfGoodClus_PhiVsEta_EC
TH2F * m_h2CSC_Segm_QsumOfGoodClus_PhiVsEta_EC
Definition: CSCSegmValAlg.h:158
CSCSegmValAlg::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: CSCSegmValAlg.cxx:730
CSCSegmValAlg::m_segmDetail_EA
std::unique_ptr< MonGroup > m_segmDetail_EA
Definition: CSCSegmValAlg.h:70
Muon::CscClusterOnTrack
Class to represent the calibrated clusters created from CSC strips.
Definition: CscClusterOnTrack.h:47
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CSCSegmValAlg::m_h2CSC_Segm_TimeOfGoodClusMap_Phi_EA
TH2F * m_h2CSC_Segm_TimeOfGoodClusMap_Phi_EA
Definition: CSCSegmValAlg.h:138
CSCSegmValAlg::m_h1CSC_Segm_TimeOfGoodClus_Eta_EA
TH1F * m_h1CSC_Segm_TimeOfGoodClus_Eta_EA
Definition: CSCSegmValAlg.h:125
PlaneSurface.h
CSCSegmValAlg::m_h1CSC_Segm_NumOfClus_Phi_EC
TH1F * m_h1CSC_Segm_NumOfClus_Phi_EC
Definition: CSCSegmValAlg.h:150
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TH1
Definition: rootspy.cxx:268
CSCSegmValAlg::m_h1CSC_Segm_NumOfGoodClus_Phi_EA
TH1F * m_h1CSC_Segm_NumOfGoodClus_Phi_EA
Definition: CSCSegmValAlg.h:143
Muon::CscClusterOnTrack::status
CscClusterStatus status() const
Returns Csc position measurement status flag.
Definition: CscClusterOnTrack.h:178
Trk::RIO_OnTrack::identify
virtual Identifier identify() const final
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:155
CSCSegmValAlg::m_segmOview_EA
std::unique_ptr< MonGroup > m_segmOview_EA
Definition: CSCSegmValAlg.h:72
CSCSegmValAlg::m_h2CSC_Segm_QsumOfGoodClusMap_Eta_EC
TH2F * m_h2CSC_Segm_QsumOfGoodClusMap_Eta_EC
Definition: CSCSegmValAlg.h:114
CSCSegmValAlg::m_h2CSC_Segm_TimeOfGoodClusMap_Eta_EC
TH2F * m_h2CSC_Segm_TimeOfGoodClusMap_Eta_EC
Definition: CSCSegmValAlg.h:117
Trk::FitQuality::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
Trk::FitQuality::numberDoF
int numberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as integer
Definition: FitQuality.h:60
merge.status
status
Definition: merge.py:17
Muon::MuonSegment::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
global position
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:157
LocalDirection.h
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
CSCSegmValAlg::m_h1CSC_Segm_StatOfClus_Eta_EA
TH1F * m_h1CSC_Segm_StatOfClus_Eta_EA
Definition: CSCSegmValAlg.h:119
CSCSegmValAlg::m_h1CSC_Segm_QsumOfClus_Eta_EA
TH1F * m_h1CSC_Segm_QsumOfClus_Eta_EA
Definition: CSCSegmValAlg.h:122
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
CSCSegmValAlg::m_h1CSC_Segm_TimeOfGoodClus_Phi_EC
TH1F * m_h1CSC_Segm_TimeOfGoodClus_Phi_EC
Definition: CSCSegmValAlg.h:155
Muon::CscClusterStatus
CscClusterStatus
Enum to represent the cluster status - see the specific enum values for more details.
Definition: CscClusterStatus.h:23
Trk::Segment::fitQuality
const FitQuality * fitQuality() const
return the FitQuality object, returns NULL if no FitQuality is defined
Definition: TrkEvent/TrkSegment/TrkSegment/Segment.h:160
CSCSegmValAlg::m_h2CSC_Segm_TimeOfGoodClusMap_Eta_EA
TH2F * m_h2CSC_Segm_TimeOfGoodClusMap_Eta_EA
Definition: CSCSegmValAlg.h:116
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
CSCSegmValAlg::m_h1CSC_Segm_QsumOfClus_Phi_EC
TH1F * m_h1CSC_Segm_QsumOfClus_Phi_EC
Definition: CSCSegmValAlg.h:152
CSCSegmValAlg::m_h2CSC_Segm_NumOfSegs_EC
TH2F * m_h2CSC_Segm_NumOfSegs_EC
Definition: CSCSegmValAlg.h:102
readCCLHist.float
float
Definition: readCCLHist.py:83
CSCSegmValAlg::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: CSCSegmValAlg.h:88
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
CSCSegmValAlg::m_h1CSC_Segm_QsumOfGoodClus_Phi_EA
TH1F * m_h1CSC_Segm_QsumOfGoodClus_Phi_EA
Definition: CSCSegmValAlg.h:145
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
Muon::MuonSegment::globalDirection
const Amg::Vector3D & globalDirection() const
global direction
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:163
CSCSegmValAlg::m_h1CSC_Segm_NumOfClus_Eta_EC
TH1F * m_h1CSC_Segm_NumOfClus_Eta_EC
Definition: CSCSegmValAlg.h:128
CSCSegmValAlg::setCSCLayerLabels
void setCSCLayerLabels(TH1 *h, int m_side)
Definition: CSCSegmValAlg.cxx:800
Generated on Tue Jul 2 2024 21:13:17 for ATLAS Offline Software by   doxygen 1.8.18