X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MUON%2FAliMUONTrack.cxx;h=c1ffa44b893cb91c420d370c115572b71d2a7217;hb=a02060852650254a16086f9dff2a3196d7c57505;hp=7a6de3b8197efd21aa7e260ede63ec61e3bad0a8;hpb=a0dc65b45f53d95747053ece26219759360f5eb6;p=u%2Fmrichter%2FAliRoot.git diff --git a/MUON/AliMUONTrack.cxx b/MUON/AliMUONTrack.cxx index 7a6de3b8197..c1ffa44b893 100644 --- a/MUON/AliMUONTrack.cxx +++ b/MUON/AliMUONTrack.cxx @@ -24,24 +24,32 @@ #include "AliMUONTrack.h" #include "AliMUONReconstructor.h" -#include "AliMUONRecoParam.h" #include "AliMUONVCluster.h" #include "AliMUONVClusterStore.h" #include "AliMUONObjectPair.h" -#include "AliMUONConstants.h" #include "AliMUONTrackExtrap.h" +#include "AliMUONConstants.h" +#include "AliMUONTrackParam.h" #include "AliLog.h" #include -#include #include +using std::setw; +using std::endl; +using std::cout; +using std::streamsize; +using std::setprecision; /// \cond CLASSIMP ClassImp(AliMUONTrack) // Class implementation in ROOT context /// \endcond + +const Double_t AliMUONTrack::fgkMaxChi2 = 1.e10; ///< maximum chi2 above which the track can be considered as abnormal + + //__________________________________________________________________________ AliMUONTrack::AliMUONTrack() : TObject(), @@ -54,12 +62,13 @@ AliMUONTrack::AliMUONTrack() fGlobalChi2(-1.), fImproved(kFALSE), fMatchTrigger(-1), - floTrgNum(-1), fChi2MatchTrigger(0.), - fTrackID(0), + fTrackID(-1), fTrackParamAtVertex(0x0), fHitsPatternInTrigCh(0), - fLocalTrigger(0) + fHitsPatternInTrigChTrk(0), + fLocalTrigger(0), + fConnected(kFALSE) { /// Default constructor fVertexErrXY2[0] = 0.; @@ -69,7 +78,7 @@ AliMUONTrack::AliMUONTrack() //__________________________________________________________________________ AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment, Double_t bendingVertexDispersion) : TObject(), - fTrackParamAtCluster(new TClonesArray("AliMUONTrackParam",10)), + fTrackParamAtCluster(new TObjArray(20)), fFitWithVertex(kFALSE), fVertexErrXY2(), fFitWithMCS(kFALSE), @@ -78,15 +87,18 @@ AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment, Double_t bendingVertexDis fGlobalChi2(0.), fImproved(kFALSE), fMatchTrigger(-1), - floTrgNum(-1), fChi2MatchTrigger(0.), - fTrackID(0), + fTrackID(-1), fTrackParamAtVertex(0x0), fHitsPatternInTrigCh(0), - fLocalTrigger(0) + fHitsPatternInTrigChTrk(0), + fLocalTrigger(0), + fConnected(kFALSE) { /// Constructor from two clusters + fTrackParamAtCluster->SetOwner(kTRUE); + fVertexErrXY2[0] = 0.; fVertexErrXY2[1] = 0.; @@ -142,24 +154,31 @@ AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment, Double_t bendingVertexDis paramCov(3,2) = paramCov(2,3); paramCov(3,3) = ( firstCluster->GetErrY2() + lastCluster->GetErrY2() ) / dZ / dZ; // Inverse bending momentum (vertex resolution + bending slope resolution + 10% error on dipole parameters+field) - paramCov(4,4) = ( ( bendingVertexDispersion*bendingVertexDispersion + - (z1 * z1 * lastCluster->GetErrY2() + z2 * z2 * firstCluster->GetErrY2()) / dZ / dZ) / - bendingImpact / bendingImpact + 0.1 * 0.1) * inverseBendingMomentum * inverseBendingMomentum ; - paramCov(2,4) = - z2 * firstCluster->GetErrY2() * inverseBendingMomentum / bendingImpact / dZ; - paramCov(4,2) = paramCov(2,4); - paramCov(3,4) = - (z1 * lastCluster->GetErrY2() + z2 * firstCluster->GetErrY2()) * inverseBendingMomentum / bendingImpact / dZ / dZ; - paramCov(4,3) = paramCov(3,4); - - // Set covariances + if (AliMUONTrackExtrap::IsFieldON()) { + paramCov(4,4) = ( ( bendingVertexDispersion*bendingVertexDispersion + + (z1 * z1 * lastCluster->GetErrY2() + z2 * z2 * firstCluster->GetErrY2()) / dZ / dZ) / + bendingImpact / bendingImpact + 0.1 * 0.1) * inverseBendingMomentum * inverseBendingMomentum ; + paramCov(2,4) = - z2 * firstCluster->GetErrY2() * inverseBendingMomentum / bendingImpact / dZ; + paramCov(4,2) = paramCov(2,4); + paramCov(3,4) = - (z1 * lastCluster->GetErrY2() + z2 * firstCluster->GetErrY2()) * inverseBendingMomentum / bendingImpact / dZ / dZ; + paramCov(4,3) = paramCov(3,4); + } else paramCov(4,4) = inverseBendingMomentum*inverseBendingMomentum; trackParamAtFirstCluster.SetCovariances(paramCov); // Compute and set track parameters covariances at last cluster - paramCov(1,0) = - paramCov(1,0); - paramCov(0,1) = - paramCov(0,1); - paramCov(3,2) = - paramCov(3,2); - paramCov(2,3) = - paramCov(2,3); - paramCov(2,4) = z1 * lastCluster->GetErrY2() * inverseBendingMomentum / bendingImpact / dZ; - paramCov(4,2) = paramCov(2,4); + // Non bending plane + paramCov(0,0) = lastCluster->GetErrX2(); + paramCov(0,1) = - lastCluster->GetErrX2() / dZ; + paramCov(1,0) = paramCov(0,1); + // Bending plane + paramCov(2,2) = lastCluster->GetErrY2(); + paramCov(2,3) = - lastCluster->GetErrY2() / dZ; + paramCov(3,2) = paramCov(2,3); + // Inverse bending momentum (vertex resolution + bending slope resolution + 10% error on dipole parameters+field) + if (AliMUONTrackExtrap::IsFieldON()) { + paramCov(2,4) = z1 * lastCluster->GetErrY2() * inverseBendingMomentum / bendingImpact / dZ; + paramCov(4,2) = paramCov(2,4); + } trackParamAtLastCluster.SetCovariances(paramCov); // Add track parameters at clusters @@ -180,23 +199,22 @@ AliMUONTrack::AliMUONTrack(const AliMUONTrack& track) fGlobalChi2(track.fGlobalChi2), fImproved(track.fImproved), fMatchTrigger(track.fMatchTrigger), - floTrgNum(track.floTrgNum), fChi2MatchTrigger(track.fChi2MatchTrigger), fTrackID(track.fTrackID), fTrackParamAtVertex(0x0), fHitsPatternInTrigCh(track.fHitsPatternInTrigCh), - fLocalTrigger(track.fLocalTrigger) + fHitsPatternInTrigChTrk(track.fHitsPatternInTrigChTrk), + fLocalTrigger(track.fLocalTrigger), + fConnected(track.fConnected) { ///copy constructor - // necessary to make a copy of the objects and not only the pointers in TClonesArray. + // necessary to make a copy of the objects and not only the pointers in TObjArray. if (track.fTrackParamAtCluster) { - fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10); - AliMUONTrackParam *trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->First(); - while (trackParamAtCluster) { - new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(*trackParamAtCluster); - trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->After(trackParamAtCluster); - } + fTrackParamAtCluster = new TObjArray(track.fTrackParamAtCluster->GetSize()); + fTrackParamAtCluster->SetOwner(kTRUE); + for (Int_t i = 0; i < track.GetNClusters(); i++) + fTrackParamAtCluster->AddLast(new AliMUONTrackParam(*static_cast(track.fTrackParamAtCluster->UncheckedAt(i)))); } // copy vertex resolution square used during the tracking procedure @@ -226,14 +244,12 @@ AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& track) // clear memory Clear(); - // necessary to make a copy of the objects and not only the pointers in TClonesArray + // necessary to make a copy of the objects and not only the pointers in TObjArray if (track.fTrackParamAtCluster) { - fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10); - AliMUONTrackParam *trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->First(); - while (trackParamAtCluster) { - new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(*trackParamAtCluster); - trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->After(trackParamAtCluster); - } + fTrackParamAtCluster = new TObjArray(track.fTrackParamAtCluster->GetSize()); + fTrackParamAtCluster->SetOwner(kTRUE); + for (Int_t i = 0; i < track.GetNClusters(); i++) + fTrackParamAtCluster->AddLast(new AliMUONTrackParam(*static_cast(track.fTrackParamAtCluster->UncheckedAt(i)))); } // copy cluster weights matrix if any @@ -265,11 +281,12 @@ AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& track) fGlobalChi2 = track.fGlobalChi2; fImproved = track.fImproved; fMatchTrigger = track.fMatchTrigger; - floTrgNum = track.floTrgNum; fChi2MatchTrigger = track.fChi2MatchTrigger; fTrackID = track.fTrackID; fHitsPatternInTrigCh = track.fHitsPatternInTrigCh; + fHitsPatternInTrigChTrk = track.fHitsPatternInTrigChTrk; fLocalTrigger = track.fLocalTrigger; + fConnected = track.fConnected; return *this; } @@ -285,14 +302,10 @@ AliMUONTrack::~AliMUONTrack() } //__________________________________________________________________________ -void AliMUONTrack::Clear(Option_t* opt) +void AliMUONTrack::Clear(Option_t* /*opt*/) { /// Clear arrays - if (opt && opt[0] == 'C' && fTrackParamAtCluster) fTrackParamAtCluster->Clear("C"); - else { - delete fTrackParamAtCluster; - fTrackParamAtCluster = 0x0; - } + delete fTrackParamAtCluster; fTrackParamAtCluster = 0x0; delete fClusterWeightsNonBending; fClusterWeightsNonBending = 0x0; delete fClusterWeightsBending; fClusterWeightsBending = 0x0; delete fTrackParamAtVertex; fTrackParamAtVertex = 0x0; @@ -310,11 +323,12 @@ void AliMUONTrack::Reset() fGlobalChi2 = -1.; fImproved = kFALSE; fMatchTrigger = -1; - floTrgNum = -1; fChi2MatchTrigger = 0.; - fTrackID = 0; + fTrackID = -1; fHitsPatternInTrigCh = 0; + fHitsPatternInTrigChTrk = 0; fLocalTrigger = 0; + fConnected = kFALSE; delete fTrackParamAtCluster; fTrackParamAtCluster = 0x0; delete fClusterWeightsNonBending; fClusterWeightsNonBending = 0x0; delete fClusterWeightsBending; fClusterWeightsBending = 0x0; @@ -322,10 +336,13 @@ void AliMUONTrack::Reset() } //__________________________________________________________________________ -TClonesArray* AliMUONTrack::GetTrackParamAtCluster() const +TObjArray* AliMUONTrack::GetTrackParamAtCluster() const { /// return array of track parameters at cluster (create it if needed) - if (!fTrackParamAtCluster) fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10); + if (!fTrackParamAtCluster) { + fTrackParamAtCluster = new TObjArray(20); + fTrackParamAtCluster->SetOwner(kTRUE); + } return fTrackParamAtCluster; } @@ -344,14 +361,18 @@ void AliMUONTrack::AddTrackParamAtCluster(const AliMUONTrackParam &trackParam, A } // check whether track parameters are given at the correct cluster z position - if (cluster.GetZ() != trackParam.GetZ()) { + if (TMath::Abs(cluster.GetZ() - trackParam.GetZ())>1.e-5) { // AU AliError("track parameters are given at a different z position than the one of the associated cluster"); return; } // add parameters to the array of track parameters - if (!fTrackParamAtCluster) fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10); - AliMUONTrackParam* trackParamAtCluster = new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(trackParam); + if (!fTrackParamAtCluster) { + fTrackParamAtCluster = new TObjArray(20); + fTrackParamAtCluster->SetOwner(kTRUE); + } + AliMUONTrackParam* trackParamAtCluster = new AliMUONTrackParam(trackParam); + fTrackParamAtCluster->AddLast(trackParamAtCluster); // link parameters with the associated cluster or its copy if (copy) { @@ -366,59 +387,81 @@ void AliMUONTrack::AddTrackParamAtCluster(const AliMUONTrackParam &trackParam, A //__________________________________________________________________________ void AliMUONTrack::RemoveTrackParamAtCluster(AliMUONTrackParam *trackParam) { - /// Remove trackParam from the array of TrackParamAtCluster - if (!fTrackParamAtCluster || !fTrackParamAtCluster->Remove(trackParam)) { - AliWarning("object to remove does not exist in array fTrackParamAtCluster"); - return; - } + /// Remove trackParam from the array of TrackParamAtCluster and delete it since the array is owner + + if (fTrackParamAtCluster) { + + AliMUONTrackParam* trackParamAtCluster = static_cast(fTrackParamAtCluster->Remove(trackParam)); + + if (trackParamAtCluster) { + + // clean memory + delete trackParamAtCluster; + + // remove hole + fTrackParamAtCluster->Compress(); + + } else AliWarning("object to remove does not exist in array fTrackParamAtCluster"); + + } else AliWarning("array fTrackParamAtCluster does not exist"); - fTrackParamAtCluster->Compress(); } //__________________________________________________________________________ -void AliMUONTrack::UpdateTrackParamAtCluster() +Bool_t AliMUONTrack::UpdateTrackParamAtCluster() { /// Update track parameters at each attached cluster + /// Return kFALSE in case of failure (i.e. extrapolation problem) - if (GetNClusters() == 0) { + Int_t nClusters = GetNClusters(); + if (nClusters == 0) { AliWarning("no cluster attached to the track"); - return; + return kFALSE; } - AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->First(); - AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(startingTrackParam); - while (trackParamAtCluster) { + Bool_t extrapStatus = kTRUE; + AliMUONTrackParam* startingTrackParam = static_cast(fTrackParamAtCluster->UncheckedAt(0)); + + for (Int_t i = 1; i < nClusters; i++) { + AliMUONTrackParam* trackParamAtCluster = static_cast(fTrackParamAtCluster->UncheckedAt(i)); // reset track parameters and their covariances trackParamAtCluster->SetParameters(startingTrackParam->GetParameters()); trackParamAtCluster->SetZ(startingTrackParam->GetZ()); // extrapolation to the given z - AliMUONTrackExtrap::ExtrapToZ(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ()); + if (!AliMUONTrackExtrap::ExtrapToZ(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ())) extrapStatus = kFALSE; // prepare next step startingTrackParam = trackParamAtCluster; - trackParamAtCluster = (AliMUONTrackParam*) (fTrackParamAtCluster->After(trackParamAtCluster)); } + // set global chi2 to max value in case of problem during track extrapolation + if (!extrapStatus) SetGlobalChi2(2.*MaxChi2()); + return extrapStatus; + } //__________________________________________________________________________ -void AliMUONTrack::UpdateCovTrackParamAtCluster() +Bool_t AliMUONTrack::UpdateCovTrackParamAtCluster() { /// Update track parameters and their covariances at each attached cluster /// Include effects of multiple scattering in chambers + /// Return kFALSE in case of failure (i.e. extrapolation problem) - if (GetNClusters() == 0) { + Int_t nClusters = GetNClusters(); + if (nClusters == 0) { AliWarning("no cluster attached to the track"); - return; + return kFALSE; } - AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->First(); - AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(startingTrackParam); + Bool_t extrapStatus = kTRUE; + AliMUONTrackParam* startingTrackParam = static_cast(fTrackParamAtCluster->UncheckedAt(0)); Int_t expectedChamber = startingTrackParam->GetClusterPtr()->GetChamberId() + 1; Int_t currentChamber; - while (trackParamAtCluster) { + + for (Int_t i = 1; i < nClusters; i++) { + AliMUONTrackParam* trackParamAtCluster = static_cast(fTrackParamAtCluster->UncheckedAt(i)); // reset track parameters and their covariances trackParamAtCluster->SetParameters(startingTrackParam->GetParameters()); @@ -426,98 +469,162 @@ void AliMUONTrack::UpdateCovTrackParamAtCluster() trackParamAtCluster->SetCovariances(startingTrackParam->GetCovariances()); // add MCS effect - AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(),1.); + AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(expectedChamber-1),-1.); // add MCS in missing chambers if any currentChamber = trackParamAtCluster->GetClusterPtr()->GetChamberId(); while (currentChamber > expectedChamber) { // extrapolation to the missing chamber - AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, AliMUONConstants::DefaultChamberZ(expectedChamber)); + if (!AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, AliMUONConstants::DefaultChamberZ(expectedChamber))) extrapStatus = kFALSE; // add MCS effect - AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(),1.); + AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(expectedChamber),-1.); expectedChamber++; } // extrapolation to the z of the current cluster - AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ()); + if (!AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ())) extrapStatus = kFALSE; // prepare next step expectedChamber = currentChamber + 1; startingTrackParam = trackParamAtCluster; - trackParamAtCluster = (AliMUONTrackParam*) (fTrackParamAtCluster->After(trackParamAtCluster)); } + // set global chi2 to max value in case of problem during track extrapolation + if (!extrapStatus) SetGlobalChi2(2.*MaxChi2()); + return extrapStatus; + } //__________________________________________________________________________ -Bool_t AliMUONTrack::IsValid(UInt_t requestedStationMask) +Bool_t AliMUONTrack::IsValid(UInt_t requestedStationMask, Bool_t request2ChInSameSt45) { - /// check the validity of the current track (at least one cluster per requested station) + /// check the validity of the current track: + /// at least one cluster per requested station + /// and at least 2 chambers in stations 4 & 5 that contain cluster(s) + /// + if request2ChInSameSt45 = kTRUE: 2 chambers hit in the same station (4 or 5) Int_t nClusters = GetNClusters(); AliMUONTrackParam *trackParam; - Int_t currentStation(0); - - UInt_t m(0); + Int_t currentCh, currentSt, previousCh = -1, nChHitInSt4 = 0, nChHitInSt5 = 0; + UInt_t presentStationMask(0); - for (Int_t i = 0; i < nClusters; i++) - { + // first loop over clusters + for (Int_t i = 0; i < nClusters; i++) { trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i); - // skip unrequested stations -// while (expectedStation < AliMUONConstants::NTrackingSt() && -// !AliMUONReconstructor::GetRecoParam()->RequestStation(expectedStation)) expectedStation++; -// - - currentStation = trackParam->GetClusterPtr()->GetChamberId()/2; + currentCh = trackParam->GetClusterPtr()->GetChamberId(); + currentSt = currentCh/2; + + // build present station mask + presentStationMask |= ( 1 << currentSt ); - m |= ( 1 << currentStation ); + // count the number of chambers hit in station 4 that contain cluster(s) + if (currentSt == 3 && currentCh != previousCh) { + nChHitInSt4++; + previousCh = currentCh; + } + + // count the number of chambers hit in station 5 that contain cluster(s) + if (currentSt == 4 && currentCh != previousCh) { + nChHitInSt5++; + previousCh = currentCh; + } } - return ( (requestedStationMask & m) == requestedStationMask ) ; + // at least one cluster per requested station + if ((requestedStationMask & presentStationMask) != requestedStationMask) return kFALSE; + + // 2 chambers hit in the same station (4 or 5) + if (request2ChInSameSt45) return (nChHitInSt4 == 2 || nChHitInSt5 == 2); + // or 2 chambers hit in station 4 & 5 together + else return (nChHitInSt4+nChHitInSt5 >= 2); + } //__________________________________________________________________________ void AliMUONTrack::TagRemovableClusters(UInt_t requestedStationMask) { /// Identify clusters that can be removed from the track, - /// with the only requirement to have at least 1 cluster per requested station + /// with the only requirements to have at least 1 cluster per requested station + /// and at least 2 chambers over 4 in stations 4 & 5 that contain cluster(s) Int_t nClusters = GetNClusters(); AliMUONTrackParam *trackParam, *nextTrackParam; - Int_t currentCh, nextCh; + Int_t currentCh, nextCh, currentSt, nextSt, previousCh = -1, nChHitInSt45 = 0; - // reset flags to kFALSE for all clusters in required station + // first loop over clusters for (Int_t i = 0; i < nClusters; i++) { trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i); - Int_t stationId = ( 1 << (trackParam->GetClusterPtr()->GetChamberId()/2) ); - UInt_t m = ( 1 << stationId ); - if ( m & requestedStationMask ) - trackParam->SetRemovable(kFALSE); + + currentCh = trackParam->GetClusterPtr()->GetChamberId(); + currentSt = currentCh/2; + + // reset flags to kFALSE for all clusters in required station + if ((1 << currentSt) & requestedStationMask) trackParam->SetRemovable(kFALSE); else trackParam->SetRemovable(kTRUE); + + // count the number of chambers in station 4 & 5 that contain cluster(s) + if (currentCh > 5 && currentCh != previousCh) { + nChHitInSt45++; + previousCh = currentCh; + } + } - // loop over track parameters + // second loop over clusters for (Int_t i = 0; i < nClusters; i++) { trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i); currentCh = trackParam->GetClusterPtr()->GetChamberId(); + currentSt = currentCh/2; - // loop over next track parameters - for (Int_t j = i+1; j < nClusters; j++) { - nextTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(j); + // make sure they are more than 2 clusters in 2 different chambers of stations 4 & 5 + // but 2 clusters in he same chamber will still be flagged as removable + if (nChHitInSt45 < 3 && currentSt > 2) { + + if (i == nClusters-1) { + + trackParam->SetRemovable(kFALSE); + + } else { + + nextTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i+1); + nextCh = nextTrackParam->GetClusterPtr()->GetChamberId(); + + // set clusters in the same chamber as being removable + if (nextCh == currentCh) { + trackParam->SetRemovable(kTRUE); + nextTrackParam->SetRemovable(kTRUE); + i++; // skip cluster already checked + } else { + trackParam->SetRemovable(kFALSE); + } + + } - nextCh = nextTrackParam->GetClusterPtr()->GetChamberId(); + } else { - // check if the 2 clusters are on the same station - if (nextCh/2 != currentCh/2) break; + // skip clusters already flag as removable + if (trackParam->IsRemovable()) continue; - // set clusters in the same station as being removable - trackParam->SetRemovable(kTRUE); - nextTrackParam->SetRemovable(kTRUE); + // loop over next track parameters + for (Int_t j = i+1; j < nClusters; j++) { + nextTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(j); + + nextCh = nextTrackParam->GetClusterPtr()->GetChamberId(); + nextSt = nextCh/2; + + // set clusters in the same station as being removable + if (nextSt == currentSt) { + trackParam->SetRemovable(kTRUE); + nextTrackParam->SetRemovable(kTRUE); + i++; // skip cluster already checked + } + + } } - + } } @@ -555,6 +662,7 @@ Bool_t AliMUONTrack::ComputeLocalChi2(Bool_t accountForMCS) if (globalChi2 < 0.) return kFALSE; // Loop over removable clusters and compute their local chi2 + AliMUONTrackParam* trackParamAtCluster; AliMUONTrackParam* trackParamAtCluster1; AliMUONVCluster *cluster, *discardedCluster; Int_t iCluster1, iCluster2, iCurrentCluster1, iCurrentCluster2; @@ -563,8 +671,8 @@ Bool_t AliMUONTrack::ComputeLocalChi2(Bool_t accountForMCS) Double_t *dX = new Double_t[nClusters-1]; Double_t *dY = new Double_t[nClusters-1]; Double_t globalChi2b; - AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->First(); - while (trackParamAtCluster) { + for (Int_t iCluster = 0; iCluster < nClusters ; iCluster++) { + trackParamAtCluster = static_cast(fTrackParamAtCluster->UncheckedAt(iCluster)); discardedCluster = trackParamAtCluster->GetClusterPtr(); @@ -613,8 +721,6 @@ Bool_t AliMUONTrack::ComputeLocalChi2(Bool_t accountForMCS) // Set local chi2 trackParamAtCluster->SetLocalChi2(globalChi2 - globalChi2b); - - trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(trackParamAtCluster); } delete [] dX; @@ -622,10 +728,12 @@ Bool_t AliMUONTrack::ComputeLocalChi2(Bool_t accountForMCS) } else { // without multiple scattering effects + Int_t nClusters = GetNClusters(); + AliMUONTrackParam* trackParamAtCluster; AliMUONVCluster *discardedCluster; Double_t dX, dY; - AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->First(); - while (trackParamAtCluster) { + for (Int_t iCluster = 0; iCluster < nClusters ; iCluster++) { + trackParamAtCluster = static_cast(fTrackParamAtCluster->UncheckedAt(iCluster)); discardedCluster = trackParamAtCluster->GetClusterPtr(); @@ -635,8 +743,6 @@ Bool_t AliMUONTrack::ComputeLocalChi2(Bool_t accountForMCS) // Set local chi2 trackParamAtCluster->SetLocalChi2(dX * dX / discardedCluster->GetErrX2() + dY * dY / discardedCluster->GetErrY2()); - - trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(trackParamAtCluster); } } @@ -651,12 +757,12 @@ Double_t AliMUONTrack::ComputeGlobalChi2(Bool_t accountForMCS) /// Compute the chi2 of the track accounting for multiple scattering or not according to the flag /// - Assume that track parameters at each cluster are corrects /// - Assume the cluster weights matrices are corrects - /// - Return negative value if chi2 computation failed + /// - Return a value of chi2 higher than the maximum allowed if computation failed AliDebug(1,"Enter ComputeGlobalChi2"); if (!fTrackParamAtCluster) { AliWarning("no cluster attached to this track"); - return 1.e10; + return 2.*MaxChi2(); } Double_t chi2 = 0.; @@ -743,7 +849,7 @@ Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD* mcsCovariances) //__________________________________________________________________________ Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD& clusterWeightsNB, TMatrixD& clusterWeightsB, - TMatrixD* mcsCovariances, AliMUONVCluster* discardedCluster) const + TMatrixD* mcsCovariances, const AliMUONVCluster* discardedCluster) const { /// Compute the weight matrices, in non bending and bending direction, /// of the other attached clusters assuming the discarded one does not exist @@ -875,7 +981,7 @@ void AliMUONTrack::ComputeMCSCovariances(TMatrixD& mcsCovariances) const AliMUONTrackExtrap::ExtrapToZ(&extrapTrackParam, zMCS[size]); // Save multiple scattering dispersion angle in missing chamber - mcsAngle2[size] = AliMUONTrackExtrap::GetMCSAngle2(extrapTrackParam,AliMUONConstants::ChamberThicknessInX0(),1.); + mcsAngle2[size] = AliMUONTrackExtrap::GetMCSAngle2(extrapTrackParam,AliMUONConstants::ChamberThicknessInX0(expectedChamber),1.); } else mcsAngle2[size] = 0.; @@ -887,7 +993,7 @@ void AliMUONTrack::ComputeMCSCovariances(TMatrixD& mcsCovariances) const zMCS[size] = trackParamAtCluster->GetZ(); // Save multiple scattering dispersion angle in current chamber - mcsAngle2[size] = AliMUONTrackExtrap::GetMCSAngle2(*trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(),1.); + mcsAngle2[size] = AliMUONTrackExtrap::GetMCSAngle2(*trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(currentChamber),1.); // Save indice in zMCS array corresponding to the current cluster indices[iCluster] = size; @@ -925,93 +1031,124 @@ void AliMUONTrack::ComputeMCSCovariances(TMatrixD& mcsCovariances) const } //__________________________________________________________________________ -Int_t AliMUONTrack::ClustersInCommon(AliMUONTrack* track) const +Int_t AliMUONTrack::ClustersInCommon(AliMUONTrack* track, Int_t stMin, Int_t stMax) const { - /// Returns the number of clusters in common between the current track ("this") - /// and the track pointed to by "track". - if (!fTrackParamAtCluster || !this->fTrackParamAtCluster) return 0; + /// Returns the number of clusters in common in stations [stMin, stMax] + /// between the current track ("this") and the track pointed to by "track". + + if (!track || !track->fTrackParamAtCluster || !this->fTrackParamAtCluster) return 0; + + Int_t chMin = 2 * stMin; + Int_t chMax = 2 * stMax + 1; Int_t clustersInCommon = 0; - AliMUONTrackParam *trackParamAtCluster1, *trackParamAtCluster2; + // Loop over clusters of first track - trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->First(); - while (trackParamAtCluster1) { + Int_t nCl1 = this->GetNClusters(); + for(Int_t iCl1 = 0; iCl1 < nCl1; iCl1++) { + AliMUONVCluster* cl1 = ((AliMUONTrackParam*) this->fTrackParamAtCluster->UncheckedAt(iCl1))->GetClusterPtr(); + + Int_t chCl1 = cl1->GetChamberId(); + if (chCl1 < chMin || chCl1 > chMax) continue; + // Loop over clusters of second track - trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->First(); - while (trackParamAtCluster2) { - // Increment "clustersInCommon" if both trackParamAtCluster1 & 2 point to the same cluster - if ((trackParamAtCluster1->GetClusterPtr()) == (trackParamAtCluster2->GetClusterPtr())) { - clustersInCommon++; + Int_t nCl2 = track->GetNClusters(); + for(Int_t iCl2 = 0; iCl2 < nCl2; iCl2++) { + AliMUONVCluster* cl2 = ((AliMUONTrackParam*) track->fTrackParamAtCluster->UncheckedAt(iCl2))->GetClusterPtr(); + + Int_t chCl2 = cl2->GetChamberId(); + if (chCl2 < chMin || chCl2 > chMax) continue; + + // Increment "clustersInCommon" if both clusters have the same ID + if (cl1->GetUniqueID() == cl2->GetUniqueID()) { + clustersInCommon++; break; } - trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->After(trackParamAtCluster2); - } // trackParamAtCluster2 - trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->After(trackParamAtCluster1); - } // trackParamAtCluster1 + + } + + } + return clustersInCommon; } + //__________________________________________________________________________ +Int_t AliMUONTrack::GetNDF() const +{ + /// return the number of degrees of freedom + + Int_t ndf = 2 * GetNClusters() - 5; + return (ndf > 0) ? ndf : 0; +} + //__________________________________________________________________________ Double_t AliMUONTrack::GetNormalizedChi2() const { - /// return the chi2 value divided by the number of degrees of freedom (or 1.e10 if ndf < 0) + /// return the chi2 value divided by the number of degrees of freedom (or FLT_MAX if ndf <= 0) - Double_t numberOfDegFree = (2. * GetNClusters() - 5.); - if (numberOfDegFree > 0.) return fGlobalChi2 / numberOfDegFree; - else return fGlobalChi2; // system is under-constraint + Double_t ndf = (Double_t) GetNDF(); + return (ndf > 0.) ? fGlobalChi2 / ndf : 2.*MaxChi2(); } //__________________________________________________________________________ -Bool_t* AliMUONTrack::CompatibleTrack(AliMUONTrack *track, Double_t sigmaCut) const +Int_t AliMUONTrack::FindCompatibleClusters(const AliMUONTrack &track, Double_t sigmaCut, Bool_t compatibleCluster[10]) const { - /// for each chamber: return kTRUE (kFALSE) if clusters are compatible (not compatible) - AliMUONTrackParam *trackParamAtCluster1, *trackParamAtCluster2; + /// Try to match clusters from this track with clusters from the given track within the provided sigma cut: + /// - Fill the array compatibleCluster[iCh] with kTRUE if a compatible cluster has been found in chamber iCh. + /// - Return the number of clusters of "this" track matched with one cluster of the given track. AliMUONVCluster *cluster1, *cluster2; - Double_t chi2, dX, dY, dZ; + Double_t chi2, dX, dY; Double_t chi2Max = sigmaCut * sigmaCut; - Double_t dZMax = 1.; // 1 cm - Bool_t *compatibleCluster = new Bool_t[AliMUONConstants::NTrackingCh()]; + // initialization + Int_t nMatchClusters = 0; for ( Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++) compatibleCluster[ch] = kFALSE; - if (!fTrackParamAtCluster || !this->fTrackParamAtCluster) return compatibleCluster; + if (!track.fTrackParamAtCluster || !this->fTrackParamAtCluster) return nMatchClusters; // Loop over clusters of first track - trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->First(); - while (trackParamAtCluster1) { - - cluster1 = trackParamAtCluster1->GetClusterPtr(); + Int_t nCl1 = this->GetNClusters(); + for(Int_t iCl1 = 0; iCl1 < nCl1; iCl1++) { + cluster1 = static_cast(this->fTrackParamAtCluster->UncheckedAt(iCl1))->GetClusterPtr(); // Loop over clusters of second track - trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->First(); - while (trackParamAtCluster2) { - - cluster2 = trackParamAtCluster2->GetClusterPtr(); + Int_t nCl2 = track.GetNClusters(); + for(Int_t iCl2 = 0; iCl2 < nCl2; iCl2++) { + cluster2 = static_cast(track.fTrackParamAtCluster->UncheckedAt(iCl2))->GetClusterPtr(); - //prepare next step - trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->After(trackParamAtCluster2); + // check DE Id + if (cluster1->GetDetElemId() != cluster2->GetDetElemId()) continue; - // z direction - dZ = cluster1->GetZ() - cluster2->GetZ(); - if (dZ > dZMax) continue; - - // non bending direction + // check local chi2 dX = cluster1->GetX() - cluster2->GetX(); - chi2 = dX * dX / (cluster1->GetErrX2() + cluster2->GetErrX2()); - if (chi2 > chi2Max) continue; - - // bending direction dY = cluster1->GetY() - cluster2->GetY(); - chi2 = dY * dY / (cluster1->GetErrY2() + cluster2->GetErrY2()); - if (chi2 > chi2Max) continue; + chi2 = dX * dX / (cluster1->GetErrX2() + cluster2->GetErrX2()) + dY * dY / (cluster1->GetErrY2() + cluster2->GetErrY2()); + if (chi2 > 2. * chi2Max) continue; // 2 because 2 quantities in chi2 compatibleCluster[cluster1->GetChamberId()] = kTRUE; + nMatchClusters++; break; } - trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->After(trackParamAtCluster1); } - return compatibleCluster; + return nMatchClusters; +} + +//__________________________________________________________________________ +Bool_t AliMUONTrack::Match(AliMUONTrack &track, Double_t sigmaCut, Int_t &nMatchClusters) const +{ + /// Try to match this track with the given track. Matching conditions: + /// - more than 50% of clusters from this track matched with clusters from the given track + /// - at least 1 cluster matched before and 1 cluster matched after the dipole + + Bool_t compTrack[10]; + nMatchClusters = FindCompatibleClusters(track, sigmaCut, compTrack); + + if ((compTrack[0] || compTrack[1] || compTrack[2] || compTrack[3]) && // at least 1 cluster matched in st 1 & 2 + (compTrack[6] || compTrack[7] || compTrack[8] || compTrack[9]) && // at least 1 cluster matched in st 4 & 5 + 2 * nMatchClusters > GetNClusters()) return kTRUE; // more than 50% of clusters matched + else return kFALSE; + } //__________________________________________________________________________ @@ -1050,16 +1187,21 @@ void AliMUONTrack::Print(Option_t*) const { /// Printing Track information + streamsize curW = cout.width(); + streamsize curPrecision = cout.precision(); cout << " No.Clusters=" << setw(2) << GetNClusters() << ", Match2Trig=" << setw(1) << GetMatchTrigger() << - ", LoTrgNum=" << setw(3) << GetLoTrgNum() << + ", LoTrgNum=" << setw(3) << LoCircuit() << ", Chi2-tracking-trigger=" << setw(8) << setprecision(5) << GetChi2MatchTrigger(); - cout << Form(" HitTriggerPattern %x",fHitsPatternInTrigCh) << endl; + cout << Form(" HitTriggerPattern trig %x track %x",fHitsPatternInTrigCh, fHitsPatternInTrigChTrk); + cout << Form(" MClabel=%d",fTrackID) << endl; if (fTrackParamAtCluster) fTrackParamAtCluster->First()->Print("FULL"); + cout.width(curW); + cout.precision(curPrecision); } //__________________________________________________________________________ -void AliMUONTrack::SetLocalTrigger(Int_t loCirc, Int_t loStripX, Int_t loStripY, Int_t loDev, Int_t loLpt, Int_t loHpt) +void AliMUONTrack::SetLocalTrigger(Int_t loCirc, Int_t loStripX, Int_t loStripY, Int_t loDev, Int_t loLpt, Int_t loHpt, UChar_t respWithoutChamber) { /// pack the local trigger information and store @@ -1072,6 +1214,51 @@ void AliMUONTrack::SetLocalTrigger(Int_t loCirc, Int_t loStripX, Int_t loStripY, fLocalTrigger += loDev << 17; fLocalTrigger += loLpt << 22; fLocalTrigger += loHpt << 24; + fLocalTrigger += respWithoutChamber << 26; + +} +//__________________________________________________________________________ +void AliMUONTrack::FindMCLabel() +{ + /// Determine the MC label from the label of the attached clusters and fill fMCLabel data member: + /// More than 50% of clusters, including 1 before and 1 after the dipole, must share the same label + + Int_t nClusters = GetNClusters(); + Int_t halfCluster = nClusters/2; + + // reset MC label + fTrackID = -1; + + // loop over first clusters (if nClusters left < (nClusters-halfCluster) the conditions cannot be fulfilled) + for (Int_t iCluster1 = 0; iCluster1 < nClusters-halfCluster; iCluster1++) { + AliMUONVCluster* cluster1 = ((AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(iCluster1))->GetClusterPtr(); + + // if the first cluster is not on station 1 or 2 the conditions cannot be fulfilled + if (cluster1->GetChamberId() > 3) return; + + Int_t label1 = cluster1->GetMCLabel(); + if (label1 < 0) continue; + + Int_t nIdenticalLabel = 1; + + // Loop over next clusters + for (Int_t iCluster2 = iCluster1+1; iCluster2 < nClusters; iCluster2++) { + AliMUONVCluster* cluster2 = ((AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(iCluster2))->GetClusterPtr(); + + if (cluster2->GetMCLabel() != label1) continue; + + nIdenticalLabel++; + + // stop as soon as conditions are fulfilled + if (nIdenticalLabel > halfCluster && cluster2->GetChamberId() > 5) { + fTrackID = label1; + return; + } + + } + + } + }