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

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

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

//_____________________________________________________________
// AliL3TrackArray
//
// Track array class 
//

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