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   fTransformer->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   fTransformer->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   fTransformer->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     fTransformer->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         MultiMerge(tout,track,2);
 163         track0->CalculateReferencePoint(angle);
 164         track1->CalculateReferencePoint(angle);
 165         PrintDiff(track0,track1);
 166         FillNtuple(ntuple,track0,track1);
 167         ttt0->Remove(min0);
 168         ttt1->Remove(min1);
 169       }
 170       else merge = kFALSE;
 171     }
 172     ttt0->Compress();
 173     ttt1->Compress();
 174   LOG(AliL3Log::kInformational,"AliL3GlobalMerger::SlowMerge","Result")
 175   <<AliL3Log::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
 176   <<angle<<ENDLOG;
 177   }
 178   WriteNtuple("ntuple_s.root",ntuple);
 179 }
 180
 181 void AliL3GlobalMerger::Merge(){
 182   AliL3Track *track[2];
 183   AliL3TrackArray *tout = GetOutTracks();
 184   if(fNSlices<2){
 185   LOG(AliL3Log::kWarning,"AliL3GlobalMerger::Merge","Slice Number")
 186     <<"Need more than one Slice!"<<ENDLOG;
 187     return;
 188   }
 189   for(Int_t i=0; i<fNSlices; i++){
 190     if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
 191     Int_t slice = fFirst + i;
 192     AliL3TrackArray *ttt0=GetInTracks(i);
 193     Int_t slice2 = i+1;
 194     if(slice2==fNSlices) slice2 =0;
 195     AliL3TrackArray *ttt1=GetInTracks(slice2);
 196     Float_t angle = PI/18.; //10 degrees -> the border of the slices
 197     fTransformer->Local2GlobalAngle(&angle,slice);
 198     if(i==0)
 199       ttt0->QSort();
 200     ttt1->QSort();
 201     Bool_t *ismatched0  = new Bool_t[ttt0->GetNTracks()];
 202     Bool_t *ismatched1  = new Bool_t[ttt1->GetNTracks()];
 203     Int_t n0=0,n1=0;
 204     for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
 205       ismatched0[s0]=kFALSE;
 206       AliL3Track *track0=ttt0->GetCheckedTrack(s0);
 207       if(!track0) continue;
 208       track0->CalculateHelix();
 209       track0->CalculateEdgePoint(angle);
 210       if(track0->IsPoint()) {n0++;track0->CalculateReferencePoint(angle);}
 211     }
 212     for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
 213       ismatched1[s1]=kFALSE;
 214       AliL3Track *track1=ttt1->GetCheckedTrack(s1);
 215       if(!track1) continue;
 216       track1->CalculateHelix();
 217       track1->CalculateEdgePoint(angle);
 218       if(track1->IsPoint()) {n1++;track1->CalculateReferencePoint(angle);}
 219     }
 220     for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
 221       AliL3Track *track0=ttt0->GetCheckedTrack(s0);
 222       if(!track0) continue;
 223       if(!track0->IsPoint()) continue;
 224       for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
 225         if(ismatched1[s1]) continue;
 226         AliL3Track *track1=ttt1->GetCheckedTrack(s1);
 227         if(!track1) continue;
 228         if(!track1->IsPoint()) continue;
 229         if(IsRTrack(track0,track1)){
 230           track[0] = track0;
 231           track[1] = track1;
 232           SortGlobalTracks(track,2);
 233           Double_t r0 = pow(track[0]->GetLastPointX(),2)+
 234                         pow(track[0]->GetLastPointY(),2);
 235           Double_t r1 = pow(track[1]->GetFirstPointX(),2)+
 236                         pow(track[1]->GetFirstPointY(),2);
 237           if(r0<r1){
 238             MultiMerge(tout,track,2);
 239             ismatched0[s0]=kTRUE;
 240             ismatched1[s1]=kTRUE;
 241             ttt0->Remove(s0);
 242             ttt1->Remove(s1);
 243           }
 244         }
 245       }
 246     }
 247   LOG(AliL3Log::kInformational,"AliL3GlobalMerger::Merge","Result")
 248   <<AliL3Log::kDec<<"slice0: "<<n0<<" slice1: "<<n1
 249   <<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
 250   }
 251 }