ATLAS Offline Software
CSCSegmValMonAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 #include "CSCSegmValMonAlg.h"
5 
10 
11 // Track
16 
19 
20 // STL
21 #include <sstream>
22 #include <utility>
23 #include "GaudiKernel/SystemOfUnits.h"
24 
25 //________________________________________________________________________________________________________
26 CSCSegmValMonAlg::CSCSegmValMonAlg( const std::string& name, ISvcLocator* pSvcLocator ) :
27  AthMonitorAlgorithm(name,pSvcLocator)
28  { }
29 
30 
31 //________________________________________________________________________________________________________
33 
34  ATH_MSG_INFO( "in CSCSegmValMonAlg::init()" );
35  if( m_doEvtSel ) ATH_CHECK(m_trigDecTool.retrieve());
36 
37  if(m_sampSelTriggers.empty() && m_doEvtSel) {
38  ATH_MSG_WARNING("Event selection triggers not specified. Switching off trigger-aware monitoring");
39  m_doEvtSel = false;
40  }
41 
42  ATH_CHECK(m_edmHelperSvc.retrieve());
43  ATH_CHECK(m_idHelperSvc.retrieve());
44  ATH_CHECK(m_segmKey.initialize());
45 
47 }
48 
49 //
50 // fillHistograms-----------------------------------------------------------------------------------------
51 //
52 
53 StatusCode CSCSegmValMonAlg::fillHistograms(const EventContext& ctx) const{
54 
55  ATH_MSG_DEBUG( "in CSCSegmValMonAlg::fillHistograms() " );
56 
58 
59  // if required, check if event passed sample-selection triggers
60  if(m_doEvtSel && !evtSelTriggersPassed()) return StatusCode::SUCCESS;
61 
62  // Segment Cluster counter
63  int segmClustCount[33];
64 
65  // arrays to hold cluster-count
66  // 32 chambers and 8 layers (each has one extra - index '0' is not counted)
67  int clusCount[33][9];
68  for(unsigned int kl = 0; kl < 33; kl++ ) {
69  for(unsigned int cm3 = 0; cm3 < 9; cm3++ ){
70  clusCount[kl][cm3] = 0;
71  }
72  }
73 
74  for (const auto& key : m_segmKey){
76  if (!segments.isValid()) {
77  ATH_MSG_ERROR("Could not retrieve Trk::SegmentCollection "<<key.key());
78  return StatusCode::FAILURE;
79  }
80 
81  if ( segments->empty() ){
82  ATH_MSG_DEBUG( " Segm Collection is Empty, done... ");
83  return StatusCode::SUCCESS;
84  }
85 
86  ATH_MSG_DEBUG( " Segm Collection size " );
87  ATH_MSG_DEBUG( "Number of segms found: " << segments->size() );
88 
89  if(segments->size() > 0){
90  ATH_MSG_DEBUG( "Number of segms in event is: " << segments->size() );
91  ATH_MSG_DEBUG( "This algorithm is designed to operate for single segm / event only" );
92  ATH_MSG_DEBUG( "Processing only the first segm in the segm collection" );
93  }
94 
95  int layerindex = 0;
96 
97  //Loop over segms
98  for (Trk::SegmentCollection::const_iterator s = segments->begin(); s != segments->end(); ++s) {
99 
100  //Get segm
101  const Muon::MuonSegment *segm=dynamic_cast<const Muon::MuonSegment*>(*s);
102 
103  if (!segm){
104  ATH_MSG_WARNING( "no pointer to segm!!!" );
105  continue;
106  }
107 
108  ATH_MSG_DEBUG( "Looking at segment id" );
109  // Skip segment if there are no csc hits
110  if ( cscHits(segm)<1 ) continue;
111 
112  // Get contained measurements
113  const std::vector<const Trk::MeasurementBase*> meas = segm->containedMeasurements();
114 
115  // Skip segment if no measurements
116  // Number of clusters on segment
117  auto n_clust = Monitored::Scalar<int>("n_clust", meas.size());
118 
119  if ( n_clust < 2 ) continue;
120 
121  // Analyze segment if it is a csc segment
122  if ( !isCscSegment(segm) ) continue;
123 
124  // Initialize cluster counter
125  for(int sect = 0; sect < 33; sect++) {
126  segmClustCount[sect] = 0;
127  for(unsigned int ilay = 0; ilay < 9; ilay++ ){
128  clusCount[sect][ilay] = 0;
129  }
130  }
131 
132  // Print out segment information
133  const Trk::FitQuality* fq = segm->fitQuality();
134  double chi2 = 999.;
135  int ndof = -1;
136  if( fq ) {
137  chi2 = fq->chiSquared();
138  ndof = fq->numberDoF();
139  ATH_MSG_DEBUG( "Chi2 " << chi2 );
140  ATH_MSG_DEBUG( "Ndof " << ndof );
141  }
142 
143  // cut on segment angle
144  float segm_ly = segm->localParameters()[Trk::locY];
145  float segm_ayz = segm->localDirection().angleYZ();
146  segm_ayz -= M_PI/2.;
147  float segm_cut = m_segmSlope;
148  bool segmAngle_cut = segmSlopeCut(segm_ly, segm_ayz, segm_cut);
149  ATH_MSG_DEBUG(" local_pos: " << segm_ly << "\tangle_yz: " << segm_ayz << "\tcut: " << segm_cut << "\t pass = " << segmAngle_cut );
150 
151  ATH_MSG_DEBUG( "R " << segm->globalPosition().perp() );
152  ATH_MSG_DEBUG( "Z " << segm->globalPosition().z() );
153  ATH_MSG_DEBUG( "Phi " << segm->globalPosition().phi() );
154  ATH_MSG_DEBUG( "Eta " << segm->globalPosition().eta() );
155  ATH_MSG_DEBUG( "Dir Phi " << segm->globalDirection().phi() );
156  ATH_MSG_DEBUG( "Dir Eta " << segm->globalDirection().eta() );
157 
158  // ==============================================================================
159  // Field Range Notes
160  // ==============================================================================
161  // StationName unsigned integer maps to "CSS", "CSL", etc.
162  // StationEta [-1,1] -1 for backward, 1 for forward endcap
163  // StationPhi [1,8] increases with Phi
164  // Technology [1] maps to "CSC"
165  // ChamberLayer [1,2] increases with |Z|
166  // WireLayer [1,4] increases with |Z|
167  // MeasuresPhi [0,1] 0 if measures R, 1 if measures Phi
168  // Strip [1,n] increases with R for MeasuresPhi=0
169  // increases with Phi for MeasuresPhi=1
170  // ==============================================================================
171 
172  // identify the segment location
173  const Trk::MeasurementBase* rio = meas.at(0);
174  Identifier segmId = m_edmHelperSvc->getIdentifier(*rio);
175 
176  int segm_stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(segmId);
177  int segm_stationEta = m_idHelperSvc->cscIdHelper().stationEta(segmId);
178  int segm_stationName = m_idHelperSvc->cscIdHelper().stationName(segmId);
179  int segm_chamberType = m_idHelperSvc->cscIdHelper().stationNameIndex("CSS") == segm_stationName ? 0 : 1;
180  auto segm_sectorNo = Monitored::Scalar<int>("segm_sectorNo", (segm_stationEta * (2 * segm_stationPhi - segm_chamberType)) ); // [-16 -> -1] and [+1 -> +16]
181  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]
182  ATH_MSG_DEBUG(" sgsec = " << segm_isec << "\tsec = " << segm_sectorNo);
183  auto sideA = Monitored::Scalar<int>("sideA", (int) (segm_stationEta==1));
184  auto sideC = Monitored::Scalar<int>("sideC",(int)(segm_stationEta==-1));
185  fill("CscSegmMonitor",n_clust,segm_sectorNo,sideA,sideC);
186 
187  float clus_kiloele = 1.0e-3; // multiply # of electrons by this number to get kiloElectrons (1 ke = 1 ADC)
188  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
189  float eta_clus_qsum[2][5] = {{-1., 0., 0., 0., 0.}, {-1., 0., 0., 0., 0.}}, phi_clus_qsum[2][5] = {{-1., 0., 0., 0., 0.}, {-1., 0., 0., 0., 0.}}; // qsum over each prec/trans. layer on segment
190  float eta_clus_time[2][5] = {{-1., 0., 0., 0., 0.}, {-1., 0., 0., 0., 0.}}, phi_clus_time[2][5] = {{-1., 0., 0., 0., 0.}, {-1., 0., 0., 0., 0.}}; // time over each prec/trans. layer on segment
191  int eta_clus_use[2][5] = {{0, 0, 0, 0, 0 },{0, 0, 0, 0, 0}}, phi_clus_use[2][5] = {{0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}};
192 
193  layerindex = 0;
194 
195  for( auto& hit : segm->containedMeasurements()) {
196  const Muon::CscClusterOnTrack* clust_rot = dynamic_cast<const Muon::CscClusterOnTrack*>(hit);
197  if ( clust_rot ) {
198  Identifier clusId = m_edmHelperSvc->getIdentifier(*clust_rot);
199 
200  // get the cluster coordinates
201  int clus_stationName = m_idHelperSvc->cscIdHelper().stationName(clusId);
202  int clus_chamberType = m_idHelperSvc->cscIdHelper().stationNameIndex("CSS") == clus_stationName ? 0 : 1;
203  int clus_stationEta = m_idHelperSvc->cscIdHelper().stationEta(clusId);
204  int clus_stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(clusId);
205  int clus_wireLayer = m_idHelperSvc->cscIdHelper().wireLayer(clusId);
206  int clus_measuresPhi = m_idHelperSvc->cscIdHelper().measuresPhi(clusId);
207 
208  // convert to my coordinates
209  int clus_sectorNo = clus_stationEta * (2 * clus_stationPhi - clus_chamberType); // [-16 -> -1] and [+1 -> +16]
210  auto clus_secLayer = Monitored::Scalar<float>("clus_secLayer", clus_sectorNo + 0.2 * (clus_wireLayer - 1) + 0.1);
211  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]
212  int clus_ilay = (clus_measuresPhi ? clus_wireLayer : clus_wireLayer+4);
213 
214  // check the cluster status; probably need to read status info from jobOptions - not done for the moment
215  Muon::CscClusterStatus status = clust_rot->status();
216  auto status_mon = Monitored::Scalar<int>("status_mon",(int)clust_rot->status());
217  auto sideA_phi0 = Monitored::Scalar<int>("sideA_phi0",(int) (segm_stationEta==1)&& (int)(clus_measuresPhi==0));
218  auto sideC_phi0 = Monitored::Scalar<int>("sideC_phi0",(int) (segm_stationEta==-1) && (int)(clus_measuresPhi == 0));
219  auto sideA_phi = Monitored::Scalar<int>("sideA_phi", (int) (segm_stationEta==1) && (int)(clus_measuresPhi!=0));
220  auto sideC_phi = Monitored::Scalar<int>("sideC_phi", (int) (segm_stationEta==-1) && (int)(clus_measuresPhi!=0));
221 
222  fill("CscSegmMonitor",status_mon, sideA_phi0, sideC_phi0, sideA_phi, sideC_phi);
223 
224  std::string clus_stat = Muon::toString(status);
225  bool clus_status = ( (int(status)==Muon::CscStatusUnspoiled) || (int(status)==Muon::CscStatusSplitUnspoiled) || (int(status)==Muon::CscStatusSimple)) ? true : false;
226  bool clus_stat_eff = ( (int(status) >= 0 && int(status) < 8 ) || (int(status) > 8 && int(status) < 18) ) ? true : false;
227 
228  // get cluster
229  const Muon::CscPrepData* theClus = clust_rot->prepRawData();
230  float clus_qsum = 0, clus_time = -1.;
231  unsigned int clus_noStrips=0;
232  if(theClus){
233  clus_qsum = theClus->charge() * clus_kiloele;
234  clus_time = theClus->time();
235 
236  if(clus_measuresPhi == 0){
237  if(clus_stationEta == 1) eta_clus_count[0][0]++;
238  else eta_clus_count[1][0]++;
239  } else{
240  if(clus_stationEta == 1) phi_clus_count[0][0]++;
241  else phi_clus_count[1][0]++;
242  }
243  // get no. of strips per cluster
244  clus_noStrips = theClus->rdoList().size();
245  }
246 
247 
248  //need at least three strips in an eta-cluster
249  bool clus_eta_status = clus_status && ( clus_noStrips > 2 ) && (clus_measuresPhi == 0);
250  bool clus_eta_eff = clus_stat_eff && ( clus_noStrips > 2 ) && (clus_measuresPhi == 0);
251  if(clus_eta_eff){
252  if(clus_stationEta == 1) eta_clus_count[0][1]++;
253  else eta_clus_count[1][1]++;
254  }
255  if(clus_eta_status){
256  if(clus_stationEta == 1){
257  eta_clus_qsum[0][clus_wireLayer] = clus_qsum;
258  eta_clus_time[0][clus_wireLayer] = clus_time;
259  eta_clus_use[0][clus_wireLayer] = 1;
260  }
261  else{
262  eta_clus_qsum[1][clus_wireLayer] = clus_qsum;
263  eta_clus_time[1][clus_wireLayer] = clus_time;
264  eta_clus_use[1][clus_wireLayer] = 1;
265  }
266  }
267 
268  // need at least one strip in a phi-cluster
269  bool clus_phi_status = clus_status && ( clus_noStrips > 0 ) && (clus_measuresPhi == 1);
270  if(clus_phi_status) {
271  if(clus_stationEta==1){
272  phi_clus_qsum[0][clus_wireLayer] = clus_qsum;
273  phi_clus_time[0][clus_wireLayer] = clus_time;
274  phi_clus_use[0][clus_wireLayer] = 1;
275  phi_clus_count[0][1]++;
276  } else {
277  phi_clus_qsum[1][clus_wireLayer] = clus_qsum;
278  phi_clus_time[1][clus_wireLayer] = clus_time;
279  phi_clus_use[1][clus_wireLayer] = 1;
280  phi_clus_count[1][1]++;
281  }
282  }
283 
284  // increment the cluster-count for this layer
285  if(clus_eta_status || clus_phi_status) clusCount[clus_isec][clus_ilay]++;
286 
287  // increment segment cluster count
288  if(clus_eta_status) segmClustCount[clus_isec]++;
289 
290  if(clus_eta_status) layerindex+=clus_wireLayer;
291 
292  ATH_MSG_DEBUG("status = " << clus_stat << "\tcharge = " << clus_qsum << "\ttime= " << clus_time << "\tnstrips = " << clus_noStrips);
293 
294  auto clus_qsum_mon = Monitored::Scalar<float>("clus_qsum_mon",clus_qsum);
295  auto clus_time_mon = Monitored::Scalar<float>("clus_time_mon",clus_time);
296  auto checkStatusEtaA = Monitored::Scalar<int>("checkStatusEtaA", (int) (clus_eta_status && (clus_stationEta==1)));
297  auto checkStatusEtaC = Monitored::Scalar<int>("checkStatusEtaC", (int) (clus_eta_status && (clus_stationEta==-1)));
298  auto checkTimeEtaA = Monitored::Scalar<int>("checkTimeEtaA", (int) (clus_eta_status && (clus_stationEta==1) && (std::abs(clus_time) <= 200)));
299  auto checkTimeEtaC = Monitored::Scalar<int>("checkTimeEtaC", (int) (clus_eta_status && (clus_stationEta==-1) && (std::abs(clus_time) <= 200)));
300 
301  auto checkStatusPhiA = Monitored::Scalar<int>("checkStatusPhiA", (int) (clus_phi_status && (clus_stationEta==1)));
302  auto checkStatusPhiC = Monitored::Scalar<int>("checkStatusPhiC", (int) (clus_phi_status && (clus_stationEta==-1)));
303  auto checkTimePhiA = Monitored::Scalar<int>("checkTimePhiA", (int) (clus_phi_status && (clus_stationEta==1) && (std::abs(clus_time) <= 200)));
304  auto checkTimePhiC = Monitored::Scalar<int>("checkTimePhiC", (int) (clus_phi_status && (clus_stationEta==-1) && (std::abs(clus_time) <= 200)));
305  fill("CscSegmMonitor", clus_qsum_mon, clus_secLayer, clus_time_mon, checkStatusEtaA, checkStatusEtaC, checkTimeEtaA, checkTimeEtaC, checkStatusPhiA, checkStatusPhiC, checkTimePhiA, checkTimePhiC );
306 
307 
308  } // if clust_rot
309 
310  } // for loop over clusters
311 
312  auto tmp_etaClusA = Monitored::Scalar<float>("tmp_etaClusA", eta_clus_count[0][0]);
313  auto tmp_etaClusGoodA = Monitored::Scalar<float>("tmp_etaClusGoodA", eta_clus_count[0][1]);
314 
315  auto tmp_phiClusA = Monitored::Scalar<float>("tmp_phiClusA", phi_clus_count[0][0]);
316  auto tmp_phiClusGoodA = Monitored::Scalar<float>("tmp_phiClusGoodA", phi_clus_count[0][1]);
317 
318  auto checkClusEtaA = Monitored::Scalar<int>("checkClusEtaA", (int) (eta_clus_count[0][0] > 0));
319  auto checkClusEtaGoodA = Monitored::Scalar<int>("checkClusEtaGoodA", (int) (eta_clus_count[0][1] > 0));
320 
321  auto checkClusPhiA = Monitored::Scalar<int>("checkClusPhiA", (int) (phi_clus_count[0][0] > 0));
322  auto checkClusPhiGoodA = Monitored::Scalar<int>("checkClusPhiGoodA", (int) (phi_clus_count[0][1] > 0));
323 
324  auto tmp_etaClusC = Monitored::Scalar<float>("tmp_etaClusC", eta_clus_count[1][0]);
325  auto tmp_etaClusGoodC = Monitored::Scalar<float>("tmp_etaClusGoodC", eta_clus_count[1][1]);
326 
327  auto tmp_phiClusC = Monitored::Scalar<float>("tmp_phiClusC", phi_clus_count[1][0]);
328  auto tmp_phiClusGoodC = Monitored::Scalar<float>("tmp_phiClusGoodC", phi_clus_count[1][1]);
329 
330  auto checkClusEtaC = Monitored::Scalar<int>("checkClusEtaC", (int) (eta_clus_count[1][0] > 0));
331  auto checkClusEtaGoodC = Monitored::Scalar<int>("checkClusEtaGoodC", (int) (eta_clus_count[1][1] > 0));
332 
333  auto checkClusPhiC = Monitored::Scalar<int>("checkClusPhiC", (int) (phi_clus_count[1][0] > 0));
334  auto checkClusPhiGoodC = Monitored::Scalar<int>("checkClusPhiGoodC", (int) (phi_clus_count[1][1] > 0));
335 
336  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);
337 
338  // Fill number of 3 and 4 cluster segment histogram
339  std::vector<int> tmp_layerIndexA;
340  std::vector<int> tmp_isectA;
341  std::vector<int> tmp_layerIndexC;
342  std::vector<int> tmp_isectC;
343 
344  for( int isect = 1; isect < 17; isect++) {
345 
346  if(segmClustCount[isect+16] > 2 ) {
347  tmp_layerIndexA.push_back(layerindex-5);
348  tmp_isectA.push_back(isect);
349  }
350 
351  if(segmClustCount[isect+16] > 3){
352  for(int i=1; i<=4; i++) {
353  tmp_layerIndexA.push_back(i);
354  tmp_isectA.push_back(isect);
355  }
356  }
357 
358  if(segmClustCount[isect] > 2) {
359  tmp_layerIndexC.push_back(layerindex-5);
360  tmp_isectC.push_back(-1.*isect);
361  }
362 
363 
364  if(segmClustCount[isect] > 3) {
365  for(int i=1; i<=4; i++) {
366  tmp_layerIndexC.push_back(i);
367  tmp_isectC.push_back(-1.*isect);
368  }
369  }
370  }
371 
372  auto tmp_layerIndexA_mon = Monitored::Collection("tmp_layerIndexA_mon", tmp_layerIndexA);
373  auto tmp_isectA_mon = Monitored::Collection("tmp_isectA_mon", tmp_isectA);
374  auto tmp_layerIndexC_mon = Monitored::Collection("tmp_layerIndexC_mon", tmp_layerIndexC);
375  auto tmp_isectC_mon = Monitored::Collection("tmp_isectC_mon", tmp_isectC);
376  fill("CscSegmMonitor", tmp_layerIndexA_mon, tmp_isectA_mon, tmp_layerIndexC_mon, tmp_isectC_mon);
377 
378  float eta_clus_qsum_tot = 0., phi_clus_qsum_tot = 0.; // total qsum over all prec. trans. layers on segment
379 
380  for(unsigned int i=0; i < 2; i++){
381  eta_clus_qsum_tot = 0; phi_clus_qsum_tot = 0.;
382 
383  for(unsigned int j = 1; j <5; j++) {
384  if(i==0){
385  auto etaClusQSumA = Monitored::Scalar<float>("etaClusQSumA", eta_clus_qsum[i][j]);
386  auto phiClusQSumA = Monitored::Scalar<float>("phiClusQSumA", phi_clus_qsum[i][j]);
387  fill("CscSegmMonitor", etaClusQSumA, phiClusQSumA);
388 
389  if(std::abs(eta_clus_time[i][j]) <= 200) {
390  auto etaTimeClusA = Monitored::Scalar<float>("etaTimeClusA",eta_clus_time[i][j]);
391  fill("CscSegmMonitor", etaTimeClusA);
392  }
393 
394  if(std::abs(phi_clus_time[i][j]) <= 200) {
395  auto phiTimeClusA = Monitored::Scalar<float>("phiTimeClusA",phi_clus_time[i][j]);
396  fill("CscSegmMonitor", phiTimeClusA);
397  }
398  }
399 
400  if(i==1){
401  auto etaClusQSumC = Monitored::Scalar<float>("etaClusQSumC", eta_clus_qsum[i][j]);
402  auto phiClusQSumC = Monitored::Scalar<float>("phiClusQSumC", phi_clus_qsum[i][j]);
403  fill("CscSegmMonitor", etaClusQSumC, phiClusQSumC);
404 
405  if(std::abs(eta_clus_time[i][j]) <= 200) {
406  auto etaTimeClusC = Monitored::Scalar<float>("etaTimeClusC",eta_clus_time[i][j]);
407  fill("CscSegmMonitor", etaTimeClusC);
408  }
409 
410  if(std::abs(phi_clus_time[i][j]) <= 200) {
411  auto phiTimeClusC = Monitored::Scalar<float>("phiTimeClusC",phi_clus_time[i][j]);
412  fill("CscSegmMonitor", phiTimeClusC);
413  }
414  }
415 
416  if(phi_clus_use[i][j] && eta_clus_use[i][j]){
417  eta_clus_qsum_tot += eta_clus_qsum[i][j];
418  phi_clus_qsum_tot += phi_clus_qsum[i][j];
419 
420  if(i==0){
421  auto etaQSumGoodClusA = Monitored::Scalar<float>("etaQSumGoodClusA",eta_clus_qsum[i][j]);
422  auto phiQSumGoodClusA = Monitored::Scalar<float>("phiQSumGoodClusA",phi_clus_qsum[i][j]);
423  fill("CscSegmMonitor", etaQSumGoodClusA, phiQSumGoodClusA);
424  if(std::abs(eta_clus_time[i][j]) <= 200){
425  auto etaTimeGoodClusA = Monitored::Scalar<float>("etaTimeGoodClusA",eta_clus_time[i][j]);
426  fill("CscSegmMonitor", etaTimeGoodClusA);
427  }
428 
429  if(std::abs(phi_clus_time[i][j]) <= 200) {
430  auto phiTimeGoodClusA = Monitored::Scalar<float>("phiTimeGoodClusA",phi_clus_time[i][j]);
431  fill("CscSegmMonitor", phiTimeGoodClusA);
432  }
433  }
434 
435  if(i==1){
436  auto etaQSumGoodClusC = Monitored::Scalar<float>("etaQSumGoodClusC",eta_clus_qsum[i][j]);
437  auto phiQSumGoodClusC = Monitored::Scalar<float>("phiQSumGoodClusC",phi_clus_qsum[i][j]);
438  fill("CscSegmMonitor", etaQSumGoodClusC, phiQSumGoodClusC);
439  if(std::abs(eta_clus_time[i][j]) <= 200){
440  auto etaTimeGoodClusC = Monitored::Scalar<float>("etaTimeGoodClusC",eta_clus_time[i][j]);
441  fill("CscSegmMonitor", etaTimeGoodClusC);
442  }
443 
444  if(std::abs(phi_clus_time[i][j]) <= 200) {
445  auto phiTimeGoodClusC = Monitored::Scalar<float>("phiTimeGoodClusC",phi_clus_time[i][j]);
446  fill("CscSegmMonitor", phiTimeGoodClusC);
447  }
448  }
449  }
450  }
451 
452  if(i==0) {
453  auto etaQSumTotA = Monitored::Scalar<float>("etaQSumTotA", eta_clus_qsum_tot);
454  auto phiQSumTotA = Monitored::Scalar<float>("phiQSumTotA", phi_clus_qsum_tot);
455  fill("CscSegmMonitor", etaQSumTotA, phiQSumTotA);
456  }
457 
458  if(i==1) {
459  auto etaQSumTotC = Monitored::Scalar<float>("etaQSumTotC", eta_clus_qsum_tot);
460  auto phiQSumTotC = Monitored::Scalar<float>("phiQSumTotC", phi_clus_qsum_tot);
461  fill("CscSegmMonitor", etaQSumTotC, phiQSumTotC);
462  }
463  }
464  } // loop over segms
465  }
466  } // environment if
467 
468  return StatusCode::SUCCESS;
469 }
470 
471 //________________________________________________________________________________________________________
473 
474  if(!m_doEvtSel) return true;
475 
476  for (const auto& trig : m_sampSelTriggers) {
477  if(m_trigDecTool->isPassed(trig, TrigDefs::eventAccepted)) {
478  return true;
479  }
480  }
481  return false;
482 
483 } // end evtSelTriggersPassed
484 
485 //________________________________________________________________________________________________________
487  bool isCsc(false);
488 
489  std::vector<const Trk::MeasurementBase*> mbs = seg->containedMeasurements();
490  for( unsigned int i = 0; i< mbs.size(); ++i){
491 
492  const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*> (mbs[i]);
493  if (!rot){
494  const Trk::CompetingRIOsOnTrack* crot = dynamic_cast<const Trk::CompetingRIOsOnTrack*> (mbs[i]);
495  if (crot) rot = &(crot->rioOnTrack(0));
496  }
497  if( !rot ) {
498  continue;
499  }
500  if( m_idHelperSvc->isCsc( rot->identify() ) ) isCsc=true;
501  }
502 
503  return isCsc;
504 }
505 
506 
507 //________________________________________________________________________________________________________
508 unsigned int CSCSegmValMonAlg::cscHits( const Muon::MuonSegment* seg ) const {
509  unsigned int nrHits(0);
510 
511  std::vector<const Trk::MeasurementBase*> mbs = seg->containedMeasurements();
512  for( unsigned int i = 0; i< mbs.size(); ++i){
513 
514  const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*> (mbs[i]);
515  if (!rot){
516  const Trk::CompetingRIOsOnTrack* crot = dynamic_cast<const Trk::CompetingRIOsOnTrack*> (mbs[i]);
517  if (crot) rot = &(crot->rioOnTrack(0));
518  }
519  if( !rot ) {
520  continue;
521  }
522  if( m_idHelperSvc->isCsc( rot->identify() ) ) ++nrHits;
523  }
524 
525  return nrHits ;
526 }
527 
528 //________________________________________________________________________________________________________
529 bool CSCSegmValMonAlg::segmSlopeCut(const float csc_x, const float csc_ax, const float cut ) const {
530  float s0 = csc_x;
531  float s1 = -std::tan(csc_ax);
532  float s1corr = s1 - 0.000119 * s0;
533  bool good_segm = std::abs(s1corr)<cut ? true : false;
534  return good_segm;
535 }
536 
IDTPM::ndof
float ndof(const U &p)
Definition: TrackParametersHelper.h:134
ReadCellNoiseFromCoolCompare.s1
s1
Definition: ReadCellNoiseFromCoolCompare.py:378
CscStripPrepDataContainer.h
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
CompetingRIOsOnTrack.h
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:38
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
Muon::CscPrepData::charge
int charge() const
Returns the charge.
Definition: CscPrepData.h:153
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
cm3
#define cm3
M_PI
#define M_PI
Definition: ActiveFraction.h:11
CscStripPrepDataCollection.h
CSCSegmValMonAlg::isCscSegment
bool isCscSegment(const Muon::MuonSegment *seg) const
Definition: CSCSegmValMonAlg.cxx:486
Trk::PrepRawData::rdoList
const std::vector< Identifier > & rdoList() const
return the List of rdo identifiers (pointers)
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
PropDirection.h
CSCSegmValMonAlg::CSCSegmValMonAlg
CSCSegmValMonAlg(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: CSCSegmValMonAlg.cxx:26
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
CSCSegmValMonAlg::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: CSCSegmValMonAlg.cxx:53
AthMonitorAlgorithm::Environment_t::user
@ user
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
Trk::LocalDirection::angleYZ
double angleYZ() const
access method for angle of local YZ projection
Definition: LocalDirection.h:106
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
CSCSegmValMonAlg::m_edmHelperSvc
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
Definition: CSCSegmValMonAlg.h:56
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.
CSCSegmValMonAlg::cscHits
unsigned int cscHits(const Muon::MuonSegment *seg) const
Definition: CSCSegmValMonAlg.cxx:508
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
CSCSegmValMonAlg::m_doEvtSel
Gaudi::Property< bool > m_doEvtSel
Definition: CSCSegmValMonAlg.h:63
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CSCSegmValMonAlg::initialize
virtual StatusCode initialize() override
initialize
Definition: CSCSegmValMonAlg.cxx:32
CscPrepData.h
lumiFormat.i
int i
Definition: lumiFormat.py:85
Muon::CscPrepData
Class representing clusters from the CSC.
Definition: CscPrepData.h:39
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
Muon::CscStatusSimple
@ CscStatusSimple
Cluster with non-precision fit.
Definition: CscClusterStatus.h:29
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: Tracking/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:523
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
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Muon::CscPrepData::time
double time() const
Returns the time.
Definition: CscPrepData.h:158
CSCSegmValMonAlg::m_segmKey
SG::ReadHandleKeyArray< Trk::SegmentCollection > m_segmKey
Definition: CSCSegmValMonAlg.h:60
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
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
CscClusterStatus.h
CSCSegmValMonAlg::m_sampSelTriggers
Gaudi::Property< std::vector< std::string > > m_sampSelTriggers
Definition: CSCSegmValMonAlg.h:62
RPDUtils::sideA
unsigned constexpr int sideA
Definition: RPDUtils.h:16
Trk::MeasurementBase
Definition: MeasurementBase.h:58
Muon::CscStatusUnspoiled
@ CscStatusUnspoiled
Clean cluster with precision fit.
Definition: CscClusterStatus.h:26
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
CSCSegmValMonAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: CSCSegmValMonAlg.h:59
CSCSegmValMonAlg::evtSelTriggersPassed
bool evtSelTriggersPassed() const
Definition: CSCSegmValMonAlg.cxx:472
CSCSegmValMonAlg::segmSlopeCut
bool segmSlopeCut(const float csc_x, const float csc_ax, const float cut) const
Definition: CSCSegmValMonAlg.cxx:529
Muon::CscClusterOnTrack::prepRawData
virtual const CscPrepData * prepRawData() const override final
Returns the CscPrepData - is a CscPrepData in this scope.
Definition: CscClusterOnTrack.h:154
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
Muon::CscClusterOnTrack
Class to represent the calibrated clusters created from CSC strips.
Definition: CscClusterOnTrack.h:47
Muon::CscStatusSplitUnspoiled
@ CscStatusSplitUnspoiled
Clean cluster with precision fit after split cluster.
Definition: CscClusterStatus.h:59
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
PlaneSurface.h
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
Muon::CscClusterOnTrack::status
CscClusterStatus status() const
Returns Csc position measurement status flag.
Definition: CscClusterOnTrack.h:178
RPDUtils::sideC
unsigned constexpr int sideC
Definition: RPDUtils.h:15
Trk::FitQuality::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
CSCSegmValMonAlg::m_segmSlope
Gaudi::Property< double > m_segmSlope
Definition: CSCSegmValMonAlg.h:64
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
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
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: Tracking/TrkEvent/TrkSegment/TrkSegment/Segment.h:160
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
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
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
CSCSegmValMonAlg.h
Identifier
Definition: IdentifierFieldParser.cxx:14