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

//$Id$

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

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

//_____________________________________________________________
// AliL3GlobalMerger
//
// The L3 Slice merger
//

ClassImp(AliL3GlobalMerger)

AliL3GlobalMerger::AliL3GlobalMerger(){
  //Default constructor
  Is2Global(kTRUE);
  SetParameter(2,2,0.001,0.05,0.1);
}


AliL3GlobalMerger::AliL3GlobalMerger(Int_t first,Int_t last):AliL3Merger(last-first+1){
  //Constructor.
  fNSlices = last-first+1;
  fFirst = first;
  fLast = last;
  Is2Global(kTRUE);
  SetParameter(2,2,0.001,0.05,0.1);
}

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

void AliL3GlobalMerger::InitSlice(Int_t slice){
  // 
  // Select Sector The following FillTracks call will 
  // fill this Sector
  //
  fSlice = slice;
  fCurrentTracks = fSlice - fFirst; 
}

Double_t AliL3GlobalMerger::CheckTracks(AliL3Track *innertrack,AliL3Track *outertrack,Int_t slice)
{
  //Compare the tracks by propagating the outermost track to the last and first point plane
  //of the innermost track. This plane is defined by the padrow plane where these points
  //are.
  
  
  Float_t angle = PI/36;//5 degrees = perpendicular to padrowplane (in local system)
  AliL3Transform::Local2GlobalAngle(&angle,slice);
  Double_t dx[2],dy[2],dz[2];
  Double_t diff =-1;
  AliL3Track *tracks[2];
  tracks[0] = innertrack;
  tracks[1] = outertrack;
  SortGlobalTracks(tracks,2);
  innertrack = tracks[0]; 
  outertrack = tracks[1];
  
  Float_t point[3];
  
  point[0]=innertrack->GetLastPointX();
  point[1]=innertrack->GetLastPointY();
  point[2]=innertrack->GetLastPointZ();
  AliL3Transform::Global2Local(point,slice,kTRUE);
  
  outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
  if(!outertrack->IsPoint()) return diff;
  dx[0] = fabs(outertrack->GetPointX()-innertrack->GetLastPointX());
  dy[0] = fabs(outertrack->GetPointY()-innertrack->GetLastPointY());
  dz[0] = fabs(outertrack->GetPointZ()-innertrack->GetLastPointZ());
  
  point[0]=innertrack->GetFirstPointX();
  point[1]=innertrack->GetFirstPointY();
  point[2]=innertrack->GetFirstPointZ();
  AliL3Transform::Global2Local(point,slice,kTRUE);
  
  outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
  if(!outertrack->IsPoint()) return diff;
  dx[1] = fabs(outertrack->GetPointX()-innertrack->GetFirstPointX());
  dy[1] = fabs(outertrack->GetPointY()-innertrack->GetFirstPointY());
  dz[1] = fabs(outertrack->GetPointZ()-innertrack->GetFirstPointZ());
  
  for(Int_t i=0; i<2; i++)
    diff += sqrt(dx[i]*dx[i] + dy[i]*dy[i] + dz[i]*dz[i]);
  return diff;
}

