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 */
25 #include "AliHLTTPCLogging.h"
26 #include "AliHLTTPCTrackArray.h"
27 #ifdef INCLUDE_TPC_HOUGH
28 #include "AliHLTTPCHoughTrack.h"
30 #include "AliHLTTPCModelTrack.h"
31 #include "AliHLTTPCConfMapTrack.h"
32 #include "AliHLTTPCTrackSegmentData.h"
33 #include "AliHLTTPCTransform.h"
34 #include "AliHLTTPCConfMapPoint.h"
40 ClassImp(AliHLTTPCTrackArray)
42 AliHLTTPCTrackArray::AliHLTTPCTrackArray()
54 AliHLTTPCTrackArray::AliHLTTPCTrackArray(const AliHLTTPCTrackArray&)
65 AliHLTTPCTrackArray& AliHLTTPCTrackArray::operator=(const AliHLTTPCTrackArray&)
76 AliHLTTPCTrackArray::AliHLTTPCTrackArray(Int_t ntrack)
87 AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype,Int_t ntrack)
94 if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
95 if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
96 #ifdef INCLUDE_TPC_HOUGH
97 if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
99 if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
103 AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype)
110 if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
111 if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
112 #ifdef INCLUDE_TPC_HOUGH
113 if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
115 if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
119 AliHLTTPCTrackArray::~AliHLTTPCTrackArray()
126 AliHLTTPCTrack *AliHLTTPCTrackArray::NextTrack()
128 //next track in array
129 if(fNTracks<fSize) return fTrack[fNTracks++];
131 return fTrack[fNTracks++];
134 void AliHLTTPCTrackArray::DeleteArray()
137 for(Int_t i=0; i<fSize;i++)
143 Bool_t AliHLTTPCTrackArray::SetSize(Int_t newsize)
146 if(newsize<=fSize) return kFALSE; //shrink comes later!!
149 fTrack = new AliHLTTPCTrack*[fSize];
150 fIsPresent = new Bool_t[fSize];
153 for(Int_t i=0;i<fSize;i++){
154 fTrack[i] = new AliHLTTPCTrack();
155 fIsPresent[i] = kTRUE;
159 for(Int_t i=0;i<fSize;i++){
160 fTrack[i] = new AliHLTTPCConfMapTrack();
161 fIsPresent[i] = kTRUE;
164 #ifdef INCLUDE_TPC_HOUGH
166 for(Int_t i=0;i<fSize;i++){
167 fTrack[i] = new AliHLTTPCHoughTrack();
168 fIsPresent[i] = kTRUE;
173 for(Int_t i=0;i<fSize;i++){
174 fTrack[i] = new AliHLTTPCModelTrack();
175 fIsPresent[i] = kTRUE;
183 AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[fSize];
184 Bool_t *pre = new Bool_t[fSize];
185 for(Int_t i=0; i<fSize;i++){
187 pre[i] = fIsPresent[i];
191 fTrack = new AliHLTTPCTrack*[newsize];
192 fIsPresent = new Bool_t[newsize];
193 for(Int_t i=0; i<fSize;i++){
195 fIsPresent[i] = pre[i];
201 for(Int_t i=fSize;i<newsize;i++){
202 fTrack[i] = new AliHLTTPCTrack();
203 fIsPresent[i] = kTRUE;
207 for(Int_t i=fSize;i<newsize;i++){
208 fTrack[i] = new AliHLTTPCConfMapTrack();
209 fIsPresent[i] = kTRUE;
212 #ifdef INCLUDE_TPC_HOUGH
214 for(Int_t i=fSize;i<newsize;i++){
215 fTrack[i] = new AliHLTTPCHoughTrack();
216 fIsPresent[i] = kTRUE;
221 for(Int_t i=fSize;i<newsize;i++){
222 fTrack[i] = new AliHLTTPCModelTrack();
223 fIsPresent[i] = kTRUE;
233 void AliHLTTPCTrackArray::Reset()
238 for(Int_t i=0; i<fSize;i++)
239 fIsPresent[i] = kTRUE;
242 void AliHLTTPCTrackArray::Remove(Int_t track)
245 if(fIsPresent[track]){
246 fIsPresent[track]=kFALSE;
251 void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr,Int_t slice, Int_t bTransform)
253 //Read tracks from shared memory (or memory)
254 AliHLTTPCTrackSegmentData *trs = tr;
255 for(Int_t i=0; i<ntracks; i++){
256 AliHLTTPCTrack *track = NextTrack();
257 track->SetPt(trs->fPt);
258 track->SetPterr(trs->fPterr);
261 if (slice>=0 && bTransform!=0) {
262 AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
264 //cout << "psi " << psi[0] << endl;
265 track->SetPsi(psi[0]);
266 track->SetTgl(trs->fTgl);
267 track->SetPsierr(trs->fPsierr);
268 track->SetTglerr(trs->fTglerr);
269 track->SetNHits(trs->fNPoints);
270 track->SetCharge(trs->fCharge);
272 first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
273 if (slice>=0 && bTransform!=0) {
274 AliHLTTPCTransform::Local2Global(first,slice);
276 //cout << "first point: " << first[0] << " " << first[1] << " " << first[3] << endl;
277 track->SetFirstPoint(first[0],first[1],first[2]);
279 last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
280 if (slice>=0 && bTransform!=0) {
281 AliHLTTPCTransform::Local2Global(last,slice);
283 //cout << "last point: " << last[0] << " " << last[1] << " " << last[3] << endl;
284 track->SetLastPoint(last[0],last[1],last[2]);
285 track->SetHits( trs->fNPoints, trs->fPointIDs );
287 if (slice>=0 && bTransform!=0) {
288 // as everything is now in global coordinates we set the sector to 0
291 // the parameters are in local coordinates, set the sector no
292 #ifndef INCLUDE_TPC_HOUGH
293 if (slice<0) track->SetSector(0);
294 else track->SetSector(slice);
296 // Matthias Feb 2007: this is some kind of legacy ...
297 // the INCLUDE_TPC_HOUGH has never been switched on in the new TPCLib
298 // and this line was below in the corresponding block. As the slice
299 // parameter is very useful but not available if the define is off
300 // we distinguish the two cases here. Should be cleaned up.
301 track->SetSector(trs->fSector);
302 #endif // INCLUDE_TPC_HOUGH
304 // BEGINN ############################################## MODIFIY JMT
305 // this we have to check
306 // track->CalculateHelix();
307 // END ################################################# MODIFIY JMT
308 #ifdef INCLUDE_TPC_HOUGH
309 #ifdef ROWHOUGHPARAMS
310 if(GetTrackType()=='h') {
311 ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
312 ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
314 track->SetMCid(trs->fTrackID);
315 track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
316 track->SetPID(trs->fPID);
318 #endif // INCLUDE_TPC_HOUGH
319 UChar_t *tmpP = (UChar_t*)trs;
320 tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
321 trs = (AliHLTTPCTrackSegmentData*)tmpP;
325 UInt_t AliHLTTPCTrackArray::GetOutSize()
328 UInt_t count = GetOutCount(); //use only present tracks
330 for(Int_t i=0;i<fNTracks;i++){ //loop over all tracks
331 AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
332 if(track) //use only present tracks
333 tHits += track->GetNHits();
336 //calculate size of track
337 return count*sizeof(AliHLTTPCTrackSegmentData)+sizeof(UInt_t)*tHits;
340 UInt_t AliHLTTPCTrackArray::WriteTracks(UInt_t & ntracks,AliHLTTPCTrackSegmentData* tr)
343 ntracks = GetOutCount();
344 return WriteTracks(tr);
347 UInt_t AliHLTTPCTrackArray::WriteTracks(AliHLTTPCTrackSegmentData* tr)
349 //if(GetTrackType()=='c') return WriteConfMapTracks(tr);
350 AliHLTTPCTrackSegmentData *tP = tr;
353 for(Int_t i=0; i<fNTracks; i++){ //loop over all tracks
354 AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
355 if(!track) continue; //use only present tracks
356 tP->fX = track->GetFirstPointX();
357 tP->fY = track->GetFirstPointY();
358 tP->fZ = track->GetFirstPointZ();
359 tP->fPt = track->GetPt();
360 tP->fPterr = track->GetPterr();
361 tP->fLastX = track->GetLastPointX();
362 tP->fLastY = track->GetLastPointY();
363 tP->fLastZ = track->GetLastPointZ();
364 tP->fPsi = track->GetPsi();
365 tP->fTgl = track->GetTgl();
366 tP->fPsierr = track->GetPsierr();
367 tP->fTglerr = track->GetTglerr();
368 tP->fCharge = track->GetCharge();
369 tP->fNPoints = track->GetNHits();
370 #ifdef INCLUDE_TPC_HOUGH
371 #ifdef ROWHOUGHPARAMS
372 if(GetTrackType()=='h') {
373 tP->fWeight = ((AliHLTTPCHoughTrack *)track)->GetWeight();
374 tP->fBinX = ((AliHLTTPCHoughTrack *)track)->GetBinX();
375 tP->fBinY = ((AliHLTTPCHoughTrack *)track)->GetBinY();
376 tP->fBinXSize = ((AliHLTTPCHoughTrack *)track)->GetSizeX();
377 tP->fBinYSize = ((AliHLTTPCHoughTrack *)track)->GetSizeY();
379 tP->fTrackID = track->GetMCid();
380 tP->fRowRange1 = track->GetFirstRow();
381 tP->fRowRange2 = track->GetLastRow();
382 tP->fSector = track->GetSector();
383 tP->fPID = track->GetPID();
385 #endif // INCLUDE_TPC_HOUGH
386 pP = (UInt_t*)track->GetHitNumbers();
387 for (UInt_t j=0;j<tP->fNPoints;j++){
388 tP->fPointIDs[j] = pP[j];
390 Byte_t *tmpP = (Byte_t *)tP;
391 tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
392 size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
393 tP = (AliHLTTPCTrackSegmentData*)tmpP;
395 // BEGINN ############################################## MODIFIY JMT
396 // LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::WriteTracks","TRACKPARAMETER") <<ENDLOG;
397 // track->Rotate(0,kFALSE);
399 // END ################################################# MODIFIY JMT
405 UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
407 // use first and last point objects
408 AliHLTTPCTrackSegmentData *tP = tr;
411 for(Int_t i=0; i<fNTracks; i++){ //loop over all tracks
412 AliHLTTPCConfMapTrack *track =(AliHLTTPCConfMapTrack *) GetCheckedTrack(i); //use only present tracks
413 if(!track) continue; //use only present tracks
414 AliHLTTPCConfMapPoint *hit = (AliHLTTPCConfMapPoint*)track->GetLastHit();
415 AliHLTTPCConfMapPoint *lastHit = (AliHLTTPCConfMapPoint*)track->GetFirstHit();
416 tP->fX = hit->GetX();
417 tP->fY = hit->GetY();
418 tP->fZ = hit->GetZ();
419 tP->fLastX = lastHit->GetX();
420 tP->fLastY = lastHit->GetY();
421 tP->fLastZ = lastHit->GetZ();
423 // tP->fX = track->GetFirstPointX();
424 // tP->fY = track->GetFirstPointY();
425 // tP->fZ = track->GetFirstPointZ();
426 tP->fPt = track->GetPt();
427 tP->fPterr = track->GetPterr();
428 // tP->fLastX = track->GetLastPointX();
429 // tP->fLastY = track->GetLastPointY();
430 // tP->fLastZ = track->GetLastPointZ();
431 tP->fPsi = track->GetPsi();
432 tP->fTgl = track->GetTgl();
433 tP->fPsierr = track->GetPsierr();
434 tP->fTglerr = track->GetTglerr();
435 tP->fCharge = track->GetCharge();
436 #ifdef INCLUDE_TPC_HOUGH
437 #ifdef ROWHOUGHPARAMS
438 tP->fTrackID = track->GetMCid();
439 tP->fRowRange1 = track->GetFirstRow();
440 tP->fRowRange2 = track->GetLastRow();
441 tP->fSector = track->GetSector();
442 tP->fPID = track->GetPID();
444 #endif // INCLUDE_TPC_HOUGH
445 tP->fNPoints = track->GetNHits();
446 pP = (UInt_t*)track->GetHitNumbers();
447 for (UInt_t j=0;j<tP->fNPoints;j++){
448 tP->fPointIDs[j] = pP[j];
450 Byte_t *tmpP = (Byte_t *)tP;
451 tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
452 size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
453 tP = (AliHLTTPCTrackSegmentData*)tmpP;
458 void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
460 //add track to last position
461 AliHLTTPCTrack *tpt = NextTrack();
466 void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
469 if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
471 LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
472 <<"Bad idea to add tracks of different types"<<ENDLOG;
475 if(fSize < fNTracks+newtrack->GetNPresent())
476 SetSize(fSize+newtrack->GetSize());
477 for(Int_t i =0;i<newtrack->GetNTracks();i++){
478 AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
482 AliHLTTPCTrack *track = NextTrack();
485 track->Rotate(slice); //Rotate track to global coordinates
487 AliHLTTPCTrack *track;
488 #ifdef INCLUDE_TPC_HOUGH
489 if(GetTrackType()=='h')
490 track = (AliHLTTPCHoughTrack*)NextTrack();
499 void AliHLTTPCTrackArray::Compress()
502 if(GetNPresent()==GetNTracks()) return;
503 AliHLTTPCTrack **tmp = new AliHLTTPCTrack *[fNTracks];
505 Int_t absent=GetNPresent();
506 for(Int_t i=0;i<GetNTracks();i++){
507 if(fIsPresent[i]) tmp[present++] = fTrack[i];
508 else tmp[absent++] = fTrack[i];
510 for(Int_t i=0;i<GetNTracks();i++)
514 for(Int_t i=0; i<GetNTracks();i++){
520 fNTracks = GetNPresent();
524 void AliHLTTPCTrackArray::QSort()
528 QSort(fTrack,0,fNTracks);
531 void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
533 // Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
534 // Uses TrackCompare() to compare objects.
537 static AliHLTTPCTrack *tmp;
538 static int i; // "static" to save stack space
541 while (last - first > 1) {
545 while (++i < last && TrackCompare(a[i], a[first]) < 0)
547 while (--j > first && TrackCompare(a[j], a[first]) > 0)
563 if (j - first < last - (j + 1)) {
565 first = j + 1; // QSort(j + 1, last);
567 QSort(a, j + 1, last);
568 last = j; // QSort(first, j);
573 Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack *a, AliHLTTPCTrack *b) const
575 // Compare the two tracks.
577 return b->Compare(a);
580 #ifdef INCLUDE_TPC_HOUGH
583 AliHLTTPCHoughTrack *tra = (AliHLTTPCHoughTrack*)a;
584 AliHLTTPCHoughTrack *trb = (AliHLTTPCHoughTrack*)b;
585 if(tra->GetWeight() < trb->GetWeight()) return 1;
586 if(tra->GetWeight() > trb->GetWeight()) return -1;
591 if(a->GetNHits() < b->GetNHits()) return 1;
592 if(a->GetNHits() > b->GetNHits()) return -1;
599 AliHLTTPCTrack* AliHLTTPCTrackArray::operator[](int index)
602 if (index<fNTracks) return fTrack[index];