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

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

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

//_____________________________________________________________
// AliL3TrackMerger
//
// The L3 track segment merger
//

ClassImp(AliL3TrackMerger)

AliL3TrackMerger::AliL3TrackMerger(){
  //Default constructor
  Is2Global(kFALSE);
  fSlow = kFALSE;
  SetParameter();
  fRowMin = 0;
  fRowMax = 0;
}


AliL3TrackMerger::AliL3TrackMerger(Int_t nsubsectors):AliL3Merger(nsubsectors){
  //Constructor.
  fNSubSector = nsubsectors;
  Is2Global(kFALSE);
  fSlow = kFALSE;
  SetParameter();
  fRowMin = new Int_t[nsubsectors];
  fRowMax = new Int_t[nsubsectors];
}

AliL3TrackMerger::~AliL3TrackMerger(){
  //Destructor
}

void AliL3TrackMerger::SetRows(Int_t *row){
  for(Int_t i =0;i<fNSubSector;i++){
    fRowMin[i]=*(row+(2*i));
    fRowMax[i]=*(row+(2*i+1));
  }
}

void AliL3TrackMerger::InitSector(Int_t slice,Int_t subsector){
  // 
  // Select Sector and subsector. The following FillTracks call will 
  // fill this subsector
  //
  fSlice = slice;
  fSubSector = subsector;
  fCurrentTracks = fSubSector;
}

void AliL3TrackMerger::SlowMerge(AliL3TrackArray *mergedtrack,AliL3TrackArray *tracksin,AliL3TrackArray *tracksout,Double_t xval){
  void *ntuple=GetNtuple();
  const Int_t  kNOut=tracksout->GetNTracks();
  const Int_t  kNIn =tracksin->GetNTracks();
  const Int_t  kNMerged =mergedtrack->GetNTracks();
  AliL3Track *tracks[2];
  Bool_t merge = kTRUE;
  while(merge){
    Int_t inmin=-1,outmin=-1;
    Double_t min=10;
    for(Int_t out=0;out<kNOut;out++){
    AliL3Track *outertrack=tracksout->GetCheckedTrack(out);
    if(!outertrack) continue;
      for(Int_t in=0;in<kNIn;in++){
        AliL3Track *innertrack=tracksin->GetCheckedTrack(in);
        if(!innertrack) continue;
        Double_t diff = TrackDiff(innertrack,outertrack);
        if(diff>=0&&diff<min){
          min=diff;
          inmin=in;
          outmin=out; 
        }
      } 
    }
    if(inmin>=0&&outmin>=0){
      AliL3Track *outertrack=tracksout->GetTrack(outmin);
      AliL3Track *innertrack=tracksin->GetTrack(inmin);
      tracks[0]=innertrack;
      tracks[1]=outertrack;
      SortTracks(tracks,2);
      MultiMerge(mergedtrack,tracks,2);
      outertrack->CalculatePoint(xval);
      innertrack->CalculatePoint(xval);
      PrintDiff(innertrack,outertrack);
      FillNtuple(ntuple,innertrack,outertrack);
      tracksout->Remove(outmin);
      tracksin->Remove(inmin);
//      tracksout->Compress();
//      tracksin->Compress(); 
    }
    else merge = kFALSE;
  }
  LOG(AliL3Log::kInformational,"AliL3TrackMerger::SlowMerge","Result")
  <<AliL3Log::kDec<<"Merged Tracks: "
  <<mergedtrack->GetNTracks()-kNMerged<<ENDLOG;
  char name[256] = "ntuple_t.root";
  for(Int_t i=0;i<4;i++)
    if(tracksin==GetInTracks(i))
      sprintf(name,"ntuple_t_%d.root",i);
  WriteNtuple(name,ntuple);
}

void AliL3TrackMerger::SlowMerge(){
  fSlow = kTRUE;
  Merge();
}

