2 // Original: AliHLTTrackArray.cxx,v 1.21 2005/06/14 10:55:21 cvetan
4 /**************************************************************************
5 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
7 * Authors: Uli Frankenfeld *
8 * Matthias Richter <Matthias.Richter@ift.uib.no> *
9 * for The ALICE Off-line Project. *
11 * Permission to use, copy, modify and distribute this software and its *
12 * documentation strictly for non-commercial purposes is hereby granted *
13 * without fee, provided that the above copyright notice appears in all *
14 * copies and that both the copyright notice and this permission notice *
15 * appear in the supporting documentation. The authors make no claims *
16 * about the suitability of this software for any purpose. It is *
17 * provided "as is" without express or implied warranty. *
18 **************************************************************************/
20 /** @file AliHLTTPCTrackArray.cxx
21 @author Uli Frankenfeld, maintained by Matthias Richter
23 @brief Array of AliHLTTPCTracks */
27 #include "AliHLTTPCLogging.h"
28 #include "AliHLTTPCTrackArray.h"
29 #define INCLUDE_TPC_HOUGH
30 #ifdef INCLUDE_TPC_HOUGH
31 #include "AliHLTTPCHoughTrack.h"
33 #include "AliHLTTPCModelTrack.h"
34 #include "AliHLTTPCConfMapTrack.h"
35 #include "AliHLTTPCTrackSegmentData.h"
36 #include "AliHLTTPCTransform.h"
37 #include "AliHLTTPCConfMapPoint.h"
43 ClassImp(AliHLTTPCTrackArray)
45 AliHLTTPCTrackArray::AliHLTTPCTrackArray()
59 AliHLTTPCTrackArray::AliHLTTPCTrackArray(const AliHLTTPCTrackArray&)
72 AliHLTTPCTrackArray& AliHLTTPCTrackArray::operator=(const AliHLTTPCTrackArray&)
83 AliHLTTPCTrackArray::AliHLTTPCTrackArray(Int_t ntrack)
96 AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype,Int_t ntrack)
106 if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
107 if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
108 #ifdef INCLUDE_TPC_HOUGH
109 if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
111 if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
115 AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype)
125 if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
126 if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
127 #ifdef INCLUDE_TPC_HOUGH
128 if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
130 if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
134 AliHLTTPCTrackArray::~AliHLTTPCTrackArray()
141 AliHLTTPCTrack *AliHLTTPCTrackArray::NextTrack()
143 //next track in array
144 if(fNTracks<fSize) return fTrack[fNTracks++];
146 return fTrack[fNTracks++];
149 void AliHLTTPCTrackArray::DeleteArray()
152 for(Int_t i=0; i<fSize;i++)
158 Bool_t AliHLTTPCTrackArray::SetSize(Int_t newsize)
161 if(newsize<=fSize) return kFALSE; //shrink comes later!!
164 fTrack = new AliHLTTPCTrack*[fSize];
165 fIsPresent = new Bool_t[fSize];
168 for(Int_t i=0;i<fSize;i++){
169 fTrack[i] = new AliHLTTPCTrack();
170 fIsPresent[i] = kTRUE;
174 for(Int_t i=0;i<fSize;i++){
175 fTrack[i] = new AliHLTTPCConfMapTrack();
176 fIsPresent[i] = kTRUE;
179 #ifdef INCLUDE_TPC_HOUGH
181 for(Int_t i=0;i<fSize;i++){
182 fTrack[i] = new AliHLTTPCHoughTrack();
183 fIsPresent[i] = kTRUE;
188 for(Int_t i=0;i<fSize;i++){
189 fTrack[i] = new AliHLTTPCModelTrack();
190 fIsPresent[i] = kTRUE;
198 AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[fSize];
199 Bool_t *pre = new Bool_t[fSize];
200 for(Int_t i=0; i<fSize;i++){
202 pre[i] = fIsPresent[i];
206 fTrack = new AliHLTTPCTrack*[newsize];
207 fIsPresent = new Bool_t[newsize];
208 for(Int_t i=0; i<fSize;i++){
210 fIsPresent[i] = pre[i];
216 for(Int_t i=fSize;i<newsize;i++){
217 fTrack[i] = new AliHLTTPCTrack();
218 fIsPresent[i] = kTRUE;
222 for(Int_t i=fSize;i<newsize;i++){
223 fTrack[i] = new AliHLTTPCConfMapTrack();
224 fIsPresent[i] = kTRUE;
227 #ifdef INCLUDE_TPC_HOUGH
229 for(Int_t i=fSize;i<newsize;i++){
230 fTrack[i] = new AliHLTTPCHoughTrack();
231 fIsPresent[i] = kTRUE;
236 for(Int_t i=fSize;i<newsize;i++){
237 fTrack[i] = new AliHLTTPCModelTrack();
238 fIsPresent[i] = kTRUE;
248 void AliHLTTPCTrackArray::Reset()
253 for(Int_t i=0; i<fSize;i++)
254 fIsPresent[i] = kTRUE;
257 void AliHLTTPCTrackArray::Remove(Int_t track)
260 if(fIsPresent[track]){
261 fIsPresent[track]=kFALSE;
266 void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr,Int_t slice, Int_t bTransform)
268 //Read tracks from shared memory (or memory)
269 AliHLTTPCTrackSegmentData *trs = tr;
270 for(Int_t i=0; i<ntracks; i++){
271 AliHLTTPCTrack *track = NextTrack();
272 track->SetPt(trs->fPt);
273 track->SetPterr(trs->fPterr);
276 if (slice>=0 && bTransform!=0) {
277 AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
279 //cout << "psi " << psi[0] << endl;
280 track->SetPsi(psi[0]);
281 track->SetTgl(trs->fTgl);
282 track->SetPsierr(trs->fPsierr);
283 track->SetTglerr(trs->fTglerr);
284 track->SetNHits(trs->fNPoints);
285 track->SetCharge(trs->fCharge);
287 first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
288 if (slice>=0 && bTransform!=0) {
289 AliHLTTPCTransform::Local2Global(first,slice);
291 //cout << "first point: " << first[0] << " " << first[1] << " " << first[3] << endl;
292 track->SetFirstPoint(first[0],first[1],first[2]);
294 last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
295 if (slice>=0 && bTransform!=0) {
296 AliHLTTPCTransform::Local2Global(last,slice);
298 //cout << "last point: " << last[0] << " " << last[1] << " " << last[3] << endl;
299 track->SetLastPoint(last[0],last[1],last[2]);
300 track->SetHits( trs->fNPoints, trs->fPointIDs );
302 if (slice>=0 && bTransform!=0) {
303 // Matthias Feb07: as everything is now in global coordinates, sector should
304 // be set to 0. But as the display does a check on the sector, we have to set
305 // it to the slice no. I suspect, that the transformation is done twice.
306 //track->SetSector(0);
307 track->SetSector(slice);
309 // the parameters are in local coordinates, set the sector no
310 //#ifndef INCLUDE_TPC_HOUGH
311 if (slice<0) track->SetSector(0);
312 else track->SetSector(slice);
314 // Matthias Feb 2007: this is some kind of legacy ...
315 // the INCLUDE_TPC_HOUGH has never been switched on in the new TPCLib
316 // and this line was below in the corresponding block. As the slice
317 // parameter is very useful but not available if the define is off
318 // we distinguish the two cases here. Should be cleaned up.
319 // Matthias April 2007: update, try to integrate Cvetans Hough tracker
320 // so we need the support for the AliHLTTPCHoughTrack. I dont have the
321 // full control of this code (should we use slice or trs->fSector?)
322 // But the FillTracks method is never called from the hough code, so we
324 if (GetTrackType()=='h') {
325 AliErrorClassStream() << "FillTracks was never used with AliHLTTPCHoughTrack:"
326 << " CHECK THIS CODE!!!" << endl;
328 //track->SetSector(trs->fSector);
329 //#endif // INCLUDE_TPC_HOUGH
332 // this is currently a quick hack for straight lines of the first version
333 // of the CA tracker.
334 // we have to think about a more general way of treating straight and curved
336 if ( trs->fPt == -9876.0 || trs->fPt == -1.0) {
337 track->SetPhi0(atan2(first[1],first[0]));
338 track->SetKappa(1.0);
339 track->SetRadius(999999.0);
341 // Matthias Feb07: just tried to take this away, but this causes the tracks
342 // in the display not to be drawn. But we still have to tink about this.
343 track->CalculateHelix();
346 #ifdef INCLUDE_TPC_HOUGH
347 #ifdef ROWHOUGHPARAMS
348 if(GetTrackType()=='h') {
349 ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
350 ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
352 track->SetMCid(trs->fTrackID);
353 track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
354 track->SetPID(trs->fPID);
356 #endif // INCLUDE_TPC_HOUGH
357 UChar_t *tmpP = (UChar_t*)trs;
358 tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
359 trs = (AliHLTTPCTrackSegmentData*)tmpP;
363 UInt_t AliHLTTPCTrackArray::GetOutSize()
366 UInt_t count = GetOutCount(); //use only present tracks
368 for(Int_t i=0;i<fNTracks;i++){ //loop over all tracks
369 AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
370 if(track) //use only present tracks
371 tHits += track->GetNHits();
374 //calculate size of track
375 return count*sizeof(AliHLTTPCTrackSegmentData)+sizeof(UInt_t)*tHits;
378 UInt_t AliHLTTPCTrackArray::WriteTracks(UInt_t & ntracks,AliHLTTPCTrackSegmentData* tr)
381 ntracks = GetOutCount();
382 return WriteTracks(tr);
385 UInt_t AliHLTTPCTrackArray::WriteTracks(AliHLTTPCTrackSegmentData* tr)
387 //if(GetTrackType()=='c') return WriteConfMapTracks(tr);
388 AliHLTTPCTrackSegmentData *tP = tr;
391 for(Int_t i=0; i<fNTracks; i++){ //loop over all tracks
392 AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
393 if(!track) continue; //use only present tracks
394 tP->fX = track->GetFirstPointX();
395 tP->fY = track->GetFirstPointY();
396 tP->fZ = track->GetFirstPointZ();
397 tP->fPt = track->GetPt();
398 tP->fPterr = track->GetPterr();
399 tP->fLastX = track->GetLastPointX();
400 tP->fLastY = track->GetLastPointY();
401 tP->fLastZ = track->GetLastPointZ();
402 tP->fPsi = track->GetPsi();
403 tP->fTgl = track->GetTgl();
404 tP->fPsierr = track->GetPsierr();
405 tP->fTglerr = track->GetTglerr();
406 tP->fCharge = track->GetCharge();
407 tP->fNPoints = track->GetNHits();
408 #ifdef INCLUDE_TPC_HOUGH
409 #ifdef ROWHOUGHPARAMS
410 if(GetTrackType()=='h') {
411 tP->fWeight = ((AliHLTTPCHoughTrack *)track)->GetWeight();
412 tP->fBinX = ((AliHLTTPCHoughTrack *)track)->GetBinX();
413 tP->fBinY = ((AliHLTTPCHoughTrack *)track)->GetBinY();
414 tP->fBinXSize = ((AliHLTTPCHoughTrack *)track)->GetSizeX();
415 tP->fBinYSize = ((AliHLTTPCHoughTrack *)track)->GetSizeY();
417 tP->fTrackID = track->GetMCid();
418 tP->fRowRange1 = track->GetFirstRow();
419 tP->fRowRange2 = track->GetLastRow();
420 tP->fSector = track->GetSector();
421 tP->fPID = track->GetPID();
423 #endif // INCLUDE_TPC_HOUGH
424 pP = (UInt_t*)track->GetHitNumbers();
425 for (UInt_t j=0;j<tP->fNPoints;j++){
426 tP->fPointIDs[j] = pP[j];
428 Byte_t *tmpP = (Byte_t *)tP;
429 tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
430 size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
431 tP = (AliHLTTPCTrackSegmentData*)tmpP;
433 // BEGINN ############################################## MODIFIY JMT
434 // LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::WriteTracks","TRACKPARAMETER") <<ENDLOG;
435 // track->Rotate(0,kFALSE);
437 // END ################################################# MODIFIY JMT
443 UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
445 // use first and last point objects
446 AliHLTTPCTrackSegmentData *tP = tr;
449 for(Int_t i=0; i<fNTracks; i++){ //loop over all tracks
450 AliHLTTPCConfMapTrack *track =(AliHLTTPCConfMapTrack *) GetCheckedTrack(i); //use only present tracks
451 if(!track) continue; //use only present tracks
452 AliHLTTPCConfMapPoint *hit = (AliHLTTPCConfMapPoint*)track->GetLastHit();
453 AliHLTTPCConfMapPoint *lastHit = (AliHLTTPCConfMapPoint*)track->GetFirstHit();
454 tP->fX = hit->GetX();
455 tP->fY = hit->GetY();
456 tP->fZ = hit->GetZ();
457 tP->fLastX = lastHit->GetX();
458 tP->fLastY = lastHit->GetY();
459 tP->fLastZ = lastHit->GetZ();
461 // tP->fX = track->GetFirstPointX();
462 // tP->fY = track->GetFirstPointY();
463 // tP->fZ = track->GetFirstPointZ();
464 tP->fPt = track->GetPt();
465 tP->fPterr = track->GetPterr();
466 // tP->fLastX = track->GetLastPointX();
467 // tP->fLastY = track->GetLastPointY();
468 // tP->fLastZ = track->GetLastPointZ();
469 tP->fPsi = track->GetPsi();
470 tP->fTgl = track->GetTgl();
471 tP->fPsierr = track->GetPsierr();
472 tP->fTglerr = track->GetTglerr();
473 tP->fCharge = track->GetCharge();
474 #ifdef INCLUDE_TPC_HOUGH
475 #ifdef ROWHOUGHPARAMS
476 tP->fTrackID = track->GetMCid();
477 tP->fRowRange1 = track->GetFirstRow();
478 tP->fRowRange2 = track->GetLastRow();
479 tP->fSector = track->GetSector();
480 tP->fPID = track->GetPID();
482 #endif // INCLUDE_TPC_HOUGH
483 tP->fNPoints = track->GetNHits();
484 pP = (UInt_t*)track->GetHitNumbers();
485 for (UInt_t j=0;j<tP->fNPoints;j++){
486 tP->fPointIDs[j] = pP[j];
488 Byte_t *tmpP = (Byte_t *)tP;
489 tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
490 size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
491 tP = (AliHLTTPCTrackSegmentData*)tmpP;
496 void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
498 //add track to last position
499 AliHLTTPCTrack *tpt = NextTrack();
504 void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
507 if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
509 LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
510 <<"Bad idea to add tracks of different types"<<ENDLOG;
513 if(fSize < fNTracks+newtrack->GetNPresent())
514 SetSize(fSize+newtrack->GetSize());
515 for(Int_t i =0;i<newtrack->GetNTracks();i++){
516 AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
520 AliHLTTPCTrack *track = NextTrack();
523 track->Rotate(slice); //Rotate track to global coordinates
525 AliHLTTPCTrack *track;
526 #ifdef INCLUDE_TPC_HOUGH
527 if(GetTrackType()=='h')
528 track = (AliHLTTPCHoughTrack*)NextTrack();
537 void AliHLTTPCTrackArray::Compress()
540 if(GetNPresent()==GetNTracks()) return;
541 AliHLTTPCTrack **tmp = new AliHLTTPCTrack *[fNTracks];
543 Int_t absent=GetNPresent();
544 for(Int_t i=0;i<GetNTracks();i++){
545 if(fIsPresent[i]) tmp[present++] = fTrack[i];
546 else tmp[absent++] = fTrack[i];
548 for(Int_t i=0;i<GetNTracks();i++)
552 for(Int_t i=0; i<GetNTracks();i++){
558 fNTracks = GetNPresent();
562 void AliHLTTPCTrackArray::QSort()
566 QSort(fTrack,0,fNTracks);
569 void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
571 // Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
572 // Uses TrackCompare() to compare objects.
575 static AliHLTTPCTrack *tmp;
576 static int i; // "static" to save stack space
579 while (last - first > 1) {
583 while (++i < last && TrackCompare(a[i], a[first]) < 0)
585 while (--j > first && TrackCompare(a[j], a[first]) > 0)
601 if (j - first < last - (j + 1)) {
603 first = j + 1; // QSort(j + 1, last);
605 QSort(a, j + 1, last);
606 last = j; // QSort(first, j);
611 Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack *a, AliHLTTPCTrack *b) const
613 // Compare the two tracks.
615 return b->Compare(a);
618 #ifdef INCLUDE_TPC_HOUGH
621 AliHLTTPCHoughTrack *tra = (AliHLTTPCHoughTrack*)a;
622 AliHLTTPCHoughTrack *trb = (AliHLTTPCHoughTrack*)b;
623 if(tra->GetWeight() < trb->GetWeight()) return 1;
624 if(tra->GetWeight() > trb->GetWeight()) return -1;
629 if(a->GetNHits() < b->GetNHits()) return 1;
630 if(a->GetNHits() > b->GetNHits()) return -1;
637 AliHLTTPCTrack* AliHLTTPCTrackArray::operator[](int index)
640 if (index<fNTracks) return fTrack[index];