Adding TRD online tracks and trackets to ESD:
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 5 Jul 2011 10:36:50 +0000 (10:36 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 5 Jul 2011 10:36:50 +0000 (10:36 +0000)
- New AliESDTrdTracklet class
- Modifications in AliESDTrdTrack

Jochen

STEER/AliESDEvent.cxx
STEER/AliESDEvent.h
STEER/AliESDTrdTrack.cxx
STEER/AliESDTrdTrack.h
STEER/AliESDTrdTracklet.cxx [new file with mode: 0644]
STEER/AliESDTrdTracklet.h [new file with mode: 0644]
STEER/CMakelibESD.pkg
STEER/ESDLinkDef.h
TRD/AliTRDtrackGTU.cxx

index 83bdaef..fb10335 100644 (file)
@@ -50,6 +50,7 @@
 #include "AliESDcascade.h"
 #include "AliESDPmdTrack.h"
 #include "AliESDTrdTrack.h"
+#include "AliESDTrdTracklet.h"
 #include "AliESDVertex.h"
 #include "AliVertexerTracks.h"
 #include "AliESDcascade.h"
@@ -93,6 +94,7 @@ ClassImp(AliESDEvent)
                                                        "MuonTracks",
                                                        "PmdTracks",
                                                        "TrdTracks",
+                                                       "TrdTracklets",
                                                        "V0s",
                                                        "Cascades",
                                                        "Kinks",
@@ -126,6 +128,7 @@ AliESDEvent::AliESDEvent():
   fMuonTracks(0),
   fPmdTracks(0),
   fTrdTracks(0),
+  fTrdTracklets(0),
   fV0s(0),  
   fCascades(0),
   fKinks(0),
@@ -164,6 +167,7 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd):
   fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
   fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
   fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
+  fTrdTracklets(new TClonesArray(*esd.fTrdTracklets)),
   fV0s(new TClonesArray(*esd.fV0s)),  
   fCascades(new TClonesArray(*esd.fCascades)),
   fKinks(new TClonesArray(*esd.fKinks)),
@@ -198,6 +202,7 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd):
   AddObject(fMuonTracks);
   AddObject(fPmdTracks);
   AddObject(fTrdTracks);
+  AddObject(fTrdTracklets);
   AddObject(fV0s);
   AddObject(fCascades);
   AddObject(fKinks);
@@ -455,6 +460,7 @@ void AliESDEvent::ResetStdContent()
   if(fMuonTracks)fMuonTracks->Delete();
   if(fPmdTracks)fPmdTracks->Delete();
   if(fTrdTracks)fTrdTracks->Delete();
+  if(fTrdTracklets)fTrdTracklets->Delete();
   if(fV0s)fV0s->Delete();
   if(fCascades)fCascades->Delete();
   if(fKinks)fKinks->Delete();
@@ -512,6 +518,7 @@ void AliESDEvent::Print(Option_t *) const
   printf("                 muon      %d\n", GetNumberOfMuonTracks());
   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
   printf("                 trd       %d\n", GetNumberOfTrdTracks());
+  printf("                 trd trkl  %d\n", GetNumberOfTrdTracklets());
   printf("                 v0        %d\n", GetNumberOfV0s());
   printf("                 cascades  %d\n", GetNumberOfCascades());
   printf("                 kinks     %d\n", GetNumberOfKinks());
@@ -941,8 +948,10 @@ void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t)
   new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
 }
 
-
-
+void AliESDEvent::AddTrdTracklet(const AliESDTrdTracklet *trkl)
+{
+  new ((*fTrdTracklets)[fTrdTracklets->GetEntriesFast()]) AliESDTrdTracklet(*trkl);
+}
 
 Int_t AliESDEvent::AddKink(const AliESDkink *c) 
 {
@@ -1141,6 +1150,7 @@ void AliESDEvent::GetStdContent()
   fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]);
   fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]);
   fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]);
+  fTrdTracklets = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracklets]);
   fV0s = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kV0s]);
   fCascades = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCascades]);
   fKinks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kKinks]);
