STEER/STEER/AliTrackFitter.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 /*************************************************************************
  17  * AliTrackFitter: base class for the fast track fitters                 *
  18  *                                                                       *
  19  * Supposed to be used for alignment framework                           *
  20  * More information is available in
  21  * http://agenda.cern.ch/askArchive.php?base=agenda&categ=a057717&id=a057717s1t6/transparencies
  22  * Author: C.Cheskov                                                     *
  23  *                                                                       *
  24  *                                                                       *
  25  *************************************************************************/
  26
  27 #include <TMatrixDSym.h>
  28 #include <TArrayI.h>
  29
  30 #include "AliTrackFitter.h"
  31 #include "AliTrackPointArray.h"
  32 #include "AliLog.h"
  33
  34 ClassImp(AliTrackFitter)
  35
  36 //_____________________________________________________________________________
  37 AliTrackFitter::AliTrackFitter() :
  38   TObject(),
  39   fCov(0),
  40   fPoints(0),
  41   fPVolId(0),
  42   fPTrack(0),
  43   fChi2(0),
  44   fNdf(0),
  45   fMinNPoints(0),
  46   fIsOwner(kFALSE)
  47 {
  48   // default constructor
  49   //
  50   for (Int_t i=0;i<6;i++) fParams[i] = 0;
  51 }
  52
  53 //_____________________________________________________________________________
  54 AliTrackFitter::AliTrackFitter(AliTrackPointArray *array, Bool_t owner) :
  55   TObject(),
  56   fCov(new TMatrixDSym(6)),
  57   fPoints(0),
  58   fPVolId(0),
  59   fPTrack(0),
  60   fChi2(0),
  61   fNdf(0),
  62   fMinNPoints(0),
  63   fIsOwner(kFALSE)
  64
  65 {
  66   // constructor from space points array
  67   //
  68   for (Int_t i=0;i<6;i++) fParams[i] = 0;
  69   SetTrackPointArray(array,owner);
  70 }
  71
  72 //_____________________________________________________________________________
  73 AliTrackFitter::AliTrackFitter(const AliTrackFitter &fitter):
  74   TObject(fitter),
  75   fCov(new TMatrixDSym(*fitter.fCov)),
  76   fPoints(0),
  77   fPVolId(0),
  78   fPTrack(0),
  79   fChi2(fitter.fChi2),
  80   fNdf(fitter.fNdf),
  81   fMinNPoints(fitter.fMinNPoints),
  82   fIsOwner(kFALSE)
  83 {
  84   // Copy constructor
  85   //
  86   SetTrackPointArray(fitter.fPoints,fitter.fIsOwner);
  87   for (Int_t i=0;i<6;i++) fParams[i] = fitter.fParams[i];
  88 }
  89
  90 //_____________________________________________________________________________
  91 AliTrackFitter &AliTrackFitter::operator =(const AliTrackFitter& fitter)
  92 {
  93   // assignment operator
  94   //
  95   if(this==&fitter) return *this;
  96
  97   SetTrackPointArray(fitter.fPoints);
  98   for (Int_t i=0;i<6;i++) fParams[i] = fitter.fParams[i];
  99   fCov = new TMatrixDSym(*fitter.fCov);
 100   fChi2 = fitter.fChi2;
 101   fNdf = fitter.fNdf;
 102   fMinNPoints = fitter.fMinNPoints;
 103   fIsOwner = kFALSE;
 104
 105   return *this;
 106 }
 107
 108 //_____________________________________________________________________________
 109 AliTrackFitter::~AliTrackFitter()
 110 {
 111   if (fIsOwner)
 112     delete fPoints;
 113   delete fCov;
 114 }
 115
 116 //_____________________________________________________________________________
 117 void AliTrackFitter::Reset()
 118 {
 119   for (Int_t i=0;i<6;i++) fParams[i] = 0;
 120   delete fCov;
 121   fCov = new TMatrixDSym(6);
 122   fPVolId = fPTrack = 0;
 123   fChi2 = 0;
 124   fNdf = 0;
 125 }
 126
 127 void AliTrackFitter::SetTrackPointArray(AliTrackPointArray *array, Bool_t owner)
 128 {
 129   // Load space points from array
 130   // By default we don't copy them but
 131   // just put the pointers to them
 132   if (!array) {
 133     AliWarning("Invalid pointer to the space-points array !");
 134     if (fIsOwner) delete fPoints;
 135     fPoints = NULL;
 136     return;
 137   }
 138
 139   Reset();
 140
 141   if (fIsOwner) delete fPoints;
 142
 143   if (owner) {
 144     fPoints = new AliTrackPointArray(*array);
 145     fIsOwner = kTRUE;
 146   }
 147   else {
 148     fPoints = array;
 149     fIsOwner = kFALSE;
 150   }
 151 }
 152
 153 Bool_t AliTrackFitter::FindVolId(const TArrayI *array, UShort_t volid) const
 154 {
 155   // The method is used to check whenever
 156   // the volume id (volid) is contained in
 157   // a array of integers
 158   Int_t nVolIds = array->GetSize();
 159   if (nVolIds == 0) return kFALSE;
 160
 161   Bool_t found = kFALSE;
 162   for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) {
 163     if ((*array)[iVolId] == volid) {
 164       found = kTRUE;
 165       break;
 166     }
 167   }
 168
 169   return found;
 170 }
 171
 172 Bool_t AliTrackFitter::Fit(const TArrayI *volIds,const TArrayI *volIdsFit,
 173 AliGeomManager::ELayerID layerRangeMin,
 174 AliGeomManager::ELayerID layerRangeMax)
 175 {
 176   //-------------------------------------------------------------------
 177   //
 178   //                      Fit the track points.
 179   //
 180   // volIds    - the array of IDs of volumes where the residuals
 181   //             will be calculated.
 182   // volIdsFit - the array of IDs of volumes having the points
 183   //              that will be fitted
 184   //
 185   // If volIdsFit==0, the IDs of volumes having the points to fit
 186   // are taken in the range defined by the two last parameters
 187   //
 188   //
 189   // The function fills two track-point arrays: fPVolId and fPTrack.
 190   // The first one contains the track points from the volumes with IDs
 191   // taken from the "volIds". The second array is filled with
 192   // the intersection points between the fitted track and the volumes
 193   // the points from the first arry belong to.
 194   //
 195   // The two arrays are used for calculation of the residuals
 196   // and for the construction of a chi2 function to be minimized
 197   // in the alignment procedures.
 198   //
 199   //--------------------------------------------------------------------
 200
 201   Int_t npoints=fPoints->GetNPoints();
 202   if (npoints<fMinNPoints) return kFALSE;
 203
 204   // Fast counting the points
 205   Int_t countFit=0;
 206   Int_t countPnt=0;
 207
 208   Int_t fst=-1;
 209   Int_t lst=-1;
 210   if (volIdsFit != 0x0) {
 211      for (Int_t i=0; i<npoints; i++) {
 212          if (FindVolId(volIds,   fPoints->GetVolumeID()[i])) countPnt++;
 213          if (FindVolId(volIdsFit,fPoints->GetVolumeID()[i])) {
 214             countFit++;
 215             if (fst<0) fst=i;
 216             lst=i;
 217          }
 218      }
 219   } else {
 220      for (Int_t i=0; i<npoints; i++) {
 221          UShort_t id=fPoints->GetVolumeID()[i];
 222          if (FindVolId(volIds,id)) countPnt++;
 223          if (id < AliGeomManager::LayerToVolUID(layerRangeMin,0)) continue;
 224          if (id > AliGeomManager::LayerToVolUID(layerRangeMax,
 225                   AliGeomManager::LayerSize(layerRangeMax))) continue;
 226          countFit++;
 227          if (fst<0) fst=i;
 228          lst=i;
 229      }
 230   }
 231   if (countPnt==0) return kFALSE;
 232   if (countFit<fMinNPoints) return kFALSE;
 233
 234
 235
 236   //************* Fit the selected track points
 237
 238   if (!Begin(fst,lst)) return kFALSE;
 239
 240   AliTrackPoint p;
 241   if (volIdsFit != 0x0) {
 242      for (Int_t i=0; i<npoints; i++) {
 243          if (!FindVolId(volIdsFit,fPoints->GetVolumeID()[i])) continue;
 244          fPoints->GetPoint(p,i);
 245          if (!AddPoint(&p)) return kFALSE;
 246      }
 247   } else {
 248      for (Int_t i=0; i<npoints; i++) {
 249          UShort_t id=fPoints->GetVolumeID()[i];
 250          if (id < AliGeomManager::LayerToVolUID(layerRangeMin,0)) continue;
 251          if (id > AliGeomManager::LayerToVolUID(layerRangeMax,
 252                   AliGeomManager::LayerSize(layerRangeMax))) continue;
 253          fPoints->GetPoint(p,i);
 254          if (!AddPoint(&p)) continue;
 255      }
 256   }
 257
 258   if (!Update()) return kFALSE;
 259
 260
 261
 262
 263   //************* Calculate the intersection points
 264
 265   fPVolId = new AliTrackPointArray(countPnt);
 266   fPTrack = new AliTrackPointArray(countPnt);
 267
 268   Int_t n=0;
 269   AliTrackPoint p2;
 270   for (Int_t i=0; i<npoints; i++) {
 271       if (!FindVolId(volIds,fPoints->GetVolumeID()[i])) continue;
 272       fPoints->GetPoint(p,i);
 273       if (GetPCA(p,p2)) {
 274         fPVolId->AddPoint(n,&p);
 275         fPTrack->AddPoint(n,&p2);
 276         n++;
 277       } else {
 278         delete fPVolId;
 279         fPVolId=0;
 280         delete fPTrack;
 281         fPTrack=0;
 282         return kFALSE;
 283       }
 284   }
 285
 286   return kTRUE;
 287 }