ATLAS Offline Software
CscSegmentMaker.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 #include "MuonReadoutGeometry/CscReadoutElement.h"
7 #include "MuonReadoutGeometry/MuonDetectorManager.h"
8 
9 #include "CscSegmentMaker.h"
10 #include "AthenaBaseComps/AthMsgStreamMacros.h"
11 
12 #include "GeoPrimitives/GeoPrimitives.h"
13 #include "xAODTrigMuon/TrigMuonDefs.h"
14 #include <cmath>
15 
16 
17 namespace TrigL2MuonSA {
18 
19 
20 CscSegmentMaker::CscSegmentMaker(const std::string& type, const std::string& name, const IInterface* parent)
21  : AthAlgTool(type, name, parent),
22  m_util()
23 {
24 }
25 
26 
27 StatusCode CscSegmentMaker::initialize(){
28  ATH_CHECK(m_cscregdict.retrieve());
29  ATH_CHECK(m_muDetMgrKey.initialize());
30  ATH_CHECK(m_idHelperSvc.retrieve());
31  return StatusCode::SUCCESS;
32 }
33 
34 
35 ReturnCode CscSegmentMaker::FindSuperPointCsc( const TrigL2MuonSA::CscHits &cscHits,
36  std::vector<TrigL2MuonSA::TrackPattern> &v_trackPatterns,
37  const TrigL2MuonSA::TgcFitResult &tgcFitResult,
38  const TrigL2MuonSA::MuonRoad &muroad) const
39 {
40  ATH_MSG_DEBUG( "FindSuperPointCsc" );
41  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
42  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
43 
44  if( !cscHits.empty() ){
45 
46  for (TrigL2MuonSA::TrackPattern& track : v_trackPatterns) { // loop for track candidates
47 
48  //get module hash to read
49  int hash_clusters[32]={0};
50 
51  TrigL2MuonSA::CscHits clusters[32][8];
52  for(unsigned int iclu=0; iclu<cscHits.size(); ++iclu){
53  const TrigL2MuonSA::CscHitData &cscHit = cscHits[iclu];
54 
55  //outlier or not
56  double width = (cscHit.MeasuresPhi == 0 ) ? m_max_residual_eta : m_max_residual_phi;
57  if ( width < std::abs(cscHit.Residual) ) continue;
58 
59 
60  int cathodelayer = 2*(cscHit.WireLayer-1)+ cscHit.MeasuresPhi;//cathodelayer is in [0,7]
61  int module_hash = m_cscregdict->get_hash(cscHit.StationName, cscHit.StationEta, cscHit.StationPhi);
62 
63  if(0<=module_hash && 32>module_hash){
64  clusters[module_hash][cathodelayer].push_back( cscHit );
65  hash_clusters[module_hash]=1;//set modules to read
66  }else{
67  continue;
68  }
69  }//for clusters
70 
71 
72  //decide which module to read
73  int hashSPs[2]={999,999};
74  if( getModuleSP( hashSPs, tgcFitResult, track.phiBin, muroad, hash_clusters)!=ReturnCode::FAILURE ){
75 
76  bool found_segment=false;
77  for(int ihash=0; ihash<2; ++ihash){
78  if(found_segment) break;//once a segment is found, then finish searching more
79 
80  int hashSP=hashSPs[ihash];
81  if(hashSP>32) continue;
82 
83  //making segment
84  CscSegment cscsegment, cscsegment_noip;
85  if (this->make_segment(hashSP, clusters[hashSP] , cscsegment, cscsegment_noip, muDetMgr) != ReturnCode::FAILURE ){
86  found_segment=true;
87  track.hashID_CSC = hashSP;
88 
89  xAOD::L2MuonParameters::Chamber csc = xAOD::L2MuonParameters::Chamber::CSC;
90  xAOD::L2MuonParameters::Chamber outer = xAOD::L2MuonParameters::Chamber::EndcapOuter;
91  TrigL2MuonSA::SuperPoint* superPoint = &(track.superPoints[csc]);
92  const TrigL2MuonSA::SuperPoint* outerSP = &(track.superPoints[outer]);
93  bool &large_dphidz = track.large_dPhidZ;
94  double &outerCorFactor = track.outerCorFactor;
95 
96  //tgcfitresult
97  double tgcmid1z = tgcFitResult.tgcMid1[3];
98  double tgcmid2z = tgcFitResult.tgcMid2[3];
99  double phimiddle = tgcFitResult.phi;
100  double dPhidz = tgcFitResult.dPhidZ;
101  if( 0.75e-6<std::abs(dPhidz) ) large_dphidz=true;
102  double tgcmidZ = (tgcmid1z+tgcmid2z)/2.;
103  double outerz = outerSP->Z;
104 
105  //calculate SP
106  CscSegment cscsegment_ext = segmentAtFirstLayer(hashSP, &cscsegment);
107  double phiMod = m_cscregdict->phiMod(hashSP);
108  double CSCR=cscsegment_ext.x()*std::cos(phiMod)+cscsegment_ext.y()*std::sin(phiMod);
109  double CSCZ=cscsegment_ext.z();
110  double PhiAtCsc = phimiddle/* - std::abs(CSCZ-tgcmidZ)*dPhidz*/;
111  double CSCSPR = CSCR/std::cos( m_util.calc_dphi(PhiAtCsc,phiMod) );
112 
113 
114  superPoint->Z = CSCZ;
115  superPoint->R = CSCSPR;
116  superPoint->Alin = cscsegment_ext.slopeRZ();
117  superPoint->Blin = cscsegment_ext.interceptRZ();
118  superPoint->Npoint = cscsegment_ext.nHitEta();
119  superPoint->Chi2 = cscsegment_ext.chiSquare();
120  ATH_MSG_DEBUG("CSC super point:hashID=" << hashSP
121  << ",CSCR=" << CSCSPR << ",CSCZ=" << CSCZ
122  << ",Slope=" << cscsegment_ext.slopeRZ() << ",Intercept=" << cscsegment_ext.interceptRZ()
123  << ",nHitsEta=" << cscsegment_ext.nHitEta() << ",Chi2="<< cscsegment_ext.chiSquare());
124 
125  //calculate outerSP's correction (dphidz of tgcFitResult)
126  double phiouter = phimiddle+std::abs(outerz-tgcmidZ)*dPhidz;
127  outerCorFactor = std::cos( m_util.calc_dphi(phiouter,phiMod) )/std::cos( m_util.calc_dphi(phimiddle,phiMod) );
128  ATH_MSG_DEBUG("outerCorFactor=" << outerCorFactor);
129 
130  }//if there is a segment.
131  }//ihash loop over modules in which segment will be made
132  }//if there is the module in which segment will be made.
133  }//loop over track pattern candidate
134  }//if there are clusters, then make a segment
135 
136 
137  return ReturnCode::SUCCESS;
138 }
139 
140 
141 
142 
143 ReturnCode CscSegmentMaker::make_segment(int mod_hash, TrigL2MuonSA::CscHits clusters[8],
144  CscSegment &cscsegment,
145  CscSegment &cscsegment_noip, const MuonGM::MuonDetectorManager* muDetMgr) const
146 {
147  ATH_MSG_DEBUG("################################## make_segment #####################################");
148 
149  std::vector<localCscHit> hits_loc_eta[4], hits_loc_phi[4],emp;
150  emp.clear();
151  for(int i =0;i<4;++i){
152  hits_loc_eta[i]=emp;
153  hits_loc_phi[i]=emp;
154  }
155 
156 
157 
158  Amg::Transform3D gToLocal;
159  if(m_use_geometry){
160  Identifier Id = m_idHelperSvc->cscIdHelper().channelID(m_cscregdict->stationName(mod_hash), m_cscregdict->stationEta(mod_hash),m_cscregdict->stationPhi(mod_hash),2/*chamberLayer*/, 1, 0, 1);
161  const MuonGM::CscReadoutElement *csc = muDetMgr->getCscReadoutElement(Id);
162  if (csc == NULL){
163  ATH_MSG_DEBUG( "Csc Readout Element not found ---- skip");
164  return ReturnCode::FAILURE;
165  }
166  ATH_MSG_DEBUG("CscReadoutElement");
167  gToLocal = csc->GlobalToAmdbLRSTransform();
168  }else{
169  double rotpi = (m_cscregdict->stationEta(mod_hash)>0) ? -M_PI/2. : M_PI/2.;
170  Amg::AngleAxis3D rotZamg( (-1)*(m_cscregdict->phiMod(mod_hash)), Amg::Vector3D(0,0,1));
171  Amg::AngleAxis3D rotYamg( (-1)*(m_cscregdict->actualAtanNormal(mod_hash)), Amg::Vector3D(0,1,0) );
172  Amg::AngleAxis3D rotPIamg( rotpi, Amg::Vector3D(0,0,1));
173  Amg::Translation3D translation( 0.0, 0.0, (-1)*(m_cscregdict->displacement(mod_hash)) );
174  gToLocal=translation*rotPIamg*rotYamg*rotZamg;
175  }
176 
177 
178  localCscHit ip_loc;
179  Amg::Vector3D ip_vec = gToLocal*Amg::Vector3D(0.0, 0.0, 0.0);
180  ip_loc.loc_x = ip_vec(Amg::x);
181  ip_loc.loc_y = ip_vec(Amg::y);
182  ip_loc.loc_z = ip_vec(Amg::z);
183  ip_loc.measphi = -1;
184  ip_loc.error = m_err_ip;
185  ip_loc.residual = 0.;
186  ip_loc.isIP = true;
187  ip_loc.enabled = false;
188  ip_loc.stationname = 0;
189 
190  for (unsigned int clyr=0; clyr<8; ++clyr) {
191  for (unsigned int ihit=0; ihit<clusters[clyr].size(); ++ihit) {
192 
193  TrigL2MuonSA::CscHitData &cschit = clusters[clyr][ihit];
194  double r = cschit.r;
195  double phi = cschit.phi;
196  double z = cschit.z;
197 
198  //move to local coordinate system
199  Amg::Vector3D vect(r*std::cos(phi),r*std::sin(phi),z);
200  Amg::Vector3D loc_vect = gToLocal*vect;
201 
202  //building localCscHit object
203  localCscHit loc_hit;
204  loc_hit.loc_x = loc_vect(Amg::x);
205  loc_hit.loc_y = loc_vect(Amg::y);
206  loc_hit.loc_z = loc_vect(Amg::z);
207  loc_hit.measphi=cschit.MeasuresPhi;
208  loc_hit.error = (loc_hit.measphi==0) ? m_err_eta : m_err_phi;
209  loc_hit.residual = cschit.Residual;
210  loc_hit.enabled=true;
211  loc_hit.isIP=false;
212  loc_hit.stationname=cschit.StationName;
213  ATH_MSG_DEBUG( "measphi=" << cschit.MeasuresPhi << " wirelyr=" << cschit.WireLayer << " x=" << loc_hit.loc_x << " y=" << loc_hit.loc_y << " z=" << loc_hit.loc_z << " err=" << loc_hit.error << " res=" << loc_hit.residual);
214 
215 
216  if(0==loc_hit.measphi) {
217  if(m_max_residual_eta>std::abs(loc_hit.residual)) hits_loc_eta[cschit.WireLayer-1].push_back( loc_hit );
218  }
219  if(1==loc_hit.measphi) {
220  if(m_max_residual_phi>std::abs(loc_hit.residual)) hits_loc_phi[cschit.WireLayer-1].push_back( loc_hit );
221  }
222  }//ihit
223  }//clyr
224 
225  Amg::Vector3D seg_pos_loc, seg_dir_loc,seg_pos_loc_noip, seg_dir_loc_noip;
226  int nhite=0,nhitp=0;
227  local2dSegment seg2d_eta ,seg2d_phi, seg2d_eta_noip, seg2d_phi_noip;
228 
229 
230  if( this->make_2dsegment( 0/*=measphi*/, ip_loc, hits_loc_eta, seg2d_eta, seg2d_eta_noip, nhite)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
231  if( this->make_2dsegment( 1/*=measphi*/, ip_loc, hits_loc_phi, seg2d_phi,seg2d_phi_noip, nhitp)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
232 
233 
234  ATH_MSG_DEBUG("==include IP==");
235  if( this->make_4dsegment(seg2d_eta,seg2d_phi,seg_pos_loc,seg_dir_loc)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
236  ATH_MSG_DEBUG("==exclude IP==");
237  if( this->make_4dsegment(seg2d_eta_noip,seg2d_phi_noip,seg_pos_loc_noip,seg_dir_loc_noip)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
238 
239 
240  Amg::Transform3D lToGlobal = gToLocal.inverse();
241  Amg::Vector3D seg_pos = lToGlobal*seg_pos_loc;
242  Amg::Vector3D seg_dir = lToGlobal.rotation()*seg_dir_loc;
243  Amg::Vector3D seg_pos_noip = lToGlobal*seg_pos_loc_noip;
244  Amg::Vector3D seg_dir_noip = lToGlobal.rotation()*seg_dir_loc_noip;
245 
246 
247  //building CscSegment objects
248  cscsegment.set(seg_pos,seg_dir, seg2d_eta.chi2, seg2d_phi.chi2);
249  cscsegment.setNHitEta(seg2d_eta.nhit);
250  cscsegment.setNHitPhi(seg2d_phi.nhit);
251  cscsegment_noip.set(seg_pos_noip,seg_dir_noip, seg2d_eta_noip.chi2, seg2d_phi_noip.chi2);
252  cscsegment_noip.setNHitEta(seg2d_eta_noip.nhit);
253  cscsegment_noip.setNHitPhi(seg2d_phi_noip.nhit);
254 
255 
256  return ReturnCode::SUCCESS;
257 }
258 
259 
260  ReturnCode CscSegmentMaker::make_2dsegment(int measphi, const localCscHit &ip_loc, const std::vector<localCscHit> hits_loc[4],
261  local2dSegment &seg2d,
262  local2dSegment &seg2d_ipremoved,
263  int &nhit) const
264 {
265 
266  int nohit=0;
267  std::vector<int> hit_lyr;
268  hit_lyr.clear();
269 
270  //counting layers without clusters
271  for (int i=0; i<4; ++i ){
272  if( 0==hits_loc[i].size() ) ++nohit;
273  }
274 
275  std::vector<local2dSegment> seg2d_4hitCollection,seg2d_3hitCollection;
276  seg2d_4hitCollection.clear(); seg2d_3hitCollection.clear();
277  std::vector<localCscHit> hits_loc_copy[4];
278  for (int i=0;i<4;++i) hits_loc_copy[i] = hits_loc[i];
279 
280 
281  if(0==nohit){
282 
283  if( this->make_2dseg4hit(measphi, ip_loc, hits_loc_copy, seg2d_4hitCollection, nhit)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
284  //hits already used are removed in hits_loc_copy
285  ATH_MSG_DEBUG("display hits left");
286  display_hits(hits_loc_copy);
287  if( this->make_2dseg3hit(measphi, ip_loc, hits_loc_copy, seg2d_3hitCollection, nhit)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
288 
289  } else if(1==nohit) {
290 
291  if( this->make_2dseg3hit(measphi, ip_loc, hits_loc_copy, seg2d_3hitCollection, nhit)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
292 
293  } else {
294  return ReturnCode::FAILURE;
295  }
296 
297  //select the segment nearest to tgcroad.
298  bool exist=false;
299  seg2d.residual=99999.;
300  for(unsigned int iseg4=0; iseg4< seg2d_4hitCollection.size(); ++iseg4){
301 
302  if( std::abs( seg2d_4hitCollection[iseg4].residual ) < std::abs(seg2d.residual) ){
303  seg2d=seg2d_4hitCollection[iseg4];
304  exist=true;
305  ATH_MSG_DEBUG("seg2d.residual=" << seg2d.residual);
306  }
307  }
308  for(unsigned int iseg3=0; iseg3< seg2d_3hitCollection.size(); ++iseg3){
309 
310  if( std::abs( seg2d_3hitCollection[iseg3].residual ) < std::abs(seg2d.residual) ){
311  seg2d=seg2d_3hitCollection[iseg3];
312  exist=true;
313  ATH_MSG_DEBUG("seg2d.residual=" << seg2d.residual);
314  }
315  }
316 
317  if(false==exist) return ReturnCode::FAILURE;
318 
319  if( this->fit_clusters(measphi,seg2d.localHits,seg2d_ipremoved)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
320 
321  return ReturnCode::SUCCESS;
322 
323 }
324 
325 ReturnCode CscSegmentMaker::make_2dseg4hit(int measphi, const localCscHit &ip_loc,
326  std::vector<localCscHit> hits_loc[4], //removing hits used in fit with 4 hits
327  std::vector<local2dSegment> &seg2d_4hitCollection,
328  int &nhit) const
329 {
330 
331  std::vector<localCscHit> hit_fit;
332 
333  for (unsigned int ihit0=0; ihit0<hits_loc[0].size(); ++ihit0) {
334  for (unsigned int ihit1=0; ihit1<hits_loc[1].size(); ++ihit1) {
335  for (unsigned int ihit2=0; ihit2<hits_loc[2].size(); ++ihit2) {
336  for (unsigned int ihit3=0; ihit3<hits_loc[3].size(); ++ihit3) {
337 
338  // set clusters
339  hit_fit.clear();
340  hit_fit.push_back(ip_loc);
341  hit_fit.push_back(hits_loc[0][ihit0]);
342  hit_fit.push_back(hits_loc[1][ihit1]);
343  hit_fit.push_back(hits_loc[2][ihit2]);
344  hit_fit.push_back(hits_loc[3][ihit3]);
345 
346  //segment fit
347  local2dSegment seg2d_tmp;
348  if( this->fit_clusters(measphi,hit_fit,seg2d_tmp)!=ReturnCode::SUCCESS ) continue;
349 
350 
351  if(seg2d_tmp.chi2<m_max_chisquare){
352  seg2d_tmp.localHits.push_back(hits_loc[0][ihit0]);
353  seg2d_tmp.localHits.push_back(hits_loc[1][ihit1]);
354  seg2d_tmp.localHits.push_back(hits_loc[2][ihit2]);
355  seg2d_tmp.localHits.push_back(hits_loc[3][ihit3]);
356  //disable hits
357  hits_loc[0][ihit0].enabled=false;
358  hits_loc[1][ihit1].enabled=false;
359  hits_loc[2][ihit2].enabled=false;
360  hits_loc[3][ihit3].enabled=false;
361 
362  seg2d_4hitCollection.push_back(seg2d_tmp);
363  ATH_MSG_DEBUG("4hitsegment was made");
364  }
365 
366  }
367  }
368  }
369  }//loop over all combination of 4hits
370 
371 
372  //make vector of hits left unused
373  std::vector<localCscHit> hit_loc_left[4];
374  for (unsigned int ilyr=0;ilyr<4; ++ilyr){
375  for(unsigned int ihit=0; ihit < hits_loc[ilyr].size(); ++ihit){
376 
377  if ( true==hits_loc[ilyr][ihit].enabled ){
378  hit_loc_left[ilyr].push_back(hits_loc[ilyr][ihit]);
379  }
380  }//loop over hits in layer
381  }//loop over wire layer
382 
383  for(int ilyr=0; ilyr<4; ++ilyr) hits_loc[ilyr]=hit_loc_left[ilyr];//copying "objects" of vector
384 
385  nhit=4;
386 
387  return ReturnCode::SUCCESS;
388 
389 }
390 
391 
392 ReturnCode CscSegmentMaker::make_2dseg3hit(int measphi, const localCscHit &ip_loc,
393  const std::vector<localCscHit> hits_loc[4],
394  std::vector<local2dSegment> &seg2d_3hitCollection,
395  int &nhit) const
396 {
397 
398  int empty_lyr=-1;
399  int nohit=0;
400  for (int ilyr=0; ilyr<4; ++ilyr ){
401  if( 0==hits_loc[ilyr].size() ){
402  ++nohit;
403  empty_lyr=ilyr;
404  }
405  }
406 
407  if ( 1<nohit ) return ReturnCode::SUCCESS;
408 
409  std::vector<localCscHit> hit_fit;
410 
411 
412  int hit_lyrA[4] = {1, 2, 3, 0};
413  int hit_lyrB[4] = {2, 3, 0, 1};
414  int hit_lyrC[4] = {3, 0, 1, 2};
415 
416  for(int lyrcomb=0; lyrcomb<4; ++lyrcomb){
417 
418  if(0<=empty_lyr && empty_lyr!=lyrcomb) continue;
419 
420  for (unsigned int ihitA=0; ihitA<hits_loc[hit_lyrA[lyrcomb]].size(); ++ihitA) {
421  for (unsigned int ihitB=0; ihitB<hits_loc[hit_lyrB[lyrcomb]].size(); ++ihitB) {
422  for (unsigned int ihitC=0; ihitC<hits_loc[hit_lyrC[lyrcomb]].size(); ++ihitC) {
423 
424  hit_fit.clear();
425  hit_fit.push_back(ip_loc);
426  hit_fit.push_back(hits_loc[hit_lyrA[lyrcomb]][ihitA]);
427  hit_fit.push_back(hits_loc[hit_lyrB[lyrcomb]][ihitB]);
428  hit_fit.push_back(hits_loc[hit_lyrC[lyrcomb]][ihitC]);
429 
430  //fit clusters
431  local2dSegment seg2d_tmp;
432 
433  if( this->fit_clusters(measphi,hit_fit,seg2d_tmp)!=ReturnCode::SUCCESS ) continue;//for eta
434 
435  if(seg2d_tmp.chi2<2.0*m_max_chisquare/3.0){
436  seg2d_tmp.localHits.push_back(hits_loc[hit_lyrA[lyrcomb]][ihitA]);
437  seg2d_tmp.localHits.push_back(hits_loc[hit_lyrB[lyrcomb]][ihitB]);
438  seg2d_tmp.localHits.push_back(hits_loc[hit_lyrC[lyrcomb]][ihitC]);
439  seg2d_3hitCollection.push_back(seg2d_tmp);
440  ATH_MSG_DEBUG("3hitsegment was made");
441  }
442  }
443  }
444  }
445  }//loop over layer combination
446  nhit=3;
447 
448 
449  return ReturnCode::SUCCESS;
450 }
451 
452 
453 ReturnCode CscSegmentMaker::fit_clusters(int measphi, const std::vector<localCscHit> &hits_fit, local2dSegment &seg2d) const{
454 
455 
456  double S=0.;
457  double Sx=0.;
458  double Sy=0.;
459  double aStt=0.;
460  int nhit=0;
461  int nhit_with_ip=0;
462  double Stt=0.;
463  double Syy=0.;
464  double Sxx=0.;
465  double Sxy=0.;
466  double a = 0.;
467  double b = 0.;
468  double rp=0.;
469  double rq=0.;
470  double aver_res=0.;
471 
472 
473  for (unsigned int ihit=0; ihit< hits_fit.size(); ++ihit) {
474 
475 
476  double x= hits_fit[ihit].loc_z;
477  double y= (measphi==0) ? hits_fit[ihit].loc_y : hits_fit[ihit].loc_x;
478  double err= hits_fit[ihit].error;
479  double w = 1./(err*err);
480  // ATH_MSG_DEBUG("local pos, z=" << hits_fit[ihit].loc_z << ", x,y=" << y << ", err=" << err << ", w=" << w << ", res=" << hits_fit[ihit].residual << ", measphi="<< hits_fit[ihit].measphi);
481  S += w;
482  Sx += w*x;
483  Sy += w*y;
484  if( !hits_fit[ihit].isIP ){
485  seg2d.stationname=hits_fit[ihit].stationname;
486  aver_res += w*hits_fit[ihit].residual;
487  rq += w;
488  rp += w*x;
489  ++nhit;
490  }
491  ++nhit_with_ip;
492  }//ihit
493  seg2d.zshift=rp/rq;
494 
495  seg2d.residual=aver_res/rq;
496 
497 
498  for (unsigned int ihit=0; ihit< hits_fit.size(); ++ihit) {
499 
500  double x= hits_fit[ihit].loc_z;
501  double y= (measphi==0) ? hits_fit[ihit].loc_y : hits_fit[ihit].loc_x;
502  double err = hits_fit[ihit].error;
503  double w = 1./(err*err);// (ihit==0)?0.25:100.;//
504  Stt += w*(x-Sx/S)*(x-Sx/S);
505  aStt += w*y*(x-Sx/S);
506  Sxx += w*x*x;
507  Syy += w*y*y;
508  Sxy += w*x*y;
509 
510  }//ihit
511 
512 
513 
514  if(nhit_with_ip>1){
515  a = seg2d.a = aStt/Stt;
516  b = seg2d.b = (Sy-Sx*a)/S;
517  seg2d.nhit = nhit;
518 
519  }else{
520  return ReturnCode::FAILURE;
521  }
522  seg2d.chi2 = Syy + a*a*Sxx + 2*b*a*Sx + b*b*S - 2*b*Sy - 2*a*Sxy;
523 
524  ATH_MSG_DEBUG( "fit: a=" << a << " b=" << b << " chi2=" << seg2d.chi2 );
525 
526  return ReturnCode::SUCCESS;
527 }
528 
529 
530 
531 ReturnCode CscSegmentMaker::make_4dsegment(const local2dSegment &seg2d_eta,
532  const local2dSegment &seg2d_phi,
533  Amg::Vector3D &seg_pos,
534  Amg::Vector3D &seg_dir) const
535 {
536 
537  int nhit_e=seg2d_eta.nhit;
538  int nhit_p=seg2d_phi.nhit;
539  double a_eta=seg2d_eta.a;
540  double b_eta=seg2d_eta.b;
541  double a_phi=seg2d_phi.a;
542  double b_phi=seg2d_phi.b;
543  double rzshift=seg2d_eta.zshift;
544  double phizshift=seg2d_phi.zshift;
545 
546 
547  if (nhit_e<2 || nhit_p<2 ) return ReturnCode::FAILURE;
548 
549 
550 
551  ATH_MSG_DEBUG("rzshift=" << rzshift << " phizshift=" << phizshift << " diff=" << (rzshift-phizshift)
552  << " angle=" << ( 0.5*M_PI - std::atan(a_phi) ) << " b_phi=" << b_phi /*<< " Newb_phi=" << Newb_phi*/ );
553 
554 
555  double norm = std::sqrt( a_phi*a_phi + a_eta*a_eta + 1 );
556 
557 
558 
559  seg_dir = Amg::Vector3D(a_phi/norm, a_eta/norm, 1./norm);
560  ATH_MSG_DEBUG("segdir_loc (px,py,pz)=" << "(" << seg_dir(Amg::px) << "," << seg_dir(Amg::py) << "," << seg_dir(Amg::pz) << ") a_eta="
561  << a_eta << " a_phi=" << a_phi << " chi2_eta=" << seg2d_eta.chi2 << " chi2_phi=" << seg2d_phi.chi2 );
562 
563  double aver_z=0.5*(rzshift+phizshift);
564 
565 
566  ATH_MSG_DEBUG(" new aver_z=" << aver_z );
567  seg_pos = Amg::Vector3D(seg_dir(Amg::px)*aver_z/seg_dir(Amg::pz) + b_phi, seg_dir(Amg::py)*aver_z/seg_dir(Amg::z) + b_eta, aver_z);
568 
569  ATH_MSG_DEBUG( "myseg_loc (x,y,z,px,py,pz)=(" << seg_pos(Amg::x) << "," << seg_pos(Amg::y) << "," << seg_pos(Amg::z)
570  << "," << seg_dir(Amg::px) << "," << seg_dir(Amg::py) << "," << seg_dir(Amg::pz) << ")");
571 
572  return ReturnCode::SUCCESS;
573 
574 }
575 
576 
577 
578 ReturnCode CscSegmentMaker::getModuleSP(int mod_hashes[2],
579  const TrigL2MuonSA::TgcFitResult &tgcFitResult,
580  int phibin,
581  const MuonRoad &muroad,
582  const int hash_clusters[32]) const
583 {
584  ATH_MSG_DEBUG("getModuleSP()");
585 
586 
587  for(unsigned int imod=0; imod<32;++imod){
588 
589  if( 0==hash_clusters[imod] ) continue;
590  int stationeta = m_cscregdict->stationEta(imod);
591  int side = (muroad.side) ? 1 : -1;
592  double phiMod = m_cscregdict->phiMod(imod);
593  double dphi = m_util.calc_dphi(phiMod, tgcFitResult.phi);
594  ATH_MSG_DEBUG("getModuleSP()::(phi,side) modlue:(" << phiMod << "," << stationeta << ") tgcroad:(" << tgcFitResult.phi << "," << side << ")");
595  if( std::abs(dphi)>M_PI/8. || side != stationeta) continue;
596 
597 
598  if(7!=phibin){
599 
600  if(imod<16 && phibin>7){//small normal
601  mod_hashes[0]=imod;
602  } else if( imod >=16 && phibin<7){//large normal
603  mod_hashes[0]=imod;
604  } else {//overlap
605  mod_hashes[1]=imod;
606  }
607 
608  } else if (7==phibin) {
609 
610  if(imod<16 && 1==muroad.LargeSmall ){//small normal
611  mod_hashes[0]=imod;
612  } else if( imod >=16 && 0== muroad.LargeSmall){//large normal
613  mod_hashes[0]=imod;
614  } else {//overlap
615  mod_hashes[1]=imod;
616  }
617 
618  }
619  }//for imod
620  ATH_MSG_DEBUG("getModuleSP::Normal sector=" << mod_hashes[0] << " overlap sector=" << mod_hashes[1]);
621 
622  return ReturnCode::SUCCESS;
623 
624 
625 }
626 
627 
628 CscSegment CscSegmentMaker::segmentAtFirstLayer(int mod_hash, TrigL2MuonSA::CscSegment *mu_seg) const{
629 
630 
631  double alpha = m_cscregdict->displacement(mod_hash);
632  Amg::Vector3D n = m_cscregdict->nomalVector(mod_hash);
633  double a0=mu_seg->px(), a1=mu_seg->py(), a2=mu_seg->pz();
634  double b0=mu_seg->x(), b1=mu_seg->y(),b2=mu_seg->z();
635  double t = ( alpha-(n(0)*b0+n(1)*b1+n(2)*b2) )/( n(0)*a0+n(1)*a1+n(2)*a2 );
636  double x0=a0*t+b0,x1=a1*t+b1,x2=a2*t+b2;
637  double chisquare=mu_seg->chiSquare();
638  double chisquare_phi=mu_seg->chiSquarePhi();
639 
640  CscSegment cscsegment;
641  cscsegment.set(x0,x1,x2,a0,a1,a2,chisquare, chisquare_phi);
642  cscsegment.setNHitEta(mu_seg->nHitEta());
643  cscsegment.setNHitPhi(mu_seg->nHitPhi());
644 
645  return cscsegment;
646 }
647 
648 
649 
650 ReturnCode CscSegmentMaker::display_hits(const std::vector<localCscHit> localHits[4]) const
651 {
652  for(unsigned int ilyr=0; ilyr<4; ++ilyr){
653  for (unsigned int ihit=0; ihit<localHits[ilyr].size(); ++ihit) {
654  const localCscHit &locHit = localHits[ilyr][ihit];
655  ATH_MSG_DEBUG("measphi=" << locHit.measphi << " wirelyr=" << ilyr+1
656  << " x=" << locHit.loc_x << " y=" << locHit.loc_y << " z=" << locHit.loc_z
657  << " err=" << locHit.error << " res=" << locHit.residual);
658  }
659  }
660 
661  return ReturnCode::SUCCESS;
662 }
663 
664 
665 
666 CscSegment::CscSegment(){
667 
668  m_x=0.;
669  m_y=0.;
670  m_z=0.;
671  m_px=0.;
672  m_py=0.;
673  m_pz=0.;
674  m_slopeRZ=0.;
675  m_interceptRZ=0.;
676  m_nhit_eta=0;
677  m_nhit_phi=0;
678  m_chisquare=0.;
679  m_chisquare_phi=0.;
680 }
681 
682 ReturnCode CscSegment::set(double x, double y, double z, double px, double py, double pz, double chisquare, double chisquare_phi)
683 {
684 
685  m_x=x;
686  m_y=y;
687  m_z=z;
688  m_px=px;
689  m_py=py;
690  m_pz=pz;
691  double r = std::sqrt( x*x + y*y );
692  m_slopeRZ = ( px*x+py*y )/( r*pz );
693  m_interceptRZ = r - slopeRZ()*z;
694  m_chisquare = chisquare;
695  m_chisquare_phi = chisquare_phi;
696 
697  return ReturnCode::SUCCESS;
698 
699 }
700 
701 ReturnCode CscSegment::set( Amg::Vector3D &seg_pos, Amg::Vector3D &seg_dir, double chisquare, double chisquare_phi)
702 {
703 
704  m_x = seg_pos(Amg::x);
705  m_y = seg_pos(Amg::y);
706  m_z = seg_pos(Amg::z);
707  m_px = seg_dir(Amg::px);
708  m_py = seg_dir(Amg::py);
709  m_pz = seg_dir(Amg::pz);
710  double r = std::sqrt( x()*x() + y()*y() );
711  m_slopeRZ = ( px()*x()+py()*y() )/( r*pz() );
712  m_interceptRZ = r - slopeRZ()*z();
713  m_chisquare = chisquare;
714  m_chisquare_phi = chisquare_phi;
715 
716  return ReturnCode::SUCCESS;
717 
718 }
719 
720 
721 
722 bool CscSegment::isClean(){
723 
724  bool eta_clean=false;
725  bool phi_clean=false;
726 
727  if (m_nhit_eta>1&&m_nhit_eta<5) eta_clean = true;
728  if (m_nhit_phi>1&&m_nhit_phi<5) phi_clean = true;
729 
730  return eta_clean && phi_clean;
731 
732 }
733 
734 
735 }//namespace TrigL2MuonSA
TrigL2MuonSA::CscSegmentMaker::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: CscSegmentMaker.h:94
beamspotman.r
def r
Definition: beamspotman.py:676
TrigL2MuonSA::CscSegment::interceptRZ
double interceptRZ()
Definition: CscSegmentMaker.h:129
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
TrigL2MuonSA::CscSegment
Definition: CscSegmentMaker.h:116
TrigL2MuonSA::CscHitData
Definition: CscData.h:14
TrigL2MuonSA::ReturnCode::SUCCESS
@ SUCCESS
Definition: CscRegUtils.h:134
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
TrigL2MuonSA::CscSegmentMaker::make_2dseg4hit
ReturnCode make_2dseg4hit(int measphi, const localCscHit &ip_loc, std::vector< localCscHit > hits_loc[4], std::vector< local2dSegment > &seg2d_4hitCollection, int &nhite) const
Definition: CscSegmentMaker.cxx:325
TrigL2MuonSA::CscSegmentMaker::make_2dseg3hit
ReturnCode make_2dseg3hit(int measphi, const localCscHit &ip_loc, const std::vector< localCscHit > hits_loc[4], std::vector< local2dSegment > &seg2d_4hitCollection, int &nhit) const
Definition: CscSegmentMaker.cxx:392
TrigL2MuonSA::CscSegmentMaker::localCscHit::enabled
bool enabled
Definition: CscSegmentMaker.h:43
test_pyathena.px
px
Definition: test_pyathena.py:18
xAOD::L2MuonParameters::Chamber
Chamber
Define chamber types and locations.
Definition: TrigMuonDefs.h:15
TrigL2MuonSA::CscSegmentMaker::localCscHit::error
double error
Definition: CscSegmentMaker.h:40
TrigL2MuonSA::CscHitData::phi
double phi
Definition: CscData.h:26
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
TrigL2MuonSA::CscSegmentMaker::CscSegmentMaker
CscSegmentMaker(const std::string &type, const std::string &name, const IInterface *parent)
Definition: CscSegmentMaker.cxx:20
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
AthMsgStreamMacros.h
TrigL2MuonSA::CscSegmentMaker::make_4dsegment
ReturnCode make_4dsegment(const local2dSegment &seg2d_eta, const local2dSegment &seg2d_phi, Amg::Vector3D &seg_pos, Amg::Vector3D &seg_dir) const
Definition: CscSegmentMaker.cxx:531
TrigL2MuonSA::CscSegmentMaker::local2dSegment::a
double a
Definition: CscSegmentMaker.h:49
ClusterSeg::residual
@ residual
Definition: ClusterNtuple.h:20
TrigL2MuonSA::CscSegmentMaker::local2dSegment::nhit
int nhit
Definition: CscSegmentMaker.h:53
TrigL2MuonSA::CscSegmentMaker::localCscHit::isIP
bool isIP
Definition: CscSegmentMaker.h:45
TrigL2MuonSA::CscSegmentMaker::fit_clusters
ReturnCode fit_clusters(int measphi, const std::vector< localCscHit > &hits_fit, local2dSegment &seg2d) const
Definition: CscSegmentMaker.cxx:453
TrigL2MuonSA::CscSegmentMaker::m_err_eta
Gaudi::Property< double > m_err_eta
Definition: CscSegmentMaker.h:106
TrigL2MuonSA::CscHitData::StationEta
int StationEta
Definition: CscData.h:16
TrigL2MuonSA::ReturnCode::FAILURE
@ FAILURE
Definition: CscRegUtils.h:133
TrigL2MuonSA::CscSegmentMaker::m_max_chisquare
Gaudi::Property< double > m_max_chisquare
Definition: CscSegmentMaker.h:100
TrigL2MuonSA::TgcFitResult
Definition: TgcFitResult.h:11
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
TrigL2MuonSA::CscSegment::py
double py()
Definition: CscSegmentMaker.h:126
TrigL2MuonSA::CscSegment::nHitPhi
int nHitPhi()
Definition: CscSegmentMaker.h:135
MuonGM::MuonReadoutElement::GlobalToAmdbLRSTransform
virtual Amg::Transform3D GlobalToAmdbLRSTransform() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:153
TrigL2MuonSA::CscSegmentMaker::local2dSegment::residual
double residual
Definition: CscSegmentMaker.h:55
TrigL2MuonSA::CscHitData::StationName
unsigned int StationName
Definition: CscData.h:15
Amg::y
@ y
Definition: GeoPrimitives.h:35
TrigL2MuonSA::CscSegment::m_slopeRZ
double m_slopeRZ
Definition: CscSegmentMaker.h:144
TrigL2MuonSA::CscSegment::y
double y()
Definition: CscSegmentMaker.h:123
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TrigL2MuonSA::CscSegmentMaker::local2dSegment
Definition: CscSegmentMaker.h:48
TrigL2MuonSA::CscSegmentMaker::m_muDetMgrKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_muDetMgrKey
Definition: CscSegmentMaker.h:95
MuonGM::CscReadoutElement
Definition: CscReadoutElement.h:56
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
TrigL2MuonSA::CscHits
std::vector< CscHitData > CscHits
Definition: CscData.h:40
x
#define x
JetTiledMap::S
@ S
Definition: TiledEtaPhiMap.h:44
TrigL2MuonSA::CscSegmentMaker::FindSuperPointCsc
ReturnCode FindSuperPointCsc(const TrigL2MuonSA::CscHits &cscHits, std::vector< TrigL2MuonSA::TrackPattern > &v_trackPatterns, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MuonRoad &muroad) const
Definition: CscSegmentMaker.cxx:35
TrigL2MuonSA::CscSegment::chiSquare
double chiSquare()
Definition: CscSegmentMaker.h:130
TrigL2MuonSA::SuperPoint::Blin
float Blin
Definition: SuperPointData.h:106
TrigL2MuonSA::CscSegmentMaker::localCscHit
Definition: CscSegmentMaker.h:36
TrigL2MuonSA::SuperPoint::R
float R
Definition: SuperPointData.h:102
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
TrigL2MuonSA::MuonRoad::side
int side
Definition: MuonRoad.h:76
TrigL2MuonSA::CscHitData::StationPhi
int StationPhi
Definition: CscData.h:17
TrigL2MuonSA::TrackPattern
Definition: TrackData.h:16
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TrigL2MuonSA::CscSegment::m_chisquare
double m_chisquare
Definition: CscSegmentMaker.h:146
TrigL2MuonSA::CscSegmentMaker::m_max_residual_phi
Gaudi::Property< double > m_max_residual_phi
Definition: CscSegmentMaker.h:104
TrigL2MuonSA::CscSegment::m_px
double m_px
Definition: CscSegmentMaker.h:143
TrigL2MuonSA::CscSegment::setNHitPhi
void setNHitPhi(int nhitp)
Definition: CscSegmentMaker.h:136
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TrigL2MuonSA::CscSegmentMaker::local2dSegment::zshift
double zshift
Definition: CscSegmentMaker.h:51
TrigL2MuonSA::CscSegmentMaker::localCscHit::residual
double residual
Definition: CscSegmentMaker.h:41
GeoPrimitives.h
TrigL2MuonSA::CscSegment::m_nhit_eta
int m_nhit_eta
Definition: CscSegmentMaker.h:145
TrigL2MuonSA::CscHitData::WireLayer
int WireLayer
Definition: CscData.h:19
TrigL2MuonSA::UtilTools::calc_dphi
double calc_dphi(double phi1, double phi2) const
Definition: CscRegUtils.cxx:229
TrigL2MuonSA::CscSegmentMaker::getModuleSP
ReturnCode getModuleSP(int mod_hash[2], const TrigL2MuonSA::TgcFitResult &tgcFitResult, int phibin, const TrigL2MuonSA::MuonRoad &muroad, const int exist_clusters[32]) const
Definition: CscSegmentMaker.cxx:578
Amg::z
@ z
Definition: GeoPrimitives.h:36
TrigL2MuonSA::CscHitData::MeasuresPhi
int MeasuresPhi
Definition: CscData.h:20
TrigL2MuonSA::CscSegment::m_interceptRZ
double m_interceptRZ
Definition: CscSegmentMaker.h:144
TrigL2MuonSA::TgcFitResult::tgcMid2
float tgcMid2[4]
Definition: TgcFitResult.h:46
WriteCellNoiseToCool.exist
exist
Definition: WriteCellNoiseToCool.py:543
TrigL2MuonSA::SuperPoint::Chi2
float Chi2
Definition: SuperPointData.h:109
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:193
TrigL2MuonSA::CscSegment::z
double z()
Definition: CscSegmentMaker.h:124
lumiFormat.i
int i
Definition: lumiFormat.py:92
TrigL2MuonSA::MuonRoad
Definition: MuonRoad.h:20
z
#define z
TrigL2MuonSA::CscSegmentMaker::local2dSegment::b
double b
Definition: CscSegmentMaker.h:50
MuonGM::MuonDetectorManager::getCscReadoutElement
const CscReadoutElement * getCscReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:225
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
TrigL2MuonSA::CscSegment::m_pz
double m_pz
Definition: CscSegmentMaker.h:143
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
TrigL2MuonSA::CscSegmentMaker::m_use_geometry
Gaudi::Property< bool > m_use_geometry
Definition: CscSegmentMaker.h:98
Amg::x
@ x
Definition: GeoPrimitives.h:34
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Amg::px
@ px
Definition: GeoPrimitives.h:38
CscReadoutElement.h
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TrigL2MuonSA::CscSegment::m_nhit_phi
int m_nhit_phi
Definition: CscSegmentMaker.h:145
TrigL2MuonSA::CscSegmentMaker::m_max_residual_eta
Gaudi::Property< double > m_max_residual_eta
Definition: CscSegmentMaker.h:102
TrigL2MuonSA::CscSegmentMaker::local2dSegment::stationname
int stationname
Definition: CscSegmentMaker.h:54
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CscSegmentMaker.h
TrigL2MuonSA::TgcFitResult::tgcMid1
float tgcMid1[4]
Definition: TgcFitResult.h:45
TrigL2MuonSA::CscSegment::pz
double pz()
Definition: CscSegmentMaker.h:127
TrigL2MuonSA::CscSegment::isClean
bool isClean()
Definition: CscSegmentMaker.cxx:722
a0
double a0
Definition: globals.cxx:27
TrigL2MuonSA::CscSegment::set
ReturnCode set(double x, double y, double z, double px, double py, double pz, double chisquare, double chisquare_phi)
Definition: CscSegmentMaker.cxx:682
TrigL2MuonSA::CscSegmentMaker::m_err_phi
Gaudi::Property< double > m_err_phi
Definition: CscSegmentMaker.h:108
TrigL2MuonSA::CscSegmentMaker::local2dSegment::localHits
std::vector< localCscHit > localHits
Definition: CscSegmentMaker.h:56
TrigL2MuonSA::CscSegmentMaker::localCscHit::loc_x
double loc_x
Definition: CscSegmentMaker.h:37
TrigL2MuonSA::CscHitData::r
double r
Definition: CscData.h:27
TrigL2MuonSA::CscSegment::m_y
double m_y
Definition: CscSegmentMaker.h:143
TrigL2MuonSA::CscSegmentMaker::make_segment
ReturnCode make_segment(int mod_hash, TrigL2MuonSA::CscHits clusters[8], CscSegment &cscsegment, CscSegment &cscsegment_noip, const MuonGM::MuonDetectorManager *muDetMgr) const
Definition: CscSegmentMaker.cxx:143
TrigL2MuonSA::TgcFitResult::dPhidZ
double dPhidZ
Definition: TgcFitResult.h:71
TrigL2MuonSA::CscSegmentMaker::m_util
UtilTools m_util
Definition: CscSegmentMaker.h:91
Amg::py
@ py
Definition: GeoPrimitives.h:39
TrigL2MuonSA::CscSegment::m_z
double m_z
Definition: CscSegmentMaker.h:143
TrigL2MuonSA::CscSegment::nHitEta
int nHitEta()
Definition: CscSegmentMaker.h:133
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
TrigL2MuonSA::CscSegmentMaker::m_cscregdict
ToolHandle< CscRegDict > m_cscregdict
Definition: CscSegmentMaker.h:92
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
TrigL2MuonSA::CscHitData::z
double z
Definition: CscData.h:28
TrigL2MuonSA::CscSegmentMaker::localCscHit::measphi
int measphi
Definition: CscSegmentMaker.h:42
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TrigL2MuonSA::TgcFitResult::phi
double phi
Definition: TgcFitResult.h:70
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
TrigL2MuonSA::CscSegment::CscSegment
CscSegment()
Definition: CscSegmentMaker.cxx:666
MuonDetectorManager.h
TrigL2MuonSA::CscSegment::px
double px()
Definition: CscSegmentMaker.h:125
TrigL2MuonSA::CscSegment::setNHitEta
void setNHitEta(int nhite)
Definition: CscSegmentMaker.h:134
TrigL2MuonSA::CscSegment::m_x
double m_x
Definition: CscSegmentMaker.h:143
TrigMuonDefs.h
TrigL2MuonSA::CscSegmentMaker::initialize
virtual StatusCode initialize() override
Definition: CscSegmentMaker.cxx:27
TrigL2MuonSA::CscSegment::chiSquarePhi
double chiSquarePhi()
Definition: CscSegmentMaker.h:131
TrigL2MuonSA::MuonRoad::LargeSmall
int LargeSmall
Definition: MuonRoad.h:77
TrigL2MuonSA::CscSegmentMaker::display_hits
ReturnCode display_hits(const std::vector< localCscHit > localHits[4]) const
Definition: CscSegmentMaker.cxx:650
TrigL2MuonSA::ReturnCode
Definition: CscRegUtils.h:126
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
TrigL2MuonSA::CscSegmentMaker::make_2dsegment
ReturnCode make_2dsegment(int measphi, const localCscHit &ip_loc, const std::vector< localCscHit > hits_loc[4], local2dSegment &seg2d_eta, local2dSegment &local2d_noip, int &nhite) const
Definition: CscSegmentMaker.cxx:260
a
TList * a
Definition: liststreamerinfos.cxx:10
y
#define y
Base_Fragment.width
width
Definition: Sherpa_i/share/common/Base_Fragment.py:59
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:49
TrigL2MuonSA::SuperPoint::Npoint
int Npoint
Definition: SuperPointData.h:97
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
TrigL2MuonSA::CscSegmentMaker::segmentAtFirstLayer
CscSegment segmentAtFirstLayer(int mod_hash, TrigL2MuonSA::CscSegment *mu_seg) const
Definition: CscSegmentMaker.cxx:628
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
TrigL2MuonSA::CscSegment::m_py
double m_py
Definition: CscSegmentMaker.h:143
TrigL2MuonSA::CscSegmentMaker::local2dSegment::chi2
double chi2
Definition: CscSegmentMaker.h:52
TrigL2MuonSA::SuperPoint::Z
float Z
Definition: SuperPointData.h:103
TrigL2MuonSA::SuperPoint
Definition: SuperPointData.h:74
Amg::AngleAxis3D
Eigen::AngleAxisd AngleAxis3D
Definition: GeoPrimitives.h:45
CSC
@ CSC
Definition: RegSelEnums.h:34
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
TrigL2MuonSA::CscSegmentMaker::localCscHit::stationname
int stationname
Definition: CscSegmentMaker.h:44
TrigL2MuonSA::CscSegmentMaker::localCscHit::loc_y
double loc_y
Definition: CscSegmentMaker.h:38
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
TrigL2MuonSA::CscSegment::slopeRZ
double slopeRZ()
Definition: CscSegmentMaker.h:128
AthAlgTool
Definition: AthAlgTool.h:26
rp
ReadCards * rp
Definition: IReadCards.cxx:26
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
TrigL2MuonSA::CscSegmentMaker::localCscHit::loc_z
double loc_z
Definition: CscSegmentMaker.h:39
TrigL2MuonSA::CscHitData::Residual
double Residual
Definition: CscData.h:33
TrigL2MuonSA::CscSegment::x
double x()
Definition: CscSegmentMaker.h:122
TrigL2MuonSA::SuperPoint::Alin
float Alin
Definition: SuperPointData.h:105
xAOD::L2MuonParameters::EndcapOuter
@ EndcapOuter
Outer station in the endcap spectrometer.
Definition: TrigMuonDefs.h:21
TrigL2MuonSA::CscSegmentMaker::m_err_ip
Gaudi::Property< double > m_err_ip
Definition: CscSegmentMaker.h:110
TrigL2MuonSA::CscSegment::m_chisquare_phi
double m_chisquare_phi
Definition: CscSegmentMaker.h:147
TrigL2MuonSA
Definition: AlignmentBarrelLUT.h:13
Generated on Sun Jun 30 2024 21:13:26 for ATLAS Offline Software by   doxygen 1.8.18