HLT/hough/AliL3HoughMerger.cxx

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