/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONTrackReconstructor
/// MUON track reconstructor using the original method
///
///
/// It contains as methods, among others:
/// - MakeTracks to build the tracks
-///
+//-----------------------------------------------------------------------------
#include "AliMUONTrackReconstructor.h"
#include "AliMUONConstants.h"
-#include "AliMUONHitForRec.h"
+#include "AliMUONVCluster.h"
+#include "AliMUONVClusterServer.h"
+#include "AliMUONVClusterStore.h"
#include "AliMUONTrack.h"
#include "AliMUONTrackParam.h"
#include "AliMUONTrackExtrap.h"
+#include "AliMUONRecoParam.h"
+#include "AliMUONGeometryTransformer.h"
+
+#include "AliMpArea.h"
+
#include "AliLog.h"
#include <TMinuit.h>
#include <Riostream.h>
#include <TMath.h>
#include <TMatrixD.h>
+#include <TClonesArray.h>
// Functions to be minimized with Minuit
void TrackChi2(Int_t &nParam, Double_t *gradient, Double_t &chi2, Double_t *param, Int_t flag);
+using std::endl;
+using std::cout;
/// \cond CLASSIMP
ClassImp(AliMUONTrackReconstructor) // Class implementation in ROOT context
/// \endcond
-//************* Parameters for reconstruction
-const Double_t AliMUONTrackReconstructor::fgkBendingVertexDispersion = 10.;
-const Double_t AliMUONTrackReconstructor::fgkNonBendingVertexDispersion = 10.;
-
-
//__________________________________________________________________________
-AliMUONTrackReconstructor::AliMUONTrackReconstructor()
- : AliMUONVTrackReconstructor()
+AliMUONTrackReconstructor::AliMUONTrackReconstructor(const AliMUONRecoParam* recoParam, AliMUONVClusterServer* clusterServer,
+ const AliMUONGeometryTransformer* transformer)
+ : AliMUONVTrackReconstructor(recoParam, clusterServer, transformer)
{
- /// Constructor for class AliMUONTrackReconstructor
- AliInfo("*** Original tracking ***");
+ /// Constructor
}
//__________________________________________________________________________
}
//__________________________________________________________________________
-void AliMUONTrackReconstructor::MakeTrackCandidates()
+Bool_t AliMUONTrackReconstructor::MakeTrackCandidates(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");
+ // Unless we're doing combined tracking, we'll clusterize all stations at once
+ Int_t firstChamber(0);
+ Int_t lastChamber(9);
+
+ if (GetRecoParam()->CombineClusterTrackReco()) {
+ // ... Here's the exception : ask the clustering to reconstruct
+ // clusters *only* in station 4 and 5 for combined tracking
+ firstChamber = 6;
+ }
+
+ for (Int_t i = firstChamber; i <= lastChamber; ++i )
+ {
+ if (fClusterServer && GetRecoParam()->UseChamber(i)) fClusterServer->Clusterize(i, clusterStore, AliMpArea(), GetRecoParam());
+ }
+
// Loop over stations(1..) 5 and 4 and make track candidates
for (Int_t istat=4; istat>=3; istat--) {
// Make segments in the station
- segments = MakeSegmentsInStation(istat);
+ segments = MakeSegmentsBetweenChambers(clusterStore, 2*istat, 2*istat+1);
// Loop over segments
for (Int_t iseg=0; iseg<segments->GetEntriesFast(); iseg++)
AliDebug(1,Form("Making primary candidate(1..) %d",++iCandidate));
// Transform segments to tracks and put them at the end of fRecTracksPtr
- track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]));
+ track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]),GetRecoParam()->GetBendingVertexDispersion());
fNRecTracks++;
- // Printout for debuging
- if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2))
- {
- cout<<endl<<"Track parameter covariances at first hit with multiple Coulomb scattering effects:"<<endl;
- ((AliMUONTrackParam*) track->GetTrackParamAtHit()->First())->GetCovariances().Print();
- }
+ // Look for compatible cluster(s) in the other station
+ if (GetRecoParam()->MakeTrackCandidatesFast())
+ clusterFound = FollowLinearTrackInStation(*track, clusterStore, 7-istat);
+ else clusterFound = FollowTrackInStation(*track, clusterStore, 7-istat);
- // Look for compatible hitForRec(s) in the other station
- if (fgkMakeTrackCandidatesFast) hitFound = FollowLinearTrackInStation(*track,7-istat);
- else hitFound = FollowTrackInStation(*track,7-istat);
-
- // Remove track if no hit found
- if (!hitFound) {
- fRecTracksPtr->Remove(track);
- fNRecTracks--;
+ // Remove track if no cluster found on a requested station
+ // or abort tracking if there are too many candidates
+ if (GetRecoParam()->RequestStation(7-istat)) {
+ if (!clusterFound) {
+ fRecTracksPtr->Remove(track);
+ fNRecTracks--;
+ } else if (fNRecTracks > GetRecoParam()->GetMaxTrackCandidates()) {
+ AliError(Form("Too many track candidates (%d tracks). Stop tracking.", fNRecTracks));
+ return kFALSE;
+ }
+ } else {
+ if ((fNRecTracks + segments->GetEntriesFast() - iseg - 1) > GetRecoParam()->GetMaxTrackCandidates()) {
+ AliError(Form("Too many track candidates (%d tracks). Stop tracking.", fNRecTracks + segments->GetEntriesFast() - iseg - 1));
+ return kFALSE;
+ }
}
}
- // delete the array of segments
- delete segments;
}
- fRecTracksPtr->Compress(); // this is essential before checking tracks
-
// Keep all different tracks or only the best ones as required
- if (fgkTrackAllTracks) RemoveIdenticalTracks();
+ if (GetRecoParam()->TrackAllTracks()) RemoveIdenticalTracks();
else RemoveDoubleTracks();
AliDebug(1,Form("Number of good candidates = %d",fNRecTracks));
+ return kTRUE;
+
}
//__________________________________________________________________________
-void AliMUONTrackReconstructor::FollowTracks()
+Bool_t AliMUONTrackReconstructor::MakeMoreTrackCandidates(AliMUONVClusterStore& clusterStore)
+{
+ /// To make extra track candidates (assuming linear propagation if the flag fgkMakeTrackCandidatesFast is set to kTRUE):
+ /// clustering is supposed to be already done
+ /// Start with segments made of 1 cluster in each of the stations 4 and 5 then follow track in remaining chambers.
+ /// Good candidates are made of at least three clusters if both station are requested (two otherwise).
+ /// Keep only best candidates or all of them according to the flag fgkTrackAllTracks.
+
+ TClonesArray *segments;
+ AliMUONObjectPair *segment;
+ AliMUONTrack *track;
+ Int_t iCandidate = 0, iCurrentTrack, nCurrentTracks;
+ Bool_t clusterFound;
+
+ AliDebug(1,"Enter MakeMoreTrackCandidates");
+
+ // Double loop over chambers in stations(1..) 4 and 5 to make track candidates
+ for (Int_t ich1 = 6; ich1 <= 7; ich1++) {
+ for (Int_t ich2 = 8; ich2 <= 9; ich2++) {
+
+ // Make segments in the station
+ segments = MakeSegmentsBetweenChambers(clusterStore, ich1, ich2);
+
+ /// Remove segments already attached to a track
+ RemoveUsedSegments(*segments);
+
+ // Loop over segments
+ for (Int_t iSegment=0; iSegment<segments->GetEntriesFast(); iSegment++)
+ {
+ AliDebug(1,Form("Making primary candidate(1..) %d",++iCandidate));
+ segment = (AliMUONObjectPair*) segments->UncheckedAt(iSegment);
+
+ // Transform segments to tracks and put them at the end of fRecTracksPtr
+ iCurrentTrack = fRecTracksPtr->GetLast()+1;
+ track = new ((*fRecTracksPtr)[iCurrentTrack]) AliMUONTrack(segment,GetRecoParam()->GetBendingVertexDispersion());
+ fNRecTracks++;
+
+ // Look for compatible cluster(s) in the second chamber of station 5
+ clusterFound = FollowLinearTrackInChamber(*track, clusterStore, 17-ich2);
+
+ // skip the original track in case it has been removed
+ if (GetRecoParam()->TrackAllTracks() && clusterFound) iCurrentTrack++;
+
+ // loop over every new tracks
+ nCurrentTracks = fRecTracksPtr->GetLast()+1;
+ while (iCurrentTrack < nCurrentTracks) {
+ track = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iCurrentTrack);
+
+ // Look for compatible cluster(s) in the second chamber of station 4
+ FollowLinearTrackInChamber(*track, clusterStore, 13-ich1);
+
+ iCurrentTrack++;
+ }
+
+ // abort tracking if there are too many candidates
+ if ((fNRecTracks + segments->GetEntriesFast() - iSegment - 1) > GetRecoParam()->GetMaxTrackCandidates()) {
+ AliError(Form("Too many track candidates (%d tracks). Stop tracking.", fNRecTracks + segments->GetEntriesFast() - iSegment - 1));
+ return kFALSE;
+ }
+
+ }
+
+ }
+ }
+
+ // Keep only the best tracks if required
+ if (!GetRecoParam()->TrackAllTracks()) RemoveDoubleTracks();
+ else fRecTracksPtr->Compress();
+
+ AliDebug(1,Form("Number of good candidates = %d",fNRecTracks));
+
+ return kTRUE;
+
+}
+
+ //__________________________________________________________________________
+Bool_t AliMUONTrackReconstructor::FollowTracks(AliMUONVClusterStore& clusterStore)
{
/// Follow tracks in stations(1..) 3, 2 and 1
AliDebug(1,"Enter FollowTracks");
AliMUONTrack *track, *nextTrack;
+ AliMUONTrackParam *trackParam, *nextTrackParam;
Int_t currentNRecTracks;
- Bool_t hitFound;
+
+ Double_t sigmaCut2 = GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking();
for (Int_t station = 2; station >= 0; station--) {
// Fit the track:
// Do not take into account the multiple scattering to speed up the fit
// Calculate the track parameter covariance matrix
- // If "station" is station(1..) 3 then use the vertex to better constrain the fit
- if (station==2) {
- SetVertexForFit(*track);
- track->SetFitWithVertex(kTRUE);
- } else track->SetFitWithVertex(kFALSE);
- Fit(*track, kFALSE, kTRUE);
-
- // Remove the track if the normalized chi2 is too high
- if (track->GetNormalizedChi2() > fgkSigmaToCutForTracking * fgkSigmaToCutForTracking) {
- fRecTracksPtr->Remove(track);
- fNRecTracks--;
- continue;
+ // If there is no cluster out of station 4 or 5 then use the vertex to better constrain the fit
+ if (((AliMUONTrackParam*) track->GetTrackParamAtCluster()->First())->GetClusterPtr()->GetChamberId() > 5)
+ Fit(*track, kFALSE, kTRUE, kTRUE);
+ else Fit(*track, kFALSE, kFALSE, kTRUE);
+
+ // remove tracks out of limits
+ if (!IsAcceptable(*((AliMUONTrackParam*)track->GetTrackParamAtCluster()->First()))) {
+ fRecTracksPtr->Remove(track);
+ fNRecTracks--;
+ continue;
}
- // Printout for debuging
- if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
- cout<<endl<<"Track parameter covariances at first hit with multiple Coulomb scattering effects:"<<endl;
- ((AliMUONTrackParam*) track->GetTrackParamAtHit()->First())->GetCovariances().Print();
+ // remove track if the normalized chi2 is too high
+ if (track->GetNormalizedChi2() > sigmaCut2) {
+ fRecTracksPtr->Remove(track);
+ fNRecTracks--;
+ continue;
}
- // Look for compatible hitForRec in station(0..) "station"
- hitFound = FollowTrackInStation(*track,station);
+ // save parameters from fit into smoothed parameters to complete track afterward
+ if (GetRecoParam()->ComplementTracks()) {
+
+ if (station==2) { // save track parameters on stations 4 and 5
+
+ // extrapolate track parameters and covariances at each cluster
+ // remove the track in case of failure
+ if (!track->UpdateCovTrackParamAtCluster()) {
+ fRecTracksPtr->Remove(track);
+ fNRecTracks--;
+ continue;
+ }
+
+ // save them
+ trackParam = (AliMUONTrackParam*) track->GetTrackParamAtCluster()->First();
+ while (trackParam) {
+ trackParam->SetSmoothParameters(trackParam->GetParameters());
+ trackParam->SetSmoothCovariances(trackParam->GetCovariances());
+ trackParam = (AliMUONTrackParam*) track->GetTrackParamAtCluster()->After(trackParam);
+ }
+
+ } else { // or save track parameters on last station only
+
+ trackParam = (AliMUONTrackParam*) track->GetTrackParamAtCluster()->First();
+ if (trackParam->GetClusterPtr()->GetChamberId() < 2*(station+2)) {
+
+ // save parameters from fit
+ trackParam->SetSmoothParameters(trackParam->GetParameters());
+ trackParam->SetSmoothCovariances(trackParam->GetCovariances());
+
+ // save parameters extrapolated to the second chamber of the same station if it has been hit
+ nextTrackParam = (AliMUONTrackParam*) track->GetTrackParamAtCluster()->After(trackParam);
+ if (nextTrackParam->GetClusterPtr()->GetChamberId() < 2*(station+2)) {
+
+ // reset parameters and covariances
+ nextTrackParam->SetParameters(trackParam->GetParameters());
+ nextTrackParam->SetZ(trackParam->GetZ());
+ nextTrackParam->SetCovariances(trackParam->GetCovariances());
+
+ // extrapolate them to the z of the corresponding cluster
+ // remove the track in case of failure
+ if (!AliMUONTrackExtrap::ExtrapToZCov(nextTrackParam, nextTrackParam->GetClusterPtr()->GetZ())) {
+ fRecTracksPtr->Remove(track);
+ fNRecTracks--;
+ continue;
+ }
+
+ // save them
+ nextTrackParam->SetSmoothParameters(nextTrackParam->GetParameters());
+ nextTrackParam->SetSmoothCovariances(nextTrackParam->GetCovariances());
+
+ }
+
+ }
+
+ }
+
+ }
- // Try to recover track if required
- if (!hitFound && fgkRecoverTracks) hitFound = RecoverTrack(*track,station);
+ // Look for compatible cluster(s) in station(0..) "station"
+ if (!FollowTrackInStation(*track, clusterStore, station)) {
+
+ // Try to recover track if required
+ if (GetRecoParam()->RecoverTracks()) {
+
+ // work on a copy of the track if this station is not required
+ // to keep the case where no cluster is reconstructed as a possible candidate
+ if (!GetRecoParam()->RequestStation(station)) {
+ track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(*track);
+ fNRecTracks++;
+ }
+
+ // try to recover
+ if (!RecoverTrack(*track, clusterStore, station)) {
+ // remove track if no cluster found
+ fRecTracksPtr->Remove(track);
+ fNRecTracks--;
+ }
+
+ } else if (GetRecoParam()->RequestStation(station)) {
+ // remove track if no cluster found
+ fRecTracksPtr->Remove(track);
+ fNRecTracks--;
+ }
+
+ }
- // remove track if no hit found
- if (!hitFound) {
- fRecTracksPtr->Remove(track);
- fNRecTracks--;
+ // abort tracking if there are too many candidates
+ if (fNRecTracks > GetRecoParam()->GetMaxTrackCandidates()) {
+ AliError(Form("Too many track candidates (%d tracks). Stop tracking.", fNRecTracks));
+ return kFALSE;
}
}
fRecTracksPtr->Compress();
// Keep only the best tracks if required
- if (!fgkTrackAllTracks) RemoveDoubleTracks();
+ if (!GetRecoParam()->TrackAllTracks()) RemoveDoubleTracks();
}
- // Last fit of track candidates with all station
+ // Last fit of track candidates with all stations
// Take into account the multiple scattering and remove bad tracks
Int_t trackIndex = -1;
track = (AliMUONTrack*) fRecTracksPtr->First();
trackIndex++;
nextTrack = (AliMUONTrack*) fRecTracksPtr->After(track); // prepare next track
- track->SetFitWithVertex(kFALSE); // just to be sure
- Fit(*track, kTRUE, kTRUE);
+ Fit(*track, kTRUE, kFALSE, kTRUE);
// Printout for debuging
if (AliLog::GetGlobalDebugLevel() >= 3) {
}
// Remove the track if the normalized chi2 is too high
- if (track->GetNormalizedChi2() > fgkSigmaToCutForTracking * fgkSigmaToCutForTracking) {
+ if (track->GetNormalizedChi2() > sigmaCut2) {
fRecTracksPtr->Remove(track);
fNRecTracks--;
+ track = nextTrack;
+ continue;
+ }
+
+ // save parameters from fit into smoothed parameters to complete track afterward
+ if (GetRecoParam()->ComplementTracks()) {
+
+ trackParam = (AliMUONTrackParam*) track->GetTrackParamAtCluster()->First();
+ if (trackParam->GetClusterPtr()->GetChamberId() < 2) {
+
+ // save parameters from fit
+ trackParam->SetSmoothParameters(trackParam->GetParameters());
+ trackParam->SetSmoothCovariances(trackParam->GetCovariances());
+
+ // save parameters extrapolated to the second chamber of the same station if it has been hit
+ nextTrackParam = (AliMUONTrackParam*) track->GetTrackParamAtCluster()->After(trackParam);
+ if (nextTrackParam->GetClusterPtr()->GetChamberId() < 2) {
+
+ // reset parameters and covariances
+ nextTrackParam->SetParameters(trackParam->GetParameters());
+ nextTrackParam->SetZ(trackParam->GetZ());
+ nextTrackParam->SetCovariances(trackParam->GetCovariances());
+
+ // extrapolate them to the z of the corresponding cluster
+ // remove the track in case of failure
+ if (!AliMUONTrackExtrap::ExtrapToZCov(nextTrackParam, nextTrackParam->GetClusterPtr()->GetZ())) {
+ fRecTracksPtr->Remove(track);
+ fNRecTracks--;
+ track = nextTrack;
+ continue;
+ }
+
+ // save them
+ nextTrackParam->SetSmoothParameters(nextTrackParam->GetParameters());
+ nextTrackParam->SetSmoothCovariances(nextTrackParam->GetCovariances());
+
+ }
+
+ }
+
}
track = nextTrack;
fRecTracksPtr->Compress();
+ return kTRUE;
+
+}
+
+ //__________________________________________________________________________
+Bool_t AliMUONTrackReconstructor::FollowTrackInChamber(AliMUONTrack &trackCandidate, AliMUONVClusterStore& clusterStore, Int_t nextChamber)
+{
+ /// Follow trackCandidate in chamber(0..) nextChamber 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 cluster(s) to the "trackCandidate". Try to add a couple of clusters in priority.
+ AliDebug(1,Form("Enter FollowTrackInChamber(1..) %d", nextChamber+1));
+
+ 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;
+ AliMUONVCluster *cluster;
+ AliMUONTrackParam extrapTrackParam;
+ AliMUONTrackParam extrapTrackParamAtCh;
+ AliMUONTrackParam extrapTrackParamAtCluster;
+ AliMUONTrackParam bestTrackParamAtCluster;
+
+ // Get track parameters according to the propagation direction
+ if (nextChamber > 7) extrapTrackParamAtCh = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->Last();
+ else extrapTrackParamAtCh = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->First();
+
+ // Printout for debuging
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+ cout<<endl<<"Track parameters and covariances at first cluster:"<<endl;
+ extrapTrackParamAtCh.GetParameters().Print();
+ extrapTrackParamAtCh.GetCovariances().Print();
+ }
+
+ // Add MCS effect
+ Int_t currentChamber = extrapTrackParamAtCh.GetClusterPtr()->GetChamberId();
+ AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(currentChamber),-1.);
+
+ // Add MCS in the missing chamber(s) if any
+ while (currentChamber > nextChamber + 1) {
+ // extrapolation to the missing chamber
+ currentChamber--;
+ if (!AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(currentChamber))) return kFALSE;
+ // add MCS effect
+ AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(currentChamber),-1.);
+ }
+
+ //Extrapolate trackCandidate to chamber
+ if (!AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(nextChamber))) return kFALSE;
+
+ // Printout for debuging
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+ cout<<endl<<"Track parameters and covariances at first cluster extrapolated to z = "<<AliMUONConstants::DefaultChamberZ(nextChamber)<<":"<<endl;
+ extrapTrackParamAtCh.GetParameters().Print();
+ extrapTrackParamAtCh.GetCovariances().Print();
+ }
+
+ // Printout for debuging
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+ cout << "FollowTrackInStation: look for clusters in chamber(1..): " << nextChamber+1 << endl;
+ }
+
+ // Ask the clustering to reconstruct new clusters around the track position in the current chamber
+ // except for station 4 and 5 that are already entirely clusterized
+ if (GetRecoParam()->CombineClusterTrackReco()) {
+ if (nextChamber < 6) AskForNewClustersInChamber(extrapTrackParamAtCh, clusterStore, nextChamber);
+ }
+
+ // Create iterators to loop over clusters in both chambers
+ TIter next(clusterStore.CreateChamberIterator(nextChamber,nextChamber));
+
+ // look for cluster in chamber
+ while ( ( cluster = static_cast<AliMUONVCluster*>(next()) ) ) {
+
+ // try to add the current cluster fast
+ if (!TryOneClusterFast(extrapTrackParamAtCh, cluster)) continue;
+
+ // try to add the current cluster accuratly
+ chi2WithOneCluster = TryOneCluster(extrapTrackParamAtCh, cluster, extrapTrackParamAtCluster);
+
+ // if good chi2 then consider to add cluster
+ if (chi2WithOneCluster < maxChi2WithOneCluster) {
+ foundOneCluster = kTRUE;
+
+ // Printout for debuging
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+ cout << "FollowTrackInStation: found one cluster in chamber(1..): " << nextChamber+1
+ << " (Chi2 = " << chi2WithOneCluster << ")" << endl;
+ cluster->Print();
+ }
+
+ 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);
+ UpdateTrack(*newTrack,extrapTrackParamAtCluster);
+ fNRecTracks++;
+
+ // Printout for debuging
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+ cout << "FollowTrackInStation: added one cluster in chamber(1..): " << nextChamber+1 << endl;
+ if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
+ }
+
+ } else if (chi2WithOneCluster < bestChi2WithOneCluster) {
+ // keep track of the best single cluster except if a couple of clusters has already been found
+ bestChi2WithOneCluster = chi2WithOneCluster;
+ bestTrackParamAtCluster = extrapTrackParamAtCluster;
+ }
+
+ }
+
+ }
+
+ // fill out the best track if required else clean up the fRecTracksPtr array
+ if (!GetRecoParam()->TrackAllTracks()) {
+ if (foundOneCluster) {
+ UpdateTrack(trackCandidate,bestTrackParamAtCluster);
+
+ // Printout for debuging
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+ cout << "FollowTrackInStation: added the best cluster in chamber(1..): " << bestTrackParamAtCluster.GetClusterPtr()->GetChamberId()+1 << endl;
+ if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
+ }
+
+ } else return kFALSE;
+
+ } else if (foundOneCluster) {
+
+ // remove obsolete track
+ fRecTracksPtr->Remove(&trackCandidate);
+ fNRecTracks--;
+
+ } else return kFALSE;
+
+ return kTRUE;
+
}
//__________________________________________________________________________
-Bool_t AliMUONTrackReconstructor::FollowTrackInStation(AliMUONTrack &trackCandidate, Int_t nextStation)
+Bool_t AliMUONTrackReconstructor::FollowTrackInStation(AliMUONTrack &trackCandidate, 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.
+ /// kFALSE: add only the best cluster(s) to the "trackCandidate". Try to add a couple of clusters in priority.
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 chi2WithOneHitForRec = 1.e10;
- Double_t chi2WithTwoHitForRec = 1.e10;
- Double_t maxChi2WithOneHitForRec = 2. * fgkSigmaToCutForTracking * fgkSigmaToCutForTracking; // 2 because 2 quantities in chi2
- Double_t maxChi2WithTwoHitForRec = 4. * fgkSigmaToCutForTracking * fgkSigmaToCutForTracking; // 4 because 4 quantities in chi2
- Double_t bestChi2WithOneHitForRec = maxChi2WithOneHitForRec;
- Double_t bestChi2WithTwoHitForRec = maxChi2WithTwoHitForRec;
- Bool_t foundOneHit = kFALSE;
- Bool_t foundTwoHits = kFALSE;
+ 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;
+ 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 extrapTrackParamAtCh;
+ AliMUONTrackParam extrapTrackParamAtCluster1;
+ AliMUONTrackParam extrapTrackParamAtCluster2;
+ AliMUONTrackParam bestTrackParamAtCluster1;
+ AliMUONTrackParam bestTrackParamAtCluster2;
- // Get track parameters
- AliMUONTrackParam extrapTrackParamAtCh(*(AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->First());
+ // Get track parameters according to the propagation direction
+ if (nextStation==4) extrapTrackParamAtCh = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->Last();
+ else extrapTrackParamAtCh = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->First();
+
+ // Printout for debuging
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+ cout<<endl<<"Track parameters and covariances at first cluster:"<<endl;
+ extrapTrackParamAtCh.GetParameters().Print();
+ extrapTrackParamAtCh.GetCovariances().Print();
+ }
// Add MCS effect
- AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
+ Int_t currentChamber = extrapTrackParamAtCh.GetClusterPtr()->GetChamberId();
+ AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(currentChamber),-1.);
- // 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) {
+ // Add MCS in the missing chamber(s) if any
+ while (ch1 < ch2 && currentChamber > ch2 + 1) {
// extrapolation to the missing chamber
- AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch2 + 1));
+ currentChamber--;
+ if (!AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(currentChamber))) return kFALSE;
// add MCS effect
- AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
+ AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(currentChamber),-1.);
}
//Extrapolate trackCandidate to chamber "ch2"
- AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch2));
+ if (!AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch2))) return kFALSE;
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
- cout<<endl<<"Track parameter covariances at first hit extrapolated to z = "<<AliMUONConstants::DefaultChamberZ(ch2)<<":"<<endl;
+ cout<<endl<<"Track parameters and covariances at first cluster extrapolated to z = "<<AliMUONConstants::DefaultChamberZ(ch2)<<":"<<endl;
+ extrapTrackParamAtCh.GetParameters().Print();
extrapTrackParamAtCh.GetCovariances().Print();
}
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 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);
+ // Ask the clustering to reconstruct new clusters around the track position in the current station
+ // except for station 4 and 5 that are already entirely clusterized
+ if (GetRecoParam()->CombineClusterTrackReco()) {
+ if (nextStation < 3) AskForNewClustersInStation(extrapTrackParamAtCh, clusterStore, nextStation);
+ }
+
+ 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;
+
+ // 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
- chi2WithOneHitForRec = TryOneHitForRec(extrapTrackParamAtCh, hitForRecCh2, extrapTrackParamAtHit2);
+ // try to add the current cluster accuratly
+ chi2WithOneCluster = TryOneCluster(extrapTrackParamAtCh, clusterCh2, extrapTrackParamAtCluster2);
- // if good chi2 then try to attach a hitForRec in the other chamber too
- if (chi2WithOneHitForRec < maxChi2WithOneHitForRec) {
- Bool_t foundSecondHit = kFALSE;
+ // if good chi2 then try to attach a cluster in the other chamber too
+ if (chi2WithOneCluster < maxChi2WithOneCluster) {
+ Bool_t foundSecondCluster = kFALSE;
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: found one hit in chamber(1..): " << ch2+1
- << " (Chi2 = " << chi2WithOneHitForRec << ")" << endl;
- cout << " look for second hits in chamber(1..): " << ch1+1 << " ..." << endl;
+ cout << "FollowTrackInStation: found one cluster in chamber(1..): " << ch2+1
+ << " (Chi2 = " << chi2WithOneCluster << ")" << endl;
+ clusterCh2->Print();
+ cout << " look for second clusters in chamber(1..): " << ch1+1 << " ..." << endl;
}
// add MCS effect for next step
- AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtHit2,AliMUONConstants::ChamberThicknessInX0(),1.);
+ AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCluster2,AliMUONConstants::ChamberThicknessInX0(ch2),-1.);
// copy new track parameters for next step
- extrapTrackParam = extrapTrackParamAtHit2;
+ extrapTrackParam = extrapTrackParamAtCluster2;
//Extrapolate track parameters to chamber "ch1"
- AliMUONTrackExtrap::ExtrapToZ(&extrapTrackParam, AliMUONConstants::DefaultChamberZ(ch1));
+ Bool_t normalExtrap = AliMUONTrackExtrap::ExtrapToZ(&extrapTrackParam, AliMUONConstants::DefaultChamberZ(ch1));
- 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
+ if (normalExtrap) 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
- chi2WithTwoHitForRec = TryTwoHitForRec(extrapTrackParamAtHit2, hitForRecCh1, extrapTrackParamAtHit1);
+ // try to add the current cluster accurately
+ chi2WithTwoClusters = TryTwoClusters(extrapTrackParamAtCluster2, clusterCh1, extrapTrackParamAtCluster1);
- // if good chi2 then create a new track by adding the 2 hitForRec to the "trackCandidate"
- if (chi2WithTwoHitForRec < maxChi2WithTwoHitForRec) {
- foundSecondHit = kTRUE;
- foundTwoHits = kTRUE;
+ // if good chi2 then create a new track by adding the 2 clusters to the "trackCandidate"
+ if (chi2WithTwoClusters < maxChi2WithTwoClusters) {
+ foundSecondCluster = kTRUE;
+ foundTwoClusters = kTRUE;
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: found second hit in chamber(1..): " << ch1+1
- << " (Global Chi2 = " << chi2WithTwoHitForRec << ")" << endl;
+ cout << "FollowTrackInStation: found second cluster in chamber(1..): " << ch1+1
+ << " (Global Chi2 = " << chi2WithTwoClusters << ")" << endl;
+ clusterCh1->Print();
}
- if (fgkTrackAllTracks) {
- // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new hitForRec's
+ 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);
- UpdateTrack(*newTrack,extrapTrackParamAtHit1,extrapTrackParamAtHit2);
+ UpdateTrack(*newTrack,extrapTrackParamAtCluster1,extrapTrackParamAtCluster2);
fNRecTracks++;
- // Tag hitForRecCh1 as used
- hitForRecCh1Used[hit1] = kTRUE;
+ // Tag clusterCh1 as used
+ clusterCh1Used[iCluster1] = kTRUE;
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 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 (chi2WithTwoHitForRec < bestChi2WithTwoHitForRec) {
- // keep track of the best couple of hits
- bestChi2WithTwoHitForRec = chi2WithTwoHitForRec;
- bestTrackParamAtHit1 = extrapTrackParamAtHit1;
- bestTrackParamAtHit2 = extrapTrackParamAtHit2;
+ } else if (chi2WithTwoClusters < bestChi2WithTwoClusters) {
+ // keep track of the best couple of clusters
+ bestChi2WithTwoClusters = chi2WithTwoClusters;
+ 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 (fgkTrackAllTracks) {
- // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new hitForRec's
+ 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);
- UpdateTrack(*newTrack,extrapTrackParamAtHit2);
+ UpdateTrack(*newTrack,extrapTrackParamAtCluster2);
fNRecTracks++;
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 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 && chi2WithOneHitForRec < bestChi2WithOneHitForRec) {
- // keep track of the best single hitForRec except if a couple of hits has already been found
- bestChi2WithOneHitForRec = chi2WithOneHitForRec;
- bestTrackParamAtHit1 = extrapTrackParamAtHit2;
+ } else if (!foundTwoClusters && chi2WithOneCluster < bestChi2WithOneCluster) {
+ // keep track of the best single cluster except if a couple of clusters has already been found
+ bestChi2WithOneCluster = chi2WithOneCluster;
+ 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 (fgkTrackAllTracks || !foundTwoHits) {
+ // if we want to keep all possible tracks or if no good couple of clusters has been found
+ if (GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
+
+ // add MCS effect for next step
+ AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(ch2),-1.);
+
+ //Extrapolate trackCandidate to chamber "ch1"
+ Bool_t normalExtrap = AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch1));
// Printout for debuging
- if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: look for single hits in chamber(1..): " << ch1+1 << endl;
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+ cout<<endl<<"Track parameters and covariances at first cluster extrapolated to z = "<<AliMUONConstants::DefaultChamberZ(ch1)<<":"<<endl;
+ extrapTrackParamAtCh.GetParameters().Print();
+ extrapTrackParamAtCh.GetCovariances().Print();
}
- // add MCS effect for next step
- AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
+ // Printout for debuging
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+ cout << "FollowTrackInStation: look for single clusters in chamber(1..): " << ch1+1 << endl;
+ }
- //Extrapolate trackCandidate to chamber "ch1"
- AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch1));
+ // reset cluster iterator of chamber 1
+ nextInCh1.Reset();
+ iCluster1 = -1;
- for (Int_t hit1 = 0; hit1 < fNHitsForRecPerChamber[ch1]; hit1++) {
+ // look for second candidates in chamber 1
+ if (normalExtrap) while ( ( clusterCh1 = static_cast<AliMUONVCluster*>(nextInCh1()) ) ) {
+ iCluster1++;
- hitForRecCh1 = (AliMUONHitForRec*) fHitsForRecPtr->UncheckedAt(fIndexOfFirstHitForRecPerChamber[ch1]+hit1);
+ if (clusterCh1Used[iCluster1]) continue; // Skip cluster already used
- if (hitForRecCh1Used[hit1]) continue; // Skip hitForRec already used
+ // try to add the current cluster fast
+ if (!TryOneClusterFast(extrapTrackParamAtCh, clusterCh1)) continue;
- // try to add the current hit fast
- if (!TryOneHitForRecFast(extrapTrackParamAtCh, hitForRecCh1)) continue;
+ // try to add the current cluster accuratly
+ chi2WithOneCluster = TryOneCluster(extrapTrackParamAtCh, clusterCh1, extrapTrackParamAtCluster1);
- // try to add the current hit accuratly
- chi2WithOneHitForRec = TryOneHitForRec(extrapTrackParamAtCh, hitForRecCh1, extrapTrackParamAtHit1);
-
- // 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 (chi2WithOneHitForRec < maxChi2WithOneHitForRec) {
- 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 (chi2WithOneCluster < maxChi2WithOneCluster) {
+ foundOneCluster = kTRUE;
+
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "FollowTrackInStation: found one hit in chamber(1..): " << ch1+1
- << " (Chi2 = " << chi2WithOneHitForRec << ")" << endl;
+ cout << "FollowTrackInStation: found one cluster in chamber(1..): " << ch1+1
+ << " (Chi2 = " << chi2WithOneCluster << ")" << endl;
+ clusterCh1->Print();
}
- if (fgkTrackAllTracks) {
- // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new hitForRec's
+ 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);
- UpdateTrack(*newTrack,extrapTrackParamAtHit1);
+ UpdateTrack(*newTrack,extrapTrackParamAtCluster1);
fNRecTracks++;
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 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 (chi2WithOneHitForRec < bestChi2WithOneHitForRec) {
- // keep track of the best single hitForRec except if a couple of hits has already been found
- bestChi2WithOneHitForRec = chi2WithOneHitForRec;
- bestTrackParamAtHit1 = extrapTrackParamAtHit1;
+ } else if (chi2WithOneCluster < bestChi2WithOneCluster) {
+ // keep track of the best single cluster except if a couple of clusters has already been found
+ bestChi2WithOneCluster = chi2WithOneCluster;
+ bestTrackParamAtCluster1 = extrapTrackParamAtCluster1;
}
}
}
// fill out the best track if required else clean up the fRecTracksPtr array
- if (!fgkTrackAllTracks) {
- if (foundTwoHits) {
- UpdateTrack(trackCandidate,bestTrackParamAtHit1,bestTrackParamAtHit2);
+ if (!GetRecoParam()->TrackAllTracks()) {
+ if (foundTwoClusters) {
+ UpdateTrack(trackCandidate,bestTrackParamAtCluster1,bestTrackParamAtCluster2);
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 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);
+ } else if (foundOneCluster) {
+ UpdateTrack(trackCandidate,bestTrackParamAtCluster1);
// Printout for debuging
if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 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 return kFALSE;
+ } else {
+ delete [] clusterCh1Used;
+ return kFALSE;
+ }
- } else if (foundOneHit || foundTwoHits) {
+ } else if (foundOneCluster || foundTwoClusters) {
// remove obsolete track
fRecTracksPtr->Remove(&trackCandidate);
fNRecTracks--;
- } else return kFALSE;
+ } else {
+ delete [] clusterCh1Used;
+ return kFALSE;
+ }
+ delete [] clusterCh1Used;
return kTRUE;
}
//__________________________________________________________________________
-Double_t AliMUONTrackReconstructor::TryTwoHitForRec(const AliMUONTrackParam &trackParamAtHit1, AliMUONHitForRec* hitForRec2,
- AliMUONTrackParam &trackParamAtHit2)
+Double_t AliMUONTrackReconstructor::TryTwoClusters(const AliMUONTrackParam &trackParamAtCluster1, AliMUONVCluster* cluster2,
+ AliMUONTrackParam &trackParamAtCluster2)
{
-/// Test the compatibility between the track and the 2 hitForRec together (using trackParam's covariance matrix):
-/// return the corresponding Chi2 accounting for covariances between the 2 hitForRec
-/// return trackParamAtHit1 & 2
-
- // extrapolate track parameters at the z position of the second hit
- trackParamAtHit2.SetParameters(trackParamAtHit1.GetParameters());
- trackParamAtHit2.SetZ(trackParamAtHit1.GetZ());
- AliMUONTrackExtrap::ExtrapToZ(&trackParamAtHit2, hitForRec2->GetZ());
-
- // set pointer to hit2 into trackParamAtHit2
- trackParamAtHit2.SetHitForRecPtr(hitForRec2);
-
- // Set differences between track and the 2 hitForRec in the bending and non bending directions
- AliMUONHitForRec* hitForRec1 = trackParamAtHit1.GetHitForRecPtr();
+/// Test the compatibility between the track and the 2 clusters together (using trackParam's covariance matrix):
+/// return the corresponding Chi2 accounting for covariances between the 2 clusters
+/// return trackParamAtCluster1 & 2
+
+ // extrapolate track parameters at the z position of the second cluster (no need to extrapolate the covariances)
+ // and set pointer to cluster into trackParamAtCluster
+ trackParamAtCluster2.SetParameters(trackParamAtCluster1.GetParameters());
+ trackParamAtCluster2.SetZ(trackParamAtCluster1.GetZ());
+ trackParamAtCluster2.SetClusterPtr(cluster2);
+ if (!AliMUONTrackExtrap::ExtrapToZ(&trackParamAtCluster2, cluster2->GetZ())) return 2.*AliMUONTrack::MaxChi2();
+
+ // Set differences between track and the 2 clusters in the bending and non bending directions
+ AliMUONVCluster* cluster1 = trackParamAtCluster1.GetClusterPtr();
TMatrixD dPos(4,1);
- dPos(0,0) = hitForRec1->GetNonBendingCoor() - trackParamAtHit1.GetNonBendingCoor();
- dPos(1,0) = hitForRec1->GetBendingCoor() - trackParamAtHit1.GetBendingCoor();
- dPos(2,0) = hitForRec2->GetNonBendingCoor() - trackParamAtHit2.GetNonBendingCoor();
- dPos(3,0) = hitForRec2->GetBendingCoor() - trackParamAtHit2.GetBendingCoor();
+ dPos(0,0) = cluster1->GetX() - trackParamAtCluster1.GetNonBendingCoor();
+ dPos(1,0) = cluster1->GetY() - trackParamAtCluster1.GetBendingCoor();
+ dPos(2,0) = cluster2->GetX() - trackParamAtCluster2.GetNonBendingCoor();
+ dPos(3,0) = cluster2->GetY() - trackParamAtCluster2.GetBendingCoor();
- // Calculate the error matrix from the track parameter covariances at first hitForRec
+ // Calculate the error matrix from the track parameter covariances at first cluster
TMatrixD error(4,4);
error.Zero();
- if (trackParamAtHit1.CovariancesExist()) {
- // Save track parameters at first hitForRec
- AliMUONTrackParam trackParamAtHit1Save(trackParamAtHit1);
- TMatrixD paramAtHit1Save(trackParamAtHit1Save.GetParameters());
- Double_t z1 = trackParamAtHit1Save.GetZ();
+ if (trackParamAtCluster1.CovariancesExist()) {
+ // Save track parameters at first cluster
+ TMatrixD paramAtCluster1Save(trackParamAtCluster1.GetParameters());
- // Save track coordinates at second hitForRec
- Double_t nonBendingCoor2 = trackParamAtHit2.GetNonBendingCoor();
- Double_t bendingCoor2 = trackParamAtHit2.GetBendingCoor();
+ // Save track coordinates at second cluster
+ Double_t nonBendingCoor2 = trackParamAtCluster2.GetNonBendingCoor();
+ Double_t bendingCoor2 = trackParamAtCluster2.GetBendingCoor();
- // add MCS effect at first hitForRec
- AliMUONTrackExtrap::AddMCSEffect(&trackParamAtHit1Save,AliMUONConstants::ChamberThicknessInX0(),1.);
+ // copy track parameters at first cluster for jacobian calculation
+ AliMUONTrackParam trackParam(trackParamAtCluster1);
- // Get the pointer to the parameter covariance matrix at first hitForRec
- const TMatrixD& kParamCov = trackParamAtHit1Save.GetCovariances();
+ // Get the pointer to the parameter covariance matrix at first cluster
+ const TMatrixD& kParamCov = trackParam.GetCovariances();
// Calculate the jacobian related to the transformation between track parameters
- // at first hitForRec and track coordinates at the 2 hitForRec z-position
+ // at first cluster and track coordinates at the 2 cluster z-positions
TMatrixD jacob(4,5);
jacob.Zero();
- // first derivative at the first hitForRec:
+ // first derivative at the first cluster:
jacob(0,0) = 1.; // dx1/dx
jacob(1,2) = 1.; // dy1/dy
- // first derivative at the second hitForRec:
+ // first derivative at the second cluster:
TMatrixD dParam(5,1);
+ Double_t direction[5] = {-1.,-1.,1.,1.,-1.};
for (Int_t i=0; i<5; i++) {
// Skip jacobian calculation for parameters with no associated error
if (kParamCov(i,i) == 0.) continue;
for (Int_t j=0; j<5; j++) {
if (j==i) {
dParam(j,0) = TMath::Sqrt(kParamCov(i,i));
- if (j == 4) dParam(j,0) *= TMath::Sign(1.,-paramAtHit1Save(4,0)); // variation always in the same direction
+ dParam(j,0) *= TMath::Sign(1.,direction[j]*paramAtCluster1Save(j,0)); // variation always in the same direction
} else dParam(j,0) = 0.;
}
- // Set new track parameters at first hitForRec
- trackParamAtHit1Save.SetParameters(paramAtHit1Save);
- trackParamAtHit1Save.AddParameters(dParam);
- trackParamAtHit1Save.SetZ(z1);
+ // Set new track parameters at first cluster
+ trackParam.SetParameters(paramAtCluster1Save);
+ trackParam.AddParameters(dParam);
+ trackParam.SetZ(cluster1->GetZ());
- // Extrapolate new track parameters to the z position of the second hitForRec
- AliMUONTrackExtrap::ExtrapToZ(&trackParamAtHit1Save,hitForRec2->GetZ());
+ // Extrapolate new track parameters to the z position of the second cluster
+ if (!AliMUONTrackExtrap::ExtrapToZ(&trackParam,cluster2->GetZ())) return 2.*AliMUONTrack::MaxChi2();
// Calculate the jacobian
- jacob(2,i) = (trackParamAtHit1Save.GetNonBendingCoor() - nonBendingCoor2) / dParam(i,0); // dx2/dParami
- jacob(3,i) = (trackParamAtHit1Save.GetBendingCoor() - bendingCoor2 ) / dParam(i,0); // dy2/dParami
+ jacob(2,i) = (trackParam.GetNonBendingCoor() - nonBendingCoor2) / dParam(i,0); // dx2/dParami
+ jacob(3,i) = (trackParam.GetBendingCoor() - bendingCoor2 ) / dParam(i,0); // dy2/dParami
}
// Calculate the error matrix
error = TMatrixD(tmp,TMatrixD::kMultTranspose,jacob);
}
- // Add hitForRec resolution to the error matrix
- error(0,0) += hitForRec1->GetNonBendingReso2();
- error(1,1) += hitForRec1->GetBendingReso2();
- error(2,2) += hitForRec2->GetNonBendingReso2();
- error(3,3) += hitForRec2->GetBendingReso2();
+ // Add cluster resolution to the error matrix
+ error(0,0) += cluster1->GetErrX2();
+ error(1,1) += cluster1->GetErrY2();
+ error(2,2) += cluster2->GetErrX2();
+ error(3,3) += cluster2->GetErrY2();
// invert the error matrix for Chi2 calculation
if (error.Determinant() != 0) {
error.Invert();
} else {
AliWarning(" Determinant error=0");
- return 1.e10;
+ return 2.*AliMUONTrack::MaxChi2();
}
// Compute the Chi2 value
}
//__________________________________________________________________________
-void AliMUONTrackReconstructor::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtHit)
+void AliMUONTrackReconstructor::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtCluster)
{
- /// Add 1 hit to the track candidate
+ /// Add 1 cluster to the track candidate
/// Update chi2 of the track
// Compute local chi2
- AliMUONHitForRec* hit = trackParamAtHit.GetHitForRecPtr();
- Double_t deltaX = trackParamAtHit.GetNonBendingCoor() - hit->GetNonBendingCoor();
- Double_t deltaY = trackParamAtHit.GetBendingCoor() - hit->GetBendingCoor();
- Double_t localChi2 = deltaX*deltaX / hit->GetNonBendingReso2() +
- deltaY*deltaY / hit->GetBendingReso2();
-
- // Flag hit as being not removable
- trackParamAtHit.SetRemovable(kFALSE);
- trackParamAtHit.SetLocalChi2(0.); // --> Local chi2 not used
+ AliMUONVCluster* cluster = trackParamAtCluster.GetClusterPtr();
+ Double_t deltaX = trackParamAtCluster.GetNonBendingCoor() - cluster->GetX();
+ Double_t deltaY = trackParamAtCluster.GetBendingCoor() - cluster->GetY();
+ Double_t localChi2 = deltaX*deltaX / cluster->GetErrX2() +
+ deltaY*deltaY / cluster->GetErrY2();
+
+ // Flag cluster as being not removable
+ if (GetRecoParam()->RequestStation(cluster->GetChamberId()/2))
+ trackParamAtCluster.SetRemovable(kFALSE);
+ else trackParamAtCluster.SetRemovable(kTRUE);
+ trackParamAtCluster.SetLocalChi2(0.); // --> Local chi2 not used
// Update the chi2 of the new track
- track.SetFitFMin(track.GetFitFMin() + localChi2);
+ track.SetGlobalChi2(track.GetGlobalChi2() + localChi2);
- // Update TrackParamAtHit
- track.AddTrackParamAtHit(&trackParamAtHit,trackParamAtHit.GetHitForRecPtr());
- track.GetTrackParamAtHit()->Sort();
+ // Update TrackParamAtCluster
+ track.AddTrackParamAtCluster(trackParamAtCluster,*cluster);
}
//__________________________________________________________________________
-void AliMUONTrackReconstructor::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtHit1, AliMUONTrackParam &trackParamAtHit2)
+void AliMUONTrackReconstructor::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtCluster1, AliMUONTrackParam &trackParamAtCluster2)
{
- /// Add 2 hits to the track candidate
+ /// Add 2 clusters to the track candidate
/// 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();
- deltaX = trackParamAtHit2.GetNonBendingCoor() - hit2->GetNonBendingCoor();
- deltaY = trackParamAtHit2.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();
+ deltaX = trackParamAtCluster2.GetNonBendingCoor() - cluster2->GetX();
+ deltaY = trackParamAtCluster2.GetBendingCoor() - cluster2->GetY();
+ Double_t localChi2AtCluster2 = deltaX*deltaX / cluster2->GetErrX2() +
+ deltaY*deltaY / cluster2->GetErrY2();
+ trackParamAtCluster2.SetLocalChi2(localChi2AtCluster2);
- // Flag first hit as being removable
- trackParamAtHit2.SetRemovable(kTRUE);
+ // Flag first cluster as being removable
+ trackParamAtCluster2.SetRemovable(kTRUE);
// Update the chi2 of the new track
- track.SetFitFMin(track.GetFitFMin() + localChi2AtHit1 + localChi2AtHit2);
+ track.SetGlobalChi2(track.GetGlobalChi2() + localChi2AtCluster1 + localChi2AtCluster2);
- // Update TrackParamAtHit
- track.AddTrackParamAtHit(&trackParamAtHit1,trackParamAtHit1.GetHitForRecPtr());
- track.AddTrackParamAtHit(&trackParamAtHit2,trackParamAtHit2.GetHitForRecPtr());
- track.GetTrackParamAtHit()->Sort();
+ // Update TrackParamAtCluster
+ track.AddTrackParamAtCluster(trackParamAtCluster1,*cluster1);
+ track.AddTrackParamAtCluster(trackParamAtCluster2,*cluster2);
}
//__________________________________________________________________________
-Bool_t AliMUONTrackReconstructor::RecoverTrack(AliMUONTrack &trackCandidate, Int_t nextStation)
+Bool_t AliMUONTrackReconstructor::RecoverTrack(AliMUONTrack &trackCandidate, 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, worstLocalChi2 = 0.;
+ Int_t worstClusterNumber = -1;
+ Double_t localChi2, worstLocalChi2 = -1.;
- // 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 in the previous station
+ if (trackParamAtCluster->GetClusterPtr()->GetChamberId()/2 != nextStation+1) break;
- // Pick up hit with the worst chi2
- localChi2 = trackParamAtHit->GetLocalChi2();
+ // check if current cluster is removable
+ if (!trackParamAtCluster->IsRemovable()) return kFALSE;
+
+ // reset the current cluster as beig not removable if it is on a required station
+ if (GetRecoParam()->RequestStation(nextStation+1)) trackParamAtCluster->SetRemovable(kFALSE);
+
+ // Pick up cluster with the worst chi2
+ localChi2 = trackParamAtCluster->GetLocalChi2();
if (localChi2 > worstLocalChi2) {
worstLocalChi2 = localChi2;
- worstHitNumber = hitNumber;
+ worstClusterNumber = clusterNumber;
}
+
}
- // Reset best hit as being NOT removable
- ((AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->UncheckedAt((worstHitNumber+1)%2))->SetRemovable(kFALSE);
+ // check if worst cluster found
+ if (worstClusterNumber < 0) return kFALSE;
- // Remove the worst hit
- trackCandidate.RemoveTrackParamAtHit((AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->UncheckedAt(worstHitNumber));
+ // Remove the worst cluster
+ trackCandidate.RemoveTrackParamAtCluster((AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->UncheckedAt(worstClusterNumber));
// Re-fit the track:
// Do not take into account the multiple scattering to speed up the fit
// Calculate the track parameter covariance matrix
- trackCandidate.SetFitWithVertex(kFALSE); // To be sure
- Fit(trackCandidate, kFALSE, kTRUE);
+ Fit(trackCandidate, kFALSE, kFALSE, kTRUE);
+
+ // skip track if the normalized chi2 is too high
+ if (trackCandidate.GetNormalizedChi2() > GetRecoParam()->GetSigmaCutForTracking() * GetRecoParam()->GetSigmaCutForTracking()) return kFALSE;
- // Look for new hit(s) in next station
- return FollowTrackInStation(trackCandidate,nextStation);
+ // skip track out of limits
+ if (!IsAcceptable(*((AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->First()))) return kFALSE;
+
+ // Look for new cluster(s) in next station
+ return FollowTrackInStation(trackCandidate,clusterStore,nextStation);
}
//__________________________________________________________________________
-void AliMUONTrackReconstructor::SetVertexForFit(AliMUONTrack &trackCandidate)
+void AliMUONTrackReconstructor::SetVertexErrXY2ForFit(AliMUONTrack &trackCandidate)
{
- /// Add the vertex as a measured hit to constrain the fit of the "trackCandidate"
- /// Compute the vertex resolution from natural vertex dispersion and
+ /// Compute the vertex resolution square from natural vertex dispersion and
/// multiple scattering effets according to trackCandidate path in absorber
/// It is necessary to account for multiple scattering effects here instead of during the fit of
/// the "trackCandidate" to do not influence the result by changing track resolution at vertex
AliDebug(1,"Enter SetVertexForFit");
- Double_t nonBendingReso2 = fgkNonBendingVertexDispersion * fgkNonBendingVertexDispersion;
- Double_t bendingReso2 = fgkBendingVertexDispersion * fgkBendingVertexDispersion;
+ Double_t nonBendingReso2 = GetRecoParam()->GetNonBendingVertexDispersion() *
+ GetRecoParam()->GetNonBendingVertexDispersion();
+ Double_t bendingReso2 = GetRecoParam()->GetBendingVertexDispersion() *
+ GetRecoParam()->GetBendingVertexDispersion();
+
// add multiple scattering effets
- AliMUONTrackParam paramAtVertex(*((AliMUONTrackParam*)(trackCandidate.GetTrackParamAtHit()->First())));
+ AliMUONTrackParam paramAtVertex(*((AliMUONTrackParam*)(trackCandidate.GetTrackParamAtCluster()->First())));
paramAtVertex.DeleteCovariances(); // to be sure to account only for multiple scattering
- AliMUONTrackExtrap::ExtrapToVertexUncorrected(¶mAtVertex,0.);
- const TMatrixD& kParamCov = paramAtVertex.GetCovariances();
- nonBendingReso2 += kParamCov(0,0);
- bendingReso2 += kParamCov(2,2);
- // Set the vertex
- AliMUONHitForRec vertex; // Coordinates set to (0.,0.,0.) by default
- vertex.SetNonBendingReso2(nonBendingReso2);
- vertex.SetBendingReso2(bendingReso2);
- trackCandidate.SetVertex(&vertex);
+ if (!AliMUONTrackExtrap::ExtrapToZ(¶mAtVertex,AliMUONConstants::AbsZEnd())) {
+ nonBendingReso2 = 0.;
+ bendingReso2 = 0.;
+ } else {
+ AliMUONTrackExtrap::ExtrapToVertexUncorrected(¶mAtVertex,0.);
+ const TMatrixD& kParamCov = paramAtVertex.GetCovariances();
+ nonBendingReso2 += kParamCov(0,0);
+ bendingReso2 += kParamCov(2,2);
+ }
+
+ // Set the vertex resolution square
+ trackCandidate.SetVertexErrXY2(nonBendingReso2,bendingReso2);
}
//__________________________________________________________________________
-void AliMUONTrackReconstructor::Fit(AliMUONTrack &track, Bool_t includeMCS, Bool_t calcCov)
+void AliMUONTrackReconstructor::Fit(AliMUONTrack &track, Bool_t includeMCS, Bool_t fitWithVertex, Bool_t calcCov)
{
- /// Fit the track "track" w/wo multiple Coulomb scattering according to "includeMCS".
+ /// Fit the track
+ /// w/wo multiple Coulomb scattering according to "includeMCS".
+ /// w/wo constraining the vertex according to "fitWithVertex".
+ /// calculating or not the covariance matrix according to "calcCov".
+ AliDebug(1,"Enter Fit");
Double_t benC, errorParam, invBenP, nonBenC, x, y;
AliMUONTrackParam *trackParam;
- Double_t arg[1], fedm, errdef, fitFMin;
+ Double_t arg[1], fedm, errdef, globalChi2;
Int_t npari, nparx;
Int_t status, covStatus;
//gMinuit->mnexcm("SET STR", arg, 1, status);
// set flag w/wo multiple scattering according to "includeMCS"
- track.SetFitWithMCS(includeMCS);
+ track.FitWithMCS(includeMCS);
if (includeMCS) {
- // compute hit weights only once
- if (!track.ComputeHitWeights()) {
+ // compute cluster weights only once
+ if (!track.UpdateTrackParamAtCluster() || !track.ComputeClusterWeights()) {
AliWarning("cannot take into account the multiple scattering effects");
- track.SetFitWithMCS(kFALSE);
+ track.FitWithMCS(kFALSE);
}
}
+ track.FitWithVertex(fitWithVertex);
+ if (fitWithVertex) SetVertexErrXY2ForFit(track);
+
// Set fitting function
gMinuit->SetFCN(TrackChi2);
// Set fitted parameters (!! The order is very important for the covariance matrix !!)
- trackParam = (AliMUONTrackParam*) (track.GetTrackParamAtHit()->First());
- // could be tried with no limits for the search (min=max=0) ????
- // mandatory limits in non Bending to avoid NaN values of parameters
+ // Mandatory limits to avoid NaN values of parameters
+ trackParam = (AliMUONTrackParam*) (track.GetTrackParamAtCluster()->First());
+ Double_t maxIBM = 1. / GetRecoParam()->GetMinBendingMomentum();
gMinuit->mnparm(0, "X", trackParam->GetNonBendingCoor(), 0.03, -500.0, 500.0, status);
- gMinuit->mnparm(1, "NonBenS", trackParam->GetNonBendingSlope(), 0.001, -0.5, 0.5, status);
- // mandatory limits in Bending to avoid NaN values of parameters
+ gMinuit->mnparm(1, "NonBenS", trackParam->GetNonBendingSlope(), 0.001, -1., 1., status);
gMinuit->mnparm(2, "Y", trackParam->GetBendingCoor(), 0.10, -500.0, 500.0, status);
- gMinuit->mnparm(3, "BenS", trackParam->GetBendingSlope(), 0.001, -0.5, 0.5, status);
- gMinuit->mnparm(4, "InvBenP", trackParam->GetInverseBendingMomentum(), 0.003, -0.4, 0.4, status);
+ gMinuit->mnparm(3, "BenS", trackParam->GetBendingSlope(), 0.001, -1.5, 1.5, status);
+ gMinuit->mnparm(4, "InvBenP", trackParam->GetInverseBendingMomentum(), 0.003, -maxIBM, maxIBM, status);
// minimization
gMinuit->mnexcm("MIGRAD", arg, 0, status);
trackParam->SetInverseBendingMomentum(invBenP);
// global result of the fit
- gMinuit->mnstat(fitFMin, fedm, errdef, npari, nparx, covStatus);
- track.SetFitFMin(fitFMin);
+ gMinuit->mnstat(globalChi2, fedm, errdef, npari, nparx, covStatus);
+ track.SetGlobalChi2(globalChi2);
// Get the covariance matrix if required
if (calcCov) {
// Covariance matrix according to HESSE status
// If problem then keep only the diagonal terms (variances)
Double_t matrix[5][5];
+ for (Int_t i=0; i<5; i++) for (Int_t j=0; j<5; j++) matrix[i][j] = 0.;
gMinuit->mnemat(&matrix[0][0],5);
if (covStatus == 3) trackParam->SetCovariances(matrix);
else trackParam->SetVariances(matrix);
void TrackChi2(Int_t & /*nParam*/, Double_t * /*gradient*/, Double_t &chi2, Double_t *param, Int_t /*flag*/)
{
/// Return the "Chi2" to be minimized with Minuit for track fitting.
- /// Assumes that the track hits are sorted according to increasing Z.
- /// Track parameters at each TrackHit are updated accordingly.
+ /// Assumes that the trackParamAtCluster are sorted according to increasing Z.
+ /// Track parameters at each cluster are updated accordingly.
/// Vertex is used according to the flag "trackBeingFitted->GetFitWithVertex()".
/// Multiple Coulomb scattering is taken into account according to the flag "trackBeingFitted->GetFitWithMCS()".
AliMUONTrack *trackBeingFitted = (AliMUONTrack*) gMinuit->GetObjectFit();
- AliMUONTrackParam* trackParamAtHit = (AliMUONTrackParam*) trackBeingFitted->GetTrackParamAtHit()->First();
+ AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) trackBeingFitted->GetTrackParamAtCluster()->First();
Double_t dX, dY;
chi2 = 0.; // initialize chi2
// update track parameters
- trackParamAtHit->SetNonBendingCoor(param[0]);
- trackParamAtHit->SetNonBendingSlope(param[1]);
- trackParamAtHit->SetBendingCoor(param[2]);
- trackParamAtHit->SetBendingSlope(param[3]);
- trackParamAtHit->SetInverseBendingMomentum(param[4]);
- trackBeingFitted->UpdateTrackParamAtHit();
+ trackParamAtCluster->SetNonBendingCoor(param[0]);
+ trackParamAtCluster->SetNonBendingSlope(param[1]);
+ trackParamAtCluster->SetBendingCoor(param[2]);
+ trackParamAtCluster->SetBendingSlope(param[3]);
+ trackParamAtCluster->SetInverseBendingMomentum(param[4]);
+ if (!trackBeingFitted->UpdateTrackParamAtCluster()) {
+ chi2 = 2.*AliMUONTrack::MaxChi2();
+ return;
+ }
// Take the vertex into account in the fit if required
- if (trackBeingFitted->GetFitWithVertex()) {
- AliMUONTrackParam paramAtVertex(*trackParamAtHit);
- AliMUONTrackExtrap::ExtrapToZ(¶mAtVertex, 0.);
- AliMUONHitForRec *vertex = trackBeingFitted->GetVertex();
- if (!vertex) {
- cout<<"Error in TrackChi2: Want to use the vertex in tracking but it has not been created!!"<<endl;
- exit(-1);
+ if (trackBeingFitted->FitWithVertex()) {
+ Double_t nonBendingReso2,bendingReso2;
+ trackBeingFitted->GetVertexErrXY2(nonBendingReso2,bendingReso2);
+ AliMUONTrackParam paramAtVertex(*trackParamAtCluster);
+ if (nonBendingReso2 != 0. && bendingReso2 != 0. && AliMUONTrackExtrap::ExtrapToZ(¶mAtVertex, 0.)) { // vextex position = (0,0,0)
+ dX = paramAtVertex.GetNonBendingCoor();
+ dY = paramAtVertex.GetBendingCoor();
+ chi2 += dX * dX / nonBendingReso2 + dY * dY / bendingReso2;
+ } else {
+ chi2 = 2.*AliMUONTrack::MaxChi2();
+ return;
}
- dX = vertex->GetNonBendingCoor() - paramAtVertex.GetNonBendingCoor();
- dY = vertex->GetBendingCoor() - paramAtVertex.GetBendingCoor();
- chi2 += dX * dX / vertex->GetNonBendingReso2() + dY * dY / vertex->GetBendingReso2();
}
// compute chi2 w/wo multiple scattering
- if (trackBeingFitted->GetFitWithMCS()) chi2 += trackBeingFitted->ComputeGlobalChi2(kTRUE);
- else chi2 += trackBeingFitted->ComputeGlobalChi2(kFALSE);
+ chi2 += trackBeingFitted->ComputeGlobalChi2(trackBeingFitted->FitWithMCS());
}
//__________________________________________________________________________
-void AliMUONTrackReconstructor::ImproveTracks()
+Bool_t AliMUONTrackReconstructor::ComplementTracks(const AliMUONVClusterStore& clusterStore)
{
- /// Improve tracks by removing clusters with local chi2 highter than the defined cut
- /// Recompute track parameters and covariances at the remaining clusters
- AliDebug(1,"Enter ImproveTracks");
-
- Double_t localChi2, worstLocalChi2;
- Int_t worstChamber;
- AliMUONTrackParam *trackParamAtHit, *worstTrackParamAtHit;
-
- // Remove double track to improve only "good" tracks
- RemoveDoubleTracks();
+ /// 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).
+ /// Re-fit track parameters and covariances.
+ /// Return kTRUE if one or more tracks have been complemented.
+ AliDebug(1,"Enter ComplementTracks");
+
+ Int_t chamberId, detElemId;
+ Double_t chi2OfCluster, bestChi2OfCluster;
+ Double_t sigmaCut2 = GetRecoParam()->GetSigmaCutForTracking() *
+ GetRecoParam()->GetSigmaCutForTracking();
+ Bool_t foundOneCluster, trackModified, hasChanged = kFALSE;
+ AliMUONVCluster* cluster;
+ AliMUONTrackParam *trackParam, *nextTrackParam, copyOfTrackParam, trackParamAtCluster, bestTrackParamAtCluster;
AliMUONTrack *track = (AliMUONTrack*) fRecTracksPtr->First();
while (track) {
+ trackModified = kFALSE;
- while (!track->IsImproved()) {
-
- // Update track parameters and covariances
- track->UpdateCovTrackParamAtHit();
+ trackParam = (AliMUONTrackParam*)track->GetTrackParamAtCluster()->First();
+ while (trackParam) {
+ foundOneCluster = kFALSE;
+ bestChi2OfCluster = 2. * sigmaCut2; // 2 because 2 quantities in chi2
+ chamberId = trackParam->GetClusterPtr()->GetChamberId();
+ detElemId = trackParam->GetClusterPtr()->GetDetElemId();
- // Compute local chi2 of each hits
- track->ComputeLocalChi2(kTRUE);
-
- // Look for the hit to remove
- worstTrackParamAtHit = 0;
- worstLocalChi2 = 0.;
- trackParamAtHit = (AliMUONTrackParam*) track->GetTrackParamAtHit()->First();
- while (trackParamAtHit) {
-
- // Pick up hit with the worst chi2
- localChi2 = trackParamAtHit->GetLocalChi2();
- if (localChi2 > worstLocalChi2) {
- worstLocalChi2 = localChi2;
- worstTrackParamAtHit = trackParamAtHit;
- }
-
- trackParamAtHit = (AliMUONTrackParam*) track->GetTrackParamAtHit()->After(trackParamAtHit);
- }
+ // prepare nextTrackParam before adding new cluster because of the sorting
+ nextTrackParam = (AliMUONTrackParam*)track->GetTrackParamAtCluster()->After(trackParam);
- // Check if bad hit found
- if (!worstTrackParamAtHit) {
- track->SetImproved(kTRUE);
- break;
- }
+ // recover track parameters from local fit and put them into a copy of trackParam
+ copyOfTrackParam.SetZ(trackParam->GetZ());
+ copyOfTrackParam.SetParameters(trackParam->GetSmoothParameters());
+ copyOfTrackParam.SetCovariances(trackParam->GetSmoothCovariances());
- // check whether the worst hit is removable or not
- if (!worstTrackParamAtHit->IsRemovable()) {
- track->SetImproved(kTRUE);
- break;
- }
+ // Create iterators to loop over clusters in current chamber
+ TIter nextInCh(clusterStore.CreateChamberIterator(chamberId,chamberId));
- // Check whether the worst chi2 is under requirement or not
- if (worstLocalChi2 < 2. * fgkSigmaToCutForImprovement * fgkSigmaToCutForImprovement) { // 2 because 2 quantities in chi2
- track->SetImproved(kTRUE);
- break;
+ // look for one second candidate in the same chamber
+ while ( ( cluster = static_cast<AliMUONVCluster*>(nextInCh()) ) ) {
+
+ // look for a cluster in another detection element
+ if (cluster->GetDetElemId() == detElemId) continue;
+
+ // try to add the current cluster fast
+ if (!TryOneClusterFast(copyOfTrackParam, cluster)) continue;
+
+ // try to add the current cluster accurately
+ chi2OfCluster = TryOneCluster(copyOfTrackParam, cluster, trackParamAtCluster);
+
+ // if better chi2 then prepare to add this cluster to the track
+ if (chi2OfCluster < bestChi2OfCluster) {
+ bestChi2OfCluster = chi2OfCluster;
+ bestTrackParamAtCluster = trackParamAtCluster;
+ foundOneCluster = kTRUE;
+ }
+
}
- // Reset the second hit in the same station as the bad one as being NOT removable
- worstChamber = worstTrackParamAtHit->GetHitForRecPtr()->GetChamberNumber();
- if (worstChamber%2 == 0) ((AliMUONTrackParam*)track->GetTrackParamAtHit()->After(worstTrackParamAtHit))->SetRemovable(kFALSE);
- else ((AliMUONTrackParam*)track->GetTrackParamAtHit()->Before(worstTrackParamAtHit))->SetRemovable(kFALSE);
-
- // Remove the worst hit
- track->RemoveTrackParamAtHit(worstTrackParamAtHit);
-
- // Re-fit the track:
- // Take into account the multiple scattering
- // Calculate the track parameter covariance matrix
- track->SetFitWithVertex(kFALSE); // To be sure
- Fit(*track, kTRUE, kTRUE);
-
- // Printout for debuging
- if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
- cout << "ImproveTracks: track " << fRecTracksPtr->IndexOf(track)+1 << " improved " << endl;
+ // add new cluster if any
+ if (foundOneCluster) {
+
+ // Printout for debuging
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+ cout << "ComplementTracks: found one cluster in chamber(1..): " << chamberId+1 << endl;
+ bestTrackParamAtCluster.GetClusterPtr()->Print();
+ cout<<endl<<"Track parameters and covariances at cluster:"<<endl;
+ bestTrackParamAtCluster.GetParameters().Print();
+ bestTrackParamAtCluster.GetCovariances().Print();
+ }
+
+ trackParam->SetRemovable(kTRUE);
+ bestTrackParamAtCluster.SetRemovable(kTRUE);
+ track->AddTrackParamAtCluster(bestTrackParamAtCluster,*(bestTrackParamAtCluster.GetClusterPtr()));
+ trackModified = kTRUE;
+ hasChanged = kTRUE;
}
+ trackParam = nextTrackParam;
}
+ // re-fit track parameters if needed
+ if (trackModified) Fit(*track, kTRUE, kFALSE, kTRUE);
+
track = (AliMUONTrack*) fRecTracksPtr->After(track);
}
+ return hasChanged;
+
}
//__________________________________________________________________________
-void AliMUONTrackReconstructor::Finalize()
+void AliMUONTrackReconstructor::ImproveTrack(AliMUONTrack &track)
{
- /// Fill AliMUONTrack's fHitForRecAtHit array
- /// Recompute track parameters and covariances at each attached cluster from those at the first one
- AliMUONTrack *track;
- AliMUONTrackParam *trackParamAtHit;
+ /// Improve the given track by removing clusters with local chi2 highter than the defined cut
+ /// Recompute track parameters and covariances at the remaining clusters
+ AliDebug(1,"Enter ImproveTrack");
- track = (AliMUONTrack*) fRecTracksPtr->First();
- while (track) {
+ Double_t localChi2, worstLocalChi2;
+ AliMUONTrackParam *trackParamAtCluster, *worstTrackParamAtCluster;
+ Double_t sigmaCut2 = GetRecoParam()->GetSigmaCutForImprovement() *
+ GetRecoParam()->GetSigmaCutForImprovement();
+
+ while (!track.IsImproved()) {
+
+ // identify removable clusters
+ track.TagRemovableClusters(GetRecoParam()->RequestedStationMask());
+
+ // Update track parameters and covariances
+ if (!track.UpdateCovTrackParamAtCluster()) {
+ AliWarning("unable to update track parameters and covariances --> stop improvement");
+ break;
+ }
- // update track parameters if not already done
- if (!track->IsImproved()) track->UpdateCovTrackParamAtHit();
+ // Compute local chi2 of each clusters
+ track.ComputeLocalChi2(kTRUE);
- trackParamAtHit = (AliMUONTrackParam*) (track->GetTrackParamAtHit()->First());
- while (trackParamAtHit) {
+ // Look for the cluster to remove
+ worstTrackParamAtCluster = NULL;
+ worstLocalChi2 = 0.;
+ trackParamAtCluster = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->First();
+ while (trackParamAtCluster) {
- // update array of track hit
- track->AddHitForRecAtHit(trackParamAtHit->GetHitForRecPtr());
+ // Pick up cluster with the worst chi2
+ localChi2 = trackParamAtCluster->GetLocalChi2();
+ if (localChi2 > worstLocalChi2) {
+ worstLocalChi2 = localChi2;
+ worstTrackParamAtCluster = trackParamAtCluster;
+ }
- trackParamAtHit = (AliMUONTrackParam*) (track->GetTrackParamAtHit()->After(trackParamAtHit));
+ trackParamAtCluster = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->After(trackParamAtCluster);
}
- track = (AliMUONTrack*) fRecTracksPtr->After(track);
+ // Check if worst cluster found
+ if (!worstTrackParamAtCluster) {
+ AliWarning("Bad local chi2 values?");
+ break;
+ }
- }
+ // Check whether the worst chi2 is under requirement or not
+ if (worstLocalChi2 < 2. * sigmaCut2) { // 2 because 2 quantities in chi2
+ track.SetImproved(kTRUE);
+ break;
+ }
+
+ // if the worst cluster is not removable then stop improvement
+ if (!worstTrackParamAtCluster->IsRemovable()) break;
+
+ // Remove the worst cluster
+ track.RemoveTrackParamAtCluster(worstTrackParamAtCluster);
+
+ // Re-fit the track:
+ // Take into account the multiple scattering
+ // Calculate the track parameter covariance matrix
+ Fit(track, kTRUE, kFALSE, kTRUE);
+
+ // Printout for debuging
+ if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+ cout << "ImproveTracks: track " << fRecTracksPtr->IndexOf(&track)+1 << " improved " << endl;
+ }
+ }
+
+}
+
+ //__________________________________________________________________________
+Bool_t AliMUONTrackReconstructor::FinalizeTrack(AliMUONTrack &track)
+{
+ /// Recompute track parameters and covariances at each attached cluster
+ /// from those at the first one, if not already done
+ AliDebug(1,"Enter FinalizeTrack");
+ if (!track.IsImproved() && !track.UpdateCovTrackParamAtCluster()) {
+ AliWarning("finalization failed due to extrapolation problem");
+ return kFALSE;
+ }
+ return kTRUE;
}
+ //__________________________________________________________________________
+Bool_t AliMUONTrackReconstructor::RefitTrack(AliMUONTrack &track, Bool_t enableImprovement)
+{
+ /// re-fit the given track
+
+ // check validity of the track
+ if (track.GetNClusters() < 3) {
+ AliWarning("the track does not contain enough clusters --> unable to refit");
+ return kFALSE;
+ }
+
+ // reset the seed (i.e. parameters at first cluster) before fitting
+ AliMUONTrackParam* firstTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->First();
+ if (firstTrackParam->GetInverseBendingMomentum() == 0.) {
+ AliWarning("track parameters at first chamber are not initialized --> unable to refit");
+ return kFALSE;
+ }
+
+ // compute track parameters at each cluster from parameters at the first one
+ // necessary to compute multiple scattering effect during refitting
+ if (!track.UpdateTrackParamAtCluster()) {
+ AliWarning("bad track refitting due to extrapolation failure");
+ return kFALSE;
+ }
+
+ // Re-fit the track:
+ // Take into account the multiple scattering
+ // Calculate the track parameter covariance matrix
+ Fit(track, kTRUE, kFALSE, kTRUE);
+
+ // Improve the reconstructed tracks if required
+ track.SetImproved(kFALSE);
+ if (enableImprovement && GetRecoParam()->ImproveTracks()) ImproveTrack(track);
+
+ // Fill AliMUONTrack data members
+ if (track.GetGlobalChi2() < AliMUONTrack::MaxChi2()) return FinalizeTrack(track);
+ else {
+ AliWarning("track not finalized due to extrapolation failure");
+ return kFALSE;
+ }
+
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff