HLT/TPCLib/AliHLTTPCInterMerger.cxx

   1 // @(#) $Id$
   2 // Original: AliHLTInterMerger.cxx,v 1.8 2005/06/14 10:55:21 cvetan
   3
   4 /**************************************************************************
   5  * This file is property of and copyright by the ALICE HLT Project        *
   6  * ALICE Experiment at CERN, All rights reserved.                         *
   7  *                                                                        *
   8  * Primary Authors: Uli Frankenfeld, maintained by                          *
   9  *                  Matthias Richter <Matthias.Richter@ift.uib.no>        *
  10  *                  for The ALICE HLT Project.                            *
  11  *                                                                        *
  12  * Permission to use, copy, modify and distribute this software and its   *
  13  * documentation strictly for non-commercial purposes is hereby granted   *
  14  * without fee, provided that the above copyright notice appears in all   *
  15  * copies and that both the copyright notice and this permission notice   *
  16  * appear in the supporting documentation. The authors make no claims     *
  17  * about the suitability of this software for any purpose. It is          *
  18  * provided "as is" without express or implied warranty.                  *
  19  **************************************************************************/
  20
  21 /** @file   AliHLTTPCInterMerger.cxx
  22     @author Uli Frankenfeld, maintained by Matthias Richter
  23     @date
  24     @brief  The HLT TPC track segment merger
  25 */
  26
  27 #include "AliHLTTPCLogging.h"
  28 #include "AliHLTTPCInterMerger.h"
  29 #include "AliHLTTPCTrack.h"
  30 #include "AliHLTTPCTrackSegmentData.h"
  31 #include "AliHLTTPCTransform.h"
  32 #include "AliHLTTPCTrackArray.h"
  33
  34 #if __GNUC__ >= 3
  35 using namespace std;
  36 #endif
  37
  38 ClassImp(AliHLTTPCInterMerger)
  39
  40 AliHLTTPCInterMerger::AliHLTTPCInterMerger()
  41   :
  42   fPatch(0),
  43   fRowMin(0),
  44   fRowMax(0)
  45 {
  46   //Default constructor
  47   InitMerger(1);
  48   Is2Global(kFALSE);
  49 //  SetParameter(2,2,.3,.3,.3);
  50   SetParameter(1,0.5,0.0005,0.05,0.1);
  51 }
  52
  53
  54 AliHLTTPCInterMerger::~AliHLTTPCInterMerger(){
  55   //Destructor
  56
  57 }
  58
  59 void AliHLTTPCInterMerger::SlowMerge(){
  60   Int_t nrow= fRowMax-fRowMin+1;
  61   void *ntuple=GetNtuple();
  62   AliHLTTPCTrackArray * tracks = GetInTracks(0);
  63   const Int_t  kNIn =tracks->GetNTracks();
  64   AliHLTTPCTrack *tr[2];
  65   Bool_t merge = kTRUE;
  66   for(Int_t in=0;in<kNIn;in++)
  67     tracks->GetCheckedTrack(in)->CalculateHelix();
  68   while(merge){
  69     Int_t inmin=-1,outmin=-1;
  70     Double_t min=10;
  71     for(Int_t out=0;out<kNIn;out++){
  72     AliHLTTPCTrack *outertrack=tracks->GetCheckedTrack(out);
  73     if(!outertrack) continue;
  74       for(Int_t in=0;in<kNIn;in++){
  75         if(in==out) continue;
  76         AliHLTTPCTrack *innertrack=tracks->GetCheckedTrack(in);
  77         if(!innertrack) continue;
  78         if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue;
  79
  80         Double_t diff = TrackDiff(innertrack,outertrack);
  81
  82         if(diff>=0&&diff<min){
  83           min=diff;
  84           inmin=in;
  85           outmin=out;
  86         }
  87       }
  88     }
  89     if(inmin>=0&&outmin>=0){
  90       AliHLTTPCTrack *outertrack=tracks->GetTrack(outmin);
  91       AliHLTTPCTrack *innertrack=tracks->GetTrack(inmin);
  92       tr[0]=innertrack;
  93       tr[1]=outertrack;
  94       SortTracks(tr,2);
  95       MultiMerge(tracks,tr,2);
  96       outertrack->CalculatePoint(tr[0]->GetLastPointX());
  97       innertrack->CalculatePoint(tr[0]->GetLastPointX());
  98       PrintDiff(innertrack,outertrack);
  99       FillNtuple(ntuple,innertrack,outertrack);
 100       tracks->Remove(outmin);
 101       tracks->Remove(inmin);
 102     }
 103     else merge = kFALSE;
 104   }
 105   LOG(AliHLTTPCLog::kInformational,"AliHLTTPCInterMerger::SlowMerge","Result")
 106   <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<tracks->GetNTracks()-kNIn<<ENDLOG;
 107
 108   char name[256];
 109   sprintf(name,"ntuple_i_%d.root",fPatch);
 110   WriteNtuple(name,ntuple);
 111 }
 112
 113 void AliHLTTPCInterMerger::MMerge(){
 114   while(Merge());
 115   GetOutTracks()->AddTracks(GetInTracks(0));
 116 }
 117
 118 Int_t AliHLTTPCInterMerger::Merge(){
 119   Int_t nrow= fRowMax-fRowMin+1;
 120   Double_t xval =AliHLTTPCTransform::Row2X((fRowMax+fRowMin)/2);
 121   AliHLTTPCTrackArray * tracks = GetInTracks(0);
 122   const Int_t  kNIn =tracks->GetNTracks();
 123   AliHLTTPCTrack *tr[2];
 124   for(Int_t in=0;in<kNIn;in++){
 125     AliHLTTPCTrack *t = tracks->GetCheckedTrack(in);
 126     if(t){
 127       t->CalculateHelix();
 128       t->CalculatePoint(xval);
 129     }
 130   }
 131   for(Int_t out=0;out<kNIn;out++){
 132   AliHLTTPCTrack *outertrack=tracks->GetCheckedTrack(out);
 133   if(!outertrack) continue;
 134     for(Int_t in=0;in<kNIn;in++){
 135       if(in==out) continue;
 136       AliHLTTPCTrack *innertrack=tracks->GetCheckedTrack(in);
 137       if(!innertrack) continue;
 138       if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue;
 139
 140       if(IsTrack(innertrack,outertrack)){
 141         tr[0]=innertrack;
 142         tr[1]=outertrack;
 143         SortGlobalTracks(tr,2);
 144
 145         Double_t r0 = pow(tr[0]->GetLastPointX(),2)+
 146                       pow(tr[0]->GetLastPointY(),2);
 147         Double_t r1 = pow(tr[1]->GetFirstPointX(),2)+
 148                       pow(tr[1]->GetFirstPointY(),2);
 149         if(r0<r1){
 150           MultiMerge(tracks,tr,2);
 151           tracks->Remove(out);
 152           tracks->Remove(in);
 153           break;
 154         }
 155       }
 156     }
 157   }
 158   Int_t nmerged = tracks->GetNTracks()-kNIn;
 159   LOG(AliHLTTPCLog::kInformational,"AliHLTTPCInterMerger::Merge","Result")
 160   <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
 161   //add in tracks
 162 //  GetOutTracks()->AddTracks(GetInTracks(0));
 163
 164   return nmerged;
 165 }
 166
 167