///
/// Perform a couple of consistency checks to make it easier
/// to find bugs:
/// - check if all observables end with '_obs'
/// - check if all predicted observables end with '_th'
/// - check if the 'observables' and 'theory' lists are correctly ordered
///
bool PDF_Abs::checkConsistency()
{
if ( m_isCrossCorPdf ) return true;
bool allOk = true;
// check if all observables end with '_obs'
TIterator* it = observables->createIterator();
while ( RooRealVar* p = (RooRealVar*)it->Next() ){
TString pObsName = p->GetName();
pObsName.ReplaceAll(uniqueID,"");
if ( !pObsName.EndsWith("_obs") ){
cout << "PDF_Abs::checkConsistency() : " << name << " : observable " << p->GetName() << " doesn't end with '_obs'" << endl;
allOk = false;
}
}
// check if all predicted observables end with '_th'
delete it; it = theory->createIterator();
while ( RooRealVar* p = (RooRealVar*)it->Next() ){
TString pThName = p->GetName();
pThName.ReplaceAll(uniqueID,"");
if ( !pThName.EndsWith("_th") ){
cout << "PDF_Abs::checkConsistency() : " << name << " : theory " << p->GetName() << " doesn't end with '_th'" << endl;
allOk = false;
}
}
// check if the 'observables' and 'theory' lists are correctly ordered
for ( int i=0; i<nObs; i++ ){
RooAbsArg* pTh = theory->at(i);
TString base = pTh->GetName();
base.ReplaceAll("_th","");
base.ReplaceAll(uniqueID,"");
TString pObsName = observables->at(i)->GetName();
pObsName.ReplaceAll(uniqueID,"");
if ( pObsName != base+"_obs"){
cout << "PDF_Abs::checkConsistency() : " << name << " : " << pTh->GetName() << " doesn't match its observable." << endl;
cout << " Expected '" << base+"_obs" << "'. Found '" << pObsName << "'." << endl;
cout << " Check ordering of the 'theory' and 'observables' lists!" << endl;
allOk = false;
}
}
return allOk;
}
RooWorkspace* makeInvertedANFit(TTree* tree, float forceSigma=-1, bool constrainMu=false, float forceMu=-1) {
RooWorkspace *ws = new RooWorkspace("ws","");
std::vector< TString (*)(TString, RooRealVar&, RooWorkspace&) > bkgPdfList;
bkgPdfList.push_back(makeSingleExp);
bkgPdfList.push_back(makeDoubleExp);
#if DEBUG==0
//bkgPdfList.push_back(makeTripleExp);
bkgPdfList.push_back(makeModExp);
bkgPdfList.push_back(makeSinglePow);
bkgPdfList.push_back(makeDoublePow);
bkgPdfList.push_back(makePoly2);
bkgPdfList.push_back(makePoly3);
#endif
RooRealVar mgg("mgg","m_{#gamma#gamma}",103,160,"GeV");
mgg.setBins(38);
mgg.setRange("sideband_low", 103,120);
mgg.setRange("sideband_high",131,160);
mgg.setRange("signal",120,131);
RooRealVar MR("MR","",0,3000,"GeV");
MR.setBins(60);
RooRealVar Rsq("t1Rsq","",0,1,"GeV");
Rsq.setBins(20);
RooRealVar hem1_M("hem1_M","",-1,2000,"GeV");
hem1_M.setBins(40);
RooRealVar hem2_M("hem2_M","",-1,2000,"GeV");
hem2_M.setBins(40);
RooRealVar ptgg("ptgg","p_{T}^{#gamma#gamma}",0,500,"GeV");
ptgg.setBins(50);
RooDataSet data("data","",tree,RooArgSet(mgg,MR,Rsq,hem1_M,hem2_M,ptgg));
RooDataSet* blind_data = (RooDataSet*)data.reduce("mgg<121 || mgg>130");
std::vector<TString> tags;
//fit many different background models
for(auto func = bkgPdfList.begin(); func != bkgPdfList.end(); func++) {
TString tag = (*func)("bonly",mgg,*ws);
tags.push_back(tag);
ws->pdf("bonly_"+tag+"_ext")->fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
RooFitResult* bres = ws->pdf("bonly_"+tag+"_ext")->fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
bres->SetName(tag+"_bonly_fitres");
ws->import(*bres);
//make blinded fit
RooPlot *fmgg_b = mgg.frame();
blind_data->plotOn(fmgg_b,RooFit::Range("sideband_low,sideband_high"));
TBox blindBox(121,fmgg_b->GetMinimum()-(fmgg_b->GetMaximum()-fmgg_b->GetMinimum())*0.015,130,fmgg_b->GetMaximum());
blindBox.SetFillColor(kGray);
fmgg_b->addObject(&blindBox);
ws->pdf("bonly_"+tag+"_ext")->plotOn(fmgg_b,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("sideband_low,sideband_high"));
fmgg_b->SetName(tag+"_blinded_frame");
ws->import(*fmgg_b);
delete fmgg_b;
//set all the parameters constant
RooArgSet* vars = ws->pdf("bonly_"+tag)->getVariables();
RooFIter iter = vars->fwdIterator();
RooAbsArg* a;
while( (a = iter.next()) ){
if(string(a->GetName()).compare("mgg")==0) continue;
static_cast<RooRealVar*>(a)->setConstant(kTRUE);
}
//make the background portion of the s+b fit
(*func)("b",mgg,*ws);
RooRealVar sigma(tag+"_s_sigma","",5,0,100);
if(forceSigma!=-1) {
sigma.setVal(forceSigma);
sigma.setConstant(true);
}
RooRealVar mu(tag+"_s_mu","",126,120,132);
if(forceMu!=-1) {
mu.setVal(forceMu);
mu.setConstant(true);
}
RooGaussian sig(tag+"_sig_model","",mgg,mu,sigma);
RooRealVar Nsig(tag+"_sb_Ns","",5,0,100);
RooRealVar Nbkg(tag+"_sb_Nb","",100,0,100000);
RooRealVar HiggsMass("HiggsMass","",125.1);
RooRealVar HiggsMassError("HiggsMassError","",0.24);
RooGaussian HiggsMassConstraint("HiggsMassConstraint","",mu,HiggsMass,HiggsMassError);
RooAddPdf fitModel(tag+"_sb_model","",RooArgList( *ws->pdf("b_"+tag), sig ),RooArgList(Nbkg,Nsig));
RooFitResult* sbres;
RooAbsReal* nll;
if(constrainMu) {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
} else {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE));
}
sbres->SetName(tag+"_sb_fitres");
ws->import(*sbres);
ws->import(fitModel);
RooPlot *fmgg = mgg.frame();
data.plotOn(fmgg);
fitModel.plotOn(fmgg);
ws->pdf("b_"+tag+"_ext")->plotOn(fmgg,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("Full"));
fmgg->SetName(tag+"_frame");
ws->import(*fmgg);
delete fmgg;
RooMinuit(*nll).migrad();
RooPlot *fNs = Nsig.frame(0,25);
fNs->SetName(tag+"_Nsig_pll");
RooAbsReal *pll = nll->createProfile(Nsig);
//nll->plotOn(fNs,RooFit::ShiftToZero(),RooFit::LineColor(kRed));
pll->plotOn(fNs);
ws->import(*fNs);
delete fNs;
RooPlot *fmu = mu.frame(125,132);
fmu->SetName(tag+"_mu_pll");
RooAbsReal *pll_mu = nll->createProfile(mu);
pll_mu->plotOn(fmu);
ws->import(*fmu);
delete fmu;
}
RooArgSet weights("weights");
RooArgSet pdfs_bonly("pdfs_bonly");
RooArgSet pdfs_b("pdfs_b");
RooRealVar minAIC("minAIC","",1E10);
//compute AIC stuff
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooAbsPdf *p_bonly = ws->pdf("bonly_"+*t);
RooAbsPdf *p_b = ws->pdf("b_"+*t);
RooFitResult *sb = (RooFitResult*)ws->obj(*t+"_bonly_fitres");
RooRealVar k(*t+"_b_k","",p_bonly->getParameters(RooArgSet(mgg))->getSize());
RooRealVar nll(*t+"_b_minNll","",sb->minNll());
RooRealVar Npts(*t+"_b_N","",blind_data->sumEntries());
RooFormulaVar AIC(*t+"_b_AIC","2*@0+2*@1+2*@1*(@1+1)/(@2-@1-1)",RooArgSet(nll,k,Npts));
ws->import(AIC);
if(AIC.getVal() < minAIC.getVal()) {
minAIC.setVal(AIC.getVal());
}
//aicExpSum+=TMath::Exp(-0.5*AIC.getVal()); //we will need this precomputed for the next step
pdfs_bonly.add(*p_bonly);
pdfs_b.add(*p_b);
}
ws->import(minAIC);
//compute the AIC weight
float aicExpSum=0;
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooFormulaVar *AIC = (RooFormulaVar*)ws->obj(*t+"_b_AIC");
aicExpSum+=TMath::Exp(-0.5*(AIC->getVal()-minAIC.getVal())); //we will need this precomputed for the next step
}
std::cout << "aicExpSum: " << aicExpSum << std::endl;
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooFormulaVar *AIC = (RooFormulaVar*)ws->obj(*t+"_b_AIC");
RooRealVar *AICw = new RooRealVar(*t+"_b_AICWeight","",TMath::Exp(-0.5*(AIC->getVal()-minAIC.getVal()))/aicExpSum);
if( TMath::IsNaN(AICw->getVal()) ) {AICw->setVal(0);}
ws->import(*AICw);
std::cout << *t << ": " << AIC->getVal()-minAIC.getVal() << " " << AICw->getVal() << std::endl;
weights.add(*AICw);
}
RooAddPdf bonly_AIC("bonly_AIC","",pdfs_bonly,weights);
RooAddPdf b_AIC("b_AIC","",pdfs_b,weights);
//b_AIC.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
//RooFitResult* bres = b_AIC.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
//bres->SetName("AIC_b_fitres");
//ws->import(*bres);
//make blinded fit
RooPlot *fmgg_b = mgg.frame(RooFit::Range("sideband_low,sideband_high"));
blind_data->plotOn(fmgg_b,RooFit::Range("sideband_low,sideband_high"));
TBox blindBox(121,fmgg_b->GetMinimum()-(fmgg_b->GetMaximum()-fmgg_b->GetMinimum())*0.015,130,fmgg_b->GetMaximum());
blindBox.SetFillColor(kGray);
fmgg_b->addObject(&blindBox);
bonly_AIC.plotOn(fmgg_b,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("sideband_low,sideband_high"));
fmgg_b->SetName("AIC_blinded_frame");
ws->import(*fmgg_b);
delete fmgg_b;
#if 1
RooRealVar sigma("AIC_s_sigma","",5,0,100);
if(forceSigma!=-1) {
sigma.setVal(forceSigma);
sigma.setConstant(true);
}
RooRealVar mu("AIC_s_mu","",126,120,132);
if(forceMu!=-1) {
mu.setVal(forceMu);
mu.setConstant(true);
}
RooGaussian sig("AIC_sig_model","",mgg,mu,sigma);
RooRealVar Nsig("AIC_sb_Ns","",5,0,100);
RooRealVar Nbkg("AIC_sb_Nb","",100,0,100000);
RooRealVar HiggsMass("HiggsMass","",125.1);
RooRealVar HiggsMassError("HiggsMassError","",0.24);
RooGaussian HiggsMassConstraint("HiggsMassConstraint","",mu,HiggsMass,HiggsMassError);
RooAddPdf fitModel("AIC_sb_model","",RooArgList( b_AIC, sig ),RooArgList(Nbkg,Nsig));
RooFitResult* sbres;
RooAbsReal *nll;
if(constrainMu) {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
} else {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE));
}
assert(nll!=0);
sbres->SetName("AIC_sb_fitres");
ws->import(*sbres);
ws->import(fitModel);
RooPlot *fmgg = mgg.frame();
data.plotOn(fmgg);
fitModel.plotOn(fmgg);
ws->pdf("b_AIC")->plotOn(fmgg,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("Full"));
fmgg->SetName("AIC_frame");
ws->import(*fmgg);
delete fmgg;
RooMinuit(*nll).migrad();
RooPlot *fNs = Nsig.frame(0,25);
fNs->SetName("AIC_Nsig_pll");
RooAbsReal *pll = nll->createProfile(Nsig);
//nll->plotOn(fNs,RooFit::ShiftToZero(),RooFit::LineColor(kRed));
pll->plotOn(fNs);
ws->import(*fNs);
delete fNs;
RooPlot *fmu = mu.frame(125,132);
fmu->SetName("AIC_mu_pll");
RooAbsReal *pll_mu = nll->createProfile(mu);
pll_mu->plotOn(fmu);
ws->import(*fmu);
delete fmu;
std::cout << "min AIC: " << minAIC.getVal() << std::endl;
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooFormulaVar *AIC = (RooFormulaVar*)ws->obj(*t+"_b_AIC");
RooRealVar *AICw = ws->var(*t+"_b_AICWeight");
RooRealVar* k = ws->var(*t+"_b_k");
printf("%s & %0.0f & %0.2f & %0.2f \\\\\n",t->Data(),k->getVal(),AIC->getVal()-minAIC.getVal(),AICw->getVal());
//std::cout << k->getVal() << " " << AIC->getVal()-minAIC.getVal() << " " << AICw->getVal() << std::endl;
}
#endif
return ws;
}
exampleScript()
{
gSystem->CompileMacro("betaHelperFunctions.h" ,"kO") ;
gSystem->CompileMacro("RooNormalFromFlatPdf.cxx" ,"kO") ;
gSystem->CompileMacro("RooBetaInverseCDF.cxx" ,"kO") ;
gSystem->CompileMacro("RooBetaPrimeInverseCDF.cxx" ,"kO") ;
gSystem->CompileMacro("RooCorrelatedBetaGeneratorHelper.cxx" ,"kO") ;
gSystem->CompileMacro("RooCorrelatedBetaPrimeGeneratorHelper.cxx" ,"kO") ;
gSystem->CompileMacro("rooFitBetaHelperFunctions.h","kO") ;
TFile betaTest("betaTest.root","RECREATE");
betaTest.cd();
RooWorkspace workspace("workspace");
TString correlatedName("testVariable");
TString observables("observables");
TString nuisances("nuisances");
RooAbsArg* betaOne = getCorrelatedBetaConstraint(workspace,"betaOne","",
0.5 , 0.1 ,
observables, nuisances,
correlatedName );
printf("\n\n *** constraint name is %s from betaOne and %s\n\n", betaOne->GetName(), correlatedName.Data() ) ;
RooAbsArg* betaTwo = getCorrelatedBetaConstraint(workspace,"betaTwo","",
0 , 0 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaThree = getCorrelatedBetaConstraint(workspace,"betaThree","",
0.2 , 0.01 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaFour = getCorrelatedBetaConstraint(workspace,"betaFour","",
0.7 , 0.1 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaFourC = getCorrelatedBetaConstraint(workspace,"betaFourC","",
0.7 , 0.1 ,
observables, nuisances,
correlatedName, kTRUE );
RooAbsArg* betaPrimeOne = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeOne","",
1.0 , 0.5 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaPrimeOneC = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeOneC","",
1.0 , 0.5 ,
observables, nuisances,
correlatedName, kTRUE );
RooAbsArg* betaPrimeTwo = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeTwo","",
0.7 , 0.5 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaPrimeThree = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeThree","",
0.1 , 0.05 ,
observables, nuisances,
correlatedName );
RooAbsArg* betaPrimeFour = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeFour","",
7 , 1 ,
observables, nuisances,
correlatedName );
RooRealVar* correlatedParameter = workspace.var(correlatedName);
RooAbsPdf* normalFromFlat = workspace.pdf(correlatedName+"_Constraint");
RooDataSet* data = normalFromFlat->generate(RooArgSet(*correlatedParameter),1e5);
data->addColumn(*normalFromFlat);
data->addColumn(*betaOne);
data->addColumn(*betaTwo);
data->addColumn(*betaThree);
data->addColumn(*betaFour);
data->addColumn(*betaFourC);
data->addColumn(*betaPrimeOne);
data->addColumn(*betaPrimeTwo);
data->addColumn(*betaPrimeThree);
data->addColumn(*betaPrimeFour);
data->addColumn(*betaPrimeOneC);
data->Print("v");
workspace.Print() ;
//Setup Plotting Kluges:
RooRealVar normalPlotter (correlatedName+"_Constraint" , correlatedName+"_Constraint" ,0,1);
RooPlot* normalPlot = normalPlotter.frame();
data->plotOn(normalPlot);
RooRealVar betaOnePlotter ("betaOne_BetaInverseCDF" ,"betaOne_BetaInverseCDF" ,0,1);
RooRealVar betaTwoPlotter ("betaTwo_BetaInverseCDF" ,"betaTwo_BetaInverseCDF" ,0,1);
RooRealVar betaThreePlotter("betaThree_BetaInverseCDF","betaThree_BetaInverseCDF",0,1);
RooRealVar betaFourPlotter ("betaFour_BetaInverseCDF" ,"betaFour_BetaInverseCDF" ,0,1);
RooRealVar betaFourCPlotter ("betaFourC_BetaInverseCDF" ,"betaFourC_BetaInverseCDF" ,0,1);
RooRealVar betaPrimeOnePlotter ("betaPrimeOne_BetaPrimeInverseCDF" ,"betaPrimeOne_BetaPrimeInverseCDF" ,0,4);
RooRealVar betaPrimeOneCPlotter ("betaPrimeOneC_BetaPrimeInverseCDF" ,"betaPrimeOneC_BetaPrimeInverseCDF" ,0,4);
RooRealVar betaPrimeTwoPlotter ("betaPrimeTwo_BetaPrimeInverseCDF" ,"betaPrimeTwo_BetaPrimeInverseCDF" ,0,4);
RooRealVar betaPrimeThreePlotter("betaPrimeThree_BetaPrimeInverseCDF","betaPrimeThree_BetaPrimeInverseCDF",0,0.3);
RooRealVar betaPrimeFourPlotter ("betaPrimeFour_BetaPrimeInverseCDF" ,"betaPrimeFour_BetaPrimeInverseCDF" ,4,12);
RooPlot* betaOnePlot = betaOnePlotter .frame();
RooPlot* betaTwoPlot = betaTwoPlotter .frame();
RooPlot* betaThreePlot = betaThreePlotter.frame();
RooPlot* betaFourPlot = betaFourPlotter .frame();
RooPlot* betaFourCPlot = betaFourCPlotter .frame();
data->plotOn(betaOnePlot );
data->plotOn(betaTwoPlot );
data->plotOn(betaThreePlot);
data->plotOn(betaFourPlot );
data->plotOn(betaFourCPlot );
RooPlot* betaPrimeOnePlot = betaPrimeOnePlotter .frame();
RooPlot* betaPrimeOneCPlot = betaPrimeOneCPlotter .frame();
RooPlot* betaPrimeTwoPlot = betaPrimeTwoPlotter .frame();
RooPlot* betaPrimeThreePlot = betaPrimeThreePlotter.frame();
RooPlot* betaPrimeFourPlot = betaPrimeFourPlotter .frame();
data->plotOn(betaPrimeOnePlot );
data->plotOn(betaPrimeOneCPlot );
data->plotOn(betaPrimeTwoPlot );
data->plotOn(betaPrimeThreePlot);
data->plotOn(betaPrimeFourPlot );
TCanvas* underlyingVariable = new TCanvas("underlyingVariable","underlyingVariable",800,800);
underlyingVariable->Divide(2,2);
underlyingVariable->cd(1);
RooPlot* underlyingPlot = correlatedParameter->frame();
data->plotOn(underlyingPlot);
underlyingPlot->Draw();
underlyingVariable->cd(2);
normalPlot->Draw();
underlyingVariable->cd(3);
TH2F* underlying = data->createHistogram(*correlatedParameter,normalPlotter,50,50);
underlying->Draw("col");
TH2F* legoUnderlying = (TH2F*)underlying->Clone();
underlyingVariable->cd(4);
legoUnderlying->Draw("lego");
underlyingVariable->SaveAs("underlyingVariable.pdf");
TCanvas* betaCanvas = new TCanvas("betaCanvas","betaCanvas",800,800);
betaCanvas->Divide(3,2);
betaCanvas->cd(1);
betaOnePlot->Draw();
betaCanvas->cd(2);
betaTwoPlot->Draw();
betaCanvas->cd(3);
betaThreePlot->Draw();
betaCanvas->cd(4);
betaFourPlot->Draw();
betaCanvas->cd(5);
betaFourCPlot->Draw();
betaCanvas->SaveAs("betaVariables.pdf");
TCanvas* betaPrimeCanvas = new TCanvas("betaPrimeCanvas","betaPrimeCanvas",1200,800);
betaPrimeCanvas->Divide(3,2);
betaPrimeCanvas->cd(1);
betaPrimeOnePlot->Draw();
betaPrimeCanvas->cd(2);
betaPrimeTwoPlot->Draw();
betaPrimeCanvas->cd(3);
betaPrimeThreePlot->Draw();
betaPrimeCanvas->cd(4);
betaPrimeFourPlot->Draw();
betaPrimeCanvas->cd(5);
betaPrimeOneCPlot->Draw();
betaPrimeCanvas->SaveAs("betaPrimeVariables.pdf");
TCanvas* betaCorrelationsCanvas = new TCanvas("betaCorrelationsCanvas","betaCorrelationsCanvas",1600,800);
betaCorrelationsCanvas->Divide(4,2);
TH2F* oneTwo = data->createHistogram(betaOnePlotter,betaTwoPlotter,30,30);
TH2F* oneThree = data->createHistogram(betaOnePlotter,betaThreePlotter,30,30);
TH2F* oneFour = data->createHistogram(betaOnePlotter,betaFourPlotter,30,30);
TH2F* twoThree = data->createHistogram(betaTwoPlotter,betaThreePlotter,30,30);
TH2F* twoFour = data->createHistogram(betaTwoPlotter,betaFourPlotter,30,30);
TH2F* threeFour = data->createHistogram(betaThreePlotter,betaFourPlotter,30,30);
TH2F* twoFourC = data->createHistogram(betaTwoPlotter,betaFourCPlotter,30,30);
TH2F* fourFourC = data->createHistogram(betaFourPlotter,betaFourCPlotter,30,30);
betaCorrelationsCanvas->cd(1);
oneTwo->DrawCopy("lego");
betaCorrelationsCanvas->cd(2);
oneThree->DrawCopy("lego");
betaCorrelationsCanvas->cd(3);
oneFour->DrawCopy("lego");
betaCorrelationsCanvas->cd(4);
twoThree->DrawCopy("lego");
betaCorrelationsCanvas->cd(5);
twoFour->DrawCopy("lego");
betaCorrelationsCanvas->cd(6);
threeFour->DrawCopy("lego");
betaCorrelationsCanvas->cd(7);
twoFourC->DrawCopy("lego");
betaCorrelationsCanvas->cd(8);
fourFourC->DrawCopy("lego");
betaCorrelationsCanvas->SaveAs("betaCorrelations.pdf");
TCanvas* betaPrimeCorrelationsCanvas = new TCanvas("betaPrimeCorrelationsCanvas","betaPrimeCorrelationsCanvas",1600,800);
betaPrimeCorrelationsCanvas->Divide(4,2);
TH2F* oneTwo = data->createHistogram(betaPrimeOnePlotter,betaPrimeTwoPlotter,30,30);
TH2F* oneThree = data->createHistogram(betaPrimeOnePlotter,betaPrimeThreePlotter,30,30);
TH2F* oneFour = data->createHistogram(betaPrimeOnePlotter,betaPrimeFourPlotter,30,30);
TH2F* twoThree = data->createHistogram(betaPrimeTwoPlotter,betaPrimeThreePlotter,30,30);
TH2F* twoFour = data->createHistogram(betaPrimeTwoPlotter,betaPrimeFourPlotter,30,30);
TH2F* threeFour = data->createHistogram(betaPrimeThreePlotter,betaPrimeFourPlotter,30,30);
TH2F* oneOneC = data->createHistogram(betaPrimeOnePlotter,betaPrimeOneCPlotter,30,30);
betaPrimeCorrelationsCanvas->cd(1);
oneTwo->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(2);
oneThree->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(3);
oneFour->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(4);
twoThree->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(5);
twoFour->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(6);
threeFour->DrawCopy("lego");
betaPrimeCorrelationsCanvas->cd(7);
oneOneC->DrawCopy("lego");
betaPrimeCorrelationsCanvas->SaveAs("betaPrimeCorrelations.pdf");
RooProdPdf totalPdf("totalPdf","totalPdf",workspace.allPdfs());
totalPdf.Print("v");
RooArgSet* observableSet = workspace.set("observables");
observableSet->Print();
RooDataSet* allDataOne = totalPdf.generate(*observableSet,1);
allDataOne->Print("v");
correlatedParameter->setVal(0.25);
RooDataSet* allDataTwo = totalPdf.generate(*observableSet,1);
allDataTwo->Print("v");
correlatedParameter->setVal(0.75);
RooDataSet* allDataThree = totalPdf.generate(*observableSet,1);
allDataThree->Print("v");
//Testing for extreme values!
for(int i = 0; i< 101; i++)
{
correlatedParameter->setVal((double)i/100.);
cout << "Correlation parameter has value of " << correlatedParameter->getVal();
cout << " and the pdf has an unnormalized value of " << normalFromFlat->getVal() << endl;
}
}
void DrawChannelCompatibility(double rMin = -5,double rMax=5)
{
gROOT->ForceStyle();
TFile *inf = TFile::Open("higgsCombineZ.ChannelCompatibilityCheck.mH120.root");
RooFitResult *fit_nominal = (RooFitResult *)inf->Get("fit_nominal");
RooFitResult *fit_alternate = (RooFitResult *)inf->Get("fit_alternate");
RooRealVar *rFit = (RooRealVar*)fit_nominal->floatParsFinal().find("r");
TString prefix = TString::Format("_ChannelCompatibilityCheck_%s_","r");
int nChann = 0;
TIterator *iter = fit_alternate->floatParsFinal().createIterator();
for (RooAbsArg *a = (RooAbsArg *) iter->Next(); a != 0; a = (RooAbsArg *) iter->Next()) {
if (TString(a->GetName()).Index(prefix) == 0) nChann++;
}
TH2F *frame = new TH2F("frame",";best fit #sigma/#sigma_{SM};",1,rMin,rMax,nChann,0,nChann);
iter->Reset();
int iChann = 0;
TGraphAsymmErrors *points = new TGraphAsymmErrors(nChann);
float chi2(0.0);
for (RooAbsArg *a = (RooAbsArg *) iter->Next(); a != 0; a = (RooAbsArg *) iter->Next()) {
if (TString(a->GetName()).Index(prefix) == 0) {
RooRealVar *ri = (RooRealVar *) a;
TString channel = a->GetName();
channel.ReplaceAll(prefix,"");
points->SetPoint(iChann,ri->getVal(),iChann+0.5);
cout<<channel<<" "<<ri->getVal()<<" "<<ri->getAsymErrorLo()<<" +"<<ri->getAsymErrorHi()<<endl;
chi2 += pow((ri->getVal()-rFit->getVal())/ri->getError(),2);
points->SetPointError(iChann,-ri->getAsymErrorLo(),ri->getAsymErrorHi(),0,0);
//points->SetPointError(iChann,ri->getAsymErrorHi(),ri->getAsymErrorHi(),0,0);
iChann++;
frame->GetYaxis()->SetBinLabel(iChann, channel);
}
}
cout<<"Combined fit: "<<rFit->getVal()<<" "<<rFit->getAsymErrorLo()<<" +"<<rFit->getAsymErrorHi()<<endl;
cout<<"chi2 = "<<chi2<<endl;
points->SetLineColor(kRed);
points->SetLineWidth(3);
points->SetMarkerStyle(21);
TCanvas *can = new TCanvas("ChannelCompatibility_Z","ChannelCompatibility_Z",900,600);
frame->GetXaxis()->SetNdivisions(505);
frame->GetXaxis()->SetTitleSize(0.06);
frame->GetXaxis()->SetTitleOffset(0.9);
frame->GetXaxis()->SetLabelSize(0.05);
frame->GetYaxis()->SetLabelSize(0.1);
frame->Draw();
//gStyle->SetOptStat(0);
TBox globalFitBand(rFit->getVal()+rFit->getAsymErrorLo(), 0, rFit->getVal()+rFit->getAsymErrorHi(), nChann);
//TBox globalFitBand(rFit->getVal()-rFit->getAsymErrorHi(), 0, rFit->getVal()+rFit->getAsymErrorHi(), nChann);
globalFitBand.SetFillStyle(3013);
globalFitBand.SetFillColor(65);
globalFitBand.SetLineStyle(0);
globalFitBand.DrawClone();
TLine globalFitLine(rFit->getVal(), 0, rFit->getVal(), nChann);
globalFitLine.SetLineWidth(4);
globalFitLine.SetLineColor(214);
globalFitLine.DrawClone();
points->Draw("P SAME");
gPad->Update();
TLine *ln0 = new TLine(1,gPad->GetFrame()->GetY1(),1,gPad->GetFrame()->GetY2());
ln0->SetLineColor(kBlack);
ln0->SetLineWidth(1);
ln0->SetLineStyle(2);
ln0->Draw("same");
}
