HLT/TPCLib/AliHLTTPCConfMapTrack.cxx

   1 // @(#) $Id$
   2 // Original: AliHLTConfMapTrack.cxx,v 1.16 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: Anders Vestbo, 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   AliHLTTPCConfMapTrack.cxx
  22     @author Anders Vestbo, maintained by Matthias Richter
  23     @date
  24     @brief  Track class for conformal mapper
  25 */
  26
  27 #include "AliHLTTPCRootTypes.h"
  28 #include "AliHLTTPCLogging.h"
  29 #include "AliHLTTPCVertex.h"
  30 #include "AliHLTTPCConfMapPoint.h"
  31 #include "AliHLTTPCConfMapFit.h"
  32 #include "AliHLTTPCConfMapTrack.h"
  33 #include "AliHLTTPCTransform.h"
  34 //#include "AliHLTTPC.h"
  35
  36 #if __GNUC__ >= 3
  37 using namespace std;
  38 #endif
  39
  40 ClassImp(AliHLTTPCConfMapTrack)
  41
  42
  43 AliHLTTPCConfMapTrack::AliHLTTPCConfMapTrack()
  44   :
  45   fCurrentHit(0),
  46   fLastHit(0),
  47   fFirstHit(0),
  48   fs11Xy(0),
  49   fs12Xy(0),
  50   fs22Xy(0),
  51   fg1Xy(0),
  52   fg2Xy(0),
  53   fs11Sz(0),
  54   fs12Sz(0),
  55   fs22Sz(0),
  56   fg1Sz(0),
  57   fg2Sz(0),
  58   fddXy(0),
  59   fa1Xy(0),
  60   fa2Xy(0),
  61   fddSz(0),
  62   fa1Sz(0),
  63   fa2Sz(0)
  64 {
  65   //Constructor
  66   fChiSq[0] = 0.;
  67   fChiSq[1] = 0.;
  68 }
  69
  70 AliHLTTPCConfMapTrack::AliHLTTPCConfMapTrack(const AliHLTTPCConfMapTrack&)
  71   :
  72   fCurrentHit(0),
  73   fLastHit(0),
  74   fFirstHit(0),
  75   fs11Xy(0),
  76   fs12Xy(0),
  77   fs22Xy(0),
  78   fg1Xy(0),
  79   fg2Xy(0),
  80   fs11Sz(0),
  81   fs12Sz(0),
  82   fs22Sz(0),
  83   fg1Sz(0),
  84   fg2Sz(0),
  85   fddXy(0),
  86   fa1Xy(0),
  87   fa2Xy(0),
  88   fddSz(0),
  89   fa1Sz(0),
  90   fa2Sz(0)
  91 {
  92   // dummy copy constructor
  93   //HLTFatal("copy constructor untested");
  94 }
  95
  96 AliHLTTPCConfMapTrack& AliHLTTPCConfMapTrack::operator=(const AliHLTTPCConfMapTrack&)
  97 {
  98   // dummy assignment operator
  99   //HLTFatal("assignment operator untested");
 100   return *this;
 101 }
 102
 103 AliHLTTPCConfMapTrack::~AliHLTTPCConfMapTrack()
 104 {
 105   //deconstructor
 106 }
 107
 108 void AliHLTTPCConfMapTrack::DeleteCandidate()
 109 {
 110   //Deletes this track by resetting all its parameters. Does not delete
 111   //the object itself.
 112
 113   AliHLTTPCConfMapPoint *curHit = (AliHLTTPCConfMapPoint*)fFirstHit;
 114   AliHLTTPCConfMapPoint *nextHit;
 115
 116   while(curHit != 0)
 117     {
 118       nextHit = (AliHLTTPCConfMapPoint*)curHit->GetNextTrackHit();
 119       curHit->SetNextTrackHit(0);
 120       curHit = nextHit;
 121     }
 122
 123   UInt_t *hit_numbers = GetHitNumbers();
 124   for(Int_t i=0; i<GetNHits(); i++)
 125     {
 126       //fHitNumbers[i] = 0;
 127       hit_numbers[i]=0;
 128     }
 129
 130   SetRadius(0.);
 131   SetCenterX(0.);
 132   SetCenterY(0.);
 133
 134   ComesFromMainVertex(false);
 135
 136   SetNHits(0);
 137   SetCharge(0);
 138   fChiSq[0] = 0.;
 139   fChiSq[1] = 0.;
 140 }
 141
 142
 143 void AliHLTTPCConfMapTrack::SetProperties(Bool_t usage)
 144 {
 145   //Set the hits to this track to 'usage'
 146   for(StartLoop(); LoopDone(); GetNextHit())
 147     {
 148       AliHLTTPCConfMapPoint *p = (AliHLTTPCConfMapPoint*)fCurrentHit;
 149       p->SetUsage(usage);
 150     }
 151   return;
 152 }
 153
 154 void AliHLTTPCConfMapTrack::Reset()
 155 {
 156   //Resets the fit parameters of this track.
 157
 158   //xy-plane
 159   fs11Xy   = 0;
 160   fs12Xy   = 0;
 161   fs22Xy   = 0;
 162   fg1Xy    = 0;
 163   fg2Xy    = 0;
 164   fChiSq[0]  = 0.;
 165
 166   //sz-plane
 167   fs11Sz = 0;
 168   fs12Sz = 0;
 169   fs22Sz = 0;
 170   fg1Sz  = 0;
 171   fg2Sz  = 0;
 172   fChiSq[1] = 0;
 173   SetLength(0);
 174   SetNHits(0);
 175 }
 176
 177 void AliHLTTPCConfMapTrack::UpdateParam(AliHLTTPCConfMapPoint *thisHit)
 178 {
 179   //Function to update fit parameters of track
 180   //Also, it updates the hit pointers.
 181
 182
 183   //Increment the number of hits assigned to this track:
 184
 185   //fNHits++;
 186   Int_t nhits = GetNHits();
 187   nhits++;
 188   SetNHits(nhits); //SetNHits(nhits++);
 189
 190   //Set the hit pointers:
 191   //if(fNHits == 1)
 192   if(GetNHits()==1)
 193     fFirstHit = thisHit;
 194   else
 195     ((AliHLTTPCConfMapPoint*)fLastHit)->SetNextTrackHit(thisHit);
 196   fLastHit = thisHit;
 197
 198
 199   fs11Xy = fs11Xy + thisHit->GetXYWeight() ;
 200   fs12Xy = fs12Xy + thisHit->GetXYWeight() * thisHit->GetXprime() ;
 201   fs22Xy = fs22Xy + thisHit->GetXYWeight() * pow((thisHit->GetXprime()),2) ;
 202   fg1Xy  = fg1Xy  + thisHit->GetXYWeight() * thisHit->GetYprime() ;
 203   fg2Xy  = fg2Xy  + thisHit->GetXYWeight() * thisHit->GetXprime() * thisHit->GetYprime() ;
 204
 205   fddXy  = fs11Xy * fs22Xy - pow((fs12Xy),2) ;
 206   if ( fddXy != 0 )
 207     {
 208       fa1Xy  = ( fg1Xy * fs22Xy - fg2Xy * fs12Xy ) / fddXy ;
 209       fa2Xy  = ( fg2Xy * fs11Xy - fg1Xy * fs12Xy ) / fddXy ;
 210     }
 211
 212   //     Now in the sz plane
 213   fs11Sz = fs11Sz + thisHit->GetZWeight() ;
 214   fs12Sz = fs12Sz + thisHit->GetZWeight() * thisHit->GetS() ;
 215   fs22Sz = fs22Sz + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetS() ;
 216   fg1Sz  = fg1Sz  + thisHit->GetZWeight() * thisHit->GetZ() ;
 217   fg2Sz  = fg2Sz  + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetZ() ;
 218
 219
 220   fddSz  = fs11Sz * fs22Sz -  fs12Sz * fs12Sz ;
 221   if ( fddSz != 0 ) {
 222     fa1Sz  = ( fg1Sz * fs22Sz - fg2Sz * fs12Sz ) / fddSz ;
 223     fa2Sz  = ( fg2Sz * fs11Sz - fg1Sz * fs12Sz ) / fddSz ;
 224   }
 225 }
 226
 227
 228 void AliHLTTPCConfMapTrack::Fill(AliHLTTPCVertex *vertex,Double_t max_Dca)
 229 {
 230     //Fill track variables with or without fit.
 231
 232     // for straight line fit
 233     if (AliHLTTPCTransform::GetBFieldValue() == 0.0 ){
 234
 235         SetRadius(0.);
 236         SetPt(0.);
 237
 238         //go for fit of straight line in real space
 239         AliHLTTPCConfMapFit *fit = new AliHLTTPCConfMapFit(this,vertex);
 240     /* Matthias 13.12.2006
 241      * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
 242      * and has always been kTRUE.
 243      * In order to remove the AliHLTTPC class (which is the old steering class for
 244      * HLT (TPC) tracking) from the compilation, this function can not be activated
 245      * again. We have to think about a more elegant way to specify the parameters
 246      * anyway.
 247         ComesFromMainVertex(AliHLTTPC::DoVertexFit());
 248      */
 249         ComesFromMainVertex(kTRUE);
 250         fit->FitStraightLine();
 251
 252         AliHLTTPCConfMapPoint *fHit = (AliHLTTPCConfMapPoint*)fFirstHit;
 253         SetLastPoint(fHit->GetX(),fHit->GetY(),fHit->GetZ());
 254
 255         UpdateToFirstPoint();
 256
 257         delete fit;
 258
 259     }
 260     // for helix fit
 261     else {
 262       //fRadius = sqrt(fa2Xy*fa2Xy+1)/(2*fabs(fa1Xy));
 263       Double_t radius = sqrt(fa2Xy*fa2Xy+1)/(2*fabs(fa1Xy));
 264       SetRadius(radius);
 265
 266       //fPt = (Double_t)(AliHLTTPCTransform::GetBFieldValue() * fRadius);
 267       Double_t pt = (Double_t)(AliHLTTPCTransform::GetBFieldValue() * GetRadius());
 268       SetPt(pt);
 269
 270       if(GetPt() > max_Dca) //go for fit of helix in real space
 271         {
 272           AliHLTTPCConfMapFit *fit = new AliHLTTPCConfMapFit(this,vertex);
 273     /* Matthias 13.12.2006
 274      * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
 275      * and has always been kTRUE.
 276      * In order to remove the AliHLTTPC class (which is the old steering class for
 277      * HLT (TPC) tracking) from the compilation, this function can not be activated
 278      * again. We have to think about a more elegant way to specify the parameters
 279      * anyway.
 280             ComesFromMainVertex(AliHLTTPC::DoVertexFit());
 281      */
 282           ComesFromMainVertex(kTRUE);
 283           fit->FitHelix();
 284
 285           //AliHLTTPCConfMapPoint *lHit = (AliHLTTPCConfMapPoint*)fLastHit;
 286           AliHLTTPCConfMapPoint *fHit = (AliHLTTPCConfMapPoint*)fFirstHit;
 287           SetLastPoint(fHit->GetX(),fHit->GetY(),fHit->GetZ());
 288
 289           UpdateToFirstPoint();
 290
 291           delete fit;
 292         }
 293       else if(GetPt() == 0)
 294         {
 295           LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<<
 296             "Found track with Pt=0!!!"<<ENDLOG;
 297         }
 298       else
 299         {
 300           LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<<
 301             "Track with pt<max_Dca :"<<GetPt()<<ENDLOG;
 302         }
 303     }
 304 }
 305
 306 Int_t AliHLTTPCConfMapTrack::GetMCLabel()
 307 {
 308   //For evaluation study.
 309   //Returns the MCtrackID of the belonging clusters.
 310   //If MCLabel < 0, means that track is fake.
 311
 312   return 0;
 313   /*
 314   Int_t num_of_clusters = GetNumberOfPoints();
 315   S *s=new S[num_of_clusters];
 316   Int_t i;
 317   for (i=0; i<num_of_clusters; i++) s[i].lab=s[i].max=0;
 318
 319   Int_t lab=123456789;
 320   for (i=0; i<num_of_clusters; i++) {
 321     AliHLTTPCConfMapPoint *c=(AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(i);
 322     lab=fabs(c->fMCTrackID[0]);
 323     Int_t j;
 324     for (j=0; j<num_of_clusters; j++)
 325       if (s[j].lab==lab || s[j].max==0) break;
 326     s[j].lab=lab;
 327     s[j].max++;
 328   }
 329
 330   Int_t max=0;
 331   for (i=0; i<num_of_clusters; i++)
 332     if (s[i].max>max) {max=s[i].max; lab=s[i].lab;}
 333
 334   delete[] s;
 335
 336   for (i=0; i<num_of_clusters; i++) {
 337     AliHLTTPCConfMapPoint *c=(AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(i);
 338     if (fabs(c->fMCTrackID[1]) == lab ||
 339         fabs(c->fMCTrackID[2]) == lab ) max++;
 340   }
 341
 342   //check if more than 10% of the clusters are incorrectly assigned (fake track):
 343
 344   if (1.-Float_t(max)/num_of_clusters > 0.10)
 345     {
 346       return -lab;
 347     }
 348   Int_t tail=Int_t(0.08*174);
 349   if (num_of_clusters < tail) return lab;
 350
 351   max=0;
 352   for (i=1; i<=tail; i++) {
 353     AliHLTTPCConfMapPoint *c = (AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(num_of_clusters-i);
 354     if (lab == fabs(c->fMCTrackID[0]) ||
 355         lab == fabs(c->fMCTrackID[1]) ||
 356         lab == fabs(c->fMCTrackID[2])) max++;
 357   }
 358   if (max < Int_t(0.5*tail))
 359     {
 360       //printf("Wrong innermost clusters\n");
 361       return -lab;
 362     }
 363   return lab;
 364   */
 365 }
 366