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