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

//Author:        Uli Frankenfeld
//Last Modified: 06.12.2000

#include <math.h>
#include <string.h>
#include <iostream.h>
#include "AliL3Logging.h"
#include "AliL3TrackArray.h"
#include "AliL3HoughTrack.h"
#include "AliL3ConfMapTrack.h"
#include "AliL3TrackSegmentData.h"
#include "AliL3Transform.h"
#include "AliL3ConfMapPoint.h"
//_____________________________________________________________
//
// The L3 TrackArray 
//

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';
  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';
  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;
      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;
    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 );
    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, AliL3Transform* trans){
  //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;
    trans->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;
    trans->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;
    trans->Local2Global(last,slice);
    track->SetLastPoint(last[0],last[1],last[2]);
    track->SetHits( trs->fNPoints, trs->fPointIDs );
    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();
    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();
    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){
  if(GetTrackType() != newtrack->GetTrackType())
    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);

  }
}


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.

  if(a->GetNHits() < b->GetNHits()) return 1;
  if(a->GetNHits() > b->GetNHits()) return -1;
  return 0;
}
Commit	Line	Data
108615fc	1	//Author: Uli Frankenfeld
	2	//Last Modified: 06.12.2000
	3
	4	#include <math.h>
	5	#include <string.h>
	6	#include <iostream.h>
	7	#include "AliL3Logging.h"
	8	#include "AliL3TrackArray.h"
	9	#include "AliL3HoughTrack.h"
	10	#include "AliL3ConfMapTrack.h"
	11	#include "AliL3TrackSegmentData.h"
	12	#include "AliL3Transform.h"
	13	#include "AliL3ConfMapPoint.h"
	14	//_____________________________________________________________
	15	//
	16	// The L3 TrackArray
	17	//
	18
	19	ClassImp(AliL3TrackArray)
	20
	21	AliL3TrackArray::AliL3TrackArray(){
	22	//Default constructor
	23	fSize = 0;
	24	fNTracks=0;
	25	fNAbsent=0;
	26	fTrackType='t';
	27	SetSize();
	28	}
	29
	30
	31	AliL3TrackArray::AliL3TrackArray(Int_t ntrack){
	32	//Constructor.
	33	fSize = 0;
	34	fNTracks=0;
	35	fNAbsent=0;
	36	fTrackType='t';
	37	SetSize(ntrack);
	38	}
	39
	40	AliL3TrackArray::AliL3TrackArray(char* tracktype,Int_t ntrack){
	41	//Constructor.
	42	fSize = 0;
	43	fNTracks=0;
	44	fNAbsent=0;
	45	if(strcmp(tracktype,"AliL3Track")==0) fTrackType='t';
	46	if(strcmp(tracktype,"AliL3ConfMapTrack")==0) fTrackType='c';
	47	if(strcmp(tracktype,"AliL3HoughTrack")==0) fTrackType='h';
	48	SetSize(ntrack);
	49	}
	50
	51	AliL3TrackArray::AliL3TrackArray(char* tracktype){
	52	//Constructor.
	53	fSize = 0;
	54	fNTracks=0;
	55	fNAbsent=0;
	56	if(strcmp(tracktype,"AliL3Track")==0) fTrackType='t';
	57	if(strcmp(tracktype,"AliL3ConfMapTrack")==0) fTrackType='c';
	58	if(strcmp(tracktype,"AliL3HoughTrack")==0) fTrackType='h';
	59	SetSize();
	60	}
	61
	62
	63	AliL3TrackArray::~AliL3TrackArray(){
	64	//Destructor
65	DeleteArray();
66	}
67
68
69	AliL3Track *AliL3TrackArray::NextTrack(){
70	if(fNTracks<fSize) return fTrack[fNTracks++];
71	SetSize(fSize+100);
72	return fTrack[fNTracks++];
73	}
74
75	void AliL3TrackArray::DeleteArray(){
76	for(Int_t i=0; i<fSize;i++)
77	delete fTrack[i];
78	delete[] fIsPresent;
79	delete[] fTrack;
80	}
81
82	Bool_t AliL3TrackArray::SetSize(Int_t newsize){
83	if(newsize<=fSize) return kFALSE; //shrink comes later!!
84	if(!fSize){
85	fSize = newsize;
86	fTrack = new AliL3Track*[fSize];
87	fIsPresent = new Bool_t[fSize];
88	switch(fTrackType){
89	case 't':
90	for(Int_t i=0;i<fSize;i++){
91	fTrack[i] = new AliL3Track();
92	fIsPresent[i] = kTRUE;
93	}
94	break;
95	case 'c':
96	for(Int_t i=0;i<fSize;i++){
97	fTrack[i] = new AliL3ConfMapTrack();
98	fIsPresent[i] = kTRUE;
99	}
100	break;
101	case 'h':
102	for(Int_t i=0;i<fSize;i++){
103	fTrack[i] = new AliL3HoughTrack();
104	fIsPresent[i] = kTRUE;
105	}
106	break;
107	default:
108	return kFALSE;
109	}
110	return kTRUE;
111	}
112	AliL3Track *tmp = new AliL3Track[fSize];
113	Bool_t *pre = new Bool_t[fSize];
114	for(Int_t i=0; i<fSize;i++){
115	tmp[i] = fTrack[i];
116	pre[i] = fIsPresent[i];
117	}
118	delete[] fTrack;
119	delete[] fIsPresent;
12d59a2a	120	fTrack = new AliL3Track*[newsize];
108615fc	121	fIsPresent = new Bool_t[newsize];
	122	for(Int_t i=0; i<fSize;i++){
	123	fTrack[i] = tmp[i];
	124	fIsPresent[i] = pre[i];
	125	}
	126	delete[] tmp;
	127	delete[] pre;
	128	switch(fTrackType){
	129	case 't':
	130	for(Int_t i=fSize;i<newsize;i++){
	131	fTrack[i] = new AliL3Track();
	132	fIsPresent[i] = kTRUE;
	133	}
	134	break;
	135	case 'c':
	136	for(Int_t i=fSize;i<newsize;i++){
	137	fTrack[i] = new AliL3ConfMapTrack();
	138	fIsPresent[i] = kTRUE;
	139	}
	140	break;
	141	case 'h':
	142	for(Int_t i=fSize;i<newsize;i++){
	143	fTrack[i] = new AliL3HoughTrack();
	144	fIsPresent[i] = kTRUE;
	145	}
	146	break;
	147	default:
	148	return kFALSE;
	149	}
	150	fSize = newsize;
	151	return kTRUE;
	152	}
	153
	154	void AliL3TrackArray::Reset(){
	155	fNTracks=0;
	156	fNAbsent=0;
	157	for(Int_t i=0; i<fSize;i++)
	158	fIsPresent[i] = kTRUE;
	159	}
	160
	161	void AliL3TrackArray::Remove(Int_t track){
	162	if(fIsPresent[track]){
	163	fIsPresent[track]=kFALSE;
	164	fNAbsent++;
	165	}
	166	}
	167
	168	void AliL3TrackArray::FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr){
	169	//Read tracks from shared memory (or memory)
	170	AliL3TrackSegmentData *trs = tr;
	171	for(Int_t i=0; i<ntracks; i++){
	172	AliL3Track *track = NextTrack();
	173	track->SetPt(trs->fPt);
	174	track->SetPsi(trs->fPsi);
	175	track->SetTgl(trs->fTgl);
	176	track->SetNHits(trs->fNPoints);
	177	track->SetCharge(trs->fCharge);
	178	track->SetFirstPoint(trs->fX,trs->fY,trs->fZ);
	179	track->SetLastPoint(trs->fLastX,trs->fLastY,trs->fLastZ);
	180	track->SetHits( trs->fNPoints, trs->fPointIDs );
	181	UChar_t tmpP = (UChar_t)trs;
	182	tmpP += sizeof(AliL3TrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
	183	trs = (AliL3TrackSegmentData*)tmpP;
	184	}
185	}
186
187	void AliL3TrackArray::FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr,Int_t slice, AliL3Transform* trans){
188	//Read tracks from shared memory (or memory)
189	AliL3TrackSegmentData *trs = tr;
190	for(Int_t i=0; i<ntracks; i++){
191	AliL3Track *track = NextTrack();
192	track->SetPt(trs->fPt);
193	Float_t psi[1];
194	psi[0]=trs->fPsi;
195	trans->Local2GlobalAngle(psi,slice);
196	track->SetPsi(psi[0]);
197	track->SetTgl(trs->fTgl);
198	track->SetNHits(trs->fNPoints);
199	track->SetCharge(trs->fCharge);
200	Float_t first[3];
201	first[0]=trs->fX;first[1]=trs->fY;first[2]=trs->fZ;
202	trans->Local2Global(first,slice);
203	track->SetFirstPoint(first[0],first[1],first[2]);
204	Float_t last[3];
205	last[0]=trs->fLastX;last[1]=trs->fLastY;last[2]=trs->fLastZ;
206	trans->Local2Global(last,slice);
207	track->SetLastPoint(last[0],last[1],last[2]);
208	track->SetHits( trs->fNPoints, trs->fPointIDs );
209	UChar_t tmpP = (UChar_t)trs;
210	tmpP += sizeof(AliL3TrackSegmentData)+trs->fNPoints*sizeof(UInt_t);
211	trs = (AliL3TrackSegmentData*)tmpP;
212	}
213	}
214
215	UInt_t AliL3TrackArray::GetOutSize(){
216	UInt_t count = GetOutCount(); //use only present tracks
217	UInt_t tHits = 0;
218	for(Int_t i=0;i<fNTracks;i++){ //loop over all tracks
219	AliL3Track *track = GetCheckedTrack(i); //use only present tracks
220	if(track) //use only present tracks
221	tHits += track->GetNHits();
222	}
223
224	//calculate size of track
225	return countsizeof(AliL3TrackSegmentData)+sizeof(UInt_t)tHits;
226	}
227
228	UInt_t AliL3TrackArray::WriteTracks(UInt_t & ntracks,AliL3TrackSegmentData* tr){
229	ntracks = GetOutCount();
230	return WriteTracks(tr);
231	}
232
233	UInt_t AliL3TrackArray::WriteTracks(AliL3TrackSegmentData* tr){
234	if(GetTrackType()=='c') return WriteConfMapTracks(tr);
235	AliL3TrackSegmentData *tP = tr;
236	UInt_t *pP;
237	UInt_t size = 0;
238	for(Int_t i=0; i<fNTracks; i++){ //loop over all tracks
239	AliL3Track *track = GetCheckedTrack(i); //use only present tracks
240	if(!track) continue; //use only present tracks
241	tP->fX = track->GetFirstPointX();
242	tP->fY = track->GetFirstPointY();
243	tP->fZ = track->GetFirstPointZ();
244	tP->fPt = track->GetPt();
245	tP->fLastX = track->GetLastPointX();
246	tP->fLastY = track->GetLastPointY();
247	tP->fLastZ = track->GetLastPointZ();
248	tP->fPsi = track->GetPsi();
249	tP->fTgl = track->GetTgl();
250	tP->fCharge = track->GetCharge();
251	tP->fNPoints = track->GetNHits();
252	pP = (UInt_t*)track->GetHitNumbers();
253	for (UInt_t j=0;j<tP->fNPoints;j++){
254	tP->fPointIDs[j] = pP[j];
255	}
256	Byte_t tmpP = (Byte_t )tP;
257	tmpP += sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
258	size += sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
259	tP = (AliL3TrackSegmentData*)tmpP;
260	}
261	return size;
262	}
263
264	UInt_t AliL3TrackArray::WriteConfMapTracks(AliL3TrackSegmentData* tr){
265	// use first and last point objects
266	AliL3TrackSegmentData *tP = tr;
267	UInt_t *pP;
268	UInt_t size = 0;
269	for(Int_t i=0; i<fNTracks; i++){ //loop over all tracks
270	AliL3ConfMapTrack track =(AliL3ConfMapTrack ) GetCheckedTrack(i); //use only present tracks
271	if(!track) continue; //use only present tracks
272	AliL3ConfMapPoint hit = (AliL3ConfMapPoint)track->lastHit;
273	AliL3ConfMapPoint lastHit = (AliL3ConfMapPoint)track->firstHit;
274	tP->fX = hit->GetX();
275	tP->fY = hit->GetY();
276	tP->fZ = hit->GetZ();
277	tP->fLastX = lastHit->GetX();
278	tP->fLastY = lastHit->GetY();
279	tP->fLastZ = lastHit->GetZ();
280
281	// tP->fX = track->GetFirstPointX();
282	// tP->fY = track->GetFirstPointY();
283	// tP->fZ = track->GetFirstPointZ();
284	tP->fPt = track->GetPt();
285	// tP->fLastX = track->GetLastPointX();
286	// tP->fLastY = track->GetLastPointY();
287	// tP->fLastZ = track->GetLastPointZ();
288	tP->fPsi = track->GetPsi();
289	tP->fTgl = track->GetTgl();
290	tP->fCharge = track->GetCharge();
291	tP->fNPoints = track->GetNHits();
292	pP = (UInt_t*)track->GetHitNumbers();
293	for (UInt_t j=0;j<tP->fNPoints;j++){
294	tP->fPointIDs[j] = pP[j];
295	}
296	Byte_t tmpP = (Byte_t )tP;
297	tmpP += sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
298	size +=sizeof(AliL3TrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
299	tP = (AliL3TrackSegmentData*)tmpP;
300	}
301	return size;
302	}
303
2e843b99	304	void AliL3TrackArray::AddLast(AliL3Track *track)
	305	{
	306	AliL3Track *tpt = NextTrack();
	307	tpt->Set(track);
44fd1eb4	308
2e843b99	309	}
	310
	311
15846008	312	void AliL3TrackArray::AddTracks(AliL3TrackArray *newtrack,Bool_t remove_old){
108615fc	313	if(GetTrackType() != newtrack->GetTrackType())
	314	return;
	315	if(fSize < fNTracks+newtrack->GetNPresent())
	316	SetSize(fSize+newtrack->GetSize());
	317	for(Int_t i =0;i<newtrack->GetNTracks();i++){
	318	AliL3Track *tpt = newtrack->GetCheckedTrack(i);
	319	if(!tpt) continue;
15846008	320	if(remove_old)
15846008	321	newtrack->Remove(i);
108615fc	322	AliL3Track *track = NextTrack();
ce54fcc8	323	track->Set(tpt);
ce54fcc8	324
108615fc	325	}
	326	}
	327
	328
	329	void AliL3TrackArray::Compress(){
	330	if(GetNPresent()==GetNTracks()) return;
	331	AliL3Track *tmp = new AliL3Track [fNTracks];
	332	Int_t present=0;
	333	Int_t absent=GetNPresent();
	334	for(Int_t i=0;i<GetNTracks();i++){
	335	if(fIsPresent[i]) tmp[present++] = fTrack[i];
	336	else tmp[absent++] = fTrack[i];
	337	}
	338	for(Int_t i=0;i<GetNTracks();i++)
	339	fIsPresent[i]=kTRUE;
	340
	341	//Copy pointers back
	342	for(Int_t i=0; i<GetNTracks();i++){
	343	fTrack[i]=tmp[i];
	344	}
	345
	346	delete[] tmp;
	347
	348	fNTracks = GetNPresent();
	349	fNAbsent = 0;
	350	}
	351
	352	void AliL3TrackArray::QSort(){
	353	// compress an sort
	354	Compress();
	355	QSort(fTrack,0,fNTracks);
	356	}
	357
	358	void AliL3TrackArray::QSort( AliL3Track **a, Int_t first, Int_t last){
	359
	360	// Sort array of AliL3Track pointers using a quicksort algorithm.
	361	// Uses TrackCompare() to compare objects.
	362	// Thanks to Root!
	363
	364	static AliL3Track *tmp;
	365	static int i; // "static" to save stack space
	366	int j;
	367
	368	while (last - first > 1) {
	369	i = first;
	370	j = last;
	371	for (;;) {
	372	while (++i < last && TrackCompare(a[i], a[first]) < 0)
	373	;
	374	while (--j > first && TrackCompare(a[j], a[first]) > 0)
	375	;
	376	if (i >= j)
	377	break;
	378
	379	tmp = a[i];
	380	a[i] = a[j];
	381	a[j] = tmp;
	382	}
	383	if (j == first) {
	384	++first;
	385	continue;
	386	}
	387	tmp = a[first];
	388	a[first] = a[j];
389	a[j] = tmp;
390	if (j - first < last - (j + 1)) {
391	QSort(a, first, j);
392	first = j + 1; // QSort(j + 1, last);
393	} else {
394	QSort(a, j + 1, last);
395	last = j; // QSort(first, j);
396	}
397	}
398	}
399
400	Int_t AliL3TrackArray::TrackCompare(AliL3Track a, AliL3Track b){
401	// Compare the two tracks.
402
403	if(a->GetNHits() < b->GetNHits()) return 1;
404	if(a->GetNHits() > b->GetNHits()) return -1;
405	return 0;
406	}
407
408