//-----------------------------------------------------------------------------
#include "AliMUONTrackReconstructorK.h"
+
#include "AliMUONConstants.h"
-#include "AliMUONHitForRec.h"
+#include "AliMUONVCluster.h"
+#include "AliMUONVClusterStore.h"
#include "AliMUONTrack.h"
#include "AliMUONTrackParam.h"
#include "AliMUONTrackExtrap.h"
AliMUONTrackReconstructorK::AliMUONTrackReconstructorK()
: AliMUONVTrackReconstructor()
{
- /// Constructor for class AliMUONTrackReconstructorK
- AliInfo("*** Tracking with Kalman Filter ***");
+ /// Constructor
}
//__________________________________________________________________________
}
//__________________________________________________________________________
-void AliMUONTrackReconstructorK::MakeTrackCandidates()
+void AliMUONTrackReconstructorK::MakeTrackCandidates(const AliMUONVClusterStore& clusterStore)
{
/// To make track candidates (assuming linear propagation if the flag fgkMakeTrackCandidatesFast is set to kTRUE):
/// Start with segments station(1..) 4 or 5 then follow track in station 5 or 4.
- /// Good candidates are made of at least three hitForRec's.
+ /// Good candidates are made of at least three clusters.
/// Keep only best candidates or all of them according to the flag fgkTrackAllTracks.
TClonesArray *segments;
AliMUONTrack *track;
Int_t iCandidate = 0;
- Bool_t hitFound;
+ Bool_t clusterFound;
AliDebug(1,"Enter MakeTrackCandidates");
for (Int_t istat=4; istat>=3; istat--) {
// Make segments in the station
- segments = MakeSegmentsInStation(istat);
+ segments = MakeSegmentsInStation(clusterStore, istat);
// Loop over segments
for (Int_t iseg=0; iseg<segments->GetEntriesFast(); iseg++) {
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
- cout<<endl<<"Track parameter covariances at first hit:"<<endl;
- ((AliMUONTrackParam*) (track->GetTrackParamAtHit()->First()))->GetCovariances().Print();
+ cout<<endl<<"Track parameter covariances at first cluster:"<<endl;
+ ((AliMUONTrackParam*) (track->GetTrackParamAtCluster()->First()))->GetCovariances().Print();
}
- // Look for compatible hitForRec(s) in the other station
- if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast()) hitFound = FollowLinearTrackInStation(*track,7-istat);
+ // Look for compatible cluster(s) in the other station
+ if (AliMUONReconstructor::GetRecoParam()->MakeTrackCandidatesFast())
+ clusterFound = FollowLinearTrackInStation(*track, clusterStore, 7-istat);
else {
// First recompute track parameters and covariances on station(1..) 5 using Kalman filter
// (to make sure all tracks are treated in the same way)
- if (istat == 4) RetraceTrack(*track,kFALSE);
- hitFound = FollowTrackInStation(*track,7-istat);
+ if (istat == 4) RetraceTrack(*track, kFALSE);
+ clusterFound = FollowTrackInStation(*track, clusterStore, 7-istat);
}
- // Remove track if no hit found
- if (!hitFound) {
+ // Remove track if no cluster found
+ if (!clusterFound) {
fRecTracksPtr->Remove(track);
fNRecTracks--;
}
//__________________________________________________________________________
void AliMUONTrackReconstructorK::RetraceTrack(AliMUONTrack &trackCandidate, Bool_t resetSeed)
{
- /// Re-run the kalman filter from the most downstream hit to the most uptream one
+ /// Re-run the kalman filter from the most downstream cluster to the most uptream one
AliDebug(1,"Enter RetraceTrack");
- AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) trackCandidate.GetTrackParamAtHit()->Last();
+ AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) trackCandidate.GetTrackParamAtCluster()->Last();
- // Reset the "seed" (= track parameters and their covariances at last hit) if required
+ // Reset the "seed" (= track parameters and their covariances at last cluster) if required
if (resetSeed) {
- // => Shift track parameters at the position of the last hit
- AliMUONHitForRec* hitForRecAtHit = startingTrackParam->GetHitForRecPtr();
- startingTrackParam->SetNonBendingCoor(hitForRecAtHit->GetNonBendingCoor());
- startingTrackParam->SetBendingCoor(hitForRecAtHit->GetBendingCoor());
+ // => Shift track parameters at the position of the last cluster
+ AliMUONVCluster* cluster = startingTrackParam->GetClusterPtr();
+ startingTrackParam->SetNonBendingCoor(cluster->GetX());
+ startingTrackParam->SetBendingCoor(cluster->GetY());
- // => Re-compute and reset track parameters covariances at last hit (as if the other hits did not exist)
+ // => Re-compute and reset track parameters covariances at last cluster (as if the other clusters did not exist)
const TMatrixD& kParamCov = startingTrackParam->GetCovariances();
TMatrixD newParamCov(5,5);
newParamCov.Zero();
// Non bending plane
- newParamCov(0,0) = hitForRecAtHit->GetNonBendingReso2();
+ newParamCov(0,0) = cluster->GetErrX2();
newParamCov(1,1) = 100.*kParamCov(1,1);
// Bending plane
- newParamCov(2,2) = hitForRecAtHit->GetBendingReso2();
+ newParamCov(2,2) = cluster->GetErrY2();
newParamCov(3,3) = 100.*kParamCov(3,3);
// Inverse bending momentum
newParamCov(4,4) = 0.5*startingTrackParam->GetInverseBendingMomentum() * 0.5*startingTrackParam->GetInverseBendingMomentum();
//__________________________________________________________________________
void AliMUONTrackReconstructorK::RetracePartialTrack(AliMUONTrack &trackCandidate, const AliMUONTrackParam* startingTrackParam)
{
- /// Re-run the kalman filter from the hit attached to startingTrackParam to the most uptream hit
+ /// Re-run the kalman filter from the cluster attached to startingTrackParam to the most uptream cluster
AliDebug(1,"Enter RetracePartialTrack");
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "RetracePartialTrack: track chi2 before re-tracking: " << trackCandidate.GetFitFMin() << endl;
+ cout << "RetracePartialTrack: track chi2 before re-tracking: " << trackCandidate.GetGlobalChi2() << endl;
}
// Reset the track chi2
- trackCandidate.SetFitFMin(startingTrackParam->GetTrackChi2());
+ trackCandidate.SetGlobalChi2(startingTrackParam->GetTrackChi2());
- // loop over attached hits until the first one and recompute track parameters and covariances using kalman filter
- Int_t expectedChamber = startingTrackParam->GetHitForRecPtr()->GetChamberNumber() - 1;
+ // loop over attached clusters until the first one and recompute track parameters and covariances using kalman filter
+ Int_t expectedChamber = startingTrackParam->GetClusterPtr()->GetChamberId() - 1;
Int_t currentChamber;
- Double_t addChi2TrackAtHit;
- AliMUONTrackParam* trackParamAtHit = (AliMUONTrackParam*) trackCandidate.GetTrackParamAtHit()->Before(startingTrackParam);
- while (trackParamAtHit) {
+ Double_t addChi2TrackAtCluster;
+ AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) trackCandidate.GetTrackParamAtCluster()->Before(startingTrackParam);
+ while (trackParamAtCluster) {
// reset track parameters and their covariances
- trackParamAtHit->SetParameters(startingTrackParam->GetParameters());
- trackParamAtHit->SetZ(startingTrackParam->GetZ());
- trackParamAtHit->SetCovariances(startingTrackParam->GetCovariances());
+ trackParamAtCluster->SetParameters(startingTrackParam->GetParameters());
+ trackParamAtCluster->SetZ(startingTrackParam->GetZ());
+ trackParamAtCluster->SetCovariances(startingTrackParam->GetCovariances());
// add MCS effect
- AliMUONTrackExtrap::AddMCSEffect(trackParamAtHit,AliMUONConstants::ChamberThicknessInX0(),1.);
+ AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(),1.);
// reset propagator for smoother
- if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) trackParamAtHit->ResetPropagator();
+ if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) trackParamAtCluster->ResetPropagator();
// add MCS in missing chambers if any (at most 2 chambers can be missing according to tracking criteria)
- currentChamber = trackParamAtHit->GetHitForRecPtr()->GetChamberNumber();
+ currentChamber = trackParamAtCluster->GetClusterPtr()->GetChamberId();
while (currentChamber < expectedChamber) {
// extrapolation to the missing chamber (update the propagator)
- AliMUONTrackExtrap::ExtrapToZCov(trackParamAtHit, AliMUONConstants::DefaultChamberZ(expectedChamber),
+ AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, AliMUONConstants::DefaultChamberZ(expectedChamber),
AliMUONReconstructor::GetRecoParam()->UseSmoother());
// add MCS effect
- AliMUONTrackExtrap::AddMCSEffect(trackParamAtHit,AliMUONConstants::ChamberThicknessInX0(),1.);
+ AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(),1.);
expectedChamber--;
}
- // extrapolation to the plane of the hitForRec attached to the current trackParamAtHit (update the propagator)
- AliMUONTrackExtrap::ExtrapToZCov(trackParamAtHit, trackParamAtHit->GetHitForRecPtr()->GetZ(),
+ // extrapolation to the plane of the cluster attached to the current trackParamAtCluster (update the propagator)
+ AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ(),
AliMUONReconstructor::GetRecoParam()->UseSmoother());
if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) {
// save extrapolated parameters for smoother
- trackParamAtHit->SetExtrapParameters(trackParamAtHit->GetParameters());
+ trackParamAtCluster->SetExtrapParameters(trackParamAtCluster->GetParameters());
// save extrapolated covariance matrix for smoother
- trackParamAtHit->SetExtrapCovariances(trackParamAtHit->GetCovariances());
+ trackParamAtCluster->SetExtrapCovariances(trackParamAtCluster->GetCovariances());
}
- // Compute new track parameters including "hitForRecCh2" using kalman filter
- addChi2TrackAtHit = RunKalmanFilter(*trackParamAtHit);
+ // Compute new track parameters including "clusterCh2" using kalman filter
+ addChi2TrackAtCluster = RunKalmanFilter(*trackParamAtCluster);
// Update the track chi2
- trackCandidate.SetFitFMin(trackCandidate.GetFitFMin() + addChi2TrackAtHit);
- trackParamAtHit->SetTrackChi2(trackCandidate.GetFitFMin());
+ trackCandidate.SetGlobalChi2(trackCandidate.GetGlobalChi2() + addChi2TrackAtCluster);
+ trackParamAtCluster->SetTrackChi2(trackCandidate.GetGlobalChi2());
- // prepare next step, add MCS effects in parameter covariances
- expectedChamber--;
- startingTrackParam = trackParamAtHit;
- trackParamAtHit = (AliMUONTrackParam*) (trackCandidate.GetTrackParamAtHit()->Before(startingTrackParam));
+ // prepare next step
+ expectedChamber = currentChamber - 1;
+ startingTrackParam = trackParamAtCluster;
+ trackParamAtCluster = (AliMUONTrackParam*) (trackCandidate.GetTrackParamAtCluster()->Before(startingTrackParam));
}
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "RetracePartialTrack: track chi2 after re-tracking: " << trackCandidate.GetFitFMin() << endl;
+ cout << "RetracePartialTrack: track chi2 after re-tracking: " << trackCandidate.GetGlobalChi2() << endl;
}
}
//__________________________________________________________________________
-void AliMUONTrackReconstructorK::FollowTracks()
+void AliMUONTrackReconstructorK::FollowTracks(const AliMUONVClusterStore& clusterStore)
{
/// Follow tracks in stations(1..) 3, 2 and 1
AliDebug(1,"Enter FollowTracks");
AliMUONTrack *track;
Int_t currentNRecTracks;
- Bool_t hitFound;
+ Bool_t clusterFound;
for (Int_t station = 2; station >= 0; station--) {
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
- cout<<endl<<"Track parameter covariances at first hit:"<<endl;
- ((AliMUONTrackParam*) (track->GetTrackParamAtHit()->First()))->GetCovariances().Print();
+ cout<<endl<<"Track parameter covariances at first cluster:"<<endl;
+ ((AliMUONTrackParam*) (track->GetTrackParamAtCluster()->First()))->GetCovariances().Print();
}
- // Look for compatible hitForRec in station(0..) "station"
- hitFound = FollowTrackInStation(*track,station);
+ // Look for compatible cluster(s) in station(0..) "station"
+ clusterFound = FollowTrackInStation(*track, clusterStore, station);
// Try to recover track if required
- if (!hitFound && AliMUONReconstructor::GetRecoParam()->RecoverTracks()) hitFound = RecoverTrack(*track,station);
+ if (!clusterFound && AliMUONReconstructor::GetRecoParam()->RecoverTracks())
+ clusterFound = RecoverTrack(*track, clusterStore, station);
- // remove track if no hit found
- if (!hitFound) {
+ // remove track if no cluster found
+ if (!clusterFound) {
fRecTracksPtr->Remove(track);
fNRecTracks--;
}
}
//__________________________________________________________________________
-Bool_t AliMUONTrackReconstructorK::FollowTrackInStation(AliMUONTrack &trackCandidate, Int_t nextStation)
+Bool_t AliMUONTrackReconstructorK::FollowTrackInStation(AliMUONTrack &trackCandidate, const AliMUONVClusterStore& clusterStore, Int_t nextStation)
{
- /// Follow trackCandidate in station(0..) nextStation and search for compatible HitForRec(s)
+ /// Follow trackCandidate in station(0..) nextStation and search for compatible cluster(s)
/// Keep all possibilities or only the best one(s) according to the flag fgkTrackAllTracks:
/// kTRUE: duplicate "trackCandidate" if there are several possibilities and add the new tracks at the end of
/// fRecTracksPtr to avoid conficts with other track candidates at this current stage of the tracking procedure.
/// Remove the obsolete "trackCandidate" at the end.
- /// kFALSE: add only the best hit(s) to the "trackCandidate". Try to add a couple of hits in priority.
- /// return kTRUE if new hits have been found (otherwise return kFALSE)
+ /// kFALSE: add only the best cluster(s) to the "trackCandidate". Try to add a couple of clusters in priority.
+ /// return kTRUE if new cluster(s) have been found (otherwise return kFALSE)
AliDebug(1,Form("Enter FollowTrackInStation(1..) %d", nextStation+1));
// Order the chamber according to the propagation direction (tracking starts with chamber 2):
ch2 = 2*nextStation+1;
}
- Double_t chi2OfHitForRec;
- Double_t maxChi2OfHitForRec = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
- Double_t addChi2TrackAtHit1;
- Double_t addChi2TrackAtHit2;
- Double_t bestAddChi2TrackAtHit1 = 1.e10;
- Double_t bestAddChi2TrackAtHit2 = 1.e10;
- Bool_t foundOneHit = kFALSE;
- Bool_t foundTwoHits = kFALSE;
+ Double_t chi2OfCluster;
+ Double_t maxChi2OfCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
+ AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Double_t addChi2TrackAtCluster1;
+ Double_t addChi2TrackAtCluster2;
+ Double_t bestAddChi2TrackAtCluster1 = 1.e10;
+ Double_t bestAddChi2TrackAtCluster2 = 1.e10;
+ Bool_t foundOneCluster = kFALSE;
+ Bool_t foundTwoClusters = kFALSE;
AliMUONTrack *newTrack = 0x0;
- AliMUONHitForRec *hitForRecCh1, *hitForRecCh2;
+ AliMUONVCluster *clusterCh1, *clusterCh2;
AliMUONTrackParam extrapTrackParam;
- AliMUONTrackParam extrapTrackParamAtHit1;
- AliMUONTrackParam extrapTrackParamAtHit2;
- AliMUONTrackParam bestTrackParamAtHit1;
- AliMUONTrackParam bestTrackParamAtHit2;
- Bool_t *hitForRecCh1Used = new Bool_t[fNHitsForRecPerChamber[ch1]];
- for (Int_t hit1 = 0; hit1 < fNHitsForRecPerChamber[ch1]; hit1++) hitForRecCh1Used[hit1] = kFALSE;
-
+ AliMUONTrackParam extrapTrackParamAtCluster1;
+ AliMUONTrackParam extrapTrackParamAtCluster2;
+ AliMUONTrackParam bestTrackParamAtCluster1;
+ AliMUONTrackParam bestTrackParamAtCluster2;
+
+ Int_t nClusters = clusterStore.GetSize();
+ Bool_t *clusterCh1Used = new Bool_t[nClusters];
+ for (Int_t i = 0; i < nClusters; i++) clusterCh1Used[i] = kFALSE;
+ Int_t iCluster1;
+
// Get track parameters
- AliMUONTrackParam extrapTrackParamAtCh(*(AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->First());
+ AliMUONTrackParam extrapTrackParamAtCh(*(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->First());
// Add MCS effect
AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) extrapTrackParamAtCh.ResetPropagator();
// Add MCS in the missing chamber if any (only 1 chamber can be missing according to tracking criteria)
- if (ch1 < ch2 && extrapTrackParamAtCh.GetHitForRecPtr()->GetChamberNumber() > ch2 + 1) {
+ if (ch1 < ch2 && extrapTrackParamAtCh.GetClusterPtr()->GetChamberId() > ch2 + 1) {
// extrapolation to the missing chamber
AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch2 + 1),
AliMUONReconstructor::GetRecoParam()->UseSmoother());
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
- cout<<endl<<"Track parameter covariances at first
hit extrapolated to z = "<<AliMUONConstants::DefaultChamberZ(ch2)<<":"<<endl;
+ cout<<endl<<"Track parameter covariances at first
cluster extrapolated to z = "<<AliMUONConstants::DefaultChamberZ(ch2)<<":"<<endl;
extrapTrackParamAtCh.GetCovariances().Print();
}
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: look for hits in chamber(1..): " << ch2+1 << endl;
+ cout << "FollowTrackInStation: look for clusters in chamber(1..): " << ch2+1 << endl;
}
- // look for candidates in chamber 2
- for (Int_t hit2 = 0; hit2 < fNHitsForRecPerChamber[ch2]; hit2++) {
-
- hitForRecCh2 = (AliMUONHitForRec*) fHitsForRecPtr->UncheckedAt(fIndexOfFirstHitForRecPerChamber[ch2]+hit2);
+ // Create iterators to loop over clusters in both chambers
+ TIter nextInCh1(clusterStore.CreateChamberIterator(ch1,ch1));
+ TIter nextInCh2(clusterStore.CreateChamberIterator(ch2,ch2));
+
+ // look for candidates in chamber 2
+ while ( ( clusterCh2 = static_cast<AliMUONVCluster*>(nextInCh2()) ) ) {
- // try to add the current hit fast
- if (!TryOneHitForRecFast(extrapTrackParamAtCh, hitForRecCh2)) continue;
+ // try to add the current cluster fast
+ if (!TryOneClusterFast(extrapTrackParamAtCh, clusterCh2)) continue;
- // try to add the current hit accuratly
- chi2OfHitForRec = TryOneHitForRec(extrapTrackParamAtCh, hitForRecCh2, extrapTrackParamAtHit2,
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ // try to add the current cluster accuratly
+ chi2OfCluster = TryOneCluster(extrapTrackParamAtCh, clusterCh2, extrapTrackParamAtCluster2,
+ AliMUONReconstructor::GetRecoParam()->UseSmoother());
- // if good chi2 then try to attach a hitForRec in the other chamber too
- if (chi2OfHitForRec < maxChi2OfHitForRec) {
- Bool_t foundSecondHit = kFALSE;
+ // if good chi2 then try to attach a cluster in the other chamber too
+ if (chi2OfCluster < maxChi2OfCluster) {
+ Bool_t foundSecondCluster = kFALSE;
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: found one hit in chamber(1..): " << ch2+1
- << " (Chi2 = " << chi2OfHitForRec << ")" << endl;
- cout << " look for second hits in chamber(1..): " << ch1+1 << " ..." << endl;
+ cout << "FollowTrackInStation: found one cluster in chamber(1..): " << ch2+1
+ << " (Chi2 = " << chi2OfCluster << ")" << endl;
+ cout << " look for second clusters in chamber(1..): " << ch1+1 << " ..." << endl;
}
if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) {
// save extrapolated parameters for smoother
- extrapTrackParamAtHit2.SetExtrapParameters(extrapTrackParamAtHit2.GetParameters());
+ extrapTrackParamAtCluster2.SetExtrapParameters(extrapTrackParamAtCluster2.GetParameters());
// save extrapolated covariance matrix for smoother
- extrapTrackParamAtHit2.SetExtrapCovariances(extrapTrackParamAtHit2.GetCovariances());
+ extrapTrackParamAtCluster2.SetExtrapCovariances(extrapTrackParamAtCluster2.GetCovariances());
}
- // Compute new track parameters including "hitForRecCh2" using kalman filter
- addChi2TrackAtHit2 = RunKalmanFilter(extrapTrackParamAtHit2);
+ // Compute new track parameters including "clusterCh2" using kalman filter
+ addChi2TrackAtCluster2 = RunKalmanFilter(extrapTrackParamAtCluster2);
// copy new track parameters for next step
- extrapTrackParam = extrapTrackParamAtHit2;
+ extrapTrackParam = extrapTrackParamAtCluster2;
// add MCS effect
AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParam,AliMUONConstants::ChamberThicknessInX0(),1.);
AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParam, AliMUONConstants::DefaultChamberZ(ch1),
AliMUONReconstructor::GetRecoParam()->UseSmoother());
- for (Int_t hit1 = 0; hit1 < fNHitsForRecPerChamber[ch1]; hit1++) {
-
- hitForRecCh1 = (AliMUONHitForRec*) fHitsForRecPtr->UncheckedAt(fIndexOfFirstHitForRecPerChamber[ch1]+hit1);
+ // reset cluster iterator of chamber 1
+ nextInCh1.Reset();
+ iCluster1 = -1;
+
+ // look for second candidates in chamber 1
+ while ( ( clusterCh1 = static_cast<AliMUONVCluster*>(nextInCh1()) ) ) {
+ iCluster1++;
- // try to add the current hit fast
- if (!TryOneHitForRecFast(extrapTrackParam, hitForRecCh1)) continue;
+ // try to add the current cluster fast
+ if (!TryOneClusterFast(extrapTrackParam, clusterCh1)) continue;
- // try to add the current hit accuratly
- chi2OfHitForRec = TryOneHitForRec(extrapTrackParam, hitForRecCh1, extrapTrackParamAtHit1,
+ // try to add the current cluster accuratly
+ chi2OfCluster = TryOneCluster(extrapTrackParam, clusterCh1, extrapTrackParamAtCluster1,
AliMUONReconstructor::GetRecoParam()->UseSmoother());
- // if good chi2 then consider to add the 2 hitForRec to the "trackCandidate"
- if (chi2OfHitForRec < maxChi2OfHitForRec) {
- foundSecondHit = kTRUE;
- foundTwoHits = kTRUE;
+ // if good chi2 then consider to add the 2 clusters to the "trackCandidate"
+ if (chi2OfCluster < maxChi2OfCluster) {
+ foundSecondCluster = kTRUE;
+ foundTwoClusters = kTRUE;
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: found one hit in chamber(1..): " << ch1+1
- << " (Chi2 = " << chi2OfHitForRec << ")" << endl;
+ cout << "FollowTrackInStation: found one cluster in chamber(1..): " << ch1+1
+ << " (Chi2 = " << chi2OfCluster << ")" << endl;
}
if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) {
// save extrapolated parameters for smoother
- extrapTrackParamAtHit1.SetExtrapParameters(extrapTrackParamAtHit1.GetParameters());
+ extrapTrackParamAtCluster1.SetExtrapParameters(extrapTrackParamAtCluster1.GetParameters());
// save extrapolated covariance matrix for smoother
- extrapTrackParamAtHit1.SetExtrapCovariances(extrapTrackParamAtHit1.GetCovariances());
+ extrapTrackParamAtCluster1.SetExtrapCovariances(extrapTrackParamAtCluster1.GetCovariances());
}
- // Compute new track parameters including "hitForRecCh1" using kalman filter
- addChi2TrackAtHit1 = RunKalmanFilter(extrapTrackParamAtHit1);
+ // Compute new track parameters including "clusterCh1" using kalman filter
+ addChi2TrackAtCluster1 = RunKalmanFilter(extrapTrackParamAtCluster1);
if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
- // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new hitForRec's
+ // 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);
- UpdateTrack(*newTrack,extrapTrackParamAtHit1,extrapTrackParamAtHit2,addChi2TrackAtHit1,addChi2TrackAtHit2);
+ UpdateTrack(*newTrack,extrapTrackParamAtCluster1,extrapTrackParamAtCluster2,addChi2TrackAtCluster1,addChi2TrackAtCluster2);
fNRecTracks++;
// if we are arrived on station(1..) 5, recompute track parameters and covariances starting from this station
// (going in the right direction)
if (nextStation == 4) RetraceTrack(*newTrack,kTRUE);
- // Tag hitForRecCh1 as used
- hitForRecCh1Used[hit1] = kTRUE;
+ // Tag clusterCh1 as used
+ clusterCh1Used[iCluster1] = kTRUE;
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: added two hits in station(1..): " << nextStation+1 << endl;
+ cout << "FollowTrackInStation: added two clusters in station(1..): " << nextStation+1 << endl;
if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
}
- } else if (addChi2TrackAtHit1+addChi2TrackAtHit2 < bestAddChi2TrackAtHit1+bestAddChi2TrackAtHit2) {
- // keep track of the best couple of hits
- bestAddChi2TrackAtHit1 = addChi2TrackAtHit1;
- bestAddChi2TrackAtHit2 = addChi2TrackAtHit2;
- bestTrackParamAtHit1 = extrapTrackParamAtHit1;
- bestTrackParamAtHit2 = extrapTrackParamAtHit2;
+ } else if (addChi2TrackAtCluster1+addChi2TrackAtCluster2 < bestAddChi2TrackAtCluster1+bestAddChi2TrackAtCluster2) {
+ // keep track of the best couple of clusters
+ bestAddChi2TrackAtCluster1 = addChi2TrackAtCluster1;
+ bestAddChi2TrackAtCluster2 = addChi2TrackAtCluster2;
+ bestTrackParamAtCluster1 = extrapTrackParamAtCluster1;
+ bestTrackParamAtCluster2 = extrapTrackParamAtCluster2;
}
}
}
- // if no hitForRecCh1 found then consider to add hitForRecCh2 only
- if (!foundSecondHit) {
- foundOneHit = kTRUE;
+ // if no clusterCh1 found then consider to add clusterCh2 only
+ if (!foundSecondCluster) {
+ foundOneCluster = kTRUE;
if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
- // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new hitForRec's
+ // 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);
- UpdateTrack(*newTrack,extrapTrackParamAtHit2,addChi2TrackAtHit2);
+ UpdateTrack(*newTrack,extrapTrackParamAtCluster2,addChi2TrackAtCluster2);
fNRecTracks++;
// if we are arrived on station(1..) 5, recompute track parameters and covariances starting from this station
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: added one hit in chamber(1..): " << ch2+1 << endl;
+ cout << "FollowTrackInStation: added one cluster in chamber(1..): " << ch2+1 << endl;
if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
}
- } else if (!foundTwoHits && addChi2TrackAtHit2 < bestAddChi2TrackAtHit1) {
- // keep track of the best single hitForRec except if a couple of hits has already been found
- bestAddChi2TrackAtHit1 = addChi2TrackAtHit2;
- bestTrackParamAtHit1 = extrapTrackParamAtHit2;
+ } else if (!foundTwoClusters && addChi2TrackAtCluster2 < bestAddChi2TrackAtCluster1) {
+ // keep track of the best single cluster except if a couple of clusters has already been found
+ bestAddChi2TrackAtCluster1 = addChi2TrackAtCluster2;
+ bestTrackParamAtCluster1 = extrapTrackParamAtCluster2;
}
}
}
// 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 hitForRec has been found
- if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks() || !foundTwoHits) {
+ // if we want to keep all possible tracks or if no good couple of clusters has been found
+ if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: look for single hits in chamber(1..): " << ch1+1 << endl;
+ cout << "FollowTrackInStation: look for single clusters in chamber(1..): " << ch1+1 << endl;
}
// add MCS effect for next step
AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch1),
AliMUONReconstructor::GetRecoParam()->UseSmoother());
- for (Int_t hit1 = 0; hit1 < fNHitsForRecPerChamber[ch1]; hit1++) {
-
- hitForRecCh1 = (AliMUONHitForRec*) fHitsForRecPtr->UncheckedAt(fIndexOfFirstHitForRecPerChamber[ch1]+hit1);
+ // reset cluster iterator of chamber 1
+ nextInCh1.Reset();
+ iCluster1 = -1;
+
+ // look for second candidates in chamber 1
+ while ( ( clusterCh1 = static_cast<AliMUONVCluster*>(nextInCh1()) ) ) {
+ iCluster1++;
- if (hitForRecCh1Used[hit1]) continue; // Skip hitForRec already used
+ if (clusterCh1Used[iCluster1]) continue; // Skip clusters already used
- // try to add the current hit fast
- if (!TryOneHitForRecFast(extrapTrackParamAtCh, hitForRecCh1)) continue;
+ // try to add the current cluster fast
+ if (!TryOneClusterFast(extrapTrackParamAtCh, clusterCh1)) continue;
- // try to add the current hit accuratly
- chi2OfHitForRec = TryOneHitForRec(extrapTrackParamAtCh, hitForRecCh1, extrapTrackParamAtHit1,
- AliMUONReconstructor::GetRecoParam()->UseSmoother());
+ // try to add the current cluster accuratly
+ chi2OfCluster = TryOneCluster(extrapTrackParamAtCh, clusterCh1, extrapTrackParamAtCluster1,
+ AliMUONReconstructor::GetRecoParam()->UseSmoother());
- // if good chi2 then consider to add hitForRecCh1
- // We do not try to attach a hitForRec in the other chamber too since it has already been done above
- if (chi2OfHitForRec < maxChi2OfHitForRec) {
- foundOneHit = kTRUE;
+ // if good chi2 then consider to add clusterCh1
+ // We do not try to attach a cluster in the other chamber too since it has already been done above
+ if (chi2OfCluster < maxChi2OfCluster) {
+ foundOneCluster = kTRUE;
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: found one hit in chamber(1..): " << ch1+1
- << " (Chi2 = " << chi2OfHitForRec << ")" << endl;
+ cout << "FollowTrackInStation: found one cluster in chamber(1..): " << ch1+1
+ << " (Chi2 = " << chi2OfCluster << ")" << endl;
}
if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) {
// save extrapolated parameters for smoother
- extrapTrackParamAtHit1.SetExtrapParameters(extrapTrackParamAtHit1.GetParameters());
+ extrapTrackParamAtCluster1.SetExtrapParameters(extrapTrackParamAtCluster1.GetParameters());
// save extrapolated covariance matrix for smoother
- extrapTrackParamAtHit1.SetExtrapCovariances(extrapTrackParamAtHit1.GetCovariances());
+ extrapTrackParamAtCluster1.SetExtrapCovariances(extrapTrackParamAtCluster1.GetCovariances());
}
- // Compute new track parameters including "hitForRecCh1" using kalman filter
- addChi2TrackAtHit1 = RunKalmanFilter(extrapTrackParamAtHit1);
+ // Compute new track parameters including "clusterCh1" using kalman filter
+ addChi2TrackAtCluster1 = RunKalmanFilter(extrapTrackParamAtCluster1);
if (AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
- // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new hitForRec's
+ // 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);
- UpdateTrack(*newTrack,extrapTrackParamAtHit1,addChi2TrackAtHit1);
+ UpdateTrack(*newTrack,extrapTrackParamAtCluster1,addChi2TrackAtCluster1);
fNRecTracks++;
// if we are arrived on station(1..) 5, recompute track parameters and covariances starting from this station
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: added one hit in chamber(1..): " << ch1+1 << endl;
+ cout << "FollowTrackInStation: added one cluster in chamber(1..): " << ch1+1 << endl;
if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
}
- } else if (addChi2TrackAtHit1 < bestAddChi2TrackAtHit1) {
- // keep track of the best single hitForRec except if a couple of hits has already been found
- bestAddChi2TrackAtHit1 = addChi2TrackAtHit1;
- bestTrackParamAtHit1 = extrapTrackParamAtHit1;
+ } else if (addChi2TrackAtCluster1 < bestAddChi2TrackAtCluster1) {
+ // keep track of the best single cluster except if a couple of clusters has already been found
+ bestAddChi2TrackAtCluster1 = addChi2TrackAtCluster1;
+ bestTrackParamAtCluster1 = extrapTrackParamAtCluster1;
}
}
// fill out the best track if required else clean up the fRecTracksPtr array
if (!AliMUONReconstructor::GetRecoParam()->TrackAllTracks()) {
- if (foundTwoHits) {
- UpdateTrack(trackCandidate,bestTrackParamAtHit1,bestTrackParamAtHit2,bestAddChi2TrackAtHit1,bestAddChi2TrackAtHit2);
+ if (foundTwoClusters) {
+ UpdateTrack(trackCandidate,bestTrackParamAtCluster1,bestTrackParamAtCluster2,bestAddChi2TrackAtCluster1,bestAddChi2TrackAtCluster2);
// if we are arrived on station(1..) 5, recompute track parameters and covariances starting from this station
// (going in the right direction)
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: added the two best hits in station(1..): " << nextStation+1 << endl;
+ cout << "FollowTrackInStation: added the two best clusters in station(1..): " << nextStation+1 << endl;
if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
}
- } else if (foundOneHit) {
- UpdateTrack(trackCandidate,bestTrackParamAtHit1,bestAddChi2TrackAtHit1);
+ } else if (foundOneCluster) {
+ UpdateTrack(trackCandidate,bestTrackParamAtCluster1,bestAddChi2TrackAtCluster1);
// if we are arrived on station(1..) 5, recompute track parameters and covariances starting from this station
// (going in the right direction)
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: added the best hit in chamber(1..): " << bestTrackParamAtHit1.GetHitForRecPtr()->GetChamberNumber()+1 << endl;
+ cout << "FollowTrackInStation: added the best cluster in chamber(1..): " << bestTrackParamAtCluster1.GetClusterPtr()->GetChamberId()+1 << endl;
if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
}
} else {
- delete [] hitForRecCh1Used;
+ delete [] clusterCh1Used;
return kFALSE;
}
- } else if (foundOneHit || foundTwoHits) {
+ } else if (foundOneCluster || foundTwoClusters) {
// remove obsolete track
fRecTracksPtr->Remove(&trackCandidate);
fNRecTracks--;
} else {
- delete [] hitForRecCh1Used;
+ delete [] clusterCh1Used;
return kFALSE;
}
- delete [] hitForRecCh1Used;
+ delete [] clusterCh1Used;
return kTRUE;
}
//__________________________________________________________________________
-Double_t AliMUONTrackReconstructorK::RunKalmanFilter(AliMUONTrackParam &trackParamAtHit)
+Double_t AliMUONTrackReconstructorK::RunKalmanFilter(AliMUONTrackParam &trackParamAtCluster)
{
- /// Compute new track parameters and their covariances including new hit using kalman filter
+ /// Compute new track parameters and their covariances including new cluster using kalman filter
/// return the additional track chi2
AliDebug(1,"Enter RunKalmanFilter");
// Get actual track parameters (p)
- TMatrixD param(trackParamAtHit.GetParameters());
+ TMatrixD param(trackParamAtCluster.GetParameters());
- // Get new hit parameters (m)
- AliMUONHitForRec *hitForRecAtHit = trackParamAtHit.GetHitForRecPtr();
- TMatrixD hit(5,1);
- hit.Zero();
- hit(0,0) = hitForRecAtHit->GetNonBendingCoor();
- hit(2,0) = hitForRecAtHit->GetBendingCoor();
+ // Get new cluster parameters (m)
+ AliMUONVCluster *cluster = trackParamAtCluster.GetClusterPtr();
+ TMatrixD clusterParam(5,1);
+ clusterParam.Zero();
+ clusterParam(0,0) = cluster->GetX();
+ clusterParam(2,0) = cluster->GetY();
// Compute the actual parameter weight (W)
- TMatrixD paramWeight(trackParamAtHit.GetCovariances());
+ TMatrixD paramWeight(trackParamAtCluster.GetCovariances());
if (paramWeight.Determinant() != 0) {
paramWeight.Invert();
} else {
return 1.e10;
}
- // Compute the new hit weight (U)
- TMatrixD hitWeight(5,5);
- hitWeight.Zero();
- hitWeight(0,0) = 1. / hitForRecAtHit->GetNonBendingReso2();
- hitWeight(2,2) = 1. / hitForRecAtHit->GetBendingReso2();
+ // Compute the new cluster weight (U)
+ TMatrixD clusterWeight(5,5);
+ clusterWeight.Zero();
+ clusterWeight(0,0) = 1. / cluster->GetErrX2();
+ clusterWeight(2,2) = 1. / cluster->GetErrY2();
// Compute the new parameters covariance matrix ( (W+U)^-1 )
- TMatrixD newParamCov(paramWeight,TMatrixD::kPlus,hitWeight);
+ TMatrixD newParamCov(paramWeight,TMatrixD::kPlus,clusterWeight);
if (newParamCov.Determinant() != 0) {
newParamCov.Invert();
} else {
}
// Save the new parameters covariance matrix
- trackParamAtHit.SetCovariances(newParamCov);
+ trackParamAtCluster.SetCovariances(newParamCov);
// Compute the new parameters (p' = ((W+U)^-1)U(m-p) + p)
- TMatrixD tmp(hit,TMatrixD::kMinus,param);
- TMatrixD tmp2(hitWeight,TMatrixD::kMult,tmp); // U(m-p)
+ TMatrixD tmp(clusterParam,TMatrixD::kMinus,param);
+ TMatrixD tmp2(clusterWeight,TMatrixD::kMult,tmp); // U(m-p)
TMatrixD newParam(newParamCov,TMatrixD::kMult,tmp2); // ((W+U)^-1)U(m-p)
newParam += param; // ((W+U)^-1)U(m-p) + p
// Save the new parameters
- trackParamAtHit.SetParameters(newParam);
+ trackParamAtCluster.SetParameters(newParam);
// Compute the additional chi2 (= ((p'-p)^-1)W(p'-p) + ((p'-m)^-1)U(p'-m))
tmp = newParam; // p'
TMatrixD tmp3(paramWeight,TMatrixD::kMult,tmp); // W(p'-p)
TMatrixD addChi2Track(tmp,TMatrixD::kTransposeMult,tmp3); // ((p'-p)^-1)W(p'-p)
tmp = newParam; // p'
- tmp -= hit; // (p'-m)
- TMatrixD tmp4(hitWeight,TMatrixD::kMult,tmp); // U(p'-m)
+ tmp -= clusterParam; // (p'-m)
+ TMatrixD tmp4(clusterWeight,TMatrixD::kMult,tmp); // U(p'-m)
addChi2Track += TMatrixD(tmp,TMatrixD::kTransposeMult,tmp4); // ((p'-p)^-1)W(p'-p) + ((p'-m)^-1)U(p'-m)
return addChi2Track(0,0);
}
//__________________________________________________________________________
-void AliMUONTrackReconstructorK::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtHit, Double_t addChi2)
+void AliMUONTrackReconstructorK::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtCluster, Double_t addChi2)
{
- /// Add 1 hit to the track candidate
+ /// Add 1 cluster to the track candidate
/// Update chi2 of the track
- // Flag hit as being not removable
- trackParamAtHit.SetRemovable(kFALSE);
- trackParamAtHit.SetLocalChi2(0.); // --> Local chi2 not used
+ // Flag cluster as being not removable
+ trackParamAtCluster.SetRemovable(kFALSE);
+ trackParamAtCluster.SetLocalChi2(0.); // --> Local chi2 not used
- // Update the track chi2 into TrackParamAtHit
- trackParamAtHit.SetTrackChi2(track.GetFitFMin() + addChi2);
+ // Update the track chi2 into trackParamAtCluster
+ trackParamAtCluster.SetTrackChi2(track.GetGlobalChi2() + addChi2);
// Update the chi2 of the new track
- track.SetFitFMin(trackParamAtHit.GetTrackChi2());
+ track.SetGlobalChi2(trackParamAtCluster.GetTrackChi2());
- // Update array of TrackParamAtHit
- track.AddTrackParamAtHit(&trackParamAtHit,trackParamAtHit.GetHitForRecPtr());
- track.GetTrackParamAtHit()->Sort();
+ // Update array of TrackParamAtCluster
+ track.AddTrackParamAtCluster(trackParamAtCluster,*(trackParamAtCluster.GetClusterPtr()));
+ track.GetTrackParamAtCluster()->Sort();
}
//__________________________________________________________________________
-void AliMUONTrackReconstructorK::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtHit1, AliMUONTrackParam &trackParamAtHit2,
- Double_t addChi2AtHit1, Double_t addChi2AtHit2)
+void AliMUONTrackReconstructorK::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtCluster1, AliMUONTrackParam &trackParamAtCluster2,
+ Double_t addChi2AtCluster1, Double_t addChi2AtCluster2)
{
- /// Add 2 hits to the track candidate
+ /// Add 2 clusters to the track candidate (order is important)
/// Update track and local chi2
- // Update local chi2 at first hit
- AliMUONHitForRec* hit1 = trackParamAtHit1.GetHitForRecPtr();
- Double_t deltaX = trackParamAtHit1.GetNonBendingCoor() - hit1->GetNonBendingCoor();
- Double_t deltaY = trackParamAtHit1.GetBendingCoor() - hit1->GetBendingCoor();
- Double_t localChi2AtHit1 = deltaX*deltaX / hit1->GetNonBendingReso2() +
- deltaY*deltaY / hit1->GetBendingReso2();
- trackParamAtHit1.SetLocalChi2(localChi2AtHit1);
+ // Update local chi2 at first cluster
+ AliMUONVCluster* cluster1 = trackParamAtCluster1.GetClusterPtr();
+ Double_t deltaX = trackParamAtCluster1.GetNonBendingCoor() - cluster1->GetX();
+ Double_t deltaY = trackParamAtCluster1.GetBendingCoor() - cluster1->GetY();
+ Double_t localChi2AtCluster1 = deltaX*deltaX / cluster1->GetErrX2() +
+ deltaY*deltaY / cluster1->GetErrY2();
+ trackParamAtCluster1.SetLocalChi2(localChi2AtCluster1);
- // Flag first hit as being removable
- trackParamAtHit1.SetRemovable(kTRUE);
+ // Flag first cluster as being removable
+ trackParamAtCluster1.SetRemovable(kTRUE);
- // Update local chi2 at second hit
- AliMUONHitForRec* hit2 = trackParamAtHit2.GetHitForRecPtr();
- AliMUONTrackParam extrapTrackParamAtHit2(trackParamAtHit1);
- AliMUONTrackExtrap::ExtrapToZ(&extrapTrackParamAtHit2, trackParamAtHit2.GetZ());
- deltaX = extrapTrackParamAtHit2.GetNonBendingCoor() - hit2->GetNonBendingCoor();
- deltaY = extrapTrackParamAtHit2.GetBendingCoor() - hit2->GetBendingCoor();
- Double_t localChi2AtHit2 = deltaX*deltaX / hit2->GetNonBendingReso2() +
- deltaY*deltaY / hit2->GetBendingReso2();
- trackParamAtHit2.SetLocalChi2(localChi2AtHit2);
+ // Update local chi2 at second cluster
+ AliMUONVCluster* cluster2 = trackParamAtCluster2.GetClusterPtr();
+ AliMUONTrackParam extrapTrackParamAtCluster2(trackParamAtCluster1);
+ AliMUONTrackExtrap::ExtrapToZ(&extrapTrackParamAtCluster2, trackParamAtCluster2.GetZ());
+ deltaX = extrapTrackParamAtCluster2.GetNonBendingCoor() - cluster2->GetX();
+ deltaY = extrapTrackParamAtCluster2.GetBendingCoor() - cluster2->GetY();
+ Double_t localChi2AtCluster2 = deltaX*deltaX / cluster2->GetErrX2() +
+ deltaY*deltaY / cluster2->GetErrY2();
+ trackParamAtCluster2.SetLocalChi2(localChi2AtCluster2);
- // Flag second hit as being removable
- trackParamAtHit2.SetRemovable(kTRUE);
+ // Flag second cluster as being removable
+ trackParamAtCluster2.SetRemovable(kTRUE);
- // Update the track chi2 into TrackParamAtHit1
- trackParamAtHit1.SetTrackChi2(track.GetFitFMin() + addChi2AtHit1);
+ // Update the track chi2 into trackParamAtCluster2
+ trackParamAtCluster2.SetTrackChi2(track.GetGlobalChi2() + addChi2AtCluster2);
- // Update the track chi2 into TrackParamAtHit2
- trackParamAtHit2.SetTrackChi2(trackParamAtHit1.GetTrackChi2() + addChi2AtHit2);
+ // Update the track chi2 into trackParamAtCluster1
+ trackParamAtCluster1.SetTrackChi2(trackParamAtCluster2.GetTrackChi2() + addChi2AtCluster1);
// Update the chi2 of the new track
- track.SetFitFMin(trackParamAtHit2.GetTrackChi2());
+ track.SetGlobalChi2(trackParamAtCluster1.GetTrackChi2());
- // Update array of TrackParamAtHit
- track.AddTrackParamAtHit(&trackParamAtHit1,trackParamAtHit1.GetHitForRecPtr());
- track.AddTrackParamAtHit(&trackParamAtHit2,trackParamAtHit2.GetHitForRecPtr());
- track.GetTrackParamAtHit()->Sort();
+ // Update array of trackParamAtCluster
+ track.AddTrackParamAtCluster(trackParamAtCluster1,*cluster1);
+ track.AddTrackParamAtCluster(trackParamAtCluster2,*cluster2);
+ track.GetTrackParamAtCluster()->Sort();
}
//__________________________________________________________________________
-Bool_t AliMUONTrackReconstructorK::RecoverTrack(AliMUONTrack &trackCandidate, Int_t nextStation)
+Bool_t AliMUONTrackReconstructorK::RecoverTrack(AliMUONTrack &trackCandidate, const AliMUONVClusterStore& clusterStore, Int_t nextStation)
{
/// Try to recover the track candidate in the next station
- /// by removing the worst of the two hits attached in the current station
+ /// by removing the worst of the two clusters attached in the current station
/// Return kTRUE if recovering succeeds
AliDebug(1,"Enter RecoverTrack");
- // Do not try to recover track until we have attached hit(s) on station(1..) 3
+ // Do not try to recover track until we have attached cluster(s) on station(1..) 3
if (nextStation > 1) return kFALSE;
- Int_t worstHitNumber = -1;
- Double_t localChi2, worstChi2 = 0.;
+ Int_t worstClusterNumber = -1;
+ Double_t localChi2, worstLocalChi2 = 0.;
- // Look for the hit to remove
- for (Int_t hitNumber = 0; hitNumber < 2; hitNumber++) {
- AliMUONTrackParam *trackParamAtHit = (AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->UncheckedAt(hitNumber);
+ // Look for the cluster to remove
+ for (Int_t clusterNumber = 0; clusterNumber < 2; clusterNumber++) {
+ AliMUONTrackParam *trackParamAtCluster = (AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->UncheckedAt(clusterNumber);
- // check if current hit is removable
- if (!trackParamAtHit->IsRemovable()) return kFALSE;
+ // check if current cluster is removable
+ if (!trackParamAtCluster->IsRemovable()) return kFALSE;
- // Pick up hit with the worst chi2
- localChi2 = trackParamAtHit->GetLocalChi2();
- if (localChi2 > worstChi2) {
- worstChi2 = localChi2;
- worstHitNumber = hitNumber;
+ // Pick up cluster with the worst chi2
+ localChi2 = trackParamAtCluster->GetLocalChi2();
+ if (localChi2 > worstLocalChi2) {
+ worstLocalChi2 = localChi2;
+ worstClusterNumber = clusterNumber;
}
}
- // Reset best hit as being NOT removable
- ((AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->UncheckedAt((worstHitNumber+1)%2))->SetRemovable(kFALSE);
+ // Reset best cluster as being NOT removable
+ ((AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->UncheckedAt((worstClusterNumber+1)%2))->SetRemovable(kFALSE);
- // Remove the worst hit
- trackCandidate.RemoveTrackParamAtHit((AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->UncheckedAt(worstHitNumber));
+ // Remove the worst cluster
+ trackCandidate.RemoveTrackParamAtCluster((AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->UncheckedAt(worstClusterNumber));
- // Re-calculate track parameters at the (new) first hit
- RetracePartialTrack(trackCandidate,(AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->UncheckedAt(1));
+ // Re-calculate track parameters at the (new) first cluster
+ RetracePartialTrack(trackCandidate,(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->UncheckedAt(1));
- // Look for new hit(s) in next station
- return FollowTrackInStation(trackCandidate,nextStation);
+ // Look for new cluster(s) in next station
+ return FollowTrackInStation(trackCandidate, clusterStore, nextStation);
}
/// Compute new track parameters and their covariances using smoother
AliDebug(1,"Enter UseSmoother");
- AliMUONTrackParam *previousTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtHit()->First();
+ AliMUONTrackParam *previousTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->First();
- // Smoothed parameters and covariances at first hit = filtered parameters and covariances
+ // Smoothed parameters and covariances at first cluster = filtered parameters and covariances
previousTrackParam->SetSmoothParameters(previousTrackParam->GetParameters());
previousTrackParam->SetSmoothCovariances(previousTrackParam->GetCovariances());
- // Compute local chi2 at first hit
- AliMUONHitForRec *hitForRecAtHit = previousTrackParam->GetHitForRecPtr();
- Double_t dX = hitForRecAtHit->GetNonBendingCoor() - previousTrackParam->GetNonBendingCoor();
- Double_t dY = hitForRecAtHit->GetBendingCoor() - previousTrackParam->GetBendingCoor();
- Double_t localChi2 = dX * dX / hitForRecAtHit->GetNonBendingReso2() + dY * dY / hitForRecAtHit->GetBendingReso2();
+ // Compute local chi2 at first cluster
+ AliMUONVCluster *cluster = previousTrackParam->GetClusterPtr();
+ Double_t dX = cluster->GetX() - previousTrackParam->GetNonBendingCoor();
+ Double_t dY = cluster->GetY() - previousTrackParam->GetBendingCoor();
+ Double_t localChi2 = dX * dX / cluster->GetErrX2() + dY * dY / cluster->GetErrY2();
- // Save local chi2 at first hit
+ // Save local chi2 at first cluster
previousTrackParam->SetLocalChi2(localChi2);
- AliMUONTrackParam *currentTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtHit()->After(previousTrackParam);
+ AliMUONTrackParam *currentTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->After(previousTrackParam);
while (currentTrackParam) {
// Get variables
// Save smoothed covariances
currentTrackParam->SetSmoothCovariances(smoothCovariances);
- // Compute smoothed residual: r(k n) = hit - X(k n)
- hitForRecAtHit = currentTrackParam->GetHitForRecPtr();
+ // Compute smoothed residual: r(k n) = cluster - X(k n)
+ cluster = currentTrackParam->GetClusterPtr();
TMatrixD smoothResidual(2,1);
smoothResidual.Zero();
- smoothResidual(0,0) = hitForRecAtHit->GetNonBendingCoor() - smoothParameters(0,0);
- smoothResidual(1,0) = hitForRecAtHit->GetBendingCoor() - smoothParameters(2,0);
+ smoothResidual(0,0) = cluster->GetX() - smoothParameters(0,0);
+ smoothResidual(1,0) = cluster->GetY() - smoothParameters(2,0);
- // Compute weight of smoothed residual: W(k n) = (hitCov - C(k n))^-1
+ // Compute weight of smoothed residual: W(k n) = (clusterCov - C(k n))^-1
TMatrixD smoothResidualWeight(2,2);
- smoothResidualWeight(0,0) = hitForRecAtHit->GetNonBendingReso2() - smoothCovariances(0,0);
+ smoothResidualWeight(0,0) = cluster->GetErrX2() - smoothCovariances(0,0);
smoothResidualWeight(0,1) = - smoothCovariances(0,2);
smoothResidualWeight(1,0) = - smoothCovariances(2,0);
- smoothResidualWeight(1,1) = hitForRecAtHit->GetBendingReso2() - smoothCovariances(2,2);
+ smoothResidualWeight(1,1) = cluster->GetErrY2() - smoothCovariances(2,2);
if (smoothResidualWeight.Determinant() != 0) {
smoothResidualWeight.Invert();
} else {
currentTrackParam->SetLocalChi2(localChi2(0,0));
previousTrackParam = currentTrackParam;
- currentTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtHit()->After(previousTrackParam);
+ currentTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->After(previousTrackParam);
}
return kTRUE;
}
//__________________________________________________________________________
-void AliMUONTrackReconstructorK::ComplementTracks()
+void AliMUONTrackReconstructorK::ComplementTracks(const AliMUONVClusterStore& clusterStore)
{
/// Complete tracks by adding missing clusters (if there is an overlap between
/// two detection elements, the track may have two clusters in the same chamber)
AliDebug(1,"Enter ComplementTracks");
Int_t chamberId, detElemId;
- Double_t chi2OfHitForRec, addChi2TrackAtHit, bestAddChi2TrackAtHit;
- Double_t maxChi2OfHitForRec = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
- AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
- Bool_t foundOneHit, trackModified;
- AliMUONHitForRec *hitForRec;
- AliMUONTrackParam *trackParam, *previousTrackParam, *nextTrackParam;
- AliMUONTrackParam trackParamAtHit;
- AliMUONTrackParam bestTrackParamAtHit;
+ Double_t chi2OfCluster, addChi2TrackAtCluster, bestAddChi2TrackAtCluster;
+ Double_t maxChi2OfCluster = 2. * AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking() *
+ AliMUONReconstructor::GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+ Bool_t foundOneCluster, trackModified;
+ AliMUONVCluster *cluster;
+ AliMUONTrackParam *trackParam, *previousTrackParam, *nextTrackParam, trackParamAtCluster, bestTrackParamAtCluster;
// Remove double track to complete only "good" tracks
RemoveDoubleTracks();
while (track) {
trackModified = kFALSE;
- trackParam = (AliMUONTrackParam*)track->GetTrackParamAtHit()->First();
+ trackParam = (AliMUONTrackParam*)track->GetTrackParamAtCluster()->First();
previousTrackParam = trackParam;
while (trackParam) {
- foundOneHit = kFALSE;
- bestAddChi2TrackAtHit = 1.e10;
+ foundOneCluster = kFALSE;
+ bestAddChi2TrackAtCluster = 1.e10;
+ chamberId = trackParam->GetClusterPtr()->GetChamberId();
+ detElemId = trackParam->GetClusterPtr()->GetDetElemId();
// prepare nextTrackParam before adding new cluster because of the sorting
- nextTrackParam = (AliMUONTrackParam*)track->GetTrackParamAtHit()->After(trackParam);
+ nextTrackParam = (AliMUONTrackParam*)track->GetTrackParamAtCluster()->After(trackParam);
- chamberId = trackParam->GetHitForRecPtr()->GetChamberNumber();
- detElemId = trackParam->GetHitForRecPtr()->GetDetElemId();
+ // Create iterators to loop over clusters in current chamber
+ TIter nextInCh(clusterStore.CreateChamberIterator(chamberId,chamberId));
// look for one second candidate in the same chamber
- for (Int_t hit = 0; hit < fNHitsForRecPerChamber[chamberId]; hit++) {
-
- hitForRec = (AliMUONHitForRec*) fHitsForRecPtr->UncheckedAt(fIndexOfFirstHitForRecPerChamber[chamberId]+hit);
+ while ( ( cluster = static_cast<AliMUONVCluster*>(nextInCh()) ) ) {
// look for a cluster in another detection element
- if (hitForRec->GetDetElemId() == detElemId) continue;
+ if (cluster->GetDetElemId() == detElemId) continue;
- // try to add the current hit fast
- if (!TryOneHitForRecFast(*trackParam, hitForRec)) continue;
+ // try to add the current cluster fast
+ if (!TryOneClusterFast(*trackParam, cluster)) continue;
- // try to add the current hit accurately
+ // try to add the current cluster accurately
// never use track parameters at last cluster because the covariance matrix is meaningless
- if (nextTrackParam) chi2OfHitForRec = TryOneHitForRec(*trackParam, hitForRec, trackParamAtHit);
- else chi2OfHitForRec = TryOneHitForRec(*previousTrackParam, hitForRec, trackParamAtHit);
+ if (nextTrackParam) chi2OfCluster = TryOneCluster(*trackParam, cluster, trackParamAtCluster);
+ else chi2OfCluster = TryOneCluster(*previousTrackParam, cluster, trackParamAtCluster);
// if good chi2 then consider to add this cluster to the track
- if (chi2OfHitForRec < maxChi2OfHitForRec) {
+ if (chi2OfCluster < maxChi2OfCluster) {
- // Compute local track parameters including "hitForRec" using kalman filter
- addChi2TrackAtHit = RunKalmanFilter(trackParamAtHit);
+ // Compute local track parameters including current cluster using kalman filter
+ addChi2TrackAtCluster = RunKalmanFilter(trackParamAtCluster);
// keep track of the best cluster
- if (addChi2TrackAtHit < bestAddChi2TrackAtHit) {
- bestAddChi2TrackAtHit = addChi2TrackAtHit;
- bestTrackParamAtHit = trackParamAtHit;
- foundOneHit = kTRUE;
+ if (addChi2TrackAtCluster < bestAddChi2TrackAtCluster) {
+ bestAddChi2TrackAtCluster = addChi2TrackAtCluster;
+ bestTrackParamAtCluster = trackParamAtCluster;
+ foundOneCluster = kTRUE;
}
}
}
// add new cluster if any
- if (foundOneHit) {
- UpdateTrack(*track,bestTrackParamAtHit,bestAddChi2TrackAtHit);
- bestTrackParamAtHit.SetAloneInChamber(kFALSE);
+ if (foundOneCluster) {
+ UpdateTrack(*track,bestTrackParamAtCluster,bestAddChi2TrackAtCluster);
+ bestTrackParamAtCluster.SetAloneInChamber(kFALSE);
trackParam->SetAloneInChamber(kFALSE);
trackModified = kTRUE;
}
Double_t localChi2, worstLocalChi2;
Int_t worstChamber, previousChamber;
AliMUONTrack *track, *nextTrack;
- AliMUONTrackParam *trackParamAtHit, *worstTrackParamAtHit, *previousTrackParam, *nextTrackParam;
+ AliMUONTrackParam *trackParamAtCluster, *worstTrackParamAtCluster, *previousTrackParam, *nextTrackParam;
Bool_t smoothed;
Double_t sigmaCut2 = AliMUONReconstructor::GetRecoParam()->GetSigmaCutForImprovement() *
AliMUONReconstructor::GetRecoParam()->GetSigmaCutForImprovement();
if (!smoothed) {
// Update track parameters and covariances
- track->UpdateCovTrackParamAtHit();
+ track->UpdateCovTrackParamAtCluster();
- // Compute local chi2 of each hits
+ // Compute local chi2 of each clusters
track->ComputeLocalChi2(kTRUE);
}
- // Look for the hit to remove
- worstTrackParamAtHit = NULL;
+ // Look for the cluster to remove
+ worstTrackParamAtCluster = NULL;
worstLocalChi2 = 0.;
- trackParamAtHit = (AliMUONTrackParam*)track->GetTrackParamAtHit()->First();
- while (trackParamAtHit) {
+ trackParamAtCluster = (AliMUONTrackParam*)track->GetTrackParamAtCluster()->First();
+ while (trackParamAtCluster) {
- // Pick up hit with the worst chi2
- localChi2 = trackParamAtHit->GetLocalChi2();
+ // Pick up cluster with the worst chi2
+ localChi2 = trackParamAtCluster->GetLocalChi2();
if (localChi2 > worstLocalChi2) {
worstLocalChi2 = localChi2;
- worstTrackParamAtHit = trackParamAtHit;
+ worstTrackParamAtCluster = trackParamAtCluster;
}
- trackParamAtHit = (AliMUONTrackParam*)track->GetTrackParamAtHit()->After(trackParamAtHit);
+ trackParamAtCluster = (AliMUONTrackParam*)track->GetTrackParamAtCluster()->After(trackParamAtCluster);
}
- // Check if bad removable hit found
- if (!worstTrackParamAtHit) {
+ // Check if bad removable cluster found
+ if (!worstTrackParamAtCluster) {
track->SetImproved(kTRUE);
break;
}
break;
}
- // if the worst hit is not removable then remove the entire track
- if (!worstTrackParamAtHit->IsRemovable() && worstTrackParamAtHit->IsAloneInChamber()) {
+ // if the worst cluster is not removable then remove the entire track
+ if (!worstTrackParamAtCluster->IsRemovable() && worstTrackParamAtCluster->IsAloneInChamber()) {
fRecTracksPtr->Remove(track);
fNRecTracks--;
break;
}
- // Reset the second hit in the same station as being not removable
- // or reset the second hit in the same chamber as being alone
- worstChamber = worstTrackParamAtHit->GetHitForRecPtr()->GetChamberNumber();
- previousTrackParam = (AliMUONTrackParam*) track->GetTrackParamAtHit()->Before(worstTrackParamAtHit);
- nextTrackParam = (AliMUONTrackParam*) track->GetTrackParamAtHit()->After(worstTrackParamAtHit);
- if (worstTrackParamAtHit->IsAloneInChamber()) { // Worst hit removable and alone in chamber
+ // Reset the second cluster in the same station as being not removable
+ // or reset the second cluster in the same chamber as being alone
+ worstChamber = worstTrackParamAtCluster->GetClusterPtr()->GetChamberId();
+ previousTrackParam = (AliMUONTrackParam*) track->GetTrackParamAtCluster()->Before(worstTrackParamAtCluster);
+ nextTrackParam = (AliMUONTrackParam*) track->GetTrackParamAtCluster()->After(worstTrackParamAtCluster);
+ if (worstTrackParamAtCluster->IsAloneInChamber()) { // Worst cluster removable and alone in chamber
if (worstChamber%2 == 0) { // Modify flags in next chamber
nextTrackParam->SetRemovable(kFALSE);
- if (!nextTrackParam->IsAloneInChamber()) // Make sure both hits in second chamber are not removable anymore
- ((AliMUONTrackParam*) track->GetTrackParamAtHit()->After(nextTrackParam))->SetRemovable(kFALSE);
+ if (!nextTrackParam->IsAloneInChamber()) // Make sure both clusters in second chamber are not removable anymore
+ ((AliMUONTrackParam*) track->GetTrackParamAtCluster()->After(nextTrackParam))->SetRemovable(kFALSE);
} else { // Modify flags in previous chamber
previousTrackParam->SetRemovable(kFALSE);
- if (!previousTrackParam->IsAloneInChamber()) // Make sure both hits in second chamber are not removable anymore
- ((AliMUONTrackParam*) track->GetTrackParamAtHit()->Before(previousTrackParam))->SetRemovable(kFALSE);
+ if (!previousTrackParam->IsAloneInChamber()) // Make sure both clusters in second chamber are not removable anymore
+ ((AliMUONTrackParam*) track->GetTrackParamAtCluster()->Before(previousTrackParam))->SetRemovable(kFALSE);
}
- } else { // Worst hit not alone in its chamber
+ } else { // Worst cluster not alone in its chamber
- if (previousTrackParam) previousChamber = previousTrackParam->GetHitForRecPtr()->GetChamberNumber();
+ if (previousTrackParam) previousChamber = previousTrackParam->GetClusterPtr()->GetChamberId();
else previousChamber = -1;
- if (previousChamber == worstChamber) { // the second hit on the same chamber is the previous one
+ if (previousChamber == worstChamber) { // the second cluster on the same chamber is the previous one
previousTrackParam->SetAloneInChamber(kTRUE);
- // transfert the removability to the second hit
- if (worstTrackParamAtHit->IsRemovable()) previousTrackParam->SetRemovable(kTRUE);
+ // transfert the removability to the second cluster
+ if (worstTrackParamAtCluster->IsRemovable()) previousTrackParam->SetRemovable(kTRUE);
- } else { // the second hit on the same chamber is the next one
+ } else { // the second cluster on the same chamber is the next one
nextTrackParam->SetAloneInChamber(kTRUE);
- // transfert the removability to the second hit
- if (worstTrackParamAtHit->IsRemovable()) nextTrackParam->SetRemovable(kTRUE);
+ // transfert the removability to the second cluster
+ if (worstTrackParamAtCluster->IsRemovable()) nextTrackParam->SetRemovable(kTRUE);
}
}
- // Remove the worst hit
- track->RemoveTrackParamAtHit(worstTrackParamAtHit);
+ // Remove the worst cluster
+ track->RemoveTrackParamAtCluster(worstTrackParamAtCluster);
// Re-calculate track parameters
- // - from the hit immediately downstream the one suppressed
+ // - from the cluster immediately downstream the one suppressed
// - or from the begining - if parameters have been re-computed using the standard method (kalman parameters have been lost)
- // - or if the removed hit was the last one
+ // - or if the removed cluster was the last one
if (smoothed && nextTrackParam) RetracePartialTrack(*track,nextTrackParam);
else RetraceTrack(*track,kTRUE);
//__________________________________________________________________________
void AliMUONTrackReconstructorK::Finalize()
{
- /// Fill AliMUONTrack's fHitForRecAtHit array
+ /// Update track parameters and covariances at each attached cluster
AliMUONTrack *track;
- AliMUONTrackParam *trackParamAtHit;
+ AliMUONTrackParam *trackParamAtCluster;
Bool_t smoothed = kFALSE;
track = (AliMUONTrack*) fRecTracksPtr->First();
if (!track->IsImproved()) {
smoothed = kFALSE;
if (AliMUONReconstructor::GetRecoParam()->UseSmoother()) smoothed = RunSmoother(*track);
- if (!smoothed) track->UpdateCovTrackParamAtHit();
+ if (!smoothed) track->UpdateCovTrackParamAtCluster();
}
- trackParamAtHit = (AliMUONTrackParam*) (track->GetTrackParamAtHit()->First());
- while (trackParamAtHit) {
+ // copy smoothed parameters and covariances if any
+ if (smoothed) {
- // copy smoothed parameters and covariances if any
- if (smoothed) {
- trackParamAtHit->SetParameters(trackParamAtHit->GetSmoothParameters());
- trackParamAtHit->SetCovariances(trackParamAtHit->GetSmoothCovariances());
+ trackParamAtCluster = (AliMUONTrackParam*) (track->GetTrackParamAtCluster()->First());
+ while (trackParamAtCluster) {
+
+ trackParamAtCluster->SetParameters(trackParamAtCluster->GetSmoothParameters());
+ trackParamAtCluster->SetCovariances(trackParamAtCluster->GetSmoothCovariances());
+
+ trackParamAtCluster = (AliMUONTrackParam*) (track->GetTrackParamAtCluster()->After(trackParamAtCluster));
}
- // update array of track hits
- track->AddHitForRecAtHit(trackParamAtHit->GetHitForRecPtr());
-
- trackParamAtHit = (AliMUONTrackParam*) (track->GetTrackParamAtHit()->After(trackParamAtHit));
}
track = (AliMUONTrack*) fRecTracksPtr->After(track);
-
}
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff