[u/mrichter/AliRoot.git] / HLT / src / AliL3TrackArray.cxx

// @(#) $Id$

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

#include "AliL3StandardIncludes.h"

#include "AliL3Logging.h"
#include "AliL3TrackArray.h"
#include "AliL3HoughTrack.h"
#include "AliL3ModelTrack.h"
#include "AliL3ConfMapTrack.h"
#include "AliL3TrackSegmentData.h"
#include "AliL3Transform.h"
#include "AliL3ConfMapPoint.h"

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

ClassImp(AliL3TrackArray)

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


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

AliL3TrackArray::AliL3TrackArray(char* tracktype,Int_t ntrack){
  //Constructor.
  fSize = 0;
  fNTracks=0;
  fNAbsent=0;
  if(strcmp(tracktype,"AliL3Track")==0) fTrackType='t';
  if(strcmp(tracktype,"AliL3ConfMapTrack")==0) fTrackType='c';
  if(strcmp(tracktype,"AliL3HoughTrack")==0) fTrackType='h';
  if(strcmp(tracktype,"AliL3ModelTrack")==0) fTrackType='m';
  SetSize(ntrack);
}

AliL3TrackArray::AliL3TrackArray(char* tracktype){
  //Constructor.
  fSize = 0;
  fNTracks=0;
  fNAbsent=0;
  if(strcmp(tracktype,"AliL3Track")==0) fTrackType='t';
  if(strcmp(tracktype,"AliL3ConfMapTrack")==0) fTrackType='c';
  if(strcmp(tracktype,"AliL3HoughTrack")==0) fTrackType='h';
  if(strcmp(tracktype,"AliL3ModelTrack")==0) fTrackType='m';
  SetSize();
}

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


AliL3Track *AliL3TrackArray::NextTrack(){
  if(fNTracks<fSize) return fTrack[fNTracks++];
  SetSize(fSize+100);
   return fTrack[fNTracks++]; 
}

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

Bool_t AliL3TrackArray::SetSize(Int_t newsize){
  if(newsize<=fSize) return kFALSE; //shrink comes later!! 
  if(!fSize){
    fSize = newsize;
    fTrack = new AliL3Track*[fSize];
    fIsPresent = new Bool_t[fSize];
    switch(fTrackType){
      case 't':
        for(Int_t i=0;i<fSize;i++){
          fTrack[i]   = new AliL3Track();
          fIsPresent[i] = kTRUE;
        }
        break;
      case 'c':  
        for(Int_t i=0;i<fSize;i++){
          fTrack[i]   = new AliL3ConfMapTrack();
          fIsPresent[i] = kTRUE;
        }
        break;
      case 'h':
        for(Int_t i=0;i<fSize;i++){
          fTrack[i]   = new AliL3HoughTrack();
          fIsPresent[i] = kTRUE;
        }
        break;
       case 'm':
        for(Int_t i=0;i<fSize;i++){
          fTrack[i]   = new AliL3ModelTrack();
          fIsPresent[i] = kTRUE;
        }
        break;
      default: 
        return kFALSE;
    }
    return kTRUE;
  }
  AliL3Track **tmp = new AliL3Track*[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 AliL3Track*[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 AliL3Track();
        fIsPresent[i] = kTRUE;
      }
      break;
    case 'c':  
      for(Int_t i=fSize;i<newsize;i++){
        fTrack[i]   = new AliL3ConfMapTrack();
        fIsPresent[i] = kTRUE;
      }
      break;
    case 'h':
      for(Int_t i=fSize;i<newsize;i++){
        fTrack[i]   = new AliL3HoughTrack();
        fIsPresent[i] = kTRUE;
      }
      break;
    case 'm':
      for(Int_t i=fSize;i<newsize;i++){
        fTrack[i]   = new AliL3ModelTrack();
        fIsPresent[i] = kTRUE;
      }
      break;
    default: 
      return kFALSE;
  }
  fSize = newsize;
  return kTRUE;
}

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

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

