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