TPC/AliTPCTracklet.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 ////
  17 // This class stores a tracklet (a track that lives only in a single TPC
  18 // sector). Its objects can be constructed out of TPCseeds, that are
  19 // holding the necessary cluster information.
  20 ////
  21 ////
  22 ////
  23
  24
  25 #include "AliTPCTracklet.h"
  26 #include "TObjArray.h"
  27 #include "AliTPCseed.h"
  28 #include "AliESDVertex.h"
  29
  30 ClassImp(AliTPCTracklet)
  31
  32 AliTPCTracklet::AliTPCTracklet()
  33   : fNClusters(0),fSector(-1),fOuter(0),fInner(0),fPrimary(0) {
  34   ////
  35   // The default constructor. It is intended to be used for I/O only.
  36   ////
  37 }
  38
  39 AliTPCTracklet::AliTPCTracklet(const AliTPCseed *track,Int_t sector)
  40   : fNClusters(0),fSector(sector),fOuter(0),fInner(0),fPrimary(0) {
  41   ////
  42   // Contructor for a tracklet out of a track. Only clusters within a given
  43   // sector are used.
  44   ///
  45
  46   AliTPCseed *t=new AliTPCseed(*track);
  47
  48   if (!t->Rotate(TMath::DegToRad()*(sector%18*20.+10.)-t->GetAlpha())) {
  49     delete t;
  50     return;
  51   }
  52
  53   // fit from inner to outer row
  54   AliTPCseed *outerSeed=new AliTPCseed(*t);
  55   Int_t n=0;
  56   for (Int_t i=0;i<160;++i) {
  57     AliTPCclusterMI *c=t->GetClusterPointer(i);
  58     if (c&&c->GetDetector()==sector) {
  59       if (n==1) {
  60         outerSeed->ResetCovariance(100.);
  61       }
  62       ++n;
  63       Double_t r[3]={c->GetX(),c->GetY(),c->GetZ()};
  64       Double_t cov[3]={0.1,0.,0.1}; //TODO: correct error parametrisation
  65       if (!outerSeed->PropagateTo(r[0])
  66           || !static_cast<AliExternalTrackParam*>(outerSeed)->Update(&r[1],cov)) {
  67         delete outerSeed;
  68         outerSeed=0;
  69         break;
  70       }
  71     }
  72   }
  73   fNClusters=n;
  74   if (outerSeed)
  75     fOuter=new AliExternalTrackParam(*outerSeed);
  76   delete outerSeed;
  77   // fit from outer to inner rows
  78   AliTPCseed *innerSeed=new AliTPCseed(*t);
  79   n=0;
  80   for (Int_t i=159;i>=0;--i) {
  81     AliTPCclusterMI *c=t->GetClusterPointer(i);
  82     if (c&&c->GetDetector()==sector) {
  83       if (n==1) {
  84         innerSeed->ResetCovariance(100.);
  85       }
  86       ++n;
  87       Double_t r[3]={c->GetX(),c->GetY(),c->GetZ()};
  88       Double_t cov[3]={0.1,0.,0.1};
  89       if (!innerSeed->PropagateTo(r[0])
  90           || !static_cast<AliExternalTrackParam*>(innerSeed)->Update(&r[1],cov)) {
  91         delete innerSeed;
  92         innerSeed=0;
  93         break;
  94       }
  95     }
  96   }
  97   fNClusters=TMath::Max(fNClusters,n);
  98   if (innerSeed)
  99     fInner=new AliExternalTrackParam(*outerSeed);
 100   // propagate to the primary vertex
 101   if (innerSeed) {
 102     AliTPCseed *primarySeed=new AliTPCseed(*innerSeed);
 103     Double_t pos[]={0.,0.,0.};
 104     Double_t sigma[]={.1,.1,.1}; //TODO: is this correct?
 105     AliESDVertex vertex(pos,sigma);
 106     if (primarySeed->PropagateToVertex(&vertex))
 107       fPrimary=new AliExternalTrackParam(*primarySeed);
 108     delete primarySeed;
 109   }
 110   delete innerSeed;
 111
 112   if (!fOuter&&!fInner)
 113     fNClusters=0;
 114
 115   delete t;
 116 }
 117
 118 AliTPCTracklet::AliTPCTracklet(const AliTPCTracklet &t)
 119   : fNClusters(t.fNClusters),fSector(t.fSector),fOuter(0),fInner(0),
 120     fPrimary(0) {
 121   ////
 122   // The copy constructor. You can copy tracklets!
 123   ////
 124
 125   if (t.fOuter)
 126     fOuter=new AliExternalTrackParam(*t.fOuter);
 127   if (t.fInner)
 128     fInner=new AliExternalTrackParam(*t.fInner);
 129   if (t.fPrimary)
 130     fPrimary=new AliExternalTrackParam(*t.fPrimary);
 131 }
 132
 133 AliTPCTracklet& AliTPCTracklet::operator=(const AliTPCTracklet &t) {
 134   ////
 135   // The assignment constructor. You can assign tracklets!
 136   ////
 137   fNClusters=t.fNClusters;
 138   fSector=t.fSector;
 139   if (this!=&t) {
 140     if (t.fOuter) {
 141       if (fOuter)
 142         *fOuter=*t.fOuter;
 143       else
 144         fOuter=new AliExternalTrackParam(*t.fOuter);
 145     }
 146     else {
 147       delete fOuter;
 148       fOuter=0;
 149     }
 150
 151     if (t.fInner) {
 152       if (fInner)
 153         *fInner=*t.fInner;
 154       else
 155         fInner=new AliExternalTrackParam(*t.fInner);
 156     }
 157     else {
 158       delete fInner;
 159       fInner=0;
 160     }
 161
 162     if (t.fPrimary) {
 163       if (fPrimary)
 164         *fPrimary=*t.fPrimary;
 165       else
 166         fPrimary=new AliExternalTrackParam(*t.fPrimary);
 167     }
 168     else {
 169       delete fPrimary;
 170       fPrimary=0;
 171     }
 172   }
 173   return *this;
 174 }
 175
 176 AliTPCTracklet::~AliTPCTracklet() {
 177   //
 178   // The destructor. Yes, you can even destruct tracklets.
 179   //
 180   delete fOuter;
 181   delete fInner;
 182   delete fPrimary;
 183 }
 184
 185 TObjArray AliTPCTracklet::CreateTracklets(const AliTPCseed *s,
 186                                           Int_t minClusters,
 187                                           Int_t maxTracklets) {
 188 // The tracklet factory: It creates several tracklets out of a track. They
 189 // are created for sectors that fullfill the constraint of having enough
 190 // clusters inside. Futhermore you can specify the maximum amount of
 191 // tracklets that are to be created.
 192 // The tracklets appear in a sorted fashion, beginning with those having the
 193 // most clusters.
 194
 195   Int_t sectors[72]={0};
 196   for (Int_t i=0;i<160;++i) {
 197     AliTPCclusterMI *c=s->GetClusterPointer(i);
 198     if (c)
 199       ++sectors[c->GetDetector()];
 200   }
 201   Int_t indices[72];
 202   TMath::Sort(72,sectors,indices);
 203   TObjArray tracklets;
 204   if (maxTracklets>72) maxTracklets=72; // just to protect against "users".
 205   for (Int_t i=0;i<maxTracklets&&sectors[indices[i]]>=minClusters;++i) {
 206     tracklets.Add(new AliTPCTracklet(s,indices[i]));
 207   }
 208   return tracklets;
 209 }