Line data Source code
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 172 : ClassImp(AliESDTrdTrack)
31 :
32 : //_____________________________________________________________________________
33 67899 : AliESDTrdTrack::AliESDTrdTrack():
34 5223 : AliVTrdTrack(),
35 5223 : fSector(-1),
36 5223 : fStack(-1),
37 5223 : fA(0),
38 5223 : fB(0),
39 5223 : fC(0),
40 5223 : fY(0),
41 5223 : fPID(0),
42 5223 : fLayerMask(0),
43 5223 : fFlags(0),
44 5223 : fFlagsTiming(0),
45 5223 : fReserved(0),
46 5223 : fTrackMatch(),
47 5223 : fLabel(-1)
48 26115 : {
49 : //
50 : // Default constructor
51 73122 : for (int i=fgkNlayers;i--;) fTrackletIndex[i] = 0;
52 : //
53 :
54 10446 : }
55 :
56 30342 : AliESDTrdTrack::AliESDTrdTrack(const AliESDTrdTrack& track):
57 2334 : AliVTrdTrack(track),
58 2334 : fSector(track.fSector),
59 2334 : fStack(track.fStack),
60 2334 : fA(track.fA),
61 2334 : fB(track.fB),
62 2334 : fC(track.fC),
63 2334 : fY(track.fY),
64 2334 : fPID(track.fPID),
65 2334 : fLayerMask(track.fLayerMask),
66 2334 : fFlags(track.fFlags),
67 2334 : fFlagsTiming(track.fFlagsTiming),
68 2334 : fReserved(track.fReserved),
69 2334 : fTrackMatch(track.fTrackMatch),
70 2334 : fLabel(track.fLabel)
71 11670 : {
72 : //
73 : // Copy contructor
74 : //
75 :
76 32676 : for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
77 14004 : fTrackletIndex[iLayer] = track.fTrackletIndex[iLayer];
78 :
79 28008 : if (track.fTrackletRefs[iLayer].GetObject())
80 73 : fTrackletRefs[iLayer] = track.fTrackletRefs[iLayer];
81 : }
82 4668 : }
83 :
84 : AliESDTrdTrack& AliESDTrdTrack::operator=(const AliESDTrdTrack& track)
85 : {
86 : //
87 : // assignment operator
88 : //
89 :
90 0 : if (this == &track)
91 0 : return *this;
92 0 : AliVTrdTrack::operator=(track);
93 0 : fSector = track.fSector;
94 0 : fStack = track.fStack;
95 0 : fA = track.fA;
96 0 : fB = track.fB;
97 0 : fC = track.fC;
98 0 : fPID = track.fPID;
99 0 : fLayerMask = track.fLayerMask;
100 0 : fFlags = track.fFlags;
101 0 : fFlagsTiming = track.fFlagsTiming;
102 0 : fReserved = track.fReserved;
103 0 : fTrackMatch = track.fTrackMatch;
104 0 : fLabel = track.fLabel;
105 0 : for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
106 0 : fTrackletIndex[iLayer] = track.fTrackletIndex[iLayer];
107 0 : fTrackletRefs[iLayer] = track.fTrackletRefs[iLayer];
108 : }
109 :
110 0 : return *this;
111 0 : }
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 0 : if(this==&obj)return;
120 0 : AliESDTrdTrack *robj = dynamic_cast<AliESDTrdTrack*>(&obj);
121 0 : if(!robj)return; // not an aliesdtrdtrack
122 0 : *robj = *this;
123 0 : }
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 0 : ULong64_t trackWord = 1;
131 0 : AppendBits(trackWord, 1, 0);
132 0 : AppendBits(trackWord, 6, fLayerMask);
133 0 : AppendBits(trackWord, 18, fA);
134 0 : AppendBits(trackWord, 18, fB);
135 0 : AppendBits(trackWord, 12, fC);
136 0 : AppendBits(trackWord, 8, fPID);
137 0 : return trackWord;
138 0 : }
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 0 : ULong64_t trackWord = 0;
146 0 : AppendBits(trackWord, 11, fFlags);
147 0 : AppendBits(trackWord, 1, fFlagsTiming);
148 0 : AppendBits(trackWord, 2, fReserved);
149 0 : AppendBits(trackWord, 13, fY);
150 0 : AppendBits(trackWord, 6, fTrackletIndex[5]);
151 0 : AppendBits(trackWord, 6, fTrackletIndex[4]);
152 0 : AppendBits(trackWord, 6, fTrackletIndex[3]);
153 0 : AppendBits(trackWord, 6, fTrackletIndex[2]);
154 0 : AppendBits(trackWord, 6, fTrackletIndex[1]);
155 0 : AppendBits(trackWord, 6, fTrackletIndex[0]);
156 0 : return trackWord;
157 0 : }
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 4638 : if (this->GetA() != 0) {
178 15 : Int_t layerMaskId = maskIdLut[this->GetLayerMask()];
179 15 : Int_t c1 = c1Lut[layerMaskId];
180 15 : Int_t c1Ext = c1 << 8;
181 45 : Int_t ptRawStage4 = c1Ext / ((this->GetA() >> 2) != 0 ? (this->GetA() >> 2) : 1 );
182 : Int_t ptRawComb4 = ptRawStage4;
183 15 : Int_t ptExtComb4 = (ptRawComb4 > 0) ? ptRawComb4 + 33 : ptRawComb4 - 30;
184 :
185 15 : return -ptExtComb4/2;
186 : }
187 : else
188 2304 : return 0;
189 2319 : }
190 :
191 : Int_t AliESDTrdTrack::Compare(const TObject* obj) const
192 : {
193 0 : if (this == obj)
194 0 : return 0;
195 0 : else if (TMath::Abs(Pt()) < TMath::Abs(((AliESDTrdTrack*)(obj))->Pt()))
196 0 : return 1;
197 : else
198 0 : return -1;
199 0 : }
|
