const Double_t AliMUONConstants::fgkDefaultNonBendingReso = 0.144;
const Double_t AliMUONConstants::fgkDefaultBendingReso = 0.01;
+// Default trigger chamber resolution (cm)
+const Double_t AliMUONConstants::fgkTriggerNonBendingReso = 1.;
+const Double_t AliMUONConstants::fgkTriggerBendingReso = 1.;
+
+// Defaults parameters for muon filter (19/11/07)
+const Double_t AliMUONConstants::fgkMuonFilterZBeg = -1471.;
+const Double_t AliMUONConstants::fgkMuonFilterZEnd = -1471.-120.;
+const Double_t AliMUONConstants::fgkMuonFilterX0 = 1.76;
+
// Defaults parameters for track reconstruction
Double_t AliMUONConstants::fgChamberThicknessInX0 = 0.03;
static const Double_t DefaultBendingReso() {return fgkDefaultBendingReso;}
/// Return default chamber resolution**2 in bending direction
static const Double_t DefaultBendingReso2() {return fgkDefaultBendingReso*fgkDefaultBendingReso;}
+ /// Return default trigger chamber resolution in non bending direction
+ static const Double_t TriggerNonBendingReso() {return fgkTriggerNonBendingReso;}
+ /// Return default trigger chamber resolution in bending direction
+ static const Double_t TriggerBendingReso() {return fgkTriggerBendingReso;}
+ /// Return z-position of muon filter begining
+ static const Double_t MuonFilterZBeg() {return fgkMuonFilterZBeg;}
+ /// Return z-position of muon filter end
+ static const Double_t MuonFilterZEnd() {return fgkMuonFilterZEnd;}
+ /// Return radiation length (in cm) of muon filter
+ static const Double_t MuonFilterX0() {return fgkMuonFilterX0;}
+
protected:
/// Default constructor
static const Double_t fgkDefaultNonBendingReso; ///< default chamber resolution in the non-bending direction
static const Double_t fgkDefaultBendingReso; ///< default chamber resolution in the bending direction
+
+ static const Double_t fgkTriggerNonBendingReso; ///< default trigger chamber resolution in the non-bending direction
+ static const Double_t fgkTriggerBendingReso; ///< default trigger chamber resolution in the bending direction
+
+ static const Double_t fgkMuonFilterZBeg; ///< z-position of the begining of the muon filter
+ static const Double_t fgkMuonFilterZEnd; ///< z-position of the end of the muon filter
+ static const Double_t fgkMuonFilterX0; ///< x0 of the muon filter
ClassDef(AliMUONConstants, 0) // MUON global constants
};
fMaxBendingDistanceToTrack(0.),
fSigmaCutForTracking(0.),
fSigmaCutForImprovement(0.),
+ fSigmaCutForTrigger(0.),
fMaxNormChi2MatchTrigger(0.),
fTrackAllTracks(kFALSE),
fRecoverTracks(kFALSE),
fMaxBendingDistanceToTrack = 2.;
fSigmaCutForTracking = 6.;
fSigmaCutForImprovement = 5.;
+ fSigmaCutForTrigger = 8.;
fMaxNormChi2MatchTrigger = 16.;
fTrackAllTracks = kTRUE;
fRecoverTracks = kTRUE;
fMaxBendingDistanceToTrack = 2.;
fSigmaCutForTracking = 6.;
fSigmaCutForImprovement = 5.;
+ fSigmaCutForTrigger = 8.;
fMaxNormChi2MatchTrigger = 16.;
fTrackAllTracks = kTRUE;
fRecoverTracks = kTRUE;
cout<<Form("Maximum distance to track = (%5.2f,%5.2f)",fMaxNonBendingDistanceToTrack,fMaxBendingDistanceToTrack)<<endl;
cout<<Form("Sigma cut for tracking = %5.2f",fSigmaCutForTracking)<<endl;
+
+ cout<<Form("Sigma cut for trigger hit pattern = %5.2f",fSigmaCutForTrigger)<<endl;
if (fTrackAllTracks) cout<<"Track all the possible candidates"<<endl;
else cout<<"Track only the best candidates"<<endl;
Bool_t ImproveTracks() const {return fImproveTracks;}
/// return the cut in sigma to apply on cluster (local chi2) during track improvement
Double_t GetSigmaCutForImprovement() const {return fSigmaCutForImprovement;}
+
+ /// set the cut in sigma to apply on track during trigger hit pattern search
+ void SetSigmaCutForTrigger(Double_t val) {fSigmaCutForTrigger = val;}
+ /// return the cut in sigma to apply on track during trigger hit pattern search
+ Double_t GetSigmaCutForTrigger() const {return fSigmaCutForTrigger;}
/// set the maximum normalized chi2 of tracking/trigger track matching
void SetMaxNormChi2MatchTrigger(Double_t val) {fMaxNormChi2MatchTrigger = val;}
Double32_t fMaxBendingDistanceToTrack; ///< maximum distance to the track to search for compatible cluster(s) in bending direction
Double32_t fSigmaCutForTracking; ///< cut in sigma to apply on cluster (local chi2) and track (global chi2) during tracking
-
+
Double32_t fSigmaCutForImprovement; ///< cut in sigma to apply on cluster (local chi2) during track improvement
+ Double32_t fSigmaCutForTrigger; ///< cut in sigma to apply on track during trigger hit pattern search
+
Double32_t fMaxNormChi2MatchTrigger; ///< maximum normalized chi2 of tracking/trigger track matching
Bool_t fTrackAllTracks; ///< kTRUE to track all the possible candidates; kFALSE to track only the best ones
///
/// To each track, a hit pattern for trigger chambers is set.
/// The hit pattern is a UShort_t with 8 bits used:
-///
+/// <pre>
/// 1 1 0 1 1 1 0 1
/// | | |
/// ----------- ------------
/// chamber: 11 12 13 14 | 11 12 13 14
/// cathode: bending | non-bending
-///
+/// </pre>
/// The main method is:
/// * GetHitPattern
///
#include "AliMpPad.h"
#include "AliMpSegmentation.h"
#include "AliMpVSegmentation.h"
+#include "AliMpDEManager.h"
+#include "AliMUONReconstructor.h"
+#include "AliMUONRecoParam.h"
#include "AliMagF.h"
#include "AliLog.h"
/// Loops on reco tracks, extrapolates them to trigger chambers
/// and searches for matching digits
//
-
+
const Int_t kMask[2][4]= {{0x80, 0x40, 0x20, 0x10},
{0x08, 0x04, 0x02, 0x01}};
Bool_t isMatch[2];
AliMUONTrack* muonTrack;
TIter next(trackStore.CreateIterator());
-
+
+ const Int_t kNTrackingCh = AliMUONConstants::NTrackingCh();
+
while ( ( muonTrack = static_cast<AliMUONTrack*>(next()) ) )
{
pattern = 0;
- AliMUONTrackParam trackParam = (*(static_cast<AliMUONTrackParam*>
- (muonTrack->GetTrackParamAtCluster()->Last())));
-
+ AliMUONTrackParam trackParam(*((AliMUONTrackParam*) (muonTrack->GetTrackParamAtCluster()->Last())));
+
+ ApplyMCSCorrections(trackParam);
+
for(Int_t ch=0; ch<4; ++ch)
{
- AliMUONTrackExtrap::ExtrapToZCov(&trackParam, AliMUONConstants::DefaultChamberZ(10+ch));
- FindPadMatchingTrack(digitStore,trackParam, isMatch, ch);
+ Int_t iChamber = kNTrackingCh+ch;
+ AliMUONTrackExtrap::ExtrapToZCov(&trackParam, AliMUONConstants::DefaultChamberZ(iChamber));
+ FindPadMatchingTrack(digitStore, trackParam, isMatch, iChamber);
for(Int_t cath=0; cath<2; ++cath)
{
if(isMatch[cath]) pattern |= kMask[cath][ch];
- }
+ }
}
muonTrack->SetHitsPatternInTrigCh(pattern);
}
void
AliMUONTrackHitPattern::FindPadMatchingTrack(AliMUONVDigitStore& digitStore,
const AliMUONTrackParam& trackParam,
- Bool_t isMatch[2], Int_t /*iChamber*/) const
+ Bool_t isMatch[2], Int_t iChamber) const
{
//
/// Given track position, searches for matching digits.
TIter next(digitStore.CreateIterator());
AliMUONVDigit* mDigit;
-
+
while ( ( mDigit = static_cast<AliMUONVDigit*>(next()) ) )
{
Int_t currDetElemId = mDigit->DetElemId();
+ Int_t currCh = AliMpDEManager::GetChamberId(currDetElemId);
+ if(currCh!=iChamber) continue;
Int_t cathode = mDigit->Cathode();
Int_t ix = mDigit->PadX();
Int_t iy = mDigit->PadY();
Float_t matchDist = MinDistanceFromPad(xpad, ypad, zpad, dpx, dpy, trackParam);
if(matchDist>minMatchDist[cathode])continue;
isMatch[cathode] = kTRUE;
+ if(isMatch[0] && isMatch[1]) break;
minMatchDist[cathode] = matchDist;
}
}
//
/// Decides if the digit belongs to the track.
//
- Float_t xTrackAtPad = trackParam.GetNonBendingCoor();
- Float_t yTrackAtPad = trackParam.GetBendingCoor();
- Float_t sigmaX, sigmaY, sigmaMS;
- GetPosUncertainty(trackParam, zPad, sigmaX, sigmaY, sigmaMS);
+ AliMUONTrackParam trackParamAtPadZ(trackParam);
+ AliMUONTrackExtrap::ExtrapToZCov(&trackParamAtPadZ, zPad);
+
+ Float_t xTrackAtPad = trackParamAtPadZ.GetNonBendingCoor();
+ Float_t yTrackAtPad = trackParamAtPadZ.GetBendingCoor();
- Float_t maxDistX = 3.*(sigmaX + sigmaMS); // in cm
- Float_t maxDistY = 3.*(sigmaY + sigmaMS); // in cm
+ const Float_t kNSigma = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTrigger();
+
+ const TMatrixD& kCovParam = trackParamAtPadZ.GetCovariances();
+
+ Float_t sigmaX = TMath::Sqrt(kCovParam(0,0));
+ Float_t sigmaY = TMath::Sqrt(kCovParam(2,2));
+
+ Float_t maxDistX = kNSigma * sigmaX; // in cm
+ Float_t maxDistY = kNSigma * sigmaY; // in cm
Float_t deltaX = TMath::Abs(xPad-xTrackAtPad)-dpx;
Float_t deltaY = TMath::Abs(yPad-yTrackAtPad)-dpy;
Float_t matchDist = 99999.;
if(deltaX<=maxDistX && deltaY<=maxDistY) matchDist = TMath::Max(deltaX, deltaY);
+
return matchDist;
}
//______________________________________________________________________________
void
-AliMUONTrackHitPattern::GetPosUncertainty(const AliMUONTrackParam& trackParam,
- Float_t zChamber,
- Float_t &sigmaX, Float_t &sigmaY,
- Float_t &sigmaMS) const
+AliMUONTrackHitPattern::ApplyMCSCorrections(AliMUONTrackParam& trackParam) const
{
- //
- /// Returns uncertainties on extrapolated position.
- /// Takes into account Branson plane corrections in the iron wall.
- //
-
- const Float_t kAlpha = 0.1123; // GeV/c
-
- // Find a better way to get such parameters ???
- const Float_t kZFilterIn = 1471.; // From STRUCT/SHILConst2.h
- const Float_t kZFilterOut = kZFilterIn + 120.; // From STRUCT/SHILConst2.h
-
- const Float_t kZBranson = - (kZFilterIn + (kZFilterOut - kZFilterIn)*2./3. ); // - sign because distance are positive
- Float_t zDistFromWall = TMath::Abs(zChamber - kZBranson);
- Float_t zDistFromLastTrackCh = TMath::Abs(zChamber - AliMUONConstants::DefaultChamberZ(9));
-
- const TMatrixD& kCovParam = trackParam.GetCovariances();
-
- sigmaX = kCovParam(0,0);
- sigmaY = kCovParam(2,2);
+ //
+ /// Returns uncertainties on extrapolated position.
+ /// Takes into account Branson plane corrections in the iron wall.
+ //
- // If covariance matrix is not extrapolated, use "reasonable" errors
- // (To be removed as soon as covariance matrix is correctly propagated).
- if (sigmaX==0.)sigmaX = 0.003 * zDistFromLastTrackCh;
- if (sigmaY==0.)sigmaY = 0.004 * zDistFromLastTrackCh;
+ const Float_t kZFilterOut = AliMUONConstants::MuonFilterZEnd();
+ const Float_t kFilterThickness = TMath::Abs(kZFilterOut-AliMUONConstants::MuonFilterZBeg()); // cm
- Float_t p = trackParam.P();
- Float_t thetaMS = kAlpha/p;
- sigmaMS = zDistFromWall * TMath::Tan(thetaMS);
+ AliMUONTrackExtrap::ExtrapToZCov(&trackParam, kZFilterOut);
+ AliMUONTrackExtrap::AddMCSEffect(&trackParam, kFilterThickness, AliMUONConstants::MuonFilterX0());
+ return;
}
Float_t dpx, Float_t dpy,
const AliMUONTrackParam& trackParam) const;
- void GetPosUncertainty(const AliMUONTrackParam& trackParm, Float_t zChamber,
- Float_t &sigmaX, Float_t &sigmaY, Float_t &sigmaMS) const;
+ void ApplyMCSCorrections(AliMUONTrackParam& trackParam) const;
Bool_t TriggerDigits(const AliMUONVTriggerStore& triggerStore,
AliMUONVDigitStore& digitStore) const;
{
/// Try to match track from tracking system with trigger track
AliCodeTimerAuto("");
-
- static const Double_t kDistSigma[3]={1,1,0.02}; // sigma of distributions (trigger-track) X,Y,slopeY
-
+
+ const Double_t kDeltaZ = TMath::Abs(AliMUONConstants::DefaultChamberZ(12) - AliMUONConstants::DefaultChamberZ(10));
+
+ //static const Double_t kDistSigma[3]={1,1,0.02}; // sigma of distributions (trigger-track) X,Y,slopeY
+ // sigma of distributions (trigger-track) X,Y,slopeY
+ const Double_t kDistSigma[3]={AliMUONConstants::TriggerNonBendingReso(),
+ AliMUONConstants::TriggerBendingReso(),
+ 1.414 * AliMUONConstants::TriggerBendingReso()/kDeltaZ};
+
+ const Double_t kTrigNonBendReso = AliMUONConstants::TriggerNonBendingReso();
+ const Double_t kTrigBendReso = AliMUONConstants::TriggerBendingReso();
+ const Double_t kTrigSlopeBendReso = 1.414 * AliMUONConstants::TriggerBendingReso()/kDeltaZ;
+ const Double_t kTrigCovSlopeBend = - kTrigBendReso * kTrigBendReso / kDeltaZ;
+
+ // Covariance matrix 3x3 (X,Y,slopeY) for trigger tracks
+ TMatrixD trigCov(3,3);
+ trigCov.Zero();
+ trigCov(0,0) = kTrigNonBendReso * kTrigNonBendReso;
+ trigCov(1,1) = kTrigBendReso * kTrigBendReso;
+ trigCov(2,2) = kTrigSlopeBendReso * kTrigSlopeBendReso;
+ trigCov(1,2) = trigCov(2,1) = kTrigCovSlopeBend;
+
Int_t matchTrigger;
Int_t loTrgNum(-1);
- Double_t distTriggerTrack[3];
+ Double_t distTriggerTrack[3], sigma2[3];
Double_t xTrack, yTrack, ySlopeTrack, chi2MatchTrigger, minChi2MatchTrigger, chi2;
TIter itTrack(trackStore.CreateIterator());
AliMUONTrack* track;
+
+ const Float_t kZFilterOut = AliMUONConstants::MuonFilterZEnd();
+ const Float_t kFilterThickness = TMath::Abs(kZFilterOut-AliMUONConstants::MuonFilterZBeg()); // cm
+ const Int_t kFirstTrigCh = AliMUONConstants::NTrackingCh();
while ( ( track = static_cast<AliMUONTrack*>(itTrack()) ) )
{
Double_t doubleChi2 = -1.;
AliMUONTrackParam trackParam(*((AliMUONTrackParam*) (track->GetTrackParamAtCluster()->Last())));
- AliMUONTrackExtrap::ExtrapToZ(&trackParam, AliMUONConstants::DefaultChamberZ(10)); // extrap to 1st trigger chamber
+
+ AliMUONTrackExtrap::ExtrapToZCov(&trackParam, kZFilterOut); // Extrap to muon filter end
+ AliMUONTrackExtrap::AddMCSEffect(&trackParam, kFilterThickness, AliMUONConstants::MuonFilterX0()); // Add MCS effects
+ AliMUONTrackExtrap::ExtrapToZCov(&trackParam, AliMUONConstants::DefaultChamberZ(kFirstTrigCh)); // extrap to 1st trigger chamber
+
+ const TMatrixD& kParamCov = trackParam.GetCovariances();
xTrack = trackParam.GetNonBendingCoor();
yTrack = trackParam.GetBendingCoor();
ySlopeTrack = trackParam.GetBendingSlope();
+
+ // Covariance matrix 3x3 (X,Y,slopeY) for tracker tracks
+ TMatrixD trackCov(3,3);
+ trackCov.Zero();
+ trackCov(0,0) = kParamCov(0,0);
+ trackCov(1,1) = kParamCov(2,2);
+ trackCov(2,2) = kParamCov(3,3);
+ trackCov(1,2) = kParamCov(2,3);
+ trackCov(2,1) = kParamCov(3,2);
+
+ TMatrixD sumCov(trackCov,TMatrixD::kPlus,trigCov);
+
+ Bool_t isCovOK = kTRUE;
+
+ if (sumCov.Determinant() != 0) {
+ sumCov.Invert();
+ } else {
+ AliWarning(" Determinant = 0");
+ isCovOK = kFALSE;
+ sigma2[0] = kParamCov(0,0);
+ sigma2[1] = kParamCov(2,2);
+ sigma2[2] = kParamCov(3,3);
+ for (Int_t iVar = 0; iVar < 3; iVar++) sigma2[iVar] += kDistSigma[iVar] * kDistSigma[iVar];
+ }
+
minChi2MatchTrigger = 999.;
-
+
AliMUONTriggerTrack *triggerTrack;
TIter itTriggerTrack(triggerTrackStore.CreateIterator());
while ( ( triggerTrack = static_cast<AliMUONTriggerTrack*>(itTriggerTrack() ) ) )
{
- distTriggerTrack[0] = (triggerTrack->GetX11()-xTrack)/kDistSigma[0];
- distTriggerTrack[1] = (triggerTrack->GetY11()-yTrack)/kDistSigma[1];
- distTriggerTrack[2] = (TMath::Tan(triggerTrack->GetThetay())-ySlopeTrack)/kDistSigma[2];
- chi2 = 0.;
- for (Int_t iVar = 0; iVar < 3; iVar++) chi2 += distTriggerTrack[iVar]*distTriggerTrack[iVar];
+ distTriggerTrack[0] = triggerTrack->GetX11()-xTrack;
+ distTriggerTrack[1] = triggerTrack->GetY11()-yTrack;
+ distTriggerTrack[2] = TMath::Tan(triggerTrack->GetThetay())-ySlopeTrack;
+
+ if(isCovOK){
+ TMatrixD paramDiff(3,1);
+ for(Int_t iVar = 0; iVar < 3; iVar++)
+ paramDiff(iVar,0) = distTriggerTrack[iVar];
+
+ TMatrixD tmp(sumCov,TMatrixD::kMult,paramDiff);
+ TMatrixD chi2M(paramDiff,TMatrixD::kTransposeMult,tmp);
+ chi2 = chi2M(0,0);
+ }
+ else {
+ chi2 = 0.;
+ for (Int_t iVar = 0; iVar < 3; iVar++) chi2 += distTriggerTrack[iVar]*distTriggerTrack[iVar]/sigma2[iVar];
+ }
+
chi2 /= 3.; // Normalized Chi2: 3 degrees of freedom (X,Y,slopeY)
if (chi2 < AliMUONReconstructor::GetRecoParam()->GetMaxNormChi2MatchTrigger())
{
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff