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


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

#include "AliL3Logging.h"
#include <math.h>
#include <iostream.h>
#include "AliL3Merger.h"
#include "AliL3Track.h"
#include "AliL3TrackSegmentData.h"
#include "AliL3Transform.h"
#include "AliL3TrackArray.h"

#ifdef use_root //use root ntuple for slow merge
#include <TNtuple.h>
#include <TTree.h>
#include <TFile.h>
#endif
//_____________________________________________________________
//
// The L3 merger base class
//

ClassImp(AliL3Merger)

AliL3Merger::AliL3Merger(){
  //Default constructor
  fTransformer= 0;
  SetArray(0);
}


AliL3Merger::AliL3Merger(Int_t ntrackarrays){
  //Constructor.
  SetArray(ntrackarrays);
  fCurrentTracks=0;
}

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

void AliL3Merger::DeleteArray(){
  for(Int_t i=0; i<fNIn;i++)
    delete fInTrack[i];
  delete[] (Byte_t*) fInTrack;
  delete fOutTrack;
}

void AliL3Merger::SetArray(Int_t nin){
  fNIn = nin;
  fInTrack = (AliL3TrackArray **) new Byte_t[fNIn*sizeof(AliL3TrackArray *)];
  for(Int_t i=0; i<fNIn;i++){
    fInTrack[i] = new AliL3TrackArray();
  }
  fOutTrack= new AliL3TrackArray();
}

void AliL3Merger::Reset(){
  for(Int_t i=0; i<fNIn;i++){
    fInTrack[i]->Reset();
  }
  fOutTrack->Reset();
}

void AliL3Merger::FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr){
  //Read tracks from shared memory (or memory)
  AliL3TrackArray *destination = GetInTracks(fCurrentTracks);
  if(Is2Global())
    destination->FillTracks(ntracks, tr, fSlice, fTransformer);
  else
    destination->FillTracks(ntracks, tr);
}

void AliL3Merger::AddAllTracks(){
  for(Int_t i=0; i<GetNIn();i++){
    AliL3TrackArray *in = GetInTracks(i);
    AliL3TrackArray *out = GetOutTracks();
    out->AddTracks(in);
  }
}

void AliL3Merger::SortGlobalTracks(AliL3Track **tracks, Int_t ntrack){
  AliL3Track **tmp = new AliL3Track*[ntrack]; 
  for(Int_t i=0;i<ntrack;i++) tmp[i] = tracks[i];
  Int_t *t = new Int_t[ntrack];
  for(Int_t i=0;i<ntrack;i++) t[i]=-1;

  for(Int_t j=0;j<ntrack;j++){
    Double_t minr=300;
    Int_t    mini=0;
    for(Int_t i=0;i<ntrack;i++){
     if(!tracks[i]) continue;
       Double_t rr=pow(tracks[i]->GetFirstPointX(),2)+pow(tracks[i]->GetFirstPointY(),2);
       Double_t r=sqrt(rr);
       if(r<minr){
         minr=r;
         mini=i;
       }
    }
    t[j]=mini;
    tracks[mini]=0;
  }
  for(Int_t i=0;i<ntrack;i++) tracks[i] = tmp[t[i]];
  delete[] t;
  delete[] tmp;
}


void AliL3Merger::SortTracks(AliL3Track **tracks, Int_t ntrack){
  AliL3Track **tmp = new  AliL3Track*[ntrack];
  for(Int_t i=0;i<ntrack;i++) tmp[i] = tracks[i];
  Int_t *t = new Int_t[ntrack];
  for(Int_t i=0;i<ntrack;i++) t[i]=-1;

  for(Int_t j=0;j<ntrack;j++){
    Double_t minx=300; 
    Int_t    mini=0;
    for(Int_t i=0;i<ntrack;i++){
     if(!tracks[i]) continue;
       if(tracks[i]->GetFirstPointX()<minx){
         minx=tracks[i]->GetFirstPointX();
         mini=i;
       }     
    }
    t[j]=mini;  
    tracks[mini]=0;
  }
  for(Int_t i=0;i<ntrack;i++) tracks[i] = tmp[t[i]];
  delete[] t;
  delete[] tmp;
}

void AliL3Merger::AddTrack(AliL3TrackArray *mergedtrack,AliL3Track *track){
  AliL3Track *t[1];
  t[0] = track;
  MultiMerge(mergedtrack,t,1);
}

