TRD/AliTRDtrackGTU.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 //                                                                        //
  18 //  A GTU track                                                           //
  19 //                                                                        //
  20 //  Author: J. Klein (Jochen.Klein@cern.ch)                               //
  21 //                                                                        //
  22 ////////////////////////////////////////////////////////////////////////////
  23
  24 /* $Id: AliTRDtrackGTU.cxx 27566 2008-07-24 15:31:08Z cblume $ */
  25
  26 #include "TObject.h"
  27 #include "TObjArray.h"
  28 #include "TClass.h"
  29 #include "TMath.h"
  30 #include "TH1F.h"
  31
  32 #include "AliESDTrdTrack.h"
  33 #include "AliLog.h"
  34 #include "AliTRDgtuParam.h"
  35 #include "AliTRDtrackGTU.h"
  36 #include "AliTRDtrackletGTU.h"
  37 #include "AliTRDtrackletMCM.h"
  38 #include "AliESDTrdTrack.h"
  39
  40 ClassImp(AliTRDtrackGTU)
  41
  42 AliTRDtrackGTU::AliTRDtrackGTU() :
  43   TObject(),
  44   fStack(-1),
  45   fSector(-1),
  46   fPID(0),
  47   fTracklets(0x0),
  48   fTrackletMask(0),
  49   fNTracklets(0),
  50   fRefLayerIdx(-1),
  51   fZChannel(-1),
  52   fZSubChannel(-1),
  53   fA(0),
  54   fB(0),
  55   fC(0),
  56   fLabel(-1)
  57 {
  58 // default ctor
  59
  60   fTracklets = new TClonesArray("AliTRDtrackletGTU", 6);
  61   for (Int_t iTracklet = 0; iTracklet < 6; iTracklet++)
  62       new ((*fTracklets)[iTracklet]) AliTRDtrackletGTU();
  63 //  fTracklets->BypassStreamer(kFALSE);
  64 }
  65
  66 AliTRDtrackGTU::AliTRDtrackGTU(const AliTRDtrackGTU &rhs) :
  67   TObject(),
  68   fStack(rhs.fStack),
  69   fSector(rhs.fSector),
  70   fPID(rhs.fPID),
  71   fTracklets(0x0),
  72   fTrackletMask(rhs.fTrackletMask),
  73   fNTracklets(rhs.fNTracklets),
  74   fRefLayerIdx(rhs.fRefLayerIdx),
  75   fZChannel(rhs.fZChannel),
  76   fZSubChannel(rhs.fZSubChannel),
  77   fA(rhs.fA),
  78   fB(rhs.fB),
  79   fC(rhs.fC),
  80   fLabel(rhs.fLabel)
  81 {
  82   fTracklets = new TClonesArray("AliTRDtrackletGTU", 6);
  83   for (Int_t iTracklet = 0; iTracklet < 6; iTracklet++)
  84     new ((*fTracklets)[iTracklet]) AliTRDtrackletGTU(*((AliTRDtrackletGTU*)(*(rhs.fTracklets))[iTracklet]));
  85 }
  86
  87 AliTRDtrackGTU& AliTRDtrackGTU::operator=(const AliTRDtrackGTU &rhs)
  88 {
  89   if (&rhs != this) {
  90     TObject::operator=(rhs);
  91     fStack         = rhs.fStack;
  92     fSector        = rhs.fSector;
  93     fPID           = rhs.fPID;
  94     fTrackletMask  = rhs.fTrackletMask;
  95     fNTracklets    = rhs.fNTracklets;
  96     fRefLayerIdx   = rhs.fRefLayerIdx;
  97     fZChannel      = rhs.fZChannel;
  98     fZSubChannel   = rhs.fZSubChannel;
  99     fA             = rhs.fA;
 100     fB             = rhs.fB;
 101     fC             = rhs.fC;
 102     fLabel         = rhs.fLabel;
 103     for (Int_t iTracklet = 0; iTracklet < 6; iTracklet++)
 104       new ((*fTracklets)[iTracklet]) AliTRDtrackletGTU(*((AliTRDtrackletGTU*)(*(rhs.fTracklets))[iTracklet]));
 105   }
 106
 107   return *this;
 108 }
 109
 110 AliTRDtrackGTU& AliTRDtrackGTU::operator=(const AliESDTrdTrack &rhs)
 111 {
 112   if ((void*) &rhs != (void*) this) {
 113     TObject::operator=(rhs);
 114     fStack         = rhs.GetStack();
 115     fSector        = rhs.GetSector();
 116     fPID           = rhs.GetPID();
 117     fTrackletMask  = rhs.GetLayerMask();
 118     fNTracklets    = 0;
 119     fRefLayerIdx   = -1;
 120     fZChannel      = -1;
 121     fZSubChannel   = -1;
 122     fA             = rhs.GetA();
 123     fB             = rhs.GetB();
 124     fC             = rhs.GetC();
 125     fLabel         = rhs.GetLabel();
 126     for (Int_t iTracklet = 0; iTracklet < 6; iTracklet++) {
 127       AliTRDtrackletGTU *trkl = new ((*fTracklets)[iTracklet]) AliTRDtrackletGTU();
 128       if (fTrackletMask & (1 << iTracklet)) {
 129         ++fNTracklets;
 130         trkl->SetIndex(rhs.GetTrackletIndex(iTracklet));
 131       }
 132       else
 133         trkl->SetIndex(-1);
 134     }
 135   }
 136
 137   return *this;
 138 }
 139
 140 AliTRDtrackGTU::~AliTRDtrackGTU()
 141 {
 142 // dtor
 143
 144   fTracklets->Delete();
 145   delete fTracklets;
 146 }
 147
 148 void AliTRDtrackGTU::AddTracklet(const AliTRDtrackletGTU * const tracklet, Int_t layer)
 149 {
 150 // add a tracklet to this track
 151
 152   if ( (fTrackletMask & (1 << layer)) != 0 ) {
 153     AliError(Form("Only one tracklet per layer (%i) possible! Mask: 0x%02x", layer, fTrackletMask));
 154     return;
 155   }
 156
 157   new ((*fTracklets)[layer]) AliTRDtrackletGTU(*tracklet);
 158   fNTracklets++;
 159   fTrackletMask |= (1 << layer);
 160 }
 161
 162 AliTRDtrackletGTU* AliTRDtrackGTU::GetTracklet(Int_t layer) const
 163 {
 164 // get a pointer to the tracklet in the layer specified
 165
 166   if (IsTrackletInLayer(layer))
 167     return ((AliTRDtrackletGTU*) (*fTracklets)[layer]);
 168   else
 169     return 0x0;
 170 }
 171
 172 Int_t AliTRDtrackGTU::GetNTracklets() const
 173 {
 174 // returns the number of tracklets in this track
 175
 176   return fNTracklets;
 177 }
 178
 179 Bool_t AliTRDtrackGTU::IsTrackletInLayer(Int_t layer) const
 180 {
 181 // checks for a tracklet in the given layer
 182
 183   if ( (GetTrackletMask() & (1 << layer)) != 0)
 184     return kTRUE;
 185   else
 186     return kFALSE;
 187 }
 188
 189 void AliTRDtrackGTU::SetFitParams(Float_t a, Float_t b, Float_t c)
 190 {
 191 // set the fit parameters
 192
 193   fA = a;
 194   fB = b;
 195   fC = c;
 196 }
 197
 198 Int_t AliTRDtrackGTU::GetZSubChannel()
 199 {
 200 // returns the z-subchannel
 201
 202   if (fZSubChannel < 0) {
 203     for (Int_t layer = 0; layer < AliTRDgtuParam::GetNLayers(); layer++) {
 204       if (IsTrackletInLayer(layer)) {
 205         AliTRDtrackletGTU *trkl = (AliTRDtrackletGTU*) (*fTracklets)[layer];
 206         if (trkl) {
 207           if ((fZSubChannel > -1) &&
 208               (fZSubChannel != trkl->GetSubChannel(GetZChannel())))
 209             AliError(Form("found inconsistent z-subchannels: track = %i/%i, trkl = %i",
 210                           GetZChannel(), fZSubChannel, trkl->GetSubChannel(GetZChannel())));
 211           fZSubChannel = trkl->GetSubChannel(GetZChannel());
 212         }
 213         else {
 214           AliError("no tracklet where one should be according to layer mask");
 215         }
 216       }
 217     }
 218   }
 219   return fZSubChannel;
 220 }
 221
 222 Int_t AliTRDtrackGTU::GetYapprox()
 223 {
 224   // returns an approximated y-position for the track
 225   // taken from the projected y-position of the tracklet in the reference layer
 226   // in which the track was found
 227
 228   if ((fRefLayerIdx > -1) && (fRefLayerIdx < AliTRDgtuParam::GetNRefLayers()))
 229     return ((AliTRDtrackletGTU*) (*fTracklets)[AliTRDgtuParam::GetRefLayer(fRefLayerIdx)])->GetYProj();
 230   else
 231     return 0;
 232 }
 233
 234 AliESDTrdTrack* AliTRDtrackGTU::CreateTrdTrack() const
 235 {
 236   // creates an AliESDTrdTrack to be added to the ESD
 237
 238   AliESDTrdTrack *trk = new AliESDTrdTrack();
 239   trk->SetA((Int_t) fA);
 240   trk->SetB(TMath::Nint(128. * fB));
 241   trk->SetC(TMath::Nint(256. * fC));
 242   trk->SetLayerMask(fTrackletMask);
 243   trk->SetPID(fPID);
 244   trk->SetStack(fStack);
 245   trk->SetSector(fSector);
 246   trk->SetLabel(fLabel);
 247
 248   for (Int_t iLayer = 0; iLayer < AliTRDgtuParam::GetNLayers(); iLayer++) {
 249     AliTRDtrackletGTU *trklGTU = GetTracklet(iLayer);
 250     if (trklGTU) {
 251       trk->SetTrackletIndex(trklGTU->GetIndex(), iLayer);
 252       AliESDTrdTracklet *trkl = trklGTU->GetTrackletESD();
 253       if (trkl)
 254         trk->AddTrackletReference(trkl, iLayer);
 255     }
 256   }
 257
 258   return trk;
 259 }
 260
 261 Bool_t AliTRDtrackGTU::CookLabel()
 262 {
 263   // assign label from tracklets according to frequency
 264
 265   Int_t nLabels = 0;
 266   Int_t label[6] = { 0 };
 267   Int_t count[6] = { 0 };
 268
 269   for (Int_t iTracklet = 0; iTracklet < 6; iTracklet++) {
 270     if (!IsTrackletInLayer(iTracklet))
 271       continue;
 272
 273     Int_t currLabel = GetTracklet(iTracklet)->GetLabel();
 274
 275     Bool_t assigned = kFALSE;
 276     for (Int_t iLabel = 0; iLabel < nLabels; iLabel++) {
 277       if (currLabel == label[iLabel]) {
 278         count[iLabel]++;
 279         assigned = kTRUE;
 280         break;
 281       }
 282     }
 283
 284     if (!assigned) {
 285       label[nLabels] = currLabel;
 286       count[nLabels] = 1;
 287       nLabels++;
 288     }
 289   }
 290
 291   Int_t index[32];
 292   TMath::Sort(6, count, index);
 293   fLabel = label[index[0]];
 294
 295   return kTRUE;
 296 }