+Double_t AliESDV0MI::GetSigmaY(){
+ //
+ // return sigmay in y at vertex position using covariance matrix
+ //
+ const Double_t * cp = fParamP.GetCovariance();
+ const Double_t * cm = fParamM.GetCovariance();
+ Double_t sigmay = cp[0]+cm[0]+ cp[5]*(fParamP.GetX()-fRr)*(fParamP.GetX()-fRr)+ cm[5]*(fParamM.GetX()-fRr)*(fParamM.GetX()-fRr);
+ return (sigmay>0) ? TMath::Sqrt(sigmay):100;
+}
+
+Double_t AliESDV0MI::GetSigmaZ(){
+ //
+ // return sigmay in y at vertex position using covariance matrix
+ //
+ const Double_t * cp = fParamP.GetCovariance();
+ const Double_t * cm = fParamM.GetCovariance();
+ Double_t sigmaz = cp[2]+cm[2]+ cp[9]*(fParamP.GetX()-fRr)*(fParamP.GetX()-fRr)+ cm[9]*(fParamM.GetX()-fRr)*(fParamM.GetX()-fRr);
+ return (sigmaz>0) ? TMath::Sqrt(sigmaz):100;
+}
+
+Double_t AliESDV0MI::GetSigmaD0(){
+ //
+ // Sigma parameterization using covariance matrix
+ //
+ // sigma of distance between two tracks in vertex position
+ // sigma of DCA is proportianal to sigmaD0
+ // factor 2 difference is explained by the fact that the DCA is calculated at the position
+ // where the tracks as closest together ( not exact position of the vertex)
+ //
+ const Double_t * cp = fParamP.GetCovariance();
+ const Double_t * cm = fParamM.GetCovariance();
+ Double_t sigmaD0 = cp[0]+cm[0]+cp[2]+cm[2]+fgkParams.fPSigmaOffsetD0*fgkParams.fPSigmaOffsetD0;
+ sigmaD0 += ((fParamP.GetX()-fRr)*(fParamP.GetX()-fRr))*(cp[5]+cp[9]);
+ sigmaD0 += ((fParamM.GetX()-fRr)*(fParamM.GetX()-fRr))*(cm[5]+cm[9]);
+ return (sigmaD0>0)? TMath::Sqrt(sigmaD0):100;
+}
+
+
+Double_t AliESDV0MI::GetSigmaAP0(){
+ //
+ //Sigma parameterization using covariance matrices
+ //
+ Double_t prec = TMath::Sqrt((fPM[0]+fPP[0])*(fPM[0]+fPP[0])
+ +(fPM[1]+fPP[1])*(fPM[1]+fPP[1])
+ +(fPM[2]+fPP[2])*(fPM[2]+fPP[2]));
+ Double_t normp = TMath::Sqrt(fPP[0]*fPP[0]+fPP[1]*fPP[1]+fPP[2]*fPP[2])/prec; // fraction of the momenta
+ Double_t normm = TMath::Sqrt(fPM[0]*fPM[0]+fPM[1]*fPM[1]+fPM[2]*fPM[2])/prec;
+ const Double_t * cp = fParamP.GetCovariance();
+ const Double_t * cm = fParamM.GetCovariance();
+ Double_t sigmaAP0 = fgkParams.fPSigmaOffsetAP0*fgkParams.fPSigmaOffsetAP0; // minimal part
+ sigmaAP0 += (cp[5]+cp[9])*(normp*normp)+(cm[5]+cm[9])*(normm*normm); // angular resolution part
+ Double_t sigmaAP1 = GetSigmaD0()/(TMath::Abs(fRr)+0.01); // vertex position part
+ sigmaAP0 += 0.5*sigmaAP1*sigmaAP1;
+ return (sigmaAP0>0)? TMath::Sqrt(sigmaAP0):100;
+}
+
+Double_t AliESDV0MI::GetEffectiveSigmaD0(){
+ //
+ // minimax - effective Sigma parameterization
+ // p12 effective curvature and v0 radius postion used as parameters
+ //
+ Double_t p12 = TMath::Sqrt(fParamP.GetParameter()[4]*fParamP.GetParameter()[4]+
+ fParamM.GetParameter()[4]*fParamM.GetParameter()[4]);
+ Double_t sigmaED0= TMath::Max(TMath::Sqrt(fRr)-fgkParams.fPSigmaRminDE,0.0)*fgkParams.fPSigmaCoefDE*p12*p12;
+ sigmaED0*= sigmaED0;
+ sigmaED0*= sigmaED0;
+ sigmaED0 = TMath::Sqrt(sigmaED0+fgkParams.fPSigmaOffsetDE*fgkParams.fPSigmaOffsetDE);
+ return (sigmaED0<fgkParams.fPSigmaMaxDE) ? sigmaED0: fgkParams.fPSigmaMaxDE;
+}
+
+
+Double_t AliESDV0MI::GetEffectiveSigmaAP0(){
+ //
+ // effective Sigma parameterization of point angle resolution
+ //
+ Double_t p12 = TMath::Sqrt(fParamP.GetParameter()[4]*fParamP.GetParameter()[4]+
+ fParamM.GetParameter()[4]*fParamM.GetParameter()[4]);
+ Double_t sigmaAPE= fgkParams.fPSigmaBase0APE;
+ sigmaAPE+= fgkParams.fPSigmaR0APE/(fgkParams.fPSigmaR1APE+fRr);
+ sigmaAPE*= (fgkParams.fPSigmaP0APE+fgkParams.fPSigmaP1APE*p12);
+ sigmaAPE = TMath::Min(sigmaAPE,fgkParams.fPSigmaMaxAPE);
+ return sigmaAPE;
+}
+
+
+Double_t AliESDV0MI::GetMinimaxSigmaAP0(){
+ //
+ // calculate mini-max effective sigma of point angle resolution
+ //
+ //compv0->fTree->SetAlias("SigmaAP2","max(min((SigmaAP0+SigmaAPE0)*0.5,1.5*SigmaAPE0),0.5*SigmaAPE0+0.003)");
+ Double_t effectiveSigma = GetEffectiveSigmaAP0();
+ Double_t sigmaMMAP = 0.5*(GetSigmaAP0()+effectiveSigma);
+ sigmaMMAP = TMath::Min(sigmaMMAP, fgkParams.fPMaxFractionAP0*effectiveSigma);
+ sigmaMMAP = TMath::Max(sigmaMMAP, fgkParams.fPMinFractionAP0*effectiveSigma+fgkParams.fPMinAP0);
+ return sigmaMMAP;
+}
+Double_t AliESDV0MI::GetMinimaxSigmaD0(){
+ //
+ // calculate mini-max sigma of dca resolution
+ //
+ //compv0->fTree->SetAlias("SigmaD2","max(min((SigmaD0+SigmaDE0)*0.5,1.5*SigmaDE0),0.5*SigmaDE0)");
+ Double_t effectiveSigma = GetEffectiveSigmaD0();
+ Double_t sigmaMMD0 = 0.5*(GetSigmaD0()+effectiveSigma);
+ sigmaMMD0 = TMath::Min(sigmaMMD0, fgkParams.fPMaxFractionD0*effectiveSigma);
+ sigmaMMD0 = TMath::Max(sigmaMMD0, fgkParams.fPMinFractionD0*effectiveSigma+fgkParams.fPMinD0);
+ return sigmaMMD0;
+}
+
+
+Double_t AliESDV0MI::GetLikelihoodAP(Int_t mode0, Int_t mode1){
+ //
+ // get likelihood for point angle
+ //
+ Double_t sigmaAP = 0.007; //default sigma
+ switch (mode0){
+ case 0:
+ sigmaAP = GetSigmaAP0(); // mode 0 - covariance matrix estimates used
+ break;
+ case 1:
+ sigmaAP = GetEffectiveSigmaAP0(); // mode 1 - effective sigma used
+ break;
+ case 2:
+ sigmaAP = GetMinimaxSigmaAP0(); // mode 2 - minimax sigma
+ break;
+ }
+ Double_t apNorm = TMath::Min(TMath::ACos(fPointAngle)/sigmaAP,50.);
+ //normalized point angle, restricted - because of overflow problems in Exp
+ Double_t likelihood = 0;
+ switch(mode1){
+ case 0:
+ likelihood = TMath::Exp(-0.5*apNorm*apNorm);
+ // one component
+ break;
+ case 1:
+ likelihood = (TMath::Exp(-0.5*apNorm*apNorm)+0.5* TMath::Exp(-0.25*apNorm*apNorm))/1.5;
+ // two components
+ break;
+ case 2:
+ likelihood = (TMath::Exp(-0.5*apNorm*apNorm)+0.5* TMath::Exp(-0.25*apNorm*apNorm)+0.25*TMath::Exp(-0.125*apNorm*apNorm))/1.75;
+ // three components
+ break;
+ }
+ return likelihood;
+}
+
+Double_t AliESDV0MI::GetLikelihoodD(Int_t mode0, Int_t mode1){
+ //
+ // get likelihood for DCA
+ //
+ Double_t sigmaD = 0.03; //default sigma
+ switch (mode0){
+ case 0:
+ sigmaD = GetSigmaD0(); // mode 0 - covariance matrix estimates used
+ break;
+ case 1:
+ sigmaD = GetEffectiveSigmaD0(); // mode 1 - effective sigma used
+ break;
+ case 2:
+ sigmaD = GetMinimaxSigmaD0(); // mode 2 - minimax sigma
+ break;
+ }
+ Double_t dNorm = TMath::Min(fDist2/sigmaD,50.);
+ //normalized point angle, restricted - because of overflow problems in Exp
+ Double_t likelihood = 0;
+ switch(mode1){
+ case 0:
+ likelihood = TMath::Exp(-2.*dNorm);
+ // one component
+ break;
+ case 1:
+ likelihood = (TMath::Exp(-2.*dNorm)+0.5* TMath::Exp(-dNorm))/1.5;
+ // two components
+ break;
+ case 2:
+ likelihood = (TMath::Exp(-2.*dNorm)+0.5* TMath::Exp(-dNorm)+0.25*TMath::Exp(-0.5*dNorm))/1.75;
+ // three components
+ break;
+ }
+ return likelihood;
+
+}
+
+Double_t AliESDV0MI::GetLikelihoodC(Int_t mode0, Int_t /*mode1*/){
+ //
+ // get likelihood for Causality
+ // !!! Causality variables defined in AliITStrackerMI !!!
+ // when more information was available
+ //
+ Double_t likelihood = 0.5;
+ Double_t minCausal = TMath::Min(fCausality[0],fCausality[1]);
+ Double_t maxCausal = TMath::Max(fCausality[0],fCausality[1]);
+ // minCausal = TMath::Max(minCausal,0.5*maxCausal);
+ //compv0->fTree->SetAlias("LCausal","(1.05-(2*(0.8-exp(-max(RC.fV0rec.fCausality[0],RC.fV0rec.fCausality[1])))+2*(0.8-exp(-min(RC.fV0rec.fCausality[0],RC.fV0rec.fCausality[1]))))/2)**4");
+
+ switch(mode0){
+ case 0:
+ //normalization
+ likelihood = TMath::Power((1.05-2*(0.8-TMath::Exp(-maxCausal))),4.);
+ break;
+ case 1:
+ likelihood = TMath::Power(1.05-(2*(0.8-TMath::Exp(-maxCausal))+(2*(0.8-TMath::Exp(-minCausal))))*0.5,4.);
+ break;
+ }
+ return likelihood;
+
+}