Line data    Source code

       1             : #include "AliAODTrdTrack.h"
       2             : 
       3             : AliAODTrdTrack::AliAODTrdTrack() :
       4           2 :   AliVTrdTrack(),
       5           2 :   fGlobalStack(-1),
       6           2 :   fPID(0),
       7           2 :   fLayerMask(0),
       8           2 :   fA(0),
       9           2 :   fFlagsTiming(0),
      10           2 :   fTracklets(),
      11           2 :   fTrackMatch(0x0),
      12           2 :   fLabel(-1)
      13          10 : {
      14             :   // default constructor
      15             : 
      16           2 :   fTracklets.SetClass("AliAODTrdTracklet", 6);
      17           4 : }
      18             : 
      19             : AliAODTrdTrack::AliAODTrdTrack(const AliVTrdTrack &rhs) :
      20        2319 :   AliVTrdTrack(rhs),
      21        6957 :   fGlobalStack(5*rhs.GetSector() + rhs.GetStack()),
      22        4638 :   fPID(rhs.GetPID()),
      23        4638 :   fLayerMask(rhs.GetLayerMask()),
      24        4638 :   fA(rhs.GetA()),
      25        4638 :   fFlagsTiming(rhs.GetFlagsTiming()),
      26        2319 :   fTracklets(),
      27        4638 :   fTrackMatch(rhs.GetTrackMatch()),
      28        4638 :   fLabel(rhs.GetLabel())
      29       11595 : {
      30             :   // constructor from abstract base class
      31             : 
      32        2319 :   fTracklets.SetClass("AliAODTrdTracklet", 6);
      33             : 
      34             :   // copy the contributing tracklets
      35       32466 :   for (Int_t iTracklet = 0; iTracklet < 6; ++iTracklet) {
      36       13914 :     const AliVTrdTracklet *trkl = rhs.GetTracklet(iTracklet);
      37       13914 :     if (trkl)
      38         219 :       new (fTracklets[iTracklet]) AliAODTrdTracklet(*trkl);
      39             :     else
      40       41523 :       new (fTracklets[iTracklet]) AliAODTrdTracklet();
      41             :   }
      42        4638 : }
      43             : 
      44             : AliAODTrdTrack::AliAODTrdTrack(const AliAODTrdTrack& rhs) :
      45           0 :   AliVTrdTrack(rhs),
      46           0 :   fGlobalStack(rhs.fGlobalStack),
      47           0 :   fPID(rhs.fPID),
      48           0 :   fLayerMask(rhs.fLayerMask),
      49           0 :   fA(rhs.fA),
      50           0 :   fFlagsTiming(rhs.fFlagsTiming),
      51           0 :   fTracklets(),
      52           0 :   fTrackMatch(rhs.fTrackMatch),
      53           0 :   fLabel(rhs.fLabel)
      54           0 : {
      55             :   // copy constructor
      56             : 
      57           0 :   fTracklets.SetClass("AliAODTrdTracklet", 6);
      58             : 
      59             :   // copy the contributing tracklets
      60           0 :   for (Int_t iTracklet = 0; iTracklet < 6; ++iTracklet) {
      61           0 :     const AliVTrdTracklet *trkl = rhs.GetTracklet(iTracklet);
      62           0 :     if (trkl)
      63           0 :       new (fTracklets[iTracklet]) AliAODTrdTracklet(*trkl);
      64             :     else
      65           0 :       new (fTracklets[iTracklet]) AliAODTrdTracklet();
      66             :   }
      67           0 : }
      68             : 
      69             : AliAODTrdTrack& AliAODTrdTrack::operator=(const AliAODTrdTrack& rhs)
      70             : {
      71             :   // assignment operator
      72             : 
      73           0 :   if (&rhs != this)
      74           0 :     AliVTrdTrack::operator=(rhs);
      75             : 
      76           0 :   fGlobalStack = rhs.fGlobalStack;
      77           0 :   fPID         = rhs.fPID;
      78           0 :   fLayerMask   = rhs.fLayerMask;
      79           0 :   fA           = rhs.fA;
      80           0 :   fFlagsTiming = rhs.fFlagsTiming;
      81           0 :   fTrackMatch  = rhs.fTrackMatch;
      82           0 :   fLabel       = rhs.fLabel;
      83             : 
      84             :   // assign the contributing tracklets
      85           0 :   for (Int_t iTracklet = 0; iTracklet < 6; ++iTracklet) {
      86           0 :     const AliVTrdTracklet *trkl = rhs.GetTracklet(iTracklet);
      87           0 :     if (trkl)
      88           0 :       new (fTracklets[iTracklet]) AliAODTrdTracklet(*trkl);
      89             :     else
      90           0 :       new (fTracklets[iTracklet]) AliAODTrdTracklet();
      91             :   }
      92             : 
      93           0 :   return *this;
      94           0 : }
      95             : 
      96             : void AliAODTrdTrack::Copy(TObject &rhs) const
      97             : {
      98             :   // copy
      99             : 
     100           0 :   AliVTrdTrack::Copy(rhs);
     101           0 : }
     102             : 
     103             : Int_t AliAODTrdTrack::GetPt() const
     104             : {
     105             :   // calculate pt from a as done in hardware
     106             : 
     107             :   const Int_t maskIdLut[64] = {
     108             :     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  0,
     109             :     -1, -1, -1, -1, -1, -1, -1,  1, -1, -1, -1,  2, -1,  3,  4,  5,
     110             :     -1, -1, -1, -1, -1, -1, -1,  6, -1, -1, -1,  7, -1,  8,  9, 10,
     111             :     -1, -1, -1, 11, -1, 12, 13, 14, -1, 15, 16, 17, 18, 19, 20, 21
     112             :   };
     113             : 
     114             :   const Int_t c1Lut[32] = {
     115             :     -2371, -2474, -2474, -2474, -2563, -2448, -2578, -2578,
     116             :     -2578, -2670, -2557, -2578, -2578, -2670, -2557, -2578,
     117             :     -2670, -2557, -2763, -2557, -2644, -2523,    -1,    -1,
     118             :     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1
     119             :   };
     120             : 
     121           0 :   if (this->GetA() != 0) {
     122           0 :     Int_t layerMaskId = maskIdLut[this->GetLayerMask()];
     123           0 :     Int_t c1 = c1Lut[layerMaskId];
     124           0 :     Int_t c1Ext = c1 << 8;
     125           0 :     Int_t ptRawStage4 = c1Ext / ((this->GetA() >> 2) != 0 ? (this->GetA() >> 2) : 1 );
     126             :     Int_t ptRawComb4 = ptRawStage4;
     127           0 :     Int_t ptExtComb4 = (ptRawComb4 > 0) ? ptRawComb4 + 33 : ptRawComb4 - 30;
     128             : 
     129           0 :     return -ptExtComb4/2;
     130             :   }
     131             :   else
     132           0 :     return 0;
     133           0 : }