]>
Commit | Line | Data |
---|---|---|
e4f2f73d | 1 | #ifndef ALITRDSEEDV1_H |
2 | #define ALITRDSEEDV1_H | |
3 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
e44586fb | 4 | * See cxx source for full Copyright notice */ |
e4f2f73d | 5 | |
6 | /* $Id$ */ | |
7 | ||
8 | //////////////////////////////////////////////////////////////////////////// | |
9 | // // | |
ee8fb199 | 10 | // \class AliTRDseedV1 |
11 | // \brief The TRD offline tracklet | |
12 | // \author Alexandru Bercuci | |
e4f2f73d | 13 | // // |
14 | //////////////////////////////////////////////////////////////////////////// | |
15 | ||
3e778975 | 16 | #ifndef ALITRDTRACKLETBASE_H |
17 | #include "AliTRDtrackletBase.h" | |
e3cf3d02 | 18 | #endif |
19 | ||
20 | #ifndef ROOT_TMath | |
21 | #include "TMath.h" | |
e4f2f73d | 22 | #endif |
23 | ||
ae4e8b84 | 24 | #ifndef ALITRDGEOMETRY_H |
25 | #include "AliTRDgeometry.h" | |
26 | #endif | |
27 | ||
0906e73e | 28 | #ifndef ALIPID_H |
29 | #include "AliPID.h" | |
30 | #endif | |
31 | ||
e4f2f73d | 32 | |
f29f13a6 | 33 | #ifndef ALITRDCLUSTER_H |
34 | #include "AliTRDcluster.h" | |
35 | #endif | |
36 | ||
d07eec70 | 37 | |
e4f2f73d | 38 | class TTreeSRedirector; |
f301a656 | 39 | class TLinearFitter; |
e4f2f73d | 40 | |
41 | class AliRieman; | |
42 | ||
4ecadb52 | 43 | class AliTRDReconstructor; |
eb38ed55 | 44 | class AliTRDtrackingChamber; |
f3d3af1b | 45 | class AliTRDtrackV1; |
eb2b4f91 | 46 | class AliTRDpadPlane; |
3e778975 | 47 | class AliTRDseedV1 : public AliTRDtrackletBase |
48 | { | |
4ecadb52 | 49 | friend class AliHLTTRDTracklet; // wrapper for HLT |
3044dfe5 | 50 | |
e3cf3d02 | 51 | public: |
52 | enum ETRDtrackletBuffers { | |
980d5a2a | 53 | kNbits = 6 // bits to store number of clusters |
54 | ,kMask = 0x3f // bit mask | |
55 | ,kNtb = 31 // max clusters/pad row | |
8d2bec9e | 56 | ,kNclusters = 2*kNtb // max number of clusters/tracklet |
1f97f376 | 57 | ,kNdEdxSlices= 8 // dEdx slices allocated in reconstruction |
e44586fb | 58 | }; |
e3cf3d02 | 59 | |
2e2915e7 | 60 | // bits from 0-13 are reserved by ROOT (see TObject.h) |
e3cf3d02 | 61 | enum ETRDtrackletStatus { |
f29f13a6 | 62 | kOwner = BIT(14) // owner of its clusters |
63 | ,kRowCross = BIT(15) // pad row cross tracklet | |
1f97f376 | 64 | ,kChmbGood = BIT(16) // status of the detector from calibration view point |
e20bef2b | 65 | ,kCalib = BIT(17) // calibrated tracklet |
66 | ,kKink = BIT(18) // kink prolongation tracklet | |
1fd9389f | 67 | ,kStandAlone = BIT(19) // tracklet build during stand alone track finding |
2eb10c34 | 68 | ,kPrimary = BIT(20) // tracklet from a primary track candidate |
e44586fb | 69 | }; |
2eb10c34 | 70 | |
71 | enum ETRDtrackletError { // up to 8 bits | |
72 | kAttachClFound = 0 // not enough clusters found | |
73 | ,kAttachRowGap = 1 // found gap attached rows | |
74 | ,kAttachRow = 2 // found 3 rows | |
75 | ,kAttachMultipleCl= 3// multiple clusters attached to time bin | |
76 | ,kAttachClAttach= 4 // not enough clusters attached | |
77 | ,kFitCl = 5 // not enough clusters for fit | |
78 | ,kFitFailedY = 6 // fit failed in XY plane failed | |
79 | ,kFitFailedZ = 7 // fit in the QZ plane failed | |
7c3eecb8 | 80 | }; |
e44586fb | 81 | |
ae4e8b84 | 82 | AliTRDseedV1(Int_t det = -1); |
e44586fb | 83 | ~AliTRDseedV1(); |
84 | AliTRDseedV1(const AliTRDseedV1 &ref); | |
85 | AliTRDseedV1& operator=(const AliTRDseedV1 &ref); | |
ddfbc51a | 86 | |
9dcc64cc | 87 | Bool_t AttachClusters(AliTRDtrackingChamber *const chamber, Bool_t tilt = kFALSE, Bool_t ChgPlus=kTRUE, Int_t ev=-1); |
203967fc | 88 | void Bootstrap(const AliTRDReconstructor *rec); |
e3cf3d02 | 89 | void Calibrate(); |
203967fc | 90 | void CookdEdx(Int_t nslices); |
e3cf3d02 | 91 | void CookLabels(); |
3e778975 | 92 | Bool_t CookPID(); |
2eb10c34 | 93 | Bool_t Fit(UChar_t opt=0); |
9dcc64cc | 94 | Bool_t FitRobust(Bool_t ChgPlus=kTRUE); |
33ab3872 | 95 | Bool_t Init(const AliTRDtrackV1 *track); |
4ecadb52 | 96 | void Init(const AliRieman *fit); |
203967fc | 97 | Bool_t IsEqual(const TObject *inTracklet) const; |
e3cf3d02 | 98 | Bool_t IsCalibrated() const { return TestBit(kCalib);} |
803dc399 | 99 | Bool_t IsChmbGood() const { return TestBit(kChmbGood);} |
e44586fb | 100 | Bool_t IsOwner() const { return TestBit(kOwner);} |
f29f13a6 | 101 | Bool_t IsKink() const { return TestBit(kKink);} |
2eb10c34 | 102 | Bool_t IsPrimary() const { return TestBit(kPrimary);} |
2eb10c34 | 103 | Bool_t HasError(ETRDtrackletError err) const |
104 | { return TESTBIT(fErrorMsg, err);} | |
3e778975 | 105 | Bool_t IsOK() const { return GetN() > 4 && GetNUsed() < 4;} |
e44586fb | 106 | Bool_t IsRowCross() const { return TestBit(kRowCross);} |
f29f13a6 | 107 | Bool_t IsUsable(Int_t i) const { return fClusters[i] && !fClusters[i]->IsUsed();} |
108 | Bool_t IsStandAlone() const { return TestBit(kStandAlone);} | |
e44586fb | 109 | |
2eb10c34 | 110 | Float_t GetAnodeWireOffset(Float_t zt); |
68f9b6bd | 111 | Float_t GetC(Int_t typ=0) const { return fC[typ]; } |
9dcc64cc | 112 | Float_t GetCharge(Bool_t useOutliers=kFALSE) const; |
e3cf3d02 | 113 | Float_t GetChi2() const { return fChi2; } |
114 | inline Float_t GetChi2Z() const; | |
115 | inline Float_t GetChi2Y() const; | |
f29f13a6 | 116 | inline Float_t GetChi2Phi() const; |
e44586fb | 117 | void GetCovAt(Double_t x, Double_t *cov) const; |
d937ad7a | 118 | void GetCovXY(Double_t *cov) const { memcpy(cov, &fCov[0], 3*sizeof(Double_t));} |
16cca13f | 119 | void GetCovRef(Double_t *cov) const { memcpy(cov, &fRefCov, 7*sizeof(Double_t));} |
66765e8e | 120 | static Int_t GetCovSqrt(const Double_t * const c, Double_t *d); |
4d6aee34 | 121 | static Double_t GetCovInv(const Double_t * const c, Double_t *d); |
7c3eecb8 | 122 | UChar_t GetErrorMsg() const { return fErrorMsg;} |
203967fc | 123 | Float_t GetdX() const { return fdX;} |
4d6aee34 | 124 | const Float_t* GetdEdx() const { return &fdEdx[0];} |
a0bb5615 | 125 | Float_t GetQperTB(Int_t tb) const; |
9dcc64cc | 126 | Float_t GetdQdl() const; |
4d6aee34 | 127 | Float_t GetdQdl(Int_t ic, Float_t *dx=NULL) const; |
2eb10c34 | 128 | Float_t GetdYdX() const { return fYfit[1];} |
129 | Float_t GetdZdX() const { return fZfit[1];} | |
3e778975 | 130 | Int_t GetdY() const { return Int_t(GetY()/0.014);} |
203967fc | 131 | Int_t GetDetector() const { return fDet;} |
15a4c6d0 | 132 | Int_t GetChargeGaps(Float_t sz[kNtb], Float_t pos[kNtb], Int_t ntb[kNtb]) const; |
e3cf3d02 | 133 | void GetCalibParam(Float_t &exb, Float_t &vd, Float_t &t0, Float_t &s2, Float_t &dl, Float_t &dt) const { |
134 | exb = fExB; vd = fVD; t0 = fT0; s2 = fS2PRF; dl = fDiffL; dt = fDiffT;} | |
4d6aee34 | 135 | AliTRDcluster* GetClusters(Int_t i) const { return i<0 || i>=kNclusters ? NULL: fClusters[i];} |
e1bcf0af | 136 | Bool_t GetEstimatedCrossPoint(Float_t &x, Float_t &z) const; |
8d2bec9e | 137 | Int_t GetIndexes(Int_t i) const{ return i<0 || i>=kNclusters ? -1 : fIndexes[i];} |
e3cf3d02 | 138 | Int_t GetLabels(Int_t i) const { return fLabels[i];} |
4d6aee34 | 139 | Float_t GetMomentum(Float_t *err = NULL) const; |
980d5a2a | 140 | Int_t GetN() const { return (Int_t)fN&kMask;} |
3e778975 | 141 | Int_t GetN2() const { return GetN();} |
980d5a2a | 142 | Int_t GetNUsed() const { return Int_t((fN>>kNbits)&kMask);} |
143 | Int_t GetNShared() const { return Int_t(((fN>>kNbits)>>kNbits)&kMask);} | |
5c5d503a | 144 | Int_t GetTBoccupancy() const; |
145 | Int_t GetTBcross() const; | |
e44586fb | 146 | Float_t GetQuality(Bool_t kZcorr) const; |
dd8059a8 | 147 | Float_t GetPadLength() const { return fPad[0];} |
148 | Float_t GetPadWidth() const { return fPad[1];} | |
ae4e8b84 | 149 | Int_t GetPlane() const { return AliTRDgeometry::GetLayer(fDet); } |
150 | ||
3e778975 | 151 | Float_t* GetProbability(Bool_t force=kFALSE); |
b25a5e9e | 152 | Float_t GetPt() const { return fPt; } |
3e778975 | 153 | inline Double_t GetPID(Int_t is=-1) const; |
e3cf3d02 | 154 | Float_t GetS2Y() const { return fS2Y;} |
155 | Float_t GetS2Z() const { return fS2Z;} | |
156 | Float_t GetSigmaY() const { return fS2Y > 0. ? TMath::Sqrt(fS2Y) : 0.2;} | |
157 | Float_t GetSnp() const { return fYref[1]/TMath::Sqrt(1+fYref[1]*fYref[1]);} | |
1fd9389f | 158 | Float_t GetTgl() const { return fZref[1]/TMath::Sqrt(1+fYref[1]*fYref[1]);} |
dd8059a8 | 159 | Float_t GetTilt() const { return fPad[2];} |
3e778975 | 160 | UInt_t GetTrackletWord() const { return 0;} |
b72f4eaf | 161 | UShort_t GetVolumeId() const; |
e3cf3d02 | 162 | Float_t GetX0() const { return fX0;} |
163 | Float_t GetX() const { return fX0 - fX;} | |
5a7a515d | 164 | Float_t GetY() const { return fYfit[0] - fYfit[1] * fX;} |
b1957d3c | 165 | Double_t GetYat(Double_t x) const { return fYfit[0] - fYfit[1] * (fX0-x);} |
1fd9389f | 166 | Float_t GetYfit(Int_t id) const { return fYfit[id];} |
167 | Float_t GetYref(Int_t id) const { return fYref[id];} | |
168 | Float_t GetZ() const { return fZfit[0] - fZfit[1] * fX;} | |
b1957d3c | 169 | Double_t GetZat(Double_t x) const { return fZfit[0] - fZfit[1] * (fX0-x);} |
1fd9389f | 170 | Float_t GetZfit(Int_t id) const { return fZfit[id];} |
171 | Float_t GetZref(Int_t id) const { return fZref[id];} | |
172 | Int_t GetYbin() const { return Int_t(GetY()/0.016);} | |
173 | Int_t GetZbin() const { return Int_t(GetZ()/fPad[0]);} | |
e3cf3d02 | 174 | |
ae4e8b84 | 175 | inline AliTRDcluster* NextCluster(); |
71ea19a3 | 176 | inline AliTRDcluster* PrevCluster(); |
e44586fb | 177 | void Print(Option_t *o = "") const; |
71ea19a3 | 178 | inline void ResetClusterIter(Bool_t forward = kTRUE); |
980d5a2a | 179 | void Reset(Option_t *opt=""); |
ae4e8b84 | 180 | |
68f9b6bd | 181 | void SetC(Float_t c, Int_t typ=0) { fC[typ] = c;} |
803dc399 | 182 | void SetChmbGood(Bool_t k = kTRUE){ SetBit(kChmbGood, k);} |
1fd9389f | 183 | void SetChi2(Float_t chi2) { fChi2 = chi2;} |
16cca13f | 184 | inline void SetCovRef(const Double_t *cov); |
2eb10c34 | 185 | void SetErrorMsg(ETRDtrackletError err) { SETBIT(fErrorMsg, err);} |
e3cf3d02 | 186 | void SetIndexes(Int_t i, Int_t idx) { fIndexes[i] = idx; } |
187 | void SetLabels(Int_t *lbls) { memcpy(fLabels, lbls, 3*sizeof(Int_t)); } | |
e20bef2b | 188 | void SetKink(Bool_t k = kTRUE){ SetBit(kKink, k);} |
2eb10c34 | 189 | void SetPrimary(Bool_t k = kTRUE){ SetBit(kPrimary, k);} |
f29f13a6 | 190 | void SetStandAlone(Bool_t st) { SetBit(kStandAlone, st); } |
b25a5e9e | 191 | void SetPt(Double_t pt) { fPt = pt;} |
29b87567 | 192 | void SetOwner(); |
4ecadb52 | 193 | void SetPadPlane(AliTRDpadPlane * const p); |
dd8059a8 | 194 | void SetPadLength(Float_t l) { fPad[0] = l;} |
195 | void SetPadWidth(Float_t w) { fPad[1] = w;} | |
cbe97468 | 196 | void SetTilt(Float_t tilt) { fPad[2] = tilt; } |
203967fc | 197 | void SetDetector(Int_t d) { fDet = d; } |
bee2b41e | 198 | void SetDX(Float_t inDX) { fdX = inDX;} |
4d6aee34 | 199 | void SetReconstructor(const AliTRDReconstructor *rec) {fkReconstructor = rec;} |
e3cf3d02 | 200 | void SetX0(Float_t x0) { fX0 = x0; } |
201 | void SetYref(Int_t i, Float_t y) { fYref[i] = y;} | |
202 | void SetZref(Int_t i, Float_t z) { fZref[i] = z;} | |
f29f13a6 | 203 | // void SetUsabilityMap(Long_t um) { fUsable = um; } |
16cca13f | 204 | void Update(const AliTRDtrackV1* trk); |
e3cf3d02 | 205 | void UpdateUsed(); |
206 | void UseClusters(); | |
e4f2f73d | 207 | |
d937ad7a | 208 | protected: |
3e778975 | 209 | void Copy(TObject &ref) const; |
e4f2f73d | 210 | |
e44586fb | 211 | private: |
3e778975 | 212 | inline void SetN(Int_t n); |
213 | inline void SetNUsed(Int_t n); | |
214 | inline void SetNShared(Int_t n); | |
4ecadb52 | 215 | inline void Swap(Int_t &n1, Int_t &n2) const; |
216 | inline void Swap(Double_t &d1, Double_t &d2) const; | |
3e778975 | 217 | |
4d6aee34 | 218 | const AliTRDReconstructor *fkReconstructor;//! local reconstructor |
e3cf3d02 | 219 | AliTRDcluster **fClusterIter; //! clusters iterator |
8d2bec9e | 220 | Int_t fIndexes[kNclusters]; //! Indexes |
0323ef61 | 221 | Float_t fExB; // tg(a_L) @ tracklet location |
222 | Float_t fVD; // drift velocity @ tracklet location | |
223 | Float_t fT0; // time 0 @ tracklet location | |
224 | Float_t fS2PRF; // sigma^2 PRF for xd->0 and phi=a_L | |
225 | Float_t fDiffL; // longitudinal diffusion coefficient | |
226 | Float_t fDiffT; // transversal diffusion coefficient | |
71ea19a3 | 227 | Char_t fClusterIdx; //! clusters iterator |
7c3eecb8 | 228 | UChar_t fErrorMsg; // processing error |
6ad5e6b2 | 229 | UInt_t fN; // number of clusters attached/used/shared |
e3cf3d02 | 230 | Short_t fDet; // TRD detector |
8d2bec9e | 231 | AliTRDcluster *fClusters[kNclusters]; // Clusters |
2eb10c34 | 232 | Float_t fPad[4]; // local pad definition : length/width/tilt/anode wire offset |
1fd9389f | 233 | Float_t fYref[2]; // Reference y, dydx |
234 | Float_t fZref[2]; // Reference z, dz/dx | |
235 | Float_t fYfit[2]; // Fit y, dy/dx | |
236 | Float_t fZfit[2]; // Fit z | |
16cca13f | 237 | Float_t fPt; // Pt estimate @ tracklet [GeV/c] |
e44586fb | 238 | Float_t fdX; // length of time bin |
e3cf3d02 | 239 | Float_t fX0; // anode wire position |
240 | Float_t fX; // radial position of the tracklet | |
241 | Float_t fY; // r-phi position of the tracklet | |
242 | Float_t fZ; // z position of the tracklet | |
243 | Float_t fS2Y; // estimated resolution in the r-phi direction | |
244 | Float_t fS2Z; // estimated resolution in the z direction | |
68f9b6bd | 245 | Float_t fC[2]; // Curvature for standalone [0] rieman [1] vertex constrained |
e3cf3d02 | 246 | Float_t fChi2; // Global chi2 |
1f97f376 | 247 | Float_t fdEdx[kNdEdxSlices]; // dE/dx measurements for tracklet |
1fd9389f | 248 | Float_t fProb[AliPID::kSPECIES]; // PID probabilities |
e3cf3d02 | 249 | Int_t fLabels[3]; // most frequent MC labels and total number of different labels |
16cca13f | 250 | Double_t fRefCov[7]; // covariance matrix of the track in the yz plane + the rest of the diagonal elements |
d937ad7a | 251 | Double_t fCov[3]; // covariance matrix of the tracklet in the xy plane |
e4f2f73d | 252 | |
c51f4ffb | 253 | ClassDef(AliTRDseedV1, 12) // The offline TRD tracklet |
e4f2f73d | 254 | }; |
255 | ||
256 | //____________________________________________________________ | |
e3cf3d02 | 257 | inline Float_t AliTRDseedV1::GetChi2Z() const |
e4f2f73d | 258 | { |
e3cf3d02 | 259 | Double_t dz = fZref[0]-fZfit[0]; dz*=dz; |
260 | Double_t cov[3]; GetCovAt(fX, cov); | |
261 | Double_t s2 = fRefCov[2]+cov[2]; | |
262 | return s2 > 0. ? dz/s2 : 0.; | |
e4f2f73d | 263 | } |
264 | ||
265 | //____________________________________________________________ | |
e3cf3d02 | 266 | inline Float_t AliTRDseedV1::GetChi2Y() const |
e4f2f73d | 267 | { |
e3cf3d02 | 268 | Double_t dy = fYref[0]-fYfit[0]; dy*=dy; |
269 | Double_t cov[3]; GetCovAt(fX, cov); | |
270 | Double_t s2 = fRefCov[0]+cov[0]; | |
271 | return s2 > 0. ? dy/s2 : 0.; | |
e4f2f73d | 272 | } |
273 | ||
f29f13a6 | 274 | //____________________________________________________________ |
275 | inline Float_t AliTRDseedV1::GetChi2Phi() const | |
276 | { | |
277 | Double_t dphi = fYref[1]-fYfit[1]; dphi*=dphi; | |
278 | Double_t cov[3]; GetCovAt(fX, cov); | |
279 | Double_t s2 = fRefCov[2]+cov[2]; | |
280 | return s2 > 0. ? dphi/s2 : 0.; | |
281 | } | |
282 | ||
16cca13f | 283 | |
284 | ||
3e778975 | 285 | //____________________________________________________________ |
286 | inline Double_t AliTRDseedV1::GetPID(Int_t is) const | |
287 | { | |
288 | if(is<0) return fProb[AliPID::kElectron]; | |
289 | if(is<AliPID::kSPECIES) return fProb[is]; | |
290 | return 0.; | |
291 | } | |
292 | ||
ae4e8b84 | 293 | //____________________________________________________________ |
294 | inline AliTRDcluster* AliTRDseedV1::NextCluster() | |
295 | { | |
71ea19a3 | 296 | // Mimic the usage of STL iterators. |
297 | // Forward iterator | |
298 | ||
ae4e8b84 | 299 | fClusterIdx++; fClusterIter++; |
8d2bec9e | 300 | while(fClusterIdx < kNclusters){ |
71ea19a3 | 301 | if(!(*fClusterIter)){ |
302 | fClusterIdx++; | |
303 | fClusterIter++; | |
304 | continue; | |
305 | } | |
306 | return *fClusterIter; | |
307 | } | |
4d6aee34 | 308 | return NULL; |
71ea19a3 | 309 | } |
310 | ||
311 | //____________________________________________________________ | |
312 | inline AliTRDcluster* AliTRDseedV1::PrevCluster() | |
313 | { | |
314 | // Mimic the usage of STL iterators. | |
315 | // Backward iterator | |
316 | ||
317 | fClusterIdx--; fClusterIter--; | |
318 | while(fClusterIdx >= 0){ | |
319 | if(!(*fClusterIter)){ | |
320 | fClusterIdx--; | |
321 | fClusterIter--; | |
322 | continue; | |
323 | } | |
324 | return *fClusterIter; | |
325 | } | |
4d6aee34 | 326 | return NULL; |
71ea19a3 | 327 | } |
328 | ||
329 | //____________________________________________________________ | |
330 | inline void AliTRDseedV1::ResetClusterIter(Bool_t forward) | |
331 | { | |
332 | // Mimic the usage of STL iterators. | |
333 | // Facilitate the usage of NextCluster for forward like | |
334 | // iterator (kTRUE) and PrevCluster for backward like iterator (kFALSE) | |
335 | ||
336 | if(forward){ | |
337 | fClusterIter = &fClusters[0]; fClusterIter--; | |
338 | fClusterIdx=-1; | |
339 | } else { | |
8d2bec9e | 340 | fClusterIter = &fClusters[kNclusters-1]; fClusterIter++; |
341 | fClusterIdx=kNclusters; | |
71ea19a3 | 342 | } |
ae4e8b84 | 343 | } |
344 | ||
16cca13f | 345 | //____________________________________________________________ |
346 | inline void AliTRDseedV1::SetCovRef(const Double_t *cov) | |
347 | { | |
348 | // Copy some "important" covariance matrix elements | |
349 | // var(y) | |
350 | // cov(y,z) var(z) | |
351 | // var(snp) | |
352 | // var(tgl) | |
353 | // cov(tgl, 1/pt) var(1/pt) | |
354 | ||
355 | memcpy(&fRefCov[0], cov, 3*sizeof(Double_t)); // yz full covariance | |
356 | fRefCov[3] = cov[ 5]; // snp variance | |
357 | fRefCov[4] = cov[ 9]; // tgl variance | |
358 | fRefCov[5] = cov[13]; // cov(tgl, 1/pt) | |
359 | fRefCov[6] = cov[14]; // 1/pt variance | |
360 | } | |
361 | ||
362 | ||
3e778975 | 363 | //____________________________________________________________ |
364 | inline void AliTRDseedV1::SetN(Int_t n) | |
365 | { | |
6ad5e6b2 | 366 | if(n<0 || n>kNclusters) return; |
980d5a2a | 367 | fN &= ~kMask; |
368 | fN |= (n&kMask); | |
3e778975 | 369 | } |
370 | ||
371 | //____________________________________________________________ | |
372 | inline void AliTRDseedV1::SetNUsed(Int_t n) | |
373 | { | |
6ad5e6b2 | 374 | if(n<0 || n>kNclusters) return; |
980d5a2a | 375 | UInt_t mask(kMask<<kNbits); |
6ad5e6b2 | 376 | fN &= ~mask; |
980d5a2a | 377 | n=n<<kNbits; fN |= (n&mask); |
3e778975 | 378 | } |
379 | ||
380 | //____________________________________________________________ | |
381 | inline void AliTRDseedV1::SetNShared(Int_t n) | |
382 | { | |
6ad5e6b2 | 383 | if(n<0 || n>kNclusters) return; |
980d5a2a | 384 | UInt_t mask((kMask<<kNbits)<<kNbits); |
6ad5e6b2 | 385 | fN &= ~mask; |
980d5a2a | 386 | n = (n<<kNbits)<<kNbits; fN|=(n&mask); |
3e778975 | 387 | } |
388 | ||
560e5c05 | 389 | //____________________________________________________________ |
4ecadb52 | 390 | inline void AliTRDseedV1::Swap(Int_t &n1, Int_t &n2) const |
560e5c05 | 391 | { |
392 | // swap values of n1 with n2 | |
393 | Int_t tmp(n1); | |
394 | n1=n2; n2=tmp; | |
395 | } | |
396 | ||
397 | //____________________________________________________________ | |
4ecadb52 | 398 | inline void AliTRDseedV1::Swap(Double_t &d1, Double_t &d2) const |
560e5c05 | 399 | { |
400 | // swap values of d1 with d2 | |
401 | Double_t tmp(d1); | |
402 | d1=d2; d2=tmp; | |
403 | } | |
404 | ||
3e778975 | 405 | |
e4f2f73d | 406 | #endif |
407 | ||
47d5d320 | 408 | |
6e49cfdb | 409 |