AliL3Track * AliL3Merger::MergeTracks(AliL3TrackArray *mergedtrack,AliL3Track *t0,AliL3Track *t1){
  AliL3Track *t[2];
  t[0] = t0; 
  t[1] = t1;
  SortTracks(t,2);
  return MultiMerge(mergedtrack,t,2);
}

AliL3Track * AliL3Merger::MultiMerge(AliL3TrackArray *mergedtracks,AliL3Track **tracks, Int_t ntrack){
// merge the tracks!!

//check npoints
  Int_t nps = 0;
  for(Int_t i=0;i<ntrack;i++){
    nps+=tracks[i]->GetNHits();
  }
  if(nps>176){
    LOG(AliL3Log::kWarning,"AliL3Merger::MultiMerge","Adding Points")
    <<AliL3Log::kDec<<"Too many Points: "<<nps<<ENDLOG;
    return 0;
  }

  //create new track
  AliL3Track *newtrack = mergedtracks->NextTrack();
  //copy points
  UInt_t nn[176];
  nps = 0;

//  for(Int_t i=0;i<ntrack;i++){
  for(Int_t i=ntrack-1;i>=0;i--){
    memcpy(&nn[nps],tracks[i]->GetHitNumbers(),tracks[i]->GetNHits()*sizeof(UInt_t));
    nps+=tracks[i]->GetNHits();
  }
  AliL3Track *tpf=tracks[0];
  AliL3Track *tpl=tracks[ntrack-1];

  newtrack->SetNHits(nps);
  newtrack->SetHits(nps,nn);
  newtrack->SetFirstPoint(tpf->GetFirstPointX(),tpf->GetFirstPointY(),tpf->GetFirstPointZ());
  newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ());
  newtrack->SetPt(tpf->GetPt());
  newtrack->SetPsi(tpf->GetPsi());
  newtrack->SetTgl(tpf->GetTgl());
  newtrack->SetCharge(tpf->GetCharge());
  return newtrack;
}

void* AliL3Merger::GetNtuple(char *varlist){
#ifdef use_root
  TNtuple* nt = new TNtuple("ntuple","ntuple",varlist);
  return (void*) nt;
#else
  return 0;
#endif
}

void* AliL3Merger::GetNtuple(){
#ifdef use_root
  TNtuple* nt = new TNtuple("ntuple","ntuple",
       "dx:dy:dz:dk:dpsi:dtgl:dq:disx:disy:disz:dis:n0:n1:diff:drx:dry:drz");
  return (void*) nt;
#else
  return 0;
#endif
}

Bool_t AliL3Merger::WriteNtuple(char *filename, void* nt){
#ifdef use_root
  TNtuple *ntuple=(TNtuple *) nt;
  TFile *f = new TFile(filename,"RECREATE");
  ntuple->Write();
  f->Close();
  delete ntuple; 
  return kTRUE; 
#else
  return kFALSE;
#endif
}

void AliL3Merger::FillNtuple(void *nt,AliL3Track *innertrack,AliL3Track *outertrack){
  Float_t data[17];
  if(outertrack->IsPoint()&&innertrack->IsPoint()){
    data[0] =Float_t(innertrack->GetPointX()-outertrack->GetPointX());
    data[1] =Float_t(innertrack->GetPointY()-outertrack->GetPointY());
    data[2] =Float_t(innertrack->GetPointZ()-outertrack->GetPointZ());
    data[3] =Float_t(innertrack->GetKappa()-outertrack->GetKappa());
    Double_t psi= innertrack->GetPointPsi() - outertrack->GetPointPsi();
    if(psi>PI) psi-=2*PI;
    if(psi<-PI)psi+=2*PI;
    data[4] =Float_t(psi);
    data[5] =Float_t(innertrack->GetTgl()-outertrack->GetTgl());
    data[6] =Float_t(innertrack->GetCharge()-outertrack->GetCharge());
    data[7] =Float_t(innertrack->GetLastPointX()-outertrack->GetFirstPointX());
    data[8] =Float_t(innertrack->GetLastPointY()-outertrack->GetFirstPointY());
    data[9] =Float_t(innertrack->GetLastPointZ()-outertrack->GetFirstPointZ());
    data[10] =sqrt(pow(data[7],2)+pow(data[8],2)+pow(data[9],2));
    data[11]= outertrack->GetNHits();
    data[12]= innertrack->GetNHits();
    data[13] = Float_t(TrackDiff(innertrack,outertrack));
#ifdef use_root
    TNtuple *ntuple = (TNtuple *) nt;
    ntuple->Fill(data);
#endif
  }
}