void AliL3TrackMerger::InterMerge(){

  for(Int_t patch=0;patch< GetNIn();patch++){
    AliL3TrackArray * tracks = GetInTracks(patch);
    Double_t xval = fTransformer->Row2X((fRowMax[patch]+fRowMin[patch])/2);
    Int_t nrow= fRowMax[patch]-fRowMin[patch]+1;
    const Int_t  kNIn =tracks->GetNTracks();
    AliL3Track *tr[2];
    for(Int_t in=0;in<kNIn;in++){
      AliL3Track *t = tracks->GetCheckedTrack(in);
      if(t){
        t->CalculateHelix();
        t->CalculatePoint(xval);
      }
    }
    for(Int_t out=0;out<kNIn;out++){
    AliL3Track *outertrack=tracks->GetCheckedTrack(out);
    if(!outertrack) continue;
      for(Int_t in=0;in<kNIn;in++){
        if(in==out) continue;
        AliL3Track *innertrack=tracks->GetCheckedTrack(in);
        if(!innertrack) continue;
        if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue;

        if(IsTrack(innertrack,outertrack)){
          tr[0]=innertrack;
          tr[1]=outertrack;
          SortTracks(tr,2);
          if(tr[0]->GetLastPointX()<tr[1]->GetFirstPointX()){
            MultiMerge(tracks,tr,2);
            tracks->Remove(out);
            tracks->Remove(in);
            break;
          }
        }
      }
    }
    Int_t nmerged = tracks->GetNTracks()-kNIn;
    LOG(AliL3Log::kInformational,"AliL3TrackMerger::InterMerge","Result")
    <<AliL3Log::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
  }
}

void AliL3TrackMerger::Merge(){
  //Loop over tracks and pass them to the track merger.
  Double_t edge0 = PI/18.;
  Double_t edge1 = 2*PI - edge0;
  AliL3TrackArray *ttt = GetOutTracks();
  if(fNSubSector==1) {
    GetOutTracks()->AddTracks(GetInTracks(0)); 
    LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result")
    <<AliL3Log::kDec<<"Total Copied Tracks: "<<GetOutTracks()->GetNPresent()
    <<ENDLOG;
    return;
  }
  Int_t subsec = fNSubSector -2; 
  for(Int_t i=subsec;i>=0;i--){
    AliL3TrackArray *tout = GetOutTracks();
    if(i==subsec) tout = GetInTracks(subsec+1);
    AliL3TrackArray *tin = GetInTracks(i);
    Double_t xval = fTransformer->Row2X(fRowMax[i]);
    Double_t xmax = fTransformer->Row2X(fRowMax[i+1]);
    Double_t ymax = xval*tan(edge0);
    for(Int_t out=0;out<tout->GetNTracks();out++){
      AliL3Track *outtrack=tout->GetCheckedTrack(out);
      if(!outtrack) continue;
      outtrack->CalculateHelix();
      outtrack->CalculatePoint(xval);
      if(outtrack->IsPoint()&&fabs(outtrack->GetPointY())>ymax){
        if(outtrack->GetNHits()<10)
          tout->Remove(out);
      }
    }
//    tout->Compress();
    for(Int_t in=0;in<tin->GetNTracks();in++){
      AliL3Track *intrack=(AliL3Track*)tin->GetTrack(in);
      intrack->CalculateHelix();
      intrack->CalculatePoint(xval);
    }
    tin->QSort();
    tout->QSort();

    if(fSlow) SlowMerge(ttt,tin,tout,xval);
    else Merge(ttt,tin,tout);
    for(Int_t in=0;in<tin->GetNTracks();in++){
      AliL3Track *intrack=(AliL3Track*)tin->GetCheckedTrack(in);
      if(!intrack) continue;
      if(intrack->CalculateEdgePoint(edge0)){
        if(intrack->GetPointX()<xmax ){
          AddTrack(ttt,intrack);
          tin->Remove(in);
        }
      } 
      else if(intrack->CalculateEdgePoint(edge1)){
        if(intrack->GetPointX()<xmax ){
          AddTrack(ttt,intrack);
          tin->Remove(in);
        }
      }
    }
/*
    for(Int_t in=0;in<tin->GetNTracks();in++){
      AliL3Track *intrack=(AliL3Track*)tin->GetCheckedTrack(in);
      if(!intrack) continue;
      if(intrack->GetNHits()<10) continue;
      AddTrack(ttt,intrack);
      tin->Remove(in);
    }
*/
  } // end subsector loop
  LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result")
  <<AliL3Log::kDec<<"Total Merged Tracks: "<<GetOutTracks()->GetNPresent()
  <<ENDLOG;
}