void AliL3GlobalMerger::SlowMerge(){
  void* ntuple=GetNtuple();
  AliL3Track *track[2];
  AliL3TrackArray *tout = GetOutTracks();
  if(fNSlices<2){
    LOG(AliL3Log::kWarning,"AliL3GlobalMerger::SlowMerge","Slice Number")
    <<"Need more than one Slice!"<<ENDLOG;
    return;
  }
  for(Int_t i=0; i<fNSlices; i++){
    if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
    Int_t slice = fFirst + i;
    AliL3TrackArray *ttt0=GetInTracks(i);
    Int_t slice2 = i+1;
    if(slice2==fNSlices) slice2 =0; 
    AliL3TrackArray *ttt1=GetInTracks(slice2);
    Float_t angle = PI/18.; //10 degrees -> the border of the slices
    AliL3Transform::Local2GlobalAngle(&angle,slice);
    if(i==0)
      ttt0->QSort();
    ttt1->QSort();
    for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
      AliL3Track *track0=ttt0->GetCheckedTrack(s0);
      if(!track0) continue;
      track0->CalculateHelix();
      track0->CalculateEdgePoint(angle);
      //      if(track0->IsPoint()) AddTrack(tout,track0);
    }
    for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
      AliL3Track *track1=ttt1->GetCheckedTrack(s1);
      if(!track1) continue;
      track1->CalculateHelix();
      track1->CalculateEdgePoint(angle);
      //      if(track1->IsPoint())  AddTrack(tout,track1); 
    }
    Bool_t merge = kTRUE;
    while(merge){
      Int_t min0=-1,min1=-1;
      Double_t min=10;
      for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
        AliL3Track *track0=ttt0->GetCheckedTrack(s0);
        if(!track0) continue;
        if(!track0->IsPoint()) continue;
        for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
          AliL3Track *track1=ttt1->GetCheckedTrack(s1);
          if(!track1) continue;
          if(!track1->IsPoint()) continue;
	  
          //Double_t diff = TrackDiff(track0,track1,angle);
	  Double_t diff = CheckTracks(track0,track1,slice);
	  //PrintDiff(track0,track1);
	  if(diff>=0&&diff<min){
            min=diff;
            min0=s0;
            min1=s1;
          }
        }
      }
      if(min0>=0&&min1>=0){
        AliL3Track *track0=ttt0->GetTrack(min0);
        AliL3Track *track1=ttt1->GetTrack(min1);
	track[0] = track0;
        track[1] = track1;
        SortGlobalTracks(track,2);
	track1->CalculateEdgePoint((angle+PI/9));
	if(track1->IsPoint())//Check if the track will cross the boundary of yet another slice.
	  MultiMerge(ttt1,track,2);
	else
	  MultiMerge(tout,track,2); 
        track0->CalculateReferencePoint(angle);
        track1->CalculateReferencePoint(angle);
	PrintDiff(track0,track1);
        FillNtuple(ntuple,track0,track1);
        ttt0->Remove(min0);
        ttt1->Remove(min1);
	
      }
      else merge = kFALSE;
    }
    ttt0->Compress();
    ttt1->Compress();
  LOG(AliL3Log::kInformational,"AliL3GlobalMerger::SlowMerge","Result")
  <<AliL3Log::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
  <<angle<<ENDLOG;
  }
  WriteNtuple("ntuple_s.root",ntuple);
}

void AliL3GlobalMerger::Merge(){
  AliL3Track *track[2];
  AliL3TrackArray *tout = GetOutTracks();
  if(fNSlices<2){
  LOG(AliL3Log::kWarning,"AliL3GlobalMerger::Merge","Slice Number")
    <<"Need more than one Slice!"<<ENDLOG;
    return;
  }
  for(Int_t i=0; i<fNSlices; i++){
    if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
    Int_t slice = fFirst + i;
    AliL3TrackArray *ttt0=GetInTracks(i);
    Int_t slice2 = i+1;
    if(slice2==fNSlices) slice2 =0;
    AliL3TrackArray *ttt1=GetInTracks(slice2);
    Float_t angle = PI/18.; //10 degrees -> the border of the slices
    AliL3Transform::Local2GlobalAngle(&angle,slice);
    if(i==0)
      ttt0->QSort();
    ttt1->QSort();
    Bool_t *ismatched0  = new Bool_t[ttt0->GetNTracks()];
    Bool_t *ismatched1  = new Bool_t[ttt1->GetNTracks()];
    Int_t n0=0,n1=0;
    for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
      ismatched0[s0]=kFALSE;
      AliL3Track *track0=ttt0->GetCheckedTrack(s0);
      if(!track0) continue;
      track0->CalculateHelix();
      track0->CalculateEdgePoint(angle);
      if(track0->IsPoint()) {n0++;track0->CalculateReferencePoint(angle);}
    }
    for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
      ismatched1[s1]=kFALSE;
      AliL3Track *track1=ttt1->GetCheckedTrack(s1);
      if(!track1) continue;
      track1->CalculateHelix();
      track1->CalculateEdgePoint(angle);
      if(track1->IsPoint()) {n1++;track1->CalculateReferencePoint(angle);}
    }
    for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
      AliL3Track *track0=ttt0->GetCheckedTrack(s0);
      if(!track0) continue;
      if(!track0->IsPoint()) continue;
      for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
        if(ismatched1[s1]) continue;
        AliL3Track *track1=ttt1->GetCheckedTrack(s1);
        if(!track1) continue;
        if(!track1->IsPoint()) continue;
        if(IsRTrack(track0,track1)){
          track[0] = track0;
          track[1] = track1;
          SortGlobalTracks(track,2);
          Double_t r0 = pow(track[0]->GetLastPointX(),2)+
                        pow(track[0]->GetLastPointY(),2);
          Double_t r1 = pow(track[1]->GetFirstPointX(),2)+
                        pow(track[1]->GetFirstPointY(),2);
          if(r0<r1){
            MultiMerge(tout,track,2); 
            ismatched0[s0]=kTRUE;
            ismatched1[s1]=kTRUE;
            ttt0->Remove(s0);
            ttt1->Remove(s1);
          }
        }
      }
    }
  LOG(AliL3Log::kInformational,"AliL3GlobalMerger::Merge","Result")
  <<AliL3Log::kDec<<"slice0: "<<n0<<" slice1: "<<n1
  <<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
  }
}
Commit	Line	Data
99cd2dbf	1	//$Id$
99cd2dbf	2
b661165c	3	// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
b661165c	4	//*-- Copyright &copy Uli
108615fc	5
	6	#include <math.h>
	7	#include <iostream.h>
	8	#include "AliL3Logging.h"
	9	#include "AliL3GlobalMerger.h"
	10	#include "AliL3Track.h"
	11	#include "AliL3Transform.h"
	12	#include "AliL3TrackArray.h"
