STEER/ESD/AliESDTrdTrack.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 // ESD format for the TRD tracks calculated in the
  19 // Global Tracking Unit, used for the TRD L1 trigger
  20 //
  21 // Author: Jochen Klein <jochen.klein@cern.ch>
  22 //
  23 ///////////////////////////////////////////////////////////////////////////////
  24
  25 #include "TMath.h"
  26
  27 #include "AliESDTrdTrack.h"
  28 #include "AliESDTrdTracklet.h"
  29
  30 ClassImp(AliESDTrdTrack)
  31
  32 //_____________________________________________________________________________
  33 AliESDTrdTrack::AliESDTrdTrack():
  34   AliVTrdTrack(),
  35   fSector(-1),
  36   fStack(-1),
  37   fA(0),
  38   fB(0),
  39   fC(0),
  40   fY(0),
  41   fPID(0),
  42   fLayerMask(0),
  43   fFlags(0),
  44   fFlagsTiming(0),
  45   fReserved(0),
  46   fTrackMatch(),
  47   fLabel(-1)
  48 {
  49   //
  50   // Default constructor
  51   for (int i=fgkNlayers;i--;) fTrackletIndex[i] = 0;
  52   //
  53
  54 }
  55
  56 AliESDTrdTrack::AliESDTrdTrack(const AliESDTrdTrack& track):
  57   AliVTrdTrack(track),
  58   fSector(track.fSector),
  59   fStack(track.fStack),
  60   fA(track.fA),
  61   fB(track.fB),
  62   fC(track.fC),
  63   fY(track.fY),
  64   fPID(track.fPID),
  65   fLayerMask(track.fLayerMask),
  66   fFlags(track.fFlags),
  67   fFlagsTiming(track.fFlagsTiming),
  68   fReserved(track.fReserved),
  69   fTrackMatch(track.fTrackMatch),
  70   fLabel(track.fLabel)
  71 {
  72   //
  73   // Copy contructor
  74   //
  75
  76   for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
  77     fTrackletIndex[iLayer] = track.fTrackletIndex[iLayer];
  78
  79     if (track.fTrackletRefs[iLayer].GetObject())
  80       fTrackletRefs[iLayer] = track.fTrackletRefs[iLayer];
  81   }
  82 }
  83
  84 AliESDTrdTrack& AliESDTrdTrack::operator=(const AliESDTrdTrack& track)
  85 {
  86   //
  87   // assignment operator
  88   //
  89
  90   if (this == &track)
  91     return *this;
  92   AliVTrdTrack::operator=(track);
  93   fSector       = track.fSector;
  94   fStack        = track.fStack;
  95   fA            = track.fA;
  96   fB            = track.fB;
  97   fC            = track.fC;
  98   fPID          = track.fPID;
  99   fLayerMask    = track.fLayerMask;
 100   fFlags        = track.fFlags;
 101   fFlagsTiming  = track.fFlagsTiming;
 102   fReserved     = track.fReserved;
 103   fTrackMatch   = track.fTrackMatch;
 104   fLabel        = track.fLabel;
 105   for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
 106     fTrackletIndex[iLayer] = track.fTrackletIndex[iLayer];
 107     fTrackletRefs[iLayer] = track.fTrackletRefs[iLayer];
 108   }
 109
 110   return *this;
 111 }
 112
 113 void AliESDTrdTrack::Copy(TObject& obj) const
 114 {
 115   // this overwrites the virtual TOBject::Copy()
 116   // to allow run time copying without casting
 117   // in AliESDEvent
 118
 119   if(this==&obj)return;
 120   AliESDTrdTrack *robj = dynamic_cast<AliESDTrdTrack*>(&obj);
 121   if(!robj)return; // not an aliesdtrdtrack
 122   *robj = *this;
 123 }
 124
 125 ULong64_t AliESDTrdTrack::GetTrackWord(Int_t /* rev */) const
 126 {
 127   // return track word representation as in raw data
 128   // MSB always 1
 129
 130   ULong64_t trackWord = 1;
 131   AppendBits(trackWord,   1, 0);
 132   AppendBits(trackWord,   6, fLayerMask);
 133   AppendBits(trackWord,  18, fA);
 134   AppendBits(trackWord,  18, fB);
 135   AppendBits(trackWord,  12, fC);
 136   AppendBits(trackWord,   8, fPID);
 137   return trackWord;
 138 }
 139
 140 ULong64_t AliESDTrdTrack::GetExtendedTrackWord(Int_t /* rev */) const
 141 {
 142   // return extended track word representation as in raw data
 143   // MSB always 0
 144
 145   ULong64_t trackWord = 0;
 146   AppendBits(trackWord,  11, fFlags);
 147   AppendBits(trackWord,  1, fFlagsTiming);
 148   AppendBits(trackWord,  2, fReserved);
 149   AppendBits(trackWord, 13, fY);
 150   AppendBits(trackWord,  6, fTrackletIndex[5]);
 151   AppendBits(trackWord,  6, fTrackletIndex[4]);
 152   AppendBits(trackWord,  6, fTrackletIndex[3]);
 153   AppendBits(trackWord,  6, fTrackletIndex[2]);
 154   AppendBits(trackWord,  6, fTrackletIndex[1]);
 155   AppendBits(trackWord,  6, fTrackletIndex[0]);
 156   return trackWord;
 157 }
 158
 159 Int_t AliESDTrdTrack::GetPt() const
 160 {
 161   // calculate pt from a as done in hardware
 162
 163   const Int_t maskIdLut[64] = {
 164     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  0,
 165     -1, -1, -1, -1, -1, -1, -1,  1, -1, -1, -1,  2, -1,  3,  4,  5,
 166     -1, -1, -1, -1, -1, -1, -1,  6, -1, -1, -1,  7, -1,  8,  9, 10,
 167     -1, -1, -1, 11, -1, 12, 13, 14, -1, 15, 16, 17, 18, 19, 20, 21
 168   };
 169
 170   const Int_t c1Lut[32] = {
 171     -2371, -2474, -2474, -2474, -2563, -2448, -2578, -2578,
 172     -2578, -2670, -2557, -2578, -2578, -2670, -2557, -2578,
 173     -2670, -2557, -2763, -2557, -2644, -2523,    -1,    -1,
 174     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1
 175   };
 176
 177   if (this->GetA() != 0) {
 178     Int_t layerMaskId = maskIdLut[this->GetLayerMask()];
 179     Int_t c1 = c1Lut[layerMaskId];
 180     Int_t c1Ext = c1 << 8;
 181     Int_t ptRawStage4 = c1Ext / ((this->GetA() >> 2) != 0 ? (this->GetA() >> 2) : 1 );
 182     Int_t ptRawComb4 = ptRawStage4;
 183     Int_t ptExtComb4 = (ptRawComb4 > 0) ? ptRawComb4 + 33 : ptRawComb4 - 30;
 184
 185     return -ptExtComb4/2;
 186   }
 187   else
 188     return 0;
 189 }
 190
 191 Int_t AliESDTrdTrack::Compare(const TObject* obj) const
 192 {
 193   if (this == obj)
 194     return 0;
 195   else if (TMath::Abs(Pt()) < TMath::Abs(((AliESDTrdTrack*)(obj))->Pt()))
 196     return 1;
 197   else
 198     return -1;
 199 }