@@ -1200,6 +1210,7 @@ void AliESDEvent::CreateStdContent()
   AddObject(new TClonesArray("AliESDMuonTrack",0));
   AddObject(new TClonesArray("AliESDPmdTrack",0));
   AddObject(new TClonesArray("AliESDTrdTrack",0));
+  AddObject(new TClonesArray("AliESDTrdTracklet",0));
   AddObject(new TClonesArray("AliESDv0",0));
   AddObject(new TClonesArray("AliESDcascade",0));
   AddObject(new TClonesArray("AliESDkink",0));
index 7960ec5..62d323a 100644 (file)
@@ -54,6 +54,7 @@ class AliMultiplicity;
 class AliRawDataErrorLog;
 class AliESDRun;
 class AliESDTrdTrack;
+class AliESDTrdTracklet;
 class AliESDMuonTrack;
 class AliESD;
 class AliESDcascade;
@@ -89,6 +90,7 @@ public:
                       kMuonTracks,
                       kPmdTracks,
                       kTrdTracks,
+                      kTrdTracklets,
                       kV0s,
                       kCascades,
                       kKinks,
@@ -342,6 +344,12 @@ public:
   
   void AddTrdTrack(const AliESDTrdTrack *t);
 
+  AliESDTrdTracklet* GetTrdTracklet(Int_t idx) const {
+    return (AliESDTrdTracklet*)(fTrdTracklets?fTrdTracklets->UncheckedAt(idx):0x0);
+  }
+
+  void AddTrdTracklet(const AliESDTrdTracklet *trkl);
+
   AliESDv0 *GetV0(Int_t i) const {
     return (AliESDv0*)(fV0s?fV0s->UncheckedAt(i):0x0);
   }
@@ -396,6 +404,7 @@ public:
   Int_t GetNumberOfMuonTracks() const {return fMuonTracks?fMuonTracks->GetEntriesFast():0;}
   Int_t GetNumberOfPmdTracks() const {return fPmdTracks?fPmdTracks->GetEntriesFast():0;}
   Int_t GetNumberOfTrdTracks() const {return fTrdTracks?fTrdTracks->GetEntriesFast():0;}
+  Int_t GetNumberOfTrdTracklets() const {return fTrdTracklets?fTrdTracklets->GetEntriesFast():0;}
   Int_t GetNumberOfV0s()      const {return fV0s?fV0s->GetEntriesFast():0;}
   Int_t GetNumberOfCascades() const {return fCascades?fCascades->GetEntriesFast():0;}
   Int_t GetNumberOfKinks() const {return fKinks?fKinks->GetEntriesFast():0;}
@@ -459,6 +468,7 @@ protected:
   TClonesArray *fMuonTracks;       //! MUON ESD tracks
   TClonesArray *fPmdTracks;        //! PMD ESD tracks
   TClonesArray *fTrdTracks;        //! TRD ESD tracks (triggered)
+  TClonesArray *fTrdTracklets;     //! TRD tracklets (for trigger)
   TClonesArray *fV0s;              //! V0 vertices
   TClonesArray *fCascades;         //! Cascade vertices
   TClonesArray *fKinks;            //! Kinks
index 365368c..0edae0f 100644 (file)
 
 ///////////////////////////////////////////////////////////////////////////////
 //
-//  Tracks from the TRD Global Tracking Unit (GTU, trigger)
-//  The TRD trigger stores the found tracks 
-//  as ESDTrdTrack objects in the ESD object
-//  Related classes: AliTRDReconstructor, AliESD
-//  Author: B.Vulpescu
+// ESD format for the TRD tracks calculated in the
+// Global Tracking Unit, used for the TRD L1 trigger
+//
+// Author: Jochen Klein <jochen.klein@cern.ch>
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliESDTrdTrack.h"
+#include "AliESDTrdTracklet.h"
 
 ClassImp(AliESDTrdTrack)
 
 //_____________________________________________________________________________
 AliESDTrdTrack::AliESDTrdTrack():
   TObject(),
-  fYproj(0),
-  fZproj(0),
-  fSlope(0),
-  fPt(0),
-  fPhi(0),
-  fEta(0),
+  fSector(-1),
+  fStack(-1),
+  fA(0),
+  fB(0),
+  fC(0),
+  fY(0),
   fPID(0),
