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