FairRoot/PandaRoot: KFParticleBase Class Reference

Int_t i

Definition: run_full.C:25

KFParticleBase::IJ

static Int_t IJ(Int_t i, Int_t j)

Definition: KFParticleBase.h:281

Double_t fC[36]

Definition: KFParticleBase.h:307

void KFParticleBase::Construct	(	const KFParticleBase *	vDaughters[],
		Int_t	nDaughters,
		const KFParticleBase *	ProdVtx = `0`,
		Double_t	Mass = `-1`,
		Bool_t	IsConstrained = `0`
	)

Definition at line 1477 of file KFParticleBase.cxx.

References AddDaughter(), C(), Double_t, fAtProductionVertex, fC, fChi2, fIsLinearized, fNDF, fP, fQ, fSFromDecay, fVtxGuess, GetDStoParticle(), i, P, SetMassConstraint(), SetProductionVertex(), SumDaughterMass, and Transport().

Referenced by KFParticle::Construct().

 { 
   //* Full reconstruction in one go
 
   Int_t maxIter = 1;
   bool wasLinearized = fIsLinearized;
   if( !fIsLinearized || IsConstrained ){
     //fVtxGuess[0] = fVtxGuess[1] = fVtxGuess[2] = 0;  //!!!!
     Double_t ds=0., ds1=0.;
     Double_t P[8], C[36];
     vDaughters[0]->GetDStoParticle(*vDaughters[1], ds, ds1);
     vDaughters[0]->Transport(ds,P,C);
     fVtxGuess[0] = P[0];
     fVtxGuess[1] = P[1];
     fVtxGuess[2] = P[2];
 /*    fVtxGuess[0] = GetX();
     fVtxGuess[1] = GetY();
     fVtxGuess[2] = GetZ();*/
 
     fIsLinearized = 1;
     maxIter = 3;
   }
 
   Double_t constraintC[6];
 
   if( IsConstrained ){
     for(Int_t i=0;i<6;++i) constraintC[i]=fC[i];
   } else {
     for(Int_t i=0;i<6;++i) constraintC[i]=0.;
 //    constraintC[0] = constraintC[2] = constraintC[5] = 100.;
     constraintC[0] = 100.*vDaughters[0]->fC[0];
     constraintC[2] = 100.*vDaughters[0]->fC[2];
     constraintC[5] = 100.*vDaughters[0]->fC[5];
   }
 
 
   for( Int_t iter=0; iter<maxIter; iter++ ){
     fAtProductionVertex = 0;
     fSFromDecay = 0;
     fP[0] = fVtxGuess[0];
     fP[1] = fVtxGuess[1];
     fP[2] = fVtxGuess[2];
     fP[3] = 0;
     fP[4] = 0;
     fP[5] = 0;
     fP[6] = 0;
     fP[7] = 0;
     SumDaughterMass = 0;
 
     for(Int_t i=0;i<6; ++i) fC[i]=constraintC[i];
     for(Int_t i=6;i<36;++i) fC[i]=0.;
     fC[35] = 1.;
     
     fNDF  = IsConstrained ?0 :-3;
     fChi2 =  0.;
     fQ = 0;
 
     for( Int_t itr =0; itr<nDaughters; itr++ ){
       AddDaughter( *vDaughters[itr] );    
     }
     if( iter<maxIter-1){
       for( Int_t i=0; i<3; i++ ) fVtxGuess[i] = fP[i];  
     }
   }
   fIsLinearized = wasLinearized;    
 
   if( Mass>=0 ) SetMassConstraint( Mass );
   if( Parent ) SetProductionVertex( *Parent );
 }

void KFParticleBase::ConstructGammaBz	(	const KFParticleBase &	daughter1,
		const KFParticleBase &	daughter2,
		double	Bz
	)

Definition at line 2821 of file KFParticleBase.cxx.

References d0, Double_t, fAtProductionVertex, fC, fChi2, fIsLinearized, fNDF, fP, fQ, fSFromDecay, fVtxGuess, GetDStoParticle(), GetDStoPoint(), GetMeasurement(), GetQ(), i, IJ(), InvertSym3(), m, p, r, SetNonlinearMassConstraint(), sqrt(), Transport(), and z.

