MUON/AliMUONVTrackReconstructor.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //-----------------------------------------------------------------------------
  19 /// \class AliMUONVTrackReconstructor
  20 /// Virtual MUON track reconstructor in ALICE (class renamed from AliMUONEventReconstructor)
  21 ///
  22 /// This class contains as data a pointer to the array of reconstructed tracks
  23 ///
  24 /// It contains as methods, among others:
  25 /// * EventReconstruct to build the muon tracks
  26 /// * EventReconstructTrigger to build the trigger tracks
  27 /// * ValidateTracksWithTrigger to match tracker/trigger tracks
  28 ///
  29 /// Several options and adjustable parameters are available for both KALMAN and ORIGINAL
  30 /// tracking algorithms. They can be changed through the AliMUONRecoParam object
  31 /// set in the reconstruction macro or read from the CDB
  32 /// (see methods in AliMUONRecoParam.h file for details)
  33 ///
  34 /// Main parameters and options are:
  35 /// - *fgkSigmaToCutForTracking* : quality cut used to select new clusters to be
  36 ///   attached to the track candidate and to select good tracks.
  37 /// - *fgkMakeTrackCandidatesFast* : if this flag is set to 'true', the track candidates
  38 ///   are made assuming linear propagation between stations 4 and 5.
  39 /// - *fgkTrackAllTracks* : according to the value of this flag, in case that several
  40 ///   new clusters pass the quality cut, either we consider all the possibilities
  41 ///   (duplicating tracks) or we attach only the best cluster.
  42 /// - *fgkRecoverTracks* : if this flag is set to 'true', we try to recover the tracks
  43 ///   lost during the tracking by removing the worst of the 2 clusters attached in the
  44 ///   previous station.
  45 /// - *fgkImproveTracks* : if this flag is set to 'true', we try to improve the quality
  46 ///   of the tracks at the end of the tracking by removing clusters that do not pass
  47 ///   new quality cut (the track is removed is it does not contain enough cluster anymore).
  48 /// - *fgkComplementTracks* : if this flag is set to 'true', we try to improve the quality
  49 ///   of the tracks at the end of the tracking by adding potentially missing clusters
  50 ///   (we may have 2 clusters in the same chamber because of the overlapping of detection
  51 ///   elements, which is not handle by the tracking algorithm).
  52 /// - *fgkSigmaToCutForImprovement* : quality cut used when we try to improve the
  53 ///   quality of the tracks.
  54 ///
  55 ///  \author Philippe Pillot
  56 //-----------------------------------------------------------------------------
  57
  58 #include "AliMUONVTrackReconstructor.h"
  59
  60 #include "AliMUONConstants.h"
  61 #include "AliMUONObjectPair.h"
  62 #include "AliMUONTriggerTrack.h"
  63 #include "AliMUONTriggerCircuit.h"
  64 #include "AliMUONLocalTrigger.h"
  65 #include "AliMUONGlobalTrigger.h"
  66 #include "AliMUONTrack.h"
  67 #include "AliMUONTrackParam.h"
  68 #include "AliMUONTrackExtrap.h"
  69 #include "AliMUONTrackHitPattern.h"
  70 #include "AliMUONVTrackStore.h"
  71 #include "AliMUONVClusterStore.h"
  72 #include "AliMUONVCluster.h"
  73 #include "AliMUONVClusterServer.h"
  74 #include "AliMUONVTriggerStore.h"
  75 #include "AliMUONVTriggerTrackStore.h"
  76 #include "AliMpDEManager.h"
  77 #include "AliMpArea.h"
  78
  79 #include "AliLog.h"
  80 #include "AliCodeTimer.h"
  81 #include "AliTracker.h"
  82
  83 #include <TClonesArray.h>
  84 #include <TMath.h>
  85 #include <TMatrixD.h>
  86 #include <TVector2.h>
  87
  88 #include <Riostream.h>
  89
  90 /// \cond CLASSIMP
  91 ClassImp(AliMUONVTrackReconstructor) // Class implementation in ROOT context
  92 /// \endcond
  93
  94   //__________________________________________________________________________
  95 AliMUONVTrackReconstructor::AliMUONVTrackReconstructor(const AliMUONRecoParam* recoParam,
  96                                                        AliMUONVClusterServer* clusterServer)
  97 : TObject(),
  98 fRecTracksPtr(0x0),
  99 fNRecTracks(0),
 100 fClusterServer(clusterServer),
 101 fRecoParam(recoParam)
 102 {
 103   /// Constructor for class AliMUONVTrackReconstructor
 104   /// WARNING: if clusterServer=0x0, no clusterization will be possible at this level
 105
 106   // Memory allocation for the TClonesArray of reconstructed tracks
 107   fRecTracksPtr = new TClonesArray("AliMUONTrack", 100);
 108
 109   // set the magnetic field for track extrapolations
 110   const AliMagF* kField = AliTracker::GetFieldMap();
 111   if (!kField) AliFatal("No field available");
 112   AliMUONTrackExtrap::SetField(kField);
 113 }
 114
 115   //__________________________________________________________________________
 116 AliMUONVTrackReconstructor::~AliMUONVTrackReconstructor()
 117 {
 118   /// Destructor for class AliMUONVTrackReconstructor
 119   delete fRecTracksPtr;
 120 }
 121
 122   //__________________________________________________________________________
 123 void AliMUONVTrackReconstructor::ResetTracks()
 124 {
 125   /// To reset the TClonesArray of reconstructed tracks
 126   if (fRecTracksPtr) fRecTracksPtr->Clear("C");
 127   fNRecTracks = 0;
 128   return;
 129 }
 130
 131   //__________________________________________________________________________
 132 void AliMUONVTrackReconstructor::EventReconstruct(AliMUONVClusterStore& clusterStore, AliMUONVTrackStore& trackStore)
 133 {
 134   /// To reconstruct one event
 135   AliDebug(1,"");
 136   AliCodeTimerAuto("");
 137
 138   // Reset array of tracks
 139   ResetTracks();
 140
 141   // Look for candidates from clusters in stations(1..) 4 and 5
 142   MakeTrackCandidates(clusterStore);
 143
 144   // Look for extra candidates from clusters in stations(1..) 4 and 5
 145   if (GetRecoParam()->MakeMoreTrackCandidates()) MakeMoreTrackCandidates(clusterStore);
 146
 147   // Stop tracking if no candidate found
 148   if (fRecTracksPtr->GetEntriesFast() == 0) return;
 149
 150   // Follow tracks in stations(1..) 3, 2 and 1
 151   FollowTracks(clusterStore);
 152
 153   // Complement the reconstructed tracks
 154   if (GetRecoParam()->ComplementTracks()) ComplementTracks(clusterStore);
 155
 156   // Improve the reconstructed tracks
 157   if (GetRecoParam()->ImproveTracks()) ImproveTracks();
 158
 159   // Remove double tracks
 160   RemoveDoubleTracks();
 161
 162   // Fill AliMUONTrack data members
 163   Finalize();
 164
 165   // Add tracks to MUON data container
 166   for (Int_t i=0; i<fNRecTracks; ++i)
 167   {
 168     AliMUONTrack * track = (AliMUONTrack*) fRecTracksPtr->At(i);
 169     track->SetUniqueID(i+1);
 170     trackStore.Add(*track);
 171   }
 172 }
 173
 174   //__________________________________________________________________________
 175 TClonesArray* AliMUONVTrackReconstructor::MakeSegmentsBetweenChambers(const AliMUONVClusterStore& clusterStore, Int_t ch1, Int_t ch2)
 176 {
 177   /// To make the list of segments from the list of clusters in the 2 given chambers.
 178   /// Return a new TClonesArray of segments.
 179   /// It is the responsibility of the user to delete it afterward.
 180   AliDebug(1,Form("Enter MakeSegmentsBetweenChambers (1..) %d-%d", ch1+1, ch2+1));
 181
 182   AliMUONVCluster *cluster1, *cluster2;
 183   AliMUONObjectPair *segment;
 184   Double_t nonBendingSlope = 0, bendingSlope = 0, impactParam = 0., bendingMomentum = 0.; // to avoid compilation warning
 185
 186   // Create iterators to loop over clusters in both chambers
 187   TIter nextInCh1(clusterStore.CreateChamberIterator(ch1,ch1));
 188   TIter nextInCh2(clusterStore.CreateChamberIterator(ch2,ch2));
 189
 190   // list of segments
 191   TClonesArray *segments = new TClonesArray("AliMUONObjectPair", 100);
 192
 193   // Loop over clusters in the first chamber of the station
 194   while ( ( cluster1 = static_cast<AliMUONVCluster*>(nextInCh1()) ) ) {
 195
 196     // reset cluster iterator of chamber 2
 197     nextInCh2.Reset();
 198
 199     // Loop over clusters in the second chamber of the station
 200     while ( ( cluster2 = static_cast<AliMUONVCluster*>(nextInCh2()) ) ) {
 201
 202       // non bending slope
 203       nonBendingSlope = (cluster1->GetX() - cluster2->GetX()) / (cluster1->GetZ() - cluster2->GetZ());
 204
 205       // check if non bending slope is within tolerances
 206       if (TMath::Abs(nonBendingSlope) > GetRecoParam()->GetMaxNonBendingSlope()) continue;
 207
 208       // bending slope
 209       bendingSlope = (cluster1->GetY() - cluster2->GetY()) / (cluster1->GetZ() - cluster2->GetZ());
 210
 211       // check the bending momentum of the bending slope depending if the field is ON or OFF
 212       if (AliMUONTrackExtrap::IsFieldON()) {
 213
 214         // impact parameter
 215         impactParam = cluster1->GetY() - cluster1->GetZ() * bendingSlope;
 216
 217         // absolute value of bending momentum
 218         bendingMomentum = TMath::Abs(AliMUONTrackExtrap::GetBendingMomentumFromImpactParam(impactParam));
 219
 220         // check if bending momentum is within tolerances
 221         if (bendingMomentum < GetRecoParam()->GetMinBendingMomentum() ||
 222             bendingMomentum > GetRecoParam()->GetMaxBendingMomentum()) continue;
 223
 224       } else {
 225
 226         // check if non bending slope is within tolerances
 227         if (TMath::Abs(bendingSlope) > GetRecoParam()->GetMaxBendingSlope()) continue;
 228
 229       }
 230       // make new segment
 231       segment = new ((*segments)[segments->GetLast()+1]) AliMUONObjectPair(cluster1, cluster2, kFALSE, kFALSE);
 232
 233       // Printout for debug
 234       if (AliLog::GetGlobalDebugLevel() > 1) {
 235         cout << "segmentIndex(0...): " << segments->GetLast() << endl;
 236         segment->Dump();
 237         cout << "Cluster in first chamber" << endl;
 238         cluster1->Print();
 239         cout << "Cluster in second chamber" << endl;
 240         cluster2->Print();
 241       }
 242
 243     }
 244
 245   }
 246
 247   // Printout for debug
 248   AliDebug(1,Form("chambers%d-%d: NSegments =  %d ", ch1+1, ch2+1, segments->GetEntriesFast()));
 249
 250   return segments;
 251 }
 252
 253   //__________________________________________________________________________
 254 void AliMUONVTrackReconstructor::RemoveIdenticalTracks()
 255 {
 256   /// To remove identical tracks:
 257   /// Tracks are considered identical if they have all their clusters in common.
 258   /// One keeps the track with the larger number of clusters if need be
 259   AliMUONTrack *track1, *track2, *trackToRemove;
 260   Int_t clustersInCommon, nClusters1, nClusters2;
 261   Bool_t removedTrack1;
 262   // Loop over first track of the pair
 263   track1 = (AliMUONTrack*) fRecTracksPtr->First();
 264   while (track1) {
 265     removedTrack1 = kFALSE;
 266     nClusters1 = track1->GetNClusters();
 267     // Loop over second track of the pair
 268     track2 = (AliMUONTrack*) fRecTracksPtr->After(track1);
 269     while (track2) {
 270       nClusters2 = track2->GetNClusters();
 271       // number of clusters in common between two tracks
 272       clustersInCommon = track1->ClustersInCommon(track2);
 273       // check for identical tracks
 274       if ((clustersInCommon == nClusters1) || (clustersInCommon == nClusters2)) {
 275         // decide which track to remove
 276         if (nClusters2 > nClusters1) {
 277           // remove track1 and continue the first loop with the track next to track1
 278           trackToRemove = track1;
 279           track1 = (AliMUONTrack*) fRecTracksPtr->After(track1);
 280           fRecTracksPtr->Remove(trackToRemove);
 281           fRecTracksPtr->Compress(); // this is essential to retrieve the TClonesArray afterwards
 282           fNRecTracks--;
 283           removedTrack1 = kTRUE;
 284           break;
 285         } else {
 286           // remove track2 and continue the second loop with the track next to track2
 287           trackToRemove = track2;
 288           track2 = (AliMUONTrack*) fRecTracksPtr->After(track2);
 289           fRecTracksPtr->Remove(trackToRemove);
 290           fRecTracksPtr->Compress(); // this is essential to retrieve the TClonesArray afterwards
 291           fNRecTracks--;
 292         }
 293       } else track2 = (AliMUONTrack*) fRecTracksPtr->After(track2);
 294     } // track2
 295     if (removedTrack1) continue;
 296     track1 = (AliMUONTrack*) fRecTracksPtr->After(track1);
 297   } // track1
 298   return;
 299 }
 300
 301   //__________________________________________________________________________
 302 void AliMUONVTrackReconstructor::RemoveDoubleTracks()
 303 {
 304   /// To remove double tracks:
 305   /// Tracks are considered identical if more than half of the clusters of the track
 306   /// which has the smaller number of clusters are in common with the other track.
 307   /// Among two identical tracks, one keeps the track with the larger number of clusters
 308   /// or, if these numbers are equal, the track with the minimum chi2.
 309   AliMUONTrack *track1, *track2, *trackToRemove;
 310   Int_t clustersInCommon, nClusters1, nClusters2;
 311   Bool_t removedTrack1;
 312   // Loop over first track of the pair
 313   track1 = (AliMUONTrack*) fRecTracksPtr->First();
 314   while (track1) {
 315     removedTrack1 = kFALSE;
 316     nClusters1 = track1->GetNClusters();
 317     // Loop over second track of the pair
 318     track2 = (AliMUONTrack*) fRecTracksPtr->After(track1);
 319     while (track2) {
 320       nClusters2 = track2->GetNClusters();
 321       // number of clusters in common between two tracks
 322       clustersInCommon = track1->ClustersInCommon(track2);
 323       // check for identical tracks
 324       if (((nClusters1 < nClusters2) && (2 * clustersInCommon > nClusters1)) || (2 * clustersInCommon > nClusters2)) {
 325         // decide which track to remove
 326         if ((nClusters1 > nClusters2) || ((nClusters1 == nClusters2) && (track1->GetGlobalChi2() <= track2->GetGlobalChi2()))) {
 327           // remove track2 and continue the second loop with the track next to track2
 328           trackToRemove = track2;
 329           track2 = (AliMUONTrack*) fRecTracksPtr->After(track2);
 330           fRecTracksPtr->Remove(trackToRemove);
 331           fRecTracksPtr->Compress(); // this is essential to retrieve the TClonesArray afterwards
 332           fNRecTracks--;
 333         } else {
 334           // else remove track1 and continue the first loop with the track next to track1
 335           trackToRemove = track1;
 336           track1 = (AliMUONTrack*) fRecTracksPtr->After(track1);
 337           fRecTracksPtr->Remove(trackToRemove);
 338           fRecTracksPtr->Compress(); // this is essential to retrieve the TClonesArray afterwards
 339           fNRecTracks--;
 340           removedTrack1 = kTRUE;
 341           break;
 342         }
 343       } else track2 = (AliMUONTrack*) fRecTracksPtr->After(track2);
 344     } // track2
 345     if (removedTrack1) continue;
 346     track1 = (AliMUONTrack*) fRecTracksPtr->After(track1);
 347   } // track1
 348   return;
 349 }
 350
 351   //__________________________________________________________________________
 352 void AliMUONVTrackReconstructor::AskForNewClustersInChamber(const AliMUONTrackParam &trackParam,
 353                                                             AliMUONVClusterStore& clusterStore, Int_t chamber)
 354 {
 355   /// Ask the clustering to reconstruct new clusters around the track candidate position
 356
 357   // check if the current chamber is useable
 358   if (!fClusterServer || !GetRecoParam()->UseChamber(chamber)) return;
 359
 360   // maximum distance between the center of the chamber and a detection element
 361   // (accounting for the inclination of the chamber)
 362   static const Double_t kMaxDZ = 15.; // 15 cm
 363
 364   // extrapolate track parameters to the chamber
 365   AliMUONTrackParam extrapTrackParam(trackParam);
 366   AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParam, AliMUONConstants::DefaultChamberZ(chamber));
 367
 368   // build the searching area using the track resolution and the maximum-distance-to-track value
 369   const TMatrixD& kParamCov = extrapTrackParam.GetCovariances();
 370   Double_t errX2 = kParamCov(0,0) + kMaxDZ * kMaxDZ * kParamCov(1,1) + 2. * kMaxDZ * TMath::Abs(kParamCov(0,1));
 371   Double_t errY2 = kParamCov(2,2) + kMaxDZ * kMaxDZ * kParamCov(3,3) + 2. * kMaxDZ * TMath::Abs(kParamCov(2,3));
 372   Double_t dX = TMath::Abs(trackParam.GetNonBendingSlope()) * kMaxDZ +
 373                 GetRecoParam()->GetMaxNonBendingDistanceToTrack() +
 374                 GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errX2);
 375   Double_t dY = TMath::Abs(trackParam.GetBendingSlope()) * kMaxDZ +
 376                 GetRecoParam()->GetMaxBendingDistanceToTrack() +
 377                 GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errY2);
 378   TVector2 dimensions(dX, dY);
 379   TVector2 position(extrapTrackParam.GetNonBendingCoor(), extrapTrackParam.GetBendingCoor());
 380   AliMpArea area(position, dimensions);
 381
 382   // ask to cluterize in the given area of the given chamber
 383   fClusterServer->Clusterize(chamber, clusterStore, area);
 384
 385 }
 386
 387   //__________________________________________________________________________
 388 void AliMUONVTrackReconstructor::AskForNewClustersInStation(const AliMUONTrackParam &trackParam,
 389                                                             AliMUONVClusterStore& clusterStore, Int_t station)
 390 {
 391   /// Ask the clustering to reconstruct new clusters around the track candidate position
 392   /// in the 2 chambers of the given station
 393   AskForNewClustersInChamber(trackParam, clusterStore, 2*station+1);
 394   AskForNewClustersInChamber(trackParam, clusterStore, 2*station);
 395 }
 396
 397   //__________________________________________________________________________
 398 Double_t AliMUONVTrackReconstructor::TryOneCluster(const AliMUONTrackParam &trackParam, AliMUONVCluster* cluster,
 399                                                    AliMUONTrackParam &trackParamAtCluster, Bool_t updatePropagator)
 400 {
 401 /// Test the compatibility between the track and the cluster (using trackParam's covariance matrix):
 402 /// return the corresponding Chi2
 403 /// return trackParamAtCluster
 404
 405   // extrapolate track parameters and covariances at the z position of the tested cluster
 406   trackParamAtCluster = trackParam;
 407   AliMUONTrackExtrap::ExtrapToZCov(&trackParamAtCluster, cluster->GetZ(), updatePropagator);
 408
 409   // set pointer to cluster into trackParamAtCluster
 410   trackParamAtCluster.SetClusterPtr(cluster);
 411
 412   // Set differences between trackParam and cluster in the bending and non bending directions
 413   Double_t dX = cluster->GetX() - trackParamAtCluster.GetNonBendingCoor();
 414   Double_t dY = cluster->GetY() - trackParamAtCluster.GetBendingCoor();
 415
 416   // Calculate errors and covariances
 417   const TMatrixD& kParamCov = trackParamAtCluster.GetCovariances();
 418   Double_t sigmaX2 = kParamCov(0,0) + cluster->GetErrX2();
 419   Double_t sigmaY2 = kParamCov(2,2) + cluster->GetErrY2();
 420
 421   // Compute chi2
 422   return dX * dX / sigmaX2 + dY * dY / sigmaY2;
 423
 424 }
 425
 426   //__________________________________________________________________________
 427 Bool_t AliMUONVTrackReconstructor::TryOneClusterFast(const AliMUONTrackParam &trackParam, AliMUONVCluster* cluster)
 428 {
 429 /// Test the compatibility between the track and the cluster
 430 /// given the track resolution + the maximum-distance-to-track value
 431 /// and assuming linear propagation of the track:
 432 /// return kTRUE if they are compatibles
 433
 434   Double_t dZ = cluster->GetZ() - trackParam.GetZ();
 435   Double_t dX = cluster->GetX() - (trackParam.GetNonBendingCoor() + trackParam.GetNonBendingSlope() * dZ);
 436   Double_t dY = cluster->GetY() - (trackParam.GetBendingCoor() + trackParam.GetBendingSlope() * dZ);
 437   const TMatrixD& kParamCov = trackParam.GetCovariances();
 438   Double_t errX2 = kParamCov(0,0) + dZ * dZ * kParamCov(1,1) + 2. * dZ * kParamCov(0,1);
 439   Double_t errY2 = kParamCov(2,2) + dZ * dZ * kParamCov(3,3) + 2. * dZ * kParamCov(2,3);
 440
 441   Double_t dXmax = GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errX2) +
 442                    GetRecoParam()->GetMaxNonBendingDistanceToTrack();
 443   Double_t dYmax = GetRecoParam()->GetSigmaCutForTracking() * TMath::Sqrt(errY2) +
 444                    GetRecoParam()->GetMaxBendingDistanceToTrack();
 445
 446   if (TMath::Abs(dX) > dXmax || TMath::Abs(dY) > dYmax) return kFALSE;
 447
 448   return kTRUE;
 449
 450 }
 451
 452   //__________________________________________________________________________
 453 Double_t AliMUONVTrackReconstructor::TryTwoClustersFast(const AliMUONTrackParam &trackParamAtCluster1, AliMUONVCluster* cluster2,
 454                                                         AliMUONTrackParam &trackParamAtCluster2)
 455 {
 456 /// Test the compatibility between the track and the 2 clusters together (using trackParam's covariance matrix)
 457 /// assuming linear propagation between the two clusters:
 458 /// return the corresponding Chi2 accounting for covariances between the 2 clusters
 459 /// return trackParamAtCluster2
 460
 461   // extrapolate linearly track parameters and covariances at the z position of the second cluster
 462   trackParamAtCluster2 = trackParamAtCluster1;
 463   AliMUONTrackExtrap::LinearExtrapToZ(&trackParamAtCluster2, cluster2->GetZ());
 464
 465   // set pointer to cluster2 into trackParamAtCluster2
 466   trackParamAtCluster2.SetClusterPtr(cluster2);
 467
 468   // Set differences between track and clusters in the bending and non bending directions
 469   AliMUONVCluster* cluster1 = trackParamAtCluster1.GetClusterPtr();
 470   Double_t dX1 = cluster1->GetX() - trackParamAtCluster1.GetNonBendingCoor();
 471   Double_t dX2 = cluster2->GetX() - trackParamAtCluster2.GetNonBendingCoor();
 472   Double_t dY1 = cluster1->GetY() - trackParamAtCluster1.GetBendingCoor();
 473   Double_t dY2 = cluster2->GetY() - trackParamAtCluster2.GetBendingCoor();
 474
 475   // Calculate errors and covariances
 476   const TMatrixD& kParamCov1 = trackParamAtCluster1.GetCovariances();
 477   const TMatrixD& kParamCov2 = trackParamAtCluster2.GetCovariances();
 478   Double_t dZ = trackParamAtCluster2.GetZ() - trackParamAtCluster1.GetZ();
 479   Double_t sigma2X1 = kParamCov1(0,0) + cluster1->GetErrX2();
 480   Double_t sigma2X2 = kParamCov2(0,0) + cluster2->GetErrX2();
 481   Double_t covX1X2  = kParamCov1(0,0) + dZ * kParamCov1(0,1);
 482   Double_t sigma2Y1 = kParamCov1(2,2) + cluster1->GetErrY2();
 483   Double_t sigma2Y2 = kParamCov2(2,2) + cluster2->GetErrY2();
 484   Double_t covY1Y2  = kParamCov1(2,2) + dZ * kParamCov1(2,3);
 485
 486   // Compute chi2
 487   Double_t detX = sigma2X1 * sigma2X2 - covX1X2 * covX1X2;
 488   Double_t detY = sigma2Y1 * sigma2Y2 - covY1Y2 * covY1Y2;
 489   if (detX == 0. || detY == 0.) return 1.e10;
 490   return   (dX1 * dX1 * sigma2X2 + dX2 * dX2 * sigma2X1 - 2. * dX1 * dX2 * covX1X2) / detX
 491          + (dY1 * dY1 * sigma2Y2 + dY2 * dY2 * sigma2Y1 - 2. * dY1 * dY2 * covY1Y2) / detY;
 492
 493 }
 494
 495   //__________________________________________________________________________
 496 Bool_t AliMUONVTrackReconstructor::FollowLinearTrackInChamber(AliMUONTrack &trackCandidate, const AliMUONVClusterStore& clusterStore,
 497                                                               Int_t nextChamber)
 498 {
 499   /// Follow trackCandidate in chamber(0..) nextChamber assuming linear propagation, and search for compatible cluster(s)
 500   /// Keep all possibilities or only the best one(s) according to the flag fgkTrackAllTracks:
 501   /// kTRUE:  duplicate "trackCandidate" if there are several possibilities and add the new tracks at the end of
 502   ///         fRecTracksPtr to avoid conficts with other track candidates at this current stage of the tracking procedure.
 503   ///         Remove the obsolete "trackCandidate" at the end.
 504   /// kFALSE: add only the best cluster(s) to the "trackCandidate". Try to add a couple of clusters in priority.
 505   /// return kTRUE if new cluster(s) have been found (otherwise return kFALSE)
 506   AliDebug(1,Form("Enter FollowLinearTrackInChamber(1..) %d", nextChamber+1));
 507
 508   Double_t chi2WithOneCluster = 1.e10;
 509   Double_t maxChi2WithOneCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
 510                                         GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
 511   Double_t bestChi2WithOneCluster = maxChi2WithOneCluster;
 512   Bool_t foundOneCluster = kFALSE;
 513   AliMUONTrack *newTrack = 0x0;
 514   AliMUONVCluster *cluster;
 515   AliMUONTrackParam trackParam;
 516   AliMUONTrackParam extrapTrackParamAtCluster;
 517   AliMUONTrackParam bestTrackParamAtCluster;
 518
 519   // Get track parameters according to the propagation direction
 520   if (nextChamber > 7) trackParam = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->Last();
 521   else trackParam = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->First();
 522
 523   // Printout for debuging
 524   if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
 525     cout<<endl<<"Track parameters and covariances at first cluster:"<<endl;
 526     trackParam.GetParameters().Print();
 527     trackParam.GetCovariances().Print();
 528   }
 529
 530   // Add MCS effect
 531   AliMUONTrackExtrap::AddMCSEffect(&trackParam,AliMUONConstants::ChamberThicknessInX0(),1.);
 532
 533   // Printout for debuging
 534   if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 535     cout << "FollowLinearTrackInChamber: look for cluster in chamber(1..): " << nextChamber+1 << endl;
 536   }
 537
 538   // Create iterators to loop over clusters in chamber
 539   TIter next(clusterStore.CreateChamberIterator(nextChamber,nextChamber));
 540
 541   // look for candidates in chamber
 542   while ( ( cluster = static_cast<AliMUONVCluster*>(next()) ) ) {
 543
 544     // try to add the current cluster fast
 545     if (!TryOneClusterFast(trackParam, cluster)) continue;
 546
 547     // try to add the current cluster accuratly
 548     extrapTrackParamAtCluster = trackParam;
 549     AliMUONTrackExtrap::LinearExtrapToZ(&extrapTrackParamAtCluster, cluster->GetZ());
 550     chi2WithOneCluster = TryOneCluster(extrapTrackParamAtCluster, cluster, extrapTrackParamAtCluster);
 551
 552     // if good chi2 then consider to add cluster
 553     if (chi2WithOneCluster < maxChi2WithOneCluster) {
 554       foundOneCluster = kTRUE;
 555
 556       // Printout for debuging
 557       if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 558         cout << "FollowLinearTrackInChamber: found one cluster in chamber(1..): " << nextChamber+1
 559         << " (Chi2 = " << chi2WithOneCluster << ")" << endl;
 560         cluster->Print();
 561       }
 562
 563       if (GetRecoParam()->TrackAllTracks()) {
 564         // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
 565         newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
 566         if (GetRecoParam()->RequestStation(nextChamber/2))
 567           extrapTrackParamAtCluster.SetRemovable(kFALSE);
 568         else extrapTrackParamAtCluster.SetRemovable(kTRUE);
 569         newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster,*cluster);
 570         fNRecTracks++;
 571
 572         // Printout for debuging
 573         if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 574           cout << "FollowLinearTrackInChamber: added one cluster in chamber(1..): " << nextChamber+1 << endl;
 575           if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
 576         }
 577
 578       } else if (chi2WithOneCluster < bestChi2WithOneCluster) {
 579         // keep track of the best cluster
 580         bestChi2WithOneCluster = chi2WithOneCluster;
 581         bestTrackParamAtCluster = extrapTrackParamAtCluster;
 582       }
 583
 584     }
 585
 586   }
 587
 588   // fill out the best track if required else clean up the fRecTracksPtr array
 589   if (!GetRecoParam()->TrackAllTracks()) {
 590     if (foundOneCluster) {
 591       if (GetRecoParam()->RequestStation(nextChamber/2))
 592         bestTrackParamAtCluster.SetRemovable(kFALSE);
 593       else bestTrackParamAtCluster.SetRemovable(kTRUE);
 594       trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster,*(bestTrackParamAtCluster.GetClusterPtr()));
 595
 596       // Printout for debuging
 597       if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 598         cout << "FollowLinearTrackInChamber: added the best cluster in chamber(1..): " << bestTrackParamAtCluster.GetClusterPtr()->GetChamberId()+1 << endl;
 599         if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
 600       }
 601
 602     } else return kFALSE;
 603
 604   } else if (foundOneCluster) {
 605
 606     // remove obsolete track
 607     fRecTracksPtr->Remove(&trackCandidate);
 608     fNRecTracks--;
 609
 610   } else return kFALSE;
 611
 612   return kTRUE;
 613
 614 }
 615
 616 //__________________________________________________________________________
 617 Bool_t AliMUONVTrackReconstructor::FollowLinearTrackInStation(AliMUONTrack &trackCandidate, const AliMUONVClusterStore& clusterStore,
 618                                                               Int_t nextStation)
 619 {
 620   /// Follow trackCandidate in station(0..) nextStation assuming linear propagation, and search for compatible cluster(s)
 621   /// Keep all possibilities or only the best one(s) according to the flag fgkTrackAllTracks:
 622   /// kTRUE:  duplicate "trackCandidate" if there are several possibilities and add the new tracks at the end of
 623   ///         fRecTracksPtr to avoid conficts with other track candidates at this current stage of the tracking procedure.
 624   ///         Remove the obsolete "trackCandidate" at the end.
 625   /// kFALSE: add only the best cluster(s) to the "trackCandidate". Try to add a couple of clusters in priority.
 626   /// return kTRUE if new cluster(s) have been found (otherwise return kFALSE)
 627   AliDebug(1,Form("Enter FollowLinearTrackInStation(1..) %d", nextStation+1));
 628
 629   // Order the chamber according to the propagation direction (tracking starts with chamber 2):
 630   // - nextStation == station(1...) 5 => forward propagation
 631   // - nextStation < station(1...) 5 => backward propagation
 632   Int_t ch1, ch2;
 633   if (nextStation==4) {
 634     ch1 = 2*nextStation+1;
 635     ch2 = 2*nextStation;
 636   } else {
 637     ch1 = 2*nextStation;
 638     ch2 = 2*nextStation+1;
 639   }
 640
 641   Double_t chi2WithOneCluster = 1.e10;
 642   Double_t chi2WithTwoClusters = 1.e10;
 643   Double_t maxChi2WithOneCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
 644                                         GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
 645   Double_t maxChi2WithTwoClusters = 4. * GetRecoParam()->GetSigmaCutForTracking() *
 646                                          GetRecoParam()->GetSigmaCutForTracking(); // 4 because 4 quantities in chi2
 647   Double_t bestChi2WithOneCluster = maxChi2WithOneCluster;
 648   Double_t bestChi2WithTwoClusters = maxChi2WithTwoClusters;
 649   Bool_t foundOneCluster = kFALSE;
 650   Bool_t foundTwoClusters = kFALSE;
 651   AliMUONTrack *newTrack = 0x0;
 652   AliMUONVCluster *clusterCh1, *clusterCh2;
 653   AliMUONTrackParam trackParam;
 654   AliMUONTrackParam extrapTrackParamAtCluster1;
 655   AliMUONTrackParam extrapTrackParamAtCluster2;
 656   AliMUONTrackParam bestTrackParamAtCluster1;
 657   AliMUONTrackParam bestTrackParamAtCluster2;
 658
 659   Int_t nClusters = clusterStore.GetSize();
 660   Bool_t *clusterCh1Used = new Bool_t[nClusters];
 661   for (Int_t i = 0; i < nClusters; i++) clusterCh1Used[i] = kFALSE;
 662   Int_t iCluster1;
 663
 664   // Get track parameters according to the propagation direction
 665   if (nextStation==4) trackParam = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->Last();
 666   else trackParam = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->First();
 667
 668   // Printout for debuging
 669   if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
 670     cout<<endl<<"Track parameters and covariances at first cluster:"<<endl;
 671     trackParam.GetParameters().Print();
 672     trackParam.GetCovariances().Print();
 673   }
 674
 675   // Add MCS effect
 676   AliMUONTrackExtrap::AddMCSEffect(&trackParam,AliMUONConstants::ChamberThicknessInX0(),1.);
 677
 678   // Printout for debuging
 679   if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 680     cout << "FollowLinearTrackInStation: look for clusters in chamber(1..): " << ch2+1 << endl;
 681   }
 682
 683   // Create iterators to loop over clusters in both chambers
 684   TIter nextInCh1(clusterStore.CreateChamberIterator(ch1,ch1));
 685   TIter nextInCh2(clusterStore.CreateChamberIterator(ch2,ch2));
 686
 687   // look for candidates in chamber 2
 688   while ( ( clusterCh2 = static_cast<AliMUONVCluster*>(nextInCh2()) ) ) {
 689
 690     // try to add the current cluster fast
 691     if (!TryOneClusterFast(trackParam, clusterCh2)) continue;
 692
 693     // try to add the current cluster accuratly
 694     extrapTrackParamAtCluster2 = trackParam;
 695     AliMUONTrackExtrap::LinearExtrapToZ(&extrapTrackParamAtCluster2, clusterCh2->GetZ());
 696     chi2WithOneCluster = TryOneCluster(extrapTrackParamAtCluster2, clusterCh2, extrapTrackParamAtCluster2);
 697
 698     // if good chi2 then try to attach a cluster in the other chamber too
 699     if (chi2WithOneCluster < maxChi2WithOneCluster) {
 700       Bool_t foundSecondCluster = kFALSE;
 701
 702       // Printout for debuging
 703       if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 704         cout << "FollowLinearTrackInStation: found one cluster in chamber(1..): " << ch2+1
 705              << " (Chi2 = " << chi2WithOneCluster << ")" << endl;
 706         clusterCh2->Print();
 707         cout << "                      look for second clusters in chamber(1..): " << ch1+1 << " ..." << endl;
 708       }
 709
 710       // add MCS effect
 711       AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCluster2,AliMUONConstants::ChamberThicknessInX0(),1.);
 712
 713       // reset cluster iterator of chamber 1
 714       nextInCh1.Reset();
 715       iCluster1 = -1;
 716
 717       // look for second candidates in chamber 1
 718       while ( ( clusterCh1 = static_cast<AliMUONVCluster*>(nextInCh1()) ) ) {
 719         iCluster1++;
 720
 721         // try to add the current cluster fast
 722         if (!TryOneClusterFast(extrapTrackParamAtCluster2, clusterCh1)) continue;
 723
 724         // try to add the current cluster in addition to the one found in the previous chamber
 725         chi2WithTwoClusters = TryTwoClustersFast(extrapTrackParamAtCluster2, clusterCh1, extrapTrackParamAtCluster1);
 726
 727         // if good chi2 then consider to add the 2 clusters to the "trackCandidate"
 728         if (chi2WithTwoClusters < maxChi2WithTwoClusters) {
 729           foundSecondCluster = kTRUE;
 730           foundTwoClusters = kTRUE;
 731
 732           // Printout for debuging
 733           if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 734             cout << "FollowLinearTrackInStation: found one cluster in chamber(1..): " << ch1+1
 735                  << " (Chi2 = " << chi2WithTwoClusters << ")" << endl;
 736             clusterCh1->Print();
 737           }
 738
 739           if (GetRecoParam()->TrackAllTracks()) {
 740             // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new clusters
 741             newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
 742             extrapTrackParamAtCluster1.SetRemovable(kTRUE);
 743             newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster1,*clusterCh1);
 744             extrapTrackParamAtCluster2.SetRemovable(kTRUE);
 745             newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster2,*clusterCh2);
 746             fNRecTracks++;
 747
 748             // Tag clusterCh1 as used
 749             clusterCh1Used[iCluster1] = kTRUE;
 750
 751             // Printout for debuging
 752             if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 753               cout << "FollowLinearTrackInStation: added two clusters in station(1..): " << nextStation+1 << endl;
 754               if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
 755             }
 756
 757           } else if (chi2WithTwoClusters < bestChi2WithTwoClusters) {
 758             // keep track of the best couple of clusters
 759             bestChi2WithTwoClusters = chi2WithTwoClusters;
 760             bestTrackParamAtCluster1 = extrapTrackParamAtCluster1;
 761             bestTrackParamAtCluster2 = extrapTrackParamAtCluster2;
 762           }
 763
 764         }
 765
 766       }
 767
 768       // if no cluster found in chamber1 then consider to add clusterCh2 only
 769       if (!foundSecondCluster) {
 770         foundOneCluster = kTRUE;
 771
 772         if (GetRecoParam()->TrackAllTracks()) {
 773           // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
 774           newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
 775           if (GetRecoParam()->RequestStation(nextStation))
 776             extrapTrackParamAtCluster2.SetRemovable(kFALSE);
 777           else extrapTrackParamAtCluster2.SetRemovable(kTRUE);
 778           newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster2,*clusterCh2);
 779           fNRecTracks++;
 780
 781           // Printout for debuging
 782           if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 783             cout << "FollowLinearTrackInStation: added one cluster in chamber(1..): " << ch2+1 << endl;
 784             if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
 785           }
 786
 787         } else if (!foundTwoClusters && chi2WithOneCluster < bestChi2WithOneCluster) {
 788           // keep track of the best cluster except if a couple of clusters has already been found
 789           bestChi2WithOneCluster = chi2WithOneCluster;
 790           bestTrackParamAtCluster1 = extrapTrackParamAtCluster2;
 791         }
 792
 793       }
 794
 795     }
 796
 797   }
 798
 799   // look for candidates in chamber 1 not already attached to a track
 800   // if we want to keep all possible tracks or if no good couple of clusters has been found
 801   if (GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
 802
 803     // Printout for debuging
 804     if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 805       cout << "FollowLinearTrackInStation: look for single cluster in chamber(1..): " << ch1+1 << endl;
 806     }
 807
 808     //Extrapolate trackCandidate to chamber "ch2"
 809     AliMUONTrackExtrap::LinearExtrapToZ(&trackParam, AliMUONConstants::DefaultChamberZ(ch2));
 810
 811     // add MCS effect for next step
 812     AliMUONTrackExtrap::AddMCSEffect(&trackParam,AliMUONConstants::ChamberThicknessInX0(),1.);
 813
 814     // reset cluster iterator of chamber 1
 815     nextInCh1.Reset();
 816     iCluster1 = -1;
 817
 818     // look for second candidates in chamber 1
 819     while ( ( clusterCh1 = static_cast<AliMUONVCluster*>(nextInCh1()) ) ) {
 820       iCluster1++;
 821
 822       if (clusterCh1Used[iCluster1]) continue; // Skip clusters already used
 823
 824       // try to add the current cluster fast
 825       if (!TryOneClusterFast(trackParam, clusterCh1)) continue;
 826
 827       // try to add the current cluster accuratly
 828       extrapTrackParamAtCluster1 = trackParam;
 829       AliMUONTrackExtrap::LinearExtrapToZ(&extrapTrackParamAtCluster1, clusterCh1->GetZ());
 830       chi2WithOneCluster = TryOneCluster(extrapTrackParamAtCluster1, clusterCh1, extrapTrackParamAtCluster1);
 831
 832       // if good chi2 then consider to add clusterCh1
 833       // We do not try to attach a cluster in the other chamber too since it has already been done above
 834       if (chi2WithOneCluster < maxChi2WithOneCluster) {
 835         foundOneCluster = kTRUE;
 836
 837         // Printout for debuging
 838         if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 839           cout << "FollowLinearTrackInStation: found one cluster in chamber(1..): " << ch1+1
 840                << " (Chi2 = " << chi2WithOneCluster << ")" << endl;
 841           clusterCh1->Print();
 842         }
 843
 844         if (GetRecoParam()->TrackAllTracks()) {
 845           // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
 846           newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
 847           if (GetRecoParam()->RequestStation(nextStation))
 848             extrapTrackParamAtCluster1.SetRemovable(kFALSE);
 849           else extrapTrackParamAtCluster1.SetRemovable(kTRUE);
 850           newTrack->AddTrackParamAtCluster(extrapTrackParamAtCluster1,*clusterCh1);
 851           fNRecTracks++;
 852
 853           // Printout for debuging
 854           if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 855             cout << "FollowLinearTrackInStation: added one cluster in chamber(1..): " << ch1+1 << endl;
 856             if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
 857           }
 858
 859         } else if (chi2WithOneCluster < bestChi2WithOneCluster) {
 860           // keep track of the best cluster except if a couple of clusters has already been found
 861           bestChi2WithOneCluster = chi2WithOneCluster;
 862           bestTrackParamAtCluster1 = extrapTrackParamAtCluster1;
 863         }
 864
 865       }
 866
 867     }
 868
 869   }
 870
 871   // fill out the best track if required else clean up the fRecTracksPtr array
 872   if (!GetRecoParam()->TrackAllTracks()) {
 873     if (foundTwoClusters) {
 874       bestTrackParamAtCluster1.SetRemovable(kTRUE);
 875       trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster1,*(bestTrackParamAtCluster1.GetClusterPtr()));
 876       bestTrackParamAtCluster2.SetRemovable(kTRUE);
 877       trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster2,*(bestTrackParamAtCluster2.GetClusterPtr()));
 878
 879       // Printout for debuging
 880       if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 881         cout << "FollowLinearTrackInStation: added the two best clusters in station(1..): " << nextStation+1 << endl;
 882         if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
 883       }
 884
 885     } else if (foundOneCluster) {
 886       if (GetRecoParam()->RequestStation(nextStation))
 887         bestTrackParamAtCluster1.SetRemovable(kFALSE);
 888       else bestTrackParamAtCluster1.SetRemovable(kTRUE);
 889       trackCandidate.AddTrackParamAtCluster(bestTrackParamAtCluster1,*(bestTrackParamAtCluster1.GetClusterPtr()));
 890
 891       // Printout for debuging
 892       if ((AliLog::GetDebugLevel("MUON","AliMUONVTrackReconstructor") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
 893         cout << "FollowLinearTrackInStation: added the best cluster in chamber(1..): " << bestTrackParamAtCluster1.GetClusterPtr()->GetChamberId()+1 << endl;
 894         if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
 895       }
 896
 897     } else {
 898       delete [] clusterCh1Used;
 899       return kFALSE;
 900     }
 901
 902   } else if (foundOneCluster || foundTwoClusters) {
 903
 904     // remove obsolete track
 905     fRecTracksPtr->Remove(&trackCandidate);
 906     fNRecTracks--;
 907
 908   } else {
 909     delete [] clusterCh1Used;
 910     return kFALSE;
 911   }
 912
 913   delete [] clusterCh1Used;
 914   return kTRUE;
 915
 916 }
 917
 918 //__________________________________________________________________________
 919 void AliMUONVTrackReconstructor::ImproveTracks()
 920 {
 921   /// Improve tracks by removing clusters with local chi2 highter than the defined cut
 922   /// Recompute track parameters and covariances at the remaining clusters
 923   AliDebug(1,"Enter ImproveTracks");
 924
 925   AliMUONTrack *track, *nextTrack;
 926
 927   track = (AliMUONTrack*) fRecTracksPtr->First();
 928   while (track) {
 929
 930     // prepare next track in case the actual track is suppressed
 931     nextTrack = (AliMUONTrack*) fRecTracksPtr->After(track);
 932
 933     ImproveTrack(*track);
 934
 935     // remove track if improvement failed
 936     if (!track->IsImproved()) {
 937       fRecTracksPtr->Remove(track);
 938       fNRecTracks--;
 939     }
 940
 941     track = nextTrack;
 942   }
 943
 944   // compress the array in case of some tracks have been removed
 945   fRecTracksPtr->Compress();
 946
 947 }
 948
 949 //__________________________________________________________________________
 950 void AliMUONVTrackReconstructor::Finalize()
 951 {
 952   /// Recompute track parameters and covariances at each attached cluster from those at the first one
 953
 954   AliMUONTrack *track;
 955
 956   track = (AliMUONTrack*) fRecTracksPtr->First();
 957   while (track) {
 958
 959     FinalizeTrack(*track);
 960
 961     track = (AliMUONTrack*) fRecTracksPtr->After(track);
 962
 963   }
 964
 965 }
 966
 967 //__________________________________________________________________________
 968 void AliMUONVTrackReconstructor::ValidateTracksWithTrigger(AliMUONVTrackStore& trackStore,
 969                                                            const AliMUONVTriggerTrackStore& triggerTrackStore,
 970                                                            const AliMUONVTriggerStore& triggerStore,
 971                                                            const AliMUONTrackHitPattern& trackHitPattern)
 972 {
 973   /// Try to match track from tracking system with trigger track
 974   AliCodeTimerAuto("");
 975
 976   trackHitPattern.ExecuteValidation(trackStore, triggerTrackStore, triggerStore);
 977 }
 978
 979   //__________________________________________________________________________
 980 void AliMUONVTrackReconstructor::EventReconstructTrigger(const AliMUONTriggerCircuit& circuit,
 981                                                          const AliMUONVTriggerStore& triggerStore,
 982                                                          AliMUONVTriggerTrackStore& triggerTrackStore)
 983 {
 984   /// To make the trigger tracks from Local Trigger
 985   AliDebug(1, "");
 986   AliCodeTimerAuto("");
 987
 988   AliMUONGlobalTrigger* globalTrigger = triggerStore.Global();
 989
 990   UChar_t gloTrigPat = 0;
 991
 992   if (globalTrigger)
 993   {
 994     gloTrigPat = globalTrigger->GetGlobalResponse();
 995   }
 996
 997   TIter next(triggerStore.CreateIterator());
 998   AliMUONLocalTrigger* locTrg(0x0);
 999
1000   Float_t z11 = AliMUONConstants::DefaultChamberZ(10);
1001   Float_t z21 = AliMUONConstants::DefaultChamberZ(12);
1002
1003   AliMUONTriggerTrack triggerTrack;
1004
1005   while ( ( locTrg = static_cast<AliMUONLocalTrigger*>(next()) ) )
1006   {
1007     Bool_t xTrig=locTrg->IsTrigX();
1008     Bool_t yTrig=locTrg->IsTrigY();
1009
1010     Int_t localBoardId = locTrg->LoCircuit();
1011
1012     if (xTrig && yTrig)
1013     { // make Trigger Track if trigger in X and Y
1014
1015       Float_t y11 = circuit.GetY11Pos(localBoardId, locTrg->LoStripX());
1016       // need first to convert deviation to [0-30]
1017       // (see AliMUONLocalTriggerBoard::LocalTrigger)
1018       Int_t deviation = locTrg->GetDeviation();
1019       Int_t stripX21 = locTrg->LoStripX()+deviation+1;
1020       Float_t y21 = circuit.GetY21Pos(localBoardId, stripX21);
1021       Float_t x11 = circuit.GetX11Pos(localBoardId, locTrg->LoStripY());
1022
1023       AliDebug(1, Form(" MakeTriggerTrack %d %d %d %d %f %f %f \n",locTrg->LoCircuit(),
1024                        locTrg->LoStripX(),locTrg->LoStripX()+locTrg->LoDev()+1,locTrg->LoStripY(),y11, y21, x11));
1025
1026       Float_t thetax = TMath::ATan2( x11 , z11 );
1027       Float_t thetay = TMath::ATan2( (y21-y11) , (z21-z11) );
1028
1029       triggerTrack.SetX11(x11);
1030       triggerTrack.SetY11(y11);
1031       triggerTrack.SetThetax(thetax);
1032       triggerTrack.SetThetay(thetay);
1033       triggerTrack.SetGTPattern(gloTrigPat);
1034       triggerTrack.SetLoTrgNum(localBoardId);
1035
1036       triggerTrackStore.Add(triggerTrack);
1037     } // board is fired
1038   } // end of loop on Local Trigger
1039 }
1040