//____________________________________
void DoSPlot(RooWorkspace* ws){
std::cout << "Calculate sWeights" << std::endl;
// get what we need out of the workspace to do the fit
RooAbsPdf* model = ws->pdf("model");
RooRealVar* zYield = ws->var("zYield");
RooRealVar* qcdYield = ws->var("qcdYield");
RooDataSet* data = (RooDataSet*) ws->data("data");
// fit the model to the data.
model->fitTo(*data, Extended() );
// The sPlot technique requires that we fix the parameters
// of the model that are not yields after doing the fit.
RooRealVar* sigmaZ = ws->var("sigmaZ");
RooRealVar* qcdMassDecayConst = ws->var("qcdMassDecayConst");
sigmaZ->setConstant();
qcdMassDecayConst->setConstant();
RooMsgService::instance().setSilentMode(true);
// Now we use the SPlot class to add SWeights to our data set
// based on our model and our yield variables
RooStats::SPlot* sData = new RooStats::SPlot("sData","An SPlot",
*data, model, RooArgList(*zYield,*qcdYield) );
// Check that our weights have the desired properties
std::cout << "Check SWeights:" << std::endl;
std::cout << std::endl << "Yield of Z is "
<< zYield->getVal() << ". From sWeights it is "
<< sData->GetYieldFromSWeight("zYield") << std::endl;
std::cout << "Yield of QCD is "
<< qcdYield->getVal() << ". From sWeights it is "
<< sData->GetYieldFromSWeight("qcdYield") << std::endl
<< std::endl;
for(Int_t i=0; i < 10; i++)
{
std::cout << "z Weight " << sData->GetSWeight(i,"zYield")
<< " qcd Weight " << sData->GetSWeight(i,"qcdYield")
<< " Total Weight " << sData->GetSumOfEventSWeight(i)
<< std::endl;
}
std::cout << std::endl;
// import this new dataset with sWeights
std::cout << "import new dataset with sWeights" << std::endl;
ws->import(*data, Rename("dataWithSWeights"));
}
//____________________________________
void MakePlots(RooWorkspace* wks) {
// Make plots of the data and the best fit model in two cases:
// first the signal+background case
// second the background-only case.
// get some things out of workspace
RooAbsPdf* model = wks->pdf("model");
RooAbsPdf* sigModel = wks->pdf("sigModel");
RooAbsPdf* zjjModel = wks->pdf("zjjModel");
RooAbsPdf* qcdModel = wks->pdf("qcdModel");
RooRealVar* mu = wks->var("mu");
RooRealVar* invMass = wks->var("invMass");
RooAbsData* data = wks->data("data");
//////////////////////////////////////////////////////////
// Make plots for the Alternate hypothesis, eg. let mu float
mu->setConstant(kFALSE);
model->fitTo(*data,Save(kTRUE),Minos(kFALSE), Hesse(kFALSE),PrintLevel(-1));
//plot sig candidates, full model, and individual componenets
new TCanvas();
RooPlot* frame = invMass->frame() ;
data->plotOn(frame ) ;
model->plotOn(frame) ;
model->plotOn(frame,Components(*sigModel),LineStyle(kDashed), LineColor(kRed)) ;
model->plotOn(frame,Components(*zjjModel),LineStyle(kDashed),LineColor(kBlack)) ;
model->plotOn(frame,Components(*qcdModel),LineStyle(kDashed),LineColor(kGreen)) ;
frame->SetTitle("An example fit to the signal + background model");
frame->Draw() ;
// cdata->SaveAs("alternateFit.gif");
//////////////////////////////////////////////////////////
// Do Fit to the Null hypothesis. Eg. fix mu=0
mu->setVal(0); // set signal fraction to 0
mu->setConstant(kTRUE); // set constant
model->fitTo(*data, Save(kTRUE), Minos(kFALSE), Hesse(kFALSE),PrintLevel(-1));
// plot signal candidates with background model and components
new TCanvas();
RooPlot* xframe2 = invMass->frame() ;
data->plotOn(xframe2, DataError(RooAbsData::SumW2)) ;
model->plotOn(xframe2) ;
model->plotOn(xframe2, Components(*zjjModel),LineStyle(kDashed),LineColor(kBlack)) ;
model->plotOn(xframe2, Components(*qcdModel),LineStyle(kDashed),LineColor(kGreen)) ;
xframe2->SetTitle("An example fit to the background-only model");
xframe2->Draw() ;
// cbkgonly->SaveAs("nullFit.gif");
}
RooAbsPdf *MakeModelNoSignal(RooDataHist *data, RooRealVar *mww, char *name) {
char *modelName = (char*)calloc(50, sizeof(char));
strcat(modelName, name);
strcat(modelName, "model");
char *signalName = (char*)calloc(50, sizeof(char));
char *backgroundName = (char*)calloc(50, sizeof(char));
strcat(signalName, name);
strcat(signalName, "signal");
strcat(backgroundName, name);
strcat(backgroundName, "background");
char *meanName = (char*)calloc(50, sizeof(char));
strcat(meanName, name);
strcat(meanName, "mean");
char *sigmaName = (char*)calloc(50, sizeof(char));
strcat(sigmaName, name);
strcat(sigmaName, "sigma");
char *decayName = (char*)calloc(50, sizeof(char));
strcat(decayName, name);
strcat(decayName, "decay");
char *weightName = (char*)calloc(50, sizeof(char));
strcat(weightName, name);
strcat(weightName, "weight");
RooRealVar *decay = new RooRealVar(decayName, "decay", -10, 10, "GeV");
RooExponential *background = new RooExponential(backgroundName, "background", *mww, *decay);
background->fitTo(*data);
decay->setConstant();
return background;
}
void testResolution() {
Prep();
RooRealVar lXVar ("XVar","mass(GeV/c^{2})",100,60,150); lXVar.setBins(1000);
RooRealVar l1Sigma("sigma1","sigma1",1.6 ,0.,15.); //l1Sigma.setConstant(kTRUE);
RooRealVar l2Sigma("sigma2","sigma2",1.6,0.,15.); l2Sigma.setConstant(kTRUE);
RooRealVar l3Sigma("sigma3","sigma3",2.90,0.,35.); l3Sigma.setConstant(kTRUE);
RooRealVar lN ("n" ,"n" ,1.00,-15,15.); lN.setConstant(kTRUE);
RooRealVar lExp ("exp" ,"exp" ,-0.003,-15,15.); //lExp.setConstant(kTRUE);
RooRealVar lR0Mean("xmean","xmean",0,-10,10); lR0Mean.setConstant(kTRUE);
RooRealVar lR1Mean("mean","mean",90.8,60,150); //lR1Mean.setConstant(kTRUE);
RooVoigtianShape lGAdd("Add","Add",lXVar,lR1Mean,l1Sigma,l2Sigma,lN,l3Sigma,true);
RooRealVar lSPar ("SPar","SPar", 1.,0., 2.);
RooFormulaVar lXShift("uparshift","@0*@1",RooArgList(lXVar,lSPar));
TH1F *lMass = getMass(0,-5,5,-1.5,1.5);
RooDataHist *lMHist = new RooDataHist("M" ,"M" ,RooArgSet(lXVar),lMass);
RooHistPdf *lMPdf = new RooHistPdf ("MH","MH",lXShift,lXVar,*lMHist,5);
RooRealVar lGSigma("gsigma","gsigma",1.6 ,0.,15.);
RooGaussian lGaus1("gaus1","gaus1",lXVar,lR0Mean,lGSigma);
RooFFTConvPdf lConv("Conv","Conv",lXVar,*lMPdf,lGaus1);
RooDataSet *lData = new RooDataSet("crap","crap",RooArgSet(lXVar));
fillData(lData,lXVar,0,-5,5,-1.5,1.5);
lConv.fitTo(*lData,Strategy(2));
lGSigma.setVal(lGSigma.getVal());
lSPar.setVal(lSPar.getVal()*1.01);
//cout << "=====> Check " << l1Sigma.getVal() << " --- " << lR1Mean.getVal() << "----" << lSPar.getVal() << endl;
PEs(&lConv,&lGAdd,2000,500,lXVar,l1Sigma,lR1Mean,lSPar,lGSigma);
lData = 0;
Plot(&lConv,&lGAdd,2000,50000,lXVar,l1Sigma,lR1Mean,lSPar,lGSigma,lData);
}
RooAbsPdf *MakeModel(RooDataHist *data, RooRealVar *mww, char *name) {
char *modelName = (char*)calloc(50, sizeof(char));
strcat(modelName, name);
strcat(modelName, "model");
char *signalName = (char*)calloc(50, sizeof(char));
char *backgroundName = (char*)calloc(50, sizeof(char));
strcat(signalName, name);
strcat(signalName, "signal");
strcat(backgroundName, name);
strcat(backgroundName, "background");
char *meanName = (char*)calloc(50, sizeof(char));
strcat(meanName, name);
strcat(meanName, "mean");
char *sigmaName = (char*)calloc(50, sizeof(char));
strcat(sigmaName, name);
strcat(sigmaName, "sigma");
char *decayName = (char*)calloc(50, sizeof(char));
strcat(decayName, name);
strcat(decayName, "decay");
char *weightName = (char*)calloc(50, sizeof(char));
strcat(weightName, name);
strcat(weightName, "weight");
RooRealVar *mean = new RooRealVar(meanName, "mean", 0, 10000, "GeV");
RooRealVar *sigma = new RooRealVar(sigmaName, "sigma", 0, 3000, "GeV");
RooGaussian *signal = new RooGaussian(signalName, "signal", *mww, *mean, *sigma);
RooRealVar *decay = new RooRealVar(decayName, "decay", -10, 10, "GeV");
RooExponential *background = new RooExponential(backgroundName, "background", *mww, *decay);
RooRealVar *weight = new RooRealVar("decayweight", "weight", 0, 1.0, "None");
RooAbsPdf *model = new RooAddPdf(modelName, "model", RooArgList(*signal, *background), RooArgList(*weight), kTRUE);
model->fitTo(*data);
mean->setConstant();
sigma->setConstant();
weight->setConstant();
decay->setConstant();
return model;
}
RooRealVar* LoadParameters(string filename, string label, string parname )
{
RooRealVar *newVar = 0;
// now read in the parameters from the file. Stored in the file as
// parameter manager | name | initial val | min | max | step
fstream parameter_file(filename.c_str(), ios::in);
if (! parameter_file) {
cout << "Error: Couldn't open parameters file " << filename << endl;
return false;
}
string name;
string category;
double initial_val, min, max, step;
char c;
Bool_t foundPar = kFALSE;
while (true) {
// skip white spaces and look for a #
while(parameter_file.get(c)) {
if (isspace(c) || c == '\n')
continue;
else if (c == '#')
while (c != '\n') parameter_file.get(c);
else {
parameter_file.putback(c);
break;
}
}
if (parameter_file.fail())
break;
parameter_file >> category >> name >> initial_val >> min >> max >> step;
if (parameter_file.fail())
break;
if (category == label && parname == name) {
// create a new fit parameter
newVar = new RooRealVar(name.c_str(),name.c_str(),initial_val,min, max);
if (step == 0) {
newVar->setConstant(kTRUE);
}
break;
}
} //end while loop
if (!newVar) {
cout << "Could not load parameter " << parname << " from file " << filename << " , category " << label << endl;
assert(newVar);
}
return newVar;
}
int main(int argc, char* argv[]) {
doofit::builder::EasyPdf *epdf = new doofit::builder::EasyPdf();
epdf->Var("sig_yield");
epdf->Var("sig_yield").setVal(153000);
epdf->Var("sig_yield").setConstant(false);
//decay time
epdf->Var("obsTime");
epdf->Var("obsTime").SetTitle("t_{#kern[-0.2]{B}_{#kern[-0.1]{ d}}^{#kern[-0.1]{ 0}}}");
epdf->Var("obsTime").setUnit("ps");
epdf->Var("obsTime").setRange(0.,16.);
// tag, respectively the initial state of the produced B meson
epdf->Cat("obsTag");
epdf->Cat("obsTag").defineType("B_S",1);
epdf->Cat("obsTag").defineType("Bbar_S",-1);
//finalstate
epdf->Cat("catFinalState");
epdf->Cat("catFinalState").defineType("f",1);
epdf->Cat("catFinalState").defineType("fbar",-1);
epdf->Var("obsEtaOS");
epdf->Var("obsEtaOS").setRange(0.0,0.5);
std::vector<double> knots;
knots.push_back(0.07);
knots.push_back(0.10);
knots.push_back(0.138);
knots.push_back(0.16);
knots.push_back(0.23);
knots.push_back(0.28);
knots.push_back(0.35);
knots.push_back(0.42);
knots.push_back(0.44);
knots.push_back(0.48);
knots.push_back(0.5);
// empty arg list for coefficients
RooArgList* list = new RooArgList();
// create first coefficient
RooRealVar* coeff_first = &(epdf->Var("parCSpline1"));
coeff_first->setRange(0,10000);
coeff_first->setVal(1);
coeff_first->setConstant(false);
list->add( *coeff_first );
for (unsigned int i=1; i <= knots.size(); ++i){
std::string number = boost::lexical_cast<std::string>(i);
RooRealVar* coeff = &(epdf->Var("parCSpline"+number));
coeff->setRange(0,10000);
coeff->setVal(1);
coeff->setConstant(false);
list->add( *coeff );
}
// create last coefficient
RooRealVar* coeff_last = &(epdf->Var("parCSpline"+boost::lexical_cast<std::string>(knots.size())));
coeff_last->setRange(0,10000);
coeff_last->setVal(1);
coeff_last->setConstant(false);
list->add( *coeff_last );
list->Print();
doofit::roofit::pdfs::DooCubicSplinePdf splinePdf("splinePdf",epdf->Var("obsEtaOS"),knots,*list,0,0.5);
//doofit::roofit::pdfs::DooCubicSplinePdf* splinePdf = new doofit::roofit::pdfs::DooCubicSplinePdf("splinePdf", epdf->Var("obsEtaOS"), knots, *list,0,0.5);
//Koeffizienten
DecRateCoeff *coeff_c = new DecRateCoeff("coef_cos","coef_cos",DecRateCoeff::CPOdd,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("C_f"),epdf->Var("C_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Var("obsEtaOS"),epdf->Var("asym_prod"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
DecRateCoeff *coeff_s = new DecRateCoeff("coef_sin","coef_sin",DecRateCoeff::CPOdd,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("S_f"),epdf->Var("S_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Var("obsEtaOS"),epdf->Var("asym_prod"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
DecRateCoeff *coeff_sh = new DecRateCoeff("coef_sinh","coef_sinh",DecRateCoeff::CPEven,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("f1_f"),epdf->Var("f1_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Var("obsEtaOS"),epdf->Var("asym_prod"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
DecRateCoeff *coeff_ch = new DecRateCoeff("coef_cosh","coef_cosh",DecRateCoeff::CPEven,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("f0_f"),epdf->Var("f0_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Var("obsEtaOS"),epdf->Var("asym_prod"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
epdf->AddRealToStore(coeff_ch);
epdf->AddRealToStore(coeff_sh);
epdf->AddRealToStore(coeff_c);
epdf->AddRealToStore(coeff_s);
///////////////////Generiere PDF's/////////////////////
//Zeit
epdf->GaussModel("resTimeGauss",epdf->Var("obsTime"),epdf->Var("allTimeResMean"),epdf->Var("allTimeReso"));
epdf->BDecay("pdfSigTime",epdf->Var("obsTime"),epdf->Var("tau"),epdf->Var("dgamma"),epdf->Real("coef_cosh"),epdf->Real("coef_sinh"),epdf->Real("coef_cos"),epdf->Real("coef_sin"),epdf->Var("deltaM"),epdf->Model("resTimeGauss"));
//Zusammenfassen der Parameter in einem RooArgSet
RooArgSet Observables;
Observables.add(RooArgSet( epdf->Var("obsTime"),epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("obsEtaOS")));
epdf->Extend("pdfExtend", epdf->Pdf("pdfSigTime"),epdf->Real("sig_yield"));
//Multipliziere Signal und Untergrund PDF mit ihrer jeweiligen Zerfalls PDF//
//Untergrund * Zerfall
/*epdf->Product("pdf_bkg", RooArgSet(epdf->Pdf("pdf_bkg_mass_expo"), epdf->Pdf("pdf_bkg_mass_time")));
//Signal * Zerfall
epdf->Product("pdf_sig", RooArgSet(epdf->Pdf("pdf_sig_mass_gauss"),epdf->Pdf("pdfSigTime")));
//Addiere PDF's
epdf->Add("pdf_total", RooArgSet(epdf->Pdf("pdf_sig_mass_gauss*pdf_sig_time_decay"), epdf->Pdf("pdf_bkg_mass*pdf_bkg_time_decay")), RooArgSet(epdf->Var("bkg_Yield"),epdf->Var("sig_Yield")));*/
RooWorkspace ws;
ws.import(epdf->Pdf("pdfExtend"));
ws.defineSet("Observables",Observables, true);
ws.Print();
doofit::config::CommonConfig cfg_com("common");
cfg_com.InitializeOptions(argc, argv);
doofit::toy::ToyFactoryStdConfig cfg_tfac("toyfac");
cfg_tfac.InitializeOptions(cfg_com);
doofit::toy::ToyStudyStdConfig cfg_tstudy("toystudy");
cfg_tstudy.InitializeOptions(cfg_tfac);
// set a previously defined workspace to get PDF from (not mandatory, but convenient)
cfg_tfac.set_workspace(&ws);
// Check for a set --help flag and if so, print help and exit gracefully
// (recommended).
cfg_com.CheckHelpFlagAndPrintHelp();
// More custom code, e.g. to set options internally.
// Not required as configuration via command line/config file is enough.
cfg_com.PrintAll();
// Print overview of all options (optional)
// cfg_com.PrintAll();
// Initialize the toy factory module with the config objects and start
// generating toy samples.
doofit::toy::ToyFactoryStd tfac(cfg_com, cfg_tfac);
doofit::toy::ToyStudyStd tstudy(cfg_com, cfg_tstudy);
RooDataSet* data = tfac.Generate();
data->Print();
epdf->Pdf("pdfExtend").getParameters(data)->readFromFile("/home/chasenberg/Repository/bachelor-template/ToyStudy/dootoycp-parameter_spline.txt");
epdf->Pdf("pdfExtend").getParameters(data)->writeToFile("/home/chasenberg/Repository/bachelor-template/ToyStudy/dootoycp-parameter_spline.txt.new");
//epdf->Pdf("pdfExtend").fitTo(*data);
//epdf->Pdf("pdfExtend").getParameters(data)->writeToFile("/home/chasenberg/Repository/bachelor-template/ToyStudy/dootoycp-fit-result.txt");
RooFitResult* fit_result = epdf->Pdf("pdfExtend").fitTo(*data, RooFit::Save(true));
tstudy.StoreFitResult(fit_result);
/*using namespace doofit::plotting;
PlotConfig cfg_plot("cfg_plot");
cfg_plot.InitializeOptions();
cfg_plot.set_plot_directory("/net/lhcb-tank/home/chasenberg/Ergebnis/dootoycp_spline-lhcb/time/");
// plot PDF and directly specify components
Plot myplot(cfg_plot, epdf->Var("obsTime"), *data, RooArgList(epdf->Pdf("pdfExtend")));
myplot.PlotItLogNoLogY();
PlotConfig cfg_plotEta("cfg_plotEta");
cfg_plotEta.InitializeOptions();
cfg_plotEta.set_plot_directory("/net/lhcb-tank/home/chasenberg/Ergebnis/dootoycp_spline-lhcb/eta/");
// plot PDF and directly specify components
Plot myplotEta(cfg_plotEta, epdf->Var("obsEtaOS"), *data, RooArgList(splinePdf));
myplotEta.PlotIt();*/
}
void getHltAcceptance(TString const& filename, particleProperties* prop,
Int_t const& bins = 20)
{
uselhcbStyle(0.08,1.5);
Double_t t_min(prop->t_min);
Double_t t_max(prop->t_max);
Double_t nStart(1000.);
Int_t bins_M(40);
TString particle = prop->GetName();
Double_t mass = prop->GetMass();
Double_t tau_PDG = prop->GetTau();
TObjArray* tokens = filename.Tokenize("/");
TString prefix(((TObjString*)tokens->At(tokens->GetEntriesFast()-1))->GetString());
prefix.ReplaceAll(".txt","");
prefix.ReplaceAll("_Stripping","");
prefix.ReplaceAll("Tuple","_StrippingPropertimeAcceptance");
TString outputname("ROOT/");
outputname += prefix;
outputname += "_";
outputname += bins;
outputname += "bins.root";
TFile* outputfile = new TFile(outputname,"RECREATE");
RooRealVar TAU("B_TAU",prop->plotName+" Decay Time #tau",t_min,t_max,"ps") ;
TAU.setRange("total",t_min,t_max);
RooRealVar M("B_s0_M","Mass",prop->mass_low_acc,prop->mass_high_acc,"MeV/c^{2}") ;
RooRealVar Weight("Weight","Weight",-1000.,1000.,"") ;
RooRealVar Weight2("Weight2","Weight2",-1000.,1000.,"") ;
RooCategory CatA("CatA","Category A");
CatA.defineType("CatA0", 0);
CatA.defineType("CatA1", 1);
CatA.defineType("CatA2", 2);
RooCategory CatB("CatB","Category B");
CatB.defineType("CatB0", 0);
CatB.defineType("CatB1", 1);
CatB.defineType("CatB2", 2);
CatB.defineType("CatB3", 3);
RooArgList list("list");
list.add(M);
list.add(TAU);
list.add(CatA);
list.add(CatB);
list.add(Weight);
//RooBinning* binning = new RooBinning(bins,t_min,t_max);
RooBinning* binning = new RooBinning(t_min,t_max);
Double_t A(TMath::Exp(-t_max/tau_PDG));
Double_t B(TMath::Exp(-t_min/tau_PDG));
for(Int_t i(1); i< bins; i++){
binning->addBoundary(-TMath::Log(((Double_t)i*(A-B)/(Double_t)bins+B))*tau_PDG);
}
TAU.setBinning(*binning);
RooDataSet* data_ = RooDataSet::read(filename, list);
RooDataSet* data = new RooDataSet("data", "data", data_, list, 0, "Weight");
Double_t width_boundary;
if(particle == "Bs" || particle == "Lambdab0")
width_boundary = 8.;
else if(particle == "Bd")
width_boundary = 9.;
else
width_boundary = 11.;
/*
Double_t width_boundary_high;
if(particle == "Bs" || particle == "BdJPsiKs" || particle == "Lambdab0")
width_boundary_high = 15.;
else if(particle == "Bd")
width_boundary_high = 18.;
else
width_boundary_high = 22.;
*/
RooRealVar c0("c_{0}", "coefficient #0", -0.15,-1.0,1.0);
RooRealVar Bmass = RooRealVar("#m_{B}", "Mean B mass", mass, mass-5.,mass+5., "MeV/c^{2}");
RooRealVar Bwidth1 = RooRealVar("Bwidth1", "B mass resolution", 7., 4., width_boundary-0.1, "MeV/c^{2}");
//RooRealVar Bwidth2 = RooRealVar("Bwidth2", "B mass resolution", 15., width_boundary+0.1, width_boundary_high, "MeV/c^{2}");
RooRealVar frac = RooRealVar("frac", "frac", prop->frac_M_sig, 0.3, 1.);
RooRealVar rfrac = RooRealVar("rfrac", "rfrac", prop->rfrac_M_sig, 1.2, 4.);
RooFormulaVar Bwidth2 = RooFormulaVar("#sigma_{B^{0}_{s,2}}", "B mass resolution", "Bwidth1*rfrac",RooArgList(Bwidth1,rfrac));
RooChebychev * pdf_J_Bmass = new RooChebychev("Bmass_J_bkg", "background PDF", M, RooArgList(c0));
RooGaussian * pdf_S_Bmass1 = new RooGaussian("Bmass_pdf_sig1", "B signal mass pdf", M, Bmass, Bwidth1);
RooGaussian * pdf_S_Bmass2 = new RooGaussian("Bmass_pdf_sig2", "B signal mass pdf", M, Bmass, Bwidth2);
RooAddPdf * pdf_S_Bmass = new RooAddPdf("Bmass_pdf_sig", "B signal mass pdf", RooArgSet(*pdf_S_Bmass1, *pdf_S_Bmass2), frac);
RooRealVar ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S = RooRealVar("ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S","ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S",0.9, 0., 1.5);
RooRealVar ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S = RooRealVar("ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S","ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S",0.3, -0.5, 1.5);
RooRealVar n_A_1_S = RooRealVar("n_A_1_S","n_A_1_S",nStart, 0.0000001, 5000000.);
RooRealVar n_A_2_S = RooRealVar("n_A_2_S","n_A_2_S",nStart, 0.0000001, 5000000.);
RooRealVar n_B_1_S = RooRealVar("n_B_1_S","n_B_1_S",nStart, 0.0000001, 5000000.);
RooRealVar n_B_2_S = RooRealVar("n_B_2_S","n_B_2_S",nStart, 0.0000001, 5000000.);
RooFormulaVar n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_S = RooFormulaVar("n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_S","n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_S","n_A_1_S/ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S-n_A_1_S",RooArgList(ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S,n_A_1_S));
RooFormulaVar n_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S = RooFormulaVar("n_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S","n_B_1_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S","n_B_1_S/ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S-n_B_1_S",RooArgList(ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S,n_B_1_S));
RooRealVar ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B = RooRealVar("ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B","ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B",0.9, -0.5, 1.5);
RooRealVar ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B = RooRealVar("ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B","ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B",0.9, -0.5, 1.5);
RooRealVar n_A_1_B = RooRealVar("n_A_1_B","n_A_1_B",nStart, 0.0000001, 5000000.);
RooRealVar n_A_2_B = RooRealVar("n_A_2_B","n_A_2_B",nStart, 0.0000001, 5000000.);
RooRealVar n_B_1_B = RooRealVar("n_B_1_B","n_B_1_B",nStart, 0.0000001, 5000000.);
RooRealVar n_B_2_B = RooRealVar("n_B_2_B","n_B_2_B",nStart, 0.0000001, 5000000.);
RooFormulaVar n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_B = RooFormulaVar("n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_B","n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_B","n_A_1_B/ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B-n_A_1_B",RooArgList(ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B,n_A_1_B));
RooFormulaVar n_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B = RooFormulaVar("n_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B","n_B_1_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B","n_B_1_B/ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B-n_B_1_B",RooArgList(ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B,n_B_1_B));
RooAddPdf * model_A_1 = new RooAddPdf("model_A_1","model_A_1", RooArgList(*pdf_S_Bmass, *pdf_J_Bmass), RooArgList(n_A_1_S, n_A_1_B));
RooAddPdf * model_A_2 = new RooAddPdf("model_A_2","model_A_2", RooArgList(*pdf_S_Bmass, *pdf_J_Bmass), RooArgList(n_A_2_S, n_A_2_B));
RooAddPdf * model_B_1 = new RooAddPdf("model_B_1","model_B_1", RooArgList(*pdf_S_Bmass, *pdf_J_Bmass), RooArgList(n_B_1_S, n_B_1_B));
RooAddPdf * model_B_2 = new RooAddPdf("model_B_2","model_B_2", RooArgList(*pdf_S_Bmass, *pdf_J_Bmass), RooArgList(n_B_2_S, n_B_2_B));
RooAddPdf * model_A_2_Hlt1DiMuon_Hlt2DiMuonDetached = new RooAddPdf("model_A_2_Hlt1DiMuon_Hlt2DiMuonDetached","model_A_2_Hlt1DiMuon_Hlt2DiMuonDetached", RooArgList(*pdf_S_Bmass, *pdf_J_Bmass), RooArgList(n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_S, n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_B));
RooAddPdf * model_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached = new RooAddPdf("model_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached","model_B_1_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached", RooArgList(*pdf_S_Bmass, *pdf_J_Bmass), RooArgList(n_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S, n_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B));
RooDataHist * histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S_ = new RooDataHist("histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S_","histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S_",TAU);
RooDataHist * histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S_ = new RooDataHist("histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S_","histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S_",TAU);
RooDataHist * histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S_ = new RooDataHist("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S_","histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S_",TAU);
RooDataHist * histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S_ = new RooDataHist("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S_","histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S_",TAU);
RooDataHist * histo_Hlt1DiMuon_Hlt2DiMuonDetached_S_ = new RooDataHist("histo_Hlt1DiMuon_Hlt2DiMuonDetached_S_","histo_Hlt1DiMuon_Hlt2DiMuonDetached_S_",TAU);
RooDataHist * histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S_ = new RooDataHist("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S_","histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S_",TAU);
RooDataHist * histo_Hlt1DiMuon_Hlt2DiMuonDetached_B_ = new RooDataHist("histo_Hlt1DiMuon_Hlt2DiMuonDetached_B_","histo_Hlt1DiMuon_Hlt2DiMuonDetached_B_",TAU);
RooDataHist * histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B_ = new RooDataHist("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B_","histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B_",TAU);
RooHist * graph_Hlt1DiMuon_Hlt2DiMuonDetached_1_S = new RooHist();
RooHist * graph_Hlt1DiMuon_Hlt2DiMuonDetached_2_S = new RooHist();
RooHist * graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S = new RooHist();
RooHist * graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S = new RooHist();
RooHist * graph_Hlt1DiMuon_Hlt2DiMuonDetached_S = new RooHist();
RooHist * graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S = new RooHist();
RooHist * graph_Hlt1DiMuon_Hlt2DiMuonDetached_B = new RooHist();
RooHist * graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B = new RooHist();
TH1F* histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S = TAU.createHistogram("histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S", "Hlt Acceptance", *binning);
TH1F* histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S = TAU.createHistogram("histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S", "Hlt Acceptance", *binning);
TH1F* histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S = TAU.createHistogram("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S", "Hlt Acceptance", *binning);
TH1F* histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S = TAU.createHistogram("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S", "Hlt Acceptance", *binning);
TH1F* histo_Hlt1DiMuon_Hlt2DiMuonDetached_S = TAU.createHistogram("histo_Hlt1DiMuon_Hlt2DiMuonDetached_S", "Hlt Acceptance", *binning);
TH1F* histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S = TAU.createHistogram("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S", "Hlt Acceptance", *binning);
TH1F* histo_Hlt1DiMuon_Hlt2DiMuonDetached_B = TAU.createHistogram("histo_Hlt1DiMuon_Hlt2DiMuonDetached_B", "Hlt Acceptance", *binning);
TH1F* histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B = TAU.createHistogram("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B", "Hlt Acceptance", *binning);
TH1F* histo_Hlt1DiMuon_Hlt2DiMuonDetached_check_S = TAU.createHistogram("histo_Hlt1DiMuon_Hlt2DiMuonDetached_check_S", "Hlt Acceptance", *binning);
TH1F* histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_check_S = TAU.createHistogram("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_check_S", "Hlt Acceptance", *binning);
TString tmp;
tmp = prefix;
tmp += "_";
tmp += bins;
tmp += "bins";
tmp += "_Hlt1DiMuon_Hlt2DiMuonDetached";
histo_Hlt1DiMuon_Hlt2DiMuonDetached_S->SetName(tmp);
histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S->SetName(tmp+"_SetA");
histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S->SetName(tmp+"_SetB");
histo_Hlt1DiMuon_Hlt2DiMuonDetached_check_S->SetName(tmp+"_check");
tmp += "_AsymErrors";
graph_Hlt1DiMuon_Hlt2DiMuonDetached_S->SetName(tmp);
graph_Hlt1DiMuon_Hlt2DiMuonDetached_1_S->SetName(tmp+"_SetA");
graph_Hlt1DiMuon_Hlt2DiMuonDetached_2_S->SetName(tmp+"_SetB");
tmp = particle;
tmp += " Hlt1DiMuon_Hlt2DiMuonDetached Acceptance";
histo_Hlt1DiMuon_Hlt2DiMuonDetached_S->SetTitle(tmp);
graph_Hlt1DiMuon_Hlt2DiMuonDetached_S->SetTitle(tmp);
tmp = prefix;
tmp += "_";
tmp += bins;
tmp += "bins";
tmp += "_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached";
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S->SetName(tmp);
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S->SetName(tmp+"_SetC");
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S->SetName(tmp+"_SetD");
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_check_S->SetName(tmp+"_check");
tmp += "_AsymErrors";
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S->SetName(tmp);
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S->SetName(tmp+"_SetC");
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S->SetName(tmp+"_SetD");
tmp = particle;
tmp += " Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached Acceptance";
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S->SetTitle(tmp);
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S->SetTitle(tmp);
tmp = prefix;
tmp += "_";
tmp += bins;
tmp += "bins";
tmp += "_Hlt1DiMuon_Hlt2DiMuonDetached_Background";
histo_Hlt1DiMuon_Hlt2DiMuonDetached_B->SetName(tmp);
tmp += "_AsymErrors";
graph_Hlt1DiMuon_Hlt2DiMuonDetached_B->SetName(tmp);
tmp = particle;
tmp += " Hlt1DiMuon_Hlt2DiMuonDetached UB Acceptance";
histo_Hlt1DiMuon_Hlt2DiMuonDetached_B->SetTitle(tmp);
graph_Hlt1DiMuon_Hlt2DiMuonDetached_B->SetTitle(tmp);
tmp = prefix;
tmp += "_";
tmp += bins;
tmp += "bins";
tmp += "_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_Background";
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B->SetName(tmp);
tmp += "_AsymErrors";
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B->SetName(tmp);
tmp = particle;
tmp += " Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached Acceptance";
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B->SetTitle(tmp);
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B->SetTitle(tmp);
RooDataSet* data_sub;
RooDataSet* data_sub2;
RooDataSet* data_sub_A_1;
RooDataSet* data_sub_A_2;
RooDataSet* data_sub_B_1;
RooDataSet* data_sub_B_2;
data_sub2 = ((RooDataSet*)data->reduce("CatB>0."));
n_A_1_S.setVal(TMath::Max(data_sub2->sumEntries()/2.,100.));
n_A_1_B.setVal(TMath::Max(data_sub2->sumEntries()/2.,100.));
model_A_1->fitTo(*data_sub2,RooFit::Minos(kFALSE),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
rfrac.setConstant();
frac.setConstant();
Bmass.setConstant();
c0.setConstant();
Bwidth1.setConstant();
data_sub2->Delete();
for(Int_t i(0); i< bins; i++){
tmp = "B_TAU < ";
tmp += binning->binHigh(i);
tmp += " && B_TAU > ";
tmp += binning->binLow(i);
data_sub = (RooDataSet*)data->reduce(tmp);
data_sub2 = ((RooDataSet*)data_sub->reduce("CatB>0."));
data_sub_A_1 = ((RooDataSet*)data_sub->reduce("CatA==CatA::CatA1"));
data_sub_A_2 = ((RooDataSet*)data_sub->reduce("CatA==CatA::CatA2"));
data_sub_B_1 = ((RooDataSet*)data_sub->reduce("CatB==CatB::CatB1"));
data_sub_B_2 = ((RooDataSet*)data_sub->reduce("CatB==CatB::CatB2"));
TAU.setRange("fit",binning->binLow(i),binning->binHigh(i));
TAU.setBin(i);
n_A_1_S.setVal(TMath::Max(data_sub_A_1->sumEntries()/2.,100.));
n_A_1_B.setVal(TMath::Max(data_sub_A_1->sumEntries()/2.,100.));
c0.setConstant(kFALSE);
//Bwidth1.setConstant(kFALSE);
//n_A_1_S.setMin(-1000.);
model_A_1->fitTo(*data_sub2,RooFit::Minos(kFALSE),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
n_A_1_S.setMin(0.0000001);
//c0.setConstant();
//Bwidth1.setConstant();
//n_A_1_S.setMin(-1000.);
//n_A_2_S.setMin(-1000.);
//n_B_1_S.setMin(-1000.);
//n_B_2_S.setMin(-1000.);
n_A_1_S.setVal(TMath::Max(data_sub_A_1->sumEntries()*n_A_1_S.getVal()/(n_A_1_S.getVal()+n_A_1_B.getVal()),100.));
n_A_2_S.setVal(TMath::Max(data_sub_A_2->sumEntries()*n_A_2_S.getVal()/(n_A_2_S.getVal()+n_A_2_B.getVal()),100.));
n_B_1_S.setVal(TMath::Max(data_sub_B_1->sumEntries()*n_B_1_S.getVal()/(n_B_1_S.getVal()+n_B_1_B.getVal()),100.));
n_B_2_S.setVal(TMath::Max(data_sub_B_2->sumEntries()*n_B_2_S.getVal()/(n_B_2_S.getVal()+n_B_2_B.getVal()),100.));
n_A_1_B.setVal(TMath::Max(data_sub_A_1->sumEntries()*n_A_1_B.getVal()/(n_A_1_B.getVal()+n_A_1_S.getVal()),100.));
n_A_2_B.setVal(TMath::Max(data_sub_A_2->sumEntries()*n_A_2_B.getVal()/(n_A_2_B.getVal()+n_A_2_S.getVal()),100.));
n_B_1_B.setVal(TMath::Max(data_sub_B_1->sumEntries()*n_B_1_B.getVal()/(n_B_1_B.getVal()+n_B_1_S.getVal()),100.));
n_B_2_B.setVal(TMath::Max(data_sub_B_2->sumEntries()*n_B_2_B.getVal()/(n_B_2_B.getVal()+n_B_2_S.getVal()),100.));
RooSimultaneous* simmodel_Hlt1DiMuon_Hlt2DiMuonDetached = new RooSimultaneous("simmodel_Hlt1DiMuon_Hlt2DiMuonDetached","simultaneous pdf",CatA) ;
RooSimultaneous* simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached = new RooSimultaneous("simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached","simultaneous pdf",CatB) ;
RooSimultaneous* simmodel_Hlt1DiMuon_Hlt2DiMuonDetached_ = new RooSimultaneous("simmodel_Hlt1DiMuon_Hlt2DiMuonDetached_","simultaneous pdf",CatA) ;
RooSimultaneous* simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_ = new RooSimultaneous("simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_","simultaneous pdf",CatB) ;
model_A_1->fitTo(*data_sub_A_1,RooFit::Minos(kFALSE),RooFit::Strategy(1),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
simmodel_Hlt1DiMuon_Hlt2DiMuonDetached->addPdf(*model_A_1,"CatA1") ;
simmodel_Hlt1DiMuon_Hlt2DiMuonDetached_->addPdf(*model_A_1,"CatA1") ;
model_A_2->fitTo(*data_sub_A_2,RooFit::Minos(kFALSE),RooFit::Strategy(1),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
simmodel_Hlt1DiMuon_Hlt2DiMuonDetached->addPdf(*model_A_2_Hlt1DiMuon_Hlt2DiMuonDetached,"CatA2") ;
simmodel_Hlt1DiMuon_Hlt2DiMuonDetached_->addPdf(*model_A_2,"CatA2") ;
model_B_1->fitTo(*data_sub_B_1,RooFit::Minos(kFALSE),RooFit::Strategy(1),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached->addPdf(*model_B_1,"CatB1") ;
simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_->addPdf(*model_B_1,"CatB1") ;
model_B_2->fitTo(*data_sub_B_2,RooFit::Minos(kFALSE),RooFit::Strategy(1),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached->addPdf(*model_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached,"CatB2") ;
simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_->addPdf(*model_B_2,"CatB2") ;
ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S.setVal(n_A_1_S.getVal()/(n_A_1_S.getVal()+n_A_2_S.getVal())-0.001);
ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.setVal(n_B_1_S.getVal()/(n_B_1_S.getVal()+n_B_2_S.getVal())-0.001);
ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B.setVal(n_A_1_B.getVal()/(n_A_1_B.getVal()+n_A_2_B.getVal())-0.001);
ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B.setVal(n_B_1_B.getVal()/(n_B_1_B.getVal()+n_B_2_B.getVal())-0.001);
n_A_1_B.setConstant();
n_A_2_B.setConstant();
n_B_1_B.setConstant();
n_B_2_B.setConstant();
ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B.setConstant();
ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B.setConstant();
simmodel_Hlt1DiMuon_Hlt2DiMuonDetached->fitTo(*data_sub,RooFit::Minos(kTRUE),RooFit::Strategy(1),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached->fitTo(*data_sub,RooFit::Minos(kTRUE),RooFit::Strategy(1),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
simmodel_Hlt1DiMuon_Hlt2DiMuonDetached_->fitTo(*data_sub,RooFit::Minos(kTRUE),RooFit::Strategy(1),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_->fitTo(*data_sub,RooFit::Minos(kTRUE),RooFit::Strategy(1),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
simmodel_Hlt1DiMuon_Hlt2DiMuonDetached->fitTo(*data_sub,RooFit::Minos(kTRUE),RooFit::Strategy(1),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached->fitTo(*data_sub,RooFit::Minos(kTRUE),RooFit::Strategy(1),Optimize(kFALSE),RooFit::SumW2Error(kTRUE));
TCanvas* canvas = new TCanvas("canvas","canvas", 1400, 800);
gPad->SetLeftMargin(0.15);
outputname = particle;
outputname += " Mass";
canvas->Divide(2,1);
canvas->cd(1);
RooPlot* frame2 = M.frame(Bins(bins_M),Title(outputname));
data_sub_A_1->plotOn(frame2);
model_A_1->plotOn(frame2);
frame2->Draw();
canvas->cd(2);
RooPlot* frame3 = M.frame(Bins(bins_M),Title(outputname));
data_sub_A_2->plotOn(frame3);
model_A_2_Hlt1DiMuon_Hlt2DiMuonDetached->plotOn(frame3);
frame3->Draw();
TString tmp("test_");
tmp += i;
tmp += ".eps";
canvas->SaveAs(tmp);
canvas->Delete();
n_A_1_B.setConstant(kFALSE);
n_A_2_B.setConstant(kFALSE);
n_B_1_B.setConstant(kFALSE);
n_B_2_B.setConstant(kFALSE);
ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B.setConstant(kFALSE);
ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B.setConstant(kFALSE);
n_A_1_S.setConstant(kFALSE);
n_A_2_S.setConstant(kFALSE);
n_B_1_S.setConstant(kFALSE);
n_B_2_S.setConstant(kFALSE);
ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S.setConstant(kFALSE);
ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.setConstant(kFALSE);
histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S_->set(RooArgSet(TAU),n_A_1_S.getVal()/binning->binWidth(i),n_A_1_S.getError()/binning->binWidth(i));
histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S_->set(RooArgSet(TAU),n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_S.getVal()/binning->binWidth(i),n_A_2_S.getError()/binning->binWidth(i));
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S_->set(RooArgSet(TAU),n_B_1_S.getVal()/binning->binWidth(i),n_B_1_S.getError()/binning->binWidth(i));
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S_->set(RooArgSet(TAU),n_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.getVal()/binning->binWidth(i),n_B_2_S.getError()/binning->binWidth(i));
histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S->SetBinContent(i+1,n_A_1_S.getVal()/binning->binWidth(i));
histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S->SetBinError(i+1,n_A_1_S.getError()/binning->binWidth(i));
histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S->SetBinContent(i+1,n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_S.getVal()/binning->binWidth(i));
histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S->SetBinError(i+1,n_A_2_S.getError()/binning->binWidth(i));
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S->SetBinContent(i+1,n_B_1_S.getVal()/binning->binWidth(i));
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S->SetBinError(i+1,n_B_1_S.getError()/binning->binWidth(i));
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S->SetBinContent(i+1,n_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.getVal()/binning->binWidth(i));
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S->SetBinError(i+1,n_B_2_S.getError()/binning->binWidth(i));
histo_Hlt1DiMuon_Hlt2DiMuonDetached_check_S->SetBinContent(i+1,n_A_1_S.getVal()/(n_A_1_S.getVal()+n_A_2_S.getVal()));
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_check_S->SetBinContent(i+1,n_B_1_S.getVal()/n_B_2_S.getVal());
histo_Hlt1DiMuon_Hlt2DiMuonDetached_S_->set(RooArgSet(TAU),ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S.getVal(),ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S.getError());
histo_Hlt1DiMuon_Hlt2DiMuonDetached_S->SetBinContent(i+1,ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S.getVal());
histo_Hlt1DiMuon_Hlt2DiMuonDetached_S->SetBinError(i+1,ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S.getError());
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S_->set(RooArgSet(TAU),ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.getVal(),ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.getError());
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S->SetBinContent(i+1,ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.getVal());
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S->SetBinError(i+1,ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.getError());
histo_Hlt1DiMuon_Hlt2DiMuonDetached_B_->set(RooArgSet(TAU),ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B.getVal(),ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B.getError());
histo_Hlt1DiMuon_Hlt2DiMuonDetached_B->SetBinContent(i+1,ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B.getVal());
histo_Hlt1DiMuon_Hlt2DiMuonDetached_B->SetBinError(i+1,ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B.getError());
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B_->set(RooArgSet(TAU),ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B.getVal(),ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B.getError());
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B->SetBinContent(i+1,ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B.getVal());
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B->SetBinError(i+1,ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B.getError());
graph_Hlt1DiMuon_Hlt2DiMuonDetached_1_S->addBinWithError(TAU.getVal(),n_A_1_S.getVal(),TMath::Abs(n_A_1_S.getErrorLo()),
n_A_1_S.getErrorHi(),TAU.getBinWidth(i));
graph_Hlt1DiMuon_Hlt2DiMuonDetached_2_S->addBinWithError(TAU.getVal(),n_A_2_Hlt1DiMuon_Hlt2DiMuonDetached_S.getVal(),TMath::Abs(n_A_2_S.getErrorLo()),
n_A_2_S.getErrorHi(),TAU.getBinWidth(i));
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S->addBinWithError(TAU.getVal(),n_B_1_S.getVal(),
TMath::Abs(n_B_1_S.getErrorLo()),
n_B_1_S.getErrorHi(),TAU.getBinWidth(i));
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S->addBinWithError(TAU.getVal(),n_B_2_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.getVal(),
TMath::Abs(n_B_2_S.getErrorLo()),
n_B_2_S.getErrorHi(),TAU.getBinWidth(i));
graph_Hlt1DiMuon_Hlt2DiMuonDetached_S->addBinWithError(TAU.getVal(),ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S.getVal(),TMath::Abs(ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S.getErrorLo()),
ratio_Hlt1DiMuon_Hlt2DiMuonDetached_S.getErrorHi(),TAU.getBinWidth(i),1.,kFALSE);
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S->addBinWithError(TAU.getVal(),ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.getVal(),
TMath::Abs(ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.getErrorLo()),
ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S.getErrorHi(),TAU.getBinWidth(i),1.,kFALSE);
graph_Hlt1DiMuon_Hlt2DiMuonDetached_B->addBinWithError(TAU.getVal(),ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B.getVal(),TMath::Abs(ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B.getErrorLo()),
ratio_Hlt1DiMuon_Hlt2DiMuonDetached_B.getErrorHi(),TAU.getBinWidth(i),1.,kFALSE);
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B->addBinWithError(TAU.getVal(),ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B.getVal(),
TMath::Abs(ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B.getErrorLo()),
ratio_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_B.getErrorHi(),TAU.getBinWidth(i),1.,kFALSE);
simmodel_Hlt1DiMuon_Hlt2DiMuonDetached->Delete();
simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached->Delete();
simmodel_Hlt1DiMuon_Hlt2DiMuonDetached_->Delete();
simmodel_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_->Delete();
data_sub->Delete();
data_sub2->Delete();
data_sub_A_1->Delete();
data_sub_A_2->Delete();
data_sub_B_1->Delete();
data_sub_B_2->Delete();
}
histo_Hlt1DiMuon_Hlt2DiMuonDetached_S->Write();
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S->Write();
graph_Hlt1DiMuon_Hlt2DiMuonDetached_S->Write();
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S->Write();
histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S->Write();
histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S->Write();
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S->Write();
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S->Write();
graph_Hlt1DiMuon_Hlt2DiMuonDetached_1_S->Write();
graph_Hlt1DiMuon_Hlt2DiMuonDetached_2_S->Write();
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S->Write();
graph_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S->Write();
/*
histo_Hlt1DiMuon_Hlt2DiMuonDetached_check_S->Write();
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_check_S->Write();
*/
TCanvas* cdata = new TCanvas("cdata","cdata", 1600, 1000);
cdata->Divide(2,2);
cdata->cd(1);
gPad->SetLeftMargin(0.15);
outputname = "";
outputname += particle;
outputname += " Decay Time used for Almost Unbiased Acceptance";
RooPlot* frame1 = TAU.frame(Bins(bins),Title(outputname));
histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S_->plotOn(frame1,Name("histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S_"), LineColor(kBlue), MarkerColor(kBlue));
histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S_->plotOn(frame1,Name("histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S_"), LineColor(kRed), MarkerColor(kRed));
frame1->GetYaxis()->SetTitle("Events / Bin Width (ps^{-1})");
frame1->Draw();
gPad->SetLogx();
TLegend* legend_1 = new TLegend(0.65,0.6,0.9,0.85);
legend_1->SetFillColor(kWhite);
legend_1->AddEntry((RooHist*)frame1->findObject("histo_Hlt1DiMuon_Hlt2DiMuonDetached_1_S_"),"Set A","lep");
legend_1->AddEntry((RooHist*)frame1->findObject("histo_Hlt1DiMuon_Hlt2DiMuonDetached_2_S_"),"Set B","lep");
legend_1->SetTextFont(132);
legend_1->Draw();
cdata->cd(2);
gPad->SetLeftMargin(0.15);
outputname = "Almost Unbiased Acceptance VS ";
outputname += particle;
outputname += " Decay Time";
RooPlot* frame2 = TAU.frame(Bins(bins),Title(outputname));
histo_Hlt1DiMuon_Hlt2DiMuonDetached_S_->plotOn(frame2,Name("histo_Hlt1DiMuon_Hlt2DiMuonDetached_S_"), LineColor(kBlack), MarkerColor(kBlack));
frame2->SetMinimum(0.);
//frame2->SetMinimum(0.85);
frame2->SetMaximum(1.1);
frame2->GetYaxis()->SetTitle("Acceptance");
frame2->Draw();
gPad->SetLogx();
TLegend* legend_2 = new TLegend(0.3,0.25,0.9,0.45);
legend_2->SetFillColor(kWhite);
legend_2->AddEntry((RooHist*)frame2->findObject("histo_Hlt1DiMuon_Hlt2DiMuonDetached_S_"),"Almost Unbiased Acceptance","lep");
legend_2->SetTextFont(132);
legend_2->Draw();
cdata->cd(3);
gPad->SetLeftMargin(0.15);
outputname = "";
outputname += particle;
outputname += " Decay Time used for Exclusively Biased Acceptance";
RooPlot* frame3 = TAU.frame(Bins(bins),Title(outputname));
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S_->plotOn(frame3,Name("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S_"), LineColor(kBlue), MarkerColor(kBlue));
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S_->plotOn(frame3,Name("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S_"), LineColor(kRed), MarkerColor(kRed));
frame3->GetYaxis()->SetTitle("Events / Bin Width (ps^{-1})");
frame3->Draw();
gPad->SetLogx();
TLegend* legend_3 = new TLegend(0.65,0.6,0.9,0.85);
legend_3->SetFillColor(kWhite);
legend_3->AddEntry((RooHist*)frame3->findObject("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_1_S_"),"Set A","lep");
legend_3->AddEntry((RooHist*)frame3->findObject("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_2_S_"),"Set B","lep");
legend_3->SetTextFont(132);
legend_3->Draw();
cdata->cd(4);
gPad->SetLeftMargin(0.15);
outputname = "Exclusively Biased Acceptance VS ";
outputname += particle;
outputname += " Decay Time";
RooPlot* frame4 = TAU.frame(Bins(bins),Title(outputname));
histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S_->plotOn(frame4,Name("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S_"), LineColor(kBlack), MarkerColor(kBlack));
frame4->SetMinimum(0.);
//frame4->SetMinimum(0.85);
frame4->SetMaximum(1.1);
frame4->GetYaxis()->SetTitle("Acceptance");
frame4->Draw();
gPad->SetLogx();
TLegend* legend_4 = new TLegend(0.3,0.25,0.9,0.45);
legend_4->SetFillColor(kWhite);
legend_4->AddEntry((RooHist*)frame4->findObject("histo_Hlt1TrackAndTrackMuonExcl_Hlt2DiMuonDetached_S_"),"Exclusively Biased Acceptance","lep");
legend_4->SetTextFont(132);
legend_4->Draw();
outputname = "plots/";
outputname += prefix;
outputname += "_";
outputname += bins;
outputname += "bins.eps";
cdata->SaveAs(outputname);
TCanvas* cdata1 = new TCanvas("cdata1","cdata1", 800, 500);
frame2->Draw();
gPad->SetLogx();
legend_2->Draw();
outputname = "plots/";
outputname += prefix;
outputname += "_";
outputname += bins;
outputname += "bins_AlmostUnbiased.eps";
cdata1->SaveAs(outputname);
TCanvas* cdata2 = new TCanvas("cdata2","cdata2", 800, 500);
frame4->Draw();
gPad->SetLogx();
legend_4->Draw();
outputname = "plots/";
outputname += prefix;
outputname += "_";
outputname += bins;
outputname += "bins_ExclusivelyBiased.eps";
cdata2->SaveAs(outputname);
TCanvas* cdata3 = new TCanvas("cdata3","cdata3", 800, 500);
frame1->Draw();
gPad->SetLogx();
legend_1->Draw();
outputname = "plots/";
outputname += prefix;
outputname += "_";
outputname += bins;
outputname += "bins_AlmostUnbiasedYields.eps";
cdata3->SaveAs(outputname);
TCanvas* cdata4 = new TCanvas("cdata4","cdata4", 800, 500);
frame3->Draw();
gPad->SetLogx();
legend_3->Draw();
outputname = "plots/";
outputname += prefix;
outputname += "_";
outputname += bins;
outputname += "bins_ExclusivelyBiasedYields.eps";
cdata4->SaveAs(outputname);
outputfile->Close();
}
//-------------------------------------------------------------
//Main macro for generating data and fitting
//=============================================================
void FitMassPhotonResolutionSystematics(const string workspaceFile = "/afs/cern.ch/work/d/daan/public/releases/CMSSW_5_3_9_patch3/src/CMSAna/HHToBBGG/data/FitWorkspace_asdf.root", const string outputTree = "/afs/cern.ch/work/d/daan/public/releases/CMSSW_5_3_9_patch3/src/CMSAna/HHToBBGG/data/MassFitResults/MassFitTwoD_asdf.root", Int_t plotOption = 0, Int_t storeOption = 1, Int_t SystematicsUpOrDown = 1, Int_t NToys = 5000) {
TRandom3 *randomnumber = new TRandom3(1200);
TFile *wsFile = new TFile (workspaceFile.c_str(), "READ");
RooWorkspace *ws = (RooWorkspace*)wsFile->Get("MassFitWorkspace");
//Import variables from workspace
RooAbsPdf *model2Dpdf = ws->pdf("model2Dpdf");
RooRealVar *massBjet = ws->var("massBjet");
RooRealVar *massPho = ws->var("massPho");
RooRealVar *nsig = ws->var("N (Sig)"); RooRealVar constNsig(*nsig);
RooRealVar *nres = ws->var("N (ResBkg)"); RooRealVar constNres(*nres);
RooRealVar *nnonres = ws->var("N (NonResBkg)"); RooRealVar constNnonres(*nnonres);
RooRealVar *expRateBjet = ws->var("expRateBjet"); RooRealVar constexpBjet(*expRateBjet);
RooRealVar *expRatePho = ws->var("expRatePho"); RooRealVar constexpPho(*expRatePho);
//Variables to set constant
RooRealVar *sigMeanBjet = ws->var("sigMeanBjet"); sigMeanBjet->setConstant();
RooRealVar *sigSigmaBjet = ws->var("sigSigmaBjet"); sigSigmaBjet->setConstant();
RooRealVar *sigAlpha = ws->var("sigAlpha"); sigAlpha->setConstant();
RooRealVar *sigPower = ws->var("sigPower"); sigPower->setConstant();
RooRealVar *sigmaPho = ws->var("sigmaPho"); sigmaPho->setConstant();
RooRealVar *resMeanBjet = ws->var("resMeanBjet"); resMeanBjet->setConstant();
RooRealVar *resSigmaBjet = ws->var("resSigmaBjet"); resSigmaBjet->setConstant();
RooRealVar *resAlpha = ws->var("resAlpha"); resAlpha->setConstant();
RooRealVar *resPower = ws->var("resPower"); resPower->setConstant();
RooRealVar *resExpo = ws->var("resExpo"); resExpo->setConstant();
RooRealVar *nbbH = ws->var("nbbH"); nbbH->setConstant();
RooRealVar *nOthers = ws->var("nOthers"); nOthers->setConstant();
double inputSigmaPho = sigmaPho->getVal();
//Create TTree to store the resulting yield data
TFile *f = new TFile(outputTree.c_str(), "RECREATE");
TTree *resultTree = new TTree("resultTree", "Parameter results from fitting");
Float_t nsigOut, nresOut, nnonresOut;
Float_t nsigStd, nresStd, nnonresStd;
resultTree->Branch("nsigOut",&nsigOut, "nsigOut/F");
resultTree->Branch("nresOut",&nresOut, "nresOut/F");
resultTree->Branch("nnonresOut",&nnonresOut, "nnonresOut/F");
resultTree->Branch("nsigStd",&nsigStd, "nsigStd/F");
resultTree->Branch("nresStd",&nresStd, "nresStd/F");
resultTree->Branch("nnonresStd",&nnonresStd, "nnonresStd/F");
//Generate Toy MC experiment data and fits
for(UInt_t t=0; t < NToys; ++t) {
cout << "Toy #" << t << endl;
nsig->setVal(constNsig.getVal()); nres->setVal(constNres.getVal()); nnonres->setVal(constNnonres.getVal());
expRateBjet->setVal(constexpBjet.getVal()); expRatePho->setVal(constexpPho.getVal());
//set jet energy resolutions to nominal
sigmaPho->setVal(inputSigmaPho);
cout << "Before: " << sigmaPho->getVal() << " | ";
Float_t ran = randomnumber->Poisson(325.);
RooDataSet *pseudoData2D = model2Dpdf->generate(RooArgList(*massBjet,*massPho), ran);
//move jet energy resolution up/down
if (SystematicsUpOrDown == 1) {
sigmaPho->setVal(inputSigmaPho*1.15);
} else if (SystematicsUpOrDown == -1) {
sigmaPho->setVal(inputSigmaPho/1.15);
}
cout << "After: " << sigmaPho->getVal() << " \n";
RooFitResult *fitResult2D = model2Dpdf->fitTo(*pseudoData2D, RooFit::Save(), RooFit::Extended(kTRUE), RooFit::Strategy(2));
// if (t == 1763) {
// ws->import(*pseudoData2D, kTRUE);
// ws->import(*pseudoData2D, Rename("pseudoData2D"));
// }
// if (plotOption == 1) MakePlots(ws, fitResult2D);
cout << "DEBUG: " << constexpBjet.getVal() << " , " << constexpPho.getVal() << " | " << expRateBjet->getVal() << " " << expRatePho->getVal() << "\n";
//Store fit parameters into ROOT file
if (storeOption == 1) {
//Save variables into separate branches of root tree
nsigOut = nsig->getVal();
nresOut = nres->getVal();
nnonresOut = nnonres->getVal();
nsigStd = nsig->getPropagatedError(*fitResult2D);
nresStd = nres->getPropagatedError(*fitResult2D);
nnonresStd = nnonres->getPropagatedError(*fitResult2D);
//cout << "\n\n\n\n\n\n" << nsigOut << " | " << nresOut << " | " << nnonresOut << " | " << ran << "\n\n\n\n\n" << endl;
resultTree->Fill();
}
}
//Write to the TTree and close it
resultTree->Write();
f->Close();
}
MakeAICFits::MakeAICFits() {
//RooRandom::randomGenerator()->SetSeed(314159);
// Create Toy Data Set
// Single Exponential
RooRealVar *mass = new RooRealVar("mass","mass", 50., 35., 65.);
//RooRealVar *alpha1 = new RooRealVar("Exp_alpha","Exp_alpha",-0.1,-1.,0.);
//alpha1->setVal(-0.1);
RooRealVar *alpha1 = new RooRealVar("Exp_alpha","Exp_alpha", -0.1);
RooExponential expon("exp","Background Exponential",*mass,*alpha1);
// KPower
//RooRealVar *alpha2 = new RooRealVar("Power_alpha","Power_alpha",-3.,-10.,0.);
//alpha2->setVal(-3.);
RooRealVar *alpha2 = new RooRealVar("Power_alpha", "Power_alpha", -3);
RooGenericPdf bkg("pow","Background Power","@0^@1",RooArgList(*mass,*alpha2));
//RooRealVar ratio("ratio","Background Ratio", 0.5, 0., 1.);
//ratio.setVal(0.5);
RooRealVar ratio("ratio", "Background Ratio", 0.5);
//Create Background pdf
// RooAddPdf bkg("bkg","bkg",RooArgList(pow,expon),ratio);
std::cout<<"========== Data Model Made ==========="<<std::endl;
const Int_t nToys = 1;
//ratio.setVal(0);
RooDataSet* data = bkg.generate(RooArgSet(*mass), 1000000);
//ratio.setVal(0.20);
std::cout<<"========== Data Set Made ==========="<<std::endl;
// Make plain projection of data and pdf on mass
//bkg.fitTo(*data);
RooFitResult* bkg_data = bkg.fitTo(*data, RooFit::Save(kTRUE), RooFit::Optimize(0));
Double_t bkg_data_Nll = bkg_data->minNll();
std::cout<<" ======== Data fitted ==========="<<std::endl;
RooArgSet* bkgParams = bkg.getParameters(*data);
const RooArgList& fitbkgParams = bkg_data->floatParsFinal();
std::cout<< "======================= parameters done ========================"<<std::endl;
Double_t LogLikelihood[8] = {0,0,0,0,0,0,0,0};
Double_t AIC_bkg_array[8] = {0,0,0,0,0,0,0,0};
Double_t AICc_bkg_array[8] = {0,0,0,0,0,0,0,0};
//Double_t BIC_bkg_array[7] = {0,0,0,0,0,0,0};
Double_t LogLikelihood_data = bkg_data_Nll;
Int_t avgcov[8] = {0,0,0,0,0,0,0};
std::cout<<"====================== Starting Toys ==============="<<std::endl;
for (Int_t i=0; i<nToys; i++) {
if (i%10==0) {
std::cout<<">> Processing Toy Trial " << i << "/" << nToys << std::endl;
}
RooPlot* frame = mass->frame();
leg = new TLegend(0.55,0.55,0.9,0.9);
mass->setConstant(kFALSE);
alpha1->setConstant(kFALSE);
alpha2->setConstant(kFALSE);
ratio.setConstant(kFALSE);
const RooArgList ranbkgParams = bkg_data->randomizePars();
*bkgParams = ranbkgParams;
Int_t SampleSize = 100000;
RooDataSet* toybkg = bkg.generate(RooArgSet(*mass),SampleSize);
toybkg->plotOn(frame);
leg->AddEntry(toybkg,"Toy Background", "lep");
*bkgParams = fitbkgParams;
mass->setConstant(kTRUE);
alpha1->setConstant(kTRUE);
alpha2->setConstant(kTRUE);
ratio.setConstant(kTRUE);
for (int type=0; type<7; type++) {
std::cout<<type<<endl;
}
int display = 8;
for (int type=0; type<display; type++) {
if (type<7) {
//std::cout<<"Model Shape: "<<type<<std::endl;
RooAbsPdf* ModelShape = MakeAICFits::getBackgroundPdf(type,mass);
//std::cout<<"Model Shape made"<<std::endl;
int k = MakeAICFits::Num_Params(type);
//std::cout<<"Params counted"<<std::endl;
}
if (type==7) {
RooAbsPdf* Model1 = MakeAICFits::getBackgroundPdf(5,mass);
RooAbsPdf* Model2 = MakeAICFits::getBackgroundPdf(6,mass);
RooAbsPdf* Model3 = MakeAICFits::getBackgroundPdf(2,mass);
RooAbsPdf* Model4 = MakeAICFits::getBackgroundPdf(3,mass);
RooAbsPdf* Model5 = MakeAICFits::getBackgroundPdf(4,mass);
int k = MakeAICFits::Num_Params(5);
k+= MakeAICFits::Num_Params(6);
//k+= MakeAICFits::Num_Params(0);
//k+= MakeAICFits::Num_Params(3);
//k+= MakeAICFits::Num_Params(4);
RooRealVar* modratio1 = new RooRealVar("modrat1", "modrat1", 0.82, 0.81, 0.83);
RooRealVar* modratio2 = new RooRealVar("modrat2", "modrat2", 0.17, 0.25, 0.35);
RooRealVar* modratio3 = new RooRealVar("modrat3", "modrat3", 0.01);
//RooRealVar* modratio4 = new RooRealVar("modrat4", "modrat4", 0.25);
RooAbsPdf* ModelShape = new RooAddPdf("Composite", "Background Model", RooArgList(*Model1, *Model2), RooArgList(*modratio1));
//RooAbsPdf* ModelShape = new RooAddPdf("Composite", "Background Model", RooArgList(*Model1, *Model4), *modratio1);
}
assert(ModelShape!=0);
RooRealVar *Nbkg = new RooRealVar("Nbkg","N Background Events", SampleSize,0,1e9);
RooExtendPdf *BkgModel = new RooExtendPdf("BKGFIT_bkgModel", "Background Model", *ModelShape, *Nbkg);
TH1F* Model = new TH1F("Model", "Model", 100,0,100);
//BkgModel->fitTo(*toybkg, RooFit::Strategy(0), RooFit::NumCPU(NUM_CPU), RooFit::Minos(kFALSE), RooFit::Extended(kTRUE));
//RooFitResult *bkg_toybkg = BkgModel->fitTo(*toybkg,RooFit::Save(kTRUE), RooFit::Strategy(2), RooFit::NumCPU(NUM_CPU), RooFit::Minos(kFALSE), RooFit::Extended(kTRUE));
RooFitResult *bkg_toybkg = BkgModel->fitTo(*toybkg, RooFit::Save(kTRUE), RooFit::Optimize(0));
if (type == 0) {
BkgModel->plotOn(frame, RooFit::LineColor(kBlue));
Model->RooFit::SetLineColor(kBlue);
leg->AddEntry(Model, "Exponential Model", "l");
}
if (type == 4) {
BkgModel->plotOn(frame, RooFit::LineColor(kRed));
Model->RooFit::SetLineColor(kRed);
leg->AddEntry(Model, "Polynomial Model", "l");
}
if (type == 5) {
BkgModel->plotOn(frame, RooFit::LineColor(kGreen));
Model->RooFit::SetLineColor("kGreen");
leg->AddEntry(Model, "Power Model", "l");
}
if (type == 7) {
BkgModel->plotOn(frame, RooFit::LineColor(kMagenta));
Model->RooFit::SetLineColor("kMagenta");
leg->AddEntry(Model, "Composite Model", "l");
}
Double_t bkg_toybkg_Nll = bkg_toybkg->minNll();
Int_t covariance = bkg_toybkg->covQual();
avgcov[type] += covariance;
//assert (covariance == 3);
// Calculate AIC for each model
LogLikelihood[type] += -bkg_toybkg_Nll;
AICc_bkg_array[type] += 2.*(k + k*(k + 1.)/(SampleSize - (k + 1.)) + bkg_toybkg_Nll);
//BIC_bkg_array[type] += 2.*(k*log(SampleSize)/2. + bkg_toybkg_Nll);
AIC_bkg_array[type] += 2.*(k + bkg_toybkg_Nll);
// Clean up objects
delete bkg_toybkg;
bkg_toybkg_Nll = 0.;
}
delete toybkg;
TCanvas *c = new TCanvas("", "", 800, 600);
frame->Draw();
leg->Draw();
c->Update();
c->Print("pow_plot_combined.pdf");
}
std::cout<<"Printing AIC Values" << std::endl;
std::cout<<"Log Likelihood Data : " << LogLikelihood_data <<std::endl;
for (int type = 0; type<display; type++) {
avgcov[type] = avgcov[type]/nToys;
LogLikelihood[type] = LogLikelihood[type]/nToys;
AIC_bkg_array[type] = AIC_bkg_array[type]/nToys;
AICc_bkg_array[type] = AICc_bkg_array[type]/nToys;
//BIC_bkg_array[type] = BIC_bkg_array[type]/nToys;
std::cout<<"average covariance quality" << type <<" ===" << avgcov[type] <<std::endl;
std::cout<<"Log Likelihood for Model " << type << " ==== " << LogLikelihood[type] <<std::endl;
std::cout<<"AICc Value for Model: " << type << " ==== " << AICc_bkg_array[type] <<std::endl;
std::cout<<"AIC Value for Model: " << type << " ==== " << AIC_bkg_array[type] << std::endl;
//std::cout<<"BIC Value for Model: " << type << " ==== " << BIC_bkg_array[type] <<std::endl;
}
double minAIC = 10000000000.;
//double minBIC = 10000000000.;
for (int type = 0; type<display; type++) {
if (AICc_bkg_array[type] < minAIC) {
minAIC = AICc_bkg_array[type];
}
//if (BIC_bkg_array[type] < minBIC) {
// minBIC = BIC_bkg_array[type];
//}
}
std::cout<<"Minimum AIC: " << minAIC << std::endl;
double DeltaIA[8];
//double DeltaIB[7];
double sumExpA=0;
//double sumExpB=0;
int bestmodelA;
//int bestmodelB;
for (int type = 0; type<display; type++) {
DeltaIA[type] = AICc_bkg_array[type] - minAIC;
//DeltaIB[type] = BIC_bkg_array[type] - minBIC;
if (DeltaIA[type] == 0) {
bestmodelA = type;
}
//if (DeltaIB[type] == 0) {
// bestmodelB = type;
//}
std::cout<<"Delta AIC values : " << type << " ====" << DeltaIA[type] <<std::endl;
//std::cout<<"Delta BIC values : " << type << " ====" << DeltaIB[type] <<std::endl;
sumExpA+= exp(-DeltaIA[type]/2);
//sumExpB+= exp(-DeltaIB[type]/2);
}
double AICweights[8];
//double BICweights[7];
for (int type = 0; type<display; type++) {
AICweights[type] = exp(-DeltaIA[type]/2)/sumExpA;
//BICweights[type] = exp(-DeltaIB[type]/2)/sumExpB;
std::cout<<"Relative Likelihood AIC " << type << " ==== " <<exp(-DeltaIA[type]/2)<<std::endl;
std::cout<<"AIC Weights : " << type << " =====" << AICweights[type] <<std::endl;
//std::cout<<"Relative Likelihood BIC " << type << " ==== " <<exp(-DeltaIB[type]/2)<<std::endl;
//std::cout<<"BIC Weights : " << type << " =====" << BICweights[type] <<std::endl;
}
for (int type2 = 0; type2<display; type2++) {
std::cout<< "AIC Ratio for: " << "Model " << bestmodelA << " / " << "Model " << type2 << " = " << AICweights[bestmodelA]/AICweights[type2] <<std::endl;
//std::cout<< "BIC Ratio for: " << "Model " << bestmodelB << " / " << "Model " << type2 << " = " << BICweights[bestmodelB]/BICweights[type2] <<std::endl;
}
}
void CreateDataTemplates(double dX,int BRN_ORDER)
{
gROOT->ForceStyle();
RooMsgService::instance().setSilentMode(kTRUE);
for(int i=0;i<2;i++) {
RooMsgService::instance().setStreamStatus(i,kFALSE);
}
double XMIN = 80;
double XMAX = 200;
const int NSEL(2);
const int NCAT[NSEL] = {4,3};
const double MVA_BND[NSEL][NCAT[0]+1] = {{-0.6,0.0,0.7,0.84,1},{-0.1,0.4,0.8,1}};
char name[1000];
TString SELECTION[NSEL] = {"NOM","VBF"};
TString SELTAG[NSEL] = {"NOM","PRK"};
TString MASS_VAR[NSEL] = {"mbbReg[1]","mbbReg[2]"};
TFile *fBKG = TFile::Open("limit_BRN5+4_dX0p1_80-200_CAT0-6/output/bkg_shapes_workspace.root");
RooWorkspace *wBkg = (RooWorkspace*)fBKG->Get("w");
RooWorkspace *w = new RooWorkspace("w","workspace");
//RooRealVar x(*(RooRealVar*)wBkg->var("mbbReg"));
TTree *tr;
TH1F *h,*hBlind;
TCanvas *canFit[5];
RooDataHist *roohist[5],*roohist_blind[5];
TFile *fTransfer = TFile::Open("limit_BRN5+4_dX0p1_80-200_CAT0-6/output/transferFunctions.root");
TF1 *transFunc;
int counter(0);
int NPAR = BRN_ORDER;
for(int isel=0;isel<NSEL;isel++) {
TFile *fDATA = TFile::Open("flat/Fit_data_sel"+SELECTION[isel]+".root");
RooRealVar *brn[8];
RooArgSet brn_params;
if (isel == 1) {
NPAR = 4;
}
for(int ib=0;ib<=NPAR;ib++) {
brn[ib] = new RooRealVar("b"+TString::Format("%d",ib)+"_sel"+SELECTION[isel],"b"+TString::Format("%d",ib)+"_sel"+SELECTION[isel],0.5,0,10.);
brn_params.add(*brn[ib]);
}
for(int icat=0;icat<NCAT[isel];icat++) {
RooRealVar x("mbbReg_"+TString::Format("CAT%d",counter),"mbbReg_"+TString::Format("CAT%d",counter),XMIN,XMAX);
sprintf(name,"fitRatio_sel%s_CAT%d",SELTAG[isel].Data(),counter);
transFunc = (TF1*)fTransfer->Get(name);
transFunc->Print();
// --- The error on the tranfer function parameters is shrinked because the correlations are ingored.
// --- Must be consistent with TransferFunctions.C
float p0 = transFunc->GetParameter(0);
float e0 = transFunc->GetParError(0);
float p1 = transFunc->GetParameter(1);
float e1 = transFunc->GetParError(1);
float p2 = transFunc->GetParameter(2);
float e2 = transFunc->GetParError(2);
RooRealVar trans_p2(TString::Format("trans_p2_CAT%d",counter),TString::Format("trans_p2_CAT%d",counter),p2);
RooRealVar trans_p1(TString::Format("trans_p1_CAT%d",counter),TString::Format("trans_p1_CAT%d",counter),p1);
RooRealVar trans_p0(TString::Format("trans_p0_CAT%d",counter),TString::Format("trans_p0_CAT%d",counter),p0);
printf("%.2f %.2f %.2f\n",p0,p1,p2);
RooGenericPdf *transfer;
if (isel == 0) {
trans_p2.setError(0.5*e2);
trans_p1.setError(0.5*e1);
trans_p0.setError(0.5*e0);
transfer = new RooGenericPdf(TString::Format("transfer_CAT%d",counter),"@2*@0+@1",RooArgList(x,trans_p0,trans_p1));
}
else {
trans_p2.setError(0.05*e2);
trans_p1.setError(0.05*e1);
trans_p0.setError(0.05*e0);
transfer = new RooGenericPdf(TString::Format("transfer_CAT%d",counter),"@3*@0*@0+@2*@0+@1",RooArgList(x,trans_p0,trans_p1,trans_p2));
}
trans_p2.setConstant(kTRUE);
trans_p1.setConstant(kTRUE);
trans_p0.setConstant(kTRUE);
transfer->Print();
sprintf(name,"FitData_sel%s_CAT%d",SELECTION[isel].Data(),icat);
canFit[icat] = new TCanvas(name,name,900,600);
canFit[icat]->cd(1)->SetBottomMargin(0.4);
sprintf(name,"Hbb/events");
tr = (TTree*)fDATA->Get(name);
sprintf(name,"hMbb_%s_CAT%d",SELECTION[isel].Data(),icat);
int NBINS = (XMAX[isel][icat]-XMIN[isel][icat])/dX;
h = new TH1F(name,name,NBINS,XMIN[isel][icat],XMAX[isel][icat]);
sprintf(name,"hMbb_blind_%s_CAT%d",SELECTION[isel].Data(),icat);
hBlind = new TH1F(name,name,NBINS,XMIN[isel][icat],XMAX[isel][icat]);
sprintf(name,"mva%s>%1.2f && mva%s<=%1.2f",SELECTION[isel].Data(),MVA_BND[isel][icat],SELECTION[isel].Data(),MVA_BND[isel][icat+1]);
TCut cut(name);
sprintf(name,"mva%s>%1.2f && mva%s<=%1.2f && %s>100 && %s<150",SELECTION[isel].Data(),MVA_BND[isel][icat],SELECTION[isel].Data(),MVA_BND[isel][icat+1],MASS_VAR[isel].Data(),MASS_VAR[isel].Data());
TCut cutBlind(name);
tr->Draw(MASS_VAR[isel]+">>"+h->GetName(),cut);
tr->Draw(MASS_VAR[isel]+">>"+hBlind->GetName(),cutBlind);
sprintf(name,"yield_data_CAT%d",counter);
RooRealVar *Yield = new RooRealVar(name,name,h->Integral());
sprintf(name,"data_hist_CAT%d",counter);
roohist[icat] = new RooDataHist(name,name,x,h);
sprintf(name,"data_hist_blind_CAT%d",counter);
roohist_blind[icat] = new RooDataHist(name,name,x,hBlind);
RooAbsPdf *qcd_pdf;
if (icat == 0) {
for(int ib=0;ib<=NPAR;ib++) {
brn[ib]->setConstant(kFALSE);
}
sprintf(name,"qcd_model_CAT%d",counter);
RooBernstein *qcd_pdf_aux = new RooBernstein(name,name,x,brn_params);
qcd_pdf = dynamic_cast<RooAbsPdf*> (qcd_pdf_aux);
}
else {
for(int ib=0;ib<=NPAR;ib++) {
brn[ib]->setConstant(kTRUE);
}
sprintf(name,"qcd_model_aux1_CAT%d",counter);
RooBernstein *qcd_pdf_aux1 = new RooBernstein(name,name,x,brn_params);
sprintf(name,"qcd_model_CAT%d",counter);
RooProdPdf *qcd_pdf_aux2 = new RooProdPdf(name,name,RooArgSet(*transfer,*qcd_pdf_aux1));
qcd_pdf = dynamic_cast<RooAbsPdf*> (qcd_pdf_aux2);
}
sprintf(name,"Z_model_CAT%d",counter);
RooAbsPdf *z_pdf = (RooAbsPdf*)wBkg->pdf(name);
sprintf(name,"Top_model_CAT%d",counter);
RooAbsPdf *top_pdf = (RooAbsPdf*)wBkg->pdf(name);
sprintf(name,"yield_ZJets_CAT%d",counter);
RooRealVar *nZ = (RooRealVar*)wBkg->var(name);
sprintf(name,"yield_Top_CAT%d",counter);
RooRealVar *nT = (RooRealVar*)wBkg->var(name);
sprintf(name,"yield_QCD_CAT%d",counter);
RooRealVar nQCD(name,name,1000,0,1e+10);
nZ->setConstant(kTRUE);
nT->setConstant(kTRUE);
sprintf(name,"bkg_model_CAT%d",counter);
RooAddPdf model(name,name,RooArgList(*z_pdf,*top_pdf,*qcd_pdf),RooArgList(*nZ,*nT,nQCD));
RooFitResult *res = model.fitTo(*roohist[icat],RooFit::Save());
res->Print();
RooPlot* frame = x.frame();
RooPlot* frame1 = x.frame();
roohist[icat]->plotOn(frame);
model.plotOn(frame,LineWidth(2));
cout<<"chi2/ndof = "<<frame->chiSquare()<<endl;
RooHist *hresid = frame->residHist();
//model.plotOn(frame,RooFit::VisualizeError(*res,1,kFALSE),FillColor(kGray)MoveToBack());
model.plotOn(frame,Components(*qcd_pdf),LineWidth(2),LineColor(kBlack),LineStyle(kDashed));
model.plotOn(frame,Components(*z_pdf),LineWidth(2),LineColor(kBlue));
model.plotOn(frame,Components(*top_pdf),LineWidth(2),LineColor(kGreen+1));
frame->Draw();
gPad->Update();
TPad* pad = new TPad("pad", "pad", 0., 0., 1., 1.);
pad->SetTopMargin(0.6);
pad->SetFillColor(0);
pad->SetFillStyle(0);
pad->Draw();
pad->cd(0);
frame1->addPlotable(hresid,"p");
frame1->Draw();
for(int ib=0;ib<=NPAR;ib++) {
brn[ib]->setConstant(kFALSE);
}
if (icat > 0) {
trans_p2.setConstant(kFALSE);
trans_p1.setConstant(kFALSE);
trans_p0.setConstant(kFALSE);
}
if (isel == 0) {
w->import(trans_p1);
w->import(trans_p0);
}
else {
w->import(trans_p2);
w->import(trans_p1);
w->import(trans_p0);
}
w->import(*roohist[icat]);
w->import(*roohist_blind[icat]);
w->import(model);
w->import(*Yield);
counter++;
}// category loop
}// selection loop
w->Print();
w->writeToFile("data_shapes_workspace_"+TString::Format("BRN%d",BRN_ORDER)+".root");
}
void forData(string channel, string catcut, bool removeMinor=true){
// Suppress all the INFO message
RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING);
// Input files and sum all backgrounds
TChain* treeData = new TChain("tree");
TChain* treeZjets = new TChain("tree");
if( channel == "ele" ){
treeData->Add(Form("%s/data/SingleElectron-Run2015D-05Oct2015-v1_toyMCnew.root", channel.data()));
treeData->Add(Form("%s/data/SingleElectron-Run2015D-PromptReco-V4_toyMCnew.root", channel.data()));
}
else if( channel == "mu" ){
treeData->Add(Form("%s/data/SingleMuon-Run2015D-05Oct2015-v1_toyMCnew.root", channel.data()));
treeData->Add(Form("%s/data/SingleMuon-Run2015D-PromptReco-V4_toyMCnew.root", channel.data()));
}
else return;
treeZjets->Add(Form("%s/Zjets/DYJetsToLL_M-50_HT-100to200_13TeV_toyMCnew.root", channel.data()));
treeZjets->Add(Form("%s/Zjets/DYJetsToLL_M-50_HT-200to400_13TeV_toyMCnew.root", channel.data()));
treeZjets->Add(Form("%s/Zjets/DYJetsToLL_M-50_HT-400to600_13TeV_toyMCnew.root", channel.data()));
treeZjets->Add(Form("%s/Zjets/DYJetsToLL_M-50_HT-600toInf_13TeV_toyMCnew.root", channel.data()));
// To remove minor background contribution in data set (weight is -1)
if( removeMinor ){
treeData->Add(Form("%s/VV/WW_TuneCUETP8M1_13TeV_toyMCnew.root", channel.data()));
treeData->Add(Form("%s/VV/WZ_TuneCUETP8M1_13TeV_toyMCnew.root", channel.data()));
treeData->Add(Form("%s/VV/ZZ_TuneCUETP8M1_13TeV_toyMCnew.root", channel.data()));
treeData->Add(Form("%s/TT/TT_TuneCUETP8M1_13TeV_toyMCnew.root", channel.data()));
}
// Define all the variables from the trees
RooRealVar cat ("cat", "", 0, 2);
RooRealVar mJet("prmass", "M_{jet}", 30., 300., "GeV");
RooRealVar mZH ("mllbb", "M_{ZH}", 900., 3000., "GeV");
RooRealVar evWeight("evweight", "", -1.e3, 1.e3);
// Set the range in jet mass
mJet.setRange("allRange", 30., 300.);
mJet.setRange("lowSB", 30., 65.);
mJet.setRange("highSB", 135., 300.);
mJet.setRange("signal", 105., 135.);
RooBinning binsmJet(54, 30, 300);
RooArgSet variables(cat, mJet, mZH, evWeight);
TCut catCut = Form("cat==%s", catcut.c_str());
TCut sbCut = "prmass>30 && !(prmass>65 && prmass<135) && prmass<300";
TCut sigCut = "prmass>105 && prmass<135";
// Create a dataset from a tree -> to process an unbinned likelihood fitting
RooDataSet dataSetData ("dataSetData", "dataSetData", variables, Cut(catCut), WeightVar(evWeight), Import(*treeData));
RooDataSet dataSetDataSB ("dataSetDataSB", "dataSetDataSB", variables, Cut(catCut && sbCut), WeightVar(evWeight), Import(*treeData));
RooDataSet dataSetZjets ("dataSetZjets", "dataSetZjets", variables, Cut(catCut), WeightVar(evWeight), Import(*treeZjets));
RooDataSet dataSetZjetsSB("dataSetZjetsSB", "dataSetZjetsSB", variables, Cut(catCut && sbCut), WeightVar(evWeight), Import(*treeZjets));
RooDataSet dataSetZjetsSG("dataSetZjetsSG", "dataSetZjetsSG", variables, Cut(catCut && sigCut), WeightVar(evWeight), Import(*treeZjets));
// Total events number
float totalMcEv = dataSetZjetsSB.sumEntries() + dataSetZjetsSG.sumEntries();
float totalDataEv = dataSetData.sumEntries();
RooRealVar nMcEvents("nMcEvents", "nMcEvents", 0., 99999.);
RooRealVar nDataEvents("nDataEvents", "nDataEvents", 0., 99999.);
nMcEvents.setVal(totalMcEv);
nMcEvents.setConstant(true);
nDataEvents.setVal(totalDataEv);
nDataEvents.setConstant(true);
// Signal region jet mass
RooRealVar constant("constant", "constant", -0.02, -1., 0.);
RooRealVar offset ("offset", "offset", 30., -50., 200.);
RooRealVar width ("width", "width", 100., 0., 200.);
if( catcut == "1" ) offset.setConstant(true);
RooErfExpPdf model_mJet("model_mJet", "model_mJet", mJet, constant, offset, width);
RooExtendPdf ext_model_mJet("ext_model_mJet", "ext_model_mJet", model_mJet, nMcEvents);
RooFitResult* mJet_result = ext_model_mJet.fitTo(dataSetZjets, SumW2Error(true), Extended(true), Range("allRange"), Strategy(2), Minimizer("Minuit2"), Save(1));
// Side band jet mass
RooRealVar constantSB("constantSB", "constantSB", constant.getVal(), -1., 0.);
RooRealVar offsetSB ("offsetSB", "offsetSB", offset.getVal(), -50., 200.);
RooRealVar widthSB ("widthSB", "widthSB", width.getVal(), 0., 200.);
offsetSB.setConstant(true);
RooErfExpPdf model_mJetSB("model_mJetSB", "model_mJetSB", mJet, constantSB, offsetSB, widthSB);
RooExtendPdf ext_model_mJetSB("ext_model_mJetSB", "ext_model_mJetSB", model_mJetSB, nMcEvents);
RooFitResult* mJetSB_result = ext_model_mJetSB.fitTo(dataSetZjetsSB, SumW2Error(true), Extended(true), Range("lowSB,highSB"), Strategy(2), Minimizer("Minuit2"), Save(1));
RooAbsReal* nSIGFit = ext_model_mJetSB.createIntegral(RooArgSet(mJet), NormSet(mJet), Range("signal"));
float normFactor = nSIGFit->getVal() * totalMcEv;
// Plot the results on a frame
RooPlot* mJetFrame = mJet.frame();
dataSetZjetsSB. plotOn(mJetFrame, Binning(binsmJet));
ext_model_mJetSB.plotOn(mJetFrame, Range("allRange"), VisualizeError(*mJetSB_result), FillColor(kYellow));
dataSetZjetsSB. plotOn(mJetFrame, Binning(binsmJet));
ext_model_mJetSB.plotOn(mJetFrame, Range("allRange"));
mJetFrame->SetTitle("M_{jet} distribution in Z+jets MC");
// Alpha ratio part
mZH.setRange("fullRange", 900., 3000.);
RooBinning binsmZH(21, 900, 3000);
RooRealVar a("a", "a", 0., -1., 1.);
RooRealVar b("b", "b", 1000, 0., 4000.);
RooGenericPdf model_ZHSB("model_ZHSB", "model_ZHSB", "TMath::Exp(@1*@0+@2/@0)", RooArgSet(mZH,a,b));
RooGenericPdf model_ZHSG("model_ZHSG", "model_ZHSG", "TMath::Exp(@1*@0+@2/@0)", RooArgSet(mZH,a,b));
RooGenericPdf model_ZH ("model_ZH", "model_ZH", "TMath::Exp(@1*@0+@2/@0)", RooArgSet(mZH,a,b));
RooExtendPdf ext_model_ZHSB("ext_model_ZHSB", "ext_model_ZHSB", model_ZHSB, nMcEvents);
RooExtendPdf ext_model_ZHSG("ext_model_ZHSG", "ext_model_ZHSG", model_ZHSG, nMcEvents);
RooExtendPdf ext_model_ZH ("ext_model_ZH", "ext_model_ZH", model_ZH, nDataEvents);
// Fit ZH mass in side band
RooFitResult* mZHSB_result = ext_model_ZHSB.fitTo(dataSetZjetsSB, SumW2Error(true), Extended(true), Range("fullRange"), Strategy(2), Minimizer("Minuit2"), Save(1));
float p0 = a.getVal();
float p1 = b.getVal();
// Fit ZH mass in signal region
RooFitResult* mZHSG_result = ext_model_ZHSG.fitTo(dataSetZjetsSG, SumW2Error(true), Extended(true), Range("fullRange"), Strategy(2), Minimizer("Minuit2"), Save(1));
float p2 = a.getVal();
float p3 = b.getVal();
// Fit ZH mass in side band region (data)
RooFitResult* mZH_result = ext_model_ZH.fitTo(dataSetDataSB, SumW2Error(true), Extended(true), Range("fullRange"), Strategy(2), Minimizer("Minuit2"), Save(1));
// Draw the model of alpha ratio
// Multiply the model of background in data side band with the model of alpha ratio to the a model of background in data signal region
RooGenericPdf model_alpha("model_alpha", "model_alpha", Form("TMath::Exp(%f*@0+%f/@0)/TMath::Exp(%f*@0+%f/@0)", p2,p3,p0,p1), RooArgSet(mZH));
RooProdPdf model_sigData("model_sigData", "ext_model_ZH*model_alpha", RooArgList(ext_model_ZH,model_alpha));
// Plot the results to a frame
RooPlot* mZHFrameMC = mZH.frame();
dataSetZjetsSB.plotOn(mZHFrameMC, Binning(binsmZH));
ext_model_ZHSB.plotOn(mZHFrameMC, VisualizeError(*mZHSB_result), FillColor(kYellow));
dataSetZjetsSB.plotOn(mZHFrameMC, Binning(binsmZH));
ext_model_ZHSB.plotOn(mZHFrameMC, LineStyle(7), LineColor(kBlue));
dataSetZjetsSG.plotOn(mZHFrameMC, Binning(binsmZH));
ext_model_ZHSG.plotOn(mZHFrameMC, VisualizeError(*mZHSG_result), FillColor(kYellow));
dataSetZjetsSG.plotOn(mZHFrameMC, Binning(binsmZH));
ext_model_ZHSG.plotOn(mZHFrameMC, LineStyle(7), LineColor(kRed));
TLegend* leg = new TLegend(0.65,0.77,0.85,0.85);
leg->AddEntry(mZHFrameMC->findObject(mZHFrameMC->nameOf(3)), "side band", "l");
leg->AddEntry(mZHFrameMC->findObject(mZHFrameMC->nameOf(7)), "signal region", "l");
leg->Draw();
mZHFrameMC->addObject(leg);
mZHFrameMC->SetTitle("M_{ZH} distribution in MC");
RooPlot* mZHFrame = mZH.frame();
dataSetDataSB.plotOn(mZHFrame, Binning(binsmZH));
ext_model_ZH .plotOn(mZHFrame, VisualizeError(*mZH_result), FillColor(kYellow));
dataSetDataSB.plotOn(mZHFrame, Binning(binsmZH));
ext_model_ZH .plotOn(mZHFrame, LineStyle(7), LineColor(kBlue));
model_sigData.plotOn(mZHFrame, Normalization(normFactor, RooAbsReal::NumEvent), LineStyle(7), LineColor(kRed));
TLegend* leg1 = new TLegend(0.65,0.77,0.85,0.85);
leg1->AddEntry(mZHFrame->findObject(mZHFrame->nameOf(3)), "side band", "l");
leg1->AddEntry(mZHFrame->findObject(mZHFrame->nameOf(4)), "signal region", "l");
leg1->Draw();
mZHFrame->addObject(leg1);
mZHFrame->SetTitle("M_{ZH} distribution in Data");
TCanvas* c = new TCanvas("c","",0,0,1000,800);
c->cd();
mZHFrameMC->Draw();
c->Print(Form("rooFit_forData_%s_cat%s.pdf(", channel.data(), catcut.data()));
c->cd();
mZHFrame->Draw();
c->Print(Form("rooFit_forData_%s_cat%s.pdf", channel.data(), catcut.data()));
c->cd();
mJetFrame->Draw();
c->Print(Form("rooFit_forData_%s_cat%s.pdf)", channel.data(), catcut.data()));
}
void compute_p0(const char* inFileName,
const char* wsName = "combined",
const char* modelConfigName = "ModelConfig",
const char* dataName = "obsData",
const char* asimov1DataName = "asimovData_1",
const char* conditional1Snapshot = "conditionalGlobs_1",
const char* nominalSnapshot = "nominalGlobs",
string smass = "130",
string folder = "test")
{
double mass;
stringstream massStr;
massStr << smass;
massStr >> mass;
double mu_profile_value = 1; // mu value to profile the obs data at wbefore generating the expected
bool doConditional = 1; // do conditional expected data
bool remakeData = 0; // handle unphysical pdf cases in H->ZZ->4l
bool doUncap = 1; // uncap p0
bool doInj = 0; // setup the poi for injection study (zero is faster if you're not)
bool doObs = 1; // compute median significance
bool doMedian = 1; // compute observed significance
TStopwatch timer;
timer.Start();
TFile f(inFileName);
RooWorkspace* ws = (RooWorkspace*)f.Get(wsName);
if (!ws)
{
cout << "ERROR::Workspace: " << wsName << " doesn't exist!" << endl;
return;
}
ModelConfig* mc = (ModelConfig*)ws->obj(modelConfigName);
if (!mc)
{
cout << "ERROR::ModelConfig: " << modelConfigName << " doesn't exist!" << endl;
return;
}
RooDataSet* data = (RooDataSet*)ws->data(dataName);
if (!data)
{
cout << "ERROR::Dataset: " << dataName << " doesn't exist!" << endl;
return;
}
mc->GetNuisanceParameters()->Print("v");
ROOT::Math::MinimizerOptions::SetDefaultMinimizer("Minuit2");
ROOT::Math::MinimizerOptions::SetDefaultStrategy(0);
ROOT::Math::MinimizerOptions::SetDefaultPrintLevel(1);
cout << "Setting max function calls" << endl;
ws->loadSnapshot("conditionalNuis_0");
RooArgSet nuis(*mc->GetNuisanceParameters());
RooRealVar* mu = (RooRealVar*)mc->GetParametersOfInterest()->first();
RooAbsPdf* pdf = mc->GetPdf();
string condSnapshot(conditional1Snapshot);
RooArgSet nuis_tmp2 = *mc->GetNuisanceParameters();
RooNLLVar* obs_nll = doObs ? (RooNLLVar*)pdf->createNLL(*data, Constrain(nuis_tmp2)) : NULL;
RooDataSet* asimovData1 = (RooDataSet*)ws->data(asimov1DataName);
RooRealVar* emb = (RooRealVar*)mc->GetNuisanceParameters()->find("ATLAS_EMB");
if (!asimovData1 || (string(inFileName).find("ic10") != string::npos && emb))
{
if (emb) emb->setVal(0.7);
cout << "Asimov data doesn't exist! Please, allow me to build one for you..." << endl;
string mu_str, mu_prof_str;
asimovData1 = makeAsimovData(mc, doConditional, ws, obs_nll, 1, &mu_str, &mu_prof_str, mu_profile_value, true);
condSnapshot="conditionalGlobs"+mu_prof_str;
}
if (!doUncap) mu->setRange(0, 40);
else mu->setRange(-40, 40);
RooAbsPdf* pdf = mc->GetPdf();
RooArgSet nuis_tmp1 = *mc->GetNuisanceParameters();
RooNLLVar* asimov_nll = (RooNLLVar*)pdf->createNLL(*asimovData1, Constrain(nuis_tmp1));
//do asimov
mu->setVal(1);
mu->setConstant(0);
if (!doInj) mu->setConstant(1);
int status,sign;
double med_sig=0,obs_sig=0,asimov_q0=0,obs_q0=0;
if (doMedian)
{
ws->loadSnapshot(condSnapshot.c_str());
if (doInj) ws->loadSnapshot("conditionalNuis_inj");
else ws->loadSnapshot("conditionalNuis_1");
mc->GetGlobalObservables()->Print("v");
mu->setVal(0);
mu->setConstant(1);
status = minimize(asimov_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(asimov_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double asimov_nll_cond = asimov_nll->getVal();
mu->setVal(1);
if (doInj) ws->loadSnapshot("conditionalNuis_inj");
else ws->loadSnapshot("conditionalNuis_1");
if (doInj) mu->setConstant(0);
status = minimize(asimov_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(asimov_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double asimov_nll_min = asimov_nll->getVal();
asimov_q0 = 2*(asimov_nll_cond - asimov_nll_min);
if (doUncap && mu->getVal() < 0) asimov_q0 = -asimov_q0;
sign = int(asimov_q0 != 0 ? asimov_q0/fabs(asimov_q0) : 0);
med_sig = sign*sqrt(fabs(asimov_q0));
ws->loadSnapshot(nominalSnapshot);
}
if (doObs)
{
ws->loadSnapshot("conditionalNuis_0");
mu->setVal(0);
mu->setConstant(1);
status = minimize(obs_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(obs_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double obs_nll_cond = obs_nll->getVal();
mu->setConstant(0);
status = minimize(obs_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(obs_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double obs_nll_min = obs_nll->getVal();
obs_q0 = 2*(obs_nll_cond - obs_nll_min);
if (doUncap && mu->getVal() < 0) obs_q0 = -obs_q0;
sign = int(obs_q0 == 0 ? 0 : obs_q0 / fabs(obs_q0));
if (!doUncap && (obs_q0 < 0 && obs_q0 > -0.1 || mu->getVal() < 0.001)) obs_sig = 0;
else obs_sig = sign*sqrt(fabs(obs_q0));
}
// Report results
cout << "obs: " << obs_sig << endl;
cout << "Observed significance: " << obs_sig << endl;
cout << "Corresponding to a p-value of " << (1-ROOT::Math::gaussian_cdf( obs_sig )) << endl;
if (med_sig)
{
cout << "Median test stat val: " << asimov_q0 << endl;
cout << "Median significance: " << med_sig << endl;
}
f.Close();
stringstream fileName;
fileName << "root-files/" << folder << "/" << mass << ".root";
system(("mkdir -vp root-files/" + folder).c_str());
TFile f2(fileName.str().c_str(),"recreate");
TH1D* h_hypo = new TH1D("hypo","hypo",2,0,2);
h_hypo->SetBinContent(1, obs_sig);
h_hypo->SetBinContent(2, med_sig);
f2.Write();
f2.Close();
timer.Stop();
timer.Print();
}
void runQ(const char* inFileName,
const char* wsName = "combined",
const char* modelConfigName = "ModelConfig",
const char* dataName = "obsData",
const char* asimov0DataName = "asimovData_0",
const char* conditional0Snapshot = "conditionalGlobs_0",
const char* asimov1DataName = "asimovData_1",
const char* conditional1Snapshot = "conditionalGlobs_1",
const char* nominalSnapshot = "nominalGlobs",
string smass = "130",
string folder = "test")
{
double mass;
stringstream massStr;
massStr << smass;
massStr >> mass;
bool errFast = 0;
bool goFast = 1;
bool remakeData = 1;
bool doRightSided = 1;
bool doInj = 0;
bool doObs = 1;
bool doMedian = 1;
TStopwatch timer;
timer.Start();
TFile f(inFileName);
RooWorkspace* ws = (RooWorkspace*)f.Get(wsName);
if (!ws)
{
cout << "ERROR::Workspace: " << wsName << " doesn't exist!" << endl;
return;
}
ModelConfig* mc = (ModelConfig*)ws->obj(modelConfigName);
if (!mc)
{
cout << "ERROR::ModelConfig: " << modelConfigName << " doesn't exist!" << endl;
return;
}
RooDataSet* data = (RooDataSet*)ws->data(dataName);
if (!data)
{
cout << "ERROR::Dataset: " << dataName << " doesn't exist!" << endl;
return;
}
mc->GetNuisanceParameters()->Print("v");
RooNLLVar::SetIgnoreZeroEntries(1);
ROOT::Math::MinimizerOptions::SetDefaultMinimizer("Minuit2");
ROOT::Math::MinimizerOptions::SetDefaultStrategy(0);
ROOT::Math::MinimizerOptions::SetDefaultPrintLevel(1);
cout << "Setting max function calls" << endl;
//ROOT::Math::MinimizerOptions::SetDefaultMaxFunctionCalls(20000);
RooMinimizer::SetMaxFunctionCalls(10000);
ws->loadSnapshot("conditionalNuis_0");
RooArgSet nuis(*mc->GetNuisanceParameters());
RooRealVar* mu = (RooRealVar*)mc->GetParametersOfInterest()->first();
if (string(mc->GetPdf()->ClassName()) == "RooSimultaneous" && remakeData)
{
RooSimultaneous* simPdf = (RooSimultaneous*)mc->GetPdf();
double min_mu;
data = makeData(data, simPdf, mc->GetObservables(), mu, mass, min_mu);
}
RooDataSet* asimovData0 = (RooDataSet*)ws->data(asimov0DataName);
if (!asimovData0)
{
cout << "Asimov data doesn't exist! Please, allow me to build one for you..." << endl;
makeAsimovData(mc, true, ws, mc->GetPdf(), data, 1);
ws->Print();
asimovData0 = (RooDataSet*)ws->data("asimovData_0");
}
RooDataSet* asimovData1 = (RooDataSet*)ws->data(asimov1DataName);
if (!asimovData1)
{
cout << "Asimov data doesn't exist! Please, allow me to build one for you..." << endl;
makeAsimovData(mc, true, ws, mc->GetPdf(), data, 0);
ws->Print();
asimovData1 = (RooDataSet*)ws->data("asimovData_1");
}
if (!doRightSided) mu->setRange(0, 40);
else mu->setRange(-40, 40);
bool old = false;
if (old)
{
mu->setVal(0);
RooArgSet poi(*mu);
ProfileLikelihoodTestStat_modified asimov_testStat_sig(*mc->GetPdf());
asimov_testStat_sig.SetRightSided(doRightSided);
asimov_testStat_sig.SetNuis(&nuis);
if (!doInj) asimov_testStat_sig.SetDoAsimov(true, 1);
asimov_testStat_sig.SetWorkspace(ws);
ProfileLikelihoodTestStat_modified testStat(*mc->GetPdf());
testStat.SetRightSided(doRightSided);
testStat.SetNuis(&nuis);
testStat.SetWorkspace(ws);
//RooMinimizerFcn::SetOverrideEverything(true);
double med_sig = 0;
double med_testStat_val = 0;
//gRandom->SetSeed(1);
//RooRandom::randomGenerator()->SetSeed(1);
RooNLLVar::SetIgnoreZeroEntries(1);
if (asimov1DataName != "" && doMedian)
{
mu->setVal(0);
if (!doInj) mu->setRange(0, 2);
ws->loadSnapshot("conditionalNuis_0");
asimov_testStat_sig.SetLoadUncondSnapshot("conditionalNuis_1");
if (string(conditional1Snapshot) != "") ws->loadSnapshot(conditional1Snapshot);
med_testStat_val = 2*asimov_testStat_sig.Evaluate(*asimovData1, poi);
if (med_testStat_val < 0 && !doInj)
{
mu->setVal(0);
med_testStat_val = 2*asimov_testStat_sig.Evaluate(*asimovData1, poi); // just try again
}
int sign = med_testStat_val != 0 ? med_testStat_val/fabs(med_testStat_val) : 0;
med_sig = sign*sqrt(fabs(med_testStat_val));
if (string(nominalSnapshot) != "") ws->loadSnapshot(nominalSnapshot);
if (!doRightSided) mu->setRange(0, 40);
else mu->setRange(-40, 40);
}
RooNLLVar::SetIgnoreZeroEntries(0);
//gRandom->SetSeed(1);
//RooRandom::randomGenerator()->SetSeed(1);
//RooMinimizerFcn::SetOverrideEverything(false);
cout << "med test stat: " << med_testStat_val << endl;
ws->loadSnapshot("nominalGlobs");
ws->loadSnapshot("conditionalNuis_0");
mu->setVal(0);
testStat.SetWorkspace(ws);
testStat.SetLoadUncondSnapshot("ucmles");
double obsTestStat_val = doObs ? 2*testStat.Evaluate(*data, poi) : 0;
cout << "obs test stat: " << obsTestStat_val << endl;
// obsTestStat_val = 2*testStat.Evaluate(*data, poi);
// cout << "obs test stat: " << obsTestStat_val << endl;
// obsTestStat_val = 2*testStat.Evaluate(*data, poi);
// cout << "obs test stat: " << obsTestStat_val << endl;
double obs_sig;
int sign = obsTestStat_val == 0 ? 0 : obsTestStat_val / fabs(obsTestStat_val);
if (!doRightSided && (obsTestStat_val < 0 && obsTestStat_val > -0.1 || mu->getVal() < 0.001)) obs_sig = 0;
else obs_sig = sign*sqrt(fabs(obsTestStat_val));
if (obs_sig != obs_sig) //nan, do by hand
{
cout << "Obs test stat gave nan: try by hand" << endl;
mu->setVal(0);
mu->setConstant(1);
mc->GetPdf()->fitTo(*data, Hesse(0), Minos(0), PrintLevel(-1), Constrain(*mc->GetNuisanceParameters()));
mu->setConstant(0);
double L_0 = mc->GetPdf()->getVal();
//mu->setVal(0);
//mu->setConstant(1);
mc->GetPdf()->fitTo(*data, Hesse(0), Minos(0), PrintLevel(-1), Constrain(*mc->GetNuisanceParameters()));
//mu->setConstant(0);
double L_muhat = mc->GetPdf()->getVal();
cout << "L_0: " << L_0 << ", L_muhat: " << L_muhat << endl;
obs_sig = sqrt(-2*TMath::Log(L_0/L_muhat));
//still nan
if (obs_sig != obs_sig && fabs(L_0 - L_muhat) < 0.000001) obs_sig = 0;
}
cout << "obs: " << obs_sig << endl;
cout << "Observed significance: " << obs_sig << endl;
if (med_sig)
{
cout << "Median test stat val: " << med_testStat_val << endl;
cout << "Median significance: " << med_sig << endl;
}
f.Close();
stringstream fileName;
fileName << "root_files/" << folder << "/" << mass << ".root";
system(("mkdir -vp root_files/" + folder).c_str());
TFile f2(fileName.str().c_str(),"recreate");
// stringstream fileName;
// fileName << "results_sig/" << mass << ".root";
// system("mkdir results_sig");
// TFile f(fileName.str().c_str(),"recreate");
TH1D* h_hypo = new TH1D("hypo","hypo",2,0,2);
h_hypo->SetBinContent(1, obs_sig);
h_hypo->SetBinContent(2, med_sig);
f2.Write();
f2.Close();
//mc->GetPdf()->fitTo(*data, PrintLevel(0));
timer.Stop();
timer.Print();
}
else
{
RooAbsPdf* pdf = mc->GetPdf();
RooArgSet nuis_tmp1 = *mc->GetNuisanceParameters();
RooNLLVar* asimov_nll0 = (RooNLLVar*)pdf->createNLL(*asimovData0, Constrain(nuis_tmp1));
RooArgSet nuis_tmp2 = *mc->GetNuisanceParameters();
RooNLLVar* asimov_nll1 = (RooNLLVar*)pdf->createNLL(*asimovData1, Constrain(nuis_tmp2));
RooArgSet nuis_tmp3 = *mc->GetNuisanceParameters();
RooNLLVar* obs_nll = (RooNLLVar*)pdf->createNLL(*data, Constrain(nuis_tmp3));
//do asimov
int status;
//get sigma_b
ws->loadSnapshot(conditional0Snapshot);
status = ws->loadSnapshot("conditionalNuis_0");
if (status != 0 && goFast) errFast = 1;
mu->setVal(0);
mu->setConstant(1);
status = goFast ? 0 : minimize(asimov_nll0, ws);
if (status < 0)
{
cout << "Retrying" << endl;
//ws->loadSnapshot("conditionalNuis_0");
status = minimize(asimov_nll0, ws);
if (status >= 0) cout << "Success!" << endl;
}
double asimov0_nll0 = asimov_nll0->getVal();
mu->setVal(1);
ws->loadSnapshot("conditionalNuis_1");
status = minimize(asimov_nll0, ws);
if (status < 0)
{
cout << "Retrying" << endl;
//ws->loadSnapshot("conditionalNuis_0");
status = minimize(asimov_nll0, ws);
if (status >= 0) cout << "Success!" << endl;
}
double asimov0_nll1 = asimov_nll0->getVal();
double asimov0_q = 2*(asimov0_nll1 - asimov0_nll0);
double sigma_b = sqrt(1./asimov0_q);
ws->loadSnapshot(nominalSnapshot);
//get sigma_sb
ws->loadSnapshot(conditional1Snapshot);
ws->loadSnapshot("conditionalNuis_0");
mu->setVal(0);
mu->setConstant(1);
status = minimize(asimov_nll1, ws);
if (status < 0)
{
cout << "Retrying" << endl;
//ws->loadSnapshot("conditionalNuis_0");
status = minimize(asimov_nll1, ws);
if (status >= 0) cout << "Success!" << endl;
}
double asimov1_nll0 = asimov_nll1->getVal();
mu->setVal(1);
status = ws->loadSnapshot("conditionalNuis_1");
if (status != 0 && goFast) errFast = 1;
status = goFast ? 0 : minimize(asimov_nll1, ws);
if (status < 0)
{
cout << "Retrying" << endl;
//ws->loadSnapshot("conditionalNuis_0");
status = minimize(asimov_nll1, ws);
if (status >= 0) cout << "Success!" << endl;
}
double asimov1_nll1 = asimov_nll1->getVal();
double asimov1_q = 2*(asimov1_nll1 - asimov1_nll0);
double sigma_sb = sqrt(-1./asimov1_q);
ws->loadSnapshot(nominalSnapshot);
//do obs
mu->setVal(0);
status = ws->loadSnapshot("conditionalNuis_0");
if (status != 0 && goFast) errFast = 1;
mu->setConstant(1);
status = goFast ? 0 : minimize(obs_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(obs_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double obs_nll0 = obs_nll->getVal();
status = ws->loadSnapshot("conditionalNuis_1");
if (status != 0 && goFast) errFast = 1;
mu->setVal(1);
status = goFast ? 0 : minimize(obs_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(obs_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double obs_nll1 = obs_nll->getVal();
double obs_q = 2*(obs_nll1 - obs_nll0);
double Zobs = (1./sigma_b/sigma_b - obs_q) / (2./sigma_b);
double Zexp = (1./sigma_b/sigma_b - asimov1_q) / (2./sigma_b);
double pb_obs = 1-ROOT::Math::gaussian_cdf(Zobs);
double pb_exp = 1-ROOT::Math::gaussian_cdf(Zexp);
cout << "asimov0_q = " << asimov0_q << endl;
cout << "asimov1_q = " << asimov1_q << endl;
cout << "obs_q = " << obs_q << endl;
cout << "sigma_b = " << sigma_b << endl;
cout << "sigma_sb = " << sigma_sb << endl;
cout << "Z obs = " << Zobs << endl;
cout << "Z exp = " << Zexp << endl;
f.Close();
stringstream fileName;
fileName << "root_files/" << folder << "/" << mass << ".root";
system(("mkdir -vp root_files/" + folder).c_str());
TFile f2(fileName.str().c_str(),"recreate");
TH1D* h_hypo = new TH1D("hypo_tev","hypo_tev",2,0,2);
h_hypo->SetBinContent(1, pb_obs);
h_hypo->SetBinContent(2, pb_exp);
f2.Write();
f2.Close();
stringstream fileName3;
fileName3 << "root_files/" << folder << "_llr/" << mass << ".root";
system(("mkdir -vp root_files/" + folder + "_llr").c_str());
TFile f3(fileName3.str().c_str(),"recreate");
TH1D* h_hypo3 = new TH1D("hypo_llr","hypo_llr",7,0,7);
h_hypo3->SetBinContent(1, -obs_q);
h_hypo3->SetBinContent(2, -asimov1_q);
h_hypo3->SetBinContent(3, -asimov0_q);
h_hypo3->SetBinContent(4, -asimov0_q-2*2/sigma_b);
h_hypo3->SetBinContent(5, -asimov0_q-1*2/sigma_b);
h_hypo3->SetBinContent(6, -asimov0_q+1*2/sigma_b);
h_hypo3->SetBinContent(7, -asimov0_q+2*2/sigma_b);
f3.Write();
f3.Close();
timer.Stop();
timer.Print();
}
}
void RooToyMCFit(){
stringstream out;
out.str("");
out << "toyMC_" << _sigma_over_tau << "_" << _purity << "_" << mistag_rate << ".root";
TFile* file = TFile::Open(out.str().c_str());
TTree* tree = (TTree*)file->Get("ToyTree");
tree->Print();
// TFile* file = TFile::Open("ToyData/toyMC_453_0.912888_0.3_0.8_0.root");
// TFile* file = TFile::Open("ToyData/toyMC_10000_0.9_0.3_0.8_0.root");
// TTree* tree = (TTree*)file->Get("ToyTree1");
RooRealVar tau("tau","tau",_tau,"ps"); tau.setConstant(kTRUE);
RooRealVar dm("dm","dm",_dm,"ps^{-1}"); dm.setConstant(kTRUE);
RooAbsReal* sin2beta;
RooAbsReal* cos2beta;
if(softlimit){
RooRealVar x("x","x",_cos2beta,-3.,30000.); if(constBeta) x.setConstant(kTRUE);
RooRealVar y("y","y",_sin2beta,-3.,30000.); if(constBeta) y.setConstant(kTRUE);
cos2beta = new RooFormulaVar("cos2beta","cos2beta","@0/sqrt(@0*@0+@1*@1)",RooArgSet(x,y));
sin2beta = new RooFormulaVar("sin2beta","sin2beta","@0/sqrt(@0*@0+@1*@1)",RooArgSet(y,x));
// sin2beta = new RooFormulaVar("sin2beta","sin2beta","2/TMath::Pi()*TMath::ATan(@0)",RooArgSet(y));
// cos2beta = new RooFormulaVar("cos2beta","cos2beta","2/TMath::Pi()*TMath::ATan(@0)",RooArgSet(x));
}
else{
sin2beta = new RooRealVar("sin2beta","sin2beta",_sin2beta,-3.,3.); if(constBeta) ((RooRealVar*)sin2beta)->setConstant(kTRUE);
cos2beta = new RooRealVar("cos2beta","cos2beta",_cos2beta,-3.,3.); if(constBeta) ((RooRealVar*)cos2beta)->setConstant(kTRUE);
}
RooRealVar dt("dt","#Deltat",-5.,5.,"ps");
RooRealVar avgMisgat("avgMisgat","avgMisgat",mistag_rate,0.0,0.5); if(constMistag) avgMisgat.setConstant(kTRUE);
RooRealVar delMisgat("delMisgat","delMisgat",0); delMisgat.setConstant(kTRUE);
RooRealVar mu("mu","mu",0); mu.setConstant(kTRUE);
tau.Print();
dm.Print();
sin2beta->Print();
cos2beta->Print();
avgMisgat.Print();
RooRealVar moment("moment","moment",0.); moment.setConstant(kTRUE);
RooRealVar parity("parity","parity",-1.); parity.setConstant(kTRUE);
RooRealVar* K[8];
RooAbsReal* Kb[8];
RooArgList Kset;
RooRealVar* C[8];
RooRealVar* S[8];
RooFormulaVar* a1[2][8];
RooFormulaVar* b1[2][8];
RooFormulaVar* a2[2][8];
RooFormulaVar* b2[2][8];
for(int i=0; i<8; i++){
out.str("");
out << "K" << i+1;
K[i] = new RooRealVar(out.str().c_str(),out.str().c_str(),_K[i],0.,1.); Kset.add(*K[i]); if(constK) K[i]->setConstant(kTRUE);
K[i]->Print();
if(i!=7){
out.str("");
out << "Kb" << i+1;
Kb[i] = new RooRealVar(out.str().c_str(),out.str().c_str(),_Kb[i],0.,1.); Kset.add(*Kb[i]); if(constK) ((RooRealVar*)Kb[i])->setConstant(kTRUE);
Kb[i]->Print();
}
out.str("");
out << "C" << i+1;
C[i] = new RooRealVar(out.str().c_str(),out.str().c_str(),_C[i]); C[i]->setConstant(kTRUE);
C[i]->Print();
out.str("");
out << "S" << i+1;
S[i] = new RooRealVar(out.str().c_str(),out.str().c_str(),_S[i]); S[i]->setConstant(kTRUE);
S[i]->Print();
}
Kb[7] = new RooFormulaVar("K8b","K8b","1-@0-@1-@2-@3-@4-@5-@6-@7-@8-@9-@10-@11-@12-@13-@14",Kset);
for(int i=0; i<8; i++){
out.str("");
out << "a10_" << i+1;
a1[0][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"-(@0-@1)/(@0+@1)",RooArgList(*K[i],*Kb[i]));
a1[0][i]->Print();
out.str("");
out << "a11_" << i+1;
a1[1][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"(@0-@1)/(@0+@1)",RooArgList(*K[i],*Kb[i]));
a1[1][i]->Print();
out.str("");
out << "a20_" << i+1;
a2[0][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"(@0-@1)/(@0+@1)",RooArgList(*K[i],*Kb[i]));
a2[0][i]->Print();
out.str("");
out << "a21_" << i+1;
a2[1][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"-(@0-@1)/(@0+@1)",RooArgList(*K[i],*Kb[i]));
a2[1][i]->Print();
out.str("");
out << "b10_" << i+1;
b1[0][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"2.*(@2*@4+@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1)",RooArgList(*K[i],*Kb[i],*C[i],*S[i],*sin2beta,*cos2beta));
b1[0][i]->Print();
out.str("");
out << "b11_" << i+1;
b1[1][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"2.*(@2*@4-@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1)",RooArgList(*K[i],*Kb[i],*C[i],*S[i],*sin2beta,*cos2beta));
b1[1][i]->Print();
out.str("");
out << "b20_" << i+1;
b2[0][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"-2.*(@2*@4+@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1)",RooArgList(*K[i],*Kb[i],*C[i],*S[i],*sin2beta,*cos2beta));
b2[0][i]->Print();
out.str("");
out << "b21_" << i+1;
b2[1][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"-2.*(@2*@4-@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1)",RooArgList(*K[i],*Kb[i],*C[i],*S[i],*sin2beta,*cos2beta));
b2[1][i]->Print();
cout << "bin = " << i+1 << endl;
cout << " a11 = " << a1[0][i]->getVal() << " b11 = " << b1[0][i]->getVal() << endl;
cout << " a12 = " << a1[1][i]->getVal() << " b12 = " << b1[1][i]->getVal() << endl;
cout << " a21 = " << a2[0][i]->getVal() << " b21 = " << b2[0][i]->getVal() << endl;
cout << " a22 = " << a2[1][i]->getVal() << " b22 = " << b2[1][i]->getVal() << endl;
}
RooRealVar* dgamma = new RooRealVar("dgamma","dgamma",0.); dgamma->setConstant(kTRUE);
RooRealVar* f0 = new RooRealVar("f0","f0",1.); f0->setConstant(kTRUE);
RooRealVar* f1 = new RooRealVar("f1","f1",0.); f1->setConstant(kTRUE);
RooCategory tag("tag","tag");
tag.defineType("B0",1);
tag.defineType("anti-B0",-1);
RooCategory bin("bin","bin");
bin.defineType("1",1);
bin.defineType("2",2);
bin.defineType("3",3);
bin.defineType("4",4);
bin.defineType("5",5);
bin.defineType("6",6);
bin.defineType("7",7);
bin.defineType("8",8);
bin.defineType("-1",-1);
bin.defineType("-2",-2);
bin.defineType("-3",-3);
bin.defineType("-4",-4);
bin.defineType("-5",-5);
bin.defineType("-6",-6);
bin.defineType("-7",-7);
bin.defineType("-8",-8);
RooSuperCategory bintag("bintag","bintag",RooArgSet(bin,tag));
tree->Print();
RooDataSet d("data","data",tree,RooArgSet(dt,bin,tag));
cout << "DataSet is ready." << endl;
d.Print();
RooRealVar mean("mean","mean",0.,"ps"); mean.setConstant(kTRUE);
RooRealVar sigma("sigma","sigma",_sigma_over_tau*_tau,0.,1.5*_tau,"ps"); if(constSigma) sigma.setConstant(kTRUE);
RooGaussModel rf("rf","rf",dt,mean,sigma);
// RooTruthModel rf("rf","rf",dt);
RooGaussian rfpdf("rfpdf","rfpdf",dt,mean,sigma);
cout << "Preparing PDFs..." << endl;
// RooRealVar* fsigs1[8];
// RooRealVar* fsigs1b[8];
// RooRealVar* fsigs2[8];
// RooRealVar* fsigs2b[8];
RooBDecay* sigpdfs1[8];
RooBDecay* sigpdfs1b[8];
RooBDecay* sigpdfs2[8];
RooBDecay* sigpdfs2b[8];
RooAddPdf* PDFs1[8];
RooAddPdf* PDFs1b[8];
RooAddPdf* PDFs2[8];
RooAddPdf* PDFs2b[8];
RooAddPdf* pdfs1[8];
RooAddPdf* pdfs1b[8];
RooAddPdf* pdfs2[8];
RooAddPdf* pdfs2b[8];
RooSimultaneous pdf("pdf","pdf",bintag);
RooRealVar fsig("fsig","fsig",_purity,0.,1.); if(constFSig) fsig.setConstant(kTRUE);
fsig.Print();
for(int j=0; j<8; j++){
// out.str("");
// out << "fsig1" << j+1;
// fsigs1[j] = new RooRealVar(out.str().c_str(),out.str().c_str(),_purity,0.,1.); if(constFSig) fsigs1[j]->setConstant(kTRUE);
// out.str("");
// out << "fsig1b" << j+1;
// fsigs1b[j] = new RooRealVar(out.str().c_str(),out.str().c_str(),_purity,0.,1.); if(constFSig) fsigs1b[j]->setConstant(kTRUE);
// out.str("");
// out << "fsig2" << j+1;
// fsigs2[j] = new RooRealVar(out.str().c_str(),out.str().c_str(),_purity,0.,1.); if(constFSig) fsigs2[j]->setConstant(kTRUE);
// out.str("");
// out << "fsig2b" << j+1;
// fsigs2b[j] = new RooRealVar(out.str().c_str(),out.str().c_str(),_purity,0.,1.); if(constFSig) fsigs2b[j]->setConstant(kTRUE);
out.str("");
out << "sigpdf1" << j+1;
sigpdfs1[j] = new RooBDecay(out.str().c_str(),out.str().c_str(),dt,tau,*dgamma,*f0,*f1,*a1[0][j],*b1[0][j],dm,rf,RooBDecay::DoubleSided);
out.str("");
out << "sigpdf1b" << j+1;
sigpdfs1b[j] = new RooBDecay(out.str().c_str(),out.str().c_str(),dt,tau,*dgamma,*f0,*f1,*a1[1][j],*b1[1][j],dm,rf,RooBDecay::DoubleSided);
out.str("");
out << "sigpdf2" << j+1;
sigpdfs2[j] = new RooBDecay(out.str().c_str(),out.str().c_str(),dt,tau,*dgamma,*f0,*f1,*a2[0][j],*b2[0][j],dm,rf,RooBDecay::DoubleSided);
out.str("");
out << "sigpdf2b" << j+1;
sigpdfs2b[j] = new RooBDecay(out.str().c_str(),out.str().c_str(),dt,tau,*dgamma,*f0,*f1,*a2[1][j],*b2[1][j],dm,rf,RooBDecay::DoubleSided);
out.str("");
out << "PDF1" << j+1;
PDFs1[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*sigpdfs1[j],rfpdf),RooArgList(fsig));
out.str("");
out << "PDF1b" << j+1;
PDFs1b[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*sigpdfs1b[j],rfpdf),RooArgList(fsig));
out.str("");
out << "PDF2" << j+1;
PDFs2[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*sigpdfs2[j],rfpdf),RooArgList(fsig));
out.str("");
out << "PDF2b" << j+1;
PDFs2b[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*sigpdfs2b[j],rfpdf),RooArgList(fsig));
//Adding mistaging
out.str("");
out << "pdf1" << j+1;
pdfs1[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*PDFs2[j],*PDFs1[j]),RooArgList(avgMisgat));
out.str("");
out << "pdf1b" << j+1;
pdfs1b[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*PDFs2b[j],*PDFs1b[j]),RooArgList(avgMisgat));
out.str("");
out << "pdf2" << j+1;
pdfs2[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*PDFs1[j],*PDFs2[j]),RooArgList(avgMisgat));
out.str("");
out << "pdf2b" << j+1;
pdfs2b[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*PDFs1b[j],*PDFs2b[j]),RooArgList(avgMisgat));
out.str("");
out << "{" << j+1 << ";B0}";
pdf.addPdf(*pdfs1[j],out.str().c_str());
out.str("");
out << "{" << -(j+1) << ";B0}";
pdf.addPdf(*pdfs1b[j],out.str().c_str());
out.str("");
out << "{" << j+1 << ";anti-B0}";
pdf.addPdf(*pdfs2[j],out.str().c_str());
out.str("");
out << "{" << -(j+1) << ";anti-B0}";
pdf.addPdf(*pdfs2b[j],out.str().c_str());
}
cout << "Fitting..." << endl;
pdf.fitTo(d,Verbose(),Timer());
dt.setBins(50);
cout << "Drawing plots." << endl;
for(int i=0; i<8; i++){
RooPlot* dtFrame = dt.frame();
out.str("");
out << "tag == 1 && bin == " << i+1;
RooDataSet* ds = d.reduce(out.str().c_str());
ds->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),Cut(out.str().c_str()),MarkerColor(kBlue));
out.str("");
out << "{" << j+1 << ";B0}";
bintag = out.str().c_str();
pdf.plotOn(dtFrame,ProjWData(*ds),Slice(bintag),LineColor(kBlue));
double chi2 = dtFrame->chiSquare();
out.str("");
out << "tag == -1 && bin == " << i+1;
RooDataSet* dsb = d.reduce(out.str().c_str());
dsb->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),Cut(out.str().c_str()),MarkerColor(kRed));
out.str("");
out << "{" << j+1 << ";anti-B0}";
bintag = out.str().c_str();
pdf.plotOn(dtFrame,ProjWData(*dsb),Slice(bintag),LineColor(kRed));
double chi2b = dtFrame->chiSquare();
out.str("");
out << "#Delta t, toy MC, bin == " << i+1;
TCanvas* cm = new TCanvas(out.str().c_str(),out.str().c_str(),600,400);
cm->cd();
dtFrame->GetXaxis()->SetTitleSize(0.05);
dtFrame->GetXaxis()->SetTitleOffset(0.85);
dtFrame->GetXaxis()->SetLabelSize(0.05);
dtFrame->GetYaxis()->SetTitleOffset(1.6);
TPaveText *ptB = new TPaveText(0.7,0.65,0.98,0.99,"brNDC");
ptB->SetFillColor(0);
ptB->SetTextAlign(12);
out.str("");
out << "bin = " << (i+1);
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(B^{0}) = " << chi2;
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(#barB^{0}) = " << chi2b;
ptB->AddText(out.str().c_str());
out.str("");
out << "#sigma/#tau = " << _sigma_over_tau;
ptB->AddText(out.str().c_str());
out.str("");
out << "purity = " << _purity;
ptB->AddText(out.str().c_str());
out.str("");
out << "mistag = " << mistag_rate;
ptB->AddText(out.str().c_str());
dtFrame->Draw();
ptB->Draw();
out.str("");
out << "../Reports/cpfitfigs/dt_bin" << (i+1) << ".root";
cm->Print(out.str().c_str());
out.str("");
out << "../Reports/cpfitfigs/dt_bin" << (i+1) << ".png";
cm->Print(out.str().c_str());
}
for(int i=0; i<8; i++){
RooPlot* dtFrame = dt.frame();
out.str("");
out << "tag == 1 && bin == " << -(i+1);
RooDataSet* ds2 = (RooDataSet*)d.reduce(out.str().c_str());
ds2->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),Cut(out.str().c_str()),MarkerColor(kBlue));
out.str("");
out << "{" << -(j+1) << ";B0}";
bintag = out.str().c_str();
pdf.plotOn(dtFrame,ProjWData(*ds2),Slice(bintag),LineColor(kBlue));
double chi2 = dtFrame->chiSquare();
out.str("");
out << "tag == -1 && bin == " << -(i+1);
RooDataSet* ds2b = (RooDataSet*)d.reduce(out.str().c_str());
ds2b->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),Cut(out.str().c_str()),MarkerColor(kRed));
out.str("");
out << "{" << -(j+1) << ";anti-B0}";
bin = out.str().c_str();
pdf.plotOn(dtFrame,ProjWData(*ds2b),Slice(bintag),LineColor(kRed));
double chi2b = dtFrame->chiSquare();
out.str("");
out << "#Delta t, toy MC, bin == " << -(i+1);
TCanvas* cm = new TCanvas(out.str().c_str(),out.str().c_str(),600,400);
cm->cd();
dtFrame->GetXaxis()->SetTitleSize(0.05);
dtFrame->GetXaxis()->SetTitleOffset(0.85);
dtFrame->GetXaxis()->SetLabelSize(0.05);
dtFrame->GetYaxis()->SetTitleOffset(1.6);
TPaveText *ptB = new TPaveText(0.7,0.65,0.98,0.99,"brNDC");
ptB->SetFillColor(0);
ptB->SetTextAlign(12);
out.str("");
out << "bin = " << -(i+1);
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(B^{0}) = " << chi2;
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(#barB^{0}) = " << chi2b;
ptB->AddText(out.str().c_str());
out.str("");
out << "#sigma/#tau = " << _sigma_over_tau;
ptB->AddText(out.str().c_str());
out.str("");
out << "purity = " << _purity;
ptB->AddText(out.str().c_str());
out.str("");
out << "mistag = " << mistag_rate;
ptB->AddText(out.str().c_str());
dtFrame->Draw();
ptB->Draw();
out.str("");
out << "../Reports/cpfitfigs/dt_bin" << -(i+1) << ".root";
cm->Print(out.str().c_str());
out.str("");
out << "../Reports/cpfitfigs/dt_bin" << -(i+1) << ".png";
cm->Print(out.str().c_str());
}
return;
}
void combinedWorkspace_4WS(const char* name_pbpb_pass="******", const char* name_pbpb_fail="fitresult_pbpb_fail.root", const char* name_pp_pass="******", const char* name_pp_fail="fitresult_pp_fail.root", const char* name_out="fitresult_combo.root", const float systval = 0., const char* subDirName ="wsTest", int nCPU=2){
// subdir: Directory to save workspaces under currentPATH/CombinedWorkspaces/subDir/
// set things silent
gErrorIgnoreLevel=kError;
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
bool dosyst = (systval > 0.);
TString nameOut(name_out);
RooWorkspace * ws = test_combine_4WS(name_pbpb_pass, name_pp_pass, name_pbpb_fail, name_pp_fail, false, nCPU);
RooAbsData * data = ws->data("dOS_DATA");
RooRealVar* RFrac2Svs1S_PbPbvsPP_P = ws->var("RFrac2Svs1S_PbPbvsPP_P");
RooRealVar* leftEdge = new RooRealVar("leftEdge","leftEdge",-10);
RooRealVar* rightEdge = new RooRealVar("rightEdge","rightEdge",10);
RooGenericPdf step("step", "step", "(@0 >= @1) && (@0 < @2)", RooArgList(*RFrac2Svs1S_PbPbvsPP_P, *leftEdge, *rightEdge));
ws->import(step);
ws->factory( "Uniform::flat(RFrac2Svs1S_PbPbvsPP_P)" );
// systematics
if (dosyst) {
ws->factory( Form("kappa_syst[%f]",systval) );
ws->factory( "expr::alpha_syst('kappa_syst*beta_syst',kappa_syst,beta_syst[0,-5,5])" );
ws->factory( "Gaussian::constr_syst(beta_syst,glob_syst[0,-5,5],1)" );
// add systematics into the double ratio
ws->factory( "expr::RFrac2Svs1S_PbPbvsPP_P_syst('@0+@1',RFrac2Svs1S_PbPbvsPP_P,alpha_syst)" );
// build the pbpb pdf
RooRealVar* effjpsi_pp_P = (RooRealVar*)ws->var("effjpsi_pp_P");
RooRealVar* effpsip_pp_P = (RooRealVar*)ws->var("effpsip_pp_P");
RooRealVar* effjpsi_pp_NP = (RooRealVar*)ws->var("effjpsi_pp_NP");
Double_t Npsi2SPbPbPass = npsip_pbpb_pass_from_doubleratio_prompt(ws, RooArgList(*effjpsi_pp_P,*effpsip_pp_P,*effjpsi_pp_NP),true); // Create and import N_Psi2S_PbPb_pass_syst
ws->factory( "SUM::pdfMASS_Tot_PbPb_pass_syst(N_Jpsi_PbPb_pass * pdfMASS_Jpsi_PbPb_pass, N_Psi2S_PbPb_pass_syst * pdfMASS_Psi2S_PbPb_pass, N_Bkg_PbPb_pass * pdfMASS_Bkg_PbPb_pass)" );
ws->factory( "PROD::pdfMASS_Tot_PbPb_pass_constr(pdfMASS_Tot_PbPb_pass_syst,constr_syst)" );
// build the combined pdf
ws->factory("SIMUL::simPdf_syst_noconstr(sample,PbPb_pass=pdfMASS_Tot_PbPb_pass_syst,PbPb_fail=pdfMASS_Tot_PbPb_fail,PP_pass=pdfMASS_Tot_PP_pass,PP_fail=pdfMASS_Tot_PP_fail)");
RooSimultaneous *simPdf = (RooSimultaneous*) ws->pdf("simPdf_syst_noconstr");
RooGaussian *constr_syst = (RooGaussian*) ws->pdf("constr_syst");
RooProdPdf *simPdf_constr = new RooProdPdf("simPdf_syst","simPdf_syst",RooArgSet(*simPdf,*constr_syst));
ws->import(*simPdf_constr);
} else {
ws->factory("SIMUL::simPdf_syst(sample,PbPb_pass=pdfMASS_Tot_PbPb_pass,PbPb_fail=pdfMASS_Tot_PbPb_fail,PP_pass=pdfMASS_Tot_PP_pass,PP_fail=pdfMASS_Tot_PP_fail)");
}
ws->Print();
if (dosyst) ws->var("beta_syst")->setConstant(kFALSE);
/////////////////////////////////////////////////////////////////////
RooRealVar * pObs = ws->var("invMass"); // get the pointer to the observable
RooArgSet obs("observables");
obs.add(*pObs);
obs.add( *ws->cat("sample"));
// /////////////////////////////////////////////////////////////////////
if (dosyst) ws->var("glob_syst")->setConstant(true);
RooArgSet globalObs("global_obs");
if (dosyst) globalObs.add( *ws->var("glob_syst") );
// ws->Print();
RooArgSet poi("poi");
poi.add( *ws->var("RFrac2Svs1S_PbPbvsPP_P") );
// create set of nuisance parameters
RooArgSet nuis("nuis");
if (dosyst) nuis.add( *ws->var("beta_syst") );
// set parameters constant
RooArgSet allVars = ws->allVars();
TIterator* it = allVars.createIterator();
RooRealVar *theVar = (RooRealVar*) it->Next();
while (theVar) {
TString varname(theVar->GetName());
// if (varname != "RFrac2Svs1S_PbPbvsPP"
// && varname != "invMass"
// && varname != "sample"
// )
// theVar->setConstant();
if ( varname.Contains("f_Jpsi_PP") || varname.Contains("f_Jpsi_PbPb") ||
varname.Contains("rSigma21_Jpsi_PP") ||
varname.Contains("m_Jpsi_PP") || varname.Contains("m_Jpsi_PbPb") ||
varname.Contains("sigma1_Jpsi_PP") || varname.Contains("sigma1_Jpsi_PbPb") ||
(varname.Contains("lambda")) ||
(varname.Contains("_fail") && !varname.Contains("RFrac2Svs1S")))
{
theVar->setConstant();
}
if (varname=="glob_syst"
|| varname=="beta_syst"
) {
cout << varname << endl;
theVar->setConstant(!dosyst);
}
theVar = (RooRealVar*) it->Next();
}
// create signal+background Model Config
RooStats::ModelConfig sbHypo("SbHypo");
sbHypo.SetWorkspace( *ws );
sbHypo.SetPdf( *ws->pdf("simPdf_syst") );
sbHypo.SetObservables( obs );
sbHypo.SetGlobalObservables( globalObs );
sbHypo.SetParametersOfInterest( poi );
sbHypo.SetNuisanceParameters( nuis );
sbHypo.SetPriorPdf( *ws->pdf("step") ); // this is optional
/////////////////////////////////////////////////////////////////////
RooAbsReal * pNll = sbHypo.GetPdf()->createNLL( *data,NumCPU(nCPU) );
RooMinuit(*pNll).migrad(); // minimize likelihood wrt all parameters before making plots
if (controlPlots)
{
RooPlot *framepoi = ((RooRealVar *)poi.first())->frame(Bins(10),Range(0.,1),Title("LL and profileLL in RFrac2Svs1S_PbPbvsPP_P"));
pNll->plotOn(framepoi,ShiftToZero());
framepoi->SetMinimum(0);
framepoi->SetMaximum(10);
TCanvas *cpoi = new TCanvas();
cpoi->cd(); framepoi->Draw();
cpoi->SaveAs("cpoi.pdf");
}
((RooRealVar *)poi.first())->setMin(0.);
RooArgSet * pPoiAndNuisance = new RooArgSet("poiAndNuisance");
pPoiAndNuisance->add( nuis );
pPoiAndNuisance->add( poi );
sbHypo.SetSnapshot(*pPoiAndNuisance);
if (controlPlots)
{
RooPlot* xframeSB_PP_pass = pObs->frame(Title("SBhypo_PP_pass"));
data->plotOn(xframeSB_PP_pass,Cut("sample==sample::PP_pass"));
RooAbsPdf *pdfSB_PP_pass = sbHypo.GetPdf();
RooCategory *sample = ws->cat("sample");
pdfSB_PP_pass->plotOn(xframeSB_PP_pass,Slice(*sample,"PP_pass"),ProjWData(*sample,*data));
TCanvas *c1 = new TCanvas();
c1->cd(); xframeSB_PP_pass->Draw();
c1->SaveAs("c1.pdf");
RooPlot* xframeSB_PP_fail = pObs->frame(Title("SBhypo_PP_fail"));
data->plotOn(xframeSB_PP_fail,Cut("sample==sample::PP_fail"));
RooAbsPdf *pdfSB_PP_fail = sbHypo.GetPdf();
pdfSB_PP_fail->plotOn(xframeSB_PP_fail,Slice(*sample,"PP_fail"),ProjWData(*sample,*data));
TCanvas *c2 = new TCanvas();
c2->cd(); xframeSB_PP_fail->Draw();
c2->SaveAs("c1.pdf");
RooPlot* xframeB_PbPb_pass = pObs->frame(Title("SBhypo_PbPb_pass"));
data->plotOn(xframeB_PbPb_pass,Cut("sample==sample::PbPb_pass"));
RooAbsPdf *pdfB_PbPb_pass = sbHypo.GetPdf();
pdfB_PbPb_pass->plotOn(xframeB_PbPb_pass,Slice(*sample,"PbPb_pass"),ProjWData(*sample,*data));
TCanvas *c3 = new TCanvas();
c3->cd(); xframeB_PbPb_pass->Draw();
c3->SetLogy();
c3->SaveAs("c2.pdf");
RooPlot* xframeB_PbPb_fail = pObs->frame(Title("SBhypo_PbPb_fail"));
data->plotOn(xframeB_PbPb_fail,Cut("sample==sample::PbPb_fail"));
RooAbsPdf *pdfB_PbPb_fail = sbHypo.GetPdf();
pdfB_PbPb_fail->plotOn(xframeB_PbPb_fail,Slice(*sample,"PbPb_fail"),ProjWData(*sample,*data));
TCanvas *c4 = new TCanvas();
c4->cd(); xframeB_PbPb_fail->Draw();
c4->SetLogy();
c4->SaveAs("c2.pdf");
}
delete pNll;
delete pPoiAndNuisance;
ws->import( sbHypo );
/////////////////////////////////////////////////////////////////////
RooStats::ModelConfig bHypo = sbHypo;
bHypo.SetName("BHypo");
bHypo.SetWorkspace(*ws);
pNll = bHypo.GetPdf()->createNLL( *data,NumCPU(nCPU) );
// RooMinuit(*pNll).migrad(); // minimize likelihood wrt all parameters before making plots
RooArgSet poiAndGlobalObs("poiAndGlobalObs");
poiAndGlobalObs.add( poi );
poiAndGlobalObs.add( globalObs );
RooAbsReal * pProfile = pNll->createProfile( poiAndGlobalObs ); // do not profile POI and global observables
((RooRealVar *)poi.first())->setVal( 0 ); // set RFrac2Svs1S_PbPbvsPP=0 here
pProfile->getVal(); // this will do fit and set nuisance parameters to profiled values
pPoiAndNuisance = new RooArgSet( "poiAndNuisance" );
pPoiAndNuisance->add( nuis );
pPoiAndNuisance->add( poi );
bHypo.SetSnapshot(*pPoiAndNuisance);
delete pNll;
delete pPoiAndNuisance;
// import model config into workspace
bHypo.SetWorkspace(*ws);
ws->import( bHypo );
/////////////////////////////////////////////////////////////////////
ws->Print();
bHypo.Print();
sbHypo.Print();
// save workspace to file
string mainDIR = gSystem->ExpandPathName(gSystem->pwd());
string wsDIR = mainDIR + "/CombinedWorkspaces/";
string ssubDirName="";
if (subDirName) ssubDirName.append(subDirName);
string subDIR = wsDIR + ssubDirName;
void * dirp = gSystem->OpenDirectory(wsDIR.c_str());
if (dirp) gSystem->FreeDirectory(dirp);
else gSystem->mkdir(wsDIR.c_str(), kTRUE);
void * dirq = gSystem->OpenDirectory(subDIR.c_str());
if (dirq) gSystem->FreeDirectory(dirq);
else gSystem->mkdir(subDIR.c_str(), kTRUE);
const char* saveName = Form("%s/%s",subDIR.c_str(),nameOut.Data());
ws->writeToFile(saveName);
}
double* fitHist(TCanvas *iC, bool iDoMu,int iPlot, std::string iName,TH1D *iData,TH1D *iW,TH1D *iEWK,TH1D *iAntiData,TH1D *iAntiW,TH1D *iAntiEWK,const Double_t METMAX,const Int_t NBINS,const Double_t lumi,const Int_t Ecm,int iAltQCD) {
//
// Declare fit parameters for signal and background yields
// Note: W signal and EWK+top PDFs are constrained to the ratio described in MC
//
RooRealVar nSig(("nSig"+iName).c_str(),("nSig"+iName).c_str(),0.7*(iData->Integral()),0,iData->Integral());
RooRealVar nQCD(("nQCD"+iName).c_str(),("nQCD"+iName).c_str(),0.3*(iData->Integral()),0,iData->Integral());
RooRealVar cewk(("cewk"+iName).c_str(),("cewk"+iName).c_str(),0.1,0,5) ;
cewk.setVal(iEWK->Integral()/iW->Integral());
cewk.setConstant(kTRUE);
RooFormulaVar nEWK(("nEWK"+iName).c_str(),("nEWK"+iName).c_str(),("cewk"+iName+"*nSig"+iName).c_str(),RooArgList(nSig,cewk));
RooRealVar nAntiSig(("nAntiSig"+iName).c_str(),("nAntiSig"+iName).c_str(),0.05*(iAntiData->Integral()),0,iAntiData->Integral());
RooRealVar nAntiQCD(("nAntiQCD"+iName).c_str(),("nAntiQCD"+iName).c_str(),0.9 *(iAntiData->Integral()),0,iAntiData->Integral());
RooRealVar dewk (("dewk" +iName).c_str(),("dewk" +iName).c_str(),0.1,0,5) ;
dewk.setVal(iAntiEWK->Integral()/iAntiW->Integral());
dewk.setConstant(kTRUE);
RooFormulaVar nAntiEWK(("nAntiEWK"+iName).c_str(),("nAntiEWK"+iName).c_str(),("dewk"+iName+"*nAntiSig"+iName).c_str(),RooArgList(nAntiSig,dewk));
//
// Construct PDFs for fitting
//
RooRealVar pfmet(("pfmet"+iName).c_str(),("pfmet"+iName).c_str(),0,METMAX);
pfmet.setBins(NBINS);
// Signal PDFs
RooDataHist wMet (("wMET" +iName).c_str(), ("wMET" +iName).c_str(), RooArgSet(pfmet),iW);
RooHistPdf pdfW(( "w"+iName).c_str(), ( "w"+iName).c_str(), pfmet, wMet, 1);
RooDataHist awMet (("awMET"+iName).c_str(), ("awMET"+iName).c_str(), RooArgSet(pfmet),iAntiW);
RooHistPdf apdfW(("aw"+iName).c_str(), ("aw"+iName).c_str(), pfmet,awMet, 1);
// EWK+top PDFs
RooDataHist ewkMet (("ewkMET" +iName).c_str(),( "ewkMET"+iName).c_str(), RooArgSet(pfmet),iEWK);
RooHistPdf pdfEWK (( "ewk"+iName).c_str(),( "ewk"+iName).c_str(), pfmet,ewkMet, 1);
RooDataHist aewkMet(("aewkMET"+iName).c_str(),("aewkMET"+iName).c_str(), RooArgSet(pfmet),iAntiEWK);
RooHistPdf apdfEWK (("aewk"+iName).c_str(),("aewk"+iName).c_str(), pfmet,aewkMet, 1);
// QCD Pdfs
CPepeModel0 qcd0 (("qcd0" +iName).c_str(),pfmet);
CPepeModel1 qcd1 (("qcd1" +iName).c_str(),pfmet);
CPepeModel2 qcd2 (("qcd2" +iName).c_str(),pfmet);
CPepeModel0 aqcd0(("aqcd0"+iName).c_str(),pfmet);
CPepeModel1 aqcd1(("aqcd1"+iName).c_str(),pfmet,qcd1.sigma);
CPepeModel2 aqcd2(("aqcd2"+iName).c_str(),pfmet);
RooGenericPdf *lQCD = qcd0.model;
RooGenericPdf *lAQCD = aqcd0.model;
if(iDoMu) lQCD = qcd1.model;
if(iDoMu) lAQCD = aqcd1.model;
if(iAltQCD == 0) lQCD = qcd0.model;
if(iAltQCD == 1) lQCD = qcd1.model;
if(iAltQCD == 2) lQCD = qcd2.model;
if(iAltQCD == 0) lAQCD = aqcd0.model;
if(iAltQCD == 1) lAQCD = aqcd1.model;
if(iAltQCD == 2) lAQCD = aqcd2.model;
// Signal + Background PDFs
RooAddPdf pdfMet (("pdfMet"+iName).c_str(), ("pdfMet" +iName).c_str(), RooArgList(pdfW ,pdfEWK ,*lQCD), RooArgList(nSig,nEWK,nQCD));
RooAddPdf apdfMet(("apdfMet"+iName).c_str(),("apdfMet"+iName).c_str(), RooArgList(apdfW,apdfEWK,*lAQCD), RooArgList(nAntiSig,nAntiEWK,nAntiQCD));
// PDF for simultaneous fit
RooCategory rooCat("rooCat","rooCat");
rooCat.defineType("Select");
rooCat.defineType("Anti");
RooSimultaneous pdfTotal("pdfTotal","pdfTotal",rooCat);
pdfTotal.addPdf(pdfMet, "Select");
if(iDoMu) pdfTotal.addPdf(apdfMet,"Anti");
// Perform fits
RooDataHist dataMet (("dataMet"+iName).c_str(),("dataMet"+iName).c_str(), RooArgSet(pfmet),iData);
RooDataHist antiMet (("antiMet"+iName).c_str(),("antiMet"+iName).c_str(), RooArgSet(pfmet),iAntiData);
RooDataHist dataTotal(("data" +iName).c_str(),("data" +iName).c_str(), RooArgList(pfmet), Index(rooCat),
Import("Select", dataMet),
Import("Anti", antiMet));
RooFitResult *fitRes = 0;
bool runMinos = kTRUE;
if(iPlot == 0 || iPlot == 3) runMinos = kFALSE; //Remove Minos when running toys (too damn slow)
if(!iDoMu) fitRes = pdfMet .fitTo(dataMet ,Extended(),Minos(runMinos),Save(kTRUE));
if( iDoMu) fitRes = pdfTotal.fitTo(dataTotal,Extended(),Minos(runMinos),Save(kTRUE));
double *lResults = new double[16];
lResults[0] = nSig.getVal();
lResults[1] = nEWK.getVal();
lResults[2] = nQCD.getVal();
lResults[3] = nAntiSig.getVal();
lResults[4] = nAntiEWK.getVal();
lResults[5] = nAntiQCD.getVal();
if(!iDoMu) lResults[6] = double(qcd0.sigma->getVal());
if( iDoMu) lResults[6] = double(qcd1.sigma->getVal());
lResults[7] = 0.;
if(!iDoMu) lResults[7] = qcd1.a1->getVal();
lResults[8] = nSig .getPropagatedError(*fitRes);
lResults[9] = nEWK .getPropagatedError(*fitRes);
lResults[10] = nQCD .getPropagatedError(*fitRes);
lResults[11] = nAntiSig.getPropagatedError(*fitRes);
lResults[12] = nAntiEWK.getPropagatedError(*fitRes);
lResults[13] = nAntiQCD.getPropagatedError(*fitRes);
if( iDoMu) lResults[14] = qcd0.sigma->getError();
if(!iDoMu) lResults[14] = qcd1.sigma->getError();
if( iDoMu) lResults[15] = 0;
if(!iDoMu) lResults[15] = qcd1.a1 ->getError();
if(iPlot == 0 ) return lResults;
//
// Use histogram version of fitted PDFs to make ratio plots
// (Will also use PDF histograms later for Chi^2 and KS tests)
//
TH1D *hPdfMet = (TH1D*)(pdfMet.createHistogram(("hPdfMet"+iName).c_str(), pfmet));
hPdfMet->Scale((nSig.getVal()+nEWK.getVal()+nQCD.getVal())/hPdfMet->Integral());
TH1D *hMetDiff = makeDiffHist(iData,hPdfMet,"hMetDiff"+iName);
hMetDiff->SetMarkerStyle(kFullCircle);
hMetDiff->SetMarkerSize(0.9);
TH1D *hPdfAntiMet = (TH1D*)(apdfMet.createHistogram(("hPdfAntiMet"+iName).c_str(), pfmet));
hPdfAntiMet->Scale((nAntiSig.getVal()+nAntiEWK.getVal()+nAntiQCD.getVal())/hPdfAntiMet->Integral());
TH1D *hAntiMetDiff = makeDiffHist(iAntiData,hPdfAntiMet,"hAntiMetDiff"+iName);
hAntiMetDiff->SetMarkerStyle(kFullCircle);
hAntiMetDiff->SetMarkerSize(0.9);
if(iPlot == 3 ) {
//Build best fit QCD with default W and EWK Shap
TH1D *hPdfMetQCD = (TH1D*)(lQCD ->createHistogram(("hPdfMetQCD" +iName).c_str(), pfmet));
TH1D *hPdfAMetQCD = (TH1D*)(lAQCD->createHistogram(("hPdfAntiMetQCD"+iName).c_str(), pfmet));
hPdfMetQCD ->Scale(nQCD .getVal()/hPdfMetQCD ->Integral());
hPdfAMetQCD->Scale(nAntiQCD.getVal()/hPdfAMetQCD->Integral());
TH1D *pW = (TH1D*) iW ->Clone("WForToys");
pW ->Scale(nSig .getVal()/pW ->Integral());
TH1D *pEWK = (TH1D*) iEWK ->Clone("EWKForToys");
pEWK ->Scale(nEWK .getVal()/pEWK ->Integral());
TH1D *pAW = (TH1D*) iAntiW ->Clone("AWForToys");
pAW ->Scale(nAntiSig.getVal()/pAW ->Integral());
TH1D *pAEWK = (TH1D*) iAntiEWK->Clone("AEWKForToys");
pAEWK->Scale(nAntiEWK.getVal()/pAEWK->Integral());
hPdfMetQCD ->Add(pW);
hPdfMetQCD ->Add(pEWK);
hPdfAMetQCD->Add(pAW);
hPdfAMetQCD->Add(pAEWK);
fBestFit = hPdfMetQCD;
fAntiBestFit = hPdfAMetQCD;
return lResults;
}
//--------------------------------------------------------------------------------------------------------------
// Make plots
//==============================================================================================================
char ylabel[100]; // string buffer for y-axis label
// file format for output plots
const TString format("png");
// label for lumi
char lumitext[100];
if(lumi<0.1) sprintf(lumitext,"%.1f pb^{-1} at #sqrt{s} = %i TeV",lumi*1000.,Ecm);
else sprintf(lumitext,"%.2f fb^{-1} at #sqrt{s} = %i TeV",lumi ,Ecm);
// plot colors
Int_t linecolorW = kOrange-3;
Int_t fillcolorW = kOrange-2;
Int_t linecolorEWK = kOrange+10;
Int_t fillcolorEWK = kOrange+7;
Int_t linecolorQCD = kViolet+2;
Int_t fillcolorQCD = kViolet-5;
Int_t ratioColor = kGray+2;
//
// Dummy histograms for TLegend
// (Nobody can figure out how to properly pass RooFit objects...)
//
TH1D *hDummyData = new TH1D("hDummyData","",0,0,10);
hDummyData->SetMarkerStyle(kFullCircle);
hDummyData->SetMarkerSize(0.9);
TH1D *hDummyW = new TH1D("hDummyW","",0,0,10);
hDummyW->SetLineColor(linecolorW);
hDummyW->SetFillColor(fillcolorW);
hDummyW->SetFillStyle(1001);
TH1D *hDummyEWK = new TH1D("hDummyEWK","",0,0,10);
hDummyEWK->SetLineColor(linecolorEWK);
hDummyEWK->SetFillColor(fillcolorEWK);
hDummyEWK->SetFillStyle(1001);
TH1D *hDummyQCD = new TH1D("hDummyQCD","",0,0,10);
hDummyQCD->SetLineColor(linecolorQCD);
hDummyQCD->SetFillColor(fillcolorQCD);
hDummyQCD->SetFillStyle(1001);
//
// W MET plot
//
RooPlot *wmframe = pfmet.frame(Bins(NBINS));
dataMet.plotOn(wmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
pdfMet.plotOn(wmframe,FillColor(fillcolorW),DrawOption("F"));
pdfMet.plotOn(wmframe,LineColor(linecolorW));
pdfMet.plotOn(wmframe,Components(RooArgSet(pdfEWK,*lQCD)),FillColor(fillcolorEWK),DrawOption("F"));
pdfMet.plotOn(wmframe,Components(RooArgSet(pdfEWK,*lQCD)),LineColor(linecolorEWK));
pdfMet.plotOn(wmframe,Components(RooArgSet(*lQCD)),FillColor(fillcolorQCD),DrawOption("F"));
pdfMet.plotOn(wmframe,Components(RooArgSet(*lQCD)),LineColor(linecolorQCD));
pdfMet.plotOn(wmframe,Components(RooArgSet(pdfW)),LineColor(linecolorW),LineStyle(2));
dataMet.plotOn(wmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
sprintf(ylabel,"Events / %.1f GeV",iData->GetBinWidth(1));
CPlot plotMet(("fitmet"+iName).c_str(),wmframe,"","",ylabel);
plotMet.SetLegend(0.68,0.57,0.93,0.77);
plotMet.GetLegend()->AddEntry(hDummyData,"data","PL");
plotMet.GetLegend()->AddEntry(hDummyW,"W#rightarrow#mu#nu","F");
plotMet.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F");
plotMet.GetLegend()->AddEntry(hDummyQCD,"QCD","F");
plotMet.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0);
plotMet.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0);
plotMet.SetYRange(0.1,1.1*(iData->GetMaximum()));
plotMet.Draw(iC,kFALSE,format,1);
CPlot plotMetDiff(("fitmet"+iName).c_str(),"","#slash{E}_{T} [GeV]","#chi");
plotMetDiff.AddHist1D(hMetDiff,"EX0",ratioColor);
plotMetDiff.SetYRange(-8,8);
plotMetDiff.AddLine(0, 0,METMAX, 0,kBlack,1);
plotMetDiff.AddLine(0, 5,METMAX, 5,kBlack,3);
plotMetDiff.AddLine(0,-5,METMAX,-5,kBlack,3);
plotMetDiff.Draw(iC,kTRUE,format,2);
plotMet.Draw(iC,kTRUE,format,1);
plotMet.SetName(("fitmetlog"+iName).c_str());
plotMet.SetLogy();
plotMet.SetYRange(1e-3*(iData->GetMaximum()),10*(iData->GetMaximum()));
plotMet.Draw(iC,kTRUE,format,1);
if(iDoMu) {
RooPlot *awmframe = pfmet.frame(Bins(NBINS));
antiMet.plotOn(awmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
apdfMet.plotOn(awmframe,FillColor(fillcolorW),DrawOption("F"));
apdfMet.plotOn(awmframe,LineColor(linecolorW));
apdfMet.plotOn(awmframe,Components(RooArgSet(apdfEWK,*lQCD)),FillColor(fillcolorEWK),DrawOption("F"));
apdfMet.plotOn(awmframe,Components(RooArgSet(apdfEWK,*lQCD)),LineColor(linecolorEWK));
apdfMet.plotOn(awmframe,Components(RooArgSet(*lQCD)),FillColor(fillcolorQCD),DrawOption("F"));
apdfMet.plotOn(awmframe,Components(RooArgSet(*lQCD)),LineColor(linecolorQCD));
apdfMet.plotOn(awmframe,Components(RooArgSet(apdfW)),LineColor(linecolorW),LineStyle(2));
antiMet.plotOn(awmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
sprintf(ylabel,"Events / %.1f GeV",iAntiData->GetBinWidth(1));
CPlot plotAntiMet(("fitantimet"+iName).c_str(),awmframe,"","",ylabel);
plotAntiMet.SetLegend(0.68,0.57,0.93,0.77);
plotAntiMet.GetLegend()->AddEntry(hDummyData,"data","PL");
plotAntiMet.GetLegend()->AddEntry(hDummyW,"W#rightarrow#mu#nu","F");
plotAntiMet.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F");
plotAntiMet.GetLegend()->AddEntry(hDummyQCD,"QCD","F");
plotAntiMet.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0);
plotAntiMet.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0);
plotAntiMet.SetYRange(0.1,1.1*(iAntiData->GetMaximum()));
plotAntiMet.Draw(iC,kFALSE,format,1);
CPlot plotAntiMetDiff(("fitantimet"+iName).c_str(),"","#slash{E}_{T} [GeV]","#chi");
plotAntiMetDiff.AddHist1D(hMetDiff,"EX0",ratioColor);
plotAntiMetDiff.SetYRange(-8,8);
plotAntiMetDiff.AddLine(0, 0,METMAX, 0,kBlack,1);
plotAntiMetDiff.AddLine(0, 5,METMAX, 5,kBlack,3);
plotAntiMetDiff.AddLine(0,-5,METMAX,-5,kBlack,3);
plotAntiMetDiff.Draw(iC,kTRUE,format,2);
plotAntiMet.SetName(("fitantimetlog"+iName).c_str());
plotAntiMet.SetLogy();
plotAntiMet.SetYRange(1e-3*(iAntiData->GetMaximum()),10*(iAntiData->GetMaximum()));
plotAntiMet.Draw(iC,kTRUE,format,1);
}
if(iPlot == 1) return lResults;
ofstream txtfile;
std::string txtfName = "fitres"+iName;
if( iDoMu) txtfName + "Mu.txt";
if(!iDoMu) txtfName + "Mu.txt";
ios_base::fmtflags flags;
cout << " --- test " << iData->Integral() << " -- " << hPdfMet->Integral() << endl;
Double_t chi2prob = iData->Chi2Test(hPdfMet,"PUW");
Double_t chi2ndf = iData->Chi2Test(hPdfMet,"CHI2/NDFUW");
Double_t ksprob = iData->KolmogorovTest(hPdfMet);
Double_t ksprobpe = 1;//iData->KolmogorovTest(hPdfMet,"DX");
txtfile.open(txtfName.c_str());
assert(txtfile.is_open());
flags = txtfile.flags();
txtfile << setprecision(10);
txtfile << " *** Yields *** " << endl;
txtfile << "Selected: " << iData->Integral() << endl;
txtfile << " Signal: " << nSig.getVal() << " +/- " << nSig.getPropagatedError(*fitRes) << endl;
txtfile << " QCD: " << nQCD.getVal() << " +/- " << nQCD.getPropagatedError(*fitRes) << endl;
txtfile << " Other: " << nEWK.getVal() << " +/- " << nEWK.getPropagatedError(*fitRes) << endl;
txtfile << endl;
txtfile.flags(flags);
fitRes->printStream(txtfile,RooPrintable::kValue,RooPrintable::kVerbose);
txtfile << endl;
printCorrelations(txtfile, fitRes);
txtfile << endl;
printChi2AndKSResults(txtfile, chi2prob, chi2ndf, ksprob, ksprobpe);
txtfile.close();
return lResults;
}
int main(int argc, char *argv[]){
OptionParser(argc,argv);
TStopwatch sw;
sw.Start();
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
RooMsgService::instance().setSilentMode(true);
system("mkdir -p plots/fTest");
vector<string> procs;
split(procs,procString_,boost::is_any_of(","));
TFile *inFile = TFile::Open(filename_.c_str());
RooWorkspace *inWS = (RooWorkspace*)inFile->Get("cms_hgg_workspace");
RooRealVar *mass = (RooRealVar*)inWS->var("CMS_hgg_mass");
//mass->setBins(320);
//mass->setRange(mass_-10,mass_+10);
//mass->setBins(20);
RooRealVar *MH = new RooRealVar("MH","MH",mass_);
MH->setVal(mass_);
MH->setConstant(true);
map<string,pair<int,int> > choices;
map<string,vector<RooPlot*> > plotsRV;
map<string,vector<RooPlot*> > plotsWV;
for (unsigned int p=0; p<procs.size(); p++){
vector<RooPlot*> tempRV;
vector<RooPlot*> tempWV;
for (int cat=0; cat<ncats_; cat++){
RooPlot *plotRV = mass->frame(Range(mass_-10,mass_+10));
plotRV->SetTitle(Form("%s_cat%d_RV",procs[p].c_str(),cat));
tempRV.push_back(plotRV);
RooPlot *plotWV = mass->frame(Range(mass_-10,mass_+10));
plotWV->SetTitle(Form("%s_cat%d_WV",procs[p].c_str(),cat));
tempWV.push_back(plotWV);
}
plotsRV.insert(pair<string,vector<RooPlot*> >(procs[p],tempRV));
plotsWV.insert(pair<string,vector<RooPlot*> >(procs[p],tempWV));
}
vector<int> colors;
colors.push_back(kBlue);
colors.push_back(kRed);
colors.push_back(kGreen+2);
colors.push_back(kMagenta+1);
for (int cat=0; cat<ncats_; cat++){
for (unsigned int p=0; p<procs.size(); p++){
string proc = procs[p];
RooDataSet *dataRV = (RooDataSet*)inWS->data(Form("sig_%s_mass_m%d_rv_cat%d",proc.c_str(),mass_,cat));
RooDataSet *dataWV = (RooDataSet*)inWS->data(Form("sig_%s_mass_m%d_wv_cat%d",proc.c_str(),mass_,cat));
//mass->setBins(160);
//RooDataHist *dataRV = dataRVtemp->binnedClone();
//RooDataHist *dataWV = dataWVtemp->binnedClone();
//RooDataSet *dataRVw = (RooDataSet*)dataRVtemp->reduce(Form("CMS_hgg_mass>=%3d && CMS_hgg_mass<=%3d",mass_-10,mass_+10));
//RooDataSet *dataWVw = (RooDataSet*)dataWVtemp->reduce(Form("CMS_hgg_mass>=%3d && CMS_hgg_mass<=%3d",mass_-10,mass_+10));
//RooDataHist *dataRV = new RooDataHist(Form("roohist_%s",dataRVtemp->GetName()),Form("roohist_%s",dataRVtemp->GetName()),RooArgSet(*mass),*dataRVtemp);
//RooDataHist *dataWV = new RooDataHist(Form("roohist_%s",dataWVtemp->GetName()),Form("roohist_%s",dataWVtemp->GetName()),RooArgSet(*mass),*dataWVtemp);
//RooDataSet *dataRV = stripWeights(dataRVweight,mass);
//RooDataSet *dataWV = stripWeights(dataWVweight,mass);
//RooDataSet *data = (RooDataSet*)inWS->data(Form("sig_%s_mass_m%d_cat%d",proc.c_str(),mass_,cat));
int rvChoice=0;
int wvChoice=0;
// right vertex
int order=1;
int prev_order=0;
int cache_order=0;
double thisNll=0.;
double prevNll=1.e6;
double chi2=0.;
double prob=0.;
dataRV->plotOn(plotsRV[proc][cat]);
//while (prob<0.8) {
while (order<5) {
RooAddPdf *pdf = buildSumOfGaussians(Form("cat%d_g%d",cat,order),mass,MH,order);
RooFitResult *fitRes = pdf->fitTo(*dataRV,Save(true),SumW2Error(true));//,Range(mass_-10,mass_+10));
double myNll=0.;
thisNll = fitRes->minNll();
//double myNll = getMyNLL(mass,pdf,dataRV);
//thisNll = getMyNLL(mass,pdf,dataRV);
//RooAbsReal *nll = pdf->createNLL(*dataRV);
//RooMinuit m(*nll);
//m.migrad();
//thisNll = nll->getVal();
//plot(Form("plots/fTest/%s_cat%d_g%d_rv",proc.c_str(),cat,order),mass_,mass,dataRV,pdf);
pdf->plotOn(plotsRV[proc][cat],LineColor(colors[order-1]));
chi2 = 2.*(prevNll-thisNll);
//if (chi2<0. && order>1) chi2=0.;
int diffInDof = (2*order+(order-1))-(2*prev_order+(prev_order-1));
prob = TMath::Prob(chi2,diffInDof);
cout << "\t RV: " << cat << " " << order << " " << diffInDof << " " << prevNll << " " << thisNll << " " << myNll << " " << chi2 << " " << prob << endl;
prevNll=thisNll;
cache_order=prev_order;
prev_order=order;
order++;
}
rvChoice=cache_order;
// wrong vertex
order=1;
prev_order=0;
cache_order=0;
thisNll=0.;
prevNll=1.e6;
chi2=0.;
prob=0.;
dataWV->plotOn(plotsWV[proc][cat]);
while (order<4) {
//while (prob<0.8) {
RooAddPdf *pdf = buildSumOfGaussians(Form("cat%d_g%d",cat,order),mass,MH,order);
RooFitResult *fitRes = pdf->fitTo(*dataWV,Save(true),SumW2Error(true));//,Range(mass_-10,mass_+10));
double myNll=0.;
thisNll = fitRes->minNll();
//double myNll = getMyNLL(mass,pdf,dataRV);
//thisNll = getMyNLL(mass,pdf,dataRV);
//RooAbsReal *nll = pdf->createNLL(*dataWV);
//RooMinuit m(*nll);
//m.migrad();
//thisNll = nll->getVal();
//plot(Form("plots/fTest/%s_cat%d_g%d_wv",proc.c_str(),cat,order),mass_,mass,dataWV,pdf);
pdf->plotOn(plotsWV[proc][cat],LineColor(colors[order-1]));
chi2 = 2.*(prevNll-thisNll);
//if (chi2<0. && order>1) chi2=0.;
int diffInDof = (2*order+(order-1))-(2*prev_order+(prev_order-1));
prob = TMath::Prob(chi2,diffInDof);
cout << "\t WV: " << cat << " " << order << " " << diffInDof << " " << prevNll << " " << thisNll << " " << myNll << " " << chi2 << " " << prob << endl;
prevNll=thisNll;
cache_order=prev_order;
prev_order=order;
order++;
}
wvChoice=cache_order;
choices.insert(pair<string,pair<int,int> >(Form("%s_cat%d",proc.c_str(),cat),make_pair(rvChoice,wvChoice)));
}
}
TLegend *leg = new TLegend(0.6,0.6,0.89,0.89);
leg->SetFillColor(0);
leg->SetLineColor(0);
TH1F *h1 = new TH1F("h1","",1,0,1);
h1->SetLineColor(colors[0]);
leg->AddEntry(h1,"1st order","L");
TH1F *h2 = new TH1F("h2","",1,0,1);
h2->SetLineColor(colors[1]);
leg->AddEntry(h2,"2nd order","L");
TH1F *h3 = new TH1F("h3","",1,0,1);
h3->SetLineColor(colors[2]);
leg->AddEntry(h3,"3rd order","L");
TH1F *h4 = new TH1F("h4","",1,0,1);
h4->SetLineColor(colors[3]);
leg->AddEntry(h4,"4th order","L");
TCanvas *canv = new TCanvas();
for (map<string,vector<RooPlot*> >::iterator plotIt=plotsRV.begin(); plotIt!=plotsRV.end(); plotIt++){
string proc = plotIt->first;
for (int cat=0; cat<ncats_; cat++){
RooPlot *plot = plotIt->second.at(cat);
plot->Draw();
leg->Draw();
canv->Print(Form("plots/fTest/rv_%s_cat%d.pdf",proc.c_str(),cat));
}
}
for (map<string,vector<RooPlot*> >::iterator plotIt=plotsWV.begin(); plotIt!=plotsWV.end(); plotIt++){
string proc = plotIt->first;
for (int cat=0; cat<ncats_; cat++){
RooPlot *plot = plotIt->second.at(cat);
plot->Draw();
leg->Draw();
canv->Print(Form("plots/fTest/wv_%s_cat%d.pdf",proc.c_str(),cat));
}
}
delete canv;
cout << "Recommended options" << endl;
for (map<string,pair<int,int> >::iterator it=choices.begin(); it!=choices.end(); it++){
cout << "\t " << it->first << " - " << it->second.first << " " << it->second.second << endl;
}
inFile->Close();
return 0;
}
int main(int argc, char* argv[]) {
doofit::builder::EasyPdf *epdf = new doofit::builder::EasyPdf();
epdf->Var("sig_yield");
epdf->Var("sig_yield").setVal(153000);
epdf->Var("sig_yield").setConstant(false);
//decay time
epdf->Var("obsTime");
epdf->Var("obsTime").SetTitle("t_{#kern[-0.2]{B}_{#kern[-0.1]{ d}}^{#kern[-0.1]{ 0}}}");
epdf->Var("obsTime").setUnit("ps");
epdf->Var("obsTime").setRange(0.,16.);
// tag, respectively the initial state of the produced B meson
epdf->Cat("obsTag");
epdf->Cat("obsTag").defineType("B_S",1);
epdf->Cat("obsTag").defineType("Bbar_S",-1);
//finalstate
epdf->Cat("catFinalState");
epdf->Cat("catFinalState").defineType("f",1);
epdf->Cat("catFinalState").defineType("fbar",-1);
epdf->Var("obsEtaOS");
epdf->Var("obsEtaOS").setRange(0.0,0.5);
std::vector<double> knots;
knots.push_back(0.07);
knots.push_back(0.10);
knots.push_back(0.138);
knots.push_back(0.16);
knots.push_back(0.23);
knots.push_back(0.28);
knots.push_back(0.35);
knots.push_back(0.42);
knots.push_back(0.44);
knots.push_back(0.48);
knots.push_back(0.5);
// empty arg list for coefficients
RooArgList* list = new RooArgList();
// create first coefficient
RooRealVar* coeff_first = &(epdf->Var("parCSpline1"));
coeff_first->setRange(0,10000);
coeff_first->setVal(1);
coeff_first->setConstant(false);
list->add( *coeff_first );
for (unsigned int i=1; i <= knots.size(); ++i){
std::string number = boost::lexical_cast<std::string>(i);
RooRealVar* coeff = &(epdf->Var("parCSpline"+number));
coeff->setRange(0,10000);
coeff->setVal(1);
coeff->setConstant(false);
list->add( *coeff );
}
// create last coefficient
RooRealVar* coeff_last = &(epdf->Var("parCSpline"+boost::lexical_cast<std::string>(knots.size())));
coeff_last->setRange(0,10000);
coeff_last->setVal(1);
coeff_last->setConstant(false);
list->add( *coeff_last );
list->Print();
// define Eta PDF
doofit::roofit::pdfs::DooCubicSplinePdf splinePdf("splinePdf",epdf->Var("obsEtaOS"),knots,*list,0,0.5);
//Berechne die Tagging Assymetrie
epdf->Var("p0");
epdf->Var("p0").setVal(0.369);
epdf->Var("p0").setConstant(true);
epdf->Var("p1");
epdf->Var("p1").setVal(0.952);
epdf->Var("p1").setConstant(true);
epdf->Var("delta_p0");
epdf->Var("delta_p0").setVal(0.019);
epdf->Var("delta_p0").setConstant(true);
epdf->Var("delta_p1");
epdf->Var("delta_p1").setVal(-0.012);
epdf->Var("delta_p1").setConstant(true);
epdf->Var("etamean");
epdf->Var("etamean").setVal(0.365);
epdf->Var("etamean").setConstant(true);
epdf->Formula("omega","@0 +@1/2 +(@2+@3/2)*(@4-@5)", RooArgList(epdf->Var("p0"),epdf->Var("delta_p0"),epdf->Var("p1"),epdf->Var("delta_p1"),epdf->Var("obsEtaOS"),epdf->Var("etamean")));
epdf->Formula("omegabar","@0 -@1/2 +(@2-@3/2)*(@4-@5)", RooArgList(epdf->Var("p0"),epdf->Var("delta_p0"),epdf->Var("p1"),epdf->Var("delta_p1"),epdf->Var("obsEtaOS"),epdf->Var("etamean")));
//Koeffizienten
DecRateCoeff *coeff_c = new DecRateCoeff("coef_cos","coef_cos",DecRateCoeff::CPOdd,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("C_f"),epdf->Var("C_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Real("omega"),epdf->Real("omegabar"),epdf->Var("asym_prod"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
DecRateCoeff *coeff_s = new DecRateCoeff("coef_sin","coef_sin",DecRateCoeff::CPOdd,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("S_f"),epdf->Var("S_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Real("omega"),epdf->Real("omegabar"),epdf->Var("asym_prod"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
DecRateCoeff *coeff_sh = new DecRateCoeff("coef_sinh","coef_sinh",DecRateCoeff::CPEven,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("f1_f"),epdf->Var("f1_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Real("omega"),epdf->Real("omegabar"),epdf->Var("asym_prod"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
DecRateCoeff *coeff_ch = new DecRateCoeff("coef_cosh","coef_cosh",DecRateCoeff::CPEven,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("f0_f"),epdf->Var("f0_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Real("omega"),epdf->Real("omegabar"),epdf->Var("asym_prod"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
epdf->AddRealToStore(coeff_ch);
epdf->AddRealToStore(coeff_sh);
epdf->AddRealToStore(coeff_c);
epdf->AddRealToStore(coeff_s);
///////////////////Generiere PDF's/////////////////////
//Zeit
epdf->GaussModel("resTimeGauss",epdf->Var("obsTime"),epdf->Var("allTimeResMean"),epdf->Var("allTimeReso"));
epdf->BDecay("pdfSigTime",epdf->Var("obsTime"),epdf->Var("tau"),epdf->Var("dgamma"),epdf->Real("coef_cosh"),epdf->Real("coef_sinh"),epdf->Real("coef_cos"),epdf->Real("coef_sin"),epdf->Var("deltaM"),epdf->Model("resTimeGauss"));
//Zusammenfassen der Parameter in einem RooArgSet
RooArgSet Observables;
Observables.add(RooArgSet( epdf->Var("obsTime"),epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("obsEtaOS")));
epdf->Extend("pdfExtend", epdf->Pdf("pdfSigTime"),epdf->Real("sig_yield"));
RooWorkspace ws;
ws.import(epdf->Pdf("pdfExtend"));
ws.defineSet("Observables",Observables, true);
ws.Print();
doofit::config::CommonConfig cfg_com("common");
cfg_com.InitializeOptions(argc, argv);
doofit::toy::ToyFactoryStdConfig cfg_tfac("toyfac");
cfg_tfac.InitializeOptions(cfg_com);
doofit::toy::ToyStudyStdConfig cfg_tstudy("toystudy");
cfg_tstudy.InitializeOptions(cfg_tfac);
// set a previously defined workspace to get PDF from (not mandatory, but convenient)
cfg_tfac.set_workspace(&ws);
cfg_com.CheckHelpFlagAndPrintHelp();
// Initialize the toy factory module with the config objects and start
// generating toy samples.
doofit::toy::ToyFactoryStd tfac(cfg_com, cfg_tfac);
doofit::toy::ToyStudyStd tstudy(cfg_com, cfg_tstudy);
//Generate data
RooDataSet* data = tfac.Generate();
data->Print();
epdf->Pdf("pdfExtend").getParameters(data)->readFromFile("/home/chasenberg/Repository/bachelor-template/ToyStudy/dootoycp-parameter.txt");
epdf->Pdf("pdfExtend").getParameters(data)->writeToFile("/home/chasenberg/Repository/bachelor-template/ToyStudy/dootoycp-parameter.txt.new");
//FIT-PDF-Koeffizienten
epdf->Var("asym_prodFit");
epdf->Var("asym_prodFit").setVal(-0.0108);
epdf->Var("asym_prodFit").setConstant(false);
DecRateCoeff *coeff_cFit = new DecRateCoeff("coef_cosFit","coef_cosFit",DecRateCoeff::CPOdd,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("C_f"),epdf->Var("C_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Real("omega"),epdf->Real("omegabar"),epdf->Var("asym_prodFit"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
DecRateCoeff *coeff_sFit = new DecRateCoeff("coef_sinFit","coef_sinFit",DecRateCoeff::CPOdd,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("S_f"),epdf->Var("S_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Real("omega"),epdf->Real("omegabar"),epdf->Var("asym_prodFit"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
DecRateCoeff *coeff_shFit = new DecRateCoeff("coef_sinhFit","coef_sinhFit",DecRateCoeff::CPEven,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("f1_f"),epdf->Var("f1_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Real("omega"),epdf->Real("omegabar"),epdf->Var("asym_prodFit"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
DecRateCoeff *coeff_chFit = new DecRateCoeff("coef_coshFit","coef_coshFit",DecRateCoeff::CPEven,epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("f0_f"),epdf->Var("f0_fbar"),epdf->Var("obsEtaOS"),splinePdf,epdf->Var("tageff"),epdf->Real("omega"),epdf->Real("omegabar"),epdf->Var("asym_prodFit"),epdf->Var("asym_det"),epdf->Var("asym_tageff"));
epdf->AddRealToStore(coeff_chFit);
epdf->AddRealToStore(coeff_shFit);
epdf->AddRealToStore(coeff_cFit);
epdf->AddRealToStore(coeff_sFit);
///////////////////Generiere PDF's/////////////////////
//Zeit
epdf->BDecay("pdfSigTimeFit",epdf->Var("obsTime"),epdf->Var("tau"),epdf->Var("dgamma"),epdf->Real("coef_coshFit"),epdf->Real("coef_sinhFit"),epdf->Real("coef_cosFit"),epdf->Real("coef_sinFit"),epdf->Var("deltaM"),epdf->Model("resTimeGauss"));
//Zusammenfassen der Parameter in einem RooArgSet
RooArgSet ObservablesFit;
ObservablesFit.add(RooArgSet( epdf->Var("obsTime"),epdf->Cat("catFinalState"),epdf->Cat("obsTag"),epdf->Var("obsEtaOS")));
epdf->Extend("pdfExtendFit", epdf->Pdf("pdfSigTimeFit"),epdf->Real("sig_yield"));
RooFitResult* fit_result = epdf->Pdf("pdfExtendFit").fitTo(*data, RooFit::Save(true));
tstudy.StoreFitResult(fit_result);
//epdf->Pdf("pdfExtendFit").getParameters(data)->readFromFile("/home/chasenberg/Repository/bachelor-template/ToyStudy/dootoycp-parameter.txt");
//epdf->Pdf("pdfExtendFit").getParameters(data)->writeToFile("/home/chasenberg/Repository/bachelor-template/ToyStudy/dootoycp-parameter.txt.new");
//Plotten auf lhcb
/*using namespace doofit::plotting;
PlotConfig cfg_plot("cfg_plot");
cfg_plot.InitializeOptions();
cfg_plot.set_plot_directory("/net/storage03/data/users/chasenberg/ergebnis/dootoycp_float-lhcb/dgamma/time/");
// plot PDF and directly specify components
Plot myplot(cfg_plot, epdf->Var("obsTime"), *data, RooArgList(epdf->Pdf("pdfExtend")));
myplot.PlotItLogNoLogY();
PlotConfig cfg_plotEta("cfg_plotEta");
cfg_plotEta.InitializeOptions();
cfg_plotEta.set_plot_directory("/net/storage03/data/users/chasenberg/ergebnis/dootoycp_float-lhcb/dgamma/eta/");
// plot PDF and directly specify components
Plot myplotEta(cfg_plotEta, epdf->Var("obsEtaOS"), *data, RooArgList(splinePdf));
myplotEta.PlotIt();*/
}
///
/// Perform the 1d Prob scan.
/// Saves chi2 values and the prob-Scan p-values in a root tree
/// For the datasets stuff, we do not yet have a MethodDatasetsProbScan class, so we do it all in
/// MethodDatasetsProbScan
/// \param nRun Part of the root tree file name to facilitate parallel production.
///
int MethodDatasetsProbScan::scan1d(bool fast, bool reverse)
{
if (fast) return 0; // tmp
if ( arg->debug ) cout << "MethodDatasetsProbScan::scan1d() : starting ... " << endl;
// Set limit to all parameters.
this->loadParameterLimits(); /// Default is "free", if not changed by cmd-line parameter
// Define scan parameter and scan range.
RooRealVar *parameterToScan = w->var(scanVar1);
float parameterToScan_min = hCL->GetXaxis()->GetXmin();
float parameterToScan_max = hCL->GetXaxis()->GetXmax();
// do a free fit
RooFitResult *result = this->loadAndFit(this->pdf); // fit on data
assert(result);
RooSlimFitResult *slimresult = new RooSlimFitResult(result,true);
slimresult->setConfirmed(true);
solutions.push_back(slimresult);
double freeDataFitValue = w->var(scanVar1)->getVal();
// Define outputfile
system("mkdir -p root");
TString probResName = Form("root/scan1dDatasetsProb_" + this->pdf->getName() + "_%ip" + "_" + scanVar1 + ".root", arg->npoints1d);
TFile* outputFile = new TFile(probResName, "RECREATE");
// Set up toy root tree
this->probScanTree = new ToyTree(this->pdf, arg);
this->probScanTree->init();
this->probScanTree->nrun = -999; //\todo: why does this branch even exist in the output tree of the prob scan?
// Save parameter values that were active at function
// call. We'll reset them at the end to be transparent
// to the outside.
RooDataSet* parsFunctionCall = new RooDataSet("parsFunctionCall", "parsFunctionCall", *w->set(pdf->getParName()));
parsFunctionCall->add(*w->set(pdf->getParName()));
// start scan
cout << "MethodDatasetsProbScan::scan1d_prob() : starting ... with " << nPoints1d << " scanpoints..." << endl;
ProgressBar progressBar(arg, nPoints1d);
for ( int i = 0; i < nPoints1d; i++ )
{
progressBar.progress();
// scanpoint is calculated using min, max, which are the hCL x-Axis limits set in this->initScan()
// this uses the "scan" range, as expected
// don't add half the bin size. try to solve this within plotting method
float scanpoint = parameterToScan_min + (parameterToScan_max - parameterToScan_min) * (double)i / ((double)nPoints1d - 1);
if (arg->debug) cout << "DEBUG in MethodDatasetsProbScan::scan1d_prob() " << scanpoint << " " << parameterToScan_min << " " << parameterToScan_max << endl;
this->probScanTree->scanpoint = scanpoint;
if (arg->debug) cout << "DEBUG in MethodDatasetsProbScan::scan1d_prob() - scanpoint in step " << i << " : " << scanpoint << endl;
// don't scan in unphysical region
// by default this means checking against "free" range
if ( scanpoint < parameterToScan->getMin() || scanpoint > parameterToScan->getMax() + 2e-13 ) {
cout << "it seems we are scanning in an unphysical region: " << scanpoint << " < " << parameterToScan->getMin() << " or " << scanpoint << " > " << parameterToScan->getMax() + 2e-13 << endl;
exit(EXIT_FAILURE);
}
// FIT TO REAL DATA WITH FIXED HYPOTHESIS(=SCANPOINT).
// THIS GIVES THE NUMERATOR FOR THE PROFILE LIKELIHOOD AT THE GIVEN HYPOTHESIS
// THE RESULTING NUISANCE PARAMETERS TOGETHER WITH THE GIVEN HYPOTHESIS ARE ALSO
// USED WHEN SIMULATING THE TOY DATA FOR THE FELDMAN-COUSINS METHOD FOR THIS HYPOTHESIS(=SCANPOINT)
// Here the scanvar has to be fixed -> this is done once per scanpoint
// and provides the scanner with the DeltaChi2 for the data as reference
// additionally the nuisances are set to the resulting fit values
parameterToScan->setVal(scanpoint);
parameterToScan->setConstant(true);
RooFitResult *result = this->loadAndFit(this->pdf); // fit on data
assert(result);
if (arg->debug) {
cout << "DEBUG in MethodDatasetsProbScan::scan1d_prob() - minNll data scan at scan point " << scanpoint << " : " << 2 * result->minNll() << ": "<< 2 * pdf->getMinNll() << endl;
}
this->probScanTree->statusScanData = result->status();
// set chi2 of fixed fit: scan fit on data
// CAVEAT: chi2min from fitresult gives incompatible results to chi2min from pdf
// this->probScanTree->chi2min = 2 * result->minNll();
this->probScanTree->chi2min = 2 * pdf->getMinNll();
this->probScanTree->covQualScanData = result->covQual();
this->probScanTree->scanbest = freeDataFitValue;
// After doing the fit with the parameter of interest constrained to the scanpoint,
// we are now saving the fit values of the nuisance parameters. These values will be
// used to generate toys according to the PLUGIN method.
this->probScanTree->storeParsScan(); // \todo : figure out which one of these is semantically the right one
this->pdf->deleteNLL();
// also save the chi2 of the free data fit to the tree:
this->probScanTree->chi2minGlobal = this->getChi2minGlobal();
this->probScanTree->chi2minBkg = this->getChi2minBkg();
this->probScanTree->genericProbPValue = this->getPValueTTestStatistic(this->probScanTree->chi2min - this->probScanTree->chi2minGlobal);
this->probScanTree->fill();
if(arg->debug && pdf->getBkgPdf())
{
float pval_cls = this->getPValueTTestStatistic(this->probScanTree->chi2min - this->probScanTree->chi2minBkg, true);
cout << "DEBUG in MethodDatasetsProbScan::scan1d() - p value CLs: " << pval_cls << endl;
}
// reset
setParameters(w, pdf->getParName(), parsFunctionCall->get(0));
//setParameters(w, pdf->getObsName(), obsDataset->get(0));
} // End of npoints loop
probScanTree->writeToFile();
if (bkgOnlyFitResult) bkgOnlyFitResult->Write();
if (dataFreeFitResult) dataFreeFitResult->Write();
outputFile->Close();
std::cout << "Wrote ToyTree to file" << std::endl;
delete parsFunctionCall;
// This is kind of a hack. The effect is supposed to be the same as callincg
// this->sethCLFromProbScanTree(); here, but the latter gives a segfault somehow....
// \todo: use this->sethCLFromProbScanTree() directly after figuring out the cause of the segfault.
this->loadScanFromFile();
return 0;
}
void BackgroundPrediction(std::string pname,int rebin_factor,int model_number = 0,int imass=750, bool plotBands = false)
{
rebin = rebin_factor;
std::string fname = std::string("../fitFilesMETPT34/") + pname + std::string("/histos_bkg.root");
stringstream iimass ;
iimass << imass;
std::string dirName = "info_"+iimass.str()+"_"+pname;
gStyle->SetOptStat(000000000);
gStyle->SetPadGridX(0);
gStyle->SetPadGridY(0);
setTDRStyle();
gStyle->SetPadGridX(0);
gStyle->SetPadGridY(0);
gStyle->SetOptStat(0000);
writeExtraText = true; // if extra text
extraText = "Preliminary"; // default extra text is "Preliminary"
lumi_13TeV = "2.7 fb^{-1}"; // default is "19.7 fb^{-1}"
lumi_7TeV = "4.9 fb^{-1}"; // default is "5.1 fb^{-1}"
double ratio_tau=-1;
TFile *f=new TFile(fname.c_str());
TH1F *h_mX_CR_tau=(TH1F*)f->Get("distribs_18_10_1")->Clone("CR_tau");
TH1F *h_mX_SR=(TH1F*)f->Get("distribs_18_10_0")->Clone("The_SR");
double maxdata = h_mX_SR->GetMaximum();
double nEventsSR = h_mX_SR->Integral(600,4000);
ratio_tau=(h_mX_SR->GetSumOfWeights()/(h_mX_CR_tau->GetSumOfWeights()));
//double nEventsSR = h_mX_SR->Integral(600,4000);
std::cout<<"ratio tau "<<ratio_tau<<std::endl;
TH1F *h_SR_Prediction;
TH1F *h_SR_Prediction2;
if(blind) {
h_SR_Prediction2 = (TH1F*)h_mX_CR_tau->Clone("h_SR_Prediction2");
h_mX_CR_tau->Rebin(rebin);
h_mX_CR_tau->SetLineColor(kBlack);
h_SR_Prediction=(TH1F*)h_mX_CR_tau->Clone("h_SR_Prediction");
} else {
h_SR_Prediction2=(TH1F*)h_mX_SR->Clone("h_SR_Prediction2");
h_mX_SR->Rebin(rebin);
h_mX_SR->SetLineColor(kBlack);
h_SR_Prediction=(TH1F*)h_mX_SR->Clone("h_SR_Prediction");
}
h_SR_Prediction->SetMarkerSize(0.7);
h_SR_Prediction->GetYaxis()->SetTitleOffset(1.2);
h_SR_Prediction->Sumw2();
/*TFile *f_sig = new TFile((dirName+"/w_signal_"+iimass.str()+".root").c_str());
RooWorkspace* xf_sig = (RooWorkspace*)f_sig->Get("Vg");
RooAbsPdf *xf_sig_pdf = (RooAbsPdf *)xf_sig->pdf((std::string("signal_fixed_")+pname).c_str());
RooWorkspace w_sig("w");
w_sig.import(*xf_sig_pdf,RooFit::RenameVariable((std::string("signal_fixed_")+pname).c_str(),(std::string("signal_fixed_")+pname+std::string("low")).c_str()),RooFit::RenameAllVariablesExcept("low","x"));
xf_sig_pdf = w_sig.pdf((std::string("signal_fixed_")+pname+std::string("low")).c_str());
RooArgSet* biasVars = xf_sig_pdf->getVariables();
TIterator *it = biasVars->createIterator();
RooRealVar* var = (RooRealVar*)it->Next();
while (var) {
var->setConstant(kTRUE);
var = (RooRealVar*)it->Next();
}
*/
RooRealVar x("x", "m_{X} (GeV)", SR_lo, SR_hi);
RooRealVar nBackground((std::string("bg_")+pname+std::string("_norm")).c_str(),"nbkg",h_mX_SR->GetSumOfWeights());
RooRealVar nBackground2((std::string("alt_bg_")+pname+std::string("_norm")).c_str(),"nbkg",h_mX_SR->GetSumOfWeights());
std::string blah = pname;
//pname=""; //Antibtag=tag to constrain b-tag to the anti-btag shape
/* RooRealVar bg_p0((std::string("bg_p0_")+pname).c_str(), "bg_p0", 4.2, 0, 200.);
RooRealVar bg_p1((std::string("bg_p1_")+pname).c_str(), "bg_p1", 4.5, 0, 300.);
RooRealVar bg_p2((std::string("bg_p2_")+pname).c_str(), "bg_p2", 0.000047, 0, 10.1);
RooGenericPdf bg_pure = RooGenericPdf((std::string("bg_pure_")+blah).c_str(),"(pow(1-@0/13000,@1)/pow(@0/13000,@2+@3*log(@0/13000)))",RooArgList(x,bg_p0,bg_p1,bg_p2));
*/
RooRealVar bg_p0((std::string("bg_p0_")+pname).c_str(), "bg_p0", 0., -1000, 200.);
RooRealVar bg_p1((std::string("bg_p1_")+pname).c_str(), "bg_p1", -13, -1000, 1000.);
RooRealVar bg_p2((std::string("bg_p2_")+pname).c_str(), "bg_p2", -1.4, -1000, 1000.);
bg_p0.setConstant(kTRUE);
//RooGenericPdf bg_pure = RooGenericPdf((std::string("bg_pure_")+blah).c_str(),"(pow(@0/13000,@1+@2*log(@0/13000)))",RooArgList(x,bg_p1,bg_p2));
RooGenericPdf bg = RooGenericPdf((std::string("bg_")+blah).c_str(),"(pow(@0/13000,@1+@2*log(@0/13000)))",RooArgList(x,bg_p1,bg_p2));
/*TF1* biasFunc = new TF1("biasFunc","(0.63*x/1000-1.45)",1350,3600);
TF1* biasFunc2 = new TF1("biasFunc2","TMath::Min(2.,2.3*x/1000-3.8)",1350,3600);
double bias_term_s = 0;
if ((imass > 2450 && blah == "antibtag") || (imass > 1640 && blah == "btag")) {
if (blah == "antibtag") {
bias_term_s = 2.7*biasFunc->Eval(imass);
} else {
bias_term_s = 2.7*biasFunc2->Eval(imass);
}
bias_term_s/=nEventsSR;
}
RooRealVar bias_term((std::string("bias_term_")+blah).c_str(), "bias_term", 0., -bias_term_s, bias_term_s);
//bias_term.setConstant(kTRUE);
RooAddPdf bg((std::string("bg_")+blah).c_str(), "bg_all", RooArgList(*xf_sig_pdf, bg_pure), bias_term);
*/
string name_output = "CR_RooFit_Exp";
std::cout<<"Nevents "<<nEventsSR<<std::endl;
RooDataHist pred("pred", "Prediction from SB", RooArgList(x), h_SR_Prediction);
RooFitResult *r_bg=bg.fitTo(pred, RooFit::Minimizer("Minuit2"), RooFit::Range(SR_lo, SR_hi), RooFit::SumW2Error(kTRUE), RooFit::Save());
//RooFitResult *r_bg=bg.fitTo(pred, RooFit::Range(SR_lo, SR_hi), RooFit::Save());
//RooFitResult *r_bg=bg.fitTo(pred, RooFit::Range(SR_lo, SR_hi), RooFit::Save(),RooFit::SumW2Error(kTRUE));
std::cout<<" --------------------- Building Envelope --------------------- "<<std::endl;
//std::cout<< "bg_p0_"<< pname << " param "<<bg_p0.getVal() << " "<<bg_p0.getError()<<std::endl;
std::cout<< "bg_p1_"<< pname << " param "<<bg_p1.getVal() << " "<<100*bg_p1.getError()<<std::endl;
std::cout<< "bg_p2_"<< pname << " param "<<bg_p2.getVal() << " "<<100*bg_p2.getError()<<std::endl;
//std::cout<< "bias_term_"<< blah << " param 0 "<<bias_term_s<<std::endl;
RooPlot *aC_plot=x.frame();
pred.plotOn(aC_plot, RooFit::MarkerColor(kPink+2));
if (!plotBands) {
bg.plotOn(aC_plot, RooFit::VisualizeError(*r_bg, 2), RooFit::FillColor(kYellow));
bg.plotOn(aC_plot, RooFit::VisualizeError(*r_bg, 1), RooFit::FillColor(kGreen));
}
bg.plotOn(aC_plot, RooFit::LineColor(kBlue));
//pred.plotOn(aC_plot, RooFit::LineColor(kBlack), RooFit::MarkerColor(kBlack));
TGraph* error_curve[5]; //correct error bands
TGraphAsymmErrors* dataGr = new TGraphAsymmErrors(h_SR_Prediction->GetNbinsX()); //data w/o 0 entries
for (int i=2; i!=5; ++i) {
error_curve[i] = new TGraph();
}
error_curve[2] = (TGraph*)aC_plot->getObject(1)->Clone("errs");
int nPoints = error_curve[2]->GetN();
error_curve[0] = new TGraph(2*nPoints);
error_curve[1] = new TGraph(2*nPoints);
error_curve[0]->SetFillStyle(1001);
error_curve[1]->SetFillStyle(1001);
error_curve[0]->SetFillColor(kGreen);
error_curve[1]->SetFillColor(kYellow);
error_curve[0]->SetLineColor(kGreen);
error_curve[1]->SetLineColor(kYellow);
if (plotBands) {
RooDataHist pred2("pred2", "Prediction from SB", RooArgList(x), h_SR_Prediction2);
error_curve[3]->SetFillStyle(1001);
error_curve[4]->SetFillStyle(1001);
error_curve[3]->SetFillColor(kGreen);
error_curve[4]->SetFillColor(kYellow);
error_curve[3]->SetLineColor(kGreen);
error_curve[4]->SetLineColor(kYellow);
error_curve[2]->SetLineColor(kBlue);
error_curve[2]->SetLineWidth(3);
double binSize = rebin;
for (int i=0; i!=nPoints; ++i) {
double x0,y0, x1,y1;
error_curve[2]->GetPoint(i,x0,y0);
RooAbsReal* nlim = new RooRealVar("nlim","y0",y0,-100000,100000);
//double lowedge = x0 - (SR_hi - SR_lo)/double(2*nPoints);
//double upedge = x0 + (SR_hi - SR_lo)/double(2*nPoints);
double lowedge = x0 - binSize/2.;
double upedge = x0 + binSize/2.;
x.setRange("errRange",lowedge,upedge);
RooExtendPdf* epdf = new RooExtendPdf("epdf","extpdf",bg, *nlim,"errRange");
// Construct unbinned likelihood
RooAbsReal* nll = epdf->createNLL(pred2,NumCPU(2));
// Minimize likelihood w.r.t all parameters before making plots
RooMinimizer* minim = new RooMinimizer(*nll);
minim->setMinimizerType("Minuit2");
minim->setStrategy(2);
minim->setPrintLevel(-1);
minim->migrad();
minim->hesse();
RooFitResult* result = minim->lastMinuitFit();
double errm = nlim->getPropagatedError(*result);
//std::cout<<x0<<" "<<lowedge<<" "<<upedge<<" "<<y0<<" "<<nlim->getVal()<<" "<<errm<<std::endl;
error_curve[0]->SetPoint(i,x0,(y0-errm));
error_curve[0]->SetPoint(2*nPoints-i-1,x0,y0+errm);
error_curve[1]->SetPoint(i,x0,(y0-2*errm));
error_curve[1]->SetPoint(2*nPoints-i-1,x0,(y0+2*errm));
error_curve[3]->SetPoint(i,x0,-errm/sqrt(y0));
error_curve[3]->SetPoint(2*nPoints-i-1,x0,errm/sqrt(y0));
error_curve[4]->SetPoint(i,x0,-2*errm/sqrt(y0));
error_curve[4]->SetPoint(2*nPoints-i-1,x0,2*errm/sqrt(y0));
}
int npois = 0;
dataGr->SetMarkerSize(1.0);
dataGr->SetMarkerStyle (20);
const double alpha = 1 - 0.6827;
for (int i=0; i!=h_SR_Prediction->GetNbinsX(); ++i){
if (h_SR_Prediction->GetBinContent(i+1) > 0) {
int N = h_SR_Prediction->GetBinContent(i+1);
double L = (N==0) ? 0 : (ROOT::Math::gamma_quantile(alpha/2,N,1.));
double U = ROOT::Math::gamma_quantile_c(alpha/2,N+1,1) ;
dataGr->SetPoint(npois,h_SR_Prediction->GetBinCenter(i+1),h_SR_Prediction->GetBinContent(i+1));
dataGr->SetPointEYlow(npois, N-L);
dataGr->SetPointEYhigh(npois, U-N);
npois++;
}
}
}
double xG[2] = {-10,4000};
double yG[2] = {0.0,0.0};
TGraph* unityG = new TGraph(2, xG, yG);
unityG->SetLineColor(kBlue);
unityG->SetLineWidth(1);
double xPad = 0.3;
TCanvas *c_rooFit=new TCanvas("c_rooFit", "c_rooFit", 800*(1.-xPad), 600);
c_rooFit->SetFillStyle(4000);
c_rooFit->SetFrameFillColor(0);
TPad *p_1=new TPad("p_1", "p_1", 0, xPad, 1, 1);
p_1->SetFillStyle(4000);
p_1->SetFrameFillColor(0);
p_1->SetBottomMargin(0.02);
TPad* p_2 = new TPad("p_2", "p_2",0,0,1,xPad);
p_2->SetBottomMargin((1.-xPad)/xPad*0.13);
p_2->SetTopMargin(0.03);
p_2->SetFillColor(0);
p_2->SetBorderMode(0);
p_2->SetBorderSize(2);
p_2->SetFrameBorderMode(0);
p_2->SetFrameBorderMode(0);
p_1->Draw();
p_2->Draw();
p_1->cd();
int nbins = (int) (SR_hi- SR_lo)/rebin;
x.setBins(nbins);
std::cout << "chi2(data) " << aC_plot->chiSquare()<<std::endl;
//std::cout << "p-value: data under hypothesis H0: " << TMath::Prob(chi2_data->getVal(), nbins - 1) << std::endl;
aC_plot->GetXaxis()->SetRangeUser(SR_lo, SR_hi);
aC_plot->GetXaxis()->SetLabelOffset(0.02);
aC_plot->GetYaxis()->SetRangeUser(0.1, 1000.);
h_SR_Prediction->GetXaxis()->SetRangeUser(SR_lo, SR_hi);
string rebin_ = itoa(rebin);
aC_plot->GetXaxis()->SetTitle("M_{Z#gamma} [GeV] ");
aC_plot->GetYaxis()->SetTitle(("Events / "+rebin_+" GeV ").c_str());
aC_plot->SetMarkerSize(0.7);
aC_plot->GetYaxis()->SetTitleOffset(1.2);
aC_plot->Draw();
if (plotBands) {
error_curve[1]->Draw("Fsame");
error_curve[0]->Draw("Fsame");
error_curve[2]->Draw("Lsame");
dataGr->Draw("p e1 same");
}
aC_plot->SetTitle("");
TPaveText *pave = new TPaveText(0.85,0.4,0.67,0.5,"NDC");
pave->SetBorderSize(0);
pave->SetTextSize(0.05);
pave->SetTextFont(42);
pave->SetLineColor(1);
pave->SetLineStyle(1);
pave->SetLineWidth(2);
pave->SetFillColor(0);
pave->SetFillStyle(0);
char name[1000];
sprintf(name,"#chi^{2}/n = %.2f",aC_plot->chiSquare());
pave->AddText(name);
//pave->Draw();
TLegend *leg = new TLegend(0.88,0.65,0.55,0.90,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.05);
leg->SetTextFont(42);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(2);
leg->SetFillColor(0);
leg->SetFillStyle(0);
h_SR_Prediction->SetMarkerColor(kBlack);
h_SR_Prediction->SetLineColor(kBlack);
h_SR_Prediction->SetMarkerStyle(20);
h_SR_Prediction->SetMarkerSize(1.0);
//h_mMMMMa_3Tag_SR->GetXaxis()->SetTitleSize(0.09);
if (blind)
leg->AddEntry(h_SR_Prediction, "Data: sideband", "ep");
else {
if (blah == "antibtag" )
leg->AddEntry(h_SR_Prediction, "Data: anti-b-tag SR", "ep");
else
leg->AddEntry(h_SR_Prediction, "Data: b-tag SR", "ep");
}
leg->AddEntry(error_curve[2], "Fit model", "l");
leg->AddEntry(error_curve[0], "Fit #pm1#sigma", "f");
leg->AddEntry(error_curve[1], "Fit #pm2#sigma", "f");
leg->Draw();
aC_plot->Draw("axis same");
CMS_lumi( p_1, iPeriod, iPos );
p_2->cd();
RooHist* hpull;
hpull = aC_plot->pullHist();
RooPlot* frameP = x.frame() ;
frameP->SetTitle("");
frameP->GetXaxis()->SetRangeUser(SR_lo, SR_hi);
frameP->addPlotable(hpull,"P");
frameP->GetYaxis()->SetRangeUser(-7,7);
frameP->GetYaxis()->SetNdivisions(505);
frameP->GetYaxis()->SetTitle("#frac{(data-fit)}{#sigma_{stat}}");
frameP->GetYaxis()->SetTitleSize((1.-xPad)/xPad*0.06);
frameP->GetYaxis()->SetTitleOffset(1.0/((1.-xPad)/xPad));
frameP->GetXaxis()->SetTitleSize((1.-xPad)/xPad*0.06);
//frameP->GetXaxis()->SetTitleOffset(1.0);
frameP->GetXaxis()->SetLabelSize((1.-xPad)/xPad*0.05);
frameP->GetYaxis()->SetLabelSize((1.-xPad)/xPad*0.05);
frameP->Draw();
if (plotBands) {
error_curve[4]->Draw("Fsame");
error_curve[3]->Draw("Fsame");
unityG->Draw("same");
hpull->Draw("psame");
frameP->Draw("axis same");
}
c_rooFit->SaveAs((dirName+"/"+name_output+".pdf").c_str());
const int nModels = 9;
TString models[nModels] = {
"env_pdf_0_13TeV_dijet2", //0
"env_pdf_0_13TeV_exp1", //1
"env_pdf_0_13TeV_expow1", //2
"env_pdf_0_13TeV_expow2", //3 => skip
"env_pdf_0_13TeV_pow1", //4
"env_pdf_0_13TeV_lau1", //5
"env_pdf_0_13TeV_atlas1", //6
"env_pdf_0_13TeV_atlas2", //7 => skip
"env_pdf_0_13TeV_vvdijet1" //8
};
int nPars[nModels] = {
2, 1, 2, 3, 1, 1, 2, 3, 2
};
TString parNames[nModels][3] = {
"env_pdf_0_13TeV_dijet2_log1","env_pdf_0_13TeV_dijet2_log2","",
"env_pdf_0_13TeV_exp1_p1","","",
"env_pdf_0_13TeV_expow1_exp1","env_pdf_0_13TeV_expow1_pow1","",
"env_pdf_0_13TeV_expow2_exp1","env_pdf_0_13TeV_expow2_pow1","env_pdf_0_13TeV_expow2_exp2",
"env_pdf_0_13TeV_pow1_p1","","",
"env_pdf_0_13TeV_lau1_l1","","",
"env_pdf_0_13TeV_atlas1_coeff1","env_pdf_0_13TeV_atlas1_log1","",
"env_pdf_0_13TeV_atlas2_coeff1","env_pdf_0_13TeV_atlas2_log1","env_pdf_0_13TeV_atlas2_log2",
"env_pdf_0_13TeV_vvdijet1_coeff1","env_pdf_0_13TeV_vvdijet1_log1",""
}
if(bias){
//alternative model
gSystem->Load("libHiggsAnalysisCombinedLimit");
gSystem->Load("libdiphotonsUtils");
TFile *f = new TFile("antibtag_multipdf.root");
RooWorkspace* xf = (RooWorkspace*)f->Get("wtemplates");
RooWorkspace *w_alt=new RooWorkspace("Vg");
for(int i=model_number; i<=model_number; i++){
RooMultiPdf *alternative = (RooMultiPdf *)xf->pdf("model_bkg_AntiBtag");
std::cout<<"Number of pdfs "<<alternative->getNumPdfs()<<std::endl;
for (int j=0; j!=alternative->getNumPdfs(); ++j){
std::cout<<alternative->getPdf(j)->GetName()<<std::endl;
}
RooAbsPdf *alt_bg = alternative->getPdf(alternative->getCurrentIndex()+i);//->clone();
w_alt->import(*alt_bg, RooFit::RenameVariable(alt_bg->GetName(),("alt_bg_"+blah).c_str()));
w_alt->Print("V");
std::cerr<<w_alt->var("x")<<std::endl;
RooRealVar * range_ = w_alt->var("x");
range_->setRange(SR_lo,SR_hi);
char* asd = ("alt_bg_"+blah).c_str() ;
w_alt->import(nBackground2);
std::cout<<alt_bg->getVal() <<std::endl;
w_alt->pdf(asd)->fitTo(pred, RooFit::Minimizer("Minuit2"), RooFit::Range(SR_lo, SR_hi), RooFit::SumW2Error(kTRUE), RooFit::Save());
RooArgSet* altVars = w_alt->pdf(asd)->getVariables();
TIterator *it2 = altVars->createIterator();
RooRealVar* varAlt = (RooRealVar*)it2->Next();
while (varAlt) {
varAlt->setConstant(kTRUE);
varAlt = (RooRealVar*)it2->Next();
}
alt_bg->plotOn(aC_plot, RooFit::LineColor(i+1), RooFit::LineStyle(i+2));
p_1->cd();
aC_plot->GetYaxis()->SetRangeUser(0.01, maxdata*50.);
aC_plot->Draw("same");
TH1F *h=new TH1F();
h->SetLineColor(1+i);
h->SetLineStyle(i+2);
leg->AddEntry(h, alt_bg->GetName(), "l");
w_alt->SaveAs((dirName+"/w_background_alternative.root").c_str());
}
leg->Draw();
p_1->SetLogy();
c_rooFit->Update();
c_rooFit->SaveAs((dirName+"/"+name_output+blah+"_multipdf.pdf").c_str());
for (int i=0; i!=nPars[model_number]; ++i) {
std::cout<<parNames[model_number][i]<<" param "<< w_alt->var(parNames[model_number][i])->getVal()<<" "<<w_alt->var(parNames[model_number][i])->getError()<<std::endl;
}
} else {
p_1->SetLogy();
c_rooFit->Update();
c_rooFit->SaveAs((dirName+"/"+name_output+"_log.pdf").c_str());
}
RooWorkspace *w=new RooWorkspace("Vg");
w->import(bg);
w->import(nBackground);
w->SaveAs((dirName+"/w_background_GaussExp.root").c_str());
TH1F *h_mX_SR_fakeData=(TH1F*)h_mX_SR->Clone("h_mX_SR_fakeData");
h_mX_SR_fakeData->Scale(nEventsSR/h_mX_SR_fakeData->GetSumOfWeights());
RooDataHist data_obs("data_obs", "Data", RooArgList(x), h_mX_SR_fakeData);
std::cout<<" Background number of events = "<<nEventsSR<<std::endl;
RooWorkspace *w_data=new RooWorkspace("Vg");
w_data->import(data_obs);
w_data->SaveAs((dirName+"/w_data.root").c_str());
}
double RunHypoTest(char *smwwFileName, char *ttbarFileName, char *wp3jetsFileName, char *wp4jetsFileName, char *opsFileName, char *outputFileName, double lambda) {
TFile *smwwFile = new TFile(smwwFileName);
TFile *ttbarFile = new TFile(ttbarFileName);
TFile *wp3jetsFile = new TFile(wp3jetsFileName);
TFile *wp4jetsFile = new TFile(wp4jetsFileName);
TFile *opsFile = new TFile(opsFileName);
TFile *outputFile = new TFile(outputFileName, "UPDATE");
TH1F *smww = (TH1F*)smwwFile->Get(WW_MASS_HISTOGRAM_NAME);
TH1F *ttbar = (TH1F*)ttbarFile->Get(WW_MASS_HISTOGRAM_NAME);
TH1F *wp3jets = (TH1F*)wp3jetsFile->Get(WW_MASS_HISTOGRAM_NAME);
TH1F *wp4jets = (TH1F*)wp4jetsFile->Get(WW_MASS_HISTOGRAM_NAME);
//Histogram of ww-scattering with effective operator contributions
TH1F *ops = (TH1F*)opsFile->Get(WW_MASS_HISTOGRAM_NAME);
RooRealVar *mww = new RooRealVar("mww", "M_{WW}", 600, 2500, "GeV");
RooDataHist smData("smData", "smData", RooArgList(*mww), smww);
RooDataHist opsData("opsData", "opsData", RooArgList(*mww), ops);
RooDataHist ttbarData("ttbarData", "ttbarData", RooArgList(*mww), ttbar);
RooDataHist wp3jetsData("wp3jetsData", "wp3jetsData", RooArgList(*mww), wp3jets);
RooDataHist wp4jetsData("wp4jetsData", "wp4jetsData", RooArgList(*mww), wp4jets);
/*
RooAbsPdf *opsModel;
if (lambda == 400) {
opsModel = SpecialCaseModel(&opsData, mww, (char*)"ops");
}
else {
opsModel = MakeModel(&opsData, mww, (char*)"ops");
}*/
RooAbsPdf *opsModel = MakeModel(&opsData, mww, (char*)"ops");
//RooPlot *xframe = mww->frame();
//opsData.plotOn(xframe);
//opsModel->plotOn(xframe);
//printf("Chi-squared for lambda = %f: = %f\n", lambda, xframe->chiSquare("opsModel", "opsData", 3));
RooAbsPdf *smModel = MakeModelNoSignal(&smData, mww, (char*)"sm");
RooAbsPdf *ttbarModel = MakeModelNoSignal(&ttbarData, mww, (char*)"ttbar");
RooAbsPdf *wp3jetsModel = MakeModelNoSignal(&wp3jetsData, mww, (char*)"wp3jets");
RooAbsPdf *wp4jetsModel = MakeModelNoSignal(&wp4jetsData, mww, (char*)"wp4jets");
TCanvas *canvas = new TCanvas(opsFileName);
RooPlot *frame = mww->frame();
frame->SetTitle("");
//smData.plotOn(frame, RooFit::LineColor(kBlack), RooFit::Name("smData"));
//smModel->plotOn(frame, RooFit::LineColor(kBlue), RooFit::Name("smModel"));
//ttbarModel->plotOn(frame, RooFit::LineColor(kRed), RooFit::Name("ttbarModel"));
//wp3jetsModel->plotOn(frame, RooFit::LineColor(kYellow), RooFit::Name("wpjetsModel"));
opsData.plotOn(frame);
opsModel->plotOn(frame, RooFit::LineColor(kBlue), RooFit::Name("opsModel"));
//leg->AddEntry(frame->findObject("smModel"), "SM Model", "lep");
//leg->AddEntry(frame->findObject("ttbarModel"), "TTBar Model", "lep");
//leg->AddEntry(frame->findObject("wp3jetsModel"), "WP3Jets Model", "lep");
//leg->AddEntry(frame->findObject("opsModel"), "Effective Operator Model", "lep");
frame->Draw();
canvas->Write();
Double_t ww_x = WW_CROSS_SECTION * smww->GetEntries();
Double_t ttbar_x = TTBAR_CROSS_SECTION * ttbar->GetEntries();
Double_t wp3jets_x = WP3JETS_CROSS_SECTION * wp3jets->GetEntries();
Double_t wp4jets_x = WP4JETS_CROSS_SECTION * wp4jets->GetEntries();
Double_t ttbar_weight = ttbar_x/(ttbar_x + wp3jets_x + wp4jets_x + ww_x);
Double_t wp3jets_weight = wp3jets_x/(wp3jets_x + ttbar_x + ww_x);
Double_t wp4jets_weight = wp4jets_x/(wp4jets_x + ttbar_x + ww_x);
RooRealVar *ttbarWeight = new RooRealVar("ttbarWeight", "ttbarWeight", 0.0, 1.0, ttbar_weight);
RooRealVar *wp3jetsWeight = new RooRealVar("wp3jetsWeight", "wp3jetsWeight", 0.0, 1.0, wp3jets_weight);
RooRealVar *wp4jetsWeight = new RooRealVar("wp4jetsWeight", "wp4jetsWeight", 0.0, 1.0, wp4jets_weight);
ttbarWeight->setConstant();
wp3jetsWeight->setConstant();
wp4jetsWeight->setConstant();
RooRealVar *mu = new RooRealVar("mu", "mu", 0.0, 1.0, "");
RooAddPdf *wwModel = new RooAddPdf("wwModel", "u*effective_ww + (1-u)*SM_WW",
RooArgList(*opsModel, *smModel), RooArgList(*mu), kTRUE);
RooAddPdf *model = new RooAddPdf("model", "Full model",
RooArgList(*ttbarModel, *wp3jetsModel, *wp4jetsModel, *wwModel),
RooArgList(*ttbarWeight, *wp3jetsWeight, *wp4jetsWeight), kTRUE);
//Generate data under the alternate hypothesis
mu->setVal(1.0);
int nTestSetEvents = WW_CROSS_SECTION * TOTAL_INTEGRATED_LUMINOSITY;
RooAbsData *generatedData = model->generate(*mww, nTestSetEvents);
TCanvas *canvas2 = new TCanvas("CombinedModels");
RooPlot *frame2 = mww->frame();
//wwModel->plotOn(frame2, RooFit::LineColor(kRed), RooFit::Name("wwModel"));
//generatedData->plotOn(frame2);
mu->setVal(0.0);
model->plotOn(frame2, RooFit::LineColor(kBlue), RooFit::Name("nullModel"));
mu->setVal(1.0);
model->plotOn(frame2, RooFit::LineColor(kRed), RooFit::Name("altModel"));
TLegend *leg2 = new TLegend(0.65,0.73,0.86,0.87);
//leg->AddEntry(frame2->findObject("wwModel"), "SM WW Scattering model with background",
// "lep");
leg2->AddEntry(frame2->findObject("nullModel"),
"SM + Background", "lep");
leg2->AddEntry(frame2->findObject("altModel"),
"Effective Operator + Background", "lep");
frame2->SetTitle("");
frame2->GetXaxis()->SetTitle("M_{WW} (GeV)");
frame2->GetYaxis()->SetTitle("");
frame2->Draw();
leg2->Draw();
canvas2->Write();
outputFile->Close();
RooArgSet poi(*mu);
RooArgSet *nullParams = (RooArgSet*) poi.snapshot();
nullParams->setRealValue("mu", 0.0);
RooStats::ProfileLikelihoodCalculator plc(*generatedData, *model, poi, 0.05, nullParams);
RooStats::HypoTestResult* htr = plc.GetHypoTest();
std::cerr << "P Value = " << htr->NullPValue() << "\n";
return htr->Significance();
}
void RooToyMCFit1Bin(const int _bin){
if(_bin<1 || _bin>8){
cout << "Bin number should be between 1 and 8" << endl;
return;
}
stringstream out;
out.str("");
out << "toyMC_" << _sigma_over_tau << "_" << _purity << "_" << mistag_rate << ".root";
TFile* file = TFile::Open(out.str().c_str());
TTree* tree = (TTree*)file->Get("ToyTree");
cout << "The tree has been readed from the file " << out.str().c_str() << endl;
RooRealVar tau("tau","tau",_tau,"ps"); tau.setConstant(kTRUE);
RooRealVar dm("dm","dm",_dm,"ps^{-1}"); dm.setConstant(kTRUE);
RooRealVar sin2beta("sin2beta","sin2beta",_sin2beta,-5.,5.); if(constBeta) sin2beta.setConstant(kTRUE);
RooRealVar cos2beta("cos2beta","cos2beta",_cos2beta,-5.,5.); if(constBeta) cos2beta.setConstant(kTRUE);
RooRealVar dt("dt","#Deltat",-5.,5.,"ps");
RooRealVar avgMisgat("avgMisgat","avgMisgat",mistag_rate,0.0,0.5); if(constMistag) avgMisgat.setConstant(kTRUE);
RooRealVar delMisgat("delMisgat","delMisgat",0); delMisgat.setConstant(kTRUE);
RooRealVar mu("mu","mu",0); mu.setConstant(kTRUE);
RooRealVar moment("moment","moment",0.); moment.setConstant(kTRUE);
RooRealVar parity("parity","parity",-1.); parity.setConstant(kTRUE);
cout << "Preparing coefficients..." << endl;
RooRealVar* K = new RooRealVar("K","K",K8[_bin-1],0.,1.); if(constK) K->setConstant(kTRUE);
RooFormulaVar* Kb = new RooFormulaVar("Kb","Kb","1-@0",RooArgList(*K));
RooRealVar* C = new RooRealVar("C","C",_C[_bin-1]); C->setConstant(kTRUE);
RooRealVar* S = new RooRealVar("S","S",_S[_bin-1]); S->setConstant(kTRUE);
RooFormulaVar* a1 = new RooFormulaVar("a1","a1","-(@0-@1)/(@0+@1)",RooArgList(*K,*Kb));
RooFormulaVar* a1b = new RooFormulaVar("a1b","a1b","(@0-@1)/(@0+@1)",RooArgList(*K,*Kb));
RooFormulaVar* a2 = new RooFormulaVar("a2","a2","(@0-@1)/(@0+@1)",RooArgList(*K,*Kb));
RooFormulaVar* a2b = new RooFormulaVar("a2b","a2b","-(@0-@1)/(@0+@1)",RooArgList(*K,*Kb));
RooFormulaVar* b1 = new RooFormulaVar("b1","b1","2.*(@2*@4+@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1);",RooArgList(*K,*Kb,*C,*S,sin2beta,cos2beta));
RooFormulaVar* b1b = new RooFormulaVar("b1b","b1b","2.*(@2*@4-@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1);",RooArgList(*K,*Kb,*C,*S,sin2beta,cos2beta));
RooFormulaVar* b2 = new RooFormulaVar("b2","b2","-2.*(@2*@4+@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1);",RooArgList(*K,*Kb,*C,*S,sin2beta,cos2beta));
RooFormulaVar* b2b = new RooFormulaVar("b2b","b2b","-2.*(@2*@4-@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1);",RooArgList(*K,*Kb,*C,*S,sin2beta,cos2beta));
RooRealVar* dgamma = new RooRealVar("dgamma","dgamma",0.); dgamma->setConstant(kTRUE);
RooRealVar* f0 = new RooRealVar("f0","f0",1.); f0->setConstant(kTRUE);
RooRealVar* f1 = new RooRealVar("f1","f1",0.); f1->setConstant(kTRUE);
RooCategory tag("tag","tag");
tag.defineType("B0",1);
tag.defineType("anti-B0",-1);
RooCategory bin("bin","bin");
bin.defineType("bin",_bin);
bin.defineType("binb",-_bin);
RooSuperCategory bintag("bintag","bintag",RooArgSet(bin,tag));
RooDataSet d("data","data",tree,RooArgSet(dt,bin,tag));
cout << "DataSet is ready." << endl;
d.Print();
RooRealVar mean("mean","mean",0.,"ps"); mean.setConstant(kTRUE);
RooRealVar sigma("sigma","sigma",_sigma_over_tau*_tau,0.,_tau,"ps"); if(constSigma) sigma.setConstant(kTRUE);
RooGaussModel rf("rf","rf",dt,mean,sigma);
// RooTruthModel rf("rf","rf",dt);
RooGaussian rfpdf("rfpdf","rfpdf",dt,mean,sigma);
cout << "Preparing PDFs..." << endl;
RooBDecay* sigpdf1 = new RooBDecay("sigpdf1","sigpdf1",dt,tau,*dgamma,*f0,*f1,*a1,*b1,dm,rf,RooBDecay::DoubleSided);
RooBDecay* sigpdf2 = new RooBDecay("sigpdf2","sigpdf2",dt,tau,*dgamma,*f0,*f1,*a2,*b2,dm,rf,RooBDecay::DoubleSided);
RooBDecay* sigpdf1b = new RooBDecay("sigpdf1b","sigpdf1b",dt,tau,*dgamma,*f0,*f1,*a1b,*b1b,dm,rf,RooBDecay::DoubleSided);
RooBDecay* sigpdf2b = new RooBDecay("sigpdf2b","sigpdf2b",dt,tau,*dgamma,*f0,*f1,*a2b,*b2b,dm,rf,RooBDecay::DoubleSided);
RooRealVar fsig("fsig","fsigs",_purity,0.,1.); if(constFSig) fsig.setConstant(kTRUE);
RooAddPdf* PDF1 = new RooAddPdf("PDF1","PDF1",RooArgList(*sigpdf1,rfpdf),RooArgList(fsig));
RooAddPdf* PDF2 = new RooAddPdf("PDF2","PDF2",RooArgList(*sigpdf2,rfpdf),RooArgList(fsig));
RooAddPdf* PDF1b= new RooAddPdf("PDF1b","PDF1b",RooArgList(*sigpdf1b,rfpdf),RooArgList(fsig));
RooAddPdf* PDF2b= new RooAddPdf("PDF2b","PDF2b",RooArgList(*sigpdf2b,rfpdf),RooArgList(fsig));
//Adding mistaging
RooAddPdf* pdf1 = new RooAddPdf("pdf1","pdf1",RooArgList(*PDF2,*PDF1),RooArgList(avgMisgat));
RooAddPdf* pdf2 = new RooAddPdf("pdf2","pdf2",RooArgList(*PDF1,*PDF2),RooArgList(avgMisgat));
RooAddPdf* pdf1b= new RooAddPdf("pdf1b","pdf1b",RooArgList(*PDF2b,*PDF1b),RooArgList(avgMisgat));
RooAddPdf* pdf2b= new RooAddPdf("pdf2b","pdf2b",RooArgList(*PDF1b,*PDF2b),RooArgList(avgMisgat));
RooSimultaneous pdf("pdf","pdf",bintag);
pdf.addPdf(*pdf1,"{bin;B0}");
pdf.addPdf(*pdf2,"{bin;anti-B0}");
pdf.addPdf(*pdf1b,"{binb;B0}");
pdf.addPdf(*pdf2b,"{binb;anti-B0}");
cout << "Fitting..." << endl;
pdf.fitTo(d,Verbose(),Timer());
cout << "Drawing plots." << endl;
// Plus bin
RooPlot* dtFrame = dt.frame();
// B0
out.str("");
out << "tag == 1 && bin == " << _bin;
cout << out.str() << endl;
RooDataSet* ds = d.reduce(out.str().c_str());
ds->Print();
ds->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),MarkerColor(kBlue));
bintag = "{bin;B0}";
pdf.plotOn(dtFrame,ProjWData(RooArgSet(),*ds),Slice(bintag),LineColor(kBlue));
double chi2 = dtFrame->chiSquare();
// anti-B0
out.str("");
out << "tag == -1 && bin == " << _bin;
cout << out.str() << endl;
RooDataSet* dsb = d.reduce(out.str().c_str());
dsb->Print();
dsb->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),MarkerColor(kRed));
bintag = "{bin;anti-B0}";
pdf.plotOn(dtFrame,ProjWData(RooArgSet(),*dsb),Slice(bintag),LineColor(kRed));
double chi2b = dtFrame->chiSquare();
// Canvas
out.str("");
out << "#Delta t, toy MC, bin == " << _bin;
TCanvas* cm = new TCanvas(out.str().c_str(),out.str().c_str(),600,400);
cm->cd();
dtFrame->GetXaxis()->SetTitleSize(0.05);
dtFrame->GetXaxis()->SetTitleOffset(0.85);
dtFrame->GetXaxis()->SetLabelSize(0.05);
dtFrame->GetYaxis()->SetTitleOffset(1.6);
TPaveText *pt = new TPaveText(0.7,0.6,0.98,0.99,"brNDC");
pt->SetFillColor(0);
pt->SetTextAlign(12);
out.str("");
out << "bin = " << _bin;
pt->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(B^{0}) = " << chi2;
pt->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(#barB^{0}) = " << chi2b;
pt->AddText(out.str().c_str());
out.str("");
out << "#sigma/#tau = " << sigma.getVal()/tau.getVal();
pt->AddText(out.str().c_str());
out.str("");
out << "purity = " << _purity;
pt->AddText(out.str().c_str());
out.str("");
out << "mistag = " << mistag_rate;
pt->AddText(out.str().c_str());
dtFrame->Draw();
pt->Draw();
// Minus bin
RooPlot* dtFrameB = dt.frame();
// B0
out.str("");
out << "tag == 1 && bin == " << -_bin;
cout << out.str() << endl;
RooDataSet* ds2 = d.reduce(out.str().c_str());
ds2->Print();
ds2->plotOn(dtFrameB,DataError(RooAbsData::SumW2),MarkerSize(1),MarkerColor(kBlue));
bintag = "{binb;B0}";
pdf.plotOn(dtFrameB,ProjWData(RooArgSet(),*ds2),Slice(bintag),LineColor(kBlue));
chi2 = dtFrameB->chiSquare();
//anti-B0
out.str("");
out << "tag == -1 && bin == " << -_bin;
cout << out.str() << endl;
RooDataSet* dsb2 = d.reduce(out.str().c_str());
dsb2->Print();
dsb2->plotOn(dtFrameB,DataError(RooAbsData::SumW2),MarkerSize(1),MarkerColor(kRed));
bintag = "{binb;anti-B0}";
pdf.plotOn(dtFrameB,ProjWData(RooArgSet(),*dsb2),Slice(bintag),LineColor(kRed));
chi2b = dtFrameB->chiSquare();
//Canvas
out.str("");
out << "#Delta t, toy MC, bin == " << -_bin;
TCanvas* cm2 = new TCanvas(out.str().c_str(),out.str().c_str(),600,400);
cm2->cd();
dtFrameB->GetXaxis()->SetTitleSize(0.05);
dtFrameB->GetXaxis()->SetTitleOffset(0.85);
dtFrameB->GetXaxis()->SetLabelSize(0.05);
dtFrameB->GetYaxis()->SetTitleOffset(1.6);
TPaveText *ptB = new TPaveText(0.7,0.65,0.98,0.99,"brNDC");
ptB->SetFillColor(0);
ptB->SetTextAlign(12);
out.str("");
out << "bin = " << -_bin;
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(B^{0}) = " << chi2;
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(#barB^{0}) = " << chi2b;
ptB->AddText(out.str().c_str());
out.str("");
out << "#sigma/#tau = " << sigma.getVal()/tau.getVal();
ptB->AddText(out.str().c_str());
out.str("");
out << "purity = " << _purity;
ptB->AddText(out.str().c_str());
out.str("");
out << "mistag = " << mistag_rate;
ptB->AddText(out.str().c_str());
dtFrameB->Draw();
ptB->Draw();
return;
}
///
/// Perform 1d Prob scan.
///
/// - Scan range defined through limit "scan".
/// - Will fill the hCL histogram with the 1-CL curve.
/// - Start at a scan value that is in the middle of the allowed
/// range, preferably a solution, and scan up and down from there.
/// - use the "probforce" command line flag to enable force minimum finding
///
/// \param fast This will scan each scanpoint only once.
/// \param reverse This will scan in reverse direction.
/// When using the drag mode, this can sometimes make a difference.
/// \return status: 2 = new global minimum found, 1 = error
///
int MethodProbScan::scan1d(bool fast, bool reverse)
{
if ( arg->debug ) cout << "MethodProbScan::scan1d() : starting ... " << endl;
nScansDone++;
// The "improve" method doesn't need multiple scans.
if ( arg->probforce || arg->probimprove ) fast = true;
if ( arg->probforce ) scanDisableDragMode = true;
// Save parameter values that were active at function call.
if ( startPars ) delete startPars;
startPars = new RooDataSet("startPars", "startPars", *w->set(parsName));
startPars->add(*w->set(parsName));
// // start scan from global minimum (not always a good idea as we need to set from other places as well)
// setParameters(w, parsName, globalMin);
// load scan parameter and scan range
setLimit(w, scanVar1, "scan");
RooRealVar *par = w->var(scanVar1);
assert(par);
float min = hCL->GetXaxis()->GetXmin();
float max = hCL->GetXaxis()->GetXmax();
if ( fabs(par->getMin()-min)>1e-6 || fabs(par->getMax()-max)>1e-6 ){
cout << "MethodProbScan::scan1d() : WARNING : Scan range was changed after initScan()" << endl;
cout << " was called so the old range will be used." << endl;
}
if ( arg->verbose ){
cout << "\nProb configuration:" << endl;
cout << " combination : " << title << endl;
cout << " scan variable : " << scanVar1 << endl;
cout << " scan range : " << min << " ... " << max << endl;
cout << " scan steps : " << nPoints1d << endl;
cout << " fast mode : " << fast << endl;
cout << endl;
}
// Set limit to all parameters.
combiner->loadParameterLimits();
// fix scan parameter
par->setConstant(true);
// j =
// 0 : start value -> upper limit
// 1 : upper limit -> start value
// 2 : start value -> lower limit
// 3 : lower limit -> start value
float startValue = par->getVal();
bool scanUp;
// for the status bar
float nTotalSteps = nPoints1d;
nTotalSteps *= fast ? 1 : 2;
float nStep = 0;
float printFreq = nTotalSteps>15 ? 10 : nTotalSteps;
// Report on the smallest new minimum we come across while scanning.
// Sometimes the scan doesn't find the minimum
// that was found before. Warn if this happens.
double bestMinOld = chi2minGlobal;
double bestMinFoundInScan = 100.;
for ( int jj=0; jj<4; jj++ )
{
int j = jj;
if ( reverse ) switch(jj)
{
case 0: j = 2; break;
case 1: j = 3; break;
case 2: j = 0; break;
case 3: j = 1; break;
}
float scanStart, scanStop;
switch(j)
{
case 0:
// UP
setParameters(w, parsName, startPars->get(0));
scanStart = startValue;
scanStop = par->getMax();
scanUp = true;
break;
case 1:
// DOWN
scanStart = par->getMax();
scanStop = startValue;
scanUp = false;
break;
case 2:
// DOWN
setParameters(w, parsName, startPars->get(0));
scanStart = startValue;
scanStop = par->getMin();
scanUp = false;
break;
case 3:
// UP
scanStart = par->getMin();
scanStop = startValue;
scanUp = true;
break;
}
if ( fast && ( j==1 || j==3 ) ) continue;
for ( int i=0; i<nPoints1d; i++ )
{
float scanvalue;
if ( scanUp )
{
scanvalue = min + (max-min)*(double)i/(double)nPoints1d + hCL->GetBinWidth(1)/2.;
if ( scanvalue < scanStart ) continue;
if ( scanvalue > scanStop ) break;
}
else
{
scanvalue = max - (max-min)*(double)(i+1)/(double)nPoints1d + hCL->GetBinWidth(1)/2.;
if ( scanvalue > scanStart ) continue;
if ( scanvalue < scanStop ) break;
}
// disable drag mode
// (the improve method doesn't work with drag mode as parameter run
// at their limits)
if ( scanDisableDragMode ) setParameters(w, parsName, startPars->get(0));
// set the parameter of interest to the scan point
par->setVal(scanvalue);
// don't scan in unphysical region
if ( scanvalue < par->getMin() || scanvalue > par->getMax() ) continue;
// status bar
if ( (((int)nStep % (int)(nTotalSteps/printFreq)) == 0))
cout << "MethodProbScan::scan1d() : scanning " << (float)nStep/(float)nTotalSteps*100. << "% \r" << flush;
// fit!
RooFitResult *fr = 0;
if ( arg->probforce ) fr = fitToMinForce(w, combiner->getPdfName());
else if ( arg->probimprove ) fr = fitToMinImprove(w, combiner->getPdfName());
else fr = fitToMinBringBackAngles(w->pdf(pdfName), false, -1);
double chi2minScan = fr->minNll();
if ( std::isinf(chi2minScan) ) chi2minScan=1e4; // else the toys in PDF_testConstraint don't work
RooSlimFitResult *r = new RooSlimFitResult(fr); // try to save memory by using the slim fit result
delete fr;
allResults.push_back(r);
bestMinFoundInScan = TMath::Min((double)chi2minScan, (double)bestMinFoundInScan);
TString warningChi2Neg;
if ( chi2minScan < 0 ){
float newChi2minScan = chi2minGlobal + 25.; // 5sigma more than best point
warningChi2Neg = "MethodProbScan::scan1d() : WARNING : " + title;
warningChi2Neg += TString(Form(" chi2 negative for scan point %i: %f",i,chi2minScan));
warningChi2Neg += " setting to: " + TString(Form("%f",newChi2minScan));
//cout << warningChi2Neg << "\r" << flush;
cout << warningChi2Neg << endl;
chi2minScan = newChi2minScan;
}
// If we find a minimum smaller than the old "global" minimum, this means that all
// previous 1-CL values are too high.
if ( chi2minScan<chi2minGlobal ){
if ( arg->verbose ) cout << "MethodProbScan::scan1d() : WARNING : '" << title << "' new global minimum found! "
<< " chi2minScan=" << chi2minScan << endl;
chi2minGlobal = chi2minScan;
// recompute previous 1-CL values
for ( int k=1; k<=hCL->GetNbinsX(); k++ ){
hCL->SetBinContent(k, TMath::Prob(hChi2min->GetBinContent(k)-chi2minGlobal, 1));
}
}
double deltaChi2 = chi2minScan - chi2minGlobal;
double oneMinusCL = TMath::Prob(deltaChi2, 1);
// Save the 1-CL value and the corresponding fit result.
// But only if better than before!
if ( hCL->GetBinContent(hCL->FindBin(scanvalue)) <= oneMinusCL ){
hCL->SetBinContent(hCL->FindBin(scanvalue), oneMinusCL);
hChi2min->SetBinContent(hCL->FindBin(scanvalue), chi2minScan);
int iRes = hCL->FindBin(scanvalue)-1;
curveResults[iRes] = r;
}
nStep++;
}
}
cout << "MethodProbScan::scan1d() : scan done. " << endl;
if ( bestMinFoundInScan-bestMinOld > 0.01 ){
cout << "MethodProbScan::scan1d() : WARNING: Scan didn't find similar minimum to what was found before!" << endl;
cout << "MethodProbScan::scan1d() : Too strict parameter limits? Too coarse scan steps? Didn't load global minimum?" << endl;
cout << "MethodProbScan::scan1d() : chi2 bestMinFoundInScan=" << bestMinFoundInScan << ", bestMinOld=" << bestMinOld << endl;
}
// attempt to correct for undercoverage
if (pvalueCorrectorSet) {
for ( int k=1; k<=hCL->GetNbinsX(); k++ ){
double pvalueProb = hCL->GetBinContent(k);
pvalueProb = pvalueCorrector->transform(pvalueProb);
hCL->SetBinContent(k, pvalueProb);
}
}
setParameters(w, parsName, startPars->get(0));
saveSolutions();
if (arg->confirmsols) confirmSolutions();
if ( (bestMinFoundInScan-bestMinOld)/bestMinOld > 0.01 ) return 1;
return 0;
}
void generateSigHist_for_combineMaker(Float_t lum =10, Int_t cc1 = 0, Int_t cc2 = 9) {
const Int_t NCAT(4); // 4 categories in the source file
TString myCut[NCAT] = {"EBHighR9","EBLowR9","EEHighR9","EELowR9"};
//Float_t lum =10;
TString lum_string = TString::Format("%g", lum);
TFile *file=TFile::Open("workspaces/HighMassGG_m1500_01_mgg_lum_"+lum_string+".root");
RooWorkspace *w_all = (RooWorkspace*)file->Get("w_all");
RooRealVar *mgg = (RooRealVar*)w_all->var("mgg");
RooRealVar *MH = (RooRealVar*)w_all->var("MH");
RooRealVar *kpl = (RooRealVar*)w_all->var("kpl");
RooNumConvPdf* numConv[NCAT];
RooFormulaVar* norm[NCAT];
// necessary to set a window as it is not saved when RooNumConvPdf is saved
RooRealVar* W = new RooRealVar("W","W",500);
W->setConstant();
RooRealVar* C = new RooRealVar("C","C",0);
C->setConstant();
cout << "READ PDFs FROM WORKSPACE : SIGNAL FROM 4 CATEGORIES" << endl;
cout << "READ ROOFORMULAs FROM WORKSPACE : NORMALIZATION OF 4 CATEGORIES" << endl;
cout << "SET WINDOW FOR THE 4 CONVOLUTIONS (PDFs)" << endl;
cout << "..." << endl;
for(Int_t c = 0; c<NCAT; c++) {
numConv[c] = (RooNumConvPdf*)w_all->pdf("mggSig_cat"+myCut[c]);
norm[c] = (RooFormulaVar*)w_all->function("mggSig_cat"+myCut[c]+"_norm");
numConv[c]->setConvolutionWindow(*C,*W);
}
cout << endl;
cout << "ADD PDFs TO FORM THE TWO CATEGORIES EBEB AND EBEE" << endl;
RooFormulaVar *mggSig_catEBEB_norm = new RooFormulaVar("mggSig_catEBEB_norm","mggSig_catEBEB_norm","@0+@1",RooArgList(*norm[0],*norm[1]));
RooFormulaVar *mggSig_catEBEE_norm = new RooFormulaVar("mggSig_catEBEE_norm","mggSig_catEBEE_norm","@0+@1",RooArgList(*norm[2],*norm[3]));
RooFormulaVar *frac1EBEB = new RooFormulaVar("frac1EBEB","frac1EBEB","@0/@1",RooArgList(*norm[0],*mggSig_catEBEB_norm));
RooFormulaVar *frac2EBEB = new RooFormulaVar("frac2EBEB","frac2EBEB","@0/@1",RooArgList(*norm[1],*mggSig_catEBEB_norm));
RooFormulaVar *frac1EBEE = new RooFormulaVar("frac1EBEE","frac1EBE","@0/@1",RooArgList(*norm[2],*mggSig_catEBEE_norm));
RooFormulaVar *frac2EBEE = new RooFormulaVar("frac2EBEE","frac2EBEE","@0/@1",RooArgList(*norm[3],*mggSig_catEBEE_norm));
RooAddPdf* mggSig_catEBEB = new RooAddPdf("mggSig_catEBEB","mggSig_catEBEB",RooArgList(*numConv[0],*numConv[1]),RooArgList(*frac1EBEB,*frac2EBEB));
RooAddPdf* mggSig_catEBEE = new RooAddPdf("mggSig_catEBEE","mggSig_catEBEE",RooArgList(*numConv[2],*numConv[3]),RooArgList(*frac1EBEE,*frac2EBEE));
cout << endl << endl ;
cout << "READ CFG FROM BACKGROUND_FINAL TO BE USED IN COMBINE_MAKER.PY" << endl;
TFile *fcfg = TFile::Open("../../Analysis/macros/workspace_cic2_dijet_lum_10/full_analysis_anv1_v18_bkg_ws_300.root");
TObjString *cfg = (TObjString*)fcfg->Get("cfg");
const Int_t nCouplings(9);
Double_t couplings[nCouplings] = {0.01, 0.025, 0.05, 0.075, 0.1, 0.125, 0.15, 0.175, 0.2};
cout << endl << endl ;
cout << "SCAN OVER MH AND KAPPA VALUES TO GET DIFFERENT PDFs FOR EACH SET OF PARAMETERS..." << endl;
for(Int_t icoupling = cc1; icoupling < cc2; icoupling++) {
//CREATE FOLDER FOR THE COUPLING
TString coupling_string = TString::Format("%g",couplings[icoupling]);
coupling_string.ReplaceAll(".","");
TString inDir("../../Analysis/macros/workspace_cic2_signalDataHist_lum_"+lum_string+"/");
gSystem->mkdir(inDir);
for(Int_t mass = 1000; mass < 5100 ; mass+=100) {
TString mass_string = TString::Format("%d",mass);
TString signame("grav_"+coupling_string+"_"+mass_string);
cout << endl;
cout << "********************************************" << endl;
cout << "SET MH and KAPPA values" << endl << "kappa: " << couplings[icoupling] << endl << "mass: " << mass << endl;
cout << "********************************************" << endl;
MH->setVal(mass);
kpl->setVal(couplings[icoupling]);
cout << "CREATE ROODATAHIST WITH NORM..." << endl;
RooDataHist* dhEBEB = mggSig_catEBEB->generateBinned(RooArgSet(*mgg),mggSig_catEBEB_norm->getVal(), RooFit::ExpectedData());
RooDataHist* dhEBEE = mggSig_catEBEE->generateBinned(RooArgSet(*mgg),mggSig_catEBEE_norm->getVal(), RooFit::ExpectedData());
dhEBEB->SetName("signal_"+signame+"_EBEB");
dhEBEB->SetTitle("signal_"+signame+"_EBEB");
dhEBEE->SetName("signal_"+signame+"_EBEE");
dhEBEE->SetTitle("signal_"+signame+"_EBEE");
//CREATE ROOHISTPDF
//RooHistPdf *fhEBEB = new RooHistPdf("mggHistPdf_catEBEB","mggHistPdf_catEBEB",RooArgSet(*mgg),*dhEBEB);
//RooHistPdf *fhEBEE = new RooHistPdf("mggHistPdf_catEBEE","mggHistPdf_catEBEE",RooArgSet(*mgg),*dhEBEE);
//SAVE ALL IN A WORKSPACE WITH FILE NAME corresponding to MASS AND COUPLING VALUE
RooWorkspace *wtemplates = new RooWorkspace("wtemplates","wtemplates");
//wtemplates->import(*fhEBEB);
//wtemplates->import(*fhEBEE);
//wtemplates->import(*mggSig_catEBEB_norm,RecycleConflictNodes());
//wtemplates->import(*mggSig_catEBEE_norm,RecycleConflictNodes());
wtemplates->import(*dhEBEB);
wtemplates->import(*dhEBEE);
//wtemplates->import(*numConv[0],RecycleConflictNodes());
cout << "******************************************" << endl;
cout << "WORKSPACE CONTENT FOR COUPLING " << couplings[icoupling] << " AND MASS " << mass << endl;
wtemplates->Print("V");
//WRITE IN FILE
TString filename = inDir+"300_"+signame+".root";
TFile *fileOutput = TFile::Open(filename,"recreate");
cfg->Write("cfg");
wtemplates->Write("wtemplates");
cout << "workspace imported to " << filename << endl;
}
}
}
void hggfitmceerr(double nommass=123., double tgtr=1., int ijob=0) {
//gSystem->cd("/scratch/bendavid/root/bare/fitplotsJun10test/");
int seed = 65539+ijob+1;
TString dirname = "/scratch/bendavid/root/bare/hggfiteerrtestall_large2/";
gSystem->mkdir(dirname,true);
gSystem->cd(dirname);
//nommass=150.;
// gSystem->cd("/scratch/bendavid/root/bare/fitplotsJun8_150_2x/");
gRandom->SetSeed(seed);
RooRandom::randomGenerator()->SetSeed(seed);
// TFile *fin = TFile::Open("/home/mingyang/cms/hist_approval/hgg-2013Moriond/merged/hgg-2013Moriond_s12-h150gg-gf-v7a_noskim.root");
// TDirectory *hdir = (TDirectory*)fin->FindObjectAny("PhotonTreeWriterPresel");
// TTree *htree = (TTree*)hdir->Get("hPhotonTree");
// TFile *fdin = TFile::Open("/home/mingyang/cms/hist/hgg-2013Moriond/merged/hgg-2013Moriond_r12_ABCD.root");
// TDirectory *ddir = (TDirectory*)fdin->FindObjectAny("PhotonTreeWriterPresel");
// TTree *dtree = (TTree*)ddir->Get("hPhotonTree");
//TCut selcut = "(ph1.pt > (mass/3.0) && ph2.pt > (mass/4.0) && mass>100. && mass<180. && ph1.idmva>-0.2 && ph2.idmva>-0.2)";
TCut selcut = "(ph1.pt > (mass/3.0) && ph2.pt > (mass/4.0) && mass>100. && mass<180. && ph1.idmva>-0.2 && ph2.idmva>-0.2)";
//TCut selweight = "xsecweight(procidx)*puweight(numPU,procidx)";
TCut selweight = "xsecweight(procidx)*mcweight*kfact(procidx,ph1.ispromptgen,ph2.ispromptgen)";
TCut sigFcut = "(procidx==0 || procidx==3)";
TCut sigVcut = "(procidx==1 || procidx==2)";
TCut bkgPPcut = "(procidx==4)";
TCut bkgPFcut = "(procidx==5 || procidx==6)";
TCut bkgFFcut = "(procidx==7 || procidx==8)";
TCut bkgcut = "(procidx>3)";
TCut bkgcutnoq = "(procidx>3 && procidx<7)";
TCut prescalenone = "(1==1)";
TCut evenevents = "(evt%2==0)";
TCut oddevents = "(evt%2==1)";
TCut prescale10 = "(evt%10==0)";
TCut prescale25 = "(evt%25==0)";
TCut prescale50 = "(evt%50==0)";
TCut prescale100 = "(evt%100==0)";
TCut fcut = prescale50;
float xsecs[50];
//TCut selcutsingle = "ph.pt>25. && ph.isbarrel && ph.ispromptgen";
//TCut selcutsingle = "ph.pt>25.&& ph.ispromptgen";
TCut selcutsingle = "ph.genpt>16.&& ph.ispromptgen";
TCut selweightsingle = "xsecweight(procidx)";
// TChain *tree = new TChain("RunLumiSelectionMod/MCProcessSelectionMod/HLTModP/GoodPVFilterMod/PhotonMvaMod/JetPub/JetCorrectionMod/SeparatePileUpMod/ElectronIDMod/MuonIDMod/PhotonPairSelectorPresel/PhotonTreeWriterPresel/hPhotonTreeSingle");
// tree->Add("/home/mingyang/cms/hist/hgg-2013Final8TeV/merged/hgg-2013Final8TeV_s12-diphoj-v7n_noskim.root");
TChain *tree = new TChain("RunLumiSelectionMod/MCProcessSelectionMod/HLTModP/GoodPVFilterMod/PhotonMvaMod/PhotonIDModPresel/PhotonTreeWriterSingle/hPhotonTreeSingle");
tree->Add("/home/mingyang/cms/hist/hgg-2013Final8TeV_reg_trans/merged/hgg-2013Final8TeV_reg_trans_s12-pj20_40-2em-v7n_noskim.root");
tree->Add("/home/mingyang/cms/hist/hgg-2013Final8TeV_reg_trans/merged/hgg-2013Final8TeV_reg_trans_s12-pj40-2em-v7n_noskim.root");
xsecs[0] = 0.001835*81930.0;
xsecs[1] = 0.05387*8884.0;
initweights(tree,xsecs,1.);
double weightscale = xsecweights[1];
xsecweights[0] /= weightscale;
xsecweights[1] /= weightscale;
tree->SetCacheSize(64*1024*1024);
RooRealVar energy("energy","ph.e",0);
RooRealVar sceta("sceta","ph.sceta",0.);
RooRealVar idmva("idmva","ph.idmva",0.,-1.,1.);
RooRealVar eerr("eerr","(ph.isbarrel + 0.5*!ph.isbarrel)*ph.eerr/ph.e",0.);
RooRealVar evt("evt","evt",0.);
RooArgList vars;
vars.add(energy);
vars.add(sceta);
//vars.add(idmva);
RooArgList condvars(vars);
vars.add(eerr);
RooArgList condvarsid(vars);
vars.add(idmva);
vars.add(evt);
// RooPowerLaw("testpow","",pt1,pt2);
// return;
// new TCanvas;
// tree->Draw("mass>>htmpall(80,100.,180.)",bkgcut*selcut*selweight,"HIST");
//
// new TCanvas;
// tree->Draw("mass>>htmpallid(80,100.,180.)",idcut*bkgcut*selcut*selweight,"HIST");
//
// new TCanvas;
// tree->Draw("mass>>htmp(80,100.,180.)",bkgcutnoq*selcut*selweight,"HIST");
// //
// return;
//RooRealVar weightvar("weightvar","(ph1.pt > (mass/3.0) && ph2.pt > (mass/4.0) && mass>100. && mass<180. && ph1.idmva>-0.2 && ph2.idmva>-0.2 && evt%100!=0)",1.);
RooRealVar weightvar("weightvar","",1.);
//RooRealVar weightvar("weightvar","(ph1.pt > (mass/3.0) && ph2.pt > (mass/4.0) && mass>100. && mass<180. && ph1.idmva>-0.2 && ph2.idmva>-0.2)",1.);
weightvar.SetTitle(selcutsingle*selweightsingle);
RooDataSet *hdataSingle = RooTreeConvert::CreateDataSet("hdataSingle",tree,vars,weightvar);
int ngauseerr = 4;
//int nparmseerr = 3*ngauseerr + 2;
//int nparmseerr = 3*ngauseerr + 2;
int nparmseerr = 5*ngauseerr;
RooArgList tgtseerr;
RooGBRFunction funceerr("funceerr","",condvars,nparmseerr);
int iparmeerr = 0;
RooArgList eerrgauspdfs;
RooArgList eerrgauscoeffs;
double stepeerr = 0.07/double(std::max(1,ngauseerr-1));
// RooRealVar *gmeanvar = new RooRealVar(TString::Format("gmeanvar_eerr_%i",0),"",0.007+stepeerr*0);
// RooRealVar *gsigmavar = new RooRealVar(TString::Format("gsigmavar_eerr_%i",0),"",0.01);
// // //RooRealVar *gsigmaRvar = new RooRealVar(TString::Format("gsigmaRvar_eerr_%i",0),"",0.02);
// //
// // //if (0==0) gmeanvar->setVal(0.007);
// //
// gmeanvar->setConstant(false);
// gsigmavar->setConstant(false);
// // //gsigmaRvar->setConstant(false);
// //
// //
// RooGBRTarget *gmean = new RooGBRTarget(TString::Format("gmean_eerr_%i",0),"",funceerr,iparmeerr++,*gmeanvar);
// RooGBRTarget *gsigma = new RooGBRTarget(TString::Format("gsigma_eerr_%i",0),"",funceerr,iparmeerr++,*gsigmavar);
// // //RooGBRTarget *gsigmaR = new RooGBRTarget(TString::Format("gsigmaR_eerr_%i",0),"",funceerr,iparmeerr++,*gsigmaRvar);
// //
// RooRealConstraint *gmeanlim = new RooRealConstraint(TString::Format("gmeanlim_eerr_%i",0),"",*gmean,0.,0.5);
// RooRealConstraint *gsigmalim = new RooRealConstraint(TString::Format("gsigmalim_eerr_%i",0),"",*gsigma,1e-7,0.5);
// //RooRealConstraint *gsigmaRlim = new RooRealConstraint(TString::Format("gsigmaRlim_eerr_%i",0),"",*gsigmaR,1e-7,0.2);
//
// tgtseerr.add(*gmean);
// tgtseerr.add(*gsigma);
for (int igaus=0; igaus<ngauseerr; ++igaus) {
RooRealVar *gmeanvar = new RooRealVar(TString::Format("gmeanvar_eerr_%i",igaus),"",0.007+stepeerr*igaus);
RooRealVar *gsigmavar = new RooRealVar(TString::Format("gsigmavar_eerr_%i",igaus),"",0.01);
RooRealVar *galphavar = new RooRealVar(TString::Format("galphavar_eerr_%i",igaus),"",1.0);
RooRealVar *gnvar = new RooRealVar(TString::Format("gnvar_eerr_%i",igaus),"",2.);
RooRealVar *gfracvar = new RooRealVar(TString::Format("gfracvar_eerr_%i",igaus),"",1.0);
//if (igaus==0) gmeanvar->setVal(0.007);
gmeanvar->setConstant(false);
gsigmavar->setConstant(false);
galphavar->setConstant(false);
gnvar->setConstant(false);
gfracvar->setConstant(false);
RooGBRTarget *gmean = new RooGBRTarget(TString::Format("gmean_eerr_%i",igaus),"",funceerr,iparmeerr++,*gmeanvar);
RooGBRTarget *gsigma = new RooGBRTarget(TString::Format("gsigma_eerr_%i",igaus),"",funceerr,iparmeerr++,*gsigmavar);
RooGBRTarget *galpha = new RooGBRTarget(TString::Format("galpha_eerr_%i",igaus),"",funceerr,iparmeerr++,*galphavar);
RooGBRTarget *gn = new RooGBRTarget(TString::Format("gn_eerr_%i",igaus),"",funceerr,iparmeerr++,*gnvar);
RooGBRTarget *gfrac = new RooGBRTarget(TString::Format("gfrac_eerr_%i",igaus),"",funceerr,iparmeerr++,*gfracvar);
RooRealConstraint *gmeanlim = new RooRealConstraint(TString::Format("gmeanlim_eerr_%i",igaus),"",*gmean,0.,0.5);
RooRealConstraint *gsigmalim = new RooRealConstraint(TString::Format("gsigmalim_eerr_%i",igaus),"",*gsigma,1e-5,0.1);
RooRealConstraint *galphalim = new RooRealConstraint(TString::Format("galphalim_eerr_%i",igaus),"",*galpha,0.05,8.);
RooRealConstraint *gnlim = new RooRealConstraint(TString::Format("gnlim_eerr_%i",igaus),"",*gn,1.01,5000.);
//RooRealConstraint *gfraclim = new RooRealConstraint(TString::Format("gfraclim_eerr_%i",igaus),"",*gfrac,0.,1.);
RooAbsReal *gfraclim = new RooProduct(TString::Format("gfraclim_eerr_%i",igaus),"",RooArgList(*gfrac,*gfrac));
if (igaus==0) {
gfraclim = new RooConstVar(TString::Format("gfraclimconst_eerr_%i",igaus),"",1.);
}
else {
tgtseerr.add(*gfrac);
}
//RooGaussianFast *gpdf = new RooGaussianFast(TString::Format("gdf_eerr_%i",igaus),"",eerr,*gmeanlim,*gsigmalim);
//RooBifurGauss *gpdf = new RooBifurGauss(TString::Format("gdf_eerr_%i",igaus),"",eerr,*gmeanlim,*gsigmalim,*galphalim);
if (igaus==0) {
RooRevCBFast *gpdf = new RooRevCBFast(TString::Format("gdf_eerr_%i",igaus),"",eerr,*gmeanlim,*gsigmalim,*galphalim, *gnlim);
tgtseerr.add(*gmean);
tgtseerr.add(*gsigma);
tgtseerr.add(*galpha);
tgtseerr.add(*gn);
eerrgauspdfs.add(*gpdf);
}
else {
RooGaussianFast *gpdf = new RooGaussianFast(TString::Format("gdf_eerr_%i",igaus),"",eerr,*gmeanlim,*gsigmalim);
tgtseerr.add(*gmean);
tgtseerr.add(*gsigma);
eerrgauspdfs.add(*gpdf);
}
eerrgauscoeffs.add(*gfraclim);
}
RooCondAddPdf eerrpdf("eerrpdf","",eerrgauspdfs,eerrgauscoeffs);
RooAbsPdf *pdf0 = static_cast<RooAbsPdf*>(eerrgauspdfs.at(0));
int ngaus = 6;
int nparms = 4*ngaus;
RooArgList tgtsid;
RooGBRFunction funcid("funcid","",condvarsid,nparms);
RooArgList gauspdfs;
RooArgList gauscoeffs;
double step = 0.5/double(std::max(1,ngaus-1));
int iparm = 0;
for (int igaus=0; igaus<ngaus; ++igaus) {
RooRealVar *gmeanvar = new RooRealVar(TString::Format("gmeanvar_%i",igaus),"",-0.2+step*igaus);
RooRealVar *gsigmavar = new RooRealVar(TString::Format("gsigmavar_%i",igaus),"",0.1);
RooRealVar *gsigmaRvar = new RooRealVar(TString::Format("gsigmaRvar_%i",igaus),"",0.1);
RooRealVar *gfracvar = new RooRealVar(TString::Format("gfracvar_%i",igaus),"",1.0);
gmeanvar->setConstant(false);
gsigmavar->setConstant(false);
gsigmaRvar->setConstant(false);
gfracvar->setConstant(false);
RooGBRTarget *gmean = new RooGBRTarget(TString::Format("gmean_%i",igaus),"",funcid,iparm++,*gmeanvar);
RooGBRTarget *gsigma = new RooGBRTarget(TString::Format("gsigma_%i",igaus),"",funcid,iparm++,*gsigmavar);
RooGBRTarget *gsigmaR = new RooGBRTarget(TString::Format("gsigmaR_%i",igaus),"",funcid,iparm++,*gsigmaRvar);
RooGBRTarget *gfrac = new RooGBRTarget(TString::Format("gfrac_%i",igaus),"",funcid,iparm++,*gfracvar);
RooRealConstraint *gmeanlim = new RooRealConstraint(TString::Format("gmeanlim_%i",igaus),"",*gmean,-1.,1.);
RooRealConstraint *gsigmalim = new RooRealConstraint(TString::Format("gsigmalim_%i",igaus),"",*gsigma,1e-4,2.);
RooRealConstraint *gsigmaRlim = new RooRealConstraint(TString::Format("gsigmaRlim_%i",igaus),"",*gsigmaR,1e-4,2.);
//RooRealConstraint *gfraclim = new RooRealConstraint(TString::Format("gfraclim_%i",igaus),"",*gfrac,0.,1.);
RooAbsReal *gfraclim = new RooProduct(TString::Format("gfraclim_%i",igaus),"",RooArgList(*gfrac,*gfrac));
if (igaus==0) {
gfraclim = new RooConstVar(TString::Format("gfraclimconst_%i",igaus),"",1.);
}
else {
tgtsid.add(*gfrac);
}
RooGaussianFast *gpdf = new RooGaussianFast(TString::Format("gdf_%i",igaus),"",idmva,*gmeanlim,*gsigmalim);
//RooBifurGauss *gpdf = new RooBifurGauss(TString::Format("gdf_%i",igaus),"",idmva,*gmeanlim,*gsigmalim,*gsigmaRlim);
gauspdfs.add(*gpdf);
gauscoeffs.add(*gfraclim);
tgtsid.add(*gmean);
tgtsid.add(*gsigma);
//tgtsid.add(*gsigmaR);
//tgtsid.add(*gfrac);
}
RooCondAddPdf idpdf("idpdf","",gauspdfs,gauscoeffs);
RooConstVar etermconst("etermconst","",0.);
RooAbsReal &eterm = etermconst;
RooRealVar dummy("dummy","",1.0);
std::vector<RooAbsData*> vdata;
vdata.push_back(hdataSingle);
std::vector<RooAbsReal*> vpdf;
vpdf.push_back(&eerrpdf);
//vpdf.push_back(pdf0);
std::vector<RooAbsReal*> vpdfid;
vpdfid.push_back(&idpdf);
RooHybridBDTAutoPdf bdtpdf("bdtpdf","",funceerr,tgtseerr,eterm,dummy,vdata,vpdf);
bdtpdf.SetPrescaleInit(100);
bdtpdf.SetMinCutSignificance(5.0);
bdtpdf.SetShrinkage(0.1);
bdtpdf.SetMinWeightTotal(200.);
bdtpdf.SetMaxNodes(200);
bdtpdf.TrainForest(1e6);
RooHybridBDTAutoPdf bdtpdfid("bdtpdfid","",funcid,tgtsid,eterm,dummy,vdata,vpdfid);
bdtpdfid.SetPrescaleInit(100);
bdtpdfid.SetMinCutSignificance(5.0);
bdtpdfid.SetShrinkage(0.1);
bdtpdfid.SetMinWeightTotal(200.);
bdtpdfid.SetMaxNodes(200);
bdtpdfid.TrainForest(1e6);
RooAbsReal *finalcdferr = eerrpdf.createCDF(eerr);
RooFormulaVar transerr("transerr","","sqrt(2.)*TMath::ErfInverse(2.*@0-1.)",*finalcdferr);
RooAbsReal *finalcdfid = idpdf.createCDF(idmva);
RooFormulaVar transid("transid","","sqrt(2.)*TMath::ErfInverse(2.*@0-1.)",*finalcdfid);
RooWorkspace *wsout = new RooWorkspace("wsfiteerr");
wsout->import(*hdataSingle);
wsout->import(eerrpdf,RecycleConflictNodes());
wsout->import(idpdf,RecycleConflictNodes());
// wsout->import(transerr,RecycleConflictNodes());
// wsout->import(transid,RecycleConflictNodes());
wsout->defineSet("datavars",vars,true);
wsout->writeToFile("hggfiteerr.root");
RooRealVar *cdfidvar = (RooRealVar*)hdataSingle->addColumn(*finalcdfid);
RooRealVar *transidvar = (RooRealVar*)hdataSingle->addColumn(transid);
RooGaussianFast unormpdfid("unormpdfid","",*transidvar,RooConst(0.),RooConst(1.));
RooRealVar *cdferrvar = (RooRealVar*)hdataSingle->addColumn(*finalcdferr);
RooRealVar *transerrvar = (RooRealVar*)hdataSingle->addColumn(transerr);
RooGaussianFast unormpdferr("unormpdferr","",*transerrvar,RooConst(0.),RooConst(1.));
//RooDataSet *testdata = (RooDataSet*)hdataSingle->reduce("abs(sceta)>1.3 && abs(sceta)<1.4");
RooDataSet *testdata = hdataSingle;
new TCanvas;
RooPlot *eerrplot = eerr.frame(0.,0.1,200);
testdata->plotOn(eerrplot);
eerrpdf.plotOn(eerrplot,ProjWData(*testdata));
eerrplot->Draw();
new TCanvas;
RooPlot *transplot = transerrvar->frame(-5.,5.,100);
hdataSingle->plotOn(transplot);
unormpdferr.plotOn(transplot);
transplot->Draw();
//return;
new TCanvas;
RooPlot *cdfploterr = cdferrvar->frame(0.,1.,100);
hdataSingle->plotOn(cdfploterr);
//unormpdf.plotOn(transplot);
cdfploterr->Draw();
//return;
new TCanvas;
RooPlot *idplot = idmva.frame(-1.,1.,200);
testdata->plotOn(idplot);
idpdf.plotOn(idplot,ProjWData(*testdata));
idplot->Draw();
new TCanvas;
RooPlot *transplotid = transidvar->frame(-5.,5.,100);
testdata->plotOn(transplotid);
unormpdfid.plotOn(transplotid);
transplotid->Draw();
//return;
new TCanvas;
RooPlot *cdfplotid = cdfidvar->frame(0.,1.,100);
testdata->plotOn(cdfplotid);
//unormpdf.plotOn(transplot);
cdfplotid->Draw();
//return;
TH1 *herrid = testdata->createHistogram("herrid",eerr,Binning(30,0.,0.1), YVar(idmva,Binning(30,-0.5,0.6)));
TH1 *herre = testdata->createHistogram("herre",energy,Binning(30,0.,200.), YVar(eerr,Binning(30,0.,0.1)));
TH1 *hideta = testdata->createHistogram("hideta",sceta,Binning(40,-2.5,2.5), YVar(idmva,Binning(30,-0.5,0.6)));
TH1 *herridtrans = testdata->createHistogram("herridtrans",*transerrvar,Binning(30,-5.,5.), YVar(*transidvar,Binning(30,-5.,5.)));
TH1 *herrtranse = testdata->createHistogram("herrtranse",energy,Binning(30,0.,200.), YVar(*transerrvar,Binning(30,-5.,5.)));
TH1 *hidtranseta = testdata->createHistogram("hidtranseta",sceta,Binning(40,-2.5,2.5), YVar(*transidvar,Binning(30,-5.,5.)));
new TCanvas;
herrid->Draw("COLZ");
new TCanvas;
herre->Draw("COLZ");
new TCanvas;
hideta->Draw("COLZ");
new TCanvas;
herridtrans->Draw("COLZ");
new TCanvas;
herrtranse->Draw("COLZ");
new TCanvas;
hidtranseta->Draw("COLZ");
// new TCanvas;
// RooRealVar *meanvar = (RooRealVar*)hdataSingle->addColumn(eerrmeanlim);
// RooPlot *meanplot = meanvar->frame(0.,0.1,200);
// hdataSingle->plotOn(meanplot);
// meanplot->Draw();
return;
}
void fitMass1(int iCharge,double iEtaMin,double iEtaMax,double iPhiMin,double iPhiMax,double &iRes,double &iShift,double &iResErr,double &iShiftErr) {
Prep();
RooRealVar l1Sigma("sigma1","sigma1",1.7 ,0.,15.); //l1Sigma.setConstant(kTRUE);
RooRealVar l2Sigma("sigma2","sigma2",1.15,0.,15.); l2Sigma.setConstant(kTRUE);
RooRealVar l3Sigma("sigma3","sigma3",2.8,0.,35.); l3Sigma.setConstant(kTRUE);
RooRealVar lN ("n" ,"n" ,1.5,-15,15.); lN.setConstant(kTRUE);
RooRealVar lExp ("exp" ,"exp" ,-0.003,-15,15.); //lExp.setConstant(kTRUE);
RooRealVar lR1Mean("mean","mean",90.8,60,150); //lR1Mean.setConstant(kTRUE);
RooRealVar lRXVar("XVar","mass(GeV/c^{2})",90,60,120); //lRXVar.setBins(500);
RooRealVar lRYield("Yield","mass(GeV/c^{2})",10000,0,20000);
RooVoigtianShape lGAdd("Add","Add",lRXVar,lR1Mean,l1Sigma,l2Sigma,lN,l3Sigma,true);
//RooExtendPdf lGEx("Ex","Ex",lGAdd,lRYield);
//RooAddPdf lGAdd("XAdd","XAdd",lGAdd1,lExpF,lCFrac);
RooDataSet *lData = new RooDataSet("crap" ,"crap",RooArgSet(lRXVar));
RooDataSet *lXData = new RooDataSet("xcrap","xcrap",RooArgSet(lRXVar));
RooDataSet *lYData = new RooDataSet("ycrap","ycrap",RooArgSet(lRXVar));
TFile *lFile = new TFile("../Efficiency/Data/mTPNT8_v1.root");//G39TP.root");
//TFile *lFile = new TFile("../Efficiency/Data/ZTP8_v2.root");//G39TP.root");
TTree *lTree = (TTree*) lFile->FindObjectAny("WNtupleIdEffNT");
float lMt = 0; lTree->SetBranchAddress("mt" ,&lMt);
int lCharge = 0; lTree->SetBranchAddress("charge",&lCharge);
float lEta = 0; lTree->SetBranchAddress("eta" ,&lEta);
float lPhi = 0; lTree->SetBranchAddress("phi" ,&lPhi);
float lPt = 0; lTree->SetBranchAddress("pt" ,&lPt);
float lOPt = 0; lTree->SetBranchAddress("jetpt" ,&lOPt);
float lOPhi = 0; lTree->SetBranchAddress("jetphi",&lOPhi);
float lOEta = 0; lTree->SetBranchAddress("jeteta",&lOEta);
float lTrkIso = 0; lTree->SetBranchAddress("trkiso",&lTrkIso);
float lEcalIso = 0; lTree->SetBranchAddress("ecaliso",&lEcalIso);
float lHcalIso = 0; lTree->SetBranchAddress("hcaliso",&lHcalIso);
float lChi2 = 0; lTree->SetBranchAddress("chi2" ,&lChi2);
int lNHit = 0; lTree->SetBranchAddress("nhit" ,&lNHit);
Muon lMuon; lTree->SetBranchAddress("muon" ,&lMuon);
for(int i0 = 0; i0 < lTree->GetEntries();i0++) {
if(i0 > 200000) break;
lTree->GetEntry(i0);
if(fabs(lPt) < 25 || fabs(lOPt) < 25) continue;
if(lMt < 60) continue;
if(lChi2 > 10) continue;
if(lNHit < 10) continue;
if(lMuon.NSeg < 2) continue;
if(lMuon.NPixel == 0) continue;
if(lMuon.NValid == 0) continue;
if(lMuon.Type != 3) continue;
if((lTrkIso+lEcalIso+lHcalIso)/lPt > 0.15) continue;
if(lCharge > 0 && iCharge < 0) continue;
if(lCharge < 0 && iCharge > 0) continue;
//if(lEta < iEtaMin || lEta > iEtaMax) continue;
if(lPhi < iPhiMin || lPhi > iPhiMax) continue;
//if(lEta < iPhiMin || lEta > iPhiMax) continue;
if(lCharge > 0) lRXVar.setVal(correct(lMt,lPhi,lOPhi,lEta,lOEta));
if(lCharge < 0) lRXVar.setVal(correct(lMt,lOPhi,lPhi,lOEta,lEta));
//cout << "====> " << lMt << " ---> " << lRXVar.getVal() << " --- " << endl;
//lXData->add(RooArgSet(lRXVar));
//lRXVar.setVal(fabs(lMt));
lYData->add(RooArgSet(lRXVar));
}
/*
RooHistPdf *lMYPdf = new RooHistPdf ("MY","MY",RooArgList(lRXVar),*lYData->binnedClone());
TFile *lQFile = new TFile("../Efficiency/Data/mTPNT8_v1.root");//G39TP.root");
TTree *lQTree = (TTree*) lQFile->FindObjectAny("WNtupleIdEffNT");
lQTree->SetBranchAddress("mt" ,&lMt);
lQTree->SetBranchAddress("charge",&lCharge);
lQTree->SetBranchAddress("eta" ,&lEta);
lQTree->SetBranchAddress("phi" ,&lPhi);
lQTree->SetBranchAddress("pt" ,&lPt);
lQTree->SetBranchAddress("jetpt" ,&lOPt);
lQTree->SetBranchAddress("jetphi",&lOPhi);
lQTree->SetBranchAddress("jeteta",&lOEta);
for(int i0 = 0; i0 < lQTree->GetEntries();i0++) {
lQTree->GetEntry(i0);
//if(lOPt*lPt < 0) continue;
if(lMt < 60) continue;
// if(lCharge > 0 && iCharge < 0) continue;
//if(lCharge < 0 && iCharge > 0) continue;
//if(lEta < iEtaMin || lEta > iEtaMax) continue;
//if(lPhi < iPhiMin || lPhi > iPhiMax) continue;
if(lCharge > 0) lRXVar.setVal(correct(lMt,lPhi,lOPhi,lEta,lOEta));
if(lCharge < 0) lRXVar.setVal(correct(lMt,lOPhi,lPhi,lOEta,lEta));
lXData->add(RooArgSet(lRXVar));
lRXVar.setVal(lMt);
lData->add(RooArgSet(lRXVar));
}
RooHistPdf *lMPdf = new RooHistPdf ("MH","MH",RooArgList(lRXVar),*lXData->binnedClone());
*/
lGAdd.fitTo(*lYData,Strategy(1),Minos());
if(lR1Mean.getError() < 0.01) lGAdd.fitTo(*lYData,Strategy(2),Minos());
lRXVar.setBins(60);
iShift = 1./(lR1Mean.getVal()/91.2); iShiftErr = lR1Mean.getError()*91.2/lR1Mean.getVal()/lR1Mean.getVal();
iRes = l1Sigma.getVal(); iResErr = l1Sigma.getError();
return;
TH1F *lH0 = new TH1F("A","A",1,-5,5); lH0->SetMarkerStyle(21);
TH1F *lH1 = new TH1F("B","B",1,-5,5); lH1->SetLineColor(kRed);
TH1F *lH2 = new TH1F("C","C",1,-5,5); lH2->SetLineColor(kBlue);
TLegend *lL = new TLegend(0.5,0.5,0.8,0.8); lL->SetFillColor(0); lL->SetBorderSize(0);
lL->AddEntry(lH0,"data" ,"lp");
lL->AddEntry(lH1,"MC-corrected" ,"l");
lL->AddEntry(lH2,"MC" ,"l");
RooPlot *lFrame1 = lRXVar.frame(RooFit::Title("XXX")) ;
lYData->plotOn(lFrame1);
lGAdd.plotOn(lFrame1);
//lXData->plotOn(lFrame1,MarkerColor(kRed));
//lMPdf->plotOn(lFrame1,LineColor(kRed));
//lMYPdf->plotOn(lFrame1,LineColor(kBlue));
TCanvas *iC =new TCanvas("A","A",800,600);
iC->cd(); lFrame1->Draw();
//lL->Draw();
iC->SaveAs("Crap.png");
//cin.get();
}
TH1D* runSig(RooWorkspace* ws,
const char* modelConfigName = "ModelConfig",
const char* dataName = "obsData",
const char* asimov1DataName = "asimovData_1",
const char* conditional1Snapshot = "conditionalGlobs_1",
const char* nominalSnapshot = "nominalGlobs")
{
string defaultMinimizer = "Minuit"; // or "Minuit"
int defaultStrategy = 2; // Minimization strategy. 0-2. 0 = fastest, least robust. 2 = slowest, most robust
double mu_profile_value = 1; // mu value to profile the obs data at wbefore generating the expected
bool doUncap = 1; // uncap p0
bool doInj = 0; // setup the poi for injection study (zero is faster if you're not)
bool doMedian = 1; // compute median significance
bool isBlind = 0; // Dont look at observed data
bool doConditional = !isBlind; // do conditional expected data
bool doObs = !isBlind; // compute observed significance
TStopwatch timer;
timer.Start();
if (!ws)
{
cout << "ERROR::Workspace is NULL!" << endl;
return NULL;
}
ModelConfig* mc = (ModelConfig*)ws->obj(modelConfigName);
if (!mc)
{
cout << "ERROR::ModelConfig: " << modelConfigName << " doesn't exist!" << endl;
return NULL;
}
RooDataSet* data = (RooDataSet*)ws->data(dataName);
if (!data)
{
cout << "ERROR::Dataset: " << dataName << " doesn't exist!" << endl;
return NULL;
}
mc->GetNuisanceParameters()->Print("v");
//RooNLLVar::SetIgnoreZeroEntries(1);
ROOT::Math::MinimizerOptions::SetDefaultMinimizer(defaultMinimizer.c_str());
ROOT::Math::MinimizerOptions::SetDefaultStrategy(defaultStrategy);
ROOT::Math::MinimizerOptions::SetDefaultPrintLevel(-1);
// cout << "Setting max function calls" << endl;
//ROOT::Math::MinimizerOptions::SetDefaultMaxFunctionCalls(20000);
//RooMinimizer::SetMaxFunctionCalls(10000);
ws->loadSnapshot("conditionalNuis_0");
RooArgSet nuis(*mc->GetNuisanceParameters());
RooRealVar* mu = (RooRealVar*)mc->GetParametersOfInterest()->first();
RooAbsPdf* pdf_temp = mc->GetPdf();
string condSnapshot(conditional1Snapshot);
RooArgSet nuis_tmp2 = *mc->GetNuisanceParameters();
RooNLLVar* obs_nll = doObs ? (RooNLLVar*)pdf_temp->createNLL(*data, Constrain(nuis_tmp2)) : NULL;
RooDataSet* asimovData1 = (RooDataSet*)ws->data(asimov1DataName);
if (!asimovData1)
{
cout << "Asimov data doesn't exist! Please, allow me to build one for you..." << endl;
string mu_str, mu_prof_str;
asimovData1 = makeAsimovData(mc, doConditional, ws, obs_nll, 1, &mu_str, &mu_prof_str, mu_profile_value, true);
condSnapshot="conditionalGlobs"+mu_prof_str;
//makeAsimovData(mc, true, ws, mc->GetPdf(), data, 0);
//ws->Print();
//asimovData1 = (RooDataSet*)ws->data("asimovData_1");
}
if (!doUncap) mu->setRange(0, 40);
else mu->setRange(-40, 40);
RooAbsPdf* pdf = mc->GetPdf();
RooArgSet nuis_tmp1 = *mc->GetNuisanceParameters();
RooNLLVar* asimov_nll = (RooNLLVar*)pdf->createNLL(*asimovData1, Constrain(nuis_tmp1));
//do asimov
mu->setVal(1);
mu->setConstant(0);
if (!doInj) mu->setConstant(1);
int status,sign;
double med_sig=0,obs_sig=0,asimov_q0=0,obs_q0=0;
if (doMedian)
{
ws->loadSnapshot(condSnapshot.c_str());
if (doInj) ws->loadSnapshot("conditionalNuis_inj");
else ws->loadSnapshot("conditionalNuis_1");
mc->GetGlobalObservables()->Print("v");
mu->setVal(0);
mu->setConstant(1);
status = minimize(asimov_nll, ws);
if (status >= 0) cout << "Success!" << endl;
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(asimov_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double asimov_nll_cond = asimov_nll->getVal();
mu->setVal(1);
if (doInj) ws->loadSnapshot("conditionalNuis_inj");
else ws->loadSnapshot("conditionalNuis_1");
if (doInj) mu->setConstant(0);
status = minimize(asimov_nll, ws);
if (status >= 0) cout << "Success!" << endl;
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(asimov_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double asimov_nll_min = asimov_nll->getVal();
asimov_q0 = 2*(asimov_nll_cond - asimov_nll_min);
if (doUncap && mu->getVal() < 0) asimov_q0 = -asimov_q0;
sign = int(asimov_q0 != 0 ? asimov_q0/fabs(asimov_q0) : 0);
med_sig = sign*sqrt(fabs(asimov_q0));
ws->loadSnapshot(nominalSnapshot);
}
if (doObs)
{
ws->loadSnapshot("conditionalNuis_0");
mu->setVal(0);
mu->setConstant(1);
status = minimize(obs_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(obs_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double obs_nll_cond = obs_nll->getVal();
//ws->loadSnapshot("ucmles");
mu->setConstant(0);
status = minimize(obs_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(obs_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double obs_nll_min = obs_nll->getVal();
obs_q0 = 2*(obs_nll_cond - obs_nll_min);
if (doUncap && mu->getVal() < 0) obs_q0 = -obs_q0;
sign = int(obs_q0 == 0 ? 0 : obs_q0 / fabs(obs_q0));
if (!doUncap && ((obs_q0 < 0 && obs_q0 > -0.1) || mu->getVal() < 0.001)) obs_sig = 0;
else obs_sig = sign*sqrt(fabs(obs_q0));
}
cout << "obs: " << obs_sig << endl;
cout << "Observed significance: " << obs_sig << endl;
if (med_sig)
{
cout << "Median test stat val: " << asimov_q0 << endl;
cout << "Median significance: " << med_sig << endl;
}
TH1D* h_hypo = new TH1D("hypo","hypo",2,0,2);
h_hypo->SetBinContent(1, obs_sig);
h_hypo->SetBinContent(2, med_sig);
timer.Stop();
timer.Print();
return h_hypo;
}
void buildModelUpsi2015(RooWorkspace& w, int signalModel, int bkgdModel){
// C r e a t e m o d e l
int nt=100000;
// cout << "you're building a model for the quarkonium resonance of mass = "<< M1S <<" GeV/c^{2},"endl;
RooRealVar *nsig1f = new RooRealVar("N_{ #varUpsilon(1S)}","nsig1S",0,nt*10);
RooRealVar* mass = (RooRealVar*) w.var("invariantMass");
RooRealVar *nsig2f = NULL;
RooRealVar *nsig3f = NULL;
RooRealVar *mean = new RooRealVar("m_{ #varUpsilon(1S)}","#Upsilon mean",M1S,M1S-0.2,M1S+0.2);
RooConstVar *rat2 = new RooConstVar("rat2", "rat2", M2S/M1S);
RooConstVar *rat3 = new RooConstVar("rat3", "rat3", M3S/M1S);
// scale mean and resolution by mass ratio
RooFormulaVar *mean1S = new RooFormulaVar("mean1S","@0",RooArgList(*mean));
RooFormulaVar *mean2S = new RooFormulaVar("mean2S","@0*@1", RooArgList(*mean,*rat2));
RooFormulaVar *mean3S = new RooFormulaVar("mean3S","@0*@1", RooArgList(*mean,*rat3));
// //detector resolution ?? where is this coming from?
RooRealVar *sigma1 = new RooRealVar("#sigma_{CB1}","#sigma_{CB1}",0.01,0.1); //
RooFormulaVar *sigma1S = new RooFormulaVar("sigma1S","@0" ,RooArgList(*sigma1));
RooFormulaVar *sigma2S = new RooFormulaVar("sigma2S","@0*@1",RooArgList(*sigma1,*rat2));
RooFormulaVar *sigma3S = new RooFormulaVar("sigma3S","@0*@1",RooArgList(*sigma1,*rat3));
RooRealVar *alpha = new RooRealVar("#alpha_{CB}","tail shift",0.1,10); // MC 5tev 1S pol2
RooRealVar *npow = new RooRealVar("n_{CB}","power order",0.1,10); // MC 5tev 1S pol2
RooRealVar *sigmaFraction = new RooRealVar("sigmaFraction","Sigma Fraction",0.,1.);
// scale the sigmaGaus with sigma1S*scale=sigmaGaus now.
RooRealVar *scaleWidth = new RooRealVar("#sigma_{CB2}/#sigma_{CB1}","scaleWidth",1.,2.5);
RooFormulaVar *sigmaGaus = new RooFormulaVar("sigmaGaus","@0*@1", RooArgList(*sigma1,*scaleWidth));
RooFormulaVar *sigmaGaus2 = new RooFormulaVar("sigmaGaus","@0*@1*@2", RooArgList(*sigma1,*scaleWidth,*rat2));
RooFormulaVar *sigmaGaus3 = new RooFormulaVar("sigmaGaus","@0*@1*@2", RooArgList(*sigma1,*scaleWidth,*rat3));
RooGaussian* gauss1 = new RooGaussian("gaus1s","gaus1s",
*nsig1f,
*mass, //mean
*sigmaGaus); //sigma
RooGaussian* gauss1b = new RooGaussian("gaus1sb","gaus1sb",
*nsig1f,
*mean, //mean
*sigma1); //sigma
// declarations
RooAbsPdf *cb1S_1 = NULL;
RooAbsPdf *cb1S_2 = NULL;
RooAbsPdf *cb2S_1 = NULL;
RooAbsPdf *cb2S_2 = NULL;
RooAbsPdf *cb3S_1 = NULL;
RooAbsPdf *cb3S_2 = NULL;
RooAbsPdf *sig1S = NULL;
RooAbsPdf *sig2S = NULL;
RooAbsPdf *sig3S = NULL;
switch(signalModel){
case 1: //crystal boule
sig1S = new RooCBShape("cb1S_1", "FSR cb 1s",
*mass,*mean1S,*sigma1,*alpha,*npow);
sig2S = new RooCBShape ("cb2S_1", "FSR cb 1s",
*mass,*mean2S,*sigma2S,*alpha,*npow);
sig3S = new RooCBShape ("cb3S_1", "FSR cb 1s",
*mass,*mean3S,*sigma3S,*alpha,*npow);
cout << "you're fitting each signal peak with a Crystal Ball function"<< endl;
break;
case 2: //Gaussein
sig1S = new RooGaussian ("g1", "gaus 1s",
*mass,*mean1S,*sigma1);
cout << "you're fitting 1 signal peak with a Gaussian function"<< endl;
break;
case 3: //Gaussein + crystal boule
cb1S_1 = new RooCBShape ("cb1S_1", "FSR cb 1s",
*mass,*mean1S,*sigma1,*alpha,*npow);
sig1S = new RooAddPdf ("cbg", "cbgaus 1s",
RooArgList(*gauss1,*cb1S_1),*sigmaFraction);
cout << "you're fitting 1 signal peak with a sum of a Gaussian and a Crystal Ball function"<< endl;
break;
case 4: //crystal boules
cb1S_1 = new RooCBShape ("cb1S_1", "FSR cb 1s",
*mass,*mean1S,*sigma1,*alpha,*npow);
cb1S_2 = new RooCBShape ("cb1S_2", "FSR cb 1s",
*mass,*mean1S,*sigmaGaus,*alpha,*npow);
sig1S = new RooAddPdf ("cbcb","1S mass pdf",
RooArgList(*cb1S_1,*cb1S_2),*sigmaFraction);
// /// Upsilon 2S
cb2S_1 = new RooCBShape ("cb2S_1", "FSR cb 2s",
*mass,*mean2S,*sigma2S,*alpha,*npow);
cb2S_2 = new RooCBShape ("cb2S_2", "FSR cb 2s",
*mass,*mean2S,*sigmaGaus2,*alpha,*npow);
sig2S = new RooAddPdf ("sig2S","2S mass pdf",
RooArgList(*cb2S_1,*cb2S_2),*sigmaFraction);
// /// Upsilon 3S
cb3S_1 = new RooCBShape ("cb3S_1", "FSR cb 3s",
*mass,*mean3S,*sigma3S,*alpha,*npow);
cb3S_2 = new RooCBShape ("cb3S_2", "FSR cb 3s",
*mass,*mean3S,*sigmaGaus3,*alpha,*npow);
sig3S = new RooAddPdf ("sig3S","3S mass pdf",
RooArgList(*cb3S_1,*cb3S_2),*sigmaFraction); // = cb3S1*sigmaFrac + cb3S2*(1-sigmaFrac)
cout << "you're fitting each signal peak with a Double Crystal Ball function"<< endl;
break;
case 5: //deux Gausseins
sig1S = new RooAddPdf ("cb1S_1", "cbgaus 1s",
RooArgList(*gauss1,*gauss1b),*sigmaFraction);
cout << "you're fitting each signal peak with a Double Gaussian function"<< endl;
break;
}
// bkg Chebychev
RooRealVar *nbkgd = new RooRealVar("n_{Bkgd}","nbkgd",0,nt);
RooRealVar *bkg_a1 = new RooRealVar("a1_bkg", "bkg_{a1}", 0, -5, 5);
RooRealVar *bkg_a2 = new RooRealVar("a2_Bkg", "bkg_{a2}", 0, -2, 2);
RooRealVar *bkg_a3 = new RooRealVar("a3_Bkg", "bkg_{a3}", 0, -0.9, 2);
// likesign
RooRealVar *nLikesignbkgd = new RooRealVar("NLikesignBkg","nlikesignbkgd",nt*0.75,0,10*nt);
// *************************************************** bkgModel
RooRealVar turnOn("turnOn","turnOn", 0,10);
RooRealVar width("width","width", 0.1,10);// MB 2.63
RooRealVar decay("decay","decay",0,10);// MB: 3.39
width.setConstant(false);
decay.setConstant(false);
turnOn.setConstant(false);
alpha->setConstant(false);
npow->setConstant(false);
sigma1->setConstant(false);
scaleWidth->setConstant(false);
sigmaFraction->setConstant(false);
//thisPdf: form of the bkg pdf
//pdf_combinedbkgd; // total bkg pdf. usually form*normalization (so that you can do extended ML fits)
RooAbsPdf *pdf_combinedbkgd = NULL;;
RooRealVar *fPol = new RooRealVar("F_{pol}","fraction of polynomial distribution",0.0,1);
RooAbsPdf *ChebPdf = NULL;
RooAbsPdf *ErrPdf = NULL;
RooAbsPdf* ExpPdf = NULL;
switch (bkgdModel)
{
case 3 : //use error function to fit the OS directly
bkg_a3->setConstant(true);
pdf_combinedbkgd = new RooGenericPdf("bkgPdf","bkgPdf",
"exp(-@0/decay)*(TMath::Erf((@0-turnOn)/width)+1)",
RooArgList(*mass,turnOn,width,decay));
break;
case 4 : //use pol 2+ErfExp to fit the OS directly
ChebPdf = new RooChebychev("ChebPdf","ChebPdf",
*mass, RooArgList(*bkg_a1,*bkg_a2));
ErrPdf = new RooGenericPdf("ErrPdf","ErrPdf",
"exp(-@0/decay)*(TMath::Erf((@0-turnOn)/width)+1)",
RooArgList(*mass,turnOn,width,decay));
pdf_combinedbkgd = new RooAddPdf ("bkgPdf","total combined background pdf",
RooArgList(*ChebPdf,*ErrPdf),
RooArgList(*fPol));
break;
case 5 : //use ( error function + polynomial 1) to fit the OS directly
bkg_a3->setConstant(true);
bkg_a2->setConstant(true);
ChebPdf = new RooChebychev("ChebPdf","ChebPdf",
*mass, RooArgList(*bkg_a1,*bkg_a2,*bkg_a3));
ErrPdf = new RooGenericPdf("ErrPdf","ErrPdf",
"exp(-@0/decay)*(TMath::Erf((@0-turnOn)/width)+1)",
RooArgList(*mass,turnOn,width,decay));
pdf_combinedbkgd = new RooAddPdf ("bkgPdf","total combined background pdf",
RooArgList(*ChebPdf,*ErrPdf),
RooArgList(*fPol));
break;
case 6: // NOT WORKING
ChebPdf = new RooChebychev("ChebPdf","ChebPdf",
*mass, RooArgList(*bkg_a1,*bkg_a2));
ExpPdf = new RooGenericPdf("ExpPdf","ExpPdf",
"exp(-@0/decay)",
RooArgList(*mass,decay));
pdf_combinedbkgd = new RooAddPdf ("bkgPdf","total combined background pdf",
RooArgList(*ChebPdf,*ExpPdf),
RooArgList(*fPol));
break;
default :
cout<<"Donno what you are talking about! Pick another fit option!"<<endl;
break;
}
//###### the nominal fit with default pdf
// can remove the double crystal ball in pbpb: just commenting out and copying an appropriate version
RooAbsPdf *pdf = new RooAddPdf ("pdf","total p.d.f.",
RooArgList(*sig1S,*sig2S,*sig3S,*pdf_combinedbkgd),
RooArgList(*nsig1f,*nsig2f,*nsig3f,*nbkgd));
// nsig3f->setVal(0); nsig3f->setConstant();
w.import(*pdf);
w.Print();
}
void testConditional() {
RooRealVar lRXVar("XVar","XVar",90,60,120); lRXVar.setBins(2000);
RooRealVar lSPar0("spar0","spar0",1.,0,10); //lSPar0.setConstant(kTRUE);
RooRealVar lS1Par0("s1par0","s1par0",1.0 ,0,10); //lSPar0.setConstant(kTRUE);
RooRealVar lS1Par1("s1par1","s1par1",0.02 ,-5,5); //lSPar1.setConstant(kTRUE);
RooRealVar lS1Par2("s1par2","s1par2",-0.05,-5,5); //lSPar2.setConstant(kTRUE);
RooRealVar lS1Par3("s1par3","s1par3", 0.0 ,-5,5); //lSPar3.setConstant(kTRUE);
RooRealVar lS1Par4("s1par4","s1par4",0.06,-5,5); //lSPar4.setConstant(kTRUE);
RooRealVar lS2Par0("s2par0","s2par0",1.26979,0,10); //lSPar0.setConstant(kTRUE);
RooRealVar lS2Par1("s2par1","s2par1",0.0127 ,-5,5); //lSPar1.setConstant(kTRUE);
RooRealVar lS2Par2("s2par2","s2par2",-0.057,-5,5); //lSPar2.setConstant(kTRUE);
RooRealVar lS2Par3("s2par3","s2par3",-0.19 ,-5,5); //lSPar3.setConstant(kTRUE);
RooRealVar lS2Par4("s2par4","s2par4",0.06 ,-5,5); //SPar4.setConstant(kTRUE);
RooRealVar lMPar0("mpar0","mpar0",0.,-5,5);
RooRealVar lMPar1("mpar1","mpar1",0.,-5,5);
RooRealVar lMPar2("mpar2","mpar2",0.,-5,5); //lMPar2.setConstant(kTRUE);
RooRealVar lMPar3("mpar3","mpar3",0.,-5,5);
RooRealVar lMPar4("mpar4","mpar4",0.,-5,5);// lMPar4.setConstant(kTRUE);
RooRealVar lMPar5("mpar5","mpar5",0.,-5,5);
RooRealVar lMPar6("mpar6","mpar6",0.,-5,5);
RooRealVar lRPhi ("phi","phi" ,0,-3.14,3.14);
RooRealVar lRPhi2("phi2","phi2" ,0,-3.14,3.14);
RooFormulaVar l1SigmaEta1("sigma1eta1","(@0+@1*@5+@2*@5*@5+@3*@5*@5*@5+@4*@5*@5*@5*@5)",RooArgList(lS1Par0,lS1Par1,lS1Par2,lS1Par3,lS1Par4,lRPhi));//,lSPar3,lSPar4,lRPhi2));
RooFormulaVar l1SigmaEta2("sigma1eta2","(@0+@1*@5+@2*@5*@5+@3*@5*@5*@5+@4*@5*@5*@5*@5)",RooArgList(lS1Par0,lS1Par1,lS1Par2,lS1Par3,lS1Par4,lRPhi2));//,lSPar3,lSPar4,lRPhi2));
//RooFormulaVar l1Sigma ("sigma1" ,"sqrt(@0*@0+@1*@1)" ,RooArgList(l1SigmaEta1,l1SigmaEta2));
RooRealVar l1Sigma("sigma1","sigma1",1.47,0.,3.); l1Sigma.setConstant(kTRUE);
RooRealVar l2Sigma("sigma2","sigma2",1.1 ,0.,3.); l2Sigma.setConstant(kTRUE);
RooRealVar l3Sigma("sigma3","sigma3",2.8,0.,15.); l3Sigma.setConstant(kTRUE);
RooRealVar lN ("n" ,"n" ,1.5,-15,15.); lN.setConstant(kTRUE);
//RooRealVar lR1Mean("mean","mean",91.2,60,250); lR1Mean.setConstant(kTRUE);
//RooFormulaVar lR1Mean("mean","91.2*sqrt((1+@1*sin(@3+@2))*(1+@1*sin(@6+@2)))+@0",RooArgList(lMPar0,lMPar1,lMPar2,lRPhi,lMPar3,lMPar4,lRPhi2)); //l1Sigma.setConstant(kTRUE);
RooFormulaVar lR1Mean("mean","91.2*sqrt((1+@1*sin(@3+@2))*(1+@4*sin(@6+@5)))+@0",RooArgList(lMPar0,lMPar1,lMPar2,lRPhi,lMPar3,lMPar4,lRPhi2)); //l1Sigma.setConstant(kTRUE);
//RooFormulaVar lR1Mean("mean","91.2*sqrt((1+@1*@3+@2*@3*@3+@7*@3*@3*@3)*(1+@4*@6+@5*@6*@6+@8*@6*@6*@6))+@0",RooArgList(lMPar0,lMPar1,lMPar2,lRPhi,lMPar3,lMPar4,lRPhi2,lMPar5,lMPar6)); //l1Sigma.setConstant(kTRUE);
RooVoigtianShape lConv("XXX","XXX",lRXVar,lR1Mean,l1Sigma,l2Sigma,lN,l3Sigma,false);
RooDataSet *lData = new RooDataSet("crap","crap",RooArgSet(lRXVar,lRPhi,lRPhi2));
TFile *lFile = new TFile("../Efficiency/Data/mTPNT8_v1.root");
//TFile *lFile = new TFile("../Efficiency/Data/ZTP8_v2.root");
TTree *lTree = (TTree*) lFile->FindObjectAny("WNtupleIdEffNT");
float lMt = 0; lTree->SetBranchAddress("mt" ,&lMt);
int lCharge = 0; lTree->SetBranchAddress("charge",&lCharge);
float lEta = 0; lTree->SetBranchAddress("eta" ,&lEta);
float lPhi = 0; lTree->SetBranchAddress("phi" ,&lPhi);
float lPt = 0; lTree->SetBranchAddress("pt" ,&lPt);
float lOPt = 0; lTree->SetBranchAddress("jetpt" ,&lOPt);
float lOPhi = 0; lTree->SetBranchAddress("jetphi",&lOPhi);
float lOEta = 0; lTree->SetBranchAddress("jeteta",&lOEta);
float lTrkIso = 0; lTree->SetBranchAddress("trkiso",&lTrkIso);
float lEcalIso = 0; lTree->SetBranchAddress("ecaliso",&lEcalIso);
float lHcalIso = 0; lTree->SetBranchAddress("hcaliso",&lHcalIso);
float lChi2 = 0; lTree->SetBranchAddress("chi2" ,&lChi2);
int lNHit = 0; lTree->SetBranchAddress("nhit" ,&lNHit);
Muon lMuon; lTree->SetBranchAddress("muon" ,&lMuon);
for(int i0 = 0; i0 < lTree->GetEntries();i0++) {
if(i0 > 50000) continue;
lTree->GetEntry(i0);
if(lMt < 60) continue;
if(lChi2 > 10) continue;
if(lNHit < 10) continue;
if(lMuon.NSeg < 2) continue;
if(lMuon.NPixel == 0) continue;
if(lMuon.NValid == 0) continue;
if(lMuon.Type != 3) continue;
if((lTrkIso+lEcalIso+lHcalIso)/lPt > 0.15) continue;
if(lMt < 60 || fabs(lEta) > 2.1 || fabs(lOEta) > 2.1 || fabs(lPt) < 25 || fabs(lOPt) < 25) continue;
lRXVar.setVal(lMt);
//if(lCharge > 0) lRXVar.setVal(correct(lMt,lPhi,lOPhi,0,0));//lEta ,lOEta));
//if(lCharge < 0) lRXVar.setVal(correct(lMt,lOPhi,lPhi,0,0));//lOEta,lEta));
//lRPhi.setVal(lEta); lRPhi2.setVal(lOEta);
//if(lCharge < 0) {lRPhi.setVal(lOEta); lRPhi2.setVal(lEta);}
lRPhi.setVal(lPhi); lRPhi2.setVal(lOPhi);
if(lCharge < 0) {lRPhi.setVal(lOPhi); lRPhi2.setVal(lPhi);}
lData->add(RooArgSet(lRXVar,lRPhi,lRPhi2));//,lRPhi2));
}
lConv.fitTo(*lData,ConditionalObservables(RooArgSet(lRXVar,lRPhi,lRPhi2)),Strategy(1),Minos());
//lConv.fitTo(*lData,Strategy(1));
lRXVar.setBins(50);
RooPlot *lFrame1 = lRXVar.frame(RooFit::Title("XXX")) ;
lData->plotOn(lFrame1);
lConv.plotOn(lFrame1);
TCanvas *iC =new TCanvas("A","A",800,600);
iC->cd(); lFrame1->Draw();
iC->SaveAs("Crap.png");
}
