initializing variables that were declare without a value
[u/mrichter/AliRoot.git] / HLT / global / AliHLTGlobalTrackMerger.cxx
1 //$Id$
2
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        * 
5  * ALICE Experiment at CERN, All rights reserved.                         *
6  *                                                                        *
7  * Primary Authors: Jacek Otwinowski (Jacek.Otwinowski@gsi.de)            *
8  *                  for The ALICE HLT Project.                            *
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 //  @file   AliHLTGlobalTrackMerger.cxx
20 //  @author Jacek Otwinowski
21 //  @date   
22 //  @brief  The HLT global merger base class
23 // 
24
25 //#include "AliTPCReconstructor.h"
26
27 #include "AliESDEvent.h"
28 #include "AliESDVertex.h"
29 #include "AliESDtrack.h"
30 #include "AliTracker.h"
31 #include "TTreeStream.h"
32
33 #include <TClonesArray.h>
34
35 #include "AliHLTGlobalTrackMerger.h"
36
37 #if __GNUC__>= 3
38 using namespace std;
39 #endif
40
41 ClassImp(AliHLTGlobalTrackMerger)
42
43 AliHLTGlobalTrackMerger::AliHLTGlobalTrackMerger()
44   :
45   fMaxY(0.0),
46   fMaxZ(0.0),
47   fMaxSnp(0.0),
48   fMaxTgl(0.0),
49   fMaxSigned1Pt(0.0),
50   fVertex(0),
51   fDebugStreamer(0)
52 {
53   //Default constructor
54
55   // standard vertex settings at the moment
56   // V(0.,0.,0.), sigmaVx=sigmaVy=5.e-3 [cm], sigmaVz=5.3 [cm]    
57   fVertex = new AliESDVertex;
58
59   // if (AliTPCReconstructor::StreamLevel()>0) {
60   //   fDebugStreamer = new TTreeSRedirector("debugGlobalMerger.root");
61   // }
62
63 }
64
65 //_____________________________________________________________________________
66 AliHLTGlobalTrackMerger::~AliHLTGlobalTrackMerger()
67 {
68   //Destructor
69   if(fVertex) delete fVertex; fVertex =0;
70   if(fDebugStreamer) delete fDebugStreamer; fDebugStreamer =0;
71 }
72
73 //_____________________________________________________________________________
74 Bool_t AliHLTGlobalTrackMerger::Merge(AliESDEvent* esdEvent)
75 {
76   // merge TPC and TRD tracks
77   // 1. propagate TPC track to the radius between TPC and TRD
78   // 2. propagate TRD track to the same radius between TPC and TRD
79   // 3. matches TPC and TRD tracks at the radius
80   // 4. propagate matched TRD track to the merging radius (first measured TPC point - x coordinate)
81   // 5. merge TPC and TRD track parameters at the merging radius 
82   // 6. create AliESDtrack from merged tracks
83   // 7. add AliESDtrack to AliESDEvent
84
85   if(!esdEvent) return kFALSE;
86
87   const Double_t kMaxStep     = 10.0;    // [cm] track propagation step
88   const Double_t kMatchRadius = 285.0;   // [cm] matching at radius between TPC and TRD
89   Double_t kMergeRadius = 0.0;
90   Bool_t isOk = kFALSE;
91   Bool_t isMatched = kFALSE;
92   AliESDtrack *track=0;
93   AliExternalTrackParam *extTPCTrack = 0;
94
95   Int_t nTracks = esdEvent->GetNumberOfTracks(); 
96   HLTWarning("nTracks %d",nTracks);
97
98   Int_t nTracksTPC =0;
99   for(Int_t iTrack = 0; iTrack<nTracks; ++iTrack) 
100   {
101     track = esdEvent->GetTrack(iTrack); 
102     if(!track) continue;
103
104     // TPC tracks
105     if((track->GetStatus()&AliESDtrack::kTPCin)==0) continue;
106     AliESDtrack *tpcTrack = track;
107     nTracksTPC++;
108
109     // create external tpc track param (needed to propagate to matching radius) 
110     if ((extTPCTrack = new AliExternalTrackParam(*tpcTrack)) == 0) continue; 
111
112     kMergeRadius = tpcTrack->GetTPCPoints(0); // [cm] merging at first measured TPC point
113
114     HLTInfo("-------------------------------------------------------------------------------------");
115     //HLTInfo("-----tpc track before matching: alpha %f, x %f, y, %f, z %f, snp %f, tgl %f, 1pt %f",tpcTrack->GetAlpha(),tpcTrack->GetX(),tpcTrack->GetY(),tpcTrack->GetZ(),tpcTrack->GetSnp(),tpcTrack->GetTgl(),tpcTrack->GetSigned1Pt());
116     HLTInfo("-----ext tpc track before matching: alpha %f, x %f, y, %f, z %f, snp %f, tgl %f, 1pt %f",extTPCTrack->GetAlpha(),extTPCTrack->GetX(),extTPCTrack->GetY(),extTPCTrack->GetZ(),extTPCTrack->GetSnp(),extTPCTrack->GetTgl(),extTPCTrack->GetSigned1Pt());
117
118     // propagate tracks to the matching radius 
119     //isOk = AliTracker::PropagateTrackTo(tpcTrack,kMatchRadius,tpcTrack->GetMass(),kMaxStep,kFALSE);
120     isOk = AliTracker::PropagateTrackTo(extTPCTrack,kMatchRadius,tpcTrack->GetMass(),kMaxStep,kFALSE);
121     if(!isOk) continue;
122
123     HLTInfo("-----ext tpc track at matching radius: alpha %f, x %f, y, %f, z %f, snp %f, tgl %f, 1pt %f",extTPCTrack->GetAlpha(),extTPCTrack->GetX(),extTPCTrack->GetY(),extTPCTrack->GetZ(),extTPCTrack->GetSnp(),extTPCTrack->GetTgl(),extTPCTrack->GetSigned1Pt());
124
125     Int_t nTracksTRD =0;
126     for(Int_t jTrack = 0; jTrack<nTracks; ++jTrack) 
127     {
128       track = esdEvent->GetTrack(jTrack); 
129       if(!track) continue;
130
131       // TRD tracks
132       if((track->GetStatus()&AliESDtrack::kTRDin)==0) continue;
133       AliESDtrack *trdTrack = track;
134       nTracksTRD++;
135
136       HLTInfo("-----trd track before matching: alpha %f, x %f, y %f, z %f, snp %f, tgl %f, 1pt %f",trdTrack->GetAlpha(),trdTrack->GetX(),trdTrack->GetY(),trdTrack->GetZ(),trdTrack->GetSnp(),trdTrack->GetTgl(),trdTrack->GetSigned1Pt());
137
138       isOk = AliTracker::PropagateTrackTo(trdTrack,kMatchRadius,trdTrack->GetMass(),kMaxStep,kFALSE);
139       if(!isOk) continue;
140
141       HLTInfo("-----trd track at matching radius: alpha %f, x %f, y %f, z %f, snp %f, tgl %f, 1pt %f",trdTrack->GetAlpha(),trdTrack->GetX(),trdTrack->GetY(),trdTrack->GetZ(),trdTrack->GetSnp(),trdTrack->GetTgl(),trdTrack->GetSigned1Pt());
142
143       // match TPC and TRD tracks
144       //isMatched = MatchTracks(tpcTrack,trdTrack);
145       isMatched = MatchTracks(extTPCTrack,trdTrack);
146       if(!isMatched) continue;
147
148       //HLTInfo("-----tpc track after matching: alpha %f, x %f, y %f, z %f, snp %f, tgl %f, 1pt %f",tpcTrack->GetAlpha(),tpcTrack->GetX(),tpcTrack->GetY(),tpcTrack->GetZ(),tpcTrack->GetSnp(),tpcTrack->GetTgl(),tpcTrack->GetSigned1Pt());
149       HLTInfo("-----ext tpc track after matching: alpha %f, x %f, y %f, z %f, snp %f, tgl %f, 1pt %f",extTPCTrack->GetAlpha(),extTPCTrack->GetX(),extTPCTrack->GetY(),extTPCTrack->GetZ(),extTPCTrack->GetSnp(),extTPCTrack->GetTgl(),extTPCTrack->GetSigned1Pt());
150       HLTInfo("-----trd track after matching: alpha %f, x %f, y %f, z %f, snp %f, tgl %f, 1pt %f",trdTrack->GetAlpha(),trdTrack->GetX(),trdTrack->GetY(),trdTrack->GetZ(),trdTrack->GetSnp(),trdTrack->GetTgl(),trdTrack->GetSigned1Pt());
151
152       // propagate TRD tracks to the merging radius 
153       //isOk = AliTracker::PropagateTrackTo(tpcTrack,kMergeRadius,tpcTrack->GetMass(),kMaxStep,kFALSE);
154       //if(!isOk) continue;
155       isOk = AliTracker::PropagateTrackTo(trdTrack,kMergeRadius,trdTrack->GetMass(),kMaxStep,kFALSE);
156       if(!isOk) continue;
157
158       HLTInfo("-----tpc before merging: alpha %f, x %f, y %f, z %f, snp %f, tgl %f, 1pt %f",tpcTrack->GetAlpha(),tpcTrack->GetX(),tpcTrack->GetY(),tpcTrack->GetZ(),tpcTrack->GetSnp(),tpcTrack->GetTgl(),tpcTrack->GetSigned1Pt());
159       HLTInfo("-----trd before merging: alpha %f, x %f, y %f, z %f, snp %f, tgl %f, 1pt %f",trdTrack->GetAlpha(),trdTrack->GetX(),trdTrack->GetY(),trdTrack->GetZ(),trdTrack->GetSnp(),trdTrack->GetTgl(),trdTrack->GetSigned1Pt());
160
161       // merge TPC and TRD tracks
162       // create AliESDtrack and add it to AliESDevent
163       Bool_t isMerged = MergeTracks(tpcTrack,trdTrack,esdEvent);
164       if(!isMerged) 
165         HLTInfo("No merged tracks");
166     }
167     HLTInfo("nTracksTRD %d",nTracksTRD);
168
169     // delete external TPC track
170     if(extTPCTrack) delete extTPCTrack; extTPCTrack=0;
171   }
172   HLTInfo("nTracksTPC %d",nTracksTPC);
173
174 return kTRUE;
175 }
176
177 //_____________________________________________________________________________
178 Bool_t AliHLTGlobalTrackMerger::MergeTracks(AliESDtrack *tpcTrack, AliESDtrack* trdTrack, AliESDEvent *esdEvent)
179 {
180   // merge TPC and TRD track parameters
181   // create new AliESDtrack with TPC+TRD merged track parameters
182   // add AliESDtrack to AliESDEvent
183
184   if(!tpcTrack) return kFALSE;
185   if(!trdTrack) return kFALSE;
186
187   Double_t trackParam[5], trackCovar[15]; 
188   Double_t trackChi2;
189   Int_t trackNDF;
190
191   // calculate merged track parameters
192   Bool_t isNotOK = SmoothTracks(tpcTrack->GetParameter(), tpcTrack->GetCovariance(), tpcTrack->GetTPCchi2(), 5,
193                                 trdTrack->GetParameter(), trdTrack->GetCovariance(), trdTrack->GetTRDchi2(), 5,
194                                 trackParam, trackCovar, trackChi2, trackNDF,5);
195
196   if(isNotOK) 
197       return kFALSE;
198
199   //
200   // create AliESDtrack
201   // merged TPC+TRD information
202   // 
203
204   AliESDtrack track;
205   //track.UpdateTrackParams(tpcTrack, AliESDtrack::kTPCrefit);
206   track.SetStatus(AliESDtrack::kGlobalMerge);
207   track.SetLabel(tpcTrack->GetLabel());
208   track.Set(tpcTrack->GetX(),tpcTrack->GetAlpha(),trackParam,trackCovar);
209   track.SetGlobalChi2(trackChi2);
210
211   //track.SetTPCLabel(tpcTrack->GetLabel());
212   Double32_t tpcPID[AliPID::kSPECIES];
213   tpcTrack->GetTPCpid(tpcPID);
214   track.SetTPCpid(tpcPID);
215   //fTPCncls=t->GetNumberOfClusters();  // no cluster on HLT
216   //fTPCchi2=t->GetChi2();
217
218   //track.SetTRDLabel(trdTrack->GetLabel());
219   Double32_t trdPID[AliPID::kSPECIES];
220   trdTrack->GetTRDpid(trdPID);
221   track.SetTRDpid(trdPID);
222   //fTRDchi2  = t->GetChi2();
223   //fTRDncls  = t->GetNumberOfClusters();
224   //for (Int_t i=0;i<6;i++) index[i]=t->GetTrackletIndex(i);
225
226   // add track to AliESDEvent
227   esdEvent->AddTrack(&track);
228
229 return kTRUE;
230 }
231
232 //_____________________________________________________________________________
233 void AliHLTGlobalTrackMerger::SetParameter(Double_t maxy, Double_t maxz, Double_t maxsnp, Double_t maxtgl, Double_t signed1Pt)
234
235   //set parameters for merger
236   fMaxY = maxy;
237   fMaxZ = maxz;
238   fMaxSnp = maxsnp;
239   fMaxTgl = maxtgl;
240   fMaxSigned1Pt = signed1Pt;
241 }
242
243 //_____________________________________________________________________________
244 Bool_t AliHLTGlobalTrackMerger::MatchTracks(AliExternalTrackParam *trackTPC, const AliESDtrack *trackTRD)
245
246   // match TPC and TRD tracks 
247   // return kTRUE in case of matching
248  
249   if(!trackTPC) return kFALSE;
250   if(!trackTRD) return kFALSE;
251
252   Double_t xTpc=trackTPC->GetX();
253   Double_t yTpc=trackTPC->GetY();
254   Double_t zTpc=trackTPC->GetZ();
255   Double_t snpTpc=trackTPC->GetSnp();
256   Double_t tglTpc=trackTPC->GetTgl();
257   Double_t signed1PtTpc=trackTPC->GetSigned1Pt();
258
259   Double_t xTrd=trackTRD->GetX();
260   Double_t yTrd=trackTRD->GetY();
261   Double_t zTrd=trackTRD->GetZ();
262   Double_t snpTrd=trackTRD->GetSnp();
263   Double_t tglTrd=trackTRD->GetTgl();
264   Double_t signed1PtTrd=trackTRD->GetSigned1Pt();
265
266   // debug stream
267   // if (AliTPCReconstructor::StreamLevel()>0) {
268   // //TTreeSRedirector &cstream = *fDebugStreamer;
269   // *fDebugStreamer<<"match"<<
270   // "xTpc="<<xTpc<<
271   // "yTpc="<<yTpc<<
272   // "zTpc="<<zTpc<<
273   // "snpTpc="<<snpTpc<<
274   // "tglTpc="<<tglTpc<<
275   // "signed1PtTpc="<<signed1PtTpc<<
276   // "xTrd="<<xTrd<<
277   // "yTrd="<<yTrd<<
278   // "zTrd="<<zTrd<<
279   // "snpTrd="<<snpTrd<<
280   // "tglTrd="<<tglTrd<<
281   // "signed1PtTrd="<<signed1PtTrd<<
282   // "\n";
283   // }
284
285   if (TMath::Abs(xTpc-xTrd) > 0) {/* get rid of warning*/;}
286   if (TMath::Abs(yTpc-yTrd) > fMaxY) return kFALSE;
287   if (TMath::Abs(zTpc-zTrd) > fMaxZ) return kFALSE;
288   if (TMath::Abs(snpTpc-snpTrd) > fMaxSnp) return kFALSE;
289   if (TMath::Abs(tglTpc-tglTrd) > fMaxTgl) return kFALSE;
290   if (TMath::Abs(signed1PtTpc-signed1PtTrd) > fMaxSigned1Pt) return kFALSE;
291
292 return kTRUE;
293 }
294
295 //_____________________________________________________________________________
296 Bool_t AliHLTGlobalTrackMerger::SmoothTracks( const Double_t T1[], const Double_t C1[], Double_t Chi21, Int_t NDF1,
297                                     const  Double_t T2[], const Double_t C2[], Double_t Chi22, Int_t NDF2,
298                                      Double_t T [], Double_t C [], Double_t &Chi2, Int_t &NDF,
299                                      Int_t N  )
300 {
301   //* Smooth two tracks with parameter vectors of size N
302   //*
303   //* Input:
304   //*
305   //* T1[N], T2[N] - tracks
306   //* C1[N*(N+1)/2], C2[N*(N+1)/2] - covariance matrices in low-diagonal form:
307   //* C = { c00, 
308   //*       c10, c11, 
309   //*       c20, c21, c22, 
310   //*       ...             };
311   //* Chi2{1,2}, NDF{1,2} - \Chi^2 and "Number of Degrees of Freedom" values for both tracks
312   //* Output: 
313   //*
314   //* T[N], C[N] ( can be aqual to {T1,C1}, or {T2,C2} )
315   //* Chi2, NDF
316   //*
317   //* returns error flag (0 means OK, 1 not OK )
318     
319   Int_t M = N*(N+1)/2;
320   
321   Double_t A[M];
322   Double_t K[N*N];
323   
324   for(Int_t k=0; k<M; k++) A[k] = C1[k] + C2[k]; 
325   Bool_t err = InvertS(A,N);
326   if( err ) return 1;
327
328   Chi2 = Chi21 + Chi22;
329   NDF = NDF1 + NDF2;
330   
331   MultSSQ( C1, A, K, N);        
332   Double_t r[N];
333   for( Int_t k=0; k<N;k++) r[k] = T1[k] - T2[k]; 
334   for( Int_t k=0; k<N;k++ )
335     for( Int_t l=0;l<N;l++) T[k] = T1[k] - K[k*N+l]*r[l];
336
337   for( Int_t ind=0,i=0; i<N; i++ ){
338     for( Int_t j=0; j<i; j++ ) Chi2+= 2*r[i]*r[j]*A[ind++];
339     Chi2+= r[i]*r[i]*A[ind++];
340   }
341   NDF+=N;
342
343   for( Int_t l=0; l<N; l++ ) K[ (N+1)*l ] -= 1;
344   
345   for( Int_t ind = 0, l=0; l<N; ++l ){
346     for( Int_t j=0; j<=l; ++j, ind++ ){
347       A[ind] = 0;
348       for( Int_t k=0; k<N; ++k ) A[ind] -= K[l*N+k] * C1[IndexS(j,k)];
349     }
350   }
351   for( Int_t l=0; l<N; l++ ) C[l] = A[l];
352   return 0;
353 }
354
355 //_____________________________________________________________________________
356 void AliHLTGlobalTrackMerger::MultSSQ( const Double_t *A, const Double_t *B, Double_t *C, Int_t N )
357 {
358   // no clue
359   for( Int_t ind=0, i=0; i<N; ++i ){
360     for( Int_t j=0; j<N; ++j, ++ind ){
361       C[ind] = 0;
362       for( Int_t k=0; k<N; ++k ) C[ind] += A[IndexS(i,k)] * B[IndexS(k,j)];
363     }
364   }
365 }
366
367 //_____________________________________________________________________________
368 Bool_t AliHLTGlobalTrackMerger::InvertS( Double_t A[], Int_t N )
369 {
370   //* input: simmetric > 0 NxN matrix A = {a11,a21,a22,a31..a33,..}  
371   //* output: inverse A, in case of problems fill zero and return 1
372   //*  
373   //* A->low triangular Anew : A = Anew x Anew^T
374   //* method:
375   //* for(j=1,N) for(i=j,N) Aij=(Aii-sum_{k=1}^{j-1}Aik*Ajk )/Ajj
376   //*   
377
378   Bool_t ret = 0;
379   
380   const Double_t ZERO = 1.E-20;
381     
382   {
383     Double_t *j1 = A, *jj = A;
384     for( Int_t j=1; j<=N; j1+=j++, jj+=j ){
385       Double_t *ik = j1, x = 0;
386       while( ik!=jj ){
387         x -= (*ik) * (*ik);
388         ik++;
389       }
390       x += *ik;
391       if( x > ZERO ){
392         x = sqrt(x);
393         *ik = x;
394         ik++;
395         x = 1 / x;
396         for( Int_t step=1; step<=N-j; ik+=++step ){ // ik==Ai1
397           Double_t sum = 0;
398           for( Double_t *jk=j1; jk!=jj; sum += (*(jk++)) * (*(ik++)) ) {}
399           *ik = (*ik - sum) * x; // ik == Aij
400         }
401       }else{
402         Double_t *ji=jj;
403         for( Int_t i=j; i<N; i++ ) *(ji+=i) = 0.;
404         ret = 1;
405       }   
406     }
407   }
408   
409   //* A -> Ainv
410   //* method : 
411   //* for(i=1,N){ 
412   //*   Aii = 1/Aii; 
413   //*   for(j=1,i-1) Aij=-(sum_{k=j}^{i-1} Aik * Akj) / Aii ;
414   //* }
415   
416   {
417     Double_t *ii=A,*ij=A;
418     for( Int_t i = 1; i<=N; ij=ii+1, ii+=++i ){
419       if( *ii > ZERO ){
420         Double_t x = -(*ii = 1./ *ii);
421         { 
422           Double_t *jj = A;
423           for( Int_t j=1; j<i; jj+=++j, ij++ ){
424             Double_t *ik = ij, *kj = jj, sum = 0.;
425             for( Int_t k=j; ik!=ii; kj+=k++, ik++ ){
426               sum += *ik * *kj;
427             }
428             *kj = sum * x;
429           }
430         }
431       }else{      
432         for( Double_t *ik = ij; ik!=ii+1; ik++ ){
433           *ik = 0.;
434         }
435         ret = 1;
436       }
437     }
438   }
439   
440   //* A -> A^T x A
441   //* method: 
442   //* Aij = sum_{k=i}^N Aki * Akj
443   
444   {
445     Double_t *ii=A, *ij=A;
446     for( Int_t i=1; i<=N; ii+=++i ){
447       do{ 
448         Double_t *ki = ii, *kj = ij, sum = 0.;
449         for( Int_t k=i; k<=N; ki+=k, kj+=k++ ) sum += (*ki) * (*kj);
450         *ij = sum;
451       }while( (ij++)!=ii );
452     }    
453   }
454   return ret;    
455 }
456
457 //_____________________________________________________________________________
458 void  AliHLTGlobalTrackMerger::PropagateTracksToDCA(const AliESDEvent *esdEvent)
459 {
460   // try to propagate all tracks to DCA to primary vertex
461   if(!esdEvent) return;
462
463   const Double_t kBz = esdEvent->GetMagneticField();
464   const Double_t kSmallRadius  = 2.8; // [cm] something less than the beam pipe radius
465   const Double_t kMaxStep  = 10.0;    // [cm] track propagation step
466   Bool_t isOK = kFALSE;
467
468   Int_t nTracks = esdEvent->GetNumberOfTracks(); 
469   for(Int_t iTrack = 0; iTrack<nTracks; ++iTrack) {
470     AliESDtrack *track = esdEvent->GetTrack(iTrack); 
471     if(!track) continue;
472
473     // propagate to small radius (material budget included)
474     isOK = AliTracker::PropagateTrackTo(track,kSmallRadius,track->GetMass(),kMaxStep,kFALSE);
475
476     // relate tracks to DCA to primary vertex
477     if(isOK) 
478     {
479       track->RelateToVertex(fVertex, kBz, kVeryBig);
480       HLTInfo("1-------: alpha %f, x %f, y %f, z %f, snp %f, tgl %f, 1pt %f",track->GetAlpha(),track->GetX(),track->GetY(),track->GetZ(),track->GetSnp(),track->GetTgl(),track->GetSigned1Pt());
481     }
482
483     //
484     // the same procedure must be repeated for TPCinner (TPC only) tracks
485     //
486     AliExternalTrackParam *tpcTrack = (AliExternalTrackParam *)track->GetTPCInnerParam();
487     if(!tpcTrack) continue;
488
489     // propagate tpcTracks to small radius (material budget included)
490     isOK = AliTracker::PropagateTrackTo(tpcTrack,kSmallRadius,track->GetMass(),kMaxStep,kFALSE);
491
492     // relate tracks to DCA to primary vertex
493     if(isOK) 
494     {
495       Double_t par[2], cov[3];
496       tpcTrack->PropagateToDCA(fVertex, kBz, kVeryBig,par,cov);
497       HLTInfo("2-------: alpha %f, x %f, y %f, z %f, snp %f, tgl %f, 1pt %f",tpcTrack->GetAlpha(),tpcTrack->GetX(),tpcTrack->GetY(),tpcTrack->GetZ(),tpcTrack->GetSnp(),tpcTrack->GetTgl(),tpcTrack->GetSigned1Pt());
498     }
499   }
500 }