Referenced by KFParticle::ConstructGamma().

 { 
   //* Create gamma
   
   const KFParticleBase *daughters[2] = { &daughter1, &daughter2};
 
   double v0[3];
   
   if( !fIsLinearized ){
     Double_t ds, ds1;
     Double_t m[8];
     Double_t mCd[36];       
     daughter1.GetDStoParticle(daughter2, ds, ds1);      
     daughter1.Transport( ds, m, mCd );
     fP[0] = m[0];
     fP[1] = m[1];
     fP[2] = m[2];
     daughter2.Transport( ds1, m, mCd );
     fP[0] = .5*( fP[0] + m[0] );
     fP[1] = .5*( fP[1] + m[1] );
     fP[2] = .5*( fP[2] + m[2] );
   } else {
     fP[0] = fVtxGuess[0];
     fP[1] = fVtxGuess[1];
     fP[2] = fVtxGuess[2];
   }
 
   double daughterP[2][8], daughterC[2][36];
   double vtxMom[2][3];
 
   int nIter = fIsLinearized ?1 :2;
 
   for( int iter=0; iter<nIter; iter++){
 
     v0[0] = fP[0];
     v0[1] = fP[1];
     v0[2] = fP[2];
     
     fAtProductionVertex = 0;
     fSFromDecay = 0;
     fP[0] = v0[0];
     fP[1] = v0[1];
     fP[2] = v0[2];
     fP[3] = 0;
     fP[4] = 0;
     fP[5] = 0;
     fP[6] = 0;
     fP[7] = 0;
 
   
     // fit daughters to the vertex guess  
     
     {  
       for( int id=0; id<2; id++ ){
         
         double *p = daughterP[id];
         double *mC = daughterC[id];
         
         daughters[id]->GetMeasurement( v0, p, mC );
         
         Double_t mAi[6];
         InvertSym3(mC, mAi );
         
         Double_t mB[3][3];
         
         mB[0][0] = mC[ 6]*mAi[0] + mC[ 7]*mAi[1] + mC[ 8]*mAi[3];
         mB[0][1] = mC[ 6]*mAi[1] + mC[ 7]*mAi[2] + mC[ 8]*mAi[4];
         mB[0][2] = mC[ 6]*mAi[3] + mC[ 7]*mAi[4] + mC[ 8]*mAi[5];
         
         mB[1][0] = mC[10]*mAi[0] + mC[11]*mAi[1] + mC[12]*mAi[3];
         mB[1][1] = mC[10]*mAi[1] + mC[11]*mAi[2] + mC[12]*mAi[4];
         mB[1][2] = mC[10]*mAi[3] + mC[11]*mAi[4] + mC[12]*mAi[5];
         
         mB[2][0] = mC[15]*mAi[0] + mC[16]*mAi[1] + mC[17]*mAi[3];
         mB[2][1] = mC[15]*mAi[1] + mC[16]*mAi[2] + mC[17]*mAi[4];
         mB[2][2] = mC[15]*mAi[3] + mC[16]*mAi[4] + mC[17]*mAi[5];
         
         Double_t z[3] = { v0[0]-p[0], v0[1]-p[1], v0[2]-p[2] };
         
         vtxMom[id][0] = p[3] + mB[0][0]*z[0] + mB[0][1]*z[1] + mB[0][2]*z[2];
         vtxMom[id][1] = p[4] + mB[1][0]*z[0] + mB[1][1]*z[1] + mB[1][2]*z[2];
         vtxMom[id][2] = p[5] + mB[2][0]*z[0] + mB[2][1]*z[1] + mB[2][2]*z[2];
         
         daughters[id]->Transport( daughters[id]->GetDStoPoint(v0), p, mC );
       
       }      
       
     } // fit daughters to guess
 
     
     // fit new vertex
     {
       
       double mpx0 =  vtxMom[0][0]+vtxMom[1][0];
       double mpy0 =  vtxMom[0][1]+vtxMom[1][1];
       double mpt0 = sqrt(mpx0*mpx0 + mpy0*mpy0);
       // double a0 = atan2(mpy0,mpx0);
       
       double ca0 = mpx0/mpt0;
       double sa0 = mpy0/mpt0;
       double r[3] = { v0[0], v0[1], v0[2] };
       double mC[3][3] = {{1000., 0 ,   0  },
                          {0,  1000.,   0  },
                          {0,     0, 1000. } };
       double chi2=0;
       
       for( int id=0; id<2; id++ ){              
         const Double_t kCLight = 0.000299792458;
         Double_t q = Bz*daughters[id]->GetQ()*kCLight;
         Double_t px0 = vtxMom[id][0];
         Double_t py0 = vtxMom[id][1];
         Double_t pz0 = vtxMom[id][2];
         Double_t pt0 = sqrt(px0*px0+py0*py0);
         Double_t mG[3][6], mB[3], mH[3][3];
         // r = {vx,vy,vz};
         // m = {x,y,z,Px,Py,Pz};
         // V = daughter.C
         // G*m + B = H*r;
         // q*x + Py - q*vx - sin(a)*Pt = 0
         // q*y - Px - q*vy + cos(a)*Pt = 0
         // (Px*cos(a) + Py*sin(a) ) (vz -z) - Pz( cos(a)*(vx-x) + sin(a)*(vy-y)) = 0
         
         mG[0][0] = q;
         mG[0][1] = 0;
         mG[0][2] = 0;
         mG[0][3] =   -sa0*px0/pt0;
         mG[0][4] = 1 -sa0*py0/pt0;
         mG[0][5] = 0;   
         mH[0][0] = q;
         mH[0][1] = 0;
         mH[0][2] = 0;      
         mB[0] = py0 - sa0*pt0 - mG[0][3]*px0 - mG[0][4]*py0 ;
         
         // q*y - Px - q*vy + cos(a)*Pt = 0
         
         mG[1][0] = 0;
         mG[1][1] = q;
         mG[1][2] = 0;
         mG[1][3] = -1 + ca0*px0/pt0;
         mG[1][4] =    + ca0*py0/pt0;
         mG[1][5] = 0;      
         mH[1][0] = 0;
         mH[1][1] = q;
         mH[1][2] = 0;      
         mB[1] = -px0 + ca0*pt0 - mG[1][3]*px0 - mG[1][4]*py0 ;
         
         // (Px*cos(a) + Py*sin(a) ) (z -vz) - Pz( cos(a)*(x-vx) + sin(a)*(y-vy)) = 0
       
         mG[2][0] = -pz0*ca0;
         mG[2][1] = -pz0*sa0;
         mG[2][2] =  px0*ca0 + py0*sa0;
         mG[2][3] = 0;
         mG[2][4] = 0;
         mG[2][5] = 0;
         
         mH[2][0] = mG[2][0];
         mH[2][1] = mG[2][1];
         mH[2][2] = mG[2][2];
         
         mB[2] = 0;
         
         // fit the vertex
 
         // V = GVGt
 
         double mGV[3][6];
         double mV[6];
         double m[3];
         for( int i=0; i<3; i++ ){
           m[i] = mB[i];
           for( int k=0; k<6; k++ ) m[i]+=mG[i][k]*daughterP[id][k];
         }
         for( int i=0; i<3; i++ ){
           for( int j=0; j<6; j++ ){
             mGV[i][j] = 0;
             for( int k=0; k<6; k++ ) mGV[i][j]+=mG[i][k]*daughterC[id][ IJ(k,j) ];
           }
         }
         for( int i=0, k=0; i<3; i++ ){
           for( int j=0; j<=i; j++,k++ ){
             mV[k] = 0;
             for( int l=0; l<6; l++ ) mV[k]+=mGV[i][l]*mG[j][l];
           }
         }
         
       
         //* CHt
         
         Double_t mCHt[3][3];
         Double_t mHCHt[6];
         Double_t mHr[3];
         for( int i=0; i<3; i++ ){         
           mHr[i] = 0;
           for( int k=0; k<3; k++ ) mHr[i]+= mH[i][k]*r[k];
         }
       
         for( int i=0; i<3; i++ ){
           for( int j=0; j<3; j++){
             mCHt[i][j] = 0;
             for( int k=0; k<3; k++ ) mCHt[i][j]+= mC[i][k]*mH[j][k];
           }
         }
 
         for( int i=0, k=0; i<3; i++ ){
           for( int j=0; j<=i; j++, k++ ){
             mHCHt[k] = 0;
             for( int l=0; l<3; l++ ) mHCHt[k]+= mH[i][l]*mCHt[l][j];
           }
         }
       
         Double_t mS[6] = { mHCHt[0]+mV[0], 
                            mHCHt[1]+mV[1], mHCHt[2]+mV[2], 
                            mHCHt[3]+mV[3], mHCHt[4]+mV[4], mHCHt[5]+mV[5]    }; 
       
 
         InvertSym3(mS,mS);
         
         //* Residual (measured - estimated)
     
         Double_t zeta[3] = { m[0]-mHr[0], m[1]-mHr[1], m[2]-mHr[2] };
             
         //* Kalman gain K = mCH'*S
     
         Double_t k[3][3];
       
         for(Int_t i=0;i<3;++i){
           k[i][0] = mCHt[i][0]*mS[0] + mCHt[i][1]*mS[1] + mCHt[i][2]*mS[3];
           k[i][1] = mCHt[i][0]*mS[1] + mCHt[i][1]*mS[2] + mCHt[i][2]*mS[4];
           k[i][2] = mCHt[i][0]*mS[3] + mCHt[i][1]*mS[4] + mCHt[i][2]*mS[5];
         }
 
         //* New estimation of the vertex position r += K*zeta
     
         for(Int_t i=0;i<3;++i) 
           r[i] = r[i] + k[i][0]*zeta[0] + k[i][1]*zeta[1] + k[i][2]*zeta[2];
       
         //* New covariance matrix C -= K*(mCH')'
 
         for(Int_t i=0;i<3;++i){
           for(Int_t j=0;j<=i;++j){
             mC[i][j] = mC[i][j] - (k[i][0]*mCHt[j][0] + k[i][1]*mCHt[j][1] + k[i][2]*mCHt[j][2]);
             mC[j][i] = mC[i][j];
           }
         }
 
         //* Calculate Chi^2 
         
         chi2 += ( ( mS[0]*zeta[0] + mS[1]*zeta[1] + mS[3]*zeta[2] )*zeta[0]
                   +(mS[1]*zeta[0] + mS[2]*zeta[1] + mS[4]*zeta[2] )*zeta[1]
                   +(mS[3]*zeta[0] + mS[4]*zeta[1] + mS[5]*zeta[2] )*zeta[2]  );  
       }
     
       // store vertex
     
       fNDF  = 2;
       fChi2 = chi2;
       for( int i=0; i<3; i++ ) fP[i] = r[i];
       for( int i=0,k=0; i<3; i++ ){
         for( int j=0; j<=i; j++,k++ ){
           fC[k] = mC[i][j];
         }
       }
     }
 
   } // iterations
 
   // now fit daughters to the vertex
   
   fQ     =  0;
   fSFromDecay = 0;    
 
   for(Int_t i=3;i<8;++i) fP[i]=0.;
   for(Int_t i=6;i<35;++i) fC[i]=0.;
   fC[35] = 100.;
 
   for( int id=0; id<2; id++ ){
 
     double *p = daughterP[id];
     double *mC = daughterC[id];      
     daughters[id]->GetMeasurement( v0, p, mC );
 
     const Double_t *m = fP, *mV = fC;
     
     Double_t mAi[6];
     InvertSym3(mC, mAi );
 
     Double_t mB[4][3];
 
     mB[0][0] = mC[ 6]*mAi[0] + mC[ 7]*mAi[1] + mC[ 8]*mAi[3];
     mB[0][1] = mC[ 6]*mAi[1] + mC[ 7]*mAi[2] + mC[ 8]*mAi[4];
     mB[0][2] = mC[ 6]*mAi[3] + mC[ 7]*mAi[4] + mC[ 8]*mAi[5];
     
     mB[1][0] = mC[10]*mAi[0] + mC[11]*mAi[1] + mC[12]*mAi[3];
     mB[1][1] = mC[10]*mAi[1] + mC[11]*mAi[2] + mC[12]*mAi[4];
     mB[1][2] = mC[10]*mAi[3] + mC[11]*mAi[4] + mC[12]*mAi[5];
     
     mB[2][0] = mC[15]*mAi[0] + mC[16]*mAi[1] + mC[17]*mAi[3];
     mB[2][1] = mC[15]*mAi[1] + mC[16]*mAi[2] + mC[17]*mAi[4];
     mB[2][2] = mC[15]*mAi[3] + mC[16]*mAi[4] + mC[17]*mAi[5];
     
     mB[3][0] = mC[21]*mAi[0] + mC[22]*mAi[1] + mC[23]*mAi[3];
     mB[3][1] = mC[21]*mAi[1] + mC[22]*mAi[2] + mC[23]*mAi[4];
     mB[3][2] = mC[21]*mAi[3] + mC[22]*mAi[4] + mC[23]*mAi[5];    
 
 
     Double_t z[3] = { m[0]-p[0], m[1]-p[1], m[2]-p[2] };
 
 //     {
 //       Double_t mAV[6] = { mC[0]-mV[0], mC[1]-mV[1], mC[2]-mV[2], 
 //                        mC[3]-mV[3], mC[4]-mV[4], mC[5]-mV[5] };
 //       
 //       Double_t mAVi[6];
 //       if( !InvertSym3(mAV, mAVi) ){
 //      Double_t dChi2 = ( +(mAVi[0]*z[0] + mAVi[1]*z[1] + mAVi[3]*z[2])*z[0]
 //                         +(mAVi[1]*z[0] + mAVi[2]*z[1] + mAVi[4]*z[2])*z[1]
 //                         +(mAVi[3]*z[0] + mAVi[4]*z[1] + mAVi[5]*z[2])*z[2] );
 //      fChi2+= fabs( dChi2 );
 //       }
 //       fNDF  += 2;
 //     }
 
     //* Add the daughter momentum to the particle momentum
  
     fP[3]+= p[3] + mB[0][0]*z[0] + mB[0][1]*z[1] + mB[0][2]*z[2];
     fP[4]+= p[4] + mB[1][0]*z[0] + mB[1][1]*z[1] + mB[1][2]*z[2];
     fP[5]+= p[5] + mB[2][0]*z[0] + mB[2][1]*z[1] + mB[2][2]*z[2];
     fP[6]+= p[6] + mB[3][0]*z[0] + mB[3][1]*z[1] + mB[3][2]*z[2];
   
     Double_t d0, d1, d2;
    
     d0= mB[0][0]*mV[0] + mB[0][1]*mV[1] + mB[0][2]*mV[3] - mC[ 6];
     d1= mB[0][0]*mV[1] + mB[0][1]*mV[2] + mB[0][2]*mV[4] - mC[ 7];
     d2= mB[0][0]*mV[3] + mB[0][1]*mV[4] + mB[0][2]*mV[5] - mC[ 8];
 
     //fC[6]+= mC[ 6] + d0;
     //fC[7]+= mC[ 7] + d1;
     //fC[8]+= mC[ 8] + d2;
     fC[9]+= mC[ 9] + d0*mB[0][0] + d1*mB[0][1] + d2*mB[0][2];
 
     d0= mB[1][0]*mV[0] + mB[1][1]*mV[1] + mB[1][2]*mV[3] - mC[10];
     d1= mB[1][0]*mV[1] + mB[1][1]*mV[2] + mB[1][2]*mV[4] - mC[11];
     d2= mB[1][0]*mV[3] + mB[1][1]*mV[4] + mB[1][2]*mV[5] - mC[12];
 
     //fC[10]+= mC[10]+ d0;
     //fC[11]+= mC[11]+ d1;
     //fC[12]+= mC[12]+ d2;
     fC[13]+= mC[13]+ d0*mB[0][0] + d1*mB[0][1] + d2*mB[0][2];
     fC[14]+= mC[14]+ d0*mB[1][0] + d1*mB[1][1] + d2*mB[1][2];
 
     d0= mB[2][0]*mV[0] + mB[2][1]*mV[1] + mB[2][2]*mV[3] - mC[15];
     d1= mB[2][0]*mV[1] + mB[2][1]*mV[2] + mB[2][2]*mV[4] - mC[16];
     d2= mB[2][0]*mV[3] + mB[2][1]*mV[4] + mB[2][2]*mV[5] - mC[17];
 
     //fC[15]+= mC[15]+ d0;
     //fC[16]+= mC[16]+ d1;
     //fC[17]+= mC[17]+ d2;
     fC[18]+= mC[18]+ d0*mB[0][0] + d1*mB[0][1] + d2*mB[0][2];
     fC[19]+= mC[19]+ d0*mB[1][0] + d1*mB[1][1] + d2*mB[1][2];
     fC[20]+= mC[20]+ d0*mB[2][0] + d1*mB[2][1] + d2*mB[2][2];
 
     d0= mB[3][0]*mV[0] + mB[3][1]*mV[1] + mB[3][2]*mV[3] - mC[21];
     d1= mB[3][0]*mV[1] + mB[3][1]*mV[2] + mB[3][2]*mV[4] - mC[22];
     d2= mB[3][0]*mV[3] + mB[3][1]*mV[4] + mB[3][2]*mV[5] - mC[23];
 
     //fC[21]+= mC[21] + d0;
     //fC[22]+= mC[22] + d1;
     //fC[23]+= mC[23] + d2;
     fC[24]+= mC[24] + d0*mB[0][0] + d1*mB[0][1] + d2*mB[0][2];
     fC[25]+= mC[25] + d0*mB[1][0] + d1*mB[1][1] + d2*mB[1][2];
     fC[26]+= mC[26] + d0*mB[2][0] + d1*mB[2][1] + d2*mB[2][2];
     fC[27]+= mC[27] + d0*mB[3][0] + d1*mB[3][1] + d2*mB[3][2];
   }
 
 //  SetMassConstraint(0,0);
   SetNonlinearMassConstraint(0);
 }

void KFParticleBase::Convert ( bool ToProduction )

protected

Definition at line 1549 of file KFParticleBase.cxx.

References c, Double_t, fC, fP, fQ, GetFieldValue(), and h.

Referenced by SetProductionVertex(), TransportToDecayVertex(), and TransportToProductionVertex().

 {
   //* Tricky function - convert the particle error along its trajectory to 
   //* the value which corresponds to its production/decay vertex
   //* It is done by combination of the error of decay length with the position errors
 
   Double_t fld[3];
   {
     GetFieldValue( fP, fld );
     const Double_t kCLight =  fQ*0.000299792458;
     fld[0]*=kCLight; fld[1]*=kCLight; fld[2]*=kCLight;
   }
 
   Double_t h[6];
   
   h[0] = fP[3];
   h[1] = fP[4];
   h[2] = fP[5];
   if( ToProduction ){ h[0]=-h[0]; h[1]=-h[1]; h[2]=-h[2]; } 
   h[3] = h[1]*fld[2]-h[2]*fld[1];
   h[4] = h[2]*fld[0]-h[0]*fld[2];
   h[5] = h[0]*fld[1]-h[1]*fld[0];
   
   Double_t c;
 
   c = fC[28]+h[0]*fC[35];
   fC[ 0]+= h[0]*(c+fC[28]);
   fC[28] = c;
 
   fC[ 1]+= h[1]*fC[28] + h[0]*fC[29];
   c = fC[29]+h[1]*fC[35];
   fC[ 2]+= h[1]*(c+fC[29]);
   fC[29] = c;
 
   fC[ 3]+= h[2]*fC[28] + h[0]*fC[30];
   fC[ 4]+= h[2]*fC[29] + h[1]*fC[30];
   c = fC[30]+h[2]*fC[35];
   fC[ 5]+= h[2]*(c+fC[30]);
   fC[30] = c;
 
   fC[ 6]+= h[3]*fC[28] + h[0]*fC[31];
   fC[ 7]+= h[3]*fC[29] + h[1]*fC[31];
   fC[ 8]+= h[3]*fC[30] + h[2]*fC[31];
   c = fC[31]+h[3]*fC[35];
   fC[ 9]+= h[3]*(c+fC[31]);
   fC[31] = c;
   
   fC[10]+= h[4]*fC[28] + h[0]*fC[32];
   fC[11]+= h[4]*fC[29] + h[1]*fC[32];
   fC[12]+= h[4]*fC[30] + h[2]*fC[32];
   fC[13]+= h[4]*fC[31] + h[3]*fC[32];
   c = fC[32]+h[4]*fC[35];
   fC[14]+= h[4]*(c+fC[32]);
   fC[32] = c;
   
   fC[15]+= h[5]*fC[28] + h[0]*fC[33];
   fC[16]+= h[5]*fC[29] + h[1]*fC[33];
   fC[17]+= h[5]*fC[30] + h[2]*fC[33];
   fC[18]+= h[5]*fC[31] + h[3]*fC[33];
   fC[19]+= h[5]*fC[32] + h[4]*fC[33];
   c = fC[33]+h[5]*fC[35];
   fC[20]+= h[5]*(c+fC[33]);
   fC[33] = c;
 
   fC[21]+= h[0]*fC[34];
   fC[22]+= h[1]*fC[34];
   fC[23]+= h[2]*fC[34];
   fC[24]+= h[3]*fC[34];
   fC[25]+= h[4]*fC[34];
   fC[26]+= h[5]*fC[34];
 }