b661165c	13
108615fc	14	//_____________________________________________________________
b661165c	15	// AliL3GlobalMerger
108615fc	16	//
	17	// The L3 Slice merger
	18	//
	19
	20	ClassImp(AliL3GlobalMerger)
	21
	22	AliL3GlobalMerger::AliL3GlobalMerger(){
	23	//Default constructor
	24	Is2Global(kTRUE);
	25	SetParameter(2,2,0.001,0.05,0.1);
	26	}
	27
	28
	29	AliL3GlobalMerger::AliL3GlobalMerger(Int_t first,Int_t last):AliL3Merger(last-first+1){
	30	//Constructor.
	31	fNSlices = last-first+1;
	32	fFirst = first;
	33	fLast = last;
	34	Is2Global(kTRUE);
3ea3b9f9	35	SetParameter(2,2,0.001,0.05,0.1);
108615fc	36	}
	37
	38	AliL3GlobalMerger::~AliL3GlobalMerger(){
	39	//Destructor
	40	}
	41
	42	void AliL3GlobalMerger::InitSlice(Int_t slice){
	43	//
	44	// Select Sector The following FillTracks call will
	45	// fill this Sector
	46	//
	47	fSlice = slice;
	48	fCurrentTracks = fSlice - fFirst;
	49	}
	50
99cd2dbf	51	Double_t AliL3GlobalMerger::CheckTracks(AliL3Track innertrack,AliL3Track outertrack,Int_t slice)
	52	{
	53	//Compare the tracks by propagating the outermost track to the last and first point plane
	54	//of the innermost track. This plane is defined by the padrow plane where these points
	55	//are.
	56
	57
	58	Float_t angle = PI/36;//5 degrees = perpendicular to padrowplane (in local system)
494fad94	59	AliL3Transform::Local2GlobalAngle(&angle,slice);
99cd2dbf	60	Double_t dx[2],dy[2],dz[2];
	61	Double_t diff =-1;
	62	AliL3Track *tracks[2];
	63	tracks[0] = innertrack;
	64	tracks[1] = outertrack;
	65	SortGlobalTracks(tracks,2);
	66	innertrack = tracks[0];
	67	outertrack = tracks[1];
	68
	69	Float_t point[3];
	70
	71	point[0]=innertrack->GetLastPointX();
	72	point[1]=innertrack->GetLastPointY();
	73	point[2]=innertrack->GetLastPointZ();
494fad94	74	AliL3Transform::Global2Local(point,slice,kTRUE);
99cd2dbf	75
	76	outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
	77	if(!outertrack->IsPoint()) return diff;
	78	dx[0] = fabs(outertrack->GetPointX()-innertrack->GetLastPointX());
	79	dy[0] = fabs(outertrack->GetPointY()-innertrack->GetLastPointY());
	80	dz[0] = fabs(outertrack->GetPointZ()-innertrack->GetLastPointZ());
	81
	82	point[0]=innertrack->GetFirstPointX();
	83	point[1]=innertrack->GetFirstPointY();
	84	point[2]=innertrack->GetFirstPointZ();
494fad94	85	AliL3Transform::Global2Local(point,slice,kTRUE);
99cd2dbf	86
	87	outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
	88	if(!outertrack->IsPoint()) return diff;
	89	dx[1] = fabs(outertrack->GetPointX()-innertrack->GetFirstPointX());
	90	dy[1] = fabs(outertrack->GetPointY()-innertrack->GetFirstPointY());
	91	dz[1] = fabs(outertrack->GetPointZ()-innertrack->GetFirstPointZ());
	92
	93	for(Int_t i=0; i<2; i++)
	94	diff += sqrt(dx[i]dx[i] + dy[i]dy[i] + dz[i]*dz[i]);
	95	return diff;
	96	}
	97
