HLT/TPCLib/AliHLTTPCGlobalMerger.cxx

   1 // @(#) $Id$
   2 // Original: AliHLTGlobalMerger.cxx,v 1.13 2005/06/14 10:55:21 cvetan
   3
   4 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
   5 //*-- Copyright &copy ALICE HLT Group
   6
   7 #include "AliHLTTPCLogging.h"
   8 #include "AliHLTTPCGlobalMerger.h"
   9 #include "AliHLTTPCTrack.h"
  10 #include "AliHLTTPCTransform.h"
  11 #include "AliHLTTPCTrackArray.h"
  12
  13 /** \class AliHLTTPCGlobalMerger
  14 <pre>
  15 //_____________________________________________________________
  16 // AliHLTTPCGlobalMerger
  17 //
  18 // The HLTTPC Slice merger
  19 //
  20 </pre>
  21 */
  22
  23 #if __GNUC__ >= 3
  24 using namespace std;
  25 #endif
  26
  27 ClassImp(AliHLTTPCGlobalMerger)
  28
  29 AliHLTTPCGlobalMerger::AliHLTTPCGlobalMerger()
  30 {
  31   //Default constructor. Use Setup to specify and setup the necessary parameters and arrays.
  32   Is2Global(kTRUE);
  33   SetParameter(0,0,0,0,0);
  34   fNSlices=0;
  35   fFirst=0;
  36   fLast=0;
  37 }
  38
  39
  40 AliHLTTPCGlobalMerger::~AliHLTTPCGlobalMerger()
  41 {
  42   //Destructor
  43 }
  44
  45 void AliHLTTPCGlobalMerger::Setup(Int_t first,Int_t last)
  46 {
  47   //Used to setup the arrays and everything
  48
  49   fNSlices = last-first+1;
  50   fFirst = first;
  51   fLast = last;
  52   InitMerger(last-first+1);
  53 }
  54
  55 void AliHLTTPCGlobalMerger::InitSlice(Int_t slice)
  56 {
  57   //
  58   // Select Sector The following FillTracks call will
  59   // fill this Sector
  60   //
  61   fSlice = slice;
  62   fCurrentTracks = fSlice - fFirst;
  63 }
  64
  65 Double_t AliHLTTPCGlobalMerger::CheckTracks(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack,Int_t slice)
  66 {
  67   //Compare the tracks by propagating the outermost track to the last and first point plane
  68   //of the innermost track. This plane is defined by the padrow plane where these points
  69   //are.
  70
  71   if(innertrack->GetCharge()!=outertrack->GetCharge()) return -1;
  72
  73   Float_t angle = 0;//perpendicular to the padrowplane (in local system)
  74   AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
  75   Double_t dx[2],dy[2],dz[2];
  76   Double_t diff =-1;
  77   AliHLTTPCTrack *tracks[2];
  78   tracks[0] = innertrack;
  79   tracks[1] = outertrack;
  80   SortGlobalTracks(tracks,2);
  81   innertrack = tracks[0];
  82   outertrack = tracks[1];
  83
  84   Float_t point[3];
  85
  86   point[0]=innertrack->GetLastPointX();
  87   point[1]=innertrack->GetLastPointY();
  88   point[2]=innertrack->GetLastPointZ();
  89   AliHLTTPCTransform::Global2LocHLT(point,slice);
  90
  91   outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
  92   if(!outertrack->IsPoint()) return diff;
  93   dx[0] = fabs(outertrack->GetPointX()-innertrack->GetLastPointX());
  94   dy[0] = fabs(outertrack->GetPointY()-innertrack->GetLastPointY());
  95   dz[0] = fabs(outertrack->GetPointZ()-innertrack->GetLastPointZ());
  96
  97   point[0]=innertrack->GetFirstPointX();
  98   point[1]=innertrack->GetFirstPointY();
  99   point[2]=innertrack->GetFirstPointZ();
 100   AliHLTTPCTransform::Global2LocHLT(point,slice);
 101
 102   outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
 103   if(!outertrack->IsPoint()) return diff;
 104   dx[1] = fabs(outertrack->GetPointX()-innertrack->GetFirstPointX());
 105   dy[1] = fabs(outertrack->GetPointY()-innertrack->GetFirstPointY());
 106   dz[1] = fabs(outertrack->GetPointZ()-innertrack->GetFirstPointZ());
 107
 108   diff=0;//This was a tough bug to find....
 109   for(Int_t i=0; i<2; i++)
 110     diff += sqrt(dx[i]*dx[i] + dy[i]*dy[i] + dz[i]*dz[i]);
 111   return diff;
 112 }
 113
 114 void AliHLTTPCGlobalMerger::SlowMerge(Char_t *path)
 115 {
 116   //Tuning of parameters. This matches _all_ tracks between two neighbouring
 117   //slices, and merges the ones which are closest in space. The difference
 118   //is written to a ntuppel, which can be used as a input for the SetParameters
 119   //when using normal Merge function.
 120
 121
 122   void* ntuple=GetNtuple();
 123   AliHLTTPCTrack *track[2];
 124   AliHLTTPCTrackArray *tout = GetOutTracks();
 125   if(fNSlices<2)
 126     {
 127       LOG(AliHLTTPCLog::kWarning,"AliHLTTPCGlobalMerger::SlowMerge","Slice Number")
 128         <<"Need more than one Slice!"<<ENDLOG;
 129       return;
 130     }
 131
 132   for(Int_t i=0; i<fNSlices; i++)
 133     {
 134       //if(fNSlices!=18 && i+1 == fNSlices) continue;
 135       Int_t slice = fFirst + i;
 136       AliHLTTPCTrackArray *ttt0=GetInTracks(i);
 137       Int_t slice2 = i+1;
 138       //if(slice2==fNSlices) slice2 =0;
 139
 140       //Make sure slices are on the same side of the TPC
 141       if(slice2 == 18) slice2=0;
 142       else if(slice2 == 36) slice2=18;
 143       AliHLTTPCTrackArray *ttt1=GetInTracks(slice2);
 144       //10 degrees -> the border of the slices in local coordinates
 145       Float_t angle = AliHLTTPCTransform::Pi()/18;
 146       AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
 147
 148       //In the two following cases, the angle is 2*pi, so set it back to 0 in order for
 149       //the calculation of crossing points to be correct.
 150       if(slice==17 || slice==35)
 151         angle=0;
 152       if(i==0)
 153         ttt0->QSort();
 154       ttt1->QSort();
 155       for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
 156         {
 157           AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
 158           if(!track0) continue;
 159           track0->CalculateHelix();
 160           track0->CalculateEdgePoint(angle);
 161           //      if(track0->IsPoint()) AddTrack(tout,track0);
 162         }
 163       for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
 164         {
 165           AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
 166           if(!track1) continue;
 167           track1->CalculateHelix();
 168           track1->CalculateEdgePoint(angle);
 169           //      if(track1->IsPoint())  AddTrack(tout,track1);
 170         }
 171       Bool_t merge = kTRUE;
 172       while(merge)
 173         {
 174           Int_t min0=-1,min1=-1;
 175           Double_t min=5;
 176           Int_t n0=ttt0->GetNTracks(),n1=ttt1->GetNTracks();
 177           for(Int_t s0=0;s0<n0;s0++)
 178             {
 179               AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
 180               if(!track0) continue;
 181               if(!track0->IsPoint()) continue;
 182               for(Int_t s1=0;s1<n1;s1++)
 183                 {
 184                   AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
 185                   if(!track1) continue;
 186                   if(!track1->IsPoint()) continue;
 187
 188                   //Double_t diff = TrackDiff(track0,track1,angle);
 189                   Double_t diff = CheckTracks(track0,track1,slice);
 190                   //PrintDiff(track0,track1);
 191                   if(diff>=0&&diff<min)
 192                     {
 193                       min=diff;
 194                       min0=s0;
 195                       min1=s1;
 196                     }
 197                 }
 198             }
 199           if(min0>=0&&min1>=0)
 200             {
 201               AliHLTTPCTrack *track0=ttt0->GetTrack(min0);
 202               AliHLTTPCTrack *track1=ttt1->GetTrack(min1);
 203               track[0] = track0;
 204               track[1] = track1;
 205               SortGlobalTracks(track,2);
 206               track1->CalculateEdgePoint((angle+AliHLTTPCTransform::Pi()/9));
 207               if(track1->IsPoint())//Check if the track will cross the boundary of yet another slice.
 208                 MultiMerge(ttt1,track,2);
 209               else
 210                 MultiMerge(tout,track,2);
 211               track0->CalculateReferencePoint(angle);
 212               track1->CalculateReferencePoint(angle);
 213               //PrintDiff(track0,track1);
 214               FillNtuple(ntuple,track0,track1);
 215               ttt0->Remove(min0);
 216               ttt1->Remove(min1);
 217
 218             }
 219           else merge = kFALSE;
 220         }
 221       ttt0->Compress();
 222       ttt1->Compress();
 223       LOG(AliHLTTPCLog::kInformational,"AliHLTTPCGlobalMerger::SlowMerge","Result")
 224         <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
 225         <<angle<<ENDLOG;
 226     }
 227   Char_t fname[1024];
 228   sprintf(fname,"%s/merge_parameters.root",path);
 229   WriteNtuple(fname,ntuple);
 230 }
 231
 232 void AliHLTTPCGlobalMerger::Merge()
 233 {
 234   //Normal merging procedure. Matches tracks which are within limits
 235   //set by SetParameters. Parameters can be tuned by SlowMerge.
 236
 237   AliHLTTPCTrack *track[2];
 238   AliHLTTPCTrackArray *tout = GetOutTracks();
 239   if(fNSlices<2)
 240     {
 241       LOG(AliHLTTPCLog::kWarning,"AliHLTTPCGlobalMerger::Merge","Slice Number")
 242         <<"Need more than one Slice!"<<ENDLOG;
 243       return;
 244     }
 245   for(Int_t i=0; i<fNSlices; i++)
 246     {
 247       //if(fNSlices!=18 && i+1 == fNSlices) continue;
 248       Int_t slice = fFirst + i;
 249       AliHLTTPCTrackArray *ttt0=GetInTracks(i);
 250       Int_t slice2 = i+1;
 251       //if(slice2==fNSlices) slice2 =0;
 252
 253       //Make sure slices are on the same side of the TPC
 254       if(slice2 == 18) slice2=0;
 255       else if(slice2 == 36) slice2=18;
 256       AliHLTTPCTrackArray *ttt1=GetInTracks(slice2);
 257       //10 degrees -> the border of the slices in local coordinates
 258       Float_t angle = AliHLTTPCTransform::Pi()/18;
 259       AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
 260
 261       //In the two following cases, the angle is 2*pi, so set it back to 0 in order for
 262       //the calculation of crossing points to be correct.
 263       if(slice==17 || slice==35)
 264         angle=0;
 265       if(i==0)
 266         ttt0->QSort();
 267       ttt1->QSort();
 268       Bool_t *ismatched0  = new Bool_t[ttt0->GetNTracks()];
 269       Bool_t *ismatched1  = new Bool_t[ttt1->GetNTracks()];
 270       Int_t n0=0,n1=0;
 271       for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
 272         {
 273           ismatched0[s0]=kFALSE;
 274           AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
 275           if(!track0) continue;
 276           track0->CalculateHelix();
 277           track0->CalculateEdgePoint(angle);
 278           if(track0->IsPoint())
 279             {
 280               n0++;
 281               track0->CalculateReferencePoint(angle);
 282             }
 283         }
 284       for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
 285         {
 286           ismatched1[s1]=kFALSE;
 287           AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
 288           if(!track1) continue;
 289           track1->CalculateHelix();
 290           track1->CalculateEdgePoint(angle);
 291           if(track1->IsPoint())
 292             {
 293               n1++;
 294               track1->CalculateReferencePoint(angle);
 295             }
 296         }
 297       for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
 298         {
 299           if(ismatched0[s0]) continue;
 300           AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
 301           if(!track0) continue;
 302           if(!track0->IsPoint()) continue;
 303           for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
 304             {
 305               if(ismatched1[s1]) continue;
 306               AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
 307               if(!track1) continue;
 308               if(!track1->IsPoint()) continue;
 309               if(IsRTrack(track0,track1))
 310                 {
 311                   track[0] = track0;
 312                   track[1] = track1;
 313                   SortGlobalTracks(track,2);
 314                   Double_t r0 = pow(track[0]->GetLastPointX(),2)+
 315                     pow(track[0]->GetLastPointY(),2);
 316                   Double_t r1 = pow(track[1]->GetFirstPointX(),2)+
 317                     pow(track[1]->GetFirstPointY(),2);
 318                   if(r0<r1)
 319                     {
 320                       MultiMerge(tout,track,2);
 321                       ismatched0[s0]=kTRUE;
 322                       ismatched1[s1]=kTRUE;
 323                       ttt0->Remove(s0);
 324                       ttt1->Remove(s1);
 325                       break;
 326                       /*
 327                         The track is merged, so we will _not_ look for more matches.
 328                         Because there could easily be more matches, if a track is being
 329                         split within the sector....
 330                       */
 331                     }
 332                 }
 333             }
 334         }
 335       LOG(AliHLTTPCLog::kInformational,"AliHLTTPCGlobalMerger::Merge","Result")
 336         <<AliHLTTPCLog::kDec<<"slice0: "<<n0<<" slice1: "<<n1
 337         <<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
 338       delete [] ismatched0;
 339       delete [] ismatched1;
 340     }
 341 }