HLT/src/AliL3GlobalMerger.cxx

   1 //$Id$
   2
   3 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
   4 //*-- Copyright &copy Uli
   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"
  13
  14 //_____________________________________________________________
  15 // AliL3GlobalMerger
  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);
  35   SetParameter(2,2,0.001,0.05,0.1);
  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
  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)
  59   AliL3Transform::Local2GlobalAngle(&angle,slice);
  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();
  74   AliL3Transform::Global2Local(point,slice,kTRUE);
  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();
  85   AliL3Transform::Global2Local(point,slice,kTRUE);
  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
  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   }
 107   for(Int_t i=0; i<fNSlices; i++){
 108     if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
 109     Int_t slice = fFirst + i;
 110     AliL3TrackArray *ttt0=GetInTracks(i);
 111     Int_t slice2 = i+1;
 112     if(slice2==fNSlices) slice2 =0;
 113     AliL3TrackArray *ttt1=GetInTracks(slice2);
 114     Float_t angle = PI/18.; //10 degrees -> the border of the slices
 115     AliL3Transform::Local2GlobalAngle(&angle,slice);
 116     if(i==0)
 117       ttt0->QSort();
 118     ttt1->QSort();
 119     for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
 120       AliL3Track *track0=ttt0->GetCheckedTrack(s0);
 121       if(!track0) continue;
 122       track0->CalculateHelix();
 123       track0->CalculateEdgePoint(angle);
 124       //      if(track0->IsPoint()) AddTrack(tout,track0);
 125     }
 126     for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
 127       AliL3Track *track1=ttt1->GetCheckedTrack(s1);
 128       if(!track1) continue;
 129       track1->CalculateHelix();
 130       track1->CalculateEdgePoint(angle);
 131       //      if(track1->IsPoint())  AddTrack(tout,track1);
 132     }
 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;
 140         if(!track0->IsPoint()) continue;
 141         for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
 142           AliL3Track *track1=ttt1->GetCheckedTrack(s1);
 143           if(!track1) continue;
 144           if(!track1->IsPoint()) continue;
 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){
 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);
 159         track[0] = track0;
 160         track[1] = track1;
 161         SortGlobalTracks(track,2);
 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);
 167         track0->CalculateReferencePoint(angle);
 168         track1->CalculateReferencePoint(angle);
 169         PrintDiff(track0,track1);
 170         FillNtuple(ntuple,track0,track1);
 171         ttt0->Remove(min0);
 172         ttt1->Remove(min1);
 173
 174       }
 175       else merge = kFALSE;
 176     }
 177     ttt0->Compress();
 178     ttt1->Compress();
 179   LOG(AliL3Log::kInformational,"AliL3GlobalMerger::SlowMerge","Result")
 180   <<AliL3Log::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
 181   <<angle<<ENDLOG;
 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   }
 194   for(Int_t i=0; i<fNSlices; i++){
 195     if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
 196     Int_t slice = fFirst + i;
 197     AliL3TrackArray *ttt0=GetInTracks(i);
 198     Int_t slice2 = i+1;
 199     if(slice2==fNSlices) slice2 =0;
 200     AliL3TrackArray *ttt1=GetInTracks(slice2);
 201     Float_t angle = PI/18.; //10 degrees -> the border of the slices
 202     AliL3Transform::Local2GlobalAngle(&angle,slice);
 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);
 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           }
 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 }