#include "AliLog.h"
#include "AliRun.h"
#include "AliMagF.h"
+#include "AliMathBase.h"
//#define DEBUG
z1 -= z0; // Distance from where track traveled
z2 -= z0; // Distance from where track traveled
s = 0.25; // Correction based on definision of Erfc
- s *= TMath::Erfc(sp*x1) - TMath::Erfc(sp*x2);
+ s *= AliMathBase::ErfcFast(sp*x1) - AliMathBase::ErfcFast(sp*x2);
if(GetDebug(3)){
cout <<"el="<<el<<" ix0="<<ix0<<" ix="<<ix<<" x0="<<x<<
" iz0="<<iz0<<" iz="<<iz<<" z0="<<z<<
" sp*x1="<<sp*x1<<" sp*x2="<<sp*x2<<" s="<<s;
} // end if GetDebug
- s *= TMath::Erfc(sp*z1) - TMath::Erfc(sp*z2);
+ s *= AliMathBase::ErfcFast(sp*z1) - AliMathBase::ErfcFast(sp*z2);
if(GetDebug(3)){
cout<<" sp*z1="<<sp*z1<<" sp*z2="<<sp*z2<<" s="<<s<< endl;
} // end if GetDebug
z1 -= z0; // Distance from where track traveled
z2 -= z0; // Distance from where track traveled
s = 0.25; // Correction based on definision of Erfc
- s *= TMath::Erfc(spx*x1) - TMath::Erfc(spx*x2);
+ s *= AliMathBase::ErfcFast(spx*x1) - AliMathBase::ErfcFast(spx*x2);
if(GetDebug(3)){
cout <<"el="<<el<<" ix0="<<ix0<<" ix="<<ix<<" x0="<<x<<
" iz0="<<iz0<<" iz="<<iz<<" z0="<<z<<
" spx*x1="<<spx*x1<<" spx*x2="<<spx*x2<<" s="<<s;
} // end if GetDebug
- s *= TMath::Erfc(spz*z1) - TMath::Erfc(spz*z2);
+ s *= AliMathBase::ErfcFast(spz*z1) - AliMathBase::ErfcFast(spz*z2);
if(GetDebug(3)){
cout<<" spz*z1="<<spz*z1<<" spz*z2="<<spz*z2<<" s="<<s<< endl;
} // end if GetDebug
#include "AliITSsimulationSSD.h"
#include "AliITSTableSSD.h"
#include <TF1.h>
-
+#include "AliMathBase.h"
ClassImp(AliITSsimulationSSD)
////////////////////////////////////////////////////////////////////////
Float_t sigm2 = sqrt2*s;
Float_t integral;
- integral = 0.5 * TMath::Erf( (x - av) / sigm2);
+ integral = 0.5 * AliMathBase::ErfFast( (x - av) / sigm2);
return integral;
}
//______________________________________________________________________
#include "AliITSPlaneEffSSD.h"
#include "AliITSV0Finder.h"
#include "AliITStrackerMI.h"
+#include "AliMathBase.h"
ClassImp(AliITStrackerMI)
}
// probability that the true z is in the range [zmin,zmax] (i.e. inside
// dead zone)
- probability = 0.5*( TMath::Erf((zpos-zmin)/zerr/TMath::Sqrt(2.)) -
- TMath::Erf((zpos-zmax)/zerr/TMath::Sqrt(2.)) );
+ probability = 0.5*( AliMathBase::ErfFast((zpos-zmin)/zerr/TMath::Sqrt(2.)) -
+ AliMathBase::ErfFast((zpos-zmax)/zerr/TMath::Sqrt(2.)) );
return probability;
}
//------------------------------------------------------------------------
}
+Double_t AliMathBase::ErfcFast(Double_t x){
+ // Fast implementation of the complementary error function
+ // The error of the approximation is |eps(x)| < 5E-4
+ // See Abramowitz and Stegun, p.299, 7.1.27
+
+ Double_t z = TMath::Abs(x);
+ Double_t ans = 1+z*(0.278393+z*(0.230389+z*(0.000972+z*0.078108)));
+ ans = 1.0/ans;
+ ans *= ans;
+ ans *= ans;
+
+ return (x>=0.0 ? ans : 2.0 - ans);
+}
///////////////////////////////////////////////////////////////
////////////// TEST functions /////////////////////////
static TGraph2D * MakeStat2D(TH3 * his, Int_t delta0, Int_t delta1, Int_t type);
static TGraph * MakeStat1D(TH3 * his, Int_t delta1, Int_t type);
+ static Double_t ErfcFast(Double_t x); // Complementary error function erfc(x)
+ static Double_t ErfFast(Double_t x) {return 1-ErfcFast(x);} // Error function erf(x)
+
//
// TestFunctions:
//
#include <TMath.h>
#include "AliSignalProcesor.h"
+#include "AliMathBase.h"
ClassImp(AliSignalProcesor)
if (-par5save*(dx-0.5*par5save*sigma2)>100) return 0; // avoid overflow
if (TMath::Abs(par[4])>1) return 0;
Double_t exp1 = par3save*TMath::Exp(-par3save*(dx-0.5*par3save*sigma2))
- *(1-TMath::Erf((par3save*sigma2-dx)/(sqrt2*par2save)));
+ *(1-AliMathBase::ErfFast((par3save*sigma2-dx)/(sqrt2*par2save)));
Double_t exp2 = par5save*TMath::Exp(-par5save*(dx-0.5*par5save*sigma2))
- *(1-TMath::Erf((par5save*sigma2-dx)/(sqrt2*par2save)));
+ *(1-AliMathBase::ErfFast((par5save*sigma2-dx)/(sqrt2*par2save)));
return par[0]*(exp1+par[4]*exp2);
if (TMath::Abs(par[4])>=1) return 0;
Double_t exp1 = par3save*TMath::Exp(-par3save*(dx-0.5*par3save*sigma2))
- *0.5*(1-TMath::Erf((par3save*sigma2-dx)/(sqrt2*par2save)));
+ *0.5*(1-AliMathBase::ErfFast((par3save*sigma2-dx)/(sqrt2*par2save)));
Double_t exp2 = par5save*TMath::Exp(-par5save*(dx-0.5*par5save*sigma2))
- *0.5*(1-TMath::Erf((par5save*sigma2-dx)/(sqrt2*par2save)));
+ *0.5*(1-AliMathBase::ErfFast((par5save*sigma2-dx)/(sqrt2*par2save)));
return par[0]*(1.*exp1+par[4]*exp2)/(1.+par[4]);
#include "AliTOFtrackerMI.h"
#include "AliTOFtrack.h"
+#include "AliMathBase.h"
+
class TGeoManager;
extern TGeoManager *gGeoManager;
//
normwidth = fDy/sigmay;
normd = dy/sigmay;
- p0 = 0.5*(1+TMath::Erf(normd-normwidth*0.5));
- p1 = 0.5*(1+TMath::Erf(normd+normwidth*0.5));
+ p0 = 0.5*(1+AliMathBase::ErfFast(normd-normwidth*0.5));
+ p1 = 0.5*(1+AliMathBase::ErfFast(normd+normwidth*0.5));
py+= 0.75*(p1-p0);
//
normwidth = fDy/(3.*sigmay);
normd = dy/(3.*sigmay);
- p0 = 0.5*(1+TMath::Erf(normd-normwidth*0.5));
- p1 = 0.5*(1+TMath::Erf(normd+normwidth*0.5));
+ p0 = 0.5*(1+AliMathBase::ErfFast(normd-normwidth*0.5));
+ p1 = 0.5*(1+AliMathBase::ErfFast(normd+normwidth*0.5));
py+= 0.25*(p1-p0);
//
// pz calculation - 75% admixture of original sigma - 25% tails
//
normwidth = fDz/sigmaz;
normd = dz/sigmaz;
- p0 = 0.5*(1+TMath::Erf(normd-normwidth*0.5));
- p1 = 0.5*(1+TMath::Erf(normd+normwidth*0.5));
+ p0 = 0.5*(1+AliMathBase::ErfFast(normd-normwidth*0.5));
+ p1 = 0.5*(1+AliMathBase::ErfFast(normd+normwidth*0.5));
pz+= 0.75*(p1-p0);
//
normwidth = fDz/(3.*sigmaz);
normd = dz/(3.*sigmaz);
- p0 = 0.5*(1+TMath::Erf(normd-normwidth*0.5));
- p1 = 0.5*(1+TMath::Erf(normd+normwidth*0.5));
+ p0 = 0.5*(1+AliMathBase::ErfFast(normd-normwidth*0.5));
+ p1 = 0.5*(1+AliMathBase::ErfFast(normd+normwidth*0.5));
pz+= 0.25*(p1-p0);
}
//_________________________________________________________________________
#include "AliTPCcalibDB.h"
#include "AliTPCParam.h"
+#include "AliMathBase.h"
+
ClassImp(AliTPCClusterParam)
Double_t exp0 = TMath::Exp(-(k1*x0-k0*x1)*(k1*x0-k0*x1)/(2*sigma2));
//
Double_t sigmaErf = 2*s0*s1*TMath::Sqrt(2*sigma2);
- Double_t erf0 = TMath::Erf( (k0*s1*s1*(k0-2*x0)+k1*s0*s0*(k1-2*x1))/sigmaErf);
- Double_t erf1 = TMath::Erf( (k0*s1*s1*(k0+2*x0)+k1*s0*s0*(k1+2*x1))/sigmaErf);
+ Double_t erf0 = AliMathBase::ErfFast( (k0*s1*s1*(k0-2*x0)+k1*s0*s0*(k1-2*x1))/sigmaErf);
+ Double_t erf1 = AliMathBase::ErfFast( (k0*s1*s1*(k0+2*x0)+k1*s0*s0*(k1+2*x1))/sigmaErf);
Double_t norm = 1./TMath::Sqrt(sigma2);
norm/=2.*TMath::Sqrt(2.*TMath::Pi());
Double_t val = norm*exp0*(erf0+erf1);
Double_t sigma2 = par2save*par2save;
Double_t sqrt2 = TMath::Sqrt(2.0);
Double_t exp1 = par3save * TMath::Exp(-par3save * (dx - 0.5 * par3save * sigma2))
- * (1.0 - TMath::Erf((par3save * sigma2 - dx) / (sqrt2 * par2save)));
+ * (1.0 - AliMathBase::ErfFast((par3save * sigma2 - dx) / (sqrt2 * par2save)));
Double_t exp2 = par5save * TMath::Exp(-par5save * (dx - 0.5 * par5save * sigma2))
- * (1.0 - TMath::Erf((par5save * sigma2 - dx) / (sqrt2 * par2save)));
+ * (1.0 - AliMathBase::ErfFast((par5save * sigma2 - dx) / (sqrt2 * par2save)));
//return par[0]*(exp1+par[4]*exp2);
return par[0] * (exp1 + 1.00124 * exp2);