AliRoot Core  3dc7879 (3dc7879)
AliTrackResiduals.cxx
Go to the documentation of this file.
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 //_____________________________________________________________________________
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 //_____________________________________________________________________________
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 //_____________________________________________________________________________
77  TObject(res),
78  fN(res.fN),
79  fLast(res.fLast),
80  fAlignObj(0),
83  fChi2(res.fChi2),
84  fNdf(res.fNdf),
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 //_____________________________________________________________________________
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 //_____________________________________________________________________________
167 {
168  // Destructor
169  delete fAlignObj;
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.
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 //_____________________________________________________________________________
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 //_____________________________________________________________________________
220 {
221  // Create the alignment object
222  // to be updated
223  delete fAlignObj;
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 //_____________________________________________________________________________
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 //_____________________________________________________
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 }
AliTrackResiduals & operator=(const AliTrackResiduals &res)
AliAlignObj * fAlignObj
Int_t GetNPoints() const
AliTrackPointArray ** fVolArray
Float_t fChi2
Pointers to the arrays containing track extrapolation points.
void SetNTracks(Int_t ntracks)
AliTrackPointArray ** fTrackArray
Pointers to the arrays containing space points.
Bool_t AddTrackPointArrays(AliTrackPointArray *volarray, AliTrackPointArray *trackarray)
void res(Char_t i)
Definition: Resolution.C:2
Bool_t GetTrackPointArrays(Int_t i, AliTrackPointArray *&volarray, AliTrackPointArray *&trackarray) const