void AliL3Merger::FillNtuple(void *nt,Float_t *data){
#ifdef use_root
    TNtuple *ntuple = (TNtuple *) nt;
    ntuple->Fill(data);
#endif
}

Double_t AliL3Merger::GetAngle(Double_t a1,Double_t a2){
  Double_t da = a1 - a2 +4*PI;
  da = fmod(da,2*PI);
  if(da>PI) da = 2*PI -da;
  return da;
}

void AliL3Merger::SetParameter(Double_t maxy, Double_t maxz, Double_t maxkappa, Double_t maxpsi, Double_t maxtgl){
  fMaxY = maxy;
  fMaxZ = maxz;
  fMaxKappa = maxkappa;
  fMaxPsi = maxpsi;
  fMaxTgl = maxtgl;
}

Bool_t AliL3Merger::IsTrack(AliL3Track *innertrack,AliL3Track *outertrack){

  if(innertrack->GetCharge()!=outertrack->GetCharge()) return kFALSE;
  if( (!innertrack->IsPoint()) || (!outertrack->IsPoint()) )  return kFALSE; 
  if(innertrack->GetNHits()+outertrack->GetNHits()>176) return kFALSE;

  if(fabs(innertrack->GetPointY()-outertrack->GetPointY()) >fMaxY) return kFALSE;
  if(fabs(innertrack->GetPointZ()-outertrack->GetPointZ()) >fMaxZ) return kFALSE;
  if(fabs(innertrack->GetKappa()-outertrack->GetKappa())   >fMaxKappa) return kFALSE;
  if(GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi()) >fMaxPsi) return kFALSE;
  if(fabs(innertrack->GetTgl()-outertrack->GetTgl()) >fMaxTgl) return kFALSE;
  //if no rejection up to this point: merge!!
  return kTRUE;
}

Bool_t AliL3Merger::IsRTrack(AliL3Track *innertrack,AliL3Track *outertrack){
  return IsTrack(innertrack,outertrack);
}

Double_t AliL3Merger::TrackDiff(AliL3Track *innertrack,AliL3Track *outertrack){
  Double_t diff =-1;
  Double_t x[4],y[4],z[4],dy[4],dz[4];
  AliL3Track *tracks[2]; 

  tracks[0] = innertrack;
  tracks[1] = outertrack;
  SortGlobalTracks(tracks,2);
  innertrack = tracks[0]; 
  outertrack = tracks[1];

  x[0] = innertrack->GetFirstPointX();
  x[1] = innertrack->GetLastPointX();
  x[2] = outertrack->GetFirstPointX();
  x[3] = outertrack->GetLastPointX();

  y[0] = innertrack->GetFirstPointY();
  y[1] = innertrack->GetLastPointY();
  y[2] = outertrack->GetFirstPointY();
  y[3] = outertrack->GetLastPointY();

  z[0] = innertrack->GetFirstPointZ();
  z[1] = innertrack->GetLastPointZ();
  z[2] = outertrack->GetFirstPointZ();
  z[3] = outertrack->GetLastPointZ();


  outertrack->CalculatePoint(x[0]);
  if(!outertrack->IsPoint()) return diff;
  dy[0] = fabs(y[0] - outertrack->GetPointY());
  dz[0] = fabs(z[0] - outertrack->GetPointZ());

  outertrack->CalculatePoint(x[1]);
  if(!outertrack->IsPoint()) return diff;
  dy[1] = fabs(y[1] - outertrack->GetPointY());
  dz[1] = fabs(z[1] - outertrack->GetPointZ());

  innertrack->CalculatePoint(x[2]);
  if(!innertrack->IsPoint()) return diff;
  dy[2] = fabs(y[2] - innertrack->GetPointY());
  dz[2] = fabs(z[2] - innertrack->GetPointZ());

  innertrack->CalculatePoint(x[3]);
  if(!innertrack->IsPoint()) return diff;
  dy[3] = fabs(y[3] - innertrack->GetPointY());
  dz[3] = fabs(z[3] - innertrack->GetPointZ());

  diff=0;
  for(Int_t i=0;i<4;i++)
    diff+=sqrt(dy[i]*dy[i]+dz[i]*dz[i]);
  return diff; 
}


