HLT/TPCLib/AliHLTTPCConfMapPoint.cxx

   1 // @(#) $Id$
   2 // Original: AliHLTConfMapPoint.cxx,v 1.10 2005/06/23 17:46:55 hristov
   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   AliHLTTPCConfMapPoint.cxx
  22     @author Anders Vestbo, maintained by Matthias Richter
  23     @date
  24     @brief  Hit class for conformal mapper
  25 */
  26
  27 #include <cassert>
  28 #include "AliHLTTPCLogging.h"
  29 #include "AliHLTTPCConfMapPoint.h"
  30 #include "AliHLTTPCSpacePointData.h"
  31 #include "AliHLTTPCVertex.h"
  32 #include "AliHLTTPCConfMapTrack.h"
  33
  34 /**
  35 <pre>
  36 //_____________________________________________________________
  37 // AliHLTTPCConfMapPoint
  38 //
  39 // Hit class for conformal mapper
  40 </pre>
  41 */
  42
  43 /** ROOT macro for the implementation of ROOT specific class methods */
  44 ClassImp(AliHLTTPCConfMapPoint);
  45
  46 Bool_t AliHLTTPCConfMapPoint::fgDontMap=kFALSE;
  47
  48 AliHLTTPCConfMapPoint::AliHLTTPCConfMapPoint()
  49   :
  50   fHitNumber(-1),
  51   fTrackNumber(0),
  52   fNextHitNumber(0),
  53   fUsed(kFALSE),
  54   fPadrow(0),
  55   fSector(0),
  56   fx(0),
  57   fy(0),
  58   fz(0),
  59   fxerr(0),
  60   fyerr(0),
  61   fzerr(0),
  62   fWxy(0),
  63   fWz(0),
  64   fs(0),
  65   fXt(0),
  66   fYt(0),
  67   fZt(0),
  68   fXterr(0),
  69   fYterr(0),
  70   fZterr(0),
  71   fXprime(0),
  72   fYprime(0),
  73   fXprimeerr(0),
  74   fYprimeerr(0),
  75   fXv(0),
  76   fYv(0),
  77   fZv(0),
  78   fXverr(0),
  79   fYverr(0),
  80   fZverr(0),
  81   fPhi(0),
  82   fEta(0),
  83   fNextVolumeHit(NULL),
  84   fNextRowHit(NULL),
  85   fNextTrackHit(NULL),
  86   fPhiIndex(0),
  87   fEtaIndex(0),
  88   fXYChi2(0),
  89   fSZChi2(0)
  90 {
  91   //Constructor
  92   fMCTrackID[0]=-1;
  93   fMCTrackID[1]=-1;
  94   fMCTrackID[2]=-1;
  95 }
  96
  97 AliHLTTPCConfMapPoint::AliHLTTPCConfMapPoint(const AliHLTTPCConfMapPoint& src)
  98   :
  99   fHitNumber(src.fHitNumber),
 100   fTrackNumber(src.fTrackNumber),
 101   fNextHitNumber(src.fNextHitNumber),
 102   fUsed(src.fUsed),
 103   fPadrow(src.fPadrow),
 104   fSector(src.fSector),
 105   fx(src.fx),
 106   fy(src.fy),
 107   fz(src.fz),
 108   fxerr(src.fxerr),
 109   fyerr(src.fyerr),
 110   fzerr(src.fzerr),
 111   fWxy(src.fWxy),
 112   fWz(src.fWz),
 113   fs(src.fs),
 114   fXt(src.fXt),
 115   fYt(src.fYt),
 116   fZt(src.fZt),
 117   fXterr(src.fXterr),
 118   fYterr(src.fYterr),
 119   fZterr(src.fZterr),
 120   fXprime(src.fXprime),
 121   fYprime(src.fYprime),
 122   fXprimeerr(src.fXprimeerr),
 123   fYprimeerr(src.fYprimeerr),
 124   fXv(src.fXv),
 125   fYv(src.fYv),
 126   fZv(src.fZv),
 127   fXverr(src.fXverr),
 128   fYverr(src.fYverr),
 129   fZverr(src.fZverr),
 130   fPhi(src.fPhi),
 131   fEta(src.fEta),
 132   fNextVolumeHit(src.fNextVolumeHit),
 133   fNextRowHit(src.fNextRowHit),
 134   fNextTrackHit(src.fNextTrackHit),
 135   fPhiIndex(src.fPhiIndex),
 136   fEtaIndex(src.fEtaIndex),
 137   fXYChi2(src.fXYChi2),
 138   fSZChi2(src.fSZChi2)
 139 {
 140   //Copy Constructor
 141   fMCTrackID[0]=src.fMCTrackID[0];
 142   fMCTrackID[1]=src.fMCTrackID[1];
 143   fMCTrackID[2]=src.fMCTrackID[2];
 144 }
 145
 146 AliHLTTPCConfMapPoint& AliHLTTPCConfMapPoint::operator=(const AliHLTTPCConfMapPoint& src)
 147 {
 148   fHitNumber=src.fHitNumber;
 149   fTrackNumber=src.fTrackNumber;
 150   fNextHitNumber=src.fNextHitNumber;
 151   fUsed=src.fUsed;
 152   fPadrow=src.fPadrow;
 153   fSector=src.fSector;
 154   fx=src.fx;
 155   fy=src.fy;
 156   fz=src.fz;
 157   fxerr=src.fxerr;
 158   fyerr=src.fyerr;
 159   fzerr=src.fzerr;
 160   fWxy=src.fWxy;
 161   fWz=src.fWz;
 162   fs=src.fs;
 163   fXt=src.fXt;
 164   fYt=src.fYt;
 165   fZt=src.fZt;
 166   fXterr=src.fXterr;
 167   fYterr=src.fYterr;
 168   fZterr=src.fZterr;
 169   fXprime=src.fXprime;
 170   fYprime=src.fYprime;
 171   fXprimeerr=src.fXprimeerr;
 172   fYprimeerr=src.fYprimeerr;
 173   fXv=src.fXv;
 174   fYv=src.fYv;
 175   fZv=src.fZv;
 176   fXverr=src.fXverr;
 177   fYverr=src.fYverr;
 178   fZverr=src.fZverr;
 179   fPhi=src.fPhi;
 180   fEta=src.fEta;
 181   fNextVolumeHit=src.fNextVolumeHit;
 182   fNextRowHit=src.fNextRowHit;
 183   fNextTrackHit=src.fNextTrackHit;
 184   fPhiIndex=src.fPhiIndex;
 185   fEtaIndex=src.fEtaIndex;
 186   fXYChi2=src.fXYChi2;
 187   fSZChi2=src.fSZChi2;
 188   fMCTrackID[0]=src.fMCTrackID[0];
 189   fMCTrackID[1]=src.fMCTrackID[1];
 190   fMCTrackID[2]=src.fMCTrackID[2];
 191
 192   return *this;
 193 }
 194
 195 AliHLTTPCConfMapPoint::~AliHLTTPCConfMapPoint()
 196 {
 197   // Destructor.
 198 }
 199
 200 Bool_t AliHLTTPCConfMapPoint::Read(const AliHLTTPCSpacePointData& hit)
 201 {
 202   //read the hits
 203   SetHitNumber(hit.fID);
 204   SetPadRow(hit.fPadRow);
 205   SetSector(hit.GetSlice());
 206   SetX(hit.fX);
 207   SetY(hit.fY);
 208   SetZ(hit.fZ);
 209   SetXerr(sqrt(hit.fSigmaY2));
 210   SetYerr(sqrt(hit.fSigmaY2));
 211   SetZerr(sqrt(hit.fSigmaZ2));
 212   return kTRUE;
 213 }
 214
 215 void AliHLTTPCConfMapPoint::Reset()
 216 {
 217   //Reset this point.
 218   SetUsage(kFALSE);
 219   SetS(0);
 220   fNextRowHit = NULL;
 221   fNextVolumeHit=NULL;
 222   fNextTrackHit=NULL;
 223 }
 224
 225 void AliHLTTPCConfMapPoint::Setup(AliHLTTPCVertex *vertex)
 226 {
 227   //Setup. Sets the vertex, conformal coordinates,
 228   //and phi and eta of each hit.
 229
 230   SetIntPoint(vertex->GetX(),    vertex->GetY(),    vertex->GetZ(),
 231               vertex->GetXErr(), vertex->GetYErr(), vertex->GetZErr());
 232   SetShiftedCoord();
 233   SetConfCoord();
 234   // The angles are set properly if they are set after
 235   // the interaction point and the shifted coordinates
 236   SetAngles();
 237   //SetDist(0., 0.);
 238   return;
 239 }
 240
 241 void AliHLTTPCConfMapPoint::SetIntPoint(Double_t inx, Double_t iny, Double_t inz,
 242                                     Double_t inxerr, Double_t inyerr, Double_t inzerr)
 243 {
 244   // Defines a new interaction point. This point is needed to calculate
 245   // the conformal coordinates.
 246
 247   SetXt(inx);
 248   SetYt(iny);
 249   SetZt(inz);
 250   SetXterr(inxerr);
 251   SetYterr(inyerr);
 252   SetZterr(inzerr);
 253
 254   return;
 255 }
 256
 257 void AliHLTTPCConfMapPoint::SetAllCoord(const AliHLTTPCConfMapPoint *precedinghit)
 258 {
 259   // Sets the interaction point, the shifted coordinates, and the conformal mapping coordinates.
 260   // These values are calculated from the interaction point of the given cluster which should be a
 261   // already found cluster on the same track.
 262
 263   if (this == precedinghit) {
 264     SetIntPoint(precedinghit->GetX(),    precedinghit->GetY(),    precedinghit->GetZ(),
 265                 precedinghit->GetXerr(), precedinghit->GetYerr(), precedinghit->GetZerr());
 266   }
 267
 268   else {
 269     SetIntPoint(precedinghit->GetXt(),    precedinghit->GetYt(),    precedinghit->GetZt(),
 270                 precedinghit->GetXterr(), precedinghit->GetYterr(), precedinghit->GetZterr());
 271   }
 272
 273   SetShiftedCoord();
 274   SetConfCoord();
 275
 276   return;
 277 }
 278
 279 void AliHLTTPCConfMapPoint::SetShiftedCoord()
 280 {
 281   // Sets the coordinates with resepct to the given vertex point
 282
 283   SetXv(GetX() - fXt);
 284   SetYv(GetY() - fYt);
 285   SetZv(GetZ() - fZt);
 286   /*
 287   SetXverr(TMath::Sqrt(GetXerr()*GetXerr() + fXterr*fXterr));
 288   SetYverr(TMath::Sqrt(GetYerr()*GetYerr() + fYterr*fYterr));
 289   SetZverr(TMath::Sqrt(GetZerr()*GetZerr() + fZterr*fZterr));
 290   */
 291   return;
 292 }
 293
 294 void AliHLTTPCConfMapPoint::SetConfCoord()
 295 {
 296   // Calculates the conformal coordinates of one cluster.
 297   // If the option "vertex_constraint" applies the interaction point is
 298   // assumed to be at (0, 0, 0). Otherwise the function will use the
 299   // interaction point specified by fXt and fYt.
 300
 301   if(fgDontMap){
 302     fXprime = fx;
 303     fYprime = fy;
 304     fWxy = 0;
 305     fs = 0; //track trajectory
 306     fWz = 0;
 307     return;
 308   }
 309
 310   Double_t r2;
 311   Double_t xyErrorScale = 1;
 312   Double_t szErrorScale = 1;
 313
 314   if ((r2 = fXv*fXv + fYv*fYv))
 315     {
 316       fXprime =  fXv / r2;
 317       fYprime = -fYv / r2;
 318
 319       //set weights:
 320       fWxy = r2*r2 / ((xyErrorScale*xyErrorScale)*((fxerr*fxerr)+(fyerr*fyerr)));
 321       fs = 0; //track trajectory
 322       fWz = (Double_t)(1./(szErrorScale*fzerr*fzerr));
 323     } else {
 324     fXprime    = 0.;
 325     fYprime    = 0.;
 326     fXprimeerr = 0.;
 327     fYprimeerr = 0.;
 328     fWxy = 0;
 329     fWz = 0;
 330     fs = 0;
 331   }
 332
 333   return;
 334 }
 335
 336 void AliHLTTPCConfMapPoint::SetAngles()
 337 {
 338   // Calculates the angle phi and the pseudorapidity eta for each cluster.
 339   /*
 340   Double_t r = TMath::Sqrt(x*x + y*y);
 341
 342   fPhi = TMath::ATan2(y,x);
 343   if(fPhi<0) fPhi = fPhi + 2*TMath::Pi();
 344   fEta = 3.*z/(TMath::Abs(z)+2.*r);
 345   return;
 346   */
 347   //  Double_t r3dim = TMath::Sqrt(fXv*fXv + fYv*fYv + fZv*fZv);
 348   Double_t r3dim = sqrt(fXv*fXv + fYv*fYv + fZv*fZv);
 349   //Double_t r2dim = TMath::Sqrt(fXv*fXv + fYv*fYv);
 350
 351   /*if (r2dim == 0.) {
 352   // If r2dim == 0 the pseudorapidity eta cannot be calculated (division by zero)!
 353   // This can only happen if the point is lying on the z-axis and this should never be possible.
 354     cerr << "The pseudorapidity eta cannot be calculated (division by zero)! Set to 1.e-10." << endl;
 355     r2dim = 1.e-10;
 356   }
 357
 358   if (fXv == 0.) {
 359     fPhi = (fYv > 0.) ? TMath::Pi() / 2. : - TMath::Pi() / 2.;
 360   }
 361
 362   else {
 363     fPhi = (fXv > 0.) ? TMath::ASin(fYv/r2dim) : TMath::Pi() - TMath::ASin(fYv/r2dim);
 364   }
 365
 366   if (fPhi < 0.) {
 367     fPhi += 2. * TMath::Pi();
 368   }
 369   */
 370   //fPhi = TMath::ATan2(y,x);
 371   fPhi = atan2(fy,fx);
 372   //if(fPhi<0) fPhi = fPhi + 2*TMath::Pi();
 373
 374   //fEta = 0.5 * TMath::Log((r3dim + fZv)/(r3dim - fZv));
 375   fEta = 0.5 * log((r3dim + fZv)/(r3dim - fZv));
 376   return;
 377 }
 378
 379 /*
 380 AliHLTTPCConfMapTrack *AliHLTTPCConfMapPoint::GetTrack(TClonesArray *tracks) const
 381 {
 382   // Returns the pointer to the track to which this hit belongs.
 383
 384   return (AliHLTTPCConfMapTrack*)tracks->At(this->GetTrackNumber());
 385 }
 386 */