1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
19 //-----------------------------------------------------------------------------
20 /// \class AliMUONTrackHitPattern
22 /// This class propagates tracks to trigger chambers
23 /// searching for matching trigger tracks and fired strips.
25 /// To each track, a hit pattern for trigger chambers is set.
27 /// The main method is:
28 /// * ExecuteValidation
30 /// \author Diego Stocco
31 //-----------------------------------------------------------------------------
34 #include "AliMUONTrackHitPattern.h"
36 #include "AliMUONConstants.h"
37 #include "AliMUONVDigit.h"
38 #include "AliMUONDigitMaker.h"
39 #include "AliMUONDigitStoreV1.h"
40 #include "AliMUONGeometryTransformer.h"
41 #include "AliMUONLocalTrigger.h"
42 #include "AliMUONLocalTriggerBoard.h"
43 #include "AliMUONRecoParam.h"
44 #include "AliMUONTrack.h"
45 #include "AliMUONTrackExtrap.h"
46 #include "AliMUONTrackParam.h"
47 #include "AliMUONVTrackStore.h"
48 #include "AliMUONVTriggerStore.h"
50 #include "AliMpSegmentation.h"
51 #include "AliMpVSegmentation.h"
52 #include "AliMpDEManager.h"
53 #include "AliMUONReconstructor.h"
54 #include "AliMUONTriggerTrack.h"
55 #include "AliMUONVTriggerTrackStore.h"
57 #include "AliMpConstants.h"
60 #include "AliTracker.h"
61 #include "AliESDMuonTrack.h"
63 #include <Riostream.h>
65 #include <TClonesArray.h>
69 #include <TDirectory.h>
77 ClassImp(AliMUONTrackHitPattern) // Class implementation in ROOT context
81 //______________________________________________________________________________
82 AliMUONTrackHitPattern::AliMUONTrackHitPattern(const AliMUONRecoParam* recoParam,
83 const AliMUONGeometryTransformer& transformer,
84 const AliMUONDigitMaker& digitMaker)
86 fkRecoParam(recoParam),
87 fkTransformer(transformer),
88 fkDigitMaker(digitMaker),
93 /// Default constructor
95 AliMUONTrackExtrap::SetField();
99 //______________________________________________________________________________
100 AliMUONTrackHitPattern::~AliMUONTrackHitPattern(void)
103 delete fTrigCovariance;
107 //______________________________________________________________________________
108 void AliMUONTrackHitPattern::InitMembers()
111 /// Initialize data members
113 fDeltaZ = AliMUONConstants::DefaultChamberZ(10) - AliMUONConstants::DefaultChamberZ(12);
115 const Double_t kTrigNonBendReso = AliMUONConstants::TriggerNonBendingReso();
116 const Double_t kTrigBendReso = AliMUONConstants::TriggerBendingReso();
118 // Covariance matrix 3x3 (X,Y,slopeY) for trigger tracks
119 fTrigCovariance = new TMatrixD(3,3);
120 fTrigCovariance->Zero();
121 (*fTrigCovariance)(0,0) = kTrigNonBendReso * kTrigNonBendReso;
122 (*fTrigCovariance)(1,1) = kTrigBendReso * kTrigBendReso;
123 (*fTrigCovariance)(2,2) = 2. * (*fTrigCovariance)(1,1) / fDeltaZ / fDeltaZ;
124 (*fTrigCovariance)(1,2) = (*fTrigCovariance)(2,1) = (*fTrigCovariance)(1,1) / fDeltaZ;
128 //_____________________________________________________________________________
129 void AliMUONTrackHitPattern::CheckConstants() const
131 /// Check consistence of redefined constants
133 assert(fgkNcathodes == AliMpConstants::NofCathodes());
134 assert(fgkNchambers == AliMpConstants::NofTriggerChambers());
135 assert(fgkNplanes == AliMpConstants::NofTriggerChambers() * fgkNcathodes);
139 //______________________________________________________________________________
140 void AliMUONTrackHitPattern::ExecuteValidation(const AliMUONVTrackStore& trackStore,
141 const AliMUONVTriggerTrackStore& triggerTrackStore,
142 const AliMUONVTriggerStore& triggerStore) const
146 /// Loops on reco tracks, extrapolates them to trigger chambers
147 /// and searches for matching trigger tracks and digits
150 AliMUONDigitStoreV1 digitStore;
151 fkDigitMaker.TriggerToDigitsStore(triggerStore,digitStore);
153 // Get the hit pattern for all trigger tracks
154 AliMUONTriggerTrack* triggerTrack;
155 TIter itTriggerTrack(triggerTrackStore.CreateIterator());
156 while ( ( triggerTrack = static_cast<AliMUONTriggerTrack*>(itTriggerTrack() ) ) ){
157 UShort_t pattern = GetHitPattern(triggerTrack, digitStore);
158 triggerTrack->SetHitsPatternInTrigCh(pattern);
159 AliDebug(1, Form("Hit pattern: hits 0x%x slat %2i board %3i effFlag %i",
160 pattern & 0xFF, AliESDMuonTrack::GetSlatOrInfo(pattern),
161 triggerTrack->GetLoTrgNum(), AliESDMuonTrack::GetEffFlag(pattern)));
164 // Match tracker tracks with trigger tracks.
165 TIter itTrack(trackStore.CreateIterator());
168 const Int_t kFirstTrigCh = AliMUONConstants::NTrackingCh();
170 while ( ( track = static_cast<AliMUONTrack*>(itTrack()) ) )
172 AliMUONTrackParam trackParam(*((AliMUONTrackParam*) (track->GetTrackParamAtCluster()->Last())));
174 ApplyMCSCorrections(trackParam);
175 AliMUONTrackExtrap::ExtrapToZCov(&trackParam, AliMUONConstants::DefaultChamberZ(kFirstTrigCh)); // extrap to 1st trigger chamber
177 AliMUONTriggerTrack *matchedTriggerTrack = MatchTriggerTrack(track, trackParam, triggerTrackStore, triggerStore);
179 // Copy trigger tracks hit pattern if there is matching,
180 // otherwise calculate the hit pattern directly from tracker track:
181 // the obtained pattern is good for check, but not good for efficiency determination.
182 UShort_t pattern = matchedTriggerTrack ?
183 matchedTriggerTrack->GetHitsPatternInTrigCh() :
184 GetHitPattern(&trackParam, digitStore);
186 track->SetHitsPatternInTrigCh(pattern);
191 //______________________________________________________________________________
192 AliMUONTriggerTrack *
193 AliMUONTrackHitPattern::MatchTriggerTrack(AliMUONTrack* track,
194 AliMUONTrackParam& trackParam,
195 const AliMUONVTriggerTrackStore& triggerTrackStore,
196 const AliMUONVTriggerStore& triggerStore) const
199 /// Match track with trigger track
202 Int_t matchTrigger = 0;
204 Double_t distTriggerTrack[3], sigma2[3];
206 Double_t chi2MatchTrigger = 0., minChi2MatchTrigger = 999.;
207 Int_t doubleMatch = -1; // Check if track matches 2 trigger tracks
208 Double_t doubleChi2 = -1.;
209 AliMUONTriggerTrack* doubleTriggerTrack = 0x0;
210 AliMUONTriggerTrack* matchedTriggerTrack = 0x0;
212 const TMatrixD& kParamCov = trackParam.GetCovariances();
214 Double_t xTrack = trackParam.GetNonBendingCoor();
215 Double_t yTrack = trackParam.GetBendingCoor();
216 Double_t ySlopeTrack = trackParam.GetBendingSlope();
218 // Covariance matrix 3x3 (X,Y,slopeY) for tracker tracks
219 TMatrixD trackCov(3,3);
221 trackCov(0,0) = kParamCov(0,0);
222 trackCov(1,1) = kParamCov(2,2);
223 trackCov(2,2) = kParamCov(3,3);
224 trackCov(1,2) = kParamCov(2,3);
225 trackCov(2,1) = kParamCov(3,2);
227 TMatrixD sumCov(trackCov,TMatrixD::kPlus,*fTrigCovariance);
229 Bool_t isCovOK = kTRUE;
231 if (sumCov.Determinant() != 0) {
234 AliWarning(" Determinant = 0");
236 sigma2[0] = kParamCov(0,0);
237 sigma2[1] = kParamCov(2,2);
238 sigma2[2] = kParamCov(3,3);
239 // sigma of distributions (trigger-track) X,Y,slopeY
240 const Double_t kDistSigma[3]={AliMUONConstants::TriggerNonBendingReso(),
241 AliMUONConstants::TriggerBendingReso(),
242 1.414 * AliMUONConstants::TriggerBendingReso()/fDeltaZ};
243 for (Int_t iVar = 0; iVar < 3; iVar++) sigma2[iVar] += kDistSigma[iVar] * kDistSigma[iVar];
246 AliMUONTriggerTrack *triggerTrack;
247 TIter itTriggerTrack(triggerTrackStore.CreateIterator());
248 while ( ( triggerTrack = static_cast<AliMUONTriggerTrack*>(itTriggerTrack() ) ) )
250 distTriggerTrack[0] = triggerTrack->GetX11() - xTrack;
251 distTriggerTrack[1] = triggerTrack->GetY11() - yTrack;
252 distTriggerTrack[2] = TMath::Tan(triggerTrack->GetThetay()) - ySlopeTrack;
255 TMatrixD paramDiff(3,1);
256 for(Int_t iVar = 0; iVar < 3; iVar++)
257 paramDiff(iVar,0) = distTriggerTrack[iVar];
259 TMatrixD tmp(sumCov,TMatrixD::kMult,paramDiff);
260 TMatrixD chi2M(paramDiff,TMatrixD::kTransposeMult,tmp);
265 for (Int_t iVar = 0; iVar < 3; iVar++) chi2 += distTriggerTrack[iVar]*distTriggerTrack[iVar]/sigma2[iVar];
268 chi2 /= 3.; // Normalized Chi2: 3 degrees of freedom (X,Y,slopeY)
269 if (chi2 < GetRecoParam()->GetMaxNormChi2MatchTrigger())
271 Bool_t isDoubleTrack = (TMath::Abs(chi2 - minChi2MatchTrigger)<1.);
272 if (chi2 < minChi2MatchTrigger && chi2 < GetRecoParam()->GetMaxNormChi2MatchTrigger())
276 doubleMatch = loTrgNum;
277 doubleChi2 = chi2MatchTrigger;
278 doubleTriggerTrack = matchedTriggerTrack;
280 minChi2MatchTrigger = chi2;
281 chi2MatchTrigger = chi2;
282 loTrgNum = triggerTrack->GetLoTrgNum();
283 matchedTriggerTrack = triggerTrack;
284 AliMUONLocalTrigger* locTrg = triggerStore.FindLocal(loTrgNum);
286 if(locTrg->LoLpt()>0) matchTrigger = 2;
287 if(locTrg->LoHpt()>0) matchTrigger = 3;
289 else if(isDoubleTrack)
291 doubleMatch = triggerTrack->GetLoTrgNum();
297 { // If two trigger tracks match, select the one passing more trigger cuts
298 AliDebug(1, Form("Two candidates found: %i and %i",loTrgNum,doubleMatch));
299 AliMUONLocalTrigger* locTrg1 = triggerStore.FindLocal(doubleMatch);
300 if((locTrg1->LoLpt()>0 && matchTrigger<2) || (locTrg1->LoHpt() && matchTrigger<3))
302 if(locTrg1->LoHpt()>0) matchTrigger=3;
303 else matchTrigger = 2;
304 loTrgNum = doubleMatch;
305 chi2MatchTrigger = doubleChi2;
306 matchedTriggerTrack = doubleTriggerTrack;
310 track->SetMatchTrigger(matchTrigger);
311 track->SetLoTrgNum(loTrgNum);
312 track->SetChi2MatchTrigger(chi2MatchTrigger);
314 AliMUONLocalTrigger* locTrg = static_cast<AliMUONLocalTrigger*>(triggerStore.FindLocal(loTrgNum));
318 Int_t deviation = locTrg->GetDeviation();
319 track->SetLocalTrigger(locTrg->LoCircuit(),
327 return matchedTriggerTrack;
331 //______________________________________________________________________________
332 UShort_t AliMUONTrackHitPattern::GetHitPattern(AliMUONTriggerTrack* matchedTriggerTrack,
333 AliMUONVDigitStore& digitStore) const
336 /// Get hit pattern on trigger chambers for the current trigger track
338 UShort_t pattern = 0;
339 PerformTrigTrackMatch(pattern, matchedTriggerTrack, digitStore);
344 //______________________________________________________________________________
345 UShort_t AliMUONTrackHitPattern::GetHitPattern(AliMUONTrackParam* trackParam,
346 AliMUONVDigitStore& digitStore) const
349 /// Get hit pattern on trigger chambers for the current tracker track
351 UShort_t pattern = 0;
353 const Int_t kNTrackingCh = AliMUONConstants::NTrackingCh();
355 for(Int_t ch=0; ch<4; ++ch)
357 Int_t iChamber = kNTrackingCh+ch;
358 AliMUONTrackExtrap::ExtrapToZCov(trackParam, AliMUONConstants::DefaultChamberZ(iChamber));
359 FindPadMatchingTrack(digitStore, *trackParam, isMatch, iChamber);
360 for(Int_t cath=0; cath<2; ++cath)
362 if(isMatch[cath]) AliESDMuonTrack::SetFiredChamber(pattern, cath, ch);
366 // pattern obtained by propagation of tracker track
367 // when it does not match the trigger.
368 AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackerTrackPattern);
373 //______________________________________________________________________________
375 AliMUONTrackHitPattern::ApplyMCSCorrections(AliMUONTrackParam& trackParam) const
378 /// Returns uncertainties on extrapolated position.
379 /// Takes into account Branson plane corrections in the iron wall.
382 const Float_t kZFilterOut = AliMUONConstants::MuonFilterZEnd();
383 const Float_t kFilterThickness = kZFilterOut-AliMUONConstants::MuonFilterZBeg(); // cm
385 AliMUONTrackExtrap::ExtrapToZCov(&trackParam, kZFilterOut); // Extrap to muon filter end
386 AliMUONTrackExtrap::AddMCSEffect(&trackParam, kFilterThickness, AliMUONConstants::MuonFilterX0()); // Add MCS effects
391 //______________________________________________________________________________
393 AliMUONTrackHitPattern::FindPadMatchingTrack(const AliMUONVDigitStore& digitStore,
394 const AliMUONTrackParam& trackParam,
395 Bool_t isMatch[2], Int_t iChamber) const
398 /// Given the tracker track position, searches for matching digits.
401 Float_t minMatchDist[2];
403 for(Int_t cath=0; cath<2; ++cath)
405 isMatch[cath]=kFALSE;
406 minMatchDist[cath]=fkMaxDistance/10.;
409 TIter next(digitStore.CreateIterator());
410 AliMUONVDigit* mDigit;
412 while ( ( mDigit = static_cast<AliMUONVDigit*>(next()) ) )
414 Int_t currDetElemId = mDigit->DetElemId();
415 Int_t currCh = AliMpDEManager::GetChamberId(currDetElemId);
416 if(currCh!=iChamber) continue;
417 Int_t cathode = mDigit->Cathode();
418 Int_t ix = mDigit->PadX();
419 Int_t iy = mDigit->PadY();
420 Float_t xpad, ypad, zpad;
421 const AliMpVSegmentation* seg = AliMpSegmentation::Instance()
422 ->GetMpSegmentation(currDetElemId,AliMp::GetCathodType(cathode));
424 AliMpPad pad = seg->PadByIndices(ix,iy,kTRUE);
425 Float_t xlocal1 = pad.GetPositionX();
426 Float_t ylocal1 = pad.GetPositionY();
427 Float_t dpx = pad.GetDimensionX();
428 Float_t dpy = pad.GetDimensionY();
430 fkTransformer.Local2Global(currDetElemId, xlocal1, ylocal1, 0, xpad, ypad, zpad);
431 Float_t matchDist = MinDistanceFromPad(xpad, ypad, zpad, dpx, dpy, trackParam);
432 if(matchDist>minMatchDist[cathode])continue;
433 isMatch[cathode] = kTRUE;
434 if(isMatch[0] && isMatch[1]) break;
435 minMatchDist[cathode] = matchDist;
440 //______________________________________________________________________________
442 AliMUONTrackHitPattern::MinDistanceFromPad(Float_t xPad, Float_t yPad, Float_t zPad,
443 Float_t dpx, Float_t dpy,
444 const AliMUONTrackParam& trackParam) const
447 /// Decides if the digit belongs to the tracker track.
450 AliMUONTrackParam trackParamAtPadZ(trackParam);
451 AliMUONTrackExtrap::ExtrapToZCov(&trackParamAtPadZ, zPad);
453 Float_t xTrackAtPad = trackParamAtPadZ.GetNonBendingCoor();
454 Float_t yTrackAtPad = trackParamAtPadZ.GetBendingCoor();
456 const Float_t kNSigma = GetRecoParam()->GetSigmaCutForTrigger();
458 const TMatrixD& kCovParam = trackParamAtPadZ.GetCovariances();
460 Float_t sigmaX = TMath::Sqrt(kCovParam(0,0));
461 Float_t sigmaY = TMath::Sqrt(kCovParam(2,2));
463 Float_t maxDistX = kNSigma * sigmaX; // in cm
464 Float_t maxDistY = kNSigma * sigmaY; // in cm
466 Float_t deltaX = TMath::Abs(xPad-xTrackAtPad)-dpx;
467 Float_t deltaY = TMath::Abs(yPad-yTrackAtPad)-dpy;
469 Float_t matchDist = fkMaxDistance;
470 if(deltaX<=maxDistX && deltaY<=maxDistY) matchDist = TMath::Max(deltaX, deltaY);
476 //_____________________________________________________________________________
477 Int_t AliMUONTrackHitPattern::FindPadMatchingTrig(const AliMUONVDigitStore& digitStore, Int_t &detElemId,
478 Float_t coor[2], Bool_t isMatch[2],
479 TArrayI nboard[2], TArrayF &zRealMatch, Float_t y11) const
482 /// Check slat and board number of digit matching trigger track
485 enum {kBending, kNonBending};
487 Float_t minMatchDist[fgkNcathodes];
488 Int_t padsInCheckArea[fgkNcathodes];
490 for(Int_t cath=0; cath<fgkNcathodes; cath++){
491 isMatch[cath] = kFALSE;
492 minMatchDist[cath] = fkMaxDistance/10.;
493 padsInCheckArea[cath] = 0;
495 Int_t iChamber = AliMpDEManager::GetChamberId(detElemId);
496 Int_t ch = iChamber-10;
497 Float_t oldDeltaZ = AliMUONConstants::DefaultChamberZ(iChamber) - AliMUONConstants::DefaultChamberZ(10);
499 Int_t iSlat = detElemId%100;
500 Int_t trigDigitBendPlane = -1;
501 Int_t foundDetElemId = detElemId;
502 Float_t foundZmatch=999.;
503 Float_t yCoorAtPadZ=999.;
505 TIter next(digitStore.CreateIterator());
506 AliMUONVDigit* mDigit;
509 while ( ( mDigit = static_cast<AliMUONVDigit*>(next()) ) )
512 Int_t currDetElemId = mDigit->DetElemId();
513 Int_t currCh = AliMpDEManager::GetChamberId(currDetElemId);
514 if(currCh!=iChamber) continue;
515 Int_t currSlat = currDetElemId%100;
516 Int_t slatDiff = TMath::Abs(currSlat-iSlat);
517 if(slatDiff>1 && slatDiff<17) continue; // Check neighbour slats
518 Int_t cathode = mDigit->Cathode();
519 Int_t ix = mDigit->PadX();
520 Int_t iy = mDigit->PadY();
521 Float_t xpad, ypad, zpad;
522 const AliMpVSegmentation* seg = AliMpSegmentation::Instance()
523 ->GetMpSegmentation(currDetElemId,AliMp::GetCathodType(cathode));
525 AliMpPad pad = seg->PadByIndices(ix,iy,kTRUE);
526 Float_t xlocal1 = pad.GetPositionX();
527 Float_t ylocal1 = pad.GetPositionY();
528 Float_t dpx = pad.GetDimensionX();
529 Float_t dpy = pad.GetDimensionY();
531 fkTransformer.Local2Global(currDetElemId, xlocal1, ylocal1, 0, xpad, ypad, zpad);
532 AliDebug(2, Form("\nDetElemId = %i Cathode = %i Pad = (%i,%i) = (%.2f,%.2f) Dim = (%.2f,%.2f) Track = (%.2f,%.2f)\n",currDetElemId,cathode,ix,iy,xpad,ypad,dpx,dpy,coor[0],coor[1]));
533 // searching track intersection with chambers (second approximation)
536 Float_t deltaZ = zpad - zRealMatch[0];
537 y = (coor[1]-y11)*deltaZ/oldDeltaZ + y11;
538 if(TMath::Abs(y-coor[1])>0.1) AliDebug(3, Form("oldDeltaZ = %7.2f newDeltaZ = %7.2f\toldY = %7.2f new y = %7.2f\n",oldDeltaZ,deltaZ,coor[1],y));
540 Float_t matchDist = PadMatchTrack(xpad, ypad, dpx, dpy, coor[0], y);
541 if(matchDist<fkMaxDistance/2.) padsInCheckArea[cathode]++;
542 if(matchDist>minMatchDist[cathode])continue;
543 isMatch[cathode] = kTRUE;
544 minMatchDist[cathode] = matchDist;
545 foundDetElemId = currDetElemId;
548 if(cathode==kBending) trigDigitBendPlane = idigit;
549 for (Int_t loc=0; loc<pad.GetNofLocations(); loc++){
550 nboard[cathode][loc] = pad.GetLocalBoardId(loc);
552 for(Int_t loc=pad.GetNofLocations(); loc<fgkNlocations; loc++){
553 nboard[cathode][loc]=-1;
557 if(isMatch[kBending] || isMatch[kNonBending]){
558 detElemId = foundDetElemId;
559 zRealMatch[ch] = foundZmatch;
560 coor[1] = yCoorAtPadZ;
563 // If track matches many pads, it is not good for effciency determination.
564 // However we still want to calculate the hit pattern.
565 for(Int_t cath=0; cath<fgkNcathodes; cath++){
566 if(padsInCheckArea[cath]>2) {
567 AliDebug(1, Form("padsInCheckArea[%i] = %i\n",cath,padsInCheckArea[cath]));
572 return trigDigitBendPlane;
575 //_____________________________________________________________________________
576 Float_t AliMUONTrackHitPattern::PadMatchTrack(Float_t xPad, Float_t yPad,
577 Float_t dpx, Float_t dpy,
578 Float_t xTrackAtPad, Float_t yTrackAtPad) const
581 /// Decides if the digit belongs to the trigger track.
584 Float_t maxDist = GetRecoParam()->GetStripCutForTrigger() * 2. * TMath::Min(dpx,dpy); // cm
585 if(maxDist<2.) maxDist = 2.;
586 Float_t maxDistCheckArea = GetRecoParam()->GetMaxStripAreaForTrigger() * 2. * TMath::Min(dpx,dpy); // cm
588 Float_t matchDist = fkMaxDistance;
590 Float_t deltaX = TMath::Abs(xPad-xTrackAtPad)-dpx;
591 Float_t deltaY = TMath::Abs(yPad-yTrackAtPad)-dpy;
592 Float_t maxDistX = maxDist;
593 Float_t maxDistY = maxDist;
595 if(deltaX<=maxDistX && deltaY<=maxDistY) matchDist = TMath::Max(deltaX, deltaY);
596 else if(deltaX<=maxDistCheckArea && deltaY<=maxDistCheckArea) matchDist = fkMaxDistance/5.;
601 //_____________________________________________________________________________
602 Int_t AliMUONTrackHitPattern::DetElemIdFromPos(Float_t x, Float_t y,
603 Int_t chamber, Int_t cathode) const
606 /// Given the (x,y) position in the chamber,
607 /// it returns the corresponding slat
610 Int_t resultingDetElemId = -1;
612 Float_t minDist = 999.;
613 for ( it.First(chamber-1); ! it.IsDone(); it.Next() ){
614 Int_t detElemId = it.CurrentDEId();
615 Int_t ich = detElemId/100-10;
616 Float_t tolerance=0.2*((Float_t)ich);
617 Float_t currDist=9999.;
619 const AliMpVSegmentation* seg =
620 AliMpSegmentation::Instance()
621 ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
624 Float_t deltax = seg->GetDimensionX();
625 Float_t deltay = seg->GetDimensionY();
626 Float_t xlocal1 = -deltax;
627 Float_t ylocal1 = -deltay;
628 Float_t xlocal2 = +deltax;
629 Float_t ylocal2 = +deltay;
630 Float_t xg01, yg01, zg1, xg02, yg02, zg2;
631 fkTransformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg01, yg01, zg1);
632 fkTransformer.Local2Global(detElemId, xlocal2, ylocal2, 0, xg02, yg02, zg2);
634 Float_t xg1 = xg01, xg2 = xg02, yg1 = yg01, yg2 = yg02;
645 if(x>=xg1-tolerance && x<=xg2+tolerance && y>=yg1-tolerance && y<=yg2+tolerance){ // takes into account errors in extrapolation
646 if(y<yg1) currDist = yg1-y;
647 else if(y>yg2) currDist = y-yg2;
648 if(currDist<minDist) {
649 resultingDetElemId = detElemId;
653 resultingDetElemId = detElemId;
656 } // loop on detElemId
657 return resultingDetElemId;
661 //_____________________________________________________________________________
662 void AliMUONTrackHitPattern::LocalBoardFromPos(Float_t x, Float_t y,
663 Int_t detElemId, Int_t cathode,
664 Int_t localBoard[4]) const
667 /// Given the (x,y) position in the chamber,
668 /// it returns the corresponding local board
671 for(Int_t loc=0; loc<fgkNlocations; loc++){
675 fkTransformer.Global2Local(detElemId, x, y, 0, xl, yl, zl);
677 const AliMpVSegmentation* seg =
678 AliMpSegmentation::Instance()
679 ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
681 AliMpPad pad = seg->PadByPosition(pos.X(),pos.Y(),kFALSE);
682 for (Int_t loc=0; loc<pad.GetNofLocations(); loc++){
683 localBoard[loc] = pad.GetLocalBoardId(loc);
689 //_____________________________________________________________________________
690 Bool_t AliMUONTrackHitPattern::PerformTrigTrackMatch(UShort_t &pattern,
691 const AliMUONTriggerTrack* matchedTrigTrack,
692 AliMUONVDigitStore& digitStore) const
695 /// It searches for matching digits around the trigger track.
698 enum {kBending, kNonBending};
700 Int_t chOrder[fgkNchambers] = {0,2,1,3};
702 TArrayF zRealMatch(fgkNchambers);
703 TArrayF correctFactor(fgkNcathodes);
705 Bool_t isMatch[fgkNcathodes];
706 for(Int_t cath=0; cath<fgkNcathodes; cath++){
707 isMatch[cath] = kFALSE;
710 TArrayF zMeanChamber(fgkNchambers);
711 for(Int_t ch=0; ch<fgkNchambers; ch++){
712 zMeanChamber[ch] = AliMUONConstants::DefaultChamberZ(10+ch);
715 TArrayI digitPerTrack(fgkNcathodes);
717 Float_t trackIntersectCh[fgkNchambers][fgkNcathodes];
719 TArrayI triggeredDigits;
720 triggeredDigits.Set(fgkNchambers);
721 triggeredDigits.Reset(-1);
723 TArrayI trigScheme[fgkNcathodes];
724 TArrayI slatThatTriggered[fgkNcathodes];
725 for(Int_t cath=0; cath<fgkNcathodes; cath++){
726 trigScheme[cath].Set(fgkNchambers);
727 slatThatTriggered[cath].Set(fgkNchambers);
730 Int_t boardThatTriggered[fgkNchambers][fgkNcathodes][fgkNlocations];
731 TArrayI nboard[fgkNcathodes];
732 for(Int_t cath=0; cath<fgkNcathodes; cath++){
733 nboard[cath].Set(fgkNlocations);
735 Int_t ineffBoard[fgkNlocations];
736 for(Int_t loc=0; loc<fgkNlocations; loc++){
737 ineffBoard[loc] = -1;
740 digitPerTrack.Reset();
741 for(Int_t ch=0; ch<fgkNchambers; ch++){
742 zRealMatch[ch] = zMeanChamber[ch];
743 for(Int_t cath=0; cath<fgkNcathodes; cath++){
744 for(Int_t loc=0; loc<fgkNlocations; loc++){
745 boardThatTriggered[ch][cath][loc]=-1;
750 for(Int_t cath=0; cath<fgkNcathodes; cath++){
751 slatThatTriggered[cath].Reset(-1);
752 trigScheme[cath].Reset();
755 Bool_t isClearEvent = kTRUE;
757 //Float_t x11 = matchedTrigTrack->GetX11();// x position (info from non-bending plane)
758 Float_t y11 = matchedTrigTrack->GetY11();// y position (info from bending plane)
759 Float_t thetaX = matchedTrigTrack->GetThetax();
760 Float_t thetaY = matchedTrigTrack->GetThetay();
762 for(Int_t ch=0; ch<fgkNchambers; ch++) { // chamber loop
763 Int_t currCh = chOrder[ch];
764 AliDebug(3, Form("zMeanChamber[%i] = %.2f\tzRealMatch[0] = %.2f\n",currCh,zMeanChamber[currCh],zRealMatch[0]));
766 for(Int_t cath=0; cath<fgkNcathodes; cath++){
767 correctFactor[cath]=1.;
769 // calculate corrections to trigger track theta
770 if(ch>=1) correctFactor[kNonBending] = zMeanChamber[0]/zRealMatch[0];// corrects x position
771 if(ch>=2) correctFactor[kBending] = (zMeanChamber[2] - zMeanChamber[0]) / (zRealMatch[2] - zRealMatch[0]);// corrects y position
773 // searching track intersection with chambers (first approximation)
774 Float_t deltaZ = zMeanChamber[currCh] - zMeanChamber[0];
775 trackIntersectCh[currCh][0] = zMeanChamber[currCh] * TMath::Tan(thetaX) * correctFactor[kNonBending];// x position (info from non-bending plane)
776 trackIntersectCh[currCh][1] = y11 + deltaZ * TMath::Tan(thetaY) * correctFactor[kBending];// y position (info from bending plane)
777 Int_t detElemIdFromTrack = DetElemIdFromPos(trackIntersectCh[currCh][0], trackIntersectCh[currCh][1], 11+currCh, 0);
778 if(detElemIdFromTrack<0) {
779 AliDebug(1, "Warning: trigger track outside trigger chamber\n");
780 isClearEvent = kFALSE;
782 // track is rejected since the extrapolated track
783 // does not match a slat (border effects)
784 AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackOutsideGeometry);
788 triggeredDigits[currCh] = FindPadMatchingTrig(digitStore, detElemIdFromTrack, trackIntersectCh[currCh], isMatch, nboard, zRealMatch, y11);
790 // if FindPadMatchingTrig = -500 => too many digits matching pad =>
791 // => Event not clear => Do not use for efficiency calculation
792 if(triggeredDigits[currCh]<-100){
793 isClearEvent = kFALSE;
794 // track is rejected since it matches many pads
795 AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackMatchesManyPads);
796 AliDebug(1, Form("Warning: track = %p (%i) matches many pads. Rejected!\n",(void *)matchedTrigTrack, detElemIdFromTrack));
799 for(Int_t cath=0; cath<fgkNcathodes; cath++){
800 if(!isMatch[cath]) continue;
801 AliESDMuonTrack::SetFiredChamber(pattern, cath, currCh);
802 digitPerTrack[cath]++;
803 trigScheme[cath][currCh]++;
804 slatThatTriggered[cath][currCh] = detElemIdFromTrack;
805 for(Int_t loc=0; loc<fgkNlocations; loc++){
806 boardThatTriggered[currCh][cath][loc] = nboard[cath][loc];
809 } // end chamber loop
811 for(Int_t cath=0; cath<fgkNcathodes; cath++){
812 if(digitPerTrack[cath]<3) {
813 isClearEvent = kFALSE;
814 // track is rejected since the number of associated
815 // digits found is less than 3.
816 AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackMatchesFewPads);
817 AliDebug(1, Form("Warning: found %i digits for trigger track cathode %i.\nRejecting event\n", digitPerTrack[cath],cath));
821 if(!isClearEvent) return kFALSE;
823 AliESDMuonTrack::EAliTriggerChPatternFlag goodForEff = AliESDMuonTrack::kBoardEff;
825 Int_t ineffSlat = -1;
826 Int_t ineffDetElId = -1;
827 Int_t firstSlat = slatThatTriggered[kBending][0]%100;
828 if(firstSlat<0) firstSlat = slatThatTriggered[kBending][1]%100;
829 Int_t firstBoard = boardThatTriggered[0][kBending][0];
830 if(firstBoard<0) firstBoard = boardThatTriggered[1][kBending][0];
831 for(Int_t ch=0; ch<fgkNchambers; ch++){
832 Bool_t isCurrChIneff = kFALSE;
833 Int_t currSlat = slatThatTriggered[kBending][ch]%100;
835 ineffDetElId = DetElemIdFromPos(trackIntersectCh[ch][0], trackIntersectCh[ch][1], 11+ch, kBending);
836 currSlat = ineffDetElId%100;
837 ineffSlat = currSlat;
838 isCurrChIneff = kTRUE;
840 if(currSlat!=firstSlat) {
841 AliESDMuonTrack::AddEffInfo(pattern,
842 AliESDMuonTrack::kCrossDifferentSlats,
843 AliESDMuonTrack::kChEff); // track crosses different slats
846 Bool_t atLeastOneLoc=kFALSE;
847 if(isCurrChIneff) LocalBoardFromPos(trackIntersectCh[ch][0], trackIntersectCh[ch][1], ineffDetElId, kBending, ineffBoard);
848 for(Int_t loc=0; loc<fgkNlocations; loc++){
849 Int_t currBoard = boardThatTriggered[ch][kBending][loc];
850 if(isCurrChIneff) currBoard = ineffBoard[loc];
851 if(currBoard==firstBoard){
856 if(!atLeastOneLoc) goodForEff = AliESDMuonTrack::kSlatEff;
857 } // end chamber loop
859 AliESDMuonTrack::AddEffInfo(pattern, firstSlat, goodForEff);