Some warning going to error and viceversa:
[u/mrichter/AliRoot.git] / 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 }