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