[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCTrackArray.cxx

// @(#) $Id$

// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright &copy ALICE HLT Group

#include "AliHLTTPCStandardIncludes.h"

#include "AliHLTTPCLogging.h"
#include "AliHLTTPCTrackArray.h"
#ifdef INCLUDE_TPC_HOUGH
#include "AliHLTTPCHoughTrack.h"
#endif
#include "AliHLTTPCModelTrack.h"
#include "AliHLTTPCConfMapTrack.h"
#include "AliHLTTPCTrackSegmentData.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCConfMapPoint.h"

/** \class AliHLTTPCTrackArray
<pre>
//_____________________________________________________________
// AliHLTTPCTrackArray
//
// Track array class 
//
</pre>
*/

#if __GNUC__ >= 3
using namespace std;
#endif

ClassImp(AliHLTTPCTrackArray)

AliHLTTPCTrackArray::AliHLTTPCTrackArray()
{
  //Default constructor
  fSize = 0;
  fNTracks=0;
  fNAbsent=0;
  fTrackType='t';
  SetSize();
}


AliHLTTPCTrackArray::AliHLTTPCTrackArray(Int_t ntrack)
{
  //Constructor.
  fSize = 0;
  fNTracks=0;
  fNAbsent=0;
  fTrackType='t';
  SetSize(ntrack);
}

AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype,Int_t ntrack)
{
  //Constructor.
  fSize = 0;
  fNTracks=0;
  fNAbsent=0;
  if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
  if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
#ifdef INCLUDE_TPC_HOUGH
  if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
#endif
  if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
  SetSize(ntrack);
}

AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype)
{
  //Constructor.
  fSize = 0;
  fNTracks=0;
  fNAbsent=0;
  if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
  if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
#ifdef INCLUDE_TPC_HOUGH
  if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
#endif
  if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
  SetSize();
}

AliHLTTPCTrackArray::~AliHLTTPCTrackArray()
{
  //Destructor
  DeleteArray();
}


AliHLTTPCTrack *AliHLTTPCTrackArray::NextTrack()
{
  //next track in array
  if(fNTracks<fSize) return fTrack[fNTracks++];
  SetSize(fSize+100);
   return fTrack[fNTracks++]; 
}

void AliHLTTPCTrackArray::DeleteArray()
{
  //delete array
  for(Int_t i=0; i<fSize;i++)
    delete fTrack[i];
  delete[] fIsPresent;
  delete[] fTrack;
}

Bool_t AliHLTTPCTrackArray::SetSize(Int_t newsize)
{
  //set size
  if(newsize<=fSize) return kFALSE; //shrink comes later!! 
  if(!fSize){
    fSize = newsize;
    fTrack = new AliHLTTPCTrack*[fSize];
    fIsPresent = new Bool_t[fSize];
    switch(fTrackType){
      case 't':
        for(Int_t i=0;i<fSize;i++){
          fTrack[i]   = new AliHLTTPCTrack();
          fIsPresent[i] = kTRUE;
        }
        break;
      case 'c':  
        for(Int_t i=0;i<fSize;i++){
          fTrack[i]   = new AliHLTTPCConfMapTrack();
          fIsPresent[i] = kTRUE;
        }
        break;
#ifdef INCLUDE_TPC_HOUGH
      case 'h':
        for(Int_t i=0;i<fSize;i++){
          fTrack[i]   = new AliHLTTPCHoughTrack();
          fIsPresent[i] = kTRUE;
        }
        break;
#endif
       case 'm':
        for(Int_t i=0;i<fSize;i++){
          fTrack[i]   = new AliHLTTPCModelTrack();
          fIsPresent[i] = kTRUE;
        }
        break;
      default: 
        return kFALSE;
    }
    return kTRUE;
  }
  AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[fSize];
  Bool_t *pre = new Bool_t[fSize];
  for(Int_t i=0; i<fSize;i++){
    tmp[i] = fTrack[i];
    pre[i] = fIsPresent[i];
  }
  delete[]  fTrack;
  delete[] fIsPresent;
  fTrack =  new AliHLTTPCTrack*[newsize];
  fIsPresent = new Bool_t[newsize];
  for(Int_t i=0; i<fSize;i++){
    fTrack[i]   = tmp[i];
    fIsPresent[i] = pre[i];
  }
  delete[] tmp;
  delete[] pre;
  switch(fTrackType){
    case 't':
      for(Int_t i=fSize;i<newsize;i++){
        fTrack[i]   = new AliHLTTPCTrack();
        fIsPresent[i] = kTRUE;
      }
      break;
    case 'c':  
      for(Int_t i=fSize;i<newsize;i++){
        fTrack[i]   = new AliHLTTPCConfMapTrack();
        fIsPresent[i] = kTRUE;
      }
      break;
#ifdef INCLUDE_TPC_HOUGH
    case 'h':
      for(Int_t i=fSize;i<newsize;i++){
        fTrack[i]   = new AliHLTTPCHoughTrack();
        fIsPresent[i] = kTRUE;
      }
      break;
#endif
    case 'm':
      for(Int_t i=fSize;i<newsize;i++){
        fTrack[i]   = new AliHLTTPCModelTrack();
        fIsPresent[i] = kTRUE;
      }
      break;
    default: 
      return kFALSE;
  }
  fSize = newsize;
  return kTRUE;
}

void AliHLTTPCTrackArray::Reset()
{
  //reset
  fNTracks=0;
  fNAbsent=0;
  for(Int_t i=0; i<fSize;i++)
    fIsPresent[i] = kTRUE; 
}

void AliHLTTPCTrackArray::Remove(Int_t track)
{
  //remove track
  if(fIsPresent[track]){
    fIsPresent[track]=kFALSE;
    fNAbsent++;
  }
}

void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr){
  //Read tracks from shared memory (or memory)
  AliHLTTPCTrackSegmentData *trs = tr;
   for(Int_t i=0; i<ntracks; i++){
    AliHLTTPCTrack *track = NextTrack(); 
    track->SetPt(trs->fPt);
    track->SetPsi(trs->fPsi);
    track->SetTgl(trs->fTgl);
    track->SetPterr(trs->fPterr);
    track->SetPsierr(trs->fPsierr);
    track->SetTglerr(trs->fTglerr);
    track->SetNHits(trs->fNPoints);
    track->SetCharge(trs->fCharge);
    track->SetFirstPoint(trs->fX,trs->fY,trs->fZ);
    track->SetLastPoint(trs->fLastX,trs->fLastY,trs->fLastZ);
    track->SetHits( trs->fNPoints, trs->fPointIDs );
#ifdef INCLUDE_TPC_HOUGH
#ifdef ROWHOUGHPARAMS
    if(GetTrackType()=='h') {
      ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
      ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
    }
    track->SetMCid(trs->fTrackID);
    track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
    track->SetSector(trs->fSector);
    track->SetPID(trs->fPID);
#endif
#endif // INCLUDE_TPC_HOUGH
    UChar_t *tmpP = (UChar_t*)trs;
    tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
    trs = (AliHLTTPCTrackSegmentData*)tmpP;
  }
}