void AliL3Merger::PrintDiff(AliL3Track *innertrack,AliL3Track *outertrack){
  if(!innertrack->IsPoint()||!outertrack->IsPoint()){
    cerr<<"AliL3Merger::PrintDiff: No Points"<<endl;
    cerr<<"---------------------------"<<endl;
    return;
  } 
  Double_t dx = innertrack->GetPointX()-outertrack->GetPointX();
  Double_t dy = innertrack->GetPointY()-outertrack->GetPointY();
  Double_t dz = innertrack->GetPointZ()-outertrack->GetPointZ();
  Double_t dk = innertrack->GetKappa()-outertrack->GetKappa();
    Double_t dpsi= innertrack->GetPointPsi() - outertrack->GetPointPsi();
    if(dpsi>PI) dpsi-=2*PI;
    if(dpsi<-PI)dpsi+=2*PI;
//  Double_t dpsi = GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi());
  Double_t dtgl= innertrack->GetTgl()-outertrack->GetTgl();
  Double_t dq =innertrack->GetCharge()-outertrack->GetCharge();

  fprintf(stderr,"dx: %4f dy: %4f dz: %4f dk: %4f dpsi: %4f dtgl: %4f dq: %4f\n",
      dx,dy,dz,dk,dpsi,dtgl,dq);
cerr<<"---------------------------"<<endl;
//  cerr<<endl; 

}

void AliL3Merger::Print(){
  // print some infos
  for(Int_t i=0; i<fNIn; i++){
    AliL3TrackArray *ttt= GetInTracks(i);
    for(Int_t j =0;j<ttt->GetNTracks();j++){
      AliL3Track *track=ttt->GetCheckedTrack(j);
      if(!track) continue;
      track->CalculateHelix();
//      Double_t angle = atan2(track->GetLastPointY(),track->GetLastPointX());
//      if(angle<0) angle+=PI;
      if(track->CalculatePoint(135))
//      if(!track->CalculateEdgePoint(angle)) cerr<<"**************"<<endl;     
//      if(track->CalculatePoint(track->GetLastPointX()))
//      if(track->CalculatePoint(0))
      {
//      PrintTrack(track);
//      track->CalculateReferencePoint(PI/180.);
      track->CalculateReferencePoint(0.001);
      fprintf(stderr,"npt: %3d dx: %8.5f dy: %8.5f dz: %8.5f\n",
        track->GetNHits(),(float)track->GetPointX()-track->GetPointX(),
                          (float)track->GetPointY()-track->GetPointY(),
                          (float)track->GetPointZ()-track->GetPointZ());

      cerr<<"---------------------------"<<endl;
      }
    }  
  }
}

