/// * ValidateTracksWithTrigger to match tracker/trigger tracks
///
/// Several options and adjustable parameters are available for both KALMAN and ORIGINAL
-/// tracking algorithms. They can be changed by using:
-/// AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLow(High)FluxParam();
-/// muonRecoParam->Set...(); // see methods in AliMUONRecoParam.h for details
-/// AliMUONReconstructor::SetRecoParam(muonRecoParam);
+/// tracking algorithms. They can be changed through the AliMUONRecoParam object
+/// set in the reconstruction macro or read from the CDB
+/// (see methods in AliMUONRecoParam.h file for details)
///
/// Main parameters and options are:
/// - *fgkSigmaToCutForTracking* : quality cut used to select new clusters to be
#include "AliMUONVClusterServer.h"
#include "AliMUONVTriggerStore.h"
#include "AliMUONVTriggerTrackStore.h"
+#include "AliMUONRecoParam.h"
+
#include "AliMpDEManager.h"
#include "AliMpArea.h"
+#include "AliMpDDLStore.h"
+#include "AliMpVSegmentation.h"
+#include "AliMpSegmentation.h"
+#include "AliMpPad.h"
+
#include "AliLog.h"
#include "AliCodeTimer.h"
#include "AliTracker.h"
#include <Riostream.h>
+using std::cout;
+using std::endl;
/// \cond CLASSIMP
ClassImp(AliMUONVTrackReconstructor) // Class implementation in ROOT context
/// \endcond
//__________________________________________________________________________
-AliMUONVTrackReconstructor::AliMUONVTrackReconstructor(AliMUONVClusterServer& clusterServer)
- : TObject(),
- fRecTracksPtr(0x0),
- fNRecTracks(0),
- fClusterServer(clusterServer)
+AliMUONVTrackReconstructor::AliMUONVTrackReconstructor(const AliMUONRecoParam* recoParam,
+ AliMUONVClusterServer* clusterServer)
+: TObject(),
+fRecTracksPtr(0x0),
+fNRecTracks(0),
+fClusterServer(clusterServer),
+fkRecoParam(recoParam),
+fMaxMCSAngle2(0x0)
{
/// Constructor for class AliMUONVTrackReconstructor
+ /// WARNING: if clusterServer=0x0, no clusterization will be possible at this level
// Memory allocation for the TClonesArray of reconstructed tracks
fRecTracksPtr = new TClonesArray("AliMUONTrack", 100);
// set the magnetic field for track extrapolations
- const AliMagF* kField = AliTracker::GetFieldMap();
- if (!kField) AliFatal("No field available");
- AliMUONTrackExtrap::SetField(kField);
+ AliMUONTrackExtrap::SetField();
+
+ // set the maximum MCS angle in chamber from the minimum acceptable momentum
+ AliMUONTrackParam param;
+ Double_t inverseBendingP = (GetRecoParam()->GetMinBendingMomentum() > 0.) ? 1./GetRecoParam()->GetMinBendingMomentum() : 1.;
+ param.SetInverseBendingMomentum(inverseBendingP);
+ fMaxMCSAngle2 = new Double_t [AliMUONConstants::NTrackingCh()];
+ for (Int_t iCh=0; iCh<AliMUONConstants::NTrackingCh(); iCh++)
+ fMaxMCSAngle2[iCh] = AliMUONTrackExtrap::GetMCSAngle2(param, AliMUONConstants::ChamberThicknessInX0(iCh), 1.);
+
}
//__________________________________________________________________________
{
/// Destructor for class AliMUONVTrackReconstructor
delete fRecTracksPtr;
+ delete[] fMaxMCSAngle2;
}
//__________________________________________________________________________
{
/// To reconstruct one event
AliDebug(1,"");
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
// Reset array of tracks
ResetTracks();
- // Look for candidates from clusters in stations(1..) 4 and 5
- MakeTrackCandidates(clusterStore);
+ // Look for candidates from clusters in stations(1..) 4 and 5 (abort in case of failure)
+ if (!MakeTrackCandidates(clusterStore)) return;
- // Look for extra candidates from clusters in stations(1..) 4 and 5
- if (AliMUONReconstructor::GetRecoParam()->MakeMoreTrackCandidates()) MakeMoreTrackCandidates(clusterStore);
+ // Look for extra candidates from clusters in stations(1..) 4 and 5 (abort in case of failure)
+ if (GetRecoParam()->MakeMoreTrackCandidates()) {
+ if (!MakeMoreTrackCandidates(clusterStore)) return;
+ }
// Stop tracking if no candidate found
if (fRecTracksPtr->GetEntriesFast() == 0) return;
- // Follow tracks in stations(1..) 3, 2 and 1
- FollowTracks(clusterStore);
+ // Follow tracks in stations(1..) 3, 2 and 1 (abort in case of failure)
+ if (!FollowTracks(clusterStore)) return;
// Complement the reconstructed tracks
- if (AliMUONReconstructor::GetRecoParam()->ComplementTracks()) ComplementTracks(clusterStore);
+ if (GetRecoParam()->ComplementTracks()) {
+ if (ComplementTracks(clusterStore)) RemoveIdenticalTracks();
+ }
// Improve the reconstructed tracks
- if (AliMUONReconstructor::GetRecoParam()->ImproveTracks()) ImproveTracks();
+ if (GetRecoParam()->ImproveTracks()) ImproveTracks();
- // Remove double tracks
- RemoveDoubleTracks();
+ // Remove connected tracks
+ RemoveConnectedTracks(3, 4, kFALSE);
+ RemoveConnectedTracks(2, 2, kFALSE);
+ if (GetRecoParam()->RemoveConnectedTracksInSt12()) RemoveConnectedTracks(0, 1, kFALSE);
// Fill AliMUONTrack data members
Finalize();
+ if (!GetRecoParam()->RemoveConnectedTracksInSt12()) TagConnectedTracks(0, 1, kTRUE);
// Add tracks to MUON data container
- for (Int_t i=0; i<fNRecTracks; ++i)
+ for (Int_t i=0; i<fNRecTracks; ++i)
{
AliMUONTrack * track = (AliMUONTrack*) fRecTracksPtr->At(i);
- track->SetUniqueID(i+1);
- trackStore.Add(*track);
+ if (track->GetGlobalChi2() < AliMUONTrack::MaxChi2()) {
+ track->SetUniqueID(i+1);
+ trackStore.Add(*track);
+ } else AliWarning("problem occur somewhere during track refitting --> discard track");
}
}
- //__________________________________________________________________________
+//__________________________________________________________________________
+Bool_t AliMUONVTrackReconstructor::IsAcceptable(AliMUONTrackParam &trackParam)
+{
+ /// Return kTRUE if the track is within given limits on momentum/angle/origin
+
+ const TMatrixD& kParamCov = trackParam.GetCovariances();
+ Int_t chamber = trackParam.GetClusterPtr()->GetChamberId();
+ Double_t z = trackParam.GetZ();
+ Double_t sigmaCut = GetRecoParam()->GetSigmaCutForTracking();
+
+ // MCS dipersion
+ Double_t angleMCS2 = 0.;
+ Double_t impactMCS2 = 0.;
+ if (AliMUONTrackExtrap::IsFieldON() && chamber < 6) {
+
+ // track momentum is known
+ for (Int_t iCh=0; iCh<=chamber; iCh++) {
+ Double_t localMCS2 = AliMUONTrackExtrap::GetMCSAngle2(trackParam, AliMUONConstants::ChamberThicknessInX0(iCh), 1.);
+ angleMCS2 += localMCS2;
+ impactMCS2 += AliMUONConstants::DefaultChamberZ(chamber) * AliMUONConstants::DefaultChamberZ(chamber) * localMCS2;
+ }
+
+ } else {
+
+ // track momentum is unknown
+ for (Int_t iCh=0; iCh<=chamber; iCh++) {
+ angleMCS2 += fMaxMCSAngle2[iCh];
+ impactMCS2 += AliMUONConstants::DefaultChamberZ(chamber) * AliMUONConstants::DefaultChamberZ(chamber) * fMaxMCSAngle2[iCh];
+ }
+
+ }
+
+ // ------ track selection in non bending direction ------
+ if (GetRecoParam()->SelectOnTrackSlope()) {
+
+ // check if non bending slope is within tolerances
+ Double_t nonBendingSlopeErr = TMath::Sqrt(kParamCov(1,1) + angleMCS2);
+ if ((TMath::Abs(trackParam.GetNonBendingSlope()) - sigmaCut * nonBendingSlopeErr) > GetRecoParam()->GetMaxNonBendingSlope()) return kFALSE;
+
+ } else {
+
+ // or check if non bending impact parameter is within tolerances
+ Double_t nonBendingImpactParam = TMath::Abs(trackParam.GetNonBendingCoor() - z * trackParam.GetNonBendingSlope());
+ Double_t nonBendingImpactParamErr = TMath::Sqrt(kParamCov(0,0) + z * z * kParamCov(1,1) - 2. * z * kParamCov(0,1) + impactMCS2);
+ if ((nonBendingImpactParam - sigmaCut * nonBendingImpactParamErr) > (3. * GetRecoParam()->GetNonBendingVertexDispersion())) return kFALSE;
+
+ }
+
+ // ------ track selection in bending direction ------
+ if (AliMUONTrackExtrap::IsFieldON()) { // depending whether the field is ON or OFF
+
+ // check if bending momentum is within tolerances
+ Double_t bendingMomentum = TMath::Abs(1. / trackParam.GetInverseBendingMomentum());
+ Double_t bendingMomentumErr = TMath::Sqrt(kParamCov(4,4)) * bendingMomentum * bendingMomentum;
+ if (chamber < 6 && (bendingMomentum + sigmaCut * bendingMomentumErr) < GetRecoParam()->GetMinBendingMomentum()) return kFALSE;
+ else if ((bendingMomentum + 3. * bendingMomentumErr) < GetRecoParam()->GetMinBendingMomentum()) return kFALSE;
+
+ } else {
+
+ if (GetRecoParam()->SelectOnTrackSlope()) {
+
+ // check if bending slope is within tolerances
+ Double_t bendingSlopeErr = TMath::Sqrt(kParamCov(3,3) + angleMCS2);
+ if ((TMath::Abs(trackParam.GetBendingSlope()) - sigmaCut * bendingSlopeErr) > GetRecoParam()->GetMaxBendingSlope()) return kFALSE;
+
+ } else {
+
+ // or check if bending impact parameter is within tolerances
+ Double_t bendingImpactParam = TMath::Abs(trackParam.GetBendingCoor() - z * trackParam.GetBendingSlope());
+ Double_t bendingImpactParamErr = TMath::Sqrt(kParamCov(2,2) + z * z * kParamCov(3,3) - 2. * z * kParamCov(2,3) + impactMCS2);
+ if ((bendingImpactParam - sigmaCut * bendingImpactParamErr) > (3. * GetRecoParam()->GetBendingVertexDispersion())) return kFALSE;
+
+ }
+
+ }
+
+ return kTRUE;
+
+}
+
+//__________________________________________________________________________
TClonesArray* AliMUONVTrackReconstructor::MakeSegmentsBetweenChambers(const AliMUONVClusterStore& clusterStore, Int_t ch1, Int_t ch2)
{
/// To make the list of segments from the list of clusters in the 2 given chambers.
- /// Return a new TClonesArray of segments.
- /// It is the responsibility of the user to delete it afterward.
+ /// Return a TClonesArray of new segments (segments made in a previous call of this function are removed).
AliDebug(1,Form("Enter MakeSegmentsBetweenChambers (1..) %d-%d", ch1+1, ch2+1));
+ AliCodeTimerAuto("",0);
AliMUONVCluster *cluster1, *cluster2;
AliMUONObjectPair *segment;
- Double_t nonBendingSlope = 0, bendingSlope = 0, impactParam = 0., bendingMomentum = 0.; // to avoid compilation warning
+ Double_t z1 = 0., z2 = 0., dZ = 0.;
+ Double_t nonBendingSlope = 0., nonBendingSlopeErr = 0., nonBendingImpactParam = 0., nonBendingImpactParamErr = 0.;
+ Double_t bendingSlope = 0., bendingSlopeErr = 0., bendingImpactParam = 0., bendingImpactParamErr = 0., bendingImpactParamErr2 = 0.;
+ Double_t bendingMomentum = 0., bendingMomentumErr = 0.;
+ Double_t bendingVertexDispersion2 = GetRecoParam()->GetBendingVertexDispersion() * GetRecoParam()->GetBendingVertexDispersion();
+ Double_t angleMCS2 = 0.; // maximum angular dispersion**2 due to MCS in chamber
+ Double_t impactMCS2 = 0.; // maximum impact parameter dispersion**2 due to MCS in chamber
+ for (Int_t iCh=0; iCh<=ch1; iCh++) {
+ angleMCS2 += fMaxMCSAngle2[iCh];
+ impactMCS2 += AliMUONConstants::DefaultChamberZ(iCh) * AliMUONConstants::DefaultChamberZ(iCh) * fMaxMCSAngle2[iCh];
+ }
+ Double_t sigmaCut = GetRecoParam()->GetSigmaCutForTracking();
// Create iterators to loop over clusters in both chambers
TIter nextInCh1(clusterStore.CreateChamberIterator(ch1,ch1));
TIter nextInCh2(clusterStore.CreateChamberIterator(ch2,ch2));
// list of segments
- TClonesArray *segments = new TClonesArray("AliMUONObjectPair", 100);
+ static TClonesArray *segments = new TClonesArray("AliMUONObjectPair", 100);
+ segments->Clear("C");
// Loop over clusters in the first chamber of the station
while ( ( cluster1 = static_cast<AliMUONVCluster*>(nextInCh1()) ) ) {
+ z1 = cluster1->GetZ();
// reset cluster iterator of chamber 2
nextInCh2.Reset();
// Loop over clusters in the second chamber of the station
while ( ( cluster2 = static_cast<AliMUONVCluster*>(nextInCh2()) ) ) {
+ z2 = cluster2->GetZ();
+ dZ = z1 - z2;
- // non bending slope
- nonBendingSlope = (cluster1->GetX() - cluster2->GetX()) / (cluster1->GetZ() - cluster2->GetZ());
+ // ------ track selection in non bending direction ------
+ nonBendingSlope = (cluster1->GetX() - cluster2->GetX()) / dZ;
+ if (GetRecoParam()->SelectOnTrackSlope()) {
+
+ // check if non bending slope is within tolerances
+ nonBendingSlopeErr = TMath::Sqrt((cluster1->GetErrX2() + cluster2->GetErrX2()) / dZ / dZ + angleMCS2);
+ if ((TMath::Abs(nonBendingSlope) - sigmaCut * nonBendingSlopeErr) > GetRecoParam()->GetMaxNonBendingSlope()) continue;
+
+ } else {
+
+ // or check if non bending impact parameter is within tolerances
+ nonBendingImpactParam = TMath::Abs(cluster1->GetX() - cluster1->GetZ() * nonBendingSlope);
+ nonBendingImpactParamErr = TMath::Sqrt((z1 * z1 * cluster2->GetErrX2() + z2 * z2 * cluster1->GetErrX2()) / dZ / dZ + impactMCS2);
+ if ((nonBendingImpactParam - sigmaCut * nonBendingImpactParamErr) > (3. * GetRecoParam()->GetNonBendingVertexDispersion())) continue;
+
+ }
- // bending slope
- bendingSlope = (cluster1->GetY() - cluster2->GetY()) / (cluster1->GetZ() - cluster2->GetZ());
+ // ------ track selection in bending direction ------
+ bendingSlope = (cluster1->GetY() - cluster2->GetY()) / dZ;
+ if (AliMUONTrackExtrap::IsFieldON()) { // depending whether the field is ON or OFF
+
+ // check if bending momentum is within tolerances
+ bendingImpactParam = cluster1->GetY() - cluster1->GetZ() * bendingSlope;
+ bendingImpactParamErr2 = (z1 * z1 * cluster2->GetErrY2() + z2 * z2 * cluster1->GetErrY2()) / dZ / dZ + impactMCS2;
+ bendingMomentum = TMath::Abs(AliMUONTrackExtrap::GetBendingMomentumFromImpactParam(bendingImpactParam));
+ bendingMomentumErr = TMath::Sqrt((bendingVertexDispersion2 + bendingImpactParamErr2) /
+ bendingImpactParam / bendingImpactParam + 0.01) * bendingMomentum;
+ if ((bendingMomentum + 3. * bendingMomentumErr) < GetRecoParam()->GetMinBendingMomentum()) continue;
+
+ } else {
+
+ if (GetRecoParam()->SelectOnTrackSlope()) {
+
+ // check if bending slope is within tolerances
+ bendingSlopeErr = TMath::Sqrt((cluster1->GetErrY2() + cluster2->GetErrY2()) / dZ / dZ + angleMCS2);
+ if ((TMath::Abs(bendingSlope) - sigmaCut * bendingSlopeErr) > GetRecoParam()->GetMaxBendingSlope()) continue;
+
+ } else {
+
+ // or check if bending impact parameter is within tolerances
+ bendingImpactParam = TMath::Abs(cluster1->GetY() - cluster1->GetZ() * bendingSlope);
+ bendingImpactParamErr = TMath::Sqrt((z1 * z1 * cluster2->GetErrY2() + z2 * z2 * cluster1->GetErrY2()) / dZ / dZ + impactMCS2);
+ if ((bendingImpactParam - sigmaCut * bendingImpactParamErr) > (3. * GetRecoParam()->GetBendingVertexDispersion())) continue;
+
+ }
+
+ }
- // impact parameter
- impactParam = cluster1->GetY() - cluster1->GetZ() * bendingSlope;
-
- // absolute value of bending momentum
- bendingMomentum = TMath::Abs(AliMUONTrackExtrap::GetBendingMomentumFromImpactParam(impactParam));
+ // make new segment
+ segment = new ((*segments)[segments->GetLast()+1]) AliMUONObjectPair(cluster1, cluster2, kFALSE, kFALSE);
- // check for non bending slope and bending momentum within tolerances
- if (TMath::Abs(nonBendingSlope) < AliMUONReconstructor::GetRecoParam()->GetMaxNonBendingSlope() &&
- bendingMomentum < AliMUONReconstructor::GetRecoParam()->GetMaxBendingMomentum() &&
- bendingMomentum > AliMUONReconstructor::GetRecoParam()->GetMinBendingMomentum()) {
-
- // make new segment
- segment = new ((*segments)[segments->GetLast()+1]) AliMUONObjectPair(cluster1, cluster2, kFALSE, kFALSE);
-
- // Printout for debug
- if (AliLog::GetGlobalDebugLevel() > 1) {
- cout << "segmentIndex(0...): " << segments->GetLast() << endl;
- segment->Dump();
- cout << "Cluster in first chamber" << endl;
- cluster1->Print();
- cout << "Cluster in second chamber" << endl;
- cluster2->Print();
- }
-
+ // Printout for debug
+ if (AliLog::GetGlobalDebugLevel() > 1) {
+ cout << "segmentIndex(0...): " << segments->GetLast() << endl;
+ segment->Dump();
+ cout << "Cluster in first chamber" << endl;
+ cluster1->Print();
+ cout << "Cluster in second chamber" << endl;
+ cluster2->Print();
}
}
return segments;
}
+ //__________________________________________________________________________
+void AliMUONVTrackReconstructor::RemoveUsedSegments(TClonesArray& segments)
+{
+ /// To remove pairs of clusters already attached to a track
+ AliDebug(1,"Enter RemoveUsedSegments");
+ Int_t nSegments = segments.GetEntriesFast();
+ Int_t nTracks = fRecTracksPtr->GetEntriesFast();
+ AliMUONObjectPair *segment;
+ AliMUONTrack *track;
+ AliMUONVCluster *cluster, *cluster1, *cluster2;
+ Bool_t foundCluster1, foundCluster2, removeSegment;
+
+ // Loop over segments
+ for (Int_t iSegment=0; iSegment<nSegments; iSegment++) {
+ segment = (AliMUONObjectPair*) segments.UncheckedAt(iSegment);
+
+ cluster1 = (AliMUONVCluster*) segment->First();
+ cluster2 = (AliMUONVCluster*) segment->Second();
+ removeSegment = kFALSE;
+
+ // Loop over tracks
+ for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
+ track = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iTrack);
+
+ // skip empty slot
+ if (!track) continue;
+
+ foundCluster1 = kFALSE;
+ foundCluster2 = kFALSE;
+
+ // Loop over clusters
+ Int_t nClusters = track->GetNClusters();
+ for (Int_t iCluster = 0; iCluster < nClusters; iCluster++) {
+ cluster = ((AliMUONTrackParam*) track->GetTrackParamAtCluster()->UncheckedAt(iCluster))->GetClusterPtr();
+
+ // check if both clusters are in that track
+ if (cluster == cluster1) foundCluster1 = kTRUE;
+ else if (cluster == cluster2) foundCluster2 = kTRUE;
+
+ if (foundCluster1 && foundCluster2) {
+ removeSegment = kTRUE;
+ break;
+ }
+
+ }
+
+ if (removeSegment) break;
+
+ }
+
+ if (removeSegment) segments.RemoveAt(iSegment);
+
+ }
+
+ segments.Compress();
+
+ // Printout for debug
+ AliDebug(1,Form("NSegments = %d ", segments.GetEntriesFast()));
+}
+
//__________________________________________________________________________
void AliMUONVTrackReconstructor::RemoveIdenticalTracks()
{
/// To remove identical tracks:
/// Tracks are considered identical if they have all their clusters in common.
/// One keeps the track with the larger number of clusters if need be
- AliMUONTrack *track1, *track2, *trackToRemove;
+ AliMUONTrack *track1, *track2;
+ Int_t nTracks = fRecTracksPtr->GetEntriesFast();
Int_t clustersInCommon, nClusters1, nClusters2;
- Bool_t removedTrack1;
// Loop over first track of the pair
- track1 = (AliMUONTrack*) fRecTracksPtr->First();
- while (track1) {
- removedTrack1 = kFALSE;
+ for (Int_t iTrack1 = 0; iTrack1 < nTracks; iTrack1++) {
+ track1 = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iTrack1);
+ // skip empty slot
+ if (!track1) continue;
nClusters1 = track1->GetNClusters();
// Loop over second track of the pair
- track2 = (AliMUONTrack*) fRecTracksPtr->After(track1);
- while (track2) {
+ for (Int_t iTrack2 = iTrack1+1; iTrack2 < nTracks; iTrack2++) {
+ track2 = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iTrack2);
+ // skip empty slot
+ if (!track2) continue;
nClusters2 = track2->GetNClusters();
// number of clusters in common between two tracks
clustersInCommon = track1->ClustersInCommon(track2);
// decide which track to remove
if (nClusters2 > nClusters1) {
// remove track1 and continue the first loop with the track next to track1
- trackToRemove = track1;
- track1 = (AliMUONTrack*) fRecTracksPtr->After(track1);
- fRecTracksPtr->Remove(trackToRemove);
- fRecTracksPtr->Compress(); // this is essential to retrieve the TClonesArray afterwards
+ fRecTracksPtr->RemoveAt(iTrack1);
fNRecTracks--;
- removedTrack1 = kTRUE;
break;
} else {
// remove track2 and continue the second loop with the track next to track2
- trackToRemove = track2;
- track2 = (AliMUONTrack*) fRecTracksPtr->After(track2);
- fRecTracksPtr->Remove(trackToRemove);
- fRecTracksPtr->Compress(); // this is essential to retrieve the TClonesArray afterwards
+ fRecTracksPtr->RemoveAt(iTrack2);
fNRecTracks--;
}
- } else track2 = (AliMUONTrack*) fRecTracksPtr->After(track2);
+ }
} // track2
- if (removedTrack1) continue;
- track1 = (AliMUONTrack*) fRecTracksPtr->After(track1);
} // track1
- return;
+ fRecTracksPtr->Compress(); // this is essential to retrieve the TClonesArray afterwards
}
//__________________________________________________________________________
/// which has the smaller number of clusters are in common with the other track.
/// Among two identical tracks, one keeps the track with the larger number of clusters
/// or, if these numbers are equal, the track with the minimum chi2.
- AliMUONTrack *track1, *track2, *trackToRemove;
- Int_t clustersInCommon, nClusters1, nClusters2;
- Bool_t removedTrack1;
+ AliMUONTrack *track1, *track2;
+ Int_t nTracks = fRecTracksPtr->GetEntriesFast();
+ Int_t clustersInCommon2, nClusters1, nClusters2;
// Loop over first track of the pair
- track1 = (AliMUONTrack*) fRecTracksPtr->First();
- while (track1) {
- removedTrack1 = kFALSE;
+ for (Int_t iTrack1 = 0; iTrack1 < nTracks; iTrack1++) {
+ track1 = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iTrack1);
+ // skip empty slot
+ if (!track1) continue;
nClusters1 = track1->GetNClusters();
// Loop over second track of the pair
- track2 = (AliMUONTrack*) fRecTracksPtr->After(track1);
- while (track2) {
+ for (Int_t iTrack2 = iTrack1+1; iTrack2 < nTracks; iTrack2++) {
+ track2 = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iTrack2);
+ // skip empty slot
+ if (!track2) continue;
nClusters2 = track2->GetNClusters();
// number of clusters in common between two tracks
- clustersInCommon = track1->ClustersInCommon(track2);
+ clustersInCommon2 = 2 * track1->ClustersInCommon(track2);
// check for identical tracks
- if (((nClusters1 < nClusters2) && (2 * clustersInCommon > nClusters1)) || (2 * clustersInCommon > nClusters2)) {
+ if (clustersInCommon2 > nClusters1 || clustersInCommon2 > nClusters2) {
// decide which track to remove
if ((nClusters1 > nClusters2) || ((nClusters1 == nClusters2) && (track1->GetGlobalChi2() <= track2->GetGlobalChi2()))) {
// remove track2 and continue the second loop with the track next to track2
- trackToRemove = track2;
- track2 = (AliMUONTrack*) fRecTracksPtr->After(track2);
- fRecTracksPtr->Remove(trackToRemove);
- fRecTracksPtr->Compress(); // this is essential to retrieve the TClonesArray afterwards
+ fRecTracksPtr->RemoveAt(iTrack2);
fNRecTracks--;
} else {
// else remove track1 and continue the first loop with the track next to track1
- trackToRemove = track1;
- track1 = (AliMUONTrack*) fRecTracksPtr->After(track1);
- fRecTracksPtr->Remove(trackToRemove);
- fRecTracksPtr->Compress(); // this is essential to retrieve the TClonesArray afterwards
+ fRecTracksPtr->RemoveAt(iTrack1);
fNRecTracks--;
- removedTrack1 = kTRUE;
break;
}
- } else track2 = (AliMUONTrack*) fRecTracksPtr->After(track2);
+ }
} // track2
- if (removedTrack1) continue;
- track1 = (AliMUONTrack*) fRecTracksPtr->After(track1);
} // track1
- return;
+ fRecTracksPtr->Compress(); // this is essential to retrieve the TClonesArray afterwards
+}
+
+ //__________________________________________________________________________
+void AliMUONVTrackReconstructor::RemoveConnectedTracks(Int_t stMin, Int_t stMax, Bool_t all)
+{
+ /// Find and remove tracks sharing 1 cluster or more in station(s) [stMin, stMax].
+ /// For each couple of connected tracks, one removes the one with the smallest
+ /// number of clusters or with the highest chi2 value in case of equality.
+ /// If all=kTRUE: both tracks are removed.
+
+ // tag the tracks to be removed
+ TagConnectedTracks(stMin, stMax, all);
+
+ // remove them
+ Int_t nTracks = fRecTracksPtr->GetEntriesFast();
+ for (Int_t i = 0; i < nTracks; i++) {
+ if (((AliMUONTrack*) fRecTracksPtr->UncheckedAt(i))->IsConnected()) {
+ fRecTracksPtr->RemoveAt(i);
+ fNRecTracks--;
+ }
+ }
+
+ // remove holes in the array if any
+ fRecTracksPtr->Compress();
+}
+
+ //__________________________________________________________________________
+void AliMUONVTrackReconstructor::TagConnectedTracks(Int_t stMin, Int_t stMax, Bool_t all)
+{
+ /// Find and tag tracks sharing 1 cluster or more in station(s) [stMin, stMax].
+ /// For each couple of connected tracks, one tags the one with the smallest
+ /// number of clusters or with the highest chi2 value in case of equality.
+ /// If all=kTRUE: both tracks are tagged.
+
+ AliMUONTrack *track1, *track2;
+ Int_t nClusters1, nClusters2;
+ Int_t nTracks = fRecTracksPtr->GetEntriesFast();
+
+ // reset the tags
+ for (Int_t i = 0; i < nTracks; i++) ((AliMUONTrack*) fRecTracksPtr->UncheckedAt(i))->Connected(kFALSE);
+
+ // Loop over first track of the pair
+ for (Int_t iTrack1 = 0; iTrack1 < nTracks; iTrack1++) {
+ track1 = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iTrack1);
+
+ // Loop over second track of the pair
+ for (Int_t iTrack2 = iTrack1+1; iTrack2 < nTracks; iTrack2++) {
+ track2 = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iTrack2);
+
+ // check for connected tracks and tag them
+ if (track1->ClustersInCommon(track2, stMin, stMax) > 0) {
+
+ if (all) {
+
+ // tag both tracks
+ track1->Connected();
+ track2->Connected();
+
+ } else {
+
+ // tag only the worst track
+ nClusters1 = track1->GetNClusters();
+ nClusters2 = track2->GetNClusters();
+ if ((nClusters1 > nClusters2) || ((nClusters1 == nClusters2) && (track1->GetGlobalChi2() <= track2->GetGlobalChi2()))) {
+ track2->Connected();
+ } else {
+ track1->Connected();
+ }
+
+ }
+
+ }
+
+ }
+
+ }
+
}
//__________________________________________________________________________
/// Ask the clustering to reconstruct new clusters around the track candidate position
// check if the current chamber is useable
- if (!AliMUONReconstructor::GetRecoParam()->UseChamber(chamber)) return;
+ if (!fClusterServer || !GetRecoParam()->UseChamber(chamber)) return;
// maximum distance between the center of the chamber and a detection element
// (accounting for the inclination of the chamber)
- static const Double_t gkMaxDZ = 15.; // 15 cm
+ static const Double_t kMaxDZ = 15.; // 15 cm
// extrapolate track parameters to the chamber
AliMUONTrackParam extrapTrackParam(trackParam);
- AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParam, AliMUONConstants::DefaultChamberZ(chamber));
+ if (!AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParam, AliMUONConstants::DefaultChamberZ(chamber))) return;
- // build the searching area using the track resolution and the maximum-distance-to-track value
+ // build the searching area using the track and chamber resolutions and the maximum-distance-to-track value
const TMatrixD& kParamCov = extrapTrackParam.GetCovariances();
- Double_t errX2 = kParamCov(0,0) + gkMaxDZ * gkMaxDZ * kParamCov(1,1) + 2. * gkMaxDZ * TMath::Abs(kParamCov(0,1));
- Double_t errY2 = kParamCov(2,2) + gkMaxDZ * gkMaxDZ * kParamCov(3,3) + 2. * gkMaxDZ * TMath::Abs(kParamCov(2,3));
- Double_t dX = TMath::Abs(trackParam.GetNonBendingSlope()) * gkMaxDZ +
- AliMUONReconstructor::GetRecoParam()->GetMaxNonBendingDistanceToTrack() +
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errX2);
- Double_t dY = TMath::Abs(trackParam.GetBendingSlope()) * gkMaxDZ +
- AliMUONReconstructor::GetRecoParam()->GetMaxBendingDistanceToTrack() +
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errY2);
- TVector2 dimensions(dX, dY);
- TVector2 position(extrapTrackParam.GetNonBendingCoor(), extrapTrackParam.GetBendingCoor());
- AliMpArea area(position, dimensions);
+ Double_t errX2 = kParamCov(0,0) + kMaxDZ * kMaxDZ * kParamCov(1,1) + 2. * kMaxDZ * TMath::Abs(kParamCov(0,1)) +
+ GetRecoParam()->GetDefaultNonBendingReso(chamber) * GetRecoParam()->GetDefaultNonBendingReso(chamber);
+ Double_t errY2 = kParamCov(2,2) + kMaxDZ * kMaxDZ * kParamCov(3,3) + 2. * kMaxDZ * TMath::Abs(kParamCov(2,3)) +
+ GetRecoParam()->GetDefaultBendingReso(chamber) * GetRecoParam()->GetDefaultBendingReso(chamber);
+ Double_t dX = TMath::Abs(trackParam.GetNonBendingSlope()) * kMaxDZ +
+ GetRecoParam()->GetMaxNonBendingDistanceToTrack() +
+ GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(2. * errX2);
+ Double_t dY = TMath::Abs(trackParam.GetBendingSlope()) * kMaxDZ +
+ GetRecoParam()->GetMaxBendingDistanceToTrack() +
+ GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(2. * errY2);
+ AliMpArea area(extrapTrackParam.GetNonBendingCoor(),
+ extrapTrackParam.GetBendingCoor(),
+ dX, dY);
// ask to cluterize in the given area of the given chamber
- fClusterServer.Clusterize(chamber, clusterStore, area);
+ fClusterServer->Clusterize(chamber, clusterStore, area, GetRecoParam());
}
/// return trackParamAtCluster
// extrapolate track parameters and covariances at the z position of the tested cluster
+ // and set pointer to cluster into trackParamAtCluster
trackParamAtCluster = trackParam;
- AliMUONTrackExtrap::ExtrapToZCov(&trackParamAtCluster, cluster->GetZ(), updatePropagator);
-
- // set pointer to cluster into trackParamAtCluster
trackParamAtCluster.SetClusterPtr(cluster);
+ if (!AliMUONTrackExtrap::ExtrapToZCov(&trackParamAtCluster, cluster->GetZ(), updatePropagator))
+ return 2.*AliMUONTrack::MaxChi2();
// Set differences between trackParam and cluster in the bending and non bending directions
Double_t dX = cluster->GetX() - trackParamAtCluster.GetNonBendingCoor();
const TMatrixD& kParamCov = trackParamAtCluster.GetCovariances();
Double_t sigmaX2 = kParamCov(0,0) + cluster->GetErrX2();
Double_t sigmaY2 = kParamCov(2,2) + cluster->GetErrY2();
+ Double_t covXY = kParamCov(0,2);
+ Double_t det = sigmaX2 * sigmaY2 - covXY * covXY;
// Compute chi2
- return dX * dX / sigmaX2 + dY * dY / sigmaY2;
+ if (det == 0.) return 2.*AliMUONTrack::MaxChi2();
+ return (dX * dX * sigmaY2 + dY * dY * sigmaX2 - 2. * dX * dY * covXY) / det;
}
//__________________________________________________________________________
-Bool_t AliMUONVTrackReconstructor::TryOneClusterFast(const AliMUONTrackParam &trackParam, AliMUONVCluster* cluster)
+Bool_t AliMUONVTrackReconstructor::TryOneClusterFast(const AliMUONTrackParam &trackParam, const AliMUONVCluster* cluster)
{
/// Test the compatibility between the track and the cluster
-/// given the track resolution + the maximum-distance-to-track value
+/// given the track and cluster resolutions + the maximum-distance-to-track value
/// and assuming linear propagation of the track:
/// return kTRUE if they are compatibles
Double_t dX = cluster->GetX() - (trackParam.GetNonBendingCoor() + trackParam.GetNonBendingSlope() * dZ);
Double_t dY = cluster->GetY() - (trackParam.GetBendingCoor() + trackParam.GetBendingSlope() * dZ);
const TMatrixD& kParamCov = trackParam.GetCovariances();
- Double_t errX2 = kParamCov(0,0) + dZ * dZ * kParamCov(1,1) + 2. * dZ * kParamCov(0,1);
- Double_t errY2 = kParamCov(2,2) + dZ * dZ * kParamCov(3,3) + 2. * dZ * kParamCov(2,3);
+ Double_t errX2 = kParamCov(0,0) + dZ * dZ * kParamCov(1,1) + 2. * dZ * kParamCov(0,1) + cluster->GetErrX2();
+ Double_t errY2 = kParamCov(2,2) + dZ * dZ * kParamCov(3,3) + 2. * dZ * kParamCov(2,3) + cluster->GetErrY2();
- Double_t dXmax = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errX2) +
- AliMUONReconstructor::GetRecoParam()->GetMaxNonBendingDistanceToTrack();
- Double_t dYmax = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errY2) +
- AliMUONReconstructor::GetRecoParam()->GetMaxBendingDistanceToTrack();
+ Double_t dXmax = GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(2. * errX2) +
+ GetRecoParam()->GetMaxNonBendingDistanceToTrack();
+ Double_t dYmax = GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(2. * errY2) +
+ GetRecoParam()->GetMaxBendingDistanceToTrack();
if (TMath::Abs(dX) > dXmax || TMath::Abs(dY) > dYmax) return kFALSE;
// extrapolate linearly track parameters and covariances at the z position of the second cluster
trackParamAtCluster2 = trackParamAtCluster1;
- AliMUONTrackExtrap::LinearExtrapToZ(&trackParamAtCluster2, cluster2->GetZ());
+ AliMUONTrackExtrap::LinearExtrapToZCov(&trackParamAtCluster2, cluster2->GetZ());
// set pointer to cluster2 into trackParamAtCluster2
trackParamAtCluster2.SetClusterPtr(cluster2);
// Compute chi2
Double_t detX = sigma2X1 * sigma2X2 - covX1X2 * covX1X2;
Double_t detY = sigma2Y1 * sigma2Y2 - covY1Y2 * covY1Y2;
- if (detX == 0. || detY == 0.) return 1.e10;
+ if (detX == 0. || detY == 0.) return 2.*AliMUONTrack::MaxChi2();
return (dX1 * dX1 * sigma2X2 + dX2 * dX2 * sigma2X1 - 2. * dX1 * dX2 * covX1X2) / detX
+ (dY1 * dY1 * sigma2Y2 + dY2 * dY2 * sigma2Y1 - 2. * dY1 * dY2 * covY1Y2) / detY;
/// return kTRUE if new cluster(s) have been found (otherwise return kFALSE)
AliDebug(1,Form("Enter FollowLinearTrackInChamber(1..) %d", nextChamber+1));
- Double_t chi2WithOneCluster = 1.e10;
- Double_t maxChi2WithOneCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Double_t chi2WithOneCluster = AliMUONTrack::MaxChi2();
+ Double_t maxChi2WithOneCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
Double_t bestChi2WithOneCluster = maxChi2WithOneCluster;
Bool_t foundOneCluster = kFALSE;
AliMUONTrack *newTrack = 0x0;
}
// Add MCS effect
- AliMUONTrackExtrap::AddMCSEffect(&trackParam,AliMUONConstants::ChamberThicknessInX0(),1.);
+ AliMUONTrackExtrap::AddMCSEffect(&trackParam,AliMUONConstants::ChamberThicknessInX0(trackParam.GetClusterPtr()->GetChamberId()),-1.);
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
// try to add the current cluster accuratly
extrapTrackParamAtCluster = trackParam;
- AliMUONTrackExtrap::LinearExtrapToZ(&extrapTrackParamAtCluster, cluster->GetZ());
+ AliMUONTrackExtrap::LinearExtrapToZCov(&extrapTrackParamAtCluster, cluster->GetZ());
chi2WithOneCluster = TryOneCluster(extrapTrackParamAtCluster, cluster, extrapTrackParamAtCluster);
// if good chi2 then consider to add cluster
cluster->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextChamber/2))
+ if (GetRecoParam()->RequestStation(nextChamber/2))
extrapTrackParamAtCluster.SetRemovable(kFALSE);
else extrapTrackParamAtCluster.SetRemovable(kTRUE);
newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster,*cluster);
+ newTrack->SetGlobalChi2(trackCandidate.GetGlobalChi2()+chi2WithOneCluster);
fNRecTracks++;
// Printout for debuging
}
// fill out the best track if required else clean up the fRecTracksPtr array
- if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (!GetRecoParam()->TrackAllTracks()) {
if (foundOneCluster) {
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextChamber/2))
+ if (GetRecoParam()->RequestStation(nextChamber/2))
bestTrackParamAtCluster.SetRemovable(kFALSE);
else bestTrackParamAtCluster.SetRemovable(kTRUE);
trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster,*(bestTrackParamAtCluster.GetClusterPtr()));
+ trackCandidate.SetGlobalChi2(trackCandidate.GetGlobalChi2()+bestChi2WithOneCluster);
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
ch2 = 2*nextStation+1;
}
- Double_t chi2WithOneCluster = 1.e10;
- Double_t chi2WithTwoClusters = 1.e10;
- Double_t maxChi2WithOneCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
- Double_t maxChi2WithTwoClusters = 4. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 4 because 4 quantities in chi2
+ Double_t chi2WithOneCluster = AliMUONTrack::MaxChi2();
+ Double_t chi2WithTwoClusters = AliMUONTrack::MaxChi2();
+ Double_t maxChi2WithOneCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Double_t maxChi2WithTwoClusters = 4. * GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking(); // 4 because 4 quantities in chi2
Double_t bestChi2WithOneCluster = maxChi2WithOneCluster;
Double_t bestChi2WithTwoClusters = maxChi2WithTwoClusters;
Bool_t foundOneCluster = kFALSE;
}
// Add MCS effect
- AliMUONTrackExtrap::AddMCSEffect(&trackParam,AliMUONConstants::ChamberThicknessInX0(),1.);
+ AliMUONTrackExtrap::AddMCSEffect(&trackParam,AliMUONConstants::ChamberThicknessInX0(trackParam.GetClusterPtr()->GetChamberId()),-1.);
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
// try to add the current cluster accuratly
extrapTrackParamAtCluster2 = trackParam;
- AliMUONTrackExtrap::LinearExtrapToZ(&extrapTrackParamAtCluster2, clusterCh2->GetZ());
+ AliMUONTrackExtrap::LinearExtrapToZCov(&extrapTrackParamAtCluster2, clusterCh2->GetZ());
chi2WithOneCluster = TryOneCluster(extrapTrackParamAtCluster2, clusterCh2, extrapTrackParamAtCluster2);
// if good chi2 then try to attach a cluster in the other chamber too
}
// add MCS effect
- AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCluster2,AliMUONConstants::ChamberThicknessInX0(),1.);
+ AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCluster2,AliMUONConstants::ChamberThicknessInX0(ch2),-1.);
// reset cluster iterator of chamber 1
nextInCh1.Reset();
clusterCh1->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new clusters
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
extrapTrackParamAtCluster1.SetRemovable(kTRUE);
newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster1,*clusterCh1);
extrapTrackParamAtCluster2.SetRemovable(kTRUE);
newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster2,*clusterCh2);
+ newTrack->SetGlobalChi2(newTrack->GetGlobalChi2()+chi2WithTwoClusters);
fNRecTracks++;
// Tag clusterCh1 as used
if (!foundSecondCluster) {
foundOneCluster = kTRUE;
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextStation))
+ if (GetRecoParam()->RequestStation(nextStation))
extrapTrackParamAtCluster2.SetRemovable(kFALSE);
else extrapTrackParamAtCluster2.SetRemovable(kTRUE);
newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster2,*clusterCh2);
+ newTrack->SetGlobalChi2(newTrack->GetGlobalChi2()+chi2WithOneCluster);
fNRecTracks++;
// Printout for debuging
// look for candidates in chamber 1 not already attached to a track
// if we want to keep all possible tracks or if no good couple of clusters has been found
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
+ if (GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
}
//Extrapolate trackCandidate to chamber "ch2"
- AliMUONTrackExtrap::LinearExtrapToZ(&trackParam, AliMUONConstants::DefaultChamberZ(ch2));
+ AliMUONTrackExtrap::LinearExtrapToZCov(&trackParam, AliMUONConstants::DefaultChamberZ(ch2));
// add MCS effect for next step
- AliMUONTrackExtrap::AddMCSEffect(&trackParam,AliMUONConstants::ChamberThicknessInX0(),1.);
+ AliMUONTrackExtrap::AddMCSEffect(&trackParam,AliMUONConstants::ChamberThicknessInX0(ch2),-1.);
// reset cluster iterator of chamber 1
nextInCh1.Reset();
// try to add the current cluster accuratly
extrapTrackParamAtCluster1 = trackParam;
- AliMUONTrackExtrap::LinearExtrapToZ(&extrapTrackParamAtCluster1, clusterCh1->GetZ());
+ AliMUONTrackExtrap::LinearExtrapToZCov(&extrapTrackParamAtCluster1, clusterCh1->GetZ());
chi2WithOneCluster = TryOneCluster(extrapTrackParamAtCluster1, clusterCh1, extrapTrackParamAtCluster1);
// if good chi2 then consider to add clusterCh1
clusterCh1->Print();
}
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (GetRecoParam()->TrackAllTracks()) {
// copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextStation))
+ if (GetRecoParam()->RequestStation(nextStation))
extrapTrackParamAtCluster1.SetRemovable(kFALSE);
else extrapTrackParamAtCluster1.SetRemovable(kTRUE);
newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster1,*clusterCh1);
+ newTrack->SetGlobalChi2(newTrack->GetGlobalChi2()+chi2WithOneCluster);
fNRecTracks++;
// Printout for debuging
}
// fill out the best track if required else clean up the fRecTracksPtr array
- if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
+ if (!GetRecoParam()->TrackAllTracks()) {
if (foundTwoClusters) {
bestTrackParamAtCluster1.SetRemovable(kTRUE);
trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster1,*(bestTrackParamAtCluster1.GetClusterPtr()));
bestTrackParamAtCluster2.SetRemovable(kTRUE);
trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster2,*(bestTrackParamAtCluster2.GetClusterPtr()));
+ trackCandidate.SetGlobalChi2(trackCandidate.GetGlobalChi2()+bestChi2WithTwoClusters);
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
}
} else if (foundOneCluster) {
- if (AliMUONReconstructor::GetRecoParam()->RequestStation(nextStation))
+ if (GetRecoParam()->RequestStation(nextStation))
bestTrackParamAtCluster1.SetRemovable(kFALSE);
else bestTrackParamAtCluster1.SetRemovable(kTRUE);
trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster1,*(bestTrackParamAtCluster1.GetClusterPtr()));
+ trackCandidate.SetGlobalChi2(trackCandidate.GetGlobalChi2()+bestChi2WithOneCluster);
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
//__________________________________________________________________________
void AliMUONVTrackReconstructor::Finalize()
{
- /// Recompute track parameters and covariances at each attached cluster from those at the first one
+ /// Recompute track parameters and covariances at each attached cluster
+ /// Set the label pointing to the corresponding MC track
+ /// Remove the track if finalization failed
- AliMUONTrack *track;
+ AliMUONTrack *track, *nextTrack;
+ Bool_t trackRemoved = kFALSE;
track = (AliMUONTrack*) fRecTracksPtr->First();
while (track) {
- FinalizeTrack(*track);
+ nextTrack = (AliMUONTrack*) fRecTracksPtr->After(track);
- track = (AliMUONTrack*) fRecTracksPtr->After(track);
+ if (FinalizeTrack(*track)) track->FindMCLabel();
+ else {
+ fRecTracksPtr->Remove(track);
+ fNRecTracks--;
+ trackRemoved = kTRUE;
+ }
+
+ track = nextTrack;
}
+ // compress array of tracks if needed
+ if (trackRemoved) fRecTracksPtr->Compress();
+
}
//__________________________________________________________________________
const AliMUONTrackHitPattern& trackHitPattern)
{
/// Try to match track from tracking system with trigger track
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
trackHitPattern.ExecuteValidation(trackStore, triggerTrackStore, triggerStore);
}
- //__________________________________________________________________________
+
+//__________________________________________________________________________
void AliMUONVTrackReconstructor::EventReconstructTrigger(const AliMUONTriggerCircuit& circuit,
const AliMUONVTriggerStore& triggerStore,
AliMUONVTriggerTrackStore& triggerTrackStore)
{
- /// To make the trigger tracks from Local Trigger
+ /// Fill trigger track store from local trigger
AliDebug(1, "");
- AliCodeTimerAuto("");
-
+ AliCodeTimerAuto("",0);
+
AliMUONGlobalTrigger* globalTrigger = triggerStore.Global();
UChar_t gloTrigPat = 0;
gloTrigPat = globalTrigger->GetGlobalResponse();
}
+ AliMUONTriggerTrack triggerTrack;
+
TIter next(triggerStore.CreateIterator());
AliMUONLocalTrigger* locTrg(0x0);
-
- Float_t z11 = AliMUONConstants::DefaultChamberZ(10);
- Float_t z21 = AliMUONConstants::DefaultChamberZ(12);
-
- AliMUONTriggerTrack triggerTrack;
while ( ( locTrg = static_cast<AliMUONLocalTrigger*>(next()) ) )
{
- Bool_t xTrig=locTrg->IsTrigX();
- Bool_t yTrig=locTrg->IsTrigY();
-
- Int_t localBoardId = locTrg->LoCircuit();
-
- if (xTrig && yTrig)
+ if ( locTrg->IsTrigX() && locTrg->IsTrigY() )
{ // make Trigger Track if trigger in X and Y
- Float_t y11 = circuit.GetY11Pos(localBoardId, locTrg->LoStripX());
- // need first to convert deviation to [0-30]
- // (see AliMUONLocalTriggerBoard::LocalTrigger)
- Int_t deviation = locTrg->GetDeviation();
- Int_t stripX21 = locTrg->LoStripX()+deviation+1;
- Float_t y21 = circuit.GetY21Pos(localBoardId, stripX21);
- Float_t x11 = circuit.GetX11Pos(localBoardId, locTrg->LoStripY());
-
- AliDebug(1, Form(" MakeTriggerTrack %d %d %d %d %f %f %f \n",locTrg->LoCircuit(),
- locTrg->LoStripX(),locTrg->LoStripX()+locTrg->LoDev()+1,locTrg->LoStripY(),y11, y21, x11));
-
- Float_t thetax = TMath::ATan2( x11 , z11 );
- Float_t thetay = TMath::ATan2( (y21-y11) , (z21-z11) );
-
- triggerTrack.SetX11(x11);
- triggerTrack.SetY11(y11);
- triggerTrack.SetThetax(thetax);
- triggerTrack.SetThetay(thetay);
- triggerTrack.SetGTPattern(gloTrigPat);
- triggerTrack.SetLoTrgNum(localBoardId);
-
+ TriggerToTrack(circuit, *locTrg, triggerTrack, gloTrigPat);
+
triggerTrackStore.Add(triggerTrack);
} // board is fired
} // end of loop on Local Trigger
}
+//__________________________________________________________________________
+void AliMUONVTrackReconstructor::TriggerToTrack(const AliMUONTriggerCircuit& circuit,
+ const AliMUONLocalTrigger& locTrg,
+ AliMUONTriggerTrack& triggerTrack,
+ UChar_t globalTriggerPattern)
+{
+ /// To make the trigger tracks from Local Trigger
+ const Double_t kTrigNonBendReso = AliMUONConstants::TriggerNonBendingReso();
+ const Double_t kTrigBendReso = AliMUONConstants::TriggerBendingReso();
+ const Double_t kSqrt12 = TMath::Sqrt(12.);
+
+ TMatrixD trigCov(3,3);
+
+ Int_t localBoardId = locTrg.LoCircuit();
+
+ Float_t y11 = circuit.GetY11Pos(localBoardId, locTrg.LoStripX());
+ Float_t z11 = circuit.GetZ11Pos(localBoardId, locTrg.LoStripX());
+ // need first to convert deviation to [0-30]
+ // (see AliMUONLocalTriggerBoard::LocalTrigger)
+ Int_t deviation = locTrg.GetDeviation();
+ Int_t stripX21 = locTrg.LoStripX()+deviation+1;
+ Float_t y21 = circuit.GetY21Pos(localBoardId, stripX21);
+ Float_t z21 = circuit.GetZ21Pos(localBoardId, stripX21);
+ Float_t x11 = circuit.GetX11Pos(localBoardId, locTrg.LoStripY());
+
+ AliDebug(1, Form(" MakeTriggerTrack %3d %2d %2d %2d (%f %f %f) (%f %f)\n",locTrg.LoCircuit(),
+ locTrg.LoStripX(),locTrg.LoStripX()+deviation+1,locTrg.LoStripY(),x11, y11, z11, y21, z21));
+
+ Double_t deltaZ = z11 - z21;
+
+ Float_t slopeX = x11/z11;
+ Float_t slopeY = (y11-y21) / deltaZ;
+
+ Float_t sigmaX = circuit.GetX11Width(localBoardId, locTrg.LoStripY()) / kSqrt12;
+ Float_t sigmaY = circuit.GetY11Width(localBoardId, locTrg.LoStripX()) / kSqrt12;
+ Float_t sigmaY21 = circuit.GetY21Width(localBoardId, locTrg.LoStripX()) / kSqrt12;
+
+ trigCov.Zero();
+ trigCov(0,0) = kTrigNonBendReso * kTrigNonBendReso + sigmaX * sigmaX;
+ trigCov(1,1) = kTrigBendReso * kTrigBendReso + sigmaY * sigmaY;
+ trigCov(2,2) =
+ (2. * kTrigBendReso * kTrigBendReso + sigmaY * sigmaY + sigmaY21 * sigmaY21 ) / deltaZ / deltaZ;
+ trigCov(1,2) = trigCov(2,1) = trigCov(1,1) / deltaZ;
+
+ triggerTrack.SetX11(x11);
+ triggerTrack.SetY11(y11);
+ triggerTrack.SetZ11(z11);
+ triggerTrack.SetZ21(z21);
+ triggerTrack.SetSlopeX(slopeX);
+ triggerTrack.SetSlopeY(slopeY);
+ triggerTrack.SetGTPattern(globalTriggerPattern);
+ triggerTrack.SetLoTrgNum(localBoardId);
+ triggerTrack.SetCovariances(trigCov);
+ triggerTrack.SetUniqueID(locTrg.GetUniqueID());
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff