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       {
  98         if (res.fVolArray[itrack])
  99           fVolArray[itrack] = new AliTrackPointArray(*res.fVolArray[itrack]);
 100         if (res.fTrackArray[itrack])
 101           fTrackArray[itrack] = new AliTrackPointArray(*res.fTrackArray[itrack]);
 102       }
 103
 104     memcpy(fBFixed,res.fBFixed,sizeof(Bool_t)*6);
 105     memcpy(fFixed,res.fFixed,sizeof(Float_t)*6);
 106
 107 }
 108
 109 //_____________________________________________________________________________
 110 AliTrackResiduals &AliTrackResiduals::operator =(const AliTrackResiduals& res)
 111 {
 112   // assignment operator
 113   // Does not copy the track point arrays
 114   if(this!=&res) {
 115     TObject::operator=(res);
 116
 117     fN = res.fN;
 118     fLast = res.fLast;
 119     fAlignObj = res.fAlignObj;
 120     fVolArray = res.fVolArray;
 121     fTrackArray = res.fTrackArray;
 122     fChi2 = res.fChi2;
 123     fNdf  = res.fNdf;
 124     fMinNPoints = res.fMinNPoints;
 125     fIsOwner = kFALSE;
 126
 127     memcpy(fBFixed,res.fBFixed,sizeof(Bool_t)*6);
 128     memcpy(fFixed,res.fFixed,sizeof(Float_t)*6);
 129   }
 130   return *this;
 131 }
 132
 133 //_____________________________________________________________________________
 134 AliTrackResiduals::~AliTrackResiduals()
 135 {
 136   // Destructor
 137   if (fAlignObj) delete fAlignObj;
 138   DeleteTrackPointArrays();
 139 }
 140
 141 //_____________________________________________________________________________
 142 void AliTrackResiduals::SetNTracks(Int_t ntracks)
 143 {
 144   // Set new size for the track point arrays.
 145   // Delete the old arrays and allocate the
 146   // new ones.
 147   DeleteTrackPointArrays();
 148
 149   fN = ntracks;
 150   fLast = 0;
 151   fChi2 = 0;
 152   fNdf  = 0;
 153   fIsOwner = kTRUE;
 154
 155   if (ntracks > 0) {
 156     fVolArray = new AliTrackPointArray*[ntracks];
 157     fTrackArray = new AliTrackPointArray*[ntracks];
 158     for (Int_t itrack = 0; itrack < ntracks; itrack++)
 159       fVolArray[itrack] = fTrackArray[itrack] = 0x0;
 160   }
 161   else {
 162     fVolArray = fTrackArray = 0x0;
 163   }
 164 }
 165
 166 //_____________________________________________________________________________
 167 Bool_t AliTrackResiduals::AddTrackPointArrays(AliTrackPointArray *volarray, AliTrackPointArray *trackarray)
 168 {
 169   // Adds pair of track space point and
 170   // track extrapolation point arrays
 171   if (!fVolArray || !fTrackArray) return kFALSE;
 172
 173   if (!volarray || !trackarray) return kFALSE;
 174
 175   if (volarray->GetNPoints() < fMinNPoints) return kFALSE;
 176
 177   if (fLast >= fN) return kFALSE;
 178
 179   fVolArray[fLast] = volarray;
 180   fTrackArray[fLast] = trackarray;
 181   fLast++;
 182
 183   return kTRUE;
 184 }
 185
 186 //_____________________________________________________________________________
 187 void AliTrackResiduals::InitAlignObj()
 188 {
 189   // Create the alignment object
 190   // to be updated
 191   if (fAlignObj) delete fAlignObj;
 192   fAlignObj = new AliAlignObjParams;
 193 }
 194
 195
 196 //_____________________________________________________________________________
 197 Bool_t AliTrackResiduals::GetTrackPointArrays(Int_t i, AliTrackPointArray* &volarray, AliTrackPointArray* &trackarray) const
 198 {
 199   // Provide an access to a pair of track point arrays
 200   // with given index
 201   if (i >= fLast) {
 202     volarray = trackarray = 0x0;
 203     return kFALSE;
 204   }
 205   else {
 206     volarray = fVolArray[i];
 207     trackarray = fTrackArray[i];
 208     return kTRUE;
 209   }
 210 }
 211
 212 //_____________________________________________________________________________
 213 void AliTrackResiduals::DeleteTrackPointArrays()
 214 {
 215   // Deletes the track point arrays only in case
 216   // the object is their owner.
 217   // Called by the destructor and SetNTracks methods.
 218   if (fIsOwner) {
 219     if (fVolArray) {
 220       for (Int_t itrack = 0; itrack < fN; itrack++) {
 221         if (fVolArray[itrack]) delete fVolArray[itrack];
 222       }
 223       delete [] fVolArray;
 224     }
 225     if (fTrackArray) {
 226       for (Int_t itrack = 0; itrack < fN; itrack++) {
 227         if (fTrackArray[itrack]) delete fTrackArray[itrack];
 228       }
 229       delete [] fTrackArray;
 230     }
 231   }
 232 }
 233
 234 //_____________________________________________________
 235 Int_t AliTrackResiduals::GetNFreeParam(){
 236   Int_t unfixedparam=6;
 237   for(Int_t j=0;j<6;j++){
 238     if(fBFixed[j]==kTRUE)unfixedparam--;
 239   }
 240   return unfixedparam;
 241 }