///
/// Here we use Manuel's bicubic histogram.
///
void PDF_GGSZ_ExpNLL::buildPdfBicubic()
{
//
// for B+
//
TString fNamePos = this->dir+"/NLL_GGSZ/histosplus_conv.root";
TString hNamePos = "hConv";
if ( !FileExists(fNamePos) ) { cout << "PDF_GGSZ_ExpNLL::buildPdf() : ERROR : File not found : " << fNamePos << endl; exit(1); }
TFile *fExpNllPos = new TFile(fNamePos, "ro");
TH2D *hExpNllPos = (TH2D*)fExpNllPos->Get(hNamePos);
assert(hExpNllPos);
RooHistPdfVar *xp_pdf = new RooHistPdfVar("xp_pdf", "xp_pdf", *xp_obs, *xp_th, RooConst(-0.102837)); // those precise shifts I got from zooming into the exp nll histogram
RooHistPdfVar *yp_pdf = new RooHistPdfVar("yp_pdf", "yp_pdf", *yp_obs, *yp_th, RooConst(-0.0083607));
RooBinned2DBicubicPdf *pdfPos = new RooBinned2DBicubicPdf("pdf_pos_"+name, "pdf_pos_"+name, *hExpNllPos, *xp_pdf, *yp_pdf);
//
// for B-
//
TString fNameNeg = this->dir+"/NLL_GGSZ/histosBM_conv.root";
TString hNameNeg = "hConv";
if ( !FileExists(fNameNeg) ) { cout << "PDF_GGSZ_ExpNLL::buildPdf() : ERROR : File not found : " << fNameNeg << endl; exit(1); }
TFile *fExpNllNeg = new TFile(fNameNeg, "ro");
TH2D *hExpNllNeg = (TH2D*)fExpNllNeg->Get(hNameNeg);
assert(hExpNllNeg);
RooHistPdfVar *xm_pdf = new RooHistPdfVar("xm_pdf", "xm_pdf", *xm_obs, *xm_th, RooConst( 0.00152658));
RooHistPdfVar *ym_pdf = new RooHistPdfVar("ym_pdf", "ym_pdf", *ym_obs, *ym_th, RooConst( 0.0273623));
RooBinned2DBicubicPdf *pdfNeg = new RooBinned2DBicubicPdf("pdf_neg_"+name, "pdf_neg_"+name, *hExpNllNeg, *xm_pdf, *ym_pdf);
// multiply both
pdf = new RooProdPdf("pdf_"+name, "pdf_"+name, RooArgSet(*pdfNeg, *pdfPos));
}
void PDF_GLWADS_DKDpi_KSKpi_DCPV_Dmix::initRelations()
{
RooArgSet *p = (RooArgSet*)parameters;
delete theory; theory = new RooArgList("theory"); ///< the order of this list must match that of the COR matrix!
RooRealVar& rbk = *((RooRealVar*)p->find("r_dk"));
RooRealVar& dbk = *((RooRealVar*)p->find("d_dk"));
RooConstVar& kbk = RooConst(1);
RooRealVar& rbp = *((RooRealVar*)p->find("r_dpi"));
RooRealVar& dbp = *((RooRealVar*)p->find("d_dpi"));
RooConstVar& kbp = RooConst(1);
RooRealVar& kf = *((RooRealVar*)p->find("kD_kskpi"));
RooRealVar& rf = *((RooRealVar*)p->find("rD_kskpi"));
RooRealVar& df = *((RooRealVar*)p->find("dD_kskpi"));
RooRealVar& g = *((RooRealVar*)p->find("g"));
RooRealVar& xD = *((RooRealVar*)p->find("xD"));
RooRealVar& yD = *((RooRealVar*)p->find("yD"));
RooRealVar& Rcab = *((RooRealVar*)p->find("RBRdkdpi"));
RooRealVar& AcpDfav = *((RooRealVar*)p->find("AcpDzKstpKm"));
RooRealVar& AcpDsup = *((RooRealVar*)p->find("AcpDzKstmKp"));
theory->add(*(new RooGLWADSDmixRADSVar( "rfavsup_dpi_kskpi_th", "RooGLWADSDmixRADSVar (inverse)", rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "inverse")));
theory->add(*(new RooGLWADSDmixRkpVar( "rfav_dkdpi_kskpi_th", "RooGLWADSDmixRkpVar (fav)", Rcab, rbk, dbk, kbk, rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "fav")));
theory->add(*(new RooGLWADSDmixRkpVar( "rsup_dkdpi_kskpi_th", "RooGLWADSDmixRkpVar (sup)", Rcab, rbk, dbk, kbk, rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "sup")));
theory->add(*(new RooGLWADSDmixAcpVar( "afav_dk_kskpi_th", "RooGLWADSDmixAcpVar", rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, AcpDfav)));
theory->add(*(new RooGLWADSDmixAcpADSVar("asup_dk_kskpi_th", "RooGLWADSDmixAcpADSVar", rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, AcpDsup)));
theory->add(*(new RooGLWADSDmixAcpVar( "afav_dpi_kskpi_th", "RooGLWADSDmixAcpVar", rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, AcpDfav)));
theory->add(*(new RooGLWADSDmixAcpADSVar("asup_dpi_kskpi_th", "RooGLWADSDmixAcpADSVar", rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, AcpDsup)));
}
void PDF_ADS_DK_Kpi_2var::initRelations()
{
RooArgSet *p = (RooArgSet*)parameters;
RooRealVar &rbk = *((RooRealVar*)p->find("r_dk"));
RooRealVar &dbk = *((RooRealVar*)p->find("d_dk"));
RooConstVar &kbk = RooConst(1.);
RooRealVar &rd = *((RooRealVar*)p->find("rD_kpi"));
RooRealVar &dd = *((RooRealVar*)p->find("dD_kpi"));
RooConstVar &kd = RooConst(1.);
RooRealVar &g = *((RooRealVar*)p->find("g"));
theory = new RooArgList("theory"); ///< the order of this list must match that of the COR matrix!
theory->add(*(new RooADSAVar("aads_dk_th", "Aads (DK)", rbk, dbk, kbk, rd, dd, kd, g )));
theory->add(*(new RooADSRVar("rads_dk_th", "Rads (DK)", rbk, dbk, kbk, rd, dd, kd, g )));
}
void PDF_GLWADS_DK_hh_Dmix::initRelations()
{
RooArgSet *p = (RooArgSet*)parameters;
delete theory; theory = new RooArgList("theory"); ///< the order of this list must match that of the COR matrix!
RooRealVar& Rcab = *((RooRealVar*)p->find("RBRdkdpi"));
RooRealVar& rbk = *((RooRealVar*)p->find("r_dk"));
RooRealVar& dbk = *((RooRealVar*)p->find("d_dk"));
RooConstVar& kbk = RooConst(1);
RooConstVar& rbp = RooConst(0); // assume rb(Dpi)=0 for DK only
RooConstVar& dbp = RooConst(1); // then the phase and the
RooConstVar& kbp = RooConst(1); // coherence factor values don't matter
RooConstVar& kf = RooConst(1);
RooRealVar& rf = *((RooRealVar*)p->find("rD_kpi"));
RooConstVar& rfGLW = RooConst(1);
RooRealVar& df = *((RooRealVar*)p->find("dD_kpi"));
RooConstVar& dfGLW = RooConst(0);
RooRealVar& g = *((RooRealVar*)p->find("g"));
RooRealVar& xD = *((RooRealVar*)p->find("xD"));
RooRealVar& yD = *((RooRealVar*)p->find("yD"));
RooRealVar& AcpDKK = *((RooRealVar*)p->find("AcpDKK"));
RooRealVar& AcpDpp = *((RooRealVar*)p->find("AcpDpipi"));
RooConstVar& AcpD = RooConst(0);
theory->add(*(new RooGLWADSDmixRkpVar("rkp_kpi_th", "RooGLWADSDmixRkpVar", Rcab, rbk, dbk, kbk, rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "fav")));
theory->add(*(new RooGLWADSDmixRkpVar("rkp_pipi_th", "RooGLWADSDmixRkpVar", Rcab, rbk, dbk, kbk, rbp, dbp, kbp, rfGLW, dfGLW, kf, g, xD, yD, _Mxy, "fav")));
theory->add(*(new RooGLWADSDmixRkpVar("rkp_kk_th", "RooGLWADSDmixRkpVar", Rcab, rbk, dbk, kbk, rbp, dbp, kbp, rfGLW, dfGLW, kf, g, xD, yD, _Mxy, "fav")));
theory->add(*(new RooGLWADSDmixAcpVar("afav_dk_kpi_th", "RooGLWADSDmixAcpVar", rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixAcpVar("acp_dk_kk_th", "RooGLWADSDmixAcpVar", rbk, dbk, kbk, rfGLW, dfGLW, kf, g, xD, yD, _Mxy, AcpDKK)));
theory->add(*(new RooGLWADSDmixAcpVar("acp_dk_pipi_th", "RooGLWADSDmixAcpVar", rbk, dbk, kbk, rfGLW, dfGLW, kf, g, xD, yD, _Mxy, AcpDpp)));
theory->add(*(new RooGLWADSDmixRpmVar("rp_dk_kpi_th", "RooGLWADSDmixRpmVar", rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, "+")));
theory->add(*(new RooGLWADSDmixRpmVar("rm_dk_kpi_th", "RooGLWADSDmixRpmVar", rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, "-")));
}
///
/// Here we use a 2d RooHistPdf.
///
void PDF_GGSZ_ExpNLL::buildPdfHistogram()
{
//
// for B+
//
// TString fNamePos = this->dir+"/NLL_GGSZ/histosplus.root";
// TString hNamePos = "eggp";
TString fNamePos = this->dir+"/NLL_GGSZ/histosplus_conv.root";
TString hNamePos = "hConv";
if ( !FileExists(fNamePos) ) { cout << "PDF_GGSZ_ExpNLL::buildPdf() : ERROR : File not found : " << fNamePos << endl; exit(1); }
cout << "PDF_GGSZ_ExpNLL::buildPdf() : Opening " << fNamePos << endl;
TFile *fExpNllPos = new TFile(fNamePos, "ro");
TH2D *hExpNllPos = (TH2D*)fExpNllPos->Get(hNamePos);
assert(hExpNllPos);
RooRealVar *xp_hist = new RooRealVar("xp_hist", "xp_hist", 0, -1.0, 1.0);
RooRealVar *yp_hist = new RooRealVar("yp_hist", "xp_hist", 0, -1.0, 1.0);
RooDataHist *dhExpNllPos = new RooDataHist("dhPos", "dhPos", RooArgList(*xp_hist,*yp_hist), Import(*hExpNllPos));
RooHistPdfVar *xp_pdf = new RooHistPdfVar("xp_pdf", "xp_pdf", *xp_obs, *xp_th, RooConst(-0.102837)); // those precise shifts I got from zooming into the exp nll histogram
RooHistPdfVar *yp_pdf = new RooHistPdfVar("yp_pdf", "yp_pdf", *yp_obs, *yp_th, RooConst(-0.0083607));
RooHistPdf *pdfPos = new RooHistPdf("pdf_pos_"+name, "pdf_pos_"+name, RooArgList(*xp_pdf,*yp_pdf), RooArgList(*xp_hist,*yp_hist), *dhExpNllPos, 1);
//
// for B-
//
// TString fNameNeg = this->dir+"/NLL_GGSZ/histosBM.root";
// TString hNameNeg = "eggp";
TString fNameNeg = this->dir+"/NLL_GGSZ/histosBM_conv.root";
TString hNameNeg = "hConv";
if ( !FileExists(fNameNeg) ) { cout << "PDF_GGSZ_ExpNLL::buildPdf() : ERROR : File not found : " << fNameNeg << endl; exit(1); }
cout << "PDF_GGSZ_ExpNLL::buildPdf() : Opening " << fNameNeg << endl;
TFile *fExpNllNeg = new TFile(fNameNeg, "ro");
TH2D *hExpNllNeg = (TH2D*)fExpNllNeg->Get(hNameNeg);
assert(hExpNllNeg);
RooRealVar *xm_hist = new RooRealVar("xm_hist", "xm_hist", 0, -1.0, 1.0);
RooRealVar *ym_hist = new RooRealVar("ym_hist", "xm_hist", 0, -1.0, 1.0);
RooDataHist *dhExpNllNeg = new RooDataHist("dhNeg", "dhNeg", RooArgList(*xm_hist,*ym_hist), Import(*hExpNllNeg));
RooHistPdfVar *xm_pdf = new RooHistPdfVar("xm_pdf", "xm_pdf", *xm_obs, *xm_th, RooConst( 0.00152658));
RooHistPdfVar *ym_pdf = new RooHistPdfVar("ym_pdf", "ym_pdf", *ym_obs, *ym_th, RooConst( 0.0273623));
RooHistPdf *pdfNeg = new RooHistPdf("pdf_neg_"+name, "pdf_neg_"+name, RooArgList(*xm_pdf,*ym_pdf), RooArgList(*xm_hist,*ym_hist), *dhExpNllNeg, 1);
// multiply both
pdf = new RooProdPdf("pdf_"+name, "pdf_"+name, RooArgSet(*pdfNeg, *pdfPos));
// cleanup
fExpNllPos->Close();
fExpNllNeg->Close();
}
void PDF_GLWADS_Dpi_K3pi_Dmix::initRelations()
{
RooArgSet *p = (RooArgSet*)parameters;
delete theory; theory = new RooArgList("theory"); ///< the order of this list must match that of the COR matrix!
RooRealVar& rbp = *((RooRealVar*)p->find("r_dpi"));
RooRealVar& dbp = *((RooRealVar*)p->find("d_dpi"));
RooConstVar& kbp = RooConst(1);
RooRealVar& kf = *((RooRealVar*)p->find("kD_k3pi"));
RooRealVar& rf = *((RooRealVar*)p->find("rD_k3pi"));
RooRealVar& df = *((RooRealVar*)p->find("dD_k3pi"));
RooRealVar& g = *((RooRealVar*)p->find("g"));
RooRealVar& xD = *((RooRealVar*)p->find("xD"));
RooRealVar& yD = *((RooRealVar*)p->find("yD"));
RooConstVar& AcpD = RooConst(0);
theory->add(*(new RooGLWADSDmixAcpVar("afav_dpi_k3pi_th", "RooGLWADSDmixAcpVar", rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixRpmVar("rp_dpi_k3pi_th", "RooGLWADSDmixRpmVar", rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "+")));
theory->add(*(new RooGLWADSDmixRpmVar("rm_dpi_k3pi_th", "RooGLWADSDmixRpmVar", rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "-")));
}
void PDF_GLW_DK_2var::initRelations()
{
RooArgSet *p = (RooArgSet*)parameters;
RooRealVar &rbk = *((RooRealVar*)p->find("r_dk"));
RooRealVar &dbk = *((RooRealVar*)p->find("d_dk"));
RooConstVar &kbk = RooConst(1.);
RooRealVar &g = *((RooRealVar*)p->find("g"));
theory = new RooArgList("theory"); ///< the order of this list must match that of the COR matrix!
theory->add(*(new RooGLWAcpVar("acpp_dk_th", "Acp+ (DK)", rbk, dbk, kbk, g, "+")));
theory->add(*(new RooGLWRcpVar("rcpp_dk_th", "Rcp+ (DK)", rbk, dbk, kbk, g, "+")));
}
void PDF_ADS_DKDpi_K3pi_Dmix_newVars::initRelations()
{
RooArgSet *p = (RooArgSet*)parameters;
delete theory; theory = new RooArgList("theory"); ///< the order of this list must match that of the COR matrix!
RooRealVar& rbk = *((RooRealVar*)p->find("r_dk"));
RooRealVar& dbk = *((RooRealVar*)p->find("d_dk"));
RooConstVar& kbk = RooConst(1);
RooRealVar& rbp = *((RooRealVar*)p->find("r_dpi"));
RooRealVar& dbp = *((RooRealVar*)p->find("d_dpi"));
RooConstVar& kbp = RooConst(1);
RooRealVar& kf = *((RooRealVar*)p->find("kD_k3pi"));
RooRealVar& rf = *((RooRealVar*)p->find("rD_k3pi"));
RooConstVar& rfGLW = RooConst(1);
RooRealVar& df = *((RooRealVar*)p->find("dD_k3pi"));
RooConstVar& dfGLW = RooConst(0);
RooRealVar& g = *((RooRealVar*)p->find("g"));
RooRealVar& xD = *((RooRealVar*)p->find("xD"));
RooRealVar& yD = *((RooRealVar*)p->find("yD"));
RooRealVar& F4pi = *((RooRealVar*)p->find("F_pipipipi"));
RooRealVar& Rcab = *((RooRealVar*)p->find("RBRdkdpi"));
RooConstVar& AcpD = RooConst(0);
RooConstVar& AcpDpppp = RooConst(0);
theory->add(*(new RooGLWADSDmixAcpADSVar ("aads_dk_k3pi_th", "RooGLWADSDmixAcpADSVar", rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixAcpADSVar ("aads_dpi_k3pi_th", "RooGLWADSDmixAcpADSVar", rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixAcpVar ("afav_dk_k3pi_th", "RooGLWADSDmixAcpVar" , rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixRADSVar ("rads_dk_k3pi_th", "RooGLWADSDmixRADSVar" , rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, "")));
theory->add(*(new RooGLWADSDmixRADSVar ("rads_dpi_k3pi_th", "RooGLWADSDmixRADSVar" , rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "")));
theory->add(*(new RooGLWADSDmixRkpVar ("rkp_k3pi_th", "RooGLWADSDmixRkpVar" , Rcab, rbk, dbk, kbk, rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "fav")));
}
void PDF_GLWADS_DKDpi_KSKpi_Dmix::initRelations()
{
RooArgSet *p = (RooArgSet*)parameters;
delete theory;
theory = new RooArgList("theory"); ///< the order of this list must match that of the COR matrix!
RooRealVar& rbk = *((RooRealVar*)p->find("r_dk"));
RooRealVar& dbk = *((RooRealVar*)p->find("d_dk"));
RooConstVar& kbk = RooConst(1);
RooRealVar& rbp = *((RooRealVar*)p->find("r_dpi"));
RooRealVar& dbp = *((RooRealVar*)p->find("d_dpi"));
RooConstVar& kbp = RooConst(1);
RooRealVar& kf = *((RooRealVar*)p->find("kD_kskpi"));
RooRealVar& rf = *((RooRealVar*)p->find("rD_kskpi"));
RooRealVar& df = *((RooRealVar*)p->find("dD_kskpi"));
RooRealVar& g = *((RooRealVar*)p->find("g"));
RooRealVar& xD = *((RooRealVar*)p->find("xD"));
RooRealVar& yD = *((RooRealVar*)p->find("yD"));
RooRealVar& Rcab = *((RooRealVar*)p->find("RBRdkdpi"));
RooConstVar& AcpD = RooConst(0);
// theory->add(*(new RooFormulaVar("rfavsup_dpi_kskpi_th", "rfavsup_dpi_kskpi_th", "(1 + r_dpi^2*rD_kskpi^2 + 2*r_dpi*rD_kskpi*kD_kskpi*cos(g)*cos(d_dpi-dD_kskpi))/(r_dpi^2 + rD_kskpi^2 + 2*r_dpi*rD_kskpi*kD_kskpi*cos(g)*cos(d_dpi+dD_kskpi))", *p)));
// theory->add(*(new RooFormulaVar("rfav_dkdpi_kskpi_th", "rfav_dkdpi_kskpi_th", "RBRdkdpi*(1 + r_dk^2*rD_kskpi^2 + 2*r_dk *rD_kskpi*kD_kskpi*cos(g)*cos(d_dk -dD_kskpi))/(1 + r_dpi^2*rD_kskpi^2 + 2*r_dpi*rD_kskpi*kD_kskpi*cos(g)*cos(d_dpi-dD_kskpi))", *p)));
// theory->add(*(new RooFormulaVar("rsup_dkdpi_kskpi_th", "rsup_dkdpi_kskpi_th", "RBRdkdpi*(r_dk^2 + rD_kskpi^2 + 2*r_dk *rD_kskpi*kD_kskpi*cos(g)*cos(d_dk +dD_kskpi))/(r_dpi^2 + rD_kskpi^2 + 2*r_dpi*rD_kskpi*kD_kskpi*cos(g)*cos(d_dpi+dD_kskpi))", *p)));
// theory->add(*(new RooFormulaVar("afav_dk_kskpi_th", "afav_dk_kskpi_th", "2*r_dk *rD_kskpi*kD_kskpi*sin(g)*sin(d_dk -dD_kskpi) / (1 + r_dk^2 * rD_kskpi^2 + 2*r_dk *rD_kskpi*kD_kskpi*cos(g)*cos(d_dk -dD_kskpi))", *p)));
// theory->add(*(new RooFormulaVar("asup_dk_kskpi_th", "asup_dk_kskpi_th", "2*r_dk *rD_kskpi*kD_kskpi*sin(g)*sin(d_dk +dD_kskpi) / (r_dk^2 + rD_kskpi^2 + 2*r_dk *rD_kskpi*kD_kskpi*cos(g)*cos(d_dk +dD_kskpi))", *p)));
// theory->add(*(new RooFormulaVar("afav_dpi_kskpi_th", "afav_dpi_kskpi_th", "2*r_dpi*rD_kskpi*kD_kskpi*sin(g)*sin(d_dpi-dD_kskpi) / (1 + r_dpi^2 * rD_kskpi^2 + 2*r_dpi*rD_kskpi*kD_kskpi*cos(g)*cos(d_dpi-dD_kskpi))", *p)));
// theory->add(*(new RooFormulaVar("asup_dpi_kskpi_th", "asup_dpi_kskpi_th", "2*r_dpi*rD_kskpi*kD_kskpi*sin(g)*sin(d_dpi+dD_kskpi) / (r_dpi^2 + rD_kskpi^2 + 2*r_dpi*rD_kskpi*kD_kskpi*cos(g)*cos(d_dpi+dD_kskpi))", *p)));
theory->add(*(new RooGLWADSDmixRADSVar( "rfavsup_dpi_kskpi_th", "RooGLWADSDmixRADSVar (inverse)", rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "inverse")));
theory->add(*(new RooGLWADSDmixRkpVar( "rfav_dkdpi_kskpi_th", "RooGLWADSDmixRkpVar (fav)", Rcab, rbk, dbk, kbk, rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "fav")));
theory->add(*(new RooGLWADSDmixRkpVar( "rsup_dkdpi_kskpi_th", "RooGLWADSDmixRkpVar (sup)", Rcab, rbk, dbk, kbk, rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "sup")));
theory->add(*(new RooGLWADSDmixAcpVar( "afav_dk_kskpi_th", "RooGLWADSDmixAcpVar", rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixAcpADSVar("asup_dk_kskpi_th", "RooGLWADSDmixAcpADSVar", rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixAcpVar( "afav_dpi_kskpi_th", "RooGLWADSDmixAcpVar", rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixAcpADSVar("asup_dpi_kskpi_th", "RooGLWADSDmixAcpADSVar", rbp, dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
}
void PDF_GLWADS_DKDpi_hh_Dmix_newVars_uv::initRelations()
{
RooArgSet *p = (RooArgSet*)parameters;
RooRealVar& Rcab = *((RooRealVar*)p->find("RBRdkdpi"));
RooRealVar& rbk = *((RooRealVar*)p->find("r_dk"));
RooRealVar& dbk = *((RooRealVar*)p->find("d_dk"));
RooConstVar& kbk = RooConst(1);
//RooRealVar& rbp = *((RooRealVar*)p->find("r_dpi"));
//RooRealVar& dbp = *((RooRealVar*)p->find("d_dpi"));
RooRealVar& u = *((RooRealVar*)p->find("u_dpi"));
RooRealVar& v = *((RooRealVar*)p->find("v_dpi"));
RooFormulaVar *rbp = new RooFormulaVar("rbp","rbp", "TMath::Sqrt( u_dpi*u_dpi + v_dpi*v_dpi )", *p);
RooFormulaVar *dbp = new RooFormulaVar("dbp","dbp", "TMath::ATan( v_dpi / u_dpi )", *p);
RooConstVar& kbp = RooConst(1);
RooConstVar& kf = RooConst(1);
RooRealVar& rf = *((RooRealVar*)p->find("rD_kpi"));
RooConstVar& rfGLW = RooConst(1);
RooRealVar& df = *((RooRealVar*)p->find("dD_kpi"));
RooConstVar& dfGLW = RooConst(0);
RooRealVar& g = *((RooRealVar*)p->find("g"));
RooRealVar& xD = *((RooRealVar*)p->find("xD"));
RooRealVar& yD = *((RooRealVar*)p->find("yD"));
RooRealVar& AcpDKK = *((RooRealVar*)p->find("AcpDKK"));
RooRealVar& AcpDpp = *((RooRealVar*)p->find("AcpDpipi"));
RooConstVar& AcpD = RooConst(0);
theory = new RooArgList("theory"); ///< the order of this list must match that of the COR matrix!
theory->add(*(new RooGLWADSDmixAcpADSVar ("aads_dk_kpi_th", "RooGLWADSDmixAcpADSVar" , rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixAcpADSVar ("aads_dpi_kpi_th", "RooGLWADSDmixAcpADSVar" , *rbp, *dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixAcpVar ("acp_dk_kk_th", "RooGLWADSDmixAcpVar" , rbk, dbk, kbk, rfGLW, dfGLW, kf, g, xD, yD, _Mxy, AcpDKK)));
theory->add(*(new RooGLWADSDmixAcpVar ("acp_dk_pipi_th", "RooGLWADSDmixAcpVar" , rbk, dbk, kbk, rfGLW, dfGLW, kf, g, xD, yD, _Mxy, AcpDpp)));
theory->add(*(new RooGLWADSDmixAcpVar ("acp_dpi_kk_th", "RooGLWADSDmixAcpVar" , *rbp, *dbp, kbp, rfGLW, dfGLW, kf, g, xD, yD, _Mxy, AcpDKK)));
theory->add(*(new RooGLWADSDmixAcpVar ("acp_dpi_pipi_th", "RooGLWADSDmixAcpVar" , *rbp, *dbp, kbp, rfGLW, dfGLW, kf, g, xD, yD, _Mxy, AcpDpp)));
theory->add(*(new RooGLWADSDmixAcpVar ("afav_dk_kpi_th", "RooGLWADSDmixAcpVar" , rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, AcpD)));
theory->add(*(new RooGLWADSDmixRADSVar ("rads_dk_kpi_th", "RooGLWADSDmixRADSVar" , rbk, dbk, kbk, rf, df, kf, g, xD, yD, _Mxy, "")));
theory->add(*(new RooGLWADSDmixRADSVar ("rads_dpi_kpi_th", "RooGLWADSDmixRADSVar" , *rbp, *dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "")));
theory->add(*(new RooGLWADSDmixRcpRatioVar ("rcp_kk_th", "RooGLWADSDmixRcpRatioVar", rbk, dbk, kbk, *rbp, *dbp, kbp, rf, df, kf, g, xD, yD, _Mxy)));
theory->add(*(new RooGLWADSDmixRcpRatioVar ("rcp_pipi_th", "RooGLWADSDmixRcpRatioVar", rbk, dbk, kbk, *rbp, *dbp, kbp, rf, df, kf, g, xD, yD, _Mxy)));
theory->add(*(new RooGLWADSDmixRkpVar ("rkp_kpi_th", "RooGLWADSDmixRkpVar" , Rcab, rbk, dbk, kbk, *rbp, *dbp, kbp, rf, df, kf, g, xD, yD, _Mxy, "fav")));
}
///
/// Build the PDF using the Cleo histogram for kD, dD.
/// \param fName file name of the histogram, needs to contain the likelihood (not chi2),
/// computed by ExpNll/computeCleoPdf.C
/// \param scale A scale factor that is applied to the histogram in order to get a chi2
/// of exactly 0 when this PDF is fit to minimum. This can be obtained by, e.g.,
/// bin/gammacombo -i --addpdf 8:8 --var kD_k3pi. The scale factor is then the
/// the observed FCN value at minimum.
/// \param kDobs kD value of the maximum in the histogram
/// \param dDobs dD value of the maximum in the histogram
///
void PDF_D_KSKpi_noDmix::buildPdfHistogram(TString fName, float scale, float kDobs, float dDobs)
{
RooMsgService::instance().setGlobalKillBelow(WARNING);
TString hName = "hPdf";
obsValSource += ", "+fName;
obsErrSource += ", "+fName;
corSource += ", "+fName;
if ( !FileExists(fName) ){cout << "PDF_D_KSKpi_noDmix::buildPdfHistogram() : ERROR : File not found : " << fName << endl; exit(1);}
TFile *fExpNll = new TFile(fName, "ro");
TH2D *hExpNll = (TH2D*)fExpNll->Get(hName);
assert(hExpNll);
// Scale the histogram so that the best fit value gives chi2=0. The value is obtained by fitting
// the histogram PDF to its maximum. There is some hidden scaling that I don't understand in RooHistPdf
// or so, so one can't just use the maximum value of the histogram.
hExpNll->Scale(1./TMath::Exp(scale/(-2.)));
RooRealVar *x_hist = new RooRealVar("x_kskpi_hist", "x_kskpi_hist", 0, -1e4, 1e4);
RooRealVar *y_hist = new RooRealVar("y_kskpi_hist", "y_kskpi_hist", 0, -1e4, 1e4);
RooDataHist *dhExpNll = new RooDataHist("dh_kskpi", "dh_kskpi", RooArgList(*x_hist,*y_hist), Import(*hExpNll));
RooRealVar *kD_kskpi_obs = (RooRealVar*)observables->find("kD_kskpi_obs");
RooRealVar *kD_kskpi = (RooRealVar*)theory->find("kD_kskpi_th");
RooRealVar *dD_kskpi_obs = (RooRealVar*)observables->find("dD_kskpi_obs");
RooRealVar *dD_kskpi = (RooRealVar*)theory->find("dD_kskpi_th");
RooHistPdfVar *kD_pdf = new RooHistPdfVar("kD_kskpi_pdf", "kD_kskpi_pdf", *kD_kskpi_obs, *kD_kskpi, RooConst(kDobs));
RooHistPdfAngleVar *dD_pdf = new RooHistPdfAngleVar("dD_kskpi_pdf", "dD_kskpi_pdf", *dD_kskpi_obs, *dD_kskpi, RooConst(dDobs));
RooHistPdf *pdf_kDdD = new RooHistPdf("pdf_kDdD_kskpi", "pdf_kDdD_kskpi", RooArgList(*kD_pdf,*dD_pdf), RooArgList(*x_hist,*y_hist), *dhExpNll, 1);
// Use a Gaussian for RD
RooRealVar *RD_kskpi_obs = (RooRealVar*)observables->find("RD_kskpi_obs");
RooRealVar *RD_kskpi_th = (RooRealVar*)theory->find("RD_kskpi_th");
assert(RD_kskpi_obs); assert(RD_kskpi_th);
RooGaussian *pdf_RD = new RooGaussian("pdf_RD_kskpi", "pdf_RD_kskpi", *RD_kskpi_obs, *RD_kskpi_th, RooConst(sqrt(sq(StatErr[0])+sq(SystErr[0]))));
// multiply both
pdf = new RooProdPdf("pdf_"+name, "pdf_"+name, RooArgSet(*pdf_kDdD, *pdf_RD));
// cleanup
fExpNll->Close();
RooMsgService::instance().setGlobalKillBelow(INFO);
addToTrash(x_hist);
addToTrash(y_hist);
addToTrash(dhExpNll);
addToTrash(kD_pdf);
addToTrash(dD_pdf);
addToTrash(pdf_kDdD);
addToTrash(pdf_RD);
}
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;
}
///
/// Cleo histogram for kD, dD
///
void PDF_D_Cleo::buildPdfHistogram()
{
RooMsgService::instance().setGlobalKillBelow(WARNING);
TString fName = this->dir+"/ExpNll/CLEO_K3PiScan_2009_GaussianRise_pdf2.root";
TString hName = "hPdf";
obsValSource += ", "+fName;
obsErrSource += ", "+fName;
corSource += ", "+fName;
if ( !FileExists(fName) ) {
cout << "PDF_D_CleoNoK2pi::buildPdfHistogram() : ERROR : File not found : " << fName << endl;
exit(1);
}
TFile *fExpNll = new TFile(fName, "ro");
TH2D *hExpNll = (TH2D*)fExpNll->Get(hName);
assert(hExpNll);
// hExpNll->Scale(1./1.3027449); // scale so best fit value gives chi2=0.
hExpNll->Scale(1./0.858588); // scale so best fit value gives chi2=0: run bin/unittests which fits PDFs to minimum. The factor is 1/min.
RooRealVar *x_hist = new RooRealVar("x_cleo_k3pi_hist", "x_cleo_k3pi_hist", 0, -1e4, 1e4);
RooRealVar *y_hist = new RooRealVar("y_cleo_k3pi_hist", "y_cleo_k3pi_hist", 0, -1e4, 1e4);
RooDataHist *dhExpNll = new RooDataHist("dh_cleo_k3pi", "dh_cleo_k3pi", RooArgList(*x_hist,*y_hist), Import(*hExpNll));
RooRealVar *kD_k3pi_obs = (RooRealVar*)observables->find("kD_k3pi_obs");
RooRealVar *kD_k3pi_th = (RooRealVar*)theory->find("kD_k3pi_th");
RooRealVar *dD_k3pi_obs = (RooRealVar*)observables->find("dD_k3pi_obs");
RooRealVar *dD_k3pi_th = (RooRealVar*)theory->find("dD_k3pi_th");
RooHistPdfVar *kD_pdf = new RooHistPdfVar("kD_cleo_k3pi_pdf", "kD_cleo_k3pi_pdf", *kD_k3pi_obs, *kD_k3pi_th, RooConst(0.3325)); // those precise shifts I got from zooming into the exp nll histogram
RooHistPdfAngleVar *dD_pdf = new RooHistPdfAngleVar("dD_cleo_k3pi_pdf", "dD_cleo_k3pi_pdf", *dD_k3pi_obs, *dD_k3pi_th, RooConst(1.9984));
RooHistPdf *pdf_kDdD = new RooHistPdf("pdf_cleo_kDdD_k3pi", "pdf_cleo_kDdD_k3pi", RooArgList(*kD_pdf,*dD_pdf), RooArgList(*x_hist,*y_hist), *dhExpNll, 1);
// Re-use the full multivariate Gaussian for the rest
// blow up errors of kD and dD
float largeNumber = 50.;
StatErr[ 0] *= largeNumber; // kD_k3pi_obs
StatErr[ 1] *= largeNumber; // dD_k3pi_obs
buildCov();
RooMultiVarGaussian *pdf_gaus = new RooMultiVarGaussian("pdf_cleo_gaus", "pdf_cleo_gaus", *(RooArgSet*)observables, *(RooArgSet*)theory, covMatrix);
// reset errors so that the pull plot remains correct
StatErr[ 0] /= largeNumber; // kD_k3pi_obs
StatErr[ 1] /= largeNumber; // dD_k3pi_obs
// multiply both
pdf = new RooProdPdf("pdf_"+name, "pdf_"+name, RooArgSet(*pdf_kDdD, *pdf_gaus));
fExpNll->Close();
RooMsgService::instance().setGlobalKillBelow(INFO);
// addToTrash(fExpNll); ///< these two get cleaned by fExpNll->Close();
// addToTrash(hExpNll);
addToTrash(x_hist);
addToTrash(y_hist);
addToTrash(dhExpNll);
addToTrash(kD_pdf);
addToTrash(dD_pdf);
addToTrash(pdf_kDdD);
addToTrash(pdf_gaus);
}
FitResult doFit(const FitSetup& setup, string conditions, string fname=string(""))
{
//cerr<<"DO FIT"<<endl;
string varname = setup.varname;
RooRealVar var(varname.c_str(),varname.c_str(),setup.varMin, setup.varMax);
//string region="0btag_MTtail";
string region= setup.region;
//should it be an argument ?
TFile* fin = 0;
if(fname=="") fin = TFile::Open(setup.filename.c_str());
//else fin = TFile::Open(fname.c_str());
else fin = TFile::Open(fname.c_str());
//-- normalisation in the MC --//
float mc_norm_1ltop = 0;
float mc_norm_tt2l = 0;
float mc_norm_Wjets = 0;
//float mc_norm_rare = 0;
// C r e a t e m o d e l f o r CR1_peak_lowM3b
// -------------------------------------------------------------
// Construct pdfs for 1ltop, tt2l, Wjets and rare
TH1F* histo_1ltop = 0;
TH1F* histo_tt2l = 0;
TH1F* histo_Wjets = 0;
RooHistPdf *pdf_1ltop = GetRooHistPdf(fin,region,PROCESS_NAME_TT_1L,varname,&var,mc_norm_1ltop, histo_1ltop, setup.do_mcstat, DO_NORM, setup.Ndata*setup.rel_norm_1ltop);
RooHistPdf *pdf_tt2l = GetRooHistPdf(fin,region,PROCESS_NAME_TT_2L,varname,&var,mc_norm_tt2l, histo_tt2l, setup.do_mcstat, DO_NORM, setup.Ndata*setup.rel_norm_tt2l);
RooHistPdf *pdf_Wjets = GetRooHistPdf(fin,region,PROCESS_NAME_WJETS,varname,&var,mc_norm_Wjets, histo_Wjets, setup.do_mcstat, DO_NORM, setup.Ndata*setup.rel_norm_Wjets);
//RooHistPdf *pdf_rare = GetRooHistPdf(fin,region,PROCESS_NAME_RARE,varname,&var,mc_norm_rare, setup.do_mcstat);
//cerr<<"TT_1L: "<<mc_norm_1ltop<<endl;
//cerr<<"TT_2l: "<<mc_norm_tt2l<<endl;
//cerr<<"WJets: "<<mc_norm_Wjets<<endl;
//cerr<<"OTHER: "<<mc_norm_rare<<endl;
// normalization factors (RooRealVar)
float val_1ltop = mc_norm_1ltop;
float val_Wjets = mc_norm_Wjets;
if(setup.do_init_uncert)
{
val_1ltop = setup.init_1ltop*mc_norm_1ltop;
val_Wjets = setup.init_Wjets*mc_norm_Wjets;
}
RooRealVar norm_1ltop("norm_1ltop","norm_1ltop",val_1ltop,0.25*mc_norm_1ltop,10.*mc_norm_1ltop);
RooRealVar norm_Wjets("norm_Wjets","norm_Wjets",val_Wjets,0.25*mc_norm_Wjets,10.*mc_norm_Wjets);
RooRealVar norm_tt2l("norm_tt2l","norm_tt2l",mc_norm_tt2l,0.25*mc_norm_tt2l,2*mc_norm_tt2l);
//RooRealVar norm_rare("norm_rare","norm_rare",mc_norm_rare,0.25*mc_norm_rare,2*mc_norm_rare);
// possibility to study a systematic on it
if(setup.do_xs_tt2l_sys) mc_norm_tt2l*=setup.xs_sysfactor;
//if(setup.do_xs_rare_sys) mc_norm_rare*=setup.xs_sysfactor;
//RooConstVar norm_rare("norm_rare","norm_rare",mc_norm_rare);
/*
RooAddPdf model("model","model",
RooArgList(*pdf_1ltop,*pdf_tt2l,*pdf_Wjets,*pdf_rare),
RooArgList(norm_1ltop,norm_tt2l,norm_Wjets,norm_rare)) ;
*/
RooAddPdf model("model","model",
RooArgList(*pdf_1ltop,*pdf_tt2l,*pdf_Wjets),
RooArgList(norm_1ltop,norm_tt2l,norm_Wjets)) ;
//RooDataHist *data_CR1_peak_lowM3b = GetRooData(fin,region,varname,&var);
RooDataHist *data_CR1_peak_lowM3b = GetRooData(histo_1ltop,histo_Wjets, histo_tt2l,&var);
fin->Close();
//-- Constraints on single top and rare --//
float RelUncert = 0.2;
// Construct another Gaussian constraint p.d.f on "rare" bkg
//RooGaussian constr_rare("constr_rare","constr_rare",norm_rare,RooConst(mc_norm_rare),RooConst(RelUncert*mc_norm_rare)) ;
// Construct another Gaussian constraint p.d.f on "tt2l" bkg
RooGaussian constr_tt2l("constr_tt2l","constr_tt2l",norm_tt2l,RooConst(mc_norm_tt2l),RooConst(RelUncert*mc_norm_tt2l)) ;
// P e r f o r m t em p l a t e f i t
// ---------------------------------------------------
//Minimizer(type,algo) -- Choose minimization package and algorithm to use. Default is MINUIT/MIGRAD through the RooMinimizer
// interface, but rare can be specified (through RooMinimizer interface). Select OldMinuit to use
// MINUIT through the old RooMinuit interface
//
// Type Algorithm
// ------ ---------
// OldMinuit migrad, simplex, minimize (=migrad+simplex), migradimproved (=migrad+improve)
// Minuit migrad, simplex, minimize (=migrad+simplex), migradimproved (=migrad+improve)
// Minuit2 migrad, simplex, minimize, scan
// GSLMultiMin conjugatefr, conjugatepr, bfgs, bfgs2, steepestdescent
// GSLSimAn -
// --- Perform simultaneous fit of model to data and model_ctl to data_ctl --//
//RooFitResult* res = model.fitTo(*data_CR1_peak_lowM3b,Save());
//RooFitResult* res = model.fitTo(*data_CR1_peak_lowM3b,ExternalConstraints(constr_rare),ExternalConstraints(constr_tt2l),PrintLevel(-1),Save(),
RooFitResult* res = model.fitTo(*data_CR1_peak_lowM3b,ExternalConstraints(constr_tt2l),PrintLevel(-1),Save(),
Minimizer(setup.type.c_str(),setup.algo.c_str()),Verbose(0));
//--- Writing the results ---///
FitResult fitRes;
fitRes.Reset();
fitRes.norm_1ltop = mc_norm_1ltop;
fitRes.SF_1ltop = GetSF(res,"norm_1ltop");
fitRes.SF_Wjets = GetSF(res,"norm_Wjets");
fitRes.edm = res->edm();
fitRes.correlation = res->correlationMatrix()[0][1];
fitRes.conditions = conditions;
return fitRes;
}
void PDF_GGSZ_ExpNLL::buildPdfParametric()
{
RooMsgService::instance().setGlobalKillBelow(ERROR);
RooWorkspace *wExpNll = new RooWorkspace("wExpNll");
//
// for B-
//
RooHistPdfVar *xm_pdf = new RooHistPdfVar("xm_pdf", "xm_pdf", *xm_obs, *xm_th, RooConst( 0.000+2.62345e-03));
RooHistPdfVar *ym_pdf = new RooHistPdfVar("ym_pdf", "ym_pdf", *ym_obs, *ym_th, RooConst( 0.027+1.88547e-03));
double xmp0wl = 0.0541675;
double xmp1wl = 0.018955;
double xmp2wl = 0.3075;
double xmp3wl = -0.89035;
double xmp4wl = -3.44858;
RooPoly4Var *ymwidthl = new RooPoly4Var("ymwidthl", "ymwidthl", *xm_pdf,
xmp0wl, xmp1wl, xmp2wl, xmp3wl, xmp4wl);
double xmp0wr = 0.0494967;
double xmp1wr = 0.0130424;
double xmp2wr = 0.110901;
double xmp3wr = -0.0796312;
double xmp4wr = 0.204101;
RooPoly4Var *ymwidthr = new RooPoly4Var("ymwidthr", "ymwidthr", *xm_pdf,
xmp0wr, xmp1wr, xmp2wr, xmp3wr, xmp4wr);
double xmp0m = 0.0292742;
double xmp1m = -0.123769;
double xmp2m = -0.39777;
double xmp3m = 0.825458;
RooPoly3Var *ymmean = new RooPoly3Var("ymmean", "ymmean", *xm_pdf,
xmp0m, xmp1m, xmp2m, xmp3m);
RooBifurGauss *ympdf = new RooBifurGauss("ympdf", "ympdf", *ym_pdf, *ymmean, *ymwidthl, *ymwidthr);
wExpNll->import(*ympdf);
wExpNll->factory("RooBifurGauss::xmpdf(xm_pdf, xmmean[2.58584e-03], xmwidthl[4.37123e-02], xmwidthr[4.37101e-02])");
wExpNll->factory("PROD::pdf_ggszexpnll_neg(xmpdf,ympdf)");
//
// for B+
//
RooHistPdfVar *xp_pdf = new RooHistPdfVar("xp_pdf", "xp_pdf", *xp_obs, *xp_th, RooConst(-0.103-5.74430e-03));
RooHistPdfVar *yp_pdf = new RooHistPdfVar("yp_pdf", "yp_pdf", *yp_obs, *yp_th, RooConst(-0.009-4.54284e-03));
double xpp0wl = 0.0292561;
double xpp1wl = 0.0703944;
double xpp2wl = -0.0922186;
double xpp3wl = -11.8135;
double xpp4wl = -34.8594;
RooPoly4Var *ypwidthl = new RooPoly4Var("ypwidthl", "ypwidthl", *xp_pdf,
xpp0wl, xpp1wl, xpp2wl, xpp3wl, xpp4wl);
double xpp0wr = 0.0403016;
double xpp1wr = 0.0367049;
double xpp2wr = 0.535281;
double xpp3wr = 2.29804;
double xpp4wr = 5.37199;
RooPoly4Var *ypwidthr = new RooPoly4Var("ypwidthr", "ypwidthr", *xp_pdf,
xpp0wr, xpp1wr, xpp2wr, xpp3wr, xpp4wr);
double xpp0m = -0.0133043;
double xpp1m = -0.139777;
double xpp2m = -1.38657;
double xpp3m = -0.727225;
RooPoly3Var *ypmean = new RooPoly3Var("ypmean", "ypmean", *xp_pdf,
xpp0m, xpp1m, xpp2m, xpp3m);
RooBifurGauss *yppdf = new RooBifurGauss("yppdf", "yppdf", *yp_pdf, *ypmean, *ypwidthl, *ypwidthr);
wExpNll->import(*yppdf);
wExpNll->factory("RooBifurGauss::xppdf(xp_pdf, xpmean[-1.08775e-01], xpwidthl[4.32573e-02], xpwidthr[4.93588e-02])");
wExpNll->factory("PROD::pdf_ggszexpnll_pos(xppdf,yppdf)");
// multiply both
wExpNll->factory("PROD::pdf_"+name+"(pdf_ggszexpnll_neg,pdf_ggszexpnll_pos)");
pdf = wExpNll->pdf("pdf_"+name);
RooMsgService::instance().setGlobalKillBelow(INFO);
}
void buildModel(RooWorkspace& w,int chooseFitParams, int chooseSample,int whatBin, int signalModel, int bkgdModel, int doRap, int doPt,int doCent,int useRef,float muonPtMin, int fixFSR){
// C r e a t e m o d e l
int nt=100000;
// cout << "you're building a model for the quarkonium resonance of mass = "<< M1S <<" GeV/c^{2},"endl;
RooRealVar *nsig1f = new RooRealVar("N_{ #varUpsilon(1S)}","nsig1S",0,nt*10);
RooRealVar* mass = new RooRealVar("invariantMass","#mu#mu mass",mass_l,mass_h,"GeV/c^{2}");
RooRealVar *nsig2f = NULL;
RooRealVar *nsig3f = NULL;
switch (chooseFitParams)
{
case 0://use the YIELDs of 2S and 3S as free parameters
//minor modif here: 3S forced positive.
nsig2f = new RooRealVar("N_{ #varUpsilon(2S)}","nsig2S", nt*0.25,-200,10*nt);
nsig3f = new RooRealVar("N_{ #varUpsilon(3S)}","nsig3S", nt*0.25,-200,10*nt);
cout << "you're fitting to extract yields, "<< endl;
break;
default:
cout<<"Make a pick from chooseFitParams!!!"<<endl;
break;
}
RooRealVar *mean = new RooRealVar("m_{ #varUpsilon(1S)}","#Upsilon mean",M1S,M1S-0.2,M1S+0.2);
RooConstVar *rat2 = new RooConstVar("rat2", "rat2", M2S/M1S);
RooConstVar *rat3 = new RooConstVar("rat3", "rat3", M3S/M1S);
// scale mean and resolution by mass ratio
RooFormulaVar *mean1S = new RooFormulaVar("mean1S","@0",RooArgList(*mean));
RooFormulaVar *mean2S = new RooFormulaVar("mean2S","@0*@1", RooArgList(*mean,*rat2));
RooFormulaVar *mean3S = new RooFormulaVar("mean3S","@0*@1", RooArgList(*mean,*rat3));
// //detector resolution ?? where is this coming from?
RooRealVar *sigma1 = new RooRealVar("#sigma_{CB1}","#sigma_{CB1}",sigma_min[whatBin],sigma_max[whatBin]); //
RooFormulaVar *sigma1S = new RooFormulaVar("sigma1S","@0" ,RooArgList(*sigma1));
RooFormulaVar *sigma2S = new RooFormulaVar("sigma2S","@0*@1",RooArgList(*sigma1,*rat2));
RooFormulaVar *sigma3S = new RooFormulaVar("sigma3S","@0*@1",RooArgList(*sigma1,*rat3));
RooRealVar *alpha = new RooRealVar("#alpha_{CB}","tail shift",alpha_min[whatBin],alpha_max[whatBin]); // MC 5tev 1S pol2
RooRealVar *npow = new RooRealVar("n_{CB}","power order",npow_min[whatBin],npow_max[whatBin]); // MC 5tev 1S pol2
RooRealVar *sigmaFraction = new RooRealVar("sigmaFraction","Sigma Fraction",0.,1.);
// scale the sigmaGaus with sigma1S*scale=sigmaGaus now.
RooRealVar *scaleWidth = new RooRealVar("#sigma_{CB2}/#sigma_{CB1}","scaleWidth",1.,2.5);
RooFormulaVar *sigmaGaus = new RooFormulaVar("sigmaGaus","@0*@1", RooArgList(*sigma1,*scaleWidth));
RooFormulaVar *sigmaGaus2 = new RooFormulaVar("sigmaGaus","@0*@1*@2", RooArgList(*sigma1,*scaleWidth,*rat2));
RooFormulaVar *sigmaGaus3 = new RooFormulaVar("sigmaGaus","@0*@1*@2", RooArgList(*sigma1,*scaleWidth,*rat3));
RooGaussian* gauss1 = new RooGaussian("gaus1s","gaus1s",
*nsig1f,
*mass, //mean
*sigmaGaus); //sigma
// RooGaussian* gauss1b = new RooGaussian("gaus1sb","gaus1sb",
// *nsig1f,
// *m, //mean
// *sigma1); //sigma
switch(signalModel){
case 1: //crystal boule
RooCBShape *sig1S = new RooCBShape ("cb1S_1", "FSR cb 1s",
*mass,*mean1S,*sigma1,*alpha,*npow);
RooCBShape *sig2S = new RooCBShape ("cb2S_1", "FSR cb 1s",
*mass,*mean2S,*sigma2S,*alpha,*npow);
RooCBShape *sig3S = new RooCBShape ("cb3S_1", "FSR cb 1s",
*mass,*mean3S,*sigma3S,*alpha,*npow);
cout << "you're fitting each signal peak with a Crystal Ball function"<< endl;
break;
case 2: //Gaussein
RooAbsPdf *sig1S = new RooGaussian ("g1", "gaus 1s",
*mass,*mean1S,*sigma1);
cout << "you're fitting 1 signal peak with a Gaussian function"<< endl;
break;
case 3: //Gaussein + crystal boule
RooCBShape *cb1S_1 = new RooCBShape ("cb1S_1", "FSR cb 1s",
*mass,*mean1S,*sigma1,*alpha,*npow);
RooAddPdf *sig1S = new RooAddPdf ("cbg", "cbgaus 1s",
RooArgList(*gauss1,*cb1S_1),*sigmaFraction);
cout << "you're fitting 1 signal peak with a sum of a Gaussian and a Crystal Ball function"<< endl;
break;
case 4: //crystal boules
RooCBShape *cb1S_1 = new RooCBShape ("cb1S_1", "FSR cb 1s",
*mass,*mean1S,*sigma1,*alpha,*npow);
RooCBShape *cb1S_2 = new RooCBShape ("cb1S_2", "FSR cb 1s",
*mass,*mean1S,*sigmaGaus,*alpha,*npow);
RooAddPdf *sig1S = new RooAddPdf ("cbcb","1S mass pdf",
RooArgList(*cb1S_1,*cb1S_2),*sigmaFraction);
// /// Upsilon 2S
RooCBShape *cb2S_1 = new RooCBShape ("cb2S_1", "FSR cb 2s",
*mass,*mean2S,*sigma2S,*alpha,*npow);
RooCBShape *cb2S_2 = new RooCBShape ("cb2S_2", "FSR cb 2s",
*mass,*mean2S,*sigmaGaus2,*alpha,*npow);
RooAddPdf *sig2S = new RooAddPdf ("sig2S","2S mass pdf",
RooArgList(*cb2S_1,*cb2S_2),*sigmaFraction);
// /// Upsilon 3S
RooCBShape *cb3S_1 = new RooCBShape ("cb3S_1", "FSR cb 3s",
*mass,*mean3S,*sigma3S,*alpha,*npow);
RooCBShape *cb3S_2 = new RooCBShape ("cb3S_2", "FSR cb 3s",
*mass,*mean3S,*sigmaGaus3,*alpha,*npow);
RooAddPdf *sig3S = new RooAddPdf ("sig3S","3S mass pdf",
RooArgList(*cb3S_1,*cb3S_2),*sigmaFraction); // = cb3S1*sigmaFrac + cb3S2*(1-sigmaFrac)
cout << "you're fitting each signal peak with a Double Crystal Ball function"<< endl;
break;
case 5: //deux Gausseins
RooAddPdf *sig1S = new RooAddPdf ("cb1S_1", "cbgaus 1s",
RooArgList(*gauss1,*gauss1b),*sigmaFraction);
cout << "you're fitting each signal peak with a Double Gaussian function"<< endl;
break;
}
// bkg Chebychev
RooRealVar *nbkgd = new RooRealVar("n_{Bkgd}","nbkgd",0,nt);
RooRealVar *bkg_a1 = new RooRealVar("a1_bkg", "bkg_{a1}", 0, -5, 5);
RooRealVar *bkg_a2 = new RooRealVar("a2_Bkg", "bkg_{a2}", 0, -2, 2);
RooRealVar *bkg_a3 = new RooRealVar("a3_Bkg", "bkg_{a3}", 0, -0.9, 2);
// likesign
RooRealVar *nLikesignbkgd = new RooRealVar("NLikesignBkg","nlikesignbkgd",nt*0.75,0,10*nt);
// *************************************************** bkgModel
RooRealVar turnOn("turnOn","turnOn", turnOn_minCent[whatBin],turnOn_maxCent[whatBin]);
RooRealVar width("width","width",width_minCent[whatBin],width_maxCent[whatBin]);// MB 2.63
RooRealVar decay("decay","decay",decay_minCent[whatBin],decay_maxCent[whatBin]);// MB: 3.39
if (doRap && !doPt)
{
RooRealVar turnOn("turnOn","turnOn", turnOn_minRap[whatBin],turnOn_maxRap[whatBin]);
RooRealVar width("width","width",width_minRap[whatBin],width_maxRap[whatBin]);// MB 2.63
RooRealVar decay("decay","decay",decay_minRap[whatBin],decay_maxRap[whatBin]);// MB: 3.39
}
if (doPt && !doRap)
{
RooRealVar turnOn("turnOn","turnOn", turnOn_minPt[whatBin],turnOn_maxPt[whatBin]);
RooRealVar width("width","width",width_minPt[whatBin],width_maxPt[whatBin]);// MB 2.63
RooRealVar decay("decay","decay",decay_minPt[whatBin],decay_maxPt[whatBin]);// MB: 3.39
}
width.setConstant(false);
decay.setConstant(false);
turnOn.setConstant(false);
switch (useRef)// no reference
{
case 0: // forcing sigma and fsr to be left free.
fixSigma1 = 0;
fixFSR = 0;
break;
case 1:
//using data-driven estimates
int dataRef=1;
cout<<"You're using the debug mode based on data parameters. So you must not take this result as the central one."<<endl;
break;
case 2:
cout << "doCent="<<doCent << endl;
//using MC-driven estimates
int dataRef=2;
if(doCent) //MB values, assumed to be the same with all centralities...
{
if(muonPtMin <4){
gROOT->LoadMacro("dataTable_loose.h");
}else if(muonPtMin > 3.5){
gROOT->LoadMacro("dataTable_tight.h");
}
npow->setVal(npow_rapBins[8]);
alpha->setVal(alpha_rapBins[8]);
sigma1->setVal(sigma1_rapBins[8]);
scaleWidth->setVal(scale_rapBins[8]);
sigmaFraction->setVal(pdFrac_rapBins[8]);
cout<< whatBin << endl;
}
if(doRap && !doPt)
{
if(muonPtMin <4){
gROOT->LoadMacro("dataTable_loose.h");
}else if(muonPtMin > 3.5){
gROOT->LoadMacro("dataTable_tight.h");
}
npow->setVal(npow_rapBins[whatBin]);
alpha->setVal(alpha_rapBins[whatBin]);
sigma1->setVal(sigma1_rapBins[whatBin]);
scaleWidth->setVal(scale_rapBins[whatBin]);
sigmaFraction->setVal(pdFrac_rapBins[whatBin]);
cout<< whatBin << endl;
}
if(doPt && !doRap)
{
// cout << "we're here" << endl;
if(muonPtMin <4){
gROOT->LoadMacro("dataTable_loose.h");
}else if(muonPtMin > 3.5){
gROOT->LoadMacro("dataTable_tight.h");
}
cout << " ok ... " <<endl;
npow->setVal(npow_ptBins[whatBin]);
alpha->setVal(alpha_ptBins[whatBin]);
sigma1->setVal(sigma1_ptBins[whatBin]);
scaleWidth->setVal(scale_ptBins[whatBin]);
sigmaFraction->setVal(pdFrac_ptBins[whatBin]);
}
cout<<"You're using MC parameters. So you may use this result as the central one, according to the LLR test outcome."<<endl;
break;
default: break;
}
//
cout << "npow tried=" << npow->getVal();
if(fixFSR==3 || fixFSR==1) cout << " constant!" << endl; else cout << " floating!" << endl;
cout << "alpha tried=" << alpha->getVal();
if(fixFSR==2 || fixFSR==1) cout << " constant!" << endl; else cout << " floating!" << endl;
cout << "sigma1 tried=" << sigma1->getVal();
if(fixFSR==4 || fixFSR==1) cout << " constant!" << endl; else cout << " floating!" << endl;
cout << "scale tried=" << scaleWidth->getVal();
if(fixFSR==4 || fixFSR==1) cout << " constant!" << endl; else cout << " floating!" << endl;
cout << "normalisation tried=" << sigmaFraction->getVal();
if(fixFSR==5 || fixFSR==1) cout << " constant!" << endl; else cout << " floating!" << endl;
switch (fixFSR) // 0: free; 1: both fixed 2: alpha fixed 3: npow fixed
{
case 0:// all free
alpha->setConstant(false);
npow->setConstant(false);
sigma1->setConstant(false);
scaleWidth->setConstant(false);
sigmaFraction->setConstant(false);
break;
case 1:// all fixed
alpha->setConstant(true);
npow ->setConstant(true);
sigma1->setConstant(true);
scaleWidth->setConstant(true);
sigmaFraction->setConstant(true);
break;
case 2: // release alpha
alpha->setConstant(false);
npow ->setConstant(true);
sigma1->setConstant(true);
scaleWidth->setConstant(true);
sigmaFraction->setConstant(true);
break;
case 3:// npow released
alpha->setConstant(true);
npow->setConstant(false);
sigma1->setConstant(true);
scaleWidth->setConstant(true);
sigmaFraction->setConstant(true);
break;
case 4:// width+ sF +scale released
alpha->setConstant(true);
npow->setConstant(true);
sigma1->setConstant(false);
scaleWidth->setConstant(true);
sigmaFraction->setConstant(true);
break;
case 5:// scale +sF
alpha->setConstant(true);
npow->setConstant(true);
sigma1->setConstant(true);
scaleWidth->setConstant(false);
sigmaFraction->setConstant(true);
break;
case 6:// scale +sF
alpha->setConstant(true);
npow->setConstant(true);
sigma1->setConstant(true);
scaleWidth->setConstant(true);
sigmaFraction->setConstant(false);
break;
default:
cout<<"Donno this choice! Pick somehting for FSR parameters that I know"<<endl;
break;
}
//thisPdf: form of the bkg pdf
//pdf_combinedbkgd; // total bkg pdf. usually form*normalization (so that you can do extended ML fits)
switch (bkgdModel)
{
case 1 : //(erf*exp ) to fit the SS, then fix the shape and fit OS, in case of constrain option
bkg_a3->setConstant(true);
RooGenericPdf *ErrPdf = new RooGenericPdf("ErrPdf","ErrPdf",
"exp(-@0/decay)*(TMath::Erf((@0-turnOn)/width)+1)",
RooArgList(*mass,turnOn,width,decay));
RooFitResult* fit_1st = ErrPdf->fitTo(*likesignData,Save(),NumCPU(4)) ; // likesign data
if (doTrkRot) fit_1st = thisPdf->fitTo(*TrkRotData,Save(),NumCPU(4)) ;
if (doConstrainFit)
{ // allow parameters to vary within cenral value from above fit + their sigma
turnOn_constr = new RooGaussian("turnOn_constr","turnOn_constr",
turnOn,
RooConst(turnOn.getVal()),
RooConst(turnOn.getError()));
width_constr = new RooGaussian("width_constr","width_constr",
width, RooConst(width.getVal()),
RooConst(width.getError()));
decay_constr = new RooGaussian("decay_constr","decay_constr",
decay,
RooConst(decay.getVal()),
RooConst(decay.getError()));
}
else
{
turnOn.setConstant(kTRUE);
width.setConstant(kTRUE);
decay.setConstant(kTRUE);
}
RooRealVar *fLS =new RooRealVar("R_{SS/OS}","Empiric LS/SS ratio",0.,1.);
RooAbsPdf *ChebPdf = new RooChebychev("ChebPdf","ChebPdf",
*mass, RooArgList(*bkg_a1,*bkg_a2));
RooAbsPdf *pdf_combinedbkgd = new RooAddPdf ("bkgPdf","total combined background pdf",
RooArgList(*ErrPdf,*ChebPdf),
RooArgList(*fLS));
break;
case 2 : //us eRooKeysPdf to smooth the SS, then fit OS with pol+keys
bkg_a3->setConstant(true);
RooRealVar *fLS =new RooRealVar("R_{SS/OS}","Empiric LS/SS ratio",0.,1.);
RooKeysPdf *KeysPdf = new RooKeysPdf("KeysPdf","KeysPdf",*mass,*likesignData,
RooKeysPdf::MirrorBoth, 1.4);
RooAbsPdf *ChebPdf = new RooChebychev("ChebPdf","ChebPdf",
*mass, RooArgList(*bkg_a1,*bkg_a2));
if (doTrkRot) thisPdf = new RooKeysPdf("thisPdf","thisPdf",*mass,*TrkRotData,
RooKeysPdf::MirrorBoth, 1.4);
RooAbsPdf *pdf_combinedbkgd = new RooAddPdf ("bkgPdf","total combined background pdf",
RooArgList(*KeysPdf,*ChebPdf),
RooArgList(*fLS));
break;
case 3 : //use error function to fit the OS directly
bkg_a3->setConstant(true);
RooAbsPdf *pdf_combinedbkgd = new RooGenericPdf("bkgPdf","bkgPdf",
"exp(-@0/decay)*(TMath::Erf((@0-turnOn)/width)+1)",
RooArgList(*mass,turnOn,width,decay));
break;
case 4 : //use pol 2+ErfExp to fit the OS directly
RooRealVar *fPol = new RooRealVar("F_{pol}","fraction of polynomial distribution",0.0,1);
RooAbsPdf *ChebPdf = new RooChebychev("ChebPdf","ChebPdf",
*mass, RooArgList(*bkg_a1,*bkg_a2));
RooGenericPdf *ErrPdf = new RooGenericPdf("ErrPdf","ErrPdf",
"exp(-@0/decay)*(TMath::Erf((@0-turnOn)/width)+1)",
RooArgList(*mass,turnOn,width,decay));
RooAbsPdf *pdf_combinedbkgd = new RooAddPdf ("bkgPdf","total combined background pdf",
RooArgList(*ChebPdf,*ErrPdf),
RooArgList(*fPol));
break;
case 5 : //use ( error function + polynomial 1) to fit the OS directly
bkg_a3->setConstant(true);
bkg_a2->setConstant(true);
RooRealVar *fPol = new RooRealVar("F_{pol}","fraction of polynomial distribution",0.0,1);
RooAbsPdf *ChebPdf = new RooChebychev("ChebPdf","ChebPdf",
*mass, RooArgList(*bkg_a1,*bkg_a2,*bkg_a3));
RooGenericPdf *ErrPdf = new RooGenericPdf("ErrPdf","ErrPdf",
"exp(-@0/decay)*(TMath::Erf((@0-turnOn)/width)+1)",
RooArgList(*mass,turnOn,width,decay));
RooAbsPdf *pdf_combinedbkgd = new RooAddPdf ("bkgPdf","total combined background pdf",
RooArgList(*ChebPdf,*ErrPdf),
RooArgList(*fPol));
break;
case 6: // NOT WORKING
RooRealVar *fPol = new RooRealVar("F_{pol}","fraction of polynomial distribution",0.0,1);
RooAbsPdf *ChebPdf = new RooChebychev("ChebPdf","ChebPdf",
*mass, RooArgList(*bkg_a1,*bkg_a2));
RooGenericPdf *ExpPdf = new RooGenericPdf("ExpPdf","ExpPdf",
"exp(-@0/decay)",
RooArgList(*mass,decay));
RooAbsPdf *pdf_combinedbkgd = new RooAddPdf ("bkgPdf","total combined background pdf",
RooArgList(*ChebPdf,*ExpPdf),
RooArgList(*fPol));
break;
default :
cout<<"Donno what you are talking about! Pick another fit option!"<<endl;
break;
}
//###### the nominal fit with default pdf
// RooAbsPdf *pdf; // nominal PDF
if(chooseSample==8)
{
// bkg_a1->setVal(0);// can be turned on at convenience
// bkg_a1->setConstant();
// bkg_a2->setVal(0);
// bkg_a2->setConstant();
// bkg_a3->setVal(0);
// bkg_a3->setConstant();
// RooAbsPdf *pdf = new RooAddPdf ("pdf","total p.d.f.",
// RooArgList(*sig1S,*pdf_combinedbkgd),
// RooArgList(*nsig1f,*nbkgd));
RooAbsPdf *pdf = new RooAddPdf ("pdf","total p.d.f.",*sig1S,*nsig1f);
} else if(chooseSample!=8)
{
// can remove the double crystal ball in pbpb: just commenting out and copying an appropriate version
RooAbsPdf *pdf = new RooAddPdf ("pdf","total p.d.f.",
RooArgList(*sig1S,*sig2S,*sig3S,*pdf_combinedbkgd),
RooArgList(*nsig1f,*nsig2f,*nsig3f,*nbkgd));
// nsig3f->setVal(0); nsig3f->setConstant();
}
w.import(*pdf);
w.Print();
}