108615fc	98	void AliL3GlobalMerger::SlowMerge(){
	99	void* ntuple=GetNtuple();
	100	AliL3Track *track[2];
	101	AliL3TrackArray *tout = GetOutTracks();
	102	if(fNSlices<2){
	103	LOG(AliL3Log::kWarning,"AliL3GlobalMerger::SlowMerge","Slice Number")
	104	<<"Need more than one Slice!"<<ENDLOG;
	105	return;
	106	}
3ea3b9f9	107	for(Int_t i=0; i<fNSlices; i++){
3ea3b9f9	108	if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
108615fc	109	Int_t slice = fFirst + i;
108615fc	110	AliL3TrackArray *ttt0=GetInTracks(i);
3ea3b9f9	111	Int_t slice2 = i+1;
	112	if(slice2==fNSlices) slice2 =0;
	113	AliL3TrackArray *ttt1=GetInTracks(slice2);
108615fc	114	Float_t angle = PI/18.; //10 degrees -> the border of the slices
494fad94	115	AliL3Transform::Local2GlobalAngle(&angle,slice);
3ea3b9f9	116	if(i==0)
	117	ttt0->QSort();
	118	ttt1->QSort();
108615fc	119	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
3ea3b9f9	120	AliL3Track *track0=ttt0->GetCheckedTrack(s0);
3ea3b9f9	121	if(!track0) continue;
108615fc	122	track0->CalculateHelix();
108615fc	123	track0->CalculateEdgePoint(angle);
99cd2dbf	124	// if(track0->IsPoint()) AddTrack(tout,track0);
108615fc	125	}
108615fc	126	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
3ea3b9f9	127	AliL3Track *track1=ttt1->GetCheckedTrack(s1);
3ea3b9f9	128	if(!track1) continue;
108615fc	129	track1->CalculateHelix();
108615fc	130	track1->CalculateEdgePoint(angle);
99cd2dbf	131	// if(track1->IsPoint()) AddTrack(tout,track1);
108615fc	132	}
108615fc	133	Bool_t merge = kTRUE;
	134	while(merge){
	135	Int_t min0=-1,min1=-1;
	136	Double_t min=10;
	137	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
	138	AliL3Track *track0=ttt0->GetCheckedTrack(s0);
	139	if(!track0) continue;
3ea3b9f9	140	if(!track0->IsPoint()) continue;
108615fc	141	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
	142	AliL3Track *track1=ttt1->GetCheckedTrack(s1);
	143	if(!track1) continue;
3ea3b9f9	144	if(!track1->IsPoint()) continue;
99cd2dbf	145
	146	//Double_t diff = TrackDiff(track0,track1,angle);
	147	Double_t diff = CheckTracks(track0,track1,slice);
	148	//PrintDiff(track0,track1);
	149	if(diff>=0&&diff<min){
108615fc	150	min=diff;
	151	min0=s0;
	152	min1=s1;
	153	}
	154	}
	155	}
	156	if(min0>=0&&min1>=0){
	157	AliL3Track *track0=ttt0->GetTrack(min0);
	158	AliL3Track *track1=ttt1->GetTrack(min1);
05144961	159	track[0] = track0;
108615fc	160	track[1] = track1;
108615fc	161	SortGlobalTracks(track,2);
05144961	162	track1->CalculateEdgePoint((angle+PI/9));
	163	if(track1->IsPoint())//Check if the track will cross the boundary of yet another slice.
	164	MultiMerge(ttt1,track,2);
	165	else
	166	MultiMerge(tout,track,2);
108615fc	167	track0->CalculateReferencePoint(angle);
108615fc	168	track1->CalculateReferencePoint(angle);
99cd2dbf	169	PrintDiff(track0,track1);
108615fc	170	FillNtuple(ntuple,track0,track1);
	171	ttt0->Remove(min0);
	172	ttt1->Remove(min1);
05144961	173
108615fc	174	}
	175	else merge = kFALSE;
	176	}
