first steps to set the covariance matrix from the errors calculated in conformal...
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCConfMapTrack.cxx
1 // @(#) $Id$
2 // Original: AliHLTConfMapTrack.cxx,v 1.16 2005/06/14 10:55:21 cvetan 
3
4 //**************************************************************************
5 //* This file is property of and copyright by the ALICE HLT Project        * 
6 //* ALICE Experiment at CERN, All rights reserved.                         *
7 //*                                                                        *
8 //* Primary Authors: Anders Vestbo, maintained by                          *
9 //*                  Matthias Richter <Matthias.Richter@ift.uib.no>        *
10 //*                  for The ALICE HLT Project.                            *
11 //*                                                                        *
12 //* Permission to use, copy, modify and distribute this software and its   *
13 //* documentation strictly for non-commercial purposes is hereby granted   *
14 //* without fee, provided that the above copyright notice appears in all   *
15 //* copies and that both the copyright notice and this permission notice   *
16 //* appear in the supporting documentation. The authors make no claims     *
17 //* about the suitability of this software for any purpose. It is          *
18 //* provided "as is" without express or implied warranty.                  *
19 //**************************************************************************
20
21 /** @file   AliHLTTPCConfMapTrack.cxx
22     @author Anders Vestbo, maintained by Matthias Richter
23     @date   
24     @brief  Track class for conformal mapper
25 */
26
27 #include "AliHLTTPCRootTypes.h"
28 #include "AliHLTTPCLogging.h"
29 #include "AliHLTTPCVertex.h"
30 #include "AliHLTTPCConfMapPoint.h"
31 #include "AliHLTTPCConfMapFit.h"
32 #include "AliHLTTPCConfMapTrack.h"
33 #include "AliHLTTPCTransform.h"
34
35 #if __GNUC__ >= 3
36 using namespace std;
37 #endif
38
39 ClassImp(AliHLTTPCConfMapTrack)
40
41
42 AliHLTTPCConfMapTrack::AliHLTTPCConfMapTrack()
43   :
44   fCurrentHit(0),
45   fLastHit(0),
46   fFirstHit(0),
47   fs11Xy(0),
48   fs12Xy(0),
49   fs22Xy(0),
50   fg1Xy(0),
51   fg2Xy(0),
52   fs11Sz(0),
53   fs12Sz(0),
54   fs22Sz(0),
55   fg1Sz(0),
56   fg2Sz(0),
57   fddXy(0),
58   fa1Xy(0),
59   fa2Xy(0),
60   fddSz(0),
61   fa1Sz(0),
62   fa2Sz(0)
63 {
64   //Constructor
65   fChiSq[0] = 0.;
66   fChiSq[1] = 0.;
67 }
68
69 AliHLTTPCConfMapTrack::~AliHLTTPCConfMapTrack()
70 {
71   //deconstructor
72 }
73
74 void AliHLTTPCConfMapTrack::DeleteCandidate()
75 {
76   //Deletes this track by resetting all its parameters. Does not delete
77   //the object itself.
78
79   AliHLTTPCConfMapPoint *curHit = (AliHLTTPCConfMapPoint*)fFirstHit;
80   AliHLTTPCConfMapPoint *nextHit;
81   
82   while(curHit != 0)
83     {
84       nextHit = (AliHLTTPCConfMapPoint*)curHit->GetNextTrackHit();
85       curHit->SetNextTrackHit(0);
86       curHit = nextHit;
87     }
88   
89   UInt_t *hit_numbers = GetHitNumbers();
90   for(Int_t i=0; i<GetNHits(); i++)
91     {
92       //fHitNumbers[i] = 0;
93       hit_numbers[i]=0;
94     }
95     
96   SetRadius(0.);
97   SetCenterX(0.);
98   SetCenterY(0.);
99   
100   ComesFromMainVertex(false);
101
102   SetNHits(0);
103   SetCharge(0);
104   fChiSq[0] = 0.;
105   fChiSq[1] = 0.;
106 }
107
108
109 void AliHLTTPCConfMapTrack::SetProperties(Bool_t usage)
110 {
111   //Set the hits to this track to 'usage'
112   for(StartLoop(); LoopDone(); GetNextHit())
113     {
114       AliHLTTPCConfMapPoint *p = (AliHLTTPCConfMapPoint*)fCurrentHit;
115       p->SetUsage(usage);
116     }
117   return;
118 }
119
120 void AliHLTTPCConfMapTrack::Reset()
121 {
122   //Resets the fit parameters of this track.
123
124   //xy-plane
125   fs11Xy   = 0;
126   fs12Xy   = 0;
127   fs22Xy   = 0;
128   fg1Xy    = 0;
129   fg2Xy    = 0;
130   fChiSq[0]  = 0.;
131     
132   //sz-plane
133   fs11Sz = 0;
134   fs12Sz = 0;
135   fs22Sz = 0;
136   fg1Sz  = 0;
137   fg2Sz  = 0;
138   fChiSq[1] = 0; 
139   SetLength(0);
140   SetNHits(0);
141 }
142
143 void AliHLTTPCConfMapTrack::UpdateParam(AliHLTTPCConfMapPoint *thisHit)
144 {
145   //Function to update fit parameters of track
146   //Also, it updates the hit pointers.
147   
148
149   //Increment the number of hits assigned to this track:
150
151   //fNHits++;
152   Int_t nhits = GetNHits();
153   nhits++;
154   SetNHits(nhits); //SetNHits(nhits++);
155
156   //Set the hit pointers:
157   //if(fNHits == 1)
158   if(GetNHits()==1)  
159     fFirstHit = thisHit;
160   else
161     ((AliHLTTPCConfMapPoint*)fLastHit)->SetNextTrackHit(thisHit);
162   fLastHit = thisHit;
163
164   
165   fs11Xy = fs11Xy + thisHit->GetXYWeight() ;
166   fs12Xy = fs12Xy + thisHit->GetXYWeight() * thisHit->GetXprime() ;
167   fs22Xy = fs22Xy + thisHit->GetXYWeight() * pow((thisHit->GetXprime()),2) ;
168   fg1Xy  = fg1Xy  + thisHit->GetXYWeight() * thisHit->GetYprime() ;
169   fg2Xy  = fg2Xy  + thisHit->GetXYWeight() * thisHit->GetXprime() * thisHit->GetYprime() ;
170     
171   fddXy  = fs11Xy * fs22Xy - pow((fs12Xy),2) ;
172   if ( fddXy != 0 ) 
173     {
174       fa1Xy  = ( fg1Xy * fs22Xy - fg2Xy * fs12Xy ) / fddXy ;
175       fa2Xy  = ( fg2Xy * fs11Xy - fg1Xy * fs12Xy ) / fddXy ;
176     }
177
178   //     Now in the sz plane
179   fs11Sz = fs11Sz + thisHit->GetZWeight() ;
180   fs12Sz = fs12Sz + thisHit->GetZWeight() * thisHit->GetS() ;
181   fs22Sz = fs22Sz + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetS() ;
182   fg1Sz  = fg1Sz  + thisHit->GetZWeight() * thisHit->GetZ() ;
183   fg2Sz  = fg2Sz  + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetZ() ;
184   
185         
186   fddSz  = fs11Sz * fs22Sz -  fs12Sz * fs12Sz ;
187   if ( fddSz != 0 ) {
188     fa1Sz  = ( fg1Sz * fs22Sz - fg2Sz * fs12Sz ) / fddSz ;
189     fa2Sz  = ( fg2Sz * fs11Sz - fg1Sz * fs12Sz ) / fddSz ;
190   }
191 }
192
193
194 void AliHLTTPCConfMapTrack::Fill(AliHLTTPCVertex *vertex,Double_t max_Dca)
195 {
196     //Fill track variables with or without fit.
197     
198     // for straight line fit
199     if (AliHLTTPCTransform::GetBFieldValue() == 0.0 ){
200
201         SetRadius(0.);  
202         SetPt(0.);
203         
204         //go for fit of straight line in real space
205         AliHLTTPCConfMapFit *fit = new AliHLTTPCConfMapFit(this,vertex);
206     /* Matthias 13.12.2006
207      * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
208      * and has always been kTRUE.
209      * In order to remove the AliHLTTPC class (which is the old steering class for
210      * HLT (TPC) tracking) from the compilation, this function can not be activated
211      * again. We have to think about a more elegant way to specify the parameters
212      * anyway. 
213         ComesFromMainVertex(AliHLTTPC::DoVertexFit());
214      */
215         ComesFromMainVertex(kTRUE);
216         fit->FitStraightLine();
217             
218         AliHLTTPCConfMapPoint *fHit = (AliHLTTPCConfMapPoint*)fFirstHit;
219         SetLastPoint(fHit->GetX(),fHit->GetY(),fHit->GetZ());
220         
221         UpdateToFirstPoint();
222         
223         delete fit;
224         
225     }
226     // for helix fit
227     else { 
228       //fRadius = sqrt(fa2Xy*fa2Xy+1)/(2*fabs(fa1Xy));
229       Double_t radius = sqrt(fa2Xy*fa2Xy+1)/(2*fabs(fa1Xy));
230       SetRadius(radius);
231       
232       //fPt = (Double_t)(AliHLTTPCTransform::GetBFieldValue() * fRadius);
233       Double_t pt = (Double_t)(AliHLTTPCTransform::GetBFieldValue() * GetRadius());
234       SetPt(pt);
235       //Set Error here?????
236       
237       if(GetPt() > max_Dca) //go for fit of helix in real space
238         {
239           AliHLTTPCConfMapFit *fit = new AliHLTTPCConfMapFit(this,vertex);
240     /* Matthias 13.12.2006
241      * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
242      * and has always been kTRUE.
243      * In order to remove the AliHLTTPC class (which is the old steering class for
244      * HLT (TPC) tracking) from the compilation, this function can not be activated
245      * again. We have to think about a more elegant way to specify the parameters
246      * anyway. 
247             ComesFromMainVertex(AliHLTTPC::DoVertexFit());
248      */
249           ComesFromMainVertex(kTRUE);
250           fit->FitHelix();
251           
252           //AliHLTTPCConfMapPoint *lHit = (AliHLTTPCConfMapPoint*)fLastHit;
253           AliHLTTPCConfMapPoint *fHit = (AliHLTTPCConfMapPoint*)fFirstHit;
254           SetLastPoint(fHit->GetX(),fHit->GetY(),fHit->GetZ());
255           
256           UpdateToFirstPoint();
257           
258           delete fit;
259         }
260       else if(GetPt() == 0) 
261         {
262           LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<<
263             "Found track with Pt=0!!!"<<ENDLOG;
264         }
265       else
266         {
267           LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<<
268             "Track with pt<max_Dca :"<<GetPt()<<ENDLOG;
269         }
270     }
271 }
272
273 Int_t AliHLTTPCConfMapTrack::GetMCLabel()
274 {
275   //For evaluation study.
276   //Returns the MCtrackID of the belonging clusters.
277   //If MCLabel < 0, means that track is fake.
278
279   return 0;
280   /*
281   Int_t num_of_clusters = GetNumberOfPoints();
282   S *s=new S[num_of_clusters];
283   Int_t i;
284   for (i=0; i<num_of_clusters; i++) s[i].lab=s[i].max=0;
285   
286   Int_t lab=123456789;
287   for (i=0; i<num_of_clusters; i++) {
288     AliHLTTPCConfMapPoint *c=(AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(i);
289     lab=fabs(c->fMCTrackID[0]);
290     Int_t j;
291     for (j=0; j<num_of_clusters; j++)
292       if (s[j].lab==lab || s[j].max==0) break;
293     s[j].lab=lab;
294     s[j].max++;
295   }
296   
297   Int_t max=0;
298   for (i=0; i<num_of_clusters; i++) 
299     if (s[i].max>max) {max=s[i].max; lab=s[i].lab;}
300     
301   delete[] s;
302   
303   for (i=0; i<num_of_clusters; i++) {
304     AliHLTTPCConfMapPoint *c=(AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(i);
305     if (fabs(c->fMCTrackID[1]) == lab ||
306         fabs(c->fMCTrackID[2]) == lab ) max++;
307   }
308   
309   //check if more than 10% of the clusters are incorrectly assigned (fake track):
310   
311   if (1.-Float_t(max)/num_of_clusters > 0.10) 
312     {
313       return -lab;
314     }
315   Int_t tail=Int_t(0.08*174);
316   if (num_of_clusters < tail) return lab;
317   
318   max=0;
319   for (i=1; i<=tail; i++) {
320     AliHLTTPCConfMapPoint *c = (AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(num_of_clusters-i);
321     if (lab == fabs(c->fMCTrackID[0]) ||
322         lab == fabs(c->fMCTrackID[1]) ||
323         lab == fabs(c->fMCTrackID[2])) max++;
324   }
325   if (max < Int_t(0.5*tail)) 
326     {
327       //printf("Wrong innermost clusters\n");
328       return -lab;
329     }
330   return lab;
331   */
332 }
333