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

// @(#) $Id$
// Original: AliHLTTrackArray.cxx,v 1.21 2005/06/14 10:55:21 cvetan 

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Authors: Uli Frankenfeld                                               *
 *          Matthias Richter <Matthias.Richter@ift.uib.no>                *
 *          for The ALICE Off-line Project.                               *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/** @file   AliHLTTPCTrackArray.cxx
    @author Uli Frankenfeld, maintained by Matthias Richter
    @date   
    @brief  Array of AliHLTTPCTracks */

#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"

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

ClassImp(AliHLTTPCTrackArray)

AliHLTTPCTrackArray::AliHLTTPCTrackArray()
  :
  fTrackType('t'),
  fSize(0),
  fIsPresent(NULL),
  fNAbsent(0),
  fTrack(NULL),
  fNTracks(0)
{
  //Default constructor
  SetSize();
}


AliHLTTPCTrackArray::AliHLTTPCTrackArray(const AliHLTTPCTrackArray&)
  :
  fTrackType('t'),
  fSize(0),
  fIsPresent(NULL),
  fNAbsent(0),
  fTrack(NULL),
  fNTracks(0)
{
  //constructor
  SetSize();
}

AliHLTTPCTrackArray& AliHLTTPCTrackArray::operator=(const AliHLTTPCTrackArray&)
{
  //assignment
  fSize=0;
  fNTracks=0;
  fNAbsent=0;
  fTrackType='t';
  SetSize();
  return *this;
}

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

AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype,Int_t ntrack)
  :
  fTrackType('t'),
  fSize(0),
  fIsPresent(NULL),
  fNAbsent(0),
  fTrack(NULL),
  fNTracks(0)
{
  //Constructor.
  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)
  :
  fTrackType('t'),
  fSize(0),
  fIsPresent(NULL),
  fNAbsent(0),
  fTrack(NULL),
  fNTracks(0)
{
  //Constructor.
  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,Int_t slice, Int_t bTransform)
{
  //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;
    if (slice>=0 && bTransform!=0)  {
      AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
    }
    //cout << "psi " << psi[0] << endl;
    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;
    if (slice>=0 && bTransform!=0)  {
      AliHLTTPCTransform::Local2Global(first,slice);
    }
    //cout << "first point: " << first[0] << " " << first[1] << " " << first[3] << endl;
    track->SetFirstPoint(first[0],first[1],first[2]);
    Float_t last[3];
    last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
    if (slice>=0 && bTransform!=0)  {
      AliHLTTPCTransform::Local2Global(last,slice);
    }
    //cout << "last point: " << last[0] << " " << last[1] << " " << last[3] << endl;
    track->SetLastPoint(last[0],last[1],last[2]);
    track->SetHits( trs->fNPoints, trs->fPointIDs );

    if (slice>=0 && bTransform!=0)  {
      // Matthias Feb07: as everything is now in global coordinates, sector should
      // be set to 0. But as the display does a check on the sector, we have to set
      // it to the slice no. I suspect, that the transformation is done twice.
      //track->SetSector(0);
      track->SetSector(slice);
    } else {
      // the parameters are in local coordinates, set the sector no
#ifndef INCLUDE_TPC_HOUGH
      if (slice<0) track->SetSector(0);
      else track->SetSector(slice);
#else 
      // Matthias Feb 2007: this is some kind of legacy ...
      // the INCLUDE_TPC_HOUGH has never been switched on in the new TPCLib
      // and this line was below in the corresponding block. As the slice
      // parameter is very useful but not available if the define is off
      // we distinguish the two cases here. Should be cleaned up.
      track->SetSector(trs->fSector);
#endif // INCLUDE_TPC_HOUGH
    }

    // this is currently a quick hack for straight lines of the first version 
    // of the CA tracker.
    // we have to think about a more general way of treating straight and curved
    // tracks
    if ( trs->fPt == -9876.0 ||  trs->fPt == -1.0) {
      track->SetPhi0(atan2(first[1],first[0]));
      track->SetKappa(1.0);
      track->SetRadius(999999.0);
    } else {
      // Matthias Feb07: just tried to take this away, but this causes the tracks
      // in the display not to be drawn. But we still have to tink about this.
      track->CalculateHelix();
    }

#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->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;

// BEGINN ############################################## MODIFIY JMT
//    LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::WriteTracks","TRACKPARAMETER") <<ENDLOG;
//    track->Rotate(0,kFALSE);
//    track->Print();
// END ################################################# MODIFIY JMT

  }
  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->Copy(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->Copy(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->Copy(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;
  */
}

AliHLTTPCTrack* AliHLTTPCTrackArray::operator[](int index)
{
  // access operator
  if (index<fNTracks) return fTrack[index];
  return NULL;
}
Commit	Line	Data
a6c02c85	1	// @(#) $Id$
4aa41877	2	// Original: AliHLTTrackArray.cxx,v 1.21 2005/06/14 10:55:21 cvetan
a6c02c85	3
4fdaad1e	4	/**************************************************************************
	5	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	6	* *
	7	* Authors: Uli Frankenfeld *
	8	* Matthias Richter <Matthias.Richter@ift.uib.no> *
	9	* for The ALICE Off-line Project. *
	10	* *
	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	**************************************************************************/
	19
	20	/** @file AliHLTTPCTrackArray.cxx
	21	@author Uli Frankenfeld, maintained by Matthias Richter
	22	@date
	23	@brief Array of AliHLTTPCTracks */
a6c02c85	24
a6c02c85	25	#include "AliHLTTPCLogging.h"
	26	#include "AliHLTTPCTrackArray.h"
	27	#ifdef INCLUDE_TPC_HOUGH
	28	#include "AliHLTTPCHoughTrack.h"
	29	#endif
	30	#include "AliHLTTPCModelTrack.h"
	31	#include "AliHLTTPCConfMapTrack.h"
	32	#include "AliHLTTPCTrackSegmentData.h"
	33	#include "AliHLTTPCTransform.h"
	34	#include "AliHLTTPCConfMapPoint.h"
	35
a6c02c85	36	#if __GNUC__ >= 3
	37	using namespace std;
	38	#endif
	39
	40	ClassImp(AliHLTTPCTrackArray)
	41
	42	AliHLTTPCTrackArray::AliHLTTPCTrackArray()
4fdaad1e	43	:
2a083ac4	44	fTrackType('t'),
4fdaad1e	45	fSize(0),
2a083ac4	46	fIsPresent(NULL),
4fdaad1e	47	fNAbsent(0),
2a083ac4	48	fTrack(NULL),
2a083ac4	49	fNTracks(0)
a6c02c85	50	{
a6c02c85	51	//Default constructor
4fdaad1e	52	SetSize();
	53	}
	54
	55
	56	AliHLTTPCTrackArray::AliHLTTPCTrackArray(const AliHLTTPCTrackArray&)
	57	:
2a083ac4	58	fTrackType('t'),
4fdaad1e	59	fSize(0),
2a083ac4	60	fIsPresent(NULL),
4fdaad1e	61	fNAbsent(0),
2a083ac4	62	fTrack(NULL),
2a083ac4	63	fNTracks(0)
4fdaad1e	64	{
	65	//constructor
	66	SetSize();
	67	}
	68
	69	AliHLTTPCTrackArray& AliHLTTPCTrackArray::operator=(const AliHLTTPCTrackArray&)
	70	{
	71	//assignment
	72	fSize=0;
a6c02c85	73	fNTracks=0;
	74	fNAbsent=0;
	75	fTrackType='t';
	76	SetSize();
4fdaad1e	77	return *this;
a6c02c85	78	}
a6c02c85	79
a6c02c85	80	AliHLTTPCTrackArray::AliHLTTPCTrackArray(Int_t ntrack)
4fdaad1e	81	:
2a083ac4	82	fTrackType('t'),
4fdaad1e	83	fSize(0),
2a083ac4	84	fIsPresent(NULL),
4fdaad1e	85	fNAbsent(0),
2a083ac4	86	fTrack(NULL),
2a083ac4	87	fNTracks(0)
a6c02c85	88	{
a6c02c85	89	//Constructor.
a6c02c85	90	SetSize(ntrack);
	91	}
	92
	93	AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype,Int_t ntrack)
4fdaad1e	94	:
2a083ac4	95	fTrackType('t'),
4fdaad1e	96	fSize(0),
2a083ac4	97	fIsPresent(NULL),
	98	fNAbsent(0),
	99	fTrack(NULL),
	100	fNTracks(0)
a6c02c85	101	{
a6c02c85	102	//Constructor.
a6c02c85	103	if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
	104	if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
	105	#ifdef INCLUDE_TPC_HOUGH
	106	if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
	107	#endif
	108	if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
	109	SetSize(ntrack);
	110	}
	111
	112	AliHLTTPCTrackArray::AliHLTTPCTrackArray(char* tracktype)
4fdaad1e	113	:
2a083ac4	114	fTrackType('t'),
4fdaad1e	115	fSize(0),
2a083ac4	116	fIsPresent(NULL),
	117	fNAbsent(0),
	118	fTrack(NULL),
	119	fNTracks(0)
a6c02c85	120	{
a6c02c85	121	//Constructor.
a6c02c85	122	if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
	123	if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
	124	#ifdef INCLUDE_TPC_HOUGH
	125	if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
	126	#endif
	127	if(strcmp(tracktype,"AliHLTTPCModelTrack")==0) fTrackType='m';
	128	SetSize();
	129	}
	130
	131	AliHLTTPCTrackArray::~AliHLTTPCTrackArray()
	132	{
	133	//Destructor
	134	DeleteArray();
	135	}
	136
	137
	138	AliHLTTPCTrack *AliHLTTPCTrackArray::NextTrack()
	139	{
	140	//next track in array
	141	if(fNTracks<fSize) return fTrack[fNTracks++];
	142	SetSize(fSize+100);
	143	return fTrack[fNTracks++];
	144	}
	145
	146	void AliHLTTPCTrackArray::DeleteArray()
	147	{
	148	//delete array
	149	for(Int_t i=0; i<fSize;i++)
	150	delete fTrack[i];
	151	delete[] fIsPresent;
	152	delete[] fTrack;
	153	}
	154
	155	Bool_t AliHLTTPCTrackArray::SetSize(Int_t newsize)
	156	{
	157	//set size
	158	if(newsize<=fSize) return kFALSE; //shrink comes later!!
	159	if(!fSize){
	160	fSize = newsize;
	161	fTrack = new AliHLTTPCTrack*[fSize];
	162	fIsPresent = new Bool_t[fSize];
	163	switch(fTrackType){
	164	case 't':
	165	for(Int_t i=0;i<fSize;i++){
	166	fTrack[i] = new AliHLTTPCTrack();
	167	fIsPresent[i] = kTRUE;
	168	}
	169	break;
	170	case 'c':
	171	for(Int_t i=0;i<fSize;i++){
	172	fTrack[i] = new AliHLTTPCConfMapTrack();
	173	fIsPresent[i] = kTRUE;
	174	}
	175	break;
	176	#ifdef INCLUDE_TPC_HOUGH
	177	case 'h':
	178	for(Int_t i=0;i<fSize;i++){
	179	fTrack[i] = new AliHLTTPCHoughTrack();
	180	fIsPresent[i] = kTRUE;
	181	}
	182	break;
	183	#endif
	184	case 'm':
	185	for(Int_t i=0;i<fSize;i++){
186	fTrack[i] = new AliHLTTPCModelTrack();
187	fIsPresent[i] = kTRUE;
188	}
189	break;
190	default:
191	return kFALSE;
192	}
193	return kTRUE;
194	}
195	AliHLTTPCTrack *tmp = new AliHLTTPCTrack[fSize];
196	Bool_t *pre = new Bool_t[fSize];
197	for(Int_t i=0; i<fSize;i++){
198	tmp[i] = fTrack[i];
199	pre[i] = fIsPresent[i];
200	}
201	delete[] fTrack;
202	delete[] fIsPresent;
203	fTrack = new AliHLTTPCTrack*[newsize];
204	fIsPresent = new Bool_t[newsize];
205	for(Int_t i=0; i<fSize;i++){
206	fTrack[i] = tmp[i];
207	fIsPresent[i] = pre[i];
208	}
209	delete[] tmp;
210	delete[] pre;
211	switch(fTrackType){
212	case 't':
213	for(Int_t i=fSize;i<newsize;i++){
214	fTrack[i] = new AliHLTTPCTrack();
215	fIsPresent[i] = kTRUE;
216	}
217	break;
218	case 'c':
219	for(Int_t i=fSize;i<newsize;i++){
220	fTrack[i] = new AliHLTTPCConfMapTrack();
221	fIsPresent[i] = kTRUE;
222	}
223	break;
224	#ifdef INCLUDE_TPC_HOUGH
225	case 'h':
226	for(Int_t i=fSize;i<newsize;i++){
227	fTrack[i] = new AliHLTTPCHoughTrack();
228	fIsPresent[i] = kTRUE;
229	}
230	break;
231	#endif
232	case 'm':
233	for(Int_t i=fSize;i<newsize;i++){
234	fTrack[i] = new AliHLTTPCModelTrack();
235	fIsPresent[i] = kTRUE;
236	}
237	break;
238	default:
239	return kFALSE;
240	}
241	fSize = newsize;
242	return kTRUE;
243	}
244
245	void AliHLTTPCTrackArray::Reset()
246	{
247	//reset
248	fNTracks=0;
249	fNAbsent=0;
250	for(Int_t i=0; i<fSize;i++)
251	fIsPresent[i] = kTRUE;
252	}
253
254	void AliHLTTPCTrackArray::Remove(Int_t track)
255	{
256	//remove track
257	if(fIsPresent[track]){
258	fIsPresent[track]=kFALSE;
259	fNAbsent++;
260	}
261	}
262
4fdaad1e	263	void AliHLTTPCTrackArray::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr,Int_t slice, Int_t bTransform)
a6c02c85	264	{
	265	//Read tracks from shared memory (or memory)
	266	AliHLTTPCTrackSegmentData *trs = tr;
	267	for(Int_t i=0; i<ntracks; i++){
	268	AliHLTTPCTrack *track = NextTrack();
	269	track->SetPt(trs->fPt);
	270	track->SetPterr(trs->fPterr);
	271	Float_t psi[1];
	272	psi[0]=trs->fPsi;
4fdaad1e	273	if (slice>=0 && bTransform!=0) {
	274	AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
	275	}
	276	//cout << "psi " << psi[0] << endl;
a6c02c85	277	track->SetPsi(psi[0]);
	278	track->SetTgl(trs->fTgl);
	279	track->SetPsierr(trs->fPsierr);
	280	track->SetTglerr(trs->fTglerr);
	281	track->SetNHits(trs->fNPoints);
	282	track->SetCharge(trs->fCharge);
	283	Float_t first[3];
	284	first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
4fdaad1e	285	if (slice>=0 && bTransform!=0) {
	286	AliHLTTPCTransform::Local2Global(first,slice);
	287	}
	288	//cout << "first point: " << first[0] << " " << first[1] << " " << first[3] << endl;
a6c02c85	289	track->SetFirstPoint(first[0],first[1],first[2]);
	290	Float_t last[3];
	291	last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
4fdaad1e	292	if (slice>=0 && bTransform!=0) {
	293	AliHLTTPCTransform::Local2Global(last,slice);
	294	}
	295	//cout << "last point: " << last[0] << " " << last[1] << " " << last[3] << endl;
a6c02c85	296	track->SetLastPoint(last[0],last[1],last[2]);
a6c02c85	297	track->SetHits( trs->fNPoints, trs->fPointIDs );
4fdaad1e	298
4fdaad1e	299	if (slice>=0 && bTransform!=0) {
4e57c862	300	// Matthias Feb07: as everything is now in global coordinates, sector should
	301	// be set to 0. But as the display does a check on the sector, we have to set
	302	// it to the slice no. I suspect, that the transformation is done twice.
	303	//track->SetSector(0);
	304	track->SetSector(slice);
4fdaad1e	305	} else {
	306	// the parameters are in local coordinates, set the sector no
	307	#ifndef INCLUDE_TPC_HOUGH
	308	if (slice<0) track->SetSector(0);
	309	else track->SetSector(slice);
	310	#else
	311	// Matthias Feb 2007: this is some kind of legacy ...
	312	// the INCLUDE_TPC_HOUGH has never been switched on in the new TPCLib
	313	// and this line was below in the corresponding block. As the slice
	314	// parameter is very useful but not available if the define is off
	315	// we distinguish the two cases here. Should be cleaned up.
	316	track->SetSector(trs->fSector);
	317	#endif // INCLUDE_TPC_HOUGH
	318	}
21b6a334	319
	320	// this is currently a quick hack for straight lines of the first version
	321	// of the CA tracker.
	322	// we have to think about a more general way of treating straight and curved
	323	// tracks
	324	if ( trs->fPt == -9876.0 \|\| trs->fPt == -1.0) {
	325	track->SetPhi0(atan2(first[1],first[0]));
	326	track->SetKappa(1.0);
	327	track->SetRadius(999999.0);
	328	} else {
4e57c862	329	// Matthias Feb07: just tried to take this away, but this causes the tracks
	330	// in the display not to be drawn. But we still have to tink about this.
	331	track->CalculateHelix();
21b6a334	332	}
21b6a334	333
a6c02c85	334	#ifdef INCLUDE_TPC_HOUGH
	335	#ifdef ROWHOUGHPARAMS
	336	if(GetTrackType()=='h') {
	337	((AliHLTTPCHoughTrack *)track)->SetWeight(trs->fWeight);
	338	((AliHLTTPCHoughTrack *)track)->SetBinXY(trs->fBinX,trs->fBinY,trs->fBinXSize,trs->fBinYSize);
	339	}
	340	track->SetMCid(trs->fTrackID);
	341	track->SetRowRange(trs->fRowRange1,trs->fRowRange2);
a6c02c85	342	track->SetPID(trs->fPID);
	343	#endif
	344	#endif // INCLUDE_TPC_HOUGH
	345	UChar_t tmpP = (UChar_t)trs;
	346	tmpP += sizeof(AliHLTTPCTrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
	347	trs = (AliHLTTPCTrackSegmentData*)tmpP;
	348	}
	349	}
	350
	351	UInt_t AliHLTTPCTrackArray::GetOutSize()
	352	{
	353	//get size for IO
	354	UInt_t count = GetOutCount(); //use only present tracks
	355	UInt_t tHits = 0;
	356	for(Int_t i=0;i<fNTracks;i++){ //loop over all tracks
	357	AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
	358	if(track) //use only present tracks
	359	tHits += track->GetNHits();
	360	}
	361
	362	//calculate size of track
	363	return countsizeof(AliHLTTPCTrackSegmentData)+sizeof(UInt_t)tHits;
	364	}
	365
	366	UInt_t AliHLTTPCTrackArray::WriteTracks(UInt_t & ntracks,AliHLTTPCTrackSegmentData* tr)
	367	{
	368	//write tracks
	369	ntracks = GetOutCount();
	370	return WriteTracks(tr);
	371	}
	372
	373	UInt_t AliHLTTPCTrackArray::WriteTracks(AliHLTTPCTrackSegmentData* tr)
	374	{
	375	//if(GetTrackType()=='c') return WriteConfMapTracks(tr);
	376	AliHLTTPCTrackSegmentData *tP = tr;
	377	UInt_t *pP;
	378	UInt_t size = 0;
	379	for(Int_t i=0; i<fNTracks; i++){ //loop over all tracks
	380	AliHLTTPCTrack *track = GetCheckedTrack(i); //use only present tracks
	381	if(!track) continue; //use only present tracks
	382	tP->fX = track->GetFirstPointX();
	383	tP->fY = track->GetFirstPointY();
	384	tP->fZ = track->GetFirstPointZ();
	385	tP->fPt = track->GetPt();
	386	tP->fPterr = track->GetPterr();
	387	tP->fLastX = track->GetLastPointX();
	388	tP->fLastY = track->GetLastPointY();
	389	tP->fLastZ = track->GetLastPointZ();
	390	tP->fPsi = track->GetPsi();
	391	tP->fTgl = track->GetTgl();
	392	tP->fPsierr = track->GetPsierr();
	393	tP->fTglerr = track->GetTglerr();
	394	tP->fCharge = track->GetCharge();
	395	tP->fNPoints = track->GetNHits();
	396	#ifdef INCLUDE_TPC_HOUGH
	397	#ifdef ROWHOUGHPARAMS
	398	if(GetTrackType()=='h') {
	399	tP->fWeight = ((AliHLTTPCHoughTrack *)track)->GetWeight();
	400	tP->fBinX = ((AliHLTTPCHoughTrack *)track)->GetBinX();
	401	tP->fBinY = ((AliHLTTPCHoughTrack *)track)->GetBinY();
	402	tP->fBinXSize = ((AliHLTTPCHoughTrack *)track)->GetSizeX();
	403	tP->fBinYSize = ((AliHLTTPCHoughTrack *)track)->GetSizeY();
	404	}
	405	tP->fTrackID = track->GetMCid();
406	tP->fRowRange1 = track->GetFirstRow();
407	tP->fRowRange2 = track->GetLastRow();
408	tP->fSector = track->GetSector();
409	tP->fPID = track->GetPID();
410	#endif
411	#endif // INCLUDE_TPC_HOUGH
412	pP = (UInt_t*)track->GetHitNumbers();
413	for (UInt_t j=0;j<tP->fNPoints;j++){
414	tP->fPointIDs[j] = pP[j];
415	}
416	Byte_t tmpP = (Byte_t )tP;
417	tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
418	size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
419	tP = (AliHLTTPCTrackSegmentData*)tmpP;
738c049f	420
738c049f	421	// BEGINN ############################################## MODIFIY JMT
db16520a	422	// LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::WriteTracks","TRACKPARAMETER") <<ENDLOG;
	423	// track->Rotate(0,kFALSE);
	424	// track->Print();
738c049f	425	// END ################################################# MODIFIY JMT
738c049f	426
a6c02c85	427	}
	428	return size;
	429	}
	430
	431	UInt_t AliHLTTPCTrackArray::WriteConfMapTracks(AliHLTTPCTrackSegmentData* tr)
	432	{
	433	// use first and last point objects
	434	AliHLTTPCTrackSegmentData *tP = tr;
	435	UInt_t *pP;
	436	UInt_t size = 0;
	437	for(Int_t i=0; i<fNTracks; i++){ //loop over all tracks
	438	AliHLTTPCConfMapTrack track =(AliHLTTPCConfMapTrack ) GetCheckedTrack(i); //use only present tracks
	439	if(!track) continue; //use only present tracks
	440	AliHLTTPCConfMapPoint hit = (AliHLTTPCConfMapPoint)track->GetLastHit();
	441	AliHLTTPCConfMapPoint lastHit = (AliHLTTPCConfMapPoint)track->GetFirstHit();
	442	tP->fX = hit->GetX();
	443	tP->fY = hit->GetY();
	444	tP->fZ = hit->GetZ();
	445	tP->fLastX = lastHit->GetX();
	446	tP->fLastY = lastHit->GetY();
	447	tP->fLastZ = lastHit->GetZ();
	448
	449	// tP->fX = track->GetFirstPointX();
	450	// tP->fY = track->GetFirstPointY();
	451	// tP->fZ = track->GetFirstPointZ();
	452	tP->fPt = track->GetPt();
	453	tP->fPterr = track->GetPterr();
	454	// tP->fLastX = track->GetLastPointX();
	455	// tP->fLastY = track->GetLastPointY();
	456	// tP->fLastZ = track->GetLastPointZ();
	457	tP->fPsi = track->GetPsi();
	458	tP->fTgl = track->GetTgl();
	459	tP->fPsierr = track->GetPsierr();
	460	tP->fTglerr = track->GetTglerr();
	461	tP->fCharge = track->GetCharge();
	462	#ifdef INCLUDE_TPC_HOUGH
	463	#ifdef ROWHOUGHPARAMS
	464	tP->fTrackID = track->GetMCid();
	465	tP->fRowRange1 = track->GetFirstRow();
	466	tP->fRowRange2 = track->GetLastRow();
	467	tP->fSector = track->GetSector();
	468	tP->fPID = track->GetPID();
	469	#endif
	470	#endif // INCLUDE_TPC_HOUGH
	471	tP->fNPoints = track->GetNHits();
	472	pP = (UInt_t*)track->GetHitNumbers();
	473	for (UInt_t j=0;j<tP->fNPoints;j++){
	474	tP->fPointIDs[j] = pP[j];
	475	}
	476	Byte_t tmpP = (Byte_t )tP;
	477	tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
	478	size +=sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
	479	tP = (AliHLTTPCTrackSegmentData*)tmpP;
	480	}
	481	return size;
	482	}
	483
	484	void AliHLTTPCTrackArray::AddLast(AliHLTTPCTrack *track)
	485	{
	486	//add track to last position
	487	AliHLTTPCTrack *tpt = NextTrack();
3cde846d	488	tpt->Copy(track);
a6c02c85	489
	490	}
	491
	492	void AliHLTTPCTrackArray::AddTracks(AliHLTTPCTrackArray *newtrack,Bool_t remove_old,Int_t slice)
	493	{
	494	//add tracks
	495	if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
	496	{
	497	LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::AddTracks","Track types")
	498	<<"Bad idea to add tracks of different types"<<ENDLOG;
	499	return;
	500	}
	501	if(fSize < fNTracks+newtrack->GetNPresent())
	502	SetSize(fSize+newtrack->GetSize());
	503	for(Int_t i =0;i<newtrack->GetNTracks();i++){
	504	AliHLTTPCTrack *tpt = newtrack->GetCheckedTrack(i);
	505	if(!tpt) continue;
	506	if(remove_old)
	507	newtrack->Remove(i);
	508	AliHLTTPCTrack *track = NextTrack();
3cde846d	509	track->Copy(tpt);
a6c02c85	510	if(slice>=0)
	511	track->Rotate(slice); //Rotate track to global coordinates
	512	/*
	513	AliHLTTPCTrack *track;
	514	#ifdef INCLUDE_TPC_HOUGH
	515	if(GetTrackType()=='h')
	516	track = (AliHLTTPCHoughTrack*)NextTrack();
	517	else
	518	#endif
	519	track = NextTrack();
3cde846d	520	track->Copy(tpt);
a6c02c85	521	*/
	522	}
	523	}
	524
	525	void AliHLTTPCTrackArray::Compress()
	526	{
	527	//compress array
	528	if(GetNPresent()==GetNTracks()) return;
	529	AliHLTTPCTrack *tmp = new AliHLTTPCTrack [fNTracks];
	530	Int_t present=0;
	531	Int_t absent=GetNPresent();
	532	for(Int_t i=0;i<GetNTracks();i++){
	533	if(fIsPresent[i]) tmp[present++] = fTrack[i];
	534	else tmp[absent++] = fTrack[i];
	535	}
	536	for(Int_t i=0;i<GetNTracks();i++)
	537	fIsPresent[i]=kTRUE;
	538
	539	//Copy pointers back
	540	for(Int_t i=0; i<GetNTracks();i++){
	541	fTrack[i]=tmp[i];
	542	}
	543
	544	delete[] tmp;
	545
	546	fNTracks = GetNPresent();
	547	fNAbsent = 0;
	548	}
	549
	550	void AliHLTTPCTrackArray::QSort()
	551	{
	552	// compress and sort
	553	Compress();
	554	QSort(fTrack,0,fNTracks);
	555	}
	556
	557	void AliHLTTPCTrackArray::QSort( AliHLTTPCTrack **a, Int_t first, Int_t last)
	558	{
	559	// Sort array of AliHLTTPCTrack pointers using a quicksort algorithm.
	560	// Uses TrackCompare() to compare objects.
	561	// Thanks to Root!
	562
	563	static AliHLTTPCTrack *tmp;
	564	static int i; // "static" to save stack space
	565	int j;
	566
	567	while (last - first > 1) {
	568	i = first;
	569	j = last;
	570	for (;;) {
	571	while (++i < last && TrackCompare(a[i], a[first]) < 0)
	572	;
	573	while (--j > first && TrackCompare(a[j], a[first]) > 0)
	574	;
	575	if (i >= j)
	576	break;
	577
	578	tmp = a[i];
	579	a[i] = a[j];
	580	a[j] = tmp;
	581	}
	582	if (j == first) {
	583	++first;
	584	continue;
585	}
586	tmp = a[first];
587	a[first] = a[j];
588	a[j] = tmp;
589	if (j - first < last - (j + 1)) {
590	QSort(a, first, j);
591	first = j + 1; // QSort(j + 1, last);
592	} else {
593	QSort(a, j + 1, last);
594	last = j; // QSort(first, j);
595	}
596	}
597	}
598
599	Int_t AliHLTTPCTrackArray::TrackCompare(AliHLTTPCTrack a, AliHLTTPCTrack b) const
600	{
601	// Compare the two tracks.
602
603	return b->Compare(a);
604
605	/*
606	#ifdef INCLUDE_TPC_HOUGH
607	if(fTrackType=='h')
608	{
609	AliHLTTPCHoughTrack tra = (AliHLTTPCHoughTrack)a;
610	AliHLTTPCHoughTrack trb = (AliHLTTPCHoughTrack)b;
611	if(tra->GetWeight() < trb->GetWeight()) return 1;
612	if(tra->GetWeight() > trb->GetWeight()) return -1;
613	}
614	else
615	#endif
616	{
617	if(a->GetNHits() < b->GetNHits()) return 1;
618	if(a->GetNHits() > b->GetNHits()) return -1;
619	}
620
621	return 0;
622	*/
623	}
624
3cde846d	625	AliHLTTPCTrack* AliHLTTPCTrackArray::operator[](int index)
3cde846d	626	{
4fdaad1e	627	// access operator
3cde846d	628	if (index<fNTracks) return fTrack[index];
	629	return NULL;
	630	}