HLT/TPCLib/AliHLTTPCGlobalMerger.cxx

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