HLT/src/AliL3TrackMerger.cxx

   1 // @(#) $Id$
   2
   3 // Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
   4 //*-- Copyright &copy ALICE HLT Group
   5
   6 #include "AliL3StandardIncludes.h"
   7
   8 #include "AliL3Logging.h"
   9 #include "AliL3TrackMerger.h"
  10 #include "AliL3Track.h"
  11 #include "AliL3TrackSegmentData.h"
  12 #include "AliL3Transform.h"
  13 #include "AliL3TrackArray.h"
  14
  15 /** \class AliL3TrackMerger
  16 <pre>
  17 //_____________________________________________________________
  18 // AliL3TrackMerger
  19 //
  20 // The L3 track segment merger
  21 //
  22 </pre
  23 */
  24
  25 ClassImp(AliL3TrackMerger)
  26
  27 AliL3TrackMerger::AliL3TrackMerger(){
  28   //Default constructor
  29   Is2Global(kFALSE);
  30   fSlow = kFALSE;
  31   SetParameter();
  32   fRowMin = 0;
  33   fRowMax = 0;
  34 }
  35
  36
  37 AliL3TrackMerger::AliL3TrackMerger(Int_t nsubsectors):AliL3Merger(nsubsectors){
  38   //Constructor.
  39   fNSubSector = nsubsectors;
  40   Is2Global(kFALSE);
  41   fSlow = kFALSE;
  42   SetParameter();
  43   fRowMin = new Int_t[nsubsectors];
  44   fRowMax = new Int_t[nsubsectors];
  45 }
  46
  47 AliL3TrackMerger::~AliL3TrackMerger(){
  48   //Destructor
  49 }
  50
  51 void AliL3TrackMerger::SetRows(Int_t *row){
  52   for(Int_t i=0;i<fNSubSector;i++){
  53     fRowMin[i]=*(row+(2*i));
  54     fRowMax[i]=*(row+(2*i+1));
  55   }
  56 }
  57
  58 void AliL3TrackMerger::InitSector(Int_t slice,Int_t subsector){
  59   //
  60   // Select Sector and subsector. The following FillTracks call will
  61   // fill this subsector
  62   //
  63   fSlice = slice;
  64   fSubSector = subsector;
  65   fCurrentTracks = fSubSector;
  66 }
  67
  68 void AliL3TrackMerger::SlowMerge(AliL3TrackArray *mergedtrack,AliL3TrackArray *tracksin,AliL3TrackArray *tracksout,Double_t xval){
  69   void *ntuple=GetNtuple();
  70   const Int_t  kNOut=tracksout->GetNTracks();
  71   const Int_t  kNIn =tracksin->GetNTracks();
  72   const Int_t  kNMerged =mergedtrack->GetNTracks();
  73   AliL3Track *tracks[2];
  74   Bool_t merge = kTRUE;
  75   while(merge){
  76     Int_t inmin=-1,outmin=-1;
  77     Double_t min=10;
  78     for(Int_t out=0;out<kNOut;out++){
  79     AliL3Track *outertrack=tracksout->GetCheckedTrack(out);
  80     if(!outertrack) continue;
  81       for(Int_t in=0;in<kNIn;in++){
  82         AliL3Track *innertrack=tracksin->GetCheckedTrack(in);
  83         if(!innertrack) continue;
  84         Double_t diff = TrackDiff(innertrack,outertrack);
  85         if(diff>=0&&diff<min){
  86           min=diff;
  87           inmin=in;
  88           outmin=out;
  89         }
  90       }
  91     }
  92     if(inmin>=0&&outmin>=0){
  93       AliL3Track *outertrack=tracksout->GetTrack(outmin);
  94       AliL3Track *innertrack=tracksin->GetTrack(inmin);
  95       tracks[0]=innertrack;
  96       tracks[1]=outertrack;
  97       SortTracks(tracks,2);
  98       MultiMerge(mergedtrack,tracks,2);
  99       outertrack->CalculatePoint(xval);
 100       innertrack->CalculatePoint(xval);
 101       PrintDiff(innertrack,outertrack);
 102       //FillNtuple(ntuple,innertrack,outertrack);
 103       tracksout->Remove(outmin);
 104       tracksin->Remove(inmin);
 105 //      tracksout->Compress();
 106 //      tracksin->Compress();
 107     }
 108     else merge = kFALSE;
 109   }
 110   LOG(AliL3Log::kInformational,"AliL3TrackMerger::SlowMerge","Result")
 111   <<AliL3Log::kDec<<"Merged Tracks: "
 112   <<mergedtrack->GetNTracks()-kNMerged<<ENDLOG;
 113   char name[256] = "ntuple_t.root";
 114   for(Int_t i=0;i<4;i++)
 115     if(tracksin==GetInTracks(i))
 116       sprintf(name,"ntuple_t_%d.root",i);
 117   WriteNtuple(name,ntuple);
 118 }
 119
 120 void AliL3TrackMerger::SlowMerge(){
 121   fSlow = kTRUE;
 122   Merge();
 123 }
 124
 125 void AliL3TrackMerger::InterMerge(){
 126
 127   for(Int_t patch=0;patch< GetNIn();patch++){
 128     AliL3TrackArray * tracks = GetInTracks(patch);
 129     Double_t xval = AliL3Transform::Row2X((fRowMax[patch]+fRowMin[patch])/2);
 130     Int_t nrow= fRowMax[patch]-fRowMin[patch]+1;
 131     const Int_t  kNIn =tracks->GetNTracks();
 132     AliL3Track *tr[2];
 133     for(Int_t in=0;in<kNIn;in++){
 134       AliL3Track *t = tracks->GetCheckedTrack(in);
 135       if(t){
 136         t->CalculateHelix();
 137         t->CalculatePoint(xval);
 138       }
 139     }
 140     for(Int_t out=0;out<kNIn;out++){
 141     AliL3Track *outertrack=tracks->GetCheckedTrack(out);
 142     if(!outertrack) continue;
 143       for(Int_t in=0;in<kNIn;in++){
 144         if(in==out) continue;
 145         AliL3Track *innertrack=tracks->GetCheckedTrack(in);
 146         if(!innertrack) continue;
 147         if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue;
 148
 149         if(IsTrack(innertrack,outertrack)){
 150           tr[0]=innertrack;
 151           tr[1]=outertrack;
 152           SortTracks(tr,2);
 153           if(tr[0]->GetLastPointX()<tr[1]->GetFirstPointX()){
 154             MultiMerge(tracks,tr,2);
 155             tracks->Remove(out);
 156             tracks->Remove(in);
 157             break;
 158           }
 159         }
 160       }
 161     }
 162     Int_t nmerged = tracks->GetNTracks()-kNIn;
 163     LOG(AliL3Log::kInformational,"AliL3TrackMerger::InterMerge","Result")
 164     <<AliL3Log::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
 165   }
 166 }
 167
 168 void AliL3TrackMerger::Merge(){
 169   //Loop over tracks and pass them to the track merger.
 170   Double_t edge0 = PI/18.;
 171   Double_t edge1 = 2*PI - edge0;
 172   AliL3TrackArray *ttt = GetOutTracks();
 173   if(fNSubSector==1) {
 174     GetOutTracks()->AddTracks(GetInTracks(0));
 175     LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result")
 176     <<AliL3Log::kDec<<"Total Copied Tracks: "<<GetOutTracks()->GetNPresent()
 177     <<ENDLOG;
 178     return;
 179   }
 180   Int_t subsec = fNSubSector -2;
 181   for(Int_t i=subsec;i>=0;i--){
 182     AliL3TrackArray *tout = GetOutTracks();
 183     if(i==subsec) tout = GetInTracks(subsec+1);
 184     AliL3TrackArray *tin = GetInTracks(i);
 185     Double_t xval = AliL3Transform::Row2X(fRowMax[i]);
 186     Double_t xmax = AliL3Transform::Row2X(fRowMax[i+1]);
 187     Double_t ymax = xval*tan(edge0);
 188     for(Int_t out=0;out<tout->GetNTracks();out++){
 189       AliL3Track *outtrack=tout->GetCheckedTrack(out);
 190       if(!outtrack) continue;
 191       outtrack->CalculateHelix();
 192       outtrack->CalculatePoint(xval);
 193       if(outtrack->IsPoint()&&fabs(outtrack->GetPointY())>ymax){
 194         if(outtrack->GetNHits()<10)
 195           tout->Remove(out);
 196       }
 197     }
 198 //    tout->Compress();
 199     for(Int_t in=0;in<tin->GetNTracks();in++){
 200       AliL3Track *intrack=(AliL3Track*)tin->GetTrack(in);
 201       intrack->CalculateHelix();
 202       intrack->CalculatePoint(xval);
 203     }
 204     tin->QSort();
 205     tout->QSort();
 206
 207     if(fSlow) SlowMerge(ttt,tin,tout,xval);
 208     else Merge(ttt,tin,tout);
 209     for(Int_t in=0;in<tin->GetNTracks();in++){
 210       AliL3Track *intrack=(AliL3Track*)tin->GetCheckedTrack(in);
 211       if(!intrack) continue;
 212       if(intrack->CalculateEdgePoint(edge0)){
 213         if(intrack->GetPointX()<xmax ){
 214           AddTrack(ttt,intrack);
 215           tin->Remove(in);
 216         }
 217       }
 218       else if(intrack->CalculateEdgePoint(edge1)){
 219         if(intrack->GetPointX()<xmax ){
 220           AddTrack(ttt,intrack);
 221           tin->Remove(in);
 222         }
 223       }
 224     }
 225 /*
 226     for(Int_t in=0;in<tin->GetNTracks();in++){
 227       AliL3Track *intrack=(AliL3Track*)tin->GetCheckedTrack(in);
 228       if(!intrack) continue;
 229       if(intrack->GetNHits()<10) continue;
 230       AddTrack(ttt,intrack);
 231       tin->Remove(in);
 232     }
 233 */
 234   } // end subsector loop
 235   LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result")
 236   <<AliL3Log::kDec<<"Total Merged Tracks: "<<GetOutTracks()->GetNPresent()
 237   <<ENDLOG;
 238 }
 239
 240 Int_t AliL3TrackMerger::Merge(AliL3TrackArray* mergedtrack,AliL3TrackArray *tracksin,AliL3TrackArray *tracksout){
 241   //Loop over tracks and pass them to the track merger.
 242   AliL3Track *tracks[2];
 243
 244   const Int_t  kNOut=tracksout->GetNTracks();
 245   const Int_t  kNIn =tracksin->GetNTracks();
 246   const Int_t  kNMerged =mergedtrack->GetNTracks();
 247
 248   Bool_t *ismatchedin  = new Bool_t[kNIn];
 249   for(Int_t in =0;in<kNIn;in++)
 250     ismatchedin[in]=kFALSE;
 251   Bool_t *ismatchedout = new Bool_t[kNOut];
 252   for(Int_t out =0;out<kNOut;out++)
 253     ismatchedout[out] = kFALSE;
 254   for(Int_t out =0;out<kNOut;out++){
 255     AliL3Track *outertrack=(AliL3Track*)tracksout->GetCheckedTrack(out);
 256     if(!outertrack) continue;
 257     for(Int_t in =0;in<kNIn;in++){
 258       if(ismatchedin[in]) continue;
 259       AliL3Track *innertrack=(AliL3Track*)tracksin->GetCheckedTrack(in);
 260       if(!innertrack) continue;
 261       if(outertrack==innertrack) continue;
 262       if(outertrack->GetCharge()!=innertrack->GetCharge()) continue;
 263       if(IsTrack(innertrack,outertrack)){
 264         tracks[0]=innertrack; tracks[1]=outertrack;
 265         SortTracks(tracks,2);
 266         if(tracks[0]->GetLastPointX()<tracks[1]->GetFirstPointX()){
 267           MultiMerge(mergedtrack,tracks,2);
 268           tracksout->Remove(out);
 269           tracksin->Remove(in);
 270           ismatchedin[in]=kTRUE;
 271           ismatchedout[out]=kTRUE;
 272           break;
 273         }
 274       }
 275     }
 276   }
 277
 278   Int_t nmerged = mergedtrack->GetNTracks()-kNMerged;
 279   LOG(AliL3Log::kInformational,"AliL3TrackMerger::Merge","Result")
 280   <<AliL3Log::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
 281   delete[] ismatchedin;
 282   delete[] ismatchedout;
 283   return nmerged;
 284 }
 285
 286