HLT/hough/AliHLTHoughMerger.cxx

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