Double_t& KFParticleBase::Covariance ( Int_t i )

inline

Definition at line 159 of file KFParticleBase.h.

References fC, and i.

Referenced by KFParticle::Covariance(), and RotateXY().

159 { return fC[i]; }

Int_t i

Definition: run_full.C:25

Double_t fC[36]

Definition: KFParticleBase.h:307

Double_t& KFParticleBase::Covariance	(	Int_t	i,
		Int_t	j
	)

inline

Definition at line 160 of file KFParticleBase.h.

References fC, and IJ().

160 { return fC[IJ(i,j)]; }

Int_t i

Definition: run_full.C:25

KFParticleBase::IJ

static Int_t IJ(Int_t i, Int_t j)

Definition: KFParticleBase.h:281

KFParticleBase::fDaughtersIds

Double_t fC[36]

Definition: KFParticleBase.h:307

const std::vector<int>& KFParticleBase::DaughterIds ( ) const

inline

Definition at line 271 of file KFParticleBase.h.

References fDaughtersIds.

Referenced by KFParticleFinder::CombineTrackPart(), KFParticleFinder::FindHyperons(), and KFParticleSIMD::KFParticleSIMD().

271 { return fDaughtersIds; };

std::vector< int > fDaughtersIds

Definition: KFParticleBase.h:331

const Double_t& KFParticleBase::E ( ) const

inline

Definition at line 119 of file KFParticleBase.h.

References fP.

Referenced by KFParticle::E().