3ea3b9f9	177	ttt0->Compress();
3ea3b9f9	178	ttt1->Compress();
108615fc	179	LOG(AliL3Log::kInformational,"AliL3GlobalMerger::SlowMerge","Result")
3ea3b9f9	180	<<AliL3Log::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
3ea3b9f9	181	<<angle<<ENDLOG;
108615fc	182	}
	183	WriteNtuple("ntuple_s.root",ntuple);
	184	}
	185
	186	void AliL3GlobalMerger::Merge(){
	187	AliL3Track *track[2];
	188	AliL3TrackArray *tout = GetOutTracks();
	189	if(fNSlices<2){
	190	LOG(AliL3Log::kWarning,"AliL3GlobalMerger::Merge","Slice Number")
	191	<<"Need more than one Slice!"<<ENDLOG;
	192	return;
	193	}
3ea3b9f9	194	for(Int_t i=0; i<fNSlices; i++){
3ea3b9f9	195	if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
108615fc	196	Int_t slice = fFirst + i;
108615fc	197	AliL3TrackArray *ttt0=GetInTracks(i);
3ea3b9f9	198	Int_t slice2 = i+1;
	199	if(slice2==fNSlices) slice2 =0;
	200	AliL3TrackArray *ttt1=GetInTracks(slice2);
108615fc	201	Float_t angle = PI/18.; //10 degrees -> the border of the slices
494fad94	202	AliL3Transform::Local2GlobalAngle(&angle,slice);
108615fc	203	if(i==0)
	204	ttt0->QSort();
	205	ttt1->QSort();
	206	Bool_t *ismatched0 = new Bool_t[ttt0->GetNTracks()];
	207	Bool_t *ismatched1 = new Bool_t[ttt1->GetNTracks()];
	208	Int_t n0=0,n1=0;
	209	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
	210	ismatched0[s0]=kFALSE;
	211	AliL3Track *track0=ttt0->GetCheckedTrack(s0);
	212	if(!track0) continue;
	213	track0->CalculateHelix();
	214	track0->CalculateEdgePoint(angle);
	215	if(track0->IsPoint()) {n0++;track0->CalculateReferencePoint(angle);}
	216	}
	217	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
	218	ismatched1[s1]=kFALSE;
	219	AliL3Track *track1=ttt1->GetCheckedTrack(s1);
	220	if(!track1) continue;
	221	track1->CalculateHelix();
	222	track1->CalculateEdgePoint(angle);
	223	if(track1->IsPoint()) {n1++;track1->CalculateReferencePoint(angle);}
	224	}
	225	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
	226	AliL3Track *track0=ttt0->GetCheckedTrack(s0);
	227	if(!track0) continue;
	228	if(!track0->IsPoint()) continue;
	229	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
	230	if(ismatched1[s1]) continue;
	231	AliL3Track *track1=ttt1->GetCheckedTrack(s1);
	232	if(!track1) continue;
	233	if(!track1->IsPoint()) continue;
	234	if(IsRTrack(track0,track1)){
	235	track[0] = track0;
	236	track[1] = track1;
	237	SortGlobalTracks(track,2);
3ea3b9f9	238	Double_t r0 = pow(track[0]->GetLastPointX(),2)+
	239	pow(track[0]->GetLastPointY(),2);
	240	Double_t r1 = pow(track[1]->GetFirstPointX(),2)+
	241	pow(track[1]->GetFirstPointY(),2);
	242	if(r0<r1){
	243	MultiMerge(tout,track,2);
	244	ismatched0[s0]=kTRUE;
	245	ismatched1[s1]=kTRUE;
	246	ttt0->Remove(s0);
	247	ttt1->Remove(s1);
	248	}
108615fc	249	}
	250	}
	251	}
	252	LOG(AliL3Log::kInformational,"AliL3GlobalMerger::Merge","Result")
	253	<<AliL3Log::kDec<<"slice0: "<<n0<<" slice1: "<<n1
	254	<<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
	255	}
	256	}