void AliL3TrackArray::FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr){
  //Read tracks from shared memory (or memory)
  AliL3TrackSegmentData *trs = tr;
   for(Int_t i=0; i<ntracks; i++){
    AliL3Track *track = NextTrack(); 
    track->SetPt(trs->fPt);
    track->SetPsi(trs->fPsi);
    track->SetTgl(trs->fTgl);
    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 ROWHOUGHPARAMS
    if(GetTrackType()=='h') {
      ((AliL3HoughTrack *)track)->SetWeight(trs->fWeight);
      ((AliL3HoughTrack *)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
    UChar_t *tmpP = (UChar_t*)trs;
    tmpP += sizeof(AliL3TrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
    trs = (AliL3TrackSegmentData*)tmpP;
  }
}

void AliL3TrackArray::FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr,Int_t slice){
  //Read tracks from shared memory (or memory)
  AliL3TrackSegmentData *trs = tr;
  for(Int_t i=0; i<ntracks; i++){
    AliL3Track *track = NextTrack(); 
    track->SetPt(trs->fPt);
    Float_t psi[1];
    psi[0]=trs->fPsi;
    AliL3Transform::Local2GlobalAngle(psi,slice);
    track->SetPsi(psi[0]);
    track->SetTgl(trs->fTgl);
    track->SetNHits(trs->fNPoints);
    track->SetCharge(trs->fCharge);
    Float_t first[3];
    first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
    AliL3Transform::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;
    AliL3Transform::Local2Global(last,slice);
    track->SetLastPoint(last[0],last[1],last[2]);
    track->SetHits( trs->fNPoints, trs->fPointIDs );
#ifdef ROWHOUGHPARAMS
    if(GetTrackType()=='h') {
      ((AliL3HoughTrack *)track)->SetWeight(trs->fWeight);
      ((AliL3HoughTrack *)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
    UChar_t *tmpP = (UChar_t*)trs;
    tmpP += sizeof(AliL3TrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
    trs = (AliL3TrackSegmentData*)tmpP;
  }
}

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

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

UInt_t AliL3TrackArray::WriteTracks(UInt_t & ntracks,AliL3TrackSegmentData* tr){
  ntracks = GetOutCount();
  return WriteTracks(tr);
}

UInt_t AliL3TrackArray::WriteTracks(AliL3TrackSegmentData* tr){
  //if(GetTrackType()=='c') return WriteConfMapTracks(tr);
  AliL3TrackSegmentData *tP = tr;
  UInt_t *pP;
  UInt_t size = 0;
  for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
    AliL3Track *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->fLastX = track->GetLastPointX();
    tP->fLastY = track->GetLastPointY();
    tP->fLastZ = track->GetLastPointZ();
    tP->fPsi = track->GetPsi();
    tP->fTgl = track->GetTgl();
    tP->fCharge = track->GetCharge();
    tP->fNPoints = track->GetNHits();
#ifdef ROWHOUGHPARAMS
    if(GetTrackType()=='h') {
      tP->fWeight = ((AliL3HoughTrack *)track)->GetWeight();
      tP->fBinX = ((AliL3HoughTrack *)track)->GetBinX();
      tP->fBinY = ((AliL3HoughTrack *)track)->GetBinY();
      tP->fBinXSize = ((AliL3HoughTrack *)track)->GetSizeX();
      tP->fBinYSize = ((AliL3HoughTrack *)track)->GetSizeY();
    }
    tP->fTrackID = track->GetMCid();
    tP->fRowRange1 = track->GetFirstRow();
    tP->fRowRange2 = track->GetLastRow();
    tP->fSector = track->GetSector();
    tP->fPID = track->GetPID();
#endif
    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(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
    size += sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
    tP = (AliL3TrackSegmentData*)tmpP;
  }
  return size;
}

UInt_t AliL3TrackArray::WriteConfMapTracks(AliL3TrackSegmentData* tr){
  // use first and last point objects
  AliL3TrackSegmentData *tP = tr;
  UInt_t *pP;
  UInt_t size = 0;
  for(Int_t i=0; i<fNTracks; i++){  //loop over all tracks
    AliL3ConfMapTrack *track =(AliL3ConfMapTrack *) GetCheckedTrack(i); //use only present tracks
    if(!track) continue;                           //use only present tracks
    AliL3ConfMapPoint *hit = (AliL3ConfMapPoint*)track->lastHit;
    AliL3ConfMapPoint *lastHit = (AliL3ConfMapPoint*)track->firstHit;
    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->fLastX = track->GetLastPointX();
//    tP->fLastY = track->GetLastPointY();
//    tP->fLastZ = track->GetLastPointZ();
    tP->fPsi = track->GetPsi();
    tP->fTgl = track->GetTgl();
    tP->fCharge = track->GetCharge();
#ifdef ROWHOUGHPARAMS
    tP->fTrackID = track->GetMCid();
    tP->fRowRange1 = track->GetFirstRow();
    tP->fRowRange2 = track->GetLastRow();
    tP->fSector = track->GetSector();
    tP->fPID = track->GetPID();
#endif
    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(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
    size +=sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
    tP = (AliL3TrackSegmentData*)tmpP;
  }
  return size;
}

void AliL3TrackArray::AddLast(AliL3Track *track)
{
  AliL3Track *tpt = NextTrack();
  tpt->Set(track);
  
}

void AliL3TrackArray::AddTracks(AliL3TrackArray *newtrack,Bool_t remove_old,Int_t slice)
{
  if(GetTrackType() != newtrack->GetTrackType() && GetTrackType()!='t')
    {
      LOG(AliL3Log::kError,"AliL3TrackArray::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++){
    AliL3Track *tpt = newtrack->GetCheckedTrack(i);
    if(!tpt) continue;
    if(remove_old)
      newtrack->Remove(i);
    AliL3Track *track = NextTrack();
    track->Set(tpt);
    if(slice>=0)
      track->Rotate(slice); //Rotate track to global coordinates
    /*
      AliL3Track *track;
      if(GetTrackType()=='h')
      track = (AliL3HoughTrack*)NextTrack();
      else
      track = NextTrack();
      track->Set(tpt);
    */
  }
}


void AliL3TrackArray::Compress(){
  if(GetNPresent()==GetNTracks()) return;
  AliL3Track **tmp =  new AliL3Track *[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 AliL3TrackArray::QSort(){
  // compress an sort
  Compress();
  QSort(fTrack,0,fNTracks);
}

void AliL3TrackArray::QSort( AliL3Track **a, Int_t first, Int_t last){

   // Sort array of AliL3Track pointers using a quicksort algorithm.
   // Uses TrackCompare() to compare objects.
   // Thanks to Root! 

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