-  fLabel(0),
-  fNtracklets(0),
-  fNclusters(0),
-  fNplanes(0),
-  fDetector(0)
+  fLayerMask(0),
+  fFlags(0),
+  fReserved(0),
+  fLabel(-1)
 {
-
   //
   // Default constructor
   //
 
 }
 
-//_____________________________________________________________________________
 AliESDTrdTrack::AliESDTrdTrack(const AliESDTrdTrack& track):
   TObject(track),
-  fYproj(track.fYproj),
-  fZproj(track.fZproj),
-  fSlope(track.fSlope),
-  fPt(track.fPt),
-  fPhi(track.fPhi),
-  fEta(track.fEta),
+  fSector(track.fSector),
+  fStack(track.fStack),
+  fA(track.fA),
+  fB(track.fB),
+  fC(track.fC),
+  fY(track.fY),
   fPID(track.fPID),
-  fLabel(track.fLabel),
-  fNtracklets(track.fNtracklets),
-  fNclusters(track.fNclusters),
-  fNplanes(track.fNplanes),
-  fDetector(track.fDetector)
+  fLayerMask(track.fLayerMask),
+  fFlags(track.fFlags),
+  fReserved(track.fReserved),
+  fLabel(track.fLabel)
 {
-
   //
   // Copy contructor
   //
 
+  for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
+    fTrackletIndex[iLayer] = track.fTrackletIndex[iLayer];
+
+    if (track.fTrackletRefs[iLayer].GetObject())
+      fTrackletRefs[iLayer] = track.fTrackletRefs[iLayer];
+  }
 }
 
-//_____________________________________________________________________________
 AliESDTrdTrack& AliESDTrdTrack::operator=(const AliESDTrdTrack& track)
 {
-  // 
-  // Equal operator
+  //
+  // assignment operator
   //
 
   if (this == &track)
     return *this;
   TObject::operator=(track);
-  fYproj      = track.fYproj;
-  fZproj      = track.fZproj;
-  fSlope      = track.fSlope;
-  fPt         = track.fPt;
-  fPhi        = track.fPhi;
-  fEta        = track.fEta;
-  fPID        = track.fPID;
-  fLabel      = track.fLabel;
-  fNtracklets = track.fNtracklets;
-  fNclusters  = track.fNclusters;
-  fDetector   = track.fDetector;
-  fNplanes    = track.fNplanes;
+  fLabel        = track.fLabel;
+  fSector       = track.fSector;
+  for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
+    fTrackletIndex[iLayer] = track.fTrackletIndex[iLayer];
+    fTrackletRefs[iLayer] = track.fTrackletRefs[iLayer];
+  }
 
   return *this;
-
 }
 
