Line data Source code
1 : //---------------------------------------------------------------------------------
2 : // The AliKFParticle class
3 : // .
4 : // @author S.Gorbunov, I.Kisel
5 : // @version 1.0
6 : // @since 13.05.07
7 : //
8 : // Class to reconstruct and store the decayed particle parameters.
9 : // The method is described in CBM-SOFT note 2007-003,
10 : // ``Reconstruction of decayed particles based on the Kalman filter'',
11 : // http://www.gsi.de/documents/DOC-2007-May-14-1.pdf
12 : //
13 : // This class is ALICE interface to general mathematics in AliKFParticleBase
14 : //
15 : // -= Copyright © ALICE HLT Group =-
16 : //_________________________________________________________________________________
17 :
18 : #ifndef ALIKFPARTICLE_H
19 : #define ALIKFPARTICLE_H
20 :
21 : #include "AliKFParticleBase.h"
22 : #include "TMath.h"
23 :
24 : class AliVTrack;
25 : class AliVVertex;
26 : class AliExternalTrackParam;
27 :
28 112 : class AliKFParticle :public AliKFParticleBase
29 : {
30 :
31 : public:
32 :
33 : //*
34 : //* INITIALIZATION
35 : //*
36 :
37 : //* Set magnetic field for all particles
38 :
39 : static void SetField( Double_t Bz );
40 :
41 : //* Constructor (empty)
42 :
43 492 : AliKFParticle():AliKFParticleBase(){ ; }
44 :
45 : //* Destructor (empty)
46 :
47 1052 : ~AliKFParticle(){ ; }
48 :
49 : //* Construction of mother particle by its 2-3-4 daughters
50 :
51 : AliKFParticle( const AliKFParticle &d1, const AliKFParticle &d2, Bool_t gamma = kFALSE );
52 :
53 : AliKFParticle( const AliKFParticle &d1, const AliKFParticle &d2,
54 : const AliKFParticle &d3 );
55 :
56 : AliKFParticle( const AliKFParticle &d1, const AliKFParticle &d2,
57 : const AliKFParticle &d3, const AliKFParticle &d4 );
58 :
59 : //* Initialisation from "cartesian" coordinates ( X Y Z Px Py Pz )
60 : //* Parameters, covariance matrix, charge and PID hypothesis should be provided
61 :
62 : void Create( const Double_t Param[], const Double_t Cov[], Int_t Charge, Int_t PID );
63 : void Create( const Double_t Param[], const Double_t Cov[], Int_t Charge, Double_t Mass );
64 :
65 : //* Initialisation from ALICE track, PID hypothesis shoould be provided
66 :
67 : AliKFParticle( const AliVTrack &track, Int_t PID );
68 : AliKFParticle( const AliExternalTrackParam &track, Double_t Mass, Int_t Charge );
69 :
70 : //* Initialisation from VVertex
71 :
72 : AliKFParticle( const AliVVertex &vertex );
73 :
74 : //* Initialise covariance matrix and set current parameters to 0.0
75 :
76 : void Initialize();
77 :
78 : //* Set decay vertex parameters for linearisation
79 :
80 : void SetVtxGuess( Double_t x, Double_t y, Double_t z );
81 :
82 : //*
83 : //* ACCESSORS
84 : //*
85 :
86 : //* Simple accessors
87 :
88 : Double_t GetX () const ; //* x of current position
89 : Double_t GetY () const ; //* y of current position
90 : Double_t GetZ () const ; //* z of current position
91 : Double_t GetPx () const ; //* x-compoment of 3-momentum
92 : Double_t GetPy () const ; //* y-compoment of 3-momentum
93 : Double_t GetPz () const ; //* z-compoment of 3-momentum
94 : Double_t GetE () const ; //* energy
95 : Double_t GetS () const ; //* decay length / momentum
96 : Int_t GetQ () const ; //* charge
97 : Double_t GetChi2 () const ; //* chi^2
98 : Int_t GetNDF () const ; //* Number of Degrees of Freedom
99 :
100 0 : const Double_t& X () const { return fP[0]; }
101 0 : const Double_t& Y () const { return fP[1]; }
102 0 : const Double_t& Z () const { return fP[2]; }
103 0 : const Double_t& Px () const { return fP[3]; }
104 0 : const Double_t& Py () const { return fP[4]; }
105 0 : const Double_t& Pz () const { return fP[5]; }
106 0 : const Double_t& E () const { return fP[6]; }
107 0 : const Double_t& S () const { return fP[7]; }
108 0 : const Int_t & Q () const { return fQ; }
109 0 : const Double_t& Chi2 () const { return fChi2; }
110 0 : const Int_t & NDF () const { return fNDF; }
111 :
112 : Double_t GetParameter ( int i ) const ;
113 : Double_t GetCovariance( int i ) const ;
114 : Double_t GetCovariance( int i, int j ) const ;
115 :
116 : //* Accessors with calculations, value returned w/o error flag
117 :
118 : Double_t GetP () const; //* momentum
119 : Double_t GetPt () const; //* transverse momentum
120 : Double_t GetEta () const; //* pseudorapidity
121 : Double_t GetPhi () const; //* phi
122 : Double_t GetMomentum () const; //* momentum (same as GetP() )
123 : Double_t GetMass () const; //* mass
124 : Double_t GetDecayLength () const; //* decay length
125 : Double_t GetDecayLengthXY () const; //* decay length in XY
126 : Double_t GetLifeTime () const; //* life time
127 : Double_t GetR () const; //* distance to the origin
128 :
129 : //* Accessors to estimated errors
130 :
131 : Double_t GetErrX () const ; //* x of current position
132 : Double_t GetErrY () const ; //* y of current position
133 : Double_t GetErrZ () const ; //* z of current position
134 : Double_t GetErrPx () const ; //* x-compoment of 3-momentum
135 : Double_t GetErrPy () const ; //* y-compoment of 3-momentum
136 : Double_t GetErrPz () const ; //* z-compoment of 3-momentum
137 : Double_t GetErrE () const ; //* energy
138 : Double_t GetErrS () const ; //* decay length / momentum
139 : Double_t GetErrP () const ; //* momentum
140 : Double_t GetErrPt () const ; //* transverse momentum
141 : Double_t GetErrEta () const ; //* pseudorapidity
142 : Double_t GetErrPhi () const ; //* phi
143 : Double_t GetErrMomentum () const ; //* momentum
144 : Double_t GetErrMass () const ; //* mass
145 : Double_t GetErrDecayLength () const ; //* decay length
146 : Double_t GetErrDecayLengthXY () const ; //* decay length in XY
147 : Double_t GetErrLifeTime () const ; //* life time
148 : Double_t GetErrR () const ; //* distance to the origin
149 :
150 : //* Accessors with calculations( &value, &estimated sigma )
151 : //* error flag returned (0 means no error during calculations)
152 :
153 : int GetP ( Double_t &P, Double_t &SigmaP ) const ; //* momentum
154 : int GetPt ( Double_t &Pt, Double_t &SigmaPt ) const ; //* transverse momentum
155 : int GetEta ( Double_t &Eta, Double_t &SigmaEta ) const ; //* pseudorapidity
156 : int GetPhi ( Double_t &Phi, Double_t &SigmaPhi ) const ; //* phi
157 : int GetMomentum ( Double_t &P, Double_t &SigmaP ) const ; //* momentum
158 : int GetMass ( Double_t &M, Double_t &SigmaM ) const ; //* mass
159 : int GetDecayLength ( Double_t &L, Double_t &SigmaL ) const ; //* decay length
160 : int GetDecayLengthXY ( Double_t &L, Double_t &SigmaL ) const ; //* decay length in XY
161 : int GetLifeTime ( Double_t &T, Double_t &SigmaT ) const ; //* life time
162 : int GetR ( Double_t &R, Double_t &SigmaR ) const ; //* R
163 :
164 :
165 : //*
166 : //* MODIFIERS
167 : //*
168 :
169 : Double_t & X () ;
170 : Double_t & Y () ;
171 : Double_t & Z () ;
172 : Double_t & Px () ;
173 : Double_t & Py () ;
174 : Double_t & Pz () ;
175 : Double_t & E () ;
176 : Double_t & S () ;
177 : Int_t & Q () ;
178 : Double_t & Chi2 () ;
179 : Int_t & NDF () ;
180 :
181 : Double_t & Parameter ( int i ) ;
182 : Double_t & Covariance( int i ) ;
183 : Double_t & Covariance( int i, int j ) ;
184 : Double_t * Parameters () ;
185 : Double_t * CovarianceMatrix() ;
186 :
187 : //*
188 : //* CONSTRUCTION OF THE PARTICLE BY ITS DAUGHTERS AND MOTHER
189 : //* USING THE KALMAN FILTER METHOD
190 : //*
191 :
192 :
193 : //* Add daughter to the particle
194 :
195 : void AddDaughter( const AliKFParticle &Daughter );
196 :
197 : //* Add daughter via += operator: ex.{ D0; D0+=Pion; D0+= Kaon; }
198 :
199 : void operator +=( const AliKFParticle &Daughter );
200 :
201 : //* Set production vertex
202 :
203 : void SetProductionVertex( const AliKFParticle &Vtx );
204 :
205 : //* Set mass constraint
206 :
207 : void SetMassConstraint( Double_t Mass, Double_t SigmaMass = 0 );
208 :
209 : //* Set no decay length for resonances
210 :
211 : void SetNoDecayLength();
212 :
213 : //* Everything in one go
214 :
215 : void Construct( const AliKFParticle *vDaughters[], int NDaughters,
216 : const AliKFParticle *ProdVtx=0, Double_t Mass=-1, Bool_t IsConstrained=0 );
217 :
218 : //*
219 : //* TRANSPORT
220 : //*
221 : //* ( main transportation parameter is S = SignedPath/Momentum )
222 : //* ( parameters of decay & production vertices are stored locally )
223 : //*
224 :
225 : //* Transport the particle to its decay vertex
226 :
227 : void TransportToDecayVertex();
228 :
229 : //* Transport the particle to its production vertex
230 :
231 : void TransportToProductionVertex();
232 :
233 : //* Transport the particle close to xyz[] point
234 :
235 : void TransportToPoint( const Double_t xyz[] );
236 :
237 : //* Transport the particle close to VVertex
238 :
239 : void TransportToVertex( const AliVVertex &v );
240 :
241 : //* Transport the particle close to another particle p
242 :
243 : void TransportToParticle( const AliKFParticle &p );
244 :
245 : //* Transport the particle on dS parameter (SignedPath/Momentum)
246 :
247 : void TransportToDS( Double_t dS );
248 :
249 : //* Get dS to a certain space point
250 :
251 : Double_t GetDStoPoint( const Double_t xyz[] ) const ;
252 :
253 : //* Get dS to other particle p (dSp for particle p also returned)
254 :
255 : void GetDStoParticle( const AliKFParticle &p,
256 : Double_t &DS, Double_t &DSp ) const ;
257 :
258 : //* Get dS to other particle p in XY-plane
259 :
260 : void GetDStoParticleXY( const AliKFParticleBase &p,
261 : Double_t &DS, Double_t &DSp ) const ;
262 :
263 : //*
264 : //* OTHER UTILITIES
265 : //*
266 :
267 :
268 : //* Calculate distance from another object [cm]
269 :
270 : Double_t GetDistanceFromVertex( const Double_t vtx[] ) const ;
271 : Double_t GetDistanceFromVertex( const AliKFParticle &Vtx ) const ;
272 : Double_t GetDistanceFromVertex( const AliVVertex &Vtx ) const ;
273 : Double_t GetDistanceFromParticle( const AliKFParticle &p ) const ;
274 :
275 : //* Calculate sqrt(Chi2/ndf) deviation from another object
276 : //* ( v = [xyz]-vertex, Cv=[Cxx,Cxy,Cyy,Cxz,Cyz,Czz]-covariance matrix )
277 :
278 : Double_t GetDeviationFromVertex( const Double_t v[], const Double_t Cv[]=0 ) const ;
279 : Double_t GetDeviationFromVertex( const AliKFParticle &Vtx ) const ;
280 : Double_t GetDeviationFromVertex( const AliVVertex &Vtx ) const ;
281 : Double_t GetDeviationFromParticle( const AliKFParticle &p ) const ;
282 :
283 : //* Calculate distance from another object [cm] in XY-plane
284 :
285 : Bool_t GetDistanceFromVertexXY( const Double_t vtx[], Double_t &val, Double_t &err ) const ;
286 : Bool_t GetDistanceFromVertexXY( const Double_t vtx[], const Double_t Cv[], Double_t &val, Double_t &err ) const ;
287 : Bool_t GetDistanceFromVertexXY( const AliKFParticle &Vtx, Double_t &val, Double_t &err ) const ;
288 : Bool_t GetDistanceFromVertexXY( const AliVVertex &Vtx, Double_t &val, Double_t &err ) const ;
289 :
290 : Double_t GetDistanceFromVertexXY( const Double_t vtx[] ) const ;
291 : Double_t GetDistanceFromVertexXY( const AliKFParticle &Vtx ) const ;
292 : Double_t GetDistanceFromVertexXY( const AliVVertex &Vtx ) const ;
293 : Double_t GetDistanceFromParticleXY( const AliKFParticle &p ) const ;
294 :
295 : //* Calculate sqrt(Chi2/ndf) deviation from another object in XY plane
296 : //* ( v = [xyz]-vertex, Cv=[Cxx,Cxy,Cyy,Cxz,Cyz,Czz]-covariance matrix )
297 :
298 : Double_t GetDeviationFromVertexXY( const Double_t v[], const Double_t Cv[]=0 ) const ;
299 : Double_t GetDeviationFromVertexXY( const AliKFParticle &Vtx ) const ;
300 : Double_t GetDeviationFromVertexXY( const AliVVertex &Vtx ) const ;
301 : Double_t GetDeviationFromParticleXY( const AliKFParticle &p ) const ;
302 :
303 : //* Calculate opennig angle between two particles
304 :
305 : Double_t GetAngle ( const AliKFParticle &p ) const ;
306 : Double_t GetAngleXY( const AliKFParticle &p ) const ;
307 : Double_t GetAngleRZ( const AliKFParticle &p ) const ;
308 :
309 : //* Subtract the particle from the vertex
310 :
311 : void SubtractFromVertex( AliKFParticle &v ) const ;
312 :
313 : //* Special method for creating gammas
314 :
315 : void ConstructGamma( const AliKFParticle &daughter1,
316 : const AliKFParticle &daughter2 );
317 :
318 : // * Pseudo Proper Time of decay = (r*pt) / |pt| * M/|pt|
319 : // @primVertex - primary vertex
320 : // @mass - mass of the mother particle (in the case of "Hb -> JPsi" it would be JPsi mass)
321 : // @*timeErr2 - squared error of the decay time. If timeErr2 = 0 it isn't calculated
322 : Double_t GetPseudoProperDecayTime( const AliKFParticle &primVertex, const Double_t& mass, Double_t* timeErr2 = 0 ) const;
323 :
324 : protected:
325 :
326 : //*
327 : //* INTERNAL STUFF
328 : //*
329 :
330 : //* Method to access ALICE field
331 :
332 : static Double_t GetFieldAlice();
333 :
334 : //* Other methods required by the abstract AliKFParticleBase class
335 :
336 : void GetFieldValue( const Double_t xyz[], Double_t B[] ) const ;
337 : void GetDStoParticle( const AliKFParticleBase &p, Double_t &DS, Double_t &DSp )const ;
338 : void Transport( Double_t dS, Double_t P[], Double_t C[] ) const ;
339 : static void GetExternalTrackParam( const AliKFParticleBase &p, Double_t &X, Double_t &Alpha, Double_t P[5] ) ;
340 :
341 : //void GetDStoParticleALICE( const AliKFParticleBase &p, Double_t &DS, Double_t &DS1 ) const;
342 :
343 :
344 : private:
345 :
346 : static Double_t fgBz; //* Bz compoment of the magnetic field
347 :
348 172 : ClassDef( AliKFParticle, 1 );
349 :
350 : };
351 :
352 :
353 :
354 : //---------------------------------------------------------------------
355 : //
356 : // Inline implementation of the AliKFParticle methods
357 : //
358 : //---------------------------------------------------------------------
359 :
360 :
361 : inline void AliKFParticle::SetField( Double_t Bz )
362 : {
363 0 : fgBz = Bz;
364 0 : }
365 :
366 0 : inline AliKFParticle::AliKFParticle( const AliKFParticle &d1,
367 : const AliKFParticle &d2,
368 : const AliKFParticle &d3 )
369 0 : {
370 0 : AliKFParticle mother;
371 0 : mother+= d1;
372 0 : mother+= d2;
373 0 : mother+= d3;
374 0 : *this = mother;
375 0 : }
376 :
377 0 : inline AliKFParticle::AliKFParticle( const AliKFParticle &d1,
378 : const AliKFParticle &d2,
379 : const AliKFParticle &d3,
380 : const AliKFParticle &d4 )
381 0 : {
382 0 : AliKFParticle mother;
383 0 : mother+= d1;
384 0 : mother+= d2;
385 0 : mother+= d3;
386 0 : mother+= d4;
387 0 : *this = mother;
388 0 : }
389 :
390 :
391 : inline void AliKFParticle::Initialize()
392 : {
393 36 : AliKFParticleBase::Initialize();
394 18 : }
395 :
396 : inline void AliKFParticle::SetVtxGuess( Double_t x, Double_t y, Double_t z )
397 : {
398 0 : AliKFParticleBase::SetVtxGuess(x,y,z);
399 0 : }
400 :
401 : inline Double_t AliKFParticle::GetX () const
402 : {
403 0 : return AliKFParticleBase::GetX();
404 : }
405 :
406 : inline Double_t AliKFParticle::GetY () const
407 : {
408 0 : return AliKFParticleBase::GetY();
409 : }
410 :
411 : inline Double_t AliKFParticle::GetZ () const
412 : {
413 0 : return AliKFParticleBase::GetZ();
414 : }
415 :
416 : inline Double_t AliKFParticle::GetPx () const
417 : {
418 0 : return AliKFParticleBase::GetPx();
419 : }
420 :
421 : inline Double_t AliKFParticle::GetPy () const
422 : {
423 0 : return AliKFParticleBase::GetPy();
424 : }
425 :
426 : inline Double_t AliKFParticle::GetPz () const
427 : {
428 0 : return AliKFParticleBase::GetPz();
429 : }
430 :
431 : inline Double_t AliKFParticle::GetE () const
432 : {
433 0 : return AliKFParticleBase::GetE();
434 : }
435 :
436 : inline Double_t AliKFParticle::GetS () const
437 : {
438 8 : return AliKFParticleBase::GetS();
439 : }
440 :
441 : inline Int_t AliKFParticle::GetQ () const
442 : {
443 0 : return AliKFParticleBase::GetQ();
444 : }
445 :
446 : inline Double_t AliKFParticle::GetChi2 () const
447 : {
448 148 : return AliKFParticleBase::GetChi2();
449 : }
450 :
451 : inline Int_t AliKFParticle::GetNDF () const
452 : {
453 296 : return AliKFParticleBase::GetNDF();
454 : }
455 :
456 : inline Double_t AliKFParticle::GetParameter ( int i ) const
457 : {
458 0 : return AliKFParticleBase::GetParameter(i);
459 : }
460 :
461 : inline Double_t AliKFParticle::GetCovariance( int i ) const
462 : {
463 0 : return AliKFParticleBase::GetCovariance(i);
464 : }
465 :
466 : inline Double_t AliKFParticle::GetCovariance( int i, int j ) const
467 : {
468 0 : return AliKFParticleBase::GetCovariance(i,j);
469 : }
470 :
471 :
472 : inline Double_t AliKFParticle::GetP () const
473 : {
474 0 : Double_t par, err;
475 0 : if( AliKFParticleBase::GetMomentum( par, err ) ) return 0;
476 0 : else return par;
477 0 : }
478 :
479 : inline Double_t AliKFParticle::GetPt () const
480 : {
481 0 : Double_t par, err;
482 0 : if( AliKFParticleBase::GetPt( par, err ) ) return 0;
483 0 : else return par;
484 0 : }
485 :
486 : inline Double_t AliKFParticle::GetEta () const
487 : {
488 0 : Double_t par, err;
489 0 : if( AliKFParticleBase::GetEta( par, err ) ) return 0;
490 0 : else return par;
491 0 : }
492 :
493 : inline Double_t AliKFParticle::GetPhi () const
494 : {
495 0 : Double_t par, err;
496 0 : if( AliKFParticleBase::GetPhi( par, err ) ) return 0;
497 0 : else return par;
498 0 : }
499 :
500 : inline Double_t AliKFParticle::GetMomentum () const
501 : {
502 0 : Double_t par, err;
503 0 : if( AliKFParticleBase::GetMomentum( par, err ) ) return 0;
504 0 : else return par;
505 0 : }
506 :
507 : inline Double_t AliKFParticle::GetMass () const
508 : {
509 0 : Double_t par, err;
510 0 : if( AliKFParticleBase::GetMass( par, err ) ) return 0;
511 0 : else return par;
512 0 : }
513 :
514 : inline Double_t AliKFParticle::GetDecayLength () const
515 : {
516 0 : Double_t par, err;
517 0 : if( AliKFParticleBase::GetDecayLength( par, err ) ) return 0;
518 0 : else return par;
519 0 : }
520 :
521 : inline Double_t AliKFParticle::GetDecayLengthXY () const
522 : {
523 0 : Double_t par, err;
524 0 : if( AliKFParticleBase::GetDecayLengthXY( par, err ) ) return 0;
525 0 : else return par;
526 0 : }
527 :
528 : inline Double_t AliKFParticle::GetLifeTime () const
529 : {
530 0 : Double_t par, err;
531 0 : if( AliKFParticleBase::GetLifeTime( par, err ) ) return 0;
532 0 : else return par;
533 0 : }
534 :
535 : inline Double_t AliKFParticle::GetR () const
536 : {
537 0 : Double_t par, err;
538 0 : if( AliKFParticleBase::GetR( par, err ) ) return 0;
539 0 : else return par;
540 0 : }
541 :
542 : inline Double_t AliKFParticle::GetErrX () const
543 : {
544 0 : return TMath::Sqrt(TMath::Abs( GetCovariance(0,0) ));
545 : }
546 :
547 : inline Double_t AliKFParticle::GetErrY () const
548 : {
549 0 : return TMath::Sqrt(TMath::Abs( GetCovariance(1,1) ));
550 : }
551 :
552 : inline Double_t AliKFParticle::GetErrZ () const
553 : {
554 0 : return TMath::Sqrt(TMath::Abs( GetCovariance(2,2) ));
555 : }
556 :
557 : inline Double_t AliKFParticle::GetErrPx () const
558 : {
559 0 : return TMath::Sqrt(TMath::Abs( GetCovariance(3,3) ));
560 : }
561 :
562 : inline Double_t AliKFParticle::GetErrPy () const
563 : {
564 0 : return TMath::Sqrt(TMath::Abs( GetCovariance(4,4) ));
565 : }
566 :
567 : inline Double_t AliKFParticle::GetErrPz () const
568 : {
569 0 : return TMath::Sqrt(TMath::Abs( GetCovariance(5,5) ));
570 : }
571 :
572 : inline Double_t AliKFParticle::GetErrE () const
573 : {
574 0 : return TMath::Sqrt(TMath::Abs( GetCovariance(6,6) ));
575 : }
576 :
577 : inline Double_t AliKFParticle::GetErrS () const
578 : {
579 0 : return TMath::Sqrt(TMath::Abs( GetCovariance(7,7) ));
580 : }
581 :
582 : inline Double_t AliKFParticle::GetErrP () const
583 : {
584 0 : Double_t par, err;
585 0 : if( AliKFParticleBase::GetMomentum( par, err ) ) return 1.e10;
586 0 : else return err;
587 0 : }
588 :
589 : inline Double_t AliKFParticle::GetErrPt () const
590 : {
591 0 : Double_t par, err;
592 0 : if( AliKFParticleBase::GetPt( par, err ) ) return 1.e10;
593 0 : else return err;
594 0 : }
595 :
596 : inline Double_t AliKFParticle::GetErrEta () const
597 : {
598 0 : Double_t par, err;
599 0 : if( AliKFParticleBase::GetEta( par, err ) ) return 1.e10;
600 0 : else return err;
601 0 : }
602 :
603 : inline Double_t AliKFParticle::GetErrPhi () const
604 : {
605 0 : Double_t par, err;
606 0 : if( AliKFParticleBase::GetPhi( par, err ) ) return 1.e10;
607 0 : else return err;
608 0 : }
609 :
610 : inline Double_t AliKFParticle::GetErrMomentum () const
611 : {
612 0 : Double_t par, err;
613 0 : if( AliKFParticleBase::GetMomentum( par, err ) ) return 1.e10;
614 0 : else return err;
615 0 : }
616 :
617 : inline Double_t AliKFParticle::GetErrMass () const
618 : {
619 0 : Double_t par, err;
620 0 : if( AliKFParticleBase::GetMass( par, err ) ) return 1.e10;
621 0 : else return err;
622 0 : }
623 :
624 : inline Double_t AliKFParticle::GetErrDecayLength () const
625 : {
626 0 : Double_t par, err;
627 0 : if( AliKFParticleBase::GetDecayLength( par, err ) ) return 1.e10;
628 0 : else return err;
629 0 : }
630 :
631 : inline Double_t AliKFParticle::GetErrDecayLengthXY () const
632 : {
633 0 : Double_t par, err;
634 0 : if( AliKFParticleBase::GetDecayLengthXY( par, err ) ) return 1.e10;
635 0 : else return err;
636 0 : }
637 :
638 : inline Double_t AliKFParticle::GetErrLifeTime () const
639 : {
640 0 : Double_t par, err;
641 0 : if( AliKFParticleBase::GetLifeTime( par, err ) ) return 1.e10;
642 0 : else return err;
643 0 : }
644 :
645 : inline Double_t AliKFParticle::GetErrR () const
646 : {
647 0 : Double_t par, err;
648 0 : if( AliKFParticleBase::GetR( par, err ) ) return 1.e10;
649 0 : else return err;
650 0 : }
651 :
652 :
653 : inline int AliKFParticle::GetP( Double_t &P, Double_t &SigmaP ) const
654 : {
655 0 : return AliKFParticleBase::GetMomentum( P, SigmaP );
656 : }
657 :
658 : inline int AliKFParticle::GetPt( Double_t &Pt, Double_t &SigmaPt ) const
659 : {
660 0 : return AliKFParticleBase::GetPt( Pt, SigmaPt );
661 : }
662 :
663 : inline int AliKFParticle::GetEta( Double_t &Eta, Double_t &SigmaEta ) const
664 : {
665 0 : return AliKFParticleBase::GetEta( Eta, SigmaEta );
666 : }
667 :
668 : inline int AliKFParticle::GetPhi( Double_t &Phi, Double_t &SigmaPhi ) const
669 : {
670 0 : return AliKFParticleBase::GetPhi( Phi, SigmaPhi );
671 : }
672 :
673 : inline int AliKFParticle::GetMomentum( Double_t &P, Double_t &SigmaP ) const
674 : {
675 0 : return AliKFParticleBase::GetMomentum( P, SigmaP );
676 : }
677 :
678 : inline int AliKFParticle::GetMass( Double_t &M, Double_t &SigmaM ) const
679 : {
680 36 : return AliKFParticleBase::GetMass( M, SigmaM );
681 : }
682 :
683 : inline int AliKFParticle::GetDecayLength( Double_t &L, Double_t &SigmaL ) const
684 : {
685 0 : return AliKFParticleBase::GetDecayLength( L, SigmaL );
686 : }
687 :
688 : inline int AliKFParticle::GetDecayLengthXY( Double_t &L, Double_t &SigmaL ) const
689 : {
690 0 : return AliKFParticleBase::GetDecayLengthXY( L, SigmaL );
691 : }
692 :
693 : inline int AliKFParticle::GetLifeTime( Double_t &T, Double_t &SigmaT ) const
694 : {
695 0 : return AliKFParticleBase::GetLifeTime( T, SigmaT );
696 : }
697 :
698 : inline int AliKFParticle::GetR( Double_t &R, Double_t &SigmaR ) const
699 : {
700 0 : return AliKFParticleBase::GetR( R, SigmaR );
701 : }
702 :
703 : inline Double_t & AliKFParticle::X()
704 : {
705 44 : return AliKFParticleBase::X();
706 : }
707 :
708 : inline Double_t & AliKFParticle::Y()
709 : {
710 44 : return AliKFParticleBase::Y();
711 : }
712 :
713 : inline Double_t & AliKFParticle::Z()
714 : {
715 44 : return AliKFParticleBase::Z();
716 : }
717 :
718 : inline Double_t & AliKFParticle::Px()
719 : {
720 0 : return AliKFParticleBase::Px();
721 : }
722 :
723 : inline Double_t & AliKFParticle::Py()
724 : {
725 0 : return AliKFParticleBase::Py();
726 : }
727 :
728 : inline Double_t & AliKFParticle::Pz()
729 : {
730 0 : return AliKFParticleBase::Pz();
731 : }
732 :
733 : inline Double_t & AliKFParticle::E()
734 : {
735 0 : return AliKFParticleBase::E();
736 : }
737 :
738 : inline Double_t & AliKFParticle::S()
739 : {
740 0 : return AliKFParticleBase::S();
741 : }
742 :
743 : inline Int_t & AliKFParticle::Q()
744 : {
745 0 : return AliKFParticleBase::Q();
746 : }
747 :
748 : inline Double_t & AliKFParticle::Chi2()
749 : {
750 0 : return AliKFParticleBase::Chi2();
751 : }
752 :
753 : inline Int_t & AliKFParticle::NDF()
754 : {
755 0 : return AliKFParticleBase::NDF();
756 : }
757 :
758 : inline Double_t & AliKFParticle::Parameter ( int i )
759 : {
760 0 : return AliKFParticleBase::Parameter(i);
761 : }
762 :
763 : inline Double_t & AliKFParticle::Covariance( int i )
764 : {
765 0 : return AliKFParticleBase::Covariance(i);
766 : }
767 :
768 : inline Double_t & AliKFParticle::Covariance( int i, int j )
769 : {
770 132 : return AliKFParticleBase::Covariance(i,j);
771 : }
772 :
773 : inline Double_t * AliKFParticle::Parameters ()
774 : {
775 0 : return fP;
776 : }
777 :
778 : inline Double_t * AliKFParticle::CovarianceMatrix()
779 : {
780 0 : return fC;
781 : }
782 :
783 :
784 : inline void AliKFParticle::operator +=( const AliKFParticle &Daughter )
785 : {
786 296 : AliKFParticleBase::operator +=( Daughter );
787 148 : }
788 :
789 :
790 : inline void AliKFParticle::AddDaughter( const AliKFParticle &Daughter )
791 : {
792 0 : AliKFParticleBase::AddDaughter( Daughter );
793 0 : }
794 :
795 : inline void AliKFParticle::SetProductionVertex( const AliKFParticle &Vtx )
796 : {
797 148 : AliKFParticleBase::SetProductionVertex( Vtx );
798 74 : }
799 :
800 : inline void AliKFParticle::SetMassConstraint( Double_t Mass, Double_t SigmaMass )
801 : {
802 36 : AliKFParticleBase::SetMassConstraint( Mass, SigmaMass );
803 18 : }
804 :
805 : inline void AliKFParticle::SetNoDecayLength()
806 : {
807 0 : AliKFParticleBase::SetNoDecayLength();
808 0 : }
809 :
810 : inline void AliKFParticle::Construct( const AliKFParticle *vDaughters[], int NDaughters,
811 : const AliKFParticle *ProdVtx, Double_t Mass, Bool_t IsConstrained )
812 : {
813 0 : AliKFParticleBase::Construct( ( const AliKFParticleBase**)vDaughters, NDaughters,
814 0 : ( const AliKFParticleBase*)ProdVtx, Mass, IsConstrained );
815 0 : }
816 :
817 : inline void AliKFParticle::TransportToDecayVertex()
818 : {
819 0 : AliKFParticleBase::TransportToDecayVertex();
820 0 : }
821 :
822 : inline void AliKFParticle::TransportToProductionVertex()
823 : {
824 0 : AliKFParticleBase::TransportToProductionVertex();
825 0 : }
826 :
827 : inline void AliKFParticle::TransportToPoint( const Double_t xyz[] )
828 : {
829 0 : TransportToDS( GetDStoPoint(xyz) );
830 0 : }
831 :
832 : inline void AliKFParticle::TransportToVertex( const AliVVertex &v )
833 : {
834 0 : TransportToPoint( AliKFParticle(v).fP );
835 0 : }
836 :
837 : inline void AliKFParticle::TransportToParticle( const AliKFParticle &p )
838 : {
839 0 : Double_t dS, dSp;
840 0 : GetDStoParticle( p, dS, dSp );
841 0 : TransportToDS( dS );
842 0 : }
843 :
844 : inline void AliKFParticle::TransportToDS( Double_t dS )
845 : {
846 0 : AliKFParticleBase::TransportToDS( dS );
847 0 : }
848 :
849 : inline Double_t AliKFParticle::GetDStoPoint( const Double_t xyz[] ) const
850 : {
851 1036 : return AliKFParticleBase::GetDStoPointBz( GetFieldAlice(), xyz );
852 : }
853 :
854 :
855 : inline void AliKFParticle::GetDStoParticle( const AliKFParticle &p,
856 : Double_t &DS, Double_t &DSp ) const
857 : {
858 0 : GetDStoParticleXY( p, DS, DSp );
859 0 : }
860 :
861 :
862 : inline Double_t AliKFParticle::GetDistanceFromVertex( const Double_t vtx[] ) const
863 : {
864 0 : return AliKFParticleBase::GetDistanceFromVertex( vtx );
865 : }
866 :
867 : inline Double_t AliKFParticle::GetDeviationFromVertex( const Double_t v[],
868 : const Double_t Cv[] ) const
869 : {
870 0 : return AliKFParticleBase::GetDeviationFromVertex( v, Cv);
871 : }
872 :
873 : inline Double_t AliKFParticle::GetDistanceFromVertex( const AliKFParticle &Vtx ) const
874 : {
875 0 : return AliKFParticleBase::GetDistanceFromVertex( Vtx );
876 : }
877 :
878 : inline Double_t AliKFParticle::GetDeviationFromVertex( const AliKFParticle &Vtx ) const
879 : {
880 0 : return AliKFParticleBase::GetDeviationFromVertex( Vtx );
881 : }
882 :
883 : inline Double_t AliKFParticle::GetDistanceFromVertex( const AliVVertex &Vtx ) const
884 : {
885 0 : return GetDistanceFromVertex( AliKFParticle(Vtx) );
886 0 : }
887 :
888 : inline Double_t AliKFParticle::GetDeviationFromVertex( const AliVVertex &Vtx ) const
889 : {
890 0 : return GetDeviationFromVertex( AliKFParticle(Vtx) );
891 0 : }
892 :
893 : inline Double_t AliKFParticle::GetDistanceFromParticle( const AliKFParticle &p ) const
894 : {
895 0 : return AliKFParticleBase::GetDistanceFromParticle( p );
896 : }
897 :
898 : inline Double_t AliKFParticle::GetDeviationFromParticle( const AliKFParticle &p ) const
899 : {
900 0 : return AliKFParticleBase::GetDeviationFromParticle( p );
901 : }
902 :
903 : inline void AliKFParticle::SubtractFromVertex( AliKFParticle &v ) const
904 : {
905 0 : AliKFParticleBase::SubtractFromVertex( v );
906 0 : }
907 :
908 : inline Double_t AliKFParticle::GetFieldAlice()
909 : {
910 4292 : return fgBz;
911 : }
912 :
913 : inline void AliKFParticle::GetFieldValue( const Double_t * /*xyz*/, Double_t B[] ) const
914 : {
915 1628 : B[0] = B[1] = 0;
916 814 : B[2] = GetFieldAlice();
917 814 : }
918 :
919 : inline void AliKFParticle::GetDStoParticle( const AliKFParticleBase &p,
920 : Double_t &DS, Double_t &DSp )const
921 : {
922 148 : GetDStoParticleXY( p, DS, DSp );
923 74 : }
924 :
925 : inline void AliKFParticle::GetDStoParticleXY( const AliKFParticleBase &p,
926 : Double_t &DS, Double_t &DSp ) const
927 : {
928 148 : AliKFParticleBase::GetDStoParticleBz( GetFieldAlice(), p, DS, DSp ) ;
929 : //GetDStoParticleALICE( p, DS, DSp ) ;
930 74 : }
931 :
932 : inline void AliKFParticle::Transport( Double_t dS, Double_t P[], Double_t C[] ) const
933 : {
934 1480 : AliKFParticleBase::TransportBz( GetFieldAlice(), dS, P, C );
935 740 : }
936 :
937 : inline void AliKFParticle::ConstructGamma( const AliKFParticle &daughter1,
938 : const AliKFParticle &daughter2 )
939 : {
940 0 : AliKFParticleBase::ConstructGammaBz( daughter1, daughter2, GetFieldAlice() );
941 0 : }
942 :
943 : #endif
|
