HLT/TPCLib/AliHLTTPCGlobalMerger.cxx

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