Int_t AliL3TrackMerger::Merge(AliL3TrackArray* mergedtrack,AliL3TrackArray *tracksin,AliL3TrackArray *tracksout){
  //Loop over tracks and pass them to the track merger.
  AliL3Track *tracks[2];

  const Int_t  kNOut=tracksout->GetNTracks();
  const Int_t  kNIn =tracksin->GetNTracks();
  const Int_t  kNMerged =mergedtrack->GetNTracks();

  Bool_t *ismatchedin  = new Bool_t[kNIn];
  for(Int_t in =0;in<kNIn;in++)
    ismatchedin[in]=kFALSE;
  Bool_t *ismatchedout = new Bool_t[kNOut];
  for(Int_t out =0;out<kNOut;out++)
    ismatchedout[out] = kFALSE;
  for(Int_t out =0;out<kNOut;out++){
    AliL3Track *outertrack=(AliL3Track*)tracksout->GetCheckedTrack(out);
    if(!outertrack) continue;
    for(Int_t in =0;in<kNIn;in++){
      if(ismatchedin[in]) continue;
      AliL3Track *innertrack=(AliL3Track*)tracksin->GetCheckedTrack(in);
      if(!innertrack) continue;
      if(outertrack==innertrack) continue;
      if(outertrack->GetCharge()!=innertrack->GetCharge()) continue;
      if(IsTrack(innertrack,outertrack)){
        tracks[0]=innertrack; tracks[1]=outertrack; 
        SortTracks(tracks,2);  
        if(tracks[0]->GetLastPointX()<tracks[1]->GetFirstPointX()){
          MultiMerge(mergedtrack,tracks,2);
          tracksout->Remove(out);
          tracksin->Remove(in);
          ismatchedin[in]=kTRUE;
          ismatchedout[out]=kTRUE;
          break;
        }
      }
    }
  }

  Int_t nmerged = mergedtrack->GetNTracks()-kNMerged;
  LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result")
  <<AliL3Log::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
  delete[] ismatchedin;
  delete[] ismatchedout;
  return nmerged;
}
Commit	Line	Data
b661165c	1	// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
b661165c	2	//*-- Copyright &copy ULI
108615fc	3
	4	#include <math.h>
	5	#include <iostream.h>
	6	#include "AliL3Logging.h"
	7	#include "AliL3TrackMerger.h"
	8	#include "AliL3Track.h"
	9	#include "AliL3TrackSegmentData.h"
	10	#include "AliL3Transform.h"
	11	#include "AliL3TrackArray.h"
	12
	13	//_____________________________________________________________
b661165c	14	// AliL3TrackMerger
108615fc	15	//
	16	// The L3 track segment merger
	17	//
	18
	19	ClassImp(AliL3TrackMerger)
	20
	21	AliL3TrackMerger::AliL3TrackMerger(){
	22	//Default constructor
	23	Is2Global(kFALSE);
	24	fSlow = kFALSE;
	25	SetParameter();
cd081a54	26	fRowMin = 0;
cd081a54	27	fRowMax = 0;
108615fc	28	}
	29
	30
	31	AliL3TrackMerger::AliL3TrackMerger(Int_t nsubsectors):AliL3Merger(nsubsectors){
	32	//Constructor.
	33	fNSubSector = nsubsectors;
	34	Is2Global(kFALSE);
	35	fSlow = kFALSE;
	36	SetParameter();
cd081a54	37	fRowMin = new Int_t[nsubsectors];
cd081a54	38	fRowMax = new Int_t[nsubsectors];
108615fc	39	}
	40
	41	AliL3TrackMerger::~AliL3TrackMerger(){
	42	//Destructor
	43	}
	44
	45	void AliL3TrackMerger::SetRows(Int_t *row){
	46	for(Int_t i =0;i<fNSubSector;i++){
	47	fRowMin[i]=(row+(2i));
	48	fRowMax[i]=(row+(2i+1));
	49	}
	50	}
	51
	52	void AliL3TrackMerger::InitSector(Int_t slice,Int_t subsector){
	53	//
	54	// Select Sector and subsector. The following FillTracks call will
	55	// fill this subsector
	56	//
	57	fSlice = slice;
	58	fSubSector = subsector;
	59	fCurrentTracks = fSubSector;
	60	}
	61
	62	void AliL3TrackMerger::SlowMerge(AliL3TrackArray mergedtrack,AliL3TrackArray tracksin,AliL3TrackArray *tracksout,Double_t xval){
	63	void *ntuple=GetNtuple();
	64	const Int_t kNOut=tracksout->GetNTracks();
	65	const Int_t kNIn =tracksin->GetNTracks();
	66	const Int_t kNMerged =mergedtrack->GetNTracks();
	67	AliL3Track *tracks[2];
	68	Bool_t merge = kTRUE;
	69	while(merge){
	70	Int_t inmin=-1,outmin=-1;
	71	Double_t min=10;
	72	for(Int_t out=0;out<kNOut;out++){
	73	AliL3Track *outertrack=tracksout->GetCheckedTrack(out);
	74	if(!outertrack) continue;
	75	for(Int_t in=0;in<kNIn;in++){
	76	AliL3Track *innertrack=tracksin->GetCheckedTrack(in);
	77	if(!innertrack) continue;
	78	Double_t diff = TrackDiff(innertrack,outertrack);
	79	if(diff>=0&&diff<min){
	80	min=diff;
	81	inmin=in;
	82	outmin=out;
	83	}
	84	}
	85	}
	86	if(inmin>=0&&outmin>=0){
	87	AliL3Track *outertrack=tracksout->GetTrack(outmin);
	88	AliL3Track *innertrack=tracksin->GetTrack(inmin);
	89	tracks[0]=innertrack;
	90	tracks[1]=outertrack;
	91	SortTracks(tracks,2);
	92	MultiMerge(mergedtrack,tracks,2);
	93	outertrack->CalculatePoint(xval);
	94	innertrack->CalculatePoint(xval);
	95	PrintDiff(innertrack,outertrack);
	96	FillNtuple(ntuple,innertrack,outertrack);
	97	tracksout->Remove(outmin);
	98	tracksin->Remove(inmin);
	99	// tracksout->Compress();
	100	// tracksin->Compress();
	101	}
	102	else merge = kFALSE;
103	}
104	LOG(AliL3Log::kInformational,"AliL3TrackMerger::SlowMerge","Result")
105	<<AliL3Log::kDec<<"Merged Tracks: "
106	<<mergedtrack->GetNTracks()-kNMerged<<ENDLOG;
107	char name[256] = "ntuple_t.root";
108	for(Int_t i=0;i<4;i++)
109	if(tracksin==GetInTracks(i))
110	sprintf(name,"ntuple_t_%d.root",i);
111	WriteNtuple(name,ntuple);
112	}
113
114	void AliL3TrackMerger::SlowMerge(){
115	fSlow = kTRUE;
116	Merge();
117	}
118
119	void AliL3TrackMerger::InterMerge(){
120
121	for(Int_t patch=0;patch< GetNIn();patch++){
122	AliL3TrackArray * tracks = GetInTracks(patch);
123	Double_t xval = fTransformer->Row2X((fRowMax[patch]+fRowMin[patch])/2);
124	Int_t nrow= fRowMax[patch]-fRowMin[patch]+1;
125	const Int_t kNIn =tracks->GetNTracks();
126	AliL3Track *tr[2];
127	for(Int_t in=0;in<kNIn;in++){
128	AliL3Track *t = tracks->GetCheckedTrack(in);
129	if(t){
130	t->CalculateHelix();
131	t->CalculatePoint(xval);
132	}
133	}
134	for(Int_t out=0;out<kNIn;out++){
135	AliL3Track *outertrack=tracks->GetCheckedTrack(out);
136	if(!outertrack) continue;
137	for(Int_t in=0;in<kNIn;in++){
138	if(in==out) continue;
139	AliL3Track *innertrack=tracks->GetCheckedTrack(in);
140	if(!innertrack) continue;
141	if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue;
142
143	if(IsTrack(innertrack,outertrack)){
144	tr[0]=innertrack;
145	tr[1]=outertrack;
146	SortTracks(tr,2);
147	if(tr[0]->GetLastPointX()<tr[1]->GetFirstPointX()){
148	MultiMerge(tracks,tr,2);
149	tracks->Remove(out);
150	tracks->Remove(in);
151	break;
152	}
153	}
154	}
155	}
156	Int_t nmerged = tracks->GetNTracks()-kNIn;
157	LOG(AliL3Log::kInformational,"AliL3TrackMerger::InterMerge","Result")
158	<<AliL3Log::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
159	}
160	}
161
162	void AliL3TrackMerger::Merge(){
163	//Loop over tracks and pass them to the track merger.
164	Double_t edge0 = PI/18.;
165	Double_t edge1 = 2*PI - edge0;
166	AliL3TrackArray *ttt = GetOutTracks();
167	if(fNSubSector==1) {
168	GetOutTracks()->AddTracks(GetInTracks(0));
169	LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result")
170	<<AliL3Log::kDec<<"Total Copied Tracks: "<<GetOutTracks()->GetNPresent()
171	<<ENDLOG;
172	return;
173	}
174	Int_t subsec = fNSubSector -2;
175	for(Int_t i=subsec;i>=0;i--){
176	AliL3TrackArray *tout = GetOutTracks();
177	if(i==subsec) tout = GetInTracks(subsec+1);
178	AliL3TrackArray *tin = GetInTracks(i);
179	Double_t xval = fTransformer->Row2X(fRowMax[i]);
180	Double_t xmax = fTransformer->Row2X(fRowMax[i+1]);
181	Double_t ymax = xval*tan(edge0);
182	for(Int_t out=0;out<tout->GetNTracks();out++){
183	AliL3Track *outtrack=tout->GetCheckedTrack(out);
184	if(!outtrack) continue;
185	outtrack->CalculateHelix();
186	outtrack->CalculatePoint(xval);
187	if(outtrack->IsPoint()&&fabs(outtrack->GetPointY())>ymax){
188	if(outtrack->GetNHits()<10)
189	tout->Remove(out);
190	}
191	}
192	// tout->Compress();
193	for(Int_t in=0;in<tin->GetNTracks();in++){
194	AliL3Track intrack=(AliL3Track)tin->GetTrack(in);
195	intrack->CalculateHelix();
196	intrack->CalculatePoint(xval);
197	}
198	tin->QSort();
199	tout->QSort();
200
201	if(fSlow) SlowMerge(ttt,tin,tout,xval);
202	else Merge(ttt,tin,tout);
203	for(Int_t in=0;in<tin->GetNTracks();in++){
204	AliL3Track intrack=(AliL3Track)tin->GetCheckedTrack(in);
205	if(!intrack) continue;
206	if(intrack->CalculateEdgePoint(edge0)){
207	if(intrack->GetPointX()<xmax ){
208	AddTrack(ttt,intrack);
209	tin->Remove(in);
210	}
211	}
212	else if(intrack->CalculateEdgePoint(edge1)){
213	if(intrack->GetPointX()<xmax ){
214	AddTrack(ttt,intrack);
215	tin->Remove(in);
216	}
217	}
218	}
219	/*
220	for(Int_t in=0;in<tin->GetNTracks();in++){
221	AliL3Track intrack=(AliL3Track)tin->GetCheckedTrack(in);
222	if(!intrack) continue;
223	if(intrack->GetNHits()<10) continue;
224	AddTrack(ttt,intrack);
225	tin->Remove(in);
226	}
227	*/
228	} // end subsector loop
229	LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result")
230	<<AliL3Log::kDec<<"Total Merged Tracks: "<<GetOutTracks()->GetNPresent()
231	<<ENDLOG;
232	}
233
234	Int_t AliL3TrackMerger::Merge(AliL3TrackArray* mergedtrack,AliL3TrackArray tracksin,AliL3TrackArray tracksout){
235	//Loop over tracks and pass them to the track merger.
236	AliL3Track *tracks[2];
237
238	const Int_t kNOut=tracksout->GetNTracks();
239	const Int_t kNIn =tracksin->GetNTracks();
240	const Int_t kNMerged =mergedtrack->GetNTracks();
241
242	Bool_t *ismatchedin = new Bool_t[kNIn];
243	for(Int_t in =0;in<kNIn;in++)
244	ismatchedin[in]=kFALSE;
245	Bool_t *ismatchedout = new Bool_t[kNOut];
246	for(Int_t out =0;out<kNOut;out++)
247	ismatchedout[out] = kFALSE;
248	for(Int_t out =0;out<kNOut;out++){
249	AliL3Track outertrack=(AliL3Track)tracksout->GetCheckedTrack(out);
250	if(!outertrack) continue;
251	for(Int_t in =0;in<kNIn;in++){
252	if(ismatchedin[in]) continue;
253	AliL3Track innertrack=(AliL3Track)tracksin->GetCheckedTrack(in);
254	if(!innertrack) continue;
255	if(outertrack==innertrack) continue;
256	if(outertrack->GetCharge()!=innertrack->GetCharge()) continue;
257	if(IsTrack(innertrack,outertrack)){
258	tracks[0]=innertrack; tracks[1]=outertrack;
259	SortTracks(tracks,2);
260	if(tracks[0]->GetLastPointX()<tracks[1]->GetFirstPointX()){
261	MultiMerge(mergedtrack,tracks,2);
262	tracksout->Remove(out);
263	tracksin->Remove(in);
264	ismatchedin[in]=kTRUE;
265	ismatchedout[out]=kTRUE;
266	break;
267	}
268	}
269	}
270	}
271
272	Int_t nmerged = mergedtrack->GetNTracks()-kNMerged;
273	LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result")
274	<<AliL3Log::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
275	delete[] ismatchedin;
276	delete[] ismatchedout;
277	return nmerged;
278	}
279
280