void AliL3Merger::PrintTrack(AliL3Track *track){
  fprintf(stderr,"npt: %3d pt: %.2f psi: %.2f tgl: %5.2f q: %2d\n",
    track->GetNHits(),track->GetPt(),track->GetPsi(),
    track->GetTgl(),track->GetCharge());
  fprintf(stderr,
    "x1: %6.2f y1: %6.2f z1: %6.2f xl: %6.2f yl: %6.2f zl: %6.2f\n",
    track->GetFirstPointX(),track->GetFirstPointY(),track->GetFirstPointZ(),
    track->GetLastPointX(),track->GetLastPointY(),track->GetLastPointZ());
  if(track->IsPoint()){
    fprintf(stderr,
      "R: %.2f Xc: %.2f Yc: %.2f Xp: %.2f Yp: %.2f Zp: %.2f Psip: %.2f\n",
      track->GetRadius(),track->GetCenterX(),track->GetCenterY(),
      track->GetPointX(),track->GetPointY(),track->GetPointZ(),
      track->GetPointPsi());
  }
}
Commit	Line	Data
108615fc	1
	2	//Author: Uli Frankenfeld
	3	//Last Modified: 06.12.2000
	4
	5	#include "AliL3Logging.h"
	6	#include <math.h>
	7	#include <iostream.h>
	8	#include "AliL3Merger.h"
	9	#include "AliL3Track.h"
	10	#include "AliL3TrackSegmentData.h"
	11	#include "AliL3Transform.h"
	12	#include "AliL3TrackArray.h"
	13
	14	#ifdef use_root //use root ntuple for slow merge
	15	#include <TNtuple.h>
	16	#include <TTree.h>
	17	#include <TFile.h>
	18	#endif
	19	//_____________________________________________________________
	20	//
	21	// The L3 merger base class
	22	//
	23
	24	ClassImp(AliL3Merger)
	25
	26	AliL3Merger::AliL3Merger(){
	27	//Default constructor
	28	fTransformer= 0;
	29	SetArray(0);
	30	}
	31
	32
	33	AliL3Merger::AliL3Merger(Int_t ntrackarrays){
	34	//Constructor.
	35	SetArray(ntrackarrays);
	36	fCurrentTracks=0;
	37	}
	38
	39	AliL3Merger::~AliL3Merger(){
	40	//Destructor
	41	DeleteArray();
	42	}
	43
	44	void AliL3Merger::DeleteArray(){
	45	for(Int_t i=0; i<fNIn;i++)
	46	delete fInTrack[i];
	47	delete[] (Byte_t*) fInTrack;
	48	delete fOutTrack;
	49	}
	50
	51	void AliL3Merger::SetArray(Int_t nin){
	52	fNIn = nin;
	53	fInTrack = (AliL3TrackArray *) new Byte_t[fNInsizeof(AliL3TrackArray *)];
	54	for(Int_t i=0; i<fNIn;i++){
	55	fInTrack[i] = new AliL3TrackArray();
	56	}
	57	fOutTrack= new AliL3TrackArray();
	58	}
	59
	60	void AliL3Merger::Reset(){
	61	for(Int_t i=0; i<fNIn;i++){
	62	fInTrack[i]->Reset();
	63	}
	64	fOutTrack->Reset();
65	}
66
67	void AliL3Merger::FillTracks(Int_t ntracks, AliL3TrackSegmentData* tr){
68	//Read tracks from shared memory (or memory)
69	AliL3TrackArray *destination = GetInTracks(fCurrentTracks);
70	if(Is2Global())
71	destination->FillTracks(ntracks, tr, fSlice, fTransformer);
72	else
73	destination->FillTracks(ntracks, tr);
74	}
75
76	void AliL3Merger::AddAllTracks(){
77	for(Int_t i=0; i<GetNIn();i++){
78	AliL3TrackArray *in = GetInTracks(i);
79	AliL3TrackArray *out = GetOutTracks();
80	out->AddTracks(in);
81	}
82	}
83
84	void AliL3Merger::SortGlobalTracks(AliL3Track **tracks, Int_t ntrack){
85	AliL3Track *tmp = new AliL3Track[ntrack];
86	for(Int_t i=0;i<ntrack;i++) tmp[i] = tracks[i];
87	Int_t *t = new Int_t[ntrack];
88	for(Int_t i=0;i<ntrack;i++) t[i]=-1;
89
90	for(Int_t j=0;j<ntrack;j++){
91	Double_t minr=300;
92	Int_t mini=0;
93	for(Int_t i=0;i<ntrack;i++){
94	if(!tracks[i]) continue;
95	Double_t rr=pow(tracks[i]->GetFirstPointX(),2)+pow(tracks[i]->GetFirstPointY(),2);
96	Double_t r=sqrt(rr);
97	if(r<minr){
98	minr=r;
99	mini=i;
100	}
101	}
102	t[j]=mini;
103	tracks[mini]=0;
104	}
105	for(Int_t i=0;i<ntrack;i++) tracks[i] = tmp[t[i]];
106	delete[] t;
107	delete[] tmp;
108	}
109
110
111	void AliL3Merger::SortTracks(AliL3Track **tracks, Int_t ntrack){
112	AliL3Track *tmp = new AliL3Track[ntrack];
113	for(Int_t i=0;i<ntrack;i++) tmp[i] = tracks[i];
114	Int_t *t = new Int_t[ntrack];
115	for(Int_t i=0;i<ntrack;i++) t[i]=-1;
116
117	for(Int_t j=0;j<ntrack;j++){
118	Double_t minx=300;
119	Int_t mini=0;
120	for(Int_t i=0;i<ntrack;i++){
121	if(!tracks[i]) continue;
122	if(tracks[i]->GetFirstPointX()<minx){
123	minx=tracks[i]->GetFirstPointX();
124	mini=i;
125	}
126	}
127	t[j]=mini;
128	tracks[mini]=0;
129	}
130	for(Int_t i=0;i<ntrack;i++) tracks[i] = tmp[t[i]];
131	delete[] t;
132	delete[] tmp;
133	}
134
135	void AliL3Merger::AddTrack(AliL3TrackArray mergedtrack,AliL3Track track){
136	AliL3Track *t[1];
137	t[0] = track;
138	MultiMerge(mergedtrack,t,1);
139	}
140
141	AliL3Track * AliL3Merger::MergeTracks(AliL3TrackArray mergedtrack,AliL3Track t0,AliL3Track *t1){
142	AliL3Track *t[2];
143	t[0] = t0;
144	t[1] = t1;
145	SortTracks(t,2);
146	return MultiMerge(mergedtrack,t,2);
147	}
148
149	AliL3Track * AliL3Merger::MultiMerge(AliL3TrackArray mergedtracks,AliL3Track *tracks, Int_t ntrack){
150	// merge the tracks!!
151
152	//check npoints
153	Int_t nps = 0;
154	for(Int_t i=0;i<ntrack;i++){
155	nps+=tracks[i]->GetNHits();
156	}
ae97a0b9	157	if(nps>176){
108615fc	158	LOG(AliL3Log::kWarning,"AliL3Merger::MultiMerge","Adding Points")
	159	<<AliL3Log::kDec<<"Too many Points: "<<nps<<ENDLOG;
	160	return 0;
	161	}
	162
	163	//create new track
	164	AliL3Track *newtrack = mergedtracks->NextTrack();
	165	//copy points
ae97a0b9	166	UInt_t nn[176];
108615fc	167	nps = 0;
	168
	169	// for(Int_t i=0;i<ntrack;i++){
	170	for(Int_t i=ntrack-1;i>=0;i--){
	171	memcpy(&nn[nps],tracks[i]->GetHitNumbers(),tracks[i]->GetNHits()*sizeof(UInt_t));
	172	nps+=tracks[i]->GetNHits();
	173	}
	174	AliL3Track *tpf=tracks[0];
	175	AliL3Track *tpl=tracks[ntrack-1];
	176
	177	newtrack->SetNHits(nps);
	178	newtrack->SetHits(nps,nn);
	179	newtrack->SetFirstPoint(tpf->GetFirstPointX(),tpf->GetFirstPointY(),tpf->GetFirstPointZ());
	180	newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ());
	181	newtrack->SetPt(tpf->GetPt());
	182	newtrack->SetPsi(tpf->GetPsi());
	183	newtrack->SetTgl(tpf->GetTgl());
	184	newtrack->SetCharge(tpf->GetCharge());
	185	return newtrack;
	186	}
	187
	188	void* AliL3Merger::GetNtuple(char *varlist){
	189	#ifdef use_root
	190	TNtuple* nt = new TNtuple("ntuple","ntuple",varlist);
	191	return (void*) nt;
	192	#else
	193	return 0;
	194	#endif
	195	}
	196
	197	void* AliL3Merger::GetNtuple(){
	198	#ifdef use_root
	199	TNtuple* nt = new TNtuple("ntuple","ntuple",
	200	"dx:dy:dz:dk:dpsi:dtgl:dq:disx:disy:disz:dis:n0:n1:diff:drx:dry:drz");
	201	return (void*) nt;
	202	#else
	203	return 0;
	204	#endif
	205	}
	206
	207	Bool_t AliL3Merger::WriteNtuple(char filename, void nt){
	208	#ifdef use_root
	209	TNtuple ntuple=(TNtuple ) nt;
	210	TFile *f = new TFile(filename,"RECREATE");
	211	ntuple->Write();
	212	f->Close();
	213	delete ntuple;
	214	return kTRUE;
	215	#else
	216	return kFALSE;
	217	#endif
	218	}
	219
	220	void AliL3Merger::FillNtuple(void nt,AliL3Track innertrack,AliL3Track *outertrack){
	221	Float_t data[17];
	222	if(outertrack->IsPoint()&&innertrack->IsPoint()){
	223	data[0] =Float_t(innertrack->GetPointX()-outertrack->GetPointX());
	224	data[1] =Float_t(innertrack->GetPointY()-outertrack->GetPointY());
	225	data[2] =Float_t(innertrack->GetPointZ()-outertrack->GetPointZ());
	226	data[3] =Float_t(innertrack->GetKappa()-outertrack->GetKappa());
	227	Double_t psi= innertrack->GetPointPsi() - outertrack->GetPointPsi();
	228	if(psi>PI) psi-=2*PI;
	229	if(psi<-PI)psi+=2*PI;
	230	data[4] =Float_t(psi);
231	data[5] =Float_t(innertrack->GetTgl()-outertrack->GetTgl());
232	data[6] =Float_t(innertrack->GetCharge()-outertrack->GetCharge());
233	data[7] =Float_t(innertrack->GetLastPointX()-outertrack->GetFirstPointX());
234	data[8] =Float_t(innertrack->GetLastPointY()-outertrack->GetFirstPointY());
235	data[9] =Float_t(innertrack->GetLastPointZ()-outertrack->GetFirstPointZ());
236	data[10] =sqrt(pow(data[7],2)+pow(data[8],2)+pow(data[9],2));
237	data[11]= outertrack->GetNHits();
238	data[12]= innertrack->GetNHits();
239	data[13] = Float_t(TrackDiff(innertrack,outertrack));
240	#ifdef use_root
241	TNtuple ntuple = (TNtuple ) nt;
242	ntuple->Fill(data);
243	#endif
244	}
245	}
246
247	void AliL3Merger::FillNtuple(void nt,Float_t data){
248	#ifdef use_root
249	TNtuple ntuple = (TNtuple ) nt;
250	ntuple->Fill(data);
251	#endif
252	}
253
254	Double_t AliL3Merger::GetAngle(Double_t a1,Double_t a2){
255	Double_t da = a1 - a2 +4*PI;
256	da = fmod(da,2*PI);
257	if(da>PI) da = 2*PI -da;
258	return da;
259	}
260
261	void AliL3Merger::SetParameter(Double_t maxy, Double_t maxz, Double_t maxkappa, Double_t maxpsi, Double_t maxtgl){
262	fMaxY = maxy;
263	fMaxZ = maxz;
264	fMaxKappa = maxkappa;
265	fMaxPsi = maxpsi;
266	fMaxTgl = maxtgl;
267	}
268
269	Bool_t AliL3Merger::IsTrack(AliL3Track innertrack,AliL3Track outertrack){
270
271	if(innertrack->GetCharge()!=outertrack->GetCharge()) return kFALSE;
272	if( (!innertrack->IsPoint()) \|\| (!outertrack->IsPoint()) ) return kFALSE;
ae97a0b9	273	if(innertrack->GetNHits()+outertrack->GetNHits()>176) return kFALSE;
108615fc	274
	275	if(fabs(innertrack->GetPointY()-outertrack->GetPointY()) >fMaxY) return kFALSE;
	276	if(fabs(innertrack->GetPointZ()-outertrack->GetPointZ()) >fMaxZ) return kFALSE;
	277	if(fabs(innertrack->GetKappa()-outertrack->GetKappa()) >fMaxKappa) return kFALSE;
	278	if(GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi()) >fMaxPsi) return kFALSE;
	279	if(fabs(innertrack->GetTgl()-outertrack->GetTgl()) >fMaxTgl) return kFALSE;
	280	//if no rejection up to this point: merge!!
	281	return kTRUE;
	282	}
	283
	284	Bool_t AliL3Merger::IsRTrack(AliL3Track innertrack,AliL3Track outertrack){
	285	return IsTrack(innertrack,outertrack);
	286	}
	287
	288	Double_t AliL3Merger::TrackDiff(AliL3Track innertrack,AliL3Track outertrack){
	289	Double_t diff =-1;
	290	Double_t x[4],y[4],z[4],dy[4],dz[4];
	291	AliL3Track *tracks[2];
	292
	293	tracks[0] = innertrack;
	294	tracks[1] = outertrack;
	295	SortGlobalTracks(tracks,2);
	296	innertrack = tracks[0];
	297	outertrack = tracks[1];
	298
	299	x[0] = innertrack->GetFirstPointX();
	300	x[1] = innertrack->GetLastPointX();
	301	x[2] = outertrack->GetFirstPointX();
	302	x[3] = outertrack->GetLastPointX();
	303
	304	y[0] = innertrack->GetFirstPointY();
	305	y[1] = innertrack->GetLastPointY();
	306	y[2] = outertrack->GetFirstPointY();
	307	y[3] = outertrack->GetLastPointY();
	308
	309	z[0] = innertrack->GetFirstPointZ();
	310	z[1] = innertrack->GetLastPointZ();
	311	z[2] = outertrack->GetFirstPointZ();
	312	z[3] = outertrack->GetLastPointZ();
	313
	314
	315	outertrack->CalculatePoint(x[0]);
	316	if(!outertrack->IsPoint()) return diff;
	317	dy[0] = fabs(y[0] - outertrack->GetPointY());
	318	dz[0] = fabs(z[0] - outertrack->GetPointZ());
	319
	320	outertrack->CalculatePoint(x[1]);
	321	if(!outertrack->IsPoint()) return diff;
	322	dy[1] = fabs(y[1] - outertrack->GetPointY());
	323	dz[1] = fabs(z[1] - outertrack->GetPointZ());
	324
	325	innertrack->CalculatePoint(x[2]);
	326	if(!innertrack->IsPoint()) return diff;
	327	dy[2] = fabs(y[2] - innertrack->GetPointY());
	328	dz[2] = fabs(z[2] - innertrack->GetPointZ());
	329
	330	innertrack->CalculatePoint(x[3]);
	331	if(!innertrack->IsPoint()) return diff;
	332	dy[3] = fabs(y[3] - innertrack->GetPointY());
	333	dz[3] = fabs(z[3] - innertrack->GetPointZ());
	334
	335	diff=0;
	336	for(Int_t i=0;i<4;i++)
	337	diff+=sqrt(dy[i]dy[i]+dz[i]dz[i]);
338	return diff;
339	}
340
341
342
343	void AliL3Merger::PrintDiff(AliL3Track innertrack,AliL3Track outertrack){
344	if(!innertrack->IsPoint()\|\|!outertrack->IsPoint()){
345	cerr<<"AliL3Merger::PrintDiff: No Points"<<endl;
346	cerr<<"---------------------------"<<endl;
347	return;
348	}
349	Double_t dx = innertrack->GetPointX()-outertrack->GetPointX();
350	Double_t dy = innertrack->GetPointY()-outertrack->GetPointY();
351	Double_t dz = innertrack->GetPointZ()-outertrack->GetPointZ();
352	Double_t dk = innertrack->GetKappa()-outertrack->GetKappa();
353	Double_t dpsi= innertrack->GetPointPsi() - outertrack->GetPointPsi();
354	if(dpsi>PI) dpsi-=2*PI;
355	if(dpsi<-PI)dpsi+=2*PI;
356	// Double_t dpsi = GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi());
357	Double_t dtgl= innertrack->GetTgl()-outertrack->GetTgl();
358	Double_t dq =innertrack->GetCharge()-outertrack->GetCharge();
359
360	fprintf(stderr,"dx: %4f dy: %4f dz: %4f dk: %4f dpsi: %4f dtgl: %4f dq: %4f\n",
361	dx,dy,dz,dk,dpsi,dtgl,dq);
362	cerr<<"---------------------------"<<endl;
363	// cerr<<endl;
364
365	}
366
367	void AliL3Merger::Print(){
368	// print some infos
369	for(Int_t i=0; i<fNIn; i++){
370	AliL3TrackArray *ttt= GetInTracks(i);
371	for(Int_t j =0;j<ttt->GetNTracks();j++){
372	AliL3Track *track=ttt->GetCheckedTrack(j);
373	if(!track) continue;
374	track->CalculateHelix();
375	// Double_t angle = atan2(track->GetLastPointY(),track->GetLastPointX());
376	// if(angle<0) angle+=PI;
377	if(track->CalculatePoint(135))
378	// if(!track->CalculateEdgePoint(angle)) cerr<<"**************"<<endl;
379	// if(track->CalculatePoint(track->GetLastPointX()))
380	// if(track->CalculatePoint(0))
381	{
382	// PrintTrack(track);
383	// track->CalculateReferencePoint(PI/180.);
384	track->CalculateReferencePoint(0.001);
385	fprintf(stderr,"npt: %3d dx: %8.5f dy: %8.5f dz: %8.5f\n",
386	track->GetNHits(),(float)track->GetPointX()-track->GetPointX(),
387	(float)track->GetPointY()-track->GetPointY(),
388	(float)track->GetPointZ()-track->GetPointZ());
389
390	cerr<<"---------------------------"<<endl;
391	}
392	}
393	}
394	}
395
396	void AliL3Merger::PrintTrack(AliL3Track *track){
397	fprintf(stderr,"npt: %3d pt: %.2f psi: %.2f tgl: %5.2f q: %2d\n",
398	track->GetNHits(),track->GetPt(),track->GetPsi(),
399	track->GetTgl(),track->GetCharge());
400	fprintf(stderr,
401	"x1: %6.2f y1: %6.2f z1: %6.2f xl: %6.2f yl: %6.2f zl: %6.2f\n",
402	track->GetFirstPointX(),track->GetFirstPointY(),track->GetFirstPointZ(),
403	track->GetLastPointX(),track->GetLastPointY(),track->GetLastPointZ());
404	if(track->IsPoint()){
405	fprintf(stderr,
406	"R: %.2f Xc: %.2f Yc: %.2f Xp: %.2f Yp: %.2f Zp: %.2f Psip: %.2f\n",
407	track->GetRadius(),track->GetCenterX(),track->GetCenterY(),
408	track->GetPointX(),track->GetPointY(),track->GetPointZ(),
409	track->GetPointPsi());
410	}
411	}
412
413
414
415