#include "AliAODHeader.h"
#include "AliAODTrack.h"
#include "AliAODDimuon.h"
+#include "AliAODTrdTrack.h"
ClassImp(AliAODEvent)
"AliAODTZERO",
"AliAODVZERO",
"AliAODZDC",
- "AliTOFHeader"
+ "AliTOFHeader",
+ "trdTracks"
#ifdef MFT_UPGRADE
,"AliAODMFT"
#endif
fAODTZERO(0),
fAODVZERO(0),
fAODZDC(0),
- fTOFHeader(0)
+ fTOFHeader(0),
+ fTrdTracks(0)
#ifdef MFT_UPGRADE
,fAODMFT(0)
#endif
fAODTZERO(new AliAODTZERO(*aod.fAODTZERO)),
fAODVZERO(new AliAODVZERO(*aod.fAODVZERO)),
fAODZDC(new AliAODZDC(*aod.fAODZDC)),
- fTOFHeader(new AliTOFHeader(*aod.fTOFHeader))
+ fTOFHeader(new AliTOFHeader(*aod.fTOFHeader)),
+ fTrdTracks(new TClonesArray(*aod.fTrdTracks))
#ifdef MFT_UPGRADE
,fAODMFT(new AliAODMFT(*aod.fAODMFT))
#endif
AddObject(fAODVZERO);
AddObject(fAODZDC);
AddObject(fTOFHeader);
+ AddObject(fTrdTracks);
#ifdef MFT_UPGRADE
AddObject(fAODVZERO);
#endif
AddObject(new AliAODVZERO());
AddObject(new AliAODZDC());
AddObject(new AliTOFHeader());
+ AddObject(new TClonesArray("AliAODTrdTrack", 0));
#ifdef MFT_UPGRADE
AddObject(new AliAODMFT());
#endif
fAODVZERO = (AliAODVZERO*)fAODObjects->FindObject("AliAODVZERO");
fAODZDC = (AliAODZDC*)fAODObjects->FindObject("AliAODZDC");
fTOFHeader = (AliTOFHeader*)fAODObjects->FindObject("AliTOFHeader");
+ fTrdTracks = (TClonesArray*)fAODObjects->FindObject("trdTracks");
#ifdef MFT_UPGRADE
fAODMFT = (AliAODMFT*)fAODObjects->FindObject("AliAODMFT");
#endif
Int_t fmdClusSize,
Int_t pmdClusSize,
Int_t hmpidRingsSize,
- Int_t dimuonArrSize
+ Int_t dimuonArrSize,
+ Int_t nTrdTracks
)
{
// deletes content of standard arrays and resets size
if (dimuonArrSize > fDimuons->GetSize())
fDimuons->Expand(dimuonArrSize);
}
+ if (fTrdTracks) {
+ // no pointers in there, so cheaper Clear suffices
+ fTrdTracks->Clear("C");
+ if (nTrdTracks > fTrdTracks->GetSize())
+ fTrdTracks->Expand(nTrdTracks);
+ }
+
if (fTracklets)
fTracklets->DeleteContainer();
if (fPhosCells)
fHMPIDrings ->Clear();
if (fDimuons)
fDimuons ->Clear();
+ if (fTrdTracks)
+ fTrdTracks ->Clear();
if (fEMCALTrigger)
fEMCALTrigger->DeAllocate();
else return 0x0;
}
//------------------------------------------------------------
+AliAODTrdTrack& AliAODEvent::AddTrdTrack(const AliVTrdTrack *track) {
+ return *(new ((*fTrdTracks)[fTrdTracks->GetEntriesFast()]) AliAODTrdTrack(*track));
+}
#include "AliAODVZERO.h"
#include "AliAODHMPIDrings.h"
#include "AliAODZDC.h"
+#include "AliAODTrdTrack.h"
#ifdef MFT_UPGRADE
#include "AliAODMFT.h"
#endif
kAODVZERO,
kAODZDC,
kTOFHeader,
+ kAODTrdTracks,
#ifdef MFT_UPGRADE
kAODVZERO,
#endif
Int_t AddDimuon(const AliAODDimuon* dimu)
{new((*fDimuons)[fDimuons->GetEntriesFast()]) AliAODDimuon(*dimu); return fDimuons->GetEntriesFast()-1;}
+ // // -- TRD
+ Int_t GetNumberOfTrdTracks() const { return fTrdTracks ? fTrdTracks->GetEntriesFast() : 0; }
+ AliAODTrdTrack* GetTrdTrack(Int_t i) const {
+ return (AliAODTrdTrack *) (fTrdTracks ? fTrdTracks->At(i) : 0x0);
+ }
+ AliAODTrdTrack& AddTrdTrack(const AliVTrdTrack *track);
+
// -- Services
void CreateStdContent();
void SetStdNames();
Int_t fmdClusSize = 0,
Int_t pmdClusSize = 0,
Int_t hmpidRingsSize = 0,
- Int_t dimuonArrsize =0
+ Int_t dimuonArrsize =0,
+ Int_t nTrdTracks = 0
);
void ClearStd();
void Reset();
// combinatorial algorithm.
// It contains also TOF time resolution
// and T0spread as written in OCDB
+ TClonesArray *fTrdTracks; //! TRD AOD tracks (triggered)
#ifdef MFT_UPGRADE
AliAODMFT *fAODMFT; //! VZERO AOD
#endif
--- /dev/null
+#include "AliAODTrdTrack.h"
+
+AliAODTrdTrack::AliAODTrdTrack() :
+ AliVTrdTrack(),
+ fGlobalStack(-1),
+ fPID(0),
+ fLayerMask(0),
+ fA(0),
+ fFlagsTiming(0),
+ fTracklets(),
+ fTrackMatch(0x0),
+ fLabel(-1)
+{
+ // default constructor
+
+ fTracklets.SetClass("AliAODTrdTracklet", 6);
+}
+
+AliAODTrdTrack::AliAODTrdTrack(const AliVTrdTrack &rhs) :
+ AliVTrdTrack(rhs),
+ fGlobalStack(5*rhs.GetSector() + rhs.GetStack()),
+ fPID(rhs.GetPID()),
+ fLayerMask(rhs.GetLayerMask()),
+ fA(rhs.GetA()),
+ fFlagsTiming(rhs.GetFlagsTiming()),
+ fTracklets(),
+ fTrackMatch(rhs.GetTrackMatch()),
+ fLabel(rhs.GetLabel())
+{
+ // constructor from abstract base class
+
+ // copy the contributing tracklets
+ for (Int_t iTracklet = 0; iTracklet < 6; ++iTracklet) {
+ const AliVTrdTracklet *trkl = rhs.GetTracklet(iTracklet);
+ if (trkl)
+ new (fTracklets[iTracklet]) AliAODTrdTracklet(*trkl);
+ }
+}
+
+AliAODTrdTrack::AliAODTrdTrack(const AliAODTrdTrack& rhs) :
+ AliVTrdTrack(rhs),
+ fGlobalStack(rhs.fGlobalStack),
+ fPID(rhs.fPID),
+ fLayerMask(rhs.fLayerMask),
+ fA(rhs.fA),
+ fFlagsTiming(rhs.fFlagsTiming),
+ fTracklets(),
+ fTrackMatch(rhs.fTrackMatch),
+ fLabel(rhs.fLabel)
+{
+ // copy constructor
+
+ // copy the contributing tracklets
+ for (Int_t iTracklet = 0; iTracklet < 6; ++iTracklet) {
+ const AliVTrdTracklet *trkl = rhs.GetTracklet(iTracklet);
+ if (trkl)
+ new (fTracklets[iTracklet]) AliAODTrdTracklet(*trkl);
+ }
+}
+
+AliAODTrdTrack& AliAODTrdTrack::operator=(const AliAODTrdTrack& rhs)
+{
+ // assignment operator
+
+ if (&rhs != this)
+ AliVTrdTrack::operator=(rhs);
+
+ fGlobalStack = rhs.fGlobalStack;
+ fPID = rhs.fPID;
+ fLayerMask = rhs.fLayerMask;
+ fA = rhs.fA;
+ fFlagsTiming = rhs.fFlagsTiming;
+ fTrackMatch = rhs.fTrackMatch;
+ fLabel = rhs.fLabel;
+
+ // assign the contributing tracklets
+ for (Int_t iTracklet = 0; iTracklet < 6; ++iTracklet) {
+ const AliVTrdTracklet *trkl = rhs.GetTracklet(iTracklet);
+ if (trkl)
+ new (fTracklets[iTracklet]) AliAODTrdTracklet(*trkl);
+ }
+
+ return *this;
+}
+
+void AliAODTrdTrack::Copy(TObject &rhs) const
+{
+ // copy
+
+ AliVTrdTrack::Copy(rhs);
+}
+
+Int_t AliAODTrdTrack::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) != 0 ? (this->GetA() >> 2) : 1 );
+ Int_t ptRawComb4 = ptRawStage4;
+ Int_t ptExtComb4 = (ptRawComb4 > 0) ? ptRawComb4 + 33 : ptRawComb4 - 30;
+
+ return -ptExtComb4/2;
+ }
+ else
+ return 0;
+}
--- /dev/null
+#ifndef ALIAODTRDTRACK_H
+#define ALIAODTRDTRACK_H
+
+//
+// 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 "TRef.h"
+#include "TClonesArray.h"
+#include "AliVTrack.h"
+#include "AliVTrdTrack.h"
+#include "AliAODTrdTracklet.h"
+
+class AliAODTrdTrack : public AliVTrdTrack {
+ public:
+
+ AliAODTrdTrack();
+ AliAODTrdTrack(const AliVTrdTrack &rhs);
+ virtual ~AliAODTrdTrack() {};
+ AliAODTrdTrack(const AliAODTrdTrack& track);
+ AliAODTrdTrack& operator=(const AliAODTrdTrack& track);
+ virtual void Copy(TObject &obj) const;
+
+ virtual Int_t GetA() const { return fA; }
+ virtual Int_t GetLayerMask() const { return fLayerMask; }
+ virtual Int_t GetPID() const { return fPID; }
+ virtual Int_t GetPt() const;
+ virtual Int_t GetStack() const { return fGlobalStack%5; }
+ virtual Int_t GetSector() const { return fGlobalStack/5; }
+
+ virtual Bool_t GetTrackInTime() const { return (fFlagsTiming & 0x1); }
+ virtual UChar_t GetFlagsTiming() const { return fFlagsTiming; }
+
+ virtual Int_t GetLabel() const { return fLabel; }
+
+ virtual Double_t Pt() const { return GetPt() / 128.; }
+
+ Int_t GetNTracklets() const {
+ Int_t count = 0;
+ for (Int_t iLayer = 0; iLayer < 6; ++iLayer)
+ count += (fLayerMask >> iLayer) & 1;
+ return count;
+ }
+ virtual AliAODTrdTracklet* GetTracklet(Int_t idx) const { return (AliAODTrdTracklet*) fTracklets[idx]; }
+
+ virtual AliVTrack* GetTrackMatch() const { return 0x0; }
+
+ virtual void SetA(Int_t a) { fA = a; }
+ virtual void SetLayerMask(Int_t mask) { fLayerMask = mask; }
+ virtual void SetPID(Int_t pid) { fPID = pid; }
+ virtual void SetLabel(Int_t label) { fLabel = label; }
+ virtual void SetSector(Int_t sector) { fGlobalStack = 5*sector + (fGlobalStack%5); }
+ virtual void SetStack(Int_t stack) { fGlobalStack = 5*(fGlobalStack%5) + stack; }
+
+ void AddTracklet(const AliVTrdTracklet& trkl, Int_t layer) { new (fTracklets[layer]) AliAODTrdTracklet(trkl); }
+ void SetTrackMatchReference(AliVTrack *trk) { fTrackMatch = trk; }
+
+ virtual Bool_t IsSortable() const { return kFALSE; }
+ virtual Int_t Compare(const TObject* /* obj */) const { return 0; }
+
+ protected:
+
+ Char_t fGlobalStack; // stack (0-89) in which the track was found
+ // (unique because of stack-wise tracking)
+ UChar_t fPID; // electron PID for this track
+ UChar_t fLayerMask; // mask of contributing tracklets
+ Int_t fA; // transverse offset from nominal primary vertex
+ UChar_t fFlagsTiming; // timing flags
+
+ TClonesArray fTracklets; // array of contributing tracklets
+ TRef fTrackMatch; // reference to matched global track
+
+ Int_t fLabel; // Track label
+
+ ClassDef(AliAODTrdTrack,1)
+};
+
+#endif
--- /dev/null
+#include "AliAODTrdTracklet.h"
+
+AliAODTrdTracklet::AliAODTrdTracklet() :
+ AliVTrdTracklet(),
+ fHCId(-1),
+ fTrackletWord(0),
+ fLabel(-1)
+{
+ // default constructor
+
+}
+
+AliAODTrdTracklet::AliAODTrdTracklet(const AliVTrdTracklet &rhs) :
+ AliVTrdTracklet(rhs),
+ fHCId(rhs.GetHCId()),
+ fTrackletWord(rhs.GetTrackletWord()),
+ fLabel(rhs.GetLabel())
+{
+ // default constructor
+
+}
+
+AliAODTrdTracklet::AliAODTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label) :
+ AliVTrdTracklet(),
+ fHCId(hcid),
+ fTrackletWord(trackletWord),
+ fLabel(label)
+{
+ // constructor
+
+}
+
+AliAODTrdTracklet::AliAODTrdTracklet(const AliAODTrdTracklet& rhs) :
+ AliVTrdTracklet(rhs),
+ fHCId(rhs.fHCId),
+ fTrackletWord(rhs.fTrackletWord),
+ fLabel(rhs.fLabel)
+{
+ // copy constructor
+
+}
+
+AliAODTrdTracklet& AliAODTrdTracklet::operator=(const AliAODTrdTracklet& rhs)
+{
+ // assignment operator
+
+ if (&rhs != this) {
+ AliVTrdTracklet::operator=(rhs);
+
+ fHCId = rhs.fHCId;
+ fTrackletWord = rhs.fTrackletWord;
+ fLabel = rhs.fLabel;
+ }
+
+ return *this;
+}
+
+void AliAODTrdTracklet::Copy(TObject &rhs) const
+{
+ // copy
+
+ AliVTrdTracklet::Copy(rhs);
+}
+
+Int_t AliAODTrdTracklet::GetBinY() const
+{
+ // returns (signed) value of Y
+
+ if (fTrackletWord & 0x1000) {
+ return -((~(fTrackletWord-1)) & 0x1fff);
+ }
+ else {
+ return (fTrackletWord & 0x1fff);
+ }
+}
+
+Int_t AliAODTrdTracklet::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 AliAODTrdTracklet::GetDyDx() const
+// {
+// // returns the deflection over 3 cm drift length
+
+// return GetBinDy() * fgkBinWidthDy/fgkDriftLength;
+// }
--- /dev/null
+#ifndef ALIAODTRDTRACKLET_H
+#define ALIAODTRDTRACKLET_H
+
+#include "AliVTrdTracklet.h"
+
+class AliAODTrdTracklet : public AliVTrdTracklet {
+ public:
+
+ AliAODTrdTracklet();
+ AliAODTrdTracklet(const AliVTrdTracklet &rhs);
+ AliAODTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label = -1);
+ virtual ~AliAODTrdTracklet() {};
+ AliAODTrdTracklet(const AliAODTrdTracklet& track);
+ AliAODTrdTracklet& operator=(const AliAODTrdTracklet& track);
+ virtual void Copy(TObject &obj) const;
+
+ void SetTrackletWord(UInt_t trklWord) { fTrackletWord = trklWord; }
+ void SetHCId(Short_t hcid) { fHCId = hcid; }
+ void SetLabel(Int_t label) { fLabel = label; }
+
+ virtual UInt_t GetTrackletWord() const { return fTrackletWord; }
+ virtual Int_t GetBinY() const;
+ virtual Int_t GetBinDy() const;
+ virtual Int_t GetBinZ() const { return ((fTrackletWord >> 20) & 0xf); }
+ virtual Int_t GetPID() const { return ((fTrackletWord >> 24) & 0xff); }
+
+ virtual Int_t GetHCId() const { return fHCId; }
+ virtual Int_t GetDetector() const { return fHCId / 2; }
+
+ virtual 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
+
+ ClassDef(AliAODTrdTracklet,1)
+};
+
+#endif
#pragma link C++ class AliAODVZERO+;
#pragma link C++ class AliAODZDC+;
#pragma link C++ class AliAODHMPIDrings+;
+#pragma link C++ class AliAODTrdTrack+;
+#pragma link C++ class AliAODTrdTracklet+;
#pragma link C++ method AliAODTrack::SetPosition<double>(double const*, bool);
AOD/AliAODVZERO.cxx
AOD/AliAODZDC.cxx
AOD/AliAODHMPIDrings.cxx
+ AOD/AliAODTrdTrack.cxx
+ AOD/AliAODTrdTracklet.cxx
)
string( REPLACE ".cxx" ".h" HDRS "${SRCS}")
STEERBase/AliVCaloTrigger.cxx
STEERBase/AliProdInfo.cxx
STEERBase/AliVTrdTrack.cxx
+ STEERBase/AliVTrdTracklet.cxx
)
string(REPLACE ".cxx" ".h" HDRS "${SRCS}")
#include "AliESDCaloCells.h"
#include "AliESDVZERO.h"
+#include "AliESDTrdTrack.h"
#ifdef MFT_UPGRADE
//#include "AliESDMFT.h"
#endif
class AliRawDataErrorLog;
class AliESDRun;
class AliESDTrdTrigger;
-class AliESDTrdTrack;
class AliESDTrdTracklet;
class AliESDMuonTrack;
class AliESDMuonCluster;
fFlags = track.fFlags;
fFlagsTiming = track.fFlagsTiming;
fReserved = track.fReserved;
+ fTrackMatch = track.fTrackMatch;
fLabel = track.fLabel;
for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
fTrackletIndex[iLayer] = track.fTrackletIndex[iLayer];
Double_t Phi() const { return 0.; };
Double_t Eta() const { return 0.; };
+ Int_t GetNTracklets() const {
+ Int_t count = 0;
+ for (Int_t iLayer = 0; iLayer < 6; ++iLayer)
+ count += (fLayerMask >> iLayer) & 1;
+ return count;
+ }
AliESDTrdTracklet* GetTracklet(Int_t idx) const
{ return (GetLayerMask() & (1<<idx)) ? (AliESDTrdTracklet*) ((fTrackletRefs[idx]).GetObject()) : 0x0; }
AliVTrack* GetTrackMatch() const { return (AliVTrack*) fTrackMatch.GetObject(); }
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(),
+ AliVTrdTracklet(),
fHCId(-1),
fTrackletWord(0),
fLabel(-1)
}
AliESDTrdTracklet::AliESDTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label) :
- TObject(),
+ AliVTrdTracklet(),
fHCId(hcid),
fTrackletWord(trackletWord),
fLabel(label)
}
AliESDTrdTracklet::AliESDTrdTracklet(const AliESDTrdTracklet &trkl) :
- TObject(trkl),
+ AliVTrdTracklet(trkl),
fHCId(trkl.fHCId),
fTrackletWord(trkl.fTrackletWord),
fLabel(trkl.fLabel)
if (this == &trkl)
return *this;
- TObject::operator=(trkl);
+ AliVTrdTracklet::operator=(trkl);
fHCId = trkl.fHCId;
fTrackletWord = trkl.fTrackletWord;
fLabel = trkl.fLabel;
return ((fTrackletWord >> 13) & 0x7f);
}
}
-
-Float_t AliESDTrdTracklet::GetDyDx() const
-{
- // returns the deflection over 3 cm drift length
-
- return GetBinDy() * fgkBinWidthDy/fgkDriftLength;
-}
// ESD format for TRD tracklet from FEE used for triggering
-#include "TObject.h"
+#include "AliVTrdTracklet.h"
-class AliESDTrdTracklet : public TObject
+class AliESDTrdTracklet : public AliVTrdTracklet
{
public:
AliESDTrdTracklet();
void SetTrackletWord(UInt_t trklWord) { fTrackletWord = trklWord; }
void SetHCId(Short_t hcid) { fHCId = hcid; }
+ void SetLabel(Int_t label) { fLabel = label; }
// ----- 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;
+ virtual UInt_t GetTrackletWord() const { return fTrackletWord; }
+ virtual Int_t GetBinY() const;
+ virtual Int_t GetBinDy() const;
+ virtual Int_t GetBinZ() const { return ((fTrackletWord >> 20) & 0xf); }
+ virtual Int_t GetPID() const { return ((fTrackletWord >> 24) & 0xff); }
// ----- geometrical information -----
Int_t GetHCId() const { return fHCId; }
// 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);
};
#include "AliVCaloTrigger.h"
#include "TRefArray.h"
#include "AliTOFHeader.h"
+#include "AliVTrdTrack.h"
class AliCentrality;
class AliEventplane;
class AliVVZERO;
virtual void SetVZEROEqFactors(Float_t /* factors */[64]) const {return;}
virtual AliVZDC *GetZDCData() const = 0;
+ virtual Int_t GetNumberOfTrdTracks() const { return 0; }
+ virtual AliVTrdTrack* GetTrdTrack(Int_t /* iTrack */) const { return 0x0; }
+
ClassDef(AliVEvent,2) // base class for AliEvent data
};
#endif
#include "TObject.h"
class AliVTrack;
+class AliVTrdTracklet;
class AliVTrdTrack : public TObject {
public:
virtual Int_t GetSector() const = 0;
virtual Bool_t GetTrackInTime() const = 0;
+ virtual UChar_t GetFlagsTiming() const = 0;
virtual Int_t GetLabel() const = 0;
virtual Double_t Pt() const = 0;
+ virtual Int_t GetNTracklets() const = 0;
+ virtual AliVTrdTracklet* GetTracklet(Int_t idx) const = 0;
+
virtual AliVTrack* GetTrackMatch() const = 0;
virtual void SetA(Int_t a) = 0;
--- /dev/null
+#include "AliVTrdTracklet.h"
+
+const Float_t AliVTrdTracklet::fgkBinWidthY = 160e-4; // 160 um
+const Float_t AliVTrdTracklet::fgkBinWidthDy = 140e-4; // 140 um
+const Float_t AliVTrdTracklet::fgkDriftLength = 3.; // 3 cm
+
+AliVTrdTracklet::AliVTrdTracklet() :
+ TObject()
+{
+ // default constructor
+
+}
+
+AliVTrdTracklet::AliVTrdTracklet(const AliVTrdTracklet& rhs) :
+ TObject(rhs)
+{
+ // copy constructor
+
+}
+
+AliVTrdTracklet& AliVTrdTracklet::operator=(const AliVTrdTracklet& rhs)
+{
+ // assignment operator
+
+ if (&rhs != this)
+ TObject::operator=(rhs);
+
+ return *this;
+}
+
+void AliVTrdTracklet::Copy(TObject &rhs) const
+{
+ // copy
+
+ TObject::Copy(rhs);
+}
--- /dev/null
+#ifndef ALIVTRDTRACKLET_H
+#define ALIVTRDTRACKLET_H
+
+// format for the TRD tracklets calculated in the FEE,
+// used for the TRD L1 trigger
+// Author: Jochen Klein <jochen.klein@cern.ch>
+
+#include "TObject.h"
+
+class AliVTrdTracklet : public TObject {
+ public:
+
+ AliVTrdTracklet();
+ virtual ~AliVTrdTracklet() {};
+ AliVTrdTracklet(const AliVTrdTracklet& track);
+ AliVTrdTracklet& operator=(const AliVTrdTracklet& track);
+ virtual void Copy(TObject &obj) const;
+
+ // tracklet information
+ virtual UInt_t GetTrackletWord() const = 0;
+ virtual Int_t GetBinY() const = 0;
+ virtual Int_t GetBinDy() const = 0;
+ virtual Int_t GetBinZ() const = 0;
+ virtual Int_t GetPID() const = 0;
+
+ // position and deflection information (chamber-local)
+ Float_t GetLocalY() const { return GetBinY() * fgkBinWidthY; }
+ Float_t GetDyDx() const { return GetBinDy() * fgkBinWidthDy/fgkDriftLength; }
+
+ virtual Int_t GetHCId() const = 0;
+ virtual Int_t GetDetector() const = 0;
+ virtual Int_t GetLabel() const = 0;
+
+ protected:
+
+ static const Float_t fgkBinWidthY; // bin width y-position
+ static const Float_t fgkBinWidthDy; // bin width deflection length
+ static const Float_t fgkDriftLength; // drift length to which the deflection length is scaled
+
+ ClassDef(AliVTrdTracklet,0)
+};
+
+#endif
#pragma link C++ class AliProdInfo+;
#pragma link C++ class AliVTrdTrack+;
+#pragma link C++ class AliVTrdTracklet+;
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff