HLT/TPCLib/AliHLTTPCConfMapTrack.cxx

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