excluding deprecated classes from build
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCTrackArray.cxx
1 // @(#) $Id$
2 // Original: AliHLTTrackArray.cxx,v 1.21 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: Uli Frankenfeld, 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   AliHLTTPCTrackArray.cxx
22     @author Uli Frankenfeld, maintained by Matthias Richter
23     @date   
24     @brief  Array of AliHLTTPCTracks */
25
26 #include "AliLog.h"
27 #include "TClass.h"
28 #include "AliHLTTPCLogging.h"
29 #include "AliHLTTPCTrackArray.h"
30 // Matthias 17.10.2007 the hough code has been disabled for the moment
31 //#define INCLUDE_TPC_HOUGH
32 #ifdef INCLUDE_TPC_HOUGH
33 #include "AliHLTTPCHoughTrack.h"
34 #endif
35 #include "AliHLTTPCModelTrack.h"
36 #include "AliHLTTPCConfMapTrack.h"
37 #include "AliHLTTPCTrackSegmentData.h"
38 #include "AliHLTTPCTransform.h"
39 #include "AliHLTTPCConfMapPoint.h"
40 #include "AliHLTExternalTrackParam.h"
41
42 #if __GNUC__ >= 3
43 using namespace std;
44 #endif
45
46 ClassImp(AliHLTTPCTrackArray)
47
48 AliHLTTPCTrackArray::AliHLTTPCTrackArray()
49   :
50   fTrackType('t'),
51   fSize(0),
52   fIsPresent(NULL),
53   fNAbsent(0),
54   fTrack(NULL),
55   fNTracks(0)
56 {
57   //Default constructor
58   SetSize();
59 }
60
61
62 AliHLTTPCTrackArray::AliHLTTPCTrackArray(Int_t ntrack)
63   :
64   fTrackType('t'),
65   fSize(0),
66   fIsPresent(NULL),
67   fNAbsent(0),
68   fTrack(NULL),
69   fNTracks(0)
70 {
71   //Constructor.
72   SetSize(ntrack);
73 }
74
75 AliHLTTPCTrackArray::AliHLTTPCTrackArray(const char* tracktype,Int_t ntrack)
76   :
77   fTrackType('t'),
78   fSize(0),
79   fIsPresent(NULL),
80   fNAbsent(0),
81   fTrack(NULL),
82   fNTracks(0)
83 {
84   //Constructor.
85   if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
86   if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
87 #ifdef INCLUDE_TPC_HOUGH
88   if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
89 #endif
90   if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
91   SetSize(ntrack);
92 }
93
94 AliHLTTPCTrackArray::AliHLTTPCTrackArray(const char* tracktype)
95   :
96   fTrackType('t'),
97   fSize(0),
98   fIsPresent(NULL),
99   fNAbsent(0),
100   fTrack(NULL),
101   fNTracks(0)
102 {
103   //Constructor.
104   if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
105   if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
106 #ifdef INCLUDE_TPC_HOUGH
107   if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
108 #endif
109   if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
110   SetSize();
111 }
112
113 AliHLTTPCTrackArray::~AliHLTTPCTrackArray()
114 {
115   //Destructor
116   DeleteArray();
117 }
118
119
120 AliHLTTPCTrack *AliHLTTPCTrackArray::NextTrack()
121 {
122   //next track in array
123   if(fNTracks<fSize) return fTrack[fNTracks++];
124   SetSize(fSize+100);
125    return fTrack[fNTracks++]; 
126 }
127
128 void AliHLTTPCTrackArray::DeleteArray()
129 {
130   //delete array
131   for(Int_t i=0; i<fSize;i++)
132     delete fTrack[i];
133   delete[] fIsPresent;
134   delete[] fTrack;
135   fSize=0;
136 }
137
138 Bool_t AliHLTTPCTrackArray::SetSize(Int_t newsize)
139 {
140   //set size
141   if(newsize<=fSize) return kFALSE; //shrink comes later!! 
142   if(!fSize){
143     fSize = newsize;
144     fTrack = new AliHLTTPCTrack*[fSize];
145     fIsPresent = new Bool_t[fSize];
146     switch(fTrackType){
147       case 't':
148         for(Int_t i=0;i<fSize;i++){
149           fTrack[i]   = new AliHLTTPCTrack();
150           fIsPresent[i] = kTRUE;
151         }
152         break;
153       case 'c':  
154         for(Int_t i=0;i<fSize;i++){
155           fTrack[i]   = new AliHLTTPCConfMapTrack();
156           fIsPresent[i] = kTRUE;
157         }
158         break;
159 #ifdef INCLUDE_TPC_HOUGH
160       case 'h':
161         for(Int_t i=0;i<fSize;i++){
162           fTrack[i]   = new AliHLTTPCHoughTrack();
163           fIsPresent[i] = kTRUE;
164         }
165         break;
166 #endif
167        case 'm':
168         for(Int_t i=0;i<fSize;i++){
169           fTrack[i]   = new AliHLTTPCModelTrack();
170           fIsPresent[i] = kTRUE;
171         }
172         break;
173       default: 
174         return kFALSE;
175     }
176     return kTRUE;
177   }
178   AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[fSize];
179   Bool_t *pre = new Bool_t[fSize];
180   for(Int_t i=0; i<fSize;i++){
181     tmp[i] = fTrack[i];
182     pre[i] = fIsPresent[i];
183   }
184   delete[]  fTrack;
185   delete[] fIsPresent;
186   fTrack =  new AliHLTTPCTrack*[newsize];
187   fIsPresent = new Bool_t[newsize];
188   for(Int_t i=0; i<fSize;i++){
189     fTrack[i]   = tmp[i];
190     fIsPresent[i] = pre[i];
191   }
192   delete[] tmp;
193   delete[] pre;
194   switch(fTrackType){
195     case 't':
196       for(Int_t i=fSize;i<newsize;i++){
197         fTrack[i]   = new AliHLTTPCTrack();
198         fIsPresent[i] = kTRUE;
199       }
200       break;
201     case 'c':  
202       for(Int_t i=fSize;i<newsize;i++){
203         fTrack[i]   = new AliHLTTPCConfMapTrack();
204         fIsPresent[i] = kTRUE;
205       }
206       break;
207 #ifdef INCLUDE_TPC_HOUGH
208     case 'h':
209       for(Int_t i=fSize;i<newsize;i++){
210         fTrack[i]   = new AliHLTTPCHoughTrack();
211         fIsPresent[i] = kTRUE;
212       }
213       break;
214 #endif
215     case 'm':
216       for(Int_t i=fSize;i<newsize;i++){
217         fTrack[i]   = new AliHLTTPCModelTrack();
218         fIsPresent[i] = kTRUE;
219       }
220       break;
221     default: 
222       return kFALSE;
223   }
224   fSize = newsize;
225   return kTRUE;
226 }
227
228 void AliHLTTPCTrackArray::Reset()
229 {
230   //reset
231   fNTracks=0;
232   fNAbsent=0;
233   for(Int_t i=0; i<fSize;i++)
234     fIsPresent[i] = kTRUE; 
235 }
236
237 void AliHLTTPCTrackArray::Remove(Int_t track)
238 {
239   //remove track
240   if(fIsPresent[track]){
241     fIsPresent[track]=kFALSE;
242     fNAbsent++;
243   }
244 }
245
246 int AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr, Int_t slice, Int_t bTransform)
247 {
248   //Read tracks from shared memory (or memory)
249   return FillTracksChecked(tr, ntracks, 0, slice, bTransform);
250 }
251
252 int AliHLTTPCTrackArray::FillTracksChecked(AliHLTExternalTrackParam* tr, Int_t ntracks, unsigned int sizeInByte, Int_t slice, Int_t bTransform)
253 {
254   int iResult=0;
255   AliHLTExternalTrackParam *trs = tr;
256   
257   for(Int_t i=0; i<ntracks; i++){
258     if (sizeInByte>0 && 
259         (((AliHLTUInt8_t*)trs)+sizeof(AliHLTExternalTrackParam)>((AliHLTUInt8_t*)tr)+sizeInByte ||
260          ((AliHLTUInt8_t*)trs)+sizeof(AliHLTExternalTrackParam)+trs->fNPoints*sizeof(UInt_t)>((AliHLTUInt8_t*)tr)+sizeInByte)) {
261       iResult=-EDOM;
262       break;
263     }
264     AliHLTTPCTrack *track = NextTrack(); 
265     track->SetId( i );
266     track->SetPt(trs->fq1Pt);
267     track->SetPterr(trs->fC[14]);
268     Float_t psi[1];
269     psi[0]=trs->fSinPsi;
270     if (slice>=0 && bTransform!=0)  {
271       AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
272     }
273     //cout << "psi " << psi[0] << endl;
274     track->SetPsi(psi[0]);
275     track->SetTgl(trs->fTgl);
276     track->SetPsierr(trs->fC[5]);
277     track->SetTglerr(trs->fC[9]);
278     track->SetY0err(trs->fC[0]);
279     track->SetZ0err(trs->fC[2]);
280     track->SetNHits(trs->fNPoints);
281     //track->SetCharge(trs->fCharge);
282     Float_t first[3];
283     first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
284     if (slice>=0 && bTransform!=0)  {
285       AliHLTTPCTransform::Local2Global(first,slice);
286     }
287     //cout << "first point: " << first[0] << " " << first[1] << " " << first[3] << endl;
288     track->SetFirstPoint(first[0],first[1],first[2]);
289     Float_t last[3];
290     last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
291     if (slice>=0 && bTransform!=0)  {
292       AliHLTTPCTransform::Local2Global(last,slice);
293     }
294     //cout << "last point: " << last[0] << " " << last[1] << " " << last[3] << endl;
295     track->SetLastPoint(last[0],last[1],last[2]);
296     track->SetHits( trs->fNPoints, trs->fPointIDs );
297
298     //if (slice>=0 && bTransform!=0)  {
299       // Matthias Feb07: as everything is now in global coordinates, sector should
300       // be set to 0. But as the display does a check on the sector, we have to set
301       // it to the slice no. I suspect, that the transformation is done twice.
302       //track->SetSector(0);
303     
304       track->SetSector(slice);
305     
306     //} else {
307       // the parameters are in local coordinates, set the sector no
308       //#ifndef INCLUDE_TPC_HOUGH
309       //if (slice<0) track->SetSector(0);
310       //else track->SetSector(slice);
311       //#else 
312       // Matthias Feb 2007: this is some kind of legacy ...
313       // the INCLUDE_TPC_HOUGH has never been switched on in the new TPCLib
314       // and this line was below in the corresponding block. As the slice
315       // parameter is very useful but not available if the define is off
316       // we distinguish the two cases here. Should be cleaned up.
317       // Matthias April 2007: update, try to integrate Cvetans Hough tracker
318       // so we need the support for the AliHLTTPCHoughTrack. I dont have the
319       // full control of this code (should we use slice or trs->fSector?)
320       // But the FillTracks method is never called from the hough code, so we
321       // take 'slice'
322       if (GetTrackType()=='h') {
323         AliErrorClassStream() << "FillTracks was never used with AliHLTTPCHoughTrack:" 
324                            << " CHECK THIS CODE!!!" << endl;
325       }
326       //track->SetSector(trs->fSector);
327       //#endif // INCLUDE_TPC_HOUGH
328       //}
329
330     // this is currently a quick hack for straight lines of the first version 
331     // of the CA tracker.
332     // we have to think about a more general way of treating straight and curved
333     // tracks
334     if ( trs->fq1Pt == -9876.0 ||  trs->fq1Pt == -1.0) {
335       track->SetPhi0(atan2(first[1],first[0]));
336       track->SetKappa(1.0);
337       track->SetRadius(999999.0);
338     } else {
339       // Matthias Feb07: just tried to take this away, but this causes the tracks
340       // in the display not to be drawn. But we still have to tink about this.
341       track->CalculateHelix();
342     }
343
344 #ifdef INCLUDE_TPC_HOUGH
345 #ifdef ROWHOUGHPARAMS
346     if(GetTrackType()=='h') {
347       ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
348       ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
349     }
350     track->SetMCid(trs->fTrackID);
351     track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
352     track->SetPID(trs->fPID);
353 #endif
354 #endif // INCLUDE_TPC_HOUGH
355     track->CheckConsistency();
356
357     UChar_t *tmpP = (UChar_t*)trs;
358     tmpP += sizeof(AliHLTExternalTrackParam)+trs->fNPoints*sizeof(UInt_t);
359     trs = (AliHLTExternalTrackParam*)tmpP;
360   }
361   return iResult;
362 }
363
364 int AliHLTTPCTrackArray::FillTracksChecked(AliHLTTPCTrackSegmentData* tr, Int_t ntracks, unsigned int sizeInByte, Int_t slice, Int_t bTransform)
365 {
366   //Read tracks from shared memory (or memory)
367   int iResult=0;
368   AliHLTTPCTrackSegmentData *trs = tr;
369   for(Int_t i=0; i<ntracks; i++){
370     if (sizeInByte>0 && 
371         (((AliHLTUInt8_t*)trs)+sizeof(AliHLTTPCTrackSegmentData)>((AliHLTUInt8_t*)tr)+sizeInByte ||
372          ((AliHLTUInt8_t*)trs)+sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t)>((AliHLTUInt8_t*)tr)+sizeInByte)) {
373       iResult=-EDOM;
374       break;
375     }
376     AliHLTTPCTrack *track = NextTrack(); 
377     track->SetId( i );
378     track->SetPt(trs->fPt);
379     track->SetPterr(trs->fPterr);
380     Float_t psi[1];
381     psi[0]=trs->fPsi;
382     if (slice>=0 && bTransform!=0)  {
383       AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
384     }
385     //cout << "psi " << psi[0] << endl;
386     track->SetPsi(psi[0]);
387     track->SetTgl(trs->fTgl);
388     track->SetPsierr(trs->fPsierr);
389     track->SetTglerr(trs->fTglerr);
390     track->SetY0err(trs->fY0err);
391     track->SetZ0err(trs->fZ0err);
392     track->SetNHits(trs->fNPoints);
393     track->SetCharge(trs->fCharge);
394     Float_t first[3];
395     first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
396     if (slice>=0 && bTransform!=0)  {
397       AliHLTTPCTransform::Local2Global(first,slice);
398     }
399     //cout << "first point: " << first[0] << " " << first[1] << " " << first[3] << endl;
400     track->SetFirstPoint(first[0],first[1],first[2]);
401     Float_t last[3];
402     last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
403     if (slice>=0 && bTransform!=0)  {
404       AliHLTTPCTransform::Local2Global(last,slice);
405     }
406     //cout << "last point: " << last[0] << " " << last[1] << " " << last[3] << endl;
407     track->SetLastPoint(last[0],last[1],last[2]);
408     track->SetHits( trs->fNPoints, trs->fPointIDs );
409
410     //if (slice>=0 && bTransform!=0)  {
411       // Matthias Feb07: as everything is now in global coordinates, sector should
412       // be set to 0. But as the display does a check on the sector, we have to set
413       // it to the slice no. I suspect, that the transformation is done twice.
414       //track->SetSector(0);
415       track->SetSector(slice);
416     //} else {
417       // the parameters are in local coordinates, set the sector no
418       //#ifndef INCLUDE_TPC_HOUGH
419       //if (slice<0) track->SetSector(0);
420       //else track->SetSector(slice);
421       //#else 
422       // Matthias Feb 2007: this is some kind of legacy ...
423       // the INCLUDE_TPC_HOUGH has never been switched on in the new TPCLib
424       // and this line was below in the corresponding block. As the slice
425       // parameter is very useful but not available if the define is off
426       // we distinguish the two cases here. Should be cleaned up.
427       // Matthias April 2007: update, try to integrate Cvetans Hough tracker
428       // so we need the support for the AliHLTTPCHoughTrack. I dont have the
429       // full control of this code (should we use slice or trs->fSector?)
430       // But the FillTracks method is never called from the hough code, so we
431       // take 'slice'
432       if (GetTrackType()=='h') {
433         AliErrorClassStream() << "FillTracks was never used with AliHLTTPCHoughTrack:" 
434                            << " CHECK THIS CODE!!!" << endl;
435       }
436       //track->SetSector(trs->fSector);
437       //#endif // INCLUDE_TPC_HOUGH
438       //}
439
440     // this is currently a quick hack for straight lines of the first version 
441     // of the CA tracker.
442     // we have to think about a more general way of treating straight and curved
443     // tracks
444     if ( trs->fPt == -9876.0 ||  trs->fPt == -1.0) {
445       track->SetPhi0(atan2(first[1],first[0]));
446       track->SetKappa(1.0);
447       track->SetRadius(999999.0);
448     } else {
449       // Matthias Feb07: just tried to take this away, but this causes the tracks
450       // in the display not to be drawn. But we still have to tink about this.
451       track->CalculateHelix();
452     }
453
454 #ifdef INCLUDE_TPC_HOUGH
455 #ifdef ROWHOUGHPARAMS
456     if(GetTrackType()=='h') {
457       ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
458       ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
459     }
460     track->SetMCid(trs->fTrackID);
461     track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
462     track->SetPID(trs->fPID);
463 #endif
464 #endif // INCLUDE_TPC_HOUGH
465     track->CheckConsistency();
466
467     UChar_t *tmpP = (UChar_t*)trs;
468     tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
469     trs = (AliHLTTPCTrackSegmentData*)tmpP;
470   }
471
472   if (iResult==-EDOM) {
473     // try to recover the version 1 struct
474     Reset();
475     if ((iResult=FillTracksVersion1((AliHLTTPCTrackSegmentDataV1*)tr, ntracks, sizeInByte, slice, bTransform))>=0) {
476       LOG(AliHLTTPCLog::kWarning,"AliHLTTPCTrackArray::FillTracks","") << "version 1 track array recoverd (deprecated since r27415)" << ENDLOG;
477     }
478   }
479   if (iResult==-EDOM) {
480     Reset();
481     LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::FillTracks","") << "corrupted input data array" << ENDLOG;
482   }
483
484   return iResult;
485 }
486
487 int AliHLTTPCTrackArray::FillTracksVersion1(AliHLTTPCTrackSegmentDataV1* tr, Int_t ntracks, unsigned int sizeInByte, Int_t slice, Int_t bTransform)
488 {
489   //Read tracks from shared memory (or memory)
490   int iResult=0;
491   AliHLTTPCTrackSegmentDataV1 *trs = tr;
492   for(Int_t i=0; i<ntracks; i++){
493     if (sizeInByte>0 && 
494         (((AliHLTUInt8_t*)trs)+sizeof(AliHLTTPCTrackSegmentDataV1)>((AliHLTUInt8_t*)tr)+sizeInByte ||
495          ((AliHLTUInt8_t*)trs)+sizeof(AliHLTTPCTrackSegmentDataV1)+trs->fNPoints*sizeof(UInt_t)>((AliHLTUInt8_t*)tr)+sizeInByte)) {
496       iResult=-EDOM;
497       break;
498     }
499     AliHLTTPCTrack *track = NextTrack(); 
500     track->SetPt(trs->fPt);
501     track->SetPterr(trs->fPterr);
502     Float_t psi[1];
503     psi[0]=trs->fPsi;
504     if (slice>=0 && bTransform!=0)  {
505       AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
506     }
507     track->SetPsi(psi[0]);
508     track->SetTgl(trs->fTgl);
509     track->SetPsierr(trs->fPsierr);
510     track->SetTglerr(trs->fTglerr);
511     track->SetNHits(trs->fNPoints);
512     track->SetCharge(trs->fCharge);
513     Float_t first[3];
514     first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
515     if (slice>=0 && bTransform!=0)  {
516       AliHLTTPCTransform::Local2Global(first,slice);
517     }
518     track->SetFirstPoint(first[0],first[1],first[2]);
519     Float_t last[3];
520     last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
521     if (slice>=0 && bTransform!=0)  {
522       AliHLTTPCTransform::Local2Global(last,slice);
523     }
524     track->SetLastPoint(last[0],last[1],last[2]);
525     track->SetHits( trs->fNPoints, trs->fPointIDs );
526
527     track->SetSector(slice);
528     if ( trs->fPt == -9876.0 ||  trs->fPt == -1.0) {
529       track->SetPhi0(atan2(first[1],first[0]));
530       track->SetKappa(1.0);
531       track->SetRadius(999999.0);
532     } else {
533       track->CalculateHelix();
534     }
535
536     UChar_t *tmpP = (UChar_t*)trs;
537     tmpP += sizeof(AliHLTTPCTrackSegmentDataV1)+trs->fNPoints*sizeof(UInt_t);
538     trs = (AliHLTTPCTrackSegmentDataV1*)tmpP;
539   }
540   return iResult;
541 }
542
543 UInt_t AliHLTTPCTrackArray::GetOutSize()
544 {
545   //get size for IO
546   UInt_t count = GetOutCount();   //use only present tracks
547   UInt_t tHits = 0;
548   for(Int_t i=0;i<fNTracks;i++){  //loop over all tracks
549     AliHLTTPCTrack *track = GetCheckedTrack(i);  //use only present tracks
550     if(track)                                       //use only present tracks
551       tHits += track->GetNHits();
552   }
553
554   //calculate size of track
555   return count*sizeof(AliHLTTPCTrackSegmentData)+sizeof(UInt_t)*tHits;
556 }
557
558 UInt_t AliHLTTPCTrackArray::WriteTracks(UInt_t & ntracks,AliHLTTPCTrackSegmentData* tr)
559 {
560   //write tracks
561   ntracks = GetOutCount();
562   return WriteTracks(tr);
563 }
564
565 UInt_t AliHLTTPCTrackArray::WriteTracks(AliHLTTPCTrackSegmentData* tr)
566 {
567   //if(GetTrackType()=='c') return WriteConfMapTracks(tr);
568   AliHLTTPCTrackSegmentData *tP = tr;
569   UInt_t *pP;
570   UInt_t size = 0;
571   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
572     AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
573     if(!track) continue;                           //use only present tracks
574     tP->fX = track->GetFirstPointX();
575     tP->fY = track->GetFirstPointY();
576     tP->fZ = track->GetFirstPointZ();
577     tP->fPt = track->GetPt();
578     tP->fPterr = track->GetPterr();
579     tP->fLastX = track->GetLastPointX();
580     tP->fLastY = track->GetLastPointY();
581     tP->fLastZ = track->GetLastPointZ();
582     tP->fPsi = track->GetPsi();
583     tP->fTgl = track->GetTgl();
584     tP->fPsierr = track->GetPsierr();
585     tP->fTglerr = track->GetTglerr();
586     tP->fY0err = track->GetY0err();
587     tP->fZ0err = track->GetZ0err();
588     tP->fCharge = track->GetCharge();
589     tP->fNPoints = track->GetNHits();
590 #ifdef INCLUDE_TPC_HOUGH
591 #ifdef ROWHOUGHPARAMS
592     if(GetTrackType()=='h') {
593       tP->fWeight = ((AliHLTTPCHoughTrack *)track)->GetWeight();
594       tP->fBinX = ((AliHLTTPCHoughTrack *)track)->GetBinX();
595       tP->fBinY = ((AliHLTTPCHoughTrack *)track)->GetBinY();
596       tP->fBinXSize = ((AliHLTTPCHoughTrack *)track)->GetSizeX();
597       tP->fBinYSize = ((AliHLTTPCHoughTrack *)track)->GetSizeY();
598     }
599     tP->fTrackID = track->GetMCid();
600     tP->fRowRange1 = track->GetFirstRow();
601     tP->fRowRange2 = track->GetLastRow();
602     tP->fSector = track->GetSector();
603     tP->fPID = track->GetPID();
604 #endif
605 #endif // INCLUDE_TPC_HOUGH
606     pP = (UInt_t*)track->GetHitNumbers();
607     for (UInt_t j=0;j<tP->fNPoints;j++){
608       tP->fPointIDs[j] = pP[j];
609     }
610     Byte_t *tmpP = (Byte_t *)tP;
611     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
612     size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
613     tP = (AliHLTTPCTrackSegmentData*)tmpP;
614
615 //    LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::WriteTracks","TRACKPARAMETER") <<ENDLOG;
616 //    track->Rotate(0,kFALSE);
617 //    track->Print();
618
619   }
620   return size;
621 }
622
623 UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
624 {
625   // use first and last point objects
626   AliHLTTPCTrackSegmentData *tP = tr;
627   UInt_t *pP;
628   UInt_t size = 0;
629   for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
630     AliHLTTPCConfMapTrack *track =(AliHLTTPCConfMapTrack *) GetCheckedTrack(i); //use only present tracks
631     if(!track) continue;                           //use only present tracks
632     AliHLTTPCConfMapPoint *hit = (AliHLTTPCConfMapPoint*)track->GetLastHit();
633     AliHLTTPCConfMapPoint *lastHit = (AliHLTTPCConfMapPoint*)track->GetFirstHit();
634     tP->fX = hit->GetX();
635     tP->fY = hit->GetY();
636     tP->fZ = hit->GetZ();
637     tP->fLastX = lastHit->GetX();
638     tP->fLastY = lastHit->GetY();
639     tP->fLastZ = lastHit->GetZ();
640    
641 //    tP->fX = track->GetFirstPointX();
642 //    tP->fY = track->GetFirstPointY();
643 //    tP->fZ = track->GetFirstPointZ();
644     tP->fPt = track->GetPt();
645     tP->fPterr = track->GetPterr();
646 //    tP->fLastX = track->GetLastPointX();
647 //    tP->fLastY = track->GetLastPointY();
648 //    tP->fLastZ = track->GetLastPointZ();
649     tP->fPsi = track->GetPsi();
650     tP->fTgl = track->GetTgl();
651     tP->fPsierr = track->GetPsierr();
652     tP->fTglerr = track->GetTglerr();
653     tP->fY0err = track->GetY0err();
654     tP->fZ0err = track->GetZ0err();
655     tP->fCharge = track->GetCharge();
656 #ifdef INCLUDE_TPC_HOUGH
657 #ifdef ROWHOUGHPARAMS
658     tP->fTrackID = track->GetMCid();
659     tP->fRowRange1 = track->GetFirstRow();
660     tP->fRowRange2 = track->GetLastRow();
661     tP->fSector = track->GetSector();
662     tP->fPID = track->GetPID();
663 #endif
664 #endif // INCLUDE_TPC_HOUGH
665     tP->fNPoints = track->GetNHits();
666     pP = (UInt_t*)track->GetHitNumbers();
667     for (UInt_t j=0;j<tP->fNPoints;j++){
668       tP->fPointIDs[j] = pP[j];
669     }
670     Byte_t *tmpP = (Byte_t *)tP;
671     tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
672     size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
673     tP = (AliHLTTPCTrackSegmentData*)tmpP;
674   }
675   return size;
676 }
677
678 void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
679 {
680   //add track to last position
681   AliHLTTPCTrack *tpt = NextTrack();
682   tpt->Copy(track);
683   
684 }
685
686 void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
687 {
688   //add tracks
689   if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
690     {
691       LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
692         <<"Bad idea to add tracks of different types"<<ENDLOG;
693       return;
694     }
695   if(fSize < fNTracks+newtrack->GetNPresent())
696     SetSize(fSize+newtrack->GetSize());
697   for(Int_t i =0;i<newtrack->GetNTracks();i++){
698     AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
699     if(!tpt) continue;
700     if(remove_old)
701       newtrack->Remove(i);
702     AliHLTTPCTrack *track = NextTrack();
703     track->Copy(tpt);
704     if(slice>=0)
705       track->Rotate(slice); //Rotate track to global coordinates
706     /*
707       AliHLTTPCTrack *track;
708 #ifdef INCLUDE_TPC_HOUGH
709       if(GetTrackType()=='h')
710       track = (AliHLTTPCHoughTrack*)NextTrack();
711       else
712 #endif
713       track = NextTrack();
714       track->Copy(tpt);
715     */
716   }
717 }
718
719 void AliHLTTPCTrackArray::Compress()
720 {
721   //compress array
722   if(GetNPresent()==GetNTracks()) return;
723   AliHLTTPCTrack **tmp =  new AliHLTTPCTrack *[fNTracks];
724   Int_t present=0;
725   Int_t absent=GetNPresent();
726   for(Int_t i=0;i<GetNTracks();i++){
727     if(fIsPresent[i]) tmp[present++] = fTrack[i];
728     else tmp[absent++] = fTrack[i];
729   }
730   for(Int_t i=0;i<GetNTracks();i++)
731     fIsPresent[i]=kTRUE;
732
733   //Copy pointers back
734   for(Int_t i=0; i<GetNTracks();i++){
735     fTrack[i]=tmp[i];
736   }
737
738   delete[] tmp;
739
740   fNTracks = GetNPresent();
741   fNAbsent = 0;
742 }
743
744 void AliHLTTPCTrackArray::QSort()
745 {
746   // compress and sort
747   Compress();
748   QSort(fTrack,0,fNTracks);
749 }
750
751 void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
752 {
753    // Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
754    // Uses TrackCompare() to compare objects.
755    // Thanks to Root! 
756
757    static AliHLTTPCTrack *tmp;
758    static int i;           // "static" to save stack space
759    int j;
760
761    while (last - first > 1) {
762       i = first;
763       j = last;
764       for (;;) {
765         while (++i < last && TrackCompare(a[i], a[first]) < 0)
766           ;
767         while (--j > first && TrackCompare(a[j], a[first]) > 0)
768           ;
769          if (i >= j)
770             break;
771
772          tmp  = a[i];
773          a[i] = a[j];
774          a[j] = tmp;
775       }
776       if (j == first) {
777          ++first;
778          continue;
779       }
780       tmp = a[first];
781       a[first] = a[j];
782       a[j] = tmp;
783       if (j - first < last - (j + 1)) {
784          QSort(a, first, j);
785          first = j + 1;   // QSort(j + 1, last);
786       } else {
787          QSort(a, j + 1, last);
788          last = j;        // QSort(first, j);
789       }
790    }
791 }
792
793 Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack *a, AliHLTTPCTrack *b) const
794 {
795    // Compare the two tracks.
796   
797   return b->Compare(a);
798   
799   /*
800 #ifdef INCLUDE_TPC_HOUGH
801     if(fTrackType=='h')
802     {
803     AliHLTTPCHoughTrack *tra = (AliHLTTPCHoughTrack*)a;
804     AliHLTTPCHoughTrack *trb = (AliHLTTPCHoughTrack*)b;
805     if(tra->GetWeight() < trb->GetWeight()) return 1;
806     if(tra->GetWeight() > trb->GetWeight()) return -1;
807     }
808     else
809 #endif
810     {
811     if(a->GetNHits() < b->GetNHits()) return 1;
812     if(a->GetNHits() > b->GetNHits()) return -1;
813     }
814     
815     return 0;
816   */
817 }
818
819 AliHLTTPCTrack* AliHLTTPCTrackArray::operator[](int index)
820 {
821   // access operator
822   if (index<fNTracks) return fTrack[index];
823   return NULL;
824 }