-void AliESDTrdTrack::Copy(TObject& obj) const {
-
-   // this overwrites the virtual TOBject::Copy()
+void AliESDTrdTrack::Copy(TObject& obj) const
+{
+  // this overwrites the virtual TOBject::Copy()
   // to allow run time copying without casting
   // in AliESDEvent
 
   if(this==&obj)return;
   AliESDTrdTrack *robj = dynamic_cast<AliESDTrdTrack*>(&obj);
-  if(!robj)return; // not an aliesesdtrdtrack
+  if(!robj)return; // not an aliesdtrdtrack
   *robj = *this;
 }
+
+ULong64_t AliESDTrdTrack::GetTrackWord(Int_t /* rev */) const
+{
+  // return track word representation as in raw data
+  // MSB always 1
+
+  ULong64_t trackWord = 1;
+  AppendBits(trackWord,   1, 0);
+  AppendBits(trackWord,   6, fLayerMask);
+  AppendBits(trackWord,  18, fA);
+  AppendBits(trackWord,  18, fB);
+  AppendBits(trackWord,  12, fC);
+  AppendBits(trackWord,   8, fPID);
+  return trackWord;
+}
+
+ULong64_t AliESDTrdTrack::GetExtendedTrackWord(Int_t /* rev */) const
+{
+  // return extended track word representation as in raw data
+  // MSB always 0
+
+  ULong64_t trackWord = 0;
+  AppendBits(trackWord,  11, fFlags);
+  AppendBits(trackWord,  3, fReserved);
+  AppendBits(trackWord, 13, fY);
+  AppendBits(trackWord,  6, fTrackletIndex[5]);
+  AppendBits(trackWord,  6, fTrackletIndex[4]);
+  AppendBits(trackWord,  6, fTrackletIndex[3]);
+  AppendBits(trackWord,  6, fTrackletIndex[2]);
+  AppendBits(trackWord,  6, fTrackletIndex[1]);
+  AppendBits(trackWord,  6, fTrackletIndex[0]);
+  return trackWord;
+}
+
+Int_t AliESDTrdTrack::GetPt() const
+{
+  // calculate pt from a as done in hardware
+
+  const Int_t maskIdLut[64] = {
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  0,
+    -1, -1, -1, -1, -1, -1, -1,  1, -1, -1, -1,  2, -1,  3,  4,  5,
+    -1, -1, -1, -1, -1, -1, -1,  6, -1, -1, -1,  7, -1,  8,  9, 10,
+    -1, -1, -1, 11, -1, 12, 13, 14, -1, 15, 16, 17, 18, 19, 20, 21
+  };
+
+  const Int_t c1Lut[32] = {
+    -2371, -2474, -2474, -2474, -2563, -2448, -2578, -2578,
+    -2578, -2670, -2557, -2578, -2578, -2670, -2557, -2578,
+    -2670, -2557, -2763, -2557, -2644, -2523,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1
+  };
+
+  if (this->GetA() != 0) {
+    Int_t layerMaskId = maskIdLut[this->GetLayerMask()];
+    Int_t c1 = c1Lut[layerMaskId];
+    Int_t c1Ext = c1 << 8;
+    Int_t ptRawStage4 = c1Ext / (this->GetA() >> 2);
+    Int_t ptRawComb4 = ptRawStage4;
+    Int_t ptExtComb4 = (ptRawComb4 > 0) ? ptRawComb4 + 33 : ptRawComb4 - 30;
+
+    return -ptExtComb4/2;
+  }
+  else
+    return 0;
+}
index 23c7e08..0215ef2 100644 (file)
@@ -1,67 +1,88 @@
 #ifndef ALIESDTRDTRACK_H
 #define ALIESDTRDTRACK_H
 
-//  Tracks from the TRD Global Tracking Unit (GTU, trigger)
-//  Stored in the ESD object
-//  Author: B.Vulpescu
+//
+// ESD format for the TRD tracks calculated in the
+// Global Tracking Unit, used for the TRD L1 trigger
+// Author: Jochen Klein <jochen.klein@cern.ch>
+
 
 #include "TObject.h"
+#include "TRef.h"
+
+#include "AliESDTrdTracklet.h"
 
 class AliESDTrdTrack : public TObject {
 
  public:
 
   AliESDTrdTrack();
-  virtual ~AliESDTrdTrack(){};
+  virtual ~AliESDTrdTrack() {};
   AliESDTrdTrack(const AliESDTrdTrack& track);
   AliESDTrdTrack& operator=(const AliESDTrdTrack& track);
   virtual void Copy(TObject &obj) const;
 
-  Double_t GetYproj()     const { return fYproj; };
-  Double_t GetZproj()     const { return fZproj; };
-  Double_t GetSlope()     const { return fSlope; };
-  Char_t   GetDetector()  const { return fDetector; };
-  Short_t   GetTracklets() const { return fNtracklets; };
-  Char_t   GetPlanes()    const { return fNplanes; };
-  Short_t   GetClusters()  const { return fNclusters; };
-  Double_t GetPt()        const { return fPt; };
-  Double_t GetPhi()       const { return fPhi; };
-  Double_t GetEta()       const { return fEta; };
-  Int_t   GetLabel()     const { return fLabel; };
-  Double_t GetPID()       const { return fPID; };
-
-  void SetYproj(Float_t val)     { fYproj = val; };
-  void SetZproj(Float_t val)     { fZproj = val; };
-  void SetSlope(Float_t val)     { fSlope = val; };
-  void SetDetector(Int_t det)    { fDetector = det; };
-  void SetTracklets(Int_t val)   { fNtracklets = val; };
-  void SetPlanes(Int_t val)      { fNplanes = val; };
-  void SetClusters(Int_t val)    { fNclusters = val; };
-  void SetPt(Float_t val)        { fPt = val; };
-  void SetPhi(Float_t val)       { fPhi = val; };
-  void SetEta(Float_t val)       { fEta = val; };
-  void SetLabel(Int_t val)       { fLabel = val; };
-  void SetPID(Float_t val)       { fPID = val; };
+  ULong64_t GetTrackWord(Int_t rev) const;
+  ULong64_t GetExtendedTrackWord(Int_t rev) const;
+
+  Int_t GetA()         const { return fA; }
+  Int_t GetB()         const { return fB; }
+  Int_t GetC()         const { return fC; }
+  Int_t GetY()         const { return fY; }
+  Int_t GetLayerMask() const { return fLayerMask; }
+  Int_t GetPID()       const { return fPID; }
+  Int_t GetPt()        const;
+  Int_t GetStack()     const { return fStack; }
+  Int_t GetSector()    const { return fSector; }
+  Int_t GetLabel()     const { return fLabel; }
+  Int_t GetTrackletIndex(const Int_t iLayer) const { return fTrackletIndex[iLayer]; }
+
+  Double_t Pt()        const { return GetPt() / 128.; }
+  Double_t Phi()       const { return 0.; };
+  Double_t Eta()       const { return 0.; };
+
+  AliESDTrdTracklet* GetTracklet(Int_t idx) const
+    { return (GetLayerMask() & (1<<idx)) ? (AliESDTrdTracklet*) ((fTrackletRefs[idx]).GetObject()) : 0x0; }
+
+  void SetA(Int_t a)            { fA = a; }
+  void SetB(Int_t b)            { fB = b; }
+  void SetC(Int_t c)            { fC = c; }
+  void SetY(Int_t y)            { fY = y; }
+  void SetLayerMask(Int_t mask) { fLayerMask = mask; }
+  void SetPID(Int_t pid)        { fPID = pid; }
+  void SetLabel(Int_t label)    { fLabel = label; }
+  void SetSector(Int_t sector)  { fSector = sector; }
+  void SetStack(Int_t stack)    { fStack = stack; }
+  void SetFlags(Int_t flags)    { fFlags = flags; }
+  void SetReserved(Int_t res)   { fReserved = res; }
+  void SetTrackletIndex(const Char_t idx, const Int_t layer) { fTrackletIndex[layer] = idx; }
+
+  void AddTrackletReference(AliESDTrdTracklet* trkl, Int_t layer) { fTrackletRefs[layer] = trkl; }
 
  protected:
 
-  Double32_t fYproj;                                   // Average values calculated
-  Double32_t fZproj;                                   // from the tracklets 
-  Double32_t fSlope;                                   // slope of the tracklet
-  Double32_t fPt;                                      // Transverse momentum
-  Double32_t fPhi;                                     //  Phi angle at the vertex
-  Double32_t fEta;                                     // Eta at the vertex
-  Double32_t fPID;                                     //[0.,1.,8] PID electron likelihood
+  void AppendBits(ULong64_t &word, Int_t nBits, Int_t val) const { word = (word << nBits) | (val & ~(~0 << nBits)); }
+
+  static const Int_t fgkNlayers = 6;      // number of TRD layers
 
-  Int_t fLabel;                                        // Track label
-  Short_t   fNtracklets;                               // Number of tracklets
-  Short_t   fNclusters;                                // Total number of clusters
-  Char_t   fNplanes;                                  // Number of TRD planes
-  Char_t   fDetector;                                 // First detector in the module
+  Int_t    fSector;                      // sector in which the track was found
+  Char_t   fStack;                       // stack in which the track was found
+                                         // (unique because of stack-wise tracking)
+  Int_t    fA;                           // transverse offset from nominal primary vertex
+  Int_t    fB;                           // slope in transverse plane
+  Short_t  fC;                           // slope in r-z plane
+  Short_t  fY;                           // y position of the track
+  UChar_t  fPID;                         // electron PID for this track
+  Char_t   fLayerMask;                   // mask of contributing tracklets
+  Char_t   fTrackletIndex[fgkNlayers];   //[fgkNlayers] index to tracklets
+  UShort_t fFlags;                       // flags (high-pt, electron, positron)
+  UChar_t  fReserved;                    // reserved for future use
 
+  TRef fTrackletRefs[fgkNlayers];         // references to contributing tracklets
 
-  ClassDef(AliESDTrdTrack,2)
+  Int_t fLabel;                                  // Track label
 
+  ClassDef(AliESDTrdTrack,4)
 };
 
 #endif
diff --git a/STEER/AliESDTrdTracklet.cxx b/STEER/AliESDTrdTracklet.cxx
new file mode 100644 (file)
index 0000000..ef34147
--- /dev/null
@@ -0,0 +1,111 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// ESD format for TRD tracklet from FEE used for triggering
+//
+// Author: Jochen Klein <jochen.klein@cern.ch>
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliESDTrdTracklet.h"
+
+ClassImp(AliESDTrdTracklet)
+
+const Float_t AliESDTrdTracklet::fgkBinWidthY   = 160e-4; // 160 um
+const Float_t AliESDTrdTracklet::fgkBinWidthDy  = 140e-4; // 140 um
+const Float_t AliESDTrdTracklet::fgkX0          = 2.21;
+const Float_t AliESDTrdTracklet::fgkDriftLength = 3.;
+
+AliESDTrdTracklet::AliESDTrdTracklet() :
+  TObject(),
+  fHCId(-1),
+  fTrackletWord(0),
+  fLabel(-1)
+{
+  // default ctor
+
+}
+
+AliESDTrdTracklet::AliESDTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label) :
+  TObject(),
+  fHCId(hcid),
+  fTrackletWord(trackletWord),
+  fLabel(label)
+{
+  // ctor with given tracklet word (and label)
+}
+
+AliESDTrdTracklet::~AliESDTrdTracklet()
+{
+  // dtor
+}
+
+AliESDTrdTracklet::AliESDTrdTracklet(const AliESDTrdTracklet &trkl) :
+  TObject(trkl),
+  fHCId(trkl.fHCId),
+  fTrackletWord(trkl.fTrackletWord),
+  fLabel(trkl.fLabel)
+{
+  // copy ctor
+
+}
+
+AliESDTrdTracklet& AliESDTrdTracklet::operator=(const AliESDTrdTracklet &trkl)
+{
+  // assignment operator
+
+  if (this == &trkl)
+    return *this;
+
+  TObject::operator=(trkl);
+  fHCId = trkl.fHCId;
+  fTrackletWord = trkl.fTrackletWord;
+  fLabel = trkl.fLabel;
+
+  return *this;
+}
+
+Int_t AliESDTrdTracklet::GetBinY() const
+{
+  // returns (signed) value of Y
+
+  if (fTrackletWord & 0x1000) {
+    return -((~(fTrackletWord-1)) & 0x1fff);
+  }
+  else {
+    return (fTrackletWord & 0x1fff);
+  }
+}
+
+Int_t AliESDTrdTracklet::GetBinDy() const
+{
+  // returns (signed) value of the deflection length
+
+  if (fTrackletWord & (1 << 19)) {
+    return -((~((fTrackletWord >> 13) - 1)) & 0x7f);
+  }
+  else {
+    return ((fTrackletWord >> 13) & 0x7f);
+  }
+}
+
+Float_t AliESDTrdTracklet::GetDyDx() const
+{
+  // returns the deflection over 3 cm drift length
+
+  return GetBinDy() * fgkBinWidthDy/fgkDriftLength;
+}
diff --git a/STEER/AliESDTrdTracklet.h b/STEER/AliESDTrdTracklet.h
new file mode 100644 (file)
index 0000000..a29da8a
--- /dev/null
@@ -0,0 +1,60 @@
+#ifndef ALIESDTRDTRACKLET_H
+#define ALIESDTRDTRACKLET_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+// ESD format for TRD tracklet from FEE used for triggering
+
+#include "TObject.h"
+
+class AliESDTrdTracklet : public TObject
+{
+ public:
+  AliESDTrdTracklet();
+  AliESDTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label = -1);
+  AliESDTrdTracklet(const AliESDTrdTracklet &trkl);
+  AliESDTrdTracklet& operator=(const AliESDTrdTracklet &trkl);
+  ~AliESDTrdTracklet();
+
+  void SetTrackletWord(UInt_t trklWord) { fTrackletWord = trklWord; }
+  void SetHCId(Short_t hcid) { fHCId = hcid; }
+
+  // ----- tracklet information -----
+  UInt_t GetTrackletWord() const { return fTrackletWord; }
+  Int_t  GetBinY()  const;
+  Int_t  GetBinDy() const;
+  Int_t  GetBinZ()  const { return ((fTrackletWord >> 20) & 0xf);  }
+  Int_t  GetPID()   const { return ((fTrackletWord >> 24) & 0xff); }
+
+  // ----- position information (chamber-local) -----
+  Float_t GetLocalX() const { return fgkX0; }
+  Float_t GetLocalY() const { return GetBinY() * fgkBinWidthY; }
+  Float_t GetDyDx() const;
+
+  // ----- geometrical information -----
+  Int_t GetHCId() const { return fHCId; }
+  Int_t GetDetector() const { return fHCId / 2; }
+  Int_t GetROB() const { return -1; }
+  Int_t GetMCM() const { return -1; }
+
+  // ----- MC information -----
+  Int_t GetLabel() const { return fLabel; }
+
+ protected:
+  Short_t fHCId;               // half-chamber ID
+
+  UInt_t fTrackletWord;                // tracklet word (as from FEE)
+                               // pppp : pppp : zzzz : dddd : dddy : yyyy : yyyy : yyyy
+  Int_t  fLabel;               // MC label
+
+  static const Float_t fgkBinWidthY;   // bin width y-position
+  static const Float_t fgkBinWidthDy;  // bin width deflection length
+
+  static const Float_t fgkX0;          // reference position in x-direction
+  static const Float_t fgkDriftLength; // drift length to which the deflection length is scaled
+
+  ClassDef(AliESDTrdTracklet, 1);
+};
+
+#endif
index a5346e9..907cef7 100644 (file)
@@ -11,6 +11,7 @@ set ( SRCS
     AliESDMuonTrack.cxx 
     AliESDPmdTrack.cxx 
     AliESDTrdTrack.cxx 
+    AliESDTrdTracklet.cxx 
     AliESDHLTtrack.cxx 
     AliESDv0.cxx 
     AliESDcascade.cxx 
index 878e328..35686e3 100644 (file)
@@ -39,6 +39,7 @@
 #pragma link C++ class  AliESDMuonTrack+;
 #pragma link C++ class  AliESDPmdTrack+;
 #pragma link C++ class  AliESDTrdTrack+;
+#pragma link C++ class  AliESDTrdTracklet+;
 #pragma link C++ class  AliESDHLTtrack+;
 #pragma link C++ class  AliESDv0+;
 #pragma link C++ class  AliESDcascade+;
index ca5ee78..52e7d69 100644 (file)
@@ -152,12 +152,10 @@ AliESDTrdTrack* AliTRDtrackGTU::CreateTrdTrack() const
 // creates an AliESDTrdTrack to be added to the ESD
 
     AliESDTrdTrack *trk = new AliESDTrdTrack();
-    trk->SetPt(1./128. * fPt);
     trk->SetPID(fPID);
-    trk->SetDetector((Char_t) (fSector * 5 + fStack));
     if (fLabel >= 0)
        trk->SetLabel(fLabel);
-    AliInfo(Form("setting detector to: %i (sector: %i, stack: %i), readback: %i", fSector * 30 + fStack * 6, fSector, fStack, trk->GetDetector()));
+
     return trk;
 }