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