HLT/hough/AliL3HoughMerger.cxx

   1 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
   2 //*-- Copyright &copy ASV
   3
   4 #include <math.h>
   5 #include <stdlib.h>
   6 #include "AliL3Logging.h"
   7 #include "AliL3Defs.h"
   8 #include "AliL3Transform.h"
   9 #include "AliL3TrackArray.h"
  10 #include "AliL3HoughTrack.h"
  11 #include "AliL3HoughMerger.h"
  12 #include "AliL3HoughTransformer.h"
  13
  14 //_____________________________________________________________
  15 // AliL3HoughMerger
  16 //
  17 // Patch merging class for Hough tracklets
  18
  19 ClassImp(AliL3HoughMerger)
  20
  21
  22 AliL3HoughMerger::AliL3HoughMerger()
  23 {
  24   //Default constructor
  25 }
  26
  27
  28 AliL3HoughMerger::AliL3HoughMerger(Int_t nsubsectors) : AliL3Merger(nsubsectors,"AliL3HoughTrack")
  29 {
  30   //Constructor
  31   Is2Global(kFALSE);
  32   SetParameters(0.001,0.1,0.05);
  33 }
  34
  35
  36 AliL3HoughMerger::~AliL3HoughMerger()
  37 {
  38
  39 }
  40
  41 void AliL3HoughMerger::FillTracks(AliL3TrackArray *tracks,Int_t patch)
  42 {
  43   if(tracks->GetNTracks()==0)
  44     LOG(AliL3Log::kWarning,"AliL3HoughMerger::FillTracks","Track Array")
  45       <<"Adding empty track array"<<ENDLOG;
  46
  47   GetInTracks(patch)->AddTracks(tracks,kFALSE);//Copy tracks
  48   printf("Filling %d tracks to merger\n",tracks->GetNTracks());
  49 }
  50
  51 void AliL3HoughMerger::SetParameters(Double_t maxkappa,Double_t maxpsi,Double_t maxphi0)
  52 {
  53   fMaxKappa = maxkappa;
  54   fMaxPsi = maxpsi;
  55   fMaxPhi0 = maxphi0;
  56 }
  57
  58 Bool_t AliL3HoughMerger::IsTrack(AliL3Track *innertrack,AliL3Track *outertrack)
  59 {
  60   //Check if the tracks can be merged, called by the track merger
  61
  62   AliL3HoughTrack *tr1 = (AliL3HoughTrack*)innertrack;
  63   AliL3HoughTrack *tr2 = (AliL3HoughTrack*)outertrack;
  64
  65   if( (!tr1->IsPoint()) || (!tr2->IsPoint()) )  return kFALSE;
  66   if(abs(tr1->GetEtaIndex() - tr2->GetEtaIndex()) > 1) return kFALSE;
  67   if(tr1->GetCharge() != tr2->GetCharge()) return kFALSE;
  68   if(fabs(tr1->GetPhi0() - tr2->GetPhi0()) > fMaxPhi0) return kFALSE;
  69   if(fabs(tr1->GetKappa() - tr2->GetKappa()) > fMaxKappa) return kFALSE;
  70
  71   /*
  72     if( (!tr1->IsPoint()) || (!tr2->IsPoint()) )  return kFALSE;
  73     if(fabs(innertrack->GetPointY()-outertrack->GetPointY()) >fMaxY) return kFALSE;
  74     if(fabs(innertrack->GetPointZ()-outertrack->GetPointZ()) >fMaxZ) return kFALSE;
  75     if(fabs(innertrack->GetKappa()-outertrack->GetKappa())   >fMaxKappa) return kFALSE;
  76     if(GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi()) >fMaxPsi) return kFALSE;
  77     if(fabs(innertrack->GetTgl()-outertrack->GetTgl()) >fMaxTgl) return kFALSE;
  78   */
  79
  80   return kTRUE;//Tracks could be merged
  81 }
  82
  83 void AliL3HoughMerger::AddTrack(AliL3TrackArray *mergedtrack,AliL3Track *track)
  84 {
  85   AliL3Track *t[1];
  86   t[0] = track;
  87   MultiMerge(mergedtrack,t,1);
  88 }
  89
  90 AliL3Track *AliL3HoughMerger::MultiMerge(AliL3TrackArray *mergedtrack,AliL3Track **tracks, Int_t ntrack)
  91 {
  92   //Called by the track merger
  93
  94   AliL3HoughTrack *newtrack = (AliL3HoughTrack*)mergedtrack->NextTrack();
  95   AliL3HoughTrack **trs = (AliL3HoughTrack**)tracks;
  96   Int_t weight=0;
  97
  98   //Sum up the total weight:
  99   for(Int_t i=ntrack-1; i>=0; i--)
 100     weight += trs[i]->GetWeight();
 101
 102   AliL3HoughTrack *tpt=trs[0];//This is the innermost track
 103   AliL3HoughTrack *tpl=trs[ntrack-1];
 104   newtrack->SetTrackParameters(tpt->GetKappa(),tpt->GetPhi0(),weight);
 105   newtrack->SetEtaIndex(tpt->GetEtaIndex());
 106   newtrack->SetEta(tpt->GetEta());
 107   newtrack->SetPsi(tpt->GetPsi());
 108   newtrack->SetCenterX(tpt->GetCenterX());
 109   newtrack->SetCenterY(tpt->GetCenterY());
 110   newtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
 111   newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ());
 112   newtrack->SetCharge(tpt->GetCharge());
 113   newtrack->SetRowRange(tpt->GetFirstRow(),tpl->GetLastRow());
 114
 115   return (AliL3Track*)newtrack;
 116
 117 }
 118
 119 void AliL3HoughMerger::MergePatches(Bool_t slow)
 120 {
 121   //Merge tracks from across the patches.
 122
 123   fSlow = slow;
 124   AliL3TrackArray *tracks;
 125   AliL3HoughTrack *track;
 126   for(Int_t i=0; i<GetNIn(); i++)
 127     {
 128       tracks = GetInTracks(i);
 129       for(Int_t j=0; j<tracks->GetNTracks(); j++)
 130         {
 131           track = (AliL3HoughTrack*)tracks->GetCheckedTrack(j);
 132           if(!track) continue;
 133           track->UpdateToFirstRow();
 134         }
 135     }
 136   Merge();
 137
 138 }
 139
 140 void AliL3HoughMerger::Merge()
 141 {
 142   Double_t edge0 = PI/18.;
 143   Double_t edge1 = 2*PI - edge0;
 144   AliL3TrackArray *ttt = GetOutTracks();
 145
 146   Int_t subsec = GetNIn() - 2;
 147   for(Int_t i=subsec;i>=0;i--){
 148     AliL3TrackArray *tout = GetOutTracks();
 149     if(i==subsec) tout = GetInTracks(subsec+1);
 150     AliL3TrackArray *tin = GetInTracks(i);
 151     Double_t xval = fTransformer->Row2X(NRows[i][1]);
 152     Double_t xmax = fTransformer->Row2X(NRows[i+1][1]);
 153     Double_t ymax = xval*tan(edge0);
 154     for(Int_t out=0;out<tout->GetNTracks();out++){
 155       AliL3Track *outtrack=tout->GetCheckedTrack(out);
 156       if(!outtrack) continue;
 157       //outtrack->CalculateHelix();
 158       outtrack->CalculatePoint(xval);
 159       if(outtrack->IsPoint()&&fabs(outtrack->GetPointY())>ymax){
 160         tout->Remove(out);
 161       }
 162     }
 163     //    tout->Compress();
 164     for(Int_t in=0;in<tin->GetNTracks();in++){
 165       AliL3Track *intrack=(AliL3Track*)tin->GetTrack(in);
 166       //intrack->CalculateHelix();
 167       intrack->CalculatePoint(xval);
 168     }
 169     tin->QSort();
 170     tout->QSort();
 171
 172     if(fSlow) SlowMerge(ttt,tin,tout,xval);
 173     else Merge(ttt,tin,tout);
 174
 175     /*
 176     //Add the tracks that cross the sector boundary:
 177     for(Int_t in=0;in<tin->GetNTracks();in++){
 178       AliL3Track *intrack=(AliL3Track*)tin->GetCheckedTrack(in);
 179       if(!intrack) continue;
 180       if(intrack->CalculateEdgePoint(edge0)){
 181         if(intrack->GetPointX()<xmax ){
 182           AddTrack(ttt,intrack);
 183           tin->Remove(in);
 184         }
 185       }
 186       else if(intrack->CalculateEdgePoint(edge1)){
 187         if(intrack->GetPointX()<xmax ){
 188           AddTrack(ttt,intrack);
 189           tin->Remove(in);
 190         }
 191       }
 192     }
 193     */
 194   } // end subsector loop
 195   LOG(AliL3Log::kInformational,"AliL3HoughMerger::Merge","Result")
 196     <<AliL3Log::kDec<<"Total Merged Tracks: "<<GetOutTracks()->GetNPresent()
 197     <<ENDLOG;
 198 }
 199
 200 Int_t AliL3HoughMerger::Merge(AliL3TrackArray* mergedtrack,AliL3TrackArray *tracksin,AliL3TrackArray *tracksout)
 201 {
 202
 203   AliL3Track *tracks[2];
 204   const Int_t  kNOut=tracksout->GetNTracks();
 205   const Int_t  kNIn =tracksin->GetNTracks();
 206   const Int_t  kNMerged =mergedtrack->GetNTracks();
 207
 208   Bool_t *ismatchedin  = new Bool_t[kNIn];
 209   for(Int_t in =0;in<kNIn;in++)
 210     ismatchedin[in]=kFALSE;
 211   Bool_t *ismatchedout = new Bool_t[kNOut];
 212   for(Int_t out =0;out<kNOut;out++)
 213     ismatchedout[out] = kFALSE;
 214   for(Int_t out =0;out<kNOut;out++){
 215     AliL3Track *outertrack=(AliL3Track*)tracksout->GetCheckedTrack(out);
 216     if(!outertrack) continue;
 217     for(Int_t in =0;in<kNIn;in++){
 218       if(ismatchedin[in]) continue;
 219       AliL3Track *innertrack=(AliL3Track*)tracksin->GetCheckedTrack(in);
 220       if(!innertrack) continue;
 221       if(outertrack==innertrack) continue;
 222
 223       if(IsTrack(innertrack,outertrack)) //They can be merged
 224         {
 225           tracks[0]=innertrack; tracks[1]=outertrack;
 226           SortTracks(tracks,2); //Sort the tracks according to minimum x-point
 227           //if(tracks[0]->GetLastPointX()<tracks[1]->GetFirstPointX()){
 228           MultiMerge(mergedtrack,tracks,2);
 229           tracksout->Remove(out);
 230           tracksin->Remove(in);
 231           ismatchedin[in]=kTRUE;
 232           ismatchedout[out]=kTRUE;
 233           break;
 234           // }
 235         }
 236     }
 237   }
 238
 239   Int_t nmerged = mergedtrack->GetNTracks()-kNMerged;
 240   LOG(AliL3Log::kInformational,"AliL3HoughMerger::Merge","Result")
 241     <<AliL3Log::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
 242   delete[] ismatchedin;
 243   delete[] ismatchedout;
 244   return nmerged;
 245 }
 246
 247 void AliL3HoughMerger::SlowMerge(AliL3TrackArray *mergedtrack,AliL3TrackArray *tracksin,AliL3TrackArray *tracksout,Double_t xval)
 248 {
 249   void *ntuple=GetNtuple();
 250   const Int_t  kNOut=tracksout->GetNTracks();
 251   const Int_t  kNIn =tracksin->GetNTracks();
 252   const Int_t  kNMerged =mergedtrack->GetNTracks();
 253   AliL3Track *tracks[2];
 254   Bool_t merge = kTRUE;
 255   while(merge){
 256     Int_t inmin=-1,outmin=-1;
 257     Double_t min=10;
 258     for(Int_t out=0;out<kNOut;out++){
 259     AliL3Track *outertrack=tracksout->GetCheckedTrack(out);
 260     if(!outertrack) continue;
 261       for(Int_t in=0;in<kNIn;in++){
 262         AliL3Track *innertrack=tracksin->GetCheckedTrack(in);
 263         if(!innertrack) continue;
 264         Double_t diff = TrackDiff(innertrack,outertrack);
 265         if(diff>=0&&diff<min){
 266           min=diff;
 267           inmin=in;
 268           outmin=out;
 269         }
 270       }
 271     }
 272     if(inmin>=0&&outmin>=0){
 273       AliL3Track *outertrack=tracksout->GetTrack(outmin);
 274       AliL3Track *innertrack=tracksin->GetTrack(inmin);
 275       tracks[0]=innertrack;
 276       tracks[1]=outertrack;
 277       SortTracks(tracks,2);
 278       Print(tracks);
 279       MultiMerge(mergedtrack,tracks,2);
 280       outertrack->CalculatePoint(xval);
 281       innertrack->CalculatePoint(xval);
 282       FillNtuple(ntuple,innertrack,outertrack);
 283       tracksout->Remove(outmin);
 284       tracksin->Remove(inmin);
 285       //      tracksout->Compress();
 286       //      tracksin->Compress();
 287     }
 288     else merge = kFALSE;
 289   }
 290   LOG(AliL3Log::kInformational,"AliL3HoughMerger::SlowMerge","Result")
 291     <<AliL3Log::kDec<<"Merged Tracks: "
 292     <<mergedtrack->GetNTracks()-kNMerged<<ENDLOG;
 293   char name[256] = "ntuple_t.root";
 294   for(Int_t i=0;i<GetNIn();i++)
 295     if(tracksin==GetInTracks(i))
 296       sprintf(name,"ntuple_t_%d.root",i);
 297   WriteNtuple(name,ntuple);
 298 }
 299
 300 void AliL3HoughMerger::Print(AliL3Track **tracks)
 301 {
 302   AliL3HoughTrack *tr1 = (AliL3HoughTrack*)tracks[0];
 303   AliL3HoughTrack *tr2 = (AliL3HoughTrack*)tracks[1];
 304   Double_t kappadiff = fabs(tr1->GetKappa()-tr2->GetKappa());
 305   Double_t phi0diff = fabs(tr1->GetPhi0()-tr2->GetPhi0());
 306   cout << "---------Difference in merged tracks---------"<<endl;
 307   cout << "Kappa: "<<kappadiff<<" Phi0 : "<<phi0diff<<endl;
 308
 309 }