119 { return fP[6]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

Double_t& KFParticleBase::E ( )

inline

Definition at line 152 of file KFParticleBase.h.

References fP.

152 { return fP[6]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

void KFParticleBase::GetArmenterosPodolanski	(	KFParticleBase &	positive,
		KFParticleBase &	negative,
		Double_t	QtAlfa[2]
	)

static

Definition at line 3199 of file KFParticleBase.cxx.

References alpha, Double_t, GetPx(), GetPy(), GetPz(), and sqrt().

 {
 // example:
 //       KFParticle PosParticle(...)
 //       KFParticle NegParticle(...)
 //       Gamma.ConstructGamma(PosParticle, NegParticle);
 //       Double_t VertexGamma[3] = {Gamma.GetX(), Gamma.GetY(), Gamma.GetZ()};
 //       PosParticle.TransportToPoint(VertexGamma);
 //       NegParticle.TransportToPoint(VertexGamma);
 //       Double_t armenterosQtAlfa[2] = {0.};
 //       KFParticle::GetArmenterosPodolanski(PosParticle, NegParticle, armenterosQtAlfa );
 
   Double_t alpha = 0., qt = 0.;
   Double_t spx = positive.GetPx() + negative.GetPx();
   Double_t spy = positive.GetPy() + negative.GetPy();
   Double_t spz = positive.GetPz() + negative.GetPz();
   Double_t sp  = sqrt(spx*spx + spy*spy + spz*spz);
   if( sp == 0.0) return;
   Double_t pn, pp, pln, plp;
 
   pn = sqrt(negative.GetPx()*negative.GetPx() + negative.GetPy()*negative.GetPy() + negative.GetPz()*negative.GetPz());
   pp = sqrt(positive.GetPx()*positive.GetPx() + positive.GetPy()*positive.GetPy() + positive.GetPz()*positive.GetPz());
   pln  = (negative.GetPx()*spx+negative.GetPy()*spy+negative.GetPz()*spz)/sp;
   plp  = (positive.GetPx()*spx+positive.GetPy()*spy+positive.GetPz()*spz)/sp;
 
   if( pn == 0.0) return;
   Double_t ptm  = (1.-((pln/pn)*(pln/pn)));
   qt= (ptm>=0.)?  pn*sqrt(ptm) :0;
   alpha = (plp-pln)/(plp+pln);
 
   QtAlfa[0] = qt;
   QtAlfa[1] = alpha;
 }

Double_t KFParticleBase::GetChi2 ( ) const

inline

Definition at line 110 of file KFParticleBase.h.

References fChi2.

Referenced by KFParticle::GetChi2().

110 { return fChi2; }

KFParticleBase::fChi2

Double_t fChi2

Definition: KFParticleBase.h:310

Double_t KFParticleBase::GetCovariance ( Int_t i ) const

inline

Definition at line 126 of file KFParticleBase.h.

References fC, and i.

Referenced by KFParticle::GetCovariance(), and RotateXY().

126 { return fC[i]; }

Int_t i

Definition: run_full.C:25

Double_t fC[36]

Definition: KFParticleBase.h:307

Double_t KFParticleBase::GetCovariance	(	Int_t	i,
		Int_t	j
	)		const

inline

Definition at line 127 of file KFParticleBase.h.

References fC, and IJ().

127 { return fC[IJ(i,j)]; }

Int_t i

Definition: run_full.C:25

KFParticleBase::IJ

static Int_t IJ(Int_t i, Int_t j)

Definition: KFParticleBase.h:281

Double_t fC[36]

Definition: KFParticleBase.h:307

Int_t KFParticleBase::GetDecayLength	(	Double_t &	L,
		Double_t &	SigmaL
	)		const

Definition at line 265 of file KFParticleBase.cxx.

References Double_t, fabs(), fC, fP, p2, sqrt(), t, x, y, and z.

Referenced by KFParticle::GetDecayLength(), and KFParticle::GetErrDecayLength().

 {
   //* Calculate particle decay length [cm]
 
   Double_t x = fP[3];
   Double_t y = fP[4];
   Double_t z = fP[5];
   Double_t t = fP[7];
   Double_t x2 = x*x;
   Double_t y2 = y*y;
   Double_t z2 = z*z;
   Double_t p2 = x2+y2+z2;
   l = t*sqrt(p2);
   if( p2>1.e-4){
     error = p2*fC[35] + t*t/p2*(x2*fC[9]+y2*fC[14]+z2*fC[20]
                                 + 2*(x*y*fC[13]+x*z*fC[18]+y*z*fC[19]) )
       + 2*t*(x*fC[31]+y*fC[32]+z*fC[33]);
     error = sqrt(fabs(error));
     return 0;
   }
   error = 1.e20;
   return 1;
 }

Int_t KFParticleBase::GetDecayLengthXY	(	Double_t &	L,
		Double_t &	SigmaL
	)		const

Definition at line 289 of file KFParticleBase.cxx.

References Double_t, fabs(), fC, fP, sqrt(), t, x, and y.

Referenced by KFParticle::GetDecayLengthXY(), and KFParticle::GetErrDecayLengthXY().

 {
   //* Calculate particle decay length in XY projection [cm]
 
   Double_t x = fP[3];
   Double_t y = fP[4];
   Double_t t = fP[7];
   Double_t x2 = x*x;
   Double_t y2 = y*y;
   Double_t pt2 = x2+y2;
   l = t*sqrt(pt2);
   if( pt2>1.e-4){
     error = pt2*fC[35] + t*t/pt2*(x2*fC[9]+y2*fC[14] + 2*x*y*fC[13] )
       + 2*t*(x*fC[31]+y*fC[32]);
     error = sqrt(fabs(error));
     return 0;
   }
   error = 1.e20;
   return 1;
 }

Double_t KFParticleBase::GetDeviationFromParticle ( const KFParticleBase & p ) const

Definition at line 2625 of file KFParticleBase.cxx.

References d, Double_t, fP, GetDeviationFromVertex(), GetDStoParticle(), h, sqrt(), and Transport().

Referenced by KFParticle::GetDeviationFromParticle().

 { 
   //* Calculate sqrt(Chi2/ndf) deviation from other particle
 
   Double_t dS, dS1;
   GetDStoParticle( p, dS, dS1 );   
   Double_t mP1[8], mC1[36];
   p.Transport( dS1, mP1, mC1 ); 
 
   Double_t d[3]={ fP[0]-mP1[0], fP[1]-mP1[1], fP[2]-mP1[2]};
 
   Double_t sigmaS = .1+10.*sqrt( (d[0]*d[0]+d[1]*d[1]+d[2]*d[2])/
                                         (mP1[3]*mP1[3]+mP1[4]*mP1[4]+mP1[5]*mP1[5])  );
 
   Double_t h[3] = { mP1[3]*sigmaS, mP1[4]*sigmaS, mP1[5]*sigmaS };       
   
   mC1[0] +=h[0]*h[0];
   mC1[1] +=h[1]*h[0]; 
   mC1[2] +=h[1]*h[1]; 
   mC1[3] +=h[2]*h[0]; 
   mC1[4] +=h[2]*h[1];
   mC1[5] +=h[2]*h[2];
 
   return GetDeviationFromVertex( mP1, mC1 )*sqrt(2./1.);
 }

Double_t KFParticleBase::GetDeviationFromVertex	(	const Double_t	v[],
		const Double_t	Cv[] = `0`
	)		const

Definition at line 2575 of file KFParticleBase.cxx.

References d, Double_t, fabs(), GetDStoPoint(), h, mP, s, sqrt(), and Transport().

Referenced by GetDeviationFromParticle(), GetDeviationFromVertex(), and KFParticle::GetDeviationFromVertex().

 {
   //* Calculate sqrt(Chi2/ndf) deviation from vertex
   //* v = [xyz], Cv=[Cxx,Cxy,Cyy,Cxz,Cyz,Czz]-covariance matrix
 
   Double_t mP[8];
   Double_t mC[36];
   
   Transport( GetDStoPoint(v), mP, mC );  
 
   Double_t d[3]={ v[0]-mP[0], v[1]-mP[1], v[2]-mP[2]};
 
   Double_t sigmaS = .1+10.*sqrt( (d[0]*d[0]+d[1]*d[1]+d[2]*d[2])/
                                  (mP[3]*mP[3]+mP[4]*mP[4]+mP[5]*mP[5])  );
 
    
   Double_t h[3] = { mP[3]*sigmaS, mP[4]*sigmaS, mP[5]*sigmaS };       
   
   Double_t mSi[6] = 
     { mC[0] +h[0]*h[0], 
       mC[1] +h[1]*h[0], mC[2] +h[1]*h[1], 
       mC[3] +h[2]*h[0], mC[4] +h[2]*h[1], mC[5] +h[2]*h[2] };
 
   if( Cv ){
     mSi[0]+=Cv[0];
     mSi[1]+=Cv[1];
     mSi[2]+=Cv[2];
     mSi[3]+=Cv[3];
     mSi[4]+=Cv[4];
     mSi[5]+=Cv[5];
   }
   
   Double_t mS[6];
 
   mS[0] = mSi[2]*mSi[5] - mSi[4]*mSi[4];
   mS[1] = mSi[3]*mSi[4] - mSi[1]*mSi[5];
   mS[2] = mSi[0]*mSi[5] - mSi[3]*mSi[3];
   mS[3] = mSi[1]*mSi[4] - mSi[2]*mSi[3];
   mS[4] = mSi[1]*mSi[3] - mSi[0]*mSi[4];
   mS[5] = mSi[0]*mSi[2] - mSi[1]*mSi[1];         
       
   Double_t s = ( mSi[0]*mS[0] + mSi[1]*mS[1] + mSi[3]*mS[3] );
   s = ( s > 1.E-20 )  ?1./s :0;   
 
   return sqrt( fabs(s*( ( mS[0]*d[0] + mS[1]*d[1] + mS[3]*d[2])*d[0]
                    +(mS[1]*d[0] + mS[2]*d[1] + mS[4]*d[2])*d[1]
                    +(mS[3]*d[0] + mS[4]*d[1] + mS[5]*d[2])*d[2] ))/2);
 }

Double_t KFParticleBase::GetDeviationFromVertex ( const KFParticleBase & Vtx ) const

Definition at line 2567 of file KFParticleBase.cxx.

References fC, fP, and GetDeviationFromVertex().

 {
   //* Calculate sqrt(Chi2/ndf) deviation from vertex
 
   return GetDeviationFromVertex( Vtx.fP, Vtx.fC );
 }

Double_t KFParticleBase::GetDistanceFromParticle ( const KFParticleBase & p ) const

Definition at line 2551 of file KFParticleBase.cxx.

References Double_t, dx, dy, dz, GetDStoParticle(), mP, sqrt(), and Transport().

Referenced by KFParticle::GetDistanceFromParticle().

 { 
   //* Calculate distance to other particle [cm]
 
   Double_t dS, dS1;
   GetDStoParticle( p, dS, dS1 );   
   Double_t mP[8], mC[36], mP1[8], mC1[36];
   Transport( dS, mP, mC ); 
   p.Transport( dS1, mP1, mC1 ); 
   Double_t dx = mP[0]-mP1[0]; 
   Double_t dy = mP[1]-mP1[1]; 
   Double_t dz = mP[2]-mP1[2]; 
   return sqrt(dx*dx+dy*dy+dz*dz);
 }

Double_t KFParticleBase::GetDistanceFromVertex ( const Double_t vtx[] ) const

Definition at line 2541 of file KFParticleBase.cxx.

References d, Double_t, GetDStoPoint(), mP, sqrt(), and Transport().

Referenced by GetDistanceFromVertex(), and KFParticle::GetDistanceFromVertex().

 {
   //* Calculate distance from vertex [cm]
 
   Double_t mP[8], mC[36];  
   Transport( GetDStoPoint(vtx), mP, mC );
   Double_t d[3]={ vtx[0]-mP[0], vtx[1]-mP[1], vtx[2]-mP[2]};
   return sqrt( d[0]*d[0]+d[1]*d[1]+d[2]*d[2] );
 }

Double_t KFParticleBase::GetDistanceFromVertex ( const KFParticleBase & Vtx ) const

Definition at line 2534 of file KFParticleBase.cxx.

References fP, and GetDistanceFromVertex().

 {
   //* Calculate distance from vertex [cm]
 
   return GetDistanceFromVertex( Vtx.fP );
 }

void KFParticleBase::GetDSIter	(	const KFParticleBase &	p,
		Double_t const &	dS,
		Double_t	x[3],
		Double_t	dx[3],
		Double_t	ddx[3]
	)		const

protected

Definition at line 2046 of file KFParticleBase.cxx.

References c, Double_t, fP, fQ, GetFieldValue(), m, n, p1, and p2.

 {
   Double_t ssx=0, ssy=0, ssz=0, ssyy=0, ssyz=0, ssyyy=0;
   Double_t dssx=0, dssy=0, dssz=0, dssyy=0, dssyz=0, dssyyy=0; // d(...)/dS
   Double_t ddssx=0, ddssy=0, ddssz=0, ddssyy=0, ddssyz=0, ddssyyy=0; // d2(...)/dS2
   Double_t Kssx=0, Kssy=0, Kssz=0, Kssyy=0, Kssyz=0, Kssyyy=0;
 
   const Double_t kCLight = 0.000299792458;
   Double_t c = fQ*kCLight;
 
   // get field integrals
 
   Double_t fld[3][3];   
   Double_t p0[3], p1[3], p2[3];
 
   // line track approximation
 
   p0[0] = p.fP[0];
   p0[1] = p.fP[1];
   p0[2] = p.fP[2];
 
   p2[0] = p.fP[0] + p.fP[3]*dS;
   p2[1] = p.fP[1] + p.fP[4]*dS;
   p2[2] = p.fP[2] + p.fP[5]*dS;
 
   p1[0] = 0.5*(p0[0]+p2[0]);
   p1[1] = 0.5*(p0[1]+p2[1]);
   p1[2] = 0.5*(p0[2]+p2[2]);
 
   // first order track approximation
   {
     GetFieldValue( p0, fld[0] );
     GetFieldValue( p1, fld[1] );
     GetFieldValue( p2, fld[2] );
 
     Double_t ssy1 = ( 7*fld[0][1] + 6*fld[1][1]-fld[2][1] )*c*dS*dS/96.;
     Double_t ssy2 = (   fld[0][1] + 2*fld[1][1]         )*c*dS*dS/6.;
 
     p1[0] -= ssy1*p.fP[5];
     p1[2] += ssy1*p.fP[3];
     p2[0] -= ssy2*p.fP[5];
     p2[2] += ssy2*p.fP[3];
   }
 
   GetFieldValue( p0, fld[0] );
   GetFieldValue( p1, fld[1] );
   GetFieldValue( p2, fld[2] );
 
   Kssx = c*( fld[0][0] + 2*fld[1][0]) / 6.;
   Kssy = c*( fld[0][1] + 2*fld[1][1]) / 6.;
   Kssz = c*( fld[0][2] + 2*fld[1][2]) / 6.;
 
 //  Double_t c2[3][3]    =   { {  5, -4, -1},{  44,  80,  -4},{ 11, 44, 5} }; // /=360.    
   Double_t cc2[3][3]    =   { { 38,  8, -4},{ 148, 208, -20},{  3, 36, 3} }; // /=2520.
   for(Int_t n=0; n<3; n++)
     for(Int_t m=0; m<3; m++) 
     {
       Kssyz += cc2[n][m]*fld[n][1]*fld[m][2];
     }
   Kssyz *= c*c / 2520.;
 
   Kssyy = ( fld[0][1]*( 38*fld[0][1] + 156*fld[1][1]  -   fld[2][1] )+
             fld[1][1]*(              208*fld[1][1]  +16*fld[2][1] )+
             fld[2][1]*(                             3*fld[2][1] )  
           )*c*c/2520.;
   Kssyyy = ( fld[0][1]*( fld[0][1]*( 85*fld[0][1] + 526*fld[1][1]  - 7*fld[2][1] )+
              fld[1][1]*(             1376*fld[1][1]  +84*fld[2][1] )+
              fld[2][1]*(                            19*fld[2][1] )  )+
              fld[1][1]*( fld[1][1]*(             1376*fld[1][1] +256*fld[2][1] )+
              fld[2][1]*(                            62*fld[2][1] )  )+
              fld[2][1]*fld[2][1]  *(                             3*fld[2][1] )
            )*c*c*c/90720.;
 
   ssx = Kssx * dS*dS;
   ssy = Kssy * dS*dS;
   ssz = Kssz * dS*dS;
   ssyz = Kssyz * dS*dS*dS;
   ssyy = Kssyy * dS*dS*dS;
   ssyyy = Kssyyy * dS*dS*dS*dS;
 
   dssx = 2.*Kssx * dS;
   dssy = 2.*Kssy * dS;
   dssz = 2.*Kssz * dS;
   dssyz = 3.*Kssyz * dS*dS;
   dssyy = 3.*Kssyy * dS*dS;
   dssyyy = 4.*Kssyyy * dS*dS*dS;
 
   ddssx = 2.*Kssx;
   ddssy = 2.*Kssy;
   ddssz = 2.*Kssz;
   ddssyz = 2.*3.*Kssyz * dS;
   ddssyy = 2.*3.*Kssyy * dS;
   ddssyyy = 3.*4.*Kssyyy * dS*dS;
 
   Double_t mJ[3][3];
   for( Int_t iJ=0; iJ<3; iJ++ ) for( Int_t jJ=0; jJ<3; jJ++) mJ[iJ][jJ]=0;
 
   mJ[0][0]=dS-ssyy;   mJ[0][1]=ssx;  mJ[0][2]=ssyyy-ssy;
   mJ[1][0]=-ssz;      mJ[1][1]=dS;   mJ[1][2]=ssx+ssyz;
   mJ[2][0]=ssy-ssyyy; mJ[2][1]=-ssx; mJ[2][2]=dS-ssyy;
 
   x[0] = p.fP[0] + mJ[0][0]*p.fP[3] + mJ[0][1]*p.fP[4] + mJ[0][2]*p.fP[5];
   x[1] = p.fP[1] + mJ[1][0]*p.fP[3] + mJ[1][1]*p.fP[4] + mJ[1][2]*p.fP[5];
   x[2] = p.fP[2] + mJ[2][0]*p.fP[3] + mJ[2][1]*p.fP[4] + mJ[2][2]*p.fP[5];
 
   mJ[0][0]= 1-dssyy;      mJ[0][1]= dssx;  mJ[0][2]= dssyyy-dssy;
   mJ[1][0]= -dssz;        mJ[1][1]= 1;     mJ[1][2]= dssx+dssyz;
   mJ[2][0]= dssy-dssyyy;  mJ[2][1]= -dssx; mJ[2][2]= 1-dssyy;
 
   dx[0] = p.fP[0] + mJ[0][0]*p.fP[3] + mJ[0][1]*p.fP[4] + mJ[0][2]*p.fP[5];
   dx[1] = p.fP[1] + mJ[1][0]*p.fP[3] + mJ[1][1]*p.fP[4] + mJ[1][2]*p.fP[5];
   dx[2] = p.fP[2] + mJ[2][0]*p.fP[3] + mJ[2][1]*p.fP[4] + mJ[2][2]*p.fP[5];
 
   mJ[0][0]= -ddssyy;        mJ[0][1]= ddssx;  mJ[0][2]= ddssyyy-ddssy;
   mJ[1][0]= -ddssz;         mJ[1][1]= 0;      mJ[1][2]= ddssx+ddssyz;
   mJ[2][0]= ddssy-ddssyyy;  mJ[2][1]= -ddssx; mJ[2][2]= -ddssyy;
 
   ddx[0] = p.fP[0] + mJ[0][0]*p.fP[3] + mJ[0][1]*p.fP[4] + mJ[0][2]*p.fP[5];
   ddx[1] = p.fP[1] + mJ[1][0]*p.fP[3] + mJ[1][1]*p.fP[4] + mJ[1][2]*p.fP[5];
   ddx[2] = p.fP[2] + mJ[2][0]*p.fP[3] + mJ[2][1]*p.fP[4] + mJ[2][2]*p.fP[5];
 }

virtual void KFParticleBase::GetDStoParticle	(	const KFParticleBase &	p,
		Double_t &	DS,
		Double_t &	DSp
	)		const

pure virtual

Implemented in KFParticle.

Referenced by AddDaughterWithEnergyCalc(), AddDaughterWithEnergyFit(), AddDaughterWithEnergyFitMC(), Construct(), ConstructGammaBz(), GetDeviationFromParticle(), and GetDistanceFromParticle().

void KFParticleBase::GetDStoParticleBy	(	Double_t	B,
		const KFParticleBase &	p,
		Double_t &	dS,
		Double_t &	dS1
	)		const

Definition at line 1909 of file KFParticleBase.cxx.

References a, atan2(), b, c, cos(), d, Double_t, dx, dy, fabs(), fP, fQ, g, g1, i, p2, pz, s, sin(), and sqrt().

Referenced by GetDStoParticleCBM().

 { 
   //* Get dS to another particle for Bz field
   Double_t px = fP[3];
   Double_t py = -fP[5];
   Double_t pz = fP[4];
 
   Double_t px1 = p.fP[3];
   Double_t py1 = -p.fP[5];
   Double_t pz1 = p.fP[4];
 
   const Double_t kCLight = 0.000299792458;
 
   Double_t bq = B*fQ*kCLight;
   Double_t bq1 = B*p.fQ*kCLight;
   Double_t s=0, ds=0, s1=0, ds1=0;
 
   if( fabs(bq)>1.e-8 || fabs(bq1)>1.e-8 ){
 
     Double_t dx = (p.fP[0] - fP[0]);
     Double_t dy = (-p.fP[2] + fP[2]);
     Double_t d2 = (dx*dx+dy*dy);
 
     Double_t p2  = (px *px  + py *py); 
     Double_t p21 = (px1*px1 + py1*py1);
 
     if( fabs(p2) < 1.e-8 || fabs(p21) < 1.e-8 )
     {
       DS=0.;
       DS1=0.;
       return;
     }
 
     Double_t a = (px*py1 - py*px1);
     Double_t b = (px*px1 + py*py1);
 
     Double_t ldx = bq*bq1*dx - bq1*py + bq*py1 ;
     Double_t ldy = bq*bq1*dy + bq1*px - bq*px1 ;
     Double_t l2 = ldx*ldx + ldy*ldy;
     
     Double_t cS = bq1*p2 + bq*bq1*(dy* px - dx* py) -  bq*b;
     Double_t cS1= bq*p21 - bq*bq1*(dy*px1 - dx*py1) - bq1*b;
 
     Double_t ca  = bq*bq*bq1*d2  +2*( cS + bq*bq*(py1*dx-px1*dy)) ;
     Double_t ca1 = bq*bq1*bq1*d2 +2*( cS1 - bq1*bq1*(py*dx-px*dy)) ;  
 
     Double_t sa = 4*l2*p2 - ca*ca;
     Double_t sa1 = 4*l2*p21 - ca1*ca1;
 
     if(sa<0) sa=0;
     if(sa1<0)sa1=0;
 
     if( fabs(bq)>1.e-8){
       s  = atan2(   bq*( bq1*(dx*px +dy*py) + a ) , cS )/bq;
       ds = atan2(sqrt(sa),ca)/bq;
     } else {
       s = ( (dx*px + dy*py) + (py*px1-px*py1)/bq1)/p2;
       ds = s*s - (d2-2*(px1*dy-py1*dx)/bq1)/p2; 
       if( ds<0 ) ds = 0;
       ds = sqrt(ds);   
     }
 
     if( fabs(bq1)>1.e-8){
       s1 = atan2( -bq1*( bq*(dx*px1+dy*py1) + a), cS1 )/bq1;
       ds1 = atan2(sqrt(sa1),ca1)/bq1;  
     } else {
       s1 = (-(dx*px1 + dy*py1) + (py*px1-px*py1)/bq)/p21;
       ds1 = s1*s1 - (d2+2*(px*dy-py*dx)/bq)/p21; 
       if( ds1<0 ) ds1 = 0;
       ds1 = sqrt(ds1);
     }
   }
   Double_t ss[2], ss1[2], g[2][5],g1[2][5];
   
   ss[0] = s + ds;
   ss[1] = s - ds;
   ss1[0] = s1 + ds1;
   ss1[1] = s1 - ds1;
 
   for( Int_t i=0; i<2; i++){
     Double_t bs = bq*ss[i];
     Double_t c = cos(bs), sss = sin(bs);
     Double_t cB,sB;
     if( fabs(bq)>1.e-8){
       cB= (1-c)/bq;     
       sB= sss/bq;  
     }else{
       const Double_t kOvSqr6 = 1./sqrt(6.);
       sB = (1.-bs*kOvSqr6)*(1.+bs*kOvSqr6)*ss[i];
       cB = .5*sB*bs;
     }
     g[i][0] = fP[0] + sB*px + cB*py;
     g[i][1] = -fP[2] - cB*px + sB*py;
     g[i][2] = fP[1] + ss[i]*pz;
     g[i][3] =       + c*px + sss*py;
     g[i][4] =       - sss*px + c*py;
 
     bs = bq1*ss1[i];  
     c =  cos(bs); sss = sin(bs);
     if( fabs(bq1)>1.e-8){
       cB= (1-c)/bq1;   
       sB= sss/bq1;  
     }else{
       const Double_t kOvSqr6 = 1./sqrt(6.);
       sB = (1.-bs*kOvSqr6)*(1.+bs*kOvSqr6)*ss1[i];
       cB = .5*sB*bs;
     }
       
     g1[i][0] = p.fP[0] + sB*px1 + cB*py1;
     g1[i][1] = -p.fP[2] - cB*px1 + sB*py1;
     g1[i][2] = p.fP[1] + ss1[i]*pz1;
     g1[i][3] =         + c*px1 + sss*py1;
     g1[i][4] =         - sss*px1 + c*py1;
   }
 
   Int_t i=0, i1=0;
   
   Double_t dMin = 1.e10;
   for( Int_t j=0; j<2; j++){
     for( Int_t j1=0; j1<2; j1++){
       Double_t xx = g[j][0]-g1[j1][0];
       Double_t yy = g[j][1]-g1[j1][1];
       Double_t zz = g[j][2]-g1[j1][2];
       Double_t d = xx*xx + yy*yy + zz*zz;
       if( d<dMin ){
         dMin = d;
         i = j;
         i1 = j1;
       }
     }
   }  
 
   DS = ss[i];
   DS1 = ss1[i1];
 }

void KFParticleBase::GetDStoParticleBz	(	Double_t	Bz,
		const KFParticleBase &	p,
		Double_t &	dS,
		Double_t &	dS1
	)		const

Definition at line 1754 of file KFParticleBase.cxx.

References a, atan2(), b, c, cos(), d, Double_t, dx, dy, dz, fabs(), fP, fQ, g, g1, i, p2, pz, s, sin(), sqrt(), x, y, and z.

Referenced by KFParticle::GetDStoParticleXY().

 { 
   //* Get dS to another particle for Bz field
   Double_t px = fP[3];
   Double_t py = fP[4];
   Double_t pz = fP[5];
 
   Double_t px1 = p.fP[3];
   Double_t py1 = p.fP[4];
   Double_t pz1 = p.fP[5];
 
   const Double_t kCLight = 0.000299792458;
 
   Double_t bq = B*fQ*kCLight;
   Double_t bq1 = B*p.fQ*kCLight;
   Double_t s=0, ds=0, s1=0, ds1=0;
 
   if( fabs(bq)>1.e-8 || fabs(bq1)>1.e-8 ){
 
     Double_t dx = (p.fP[0] - fP[0]);
     Double_t dy = (p.fP[1] - fP[1]);
     Double_t d2 = (dx*dx+dy*dy);
 
     Double_t p2  = (px *px  + py *py); 
     Double_t p21 = (px1*px1 + py1*py1);
 
     if( fabs(p2) < 1.e-8 || fabs(p21) < 1.e-8 )
     {
       DS=0.;
       DS1=0.;
       return;
     }
 
     Double_t a = (px*py1 - py*px1);
     Double_t b = (px*px1 + py*py1);
 
     Double_t ldx = bq*bq1*dx - bq1*py + bq*py1 ;
     Double_t ldy = bq*bq1*dy + bq1*px - bq*px1 ;
     Double_t l2 = ldx*ldx + ldy*ldy;
     
     Double_t cS = bq1*p2 + bq*bq1*(dy* px - dx* py) -  bq*b;
     Double_t cS1= bq*p21 - bq*bq1*(dy*px1 - dx*py1) - bq1*b;
 
     Double_t ca  = bq*bq*bq1*d2  +2*( cS + bq*bq*(py1*dx-px1*dy)) ;
     Double_t ca1 = bq*bq1*bq1*d2 +2*( cS1 - bq1*bq1*(py*dx-px*dy)) ;  
 
     Double_t sa = 4*l2*p2 - ca*ca;
     Double_t sa1 = 4*l2*p21 - ca1*ca1;
 
     if(sa<0) sa=0;
     if(sa1<0)sa1=0;
 
     if( fabs(bq)>1.e-8){
       s  = atan2(   bq*( bq1*(dx*px +dy*py) + a ) , cS )/bq;
       ds = atan2(sqrt(sa),ca)/bq;
     } else {
       s = ( (dx*px + dy*py) + (py*px1-px*py1)/bq1)/p2;
       ds = s*s - (d2-2*(px1*dy-py1*dx)/bq1)/p2; 
       if( ds<0 ) ds = 0;
       ds = sqrt(ds);   
     }
 
     if( fabs(bq1)>1.e-8){
       s1 = atan2( -bq1*( bq*(dx*px1+dy*py1) + a), cS1 )/bq1;
       ds1 = atan2(sqrt(sa1),ca1)/bq1;  
     } else {
       s1 = (-(dx*px1 + dy*py1) + (py*px1-px*py1)/bq)/p21;
       ds1 = s1*s1 - (d2+2*(px*dy-py*dx)/bq)/p21; 
       if( ds1<0 ) ds1 = 0;
       ds1 = sqrt(ds1);
     }
   }
   Double_t ss[2], ss1[2], g[2][5],g1[2][5];
   
   ss[0] = s + ds;
   ss[1] = s - ds;
   ss1[0] = s1 + ds1;
   ss1[1] = s1 - ds1;
 
   for( Int_t i=0; i<2; i++){
     Double_t bs = bq*ss[i];
     Double_t c = cos(bs), sss = sin(bs);
     Double_t cB,sB;
     if( fabs(bq)>1.e-8){
       cB= (1-c)/bq;     
       sB= sss/bq;  
     }else{
       const Double_t kOvSqr6 = 1./sqrt(6.);
       sB = (1.-bs*kOvSqr6)*(1.+bs*kOvSqr6)*ss[i];
       cB = .5*sB*bs;
     }
     g[i][0] = fP[0] + sB*px + cB*py;
     g[i][1] = fP[1] - cB*px + sB*py;
     g[i][2] = fP[2] + ss[i]*pz;
     g[i][3] =       + c*px + sss*py;
     g[i][4] =       - sss*px + c*py;
 
     bs = bq1*ss1[i];  
     c =  cos(bs); sss = sin(bs);
     if( fabs(bq1)>1.e-8){
       cB= (1-c)/bq1;   
       sB= sss/bq1;  
     }else{
       const Double_t kOvSqr6 = 1./sqrt(6.);
       sB = (1.-bs*kOvSqr6)*(1.+bs*kOvSqr6)*ss1[i];
       cB = .5*sB*bs;
     }
       
     g1[i][0] = p.fP[0] + sB*px1 + cB*py1;
     g1[i][1] = p.fP[1] - cB*px1 + sB*py1;
     g1[i][2] = p.fP[2] + ss1[i]*pz1;
     g1[i][3] =         + c*px1 + sss*py1;
     g1[i][4] =         - sss*px1 + c*py1;
   }
 
   Int_t i=0, i1=0;
   
   Double_t dMin = 1.e10;
   for( Int_t j=0; j<2; j++){
     for( Int_t j1=0; j1<2; j1++){
       Double_t xx = g[j][0]-g1[j1][0];
       Double_t yy = g[j][1]-g1[j1][1];
       Double_t zz = g[j][2]-g1[j1][2];
       Double_t d = xx*xx + yy*yy + zz*zz;
       if( d<dMin ){
         dMin = d;
         i = j;
         i1 = j1;
       }
     }
   }  
 
   DS = ss[i];
   DS1 = ss1[i1];
   if(0){
     Double_t x= g[i][0], y= g[i][1], z= g[i][2], ppx= g[i][3], ppy= g[i][4];  
     Double_t x1=g1[i1][0], y1= g1[i1][1], z1= g1[i1][2], ppx1= g1[i1][3], ppy1= g1[i1][4];  
     Double_t dx = x1-x;
     Double_t dy = y1-y;
     Double_t dz = z1-z;
     Double_t a = ppx*ppx1 + ppy*ppy1 + pz*pz1;
     Double_t b = dx*ppx1 + dy*ppy1 + dz*pz1;
     Double_t c = dx*ppx  + dy*ppy  + dz*pz ;
     Double_t pp2 = ppx*ppx + ppy*ppy + pz*pz;
     Double_t pp21= ppx1*ppx1 + ppy1*ppy1 + pz1*pz1;
     Double_t det = pp2*pp21 - a*a;    
     if( fabs(det)>1.e-8 ){
       DS+=(a*b-pp21*c)/det;
       DS1+=(a*c-pp2*b)/det;
     }
   }
 }

void KFParticleBase::GetDStoParticleCBM	(	const KFParticleBase &	p,
		Double_t &	dS,
		Double_t &	dS1
	)		const

Definition at line 2230 of file KFParticleBase.cxx.

References Double_t, fP, fQ, GetDStoParticleBy(), GetDStoParticleLine(), and GetFieldValue().

Referenced by KFParticle::GetDStoParticleXY().

 {
   //* Transport the particle on dS, output to P[],C[], for CBM field
 
   GetDStoParticleLine( p, dS, dS1 );
   if( fQ==0 ){
     return;
   }
 
   Double_t fld[3];
   GetFieldValue( fP, fld );
 
   Double_t fld1[3];
   GetFieldValue( p.fP, fld1 );
 
 
   GetDStoParticleBy((fld[1]+fld1[1])/2,p,dS,dS1);
 
 //   construct coefficients 
 // int NIt;
 //   for(int i=0; i<10; i++)
 //   {
 // /*std::cout << "  dS temp "<<dS <<  "  dS1 temp "<< dS1 << std::endl;*/
 //     Double_t x[3],  dx[3],  ddx[3];
 //     Double_t x1[3], dx1[3], ddx1[3];
 // 
 //     GetDSIter(*this, dS, x, dx, ddx);
 //     GetDSIter(p, dS1, x1, dx1, ddx1);
 // 
 //     Double_t dr[3] = { x[0] - x1[0], x[1] - x1[1], x[2] - x1[2] };
 // 
 //     Double_t dS0 = dS;
 //     Double_t dS10 = dS1;
 // 
 //     Double_t f    = dx[0]  * dr[0] + dx[1]  * dr[1] + dx[2]  * dr[2];
 //     Double_t dfs  = ddx[0] * dr[0] + ddx[1] * dr[1] + ddx[2] * dr[2] + dx[0]*dx[0] + dx[1]*dx[1] + dx[2]*dx[2];
 //     Double_t dfs1 = -ddx[0] * ddx1[0] - ddx[1] * ddx1[1] - ddx[2] * ddx1[2];
 // 
 //     Double_t f1    = dx1[0]  * dr[0] + dx1[1]  * dr[1] + dx1[2]  * dr[2];
 //     Double_t df1s1 = ddx1[0] * dr[0] + ddx1[1] * dr[1] + ddx1[2] * dr[2] - dx1[0]*dx1[0] - dx1[1]*dx1[1] - dx1[2]*dx1[2];
 //     Double_t df1s  = -dfs1;
 // 
 //     Double_t det = dfs*df1s1 - dfs1*df1s;
 //     if(fabs(det) < 1.e-8) det = 1.e-8;
 // 
 //     Double_t DS  = dfs1*f1 - f*df1s1;
 //     Double_t DS1 = f*df1s - f1*dfs;
 // 
 //     dS  += DS/det;
 //     dS1 += DS1/det;
 //     NIt++;
 // /*    if( (fabs(dS - dS0) < fabs(dS)*0.001) && (fabs(dS1 - dS10) < fabs(dS1)*0.001)) break;*/
 //   }
 //std::cout << "NIt  " << NIt <<"  dS  "<<  dS << "  dS1  "<<  dS1 << std::endl;
 }

void KFParticleBase::GetDStoParticleLine	(	const KFParticleBase &	p,
		Double_t &	dS,
		Double_t &	dS1
	)		const

protected

Definition at line 2214 of file KFParticleBase.cxx.

References Double_t, fabs(), and fP.

Referenced by GetDStoParticleCBM().

 {
   Double_t p12 = fP[3]*fP[3] + fP[4]*fP[4] + fP[5]*fP[5];
   Double_t p22 = p.fP[3]*p.fP[3] + p.fP[4]*p.fP[4] + p.fP[5]*p.fP[5];
   Double_t p1p2 = fP[3]*p.fP[3] + fP[4]*p.fP[4] + fP[5]*p.fP[5];
 
   Double_t drp1 = fP[3]*(p.fP[0]-fP[0]) + fP[4]*(p.fP[1]-fP[1]) + fP[5]*(p.fP[2]-fP[2]);
   Double_t drp2 = p.fP[3]*(p.fP[0]-fP[0]) + p.fP[4]*(p.fP[1]-fP[1]) + p.fP[5]*(p.fP[2]-fP[2]);
 
   Double_t detp =  p1p2*p1p2 - p12*p22;
   if( fabs(detp)<1.e-4 ) detp = 1; //TODO correct!!!
 
   dS  = (drp2*p1p2 - drp1*p22) /detp;
   dS1 = (drp2*p12  - drp1*p1p2)/detp;
 }

virtual Double_t KFParticleBase::GetDStoPoint ( const Double_t xyz[] ) const

pure virtual

Implemented in KFParticle.

Referenced by ConstructGammaBz(), GetDeviationFromVertex(), GetDistanceFromVertex(), GetMeasurement(), and SetProductionVertex().

Double_t KFParticleBase::GetDStoPointBy	(	Double_t	By,
		const Double_t	xyz[]
	)		const

Definition at line 1734 of file KFParticleBase.cxx.

References a, atan2(), Double_t, dx, dy, fabs(), fP, and fQ.

Referenced by GetDStoPointCBM().

 { 
   
   //* Get dS to a certain space point for Bz field
   const Double_t kCLight = 0.000299792458;
   Double_t bq = B*fQ*kCLight;
   Double_t pt2 = fP[3]*fP[3] + fP[5]*fP[5];
   if( pt2<1.e-4 ) return 0;
   Double_t dx = xyz[0] - fP[0];
   Double_t dy = -xyz[2] + fP[2]; 
   Double_t a = dx*fP[3]-dy*fP[5];
   Double_t dS;
 
   if( fabs(bq)<1.e-8 ) dS = a/pt2;  
   else dS =  atan2( bq*a, pt2 + bq*(dy*fP[3] +dx*fP[5]) )/bq;
 
   return dS;
 }

Double_t KFParticleBase::GetDStoPointBz	(	Double_t	Bz,
		const Double_t	xyz[]
	)		const

Definition at line 1660 of file KFParticleBase.cxx.

References a, atan2(), c, cos(), d, Double_t, dx, dy, fabs(), fP, fQ, g, i, pz, s, sin(), sqrt(), x, y, and z.

Referenced by KFParticle::GetDStoPoint().

 { 
   
   //* Get dS to a certain space point for Bz field
   const Double_t kCLight = 0.000299792458;
   Double_t bq = B*fQ*kCLight;
   Double_t pt2 = fP[3]*fP[3] + fP[4]*fP[4];
   if( pt2<1.e-4 ) return 0;
   Double_t dx = xyz[0] - fP[0];
   Double_t dy = xyz[1] - fP[1]; 
   Double_t a = dx*fP[3]+dy*fP[4];
   Double_t dS;
 
   if( fabs(bq)<1.e-8 ) dS = a/pt2;  
   else dS =  atan2( bq*a, pt2 + bq*(dy*fP[3] -dx*fP[4]) )/bq;
 
   if(0){
 
     Double_t px = fP[3];
     Double_t py = fP[4];
     Double_t pz = fP[5];
     Double_t ss[2], g[2][5];
   
     ss[0] = dS;
     ss[1] = -dS;
     for( Int_t i=0; i<2; i++){
       Double_t bs = bq*ss[i];
       Double_t c = cos(bs), s = sin(bs);
       Double_t cB,sB;
       if( fabs(bq)>1.e-8){
         cB= (1-c)/bq;     
         sB= s/bq;  
       }else{
         const Double_t kOvSqr6 = 1./sqrt(6.);
         sB = (1.-bs*kOvSqr6)*(1.+bs*kOvSqr6)*ss[i];
         cB = .5*sB*bs;
       }
       g[i][0] = fP[0] + sB*px + cB*py;
       g[i][1] = fP[1] - cB*px + sB*py;
       g[i][2] = fP[2] + ss[i]*pz;
       g[i][3] =       + c*px + s*py;
       g[i][4] =       - s*px + c*py;      
     }
 
     Int_t i=0;
   
     Double_t dMin = 1.e10;
     for( Int_t j=0; j<2; j++){
       Double_t xx = g[j][0]-xyz[0];
       Double_t yy = g[j][1]-xyz[1];
       Double_t zz = g[j][2]-xyz[2];
       Double_t d = xx*xx + yy*yy + zz*zz;
       if( d<dMin ){
         dMin = d;
         i = j;
       }
     }
 
     dS = ss[i];
 
     Double_t x= g[i][0], y= g[i][1], z= g[i][2], ppx= g[i][3], ppy= g[i][4];      
     Double_t ddx = x-xyz[0];
     Double_t ddy = y-xyz[1];
     Double_t ddz = z-xyz[2];
     Double_t c = ddx*ppx  + ddy*ppy  + ddz*pz ;
     Double_t pp2 = ppx*ppx + ppy*ppy + pz*pz;    
     if( fabs(pp2)>1.e-8 ){
       dS+=c/pp2;
     }
   }
   return dS;
 }

Double_t KFParticleBase::GetDStoPointCBM ( const Double_t xyz[] ) const

Definition at line 2168 of file KFParticleBase.cxx.

References Double_t, fP, fQ, GetDStoPointBy(), GetDStoPointLine(), and GetFieldValue().

Referenced by KFParticle::GetDStoPoint().

 {
   //* Transport the particle on dS, output to P[],C[], for CBM field
 
   Double_t dS = 0;
   //Linear approximation
 
   Double_t fld[3];
   GetFieldValue( fP, fld );
 // 
 //   GetDStoParticleBy(fld[1],p,dS,dS1);
   dS = GetDStoPointLine( xyz );
 
   if( fQ==0 ){
     return dS;
   }
 
   dS = GetDStoPointBy( fld[1],xyz );
 
 //  const Double_t &px   = fP[3], &py   = fP[4], &pz   = fP[5];
 
 
   // construct coefficients 
 // int NIt;
 //   for(int i=0; i<100; i++)
 //   {
 // //std::cout << "  dS temp "<<dS << std::endl;
 //     Double_t x[3], dx[3], ddx[3];
 // 
 //     GetDSIter(*this, dS, x, dx, ddx);
 // 
 //     Double_t dr[3] = { x[0] - xyz[0], x[1] - xyz[1], x[2] - xyz[2] };
 // 
 //     Double_t dS0 = dS;
 // 
 //     Double_t f  = dx[0] * dr[0] + dx[1] * dr[1] + dx[2] * dr[2];
 //     Double_t df  = ddx[0] * dr[0] + ddx[1] * dr[1] + ddx[2] * dr[2] + dx[0]*dx[0] + dx[1]*dx[1] + dx[2]*dx[2];
 // 
 //     dS = dS - f/df;
 //     NIt++;
 //     if(fabs(dS - dS0) < fabs(dS)*0.001) break;
 //   }
 //std::cout << "NIt  " << NIt <<"  dS  "<<  dS << std::endl;
   return dS;
 }

Double_t KFParticleBase::GetDStoPointLine ( const Double_t xyz[] ) const

protected

Definition at line 1650 of file KFParticleBase.cxx.

References Double_t, fP, and p2.

Referenced by GetDStoPointCBM().

 {
   //* Get dS to a certain space point without field
 
   Double_t p2 = fP[3]*fP[3] + fP[4]*fP[4] + fP[5]*fP[5];  
   if( p2<1.e-4 ) p2 = 1;
   return ( fP[3]*(xyz[0]-fP[0]) + fP[4]*(xyz[1]-fP[1]) + fP[5]*(xyz[2]-fP[2]) )/p2;
 }

Double_t KFParticleBase::GetE ( ) const

inline

Definition at line 107 of file KFParticleBase.h.

References fP.

Referenced by KFParticle::GetE().

107 { return fP[6]; }

KFParticleBase::fMassHypo

Double_t fP[8]

Definition: KFParticleBase.h:306

Int_t KFParticleBase::GetEta	(	Double_t &	Eta,
		Double_t &	SigmaEta
	)		const

Definition at line 150 of file KFParticleBase.cxx.

References a, b, c, Double_t, fC, fP, h3, h4, log(), p, p2, pz, and sqrt().

Referenced by KFParticle::GetErrEta(), and KFParticle::GetEta().

 {
   //* Calculate particle pseudorapidity
 
   Double_t px = fP[3];
   Double_t py = fP[4];
   Double_t pz = fP[5];
   Double_t pt2 = px*px + py*py;
   Double_t p2 = pt2 + pz*pz;
   Double_t p = sqrt(p2);
   Double_t a = p + pz;
   Double_t b = p - pz;
   eta = 1.e10;
   if( b > 1.e-8 ){
     Double_t c = a/b;
     if( c>1.e-8 ) eta = 0.5*log(c);
   }
   Double_t h3 = -px*pz;
   Double_t h4 = -py*pz;  
   Double_t pt4 = pt2*pt2;
   Double_t p2pt4 = p2*pt4;
   error = (h3*h3*fC[9] + h4*h4*fC[14] + pt4*fC[20] + 2*( h3*(h4*fC[13] + fC[18]*pt2) + pt2*h4*fC[19] ) );
 
   if( error>0 && p2pt4>1.e-10 ){
     error = sqrt(error/p2pt4);
     return 0;
   }
 
   error = 1.e10;
   return 1;
 }

virtual void KFParticleBase::GetFieldValue	(	const Double_t	xyz[],
		Double_t	B[]
	)		const

pure virtual

Implemented in KFParticle.

Referenced by AddDaughterWithEnergyCalc(), AddDaughterWithEnergyFit(), AddDaughterWithEnergyFitMC(), Convert(), GetDSIter(), GetDStoParticleCBM(), GetDStoPointCBM(), GetMeasurement(), SubtractFromVertex(), and TransportCBM().

Int_t KFParticleBase::GetLifeTime	(	Double_t &	T,
		Double_t &	SigmaT
	)		const

Definition at line 311 of file KFParticleBase.cxx.

References Double_t, fC, fP, GetMass(), m, and sqrt().

Referenced by KFParticle::GetErrLifeTime(), and KFParticle::GetLifeTime().

 {
   //* Calculate particle decay time [s]
 
   Double_t m, dm;
   GetMass( m, dm );
   Double_t cTM = (-fP[3]*fC[31] - fP[4]*fC[32] - fP[5]*fC[33] + fP[6]*fC[34]);
   tauC = fP[7]*m;
   error = m*m*fC[35] + 2*fP[7]*cTM + fP[7]*fP[7]*dm*dm;
   if( error > 0 ){
     error = sqrt( error );
     return 0;
   }
   error = 1.e20;
   return 1;
 }

Int_t KFParticleBase::GetMass	(	Double_t &	M,
		Double_t &	SigmaM
	)		const

Definition at line 219 of file KFParticleBase.cxx.

References Double_t, fC, fP, m, m2(), s, and sqrt().

Referenced by KFParticle::GetErrMass(), GetLifeTime(), and KFParticle::GetMass().

 {
   //* Calculate particle mass
   
   // s = sigma^2 of m2/2
 
   Double_t s = (  fP[3]*fP[3]*fC[9] + fP[4]*fP[4]*fC[14] + fP[5]*fP[5]*fC[20] 
                   + fP[6]*fP[6]*fC[27] 
                 +2*( + fP[3]*fP[4]*fC[13] + fP[5]*(fP[3]*fC[18] + fP[4]*fC[19]) 
                      - fP[6]*( fP[3]*fC[24] + fP[4]*fC[25] + fP[5]*fC[26] )   )
                  ); 
 //   Double_t m2 = fabs(fP[6]*fP[6] - fP[3]*fP[3] - fP[4]*fP[4] - fP[5]*fP[5]);
 //   m  = sqrt(m2);
 //   if( m>1.e-10 ){
 //     if( s>=0 ){
 //       error = sqrt(s)/m;
 //       return 0;
 //     }
 //   }
 //   error = 1.e20;
   Double_t m2 = (fP[6]*fP[6] - fP[3]*fP[3] - fP[4]*fP[4] - fP[5]*fP[5]);
 
   if(m2<0.)
   {
     error = 1.e20;
     m = -sqrt(-m2);
     return 1;
   }
 
   m  = sqrt(m2);
   if( m>1.e-6 ){
     if( s >= 0 ) {
       error = sqrt(s)/m;
       return 0;
     }
   }
   else {
     error = 1.e20;
     return 0;
   }
   error = 1.e20;
 
   return 1;
 }

const Double_t& KFParticleBase::GetMassHypo ( ) const

inline

Definition at line 90 of file KFParticleBase.h.

References fMassHypo.

90 { return fMassHypo; }

Double_t fMassHypo

Definition: KFParticleBase.h:328

void KFParticleBase::GetMeasurement	(	const Double_t	XYZ[],
		Double_t	m[],
		Double_t	V[]
	)		const

protected

Definition at line 347 of file KFParticleBase.cxx.

References b, Double_t, GetDStoPoint(), GetFieldValue(), GetQ(), GetSCorrection(), h, and Transport().

Referenced by AddDaughterWithEnergyCalc(), AddDaughterWithEnergyFit(), AddDaughterWithEnergyFitMC(), ConstructGammaBz(), and SubtractFromVertex().

 {
   //* Get additional covariances V used during measurement
 
   Double_t b[3];
   GetFieldValue( XYZ, b );
   const Double_t kCLight =  0.000299792458;
   b[0]*=kCLight; b[1]*=kCLight; b[2]*=kCLight;
 // std::cout << "   DStoPoint "<< (GetDStoPoint(XYZ)) << std::endl;
   Transport( GetDStoPoint(XYZ), m, V );
 //std::cout << "x " << XYZ[0] << " " << m[0] <<"   y " << XYZ[1] << " " << m[1] <<"   z " << XYZ[2] << " " << m[2] <<std::endl;
   Double_t sigmaS = GetSCorrection( m, XYZ );
 
   Double_t h[6];
 
   h[0] = m[3]*sigmaS;
   h[1] = m[4]*sigmaS;
   h[2] = m[5]*sigmaS;
   h[3] = ( h[1]*b[2]-h[2]*b[1] )*GetQ();
   h[4] = ( h[2]*b[0]-h[0]*b[2] )*GetQ();
   h[5] = ( h[0]*b[1]-h[1]*b[0] )*GetQ();
     
   V[ 0]+= h[0]*h[0];
   V[ 1]+= h[1]*h[0];
   V[ 2]+= h[1]*h[1];
   V[ 3]+= h[2]*h[0];
   V[ 4]+= h[2]*h[1];
   V[ 5]+= h[2]*h[2];
 
   V[ 6]+= h[3]*h[0];
   V[ 7]+= h[3]*h[1];
   V[ 8]+= h[3]*h[2];
   V[ 9]+= h[3]*h[3];
 
   V[10]+= h[4]*h[0];
   V[11]+= h[4]*h[1];
   V[12]+= h[4]*h[2];
   V[13]+= h[4]*h[3];
   V[14]+= h[4]*h[4];
 
   V[15]+= h[5]*h[0];
   V[16]+= h[5]*h[1];
   V[17]+= h[5]*h[2];
   V[18]+= h[5]*h[3];
   V[19]+= h[5]*h[4];
   V[20]+= h[5]*h[5];
 }

Int_t KFParticleBase::GetMomentum	(	Double_t &	P,
		Double_t &	SigmaP
	)		const

Definition at line 110 of file KFParticleBase.cxx.

References Double_t, fC, fP, p, p2, sqrt(), x, y, and z.

Referenced by KFParticle::GetErrMomentum(), KFParticle::GetErrP(), KFParticle::GetMomentum(), and KFParticle::GetP().

 {
   //* Calculate particle momentum
 
   Double_t x = fP[3];
   Double_t y = fP[4];
   Double_t z = fP[5];
   Double_t x2 = x*x;
   Double_t y2 = y*y;
   Double_t z2 = z*z;
   Double_t p2 = x2+y2+z2;
   p = sqrt(p2);
   error = (x2*fC[9]+y2*fC[14]+z2*fC[20] + 2*(x*y*fC[13]+x*z*fC[18]+y*z*fC[19]) );
   if( error>1.e-16 && p>1.e-4 ){
     error = sqrt(error)/p;
     return 0;
   }
   error = 1.e8;
   return 1;
 }

Int_t KFParticleBase::GetNDF ( ) const

inline

Definition at line 111 of file KFParticleBase.h.

References fNDF.

Referenced by KFParticle::GetNDF().

111 { return fNDF; }

KFParticleBase::fNDF

Int_t fNDF

Definition: KFParticleBase.h:309

Double_t KFParticleBase::GetParameter ( Int_t i ) const

inline

Definition at line 125 of file KFParticleBase.h.

References fP, and i.

Referenced by KFParticle::GetParameter().

125 { return fP[i]; }

Int_t i

Definition: run_full.C:25

Double_t fP[8]

Definition: KFParticleBase.h:306

int KFParticleBase::GetPDG ( ) const

inline

Definition at line 277 of file KFParticleBase.h.

References fPDG.

Referenced by KFParticleSIMD::KFParticleSIMD().

277 { return fPDG; }

KFParticleBase::fPDG

int fPDG

Definition: KFParticleBase.h:333

Int_t KFParticleBase::GetPhi	(	Double_t &	Phi,
		Double_t &	SigmaPhi
	)		const

Definition at line 182 of file KFParticleBase.cxx.

References atan2(), Double_t, fC, fP, and sqrt().

Referenced by KFParticle::GetErrPhi(), and KFParticle::GetPhi().

 {
   //* Calculate particle polar angle
 
   Double_t px = fP[3];
   Double_t py = fP[4];
   Double_t px2 = px*px;
   Double_t py2 = py*py;
   Double_t pt2 = px2 + py2;
   phi = atan2(py,px);
   error = (py2*fC[9] + px2*fC[14] - 2*px*py*fC[13] );
   if( error>0 && pt2>1.e-4 ){
     error = sqrt(error)/pt2;
     return 0;
   }
   error = 1.e10;
   return 1;
 }

Int_t KFParticleBase::GetPt	(	Double_t &	Pt,
		Double_t &	SigmaPt
	)		const

Definition at line 131 of file KFParticleBase.cxx.

References Double_t, fC, fP, pt(), and sqrt().

Referenced by KFParticle::GetErrPt(), and KFParticle::GetPt().

 {
   //* Calculate particle transverse momentum
 
   Double_t px = fP[3];
   Double_t py = fP[4];
   Double_t px2 = px*px;
   Double_t py2 = py*py;
   Double_t pt2 = px2+py2;
   pt = sqrt(pt2);
   error = (px2*fC[9] + py2*fC[14] + 2*px*py*fC[13] );
   if( error>0 && pt>1.e-4 ){
     error = sqrt(error)/pt;
     return 0;
   }
   error = 1.e10;
   return 1;
 }

Double_t KFParticleBase::GetPx ( ) const

inline

Definition at line 104 of file KFParticleBase.h.

References fP.

Referenced by GetArmenterosPodolanski(), KFParticle::GetExternalTrackParam(), and KFParticle::GetPx().

104 { return fP[3]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

Double_t KFParticleBase::GetPy ( ) const

inline

Definition at line 105 of file KFParticleBase.h.

References fP.

Referenced by GetArmenterosPodolanski(), KFParticle::GetExternalTrackParam(), and KFParticle::GetPy().

105 { return fP[4]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

Double_t KFParticleBase::GetPz ( ) const

inline

Definition at line 106 of file KFParticleBase.h.

References fP.

Referenced by GetArmenterosPodolanski(), KFParticle::GetExternalTrackParam(), and KFParticle::GetPz().

106 { return fP[5]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

Int_t KFParticleBase::GetQ ( ) const

inline

Definition at line 109 of file KFParticleBase.h.

References fQ.

Referenced by AddDaughter(), AddDaughterWithEnergyCalc(), AddDaughterWithEnergyFit(), AddDaughterWithEnergyFitMC(), ConstructGammaBz(), KFParticle::GetExternalTrackParam(), GetMeasurement(), and KFParticle::GetQ().

109 { return fQ; }

KFParticleBase::fQ

Int_t fQ

Definition: KFParticleBase.h:308

Int_t KFParticleBase::GetR	(	Double_t &	R,
		Double_t &	SigmaR
	)		const

Definition at line 201 of file KFParticleBase.cxx.

References Double_t, fC, fP, r, sqrt(), x, and y.

Referenced by KFParticle::GetErrR(), and KFParticle::GetR().

 {
   //* Calculate distance to the origin
 
   Double_t x = fP[0];
   Double_t y = fP[1];
   Double_t x2 = x*x;
   Double_t y2 = y*y;
   r = sqrt(x2 + y2);
   error = (x2*fC[0] + y2*fC[2] - 2*x*y*fC[1] );
   if( error>0 && r>1.e-4 ){
     error = sqrt(error)/r;
     return 0;
   }
   error = 1.e10;
   return 1;
 }

Double_t KFParticleBase::GetS ( ) const

inline

Definition at line 108 of file KFParticleBase.h.

References fP.

Referenced by KFParticle::GetS().

108 { return fP[7]; }

KFParticleBase::SumDaughterMass

Double_t fP[8]

Definition: KFParticleBase.h:306

Double_t KFParticleBase::GetSCorrection	(	const Double_t	Part[],
		const Double_t	XYZ[]
	)

staticprotected

Definition at line 336 of file KFParticleBase.cxx.

References d, Double_t, p2, and sqrt().

Referenced by GetMeasurement().

 {
   //* Get big enough correction for S error to let the particle Part be fitted to XYZ point
   
   Double_t d[3] = { XYZ[0]-Part[0], XYZ[1]-Part[1], XYZ[2]-Part[2] };
   Double_t p2 = Part[3]*Part[3]+Part[4]*Part[4]+Part[5]*Part[5];
 //  Double_t sigmaS = (p2>1.e-4) ? ( 10.1+3.*sqrt( d[0]*d[0]+d[1]*d[1]+d[2]*d[2]) )/sqrt(p2) : 1.;
   Double_t sigmaS = (p2>1.e-4) ? ( 0.1+10.*sqrt( d[0]*d[0]+d[1]*d[1]+d[2]*d[2]) )/sqrt(p2) : 1.;
   return sigmaS;
 }

const Double_t& KFParticleBase::GetSumDaughterMass ( ) const

inline

Definition at line 93 of file KFParticleBase.h.

References SumDaughterMass.

93 {return SumDaughterMass;}

Double_t SumDaughterMass

Definition: KFParticleBase.h:327

Double_t KFParticleBase::GetX ( ) const

inline

Definition at line 101 of file KFParticleBase.h.

References fP.

Referenced by KFParticle::GetExternalTrackParam(), KFParticle::GetX(), and RotateXY().

101 { return fP[0]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

Double_t KFParticleBase::GetY ( ) const

inline

Definition at line 102 of file KFParticleBase.h.

References fP.

Referenced by KFParticle::GetExternalTrackParam(), KFParticle::GetY(), and RotateXY().

102 { return fP[1]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

Double_t KFParticleBase::GetZ ( ) const

inline

Definition at line 103 of file KFParticleBase.h.

References fP.

Referenced by KFParticle::GetExternalTrackParam(), KFParticle::GetZ(), and RotateXY().

103 { return fP[2]; }

KFParticleBase::fDaughtersIds

Double_t fP[8]

Definition: KFParticleBase.h:306

int KFParticleBase::Id ( ) const

inline

Definition at line 269 of file KFParticleBase.h.

References fId.

Referenced by KFParticleSIMD::KFParticleSIMD().

269 { return fId; };

KFParticleBase::fId

int fId

Definition: KFParticleBase.h:330

static Int_t KFParticleBase::IJ	(	Int_t	i,
		Int_t	j
	)

inlinestaticprotected

Definition at line 281 of file KFParticleBase.h.

References i.

Referenced by Cij(), ConstructGammaBz(), Covariance(), GetCovariance(), and SetMassConstraint().

                                      { 
     return ( j<=i ) ? i*(i+1)/2+j :j*(j+1)/2+i;
   }

void KFParticleBase::Initialize	(	const Double_t	Param[],
		const Double_t	Cov[],
		Int_t	Charge,
		Double_t	Mass
	)

Definition at line 32 of file KFParticleBase.cxx.

References Double_t, energy, fAtProductionVertex, fC, fChi2, fIsLinearized, fMassHypo, fNDF, fP, fQ, fSFromDecay, h1, h2, i, Mass, sqrt(), and SumDaughterMass.

 {
   // Constructor from "cartesian" track, particle mass hypothesis should be provided
   //
   // Param[6] = { X, Y, Z, Px, Py, Pz } - position and momentum
   // Cov [21] = lower-triangular part of the covariance matrix:
   //
   //                (  0  .  .  .  .  . )
   //                (  1  2  .  .  .  . )
   //  Cov. matrix = (  3  4  5  .  .  . ) - numbering of covariance elements in Cov[]
   //                (  6  7  8  9  .  . )
   //                ( 10 11 12 13 14  . )
   //                ( 15 16 17 18 19 20 )
 
 
   for( Int_t i=0; i<6 ; i++ ) fP[i] = Param[i];
   for( Int_t i=0; i<21; i++ ) fC[i] = Cov[i];
 
   Double_t energy = sqrt( Mass*Mass + fP[3]*fP[3] + fP[4]*fP[4] + fP[5]*fP[5]);
   fP[6] = energy;
   fP[7] = 0;
   fQ = Charge;
   fNDF = 0;
   fChi2 = 0;
   fAtProductionVertex = 0;
   fIsLinearized = 0;
   fSFromDecay = 0;
 
   Double_t energyInv = 1./energy;
   Double_t 
     h0 = fP[3]*energyInv,
     h1 = fP[4]*energyInv,
     h2 = fP[5]*energyInv;
 
   fC[21] = h0*fC[ 6] + h1*fC[10] + h2*fC[15];
   fC[22] = h0*fC[ 7] + h1*fC[11] + h2*fC[16];
   fC[23] = h0*fC[ 8] + h1*fC[12] + h2*fC[17];
   fC[24] = h0*fC[ 9] + h1*fC[13] + h2*fC[18];
   fC[25] = h0*fC[13] + h1*fC[14] + h2*fC[19];
   fC[26] = h0*fC[18] + h1*fC[19] + h2*fC[20];
   fC[27] = ( h0*h0*fC[ 9] + h1*h1*fC[14] + h2*h2*fC[20] 
              + 2*(h0*h1*fC[13] + h0*h2*fC[18] + h1*h2*fC[19] ) );
   for( Int_t i=28; i<36; i++ ) fC[i] = 0;
   fC[35] = 1.;
 
   SumDaughterMass = Mass;
   fMassHypo = Mass;
 }

void KFParticleBase::Initialize ( )

Definition at line 81 of file KFParticleBase.cxx.

References fAtProductionVertex, fC, fChi2, fIsLinearized, fMassHypo, fNDF, fP, fQ, fSFromDecay, fVtxGuess, i, and SumDaughterMass.

Referenced by KFParticle::Create(), KFParticle::Initialize(), and KFParticleBase().

 {
   //* Initialise covariance matrix and set current parameters to 0.0 
 
   for( Int_t i=0; i<8; i++) fP[i] = 0;
   for(Int_t i=0;i<36;++i) fC[i]=0.;
   fC[0] = fC[2] = fC[5] = 100.;
   fC[35] = 1.;
   fNDF  = -3;
   fChi2 =  0.;
   fQ = 0;
   fSFromDecay = 0;
   fAtProductionVertex = 0;
   fVtxGuess[0]=fVtxGuess[1]=fVtxGuess[2]=0.;
   fIsLinearized = 0;
   SumDaughterMass = 0;
   fMassHypo = -1;
 }

Bool_t KFParticleBase::InvertSym3	(	const Double_t	A[],
		Double_t	Ainv[]
	)

staticprotected

Definition at line 3300 of file KFParticleBase.cxx.

References Double_t, and fabs().

Referenced by ConstructGammaBz(), and SetProductionVertex().

 {
   //* Invert symmetric matric stored in low-triagonal form 
 
   bool ret = 0;
   double a0 = A[0], a1 = A[1], a2 = A[2], a3 = A[3];
 
   Ai[0] = a2*A[5] - A[4]*A[4];
   Ai[1] = a3*A[4] - a1*A[5];
   Ai[3] = a1*A[4] - a2*a3;
   Double_t det = (a0*Ai[0] + a1*Ai[1] + a3*Ai[3]);
   if( fabs(det)>1.e-20 ) det = 1./det;    
   else{ 
     det = 0;
     ret = 1;
   }
   Ai[0] *= det;
   Ai[1] *= det;
   Ai[3] *= det;
   Ai[2] = ( a0*A[5] - a3*a3 )*det;
   Ai[4] = ( a1*a3 - a0*A[4] )*det;
   Ai[5] = ( a0*a2 - a1*a1 )*det;
   return ret;
 }

void KFParticleBase::MultQSQt	(	const Double_t	Q[],
		const Double_t	S[],
		Double_t	SOut[]
	)

staticprotected

Definition at line 3325 of file KFParticleBase.cxx.

References Double_t, and i.

Referenced by TransportCBM().

 {
   //* Matrix multiplication Q*S*Q^T, Q - square matrix, S - symmetric
 
   const Int_t kN= 8;
   Double_t mA[kN*kN];
   
   for( Int_t i=0, ij=0; i<kN; i++ ){
     for( Int_t j=0; j<kN; j++, ++ij ){
       mA[ij] = 0 ;
       for( Int_t k=0; k<kN; ++k ) mA[ij]+= S[( k<=i ) ? i*(i+1)/2+k :k*(k+1)/2+i] * Q[ j*kN+k];
     }
   }
     
   for( Int_t i=0; i<kN; i++ ){
     for( Int_t j=0; j<=i; j++ ){
       Int_t ij = ( j<=i ) ? i*(i+1)/2+j :j*(j+1)/2+i;
       SOut[ij] = 0 ;
       for( Int_t k=0; k<kN; k++ )  SOut[ij] += Q[ i*kN+k ] * mA[ k*kN+j ];
     }
   }
 }

int KFParticleBase::NDaughters ( ) const

inline

Definition at line 270 of file KFParticleBase.h.

References fDaughtersIds.

Referenced by KFParticleSIMD::KFParticleSIMD().

270 { return fDaughtersIds.size(); };

std::vector< int > fDaughtersIds

Definition: KFParticleBase.h:331

const Int_t& KFParticleBase::NDF ( ) const

inline

Definition at line 123 of file KFParticleBase.h.

References fNDF.

Referenced by KFParticle::NDF().

123 { return fNDF; }

KFParticleBase::fNDF

Int_t fNDF

Definition: KFParticleBase.h:309

Int_t& KFParticleBase::NDF ( )

inline

Definition at line 156 of file KFParticleBase.h.

References fNDF.

156 { return fNDF; }

KFParticleBase::fNDF

Int_t fNDF

Definition: KFParticleBase.h:309

void KFParticleBase::operator+= ( const KFParticleBase & Daughter )

Definition at line 329 of file KFParticleBase.cxx.

References AddDaughter().

Referenced by KFParticle::operator+=().

 {
   //* Add daughter via operator+=
 
   AddDaughter( Daughter );
 }

Double_t& KFParticleBase::Parameter ( Int_t i )

inline

Definition at line 158 of file KFParticleBase.h.

References fP, and i.

Referenced by KFParticle::Parameter().

158 { return fP[i]; }

Int_t i

Definition: run_full.C:25

Double_t fP[8]

Definition: KFParticleBase.h:306

const Double_t& KFParticleBase::Px ( ) const

inline

Definition at line 116 of file KFParticleBase.h.

References fP.

Referenced by KFParticle::Px().

116 { return fP[3]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

Double_t& KFParticleBase::Px ( )

inline

Definition at line 149 of file KFParticleBase.h.

References fP.

149 { return fP[3]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

const Double_t& KFParticleBase::Py ( ) const

inline

Definition at line 117 of file KFParticleBase.h.

References fP.

Referenced by KFParticle::Py().

117 { return fP[4]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

Double_t& KFParticleBase::Py ( )

inline

Definition at line 150 of file KFParticleBase.h.

References fP.

150 { return fP[4]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

const Double_t& KFParticleBase::Pz ( ) const

inline

Definition at line 118 of file KFParticleBase.h.

References fP.

Referenced by KFParticle::Pz().

118 { return fP[5]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

Double_t& KFParticleBase::Pz ( )

inline

Definition at line 151 of file KFParticleBase.h.

References fP.

151 { return fP[5]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

const Int_t& KFParticleBase::Q ( ) const

inline

Definition at line 121 of file KFParticleBase.h.

References fQ.

Referenced by KFParticle::Q().

121 { return fQ; }

KFParticleBase::fQ

Int_t fQ

Definition: KFParticleBase.h:308

Int_t& KFParticleBase::Q ( )

inline

Definition at line 154 of file KFParticleBase.h.

References fQ.

154 { return fQ; }

KFParticleBase::fQ

Int_t fQ

Definition: KFParticleBase.h:308

void KFParticleBase::RotateXY	(	Double_t	angle,
		Double_t	Vtx[3]
	)

Definition at line 3233 of file KFParticleBase.cxx.

References c, cos(), Covariance(), Double_t, fP, GetCovariance(), GetX(), GetY(), GetZ(), i, s, sin(), X(), Y(), and Z().

 {
   // Rotates the KFParticle object around OZ axis, OZ axis is set by the vertex position
   // Double_t angle - angle of rotation in XY plane in [rad]
   // Double_t Vtx[3] - position of the vertex in [cm]
 
   // Before rotation the center of the coordinat system should be moved to the vertex position; move back after rotation
   X() = X() - Vtx[0];
   Y() = Y() - Vtx[1];
   Z() = Z() - Vtx[2];
 
   // Rotate the kf particle
   Double_t c = cos(angle);
   Double_t s = sin(angle);
 
   Double_t mA[8][ 8];
   for( Int_t i=0; i<8; i++ ){
     for( Int_t j=0; j<8; j++){
       mA[i][j] = 0;
     }
   }
   for( int i=0; i<8; i++ ){
     mA[i][i] = 1;
   }
   mA[0][0] =  c;  mA[0][1] = s;
   mA[1][0] = -s;  mA[1][1] = c;
   mA[3][3] =  c;  mA[3][4] = s;
   mA[4][3] = -s;  mA[4][4] = c;
 
   Double_t mAC[8][8];
   Double_t mAp[8];
 
   for( Int_t i=0; i<8; i++ ){
     mAp[i] = 0;
     for( Int_t k=0; k<8; k++){
       mAp[i]+=mA[i][k] * fP[k];
     }
   }
 
   for( Int_t i=0; i<8; i++){
     fP[i] = mAp[i];
   }
 
   for( Int_t i=0; i<8; i++ ){
     for( Int_t j=0; j<8; j++ ){
       mAC[i][j] = 0;
       for( Int_t k=0; k<8; k++ ){
         mAC[i][j]+= mA[i][k] * GetCovariance(k,j);
       }
     }
   }
 
   for( Int_t i=0; i<8; i++ ){
     for( Int_t j=0; j<=i; j++ ){
       Double_t xx = 0;
       for( Int_t k=0; k<8; k++){
         xx+= mAC[i][k]*mA[j][k];
       }
       Covariance(i,j) = xx;
     }
   }
 
   X() = GetX() + Vtx[0];
   Y() = GetY() + Vtx[1];
   Z() = GetZ() + Vtx[2];
 }

const Double_t& KFParticleBase::S ( ) const

inline

Definition at line 120 of file KFParticleBase.h.

References fP.

Referenced by KFParticle::S().

120 { return fP[7]; }

Double_t fP[8]

Definition: KFParticleBase.h:306

Double_t& KFParticleBase::S ( )

inline

Definition at line 153 of file KFParticleBase.h.

References fP.

153 { return fP[7]; }