void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr,Int_t slice)
{
  //Read tracks from shared memory (or memory)
  AliHLTTPCTrackSegmentData *trs = tr;
  for(Int_t i=0; i<ntracks; i++){
    AliHLTTPCTrack *track = NextTrack(); 
    track->SetPt(trs->fPt);
    track->SetPterr(trs->fPterr);
    Float_t psi[1];
    psi[0]=trs->fPsi;
    AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
    track->SetPsi(psi[0]);
    track->SetTgl(trs->fTgl);
    track->SetPsierr(trs->fPsierr);
    track->SetTglerr(trs->fTglerr);
    track->SetNHits(trs->fNPoints);
    track->SetCharge(trs->fCharge);
    Float_t first[3];
    first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
    AliHLTTPCTransform::Local2Global(first,slice);
    track->SetFirstPoint(first[0],first[1],first[2]);
    Float_t last[3];
    last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
    AliHLTTPCTransform::Local2Global(last,slice);
    track->SetLastPoint(last[0],last[1],last[2]);
    track->SetHits( trs->fNPoints, trs->fPointIDs );
#ifdef INCLUDE_TPC_HOUGH
#ifdef ROWHOUGHPARAMS
    if(GetTrackType()=='h') {
      ((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
      ((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
    }
    track->SetMCid(trs->fTrackID);
    track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
    track->SetSector(slice);
    track->SetPID(trs->fPID);
#endif
#endif // INCLUDE_TPC_HOUGH
    UChar_t *tmpP = (UChar_t*)trs;
    tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
    trs = (AliHLTTPCTrackSegmentData*)tmpP;
  }
}

UInt_t AliHLTTPCTrackArray::GetOutSize()
{
  //get size for IO
  UInt_t count = GetOutCount();   //use only present tracks
  UInt_t tHits = 0;
  for(Int_t i=0;i<fNTracks;i++){  //loop over all tracks
    AliHLTTPCTrack *track = GetCheckedTrack(i);  //use only present tracks
    if(track)                                       //use only present tracks
      tHits += track->GetNHits();
  }

  //calculate size of track
  return count*sizeof(AliHLTTPCTrackSegmentData)+sizeof(UInt_t)*tHits;
}

UInt_t AliHLTTPCTrackArray::WriteTracks(UInt_t & ntracks,AliHLTTPCTrackSegmentData* tr)
{
  //write tracks
  ntracks = GetOutCount();
  return WriteTracks(tr);
}

UInt_t AliHLTTPCTrackArray::WriteTracks(AliHLTTPCTrackSegmentData* tr)
{
  //if(GetTrackType()=='c') return WriteConfMapTracks(tr);
  AliHLTTPCTrackSegmentData *tP = tr;
  UInt_t *pP;
  UInt_t size = 0;
  for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
    AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
    if(!track) continue;                           //use only present tracks
    tP->fX = track->GetFirstPointX();
    tP->fY = track->GetFirstPointY();
    tP->fZ = track->GetFirstPointZ();
    tP->fPt = track->GetPt();
    tP->fPterr = track->GetPterr();
    tP->fLastX = track->GetLastPointX();
    tP->fLastY = track->GetLastPointY();
    tP->fLastZ = track->GetLastPointZ();
    tP->fPsi = track->GetPsi();
    tP->fTgl = track->GetTgl();
    tP->fPsierr = track->GetPsierr();
    tP->fTglerr = track->GetTglerr();
    tP->fCharge = track->GetCharge();
    tP->fNPoints = track->GetNHits();
#ifdef INCLUDE_TPC_HOUGH
#ifdef ROWHOUGHPARAMS
    if(GetTrackType()=='h') {
      tP->fWeight = ((AliHLTTPCHoughTrack *)track)->GetWeight();
      tP->fBinX = ((AliHLTTPCHoughTrack *)track)->GetBinX();
      tP->fBinY = ((AliHLTTPCHoughTrack *)track)->GetBinY();
      tP->fBinXSize = ((AliHLTTPCHoughTrack *)track)->GetSizeX();
      tP->fBinYSize = ((AliHLTTPCHoughTrack *)track)->GetSizeY();
    }
    tP->fTrackID = track->GetMCid();
    tP->fRowRange1 = track->GetFirstRow();
    tP->fRowRange2 = track->GetLastRow();
    tP->fSector = track->GetSector();
    tP->fPID = track->GetPID();
#endif
#endif // INCLUDE_TPC_HOUGH
    pP = (UInt_t*)track->GetHitNumbers();
    for (UInt_t j=0;j<tP->fNPoints;j++){
      tP->fPointIDs[j] = pP[j];
    }
    Byte_t *tmpP = (Byte_t *)tP;
    tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
    size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
    tP = (AliHLTTPCTrackSegmentData*)tmpP;
  }
  return size;
}

UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
{
  // use first and last point objects
  AliHLTTPCTrackSegmentData *tP = tr;
  UInt_t *pP;
  UInt_t size = 0;
  for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
    AliHLTTPCConfMapTrack *track =(AliHLTTPCConfMapTrack *) GetCheckedTrack(i); //use only present tracks
    if(!track) continue;                           //use only present tracks
    AliHLTTPCConfMapPoint *hit = (AliHLTTPCConfMapPoint*)track->GetLastHit();
    AliHLTTPCConfMapPoint *lastHit = (AliHLTTPCConfMapPoint*)track->GetFirstHit();
    tP->fX = hit->GetX();
    tP->fY = hit->GetY();
    tP->fZ = hit->GetZ();
    tP->fLastX = lastHit->GetX();
    tP->fLastY = lastHit->GetY();
    tP->fLastZ = lastHit->GetZ();
   
//    tP->fX = track->GetFirstPointX();
//    tP->fY = track->GetFirstPointY();
//    tP->fZ = track->GetFirstPointZ();
    tP->fPt = track->GetPt();
    tP->fPterr = track->GetPterr();
//    tP->fLastX = track->GetLastPointX();
//    tP->fLastY = track->GetLastPointY();
//    tP->fLastZ = track->GetLastPointZ();
    tP->fPsi = track->GetPsi();
    tP->fTgl = track->GetTgl();
    tP->fPsierr = track->GetPsierr();
    tP->fTglerr = track->GetTglerr();
    tP->fCharge = track->GetCharge();
#ifdef INCLUDE_TPC_HOUGH
#ifdef ROWHOUGHPARAMS
    tP->fTrackID = track->GetMCid();
    tP->fRowRange1 = track->GetFirstRow();
    tP->fRowRange2 = track->GetLastRow();
    tP->fSector = track->GetSector();
    tP->fPID = track->GetPID();
#endif
#endif // INCLUDE_TPC_HOUGH
    tP->fNPoints = track->GetNHits();
    pP = (UInt_t*)track->GetHitNumbers();
    for (UInt_t j=0;j<tP->fNPoints;j++){
      tP->fPointIDs[j] = pP[j];
    }
    Byte_t *tmpP = (Byte_t *)tP;
    tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
    size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
    tP = (AliHLTTPCTrackSegmentData*)tmpP;
  }
  return size;
}

void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
{
  //add track to last position
  AliHLTTPCTrack *tpt = NextTrack();
  tpt->Set(track);
  
}

void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
{
  //add tracks
  if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
    {
      LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
	<<"Bad idea to add tracks of different types"<<ENDLOG;
      return;
    }
  if(fSize < fNTracks+newtrack->GetNPresent())
    SetSize(fSize+newtrack->GetSize());
  for(Int_t i =0;i<newtrack->GetNTracks();i++){
    AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
    if(!tpt) continue;
    if(remove_old)
      newtrack->Remove(i);
    AliHLTTPCTrack *track = NextTrack();
    track->Set(tpt);
    if(slice>=0)
      track->Rotate(slice); //Rotate track to global coordinates
    /*
      AliHLTTPCTrack *track;
#ifdef INCLUDE_TPC_HOUGH
      if(GetTrackType()=='h')
      track = (AliHLTTPCHoughTrack*)NextTrack();
      else
#endif
      track = NextTrack();
      track->Set(tpt);
    */
  }
}

void AliHLTTPCTrackArray::Compress()
{
  //compress array
  if(GetNPresent()==GetNTracks()) return;
  AliHLTTPCTrack **tmp =  new AliHLTTPCTrack *[fNTracks];
  Int_t present=0;
  Int_t absent=GetNPresent();
  for(Int_t i=0;i<GetNTracks();i++){
    if(fIsPresent[i]) tmp[present++] = fTrack[i];
    else tmp[absent++] = fTrack[i];
  }
  for(Int_t i=0;i<GetNTracks();i++)
    fIsPresent[i]=kTRUE;

  //Copy pointers back
  for(Int_t i=0; i<GetNTracks();i++){
    fTrack[i]=tmp[i];
  }

  delete[] tmp;

  fNTracks = GetNPresent();
  fNAbsent = 0;
}

void AliHLTTPCTrackArray::QSort()
{
  // compress and sort
  Compress();
  QSort(fTrack,0,fNTracks);
}

void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
{
   // Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
   // Uses TrackCompare() to compare objects.
   // Thanks to Root! 

   static AliHLTTPCTrack *tmp;
   static int i;           // "static" to save stack space
   int j;

   while (last - first > 1) {
      i = first;
      j = last;
      for (;;) {
	while (++i < last && TrackCompare(a[i], a[first]) < 0)
	  ;
	while (--j > first && TrackCompare(a[j], a[first]) > 0)
	  ;
         if (i >= j)
            break;

         tmp  = a[i];
         a[i] = a[j];
         a[j] = tmp;
      }
      if (j == first) {
         ++first;
         continue;
      }
      tmp = a[first];
      a[first] = a[j];
      a[j] = tmp;
      if (j - first < last - (j + 1)) {
         QSort(a, first, j);
         first = j + 1;   // QSort(j + 1, last);
      } else {
         QSort(a, j + 1, last);
         last = j;        // QSort(first, j);
      }
   }
}

Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack *a, AliHLTTPCTrack *b) const
{
   // Compare the two tracks.
  
  return b->Compare(a);
  
  /*
#ifdef INCLUDE_TPC_HOUGH
    if(fTrackType=='h')
    {
    AliHLTTPCHoughTrack *tra = (AliHLTTPCHoughTrack*)a;
    AliHLTTPCHoughTrack *trb = (AliHLTTPCHoughTrack*)b;
    if(tra->GetWeight() < trb->GetWeight()) return 1;
    if(tra->GetWeight() > trb->GetWeight()) return -1;
    }
    else
#endif
    {
    if(a->GetNHits() < b->GetNHits()) return 1;
    if(a->GetNHits() > b->GetNHits()) return -1;
    }
    
    return 0;
  */
}
Commit	Line	Data
a6c02c85	1	// @(#) $Id$
	2
	3	// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
	4	//*-- Copyright &copy ALICE HLT Group
	5
	6	#include "AliHLTTPCStandardIncludes.h"
	7
	8	#include "AliHLTTPCLogging.h"
	9	#include "AliHLTTPCTrackArray.h"
	10	#ifdef INCLUDE_TPC_HOUGH
	11	#include "AliHLTTPCHoughTrack.h"
	12	#endif
	13	#include "AliHLTTPCModelTrack.h"
	14	#include "AliHLTTPCConfMapTrack.h"
	15	#include "AliHLTTPCTrackSegmentData.h"
	16	#include "AliHLTTPCTransform.h"
	17	#include "AliHLTTPCConfMapPoint.h"
	18
	19	/** \class AliHLTTPCTrackArray
	20	<pre>
	21	//_____________________________________________________________
	22	// AliHLTTPCTrackArray
	23	//
	24	// Track array class
	25	//
	26	</pre>
	27	*/
	28
	29	#if __GNUC__ >= 3
	30	using namespace std;
	31	#endif
	32
	33	ClassImp(AliHLTTPCTrackArray)
	34
	35	AliHLTTPCTrackArray::AliHLTTPCTrackArray()
	36	{
	37	//Default constructor
	38	fSize = 0;
	39	fNTracks=0;
	40	fNAbsent=0;
	41	fTrackType='t';
	42	SetSize();
	43	}
	44
	45
	46	AliHLTTPCTrackArray::AliHLTTPCTrackArray(Int_t ntrack)
	47	{
	48	//Constructor.
	49	fSize = 0;
	50	fNTracks=0;
	51	fNAbsent=0;
	52	fTrackType='t';
	53	SetSize(ntrack);
	54	}
	55
	56	AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype,Int_t ntrack)
	57	{
	58	//Constructor.
	59	fSize = 0;
	60	fNTracks=0;
	61	fNAbsent=0;
	62	if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
	63	if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
	64	#ifdef INCLUDE_TPC_HOUGH
65	if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
66	#endif
67	if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
68	SetSize(ntrack);
69	}
70
71	AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype)
72	{
73	//Constructor.
74	fSize = 0;
75	fNTracks=0;
76	fNAbsent=0;
77	if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
78	if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
79	#ifdef INCLUDE_TPC_HOUGH
80	if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
81	#endif
82	if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
83	SetSize();
84	}
85
86	AliHLTTPCTrackArray::~AliHLTTPCTrackArray()
87	{
88	//Destructor
89	DeleteArray();
90	}
91
92
93	AliHLTTPCTrack *AliHLTTPCTrackArray::NextTrack()
94	{
95	//next track in array
96	if(fNTracks<fSize) return fTrack[fNTracks++];
97	SetSize(fSize+100);
98	return fTrack[fNTracks++];
99	}
100
101	void AliHLTTPCTrackArray::DeleteArray()
102	{
103	//delete array
104	for(Int_t i=0; i<fSize;i++)
105	delete fTrack[i];
106	delete[] fIsPresent;
107	delete[] fTrack;
108	}
109
110	Bool_t AliHLTTPCTrackArray::SetSize(Int_t newsize)
111	{
112	//set size
113	if(newsize<=fSize) return kFALSE; //shrink comes later!!
114	if(!fSize){
115	fSize = newsize;
116	fTrack = new AliHLTTPCTrack*[fSize];
117	fIsPresent = new Bool_t[fSize];
118	switch(fTrackType){
119	case 't':
120	for(Int_t i=0;i<fSize;i++){
121	fTrack[i] = new AliHLTTPCTrack();
122	fIsPresent[i] = kTRUE;
123	}
124	break;
125	case 'c':
126	for(Int_t i=0;i<fSize;i++){
127	fTrack[i] = new AliHLTTPCConfMapTrack();
128	fIsPresent[i] = kTRUE;
129	}
130	break;
131	#ifdef INCLUDE_TPC_HOUGH
132	case 'h':
133	for(Int_t i=0;i<fSize;i++){
134	fTrack[i] = new AliHLTTPCHoughTrack();
135	fIsPresent[i] = kTRUE;
136	}
137	break;
138	#endif
139	case 'm':
140	for(Int_t i=0;i<fSize;i++){
141	fTrack[i] = new AliHLTTPCModelTrack();
142	fIsPresent[i] = kTRUE;
143	}
144	break;
145	default:
146	return kFALSE;
147	}
148	return kTRUE;
149	}
150	AliHLTTPCTrack *tmp = new AliHLTTPCTrack[fSize];
151	Bool_t *pre = new Bool_t[fSize];
152	for(Int_t i=0; i<fSize;i++){
153	tmp[i] = fTrack[i];
154	pre[i] = fIsPresent[i];
155	}
156	delete[] fTrack;
157	delete[] fIsPresent;
158	fTrack = new AliHLTTPCTrack*[newsize];
159	fIsPresent = new Bool_t[newsize];
160	for(Int_t i=0; i<fSize;i++){
161	fTrack[i] = tmp[i];
162	fIsPresent[i] = pre[i];
163	}
164	delete[] tmp;
165	delete[] pre;
166	switch(fTrackType){
167	case 't':
168	for(Int_t i=fSize;i<newsize;i++){
169	fTrack[i] = new AliHLTTPCTrack();
170	fIsPresent[i] = kTRUE;
171	}
172	break;
173	case 'c':
174	for(Int_t i=fSize;i<newsize;i++){
175	fTrack[i] = new AliHLTTPCConfMapTrack();
176	fIsPresent[i] = kTRUE;
177	}
178	break;
179	#ifdef INCLUDE_TPC_HOUGH
180	case 'h':
181	for(Int_t i=fSize;i<newsize;i++){
182	fTrack[i] = new AliHLTTPCHoughTrack();
183	fIsPresent[i] = kTRUE;
184	}
185	break;
186	#endif
187	case 'm':
188	for(Int_t i=fSize;i<newsize;i++){
189	fTrack[i] = new AliHLTTPCModelTrack();
190	fIsPresent[i] = kTRUE;
191	}
192	break;
193	default:
194	return kFALSE;
195	}
196	fSize = newsize;
197	return kTRUE;
198	}
199
200	void AliHLTTPCTrackArray::Reset()
201	{
202	//reset
203	fNTracks=0;
204	fNAbsent=0;
205	for(Int_t i=0; i<fSize;i++)
206	fIsPresent[i] = kTRUE;
207	}
208
209	void AliHLTTPCTrackArray::Remove(Int_t track)
210	{
211	//remove track
212	if(fIsPresent[track]){
213	fIsPresent[track]=kFALSE;
214	fNAbsent++;
215	}
216	}
217
218	void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr){
219	//Read tracks from shared memory (or memory)
220	AliHLTTPCTrackSegmentData *trs = tr;
221	for(Int_t i=0; i<ntracks; i++){
222	AliHLTTPCTrack *track = NextTrack();
223	track->SetPt(trs->fPt);
224	track->SetPsi(trs->fPsi);
225	track->SetTgl(trs->fTgl);
226	track->SetPterr(trs->fPterr);
227	track->SetPsierr(trs->fPsierr);
228	track->SetTglerr(trs->fTglerr);
229	track->SetNHits(trs->fNPoints);
230	track->SetCharge(trs->fCharge);
231	track->SetFirstPoint(trs->fX,trs->fY,trs->fZ);
232	track->SetLastPoint(trs->fLastX,trs->fLastY,trs->fLastZ);
233	track->SetHits( trs->fNPoints, trs->fPointIDs );
234	#ifdef INCLUDE_TPC_HOUGH
235	#ifdef ROWHOUGHPARAMS
236	if(GetTrackType()=='h') {
237	((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
238	((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
239	}
240	track->SetMCid(trs->fTrackID);
241	track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
242	track->SetSector(trs->fSector);
243	track->SetPID(trs->fPID);
244	#endif
245	#endif // INCLUDE_TPC_HOUGH
246	UChar_t tmpP = (UChar_t)trs;
247	tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
248	trs = (AliHLTTPCTrackSegmentData*)tmpP;
249	}
250	}
251
252	void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr,Int_t slice)
253	{
254	//Read tracks from shared memory (or memory)
255	AliHLTTPCTrackSegmentData *trs = tr;
256	for(Int_t i=0; i<ntracks; i++){
257	AliHLTTPCTrack *track = NextTrack();
258	track->SetPt(trs->fPt);
259	track->SetPterr(trs->fPterr);
260	Float_t psi[1];
261	psi[0]=trs->fPsi;
262	AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
263	track->SetPsi(psi[0]);
264	track->SetTgl(trs->fTgl);
265	track->SetPsierr(trs->fPsierr);
266	track->SetTglerr(trs->fTglerr);
267	track->SetNHits(trs->fNPoints);
268	track->SetCharge(trs->fCharge);
269	Float_t first[3];
270	first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
271	AliHLTTPCTransform::Local2Global(first,slice);
272	track->SetFirstPoint(first[0],first[1],first[2]);
273	Float_t last[3];
274	last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
275	AliHLTTPCTransform::Local2Global(last,slice);
276	track->SetLastPoint(last[0],last[1],last[2]);
277	track->SetHits( trs->fNPoints, trs->fPointIDs );
278	#ifdef INCLUDE_TPC_HOUGH
279	#ifdef ROWHOUGHPARAMS
280	if(GetTrackType()=='h') {
281	((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
282	((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
283	}
284	track->SetMCid(trs->fTrackID);
285	track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
286	track->SetSector(slice);
287	track->SetPID(trs->fPID);
288	#endif
289	#endif // INCLUDE_TPC_HOUGH
290	UChar_t tmpP = (UChar_t)trs;
291	tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
292	trs = (AliHLTTPCTrackSegmentData*)tmpP;
293	}
294	}
295
296	UInt_t AliHLTTPCTrackArray::GetOutSize()
297	{
298	//get size for IO
299	UInt_t count = GetOutCount(); //use only present tracks
300	UInt_t tHits = 0;
301	for(Int_t i=0;i<fNTracks;i++){ //loop over all tracks
302	AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
303	if(track) //use only present tracks
304	tHits += track->GetNHits();
305	}
306
307	//calculate size of track
308	return countsizeof(AliHLTTPCTrackSegmentData)+sizeof(UInt_t)tHits;
309	}
310
311	UInt_t AliHLTTPCTrackArray::WriteTracks(UInt_t & ntracks,AliHLTTPCTrackSegmentData* tr)
312	{
313	//write tracks
314	ntracks = GetOutCount();
315	return WriteTracks(tr);
316	}
317
318	UInt_t AliHLTTPCTrackArray::WriteTracks(AliHLTTPCTrackSegmentData* tr)
319	{
320	//if(GetTrackType()=='c') return WriteConfMapTracks(tr);
321	AliHLTTPCTrackSegmentData *tP = tr;
322	UInt_t *pP;
323	UInt_t size = 0;
324	for(Int_t i=0; i<fNTracks; i++){ //loop over all tracks
325	AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
326	if(!track) continue; //use only present tracks
327	tP->fX = track->GetFirstPointX();
328	tP->fY = track->GetFirstPointY();
329	tP->fZ = track->GetFirstPointZ();
330	tP->fPt = track->GetPt();
331	tP->fPterr = track->GetPterr();
332	tP->fLastX = track->GetLastPointX();
333	tP->fLastY = track->GetLastPointY();
334	tP->fLastZ = track->GetLastPointZ();
335	tP->fPsi = track->GetPsi();
336	tP->fTgl = track->GetTgl();
337	tP->fPsierr = track->GetPsierr();
338	tP->fTglerr = track->GetTglerr();
339	tP->fCharge = track->GetCharge();
340	tP->fNPoints = track->GetNHits();
341	#ifdef INCLUDE_TPC_HOUGH
342	#ifdef ROWHOUGHPARAMS
343	if(GetTrackType()=='h') {
344	tP->fWeight = ((AliHLTTPCHoughTrack *)track)->GetWeight();
345	tP->fBinX = ((AliHLTTPCHoughTrack *)track)->GetBinX();
346	tP->fBinY = ((AliHLTTPCHoughTrack *)track)->GetBinY();
347	tP->fBinXSize = ((AliHLTTPCHoughTrack *)track)->GetSizeX();
348	tP->fBinYSize = ((AliHLTTPCHoughTrack *)track)->GetSizeY();
349	}
350	tP->fTrackID = track->GetMCid();
351	tP->fRowRange1 = track->GetFirstRow();
352	tP->fRowRange2 = track->GetLastRow();
353	tP->fSector = track->GetSector();
354	tP->fPID = track->GetPID();
355	#endif
356	#endif // INCLUDE_TPC_HOUGH
357	pP = (UInt_t*)track->GetHitNumbers();
358	for (UInt_t j=0;j<tP->fNPoints;j++){
359	tP->fPointIDs[j] = pP[j];
360	}
361	Byte_t tmpP = (Byte_t )tP;
362	tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
363	size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
364	tP = (AliHLTTPCTrackSegmentData*)tmpP;
365	}
366	return size;
367	}
368
369	UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
370	{
371	// use first and last point objects
372	AliHLTTPCTrackSegmentData *tP = tr;
373	UInt_t *pP;
374	UInt_t size = 0;
375	for(Int_t i=0; i<fNTracks; i++){ //loop over all tracks
376	AliHLTTPCConfMapTrack track =(AliHLTTPCConfMapTrack ) GetCheckedTrack(i); //use only present tracks
377	if(!track) continue; //use only present tracks
378	AliHLTTPCConfMapPoint hit = (AliHLTTPCConfMapPoint)track->GetLastHit();
379	AliHLTTPCConfMapPoint lastHit = (AliHLTTPCConfMapPoint)track->GetFirstHit();
380	tP->fX = hit->GetX();
381	tP->fY = hit->GetY();
382	tP->fZ = hit->GetZ();
383	tP->fLastX = lastHit->GetX();
384	tP->fLastY = lastHit->GetY();
385	tP->fLastZ = lastHit->GetZ();
386
387	// tP->fX = track->GetFirstPointX();
388	// tP->fY = track->GetFirstPointY();
389	// tP->fZ = track->GetFirstPointZ();
390	tP->fPt = track->GetPt();
391	tP->fPterr = track->GetPterr();
392	// tP->fLastX = track->GetLastPointX();
393	// tP->fLastY = track->GetLastPointY();
394	// tP->fLastZ = track->GetLastPointZ();
395	tP->fPsi = track->GetPsi();
396	tP->fTgl = track->GetTgl();
397	tP->fPsierr = track->GetPsierr();
398	tP->fTglerr = track->GetTglerr();
399	tP->fCharge = track->GetCharge();
400	#ifdef INCLUDE_TPC_HOUGH
401	#ifdef ROWHOUGHPARAMS
402	tP->fTrackID = track->GetMCid();
403	tP->fRowRange1 = track->GetFirstRow();
404	tP->fRowRange2 = track->GetLastRow();
405	tP->fSector = track->GetSector();
406	tP->fPID = track->GetPID();
407	#endif
408	#endif // INCLUDE_TPC_HOUGH
409	tP->fNPoints = track->GetNHits();
410	pP = (UInt_t*)track->GetHitNumbers();
411	for (UInt_t j=0;j<tP->fNPoints;j++){
412	tP->fPointIDs[j] = pP[j];
413	}
414	Byte_t tmpP = (Byte_t )tP;
415	tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
416	size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
417	tP = (AliHLTTPCTrackSegmentData*)tmpP;
418	}
419	return size;
420	}
421
422	void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
423	{
424	//add track to last position
425	AliHLTTPCTrack *tpt = NextTrack();
426	tpt->Set(track);
427
428	}
429
430	void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
431	{
432	//add tracks
433	if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
434	{
435	LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
436	<<"Bad idea to add tracks of different types"<<ENDLOG;
437	return;
438	}
439	if(fSize < fNTracks+newtrack->GetNPresent())
440	SetSize(fSize+newtrack->GetSize());
441	for(Int_t i =0;i<newtrack->GetNTracks();i++){
442	AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
443	if(!tpt) continue;
444	if(remove_old)
445	newtrack->Remove(i);
446	AliHLTTPCTrack *track = NextTrack();
447	track->Set(tpt);
448	if(slice>=0)
449	track->Rotate(slice); //Rotate track to global coordinates
450	/*
451	AliHLTTPCTrack *track;
452	#ifdef INCLUDE_TPC_HOUGH
453	if(GetTrackType()=='h')
454	track = (AliHLTTPCHoughTrack*)NextTrack();
455	else
456	#endif
457	track = NextTrack();
458	track->Set(tpt);
459	*/
460	}
461	}
462
463	void AliHLTTPCTrackArray::Compress()
464	{
465	//compress array
466	if(GetNPresent()==GetNTracks()) return;
467	AliHLTTPCTrack *tmp = new AliHLTTPCTrack [fNTracks];
468	Int_t present=0;
469	Int_t absent=GetNPresent();
470	for(Int_t i=0;i<GetNTracks();i++){
471	if(fIsPresent[i]) tmp[present++] = fTrack[i];
472	else tmp[absent++] = fTrack[i];
473	}
474	for(Int_t i=0;i<GetNTracks();i++)
475	fIsPresent[i]=kTRUE;
476
477	//Copy pointers back
478	for(Int_t i=0; i<GetNTracks();i++){
479	fTrack[i]=tmp[i];
480	}
481
482	delete[] tmp;
483
484	fNTracks = GetNPresent();
485	fNAbsent = 0;
486	}
487
488	void AliHLTTPCTrackArray::QSort()
489	{
490	// compress and sort
491	Compress();
492	QSort(fTrack,0,fNTracks);
493	}
494
495	void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
496	{
497	// Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
498	// Uses TrackCompare() to compare objects.
499	// Thanks to Root!
500
501	static AliHLTTPCTrack *tmp;
502	static int i; // "static" to save stack space
503	int j;
504
505	while (last - first > 1) {
506	i = first;
507	j = last;
508	for (;;) {
509	while (++i < last && TrackCompare(a[i], a[first]) < 0)
510	;
511	while (--j > first && TrackCompare(a[j], a[first]) > 0)
512	;
513	if (i >= j)
514	break;
515
516	tmp = a[i];
517	a[i] = a[j];
518	a[j] = tmp;
519	}
520	if (j == first) {
521	++first;
522	continue;
523	}
524	tmp = a[first];
525	a[first] = a[j];
526	a[j] = tmp;
527	if (j - first < last - (j + 1)) {
528	QSort(a, first, j);
529	first = j + 1; // QSort(j + 1, last);
530	} else {
531	QSort(a, j + 1, last);
532	last = j; // QSort(first, j);
533	}
534	}
535	}
536
537	Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack a, AliHLTTPCTrack b) const
538	{
539	// Compare the two tracks.
540
541	return b->Compare(a);
542
543	/*
544	#ifdef INCLUDE_TPC_HOUGH
545	if(fTrackType=='h')
546	{
547	AliHLTTPCHoughTrack tra = (AliHLTTPCHoughTrack)a;
548	AliHLTTPCHoughTrack trb = (AliHLTTPCHoughTrack)b;
549	if(tra->GetWeight() < trb->GetWeight()) return 1;
550	if(tra->GetWeight() > trb->GetWeight()) return -1;
551	}
552	else
553	#endif
554	{
555	if(a->GetNHits() < b->GetNHits()) return 1;
556	if(a->GetNHits() > b->GetNHits()) return -1;
557	}
558
559	return 0;
560	*/
561	}
562
563