HLT/hough/AliL3HoughGlobalMerger.cxx

   1 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
   2 //*-- Copyright &copy ASV
   3
   4 #include <stdlib.h>
   5 #include <math.h>
   6 #include <iostream.h>
   7 #include "AliL3Logging.h"
   8 #include "AliL3HoughTrack.h"
   9 #include "AliL3HoughGlobalMerger.h"
  10 #include "AliL3Track.h"
  11 #include "AliL3TrackArray.h"
  12 #include "AliL3Transform.h"
  13
  14 //_____________________________________________________________
  15 // Merging Hough tracks across slices
  16
  17 ClassImp(AliL3HoughGlobalMerger)
  18
  19 AliL3HoughGlobalMerger::AliL3HoughGlobalMerger(){
  20   //Default constructor
  21   Is2Global(kTRUE);
  22   SetParameter(2,2,0.001,0.05,0.1);
  23 }
  24
  25
  26 AliL3HoughGlobalMerger::AliL3HoughGlobalMerger(Int_t first,Int_t last) : AliL3Merger(last-first+1,"AliL3HoughTrack")
  27 {
  28   //Constructor.
  29   fNSlices = last-first+1;
  30   fFirst = first;
  31   fLast = last;
  32   Is2Global(kTRUE);
  33   SetParameter(2,2,0.001,0.05,0.1);
  34 }
  35
  36 AliL3HoughGlobalMerger::~AliL3HoughGlobalMerger(){
  37   //Destructor
  38 }
  39
  40
  41 void AliL3HoughGlobalMerger::FillTracks(AliL3TrackArray *tracks,Int_t slice)
  42 {
  43   fSlice = slice;
  44   fCurrentTracks = fSlice - fFirst;
  45   if(tracks->GetNTracks()==0)
  46     LOG(AliL3Log::kWarning,"AliL3HoughGlobalMerger::FillTracks","Track Array")
  47       <<AliL3Log::kDec<<"Adding empty track array in slice "<<fSlice<<ENDLOG;
  48
  49   GetInTracks(fCurrentTracks)->AddTracks(tracks,kFALSE,fSlice);//Copy tracks, and rotate them to global coordinates
  50 }
  51
  52 Bool_t AliL3HoughGlobalMerger::IsTrack(AliL3Track *innertrack,AliL3Track *outertrack)
  53 {
  54   //Check if the tracks can be merged, called by the track merger
  55
  56   AliL3HoughTrack *tr1 = (AliL3HoughTrack*)innertrack;
  57   AliL3HoughTrack *tr2 = (AliL3HoughTrack*)outertrack;
  58
  59   if( (!tr1->IsPoint()) || (!tr2->IsPoint()) )  return kFALSE;
  60   if(abs(tr1->GetEtaIndex() - tr2->GetEtaIndex()) > 1) return kFALSE;
  61   if(tr1->GetCharge() != tr2->GetCharge()) return kFALSE;
  62   if(fabs(tr1->GetPhi0() - tr2->GetPhi0()) > fMaxPhi0) return kFALSE;
  63   if(fabs(tr1->GetKappa() - tr2->GetKappa()) > fMaxKappa) return kFALSE;
  64
  65   return kTRUE;
  66 }
  67
  68 AliL3Track *AliL3HoughGlobalMerger::MultiMerge(AliL3TrackArray *mergedtrack,AliL3Track **tracks, Int_t ntrack)
  69 {
  70   //Called by the track merger
  71
  72   AliL3HoughTrack *newtrack = (AliL3HoughTrack*)mergedtrack->NextTrack();
  73   AliL3HoughTrack **trs = (AliL3HoughTrack**)tracks;
  74   Int_t weight=0;
  75
  76   //Sum up the total weight:
  77   for(Int_t i=ntrack-1; i>=0; i--)
  78     weight += trs[i]->GetWeight();
  79
  80   AliL3HoughTrack *tpt=trs[0];//This is the innermost track
  81   AliL3HoughTrack *tpl=trs[ntrack-1];
  82   newtrack->SetTrackParameters(tpt->GetKappa(),tpt->GetPhi0(),weight);
  83   newtrack->SetEtaIndex(tpt->GetEtaIndex());
  84   newtrack->SetEta(tpt->GetEta());
  85   newtrack->SetPsi(tpt->GetPsi());
  86   newtrack->SetCenterX(tpt->GetCenterX());
  87   newtrack->SetCenterY(tpt->GetCenterY());
  88   newtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
  89   newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ());
  90   newtrack->SetCharge(tpt->GetCharge());
  91   newtrack->SetRowRange(tpt->GetFirstRow(),tpl->GetLastRow());
  92
  93   return (AliL3Track*)newtrack;
  94
  95 }
  96
  97 void AliL3HoughGlobalMerger::SlowMerge(){
  98   void* ntuple=GetNtuple();
  99   AliL3Track *track[2];
 100   AliL3TrackArray *tout = GetOutTracks();
 101   if(fNSlices<2){
 102     LOG(AliL3Log::kWarning,"AliL3HoughGlobalMerger::SlowMerge","Slice Number")
 103     <<"Need more than one Slice!"<<ENDLOG;
 104     return;
 105   }
 106   for(Int_t i=0; i<fNSlices; i++){
 107     if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
 108     Int_t slice = fFirst + i;
 109     AliL3TrackArray *ttt0=GetInTracks(i);
 110     Int_t slice2 = i+1;
 111     if(slice2==fNSlices) slice2 =0;
 112     AliL3TrackArray *ttt1=GetInTracks(slice2);
 113     Float_t angle = PI/18.; //10 degrees -> the border of the slices
 114     AliL3Transform::Local2GlobalAngle(&angle,slice);
 115     if(i==0)
 116       ttt0->QSort();
 117     ttt1->QSort();
 118     for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
 119       AliL3Track *track0=ttt0->GetCheckedTrack(s0);
 120       if(!track0) continue;
 121       track0->CalculateHelix();
 122       track0->CalculateEdgePoint(angle);
 123 //      if(track0->IsPoint()) AddTrack(tout,track0);
 124     }
 125     for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
 126       AliL3Track *track1=ttt1->GetCheckedTrack(s1);
 127       if(!track1) continue;
 128       track1->CalculateHelix();
 129       track1->CalculateEdgePoint(angle);
 130 //      if(track1->IsPoint())  AddTrack(tout,track1);
 131     }
 132     Bool_t merge = kTRUE;
 133     while(merge){
 134       Int_t min0=-1,min1=-1;
 135       Double_t min=10;
 136       for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
 137         AliL3Track *track0=ttt0->GetCheckedTrack(s0);
 138         if(!track0) continue;
 139         if(!track0->IsPoint()) continue;
 140         for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
 141           AliL3Track *track1=ttt1->GetCheckedTrack(s1);
 142           if(!track1) continue;
 143           if(!track1->IsPoint()) continue;
 144           Double_t diff = TrackDiff(track0,track1);
 145           if(diff>=0&&diff<min){
 146             min=diff;
 147             min0=s0;
 148             min1=s1;
 149           }
 150         }
 151       }
 152       if(min0>=0&&min1>=0){
 153         AliL3Track *track0=ttt0->GetTrack(min0);
 154         AliL3Track *track1=ttt1->GetTrack(min1);
 155         track[0] = track0;
 156         track[1] = track1;
 157         SortGlobalTracks(track,2);
 158         MultiMerge(tout,track,2);
 159         track0->CalculateReferencePoint(angle);
 160         track1->CalculateReferencePoint(angle);
 161         PrintDiff(track0,track1);
 162         FillNtuple(ntuple,track0,track1);
 163         ttt0->Remove(min0);
 164         ttt1->Remove(min1);
 165       }
 166       else merge = kFALSE;
 167     }
 168     ttt0->Compress();
 169     ttt1->Compress();
 170   LOG(AliL3Log::kInformational,"AliL3HoughGlobalMerger::SlowMerge","Result")
 171   <<AliL3Log::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
 172   <<angle<<ENDLOG;
 173   }
 174   WriteNtuple("ntuple_s.root",ntuple);
 175 }
 176
 177 void AliL3HoughGlobalMerger::Merge()
 178 {
 179   AliL3Track *track[2];
 180   AliL3TrackArray *tout = GetOutTracks();
 181   if(fNSlices<2){
 182     LOG(AliL3Log::kWarning,"AliL3HoughGlobalMerger::Merge","Slice Number")
 183       <<"Need more than one Slice!"<<ENDLOG;
 184     return;
 185   }
 186   Bool_t *ismatched0=0;
 187   Bool_t *ismatched1=0;
 188   for(Int_t i=0; i<fNSlices; i++)
 189     {
 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       AliL3Transform::Local2GlobalAngle(&angle,slice);
 198       if(i==0)
 199         ttt0->QSort();
 200       ttt1->QSort();
 201       if(ismatched0) delete [] ismatched0;
 202       if(ismatched1) delete [] ismatched1;
 203       ismatched0  = new Bool_t[ttt0->GetNTracks()];
 204       ismatched1  = new Bool_t[ttt1->GetNTracks()];
 205       Int_t n0=0,n1=0;
 206       for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
 207         {
 208           ismatched0[s0]=kFALSE;
 209           AliL3Track *track0=ttt0->GetCheckedTrack(s0);
 210           if(!track0) continue;
 211           track0->CalculateHelix();
 212           track0->CalculateEdgePoint(angle);
 213           if(track0->IsPoint()) {n0++;track0->CalculateReferencePoint(angle);
 214           }
 215         }
 216       for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
 217         {
 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         }
 226       for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
 227         {
 228           AliL3Track *track0=ttt0->GetCheckedTrack(s0);
 229           if(!track0) continue;
 230           if(!track0->IsPoint()) continue;
 231           for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
 232             {
 233               if(ismatched1[s1]) continue;
 234               AliL3Track *track1=ttt1->GetCheckedTrack(s1);
 235               if(!track1) continue;
 236               if(!track1->IsPoint()) continue;
 237               if(IsTrack(track0,track1))
 238                 {
 239                   track[0] = track0;
 240                   track[1] = track1;
 241                   SortGlobalTracks(track,2);
 242                   Double_t r0 = pow(track[0]->GetLastPointX(),2) + pow(track[0]->GetLastPointY(),2);
 243                   Double_t r1 = pow(track[1]->GetFirstPointX(),2) + pow(track[1]->GetFirstPointY(),2);
 244                   if(r0<r1)
 245                     {
 246                       MultiMerge(tout,track,2);
 247                       ismatched0[s0]=kTRUE;
 248                       ismatched1[s1]=kTRUE;
 249                       ttt0->Remove(s0);
 250                       ttt1->Remove(s1);
 251                     }
 252                 }
 253             }
 254         }
 255       LOG(AliL3Log::kInformational,"AliL3HoughGlobalMerger::Merge","Result")
 256         <<AliL3Log::kDec<<"slice0: "<<n0<<" slice1: "<<n1
 257         <<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
 258     }
 259   if(ismatched0) delete [] ismatched0;
 260   if(ismatched1) delete [] ismatched1;
 261 }