X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MUON%2FAliMUONTrack.cxx;h=1b83b86cbca41ff936bc2213526fc7fac0ea27c3;hb=01e3d4d7ed4aadd9301cde3debb526fea4ec5aff;hp=8b82126ae38d876ee614a7051c3cc31df7d6217f;hpb=1467f4ba9199b90673c9cad7a0771ec2caa4204b;p=u%2Fmrichter%2FAliRoot.git diff --git a/MUON/AliMUONTrack.cxx b/MUON/AliMUONTrack.cxx index 8b82126ae38..1b83b86cbca 100644 --- a/MUON/AliMUONTrack.cxx +++ b/MUON/AliMUONTrack.cxx @@ -23,16 +23,17 @@ #include "AliMUONTrack.h" -#include "AliMUONTrackParam.h" -#include "AliMUONVCluster.h" -#include "AliMUONObjectPair.h" +#include "AliMUONReconstructor.h" +#include "AliMUONVCluster.h" +#include "AliMUONVClusterStore.h" +#include "AliMUONObjectPair.h" +#include "AliMUONTrackExtrap.h" #include "AliMUONConstants.h" -#include "AliMUONTrackExtrap.h" +#include "AliMUONTrackParam.h" #include "AliLog.h" #include -#include #include @@ -40,10 +41,14 @@ 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(), - fTrackParamAtCluster(new TClonesArray("AliMUONTrackParam",10)), + fTrackParamAtCluster(0x0), fFitWithVertex(kFALSE), fVertexErrXY2(), fFitWithMCS(kFALSE), @@ -54,19 +59,18 @@ AliMUONTrack::AliMUONTrack() fMatchTrigger(-1), floTrgNum(-1), fChi2MatchTrigger(0.), - fTrackID(0), + fTrackID(-1), fTrackParamAtVertex(0x0), fHitsPatternInTrigCh(0), fLocalTrigger(0) { /// Default constructor - fTrackParamAtCluster->SetOwner(kTRUE); fVertexErrXY2[0] = 0.; fVertexErrXY2[1] = 0.; } //__________________________________________________________________________ -AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment) +AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment, Double_t bendingVertexDispersion) : TObject(), fTrackParamAtCluster(new TClonesArray("AliMUONTrackParam",10)), fFitWithVertex(kFALSE), @@ -79,37 +83,19 @@ AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment) fMatchTrigger(-1), floTrgNum(-1), fChi2MatchTrigger(0.), - fTrackID(0), + fTrackID(-1), fTrackParamAtVertex(0x0), fHitsPatternInTrigCh(0), fLocalTrigger(0) { /// Constructor from two clusters - fTrackParamAtCluster->SetOwner(kTRUE); fVertexErrXY2[0] = 0.; fVertexErrXY2[1] = 0.; // Pointers to clusters from the segment - AliMUONVCluster* cluster1 = (AliMUONVCluster*) segment->First(); - AliMUONVCluster* cluster2 = (AliMUONVCluster*) segment->Second(); - - // check sorting in -Z (spectro z<0) - if (cluster1->GetZ() < cluster2->GetZ()) { - cluster1 = cluster2; - cluster2 = (AliMUONVCluster*) segment->First(); - } - - // order the clusters into the track according to the station the segment belong to - //(the cluster first attached is the one from which we will start the tracking procedure) - AliMUONVCluster *firstCluster, *lastCluster; - if (cluster1->GetChamberId() == 8) { - firstCluster = cluster1; - lastCluster = cluster2; - } else { - firstCluster = cluster2; - lastCluster = cluster1; - } + AliMUONVCluster* firstCluster = (AliMUONVCluster*) segment->First(); + AliMUONVCluster* lastCluster = (AliMUONVCluster*) segment->Second(); // Compute track parameters Double_t z1 = firstCluster->GetZ(); @@ -127,7 +113,6 @@ AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment) Double_t bendingImpact = bendingCoor1 - z1 * bendingSlope; Double_t inverseBendingMomentum = 1. / AliMUONTrackExtrap::GetBendingMomentumFromImpactParam(bendingImpact); - // Set track parameters at first cluster AliMUONTrackParam trackParamAtFirstCluster; trackParamAtFirstCluster.SetZ(z1); @@ -137,7 +122,6 @@ AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment) trackParamAtFirstCluster.SetBendingSlope(bendingSlope); trackParamAtFirstCluster.SetInverseBendingMomentum(inverseBendingMomentum); - // Set track parameters at last cluster AliMUONTrackParam trackParamAtLastCluster; trackParamAtLastCluster.SetZ(z2); @@ -147,43 +131,46 @@ AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment) trackParamAtLastCluster.SetBendingSlope(bendingSlope); trackParamAtLastCluster.SetInverseBendingMomentum(inverseBendingMomentum); - // Compute and set track parameters covariances at first cluster - TMatrixD paramCov1(5,5); - paramCov1.Zero(); + TMatrixD paramCov(5,5); + paramCov.Zero(); // Non bending plane - paramCov1(0,0) = firstCluster->GetErrX2(); - paramCov1(0,1) = firstCluster->GetErrX2() / dZ; - paramCov1(1,0) = paramCov1(0,1); - paramCov1(1,1) = ( firstCluster->GetErrX2() + lastCluster->GetErrX2() ) / dZ / dZ; + paramCov(0,0) = firstCluster->GetErrX2(); + paramCov(0,1) = firstCluster->GetErrX2() / dZ; + paramCov(1,0) = paramCov(0,1); + paramCov(1,1) = ( firstCluster->GetErrX2() + lastCluster->GetErrX2() ) / dZ / dZ; // Bending plane - paramCov1(2,2) = firstCluster->GetErrY2(); - paramCov1(2,3) = firstCluster->GetErrY2() / dZ; - paramCov1(3,2) = paramCov1(2,3); - paramCov1(3,3) = ( firstCluster->GetErrY2() + lastCluster->GetErrY2() ) / dZ / dZ; - // Inverse bending momentum (50% error) - paramCov1(4,4) = 0.5*inverseBendingMomentum * 0.5*inverseBendingMomentum; - // Set covariances - trackParamAtFirstCluster.SetCovariances(paramCov1); - - - // Compute and set track parameters covariances at last cluster (as if the first cluster did not exist) - TMatrixD paramCov2(5,5); - paramCov2.Zero(); + paramCov(2,2) = firstCluster->GetErrY2(); + paramCov(2,3) = firstCluster->GetErrY2() / dZ; + 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) + 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 // Non bending plane - paramCov2(0,0) = paramCov1(0,0); - paramCov2(1,1) = 100.*paramCov1(1,1); + paramCov(0,0) = lastCluster->GetErrX2(); + paramCov(0,1) = - lastCluster->GetErrX2() / dZ; + paramCov(1,0) = paramCov(0,1); // Bending plane - paramCov2(2,2) = paramCov1(2,2); - paramCov2(3,3) = 100.*paramCov1(3,3); - // Inverse bending momentum - paramCov2(4,4) = paramCov1(4,4); - // Set covariances - trackParamAtLastCluster.SetCovariances(paramCov2); - - // Flag clusters as being removable - trackParamAtFirstCluster.SetRemovable(kTRUE); - trackParamAtLastCluster.SetRemovable(kTRUE); + 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 AddTrackParamAtCluster(trackParamAtFirstCluster,*firstCluster); @@ -191,10 +178,10 @@ AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment) } - //__________________________________________________________________________ +//__________________________________________________________________________ AliMUONTrack::AliMUONTrack(const AliMUONTrack& track) : TObject(track), - fTrackParamAtCluster(new TClonesArray("AliMUONTrackParam",10)), + fTrackParamAtCluster(0x0), fFitWithVertex(track.fFitWithVertex), fVertexErrXY2(), fFitWithMCS(track.fFitWithMCS), @@ -213,10 +200,13 @@ AliMUONTrack::AliMUONTrack(const AliMUONTrack& track) ///copy constructor // necessary to make a copy of the objects and not only the pointers in TClonesArray. - AliMUONTrackParam *trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->First(); - while (trackParamAtCluster) { - new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(*trackParamAtCluster); - trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->After(trackParamAtCluster); + 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); + } } // copy vertex resolution square used during the tracking procedure @@ -242,13 +232,18 @@ AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& track) // base class assignement TObject::operator=(track); - - // necessary to make a copy of the objects and not only the pointers in TClonesArray. - fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10); - AliMUONTrackParam *trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->First(); - while (trackParamAtCluster) { - new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(*trackParamAtCluster); - trackParamAtCluster = (AliMUONTrackParam*) track.fTrackParamAtCluster->After(trackParamAtCluster); + + // clear memory + Clear(); + + // necessary to make a copy of the objects and not only the pointers in TClonesArray + 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); + } } // copy cluster weights matrix if any @@ -257,9 +252,6 @@ AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& track) fClusterWeightsNonBending->ResizeTo(*(track.fClusterWeightsNonBending)); *fClusterWeightsNonBending = *(track.fClusterWeightsNonBending); } else fClusterWeightsNonBending = new TMatrixD(*(track.fClusterWeightsNonBending)); - } else if (fClusterWeightsNonBending) { - delete fClusterWeightsNonBending; - fClusterWeightsNonBending = 0x0; } // copy cluster weights matrix if any @@ -268,18 +260,12 @@ AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& track) fClusterWeightsBending->ResizeTo(*(track.fClusterWeightsBending)); *fClusterWeightsBending = *(track.fClusterWeightsBending); } else fClusterWeightsBending = new TMatrixD(*(track.fClusterWeightsBending)); - } else if (fClusterWeightsBending) { - delete fClusterWeightsBending; - fClusterWeightsBending = 0x0; } // copy track parameters at vertex if any if (track.fTrackParamAtVertex) { if (fTrackParamAtVertex) *fTrackParamAtVertex = *(track.fTrackParamAtVertex); else fTrackParamAtVertex = new AliMUONTrackParam(*(track.fTrackParamAtVertex)); - } else if (fTrackParamAtVertex) { - delete fTrackParamAtVertex; - fTrackParamAtVertex = 0x0; } fFitWithVertex = track.fFitWithVertex; @@ -312,12 +298,47 @@ AliMUONTrack::~AliMUONTrack() void AliMUONTrack::Clear(Option_t* opt) { /// Clear arrays - fTrackParamAtCluster->Clear(opt); + if (opt && opt[0] == 'C' && fTrackParamAtCluster) fTrackParamAtCluster->Clear("C"); + else { + delete fTrackParamAtCluster; + fTrackParamAtCluster = 0x0; + } + delete fClusterWeightsNonBending; fClusterWeightsNonBending = 0x0; + delete fClusterWeightsBending; fClusterWeightsBending = 0x0; + delete fTrackParamAtVertex; fTrackParamAtVertex = 0x0; +} + + //__________________________________________________________________________ +void AliMUONTrack::Reset() +{ + /// Reset to default values + SetUniqueID(0); + fFitWithVertex = kFALSE; + fVertexErrXY2[0] = 0.; + fVertexErrXY2[1] = 0.; + fFitWithMCS = kFALSE; + fGlobalChi2 = -1.; + fImproved = kFALSE; + fMatchTrigger = -1; + floTrgNum = -1; + fChi2MatchTrigger = 0.; + fTrackID = -1; + fHitsPatternInTrigCh = 0; + fLocalTrigger = 0; + delete fTrackParamAtCluster; fTrackParamAtCluster = 0x0; delete fClusterWeightsNonBending; fClusterWeightsNonBending = 0x0; delete fClusterWeightsBending; fClusterWeightsBending = 0x0; delete fTrackParamAtVertex; fTrackParamAtVertex = 0x0; } + //__________________________________________________________________________ +TClonesArray* AliMUONTrack::GetTrackParamAtCluster() const +{ + /// return array of track parameters at cluster (create it if needed) + if (!fTrackParamAtCluster) fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10); + return fTrackParamAtCluster; +} + //__________________________________________________________________________ void AliMUONTrack::AddTrackParamAtCluster(const AliMUONTrackParam &trackParam, AliMUONVCluster &cluster, Bool_t copy) { @@ -339,6 +360,7 @@ void AliMUONTrack::AddTrackParamAtCluster(const AliMUONTrackParam &trackParam, A } // add parameters to the array of track parameters + if (!fTrackParamAtCluster) fTrackParamAtCluster = new TClonesArray("AliMUONTrackParam",10); AliMUONTrackParam* trackParamAtCluster = new ((*fTrackParamAtCluster)[GetNClusters()]) AliMUONTrackParam(trackParam); // link parameters with the associated cluster or its copy @@ -346,13 +368,16 @@ void AliMUONTrack::AddTrackParamAtCluster(const AliMUONTrackParam &trackParam, A AliMUONVCluster *clusterCopy = static_cast(cluster.Clone()); trackParamAtCluster->SetClusterPtr(clusterCopy, kTRUE); } else trackParamAtCluster->SetClusterPtr(&cluster); + + // sort the array of track parameters + fTrackParamAtCluster->Sort(); } //__________________________________________________________________________ void AliMUONTrack::RemoveTrackParamAtCluster(AliMUONTrackParam *trackParam) { /// Remove trackParam from the array of TrackParamAtCluster - if (!fTrackParamAtCluster->Remove(trackParam)) { + if (!fTrackParamAtCluster || !fTrackParamAtCluster->Remove(trackParam)) { AliWarning("object to remove does not exist in array fTrackParamAtCluster"); return; } @@ -361,15 +386,17 @@ void AliMUONTrack::RemoveTrackParamAtCluster(AliMUONTrackParam *trackParam) } //__________________________________________________________________________ -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) { AliWarning("no cluster attached to the track"); - return; + return kFALSE; } + Bool_t extrapStatus = kTRUE; AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->First(); AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(startingTrackParam); while (trackParamAtCluster) { @@ -379,26 +406,32 @@ void AliMUONTrack::UpdateTrackParamAtCluster() 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) { AliWarning("no cluster attached to the track"); - return; + return kFALSE; } + Bool_t extrapStatus = kTRUE; AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->First(); AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) fTrackParamAtCluster->After(startingTrackParam); Int_t expectedChamber = startingTrackParam->GetClusterPtr()->GetChamberId() + 1; @@ -411,20 +444,20 @@ 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; @@ -432,6 +465,144 @@ void AliMUONTrack::UpdateCovTrackParamAtCluster() 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 request2ChInSameSt45) +{ + /// 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 currentCh, currentSt, previousCh = -1, nChHitInSt4 = 0, nChHitInSt5 = 0; + UInt_t presentStationMask(0); + + // first loop over clusters + for (Int_t i = 0; i < nClusters; i++) { + trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i); + + currentCh = trackParam->GetClusterPtr()->GetChamberId(); + currentSt = currentCh/2; + + // build present station mask + presentStationMask |= ( 1 << currentSt ); + + // 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; + } + + } + + // 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 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, currentSt, nextSt, previousCh = -1, nChHitInSt45 = 0; + + // first loop over clusters + for (Int_t i = 0; i < nClusters; i++) { + trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i); + + 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; + } + + } + + // second loop over clusters + for (Int_t i = 0; i < nClusters; i++) { + trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i); + + currentCh = trackParam->GetClusterPtr()->GetChamberId(); + currentSt = currentCh/2; + + // 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); + } + + } + + } else { + + // skip clusters already flag as removable + if (trackParam->IsRemovable()) continue; + + // 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 + } + + } + + } + + } + } //__________________________________________________________________________ @@ -442,6 +613,12 @@ Bool_t AliMUONTrack::ComputeLocalChi2(Bool_t accountForMCS) /// - Also recompute the weight matrices of the attached clusters if accountForMCS=kTRUE /// - Assume that track parameters at each cluster are corrects /// - Return kFALSE if computation failed + AliDebug(1,"Enter ComputeLocalChi2"); + + if (!fTrackParamAtCluster) { + AliWarning("no cluster attached to this track"); + return kFALSE; + } if (accountForMCS) { // Compute local chi2 taking into account multiple scattering effects @@ -464,8 +641,8 @@ Bool_t AliMUONTrack::ComputeLocalChi2(Bool_t accountForMCS) AliMUONTrackParam* trackParamAtCluster1; AliMUONVCluster *cluster, *discardedCluster; Int_t iCluster1, iCluster2, iCurrentCluster1, iCurrentCluster2; - TMatrixD ClusterWeightsNB(nClusters-1,nClusters-1); - TMatrixD ClusterWeightsB(nClusters-1,nClusters-1); + TMatrixD clusterWeightsNB(nClusters-1,nClusters-1); + TMatrixD clusterWeightsB(nClusters-1,nClusters-1); Double_t *dX = new Double_t[nClusters-1]; Double_t *dY = new Double_t[nClusters-1]; Double_t globalChi2b; @@ -475,7 +652,7 @@ Bool_t AliMUONTrack::ComputeLocalChi2(Bool_t accountForMCS) discardedCluster = trackParamAtCluster->GetClusterPtr(); // Recompute cluster weights without the current cluster - if (!ComputeClusterWeights(ClusterWeightsNB, ClusterWeightsB, &mcsCovariances, discardedCluster)) { + if (!ComputeClusterWeights(clusterWeightsNB, clusterWeightsB, &mcsCovariances, discardedCluster)) { AliWarning("cannot take into account the multiple scattering effects"); delete [] dX; delete [] dY; @@ -502,17 +679,17 @@ Bool_t AliMUONTrack::ComputeLocalChi2(Bool_t accountForMCS) if (cluster == discardedCluster) continue; // Add contribution from covariances - globalChi2b += (ClusterWeightsNB(iCurrentCluster1, iCurrentCluster2) + - ClusterWeightsNB(iCurrentCluster2, iCurrentCluster1)) * dX[iCurrentCluster1] * dX[iCurrentCluster2] + - (ClusterWeightsB(iCurrentCluster1, iCurrentCluster2) + - ClusterWeightsB(iCurrentCluster2, iCurrentCluster1)) * dY[iCurrentCluster1] * dY[iCurrentCluster2]; + globalChi2b += (clusterWeightsNB(iCurrentCluster1, iCurrentCluster2) + + clusterWeightsNB(iCurrentCluster2, iCurrentCluster1)) * dX[iCurrentCluster1] * dX[iCurrentCluster2] + + (clusterWeightsB(iCurrentCluster1, iCurrentCluster2) + + clusterWeightsB(iCurrentCluster2, iCurrentCluster1)) * dY[iCurrentCluster1] * dY[iCurrentCluster2]; iCurrentCluster2++; } // Add contribution from variances - globalChi2b += ClusterWeightsNB(iCurrentCluster1, iCurrentCluster1) * dX[iCurrentCluster1] * dX[iCurrentCluster1] + - ClusterWeightsB(iCurrentCluster1, iCurrentCluster1) * dY[iCurrentCluster1] * dY[iCurrentCluster1]; + globalChi2b += clusterWeightsNB(iCurrentCluster1, iCurrentCluster1) * dX[iCurrentCluster1] * dX[iCurrentCluster1] + + clusterWeightsB(iCurrentCluster1, iCurrentCluster1) * dY[iCurrentCluster1] * dY[iCurrentCluster1]; iCurrentCluster1++; } @@ -557,7 +734,13 @@ 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 2.*MaxChi2(); + } Double_t chi2 = 0.; @@ -622,6 +805,12 @@ Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD* mcsCovariances) /// - Use the provided MCS covariance matrix if any (otherwise build it temporarily) /// - Assume that track parameters at each cluster are corrects /// - Return kFALSE if computation failed + AliDebug(1,"Enter ComputeClusterWeights1"); + + if (!fTrackParamAtCluster) { + AliWarning("no cluster attached to this track"); + return kFALSE; + } // Alocate memory Int_t nClusters = GetNClusters(); @@ -636,7 +825,7 @@ Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD* mcsCovariances) } //__________________________________________________________________________ -Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD& ClusterWeightsNB, TMatrixD& ClusterWeightsB, +Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD& clusterWeightsNB, TMatrixD& clusterWeightsB, TMatrixD* mcsCovariances, AliMUONVCluster* discardedCluster) const { /// Compute the weight matrices, in non bending and bending direction, @@ -644,6 +833,7 @@ Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD& ClusterWeightsNB, TMatrixD& /// accounting for multiple scattering correlations and cluster resolution /// - Use the provided MCS covariance matrix if any (otherwise build it temporarily) /// - Return kFALSE if computation failed + AliDebug(1,"Enter ComputeClusterWeights2"); // Check MCS covariance matrix and recompute it if need Int_t nClusters = GetNClusters(); @@ -656,11 +846,11 @@ Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD& ClusterWeightsNB, TMatrixD& // Resize the weights matrices; alocate memory if (discardedCluster) { - ClusterWeightsNB.ResizeTo(nClusters-1,nClusters-1); - ClusterWeightsB.ResizeTo(nClusters-1,nClusters-1); + clusterWeightsNB.ResizeTo(nClusters-1,nClusters-1); + clusterWeightsB.ResizeTo(nClusters-1,nClusters-1); } else { - ClusterWeightsNB.ResizeTo(nClusters,nClusters); - ClusterWeightsB.ResizeTo(nClusters,nClusters); + clusterWeightsNB.ResizeTo(nClusters,nClusters); + clusterWeightsB.ResizeTo(nClusters,nClusters); } // Define variables @@ -682,25 +872,25 @@ Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD& ClusterWeightsNB, TMatrixD& if (cluster2 == discardedCluster) continue; // Fill with MCS covariances - ClusterWeightsNB(iCurrentCluster1, iCurrentCluster2) = (*mcsCovariances)(iCluster1,iCluster2); + clusterWeightsNB(iCurrentCluster1, iCurrentCluster2) = (*mcsCovariances)(iCluster1,iCluster2); // Equal contribution from multiple scattering in non bending and bending directions - ClusterWeightsB(iCurrentCluster1, iCurrentCluster2) = ClusterWeightsNB(iCurrentCluster1, iCurrentCluster2); + clusterWeightsB(iCurrentCluster1, iCurrentCluster2) = clusterWeightsNB(iCurrentCluster1, iCurrentCluster2); // Add contribution from cluster resolution to diagonal element and symmetrize the matrix if (iCurrentCluster1 == iCurrentCluster2) { // In non bending plane - ClusterWeightsNB(iCurrentCluster1, iCurrentCluster1) += cluster1->GetErrX2(); + clusterWeightsNB(iCurrentCluster1, iCurrentCluster1) += cluster1->GetErrX2(); // In bending plane - ClusterWeightsB(iCurrentCluster1, iCurrentCluster1) += cluster1->GetErrY2(); + clusterWeightsB(iCurrentCluster1, iCurrentCluster1) += cluster1->GetErrY2(); } else { // In non bending plane - ClusterWeightsNB(iCurrentCluster2, iCurrentCluster1) = ClusterWeightsNB(iCurrentCluster1, iCurrentCluster2); + clusterWeightsNB(iCurrentCluster2, iCurrentCluster1) = clusterWeightsNB(iCurrentCluster1, iCurrentCluster2); // In bending plane - ClusterWeightsB(iCurrentCluster2, iCurrentCluster1) = ClusterWeightsB(iCurrentCluster1, iCurrentCluster2); + clusterWeightsB(iCurrentCluster2, iCurrentCluster1) = clusterWeightsB(iCurrentCluster1, iCurrentCluster2); } @@ -711,13 +901,13 @@ Bool_t AliMUONTrack::ComputeClusterWeights(TMatrixD& ClusterWeightsNB, TMatrixD& } // Inversion of covariance matrices to get the weights - if (ClusterWeightsNB.Determinant() != 0 && ClusterWeightsB.Determinant() != 0) { - ClusterWeightsNB.Invert(); - ClusterWeightsB.Invert(); + if (clusterWeightsNB.Determinant() != 0 && clusterWeightsB.Determinant() != 0) { + clusterWeightsNB.Invert(); + clusterWeightsB.Invert(); } else { AliWarning(" Determinant = 0"); - ClusterWeightsNB.ResizeTo(0,0); - ClusterWeightsB.ResizeTo(0,0); + clusterWeightsNB.ResizeTo(0,0); + clusterWeightsB.ResizeTo(0,0); if(deleteMCSCov) delete mcsCovariances; return kFALSE; } @@ -733,6 +923,7 @@ void AliMUONTrack::ComputeMCSCovariances(TMatrixD& mcsCovariances) const { /// Compute the multiple scattering covariance matrix /// (assume that track parameters at each cluster are corrects) + AliDebug(1,"Enter ComputeMCSCovariances"); // Reset the size of the covariance matrix if needed Int_t nClusters = GetNClusters(); @@ -767,7 +958,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.; @@ -779,7 +970,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; @@ -821,49 +1012,90 @@ Int_t AliMUONTrack::ClustersInCommon(AliMUONTrack* track) 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; + Int_t nCluster1 = this->GetNClusters(); + Int_t nCluster2 = track->GetNClusters(); Int_t clustersInCommon = 0; AliMUONTrackParam *trackParamAtCluster1, *trackParamAtCluster2; // Loop over clusters of first track - trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->First(); - while (trackParamAtCluster1) { + for(Int_t iCluster1 = 0; iCluster1 < nCluster1; iCluster1++) { + trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->UncheckedAt(iCluster1); // Loop over clusters of second track - trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->First(); - while (trackParamAtCluster2) { + for(Int_t iCluster2 = 0; iCluster2 < nCluster2; iCluster2++) { + trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->UncheckedAt(iCluster2); // Increment "clustersInCommon" if both trackParamAtCluster1 & 2 point to the same cluster if ((trackParamAtCluster1->GetClusterPtr()) == (trackParamAtCluster2->GetClusterPtr())) { - clustersInCommon++; + clustersInCommon++; break; } - trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->After(trackParamAtCluster2); - } // trackParamAtCluster2 - trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->After(trackParamAtCluster1); - } // trackParamAtCluster1 + } + } + return clustersInCommon; +} + + //__________________________________________________________________________ +Int_t AliMUONTrack::ClustersInCommonInSt345(AliMUONTrack* track) const +{ + /// Returns the number of clusters in common on stations 3, 4 and 5 + /// between the current track ("this") and the track pointed to by "track". + if (!fTrackParamAtCluster || !this->fTrackParamAtCluster) return 0; + Int_t nCluster1 = this->GetNClusters(); + Int_t nCluster2 = track->GetNClusters(); + Int_t clustersInCommon = 0; + AliMUONTrackParam *trackParamAtCluster1, *trackParamAtCluster2; + // Loop over clusters of first track + for(Int_t iCluster1 = 0; iCluster1 < nCluster1; iCluster1++) { + trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->UncheckedAt(iCluster1); + if (trackParamAtCluster1->GetClusterPtr()->GetChamberId() < 4) continue; + // Loop over clusters of second track + for(Int_t iCluster2 = 0; iCluster2 < nCluster2; iCluster2++) { + trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->UncheckedAt(iCluster2); + if (trackParamAtCluster2->GetClusterPtr()->GetChamberId() < 4) continue; + // Increment "clustersInCommon" if both trackParamAtCluster1 & 2 point to the same cluster + if ((trackParamAtCluster1->GetClusterPtr()) == (trackParamAtCluster2->GetClusterPtr())) { + clustersInCommon++; + break; + } + } + } 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 1.e10; + Double_t ndf = (Double_t) GetNDF(); + return (ndf > 0.) ? fGlobalChi2 / ndf : 2.*MaxChi2(); } //__________________________________________________________________________ -Bool_t* AliMUONTrack::CompatibleTrack(AliMUONTrack *track, Double_t sigma2Cut) const +Int_t AliMUONTrack::FindCompatibleClusters(AliMUONTrack &track, Double_t sigmaCut, Bool_t compatibleCluster[10]) const { - /// for each chamber: return kTRUE (kFALSE) if clusters are compatible (not compatible) + /// 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. AliMUONTrackParam *trackParamAtCluster1, *trackParamAtCluster2; AliMUONVCluster *cluster1, *cluster2; - Double_t chi2, dX, dY, dZ; - Double_t chi2Max = sigma2Cut * sigma2Cut; - Double_t dZMax = 1.; // 1 cm + Double_t chi2, dX, dY; + Double_t chi2Max = sigmaCut * sigmaCut; - 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 (!track.fTrackParamAtCluster || !this->fTrackParamAtCluster) return nMatchClusters; + // Loop over clusters of first track trackParamAtCluster1 = (AliMUONTrackParam*) this->fTrackParamAtCluster->First(); while (trackParamAtCluster1) { @@ -871,44 +1103,49 @@ Bool_t* AliMUONTrack::CompatibleTrack(AliMUONTrack *track, Double_t sigma2Cut) c cluster1 = trackParamAtCluster1->GetClusterPtr(); // Loop over clusters of second track - trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->First(); + trackParamAtCluster2 = (AliMUONTrackParam*) track.fTrackParamAtCluster->First(); while (trackParamAtCluster2) { cluster2 = trackParamAtCluster2->GetClusterPtr(); //prepare next step - trackParamAtCluster2 = (AliMUONTrackParam*) track->fTrackParamAtCluster->After(trackParamAtCluster2); + trackParamAtCluster2 = (AliMUONTrackParam*) track.fTrackParamAtCluster->After(trackParamAtCluster2); - // z direction - dZ = cluster1->GetZ() - cluster2->GetZ(); - if (dZ > dZMax) continue; + // check DE Id + if (cluster1->GetDetElemId() != cluster2->GetDetElemId()) 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; } //__________________________________________________________________________ -AliMUONTrackParam* AliMUONTrack::GetTrackParamAtVertex() +Bool_t AliMUONTrack::Match(AliMUONTrack &track, Double_t sigmaCut, Int_t &nMatchClusters) const { - /// return reference to track parameters at vertex (create it before if needed) - if (!fTrackParamAtVertex) fTrackParamAtVertex = new AliMUONTrackParam(); - return fTrackParamAtVertex; + /// 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; + } //__________________________________________________________________________ @@ -951,12 +1188,13 @@ void AliMUONTrack::Print(Option_t*) const ", Match2Trig=" << setw(1) << GetMatchTrigger() << ", LoTrgNum=" << setw(3) << GetLoTrgNum() << ", Chi2-tracking-trigger=" << setw(8) << setprecision(5) << GetChi2MatchTrigger(); - cout << Form(" HitTriggerPattern %x",fHitsPatternInTrigCh) << endl; - fTrackParamAtCluster->First()->Print("FULL"); + cout << Form(" HitTriggerPattern %x",fHitsPatternInTrigCh); + cout << Form(" MClabel=%d",fTrackID) << endl; + if (fTrackParamAtCluster) fTrackParamAtCluster->First()->Print("FULL"); } //__________________________________________________________________________ -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 @@ -969,6 +1207,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; + } + + } + + } + }