STEER/STEER/AliTrackResiduals.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 //   Implementation of the base class for track residuals
  18 //
  19 //
  20 //-----------------------------------------------------------------
  21
  22 #include "AliTrackResiduals.h"
  23
  24 #include "AliAlignObj.h"
  25 #include "AliAlignObjParams.h"
  26 #include "AliTrackPointArray.h"
  27
  28 ClassImp(AliTrackResiduals)
  29
  30 //_____________________________________________________________________________
  31 AliTrackResiduals::AliTrackResiduals():
  32   fN(0),
  33   fLast(0),
  34   fAlignObj(0),
  35   fVolArray(0),
  36   fTrackArray(0),
  37   fChi2(0),
  38   fNdf(0),
  39   fMinNPoints(0),
  40   fIsOwner(kTRUE)
  41 {
  42   // Default constructor
  43   for (Int_t ipar=0; ipar<6; ipar++){
  44     fBFixed[ipar] = kFALSE;
  45     fFixed[ipar]  = 0.;
  46   }
  47 }
  48
  49 //_____________________________________________________________________________
  50 AliTrackResiduals::AliTrackResiduals(Int_t ntracks):
  51   fN(ntracks),
  52   fLast(0),
  53   fAlignObj(0),
  54   fVolArray(0),
  55   fTrackArray(0),
  56   fChi2(0),
  57   fNdf(0),
  58   fMinNPoints(0),
  59   fIsOwner(kTRUE)
  60 {
  61   // Constructor
  62   if (ntracks > 0) {
  63     fVolArray = new AliTrackPointArray*[ntracks];
  64     fTrackArray = new AliTrackPointArray*[ntracks];
  65     for (Int_t itrack = 0; itrack < ntracks; itrack++)
  66       fVolArray[itrack] = fTrackArray[itrack] = 0x0;
  67   }
  68
  69   for (Int_t ipar=0; ipar<6; ipar++){
  70     fBFixed[ipar] = kFALSE;
  71     fFixed[ipar]  = 0.;
  72   }
  73 }
  74
  75 //_____________________________________________________________________________
  76 AliTrackResiduals::AliTrackResiduals(const AliTrackResiduals &res):
  77   TObject(res),
  78   fN(res.fN),
  79   fLast(res.fLast),
  80   fAlignObj(0),
  81   fVolArray(new AliTrackPointArray*[fN]),
  82   fTrackArray(new AliTrackPointArray*[fN]),
  83   fChi2(res.fChi2),
  84   fNdf(res.fNdf),
  85   fMinNPoints(res.fMinNPoints),
  86   fIsOwner(kTRUE)
  87 {
  88   // Copy constructor
  89   // By default the created copy owns the track point arrays
  90
  91   if(res.fAlignObj) fAlignObj = (AliAlignObj *)res.fAlignObj->Clone();
  92
  93   memset(fVolArray,0,sizeof(AliTrackPointArray*)*fN);
  94   memset(fTrackArray,0,sizeof(AliTrackPointArray*)*fN);
  95
  96   for (Int_t itrack = 0; itrack < fN; itrack++) {
  97     if (res.fVolArray[itrack])
  98       fVolArray[itrack] = new AliTrackPointArray(*res.fVolArray[itrack]);
  99     if (res.fTrackArray[itrack])
 100       fTrackArray[itrack] = new AliTrackPointArray(*res.fTrackArray[itrack]);
 101   }
 102
 103   memcpy(fBFixed,res.fBFixed,sizeof(Bool_t)*6);
 104   memcpy(fFixed,res.fFixed,sizeof(Float_t)*6);
 105
 106 }
 107
 108 //_____________________________________________________________________________
 109 AliTrackResiduals &AliTrackResiduals::operator =(const AliTrackResiduals& res)
 110 {
 111   // assignment operator
 112   // Does not copy the track point arrays
 113   if(this!=&res) {
 114     TObject::operator=(res);
 115
 116     fLast = res.fLast;
 117     delete fAlignObj;
 118     if(res.fAlignObj)
 119       fAlignObj = (AliAlignObj *)res.fAlignObj->Clone();
 120     else
 121       fAlignObj = 0;
 122
 123     if (fIsOwner) {
 124       if (fVolArray) {
 125         for (Int_t itrack = 0; itrack < fN; itrack++)
 126           delete fVolArray[itrack];
 127         delete [] fVolArray;
 128         fVolArray=0;
 129       }
 130       if(res.fN) {
 131         fVolArray = new AliTrackPointArray*[res.fN];
 132         memset(fVolArray,0,sizeof(AliTrackPointArray*)*res.fN);
 133         for (Int_t itrack = 0; itrack < res.fN; itrack++)
 134           if (res.fVolArray[itrack])
 135             fVolArray[itrack] = new AliTrackPointArray(*res.fVolArray[itrack]);
 136       }
 137       if (fTrackArray) {
 138         for (Int_t itrack = 0; itrack < fN; itrack++)
 139           delete fTrackArray[itrack];
 140         delete [] fTrackArray;
 141       }
 142       if(res.fN) {
 143         fTrackArray = new AliTrackPointArray*[res.fN];
 144         memset(fTrackArray,0,sizeof(AliTrackPointArray*)*res.fN);
 145         for (Int_t itrack = 0; itrack < res.fN; itrack++)
 146           if (res.fTrackArray[itrack])
 147             fTrackArray[itrack] = new AliTrackPointArray(*res.fTrackArray[itrack]);
 148       }
 149     } else {
 150       fVolArray = res.fVolArray;
 151       fTrackArray = res.fTrackArray;
 152     }
 153     fN = res.fN;
 154     fChi2 = res.fChi2;
 155     fNdf  = res.fNdf;
 156     fMinNPoints = res.fMinNPoints;
 157     fIsOwner = kFALSE;
 158
 159     memcpy(fBFixed,res.fBFixed,sizeof(Bool_t)*6);
 160     memcpy(fFixed,res.fFixed,sizeof(Float_t)*6);
 161   }
 162   return *this;
 163 }
 164
 165 //_____________________________________________________________________________
 166 AliTrackResiduals::~AliTrackResiduals()
 167 {
 168   // Destructor
 169   delete fAlignObj;
 170   DeleteTrackPointArrays();
 171 }
 172
 173 //_____________________________________________________________________________
 174 void AliTrackResiduals::SetNTracks(Int_t ntracks)
 175 {
 176   // Set new size for the track point arrays.
 177   // Delete the old arrays and allocate the
 178   // new ones.
 179   DeleteTrackPointArrays();
 180
 181   fN = ntracks;
 182   fLast = 0;
 183   fChi2 = 0;
 184   fNdf  = 0;
 185   fIsOwner = kTRUE;
 186
 187   if (ntracks > 0) {
 188     fVolArray = new AliTrackPointArray*[ntracks];
 189     fTrackArray = new AliTrackPointArray*[ntracks];
 190     for (Int_t itrack = 0; itrack < ntracks; itrack++)
 191       fVolArray[itrack] = fTrackArray[itrack] = 0x0;
 192   }
 193   else {
 194     fVolArray = fTrackArray = 0x0;
 195   }
 196 }
 197
 198 //_____________________________________________________________________________
 199 Bool_t AliTrackResiduals::AddTrackPointArrays(AliTrackPointArray *volarray, AliTrackPointArray *trackarray)
 200 {
 201   // Adds pair of track space point and
 202   // track extrapolation point arrays
 203   if (!fVolArray || !fTrackArray) return kFALSE;
 204
 205   if (!volarray || !trackarray) return kFALSE;
 206
 207   if (volarray->GetNPoints() < fMinNPoints) return kFALSE;
 208
 209   if (fLast >= fN) return kFALSE;
 210
 211   fVolArray[fLast] = volarray;
 212   fTrackArray[fLast] = trackarray;
 213   fLast++;
 214
 215   return kTRUE;
 216 }
 217
 218 //_____________________________________________________________________________
 219 void AliTrackResiduals::InitAlignObj()
 220 {
 221   // Create the alignment object
 222   // to be updated
 223   delete fAlignObj;
 224   fAlignObj = new AliAlignObjParams;
 225 }
 226
 227
 228 //_____________________________________________________________________________
 229 Bool_t AliTrackResiduals::GetTrackPointArrays(Int_t i, AliTrackPointArray* &volarray, AliTrackPointArray* &trackarray) const
 230 {
 231   // Provide an access to a pair of track point arrays
 232   // with given index
 233   if (i >= fLast) {
 234     volarray = trackarray = 0x0;
 235     return kFALSE;
 236   }
 237   else {
 238     volarray = fVolArray[i];
 239     trackarray = fTrackArray[i];
 240     return kTRUE;
 241   }
 242 }
 243
 244 //_____________________________________________________________________________
 245 void AliTrackResiduals::DeleteTrackPointArrays()
 246 {
 247   // Deletes the track point arrays only in case
 248   // the object is their owner.
 249   // Called by the destructor and SetNTracks methods.
 250   if (fIsOwner) {
 251     if (fVolArray) {
 252       for (Int_t itrack = 0; itrack < fN; itrack++)
 253         delete fVolArray[itrack];
 254       delete [] fVolArray;
 255     }
 256     if (fTrackArray) {
 257       for (Int_t itrack = 0; itrack < fN; itrack++)
 258         delete fTrackArray[itrack];
 259       delete [] fTrackArray;
 260     }
 261   }
 262 }
 263
 264 //_____________________________________________________
 265 Int_t AliTrackResiduals::GetNFreeParam(){
 266   Int_t unfixedparam=6;
 267   for(Int_t j=0;j<6;j++){
 268     if(fBFixed[j]==kTRUE)unfixedparam--;
 269   }
 270   return unfixedparam;
 271 }