style changes
[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliTPCtrackerCA.cxx
1 // $Id$
2 // **************************************************************************
3 // This file is property of and copyright by the ALICE HLT Project          *
4 // ALICE Experiment at CERN, All rights reserved.                           *
5 //                                                                          *
6 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
7 //                  Ivan Kisel <kisel@kip.uni-heidelberg.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
20 #include "AliTPCtrackerCA.h"
21
22 #include "TTree.h"
23 #include "Riostream.h"
24 //#include "AliCluster.h"
25 #include "AliTPCClustersRow.h"
26 #include "AliTPCParam.h"
27 #include "AliTPCClusterParam.h"
28
29 #include "AliRun.h"
30 #include "AliRunLoader.h"
31 #include "AliStack.h"
32
33 #include "AliHLTTPCCAPerformance.h"
34 #include "AliHLTTPCCAParam.h"
35 #include "AliHLTTPCCATrackConvertor.h"
36 #include "AliHLTTPCCATracker.h"
37 #include "AliHLTTPCCAStandaloneFramework.h"
38
39 #include "TMath.h"
40 #include "AliTPCLoader.h"
41 #include "AliTPC.h"
42 #include "AliTPCclusterMI.h"
43 #include "AliTPCTransform.h"
44 #include "AliTPCcalibDB.h"
45 #include "AliTPCtrack.h"
46 #include "AliTPCseed.h"
47 #include "AliESDtrack.h"
48 #include "AliESDEvent.h"
49 #include "AliTrackReference.h"
50 #include "TStopwatch.h"
51 #include "AliTPCReconstructor.h"
52 #include "AliHLTTPCCAMergerOutput.h"
53
54 //#include <fstream.h>
55
56 ClassImp( AliTPCtrackerCA )
57
58 AliTPCtrackerCA::AliTPCtrackerCA()
59     : AliTracker(), fkParam( 0 ), fClusters( 0 ), fClusterSliceRow( 0 ), fNClusters( 0 ), fDoHLTPerformance( 0 ), fDoHLTPerformanceClusters( 0 ), fStatCPUTime( 0 ), fStatRealTime( 0 ), fStatNEvents( 0 )
60 {
61   //* default constructor
62 }
63
64 AliTPCtrackerCA::AliTPCtrackerCA( const AliTPCtrackerCA & ):
65     AliTracker(), fkParam( 0 ), fClusters( 0 ), fClusterSliceRow( 0 ), fNClusters( 0 ), fDoHLTPerformance( 0 ), fDoHLTPerformanceClusters( 0 ), fStatCPUTime( 0 ), fStatRealTime( 0 ), fStatNEvents( 0 )
66 {
67   //* dummy
68 }
69
70 const AliTPCtrackerCA & AliTPCtrackerCA::operator=( const AliTPCtrackerCA& ) const
71 {
72   //* dummy
73   return *this;
74 }
75
76
77 AliTPCtrackerCA::~AliTPCtrackerCA()
78 {
79   //* destructor
80   delete[] fClusters;
81   delete[] fClusterSliceRow;
82 }
83
84 //#include "AliHLTTPCCADisplay.h"
85
86 AliTPCtrackerCA::AliTPCtrackerCA( const AliTPCParam *par ):
87     AliTracker(), fkParam( par ), fClusters( 0 ), fClusterSliceRow( 0 ), fNClusters( 0 ), fDoHLTPerformance( 0 ), fDoHLTPerformanceClusters( 0 ), fStatCPUTime( 0 ), fStatRealTime( 0 ), fStatNEvents( 0 )
88 {
89   //* constructor
90
91   fDoHLTPerformance = 1;
92   fDoHLTPerformanceClusters = 1;
93
94   AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
95
96
97   for ( int iSlice = 0; iSlice < hlt.NSlices(); iSlice++ ) {
98
99     const double kCLight = 0.000299792458;
100
101     float bz = AliTracker::GetBz() * kCLight;
102
103     float inRmin = fkParam->GetInnerRadiusLow();
104     //float inRmax = fkParam->GetInnerRadiusUp();
105     //float outRmin = fkParam->GetOuterRadiusLow();
106     float outRmax = fkParam->GetOuterRadiusUp();
107     float plusZmin = 0.0529937;
108     float plusZmax = 249.778;
109     float minusZmin = -249.645;
110     float minusZmax = -0.0799937;
111     float dalpha = 0.349066;
112     float alpha = 0.174533 + dalpha * iSlice;
113
114     bool zPlus = ( iSlice < 18 );
115     float zMin =  zPlus ? plusZmin : minusZmin;
116     float zMax =  zPlus ? plusZmax : minusZmax;
117     //TPCZmin = -249.645, ZMax = 249.778
118     //float rMin =  inRmin;
119     //float rMax =  outRmax;
120
121     float padPitch = 0.4;
122     float sigmaZ = 0.228808;
123
124     int nRows = fkParam->GetNRowLow() + fkParam->GetNRowUp();
125     float rowX[200];
126     for ( int irow = 0; irow < fkParam->GetNRowLow(); irow++ ) {
127       rowX[irow] = fkParam->GetPadRowRadiiLow( irow );
128     }
129     for ( int irow = 0; irow < fkParam->GetNRowUp(); irow++ ) {
130       rowX[fkParam->GetNRowLow()+irow] = fkParam->GetPadRowRadiiUp( irow );
131     }
132     AliHLTTPCCAParam param;
133     param.Initialize( iSlice, nRows, rowX, alpha, dalpha,
134                       inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, bz );
135     param.SetHitPickUpFactor( 1. );
136     param.SetMaxTrackMatchDRow( 5 );
137     param.SetTrackConnectionFactor( 3.5 );
138
139     AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
140     for ( int iRow = 0; iRow < nRows; iRow++ ) {
141       int    type = ( iRow < 63 ) ? 0 : ( ( iRow > 126 ) ? 1 : 2 );
142       for ( int iyz = 0; iyz < 2; iyz++ ) {
143         for ( int k = 0; k < 7; k++ ) {
144           //std::cout<<param.fParamS0Par[iyz][type][k]<<" "<<clparam->fParamS0Par[iyz][type][k] - param.fParamS0Par[iyz][type][k]<<std::endl;
145           param.SetParamS0Par( iyz, type, k, clparam->fParamS0Par[iyz][type][k] );
146         }
147       }
148     }
149     hlt.SliceTracker( iSlice ).Initialize( param );
150   }
151 }
152
153
154
155 int AliTPCtrackerCA::LoadClusters ( TTree * fromTree )
156 {
157   // load clusters to the local arrays
158   fNClusters = 0;
159   delete[] fClusters;
160   delete[] fClusterSliceRow;
161
162   AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
163
164   if ( fDoHLTPerformance ) {
165     AliHLTTPCCAPerformance::Instance().StartEvent();
166     if ( fDoHLTPerformanceClusters ) AliHLTTPCCAPerformance::Instance().SetDoClusterPulls( 1 );
167   }
168
169   if ( !fkParam ) return 1;
170
171   // load mc tracks
172   while ( fDoHLTPerformance ) {
173     if ( !gAlice ) break;
174     AliRunLoader *rl = AliRunLoader::Instance();//gAlice->GetRunLoader();
175     if ( !rl ) break;
176     rl->LoadKinematics();
177     AliStack *stack = rl->Stack();
178     if ( !stack ) break;
179
180     AliHLTTPCCAPerformance::Instance().SetNMCTracks( stack->GetNtrack() );
181
182     for ( int itr = 0; itr < stack->GetNtrack(); itr++ ) {
183       TParticle *part = stack->Particle( itr );
184       AliHLTTPCCAPerformance::Instance().ReadMCTrack( itr, part );
185     }
186
187     { // check for MC tracks at the TPC entrance
188
189       bool *isTPC = 0;
190       isTPC = new bool [stack->GetNtrack()];
191       for ( int i = 0; i < stack->GetNtrack(); i++ ) isTPC[i] = 0;
192       rl->LoadTrackRefs();
193       TTree *mcTree = rl->TreeTR();
194       if ( !mcTree ) break;
195       TBranch *branch = mcTree->GetBranch( "TrackReferences" );
196       if ( !branch ) break;
197       TClonesArray tpcdummy( "AliTrackReference", 1000 ), *tpcRefs = &tpcdummy;
198       branch->SetAddress( &tpcRefs );
199       int nr = ( int )mcTree->GetEntries();
200       for ( int r = 0; r < nr; r++ ) {
201         mcTree->GetEvent( r );
202         int nref = tpcRefs->GetEntriesFast();
203         if ( !nref ) continue;
204         AliTrackReference *tpcRef = 0x0;
205         for ( int iref = 0; iref < nref; ++iref ) {
206           tpcRef = ( AliTrackReference* )tpcRefs->UncheckedAt( iref );
207           if ( tpcRef->DetectorId() == AliTrackReference::kTPC ) break;
208           tpcRef = 0x0;
209         }
210         if ( !tpcRef ) continue;
211
212         if ( isTPC[tpcRef->Label()] ) continue;
213
214         AliHLTTPCCAPerformance::Instance().ReadMCTPCTrack( tpcRef->Label(),
215             tpcRef->X(), tpcRef->Y(), tpcRef->Z(),
216             tpcRef->Px(), tpcRef->Py(), tpcRef->Pz() );
217         isTPC[tpcRef->Label()] = 1;
218         tpcRefs->Clear();
219       }
220       if ( isTPC ) delete[] isTPC;
221     }
222
223     while ( fDoHLTPerformanceClusters ) {
224       AliTPCLoader *tpcl = ( AliTPCLoader* ) rl->GetDetectorLoader( "TPC" );
225       if ( !tpcl ) break;
226       if ( tpcl->TreeH() == 0x0 ) {
227         if ( tpcl->LoadHits() ) break;
228       }
229       if ( tpcl->TreeH() == 0x0 ) break;
230
231       AliTPC *tpc = ( AliTPC* ) gAlice->GetDetector( "TPC" );
232       int nEnt = ( int )tpcl->TreeH()->GetEntries();
233       int nPoints = 0;
234       for ( int iEnt = 0; iEnt < nEnt; iEnt++ ) {
235         tpc->ResetHits();
236         tpcl->TreeH()->GetEvent( iEnt );
237         AliTPChit *phit = ( AliTPChit* )tpc->FirstHit( -1 );
238         for ( ; phit; phit = ( AliTPChit* )tpc->NextHit() ) nPoints++;
239       }
240       AliHLTTPCCAPerformance::Instance().SetNMCPoints( nPoints );
241
242       for ( int iEnt = 0; iEnt < nEnt; iEnt++ ) {
243         tpc->ResetHits();
244         tpcl->TreeH()->GetEvent( iEnt );
245         AliTPChit *phit = ( AliTPChit* )tpc->FirstHit( -1 );
246         for ( ; phit; phit = ( AliTPChit* )tpc->NextHit() ) {
247           AliHLTTPCCAPerformance::Instance().ReadMCPoint( phit->GetTrack(), phit->X(), phit->Y(), phit->Z(), phit->Time(), phit->fSector % 36 );
248         }
249       }
250       break;
251     }
252     break;
253   }
254
255   TBranch * br = fromTree->GetBranch( "Segment" );
256   if ( !br ) return 1;
257
258   AliTPCClustersRow *clrow = new AliTPCClustersRow;
259   clrow->SetClass( "AliTPCclusterMI" );
260   clrow->SetArray( 0 );
261   clrow->GetArray()->ExpandCreateFast( 10000 );
262
263   br->SetAddress( &clrow );
264
265   //
266   int nEnt = int( fromTree->GetEntries() );
267
268   fNClusters = 0;
269   for ( int i = 0; i < nEnt; i++ ) {
270     br->GetEntry( i );
271     int sec, row;
272     fkParam->AdjustSectorRow( clrow->GetID(), sec, row );
273     fNClusters += clrow->GetArray()->GetEntriesFast();
274   }
275
276   fClusters = new AliTPCclusterMI [fNClusters];
277   fClusterSliceRow = new unsigned int [fNClusters];
278
279   hlt.StartDataReading( fNClusters );
280
281   if ( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().SetNHits( fNClusters );
282
283   int ind = 0;
284   for ( int i = 0; i < nEnt; i++ ) {
285     br->GetEntry( i );
286     int sec, row;
287     fkParam->AdjustSectorRow( clrow->GetID(), sec, row );
288     int nClu = clrow->GetArray()->GetEntriesFast();
289     float x = fkParam->GetPadRowRadii( sec, row );
290
291     if ( sec >= 36 ) {
292       sec = sec - 36;
293       row = row + fkParam->GetNRowLow();
294     }
295
296     unsigned int sliceRow = ( sec << 8 ) + row;
297
298     for ( int icl = 0; icl < nClu; icl++ ) {
299       int lab0 = -1;
300       int lab1 = -1;
301       int lab2 = -1;
302       AliTPCclusterMI* cluster = ( AliTPCclusterMI* )( clrow->GetArray()->At( icl ) );
303       if ( !cluster ) continue;
304       lab0 = cluster->GetLabel( 0 );
305       lab1 = cluster->GetLabel( 1 );
306       lab2 = cluster->GetLabel( 2 );
307
308       AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
309       if ( !transform ) {
310         AliFatal( "Tranformations not in calibDB" );
311       }
312       double xx[3] = {cluster->GetRow(), cluster->GetPad(), cluster->GetTimeBin()};
313       int id[1] = {cluster->GetDetector()};
314       transform->Transform( xx, id, 0, 1 );
315       //if (!AliTPCReconstructor::GetRecoParam()->GetBYMirror()){
316       //if (cluster->GetDetector()%36>17){
317       //xx[1]*=-1;
318       //}
319       //}
320
321       cluster->SetX( xx[0] );
322       cluster->SetY( xx[1] );
323       cluster->SetZ( xx[2] );
324
325       TGeoHMatrix  *mat = fkParam->GetClusterMatrix( cluster->GetDetector() );
326       double pos[3] = {cluster->GetX(), cluster->GetY(), cluster->GetZ()};
327       double posC[3] = {cluster->GetX(), cluster->GetY(), cluster->GetZ()};
328       if ( mat ) mat->LocalToMaster( pos, posC );
329       else {
330         // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
331       }
332       cluster->SetX( posC[0] );
333       cluster->SetY( posC[1] );
334       cluster->SetZ( posC[2] );
335
336       x = cluster->GetX();
337       float y = cluster->GetY();
338       float z = cluster->GetZ();
339
340
341       int index = ind++;
342       fClusters[index] = *cluster;
343
344       fClusterSliceRow[index] = sliceRow;
345
346       hlt.ReadCluster( index, sec, row, x, y, z, cluster->GetQ() );
347
348       if ( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().ReadHitLabel( index, lab0, lab1, lab2 );
349     }
350   }
351   delete clrow;
352
353   hlt.FinishDataReading();
354
355   //AliHLTTPCCAPerformance::Instance().SmearClustersMC();
356
357   return 0;
358 }
359
360 AliCluster * AliTPCtrackerCA::GetCluster( int index ) const
361 {
362   return &( fClusters[index] );
363 }
364
365 int AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
366 {
367   // reconstruction
368   //cout<<"Start of AliTPCtrackerCA"<<endl;
369   TStopwatch timer;
370
371   AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
372
373   hlt.ProcessEvent();
374
375   if ( event ) {
376
377     const AliHLTTPCCAMergerOutput &hltOut = *( hlt.Merger().Output() );
378
379     for ( int itr = 0; itr < hltOut.NTracks(); itr++ ) {
380
381       AliTPCseed tTPC;
382
383       const AliHLTTPCCAMergedTrack &tCA = hltOut.Track( itr );
384
385       AliHLTTPCCATrackParam par = tCA.InnerParam();
386       AliHLTTPCCATrackConvertor::GetExtParam( par, tTPC, tCA.InnerAlpha() );
387       tTPC.SetMass( 0.13957 );
388       if ( TMath::Abs( tTPC.GetSigned1Pt() ) > 1. / 0.02 ) continue;
389       int nhits = tCA.NClusters();
390       int firstHit = 0;
391       if ( nhits > 160 ) {
392         firstHit = nhits - 160;
393         nhits = 160;
394       }
395       tTPC.SetNumberOfClusters( nhits );
396       float alpha = tCA.InnerAlpha();
397       AliHLTTPCCATrackParam t0 = par;
398       for ( int ih = 0; ih < nhits; ih++ ) {
399         int index = hltOut.ClusterId( tCA.FirstClusterRef() + firstHit + ih );
400         tTPC.SetClusterIndex( ih, index );
401         AliTPCclusterMI *c = &( fClusters[index] );
402         int iSlice = fClusterSliceRow[index] >> 8;
403         int row = fClusterSliceRow[index] & 0xff;
404
405         tTPC.SetClusterPointer( row, c );
406         AliTPCTrackerPoint &point = *( tTPC.GetTrackPoint( row ) );
407         {
408           AliHLTTPCCATracker &slice = hlt.SliceTracker( iSlice );
409           if ( slice.Param().Alpha() != alpha ) {
410             if ( ! t0.Rotate(  slice.Param().Alpha() - alpha, .999 ) ) continue;
411             alpha = slice.Param().Alpha();
412           }
413           float x = slice.Row( row ).X();
414           if ( !t0.TransportToX( x, slice.Param().GetBz( t0 ), .999 ) ) continue;
415           float sy2, sz2;
416           slice.GetErrors2( row, t0, sy2, sz2 );
417           point.SetSigmaY( c->GetSigmaY2() / sy2 );
418           point.SetSigmaZ( c->GetSigmaZ2() / sz2 );
419           point.SetAngleY( TMath::Abs( t0.GetSinPhi() / t0.GetCosPhi() ) );
420           point.SetAngleZ( TMath::Abs( t0.GetDzDs() ) );
421         }
422       }
423       tTPC.CookdEdx( 0.02, 0.6 );
424
425       CookLabel( &tTPC, 0.1 );
426
427       if ( 1 ) { // correction like in off-line --- Adding systematic error
428
429         const double *param = AliTPCReconstructor::GetRecoParam()->GetSystematicError();
430         double covar[15];
431         for ( int i = 0; i < 15; i++ ) covar[i] = 0;
432         covar[0] = param[0] * param[0];
433         covar[2] = param[1] * param[1];
434         covar[5] = param[2] * param[2];
435         covar[9] = param[3] * param[3];
436         double facC =  AliTracker::GetBz() * kB2C;
437         covar[14] = param[4] * param[4] * facC * facC;
438         tTPC.AddCovariance( covar );
439       }
440
441       AliESDtrack tESD;
442       tESD.UpdateTrackParams( &( tTPC ), AliESDtrack::kTPCin );
443       //tESD.SetStatus( AliESDtrack::kTPCrefit );
444       //tESD.SetTPCPoints(tTPC.GetPoints());
445       int   ndedx = tTPC.GetNCDEDX( 0 );
446       float sdedx = tTPC.GetSDEDX( 0 );
447       float dedx  = tTPC.GetdEdx();
448       tESD.SetTPCsignal( dedx, sdedx, ndedx );
449       //tESD.myTPC = tTPC;
450
451       event->AddTrack( &tESD );
452     }
453   }
454
455
456   timer.Stop();
457
458   fStatCPUTime += timer.CpuTime();
459   fStatRealTime += timer.RealTime();
460
461   //cout << "\n\nCA tracker speed: cpu = " << fStatCPUTime / ( fStatNEvents + 1 )*1.e3 << " [ms/ev], real = " << fStatRealTime / ( fStatNEvents + 1 )*1.e3 << " [ms/ev], n calls = " << ( fStatNEvents + 1 ) << endl << endl;
462
463
464   //cout<<"Do performance.."<<endl;
465
466   if ( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().Performance();
467
468   if ( 0 ) {// Write Event
469     if ( fStatNEvents == 0 ) {
470       fstream geo;
471       geo.open( "CAEvents/settings.dat", ios::out );
472       if ( geo.is_open() ) {
473         hlt.WriteSettings( geo );
474       }
475       geo.close();
476     }
477
478     fstream hits;
479     char name[255];
480     sprintf( name, "CAEvents/%i.event.dat", fStatNEvents );
481     hits.open( name, ios::out );
482     if ( hits.is_open() ) {
483       hlt.WriteEvent( hits );
484       fstream tracks;
485       sprintf( name, "CAEvents/%i.tracks.dat", fStatNEvents );
486       tracks.open( name, ios::out );
487       hlt.WriteTracks( tracks );
488     }
489     hits.close();
490     if ( fDoHLTPerformance ) {
491       fstream mcevent, mcpoints;
492       char mcname[255];
493       sprintf( mcname, "CAEvents/%i.mcevent.dat", fStatNEvents );
494       mcevent.open( mcname, ios::out );
495       if ( mcevent.is_open() ) {
496         AliHLTTPCCAPerformance::Instance().WriteMCEvent( mcevent );
497       }
498       if ( 1 && fDoHLTPerformanceClusters ) {
499         sprintf( mcname, "CAEvents/%i.mcpoints.dat", fStatNEvents );
500         mcpoints.open( mcname, ios::out );
501         if ( mcpoints.is_open() ) {
502           AliHLTTPCCAPerformance::Instance().WriteMCPoints( mcpoints );
503         }
504         mcpoints.close();
505       }
506       mcevent.close();
507     }
508   }
509
510   fStatNEvents++;
511
512
513   //cout<<"End of AliTPCtrackerCA"<<endl;
514   return 0;
515 }
516
517
518 int AliTPCtrackerCA::RefitInward ( AliESDEvent *event )
519 {
520   //* forward propagation of ESD tracks
521
522   float xTPC = fkParam->GetInnerRadiusLow();
523   float dAlpha = fkParam->GetInnerAngle() / 180.*TMath::Pi();
524   float yMax = xTPC * TMath::Tan( dAlpha / 2. );
525
526   AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
527
528   int nentr = event->GetNumberOfTracks();
529
530   for ( int itr = 0; itr < nentr; itr++ ) {
531     AliESDtrack *esd = event->GetTrack( itr );
532     ULong_t status = esd->GetStatus();
533     if ( !( status&AliESDtrack::kTPCin ) ) continue;
534     AliHLTTPCCATrackParam t0;
535     AliHLTTPCCATrackConvertor::SetExtParam( t0, *esd );
536     AliHLTTPCCATrackParam t = t0;
537     float alpha = esd->GetAlpha();
538     //float dEdX=0;
539     AliHLTTPCCAMerger::AliHLTTPCCAClusterInfo infos[500];
540     int hits[500], hits1[500];
541     int nHits = esd->GetTPCclusters( hits );
542     for ( int i = 0; i < nHits; i++ ) {
543       hits1[i] = i;
544       int index = hits[i];
545       infos[i].SetISlice( fClusterSliceRow[index] >> 8 );
546       infos[i].SetX( fClusters[index].GetX() );
547       infos[i].SetY( fClusters[index].GetY() );
548       infos[i].SetZ( fClusters[index].GetZ() );
549     }
550
551     bool ok = hlt.Merger().FitTrack( t, alpha, t0, alpha, hits1, nHits, 0, infos );
552
553     if ( ok &&  nHits > 15 ) {
554       if ( t.TransportToXWithMaterial( xTPC, hlt.Merger().SliceParam().GetBz( t ) ) ) {
555         if ( t.GetY() > yMax ) {
556           if ( t.Rotate( dAlpha ) ) {
557             alpha += dAlpha;
558             t.TransportToXWithMaterial( xTPC, hlt.Merger().SliceParam().GetBz( t ) );
559           }
560         } else if ( t.GetY() < -yMax ) {
561           if ( t.Rotate( -dAlpha ) ) {
562             alpha += -dAlpha;
563             t.TransportToXWithMaterial( xTPC, hlt.Merger().SliceParam().GetBz( t ) );
564           }
565         }
566       }
567
568       AliTPCtrack tt( *esd );
569       if ( AliHLTTPCCATrackConvertor::GetExtParam( t, tt, alpha ) ) {
570         if ( t.X() > 50 ) esd->UpdateTrackParams( &tt, AliESDtrack::kTPCrefit );
571       }
572     }
573   }
574   return 0;
575 }
576
577 int AliTPCtrackerCA::PropagateBack( AliESDEvent *event )
578 {
579
580   //* backward propagation of ESD tracks
581
582   AliHLTTPCCAStandaloneFramework &hlt = AliHLTTPCCAStandaloneFramework::Instance();
583
584   int nentr = event->GetNumberOfTracks();
585
586   for ( int itr = 0; itr < nentr; itr++ ) {
587
588     AliESDtrack *esd = event->GetTrack( itr );
589     ULong_t status = esd->GetStatus();
590     if ( !( status&AliESDtrack::kTPCin ) ) continue;
591
592     AliHLTTPCCATrackParam t0;
593     AliHLTTPCCATrackConvertor::SetExtParam( t0, *esd  );
594     AliHLTTPCCATrackParam t = t0;
595     float alpha = esd->GetAlpha();
596     //float dEdX=0;
597     AliHLTTPCCAMerger::AliHLTTPCCAClusterInfo infos[500];
598     int hits[500], hits1[500];
599     int nHits = esd->GetTPCclusters( hits );
600     for ( int i = 0; i < nHits; i++ ) {
601       hits1[i] = i;
602       int index = hits[i];
603       infos[i].SetISlice( fClusterSliceRow[index] >> 8 );
604       infos[i].SetX( fClusters[index].GetX() );
605       infos[i].SetY( fClusters[index].GetY() );
606       infos[i].SetZ( fClusters[index].GetZ() );
607     }
608
609     bool ok = hlt.Merger().FitTrack( t, alpha, t0, alpha, hits1, nHits, 1, infos );
610
611     if ( ok &&  nHits > 15 ) {
612       AliTPCtrack tt( *esd );
613       if ( AliHLTTPCCATrackConvertor::GetExtParam( t, tt, alpha ) ) {
614         if ( t.X() > 50 ) esd->UpdateTrackParams( &tt, AliESDtrack::kTPCout );
615       }
616     }
617   }
618   return 0;
619 }