void Efficiency(){
double SigSample[3][3][4] = {{{25325.2, 44262.6, 5977.5, 23677.9}, // Ds: No weights
{24474.7, 40175.5, 5764.6, 21498.8}, // Ds: Weights All
{23771.9, 38907.0, 5551.6, 20802.6}}, // Ds: Weight BDT
{{15421.6, 1607.9, 8010.9, 93.8}, // D: No weights
{14487.6, 1467.8, 7561.5, 85.1}, // D: Weights All
{14044.5, 1421.6, 7291.6, 82.6}}, // D: Weight BDT
{{1532.4, 1646.9, 727.3, 683.0}, // Dss: No weights
{1460.7, 1561.2, 692.9, 656.4}, // Dss: Weights All
{1416.5, 1482.7, 663.3, 619.4}}}; // Dss: Weight BDT
double Dpi0Sample[3][3][4] = {{{2463.5, 1821.1, 865.8, 1010.0}, // Ds: No weights
{2901.4, 2041.4, 1021.1, 1125.8}, // Ds: Weights All
{2906.5, 2069.9, 1022.5, 1146.4}}, // Ds: Weight BDT
{{832.7, 201.1, 417.5, 32.4}, // D: No weights
{975.0, 229.3, 488.9, 36.1}, // D: Weights All
{976.9, 231.6, 489.2, 36.6}}, // D: Weight BDT
{{3683.8, 2021.6, 2142.0, 1044.9}, // Dss: No weights
{4477.4, 2328.0, 2602.9, 1204.3}, // Dss: Weights All
{4475.7, 2343.8, 2602.6, 1213.3}}}; // Dss: Weight BDT
TString Component[3] = {"D*","D","D**"};
TString NameW[3] = {"No weights","Weights All","Weights BDT"};
double f[3][3][4], ef[3][3][4];
for(int comp=0; comp<3; comp++){
cout<<endl<<endl<<"Doing component "<<Component[comp]<<endl<<"=====================";
for(int weight=0; weight<3; weight++){
cout<<endl<<NameW[weight]<<":\t";
for(int chan=0; chan<4; chan++){
f[comp][weight][chan] = SigSample[comp][weight][chan]/Dpi0Sample[comp][weight][chan];
ef[comp][weight][chan] = sqrt(SigSample[comp][weight][chan]/pow(Dpi0Sample[comp][weight][chan],2)+
pow(SigSample[comp][weight][chan],2)/pow(Dpi0Sample[comp][weight][chan],3));
cout<<RoundNumber(f[comp][weight][chan],3)<<" +- "<<RoundNumber(ef[comp][weight][chan],3)<<", ";
}
}
}
cout<<endl<<endl<<"RATIOS";
for(int comp=0; comp<3; comp++){
cout<<endl<<endl<<"Doing component "<<Component[comp]<<endl<<"=====================";
for(int weight=1; weight<3; weight++){
cout<<endl<<NameW[weight]<<":\t";
for(int chan=0; chan<4; chan++){
cout<<RoundNumber(f[comp][weight][chan]*100,1,f[comp][0][chan])<<" %, ";
}
}
}
cout<<endl<<endl<<"BDT Bias";
for(int comp=0; comp<3; comp++){
cout<<endl<<endl<<"Doing component "<<Component[comp]<<endl<<"=====================";
for(int weight=2; weight<3; weight++){
cout<<endl<<NameW[weight]<<":\t";
for(int chan=0; chan<4; chan++){
cout<<RoundNumber(f[comp][weight][chan]*100,1,f[comp][1][chan])<<" %, ";
}
}
}
cout<<endl<<endl;
}
double HiggsPlot::ProbChi2(int iDecay, double tBmH, double RD[2], double RDs[2]){
double chi2;
double valMeas[3][2] = {{Measurement[0][0], Measurement[1][0]},
{MeasuredRD[0]->Eval(tBmH), MeasuredRD[2]->Eval(tBmH)},
{MeasuredRD[1]->Eval(tBmH), MeasuredRD[3]->Eval(tBmH)}};
int ndof=1;
if(iDecay<3) {
chi2 = Chi2(RD,valMeas[iDecay]);
} else {
TMatrixT<double> CovM(2,2), DiffRD(1,2), MDiff(1,2); //CovM is the covariance matrix
if(_varyRD){
CovM(0,0) = pow(RD[1],2) +pow(valMeas[1][1],2);
CovM(1,1) = pow(RDs[1],2)+pow(valMeas[2][1],2);
CovM(1,0) = Measurement[3][0]*valMeas[1][1]*valMeas[2][1];
DiffRD(0,0) = valMeas[1][0]-RD[0]; DiffRD(0,1) = valMeas[2][0]-RDs[0];
} else {
CovM(0,0) = pow(RD[1],2) +pow(Measurement[1][1],2);
CovM(1,1) = pow(RDs[1],2)+pow(Measurement[2][1],2);
CovM(1,0) = Measurement[3][0]*Measurement[1][1]*Measurement[2][1];
DiffRD(0,0) = Measurement[1][0]-RD[0]; DiffRD(0,1) = Measurement[2][0]-RDs[0];
}
CovM(0,1) = CovM(1,0);
CovM.Invert();
MDiff.Mult(DiffRD,CovM);
chi2 = MDiff(0,0)*DiffRD(0,0) + MDiff(0,1)*DiffRD(0,1);
ndof++;
if(tBmH==0 && _varyRD)
cout<<endl<<"SM chi2 is "<<RoundNumber(chi2,2)<<" with a p-value of "<<TMath::Prob(chi2,ndof)<<". This is "
<<RoundNumber(sqrt(2)*TMath::ErfInverse(1 - TMath::Prob(chi2,ndof)),2)<<" sigma away"<<endl<<endl;
}
return 1 - TMath::Prob(chi2,ndof);
}
//**************************************************************************************
//****************************Resistance************************************************
char* ADCToResistance(uint32_t Var,char* ArrayVar)
{
uint32_t Buffer;
Var=(((Var*((Vcc-10)*100))/(4095*100)));
Buffer=((Var*101)/((Vcc-10)-Var))*10;
Buffer=RoundNumber(Buffer);
if (Buffer<10000)
{
ArrayVar[0]=Buffer/10000+0x30;
Buffer-=10000*(ArrayVar[0]-0x30);
ArrayVar[1]=Buffer/1000+0x30;
Buffer-=1000*(ArrayVar[1]-0x30);
ArrayVar[2]=Buffer/100+0x30;
Buffer-=100*(ArrayVar[2]-0x30);
ArrayVar[3]=Buffer/10+0x30;
Buffer-=10*(ArrayVar[3]-0x30);
ArrayVar[4]='R';
ArrayVar[5]=0;
} else
{
ArrayVar[0]=' ';
ArrayVar[1]='O';
ArrayVar[2]='L';
ArrayVar[3]=' ';
ArrayVar[4]='R';
ArrayVar[5]=0;
}
return ArrayVar;
}
void HiggsPlot::PlotBF(int iDecay, double tBmH_max, double BF_max){
if(iDecay<0 || iDecay>2) {cout<<"iDecay must be 0, 1 or 2"<<endl; return;}
styles style; style.setPadsStyle(-1); style.setDefaultStyle();
int nBins = 1000;
TString hName, epsName = "public_html/Higgs_BF_TEMP_BaBar.eps", label, Llabel, Rlabel;
TString yTitle[] = {"BF(B#rightarrow#tau#nu) (10^{-5})", "R(D)", "R(D*)"};
TString TagDecay[] = {"BF", "R(D)", "R(D*)"};
TCanvas can;
TH1F *hBF[2];
for(int his=0; his<1; his++) {
hName = "hBF"; hName += his;
hBF[his] = new TH1F(hName,"",nBins,0,tBmH_max);
}
double tBmH, BF[2];
for(int bin=1; bin<=nBins; bin++){
tBmH = hBF[0]->GetBinCenter(bin);
Compute(tBmH,BF,iDecay);
hBF[0]->SetBinContent(bin, BF[0]);
hBF[0]->SetBinError(bin, BF[1]);
}
hBF[0]->SetFillColor(2); hBF[0]->SetLineColor(2);
hName += "1";
hBF[1] = static_cast<TH1F*>(hBF[0]->Clone(hName));
for(int bin=1; bin<=nBins; bin++)hBF[1]->SetBinError(bin,0);
hBF[1]->SetFillColor(0);hBF[1]->SetLineColor(1); hBF[1]->SetLineWidth(2);
TBox box; box.SetLineColor(4);box.SetFillColor(4);
TLine line; line.SetLineStyle(1); line.SetLineColor(4); line.SetLineWidth(3);
if(BF_max>0) hBF[0]->SetMaximum(BF_max);
hBF[0]->Draw("e3");
box.SetFillStyle(3002);
box.DrawBox(0,Measurement[iDecay][0]-Measurement[iDecay][1],
tBmH_max,Measurement[iDecay][0]+Measurement[iDecay][1]);
line.DrawLine(0,Measurement[iDecay][0],tBmH_max,Measurement[iDecay][0]);
hBF[0]->Draw("e3 same");
hBF[1]->Draw("c same");
Compute(0,BF,iDecay);
label = "#splitline{"; label += TagDecay[iDecay]; label += "_{SM} = ";
if(iDecay==0){
label+="(";label+=RoundNumber(BF[0],1); label+=" #pm ";
label+=RoundNumber(BF[1],1); label+=")#times10^{-5}}{BF_{exp} = (";
label+=RoundNumber(Measurement[iDecay][0],1); label+=" #pm ";
label+=RoundNumber(Measurement[iDecay][1],1); label+=")#times10^{-5}}";
Llabel = ""; Rlabel = label;
} else {
label+=RoundNumber(BF[0],3); label+=" #pm ";
label+=RoundNumber(BF[1],3); label+="}{"; label += TagDecay[iDecay]; label += "_{exp} = ";
label+=RoundNumber(Measurement[iDecay][0],3); label+=" #pm ";
label+=RoundNumber(Measurement[iDecay][1],3); label+="}";
Rlabel = ""; Llabel = label;
}
style.setTitles(hBF[0],"tan#beta/m_{H^{+}} (GeV^{-1})",yTitle[iDecay],Llabel,Rlabel);
epsName.ReplaceAll("TEMP",DecayName[iDecay]);
can.SaveAs(epsName);
for(int his=0; his<2; his++) hBF[his]->Delete();
}
//*******************************Voltage************************************************
uint16_t ADCToIntVoltage(uint32_t Var,uint32_t R1,uint32_t R2)
{
Var=(((Var*((Vcc)*100))/(4095*100)));
Var*=((R1*1000)/R2+1000);
Var/=1000;
Var=RoundNumber(Var);
return Var;
}
//**************************************************************************************
//******************************Current*************************************************
uint16_t ADCToIntCurrent(uint32_t Var,uint32_t Zero)
{
long int Buffer;
Buffer=(Vcc*Var*1)/4095;
Buffer=Zero*1-Buffer;
if ((Zero==2513)&&(Buffer>600)) {Buffer=Buffer+((Buffer-600)/10);} else {Buffer=Buffer;};
//if (Buffer<0) {Buffer=0;};
Buffer=RoundNumber(Buffer);
return Buffer;
}
//**************************************************************************************
uint32_t ADCToIntResistance(uint32_t Var)
{
uint32_t Buffer;
Var=(((Var*((Vcc-10)*100))/(4095*100)));
Buffer=((Var*101)/((Vcc-10)-Var))*10;
if (Buffer>20000) {Buffer=0;};
Buffer=RoundNumber(Buffer);
Buffer/=10;
return Buffer;
}
Value TestDatetimeFunctions::evaluate(const QString& formula, Value& ex)
{
Formula f;
QString expr = formula;
if ( expr[0] != '=' )
expr.prepend( '=' );
f.setExpression( expr );
Value result = f.eval();
if(result.isFloat() && ex.isInteger())
ex = Value(ex.asFloat());
if(result.isInteger() && ex.isFloat())
result = Value(result.asFloat());
return RoundNumber(result);
}
//**************************************************************************************
char* ADCToCurrent(uint32_t Var,char* ArrayVar,uint32_t Zero)
{
long int Buffer;
Buffer=(Vcc*Var*1)/4095;
Buffer=Zero*1-Buffer;
if ((Zero==2513)&&(Buffer>600)) {Buffer=Buffer+((Buffer-600)/10);} else {Buffer=Buffer;};
//if (Buffer<0) {Buffer=0;};
Buffer=RoundNumber(Buffer);
ArrayVar[0]=Buffer/1000+0x30;
Buffer-=1000*(ArrayVar[0]-0x30);
ArrayVar[1]=Buffer/100+0x30;
Buffer-=100*(ArrayVar[1]-0x30);
ArrayVar[2]='.';
ArrayVar[3]=Buffer/10+0x30;
ArrayVar[4]='A';
ArrayVar[5]=0;
return ArrayVar;
}
char* ADCToVoltage(uint32_t Var,char* ArrayVar,uint32_t R1,uint32_t R2)
{
Var=(((Var*((Vcc)*100))/(4095*100)));
Var*=((R1*1000)/R2+1000);
Var/=1000;
Var=RoundNumber(Var);
ArrayVar[0]=Var/10000+0x30;
Var-=10000*(ArrayVar[0]-0x30);
ArrayVar[1]=Var/1000+0x30;
Var-=1000*(ArrayVar[1]-0x30);
ArrayVar[2]='.';
ArrayVar[3]=Var/100+0x30;
Var-=100*(ArrayVar[3]-0x30);
ArrayVar[4]=Var/10+0x30;
ArrayVar[5]='V';
ArrayVar[6]=0;
return ArrayVar;
}
void HiggsPlot::ReadRD(TString NameFile){
fstream textFile; textFile.open(NameFile,fstream::in);
TString dummy, Name, VarNames[] = {"BFTauNu", "RD", "RDs", "Correl."};
double Value, Error;
while(textFile){
textFile>>Name>>dummy>>Value>>dummy>>Error;
for(int iVar=0; iVar<nVar; iVar++){
if(Name == VarNames[iVar]) {
Measurement[iVar][0] = Value;
Measurement[iVar][1] = Error;
}
}
}
// Obtained with PlotEffi(2,5) from babar_code/NewPhysics/PlotRate.C
// double dEffError[2][21] = {{0.00, 0.00, 0.00, 0.00, 0.23, 0.43, 0.68, 1.22, 1.79, 2.08, 2.16,
// 2.15, 2.11, 2.06, 2.02, 1.98, 1.95, 1.92, 1.90, 1.88, 1.86},
// {0.00, 0.00, 0.00, 0.03, 0.06, 0.10, 0.15, 0.21, 0.28, 0.37, 0.47,
// 0.58, 0.70, 0.81, 0.92, 1.02, 1.11, 1.18, 1.24, 1.28, 1.31}};
double RelError[2][21] = {{2.10, 2.10, 2.10, 2.10, 2.12, 2.17, 2.27, 2.57, 3.04, 3.31, 3.39,
3.37, 3.34, 3.29, 3.25, 3.22, 3.19, 3.16, 3.14, 3.13, 3.11},
{1.36, 1.36, 1.36, 1.36, 1.36, 1.37, 1.37, 1.38, 1.40, 1.43, 1.47,
1.52, 1.58, 1.65, 1.73, 1.80, 1.87, 1.93, 1.98, 2.02, 2.05}};
int iniHig = 0, iHig = iniHig, finHig = 100, dHig = 5, bin, nFiles = (finHig-iniHig)/dHig+1;
double higRD[4][30], List_tBmH[30], SysUncert[3][2] = {{0.096, 0.055}, {0.018, 0.012}, {0.044, 0.020}};
for(int isDs=0; isDs<2; isDs++)
for(int sys=0; sys<3; sys++) SysUncert[sys][isDs] *= SysUncert[sys][isDs];
TString folder = "FitAll/fits/TextFinalIsoDataHi2x", text = "";
for(int file=0; file<nFiles; file++){
TString fileName = folder;
if(iHig<100) fileName += "0";
if(iHig<10) fileName += "0";
fileName += iHig; fileName += ".txt";
fstream fitFile; fitFile.open(fileName,fstream::in);
bin = 0;
while(!text.Contains("R(D")) {
fitFile>>text;
bin++;
if(bin>1000) {cout<<"R(D) not found in "<<fileName<<endl; return;}
}
for(int cand=0; cand<2; cand++){
if(cand>0) fitFile>>text;
fitFile>>text; higRD[cand][file] = text.Atof();
fitFile>>text; fitFile>>text; text.ReplaceAll(",",""); higRD[cand+2][file] = text.Atof();
for(int i=0; i<12; i++) fitFile>>text;
// Total uncertainty = Stat + Syst* + Eff + PDFs
double ErrSystStar2 = pow(higRD[cand][file],2)*(SysUncert[0][cand]-SysUncert[1][cand]-SysUncert[2][cand]);
double ErrEff2 = pow(higRD[cand][file]*RelError[cand][file]/RelError[cand][0],2)*SysUncert[1][cand];
double ErrPDFs2 = pow(higRD[cand][file]*RelError[cand][file]/RelError[cand][0],2)*SysUncert[2][cand];
// cout<<higRD[cand][file]<<" +- "<<RoundNumber(higRD[cand+2][file],3)<<" +- "
// <<RoundNumber(sqrt(ErrSystStar2),3)
// <<" +- "<< RoundNumber(sqrt(ErrEff2),3)<<" +- "<< RoundNumber(sqrt(ErrPDFs2),3)
// <<",\t a "<<RoundNumber(sqrt(ErrEff2)*100,2,higRD[cand][file])<<" +- "
// << RoundNumber(sqrt(ErrPDFs2)*100,2,higRD[cand][file])<<" % error"<<endl;
higRD[cand+2][file] = sqrt(pow(higRD[cand+2][file],2) + ErrSystStar2 + ErrEff2 + ErrPDFs2); // Syst. errors added
List_tBmH[file] = static_cast<double>(iHig)/100.;
}
//cout<<endl;
iHig += dHig;
}
for(int isDs=0; isDs<4; isDs++){
text = "SplineRD"; text += isDs;
MeasuredRD[isDs] = new TSpline3(text,List_tBmH,higRD[isDs],nFiles,"ble1",0);
}
TString fileName = "babar_code/NewPhysics/BaBar_RDx_2HDM.txt";
fstream thdmFile; thdmFile.open(fileName,fstream::out);
thdmFile<<endl<<"tanB/mH\t\t R(D)\t\t R(D*)"<<endl<<endl;
int nPoints = 1000;
for(int point=0; point<=nPoints; point++){
double tBmH = point/static_cast<double>(nPoints);
thdmFile<<RoundNumber(tBmH,3)<<"\t\t"<<RoundNumber(MeasuredRD[0]->Eval(tBmH),3)<<" +- "
<<RoundNumber(MeasuredRD[2]->Eval(tBmH),3)<<" \t\t"<<RoundNumber(MeasuredRD[1]->Eval(tBmH),3)<<" +- "
<<RoundNumber(MeasuredRD[3]->Eval(tBmH),3)<<endl;
}
cout<<"Written "<<fileName<<endl;
fileName = "babar_code/NewPhysics/BaBar_RDx_2HDM_Theory.txt";
fstream thdmFile2; thdmFile2.open(fileName,fstream::out);
thdmFile2<<endl<<"tanB/mH\t\t R(D)\t\t R(D*)"<<endl<<endl;
double BF_D[2], BF_Ds[2];
for(int point=0; point<=nPoints; point++){
double tBmH = point/static_cast<double>(nPoints);
Compute(tBmH,BF_D,1); Compute(tBmH,BF_Ds,2);
thdmFile2<<RoundNumber(tBmH,3)<<"\t\t"<<RoundNumber(BF_D[0],3)<<" +- "
<<RoundNumber(BF_D[1],3)<<" \t\t"<<RoundNumber(BF_Ds[0],3)<<" +- "
<<RoundNumber(BF_Ds[1],3)<<endl;
}
cout<<"Written "<<fileName<<endl;
}
void HiggsPlot::PlotExclusion(int iDecay, double tBmH_max, TString Option){
//_varyRD = 0;
if(iDecay<0 || iDecay>3) {cout<<"iDecay must be 0, 1, 2 or 3"<<endl; return;}
styles style; style.setPadsStyle(-1); style.setDefaultStyle();
int nBins = 1000, nBins2D = 400;
double LikelytBmH=-1, Pvalue, Pmin=1;
TString hName, epsName = "public_html/Higgs_Exclusion1D_TEMP_BaBar.eps",label;
TCanvas can("can","Exclusion 2HDM");
TH1F h1D("h1D","",nBins,0,tBmH_max);
h1D.GetXaxis()->SetTitle("tan#beta/m_{H^{+}} (GeV^{-1})");
h1D.GetYaxis()->SetTitle("Exclusion probability (%)");
double tBmH;
for(int bin=1; bin<=nBins; bin++){
tBmH = h1D.GetBinCenter(bin);
Pvalue = ProbChi2(iDecay, tBmH);
if(Pvalue<Pmin) {LikelytBmH = tBmH; Pmin=Pvalue;}
h1D.SetBinContent(bin, 100*Pvalue);
}
h1D.Draw("c");
Pvalue = ProbChi2(iDecay, 0);
label = "#splitline{SM excluded at "; label += RoundNumber(sqrt(2)*TMath::ErfInverse(Pvalue),1);
label +=" #sigma}{"; label += "Most likely tan#beta/m_{H^{+}} = ";
label += RoundNumber(LikelytBmH,2); label += "}";
TLatex latex; latex.SetNDC(kTRUE); latex.SetTextAlign(31); latex.SetTextSize(style.TitleSize);
double xLabel = 1-style.PadRightMargin-0.02;
if(iDecay==2) {
xLabel = style.PadLeftMargin+0.03;
latex.SetTextAlign(11);
}
latex.DrawLatex(xLabel,style.PadBottomMargin+0.1,label);
////////////////// Plot 2D ///////////////////////
int nSigmas[] = {2,3,4, 5}, Nsig=4; double dl[5];
for(int ns=0; ns<Nsig+1; ns++) dl[ns] = IntG(0,1,-nSigmas[ns],nSigmas[ns]);
TLine line; line.SetLineStyle(2); line.SetLineColor(1); line.SetLineWidth(1);
line.DrawLine(0,dl[3]*100,tBmH_max,dl[3]*100);
line.DrawLine(0,dl[0]*100,tBmH_max,dl[0]*100);
epsName.ReplaceAll("TEMP",DecayName[iDecay]);
can.SaveAs(epsName);
int colors[] = {kBlue-10, kBlue-9, kBlue-7, kBlue-4, 0};
gStyle->SetPalette(Nsig, colors);
TH2F h2D("h2D","",nBins2D,15,1000,nBins2D,0,110);
h2D.GetYaxis()->CenterTitle(true); h2D.GetXaxis()->CenterTitle(true);
h2D.GetYaxis()->SetTitle("tan#beta"); h2D.GetXaxis()->SetTitle("m_{H^{+}} (GeV)");
// h2D.GetYaxis()->SetTitle("B"); h2D.GetXaxis()->SetTitle("M");
for(int binH=1; binH<=nBins2D; binH++){
for(int binB=1; binB<=nBins2D; binB++){
tBmH = h2D.GetYaxis()->GetBinCenter(binB)/h2D.GetXaxis()->GetBinCenter(binH);
h2D.SetCellContent(binH, binB, ProbChi2(iDecay, tBmH));
}
}
h2D.SetContour(Nsig,dl);
h2D.Draw(Option);
TH1F *histo[5];
double legW = 0.134, legH = 0.37;
double legX = 1-style.PadRightMargin-0.02, legY = style.PadBottomMargin+legH+0.04;
TLegend *leg = new TLegend(legX-legW, legY-legH, legX, legY);
leg->SetTextSize(0.075); leg->SetFillColor(0); leg->SetTextFont(style.nFont);
histo[4] = new TH1F("WhiteH","",10,0,10);
histo[4]->SetLineColor(10);histo[4]->SetFillColor(10);
leg->AddEntry(histo[4],"");
for(int ileg=0; ileg<Nsig; ileg++) {
TString labhisto = "histo"; labhisto += ileg+1;
histo[ileg] = new TH1F(labhisto,"histo",10,0,10);
histo[ileg]->SetLineColor(colors[ileg]);histo[ileg]->SetFillColor(colors[ileg]);
labhisto = " "; labhisto += nSigmas[ileg]; labhisto += "#sigma";
leg->AddEntry(histo[ileg],labhisto);
}
leg->Draw();
latex.SetTextSize(style.TitleSize*1.1); latex.SetTextAlign(13);
latex.DrawLatex(legX-legW+0.015, legY-0.02, "Excl. at");
epsName.ReplaceAll("1D","2D");
can.SaveAs(epsName);
for(int his=0; his<Nsig; his++) histo[his]->Delete();
}
