void Fitter::MakePlots(const string& name, const string& title, RooPlot*& pPlot1, RooPlot*& pPlot2, RooAbsPdf* pPdf, RooDataSet* pData)
{
bool plotbkg = false;
RooPlot* pFrame = pPlot1? pPlot1 : pFitVar->frame(RooFit::Bins(50), RooFit::Name(name.c_str()), RooFit::Title(title.c_str()));
RooPlot* pFramePull = pPlot2? pPlot2 : pFitVar->frame(RooFit::Bins(50), RooFit::Name((name+"_Pull").c_str()), RooFit::Title((title+" Pull").c_str()));
RooHist* pHisPull = NULL;
double pullMax = 0.;
if(!pPdf && !pData) plotbkg = true;
if(!pPdf) pPdf = pTotPdf;
if(!pData) pData = this->pData;
pData->plotOn(pFrame, RooFit::MarkerSize(0.9));
if(plotbkg)
{
RooArgList bkgComponent;
for(auto& pdf : bkgPdfs) bkgComponent.add(pdf.GetPdf());
pTotPdf->plotOn(pFrame, RooFit::Components(bkgComponent), RooFit::LineColor(kGreen) );
}
pPdf->plotOn(pFrame, RooFit::LineColor(kRed));
pPdf->paramOn(pFrame, RooFit::Format("NEU", RooFit::AutoPrecision(1)), RooFit::Layout(0.65, 0.99, 0.93));
pFrame->getAttText()->SetTextSize(0.75*pFrame->GetYaxis()->GetLabelSize());
pHisPull = pFrame->pullHist();
pFramePull->addPlotable(pHisPull, "P");
pullMax = max(fabs(pFramePull->GetMinimum()), pFramePull->GetMaximum());
pFramePull->GetYaxis()->SetRangeUser(-pullMax,pullMax);
pPlot1 = pFrame;
pPlot2 = pFramePull;
}
RooAddPdf *buildSumOfGaussians(string name, RooRealVar *mass, RooRealVar *MH, int nGaussians){
RooArgList *gaussians = new RooArgList();
RooArgList *coeffs = new RooArgList();
for (int g=0; g<nGaussians; g++){
RooRealVar *dm = new RooRealVar(Form("dm_g%d",g),Form("dm_g%d",g),0.1,-5.*(1.+0.5*g),5.*(1.+0.5*g));
RooAbsReal *mean = new RooFormulaVar(Form("mean_g%d",g),Form("mean_g%d",g),"@0+@1",RooArgList(*MH,*dm));
RooRealVar *sigma = new RooRealVar(Form("sigma_g%d",g),Form("sigma_g%d",g),2.,0.7,5.*(1.+0.5*g));
RooGaussian *gaus = new RooGaussian(Form("gaus_g%d",g),Form("gaus_g%d",g),*mass,*mean,*sigma);
//tempFitParams.insert(pair<string,RooRealVar*>(string(dm->GetName()),dm));
//tempFitParams.insert(pair<string,RooRealVar*>(string(sigma->GetName()),sigma));
//tempFitUtils.insert(pair<string,RooAbsReal*>(string(mean->GetName()),mean));
//tempGaussians.insert(pair<string,RooGaussian*>(string(gaus->GetName()),gaus));
gaussians->add(*gaus);
if (g<nGaussians-1) {
RooRealVar *frac = new RooRealVar(Form("frac_g%d",g),Form("frac_g%d",g),0.1,0.01,0.99);
//tempFitParams.insert(pair<string,RooRealVar*>(string(frac->GetName()),frac));
coeffs->add(*frac);
}
if (g==nGaussians-1 && forceFracUnity_){
string formula="1.";
for (int i=0; i<nGaussians-1; i++) formula += Form("-@%d",i);
RooAbsReal *recFrac = new RooFormulaVar(Form("frac_g%d",g),Form("frac_g%d",g),formula.c_str(),*coeffs);
//tempFitUtils.insert(pair<string,RooAbsReal*>(string(recFrac->GetName()),recFrac));
coeffs->add(*recFrac);
}
}
RooAddPdf *tempSumOfGaussians = new RooAddPdf(name.c_str(),name.c_str(),*gaussians,*coeffs,recursive_);
return tempSumOfGaussians;
}
testWrapper(){
gSystem->Load("libTMVAWrapper.so");
RooWorkspace w("w");
w.factory("x[-5,5]");
w.factory("alpha[-5,5]");
x = w.var("x");
alpha = w.var("alpha");
// vars = w.allVars();
RooArgList vars;
vars.add(*x);
vars.add(*alpha);
vars.Print();
TMVAWrapper wrap("wrap","wrap", vars, "TMVARegression_alphavary.root_MLP.weights.xml");
wrap.Print("v");
cout << "wrap = " << wrap.getVal() <<endl;
x->setVal(1);
alpha->setVal(2.);
cout << "wrap = " << wrap.getVal() <<endl;
// w.import(wrap);
// w.Print();
// return;
// cout << "\n\nvars are: " << wrap.getListOfVars() << endl;
frame = x->frame();
wrap.plotOn(frame);
frame->Draw();
}
void makePdf( RooWorkspace *w ) {
// bkg
w->factory("Exponential::bkg_pdf( B_s0_DTF_B_s0_M, bkg_exp_p1[-0.002,-0.004,0.] )");
// sig
w->factory("bs2kstkst_l [ -5 ,-20 ,0]");
w->factory("bs2kstkst_zeta [ 1.e-5 ]");
w->factory("bs2kstkst_fb [ 0. ]");
w->factory("bs2kstkst_sigma [ 15 ,10 ,100]");
w->factory("bs2kstkst_mu [ 5350 ,5400 ]");
w->factory("bs2kstkst_a [ 2.5 , 0 ,10 ]");
w->factory("bs2kstkst_n [ 2.5 , 0 ,10 ]");
w->factory("bs2kstkst_a2 [ 2.5 , 0 ,10 ]");
w->factory("bs2kstkst_n2 [ 2.5 , 0 ,10 ]");
w->var("bs2kstkst_zeta")->setConstant(true);
w->var("bs2kstkst_fb")->setConstant(true);
RooIpatia2 *pdf = new RooIpatia2("bs2kstkst_pdf","bs2kstkst_mc_pdf",*w->var("B_s0_DTF_B_s0_M"),*w->var("bs2kstkst_l"),*w->var("bs2kstkst_zeta"),*w->var("bs2kstkst_fb"),*w->var("bs2kstkst_sigma"),*w->var("bs2kstkst_mu"),*w->var("bs2kstkst_a"),*w->var("bs2kstkst_n"),*w->var("bs2kstkst_a2"),*w->var("bs2kstkst_n2"));
w->import(*pdf);
delete pdf;
//w->factory("Gaussian::bs2kstkst_pdf( B_s0_DTF_B_s0_M, bs2kstkst_mean[5320,5380], bs2kstkst_sigma[1,20] )");
// other sig
w->factory("Gaussian::bd2kstkst_pdf( B_s0_DTF_B_s0_M, bd2kstkst_mean[5250,5300], bd2kstkst_sigma[1,20] )");
RooArgList *pdfs = new RooArgList();
RooArgList *yields = new RooArgList();
pdfs->add( *w->pdf("bkg_pdf") );
pdfs->add( *w->pdf("bs2kstkst_pdf") );
pdfs->add( *w->pdf("bd2kstkst_pdf") );
w->factory( "bkg_y[1e3,1e5]" );
w->factory( "bs2kstkst_y[0,20e3]" );
w->factory( "bd2kstkst_y[0,3000]" );
yields->add( *w->var("bkg_y") );
yields->add( *w->var("bs2kstkst_y") );
yields->add( *w->var("bd2kstkst_y") );
// total
RooAddPdf *addpdf = new RooAddPdf( "pdf","pdf", *pdfs, *yields);
w->import(*addpdf);
delete addpdf;
//w->factory("SUM::pdf( bkg_y[1e3,1e5]*bkg_pdf, bs2kstkst_y[0,20e3]*bs2kstkst_pdf, bd2kstkst_y[0,3000]*bd2kstkst_pdf )");
}
void makeConnectedBinList(string procname, RooRealVar& var, RooWorkspace& ws, TH1F* rhist, vector<pair<RooRealVar*, TH1*> > syst, const RooArgList& srbinlist, RooArgList* crbinlist=NULL) {
if (crbinlist == NULL) crbinlist = new RooArgList();
for (int i = 1; i <= rhist->GetNbinsX(); i++) {
stringstream rbinss;
rbinss << "r_" << procname << "_bin" << i;
RooRealVar* rbinvar = new RooRealVar(rbinss.str().c_str(), "", rhist->GetBinContent(i));
stringstream rerrbinss;
rerrbinss << procname << "_bin" << i << "_Runc";
RooRealVar* rerrbinvar = new RooRealVar(rerrbinss.str().c_str(), "", 0., -5., 5.);
stringstream binss;
binss << procname << "_bin" << i;
RooArgList fobinlist;
fobinlist.add(srbinlist[i-1]);
fobinlist.add(*rbinvar);
fobinlist.add(*rerrbinvar);
stringstream formss;
formss << "@0/";
formss << "(";
formss << "@1";
formss << "*(1+" << rhist->GetBinError(i)/rhist->GetBinContent(i) << "*@2)";
for (int j = 0; j < syst.size(); j++) {
stringstream systbinss;
if (syst[j].first == NULL) {
systbinss << procname << "_bin" << i << "_" << syst[j].second->GetName();
RooRealVar* systbinvar = new RooRealVar(systbinss.str().c_str(), "", 0., -5., 5.);
fobinlist.add(*systbinvar);
}
else {
fobinlist.add(*syst[j].first);
}
formss << "*(1+" << syst[j].second->GetBinContent(i) << "*@" << j+3 << ")";
}
formss << ")";
RooFormulaVar* binvar = new RooFormulaVar(binss.str().c_str(), "", formss.str().c_str(), RooArgList(fobinlist));
crbinlist->add(*binvar);
}
stringstream normss;
normss << procname << "_norm";
RooParametricHist phist(procname.c_str(), "", var, *crbinlist, *rhist);
RooAddition norm(normss.str().c_str(),"", *crbinlist);
ws.import(phist,RooFit::RecycleConflictNodes());
ws.import(norm, RooFit::RecycleConflictNodes());
}
map<string,RooAddPdf*> getMITPdfs(RooWorkspace *work, int ncats, bool is2011){
map<string,RooAddPdf*> result;
RooArgList pdfs;
RooArgList norms;
string sqrts;
string catstring;
if (is2011){
sqrts="7TeV";
catstring="cat";
}
else {
sqrts="8TeV";
catstring="mvacat";
}
for (int cat=0; cat<ncats; cat++){
RooAddPdf *ggh = (RooAddPdf*)work->pdf(Form("hggpdfsmrel_%s%d_%s_ggh",catstring.c_str(),cat,sqrts.c_str()));
RooAddPdf *vbf = (RooAddPdf*)work->pdf(Form("hggpdfsmrel_%s%d_%s_vbf",catstring.c_str(),cat,sqrts.c_str()));
RooAddPdf *wzh = (RooAddPdf*)work->pdf(Form("hggpdfsmrel_%s%d_%s_wzh",catstring.c_str(),cat,sqrts.c_str()));
RooAddPdf *tth = (RooAddPdf*)work->pdf(Form("hggpdfsmrel_%s%d_%s_tth",catstring.c_str(),cat,sqrts.c_str()));
RooFormulaVar *ggh_norm = (RooFormulaVar*)work->function(Form("hggpdfsmrel_%s%d_%s_ggh_norm",catstring.c_str(),cat,sqrts.c_str()));
RooFormulaVar *vbf_norm = (RooFormulaVar*)work->function(Form("hggpdfsmrel_%s%d_%s_vbf_norm",catstring.c_str(),cat,sqrts.c_str()));
RooFormulaVar *wzh_norm = (RooFormulaVar*)work->function(Form("hggpdfsmrel_%s%d_%s_wzh_norm",catstring.c_str(),cat,sqrts.c_str()));
RooFormulaVar *tth_norm = (RooFormulaVar*)work->function(Form("hggpdfsmrel_%s%d_%s_tth_norm",catstring.c_str(),cat,sqrts.c_str()));
pdfs.add(*ggh); pdfs.add(*vbf); pdfs.add(*wzh); pdfs.add(*tth);
norms.add(*ggh_norm); norms.add(*vbf_norm); norms.add(*wzh_norm); norms.add(*tth_norm);
result.insert(pair<string,RooAddPdf*>(Form("cat%d",cat),new RooAddPdf(Form("sig_cat%d",cat),"sig",RooArgList(*ggh,*vbf,*wzh,*tth),RooArgList(*ggh_norm,*vbf_norm,*wzh_norm,*tth_norm))));
}
result.insert(pair<string,RooAddPdf*>("all",new RooAddPdf("sig_all","sig",pdfs,norms)));
return result;
}
void THSRooFit::SetDataWeight(){
if(!fInWeights) return;
if(fInWeights->GetSpeciesID(fWeightName)<0) return;
RooArgList setWeights;
RooRealVar wvar(fWeightName,fWeightName,0);
setWeights.add(wvar);
setWeights.Print();
RooDataSet wData("weights","weights",setWeights) ;
//Loop over the weights find the entry for the event ID
for(Int_t ev=0;ev<fData->numEntries();ev++){
const RooArgSet* vars=fData->get(ev);
fInWeights->GetEntryBinarySearch((Long64_t)vars->getRealValue(fIDBranchName));
// wvar.setVal(fInWeights->GetWeight(fWeightName));
wvar.setVal(fInWeights->GetWeight(fWeightName));
wData.add(setWeights);
}
wData.Print();
((RooDataSet*)fData)->merge(&wData);
fData->Print();
RooDataSet* tmpData=0;
tmpData=new RooDataSet(TString("Weight_")+fWeightName+fData->GetName(),fData->GetTitle(),(RooDataSet*)fData,*fData->get(),0,fWeightName);
fData->SetName("Empty");fData->reset();fData=0;
fData=tmpData;
fData->Print();
if(ftoWS) fWS->import(*fData); //import if told to
else if(!(fDataBins))fWS->import(*fData); //or no databins to confuse it
}
RooArgList Fitter::GetYieldsList()
{
RooArgList yldList;
for(auto& pVec_pdfs : {&sigPdfs, &bkgPdfs})
for(auto& pdf : *pVec_pdfs)
yldList.add(pdf.GetYld());
return yldList;
}
void makeSystPlot(RooWorkspace *tempWS, RooWorkspace *WS, TString systT, int Bin, int toMassNo, int fromMassNo)
{
std::cout<< "SystName--> " << systT.Data() << std::endl;
RooArgList * hobs = new RooArgList("hobs");
TString xname;
if(IFILE.Contains ("Zmm") | IFILE.Contains ("Zee"))
{
xname = "CMS_vhbb_BDT_Zll_8TeV";
}
if(IFILE.Contains("We") | IFILE.Contains("Wm"))
{
xname = "CMS_vhbb_BDT_Wln_8TeV";
}
if(IFILE.Contains ("Zn") && (Bin == 0))
{
xname = "CMS_vhbb_BDT_ZnunuLowPt_8TeV";
}
if(IFILE.Contains ("Zn") && (Bin == 1))
{
xname = "CMS_vhbb_BDT_ZnunuMedPt_8TeV";
}
if(IFILE.Contains ("Zn") && (Bin == 2))
{
xname = "CMS_vhbb_BDT_ZnunuHighPt_8TeV";
}
if(IFILE.Contains("Wt"))
{
xname = "BDT";
}
std::cout<< "BDT Name--> " << xname.Data() << std::endl;
hobs->add(*WS->var(xname.Data()));
RooRealVar BDT(xname.Data(),xname.Data(),-1,1);
tempRooDataHistNom = (RooDataHist*) tempWS->data(systT.Data());
tempHistNom = tempRooDataHistNom->createHistogram(systT.Data(),BDT,RooFit::Binning(bins));
if(systT.Contains("WH"))
{
tempHistNom->Scale(xSec8WH[toMassNo]/xSec8WH[fromMassNo]);
}
if(systT.Contains("ZH"))
{
tempHistNom->Scale(xSec8ZH[toMassNo]/xSec8ZH[fromMassNo]);
}
RooDataHist *DHnom;
DHnom = new RooDataHist(systT.Data(),"",*hobs,tempHistNom);
WS->import(*(new RooHistPdf(systT.Data(),"",*hobs,*DHnom)));
}
void Utils::setParameters(RooWorkspace* w, TString parname, RooSlimFitResult* r, bool constAndFloat)
{
if ( constAndFloat ){
RooArgList list = r->floatParsFinal();
list.add(r->constPars());
setParameters(w, parname, &list);
return;
}
setParameters(w, parname, &(r->floatParsFinal()));
}
//#include "/uscms_data/d3/cvernier/DiH_13TeV/CMSSW_7_1_5/src/HiggsAnalysis/CombinedLimit/interface/RooMultiPdf.h"
//#include "HiggsAnalysis/CombinedLimit/interface/RooMultiPdf.h"
void makeRooMultiPdfWorkspace(){
// Load the combine Library
gSystem->Load("libHiggsAnalysisCombinedLimit.so");
// Open the dummy H->gg workspace
TFile *f_hgg = TFile::Open("w_background_Bern.root");
RooWorkspace *w_hgg = (RooWorkspace*)f_hgg->Get("HbbHbb");
// The observable (CMS_hgg_mass in the workspace)
RooRealVar *mass = w_hgg->var("x");
// Get three of the functions inside, exponential, linear polynomial, power law
RooAbsPdf *pdf_exp = w_hgg->pdf("bg_exp");
RooAbsPdf *pdf_pol = w_hgg->pdf("bg");
// Fit the functions to the data to set the "prefit" state (note this can and should be redone with combine when doing
// bias studies as one typically throws toys from the "best-fit"
RooAbsData *data = w_hgg->data("data_obs");
pdf_exp->fitTo(*data); // index 0
pdf_pol->fitTo(*data); // index 2
// Make a plot (data is a toy dataset)
RooPlot *plot = mass->frame(); data->plotOn(plot);
pdf_exp->plotOn(plot,RooFit::LineColor(kBlue));
pdf_pol->plotOn(plot,RooFit::LineColor(kRed));
plot->SetTitle("PDF fits to toy data");
plot->Draw();
// Make a RooCategory object. This will control which of the pdfs is "active"
RooCategory cat("pdf_index","Index of Pdf which is active");
// Make a RooMultiPdf object. The order of the pdfs will be the order of their index, ie for below
// 0 == exponential
// 1 == linear function
// 2 == powerlaw
RooArgList mypdfs;
mypdfs.add(*pdf_exp);
mypdfs.add(*pdf_pol);
RooMultiPdf multipdf("roomultipdf","All Pdfs",cat,mypdfs);
// As usual make an extended term for the background with _norm for freely floating yield
RooRealVar norm("roomultipdf_norm","Number of background events",0,10000);
// Save to a new workspace
TFile *fout = new TFile("background_pdfs.root","RECREATE");
RooWorkspace wout("backgrounds","backgrounds");
wout.import(cat);
wout.import(norm);
wout.import(multipdf);
wout.Print();
wout.Write();
}
RooAbsArg *cloneRecursiveRename(RooAbsArg *arg, const char *postfix) {
RooAbsArg *clone = arg->cloneTree();
RooArgSet *clonecomps = clone->getComponents();
RooArgSet *clonevars = clone->getVariables();
RooArgList cloneargs;
cloneargs.add(*clonecomps);
cloneargs.add(*clonevars);
delete clonecomps;
delete clonevars;
for (int iarg=0; iarg<cloneargs.getSize(); ++iarg) {
cloneargs.at(iarg)->SetName(TString::Format("%s_%s",cloneargs.at(iarg)->GetName(),postfix));
}
return clone;
}
JetTagBin::JetTagBin(TFile & file, string jtBinName, vector<Sample> theSamples):
jtBinName_(jtBinName)
{
jtBinVar_= new RooRealVar(jtBinName.c_str(), jtBinName.c_str(), 50, 600);
int nbins_def = 0;
for(unsigned int i=0;i<theSamples.size();++i) {
string name = theSamples[i].name()+jtBinName;
string histname = "";
if ( theSamples[i].sampName()=="" ) histname = name;
else histname = theSamples[i].sampName()+jtBinName;
if ( verbose ) cout << "Opening histogram " << histname << endl;
TH1F * tempHisto = (TH1F*)file.Get(histname.c_str());
TH1F * tempHisto2;
if(tempHisto==0) {
cout << "Template " << name << " does not exist" << endl;
assert(0); // maybe we don't assert but rather break/continue so we can easily work with different jtbin names
}
else {
tempHisto2 = (TH1F*) tempHisto->Clone();
// delete tempHisto;
}
// We set the binning, assuming all samples have the same binning
int nbins = tempHisto2->GetNbinsX();
if(i==0) {
nbins_def = nbins;
int xlo = tempHisto2->GetBinLowEdge(1);
int xhi = tempHisto2->GetBinLowEdge(nbins + 1);
RooUniformBinning jtBinning(xlo,xhi,nbins_def);
jtBinVar_->setBinning(jtBinning);
}
else {
if (nbins!=nbins_def) {
cout << "something here " << endl;
assert(0);
}
}
Template * temp = new Template(*tempHisto2, name, *jtBinVar_, theSamples[i]);
jtTemplates_.push_back( temp );
delete tempHisto2;
}
if ( verbose ) cout << "Making combined pdf" << endl;
RooArgList TemplateList;
for(unsigned int i=0;i<jtTemplates_.size();++i) {
TemplateList.add(*(jtTemplates_[i]->epdf()));
}
jtPdf_ = new RooAddPdf((jtBinName_+"_pdf").c_str(),(jtBinName_+"_pdf").c_str(),TemplateList);
jtData_ = 0;
jtNll_ = 0;
}
int Fitter::InitPdfs()
{
map<string, int> serials;
auto AddSerial = [&serials](const string& name)
{
ostringstream oss;
oss << name << serials[name]++;
return oss.str();
};
const string sigName = "sig";
const string bkgName = "bkg";
int nSigs = sigPdfs.size();
int nBkgs = bkgPdfs.size();
int nData = pData->numEntries();
RooArgList pdfs;
RooArgList ylds;
for(int i=0; i<2; ++i)
{
vector<FitterPdf>& vec_pdf = i? bkgPdfs : sigPdfs;
const string& name = i? bkgName : sigName;
for(auto& pdf : vec_pdf)
{
if(pdf.Init(AddSerial(name), *pFitVar, nSigs + nBkgs, nData)) return 1;
pdfs.add(pdf.GetPdf());
ylds.add(pdf.GetYld());
}
}
pTotPdf = new RooAddPdf("pdf", "pdf", pdfs, ylds);
return 0;
}
///
/// Set each parameter in workspace to the values found
/// in the fit result
///
void Utils::setParameters(RooWorkspace* w, RooFitResult* values){
RooArgList list = values->floatParsFinal();
list.add(values->constPars());
TIterator* it = list.createIterator();
while(RooRealVar* p = (RooRealVar*)it->Next()){
RooRealVar* var = dynamic_cast<RooRealVar*>(w->allVars().find(p->GetName()));
if(!(var)){
std::cout << "WARNING in Utils::setParameters(RooWorkspace,RooFitResult) -- no Var found with name "
<< p->GetName() << " in Workspace!" << endl;
}
else{
var->setVal(p->getVal());
}
}
return;
};
void ParameterCache::printFitResultToOutStream(ofstream &out, RooSlimFitResult *slimFitRes) {
out << "### FCN: " << slimFitRes->minNll() << ", EDM: " << slimFitRes->edm() << endl;
out << "### COV quality: " << slimFitRes->covQual() << ", status: " << slimFitRes->status()
<< ", confirmed: " << (slimFitRes->isConfirmed()?"yes":"no") << endl;
RooArgList argList = slimFitRes->floatParsFinal();
argList.add(slimFitRes->constPars());
argList.sort();
TIterator *iter = argList.createIterator();
while ( RooRealVar *arg=(RooRealVar*)iter->Next() ) {
if ( TString(arg->GetName()).Contains("obs") ) continue;
out << Form("%-25s",arg->GetName()) << " " << Form("%12.6f",arg->getVal())
<< " " << Form("%12.6f",arg->getErrorLo())
<< " " << Form("%12.6f",arg->getErrorHi()) << endl;
}
delete iter;
}
void GenericModel::ConstructPseudoPDF(Bool_t)
{
// Build a parameterised pseudo-PDF from all the imported model datasets.
// Each dataset is transformed into a RooNDKeysPdf kernel estimation p.d.f.
// This p.d.f. models the distribution of an arbitrary input dataset as a
// superposition of Gaussian kernels, one for each data point, each
// contributing 1/N to the total integral of the p.d.f.
//
// If debug=kTRUE, each dataset and kernel PDF will be displayed in a canvas.
// This can help to decide if the kernel smoothing parameter needs attention.
if (!GetNumberOfDataSets()) {
Error("ConstructPseudoPDF", "import model datasets with ImportModelData() first");
return;
}
if (fModelPseudoPDF) {
delete fModelPseudoPDF;
fModelPseudoPDF = 0;
fNDKeys.Delete();
fFractions.removeAll();
}
//generate kernels
RooArgList kernels;
Double_t initialWeight = 1. / GetNumberOfDataSets();
for (int i = 0; i < GetNumberOfDataSets(); i++) {
Info("ConstructPseudoPDF", "Kernel estimation of dataset#%d...", i);
RooNDKeysPdf* p = new RooNDKeysPdf(Form("NDK%d", i),
Form("Kernel estimation of dataset#%d", i),
GetObservables(),
*((RooDataSet*)fDataSets[i]),
"am", fSmoothing);
fNDKeys.Add(p);
kernels.add(*p);
if (i < (GetNumberOfDataSets() - 1))
fFractions.addClone(RooRealVar(Form("W%d", i), Form("fractional weight of kernel-PDF #%d", i), initialWeight, 0., 1.));
}
fModelPseudoPDF = new RooAddPdf("Model", "Pseudo-PDF constructed from kernels for model datasets", kernels, fFractions, kTRUE);
}
void makeBinList(string procname, RooRealVar& var, RooWorkspace& ws, TH1F* hist, RooArgList& binlist, bool setConst = false) {
for (int i = 1; i <= hist->GetNbinsX(); i++) {
stringstream binss;
binss << procname << "_bin" << i;
RooRealVar* binvar;
if (!setConst) binvar = new RooRealVar(binss.str().c_str(), "", hist->GetBinContent(i), 0., hist->GetBinContent(i)*2.0);
else binvar = new RooRealVar(binss.str().c_str(), "", hist->GetBinContent(i));
binlist.add(*binvar);
}
stringstream normss;
normss << procname << "_norm";
RooParametricHist phist(procname.c_str(), "", var, binlist, *hist);
RooAddition norm(normss.str().c_str(), "", binlist);
ws.import(phist,RooFit::RecycleConflictNodes());
ws.import(norm, RooFit::RecycleConflictNodes());
}
void ws_v05()
{
gROOT->ProcessLine(".x ./mystyle.C");
/*RooMsgService::instance().setSilentMode(true);*/
/*RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING) ; //WAS WARNING*/
// Variables definition
Double_t xmin = 1000.;
Double_t xmax = 2000.;
Int_t nbins = 50;
cout << "\n\n >>>> Importing shapes \n\n" << endl;
TFile *f1 = new TFile("K1_1270/ws_K1_1270.root");
/*TFile *f2 = new TFile("K1_1400/ws_K1_1400.root");*/
/*TFile *f3 = new TFile("K2_1430/ws_K2_1430.root");*/
RooWorkspace* ws_K1_1270 = (RooWorkspace*) f1->Get("ws_K1_1270");
/*RooWorkspace* ws_K1_1400 = (RooWorkspace*) f2->Get("ws_K1_1400");*/
/*RooWorkspace* ws_K2_1430 = (RooWorkspace*) f3->Get("ws_K2_1430");*/
ws_K1_1270->Print();
/*ws_K1_1400->Print();*/
/*ws_K2_1430->Print();*/
// Importing variables from workspaces
RooRealVar* m_Kpipi = ws_K1_1270 -> var("m_Kpipi");
RooAbsPdf* totalPdf_K1_1270 = ws_K1_1270 -> pdf("histPdf_K1toKrho");
RooAbsPdf* totalPdf_K1_1270_Kst0_1430 = ws_K1_1270 -> pdf("histPdf_Kstar1430pi");
RooAbsPdf* totalPdf_K1_1270_Kst0_892 = ws_K1_1270 -> pdf("histPdf_Kstar892pi");
/*RooAbsPdf* totalPdf_K1_1270 = ws_K1_1270 -> pdf("totalPdf_K1_1270");*/
/*RooAbsData* data_K1_1270 = ws_K1_1270 -> data("totalPdf_K1_1270Data");*/
/*RooHistPdf* pdf_K1_1270_to_Krho = ws_K1_1270 -> pdf("histPdf_K1toKrho");*/
///////
/*TFile *MC = new TFile("radiativeVPG_MC11s20_B2K11270Gamma_magdown.root");*/
/*TTree* t_tree = (TTree*)MC->Get("k1GammaMCStrip/DecayTree");*/
/*TH1F* hist = new TH1F("hist","hist",nbins,xmin,xmax);*/
/*Float_t mass = 0.;*/
/*t_tree->SetBranchAddress("B_BMassFit_K_1_1270_plus_M",&mass);*/
/*Int_t n2 = 0;*/
/*for (int i=0;i<t_tree->GetEntries();i++)*/
/*{*/
/*t_tree->GetEntry(i);*/
/*hist->Fill(mass);*/
/*n2++;*/
/*}*/
/*RooDataHist datahist("datahist","datahist",*m_Kpipi,hist);*/
/*RooHistPdf totalPdf_K1_1270("totalPdf_K1_1270","",*m_Kpipi,datahist,2);*/
//////
/*RooRealVar* m_Kpipi = ws_K1_1400 -> var("m_Kpipi");*/
/*RooAbsPdf* totalPdf_K1_1400 = ws_K1_1400 -> pdf("totalPdf_K1_1400");*/
/*RooAbsData* data_K1_1400 = ws_K1_1400 -> data("totalPdf_K1_1400Data");*/
/*RooHistPdf* pdf_K1_1400_to_Krho = ws_K1_1400 -> pdf("histPdf_K1_1400toKrho");*/
/*RooRealVar* m_Kpipi = ws_K2_1430 -> var("m_Kpipi");*/
/*RooAbsPdf* totalPdf_K2_1430 = ws_K2_1430 -> pdf("totalPdf_K2_1430");*/
/*RooAbsData* data_K2_1430 = ws_K2_1430 -> data("totalPdf_K2_1430Data");*/
/*RooHistPdf* pdf_K2_1430_to_Krho = ws_K2_1430 -> pdf("histPdf_K2_1430toKrho");*/
// Plotting pdf
/*TCanvas* c1 = new TCanvas("c1","canvas",20,20,1200,600);*/
/*c1->Divide(3,1);*/
/*c1->cd(1);*/
/*RooPlot* frame_K1_1270 = m_Kpipi -> frame(Bins(200),Title("K1(1270) -> K#pi#pi"));*/
/*data_K1_1270->plotOn(frame_K1_1270,DrawOption("C"));*/
/*frame_K1_1270->Draw();*/
/*c1->cd(2);*/
/*RooPlot* frame_K1_1400 = m_Kpipi -> frame(Bins(200),Title("K1(1400) -> K#pi#pi"));*/
/*data_K1_1400->plotOn(frame_K1_1400,DrawOption("C"));*/
/*frame_K1_1400->Draw();*/
/*c1->cd(3);*/
/*RooPlot* frame_K2_1430= m_Kpipi -> frame(Bins(200),Title("K2*(1430) -> K#pi#pi"));*/
/*data_K2_1430->plotOn(frame_K2_1430,DrawOption("C"));*/
/*frame_K2_1430->Draw();*/
////////////////////////////////////////////////////////////////////////
cout << "\n\n >>>> Importing sPlot \n\n" << endl;
TFile *Fworkspace = new TFile("workspace.root");
RooWorkspace* wsp = (RooWorkspace*) Fworkspace->Get("wsp");
wsp->Print();
RooRealVar* B_postcalib_M = wsp -> var("B_postcalib_M");
RooRealVar* nsig_sw = wsp-> var("nsig_sw");
RooRealVar* nbkg_sw = wsp-> var("nbkg_sw");
RooRealVar* B_M13_Subst3_gamma2pi0 = wsp-> var("B_M13_Subst3_gamma2pi0");
RooRealVar* B_M023 = wsp -> var("B_M023");
RooRealVar* K_1_1270_plus_M = wsp -> var("K_1_1270_plus_M");
RooRealVar* K_1_1270_plus_SMALLESTDELTACHI2 = wsp -> var("K_1_1270_plus_SMALLESTDELTACHI2");
RooRealVar* gamma_CL = wsp -> var("gamma_CL");
RooRealVar* piminus_PIDK = wsp -> var("piminus_PIDK");
RooRealVar* piplus_PIDK = wsp -> var("piplus_PIDK");
RooRealVar* Kplus_PIDp = wsp -> var("Kplus_PIDp");
RooRealVar* Kplus_PIDK = wsp -> var("Kplus_PIDK");
RooRealVar* B_M02 = wsp -> var("B_M02");
RooRealVar* L_nsig = wsp -> var("L_nsig");
RooRealVar* L_nbkg = wsp -> var("L_nbkg");
RooArgSet arg(*B_postcalib_M,*gamma_CL,*B_M13_Subst3_gamma2pi0,*B_M023,*piminus_PIDK,*piplus_PIDK,*Kplus_PIDK,*Kplus_PIDp);
arg.add(*K_1_1270_plus_M);
arg.add(*K_1_1270_plus_SMALLESTDELTACHI2);
arg.add(*B_M02);
arg.add(*nsig_sw);
arg.add(*L_nsig);
arg.add(*nbkg_sw);
arg.add(*L_nbkg);
arg.add(*m_Kpipi);
RooDataSet* DataSWeights = (RooDataSet*) wsp -> data("DataSWeights");
RooFormulaVar newMass("m_Kpipi", "m_Kpipi", "K_1_1270_plus_M", RooArgList(*(wsp->var("K_1_1270_plus_M"))));
DataSWeights->addColumn(newMass);
RooDataSet* splot = new RooDataSet(DataSWeights->GetName(),DataSWeights->GetTitle(),DataSWeights,RooArgSet(arg),"","nsig_sw");
cout << "\n\n >>>> Defining components and fitting \n\n" << endl;
// Defining here pdfs for other resonances to be fitted
// K1(1270)
Double_t R = 0.0015; // was 3.1 GeV-1
RooRealVar mean_K1_1270("mean_K1_1270","",1272.,1262.,1282.);
RooRealVar width_K1_1270("width_K1_1270","",90.,70.,110.);
// K1(1270) -> K rho
/*RooBreitWigner totalPdf_K1_1270("totalPdf_K1_1270","",*m_Kpipi,mean_K1_1270,width_K1_1270);*/
/*RooRelBreitWigner totalPdf_K1_1270("totalPdf_K1_1270","totalPdf_K1_1270_rho",*m_Kpipi,mean_K1_1270,width_K1_1270,RooConst(0),RooConst(R),RooConst(770.),RooConst(493.7));*/
// K1(1270) -> K*0(1430) pi
/*RooBreitWigner totalPdf_K1_1270_Kst0_1430("totalPdf_K1_1270_Kst0_1430","totalPdf_K1_1270_Kst0_1430",*m_Kpipi,mean_K1_1270,width_K1_1270);*/
/*RooRelBreitWigner totalPdf_K1_1270_Kst0_1430("totalPdf_K1_1270_Kst0_1430","totalPdf_K1_1270_Kst0_1430",*m_Kpipi,mean_K1_1270,width_K1_1270,RooConst(0),RooConst(R),RooConst(1425.),RooConst(139.6));*/
// K1(1270) -> K*0(892) pi
/*RooBreitWigner totalPdf_K1_1270_Kst0_892("totalPdf_K1_1270_Kst0_892","totalPdf_K1_1270_Kst0_892",*m_Kpipi,mean_K1_1270,width_K1_1270);*/
/*RooRelBreitWigner totalPdf_K1_1270_Kst0_892("totalPdf_K1_1270_Kst0_892","totalPdf_K1_1270_Kst0_892",*m_Kpipi,mean_K1_1270,width_K1_1270,RooConst(0),RooConst(R),RooConst(895.5),RooConst(139.6));*/
// K1(1400)
RooRealVar mean_K1_1400("mean_K1_1400","",1403./*,1396.,1410.*/);
RooRealVar width_K1_1400("width_K1_1400","",174./*,151.,197.*/);
RooBreitWigner totalPdf_K1_1400("totalPdf_K1_1400","",*m_Kpipi,mean_K1_1400,width_K1_1400);
/*[>RooRelBreitWigner totalPdf_K1_1400("totalPdf_K1_1400","totalPdf_K1_1400",*m_Kpipi,mean_K1_1400,width_K1_1400,RooConst(0),RooConst(R),RooConst(895.),RooConst(139.6)); //K*(892) pi is 93%<]*/
// K2*(1430)
RooRealVar mean_K2_1430("mean_K2_1430","",1432./*,1424.,1435.*/);
RooRealVar width_K2_1430("width_K2_1430","",109./*,96.,114.*/);
RooBreitWigner totalPdf_K2_1430("totalPdf_K2_1430","",*m_Kpipi,mean_K2_1430,width_K2_1430);
// K3*(1780)
RooRealVar mean_K3st_1780("mean_K3st_1780","mean_K3st_1780",1776./*,1765.,1785.*/);
RooRealVar width_K3st_1780("width_K3st_1780","width_K3st_1780",159.7/*,150.,170.*/);
RooBreitWigner K3st_1780("K3st_1780","K3st_1780",*m_Kpipi,mean_K3st_1780,width_K3st_1780);
// K2(1770)
RooRealVar mean_K2_1770("mean_K2_1770","mean_K2_1770",1773./*,1763.,1783.*/);
RooRealVar width_K2_1770("width_K2_1770","width_K2_1770",186./*,176.,196.*/);
RooBreitWigner K2_1770("K2_1770","K2_1770",*m_Kpipi,mean_K2_1770,width_K2_1770);
// K2(1580)
RooRealVar mean_K2_1580("mean_K2_1580","mean_K2_1580",1580.);
RooRealVar width_K2_1580("width_K2_1580","width_K2_1580",110.);
RooBreitWigner K2_1580("K2_1580","K2_1580",*m_Kpipi,mean_K2_1580,width_K2_1580);
// K2*(1980)
RooRealVar mean_K2st_1980("mean_K2st_1980","mean_K2st_1980",1973./*,1957.,1999.*/);
RooRealVar width_K2st_1980("width_K2st_1980","width_K2st_1980",373./*,303.,443.*/);
RooBreitWigner K2st_1980("K2st_1980","K2st_1980",*m_Kpipi,mean_K2st_1980,width_K2st_1980);
// K*(1680)
RooRealVar mean_Kst_1680("mean_Kst_1680","mean_K*_1680",1717./*,1690.,1744.*/);
RooRealVar width_Kst_1680("width_Kst_1680","width_K*_1680",322./*,212.,432.*/);
RooBreitWigner Kst_1680("Kst_1680","K*_1680",*m_Kpipi,mean_Kst_1680,width_Kst_1680);
/*width_Kst_1680.setVal(322.);*/
/*width_Kst_1680.setConstant(kTRUE);*/
// K*(1410) mass 1414 +- 15 MeV , width 232 +- 21 MeV
RooRealVar mean_Kst_1410("mean_Kst_1410","",1414./*,1399.,1429.*/);
RooRealVar width_Kst_1410("width_Kst_1410","",232./*,253.,211.*/);
RooBreitWigner Kst_1410("Kst_1410","",*m_Kpipi,mean_Kst_1410,width_Kst_1410);
// Non resonant Kpipi
RooRealVar c0("c0","c0",1.);
RooRealVar c1("c1","c1",1.);
RooRealVar c2("c2","c2",100.,200.);
RooRealVar c3("c3","c3",-.1,+2.);
RooRealVar c4("c4","c4",-2.,0.);
RooGenericPdf non_resonant("non_resonant","non_resonant","(@0 + @1*@5)*exp(@2 + @3*@5 + @4*@5*@5)",RooArgList(c0,c1,c2,c3,c4,*m_Kpipi));
/*RooRealVar par0("par0","par0",-2.,-100.,100.);*/
/*RooRealVar par1("par1","par1",-2.,-100.,100.);*/
/*RooRealVar par2("par2","par2",1.,-100.,100.);*/
/*RooRealVar par3("par3","par3",1.,-100.,100.);*/
/*RooChebychev non_resonant("non_resonant","non_resonant",*m_Kpipi,RooArgList(par0,par1,par2,par3));*/
// defining the yields as the BR wrt K1(1270)
RooRealVar K1_1270_Kst0_1430_br("K1_1270_Kst0_1430_br","K1_1270_Kst0_1430_br",0.41,0.,1.);
RooRealVar K1_1270_Kst0_892_br("K1_1270_Kst0_892_br","K1_1270_Kst0_892_br",0.074,0.,1.);
RooRealVar K1_1400_br("K1_1400_br","K1_1400_br",0.1226,0.,1.); // upper limit only
/*RooRealVar K2_1430_br("K2_1430_br","K2_1430_br",0.07,0.,1.);*/
/*RooRealVar K1_1400_br("K1_1400_br","K1_1400_br",0.1226,0.,0.13); // upper limit only*/
RooRealVar K2_1430_br("K2_1430_br","K2_1430_br",0.07,0.05,0.09); // from Belle
RooRealVar K3st_1780_br("K3st_1780_br","K3st_1780_br",0.1,0.,1.);
RooRealVar K2_1770_br("K2_1770_br","K2_1770_br",0.1,0.,1.);
RooRealVar K2_1580_br("K2_1580_br","K2_1580_br",0.1,0.,1.);
RooRealVar K2st_1980_br("K2st_1980_br","K2st_1980_br",0.1,0.,1.);
RooRealVar Kst_1680_br("Kst_1680_br","K*_1680_br",0.1,0.,1.);
RooRealVar Kst_1410_br("Kst_1410_br","K*_1410_br",0.1,0.,.3);
RooRealVar non_resonant_br("non_resonant_br","non_resonant_br",0.3,0.,2.);
RooRealVar K1_1270_y("K1_1270_y","K1_1270_y",1000.,0.,10000.); // this is the yield of the K1(1270) TO rho
RooFormulaVar K1_1270_Kst0_1430_y("K1_1270_Kst0_1430_y","K1_1270_Kst0_1430_y","@0*@1",RooArgList(K1_1270_Kst0_1430_br,K1_1270_y));
RooFormulaVar K1_1270_Kst0_892_y("K1_1270_Kst0_892_y","K1_1270_Kst0_892_y","@0*@1",RooArgList(K1_1270_Kst0_892_br,K1_1270_y));
RooFormulaVar K1_1400_y("K1_1400_y","K1_1400_y","@0*@1",RooArgList(K1_1400_br,K1_1270_y));
RooFormulaVar K2_1430_y("K2_1430_y","K2_1430_y","@0*@1",RooArgList(K2_1430_br,K1_1270_y));
RooFormulaVar K3st_1780_y("K3st_1780_y","K3st_1780_y","@0*@1",RooArgList(K3st_1780_br,K1_1270_y));
RooFormulaVar K2_1770_y("K2_1770_y","K2_1770_y","@0*@1",RooArgList(K2_1770_br,K1_1270_y));
RooFormulaVar K2_1580_y("K2_1580_y","K2_1580_y","@0*@1",RooArgList(K2_1580_br,K1_1270_y));
RooFormulaVar K2st_1980_y("K2st_1980_y","K2st_1980_y","@0*@1",RooArgList(K2st_1980_br,K1_1270_y));
RooFormulaVar Kst_1680_y("Kst_1680_y","Kst_1680_y","@0*@1",RooArgList(Kst_1680_br,K1_1270_y));
RooFormulaVar Kst_1410_y("Kst_1410_y","Kst_1410_y","@0*@1",RooArgList(Kst_1410_br,K1_1270_y));
RooFormulaVar non_resonant_y("non_resonant_y","non_resonant_y","@0*@1",RooArgList(non_resonant_br,K1_1270_y));
// here add pdfs and FIT sum of pdf to splot
//
RooArgList shapes;
RooArgList yields;
shapes.add(*totalPdf_K1_1270);
shapes.add(*totalPdf_K1_1270_Kst0_1430);
shapes.add(*totalPdf_K1_1270_Kst0_892);
shapes.add(totalPdf_K1_1400);
shapes.add(totalPdf_K2_1430);
shapes.add(K3st_1780);
/*shapes.add(K2_1770);*/
shapes.add(K2_1580);
shapes.add(K2st_1980);
shapes.add(Kst_1680);
/*shapes.add(Kst_1410);*/
/*shapes.add(non_resonant);*/
yields.add(K1_1270_y);
yields.add(K1_1270_Kst0_1430_y);
yields.add(K1_1270_Kst0_892_y);
yields.add(K1_1400_y);
yields.add(K2_1430_y);
yields.add(K3st_1780_y);
/*yields.add(K2_1770_y);*/
yields.add(K2_1580_y);
yields.add(K2st_1980_y);
yields.add(Kst_1680_y);
/*yields.add(Kst_1410_y);*/
/*yields.add(non_resonant_y);*/
// Putting all pdfs together
RooAddPdf PDF("PDF","total Pdf for the resonances considered", shapes,yields);
/*PDF->fitTo(*splot,Extended(),SumW2Error(kFALSE),Range(1000,2000));*/
PDF.fitTo(*splot,Extended(),SumW2Error(kTRUE),Range(xmin,xmax));
// Defining frames for plotting
cout << "\n\n >>>> Plotting \n\n" << endl;
RooPlot* frame_splot = m_Kpipi->frame(Title("sPlot of m_{K#pi#pi} [MeV/c^{2}]"),Range(xmin,xmax),Bins(nbins));
splot->plotOn(frame_splot,Name("fitted_splot")/*,DataError(RooAbsData::SumW2)*/);
PDF.paramOn(frame_splot,Layout(.65,.9,.99)); // Layout(xmin,ymin,ymax)
PDF.plotOn(frame_splot,Components(*totalPdf_K1_1270),LineColor(kRed));
PDF.plotOn(frame_splot,Components(*totalPdf_K1_1270_Kst0_1430),LineColor(kRed),LineStyle(kDashed));
PDF.plotOn(frame_splot,Components(*totalPdf_K1_1270_Kst0_892),LineColor(kRed));
PDF.plotOn(frame_splot,Components(totalPdf_K1_1400),LineColor(1));
PDF.plotOn(frame_splot,Components(totalPdf_K2_1430),LineColor(51),LineStyle(kDashed));
PDF.plotOn(frame_splot,Components(K3st_1780),LineColor(kOrange),LineStyle(kDashed));
/*PDF.plotOn(frame_splot,Components(K2_1770),LineColor(5),LineStyle(kDashed));*/
PDF.plotOn(frame_splot,Components(K2_1580),LineColor(12),LineStyle(kDashed));
PDF.plotOn(frame_splot,Components(K2st_1980),LineColor(16),LineStyle(kDashed));
PDF.plotOn(frame_splot,Components(Kst_1680),LineColor(32),LineStyle(kDashed));
PDF.plotOn(frame_splot,Components(Kst_1410),LineColor(3),LineStyle(kDashed));
PDF.plotOn(frame_splot,Components(non_resonant),LineColor(5),LineStyle(kDashed));
PDF.plotOn(frame_splot);
// Plotting with residuals
TCanvas* canvas_sPlot = new TCanvas("canvas_sPlot","sPlot with weights",40,20,1200,800);
plot_with_residuals(*canvas_sPlot,*frame_splot,*m_Kpipi,nbins,xmin,xmax); // residuals(TCanvas& _canvas,RooPlot& _frame,RooRealVar& var,Int_t& _nbins,Double_t& r_min,Double_t& r_max)
// CleanUp worspaces
delete ws_K1_1270;
/*delete ws_K1_1400;*/
/*delete ws_K2_1430;*/
delete wsp;
cout << "\n\n >>>> THE END \n\n" << endl;
/*cout << gMinuit->GetStatus() << endl;*/
}
void fit_mass(TString fileN="") {//suffix added before file extension, e.g., '.pdf'
TString placeholder;//to add strings before using them, e.g., for saving text files
gROOT->SetBatch(kTRUE);
gROOT->ProcessLine(".x /afs/cern.ch/user/m/mwilkins/cmtuser/src/lhcbStyle.C");
// gStyle->SetPadTickX(1);
// gStyle->SetPadTickY(1);
// gStyle->SetPadLeftMargin(0.15);
// gStyle->SetTextSize(0.3);
// //open file and get histogram
// TFile *inHistos = new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/data/histos_data.root", "READ");
// TH1F * h100 = (TH1F*)inHistos->Get("h70");
// cout<<"data histogram gotten"<<endl;
//unbinned
TFile *hastree = new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/data/cutfile_Optimized.root", "READ");
TTree * h100 = (TTree*)hastree->Get("mytree");
cout<<"tree gotten"<<endl;
TFile *SMChistos= new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/MC/withKScut/histos_SMCfile_fullMC.root", "READ");
cout<<"SMC file opened"<<endl;
TH1F *SMCh = (TH1F*)SMChistos->Get("h00");
cout<<"SMC hist gotten"<<endl;
RooRealVar *mass = new RooRealVar("Bs_LOKI_MASS_JpsiConstr","m(J/#psi #Lambda)",4100,6100,"MeV");
mass->setRange("bkg1",4300,4800);
mass->setRange("bkg2",5700,5950);
mass->setRange("bkg3",4300,5500);
mass->setRange("bkg4",5100,5500);
mass->setRange("L",5350,5950);
mass->setRange("tot",4300,5950);
cout<<"mass declared"<<endl;
// RooDataHist *data = new RooDataHist("data","1D",RooArgList(*mass),h100);
//unbinned
RooDataSet *data = new RooDataSet("data","1D",h100,*mass);
cout<<"data declared"<<endl;
RooDataHist *SMC = new RooDataHist("SMC","1D",RooArgList(*mass),SMCh);
cout<<"SMC hist assigned to RooDataHist"<<endl;
// Construct Pdf Model
// /\0
//gaussian
RooRealVar mean1L("mean1L","/\\ gaus 1: mean",5621.103095,5525,5700);
RooRealVar sig1L("sig1L","/\\ gaus 1: sigma",6.898126,0,100);
RooGaussian gau1L("gau1L","#Lambda signal: gaussian 1",*mass,mean1L,sig1L);
RooFormulaVar mean2L("mean2L","@0",mean1L);
RooRealVar sig2L("sig2L","/\\ gaus 2: sigma",14.693117,0,100);
RooGaussian gau2L("gau2L","#Lambda signal: gaussian 2",*mass,mean2L,sig2L);
RooRealVar f1L("f1L","/\\ signal: fraction gaussian 1",0.748776,0,1);
RooAddPdf sigL("sigL","#Lambda signal",RooArgList(gau1L,gau2L),RooArgList(f1L));
// //CB
// RooRealVar mean3L("mean3L","/\\ CB: mean",5621.001,5525,5700);
// RooRealVar sig3L("sig3L","/\\ CB: sigma",5.161,0,100);
// RooRealVar alphaL3("alphaL3","/\\ CB: alpha",2.077,0,1000);
// RooRealVar nL3("nL1","/\\ CB: n",0.286,0,1000);
// RooCBShape CBL("CBL","#Lambda signal: CB",*mass,mean3L,sig3L,alphaL3,nL3);
// RooRealVar mean4L("mean4L","/\\ gaus: mean",5621.804,5525,5700);
// RooRealVar sig4L("sig4L","/\\ gaus: sigma",10.819,0,100);
// RooGaussian gauL("gauL","#Lambda signal: gaussian",*mass,mean4L,sig4L);
// RooRealVar f1L("f1L","/\\ signal: fraction CB",0.578,0,1);
// RooAddPdf sigL("sigL","#Lambda signal",RooArgList(CBL,gauL),RooArgList(f1L));
// sigma0
//using RooHistPdf from MC--no need to build pdf here
RooHistPdf sigS = makeroohistpdf(SMC,mass,"sigS","#Sigma^{0} signal (RooHistPdf)");
// /\*
cout<<"Lst stuff"<<endl;
RooRealVar meanLst1("meanLst1","/\\*(misc.): mean1",5011.031237,4900,5100);
RooRealVar sigLst1("sigLst1","/\\*(misc.): sigma1",70.522092,0,100);
RooRealVar meanLst2("mean5Lst2","/\\*(1405): mean2",5245.261703,5100,5350);
RooRealVar sigLst2("sigLst2","/\\*(1405): sigma2",64.564763,0,100);
RooRealVar alphaLst2("alphaLst2","/\\*(1405): alpha2",29.150301);
RooRealVar nLst2("nLst2","/\\*(1405): n2",4.615817,0,50);
RooGaussian gauLst1("gauLst1","#Lambda*(misc.), gaus",*mass,meanLst1,sigLst1);
RooCBShape gauLst2("gauLst2","#Lambda*(1405), CB",*mass,meanLst2,sigLst2,alphaLst2,nLst2);
// RooRealVar fLst1("fLst1","/\\* bkg: fraction gaus 1",0.743,0,1);
// RooAddPdf bkgLst("bkgLst","#Lambda* signal",RooArgList(gauLst1,gauLst2),RooArgList(fLst1));
//Poly func BKG mass
// RooRealVar b0("b0","Background: Chebychev b0",-1.071,-10000,10000);
RooRealVar b1("b1","Background: Chebychev b1",-1.323004,-10,-0.00000000000000000000001);
RooRealVar b2("b2","Background: Chebychev b2",0.145494,0,10);
RooRealVar b3("b3","Background: Chebychev b3",-0.316,-10000,10000);
RooRealVar b4("b4","Background: Chebychev b4",0.102,-10000,10000);
RooRealVar b5("b5","Background: Chebychev b5",0.014,-10000,10000);
RooRealVar b6("b6","Background: Chebychev b6",-0.015,-10000,10000);
RooRealVar b7("b7","Background: Chebychev b7",0.012,-10000,10000);
RooArgList bList(b1,b2);
RooChebychev bkg("bkg","Background", *mass, bList);
// TF1 *ep = new TF1("ep","[2]*exp([0]*x+[1]*x*x)",4300,5950);
// ep->SetParameter(0,1);
// ep->SetParameter(1,-1);
// ep->SetParameter(2,2000);
// ep->SetParName(0,"a");
// ep->SetParName(1,"b");
// ep->SetParName(2,"c");
// RooRealVar a("a","Background: Coefficent of x",1,-10000,10000);
// RooRealVar b("b","Background: Coefficent of x*x",-1,-10000,10000);
// RooRealVar c("c","Background: Coefficent of exp()",2000,-10000,10000);
// RooTFnPdfBinding bkg("ep","ep",ep,RooArgList(*mass,a,b));
//number of each shape
RooRealVar nbkg("nbkg","N bkg",2165.490249,0,100000000);
RooRealVar nsigL("nsigL","N /\\",1689.637290,0,1000000000);
RooRealVar nsigS("nsigS","N sigma",0.000002,0,10000000000);
RooRealVar ngauLst1("ngauLst1","N /\\*(misc.)",439.812103,0,10000000000);
RooRealVar ngauLst2("ngauLst2","N /\\*(1405)",152.061617,0,10000000000);
RooRealVar nbkgLst("nbkgLst","N /\\*",591.828,0,1000000000);
//add shapes and their number to a totalPdf
RooArgList shapes;
RooArgList yields;
shapes.add(sigL); yields.add(nsigL);
shapes.add(sigS); yields.add(nsigS);
// shapes.add(bkgLst); yields.add(nbkgLst);
shapes.add(gauLst1); yields.add(ngauLst1);
shapes.add(gauLst2); yields.add(ngauLst2);
shapes.add(bkg); yields.add(nbkg);
RooAddPdf totalPdf("totalPdf","totalPdf",shapes,yields);
//fit the totalPdf
RooAbsReal * nll = totalPdf.createNLL(*data,Extended(kTRUE),Range("tot"));
RooMinuit m(*nll);
m.setVerbose(kFALSE);
m.migrad();
m.minos();
m.minos();
//display and save information
ofstream textfile;//create text file to hold data
placeholder = "plots/fit"+fileN+".txt";
textfile.open(placeholder);
TString outputtext;//for useful text
//plot things
RooPlot *framex = mass->frame();
framex->GetYaxis()->SetTitle("Events/(5 MeV)");
data->plotOn(framex,Name("Hist"),MarkerColor(kBlack),LineColor(kBlack),DataError(RooAbsData::SumW2));
totalPdf.plotOn(framex,Name("curvetot"),LineColor(kBlue));
RooArgSet* totalPdfComponents = totalPdf.getComponents();
TIterator* itertPC = totalPdfComponents->createIterator();
RooAddPdf* vartPC = (RooAddPdf*) itertPC->Next();
vartPC = (RooAddPdf*) itertPC->Next();//skip totalPdf
int i=0;//color index
TLegend *leg = new TLegend(0.2, 0.02, .4, .42);
leg->SetTextSize(0.06);
leg->AddEntry(framex->findObject("curvetot"),"Total PDF","l");
while(vartPC){//loop over compotents of totalPdf
TString vartPCtitle = vartPC->GetTitle();
TIterator* itercompPars;//forward declare so it persists outside the if statement
RooRealVar* varcompPars;
if(!(vartPCtitle.Contains(":")||vartPCtitle.Contains("@"))){//only for non-sub-shapes
while(i==0||i==10||i==4||i==1||i==5||(i>=10&&i<=27))i++;//avoid white and blue and black and yellow and horribleness
RooArgSet* compPars = vartPC->getParameters(data);//set of the parameters of the component the loop is on
itercompPars = compPars->createIterator();
varcompPars = (RooRealVar*) itercompPars->Next();
while(varcompPars){//write and print mean, sig, etc. of sub-shapes
TString vartitle = varcompPars->GetTitle();
double varval = varcompPars->getVal();
TString varvalstring = Form("%f",varval);
double hi = varcompPars->getErrorHi();
TString varerrorstring = "[exact]";
if(hi!=-1){
double lo = varcompPars->getErrorLo();
double varerror = TMath::Max(fabs(lo),hi);
varerrorstring = Form("%E",varerror);
}
outputtext = vartitle+" = "+varvalstring+" +/- "+varerrorstring;
textfile<<outputtext<<endl;
cout<<outputtext<<endl;
varcompPars = (RooRealVar*) itercompPars->Next();
}
totalPdf.plotOn(framex,Name(vartPC->GetName()),LineStyle(kDashed),LineColor(i),Components(vartPC->GetName()));
leg->AddEntry(framex->findObject(vartPC->GetName()),vartPCtitle,"l");
i++;
}
vartPC = (RooAddPdf*) itertPC->Next();
itercompPars->Reset();//make sure it's ready for the next vartPC
}
// Calculate chi2/ndf
RooArgSet *floatpar = totalPdf.getParameters(data);
int floatpars = (floatpar->selectByAttrib("Constant",kFALSE))->getSize();
Double_t chi2 = framex->chiSquare("curvetot","Hist",floatpars);
TString chi2string = Form("%f",chi2);
//create text box to list important parameters on the plot
// TPaveText* txt = new TPaveText(0.1,0.5,0.7,0.9,"NBNDC");
// txt->SetTextSize(0.06);
// txt->SetTextColor(kBlack);
// txt->SetBorderSize(0);
// txt->SetFillColor(0);
// txt->SetFillStyle(0);
outputtext = "#chi^{2}/N_{DoF} = "+chi2string;
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
// txt->AddText(outputtext);
// Print stuff
TIterator* iteryields = yields.createIterator();
RooRealVar* varyields = (RooRealVar*) iteryields->Next();//only inherits things from TObject unless class specified
vector<double> Y, E;//holds yields and associated errors
vector<TString> YS, ES;//holds strings of the corresponding yields
int j=0;//count vector position
int jS=0, jL=0;//these hold the position of the S and L results;initialized in case there is no nsigS or nsigL
while(varyields){//loop over yields
TString varname = varyields->GetName();
TString vartitle = varyields->GetTitle();
double varval = varyields->getVal();
Y.push_back(varval);
double lo = varyields->getErrorLo();
double hi = varyields->getErrorHi();
E.push_back(TMath::Max(fabs(lo),hi));
YS.push_back(Form("%f",Y[j]));
ES.push_back(Form("%f",E[j]));
if(varname=="nsigS") jS=j;
if(varname=="nsigL") jL=j;
outputtext = vartitle+" = "+YS[j]+" +/- "+ES[j];
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
//txt->AddText(outputtext);
varyields = (RooRealVar*) iteryields->Next();
j++;
}
//S/L
double result = Y[jS]/Y[jL];
cout<<"result declared"<<endl;
double E_result = TMath::Abs(result)*sqrt(pow(E[jS]/Y[jS],2)+pow(E[jL]/Y[jL],2));
cout<<"E_result declared"<<endl;
TString resultstring = Form("%E",result);
TString E_resultstring = Form("%E",E_result);
outputtext = "Y_{#Sigma^{0}}/Y_{#Lambda} = "+resultstring+" +/- "+E_resultstring;
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
//txt->AddText(outputtext);
double resultlimit = (Y[jS]+E[jS])/(Y[jL]-E[jL]);
outputtext = Form("%E",resultlimit);
outputtext = "limit = "+outputtext;
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
//txt->AddText(outputtext);
// Create canvas and pads, set style
TCanvas *c1 = new TCanvas("c1","data fits",1200,800);
TPad *pad1 = new TPad("pad1","pad1",0.0,0.3,1.0,1.0);
TPad *pad2 = new TPad("pad2","pad2",0.0,0.0,1.0,0.3);
pad1->SetBottomMargin(0);
pad2->SetTopMargin(0);
pad2->SetBottomMargin(0.5);
pad2->SetBorderMode(0);
pad1->SetBorderMode(0);
c1->SetBorderMode(0);
pad2->Draw();
pad1->Draw();
pad1->cd();
framex->SetMinimum(1);
framex->SetMaximum(3000);
framex->addObject(leg);//add legend to frame
//framex->addObject(txt);//add text to frame
gPad->SetTopMargin(0.06);
pad1->SetLogy();
// pad1->Range(4100,0,6100,0.0005);
pad1->Update();
framex->Draw();
// Pull distribution
RooPlot *framex2 = mass->frame();
RooHist* hpull = framex->pullHist("Hist","curvetot");
framex2->addPlotable(hpull,"P");
hpull->SetLineColor(kBlack);
hpull->SetMarkerColor(kBlack);
framex2->SetTitle(0);
framex2->GetYaxis()->SetTitle("Pull");
framex2->GetYaxis()->SetTitleSize(0.15);
framex2->GetYaxis()->SetLabelSize(0.15);
framex2->GetXaxis()->SetTitleSize(0.2);
framex2->GetXaxis()->SetLabelSize(0.15);
framex2->GetYaxis()->CenterTitle();
framex2->GetYaxis()->SetTitleOffset(0.45);
framex2->GetXaxis()->SetTitleOffset(1.1);
framex2->GetYaxis()->SetNdivisions(505);
framex2->GetYaxis()->SetRangeUser(-8.8,8.8);
pad2->cd();
framex2->Draw();
c1->cd();
placeholder = "plots/fit"+fileN+".eps";
c1->Print(placeholder);
placeholder = "plots/fit"+fileN+".C";
c1->SaveAs(placeholder);
textfile.close();
}
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 MuScale() {
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
// event category enumeration
enum { eMuMu2HLT=1, eMuMu1HLT1L1, eMuMu1HLT, eMuMuNoSel, eMuSta, eMuTrk }; // event category enum
TString outputDir = "MuScaleResults";
vector<TString> infilenamev;
infilenamev.push_back("/afs/cern.ch/work/c/cmedlock/public/wz-ntuples/Zmumu/ntuples/data_select.trkCuts.root"); // data
infilenamev.push_back("/afs/cern.ch/work/c/cmedlock/public/wz-ntuples/Zmumu/ntuples/zmm_select.raw.trkCuts.root"); // MC
const Double_t MASS_LOW = 60;
const Double_t MASS_HIGH = 120;
const Double_t PT_CUT = 25;
const Double_t ETA_CUT = 2.4;
const Double_t MU_MASS = 0.105658369;
vector<pair<Double_t,Double_t> > scEta_limits;
scEta_limits.push_back(make_pair(0.0,1.2));
scEta_limits.push_back(make_pair(1.2,2.1));
scEta_limits.push_back(make_pair(2.1,2.4));
CPlot::sOutDir = outputDir;
const TString format("png");
//--------------------------------------------------------------------------------------------------------------
// Main analysis code
//==============================================================================================================
enum { eData=0, eMC };
char hname[100];
vector<TH1D*> hMCv, hDatav;
for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
for(UInt_t jbin=ibin; jbin<scEta_limits.size(); jbin++) {
sprintf(hname,"mc_%i_%i",ibin,jbin);
hMCv.push_back(new TH1D(hname,"",80,MASS_LOW,MASS_HIGH));
hMCv.back()->Sumw2();
sprintf(hname,"data_%i_%i",ibin,jbin);
hDatav.push_back(new TH1D(hname,"",80,MASS_LOW,MASS_HIGH));
hDatav.back()->Sumw2();
}
}
//
// Declare output ntuple variables
//
UInt_t runNum, lumiSec, evtNum;
Float_t scale1fb, puWeight;
UInt_t matchGen;
UInt_t category;
UInt_t npv, npu;
Int_t q1, q2;
TLorentzVector *dilep=0, *lep1=0, *lep2=0;
for(UInt_t ifile=0; ifile<infilenamev.size(); ifile++) {
cout << "Processing " << infilenamev[ifile] << "..." << endl;
TFile *infile = TFile::Open(infilenamev[ifile]);
assert(infile);
TTree *intree = (TTree*)infile->Get("Events");
assert(intree);
intree->SetBranchAddress("runNum", &runNum); // event run number
intree->SetBranchAddress("lumiSec", &lumiSec); // event lumi section
intree->SetBranchAddress("evtNum", &evtNum); // event number
intree->SetBranchAddress("scale1fb", &scale1fb); // event weight
intree->SetBranchAddress("puWeight", &puWeight); // pileup reweighting
intree->SetBranchAddress("matchGen", &matchGen); // event has both leptons matched to MC Z->ll
intree->SetBranchAddress("category", &category); // dilepton category
intree->SetBranchAddress("npv", &npv); // number of primary vertices
intree->SetBranchAddress("npu", &npu); // number of in-time PU events (MC)
intree->SetBranchAddress("q1", &q1); // charge of lead lepton
intree->SetBranchAddress("q2", &q2); // charge of trail lepton
intree->SetBranchAddress("dilep", &dilep); // dilepton 4-vector
intree->SetBranchAddress("lep1", &lep1); // lead lepton 4-vector
intree->SetBranchAddress("lep2", &lep2); // trail lepton 4-vector
for(UInt_t ientry=0; ientry<intree->GetEntries(); ientry++) {
intree->GetEntry(ientry);
Double_t weight = 1;
if(ifile==eMC) {
//if(!matchGen) continue;
weight=scale1fb*puWeight*1.1*TMath::Power(10,7)/5610.0;
}
if((category!=eMuMu2HLT) && (category!=eMuMu1HLT) && (category!=eMuMu1HLT1L1)) continue;
if(q1 == q2) continue;
if(dilep->M() < MASS_LOW) continue;
if(dilep->M() > MASS_HIGH) continue;
if(lep1->Pt() < PT_CUT) continue;
if(lep2->Pt() < PT_CUT) continue;
if(fabs(lep1->Eta()) > ETA_CUT) continue;
if(fabs(lep2->Eta()) > ETA_CUT) continue;
TLorentzVector vLep1(0,0,0,0);
TLorentzVector vLep2(0,0,0,0);
vLep1.SetPtEtaPhiM(lep1->Pt(), lep1->Eta(), lep1->Phi(), MU_MASS);
vLep2.SetPtEtaPhiM(lep2->Pt(), lep2->Eta(), lep2->Phi(), MU_MASS);
TLorentzVector vDilep = vLep1 + vLep2;
Int_t bin1=-1, bin2=-1;
for(UInt_t i=0; i<scEta_limits.size(); i++) {
Double_t etalow = scEta_limits.at(i).first;
Double_t etahigh = scEta_limits.at(i).second;
if(fabs(lep1->Eta())>=etalow && fabs(lep1->Eta())<=etahigh) bin1=i;
if(fabs(lep2->Eta())>=etalow && fabs(lep2->Eta())<=etahigh) bin2=i;
}
assert(bin1>=0);
assert(bin2>=0);
Int_t ibin= (bin1<=bin2) ? bin1 : bin2;
Int_t jbin= (bin1<=bin2) ? bin2 : bin1;
UInt_t n=jbin-ibin;
for(Int_t k=0; k<ibin; k++)
n+=(scEta_limits.size()-k);
if(ifile==eData) hDatav[n]->Fill(vDilep.M(),weight);
if(ifile==eMC) hMCv[n]->Fill(vDilep.M(),weight);
}
delete infile;
infile=0, intree=0;
}
//
// Fit for energy scale and resolution corrections
//
char vname[100]; // buffer for RooFit object names
char pname[100];
char str1[100];
char str2[100];
TCanvas *c = MakeCanvas("c","c",800,600);
// Dummy histograms for TLegend (I can't figure out how to properly pass RooFit objects...)
TH1D *hDummyData = new TH1D("hDummyData","",0,0,10);
hDummyData->SetMarkerStyle(kFullCircle);
hDummyData->SetMarkerSize(0.9);
TH1D *hDummyMC = new TH1D("hDummyMC","",0,0,10);
hDummyMC->SetLineColor(kBlue);
hDummyMC->SetFillColor(kBlue);
hDummyMC->SetFillStyle(3002);
TH1D *hDummyFit = new TH1D("hDummyFit","",0,0,10);
hDummyFit->SetLineColor(kGreen+2);
RooRealVar mass("mass","M_{#mu#mu}",60.0,120.0,"GeV") ;
mass.setBins(1600,"cache");
RooRealVar massmc("massmc","massmc",0.0,150.0,"GeV"); // mass variable for building MC template
RooCategory zscEta_cat("zscEta_cat","zscEta_cat");
RooSimultaneous combscalefit("combscalefit","combscalefit",zscEta_cat);
map<string,TH1*> hmap; // Mapping of category labels and data histograms
RooArgList scalebins; // List of RooRealVars storing per bin energy scale corrections
RooArgList sigmabins; // List of RooRealVars storing per bin energy resolution corrections
Int_t intOrder = 1; // Interpolation order for
for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
sprintf(vname,"scale_%i",ibin);
RooRealVar *scalebinned = new RooRealVar(vname,vname,1.0,0.5,1.5);
scalebins.add(*scalebinned);
sprintf(vname,"sigma_%i",ibin);
RooRealVar *sigmabinned = new RooRealVar(vname,vname,1.0,0.0,2.0);
sigmabins.add(*sigmabinned);
}
for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
for(UInt_t jbin=ibin; jbin<scEta_limits.size(); jbin++) {
UInt_t n=jbin-ibin;
for(UInt_t k=0; k<ibin; k++)
n+=(scEta_limits.size()-k);
sprintf(vname,"masslinearshifted_%i_%i",ibin,jbin);
RooFormulaVar *masslinearshifted = new RooFormulaVar(vname,vname,"sqrt(@0*@1)",RooArgList(*scalebins.at(ibin),*scalebins.at(jbin)));
sprintf(vname,"massshiftedscEta_%i_%i",ibin,jbin);
RooLinearVar *massshiftedscEta = new RooLinearVar(vname,vname,mass,*masslinearshifted,RooConst(0.0));
// MC-based template
sprintf(vname,"zmassmcscEta_%i_%i",ibin,jbin);
RooDataHist *zmassmcscEta = new RooDataHist(vname,vname,RooArgList(massmc),hMCv[n]);
sprintf(vname,"masstemplatescEta_%i_%i",ibin,jbin);
RooHistPdf *masstemplatescEta = new RooHistPdf(vname,vname,RooArgList(*massshiftedscEta),RooArgList(massmc),*zmassmcscEta,intOrder);
// Gaussian smearing function
sprintf(vname,"sigmascEta_%i_%i",ibin,jbin);
RooFormulaVar *sigmascEta = new RooFormulaVar(vname,vname,"sqrt(@0*@0+@1*@1)",RooArgList(*sigmabins.at(ibin),*sigmabins.at(jbin)));
sprintf(vname,"resscEta_%i_%i",ibin,jbin);
RooGaussian *resscEta = new RooGaussian(vname,vname,mass,RooConst(0.),*sigmascEta);
// Fit model: MC-template convoluted with Gaussian
sprintf(vname,"fftscEta_%i_%i",ibin,jbin);
RooFFTConvPdf *fftscEta = new RooFFTConvPdf(vname,vname,mass,*masstemplatescEta,*resscEta);
fftscEta->setBufferStrategy(RooFFTConvPdf::Flat);
// Add bin as a category
char zscEta_catname[100];
sprintf(zscEta_catname,"zscEta_cat_%i_%i",ibin,jbin);
zscEta_cat.defineType(zscEta_catname);
zscEta_cat.setLabel(zscEta_catname);
hmap.insert(pair<string,TH1*>(zscEta_catname,hDatav[n]));
combscalefit.addPdf(*fftscEta,zscEta_catname);
}
}
// perform fit
RooDataHist zdatascEta_comb("zdatascEta_comb","zdatascEta_comb",RooArgList(mass),zscEta_cat,hmap,1.0);
combscalefit.fitTo(zdatascEta_comb,PrintEvalErrors(kFALSE),Minos(kFALSE),Strategy(0),Minimizer("Minuit2",""));
Double_t xval[scEta_limits.size()];
Double_t xerr[scEta_limits.size()];
Double_t scaleDatatoMC[scEta_limits.size()];
Double_t scaleDatatoMCerr[scEta_limits.size()];
Double_t scaleMCtoData[scEta_limits.size()];
Double_t scaleMCtoDataerr[scEta_limits.size()];
Double_t sigmaMCtoData[scEta_limits.size()];
Double_t sigmaMCtoDataerr[scEta_limits.size()];
for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
Double_t etalow = scEta_limits.at(ibin).first;
Double_t etahigh = scEta_limits.at(ibin).second;
xval[ibin] = 0.5*(etahigh+etalow);
xerr[ibin] = 0.5*(etahigh-etalow);
scaleDatatoMC[ibin] = ((RooRealVar*)scalebins.at(ibin))->getVal();
scaleDatatoMCerr[ibin] = ((RooRealVar*)scalebins.at(ibin))->getError();
scaleMCtoData[ibin] = 1.0/scaleDatatoMC[ibin];
scaleMCtoDataerr[ibin] = scaleDatatoMCerr[ibin]/scaleDatatoMC[ibin]/scaleDatatoMC[ibin];
sigmaMCtoData[ibin] = ((RooRealVar*)sigmabins.at(ibin))->getVal();
sigmaMCtoDataerr[ibin] = ((RooRealVar*)sigmabins.at(ibin))->getError();
}
TGraphErrors *grScaleDatatoMC = new TGraphErrors(scEta_limits.size(),xval,scaleDatatoMC,xerr,scaleDatatoMCerr);
TGraphErrors *grScaleMCtoData = new TGraphErrors(scEta_limits.size(),xval,scaleMCtoData,xerr,scaleMCtoDataerr);
TGraphErrors *grSigmaMCtoData = new TGraphErrors(scEta_limits.size(),xval,sigmaMCtoData,xerr,sigmaMCtoDataerr);
CPlot plotScale1("mu_scale_datatomc","","Muon |#eta|","Data scale correction");
plotScale1.AddGraph(grScaleDatatoMC,"",kBlue);
plotScale1.SetYRange(0.98,1.02);
plotScale1.AddLine(0,1,2.5,1,kBlack,7);
plotScale1.Draw(c,kTRUE,format);
CPlot plotScale2("mu_scale_mctodata","","Muon |#eta|","MC#rightarrowData scale correction");
plotScale2.AddGraph(grScaleMCtoData,"",kBlue);
plotScale2.SetYRange(0.98,1.02);
plotScale2.AddLine(0,1,2.5,1,kBlack,7);
plotScale2.Draw(c,kTRUE,format);
CPlot plotRes("mu_res_mctodata","","Muon |#eta|","MC#rightarrowData additional smear [GeV]");
plotRes.AddGraph(grSigmaMCtoData,"",kBlue);
plotRes.SetYRange(0,1.6);
plotRes.Draw(c,kTRUE,format);
double nData=0;
for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
for(UInt_t jbin=ibin; jbin<scEta_limits.size(); jbin++) {
UInt_t n=jbin-ibin;
for(UInt_t k=0; k<ibin; k++)
n+=(scEta_limits.size()-k);
// Post-fit plot
RooPlot *frame = mass.frame();
char catname[100];
sprintf(catname,"zscEta_cat_%i_%i",ibin,jbin);
char cutstr[100];
sprintf(cutstr,"zscEta_cat==zscEta_cat::%s",catname);
RooDataHist zmc(catname,catname,RooArgList(mass),hMCv[n]);
RooHistPdf mctemplate(catname,catname,RooArgList(mass),zmc,intOrder);
//mctemplate.plotOn(frame,LineColor(kBlue),LineWidth(1),Normalization(hDatav[n]->GetEntries()));
mctemplate.plotOn(frame,LineColor(kBlue),LineWidth(1),Normalization(hDatav[n]->Integral()));
//mctemplate.plotOn(frame,LineColor(kBlue),FillColor(kBlue),FillStyle(3002),DrawOption("F"),Normalization(hDatav[n]->GetEntries()));
mctemplate.plotOn(frame,LineColor(kBlue),FillColor(kBlue),FillStyle(3002),DrawOption("F"),Normalization(hDatav[n]->Integral()));
zdatascEta_comb.plotOn(frame,Cut(cutstr),MarkerStyle(kFullCircle),MarkerSize(1.0),DrawOption("ZP"));
combscalefit.plotOn(frame,Slice(zscEta_cat,catname),ProjWData(RooArgSet(mass,catname),zdatascEta_comb),
LineColor(kGreen+2));
sprintf(pname,"postfit_%i_%i",ibin,jbin);
sprintf(str1,"[%.1f, %.1f]",scEta_limits.at(ibin).first,scEta_limits.at(ibin).second);
sprintf(str2,"[%.1f, %.1f]",scEta_limits.at(jbin).first,scEta_limits.at(jbin).second);
CPlot plot(pname,frame,"","m(#mu^{+}#mu^{-}) [GeV/c^{2}]","Events / 0.6 GeV/c^{2}");
plot.AddTextBox(str1,0.21,0.80,0.45,0.87,0,kBlack,-1);
plot.AddTextBox(str2,0.21,0.73,0.45,0.80,0,kBlack,-1);
plot.SetLegend(0.75,0.64,0.93,0.88);
plot.GetLegend()->AddEntry(hDummyData,"Data","PL");
plot.GetLegend()->AddEntry(hDummyMC,"Sim","FL");
plot.GetLegend()->AddEntry(hDummyFit,"Fit","L");
plot.Draw(c,kTRUE,format);
nData += hDatav[n]->Integral();
}
}
cout<<"nData = "<<nData<<endl;
//--------------------------------------------------------------------------------------------------------------
// Output
//==============================================================================================================
cout << "*" << endl;
cout << "* SUMMARY" << endl;
cout << "*--------------------------------------------------" << endl;
cout << endl;
ofstream txtfile;
char txtfname[100];
sprintf(txtfname,"%s/summary.txt",outputDir.Data());
txtfile.open(txtfname);
assert(txtfile.is_open());
txtfile << " Data->MC scale correction" << endl;
for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
Double_t etalow = scEta_limits.at(ibin).first;
Double_t etahigh = scEta_limits.at(ibin).second;
txtfile << "$" << etalow << " < |\\eta| < " << etahigh << "$ & ";
txtfile << "$" << ((RooRealVar*)scalebins.at(ibin))->getVal() << "$ \\pm $" << ((RooRealVar*)scalebins.at(ibin))->getError() << "$ \\\\" << endl;
}
txtfile << endl;
txtfile << " MC->Data resolution correction [GeV]" << endl;
for(UInt_t ibin=0; ibin<scEta_limits.size(); ibin++) {
Double_t etalow = scEta_limits.at(ibin).first;
Double_t etahigh = scEta_limits.at(ibin).second;
txtfile << etalow << " < |\\eta| < " << etahigh << " & ";
txtfile << "$" << ((RooRealVar*)sigmabins.at(ibin))->getVal() << "$ \\pm $" << ((RooRealVar*)sigmabins.at(ibin))->getError() << "$ \\\\" << endl;
}
txtfile.close();
cout << endl;
cout << " <> Output saved in " << outputDir << "/" << endl;
cout << endl;
}
void makeSystPlot( TFile * f, TString oldFolder, RooWorkspace *WS, string channel, string syst, int toMassNo, int fromMassNo) //massNo 0-51, see xSec7TeV.h
{
RooArgList * hobs = new RooArgList("hobs");
RooRealVar BDT("CMS_vhbb_BDT_Zll", "CMS_vhbb_BDT_Zll", -1, 1);///OLD VARIABLE NAME HERE
hobs->add(*WS->var("CMS_vhbb_BDT_Zll")); ///NEW VARIABLE NAME HERE
RooWorkspace *tempWS = (RooWorkspace*) f->Get(oldFolder.Data());
TString systT(syst);
TString chanT(channel);
bool writeIt = 1;
if(chanT.Contains("QCD") || chanT.Contains("Wj"))
if(!(systT.Contains("stat"))) writeIt = 0;
if((kount < 3) && (channel=="data_obs"))
{
kount++;
std::string namen = channel;
std::cout << "reading WS "<< oldFolder.Data() << std::endl;
std::cout << namen << std::endl;
RooDataHist* tempRooDataHistNom = (RooDataHist*) tempWS->data(namen.c_str());
TH1 *tempHistNom = tempRooDataHistNom->createHistogram(namen.c_str(),BDT,Binning(bins));
std::cout << namen << std::endl;
RooDataHist *DHnom = new RooDataHist(channel.c_str(),"",*hobs,tempHistNom);
WS->import(*(new RooHistPdf(channel.c_str(),"",*hobs,*DHnom)));
}
if (channel!="data_obs")
{
std::string nameUp;
std::string namen;
std::string nameDown;
if((syst == "stat"))
{
if(IFILE.Contains("7TeV"))
{
nameUp = channel + "CMS_vhbb_stats_" + channel + "_" + oldFolder.Data() + "Up";
namen = channel;
nameDown = channel + "CMS_vhbb_stats_" + channel + "_" + oldFolder.Data() + "Down";
}
if(IFILE.Contains("8TeV"))
{
nameUp = channel + "CMS_vhbb_stats_" + channel + "_" + oldFolder.Data() + "Up";
namen = channel;
nameDown = channel + "CMS_vhbb_stats_" + channel + "_" + oldFolder.Data() + "Down";
}
}
else
{
nameUp = channel + "CMS_" + syst + "Up";
namen = channel;
nameDown = channel + "CMS_" + syst + "Down";
}
if((syst == "ZJModel"))
{
if(IFILE.Contains("7TeV"))
{
nameUp = channel + "CMS_vhbb_ZJModel_" + oldFolder.Data() + "_7TeVUp";
namen = channel;
nameDown = channel + "CMS_vhbb_ZJModel_" + oldFolder.Data() + "_7TeVDown";
}
if(IFILE.Contains("8TeV"))
{
nameUp = channel + "CMS_vhbb_ZJModel_" + oldFolder.Data() + "_8TeVUp";
namen = channel;
nameDown = channel + "CMS_vhbb_ZJModel_" + oldFolder.Data() + "_8TeVDown";
}
}
if(writeIt)
{
RooDataHist* tempRooDataHistUp = (RooDataHist*) tempWS->data(nameUp.c_str());
RooDataHist* tempRooDataHistDown = (RooDataHist*) tempWS->data(nameDown.c_str());
RooDataHist* tempRooDataHistNom = (RooDataHist*) tempWS->data(namen.c_str());
std::cout << oldFolder.Data() << std::endl;
std::cout << nameUp.c_str() << std::endl;
TH1 *tempHistUp = tempRooDataHistUp->createHistogram(nameUp.c_str(),BDT,Binning(bins));
TH1 *tempHistDown = tempRooDataHistDown->createHistogram(nameDown.c_str(),BDT,Binning(bins));
std::cout << namen.c_str() << std::endl;
TH1 *tempHistNom = tempRooDataHistNom->createHistogram(namen.c_str(),BDT,Binning(bins));
if(chanT.Contains("VH") && IFILE.Contains("7TeV"))
{
tempHistUp->Scale(xSec7ZH[toMassNo]/xSec7ZH[fromMassNo]);
tempHistDown->Scale(xSec7ZH[toMassNo]/xSec7ZH[fromMassNo]);
tempHistNom->Scale(xSec7ZH[toMassNo]/xSec7ZH[fromMassNo]);
}
if(chanT.Contains("VH") && IFILE.Contains("8TeV"))
{
tempHistUp->Scale(xSec8ZH[toMassNo]/xSec8ZH[fromMassNo]);
tempHistDown->Scale(xSec8ZH[toMassNo]/xSec8ZH[fromMassNo]);
tempHistNom->Scale(xSec8ZH[toMassNo]/xSec8ZH[fromMassNo]);
}
std::cout<< "channel--> " << channel << std::endl;
tempHistUp->SetLineColor(kRed);
tempHistUp->SetLineWidth(3);
tempHistUp->SetFillColor(0);
tempHistDown->SetLineColor(kBlue);
tempHistDown->SetFillColor(0);
tempHistDown->SetLineWidth(3);
tempHistNom->SetFillColor(0);
tempHistNom->SetMarkerStyle(20);
tempHistUp->SetTitle((channel + syst).c_str());
RooDataHist *DHnom;
RooDataHist *DHup = new RooDataHist(nameUp.c_str(),"",*hobs,tempHistUp);
if(kount2 < 3) DHnom = new RooDataHist(namen.c_str(),"",*hobs,tempHistNom);
RooDataHist *DHdown = new RooDataHist(nameDown.c_str(),"",*hobs,tempHistDown);
WS->import(*(new RooHistPdf(nameUp.c_str(),"",*hobs,*DHup)));
WS->import(*(new RooHistPdf(nameDown.c_str(),"",*hobs,*DHdown)));
if(kount2 < 3){ WS->import(*(new RooHistPdf(namen.c_str(),"",*hobs,*DHnom))); kount2++;}
}
}
}
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;
}
///
/// Find the global minimum in a more thorough way.
/// First fit with external start parameters, then
/// for each parameter that starts with "d" or "r" (typically angles and ratios):
/// - at upper scan range, rest at start parameters
/// - at lower scan range, rest at start parameters
/// This amounts to a maximum of 1+2^n fits, where n is the number
/// of parameters to be varied.
///
/// \param w Workspace holding the pdf.
/// \param name Name of the pdf without leading "pdf_".
/// \param forceVariables Apply the force method for these variables only. Format
/// "var1,var2,var3," (list must end with comma). Default is to apply for all angles,
/// all ratios except rD_k3pi and rD_kpi, and the k3pi coherence factor.
///
RooFitResult* Utils::fitToMinForce(RooWorkspace *w, TString name, TString forceVariables)
{
bool debug = true;
TString parsName = "par_"+name;
TString obsName = "obs_"+name;
TString pdfName = "pdf_"+name;
RooFitResult *r = 0;
int printlevel = -1;
RooMsgService::instance().setGlobalKillBelow(ERROR);
// save start parameters
if ( !w->set(parsName) ){
cout << "MethodProbScan::scan2d() : ERROR : parsName not found: " << parsName << endl;
exit(1);
}
RooDataSet *startPars = new RooDataSet("startParsForce", "startParsForce", *w->set(parsName));
startPars->add(*w->set(parsName));
// set up parameters and ranges
RooArgList *varyPars = new RooArgList();
TIterator* it = w->set(parsName)->createIterator();
while ( RooRealVar* p = (RooRealVar*)it->Next() )
{
if ( p->isConstant() ) continue;
if ( forceVariables=="" && ( false
|| TString(p->GetName()).BeginsWith("d") ///< use these variables
// || TString(p->GetName()).BeginsWith("r")
|| TString(p->GetName()).BeginsWith("k")
|| TString(p->GetName()) == "g"
) && ! (
TString(p->GetName()) == "rD_k3pi" ///< don't use these
|| TString(p->GetName()) == "rD_kpi"
// || TString(p->GetName()) == "dD_kpi"
|| TString(p->GetName()) == "d_dk"
|| TString(p->GetName()) == "d_dsk"
))
{
varyPars->add(*p);
}
else if ( forceVariables.Contains(TString(p->GetName())+",") )
{
varyPars->add(*p);
}
}
delete it;
int nPars = varyPars->getSize();
if ( debug ) cout << "Utils::fitToMinForce() : nPars = " << nPars << " => " << pow(2.,nPars) << " fits" << endl;
if ( debug ) cout << "Utils::fitToMinForce() : varying ";
if ( debug ) varyPars->Print();
//////////
r = fitToMinBringBackAngles(w->pdf(pdfName), false, printlevel);
//////////
int nErrors = 0;
// We define a binary mask where each bit corresponds
// to parameter at max or at min.
for ( int i=0; i<pow(2.,nPars); i++ )
{
if ( debug ) cout << "Utils::fitToMinForce() : fit " << i << " \r" << flush;
setParameters(w, parsName, startPars->get(0));
for ( int ip=0; ip<nPars; ip++ )
{
RooRealVar *p = (RooRealVar*)varyPars->at(ip);
float oldMin = p->getMin();
float oldMax = p->getMax();
setLimit(w, p->GetName(), "force");
if ( i/(int)pow(2.,ip) % 2==0 ) { p->setVal(p->getMin()); }
if ( i/(int)pow(2.,ip) % 2==1 ) { p->setVal(p->getMax()); }
p->setRange(oldMin, oldMax);
}
// check if start parameters are sensible, skip if they're not
double startParChi2 = getChi2(w->pdf(pdfName));
if ( startParChi2>2000 ){
nErrors += 1;
continue;
}
// refit
RooFitResult *r2 = fitToMinBringBackAngles(w->pdf(pdfName), false, printlevel);
// In case the initial fit failed, accept the second one.
// If both failed, still select the second one and hope the
// next fit succeeds.
if ( !(r->edm()<1 && r->covQual()==3) ){
delete r;
r = r2;
}
else if ( r2->edm()<1 && r2->covQual()==3 && r2->minNll()<r->minNll() ){
// better minimum found!
delete r;
r = r2;
}
else{
delete r2;
}
}
if ( debug ) cout << endl;
if ( debug ) cout << "Utils::fitToMinForce() : nErrors = " << nErrors << endl;
RooMsgService::instance().setGlobalKillBelow(INFO);
// (re)set to best parameters
setParameters(w, parsName, r);
delete startPars;
return r;
}
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 eregtesting_13TeV_Eta(bool dobarrel=true, bool doele=false,int gammaID=0) {
//output dir
TString EEorEB = "EE";
if(dobarrel)
{
EEorEB = "EB";
}
TString gammaDir = "bothGammas";
if(gammaID==1)
{
gammaDir = "gamma1";
}
else if(gammaID==2)
{
gammaDir = "gamma2";
}
TString dirname = TString::Format("ereg_test_plots_Eta/%s_%s",gammaDir.Data(),EEorEB.Data());
gSystem->mkdir(dirname,true);
gSystem->cd(dirname);
//read workspace from training
TString fname;
if (doele && dobarrel)
fname = "wereg_ele_eb.root";
else if (doele && !dobarrel)
fname = "wereg_ele_ee.root";
else if (!doele && dobarrel)
fname = "wereg_ph_eb.root";
else if (!doele && !dobarrel)
fname = "wereg_ph_ee.root";
TString infile = TString::Format("../../ereg_ws_Eta/%s/%s",gammaDir.Data(),fname.Data());
TFile *fws = TFile::Open(infile);
RooWorkspace *ws = (RooWorkspace*)fws->Get("wereg");
//read variables from workspace
RooGBRTargetFlex *meantgt = static_cast<RooGBRTargetFlex*>(ws->arg("sigmeant"));
RooRealVar *tgtvar = ws->var("tgtvar");
RooArgList vars;
vars.add(meantgt->FuncVars());
vars.add(*tgtvar);
//read testing dataset from TTree
RooRealVar weightvar("weightvar","",1.);
TTree *dtree;
if (doele) {
//TFile *fdin = TFile::Open("root://eoscms.cern.ch//eos/cms/store/cmst3/user/bendavid/regTreesAug1/hgg-2013Final8TeV_reg_s12-zllm50-v7n_noskim.root");
TFile *fdin = TFile::Open("/data/bendavid/regTreesAug1/hgg-2013Final8TeV_reg_s12-zllm50-v7n_noskim.root");
TDirectory *ddir = (TDirectory*)fdin->FindObjectAny("PhotonTreeWriterSingleInvert");
dtree = (TTree*)ddir->Get("hPhotonTreeSingle");
}
else {
//TFile *fdin = TFile::Open("/eos/cms/store/group/dpg_ecal/alca_ecalcalib/piZero2017/zhicaiz/Gun_MultiPion_FlatPt-1To15/Gun_FlatPt1to15_MultiPion_withPhotonPtFilter_pythia8/photons_0_half2.root");
//TFile *fdin = TFile::Open("/eos/cms/store/group/dpg_ecal/alca_ecalcalib/piZero2017/zhicaiz/Gun_MultiEta_FlatPt-1To15/Gun_FlatPt1to15_MultiEta_withPhotonPtFilter_pythia8/photons_22Aug2017_V3_half2.root");
TFile *fdin = TFile::Open("/eos/cms/store/group/dpg_ecal/alca_ecalcalib/piZero2017/zhicaiz/Gun_MultiEta_FlatPt-1To15/Gun_FlatPt1to15_MultiEtaToGG_withPhotonPtFilter_pythia8/photons_20171008_half2.root");
if(gammaID==0)
{
dtree = (TTree*)fdin->Get("Tree_Optim_gamma");
}
else if(gammaID==1)
{
dtree = (TTree*)fdin->Get("Tree_Optim_gamma1");
}
else if(gammaID==2)
{
dtree = (TTree*)fdin->Get("Tree_Optim_gamma2");
}
}
//selection cuts for testing
//TCut selcut = "(STr2_enG1_true/cosh(STr2_Eta_1)>1.0) && (STr2_S4S9_1>0.75)";
//TCut selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.75) && (STr2_isMerging < 2) && (STr2_DeltaR < 0.03) && (STr2_enG_true/STr2_enG_rec)<3.0 && STr2_EOverEOther < 10.0 && STr2_EOverEOther > 0.1";
//TCut selcut = "(STr2_enG_rec/cosh(STr2_Eta)>0) && (STr2_S4S9 > 0.75) && (STr2_isMerging < 2) && (STr2_DeltaR < 0.03) && (STr2_mPi0_nocor>0.1)";
//TCut selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.75) && (STr2_Nxtal > 6) && (STr2_mPi0_nocor>0.1) && (STr2_mPi0_nocor < 0.2)";
TCut selcut = "";
if(dobarrel) selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.75) && (STr2_Nxtal > 6) && (STr2_mPi0_nocor>0.2) && (STr2_mPi0_nocor < 1.0) && (STr2_ptPi0_nocor > 2.0) && abs(STr2_Eta)<1.479 && (!STr2_fromPi0)";
//if(dobarrel) selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.75) && (STr2_Nxtal > 6) && (STr2_mPi0_nocor>0.1) && (STr2_mPi0_nocor < 0.2) && (STr2_ptPi0_nocor > 2.0) && abs(STr2_Eta)<1.479";
else selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.75) && (STr2_Nxtal > 6) && (STr2_mPi0_nocor>0.2) && (STr2_mPi0_nocor < 1.0) && (STr2_ptPi0_nocor > 2.0) && abs(STr2_Eta)>1.479 && (!STr2_fromPi0)";
//else selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.75) && (STr2_Nxtal > 6) && (STr2_mPi0_nocor>0.1) && (STr2_mPi0_nocor < 0.2) && (STr2_ptPi0_nocor > 2.0) && abs(STr2_Eta)>1.479";
//TCut selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.75) && (STr2_isMerging < 2) && (STr2_DeltaR < 0.03) && (STr2_iEta_on2520==0 || STr2_iPhi_on20==0) ";
//TCut selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.75) && (STr2_isMerging < 2) && (STr2_DeltaR < 0.03) && (abs(STr2_iEtaiX)<60)";
//TCut selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.75) && (STr2_isMerging < 2) && (STr2_DeltaR < 0.03) && (abs(STr2_iEtaiX)>60)";
//TCut selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.9) && (STr2_S2S9>0.85)&& (STr2_isMerging < 2) && (STr2_DeltaR < 0.03) && (abs(STr2_iEtaiX)<60)";
//TCut selcut = "(STr2_enG_rec/cosh(STr2_Eta)>1.0) && (STr2_S4S9 > 0.9) && (STr2_S2S9>0.85)&& (STr2_isMerging < 2) && (STr2_DeltaR < 0.03)";
/*
TCut selcut;
if (dobarrel)
selcut = "ph.genpt>25. && ph.isbarrel && ph.ispromptgen";
else
selcut = "ph.genpt>25. && !ph.isbarrel && ph.ispromptgen";
*/
TCut selweight = "xsecweight(procidx)*puweight(numPU,procidx)";
TCut prescale10 = "(Entry$%10==0)";
TCut prescale10alt = "(Entry$%10==1)";
TCut prescale25 = "(Entry$%25==0)";
TCut prescale100 = "(Entry$%100==0)";
TCut prescale1000 = "(Entry$%1000==0)";
TCut evenevents = "(Entry$%2==0)";
TCut oddevents = "(Entry$%2==1)";
TCut prescale100alt = "(Entry$%100==1)";
TCut prescale1000alt = "(Entry$%1000==1)";
TCut prescale50alt = "(Entry$%50==1)";
TCut Events3_4 = "(Entry$%4==3)";
TCut Events1_4 = "(Entry$%4==1)";
TCut Events2_4 = "(Entry$%4==2)";
TCut Events0_4 = "(Entry$%4==0)";
TCut Events01_4 = "(Entry$%4<2)";
TCut Events23_4 = "(Entry$%4>1)";
TCut EventsTest = "(Entry$%2==1)";
//weightvar.SetTitle(EventsTest*selcut);
weightvar.SetTitle(selcut);
/*
if (doele)
weightvar.SetTitle(prescale100alt*selcut);
else
weightvar.SetTitle(selcut);
*/
//make testing dataset
RooDataSet *hdata = RooTreeConvert::CreateDataSet("hdata",dtree,vars,weightvar);
if (doele)
weightvar.SetTitle(prescale1000alt*selcut);
else
weightvar.SetTitle(prescale10alt*selcut);
//make reduced testing dataset for integration over conditional variables
RooDataSet *hdatasmall = RooTreeConvert::CreateDataSet("hdatasmall",dtree,vars,weightvar);
//retrieve full pdf from workspace
RooAbsPdf *sigpdf = ws->pdf("sigpdf");
//input variable corresponding to sceta
RooRealVar *scEraw = ws->var("var_0");
scEraw->setRange(1.,2.);
scEraw->setBins(100);
// RooRealVar *scetavar = ws->var("var_1");
// RooRealVar *scphivar = ws->var("var_2");
//regressed output functions
RooAbsReal *sigmeanlim = ws->function("sigmeanlim");
RooAbsReal *sigwidthlim = ws->function("sigwidthlim");
RooAbsReal *signlim = ws->function("signlim");
RooAbsReal *sign2lim = ws->function("sign2lim");
// RooAbsReal *sigalphalim = ws->function("sigalphalim");
//RooAbsReal *sigalpha2lim = ws->function("sigalpha2lim");
//formula for corrected energy/true energy ( 1.0/(etrue/eraw) * regression mean)
RooFormulaVar ecor("ecor","","1./(@0)*@1",RooArgList(*tgtvar,*sigmeanlim));
RooRealVar *ecorvar = (RooRealVar*)hdata->addColumn(ecor);
ecorvar->setRange(0.,2.);
ecorvar->setBins(800);
//formula for raw energy/true energy (1.0/(etrue/eraw))
RooFormulaVar raw("raw","","1./@0",RooArgList(*tgtvar));
RooRealVar *rawvar = (RooRealVar*)hdata->addColumn(raw);
rawvar->setRange(0.,2.);
rawvar->setBins(800);
//clone data and add regression outputs for plotting
RooDataSet *hdataclone = new RooDataSet(*hdata,"hdataclone");
RooRealVar *meanvar = (RooRealVar*)hdataclone->addColumn(*sigmeanlim);
RooRealVar *widthvar = (RooRealVar*)hdataclone->addColumn(*sigwidthlim);
RooRealVar *nvar = (RooRealVar*)hdataclone->addColumn(*signlim);
RooRealVar *n2var = (RooRealVar*)hdataclone->addColumn(*sign2lim);
// RooRealVar *alphavar = (RooRealVar*)hdataclone->addColumn(*sigalphalim);
// RooRealVar *alpha2var = (RooRealVar*)hdataclone->addColumn(*sigalpha2lim);
//plot target variable and weighted regression prediction (using numerical integration over reduced testing dataset)
TCanvas *craw = new TCanvas;
//RooPlot *plot = tgtvar->frame(0.6,1.2,100);
RooPlot *plot = tgtvar->frame(0.6,2.0,100);
hdata->plotOn(plot);
sigpdf->plotOn(plot,ProjWData(*hdatasmall));
plot->Draw();
craw->SaveAs("RawE.pdf");
craw->SaveAs("RawE.png");
craw->SetLogy();
plot->SetMinimum(0.1);
craw->SaveAs("RawElog.pdf");
craw->SaveAs("RawElog.png");
//plot distribution of regressed functions over testing dataset
TCanvas *cmean = new TCanvas;
RooPlot *plotmean = meanvar->frame(0.8,2.0,100);
hdataclone->plotOn(plotmean);
plotmean->Draw();
cmean->SaveAs("mean.pdf");
cmean->SaveAs("mean.png");
TCanvas *cwidth = new TCanvas;
RooPlot *plotwidth = widthvar->frame(0.,0.05,100);
hdataclone->plotOn(plotwidth);
plotwidth->Draw();
cwidth->SaveAs("width.pdf");
cwidth->SaveAs("width.png");
TCanvas *cn = new TCanvas;
RooPlot *plotn = nvar->frame(0.,111.,200);
hdataclone->plotOn(plotn);
plotn->Draw();
cn->SaveAs("n.pdf");
cn->SaveAs("n.png");
TCanvas *cn2 = new TCanvas;
RooPlot *plotn2 = n2var->frame(0.,111.,100);
hdataclone->plotOn(plotn2);
plotn2->Draw();
cn2->SaveAs("n2.pdf");
cn2->SaveAs("n2.png");
/*
TCanvas *calpha = new TCanvas;
RooPlot *plotalpha = alphavar->frame(0.,5.,200);
hdataclone->plotOn(plotalpha);
plotalpha->Draw();
calpha->SaveAs("alpha.pdf");
calpha->SaveAs("alpha.png");
TCanvas *calpha2 = new TCanvas;
RooPlot *plotalpha2 = alpha2var->frame(0.,5.,200);
hdataclone->plotOn(plotalpha2);
plotalpha2->Draw();
calpha2->SaveAs("alpha2.pdf");
calpha2->SaveAs("alpha2.png");
*/
/*
TCanvas *ceta = new TCanvas;
RooPlot *ploteta = scetavar->frame(-2.6,2.6,200);
hdataclone->plotOn(ploteta);
ploteta->Draw();
ceta->SaveAs("eta.pdf");
ceta->SaveAs("eta.png");
*/
//create histograms for eraw/etrue and ecor/etrue to quantify regression performance
TH1 *heraw;// = hdata->createHistogram("hraw",*rawvar,Binning(800,0.,2.));
TH1 *hecor;// = hdata->createHistogram("hecor",*ecorvar);
if (EEorEB == "EB")
{
heraw = hdata->createHistogram("hraw",*rawvar,Binning(800,0.,2.0));
hecor = hdata->createHistogram("hecor",*ecorvar, Binning(800,0.,2.0));
}
else
{
heraw = hdata->createHistogram("hraw",*rawvar,Binning(200,0.,2.));
hecor = hdata->createHistogram("hecor",*ecorvar, Binning(200,0.,2.));
}
//heold->SetLineColor(kRed);
hecor->SetLineColor(kBlue);
heraw->SetLineColor(kMagenta);
hecor->GetYaxis()->SetRangeUser(1.0,1.3*hecor->GetMaximum());
heraw->GetYaxis()->SetRangeUser(1.0,1.3*hecor->GetMaximum());
hecor->GetXaxis()->SetRangeUser(0.0,1.5);
heraw->GetXaxis()->SetRangeUser(0.0,1.5);
/*if(EEorEB == "EE")
{
heraw->GetYaxis()->SetRangeUser(10.0,200.0);
hecor->GetYaxis()->SetRangeUser(10.0,200.0);
}
*/
//heold->GetXaxis()->SetRangeUser(0.6,1.2);
double effsigma_cor, effsigma_raw, fwhm_cor, fwhm_raw;
if(EEorEB == "EB")
{
TH1 *hecorfine = hdata->createHistogram("hecorfine",*ecorvar,Binning(800,0.,2.));
effsigma_cor = effSigma(hecorfine);
fwhm_cor = FWHM(hecorfine);
TH1 *herawfine = hdata->createHistogram("herawfine",*rawvar,Binning(800,0.,2.));
effsigma_raw = effSigma(herawfine);
fwhm_raw = FWHM(herawfine);
}
else
{
TH1 *hecorfine = hdata->createHistogram("hecorfine",*ecorvar,Binning(200,0.,2.));
effsigma_cor = effSigma(hecorfine);
fwhm_cor = FWHM(hecorfine);
TH1 *herawfine = hdata->createHistogram("herawfine",*rawvar,Binning(200,0.,2.));
effsigma_raw = effSigma(herawfine);
fwhm_raw = FWHM(herawfine);
}
TCanvas *cresponse = new TCanvas;
gStyle->SetOptStat(0);
gStyle->SetPalette(107);
hecor->SetTitle("");
heraw->SetTitle("");
hecor->Draw("HIST");
//heold->Draw("HISTSAME");
heraw->Draw("HISTSAME");
//show errSigma in the plot
TLegend *leg = new TLegend(0.1, 0.75, 0.7, 0.9);
leg->AddEntry(hecor,Form("E_{cor}/E_{true}, #sigma_{eff}=%4.3f, FWHM=%4.3f", effsigma_cor, fwhm_cor),"l");
leg->AddEntry(heraw,Form("E_{raw}/E_{true}, #sigma_{eff}=%4.3f, FWHM=%4.3f", effsigma_raw, fwhm_raw),"l");
leg->SetFillStyle(0);
leg->SetBorderSize(0);
// leg->SetTextColor(kRed);
leg->Draw();
cresponse->SaveAs("response.pdf");
cresponse->SaveAs("response.png");
cresponse->SetLogy();
cresponse->SaveAs("responselog.pdf");
cresponse->SaveAs("responselog.png");
// draw CCs vs eta and phi
/*
TCanvas *c_eta = new TCanvas;
TH1 *h_eta = hdata->createHistogram("h_eta",*scetavar,Binning(100,-3.2,3.2));
h_eta->Draw("HIST");
c_eta->SaveAs("heta.pdf");
c_eta->SaveAs("heta.png");
TCanvas *c_phi = new TCanvas;
TH1 *h_phi = hdata->createHistogram("h_phi",*scphivar,Binning(100,-3.2,3.2));
h_phi->Draw("HIST");
c_phi->SaveAs("hphi.pdf");
c_phi->SaveAs("hphi.png");
*/
RooRealVar *scetaiXvar = ws->var("var_4");
RooRealVar *scphiiYvar = ws->var("var_5");
if(EEorEB=="EB")
{
scetaiXvar->setRange(-90,90);
scetaiXvar->setBins(180);
scphiiYvar->setRange(0,360);
scphiiYvar->setBins(360);
}
else
{
scetaiXvar->setRange(0,50);
scetaiXvar->setBins(50);
scphiiYvar->setRange(0,50);
scphiiYvar->setBins(50);
}
ecorvar->setRange(0.5,1.5);
ecorvar->setBins(800);
rawvar->setRange(0.5,1.5);
rawvar->setBins(800);
TCanvas *c_cor_eta = new TCanvas;
TH3F *h3_CC_eta_phi = (TH3F*) hdata->createHistogram("var_5,var_4,ecor",(EEorEB=="EB") ? 170 : 100, (EEorEB=="EB") ? 360 : 100,25);
TProfile2D *h_CC_eta_phi = h3_CC_eta_phi->Project3DProfile();
h_CC_eta_phi->SetTitle("E_{cor}/E_{true}");
if(EEorEB=="EB")
{
h_CC_eta_phi->GetXaxis()->SetTitle("i#eta");
h_CC_eta_phi->GetYaxis()->SetTitle("i#phi");
h_CC_eta_phi->GetXaxis()->SetRangeUser(-85,85);
h_CC_eta_phi->GetYaxis()->SetRangeUser(0,360);
}
else
{
h_CC_eta_phi->GetXaxis()->SetTitle("iX");
h_CC_eta_phi->GetYaxis()->SetTitle("iY");
}
h_CC_eta_phi->SetMinimum(0.5);
h_CC_eta_phi->SetMaximum(1.5);
h_CC_eta_phi->Draw("COLZ");
c_cor_eta->SaveAs("cor_vs_eta_phi.pdf");
c_cor_eta->SaveAs("cor_vs_eta_phi.png");
TH2F *h_CC_eta = hdata->createHistogram(*scetaiXvar, *ecorvar, "","cor_vs_eta");
if(EEorEB=="EB")
{
h_CC_eta->GetXaxis()->SetTitle("i#eta");
}
else
{
h_CC_eta->GetXaxis()->SetTitle("iX");
}
h_CC_eta->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h_CC_eta->Draw("COLZ");
c_cor_eta->SaveAs("cor_vs_eta.pdf");
c_cor_eta->SaveAs("cor_vs_eta.png");
TCanvas *c_cor_scEraw = new TCanvas;
TH2F *h_CC_scEraw = hdata->createHistogram(*scEraw, *ecorvar, "","cor_vs_scEraw");
h_CC_scEraw->GetXaxis()->SetTitle("E_{raw}");
h_CC_scEraw->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h_CC_scEraw->Draw("COLZ");
c_cor_scEraw->SaveAs("cor_vs_scEraw.pdf");
c_cor_scEraw->SaveAs("cor_vs_scEraw.png");
TCanvas *c_raw_scEraw = new TCanvas;
TH2F *h_RC_scEraw = hdata->createHistogram(*scEraw, *rawvar, "","raw_vs_scEraw");
h_RC_scEraw->GetXaxis()->SetTitle("E_{raw}");
h_RC_scEraw->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h_RC_scEraw->Draw("COLZ");
c_raw_scEraw->SaveAs("raw_vs_scEraw.pdf");
c_raw_scEraw->SaveAs("raw_vs_scEraw.png");
TCanvas *c_cor_phi = new TCanvas;
TH2F *h_CC_phi = hdata->createHistogram(*scphiiYvar, *ecorvar, "","cor_vs_phi");
if(EEorEB=="EB")
{
h_CC_phi->GetXaxis()->SetTitle("i#phi");
}
else
{
h_CC_phi->GetXaxis()->SetTitle("iY");
}
h_CC_phi->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h_CC_phi->Draw("COLZ");
c_cor_phi->SaveAs("cor_vs_phi.pdf");
c_cor_phi->SaveAs("cor_vs_phi.png");
TCanvas *c_raw_eta = new TCanvas;
TH3F *h3_RC_eta_phi = (TH3F*) hdata->createHistogram("var_5,var_4,raw",(EEorEB=="EB") ? 170 : 100, (EEorEB=="EB") ? 360 : 100,25);
TProfile2D *h_RC_eta_phi = h3_RC_eta_phi->Project3DProfile();
h_RC_eta_phi->SetTitle("E_{raw}/E_{true}");
if(EEorEB=="EB")
{
h_RC_eta_phi->GetXaxis()->SetTitle("i#eta");
h_RC_eta_phi->GetYaxis()->SetTitle("i#phi");
h_RC_eta_phi->GetXaxis()->SetRangeUser(-85,85);
h_RC_eta_phi->GetYaxis()->SetRangeUser(0,360);
}
else
{
h_RC_eta_phi->GetXaxis()->SetTitle("iX");
h_RC_eta_phi->GetYaxis()->SetTitle("iY");
}
h_RC_eta_phi->SetMinimum(0.5);
h_RC_eta_phi->SetMaximum(1.5);
h_RC_eta_phi->Draw("COLZ");
c_raw_eta->SaveAs("raw_vs_eta_phi.pdf");
c_raw_eta->SaveAs("raw_vs_eta_phi.png");
TH2F *h_RC_eta = hdata->createHistogram(*scetaiXvar, *rawvar, "","raw_vs_eta");
if(EEorEB=="EB")
{
h_RC_eta->GetXaxis()->SetTitle("i#eta");
}
else
{
h_RC_eta->GetXaxis()->SetTitle("iX");
}
h_RC_eta->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h_RC_eta->Draw("COLZ");
c_raw_eta->SaveAs("raw_vs_eta.pdf");
c_raw_eta->SaveAs("raw_vs_eta.png");
TCanvas *c_raw_phi = new TCanvas;
TH2F *h_RC_phi = hdata->createHistogram(*scphiiYvar, *rawvar, "","raw_vs_phi");
if(EEorEB=="EB")
{
h_RC_phi->GetXaxis()->SetTitle("i#phi");
}
else
{
h_RC_phi->GetXaxis()->SetTitle("iY");
}
h_RC_phi->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h_RC_phi->Draw("COLZ");
c_raw_phi->SaveAs("raw_vs_phi.pdf");
c_raw_phi->SaveAs("raw_vs_phi.png");
//on2,5,20, etc
if(EEorEB == "EB")
{
TCanvas *myC_iCrystal_mod = new TCanvas;
RooRealVar *SM_distvar = ws->var("var_6");
SM_distvar->setRange(0,10);
SM_distvar->setBins(10);
TH2F *h_CC_SM_dist = hdata->createHistogram(*SM_distvar, *ecorvar, "","cor_vs_SM_dist");
h_CC_SM_dist->GetXaxis()->SetTitle("SM_dist");
h_CC_SM_dist->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h_CC_SM_dist->Draw("COLZ");
myC_iCrystal_mod->SaveAs("cor_vs_SM_dist.pdf");
myC_iCrystal_mod->SaveAs("cor_vs_SM_dist.png");
TH2F *h_RC_SM_dist = hdata->createHistogram(*SM_distvar, *rawvar, "","raw_vs_SM_dist");
h_RC_SM_dist->GetXaxis()->SetTitle("distance to SM gap");
h_RC_SM_dist->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h_RC_SM_dist->Draw("COLZ");
myC_iCrystal_mod->SaveAs("raw_vs_SM_dist.pdf");
myC_iCrystal_mod->SaveAs("raw_vs_SM_dist.png");
RooRealVar *M_distvar = ws->var("var_7");
M_distvar->setRange(0,13);
M_distvar->setBins(10);
TH2F *h_CC_M_dist = hdata->createHistogram(*M_distvar, *ecorvar, "","cor_vs_M_dist");
h_CC_M_dist->GetXaxis()->SetTitle("M_dist");
h_CC_M_dist->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h_CC_M_dist->Draw("COLZ");
myC_iCrystal_mod->SaveAs("cor_vs_M_dist.pdf");
myC_iCrystal_mod->SaveAs("cor_vs_M_dist.png");
TH2F *h_RC_M_dist = hdata->createHistogram(*M_distvar, *rawvar, "","raw_vs_M_dist");
h_RC_M_dist->GetXaxis()->SetTitle("distance to module gap");
h_RC_M_dist->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h_RC_M_dist->Draw("COLZ");
myC_iCrystal_mod->SaveAs("raw_vs_M_dist.pdf");
myC_iCrystal_mod->SaveAs("raw_vs_M_dist.png");
/*
RooRealVar *DeltaRG1G2var = ws->var("var_8");
DeltaRG1G2var->setRange(0,0.2);
DeltaRG1G2var->setBins(100);
TH2F *h_CC_DeltaRG1G2 = hdata->createHistogram(*DeltaRG1G2var, *ecorvar, "","cor_vs_DeltaRG1G2");
h_CC_DeltaRG1G2->GetXaxis()->SetTitle("DeltaRG1G2");
h_CC_DeltaRG1G2->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h_CC_DeltaRG1G2->Draw("COLZ");
myC_iCrystal_mod->SaveAs("cor_vs_DeltaRG1G2.pdf");
myC_iCrystal_mod->SaveAs("cor_vs_DeltaRG1G2.png");
TH2F *h_RC_DeltaRG1G2 = hdata->createHistogram(*DeltaRG1G2var, *rawvar, "","raw_vs_DeltaRG1G2");
h_RC_DeltaRG1G2->GetXaxis()->SetTitle("distance to module gap");
h_RC_DeltaRG1G2->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h_RC_DeltaRG1G2->Draw("COLZ");
myC_iCrystal_mod->SaveAs("raw_vs_DeltaRG1G2.pdf");
myC_iCrystal_mod->SaveAs("raw_vs_DeltaRG1G2.png");
*/
}
// other variables
TCanvas *myC_variables = new TCanvas;
RooRealVar *Nxtalvar = ws->var("var_1");
Nxtalvar->setRange(0,10);
Nxtalvar->setBins(10);
TH2F *h_CC_Nxtal = hdata->createHistogram(*Nxtalvar, *ecorvar, "","cor_vs_Nxtal");
h_CC_Nxtal->GetXaxis()->SetTitle("Nxtal");
h_CC_Nxtal->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h_CC_Nxtal->Draw("COLZ");
myC_variables->SaveAs("cor_vs_Nxtal.pdf");
myC_variables->SaveAs("cor_vs_Nxtal.png");
TH2F *h_RC_Nxtal = hdata->createHistogram(*Nxtalvar, *rawvar, "","raw_vs_Nxtal");
h_RC_Nxtal->GetXaxis()->SetTitle("Nxtal");
h_RC_Nxtal->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h_RC_Nxtal->Draw("COLZ");
myC_variables->SaveAs("raw_vs_Nxtal.pdf");
myC_variables->SaveAs("raw_vs_Nxtal.png");
RooRealVar *S4S9var = ws->var("var_2");
int Nbins_S4S9 = 100;
double Low_S4S9 = 0.6;
double High_S4S9 = 1.0;
S4S9var->setRange(Low_S4S9,High_S4S9);
S4S9var->setBins(Nbins_S4S9);
TH2F *h_CC_S4S9 = hdata->createHistogram(*S4S9var, *ecorvar, "","cor_vs_S4S9");
h_CC_S4S9->GetXaxis()->SetTitle("S4S9");
h_CC_S4S9->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h_CC_S4S9->Draw("COLZ");
myC_variables->SaveAs("cor_vs_S4S9.pdf");
myC_variables->SaveAs("cor_vs_S4S9.png");
TH2F *h_RC_S4S9 = hdata->createHistogram(*S4S9var, *rawvar, "","raw_vs_S4S9");
h_RC_S4S9->GetXaxis()->SetTitle("S4S9");
h_RC_S4S9->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h_RC_S4S9->Draw("COLZ");
myC_variables->SaveAs("raw_vs_S4S9.pdf");
myC_variables->SaveAs("raw_vs_S4S9.png");
RooRealVar *S2S9var = ws->var("var_3");
int Nbins_S2S9 = 100;
double Low_S2S9 = 0.5;
double High_S2S9 = 1.0;
S2S9var->setRange(Low_S2S9,High_S2S9);
S2S9var->setBins(Nbins_S2S9);
TH2F *h_CC_S2S9 = hdata->createHistogram(*S2S9var, *ecorvar, "","cor_vs_S2S9");
h_CC_S2S9->GetXaxis()->SetTitle("S2S9");
h_CC_S2S9->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h_CC_S2S9->Draw("COLZ");
myC_variables->SaveAs("cor_vs_S2S9.pdf");
myC_variables->SaveAs("cor_vs_S2S9.png");
TH2F *h_RC_S2S9 = hdata->createHistogram(*S2S9var, *rawvar, "","raw_vs_S2S9");
h_RC_S2S9->GetXaxis()->SetTitle("S2S9");
h_RC_S2S9->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h_RC_S2S9->Draw("COLZ");
myC_variables->SaveAs("raw_vs_S2S9.pdf");
myC_variables->SaveAs("raw_vs_S2S9.png");
TH2F *h_S2S9_eta = hdata->createHistogram(*scetaiXvar, *S2S9var, "","S2S9_vs_eta");
h_S2S9_eta->GetYaxis()->SetTitle("S2S9");
if(EEorEB=="EB")
{
h_CC_eta->GetYaxis()->SetTitle("i#eta");
}
else
{
h_CC_eta->GetYaxis()->SetTitle("iX");
}
h_S2S9_eta->Draw("COLZ");
myC_variables->SaveAs("S2S9_vs_eta.pdf");
myC_variables->SaveAs("S2S9_vs_eta.png");
TH2F *h_S4S9_eta = hdata->createHistogram(*scetaiXvar, *S4S9var, "","S4S9_vs_eta");
h_S4S9_eta->GetYaxis()->SetTitle("S4S9");
if(EEorEB=="EB")
{
h_CC_eta->GetYaxis()->SetTitle("i#eta");
}
else
{
h_CC_eta->GetYaxis()->SetTitle("iX");
}
h_S4S9_eta->Draw("COLZ");
myC_variables->SaveAs("S4S9_vs_eta.pdf");
myC_variables->SaveAs("S4S9_vs_eta.png");
TH2F *h_S2S9_phi = hdata->createHistogram(*scphiiYvar, *S2S9var, "","S2S9_vs_phi");
h_S2S9_phi->GetYaxis()->SetTitle("S2S9");
if(EEorEB=="EB")
{
h_CC_phi->GetYaxis()->SetTitle("i#phi");
}
else
{
h_CC_phi->GetYaxis()->SetTitle("iY");
}
h_S2S9_phi->Draw("COLZ");
myC_variables->SaveAs("S2S9_vs_phi.pdf");
myC_variables->SaveAs("S2S9_vs_phi.png");
TH2F *h_S4S9_phi = hdata->createHistogram(*scphiiYvar, *S4S9var, "","S4S9_vs_phi");
h_S4S9_phi->GetYaxis()->SetTitle("S4S9");
if(EEorEB=="EB")
{
h_CC_phi->GetYaxis()->SetTitle("i#phi");
}
else
{
h_CC_phi->GetYaxis()->SetTitle("iY");
}
h_S4S9_phi->Draw("COLZ");
myC_variables->SaveAs("S4S9_vs_phi.pdf");
myC_variables->SaveAs("S4S9_vs_phi.png");
if(EEorEB=="EE")
{
}
TProfile *p_CC_eta = h_CC_eta->ProfileX("p_CC_eta");//,1,-1,"s");
p_CC_eta->GetYaxis()->SetRangeUser(0.8,1.05);
if(EEorEB == "EB")
{
// p_CC_eta->GetYaxis()->SetRangeUser(0.85,1.0);
// p_CC_eta->GetXaxis()->SetRangeUser(-1.5,1.5);
}
p_CC_eta->GetYaxis()->SetTitle("E_{cor}/E_{true}");
p_CC_eta->SetTitle("");
p_CC_eta->Draw();
myC_variables->SaveAs("profile_cor_vs_eta.pdf");
myC_variables->SaveAs("profile_cor_vs_eta.png");
gStyle->SetOptStat(111);
gStyle->SetOptFit(1);
TH1F *h1_fit_CC_eta = new TH1F("h1_fit_CC_eta","h1_fit_CC_eta",(EEorEB=="EB") ? 180 : 50,(EEorEB=="EB") ? -90 : 0, (EEorEB=="EB") ? 90 : 50);
for(int ix = 1;ix <= h_CC_eta->GetNbinsX(); ix++)
{
stringstream os_iEta;
os_iEta << ((EEorEB=="EB") ? (-90 + ix -1) : (0 + ix -1));
string ss_iEta = os_iEta.str();
TH1D * h_temp = h_CC_eta->ProjectionY("h_temp",ix,ix);
h_temp->Rebin(4);
TF1 *f_temp = new TF1("f_temp","gaus(0)",0.95,1.07);
h_temp->Fit("f_temp","R");
h1_fit_CC_eta->SetBinContent(ix, f_temp->GetParameter(1));
h1_fit_CC_eta->SetBinError(ix, f_temp->GetParError(1));
h_temp->GetXaxis()->SetTitle("E_{cor}/E_{true}");
h_temp->SetTitle("");
h_temp->Draw();
myC_variables->SaveAs(("fits/CC_iEta_"+ss_iEta+".pdf").c_str());
myC_variables->SaveAs(("fits/CC_iEta_"+ss_iEta+".png").c_str());
myC_variables->SaveAs(("fits/CC_iEta_"+ss_iEta+".C").c_str());
}
gStyle->SetOptStat(0);
gStyle->SetOptFit(0);
h1_fit_CC_eta->GetYaxis()->SetRangeUser(0.95,1.05);
h1_fit_CC_eta->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h1_fit_CC_eta->GetXaxis()->SetTitle((EEorEB=="EB") ? "i#eta" : "iX");
h1_fit_CC_eta->SetTitle("");
h1_fit_CC_eta->Draw();
myC_variables->SaveAs("profile_fit_cor_vs_eta.pdf");
myC_variables->SaveAs("profile_fit_cor_vs_eta.png");
myC_variables->SaveAs("profile_fit_cor_vs_eta.C");
TProfile *p_RC_eta = h_RC_eta->ProfileX("p_RC_eta");//,1,-1,"s");
p_RC_eta->GetYaxis()->SetRangeUser(0.8,1.05);
if(EEorEB=="EB")
{
// p_RC_eta->GetYaxis()->SetRangeUser(0.80,0.95);
// p_RC_eta->GetXaxis()->SetRangeUser(-1.5,1.5);
}
p_RC_eta->GetYaxis()->SetTitle("E_{raw}/E_{true}");
p_RC_eta->SetTitle("");
p_RC_eta->Draw();
myC_variables->SaveAs("profile_raw_vs_eta.pdf");
myC_variables->SaveAs("profile_raw_vs_eta.png");
gStyle->SetOptStat(111);
gStyle->SetOptFit(1);
TH1F *h1_fit_RC_eta = new TH1F("h1_fit_RC_eta","h1_fit_RC_eta",(EEorEB=="EB") ? 180 : 50,(EEorEB=="EB") ? -90 : 0, (EEorEB=="EB") ? 90 : 50);
for(int ix = 1;ix <= h_RC_eta->GetNbinsX(); ix++)
{
stringstream os_iEta;
os_iEta << ((EEorEB=="EB") ? (-90 + ix -1) : (0 + ix -1));
string ss_iEta = os_iEta.str();
TH1D * h_temp = h_RC_eta->ProjectionY("h_temp",ix,ix);
h_temp->Rebin(4);
TF1 *f_temp = new TF1("f_temp","gaus(0)",0.87,1.05);
h_temp->Fit("f_temp","R");
h1_fit_RC_eta->SetBinContent(ix, f_temp->GetParameter(1));
h1_fit_RC_eta->SetBinError(ix, f_temp->GetParError(1));
h_temp->GetXaxis()->SetTitle("E_{raw}/E_{true}");
h_temp->SetTitle("");
h_temp->Draw();
myC_variables->SaveAs(("fits/RC_iEta_"+ss_iEta+".pdf").c_str());
myC_variables->SaveAs(("fits/RC_iEta_"+ss_iEta+".png").c_str());
myC_variables->SaveAs(("fits/RC_iEta_"+ss_iEta+".C").c_str());
}
gStyle->SetOptStat(0);
gStyle->SetOptFit(0);
h1_fit_RC_eta->GetYaxis()->SetRangeUser(0.9,1.0);
h1_fit_RC_eta->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h1_fit_RC_eta->GetXaxis()->SetTitle((EEorEB=="EB") ? "i#eta" : "iX");
h1_fit_RC_eta->SetTitle("");
h1_fit_RC_eta->Draw();
myC_variables->SaveAs("profile_fit_raw_vs_eta.pdf");
myC_variables->SaveAs("profile_fit_raw_vs_eta.png");
myC_variables->SaveAs("profile_fit_raw_vs_eta.C");
int Nbins_iEta = EEorEB=="EB" ? 180 : 50;
int nLow_iEta = EEorEB=="EB" ? -90 : 0;
int nHigh_iEta = EEorEB=="EB" ? 90 : 50;
TH1F *h1_RC_eta = new TH1F("h1_RC_eta","h1_RC_eta",Nbins_iEta,nLow_iEta,nHigh_iEta);
for(int i=1;i<=Nbins_iEta;i++)
{
h1_RC_eta->SetBinContent(i,p_RC_eta->GetBinError(i));
}
h1_RC_eta->GetXaxis()->SetTitle("i#eta");
h1_RC_eta->GetYaxis()->SetTitle("#sigma_{E_{raw}/E_{true}}");
h1_RC_eta->SetTitle("");
h1_RC_eta->Draw();
myC_variables->SaveAs("sigma_Eraw_Etrue_vs_eta.pdf");
myC_variables->SaveAs("sigma_Eraw_Etrue_vs_eta.png");
TH1F *h1_CC_eta = new TH1F("h1_CC_eta","h1_CC_eta",Nbins_iEta,nLow_iEta,nHigh_iEta);
for(int i=1;i<=Nbins_iEta;i++)
{
h1_CC_eta->SetBinContent(i,p_CC_eta->GetBinError(i));
}
h1_CC_eta->GetXaxis()->SetTitle("i#eta");
h1_CC_eta->GetYaxis()->SetTitle("#sigma_{E_{cor}/E_{true}}");
h1_CC_eta->SetTitle("");
h1_CC_eta->Draw();
myC_variables->SaveAs("sigma_Ecor_Etrue_vs_eta.pdf");
myC_variables->SaveAs("sigma_Ecor_Etrue_vs_eta.png");
TProfile *p_CC_phi = h_CC_phi->ProfileX("p_CC_phi");//,1,-1,"s");
p_CC_phi->GetYaxis()->SetRangeUser(0.9,1.0);
if(EEorEB == "EB")
{
// p_CC_phi->GetYaxis()->SetRangeUser(0.94,1.00);
}
p_CC_phi->GetYaxis()->SetTitle("E_{cor}/E_{true}");
p_CC_phi->SetTitle("");
p_CC_phi->Draw();
myC_variables->SaveAs("profile_cor_vs_phi.pdf");
myC_variables->SaveAs("profile_cor_vs_phi.png");
gStyle->SetOptStat(111);
gStyle->SetOptFit(1);
TH1F *h1_fit_CC_phi = new TH1F("h1_fit_CC_phi","h1_fit_CC_phi",(EEorEB=="EB") ? 360 : 50,(EEorEB=="EB") ? 0 : 0, (EEorEB=="EB") ? 360 : 50);
for(int ix = 1;ix <= h_CC_phi->GetNbinsX(); ix++)
{
stringstream os_iPhi;
os_iPhi << ((EEorEB=="EB") ? (0 + ix -1) : (0 + ix -1));
string ss_iPhi = os_iPhi.str();
TH1D * h_temp = h_CC_phi->ProjectionY("h_temp",ix,ix);
h_temp->Rebin(4);
TF1 *f_temp = new TF1("f_temp","gaus(0)",0.95,1.07);
h_temp->Fit("f_temp","R");
h1_fit_CC_phi->SetBinContent(ix, f_temp->GetParameter(1));
h1_fit_CC_phi->SetBinError(ix, f_temp->GetParError(1));
h_temp->GetXaxis()->SetTitle("E_{cor}/E_{true}");
h_temp->SetTitle("");
h_temp->Draw();
myC_variables->SaveAs(("fits/CC_iPhi_"+ss_iPhi+".pdf").c_str());
myC_variables->SaveAs(("fits/CC_iPhi_"+ss_iPhi+".png").c_str());
myC_variables->SaveAs(("fits/CC_iPhi_"+ss_iPhi+".C").c_str());
}
gStyle->SetOptStat(0);
gStyle->SetOptFit(0);
h1_fit_CC_phi->GetYaxis()->SetRangeUser(0.95,1.05);
h1_fit_CC_phi->GetYaxis()->SetTitle("E_{cor}/E_{true}");
h1_fit_CC_phi->GetXaxis()->SetTitle((EEorEB=="EB") ? "i#phi" : "iX");
h1_fit_CC_phi->SetTitle("");
h1_fit_CC_phi->Draw();
myC_variables->SaveAs("profile_fit_cor_vs_phi.pdf");
myC_variables->SaveAs("profile_fit_cor_vs_phi.png");
myC_variables->SaveAs("profile_fit_cor_vs_phi.C");
TProfile *p_RC_phi = h_RC_phi->ProfileX("p_RC_phi");//,1,-1,"s");
p_RC_phi->GetYaxis()->SetRangeUser(0.8,0.9);
if(EEorEB=="EB")
{
// p_RC_phi->GetYaxis()->SetRangeUser(0.89,0.95);
}
p_RC_phi->GetYaxis()->SetTitle("E_{raw}/E_{true}");
p_RC_phi->SetTitle("");
p_RC_phi->Draw();
myC_variables->SaveAs("profile_raw_vs_phi.pdf");
myC_variables->SaveAs("profile_raw_vs_phi.png");
gStyle->SetOptStat(111);
gStyle->SetOptFit(1);
TH1F *h1_fit_RC_phi = new TH1F("h1_fit_RC_phi","h1_fit_RC_phi",(EEorEB=="EB") ? 360 : 50,(EEorEB=="EB") ? 0 : 0, (EEorEB=="EB") ? 360 : 50);
for(int ix = 1;ix <= h_RC_phi->GetNbinsX(); ix++)
{
stringstream os_iPhi;
os_iPhi << ((EEorEB=="EB") ? (0 + ix -1) : (0 + ix -1));
string ss_iPhi = os_iPhi.str();
TH1D * h_temp = h_RC_phi->ProjectionY("h_temp",ix,ix);
h_temp->Rebin(4);
TF1 *f_temp = new TF1("f_temp","gaus(0)",0.87,1.05);
h_temp->Fit("f_temp","R");
h1_fit_RC_phi->SetBinContent(ix, f_temp->GetParameter(1));
h1_fit_RC_phi->SetBinError(ix, f_temp->GetParError(1));
h_temp->GetXaxis()->SetTitle("E_{raw}/E_{true}");
h_temp->SetTitle("");
h_temp->Draw();
myC_variables->SaveAs(("fits/RC_iPhi_"+ss_iPhi+".pdf").c_str());
myC_variables->SaveAs(("fits/RC_iPhi_"+ss_iPhi+".png").c_str());
myC_variables->SaveAs(("fits/RC_iPhi_"+ss_iPhi+".C").c_str());
}
gStyle->SetOptStat(0);
gStyle->SetOptFit(0);
h1_fit_RC_phi->GetYaxis()->SetRangeUser(0.9,1.0);
h1_fit_RC_phi->GetYaxis()->SetTitle("E_{raw}/E_{true}");
h1_fit_RC_phi->GetXaxis()->SetTitle((EEorEB=="EB") ? "i#phi" : "iX");
h1_fit_RC_phi->SetTitle("");
h1_fit_RC_phi->Draw();
myC_variables->SaveAs("profile_fit_raw_vs_phi.pdf");
myC_variables->SaveAs("profile_fit_raw_vs_phi.png");
myC_variables->SaveAs("profile_fit_raw_vs_phi.C");
int Nbins_iPhi = EEorEB=="EB" ? 360 : 50;
int nLow_iPhi = EEorEB=="EB" ? 0 : 0;
int nHigh_iPhi = EEorEB=="EB" ? 360 : 50;
TH1F *h1_RC_phi = new TH1F("h1_RC_phi","h1_RC_phi",Nbins_iPhi,nLow_iPhi,nHigh_iPhi);
for(int i=1;i<=Nbins_iPhi;i++)
{
h1_RC_phi->SetBinContent(i,p_RC_phi->GetBinError(i));
}
h1_RC_phi->GetXaxis()->SetTitle("i#phi");
h1_RC_phi->GetYaxis()->SetTitle("#sigma_{E_{raw}/E_{true}}");
h1_RC_phi->SetTitle("");
h1_RC_phi->Draw();
myC_variables->SaveAs("sigma_Eraw_Etrue_vs_phi.pdf");
myC_variables->SaveAs("sigma_Eraw_Etrue_vs_phi.png");
TH1F *h1_CC_phi = new TH1F("h1_CC_phi","h1_CC_phi",Nbins_iPhi,nLow_iPhi,nHigh_iPhi);
for(int i=1;i<=Nbins_iPhi;i++)
{
h1_CC_phi->SetBinContent(i,p_CC_phi->GetBinError(i));
}
h1_CC_phi->GetXaxis()->SetTitle("i#phi");
h1_CC_phi->GetYaxis()->SetTitle("#sigma_{E_{cor}/E_{true}}");
h1_CC_phi->SetTitle("");
h1_CC_phi->Draw();
myC_variables->SaveAs("sigma_Ecor_Etrue_vs_phi.pdf");
myC_variables->SaveAs("sigma_Ecor_Etrue_vs_phi.png");
// FWHM over sigma_eff vs. eta/phi
TH1F *h1_FoverS_RC_phi = new TH1F("h1_FoverS_RC_phi","h1_FoverS_RC_phi",Nbins_iPhi,nLow_iPhi,nHigh_iPhi);
TH1F *h1_FoverS_CC_phi = new TH1F("h1_FoverS_CC_phi","h1_FoverS_CC_phi",Nbins_iPhi,nLow_iPhi,nHigh_iPhi);
TH1F *h1_FoverS_RC_eta = new TH1F("h1_FoverS_RC_eta","h1_FoverS_RC_eta",Nbins_iEta,nLow_iEta,nHigh_iEta);
TH1F *h1_FoverS_CC_eta = new TH1F("h1_FoverS_CC_eta","h1_FoverS_CC_eta",Nbins_iEta,nLow_iEta,nHigh_iEta);
TH1F *h1_FoverS_CC_S2S9 = new TH1F("h1_FoverS_CC_S2S9","h1_FoverS_CC_S2S9",Nbins_S2S9,Low_S2S9,High_S2S9);
TH1F *h1_FoverS_RC_S2S9 = new TH1F("h1_FoverS_RC_S2S9","h1_FoverS_RC_S2S9",Nbins_S2S9,Low_S2S9,High_S2S9);
TH1F *h1_FoverS_CC_S4S9 = new TH1F("h1_FoverS_CC_S4S9","h1_FoverS_CC_S4S9",Nbins_S4S9,Low_S4S9,High_S4S9);
TH1F *h1_FoverS_RC_S4S9 = new TH1F("h1_FoverS_RC_S4S9","h1_FoverS_RC_S4S9",Nbins_S4S9,Low_S4S9,High_S4S9);
float FWHMoverSigmaEff = 0.0;
TH1F *h_tmp_rawvar = new TH1F("tmp_rawvar","tmp_rawvar",800,0.5,1.5);
TH1F *h_tmp_corvar = new TH1F("tmp_corvar","tmp_corvar",800,0.5,1.5);
for(int i=1;i<=Nbins_iPhi;i++)
{
float FWHM_tmp = 0.0;
float effSigma_tmp = 0.0;
for(int j=1;j<=800;j++)
{
h_tmp_rawvar->SetBinContent(j,h_RC_phi->GetBinContent(i,j));
h_tmp_corvar->SetBinContent(j,h_CC_phi->GetBinContent(i,j));
}
FWHMoverSigmaEff = 0.0;
FWHM_tmp= FWHM(h_tmp_rawvar);
effSigma_tmp = effSigma(h_tmp_rawvar);
if(effSigma_tmp>0.000001) FWHMoverSigmaEff = FWHM_tmp/effSigma_tmp;
h1_FoverS_RC_phi->SetBinContent(i, FWHMoverSigmaEff);
FWHMoverSigmaEff = 0.0;
FWHM_tmp= FWHM(h_tmp_corvar);
effSigma_tmp = effSigma(h_tmp_corvar);
if(effSigma_tmp>0.000001) FWHMoverSigmaEff = FWHM_tmp/effSigma_tmp;
h1_FoverS_CC_phi->SetBinContent(i, FWHMoverSigmaEff);
}
h1_FoverS_CC_phi->GetXaxis()->SetTitle("i#phi");
h1_FoverS_CC_phi->GetYaxis()->SetTitle("FWHM/#sigma_{eff} of E_{cor}/E_{true}");
h1_FoverS_CC_phi->SetTitle("");
h1_FoverS_CC_phi->Draw();
myC_variables->SaveAs("FoverS_Ecor_Etrue_vs_phi.pdf");
myC_variables->SaveAs("FoverS_Ecor_Etrue_vs_phi.png");
h1_FoverS_RC_phi->GetXaxis()->SetTitle("i#phi");
h1_FoverS_RC_phi->GetYaxis()->SetTitle("FWHM/#sigma_{eff} of E_{raw}/E_{true}");
h1_FoverS_RC_phi->SetTitle("");
h1_FoverS_RC_phi->Draw();
myC_variables->SaveAs("FoverS_Eraw_Etrue_vs_phi.pdf");
myC_variables->SaveAs("FoverS_Eraw_Etrue_vs_phi.png");
for(int i=1;i<=Nbins_iEta;i++)
{
float FWHM_tmp = 0.0;
float effSigma_tmp = 0.0;
for(int j=1;j<=800;j++)
{
h_tmp_rawvar->SetBinContent(j,h_RC_eta->GetBinContent(i,j));
h_tmp_corvar->SetBinContent(j,h_CC_eta->GetBinContent(i,j));
}
FWHMoverSigmaEff = 0.0;
FWHM_tmp= FWHM(h_tmp_rawvar);
effSigma_tmp = effSigma(h_tmp_rawvar);
if(effSigma_tmp>0.000001) FWHMoverSigmaEff = FWHM_tmp/effSigma_tmp;
h1_FoverS_RC_eta->SetBinContent(i, FWHMoverSigmaEff);
FWHMoverSigmaEff = 0.0;
FWHM_tmp= FWHM(h_tmp_corvar);
effSigma_tmp = effSigma(h_tmp_corvar);
if(effSigma_tmp>0.000001) FWHMoverSigmaEff = FWHM_tmp/effSigma_tmp;
h1_FoverS_CC_eta->SetBinContent(i, FWHMoverSigmaEff);
}
h1_FoverS_CC_eta->GetXaxis()->SetTitle("i#eta");
h1_FoverS_CC_eta->GetYaxis()->SetTitle("FWHM/#sigma_{eff} of E_{cor}/E_{true}");
h1_FoverS_CC_eta->SetTitle("");
h1_FoverS_CC_eta->Draw();
myC_variables->SaveAs("FoverS_Ecor_Etrue_vs_eta.pdf");
myC_variables->SaveAs("FoverS_Ecor_Etrue_vs_eta.png");
h1_FoverS_RC_eta->GetXaxis()->SetTitle("i#eta");
h1_FoverS_RC_eta->GetYaxis()->SetTitle("FWHM/#sigma_{eff} of E_{raw}/E_{true}");
h1_FoverS_RC_eta->SetTitle("");
h1_FoverS_RC_eta->Draw();
myC_variables->SaveAs("FoverS_Eraw_Etrue_vs_eta.pdf");
myC_variables->SaveAs("FoverS_Eraw_Etrue_vs_eta.png");
for(int i=1;i<=Nbins_S2S9;i++)
{
float FWHM_tmp = 0.0;
float effSigma_tmp = 0.0;
for(int j=1;j<=800;j++)
{
h_tmp_rawvar->SetBinContent(j,h_RC_S2S9->GetBinContent(i,j));
h_tmp_corvar->SetBinContent(j,h_CC_S2S9->GetBinContent(i,j));
}
FWHMoverSigmaEff = 0.0;
FWHM_tmp= FWHM(h_tmp_rawvar);
effSigma_tmp = effSigma(h_tmp_rawvar);
if(effSigma_tmp>0.000001) FWHMoverSigmaEff = FWHM_tmp/effSigma_tmp;
h1_FoverS_RC_S2S9->SetBinContent(i, FWHMoverSigmaEff);
FWHMoverSigmaEff = 0.0;
FWHM_tmp= FWHM(h_tmp_corvar);
effSigma_tmp = effSigma(h_tmp_corvar);
if(effSigma_tmp>0.000001) FWHMoverSigmaEff = FWHM_tmp/effSigma_tmp;
h1_FoverS_CC_S2S9->SetBinContent(i, FWHMoverSigmaEff);
}
h1_FoverS_CC_S2S9->GetXaxis()->SetTitle("S2S9");
h1_FoverS_CC_S2S9->GetYaxis()->SetTitle("FWHM/#sigma_{eff} of E_{cor}/E_{true}");
h1_FoverS_CC_S2S9->GetYaxis()->SetRangeUser(0.0,1.0);
h1_FoverS_CC_S2S9->SetTitle("");
h1_FoverS_CC_S2S9->Draw();
myC_variables->SaveAs("FoverS_Ecor_Etrue_vs_S2S9.pdf");
myC_variables->SaveAs("FoverS_Ecor_Etrue_vs_S2S9.png");
h1_FoverS_RC_S2S9->GetXaxis()->SetTitle("S2S9");
h1_FoverS_RC_S2S9->GetYaxis()->SetTitle("FWHM/#sigma_{eff} of E_{raw}/E_{true}");
h1_FoverS_RC_S2S9->GetYaxis()->SetRangeUser(0.0,2.0);
h1_FoverS_RC_S2S9->SetTitle("");
h1_FoverS_RC_S2S9->Draw();
myC_variables->SaveAs("FoverS_Eraw_Etrue_vs_S2S9.pdf");
myC_variables->SaveAs("FoverS_Eraw_Etrue_vs_S2S9.png");
for(int i=1;i<=Nbins_S4S9;i++)
{
float FWHM_tmp = 0.0;
float effSigma_tmp = 0.0;
for(int j=1;j<=800;j++)
{
h_tmp_rawvar->SetBinContent(j,h_RC_S4S9->GetBinContent(i,j));
h_tmp_corvar->SetBinContent(j,h_CC_S4S9->GetBinContent(i,j));
}
FWHMoverSigmaEff = 0.0;
FWHM_tmp= FWHM(h_tmp_rawvar);
effSigma_tmp = effSigma(h_tmp_rawvar);
if(effSigma_tmp>0.000001) FWHMoverSigmaEff = FWHM_tmp/effSigma_tmp;
h1_FoverS_RC_S4S9->SetBinContent(i, FWHMoverSigmaEff);
FWHMoverSigmaEff = 0.0;
FWHM_tmp= FWHM(h_tmp_corvar);
effSigma_tmp = effSigma(h_tmp_corvar);
if(effSigma_tmp>0.000001) FWHMoverSigmaEff = FWHM_tmp/effSigma_tmp;
h1_FoverS_CC_S4S9->SetBinContent(i, FWHMoverSigmaEff);
}
h1_FoverS_CC_S4S9->GetXaxis()->SetTitle("S4S9");
h1_FoverS_CC_S4S9->GetYaxis()->SetTitle("FWHM/#sigma_{eff} of E_{cor}/E_{true}");
h1_FoverS_CC_S4S9->GetYaxis()->SetRangeUser(0.0,1.0);
h1_FoverS_CC_S4S9->SetTitle("");
h1_FoverS_CC_S4S9->Draw();
myC_variables->SaveAs("FoverS_Ecor_Etrue_vs_S4S9.pdf");
myC_variables->SaveAs("FoverS_Ecor_Etrue_vs_S4S9.png");
h1_FoverS_RC_S4S9->GetXaxis()->SetTitle("S4S9");
h1_FoverS_RC_S4S9->GetYaxis()->SetTitle("FWHM/#sigma_{eff} of E_{raw}/E_{true}");
h1_FoverS_RC_S4S9->GetYaxis()->SetRangeUser(0.0,2.0);
h1_FoverS_RC_S4S9->SetTitle("");
h1_FoverS_RC_S4S9->Draw();
myC_variables->SaveAs("FoverS_Eraw_Etrue_vs_S4S9.pdf");
myC_variables->SaveAs("FoverS_Eraw_Etrue_vs_S4S9.png");
printf("calc effsigma\n");
std::cout<<"_"<<EEorEB<<std::endl;
printf("corrected curve effSigma= %5f, FWHM=%5f \n",effsigma_cor, fwhm_cor);
printf("raw curve effSigma= %5f FWHM=%5f \n",effsigma_raw, fwhm_raw);
/* new TCanvas;
RooPlot *ploteold = testvar.frame(0.6,1.2,100);
hdatasigtest->plotOn(ploteold);
ploteold->Draw();
new TCanvas;
RooPlot *plotecor = ecorvar->frame(0.6,1.2,100);
hdatasig->plotOn(plotecor);
plotecor->Draw(); */
}
void eregmerge(bool doele) {
TString dirname = "/afs/cern.ch/user/b/bendavid/CMSSWhgg/CMSSW_5_3_11_patch5/src/HiggsAnalysis/GBRLikelihoodEGTools/data/";
gSystem->mkdir(dirname,true);
gSystem->cd(dirname);
TString fnameeb;
TString fnameee;
if (doele) {
fnameeb = "wereg_ele_eb.root";
fnameee = "wereg_ele_ee.root";
}
else if (!doele) {
fnameeb = "wereg_ph_eb.root";
fnameee = "wereg_ph_ee.root";
}
TString infileeb = TString::Format("/afs/cern.ch/work/b/bendavid/bare/eregAug10RCalphafix/%s",fnameeb.Data());
TString infileee = TString::Format("/afs/cern.ch/work/b/bendavid/bare/eregAug10RCalphafix/%s",fnameee.Data());
TFile *fwseb = TFile::Open(infileeb);
TFile *fwsee = TFile::Open(infileee);
RooWorkspace *wseb = (RooWorkspace*)fwseb->Get("wereg");
RooWorkspace *wsee = (RooWorkspace*)fwsee->Get("wereg");
RooAbsPdf *sigpdfeborig = wseb->pdf("sigpdf");
RooAbsPdf *sigpdfeeorig = wsee->pdf("sigpdf");
RooAbsPdf *sigpdfeb = static_cast<RooAbsPdf*>(cloneRecursiveRename(sigpdfeborig,"EB"));
RooAbsPdf *sigpdfee = static_cast<RooAbsPdf*>(cloneRecursiveRename(sigpdfeeorig,"EE"));
RooWorkspace *wsout = new RooWorkspace("EGRegressionWorkspace");
wsout->import(*sigpdfeb);
wsout->import(*sigpdfee);
TString outname;
if (doele) outname = "regweights_v4_ele.root";
else outname = "regweights_v4_ph.root";
wsout->writeToFile(outname);
RooArgList pdfeblist;
RooArgSet *pdfebcomps = sigpdfeb->getComponents();
RooArgSet *pdfebvars = sigpdfeb->getVariables();
pdfeblist.add(*pdfebcomps);
pdfeblist.add(*pdfebvars);
delete pdfebcomps;
delete pdfebvars;
RooArgList pdfeelist;
RooArgSet *pdfeecomps = sigpdfee->getComponents();
RooArgSet *pdfeevars = sigpdfee->getVariables();
pdfeelist.add(*pdfeecomps);
pdfeelist.add(*pdfeevars);
delete pdfeecomps;
delete pdfeevars;
// RooArgList components(ws->components());
// for (int iarg=0; iarg<components.getSize(); ++iarg) {
// components.at(iarg)->SetName(TString::Format("%s_1",components.at(iarg)->GetName()));
// }
RooGBRFunction *funceb = static_cast<RooGBRFunction*>(pdfeblist.find("func_EB"));
RooGBRFunction *funcee = static_cast<RooGBRFunction*>(pdfeelist.find("func_EE"));
// funceb->Vars().Print("V");
// funcee->Vars().Print("V");
for (int ivar=0; ivar<funceb->Vars().getSize(); ++ivar) {
printf("%i: %s, %s\n",ivar,funceb->Vars().at(ivar)->GetName(),funceb->Vars().at(ivar)->GetTitle());
}
for (int ivar=0; ivar<funcee->Vars().getSize(); ++ivar) {
printf("%i: %s, %s\n",ivar,funcee->Vars().at(ivar)->GetName(),funcee->Vars().at(ivar)->GetTitle());
}
TString outnameforest;
if (doele) outnameforest = "regweights_v4_forest_ele.root";
else outnameforest = "regweights_v4_forest_ph.root";
TFile *fforest = new TFile(outnameforest,"RECREATE");
fforest->WriteObject(funceb->Forest(),"EGRegressionForest_EB");
fforest->WriteObject(funcee->Forest(),"EGRegressionForest_EE");
fforest->Close();
}
double ro_fit4( TH1F * h2, int p4,int p3,int p2,int p1 ){
TCanvas *chi=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("c_hist");
if (chi!=NULL){
chi->cd();
}
int npeaks=4;
if (npeaks>NMAX){ printf("TOO MANY PEAKS\n",""); return 1;}
TH1F *h2;
double pk[NMAX];
double si[NMAX];
double ar[NMAX];
double al[NMAX];
double n1;
double min=h2->GetXaxis()->GetFirst(),
max=h2->GetXaxis()->GetLast(),
smin=(max-min)/1000,
smax=(max-min),
amin=h2->Integral( min, max )/1000.,
amax=h2->Integral( min, max ),
almin=0.,
almax=100.,
nmin=1.0,
nmax=100.;
pk[0]=p4;
pk[1]=p3;
pk[2]=p2;
pk[3]=p1;
for (int i=0;i<npeaks;i++){
// pk[i]=1.0*(i+1)/(1+npeaks)*(max-min) +min;
si[i]=4.3.;
ar[i]=1.0*(amax+amin)/npeaks/2; //area
al[i]=1.3;
}
n1=5.1;
smin=0.5* si[0];
smax=2.*si[0];
int tag=1;
int i;
printf("%d peaks : ", npeaks);
for (i=0;i<npeaks;i++){
printf( "%8.2f ",pk[i] );
}
printf("\n######### TAG %7d\n", tag++);
//================ MAIN variable 1D ==============
RooRealVar x("x", "x", min, max);
/*
*
* CHEBYSHEV HERE
*/
char sbg="p1";
// Build Chebychev polynomial p.d.f.
// RooRealVar a0("a0","a0", 0.) ;
RooRealVar a0("a0","a0", 0., -10, 10) ;
RooRealVar a1("a1","a1", 0., -10, 10) ;
RooRealVar a2("a2","a2", 0., -10, 10) ;
RooRealVar a3("a3","a3", 0., -10, 10) ;
RooArgSet setcheb;
if ( sbg=="pn" ){ setcheb.add(a0);a0=0.;a0.setConstant(kTRUE);bgarea=0.;bgarea.setConstant(kTRUE);}
if ( sbg=="p0" ){ setcheb.add(a0); a0=0.; a0.setConstant(kTRUE); }
if ( sbg=="p1" ){ setcheb.add(a0); }
if ( sbg=="p2" ){ setcheb.add(a1);setcheb.add(a0); }
if ( sbg=="p3" ){ setcheb.add(a2);setcheb.add(a1); setcheb.add(a0);}
if ( sbg=="p4" ){ setcheb.add(a3);setcheb.add(a2); setcheb.add(a1); setcheb.add(a0); }
RooChebychev bkg("bkg","Background",x, setcheb ) ;
RooRealVar mean1("mean1", "mean_", pk[0], min,max);
RooRealVar mean2("mean2", "mean_", pk[1], min,max);
RooRealVar mean3("mean3", "mean_", pk[2], min,max);
RooRealVar mean4("mean4", "mean_", pk[3], min,max);
RooRealVar mean5("mean5", "mean_", pk[4], min,max);
RooRealVar mean6("mean6", "mean_", pk[5], min,max);
RooRealVar mean7("mean7", "mean_", pk[6], min,max);
RooRealVar mean8("mean8", "mean_", pk[7], min,max);
RooRealVar mean9("mean9", "mean_", pk[8], min,max);
RooRealVar meana("meana", "mean_", pk[9], min,max);
RooRealVar meanb("meanb", "mean_", pk[10], min,max);
RooRealVar meanc("meanc", "mean_", pk[11], min,max);
RooRealVar meand("meand", "mean_", pk[12], min,max);
RooRealVar meane("meane", "mean_", pk[13], min,max);
RooRealVar meanf("meanf", "mean_", pk[14], min,max);
RooRealVar sigm1("sigm1", "sigma", si[0], smin, smax);
RooRealVar sigm2("sigm2", "sigma", si[1], smin, smax);
RooRealVar sigm3("sigm3", "sigma", si[2], smin, smax);
RooRealVar sigm4("sigm4", "sigma", si[3], smin, smax);
RooRealVar sigm5("sigm5", "sigma", si[4], smin, smax);
RooRealVar sigm6("sigm6", "sigma", si[5], smin, smax);
RooRealVar sigm7("sigm7", "sigma", si[6], smin, smax);
RooRealVar sigm8("sigm8", "sigma", si[7], smin, smax);
RooRealVar sigm9("sigm9", "sigma", si[8], smin, smax);
RooRealVar sigma("sigma", "sigma", si[9], smin, smax);
RooRealVar sigmb("sigmb", "sigma", si[10], smin, smax);
RooRealVar sigmc("sigmc", "sigma", si[11], smin, smax);
RooRealVar sigmd("sigmd", "sigma", si[12], smin, smax);
RooRealVar sigme("sigme", "sigma", si[13], smin, smax);
RooRealVar sigmf("sigmf", "sigma", si[14], smin, smax);
RooRealVar fs2("fs2","fs2", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fs3("fs3","fs3", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fs4("fs4","fs4", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fs5("fs5","fs5", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fs6("fs6","fs6", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fs7("fs7","fs7", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fs8("fs8","fs8", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fs9("fs9","fs9", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fsa("fsa","fsa", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fsb("fsb","fsb", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fsc("fsc","fsc", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fsd("fsd","fsd", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fse("fse","fse", 0.0 ); // factor sigma = 1==free or 0==fix
RooRealVar fsf("fsf","fsf", 0.0 ); // factor sigma = 1==free or 0==fix
RooFormulaVar fsigm2( "fsigm2", " fs2*sigm2 + (1.0-fs2)*sigm1" , RooArgSet(sigm1,sigm2,fs2) );
RooFormulaVar fsigm3( "fsigm3", " fs3*sigm3 + (1.0-fs3)*sigm1" , RooArgSet(sigm1,sigm3,fs3) );
RooFormulaVar fsigm4( "fsigm4", " fs4*sigm4 + (1.0-fs4)*sigm1" , RooArgSet(sigm1,sigm4,fs4) );
RooFormulaVar fsigm5( "fsigm5", " fs5*sigm5 + (1.0-fs5)*sigm1" , RooArgSet(sigm1,sigm5,fs5) );
RooFormulaVar fsigm6( "fsigm6", " fs6*sigm6 + (1.0-fs6)*sigm1" , RooArgSet(sigm1,sigm6,fs6) );
RooFormulaVar fsigm7( "fsigm7", " fs7*sigm7 + (1.0-fs7)*sigm1" , RooArgSet(sigm1,sigm7,fs7) );
RooFormulaVar fsigm8( "fsigm8", " fs8*sigm8 + (1.0-fs8)*sigm1" , RooArgSet(sigm1,sigm8,fs8) );
RooFormulaVar fsigm9( "fsigm9", " fs9*sigm9 + (1.0-fs9)*sigm1" , RooArgSet(sigm1,sigm9,fs9) );
RooFormulaVar fsigma( "fsigma", " fsa*sigma + (1.0-fsa)*sigm1" , RooArgSet(sigm1,sigma,fsa) );
RooFormulaVar fsigmb( "fsigmb", " fsb*sigmb + (1.0-fsb)*sigm1" , RooArgSet(sigm1,sigmb,fsb) );
RooFormulaVar fsigmc( "fsigmc", " fsc*sigmc + (1.0-fsc)*sigm1" , RooArgSet(sigm1,sigmc,fsc) );
RooFormulaVar fsigmd( "fsigmd", " fsd*sigmd + (1.0-fsd)*sigm1" , RooArgSet(sigm1,sigmd,fsd) );
RooFormulaVar fsigme( "fsigme", " fse*sigme + (1.0-fse)*sigm1" , RooArgSet(sigm1,sigme,fse) );
RooFormulaVar fsigmf( "fsigmf", " fsf*sigmf + (1.0-fsf)*sigm1" , RooArgSet(sigm1,sigmf,fsf) );
// -------- fsx 0== FIX to sigm1; 1==free sigma
fs2.setVal( 0.0 );
fs3.setVal( 0.0 );
fs4.setVal( 0.0 );
fs5.setVal( 1.0 );
fs6.setVal( 1.0 );
fs7.setVal( 1.0 );
fs8.setVal( 1.0 );
fs9.setVal( 1.0 );
fsa.setVal( 1.0 );
fsb.setVal( 1.0 );
fsc.setVal( 1.0 );
fsd.setVal( 1.0 );
fse.setVal( 1.0 );
fsf.setVal( 1.0 );
fs2.setConstant( kTRUE );
fs3.setConstant( kTRUE );
fs4.setConstant( kTRUE );
fs5.setConstant( kTRUE );
fs6.setConstant( kTRUE );
fs7.setConstant( kTRUE );
fs8.setConstant( kTRUE );
fs9.setConstant( kTRUE );
fsa.setConstant( kTRUE );
fsb.setConstant( kTRUE );
fsc.setConstant( kTRUE );
fsd.setConstant( kTRUE );
fse.setConstant( kTRUE );
fsf.setConstant( kTRUE );
if (fs2.getVal()==0.0){sigm2.setConstant( kTRUE );}
if (fs3.getVal()==0.0){sigm3.setConstant( kTRUE );}
if (fs4.getVal()==0.0){sigm4.setConstant( kTRUE );}
if (fs5.getVal()==0.0){sigm5.setConstant( kTRUE );}
if (fs6.getVal()==0.0){sigm6.setConstant( kTRUE );}
if (fs7.getVal()==0.0){sigm7.setConstant( kTRUE );}
if (fs8.getVal()==0.0){sigm8.setConstant( kTRUE );}
if (fs9.getVal()==0.0){sigm9.setConstant( kTRUE );}
if (fsa.getVal()==0.0){sigma.setConstant( kTRUE );}
if (fsb.getVal()==0.0){sigmb.setConstant( kTRUE );}
if (fsc.getVal()==0.0){sigmc.setConstant( kTRUE );}
if (fsd.getVal()==0.0){sigmd.setConstant( kTRUE );}
if (fse.getVal()==0.0){sigme.setConstant( kTRUE );}
if (fsf.getVal()==0.0){sigmf.setConstant( kTRUE );}
// extra thing that goes to RootSet
RooRealVar area1("area1", "area_", ar[0], amin, amax);
RooRealVar area2("area2", "area_", ar[1], amin, amax);
RooRealVar area3("area3", "area_", ar[2], amin, amax);
RooRealVar area4("area4", "area_", ar[3], amin, amax);
RooRealVar area5("area5", "area_", ar[4], amin, amax);
RooRealVar area6("area6", "area_", ar[5], amin, amax);
RooRealVar area7("area7", "area_", ar[6], amin, amax);
RooRealVar area8("area8", "area_", ar[7], amin, amax);
RooRealVar area9("area9", "area_", ar[8], amin, amax);
RooRealVar areaa("areaa", "area_", ar[9], amin, amax);
RooRealVar areab("areab", "area_", ar[10], amin, amax);
RooRealVar areac("areac", "area_", ar[11], amin, amax);
RooRealVar aread("aread", "area_", ar[12], amin, amax);
RooRealVar areae("areae", "area_", ar[13], amin, amax);
RooRealVar areaf("areaf", "area_", ar[14], amin, amax);
RooRealVar bgarea("bgarea", "bgarea", 1.0*(amin+amax)/2., 0, amax);
//=================== only one instance ===================
RooRealVar alph1("alph1", "alph1", al[0], almin, almax );
RooRealVar ncbs1("n1", "n1", n1, nmin, nmax );
RooCBShape cb1("cb1","CBS", x,mean1, sigm1,alph1,ncbs1);
RooCBShape cb2("cb2","CBS", x,mean2,fsigm2,alph1,ncbs1);
RooCBShape cb3("cb3","CBS", x,mean3,fsigm3,alph1,ncbs1);
RooCBShape cb4("cb4","CBS", x,mean4,fsigm4,alph1,ncbs1);
RooCBShape cb5("cb5","CBS", x,mean5,fsigm5,alph1,ncbs1);
RooCBShape cb6("cb6","CBS", x,mean6,fsigm6,alph1,ncbs1);
RooCBShape cb7("cb7","CBS", x,mean7,fsigm7,alph1,ncbs1);
RooCBShape cb8("cb8","CBS", x,mean8,fsigm8,alph1,ncbs1);
RooCBShape cb9("cb9","CBS", x,mean9,fsigm9,alph1,ncbs1);
RooCBShape cba("cba","CBS", x,meana,fsigma,alph1,ncbs1);
RooCBShape cbb("cbb","CBS", x,meanb,fsigmb,alph1,ncbs1);
RooCBShape cbc("cbc","CBS", x,meanc,fsigmc,alph1,ncbs1);
RooCBShape cbd("cbd","CBS", x,meand,fsigmd,alph1,ncbs1);
RooCBShape cbe("cbe","CBS", x,meane,fsigme,alph1,ncbs1);
RooCBShape cbf("cbf","CBS", x,meanf,fsigmf,alph1,ncbs1);
RooExtendPdf ecb1("ecb1","ECBS", cb1, area1 );
RooExtendPdf ecb2("ecb2","ECBS", cb2, area2 );
RooExtendPdf ecb3("ecb3","ECBS", cb3, area3 );
RooExtendPdf ecb4("ecb4","ECBS", cb4, area4 );
RooExtendPdf ecb5("ecb5","ECBS", cb5, area5 );
RooExtendPdf ecb6("ecb6","ECBS", cb6, area6 );
RooExtendPdf ecb7("ecb7","ECBS", cb7, area7 );
RooExtendPdf ecb8("ecb8","ECBS", cb8, area8 );
RooExtendPdf ecb9("ecb9","ECBS", cb9, area9 );
RooExtendPdf ecba("ecba","ECBS", cba, areaa );
RooExtendPdf ecbb("ecbb","ECBS", cbb, areab );
RooExtendPdf ecbc("ecbc","ECBS", cbc, areac );
RooExtendPdf ecbd("ecbd","ECBS", cbd, aread );
RooExtendPdf ecbe("ecbe","ECBS", cbe, areae );
RooExtendPdf ecbf("ecbf","ECBS", cbf, areaf );
RooArgList erl;
if (npeaks>0)erl.add( ecb1 );
if (npeaks>1)erl.add( ecb2 );
if (npeaks>2)erl.add( ecb3 );
if (npeaks>3)erl.add( ecb4 );
if (npeaks>4)erl.add( ecb5 );
if (npeaks>5)erl.add( ecb6 );
if (npeaks>6)erl.add( ecb7 );
if (npeaks>7)erl.add( ecb8 );
if (npeaks>8)erl.add( ecb9 );
if (npeaks>9)erl.add( ecba );
if (npeaks>10)erl.add( ecbb );
if (npeaks>11)erl.add( ecbc );
if (npeaks>12)erl.add( ecbd );
if (npeaks>13)erl.add( ecbe );
if (npeaks>14)erl.add( ecbf );
RooExtendPdf ebkg("ebkg","EBkg", bkg, bgarea );
erl.add( ebkg );
RooAddPdf emodelV("emodel","emultiplet", erl );
emodelV.Print("v");
RooDataHist datah("datah","datah with x",x,h2);
RooPlot* xframe = x.frame();
datah.plotOn(xframe, DrawOption("logy") );
// RooPlot* xframe = x.frame();
/*
bkg.plotOn( xframe, LineColor(kBlue) );
cb1.plotOn( xframe, LineColor(kRed) );
*/
// xframe->Draw();
/*
* Here I believe to put the parameters for fit????
*
*/
/*
RooArgList rl;
if (npeaks>0)rl.add( cb1 );
if (npeaks>1)rl.add( cb2 );
if (npeaks>2)rl.add( cb3 );
if (npeaks>3)rl.add( cb4 );
if (npeaks>4)rl.add( cb5 );
if (npeaks>5)rl.add( cb6 );
if (npeaks>6)rl.add( cb7 );
if (npeaks>7)rl.add( cb8 );
if (npeaks>8)rl.add( cb9 );
if (npeaks>9)rl.add( cba );
if (npeaks>10)rl.add( cbb );
if (npeaks>11)rl.add( cbc );
if (npeaks>12)rl.add( cbd );
if (npeaks>13)rl.add( cbe );
if (npeaks>14)rl.add( cbf );
rl.add( bkg );
// asi zastoupeni jednotlivych piku viz vyse------------
// RooArgSet rs;
RooArgList rs;
if (npeaks>0)rs.add( area1 );
if (npeaks>1)rs.add( area2 );
if (npeaks>2)rs.add( area3 );
if (npeaks>3)rs.add( area4 );
if (npeaks>4)rs.add( area5 );
if (npeaks>5)rs.add( area6 );
if (npeaks>6)rs.add( area7 );
if (npeaks>7)rs.add( area8 );
if (npeaks>8)rs.add( area9 );
if (npeaks>9)rs.add( areaa );
if (npeaks>10)rs.add( areab );
if (npeaks>11)rs.add( areac );
if (npeaks>12)rs.add( aread );
if (npeaks>13)rs.add( areae );
if (npeaks>14)rs.add( areaf );
rs.add( bgarea );
//if # coefficients(rs)+1=functions(rl) => coef.are interpreted as fractions
RooAddPdf modelV("model","multiplet", rl, rs );
modelV.Print("v");
*/
/*
* WITH CUSTOMIZER - I can change parameters inside. But
* - then all is a clone and I dont know how to reach it.->Iterations...difficlt
I try something with RooFormulaVar
*/
fitresult = emodelV.fitTo( datah , Save() );
fitresult->Print("v") ;
fitresult->floatParsFinal().Print("s") ;
// model->Print(); // not interesting........
emodelV.plotOn(xframe, LineColor(kRed), DrawOption("l0z") );
emodelV.plotOn(xframe, Components(ecb1),LineColor(kGreen),LineStyle(kDashed) );
emodelV.plotOn(xframe, Components(RooArgSet(ecb1,ebkg)),LineColor(kBlue),LineStyle(kDashed) );
emodelV.plotOn(xframe, Components(RooArgSet(ecb2,ebkg)),LineColor(kBlue),LineStyle(kDashed) );
emodelV.plotOn(xframe, Components(RooArgSet(ecb3,ebkg)),LineColor(kBlue),LineStyle(kDashed) );
emodelV.plotOn(xframe, Components(RooArgSet(ecb4,ebkg)),LineColor(kBlue),LineStyle(kDashed) );
emodelV.plotOn(xframe, Components( RooArgSet(ebkg) ), LineColor(kRed) );
xframe->Draw();
printf("FWHM = = %f chan\n", sigm1.getVal()*2.3548 );
printf("FWHM = = %f keV\n", sigm1.getVal()*2.3548 *5804.0/p1 );
return sigm1.getVal()*2.3548 *5804.0/p1 ;
}//==================================ro_fit4 ======
void resonances_convolution_K1_1400()
{
Int_t nEvents = 10000;
Int_t evt = 100;
Int_t counter = 0;
Double_t pionmass = 139.6;
Double_t kaonmass = 493.7;
Double_t KpipiUP = 4000.;
Double_t KpipiLOW = 1000.;
Double_t pipiUP = 2000.;
Double_t pipiLOW = 0.;
Int_t nbins = 500;
Double_t R = 0.0031; // 3.1 GeV-1
RooRealVar m_Kpipi("m_Kpipi","m_{K#pi#pi} [MeV/c^{2}]",KpipiLOW,KpipiUP);
Double_t mass_Kpipi;
RooMsgService::instance().setSilentMode(true);
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR) ; //WAS WARNING
//--------------------------------
// K1(1400) -> K rho(pi pi) BR ~ 3%
//--------------------------------
RooRealVar m_pipi("m_pipi","m_{#pi#pi} [MeV/c^{2}]",pipiLOW,pipiUP);
RooRealVar* var_mass_pipi = new RooRealVar("var_mass_pipi","var_mass_pipi",pipiLOW,pipiUP);
Double_t mass_pipi;
// Construct BreitWigner s K1(1400) -> rho K
RooRealVar m_BWs1("m_BWs1","m_BWs1",1403.);
RooRealVar width_BWs1("width_BWs1","width_BWs1",174.);
RooRelBreitWigner BWs1("BWs","BWs",m_Kpipi,m_BWs1,width_BWs1,RooConst(0),RooConst(R),*var_mass_pipi,RooConst(403.7)); // K1 -> rho K (s wave)
// Construct BreitWigner p for rho -> pi pi
RooRealVar m_BWp1("m_BWp1","m_BWp1",775.5);
RooRealVar width_BWp1("width_BWp1","width_BWp1",146.2);
RooRelBreitWigner BWp1("BWp1","BWp1",m_pipi,m_BWp1,width_BWp1,RooConst(1),RooConst(R),RooConst(139.6),RooConst(139.6)); // rho -> pi pi (p wave)
// Define histograms
TH2F* hist1 = new TH2F("hist1","m_{#pi#pi} vs m_{K#pi#pi}",nbins,pipiLOW,pipiUP,nbins,KpipiLOW,KpipiUP);
TH1F* hist1KpipiShape = new TH1F("hist1KpipiShape","m_{K#pi#pi} shape after convolution",nbins,KpipiLOW,KpipiUP);
// Generate
RooDataSet* data_BWp1 = BWp1.generate(m_pipi,nEvents);
// Get generated values
RooArgSet* obs_2 = data_BWp1->get();
RooRealVar* data_2 = obs_2->find(m_pipi.GetName());
// Convoluting distributions
for (int j=0; j< data_BWp1->numEntries();j++)
{
if (0 == j%100) cout<<j+1<<endl;
data_BWp1->get(j);
mass_pipi = data_2->getVal();
var_mass_pipi->setVal(mass_pipi);
RooDataSet* data_BWs1 = BWs1.generate(m_Kpipi,evt);
RooArgSet* obs_1 = data_BWs1->get();
RooRealVar* data_1 = obs_1->find(m_Kpipi.GetName());
for (int k=0; k<data_BWs1->numEntries();k++)
{
data_BWs1->get(k);
mass_Kpipi = data_1->getVal();
hist1->Fill(mass_pipi,mass_Kpipi);
hist1KpipiShape->Fill(mass_Kpipi);
counter++;
}
}
cout << "generated Kpipi events = " << counter << endl;
// Generate distribution for BWs at fixed rho massa
var_mass_pipi->setVal(775.5);
RooDataSet* data_BWs1_bis = BWs1.generate(m_Kpipi,nEvents);
RooDataHist Shape_K1_1400toKrho("Shape_K1_1400toKrho","Shape of the convoluted pdf",m_Kpipi,hist1KpipiShape);
RooHistPdf histPdf_K1_1400toKrho("histPdf_K1_1400toKrho","histPdf_K1_1400toKrho",m_Kpipi,Shape_K1_1400toKrho,2); // last number is the order of the interpolation
// Drawing plots
TCanvas* c = new TCanvas("c","K1(1400) -> K #rho(#pi#pi)",1550,20,1000,1000);
c->Divide(2,2);
c->cd(1);
hist1->SetXTitle("m_{#pi#pi} [GeV/c^{2}]");
hist1->SetYTitle("m_{K#pi#pi} [GeV/c^{2}]");
hist1->Draw("colz");
c->cd(2);
RooPlot* frame1_Kpipi = m_Kpipi.frame(Name("m_{K#pi#pi} shape comparison"),Title("m_{K#pi#pi} shape comparison"));
data_BWs1_bis->plotOn(frame1_Kpipi,DrawOption("C"));
histPdf_K1_1400toKrho.plotOn(frame1_Kpipi);
frame1_Kpipi->Draw();
c->cd(3);
RooPlot* frame1 = m_pipi.frame(Name("#rho -> #pi#pi shape"),Title("#rho -> #pi#pi shape"));
data_BWp1->plotOn(frame1,DrawOption("C"));
frame1->Draw();
c->cd(4);
RooPlot* frame_final = m_Kpipi.frame(Name("m_{K#pi#pi} final shape"),Title("m_{K#pi#pi} final shape"));
Shape_K1_1400toKrho.plotOn(frame_final,DrawOption("C"));
frame_final->Draw();
//---------------------------------------
// K1(1400) -> K* (892) (K pi) pi BR ~ 93 %
//---------------------------------------
Double_t KpiUP = 2500;
Double_t KpiLOW = 0.;
RooRealVar m_Kpi_892("m_Kpi_892","m_{K#pi} [MeV/c^{2}]",KpiLOW,KpiUP);
RooRealVar* var2_mass_Kpi = new RooRealVar("var2_mass_Kpi","var2_mass_pipi",KpiLOW,KpiUP);
Double_t mass_Kpi_892;
// Construct BreitWigner s K1(1400) -> K* pi
RooRealVar m_BWs3("m_BWs3","m_BWs3",1403.);
RooRealVar width_BWs3("width_BWs3","width_BWs3",174.);
RooRelBreitWigner BWs3("BWs3","BWs3",m_Kpipi,m_BWs3,width_BWs3,RooConst(0),RooConst(R),*var2_mass_Kpi,RooConst(139.6)); // K1 -> K*0 pi (s wave)
// Construct BreitWigner p for K*0 -> K pi
RooRealVar m_BWp3("m_BWp3","m_BWp3",895.5);
RooRealVar width_BWp3("width_BWp3","width_BWp3",50.);
RooRelBreitWigner BWp3("BWp3","BWp3",m_Kpi_892,m_BWp3,width_BWp3,RooConst(1),RooConst(R),RooConst(493.7),RooConst(139.6)); // K*0 -> K pi (p wave)
// Define histograms
TH2F* hist3 = new TH2F("hist3","m_{K#pi} vs m_{K#pi#pi}",nbins,KpiLOW,KpiUP,nbins,KpipiLOW,KpipiUP);
TH1F* hist3KpipiShape = new TH1F("hist3KpipiShape","m_{K#pi#pi} final shape",nbins,KpipiLOW,KpipiUP);
// Generate
RooDataSet* data_BWp3 = BWp3.generate(m_Kpi_892,nEvents);
RooArgSet* obs_6 = data_BWp3->get();
RooRealVar* data_6 = obs_6->find(m_Kpi_892.GetName());
counter = 0;
// Convoluting distributions
for (int j=0; j< data_BWp3->numEntries();j++)
{
if (0 == j%100) cout<<j+1<<endl;
data_BWp3->get(j);
mass_Kpi_892 = data_6->getVal();
var2_mass_Kpi->setVal(mass_Kpi_892);
RooDataSet* data_BWs3 = BWs3.generate(m_Kpipi,evt);
RooArgSet* obs_5 = data_BWs3->get();
RooRealVar* data_5 = obs_5->find(m_Kpipi.GetName());
for (int k=0; k<data_BWs3->numEntries();k++)
{
data_BWs3->get(k);
mass_Kpipi = data_5->getVal();
hist3->Fill(mass_Kpi_892,mass_Kpipi);
hist3KpipiShape->Fill(mass_Kpipi);
counter++;
}
}
cout << "generated events = " << counter << endl;
var2_mass_Kpi->setVal(895.5);
RooDataSet* data_BWs3_bis = BWs3.generate(m_Kpipi,nEvents*evt);
RooDataHist Shape_K1_1400toKstar892pi("Shape_K1_1400toKstar892pi","Shape of the convoluted pdf",m_Kpipi,hist3KpipiShape);
RooHistPdf histPdf_K1_1400toKstar892pi("histPdf_K1_1400toKstar892pi","histPdf_K1_1400toKstar892pi",m_Kpipi,Shape_K1_1400toKstar892pi,2); // last number is the order of the interpolation
// Drawing plots
TCanvas* c3 = new TCanvas("c3","K1(1400) -> K*(892)(K#pi) #pi",1550,20,1000,1000);
c3->Divide(2,2);
c3->cd(1);
hist3->SetXTitle("m_{K#pi} [GeV/c^{2}]");
hist3->SetYTitle("m_{K#pi#pi} [GeV/c^{2}]");
hist3->Draw("colz");
c3->cd(2);
RooPlot* frame3_Kpipi = m_Kpipi.frame(Name("m_{K#pi#pi} final shape"),Title("m_{K#pi#pi} final shape"));
data_BWs3_bis->plotOn(frame3_Kpipi,DrawOption("C"));
histPdf_K1_1400toKstar892pi.plotOn(frame3_Kpipi);
frame3_Kpipi->Draw();
c3->cd(3);
RooPlot* frame3 = m_Kpi_892.frame(Name("m_{K#pi} shape"),Title("m_{K#pi} shape"));
data_BWp3->plotOn(frame3,DrawOption("C"));
frame3->Draw();
c3->cd(4);
hist3KpipiShape->SetXTitle("m_{K#pi#pi} [MeV/c^{2}]");
hist3KpipiShape->SetYTitle("Events");
hist3KpipiShape->SetLineColor(1);
hist3KpipiShape->Draw();
/////////////////////////////////////////
// Adding PDFs in K1(1400) with weights
/////////////////////////////////////////
RooRealVar histPdf_K1_1400toKrho_y("histPdf_K1_1400toKrho_y","histPdf_K1_1400toKrho_y",2.); // relative BR normalized to 100
RooRealVar histPdf_K1_1400toKstar892pi_y("histPdf_K1_1400toKstar892pi_y","histPdf_K1_1400toKstar892pi_y",98.);
RooArgList shapes;
RooArgList yields;
shapes.add(histPdf_K1_1400toKrho);
shapes.add(histPdf_K1_1400toKstar892pi);
yields.add(histPdf_K1_1400toKrho_y);
yields.add(histPdf_K1_1400toKstar892pi_y);
RooAddPdf totalPdf_K1_1400("totalPdf_K1_1400","total Pdf for K1(1400)",shapes,yields);
// gererating a distribution according to totalPdf
RooDataSet* data = totalPdf_K1_1400.generate(m_Kpipi,nEvents);
// Fit total Pdf to data and plot
totalPdf_K1_1400.fitTo(*data, Extended());
// dumping totalPdf to workspace
RooWorkspace *ws_K1_1400 = new RooWorkspace("ws_K1_1400","ws_K1_1400");
ws_K1_1400->import(totalPdf_K1_1400);
ws_K1_1400->import(*data);
ws_K1_1400->writeToFile("ws_K1_1400.root");
ws_K1_1400->Print();
RooPlot* dataFrame = m_Kpipi.frame(Bins(nbins),Name("dataFrame"),Title("m_{K#pi#pi}"));
data->plotOn(dataFrame,DrawOption(""));
/*totalPdf_K1_1400.paramOn(dataFrame);*/
totalPdf_K1_1400.plotOn(dataFrame,Components(histPdf_K1_1400toKrho),LineColor(kRed),LineStyle(kDashed));
totalPdf_K1_1400.plotOn(dataFrame,Components(histPdf_K1_1400toKstar892pi),LineColor(kGreen),LineStyle(kDashed));
/*totalPdf_K1_1400.plotOn(dataFrame);*/
TCanvas* cdataFrame = new TCanvas("ccc","ccc",2000,20,800,600);
dataFrame->Draw();
}
