//____________________________________
void DoSPlot(RooWorkspace* ws){
std::cout << "Calculate sWeights" << std::endl;
// get what we need out of the workspace to do the fit
RooAbsPdf* model = ws->pdf("model");
RooRealVar* zYield = ws->var("zYield");
RooRealVar* qcdYield = ws->var("qcdYield");
RooDataSet* data = (RooDataSet*) ws->data("data");
// fit the model to the data.
model->fitTo(*data, Extended() );
// The sPlot technique requires that we fix the parameters
// of the model that are not yields after doing the fit.
RooRealVar* sigmaZ = ws->var("sigmaZ");
RooRealVar* qcdMassDecayConst = ws->var("qcdMassDecayConst");
sigmaZ->setConstant();
qcdMassDecayConst->setConstant();
RooMsgService::instance().setSilentMode(true);
// Now we use the SPlot class to add SWeights to our data set
// based on our model and our yield variables
RooStats::SPlot* sData = new RooStats::SPlot("sData","An SPlot",
*data, model, RooArgList(*zYield,*qcdYield) );
// Check that our weights have the desired properties
std::cout << "Check SWeights:" << std::endl;
std::cout << std::endl << "Yield of Z is "
<< zYield->getVal() << ". From sWeights it is "
<< sData->GetYieldFromSWeight("zYield") << std::endl;
std::cout << "Yield of QCD is "
<< qcdYield->getVal() << ". From sWeights it is "
<< sData->GetYieldFromSWeight("qcdYield") << std::endl
<< std::endl;
for(Int_t i=0; i < 10; i++)
{
std::cout << "z Weight " << sData->GetSWeight(i,"zYield")
<< " qcd Weight " << sData->GetSWeight(i,"qcdYield")
<< " Total Weight " << sData->GetSumOfEventSWeight(i)
<< std::endl;
}
std::cout << std::endl;
// import this new dataset with sWeights
std::cout << "import new dataset with sWeights" << std::endl;
ws->import(*data, Rename("dataWithSWeights"));
}
void PEs(RooAbsPdf *iGen,RooAbsPdf *iFit,int iN,int iNEvents,RooRealVar &iVar,RooRealVar &iSig,RooRealVar &iMean,
RooRealVar &iScale,RooRealVar &iRes) {
double iM0 = iMean.getVal(); double iS0 = iSig.getVal();
//iScale.setVal(iMeanScale); iRes.setVal(iSigScale);
TRandom1 *lRand = new TRandom1(0xDEADBEEF);
TNtuple * lDN= new TNtuple( "xxx","xxx","ntot:m_r:m:merr:sig_r:sig:sigerr");
for(int i0=0;i0<iN;i0++){
if(i0 % 10 == 0) cout << "+++++++++++++++++++++++++++ running ======> " << i0 << endl;
int lN = lRand->Poisson(iNEvents);
RooDataSet * lSignal = iGen->generate(iVar,lN);
iMean.setVal(iM0); iSig.setVal(iS0);
iFit->fitTo(*lSignal,Strategy(1));//,Save(kTRUE),PrintLevel(1));
if(iMean.getError() < 0.05) iFit->fitTo(*lSignal,Strategy(2));
Float_t values[]={
(Float_t) lN,
(Float_t) 90.78/iScale.getVal(),
(Float_t) iMean.getVal(),
(Float_t) iMean.getError(),
(Float_t) iSig.getVal(),
(Float_t) iSig.getVal(),
(Float_t) iSig.getError()
};
lDN->Fill(values);
}
TFile *lF = new TFile("XXX.root","RECREATE");
lDN->Write();
lF->Close();
}
TGraph *graphLH(std::string nuisname, double err ){
w->loadSnapshot("bestfitall"); // SetTo BestFit values as start
// Get The parameter we want
RooRealVar *nuis =(RooRealVar*) w->var(nuisname.c_str());
double bf = nuis->getVal();
double nll_0=nll->getVal();
TGraph *gr = new TGraph(2*npoints+1);
for (int i=-1*npoints;i<=npoints;i++){
nuis->setVal(bf+err*( ((float)i)*nsigma/npoints));
double nll_v = nll->getVal();
gr->SetPoint(i+npoints,nuis->getVal(),nll_v-nll_0);
}
gr->SetTitle("");
gr->GetYaxis()->SetTitle("NLL - obs data");
gr->GetYaxis()->SetTitleOffset(1.1);
gr->GetXaxis()->SetTitleSize(0.05);
gr->GetYaxis()->SetTitleSize(0.05);
gr->GetXaxis()->SetTitle(nuisname.c_str());
gr->SetLineColor(4);
gr->SetLineWidth(2);
gr->SetMarkerStyle(21);
gr->SetMarkerSize(0.6);
return gr;
}
TGraphAsymmErrors *plotEffPt(RooDataSet *a, int aa) {
const RooArgSet *set = a->get();
RooRealVar *xAx = (RooRealVar*)set->find("pt");
RooRealVar *eff = (RooRealVar*)set->find("efficiency");
const int nbins = xAx->getBinning().numBins();
double tx[nbins], txhi[nbins], txlo[nbins];
double ty[nbins], tyhi[nbins], tylo[nbins];
for (int i=0; i<nbins; i++) {
a->get(i);
ty[i] = eff->getVal();
tx[i] = xAx->getVal();
txhi[i] = fabs(xAx->getErrorHi());
txlo[i] = fabs(xAx->getErrorLo());
tyhi[i] = fabs(eff->getErrorHi());
tylo[i] = fabs(eff->getErrorLo());
}
cout<<"NBins : "<<nbins<<endl;
const double *x = tx;
const double *xhi = txhi;
const double *xlo = txlo;
const double *y = ty;
const double *yhi = tyhi;
const double *ylo = tylo;
TGraphAsymmErrors *b = new TGraphAsymmErrors();
if(aa == 1) {
*b = TGraphAsymmErrors(nbins,x,y,xlo,xhi,ylo,yhi);
}
if(aa == 0) {
*b = TGraphAsymmErrors(nbins,x,y,0,0,ylo,yhi);
}
b->SetMaximum(1.1);
b->SetMinimum(0.0);
b->SetMarkerStyle(20);
b->SetMarkerColor(kRed+2);
b->SetMarkerSize(1.0);
b->SetTitle("");
b->GetXaxis()->SetTitleSize(0.05);
b->GetYaxis()->SetTitleSize(0.05);
b->GetXaxis()->SetTitle("p_{T} [GeV/c]");
b->GetYaxis()->SetTitle("Efficiency");
b->GetXaxis()->CenterTitle();
//b->Draw("apz");
for (int i=0; i<nbins; i++) {
cout << x[i] << " " << y[i] << " " << yhi[i] << " " << ylo[i] << endl;
}
return b;
}
void FitterUtils::initiateParams(int nGenSignalZeroGamma, int nGenSignalOneGamma, int nGenSignalTwoGamma, RooRealVar const& expoConstGen, RooRealVar& nSignal, RooRealVar& nPartReco,
RooRealVar& nComb, RooRealVar& fracZero, RooRealVar& fracOne, RooRealVar& expoConst, RooRealVar& nJpsiLeak, bool constPartReco, RooRealVar const& fracPartRecoSigma)
{
TRandom rand;
rand.SetSeed();
int nGenSignal = nGenSignalZeroGamma + nGenSignalOneGamma + nGenSignalTwoGamma;
double nGenSignal2;
double nGenPartReco2;
if(!constPartReco)
{
nGenSignal2 = rand.Uniform(nGenSignal-5*sqrt(nGenSignal), nGenSignal+5*sqrt(nGenSignal));
nGenPartReco2 = rand.Uniform(nGenPartReco-5*sqrt(nGenPartReco), nGenPartReco+5*sqrt(nGenPartReco));
}
if(constPartReco)
{
double nGenSigPartReco( nGenSignal+nGenPartReco );
double nGenSigPartReco2( rand.Uniform( nGenSigPartReco-5*sqrt(nGenSigPartReco), nGenSigPartReco+5*sqrt(nGenSigPartReco) ) );
double fracPartReco1( nGenPartReco/(1.*nGenSignal));
double fracPartReco2( rand.Uniform(fracPartReco1-5*fracPartRecoSigma.getVal(), fracPartReco1+5*fracPartRecoSigma.getVal()) );
nGenPartReco2 = fracPartReco2*nGenSigPartReco2 / (1+fracPartReco2);
nGenSignal2 = nGenSigPartReco2 / (1+fracPartReco2);
}
double nGenComb2 = rand.Uniform(nGenComb-5*sqrt(nGenComb), nGenComb+5*sqrt(nGenComb));
double nGenJpsiLeak2 = rand.Uniform(nGenJpsiLeak-5*sqrt(nGenJpsiLeak), nGenJpsiLeak+5*sqrt(nGenJpsiLeak));
nSignal.setVal(nGenSignal2);
nSignal.setRange(TMath::Max(0.,nGenSignal2-10.*sqrt(nGenSignal)) , nGenSignal2+10*sqrt(nGenSignal));
nPartReco.setVal(nGenPartReco2);
nPartReco.setRange(TMath::Max(0.,nGenPartReco2-10.*sqrt(nGenPartReco)), nGenPartReco2+10*sqrt(nGenPartReco));
nComb.setVal(nGenComb2);
nComb.setRange(TMath::Max(0.,nGenComb2-10.*sqrt(nGenComb)), nGenComb2+10*sqrt(nGenComb));
nJpsiLeak.setVal(nGenJpsiLeak2);
nJpsiLeak.setRange(TMath::Max(0., nGenJpsiLeak2-10*sqrt(nGenJpsiLeak)), nGenJpsiLeak2+10*sqrt(nGenJpsiLeak));
double fracGenZero(nGenSignalZeroGamma/(1.*nGenSignal));
double fracGenOne(nGenSignalOneGamma/(1.*nGenSignal));
fracZero.setVal(rand.Gaus(fracGenZero, sqrt(nGenSignalZeroGamma)/(1.*nGenSignal))) ;
fracZero.setRange(0., 1.);
fracOne.setVal(rand.Gaus(fracGenOne, sqrt(nGenSignalOneGamma)/(1.*nGenSignal))) ;
fracOne.setRange(0., 1.);
expoConst.setVal(rand.Uniform( expoConstGen.getVal() - 5*expoConstGen.getError(), expoConstGen.getVal() + 5*expoConstGen.getError() ) );
expoConst.setRange( expoConstGen.getVal() - 10*expoConstGen.getError(), expoConstGen.getVal() + 10*expoConstGen.getError() );
}
MakeBiasStudy::MakeBiasStudy() {
int Nmodels = 8;
//RooRealVar* mass = ws->var("mass");
RooRealVar *mass = new RooRealVar("mass","mass", 100,180);
RooRealVar *nBkgTruth = new RooRealVar("TruthNBkg","", 0,1e9);
// RooAbsData* realData = ws->data("Data_Combined")->reduce( Form("evtcat==evtcat::%s",cat.Data()) );
double Bias[Nmodels][Nmodels];
double BiasE[Nmodels][Nmodels];
MakeAICFits MakeAIC_Fits;
for(int truthType = 0; truthType < Nmodels; truthType++){
RooAbsPdf *truthPdf = MakeAIC_Fits.getBackgroundPdf(truthType,mass);
RooExtendPdf *truthExtendedPdf = new RooExtendPdf("truthExtendedPdf","",*truthPdf,*nBkgTruth);
//truthExtendedPdf.fitTo(*realData,RooFit::Strategy(0),RooFit::NumCPU(NUM_CPU),RooFit::Minos(kFALSE),RooFit::Extended(kTRUE));
//truthExtendedPdf.fitTo(*realData,RooFit::Strategy(2),RooFit::NumCPU(NUM_CPU),RooFit::Minos(kFALSE),RooFit::Extended(kTRUE));
double BiasWindow = 2.00;
mass->setRange("biasRegion", mh-BiasWindow, mh+BiasWindow);
double TruthFrac = truthExtendedPdf->createIntegral(mass,RooFit::Range("biasRegion"),RooFit::NormSet(*mass))->getVal();
double NTruth = TruthFrac * nBkgTruth->getVal();
double NTruthE = TruthFrac * nBkgTruth->getError();
RooDataSet* truthbkg = truthPdf->generate(RooArgSet(*mass),nBkgTruth);
for(int modelType = 0; modelType < Nmodels; modelType++){
RooAbsPdf* ModelShape = MakeAIC_Fits.getBackgroundPdf(modelType,mass);
RooRealVar *nBkgFit = new RooRealVar("FitNBkg", "", 0, 1e9);
RooExtendPdf ModelExtendedPdf = new RooExtendPdf("ModelExtendedPdf", "",*ModelShape, *nBkgFit);
ModelExtendedPdf.fitTo(truthbkg, RooFit::Strategy(0),RooFit::NumCPU(NUM_CPU),RooFit::Minos(kFALSE),RooFit::Extended(kTRUE));
ModelExtendedPdf.fitTo(truthbkg, RooFit::Strategy(2),RooFit::NumCPU(NUM_CPU),RooFit::Minos(kFALSE),RooFit::Extended(kTRUE));
double FitFrac = ModelExtendedPdf.createIntegral(mass,RooFit::Range("biasRegion"),RooFit::NormSet(mass))->getVal();
double NFit = FitFrac * nBkgFit->getVal();
double NFitE = FitFrac * nBkgFit->getError();
Bias[truthType][modelType] = fabs(NFit - NTruth);
BiasE[truthType][modelType] = fabs(NFitE - NTruthE);
}
}
for(int i = 0; i < Nmodels; i++) {
std::cout << "===== Truth Model : " << MakeBiasStudy::Category(i) << " ===== " << std::endl;
for (int j = 0; j < Nmodels; j++) {
std::cout << "Fit Model: " << MakeBiasStudy::Category(j) << " , Bias = " << Bias[i][j] << " +/- " << BiasE[i][j] << std::endl;
}
}
}
void MakeSpinPlots::MakeChannelComp(const char* mcType){
TGraphErrors graph(catNames.size());
RooRealVar mu("mu","",-50,50);
float exp = ws->data(Form("%s_Combined",mcType))->sumEntries();///total * 607*lumi/12.;
TH1F frame("frame","",catNames.size(),0,catNames.size());
//graph.GetXaxis()->SetNdivisions(catNames.size());
float min=99999,max=-99999;
for(int i=0;i<catNames.size();i++){
RooRealVar *ind = ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcType, catNames.at(i).Data()) );
RooRealVar *f = ws->var( Form("Data_%s_FULLFIT_%s_fsig",mcType, catNames.at(i).Data()) );
float mu = ind->getVal()/exp/f->getVal();
float muE = ind->getError()/exp/f->getVal();
graph.SetPoint(i,i+0.5,mu);
graph.SetPointError(i,0,muE);
if(mu-muE < min) min = mu-muE;
if(mu+muE > max) max = mu+muE;
//graph.GetXaxis()->SetBinLabel(i+1,catNames.at(i));
}
TF1 fit("fit","[0]",0+0.5,catNames.size()+0.5);
graph.Fit(&fit,"MNE");
float mean = fit.GetParameter(0);
float meanE = fit.GetParError(0);
frame.SetAxisRange(min-1.5,max+0.5,"Y");
frame.SetYTitle("Fitted #sigma/#sigma_{SM}");
frame.SetXTitle("Category");
TCanvas cv;
frame.Draw();
TBox err(0,mean-meanE,catNames.size(),mean+meanE);
err.SetFillColor(kGreen);
frame.Draw();
err.Draw("SAME");
TLine mLine(0,mean,catNames.size(),mean);
mLine.Draw("SAME");
graph.Draw("PSAME");
cv.SaveAs(basePath+Form("/ChannelComp_%s_%s.png",mcType,outputTag.Data()));
cv.SaveAs(basePath+Form("/ChannelComp_%s_%s.pdf",mcType,outputTag.Data()));
}
double getSigmaError(RooWorkspace *w)
{
using namespace RooFit;
// Access saved Sigma CB values and error from WorkSpace
RooRealVar *mySavedSigma = w->var("sigma_{CB}");
RooRealVar *mySavedDeltaM = w->var("#Deltam_{CB}");
Double_t sigma = mySavedSigma->getVal();
Double_t sigmaerror = mySavedSigma->getError();
Double_t DeltaM = mySavedDeltaM->getVal();
Double_t DeltaMerror = mySavedDeltaM->getError();
Double_t Sigpercent = 100 * sigma / (91.187 + DeltaM);
Double_t Sigpercenterror = 100 * pow(pow(sigmaerror / (91.198 + DeltaM), 2) + pow((sigma * DeltaMerror) / pow(DeltaM + 91.198, 2), 2), .5);
return Sigpercenterror;
} // plotFitOn(..)
void testResolution() {
Prep();
RooRealVar lXVar ("XVar","mass(GeV/c^{2})",100,60,150); lXVar.setBins(1000);
RooRealVar l1Sigma("sigma1","sigma1",1.6 ,0.,15.); //l1Sigma.setConstant(kTRUE);
RooRealVar l2Sigma("sigma2","sigma2",1.6,0.,15.); l2Sigma.setConstant(kTRUE);
RooRealVar l3Sigma("sigma3","sigma3",2.90,0.,35.); l3Sigma.setConstant(kTRUE);
RooRealVar lN ("n" ,"n" ,1.00,-15,15.); lN.setConstant(kTRUE);
RooRealVar lExp ("exp" ,"exp" ,-0.003,-15,15.); //lExp.setConstant(kTRUE);
RooRealVar lR0Mean("xmean","xmean",0,-10,10); lR0Mean.setConstant(kTRUE);
RooRealVar lR1Mean("mean","mean",90.8,60,150); //lR1Mean.setConstant(kTRUE);
RooVoigtianShape lGAdd("Add","Add",lXVar,lR1Mean,l1Sigma,l2Sigma,lN,l3Sigma,true);
RooRealVar lSPar ("SPar","SPar", 1.,0., 2.);
RooFormulaVar lXShift("uparshift","@0*@1",RooArgList(lXVar,lSPar));
TH1F *lMass = getMass(0,-5,5,-1.5,1.5);
RooDataHist *lMHist = new RooDataHist("M" ,"M" ,RooArgSet(lXVar),lMass);
RooHistPdf *lMPdf = new RooHistPdf ("MH","MH",lXShift,lXVar,*lMHist,5);
RooRealVar lGSigma("gsigma","gsigma",1.6 ,0.,15.);
RooGaussian lGaus1("gaus1","gaus1",lXVar,lR0Mean,lGSigma);
RooFFTConvPdf lConv("Conv","Conv",lXVar,*lMPdf,lGaus1);
RooDataSet *lData = new RooDataSet("crap","crap",RooArgSet(lXVar));
fillData(lData,lXVar,0,-5,5,-1.5,1.5);
lConv.fitTo(*lData,Strategy(2));
lGSigma.setVal(lGSigma.getVal());
lSPar.setVal(lSPar.getVal()*1.01);
//cout << "=====> Check " << l1Sigma.getVal() << " --- " << lR1Mean.getVal() << "----" << lSPar.getVal() << endl;
PEs(&lConv,&lGAdd,2000,500,lXVar,l1Sigma,lR1Mean,lSPar,lGSigma);
lData = 0;
Plot(&lConv,&lGAdd,2000,50000,lXVar,l1Sigma,lR1Mean,lSPar,lGSigma,lData);
}
void simplePrintResults() {
vector<string> filenames;
filenames.push_back("Output/Test2/result/FIT_DATA_Psi2SJpsi_PPPrompt_Bkg_SecondOrderChebychev_pt65300_rap016_cent0200_262620_263757.root");
const char* parname = "N_Jpsi_PP";
vector<string>::iterator it = filenames.begin();
for (it; it<filenames.end(); it++) {
TFile *f = new TFile(it->c_str());
if (!f) {
cout << "Error, " << *it << " not found" << endl;
continue;
}
RooWorkspace *ws = (RooWorkspace*) f->Get("workspace");
if (!ws) {
cout << "Error, workspace not found in " << *it << endl;
continue;
}
RooRealVar *var = ws->var(parname);
if (!ws) {
cout << "Error, variable " << parname << " not found in " << *it << endl;
continue;
}
cout << *it << " " << var->getVal() << " +- " << var->getError() << endl;
}
}
void PDF_GLWADS_DKDpi_K3pi::setObservables(config c)
{
switch(c)
{
case truth:{
setObservablesTruth();
break;
}
case toy:{
setObservablesToy();
break;
}
case lumi1fb:{
obsValSource = "1fb-1, ExpNll/sept2012K3PIResult.root";
TString File = this->dir+"/ExpNll/sept2012K3PIResult.root";
TFile *fr = TFile::Open(File);
RooFitResult *r = (RooFitResult*)fr->Get("fitresult_model_reducedData_binned");
assert(r);
TIterator* it = observables->createIterator();
while ( RooRealVar* pObs = (RooRealVar*)it->Next() )
{
RooRealVar* pRes = (RooRealVar*)r->floatParsFinal().find(obsTmkToMalcolm(pObs->GetName()));
pObs->setVal(pRes->getVal());
}
fr->Close();
delete r;
delete fr;
break;
}
case lumi3fb:{
obsValSource = "3fb-1 ANA v7 unblind"; // https://twiki.cern.ch/twiki/pub/LHCbPhysics/B2D0K/LHCb-ANA-2014-071-v7.pdf (see Vavas email 04/08/15)
// these get transformed over from the new inputs using ExpNll/transportGLWADS_new_to_old.py
// in the case of the DK only (robust) combination some of the observables don't exist
// usemap as the temp store
std::map< TString, double > vals;
vals["rkp_k3pi_obs"] = 0.0793;
vals["afav_dk_k3pi_obs"] = -0.0004;
vals["afav_dpi_k3pi_obs"] = 0.0;
vals["rp_dk_k3pi_obs"] = 0.018369;
vals["rm_dk_k3pi_obs"] = 0.009611;
vals["rp_dpi_k3pi_obs"] = 0.003683;
vals["rm_dpi_k3pi_obs"] = 0.003857;
// now can loop the observables and set the values
TIterator* it = observables->createIterator();
while ( RooRealVar* pObs = (RooRealVar*)it->Next() ){
pObs->setVal(vals[pObs->GetName()]);
}
vals.clear();
break;
}
default:{
cout << "PDF_GLWADS_DKDpi_K3pi::setObservables() : ERROR : config "+ConfigToTString(c)+" not found." << endl;
exit(1);
}
}
}
///
/// Set each parameter in setMe to the value found in values.
/// Do nothing if parameter is not found in values.
///
void Utils::setParameters(const RooAbsCollection* setMe, const RooAbsCollection* values)
{
TIterator* it = setMe->createIterator();
while ( RooRealVar* p = (RooRealVar*)it->Next() ){
RooRealVar *var = (RooRealVar*)values->find(p->GetName());
if ( var ) p->setVal(var->getVal());
}
delete it;
}
// grab the initial parameters and errors for making pull distributions:
// Take these from a fit file to the data themselves
void fillInitialParams(RooArgSet *args, std::map<std::string, std::pair<double,double> > &vals){
TIterator* iter(args->createIterator());
for (TObject *a = iter->Next(); a != 0; a = iter->Next()) {
RooRealVar *rrv = dynamic_cast<RooRealVar *>(a);
std::string name = rrv->GetName();
std::pair<double,double> valE(rrv->getVal(),rrv->getError());
vals.insert( std::pair<std::string,std::pair<double ,double> > (name,valE)) ;
}
}
void GetNominalValueNuisancePara(){
TIterator *it = mc->GetNuisanceParameters()->createIterator();
RooRealVar *var = NULL;
if (MapNuisanceParamNom.size() > 0) MapNuisanceParamNom.clear();
std::cout << "Nuisance parameter names and values" << std::endl;
while ((var = (RooRealVar*)it->Next()) != NULL){
const double val = var->getVal();
MapNuisanceParamNom[(string)var->GetName()] = val;
}
return;
}
TH2F *plotEff2D(RooDataSet *a, TString b) {
const RooArgSet *set = a->get();
RooRealVar *yAx = (RooRealVar*)set->find("pt");
RooRealVar *xAx = (RooRealVar*)set->find("eta");
RooRealVar *eff = (RooRealVar*)set->find("efficiency");
// const int xnbins = xAx->getBinning().numBins();
// const int ynbins = yAx->getBinning().numBins();
//double xbins[] = {-2.4, -1.6, -0.8, 0.0, 0.8, 1.6, 2.4};
//double ybins[] = {0, 2, 3, 5, 8, 10, 20};
const double *xvbins = xAx->getBinning().array();
const double *yvbins = yAx->getBinning().array();
TH2F* h = new TH2F(b, "", xAx->getBinning().numBins(), xvbins, yAx->getBinning().numBins(), yvbins);
gStyle->SetPaintTextFormat("5.2f");
gStyle->SetPadRightMargin(0.12);
gStyle->SetPalette(1);
h->SetOption("colztexte");
h->GetZaxis()->SetRangeUser(-0.001,1.001);
h->SetStats(kFALSE);
h->GetYaxis()->SetTitle("p_{T} [GeV/c]");
h->GetXaxis()->SetTitle("#eta");
h->GetXaxis()->CenterTitle();
h->GetYaxis()->CenterTitle();
h->GetXaxis()->SetTitleSize(0.05);
h->GetYaxis()->SetTitleSize(0.05);
h->GetYaxis()->SetTitleOffset(0.8);
h->GetXaxis()->SetTitleOffset(0.9);
for(int i=0; i<a->numEntries(); i++) {
a->get(i);
h->SetBinContent(h->FindBin(xAx->getVal(), yAx->getVal()), eff->getVal());
h->SetBinError(h->FindBin(xAx->getVal(), yAx->getVal()), (eff->getErrorHi()-eff->getErrorLo())/2.);
}
return h;
}
RooDataSet * getDataAndFrac(TString name, TString q2name, TreeReader * mydata, TCut cut, RooRealVar * MM, double * frac, Str2VarMap jpsiPars, double *outnsig)
{
RooRealVar * cosThetaL = new RooRealVar("cosThetaL","cosThetaL",0.,-1.,1.);
RooRealVar * cosThetaB = new RooRealVar("cosThetaB","cosThetaB",0.,-1.,1.);
TCut massCut = "Lb_MassConsLambda > 5590 && Lb_MassConsLambda < 5650";
Analysis * ana = new Analysis(name+"_mass"+q2name,"Lb",mydata,&cut,MM);
ana->AddVariable("J_psi_1S_MM");
ana->AddVariable(cosThetaL);
ana->AddVariable(cosThetaB);
RooAbsPdf * mysig = stringToPdf("Gauss","sig",MM,jpsiPars);
RooAbsPdf * mybkg = stringToPdf("Exp","bkgM",MM);
RooRealVar * mynsig = new RooRealVar("mynsig","mynsig",50,0,100000);
RooRealVar * mynbkg = new RooRealVar("mynbkg","mynbkg",10,0,100000);
RooAbsPdf * Mmodel = new RooAddPdf("MassModel","MassModel",RooArgSet(*mysig,*mybkg),RooArgSet(*mynsig,*mynbkg));
ana->applyCuts(&cut);
RooDataSet * data = ana->GetDataSet("-recalc");
Mmodel->fitTo(*data,Extended(kTRUE));
double sigBkg = mybkg->createIntegral(*MM,NormSet(*MM),Range("Signal"))->getVal();
double sig = mysig->createIntegral(*MM,NormSet(*MM),Range("Signal"))->getVal();
double nsig = mynsig->getVal();
double nbkg = mynbkg->getVal();
if(frac)
{
frac[0] = nsig*sig/(nsig*sig+nbkg*sigBkg);
frac[1] = frac[0]*TMath::Sqrt( TMath::Power(mynsig->getError()/nsig,2) + TMath::Power(mynbkg->getError()/nbkg,2) );
}
TCut mycut = cut + massCut;
ana->applyCuts(&mycut);
TCanvas * cc = new TCanvas();
GetFrame(MM,Mmodel,data,"-nochi2-plotAllComp",30,NULL,0,"cos#theta_{#Lambda}")->Draw();
cc->Print("M_"+name+"_"+q2name+".pdf");
if(*outnsig) *outnsig = nsig;
return ana->GetDataSet("-recalc");
}
void LatexMaker::writeFile()
{
// central values and errors
ofstream outfile;
outfile.open(outfname + ".tex");
RooArgList *observables = pdf->getObservables();
vector<TString> labels = pdf->getLatexObservables();
outfile << "\\begin{align}" << endl;
for ( int i=0; i<pdf->getNobs(); i++ ) {
RooRealVar *var = (RooRealVar*)observables->at(i);
TString title = var->GetTitle();
title.ReplaceAll("#","\\");
if ( i < labels.size() ) title = labels[i];
if ( var->getVal() < 0. ) {
outfile << Form("%-30s \\phantom{OO} &= %7.5f & {}\\pm{} & %7.5f \\phantom{1} & {}\\pm{} & %7.5f \\phantom{1} \\\\", title.Data(), var->getVal(), pdf->StatErr[i], pdf->SystErr[i]) << endl;
}
else {
outfile << Form("%-30s \\phantom{OO} &= \\phantom{-}%7.5f & {}\\pm{} & %7.5f \\phantom{1} & {}\\pm{} & %7.5f \\phantom{1} \\\\", title.Data(), var->getVal(), pdf->StatErr[i], pdf->SystErr[i]) << endl;
}
}
outfile << "\\end{align}" << endl;
outfile.close();
// stat correlations
ofstream outfile_stat;
outfile_stat.open(outfname + "_stat.tex");
writeCorrMatrix( outfile_stat, pdf->corStatMatrix, observables, labels );
outfile_stat.close();
// syst correlations
ofstream outfile_syst;
outfile_syst.open(outfname + "_syst.tex");
writeCorrMatrix( outfile_syst, pdf->corSystMatrix, observables, labels );
outfile_syst.close();
}
TTree *dataset2tree(RooDataSet *dataset){
const RooArgSet *args = dataset->get();
if(args==NULL) return NULL;
RooArgList argList(*args);
Double_t variables[50];
Long64_t nEntries= dataset->numEntries();
//nEntries=1;
TTree *tree = new TTree("tree","tree");
tree->SetDirectory(0);
TIterator *it1=NULL;
it1 = argList.createIterator();
int index1=0;
for(RooRealVar *var = (RooRealVar *) it1->Next(); var!=NULL;
var = (RooRealVar *) it1->Next(),index1++){
TString name(var->GetName());
name.ReplaceAll("-","_");
tree->Branch(name, &(variables[index1]), name+"/D");
}
// tree->Print();
for(Long64_t jentry=0; jentry<nEntries; jentry++){
TIterator *it=NULL;
RooArgList argList1(*(dataset->get(jentry)));
it = argList1.createIterator();
//(dataset->get(jentry))->Print();
int index=0;
for(RooRealVar *var = (RooRealVar *) it->Next(); var!=NULL;
var = (RooRealVar *) it->Next(), index++){
variables[index]=var->getVal();
//var->Print();
}
delete it;
tree->Fill();
}
tree->ResetBranchAddresses();
// tree->Print();
return tree;
}
void MakeSpinPlots::printYields(const char* mcType){
RooRealVar * tot = ws->var(Form("Data_%s_FULLFIT_Nsig",mcType));
if(tot==0) return;
cout << "Total Yield: " << tot->getVal() << " +- " << tot->getError() <<endl;
cout << "Category Yields: CONSTRAINED FIT " << endl;
for(int i=0;i<catNames.size();i++){
RooRealVar *f = ws->var( Form("Data_%s_FULLFIT_%s_fsig",mcType, catNames.at(i).Data()) );
cout << "\t" << catNames.at(i) <<": " << tot->getVal()*f->getVal() << " +- " << tot->getError()*f->getVal() <<endl;
}
cout << "\nCategory Yields: INDEPENDENT FIT " << endl;
for(int i=0;i<catNames.size();i++){
RooRealVar *ind = ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcType, catNames.at(i).Data()) );
if(ind==0) continue;
cout << "\t" << catNames.at(i) <<": " << ind->getVal() << " +- " << ind->getError() <<endl;
}
float exp = ws->data(Form("%s_Combined",mcType))->sumEntries();///total * 607*lumi/12.;
cout << endl << "Expected Events: " << exp << endl;
cout << "Expected Yields Per Category: " <<endl;
for(int i=0;i<catNames.size();i++){
RooRealVar *f = ws->var( Form("Data_%s_FULLFIT_%s_fsig",mcType, catNames.at(i).Data()) );
cout << "\t" << catNames.at(i) <<": " << exp*f->getVal() <<endl;
}
cout << "mu: " << tot->getVal()/exp << " +- "
<< tot->getError()/exp <<endl;
for(int i=0;i<catNames.size();i++){
RooRealVar *ind = ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcType, catNames.at(i).Data()) );
if(ind==0) continue;
RooRealVar *f = ws->var( Form("Data_%s_FULLFIT_%s_fsig",mcType, catNames.at(i).Data()) );
cout << "\t" << catNames.at(i) <<": " << ind->getVal()/(exp*f->getVal()) << " +- " << ind->getError()/(exp*f->getVal()) <<endl;
}
MakeChannelComp(mcType);
}
void compute_p0(const char* inFileName,
const char* wsName = "combined",
const char* modelConfigName = "ModelConfig",
const char* dataName = "obsData",
const char* asimov1DataName = "asimovData_1",
const char* conditional1Snapshot = "conditionalGlobs_1",
const char* nominalSnapshot = "nominalGlobs",
string smass = "130",
string folder = "test")
{
double mass;
stringstream massStr;
massStr << smass;
massStr >> mass;
double mu_profile_value = 1; // mu value to profile the obs data at wbefore generating the expected
bool doConditional = 1; // do conditional expected data
bool remakeData = 0; // handle unphysical pdf cases in H->ZZ->4l
bool doUncap = 1; // uncap p0
bool doInj = 0; // setup the poi for injection study (zero is faster if you're not)
bool doObs = 1; // compute median significance
bool doMedian = 1; // compute observed significance
TStopwatch timer;
timer.Start();
TFile f(inFileName);
RooWorkspace* ws = (RooWorkspace*)f.Get(wsName);
if (!ws)
{
cout << "ERROR::Workspace: " << wsName << " doesn't exist!" << endl;
return;
}
ModelConfig* mc = (ModelConfig*)ws->obj(modelConfigName);
if (!mc)
{
cout << "ERROR::ModelConfig: " << modelConfigName << " doesn't exist!" << endl;
return;
}
RooDataSet* data = (RooDataSet*)ws->data(dataName);
if (!data)
{
cout << "ERROR::Dataset: " << dataName << " doesn't exist!" << endl;
return;
}
mc->GetNuisanceParameters()->Print("v");
ROOT::Math::MinimizerOptions::SetDefaultMinimizer("Minuit2");
ROOT::Math::MinimizerOptions::SetDefaultStrategy(0);
ROOT::Math::MinimizerOptions::SetDefaultPrintLevel(1);
cout << "Setting max function calls" << endl;
ws->loadSnapshot("conditionalNuis_0");
RooArgSet nuis(*mc->GetNuisanceParameters());
RooRealVar* mu = (RooRealVar*)mc->GetParametersOfInterest()->first();
RooAbsPdf* pdf = mc->GetPdf();
string condSnapshot(conditional1Snapshot);
RooArgSet nuis_tmp2 = *mc->GetNuisanceParameters();
RooNLLVar* obs_nll = doObs ? (RooNLLVar*)pdf->createNLL(*data, Constrain(nuis_tmp2)) : NULL;
RooDataSet* asimovData1 = (RooDataSet*)ws->data(asimov1DataName);
RooRealVar* emb = (RooRealVar*)mc->GetNuisanceParameters()->find("ATLAS_EMB");
if (!asimovData1 || (string(inFileName).find("ic10") != string::npos && emb))
{
if (emb) emb->setVal(0.7);
cout << "Asimov data doesn't exist! Please, allow me to build one for you..." << endl;
string mu_str, mu_prof_str;
asimovData1 = makeAsimovData(mc, doConditional, ws, obs_nll, 1, &mu_str, &mu_prof_str, mu_profile_value, true);
condSnapshot="conditionalGlobs"+mu_prof_str;
}
if (!doUncap) mu->setRange(0, 40);
else mu->setRange(-40, 40);
RooAbsPdf* pdf = mc->GetPdf();
RooArgSet nuis_tmp1 = *mc->GetNuisanceParameters();
RooNLLVar* asimov_nll = (RooNLLVar*)pdf->createNLL(*asimovData1, Constrain(nuis_tmp1));
//do asimov
mu->setVal(1);
mu->setConstant(0);
if (!doInj) mu->setConstant(1);
int status,sign;
double med_sig=0,obs_sig=0,asimov_q0=0,obs_q0=0;
if (doMedian)
{
ws->loadSnapshot(condSnapshot.c_str());
if (doInj) ws->loadSnapshot("conditionalNuis_inj");
else ws->loadSnapshot("conditionalNuis_1");
mc->GetGlobalObservables()->Print("v");
mu->setVal(0);
mu->setConstant(1);
status = minimize(asimov_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(asimov_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double asimov_nll_cond = asimov_nll->getVal();
mu->setVal(1);
if (doInj) ws->loadSnapshot("conditionalNuis_inj");
else ws->loadSnapshot("conditionalNuis_1");
if (doInj) mu->setConstant(0);
status = minimize(asimov_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(asimov_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double asimov_nll_min = asimov_nll->getVal();
asimov_q0 = 2*(asimov_nll_cond - asimov_nll_min);
if (doUncap && mu->getVal() < 0) asimov_q0 = -asimov_q0;
sign = int(asimov_q0 != 0 ? asimov_q0/fabs(asimov_q0) : 0);
med_sig = sign*sqrt(fabs(asimov_q0));
ws->loadSnapshot(nominalSnapshot);
}
if (doObs)
{
ws->loadSnapshot("conditionalNuis_0");
mu->setVal(0);
mu->setConstant(1);
status = minimize(obs_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(obs_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double obs_nll_cond = obs_nll->getVal();
mu->setConstant(0);
status = minimize(obs_nll, ws);
if (status < 0)
{
cout << "Retrying with conditional snapshot at mu=1" << endl;
ws->loadSnapshot("conditionalNuis_0");
status = minimize(obs_nll, ws);
if (status >= 0) cout << "Success!" << endl;
}
double obs_nll_min = obs_nll->getVal();
obs_q0 = 2*(obs_nll_cond - obs_nll_min);
if (doUncap && mu->getVal() < 0) obs_q0 = -obs_q0;
sign = int(obs_q0 == 0 ? 0 : obs_q0 / fabs(obs_q0));
if (!doUncap && (obs_q0 < 0 && obs_q0 > -0.1 || mu->getVal() < 0.001)) obs_sig = 0;
else obs_sig = sign*sqrt(fabs(obs_q0));
}
// Report results
cout << "obs: " << obs_sig << endl;
cout << "Observed significance: " << obs_sig << endl;
cout << "Corresponding to a p-value of " << (1-ROOT::Math::gaussian_cdf( obs_sig )) << endl;
if (med_sig)
{
cout << "Median test stat val: " << asimov_q0 << endl;
cout << "Median significance: " << med_sig << endl;
}
f.Close();
stringstream fileName;
fileName << "root-files/" << folder << "/" << mass << ".root";
system(("mkdir -vp root-files/" + folder).c_str());
TFile f2(fileName.str().c_str(),"recreate");
TH1D* h_hypo = new TH1D("hypo","hypo",2,0,2);
h_hypo->SetBinContent(1, obs_sig);
h_hypo->SetBinContent(2, med_sig);
f2.Write();
f2.Close();
timer.Stop();
timer.Print();
}
void StandardBayesianNumericalDemo(const char* infile = "",
const char* workspaceName = "combined",
const char* modelConfigName = "ModelConfig",
const char* dataName = "obsData") {
// option definitions
double confLevel = optBayes.confLevel;
TString integrationType = optBayes.integrationType;
int nToys = optBayes.nToys;
bool scanPosterior = optBayes.scanPosterior;
int nScanPoints = optBayes.nScanPoints;
int intervalType = optBayes.intervalType;
int maxPOI = optBayes.maxPOI;
double nSigmaNuisance = optBayes.nSigmaNuisance;
/////////////////////////////////////////////////////////////
// First part is just to access a user-defined file
// or create the standard example file if it doesn't exist
////////////////////////////////////////////////////////////
const char* filename = "";
if (!strcmp(infile,"")) {
filename = "results/example_combined_GaussExample_model.root";
bool fileExist = !gSystem->AccessPathName(filename); // note opposite return code
// if file does not exists generate with histfactory
if (!fileExist) {
#ifdef _WIN32
cout << "HistFactory file cannot be generated on Windows - exit" << endl;
return;
#endif
// Normally this would be run on the command line
cout <<"will run standard hist2workspace example"<<endl;
gROOT->ProcessLine(".! prepareHistFactory .");
gROOT->ProcessLine(".! hist2workspace config/example.xml");
cout <<"\n\n---------------------"<<endl;
cout <<"Done creating example input"<<endl;
cout <<"---------------------\n\n"<<endl;
}
}
else
filename = infile;
// Try to open the file
TFile *file = TFile::Open(filename);
// if input file was specified byt not found, quit
if(!file ){
cout <<"StandardRooStatsDemoMacro: Input file " << filename << " is not found" << endl;
return;
}
/////////////////////////////////////////////////////////////
// Tutorial starts here
////////////////////////////////////////////////////////////
// get the workspace out of the file
RooWorkspace* w = (RooWorkspace*) file->Get(workspaceName);
if(!w){
cout <<"workspace not found" << endl;
return;
}
// get the modelConfig out of the file
ModelConfig* mc = (ModelConfig*) w->obj(modelConfigName);
// get the modelConfig out of the file
RooAbsData* data = w->data(dataName);
// make sure ingredients are found
if(!data || !mc){
w->Print();
cout << "data or ModelConfig was not found" <<endl;
return;
}
/////////////////////////////////////////////
// create and use the BayesianCalculator
// to find and plot the 95% credible interval
// on the parameter of interest as specified
// in the model config
// before we do that, we must specify our prior
// it belongs in the model config, but it may not have
// been specified
RooUniform prior("prior","",*mc->GetParametersOfInterest());
w->import(prior);
mc->SetPriorPdf(*w->pdf("prior"));
// do without systematics
//mc->SetNuisanceParameters(RooArgSet() );
if (nSigmaNuisance > 0) {
RooAbsPdf * pdf = mc->GetPdf();
assert(pdf);
RooFitResult * res = pdf->fitTo(*data, Save(true), Minimizer(ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_str()), Hesse(true),
PrintLevel(ROOT::Math::MinimizerOptions::DefaultPrintLevel()-1) );
res->Print();
RooArgList nuisPar(*mc->GetNuisanceParameters());
for (int i = 0; i < nuisPar.getSize(); ++i) {
RooRealVar * v = dynamic_cast<RooRealVar*> (&nuisPar[i] );
assert( v);
v->setMin( TMath::Max( v->getMin(), v->getVal() - nSigmaNuisance * v->getError() ) );
v->setMax( TMath::Min( v->getMax(), v->getVal() + nSigmaNuisance * v->getError() ) );
std::cout << "setting interval for nuisance " << v->GetName() << " : [ " << v->getMin() << " , " << v->getMax() << " ]" << std::endl;
}
}
BayesianCalculator bayesianCalc(*data,*mc);
bayesianCalc.SetConfidenceLevel(confLevel); // 95% interval
// default of the calculator is central interval. here use shortest , central or upper limit depending on input
// doing a shortest interval might require a longer time since it requires a scan of the posterior function
if (intervalType == 0) bayesianCalc.SetShortestInterval(); // for shortest interval
if (intervalType == 1) bayesianCalc.SetLeftSideTailFraction(0.5); // for central interval
if (intervalType == 2) bayesianCalc.SetLeftSideTailFraction(0.); // for upper limit
if (!integrationType.IsNull() ) {
bayesianCalc.SetIntegrationType(integrationType); // set integrationType
bayesianCalc.SetNumIters(nToys); // set number of ietrations (i.e. number of toys for MC integrations)
}
// in case of toyMC make a nnuisance pdf
if (integrationType.Contains("TOYMC") ) {
RooAbsPdf * nuisPdf = RooStats::MakeNuisancePdf(*mc, "nuisance_pdf");
cout << "using TOYMC integration: make nuisance pdf from the model " << std::endl;
nuisPdf->Print();
bayesianCalc.ForceNuisancePdf(*nuisPdf);
scanPosterior = true; // for ToyMC the posterior is scanned anyway so used given points
}
// compute interval by scanning the posterior function
if (scanPosterior)
bayesianCalc.SetScanOfPosterior(nScanPoints);
RooRealVar* poi = (RooRealVar*) mc->GetParametersOfInterest()->first();
if (maxPOI != -999 && maxPOI > poi->getMin())
poi->setMax(maxPOI);
SimpleInterval* interval = bayesianCalc.GetInterval();
// print out the iterval on the first Parameter of Interest
cout << "\n>>>> RESULT : " << confLevel*100 << "% interval on " << poi->GetName()<<" is : ["<<
interval->LowerLimit() << ", "<<
interval->UpperLimit() <<"] "<<endl;
// make a plot
// since plotting may take a long time (it requires evaluating
// the posterior in many points) this command will speed up
// by reducing the number of points to plot - do 50
// ignore errors of PDF if is zero
RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::Ignore) ;
cout << "\nDrawing plot of posterior function....." << endl;
// always plot using numer of scan points
bayesianCalc.SetScanOfPosterior(nScanPoints);
RooPlot * plot = bayesianCalc.GetPosteriorPlot();
plot->Draw();
}
void setup(ModelConfig* mcInWs) {
RooAbsPdf* combPdf = mcInWs->GetPdf();
RooArgSet mc_obs = *mcInWs->GetObservables();
RooArgSet mc_globs = *mcInWs->GetGlobalObservables();
RooArgSet mc_nuis = *mcInWs->GetNuisanceParameters();
// pair the nuisance parameter to the global observable
RooArgSet mc_nuis_tmp = mc_nuis;
RooArgList nui_list;
RooArgList glob_list;
RooArgSet constraint_set_tmp(*combPdf->getAllConstraints(mc_obs, mc_nuis_tmp, false));
RooArgSet constraint_set;
int counter_tmp = 0;
unfoldConstraints(constraint_set_tmp, constraint_set, mc_obs, mc_nuis_tmp, counter_tmp);
TIterator* cIter = constraint_set.createIterator();
RooAbsArg* arg;
while ((arg = (RooAbsArg*)cIter->Next())) {
RooAbsPdf* pdf = (RooAbsPdf*)arg;
if (!pdf) continue;
// pdf->Print();
TIterator* nIter = mc_nuis.createIterator();
RooRealVar* thisNui = NULL;
RooAbsArg* nui_arg;
while ((nui_arg = (RooAbsArg*)nIter->Next())) {
if (pdf->dependsOn(*nui_arg)) {
thisNui = (RooRealVar*)nui_arg;
break;
}
}
delete nIter;
// need this incase the observable isn't fundamental.
// in this case, see which variable is dependent on the nuisance parameter and use that.
RooArgSet* components = pdf->getComponents();
// components->Print();
components->remove(*pdf);
if (components->getSize()) {
TIterator* itr1 = components->createIterator();
RooAbsArg* arg1;
while ((arg1 = (RooAbsArg*)itr1->Next())) {
TIterator* itr2 = components->createIterator();
RooAbsArg* arg2;
while ((arg2 = (RooAbsArg*)itr2->Next())) {
if (arg1 == arg2) continue;
if (arg2->dependsOn(*arg1)) {
components->remove(*arg1);
}
}
delete itr2;
}
delete itr1;
}
if (components->getSize() > 1) {
cout << "ERROR::Couldn't isolate proper nuisance parameter" << endl;
return;
}
else if (components->getSize() == 1) {
thisNui = (RooRealVar*)components->first();
}
TIterator* gIter = mc_globs.createIterator();
RooRealVar* thisGlob = NULL;
RooAbsArg* glob_arg;
while ((glob_arg = (RooAbsArg*)gIter->Next())) {
if (pdf->dependsOn(*glob_arg)) {
thisGlob = (RooRealVar*)glob_arg;
break;
}
}
delete gIter;
if (!thisNui || !thisGlob) {
cout << "WARNING::Couldn't find nui or glob for constraint: " << pdf->GetName() << endl;
//return;
continue;
}
// cout << "Pairing nui: " << thisNui->GetName() << ", with glob: " << thisGlob->GetName() << ", from constraint: " << pdf->GetName() << endl;
nui_list.add(*thisNui);
glob_list.add(*thisGlob);
if (string(pdf->ClassName()) == "RooPoisson") {
double minVal = max(0.0, thisGlob->getVal() - 8*sqrt(thisGlob->getVal()));
double maxVal = max(10.0, thisGlob->getVal() + 8*sqrt(thisGlob->getVal()));
thisNui->setRange(minVal, maxVal);
thisGlob->setRange(minVal, maxVal);
}
else if (string(pdf->ClassName()) == "RooGaussian") {
thisNui->setRange(-7, 7);
thisGlob->setRange(-10, 10);
}
// thisNui->Print();
// thisGlob->Print();
}
delete cIter;
}
void FitterUtilsSimultaneousExpOfPolyTimesX::initiateParams(int nGenSignalZeroGamma, int nGenSignalOneGamma, int nGenSignalTwoGamma,
RooRealVar& nKemu, RooRealVar& nSignal, RooRealVar& nPartReco,
RooRealVar& nComb, RooRealVar& fracZero, RooRealVar& fracOne,
RooRealVar& nJpsiLeak, bool constPartReco, RooRealVar const& fracPartRecoSigma,
RooRealVar& l1Kee, RooRealVar& l2Kee, RooRealVar& l3Kee, RooRealVar& l4Kee, RooRealVar& l5Kee,
RooRealVar& l1Kemu, RooRealVar& l2Kemu, RooRealVar& l3Kemu, RooRealVar& l4Kemu, RooRealVar& l5Kemu,
RooRealVar const& l1KeeGen, RooRealVar const& l2KeeGen, RooRealVar const& l3KeeGen, RooRealVar const& l4KeeGen, RooRealVar const& l5KeeGen
)
{
FitterUtilsExpOfPolyTimesX::initiateParams(nGenSignalZeroGamma, nGenSignalOneGamma, nGenSignalTwoGamma,
nSignal, nPartReco, nComb, fracZero, fracOne, nJpsiLeak, constPartReco, fracPartRecoSigma,
l1Kee, l2Kee, l3Kee, l4Kee, l5Kee,
l1KeeGen, l2KeeGen, l3KeeGen, l4KeeGen, l5KeeGen );
TRandom rand;
rand.SetSeed();
nKemu.setVal(rand.Uniform(nGenKemu-5*sqrt(nGenKemu), nGenKemu+5*sqrt(nGenKemu)));
nKemu.setRange(nGenKemu-10*sqrt(nGenKemu), nGenKemu+10*sqrt(nGenKemu));
l1Kemu.setVal(rand.Uniform( l1KeeGen.getVal() - 5*l1KeeGen.getError(), l1KeeGen.getVal() + 5*l1KeeGen.getError() ) );
l1Kemu.setRange( l1KeeGen.getVal() - 10*l1KeeGen.getError(), l1KeeGen.getVal() + 10*l1KeeGen.getError() );
l2Kemu.setVal(rand.Uniform( l2KeeGen.getVal() - 5*l2KeeGen.getError(), l2KeeGen.getVal() + 5*l2KeeGen.getError() ) );
l2Kemu.setRange( l2KeeGen.getVal() - 10*l2KeeGen.getError(), l2KeeGen.getVal() + 10*l2KeeGen.getError() );
l3Kemu.setVal(rand.Uniform( l3KeeGen.getVal() - 5*l3KeeGen.getError(), l3KeeGen.getVal() + 5*l3KeeGen.getError() ) );
l3Kemu.setRange( l3KeeGen.getVal() - 10*l3KeeGen.getError(), l3KeeGen.getVal() + 10*l3KeeGen.getError() );
l4Kemu.setVal(rand.Uniform( l4KeeGen.getVal() - 5*l4KeeGen.getError(), l4KeeGen.getVal() + 5*l4KeeGen.getError() ) );
l4Kemu.setRange( l4KeeGen.getVal() - 10*l4KeeGen.getError(), l4KeeGen.getVal() + 10*l4KeeGen.getError() );
l5Kemu.setVal(rand.Uniform( l5KeeGen.getVal() - 5*l5KeeGen.getError(), l5KeeGen.getVal() + 5*l5KeeGen.getError() ) );
l5Kemu.setRange( l5KeeGen.getVal() - 10*l5KeeGen.getError(), l5KeeGen.getVal() + 10*l5KeeGen.getError() );
}
// internal routine to run the inverter
HypoTestInverterResult *
RooStats::HypoTestInvTool::RunInverter(RooWorkspace * w,
const char * modelSBName, const char * modelBName,
const char * dataName, int type, int testStatType,
bool useCLs, int npoints, double poimin, double poimax,
int ntoys,
bool useNumberCounting,
const char * nuisPriorName ){
std::cout << "Running HypoTestInverter on the workspace " << w->GetName() << std::endl;
w->Print();
RooAbsData * data = w->data(dataName);
if (!data) {
Error("StandardHypoTestDemo","Not existing data %s",dataName);
return 0;
}
else
std::cout << "Using data set " << dataName << std::endl;
if (mUseVectorStore) {
RooAbsData::setDefaultStorageType(RooAbsData::Vector);
data->convertToVectorStore() ;
}
// get models from WS
// get the modelConfig out of the file
ModelConfig* bModel = (ModelConfig*) w->obj(modelBName);
ModelConfig* sbModel = (ModelConfig*) w->obj(modelSBName);
if (!sbModel) {
Error("StandardHypoTestDemo","Not existing ModelConfig %s",modelSBName);
return 0;
}
// check the model
if (!sbModel->GetPdf()) {
Error("StandardHypoTestDemo","Model %s has no pdf ",modelSBName);
return 0;
}
if (!sbModel->GetParametersOfInterest()) {
Error("StandardHypoTestDemo","Model %s has no poi ",modelSBName);
return 0;
}
if (!sbModel->GetObservables()) {
Error("StandardHypoTestInvDemo","Model %s has no observables ",modelSBName);
return 0;
}
if (!sbModel->GetSnapshot() ) {
Info("StandardHypoTestInvDemo","Model %s has no snapshot - make one using model poi",modelSBName);
sbModel->SetSnapshot( *sbModel->GetParametersOfInterest() );
}
// case of no systematics
// remove nuisance parameters from model
if (noSystematics) {
const RooArgSet * nuisPar = sbModel->GetNuisanceParameters();
if (nuisPar && nuisPar->getSize() > 0) {
std::cout << "StandardHypoTestInvDemo" << " - Switch off all systematics by setting them constant to their initial values" << std::endl;
RooStats::SetAllConstant(*nuisPar);
}
if (bModel) {
const RooArgSet * bnuisPar = bModel->GetNuisanceParameters();
if (bnuisPar)
RooStats::SetAllConstant(*bnuisPar);
}
}
if (!bModel || bModel == sbModel) {
Info("StandardHypoTestInvDemo","The background model %s does not exist",modelBName);
Info("StandardHypoTestInvDemo","Copy it from ModelConfig %s and set POI to zero",modelSBName);
bModel = (ModelConfig*) sbModel->Clone();
bModel->SetName(TString(modelSBName)+TString("_with_poi_0"));
RooRealVar * var = dynamic_cast<RooRealVar*>(bModel->GetParametersOfInterest()->first());
if (!var) return 0;
double oldval = var->getVal();
var->setVal(0);
bModel->SetSnapshot( RooArgSet(*var) );
var->setVal(oldval);
}
else {
if (!bModel->GetSnapshot() ) {
Info("StandardHypoTestInvDemo","Model %s has no snapshot - make one using model poi and 0 values ",modelBName);
RooRealVar * var = dynamic_cast<RooRealVar*>(bModel->GetParametersOfInterest()->first());
if (var) {
double oldval = var->getVal();
var->setVal(0);
bModel->SetSnapshot( RooArgSet(*var) );
var->setVal(oldval);
}
else {
Error("StandardHypoTestInvDemo","Model %s has no valid poi",modelBName);
return 0;
}
}
}
// check model has global observables when there are nuisance pdf
// for the hybrid case the globobs are not needed
if (type != 1 ) {
bool hasNuisParam = (sbModel->GetNuisanceParameters() && sbModel->GetNuisanceParameters()->getSize() > 0);
bool hasGlobalObs = (sbModel->GetGlobalObservables() && sbModel->GetGlobalObservables()->getSize() > 0);
if (hasNuisParam && !hasGlobalObs ) {
// try to see if model has nuisance parameters first
RooAbsPdf * constrPdf = RooStats::MakeNuisancePdf(*sbModel,"nuisanceConstraintPdf_sbmodel");
if (constrPdf) {
Warning("StandardHypoTestInvDemo","Model %s has nuisance parameters but no global observables associated",sbModel->GetName());
Warning("StandardHypoTestInvDemo","\tThe effect of the nuisance parameters will not be treated correctly ");
}
}
}
// run first a data fit
const RooArgSet * poiSet = sbModel->GetParametersOfInterest();
RooRealVar *poi = (RooRealVar*)poiSet->first();
std::cout << "StandardHypoTestInvDemo : POI initial value: " << poi->GetName() << " = " << poi->getVal() << std::endl;
// fit the data first (need to use constraint )
TStopwatch tw;
bool doFit = initialFit;
if (testStatType == 0 && initialFit == -1) doFit = false; // case of LEP test statistic
if (type == 3 && initialFit == -1) doFit = false; // case of Asymptoticcalculator with nominal Asimov
double poihat = 0;
if (minimizerType.size()==0) minimizerType = ROOT::Math::MinimizerOptions::DefaultMinimizerType();
else
ROOT::Math::MinimizerOptions::SetDefaultMinimizer(minimizerType.c_str());
Info("StandardHypoTestInvDemo","Using %s as minimizer for computing the test statistic",
ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_str() );
if (doFit) {
// do the fit : By doing a fit the POI snapshot (for S+B) is set to the fit value
// and the nuisance parameters nominal values will be set to the fit value.
// This is relevant when using LEP test statistics
Info( "StandardHypoTestInvDemo"," Doing a first fit to the observed data ");
RooArgSet constrainParams;
if (sbModel->GetNuisanceParameters() ) constrainParams.add(*sbModel->GetNuisanceParameters());
RooStats::RemoveConstantParameters(&constrainParams);
tw.Start();
RooFitResult * fitres = sbModel->GetPdf()->fitTo(*data,InitialHesse(false), Hesse(false),
Minimizer(minimizerType.c_str(),"Migrad"), Strategy(0), PrintLevel(mPrintLevel), Constrain(constrainParams), Save(true) );
if (fitres->status() != 0) {
Warning("StandardHypoTestInvDemo","Fit to the model failed - try with strategy 1 and perform first an Hesse computation");
fitres = sbModel->GetPdf()->fitTo(*data,InitialHesse(true), Hesse(false),Minimizer(minimizerType.c_str(),"Migrad"), Strategy(1), PrintLevel(mPrintLevel+1), Constrain(constrainParams), Save(true) );
}
if (fitres->status() != 0)
Warning("StandardHypoTestInvDemo"," Fit still failed - continue anyway.....");
poihat = poi->getVal();
std::cout << "StandardHypoTestInvDemo - Best Fit value : " << poi->GetName() << " = "
<< poihat << " +/- " << poi->getError() << std::endl;
std::cout << "Time for fitting : "; tw.Print();
//save best fit value in the poi snapshot
sbModel->SetSnapshot(*sbModel->GetParametersOfInterest());
std::cout << "StandardHypoTestInvo: snapshot of S+B Model " << sbModel->GetName()
<< " is set to the best fit value" << std::endl;
}
// print a message in case of LEP test statistics because it affects result by doing or not doing a fit
if (testStatType == 0) {
if (!doFit)
Info("StandardHypoTestInvDemo","Using LEP test statistic - an initial fit is not done and the TS will use the nuisances at the model value");
else
Info("StandardHypoTestInvDemo","Using LEP test statistic - an initial fit has been done and the TS will use the nuisances at the best fit value");
}
// build test statistics and hypotest calculators for running the inverter
SimpleLikelihoodRatioTestStat slrts(*sbModel->GetPdf(),*bModel->GetPdf());
// null parameters must includes snapshot of poi plus the nuisance values
RooArgSet nullParams(*sbModel->GetSnapshot());
if (sbModel->GetNuisanceParameters()) nullParams.add(*sbModel->GetNuisanceParameters());
if (sbModel->GetSnapshot()) slrts.SetNullParameters(nullParams);
RooArgSet altParams(*bModel->GetSnapshot());
if (bModel->GetNuisanceParameters()) altParams.add(*bModel->GetNuisanceParameters());
if (bModel->GetSnapshot()) slrts.SetAltParameters(altParams);
// ratio of profile likelihood - need to pass snapshot for the alt
RatioOfProfiledLikelihoodsTestStat
ropl(*sbModel->GetPdf(), *bModel->GetPdf(), bModel->GetSnapshot());
ropl.SetSubtractMLE(false);
if (testStatType == 11) ropl.SetSubtractMLE(true);
ropl.SetPrintLevel(mPrintLevel);
ropl.SetMinimizer(minimizerType.c_str());
ProfileLikelihoodTestStat profll(*sbModel->GetPdf());
if (testStatType == 3) profll.SetOneSided(true);
if (testStatType == 4) profll.SetSigned(true);
profll.SetMinimizer(minimizerType.c_str());
profll.SetPrintLevel(mPrintLevel);
profll.SetReuseNLL(mOptimize);
slrts.SetReuseNLL(mOptimize);
ropl.SetReuseNLL(mOptimize);
if (mOptimize) {
profll.SetStrategy(0);
ropl.SetStrategy(0);
ROOT::Math::MinimizerOptions::SetDefaultStrategy(0);
}
if (mMaxPoi > 0) poi->setMax(mMaxPoi); // increase limit
MaxLikelihoodEstimateTestStat maxll(*sbModel->GetPdf(),*poi);
NumEventsTestStat nevtts;
AsymptoticCalculator::SetPrintLevel(mPrintLevel);
// create the HypoTest calculator class
HypoTestCalculatorGeneric * hc = 0;
if (type == 0) hc = new FrequentistCalculator(*data, *bModel, *sbModel);
else if (type == 1) hc = new HybridCalculator(*data, *bModel, *sbModel);
// else if (type == 2 ) hc = new AsymptoticCalculator(*data, *bModel, *sbModel, false, mAsimovBins);
// else if (type == 3 ) hc = new AsymptoticCalculator(*data, *bModel, *sbModel, true, mAsimovBins); // for using Asimov data generated with nominal values
else if (type == 2 ) hc = new AsymptoticCalculator(*data, *bModel, *sbModel, false );
else if (type == 3 ) hc = new AsymptoticCalculator(*data, *bModel, *sbModel, true ); // for using Asimov data generated with nominal values
else {
Error("StandardHypoTestInvDemo","Invalid - calculator type = %d supported values are only :\n\t\t\t 0 (Frequentist) , 1 (Hybrid) , 2 (Asymptotic) ",type);
return 0;
}
// set the test statistic
TestStatistic * testStat = 0;
if (testStatType == 0) testStat = &slrts;
if (testStatType == 1 || testStatType == 11) testStat = &ropl;
if (testStatType == 2 || testStatType == 3 || testStatType == 4) testStat = &profll;
if (testStatType == 5) testStat = &maxll;
if (testStatType == 6) testStat = &nevtts;
if (testStat == 0) {
Error("StandardHypoTestInvDemo","Invalid - test statistic type = %d supported values are only :\n\t\t\t 0 (SLR) , 1 (Tevatron) , 2 (PLR), 3 (PLR1), 4(MLE)",testStatType);
return 0;
}
ToyMCSampler *toymcs = (ToyMCSampler*)hc->GetTestStatSampler();
if (toymcs && (type == 0 || type == 1) ) {
// look if pdf is number counting or extended
if (sbModel->GetPdf()->canBeExtended() ) {
if (useNumberCounting) Warning("StandardHypoTestInvDemo","Pdf is extended: but number counting flag is set: ignore it ");
}
else {
// for not extended pdf
if (!useNumberCounting ) {
int nEvents = data->numEntries();
Info("StandardHypoTestInvDemo","Pdf is not extended: number of events to generate taken from observed data set is %d",nEvents);
toymcs->SetNEventsPerToy(nEvents);
}
else {
Info("StandardHypoTestInvDemo","using a number counting pdf");
toymcs->SetNEventsPerToy(1);
}
}
toymcs->SetTestStatistic(testStat);
if (data->isWeighted() && !mGenerateBinned) {
Info("StandardHypoTestInvDemo","Data set is weighted, nentries = %d and sum of weights = %8.1f but toy generation is unbinned - it would be faster to set mGenerateBinned to true\n",data->numEntries(), data->sumEntries());
}
toymcs->SetGenerateBinned(mGenerateBinned);
toymcs->SetUseMultiGen(mOptimize);
if (mGenerateBinned && sbModel->GetObservables()->getSize() > 2) {
Warning("StandardHypoTestInvDemo","generate binned is activated but the number of ovservable is %d. Too much memory could be needed for allocating all the bins",sbModel->GetObservables()->getSize() );
}
// set the random seed if needed
if (mRandomSeed >= 0) RooRandom::randomGenerator()->SetSeed(mRandomSeed);
}
// specify if need to re-use same toys
if (reuseAltToys) {
hc->UseSameAltToys();
}
if (type == 1) {
HybridCalculator *hhc = dynamic_cast<HybridCalculator*> (hc);
assert(hhc);
hhc->SetToys(ntoys,ntoys/mNToysRatio); // can use less ntoys for b hypothesis
// remove global observables from ModelConfig (this is probably not needed anymore in 5.32)
bModel->SetGlobalObservables(RooArgSet() );
sbModel->SetGlobalObservables(RooArgSet() );
// check for nuisance prior pdf in case of nuisance parameters
if (bModel->GetNuisanceParameters() || sbModel->GetNuisanceParameters() ) {
// fix for using multigen (does not work in this case)
toymcs->SetUseMultiGen(false);
ToyMCSampler::SetAlwaysUseMultiGen(false);
RooAbsPdf * nuisPdf = 0;
if (nuisPriorName) nuisPdf = w->pdf(nuisPriorName);
// use prior defined first in bModel (then in SbModel)
if (!nuisPdf) {
Info("StandardHypoTestInvDemo","No nuisance pdf given for the HybridCalculator - try to deduce pdf from the model");
if (bModel->GetPdf() && bModel->GetObservables() )
nuisPdf = RooStats::MakeNuisancePdf(*bModel,"nuisancePdf_bmodel");
else
nuisPdf = RooStats::MakeNuisancePdf(*sbModel,"nuisancePdf_sbmodel");
}
if (!nuisPdf ) {
if (bModel->GetPriorPdf()) {
nuisPdf = bModel->GetPriorPdf();
Info("StandardHypoTestInvDemo","No nuisance pdf given - try to use %s that is defined as a prior pdf in the B model",nuisPdf->GetName());
}
else {
Error("StandardHypoTestInvDemo","Cannnot run Hybrid calculator because no prior on the nuisance parameter is specified or can be derived");
return 0;
}
}
assert(nuisPdf);
Info("StandardHypoTestInvDemo","Using as nuisance Pdf ... " );
nuisPdf->Print();
const RooArgSet * nuisParams = (bModel->GetNuisanceParameters() ) ? bModel->GetNuisanceParameters() : sbModel->GetNuisanceParameters();
RooArgSet * np = nuisPdf->getObservables(*nuisParams);
if (np->getSize() == 0) {
Warning("StandardHypoTestInvDemo","Prior nuisance does not depend on nuisance parameters. They will be smeared in their full range");
}
delete np;
hhc->ForcePriorNuisanceAlt(*nuisPdf);
hhc->ForcePriorNuisanceNull(*nuisPdf);
}
}
else if (type == 2 || type == 3) {
if (testStatType == 3) ((AsymptoticCalculator*) hc)->SetOneSided(true);
if (testStatType != 2 && testStatType != 3)
Warning("StandardHypoTestInvDemo","Only the PL test statistic can be used with AsymptoticCalculator - use by default a two-sided PL");
}
else if (type == 0 || type == 1)
((FrequentistCalculator*) hc)->SetToys(ntoys,ntoys/mNToysRatio);
// Get the result
RooMsgService::instance().getStream(1).removeTopic(RooFit::NumIntegration);
HypoTestInverter calc(*hc);
calc.SetConfidenceLevel(0.95);
calc.UseCLs(useCLs);
calc.SetVerbose(true);
// can speed up using proof-lite
if (mUseProof && mNWorkers > 1) {
ProofConfig pc(*w, mNWorkers, "", kFALSE);
toymcs->SetProofConfig(&pc); // enable proof
}
if (npoints > 0) {
if (poimin > poimax) {
// if no min/max given scan between MLE and +4 sigma
poimin = int(poihat);
poimax = int(poihat + 4 * poi->getError());
}
std::cout << "Doing a fixed scan in interval : " << poimin << " , " << poimax << std::endl;
calc.SetFixedScan(npoints,poimin,poimax);
}
else {
//poi->setMax(10*int( (poihat+ 10 *poi->getError() )/10 ) );
std::cout << "Doing an automatic scan in interval : " << poi->getMin() << " , " << poi->getMax() << std::endl;
}
tw.Start();
HypoTestInverterResult * r = calc.GetInterval();
std::cout << "Time to perform limit scan \n";
tw.Print();
if (mRebuild) {
calc.SetCloseProof(1);
tw.Start();
SamplingDistribution * limDist = calc.GetUpperLimitDistribution(true,mNToyToRebuild);
std::cout << "Time to rebuild distributions " << std::endl;
tw.Print();
if (limDist) {
std::cout << "expected up limit " << limDist->InverseCDF(0.5) << " +/- "
<< limDist->InverseCDF(0.16) << " "
<< limDist->InverseCDF(0.84) << "\n";
//update r to a new updated result object containing the rebuilt expected p-values distributions
// (it will not recompute the expected limit)
if (r) delete r; // need to delete previous object since GetInterval will return a cloned copy
r = calc.GetInterval();
}
else
std::cout << "ERROR : failed to re-build distributions " << std::endl;
}
return r;
}
vector<Double_t*> simFit(bool makeSoupFit_ = false,
const string tnp_ = "etoTauMargLooseNoCracks70",
const string category_ = "tauAntiEMVA",
const string bin_ = "abseta<1.5",
const float binCenter_ = 0.75,
const float binWidth_ = 0.75,
const float xLow_=60,
const float xHigh_=120,
bool SumW2_ = false,
bool verbose_ = true){
vector<Double_t*> out;
//return out;
//TFile *test = new TFile( outFile->GetName(),"UPDATE");
// output file
TFile *test = new TFile( Form("EtoTauPlotsFit_%s_%s_%f.root",tnp_.c_str(),category_.c_str(),binCenter_),"RECREATE");
test->mkdir(Form("bin%f",binCenter_));
TCanvas *c = new TCanvas("fitCanvas",Form("fitCanvas_%s_%s",tnp_.c_str(),bin_.c_str()),10,30,650,600);
c->SetGrid(0,0);
c->SetFillStyle(4000);
c->SetFillColor(10);
c->SetTicky();
c->SetObjectStat(0);
TCanvas *c2 = new TCanvas("fitCanvasTemplate",Form("fitCanvasTemplate_%s_%s",tnp_.c_str(),bin_.c_str()),10,30,650,600);
c2->SetGrid(0,0);
c2->SetFillStyle(4000);
c2->SetFillColor(10);
c2->SetTicky();
c2->SetObjectStat(0);
// input files
TFile fsup("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_soup.root");
TFile fbkg("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_soup_bkg.root");
TFile fsgn("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_soup_sgn.root");
TFile fdat("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_Data.root");
// data from 2iter:
//TFile fdat("/data_CMS/cms/lbianchini/35pb/testNewWriteFromPAT_Data.root");
//********************** signal only tree *************************/
TTree *fullTreeSgn = (TTree*)fsgn.Get((tnp_+"/fitter_tree").c_str());
TH1F* hSall = new TH1F("hSall","",1,0,150);
TH1F* hSPall = new TH1F("hSPall","",1,0,150);
TH1F* hS = new TH1F("hS","",1,0,150);
TH1F* hSP = new TH1F("hSP","",1,0,150);
fullTreeSgn->Draw("mass>>hS",Form("weight*(%s && mass>%f && mass<%f && mcTrue && signalPFChargedHadrCands<1.5)",bin_.c_str(),xLow_,xHigh_));
fullTreeSgn->Draw("mass>>hSall",Form("weight*(%s && mass>%f && mass<%f)",bin_.c_str(),xLow_,xHigh_));
float SGNtrue = hS->Integral();
float SGNall = hSall->Integral();
fullTreeSgn->Draw("mass>>hSP",Form("weight*(%s && %s>0 && mass>%f && mass<%f && mcTrue && signalPFChargedHadrCands<1.5 )",bin_.c_str(),category_.c_str(),xLow_,xHigh_));
fullTreeSgn->Draw("mass>>hSPall",Form("weight*(%s && %s>0 && mass>%f && mass<%f && signalPFChargedHadrCands<1.5 )",bin_.c_str(),category_.c_str(),xLow_,xHigh_));
float SGNtruePass = hSP->Integral();
float SGNallPass = hSPall->Integral();
//********************** background only tree *************************//
TTree *fullTreeBkg = (TTree*)fbkg.Get((tnp_+"/fitter_tree").c_str());
TH1F* hB = new TH1F("hB","",1,0,150);
TH1F* hBP = new TH1F("hBP","",1,0,150);
fullTreeBkg->Draw("mass>>hB",Form("weight*(%s && mass>%f && mass<%f && signalPFChargedHadrCands<1.5 )",bin_.c_str(),xLow_,xHigh_));
float BKG = hB->Integral();
float BKGUnWeighted = hB->GetEntries();
fullTreeBkg->Draw("mass>>hBP",Form("weight*(%s && %s>0 && mass>%f && mass<%f && signalPFChargedHadrCands<1.5 )",bin_.c_str(),category_.c_str(),xLow_,xHigh_));
float BKGPass = hBP->Integral();
float BKGUnWeightedPass = hBP->GetEntries();
float BKGFail = BKG-BKGPass;
cout << "*********** BKGFail " << BKGFail << endl;
//********************** soup tree *************************//
TTree *fullTreeSoup = (TTree*)fsup.Get((tnp_+"/fitter_tree").c_str());
//********************** data tree *************************//
TTree *fullTreeData = (TTree*)fdat.Get((tnp_+"/fitter_tree").c_str());
//********************** workspace ***********************//
RooWorkspace *w = new RooWorkspace("w","w");
// tree variables to be imported
w->factory("mass[30,120]");
w->factory("weight[0,10000]");
w->factory("abseta[0,2.5]");
w->factory("pt[0,200]");
w->factory("mcTrue[0,1]");
w->factory("signalPFChargedHadrCands[0,10]");
w->factory((category_+"[0,1]").c_str());
// background pass pdf for MC
w->factory("RooExponential::McBackgroundPdfP(mass,McCP[0,-10,10])");
// background fail pdf for MC
w->factory("RooExponential::McBackgroundPdfF(mass,McCF[0,-10,10])");
// background pass pdf for Data
w->factory("RooExponential::DataBackgroundPdfP(mass,DataCP[0,-10,10])");
// background fail pdf for Data
w->factory("RooExponential::DataBackgroundPdfF(mass,DataCF[0,-10,10])");
// fit parameters for background
w->factory("McEfficiency[0.04,0,1]");
w->factory("McNumSgn[0,1000000]");
w->factory("McNumBkgP[0,100000]");
w->factory("McNumBkgF[0,100000]");
w->factory("expr::McNumSgnP('McEfficiency*McNumSgn',McEfficiency,McNumSgn)");
w->factory("expr::McNumSgnF('(1-McEfficiency)*McNumSgn',McEfficiency,McNumSgn)");
w->factory("McPassing[pass=1,fail=0]");
// fit parameters for data
w->factory("DataEfficiency[0.1,0,1]");
w->factory("DataNumSgn[0,1000000]");
w->factory("DataNumBkgP[0,1000000]");
w->factory("DataNumBkgF[0,10000]");
w->factory("expr::DataNumSgnP('DataEfficiency*DataNumSgn',DataEfficiency,DataNumSgn)");
w->factory("expr::DataNumSgnF('(1-DataEfficiency)*DataNumSgn',DataEfficiency,DataNumSgn)");
w->factory("DataPassing[pass=1,fail=0]");
RooRealVar *weight = w->var("weight");
RooRealVar *abseta = w->var("abseta");
RooRealVar *pt = w->var("pt");
RooRealVar *mass = w->var("mass");
mass->setRange(xLow_,xHigh_);
RooRealVar *mcTrue = w->var("mcTrue");
RooRealVar *cut = w->var( category_.c_str() );
RooRealVar *signalPFChargedHadrCands = w->var("signalPFChargedHadrCands");
// build the template for the signal pass sample:
RooDataSet templateP("templateP","dataset for signal-pass template", RooArgSet(*mass,*weight,*abseta,*pt,*cut,*mcTrue,*signalPFChargedHadrCands), Import( *fullTreeSgn ), /*WeightVar( *weight ),*/ Cut( Form("(mcTrue && %s>0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()) ) );
// build the template for the signal fail sample:
RooDataSet templateF("templateF","dataset for signal-fail template", RooArgSet(*mass,*weight,*abseta,*pt,*cut,*mcTrue,*signalPFChargedHadrCands), Import( *fullTreeSgn ), /*WeightVar( *weight ),*/ Cut( Form("(mcTrue && %s<0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()) ) );
mass->setBins(24);
RooDataHist templateHistP("templateHistP","",RooArgSet(*mass), templateP, 1.0);
RooHistPdf TemplateSignalPdfP("TemplateSignalPdfP","",RooArgSet(*mass),templateHistP);
w->import(TemplateSignalPdfP);
mass->setBins(24);
RooDataHist templateHistF("templateHistF","",RooArgSet(*mass),templateF,1.0);
RooHistPdf TemplateSignalPdfF("TemplateSignalPdfF","",RooArgSet(*mass),templateHistF);
w->import(TemplateSignalPdfF);
mass->setBins(10000,"fft");
RooPlot* TemplateFrameP = mass->frame(Bins(24),Title("Template passing"));
templateP.plotOn(TemplateFrameP);
w->pdf("TemplateSignalPdfP")->plotOn(TemplateFrameP);
RooPlot* TemplateFrameF = mass->frame(Bins(24),Title("Template failing"));
templateF.plotOn(TemplateFrameF);
w->pdf("TemplateSignalPdfF")->plotOn(TemplateFrameF);
//w->factory("RooFFTConvPdf::McSignalPdfP(mass,TemplateSignalPdfP,RooTruthModel::McResolModP(mass))");
//w->factory("RooFFTConvPdf::McSignalPdfF(mass,TemplateSignalPdfF,RooTruthModel::McResolModF(mass))");
// FOR GREGORY: PROBLEM WHEN TRY TO USE THE PURE TEMPLATE =>
RooHistPdf McSignalPdfP("McSignalPdfP","McSignalPdfP",RooArgSet(*mass),templateHistP);
RooHistPdf McSignalPdfF("McSignalPdfF","McSignalPdfF",RooArgSet(*mass),templateHistF);
w->import(McSignalPdfP);
w->import(McSignalPdfF);
// FOR GREGORY: FOR DATA, CONVOLUTION IS OK =>
w->factory("RooFFTConvPdf::DataSignalPdfP(mass,TemplateSignalPdfP,RooGaussian::DataResolModP(mass,DataMeanResP[0.0,-5.,5.],DataSigmaResP[0.5,0.,10]))");
w->factory("RooFFTConvPdf::DataSignalPdfF(mass,TemplateSignalPdfF,RooGaussian::DataResolModF(mass,DataMeanResF[-5.,-10.,10.],DataSigmaResF[0.5,0.,10]))");
//w->factory("RooCBShape::DataSignalPdfF(mass,DataMeanF[91.2,88,95.],DataSigmaF[3,0.5,8],DataAlfaF[1.8,0.,10],DataNF[1.0,1e-06,10])");
//w->factory("RooFFTConvPdf::DataSignalPdfF(mass,RooVoigtian::DataVoigF(mass,DataMeanF[85,80,95],DataWidthF[2.49],DataSigmaF[3,0.5,10]),RooCBShape::DataResolModF(mass,DataMeanResF[0.5,0.,10.],DataSigmaResF[0.5,0.,10],DataAlphaResF[0.5,0.,10],DataNResF[1.0,1e-06,10]))");
//w->factory("SUM::DataSignalPdfF(fVBP[0.5,0,1]*RooBifurGauss::bifF(mass,DataMeanResF[91.2,80,95],sigmaLF[10,0.5,40],sigmaRF[0.]), RooVoigtian::voigF(mass, DataMeanResF, widthF[2.49], sigmaVoigF[5,0.1,10]) )" );
// composite model pass for MC
w->factory("SUM::McModelP(McNumSgnP*McSignalPdfP,McNumBkgP*McBackgroundPdfP)");
w->factory("SUM::McModelF(McNumSgnF*McSignalPdfF,McNumBkgF*McBackgroundPdfF)");
// composite model pass for data
w->factory("SUM::DataModelP(DataNumSgnP*DataSignalPdfP,DataNumBkgP*DataBackgroundPdfP)");
w->factory("SUM::DataModelF(DataNumSgnF*DataSignalPdfF,DataNumBkgF*DataBackgroundPdfF)");
// simultaneous fir for MC
w->factory("SIMUL::McModel(McPassing,pass=McModelP,fail=McModelF)");
// simultaneous fir for data
w->factory("SIMUL::DataModel(DataPassing,pass=DataModelP,fail=DataModelF)");
w->Print("V");
w->saveSnapshot("clean", w->allVars());
w->loadSnapshot("clean");
/****************** sim fit to soup **************************/
///////////////////////////////////////////////////////////////
TFile *f = new TFile("dummySoup.root","RECREATE");
TTree* cutTreeSoupP = fullTreeSoup->CopyTree(Form("(%s>0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()));
TTree* cutTreeSoupF = fullTreeSoup->CopyTree(Form("(%s<0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()));
RooDataSet McDataP("McDataP","dataset pass for the soup", RooArgSet(*mass), Import( *cutTreeSoupP ) );
RooDataSet McDataF("McDataF","dataset fail for the soup", RooArgSet(*mass), Import( *cutTreeSoupF ) );
RooDataHist McCombData("McCombData","combined data for the soup", RooArgSet(*mass), Index(*(w->cat("McPassing"))), Import("pass", *(McDataP.createHistogram("histoP",*mass)) ), Import("fail",*(McDataF.createHistogram("histoF",*mass)) ) ) ;
RooPlot* McFrameP = 0;
RooPlot* McFrameF = 0;
RooRealVar* McEffFit = 0;
if(makeSoupFit_){
cout << "**************** N bins in mass " << w->var("mass")->getBins() << endl;
RooFitResult* ResMcCombinedFit = w->pdf("McModel")->fitTo(McCombData, Extended(1), Minos(1), Save(1), SumW2Error( SumW2_ ), Range(xLow_,xHigh_), NumCPU(4) /*, ExternalConstraints( *(w->pdf("ConstrainMcNumBkgF")) )*/ );
test->cd(Form("bin%f",binCenter_));
ResMcCombinedFit->Write("McFitResults_Combined");
RooArgSet McFitParam(ResMcCombinedFit->floatParsFinal());
McEffFit = (RooRealVar*)(&McFitParam["McEfficiency"]);
RooRealVar* McNumSigFit = (RooRealVar*)(&McFitParam["McNumSgn"]);
RooRealVar* McNumBkgPFit = (RooRealVar*)(&McFitParam["McNumBkgP"]);
RooRealVar* McNumBkgFFit = (RooRealVar*)(&McFitParam["McNumBkgF"]);
McFrameP = mass->frame(Bins(24),Title("MC: passing sample"));
McCombData.plotOn(McFrameP,Cut("McPassing==McPassing::pass"));
w->pdf("McModel")->plotOn(McFrameP,Slice(*(w->cat("McPassing")),"pass"), ProjWData(*(w->cat("McPassing")),McCombData), LineColor(kBlue),Range(xLow_,xHigh_));
w->pdf("McModel")->plotOn(McFrameP,Slice(*(w->cat("McPassing")),"pass"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McSignalPdfP"), LineColor(kRed),Range(xLow_,xHigh_));
w->pdf("McModel")->plotOn(McFrameP,Slice(*(w->cat("McPassing")),"pass"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McBackgroundPdfP"), LineColor(kGreen),Range(xLow_,xHigh_));
McFrameF = mass->frame(Bins(24),Title("MC: failing sample"));
McCombData.plotOn(McFrameF,Cut("McPassing==McPassing::fail"));
w->pdf("McModel")->plotOn(McFrameF,Slice(*(w->cat("McPassing")),"fail"), ProjWData(*(w->cat("McPassing")),McCombData), LineColor(kBlue),Range(xLow_,xHigh_));
w->pdf("McModel")->plotOn(McFrameF,Slice(*(w->cat("McPassing")),"fail"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McSignalPdfF"), LineColor(kRed),Range(xLow_,xHigh_));
w->pdf("McModel")->plotOn(McFrameF,Slice(*(w->cat("McPassing")),"fail"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McBackgroundPdfF"), LineColor(kGreen),Range(xLow_,xHigh_));
}
///////////////////////////////////////////////////////////////
/****************** sim fit to data **************************/
///////////////////////////////////////////////////////////////
TFile *f2 = new TFile("dummyData.root","RECREATE");
TTree* cutTreeDataP = fullTreeData->CopyTree(Form("(%s>0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()));
TTree* cutTreeDataF = fullTreeData->CopyTree(Form("(%s<0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()));
RooDataSet DataDataP("DataDataP","dataset pass for the soup", RooArgSet(*mass), Import( *cutTreeDataP ) );
RooDataSet DataDataF("DataDataF","dataset fail for the soup", RooArgSet(*mass), Import( *cutTreeDataF ) );
RooDataHist DataCombData("DataCombData","combined data for the soup", RooArgSet(*mass), Index(*(w->cat("DataPassing"))), Import("pass",*(DataDataP.createHistogram("histoDataP",*mass))),Import("fail",*(DataDataF.createHistogram("histoDataF",*mass)))) ;
RooFitResult* ResDataCombinedFit = w->pdf("DataModel")->fitTo(DataCombData, Extended(1), Minos(1), Save(1), SumW2Error( SumW2_ ), Range(xLow_,xHigh_), NumCPU(4));
test->cd(Form("bin%f",binCenter_));
ResDataCombinedFit->Write("DataFitResults_Combined");
RooArgSet DataFitParam(ResDataCombinedFit->floatParsFinal());
RooRealVar* DataEffFit = (RooRealVar*)(&DataFitParam["DataEfficiency"]);
RooRealVar* DataNumSigFit = (RooRealVar*)(&DataFitParam["DataNumSgn"]);
RooRealVar* DataNumBkgPFit = (RooRealVar*)(&DataFitParam["DataNumBkgP"]);
RooRealVar* DataNumBkgFFit = (RooRealVar*)(&DataFitParam["DataNumBkgF"]);
RooPlot* DataFrameP = mass->frame(Bins(24),Title("Data: passing sample"));
DataCombData.plotOn(DataFrameP,Cut("DataPassing==DataPassing::pass"));
w->pdf("DataModel")->plotOn(DataFrameP,Slice(*(w->cat("DataPassing")),"pass"), ProjWData(*(w->cat("DataPassing")),DataCombData), LineColor(kBlue),Range(xLow_,xHigh_));
w->pdf("DataModel")->plotOn(DataFrameP,Slice(*(w->cat("DataPassing")),"pass"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataSignalPdfP"), LineColor(kRed),Range(xLow_,xHigh_));
w->pdf("DataModel")->plotOn(DataFrameP,Slice(*(w->cat("DataPassing")),"pass"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataBackgroundPdfP"), LineColor(kGreen),LineStyle(kDashed),Range(xLow_,xHigh_));
RooPlot* DataFrameF = mass->frame(Bins(24),Title("Data: failing sample"));
DataCombData.plotOn(DataFrameF,Cut("DataPassing==DataPassing::fail"));
w->pdf("DataModel")->plotOn(DataFrameF,Slice(*(w->cat("DataPassing")),"fail"), ProjWData(*(w->cat("DataPassing")),DataCombData), LineColor(kBlue),Range(xLow_,xHigh_));
w->pdf("DataModel")->plotOn(DataFrameF,Slice(*(w->cat("DataPassing")),"fail"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataSignalPdfF"), LineColor(kRed),Range(xLow_,xHigh_));
w->pdf("DataModel")->plotOn(DataFrameF,Slice(*(w->cat("DataPassing")),"fail"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataBackgroundPdfF"), LineColor(kGreen),LineStyle(kDashed),Range(xLow_,xHigh_));
///////////////////////////////////////////////////////////////
if(makeSoupFit_) c->Divide(2,2);
else c->Divide(2,1);
c->cd(1);
DataFrameP->Draw();
c->cd(2);
DataFrameF->Draw();
if(makeSoupFit_){
c->cd(3);
McFrameP->Draw();
c->cd(4);
McFrameF->Draw();
}
c->Draw();
test->cd(Form("bin%f",binCenter_));
c->Write();
c2->Divide(2,1);
c2->cd(1);
TemplateFrameP->Draw();
c2->cd(2);
TemplateFrameF->Draw();
c2->Draw();
test->cd(Form("bin%f",binCenter_));
c2->Write();
// MINOS errors, otherwise HESSE quadratic errors
float McErrorLo = 0;
float McErrorHi = 0;
if(makeSoupFit_){
McErrorLo = McEffFit->getErrorLo()<0 ? McEffFit->getErrorLo() : (-1)*McEffFit->getError();
McErrorHi = McEffFit->getErrorHi()>0 ? McEffFit->getErrorHi() : McEffFit->getError();
}
float DataErrorLo = DataEffFit->getErrorLo()<0 ? DataEffFit->getErrorLo() : (-1)*DataEffFit->getError();
float DataErrorHi = DataEffFit->getErrorHi()>0 ? DataEffFit->getErrorHi() : DataEffFit->getError();
float BinomialError = TMath::Sqrt(SGNtruePass/SGNtrue*(1-SGNtruePass/SGNtrue)/SGNtrue);
Double_t* truthMC = new Double_t[6];
Double_t* tnpMC = new Double_t[6];
Double_t* tnpData = new Double_t[6];
truthMC[0] = binCenter_;
truthMC[1] = binWidth_;
truthMC[2] = binWidth_;
truthMC[3] = SGNtruePass/SGNtrue;
truthMC[4] = BinomialError;
truthMC[5] = BinomialError;
if(makeSoupFit_){
tnpMC[0] = binCenter_;
tnpMC[1] = binWidth_;
tnpMC[2] = binWidth_;
tnpMC[3] = McEffFit->getVal();
tnpMC[4] = (-1)*McErrorLo;
tnpMC[5] = McErrorHi;
}
tnpData[0] = binCenter_;
tnpData[1] = binWidth_;
tnpData[2] = binWidth_;
tnpData[3] = DataEffFit->getVal();
tnpData[4] = (-1)*DataErrorLo;
tnpData[5] = DataErrorHi;
out.push_back(truthMC);
out.push_back(tnpData);
if(makeSoupFit_) out.push_back(tnpMC);
test->Close();
//delete c; delete c2;
if(verbose_) cout << "returning from bin " << bin_ << endl;
return out;
}
void FitBias(TString CAT,TString CUT,float SIG,float BKG,int NTOYS)
{
gROOT->ForceStyle();
RooMsgService::instance().setSilentMode(kTRUE);
RooMsgService::instance().setStreamStatus(0,kFALSE);
RooMsgService::instance().setStreamStatus(1,kFALSE);
// -----------------------------------------
TFile *fTemplates = TFile::Open("templates_"+CUT+"_"+CAT+"_workspace.root");
RooWorkspace *wTemplates = (RooWorkspace*)fTemplates->Get("w");
RooRealVar *x = (RooRealVar*)wTemplates->var("mTop");
RooAbsPdf *pdf_signal = (RooAbsPdf*)wTemplates->pdf("ttbar_pdf_Nominal");
RooAbsPdf *pdf_bkg = (RooAbsPdf*)wTemplates->pdf("qcdCor_pdf");
TRandom *rnd = new TRandom();
rnd->SetSeed(0);
x->setBins(250);
RooPlot *frame;
TFile *outf;
if (NTOYS > 1) {
outf = TFile::Open("FitBiasToys_"+CUT+"_"+CAT+".root","RECREATE");
}
float nSigInj,nBkgInj,nSigFit,nBkgFit,eSigFit,eBkgFit,nll;
TTree *tr = new TTree("toys","toys");
tr->Branch("nSigInj",&nSigInj,"nSigInj/F");
tr->Branch("nSigFit",&nSigFit,"nSigFit/F");
tr->Branch("nBkgInj",&nBkgInj,"nBkgInj/F");
tr->Branch("nBkgFit",&nBkgFit,"nBkgFit/F");
tr->Branch("eSigFit",&eSigFit,"eSigFit/F");
tr->Branch("eBkgFit",&eBkgFit,"eBkgFit/F");
tr->Branch("nll" ,&nll ,"nll/F");
for(int itoy=0;itoy<NTOYS;itoy++) {
// generate pseudodataset
nSigInj = rnd->Poisson(SIG);
nBkgInj = rnd->Poisson(BKG);
RooRealVar *nSig = new RooRealVar("nSig","nSig",nSigInj);
RooRealVar *nBkg = new RooRealVar("nBkg","nBkg",nBkgInj);
RooAddPdf *model = new RooAddPdf("model","model",RooArgList(*pdf_signal,*pdf_bkg),RooArgList(*nSig,*nBkg));
RooDataSet *data = model->generate(*x,nSigInj+nBkgInj);
RooDataHist *roohist = new RooDataHist("roohist","roohist",RooArgList(*x),*data);
// build fit model
RooRealVar *nFitSig = new RooRealVar("nFitSig","nFitSig",SIG,0,10*SIG);
RooRealVar *nFitBkg = new RooRealVar("nFitBkg","nFitBkg",BKG,0,10*BKG);
RooAddPdf *modelFit = new RooAddPdf("modelFit","modelFit",RooArgList(*pdf_signal,*pdf_bkg),RooArgList(*nFitSig,*nFitBkg));
// fit the pseudo dataset
RooFitResult *res = modelFit->fitTo(*roohist,RooFit::Save(),RooFit::Extended(kTRUE));
//res->Print();
nSigFit = nFitSig->getVal();
nBkgFit = nFitBkg->getVal();
eSigFit = nFitSig->getError();
eBkgFit = nFitBkg->getError();
nll = res->minNll();
tr->Fill();
if (itoy % 100 == 0) {
cout<<"Toy #"<<itoy<<": injected = "<<nSigInj<<", fitted = "<<nSigFit<<", error = "<<eSigFit<<endl;
}
if (NTOYS == 1) {
frame = x->frame();
roohist->plotOn(frame);
model->plotOn(frame);
}
}
if (NTOYS == 1) {
TCanvas *can = new TCanvas("Toy","Toy",900,600);
frame->Draw();
}
else {
outf->cd();
tr->Write();
outf->Close();
fTemplates->Close();
}
}
int main(int argc, char **argv)
{
bool printSw = true;
//TString massModel = "Gauss-m[5622]";
string massModel = "DCB-m[5622]";
TString effbase = "/afs/cern.ch/user/p/pluca/work/Lb/Lmumu/results/";
bool printeff = false;
TString dodata = "data";
bool fitsingle = false;
TString wstr = "physRate_polp006";
TString decayToDo = "Lb2Lmumu";
if(dodata=="genMC") wstr += "_noDecay";
gROOT->ProcessLine(".x lhcbStyle.C");
RooRealVar * cosThetaL = new RooRealVar("cosThetaL","cosThetaL",0.,-1.,1.);
RooRealVar * cosThetaB = new RooRealVar("cosThetaB","cosThetaB",0.,-1.,1.);
RooRealVar * nsig_sw = new RooRealVar("nsig_sw","nsig_sw",1,-1.e6,1.e6);
RooRealVar * MCweight = new RooRealVar(wstr,wstr,1.,-1.e10,1.e10);
RooRealVar * MM = new RooRealVar("Lb_MassConsLambda","Lb_MassConsLambda",5620.,5500.,5900.);
TString datafilename = "/afs/cern.ch/user/p/pluca/work/Lb/Lmumu/candLb.root";
if(dodata=="MC") datafilename = "/afs/cern.ch/user/p/pluca/work/Lb/Lmumu/candLb_MC.root";
if(dodata=="genMC") datafilename = "/afs/cern.ch/work/p/pluca/weighted/Lmumu/"+(string)decayToDo+"_geomMC_Pythia8_NBweighted.root";
TreeReader * data;
if(dodata!="genMC") data = new TreeReader("cand"+decayToDo);
else data = new TreeReader("MCtree");
data->AddFile(datafilename);
TFile * histFile = new TFile("Afb_hist.root","recreate");
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
int nbins = 1;//CutsDef::nq2bins;
double q2min[] = {15.,11.0,15,16,18};//&CutsDef::q2min_highfirst[0];
double q2max[] = {20.,12.5,16,18,20};//&CutsDef::q2max_highfirst[0];
//int nbins = CutsDef::nq2bins
//double *q2min = &CutsDef::q2min[0];
//double *q2max = &CutsDef::q2max[0];
TGraphErrors * Afb_vs_q2 = new TGraphErrors();
TGraphErrors * AfbB_vs_q2 = new TGraphErrors();
TGraphErrors * fL_vs_q2 = new TGraphErrors();
TCanvas * ceff = new TCanvas();
RooCategory * samples = new RooCategory("samples","samples");
samples->defineType("DD");
samples->defineType("LL");
RooRealVar * afb = new RooRealVar("afb","afb",0.,-100,100);
RooRealVar * fL = new RooRealVar("fL","fL",0.7,-1.,10.);
//RooRealVar * afb = new RooRealVar("afb","afb",0.,-1.,1.);
//RooRealVar * fL = new RooRealVar("fL","fL",0.7,0.,1.);
RooRealVar * origafb = new RooRealVar("afb","afb",0.,-1.,1.);
RooRealVar * origfL = new RooRealVar("fL","fL",0.7,-1.,10.);
TString afbLpdf = "((3./8.)*(1.-fL)*(1 + TMath::Power(cosThetaL,2)) + afb*cosThetaL + (3./4.)*fL*(1 - TMath::Power(cosThetaL,2)))";
RooRealVar * afbB = new RooRealVar("afbB","afbB",0.,-100,100);
//RooRealVar * afbB = new RooRealVar("afbB","afbB",0.,-1.,1.);
RooRealVar * origafbB = new RooRealVar("afbB","afbB",0.,-1.,1.);
TString afbBpdf = "(1 + 2*afbB*cosThetaB)";
vector< vector< double > > afb_errs, afbB_errs, fL_errs;
TList * LLlist = new TList, * DDlist = new TList;
TCanvas * cDD = new TCanvas();
TCanvas * cLL = new TCanvas();
TCanvas * cDDB = new TCanvas();
TCanvas * cLLB = new TCanvas();
for(int i = 0; i < nbins; i++)
{
//if(q2min[i] < 8) continue;
TString q2name = ((TString)Form("q2_%4.2f_%4.2f",q2min[i],q2max[i])).ReplaceAll(".","");
TString curq2cut = Form("TMath::Power(J_psi_1S_MM/1000,2) >= %e && TMath::Power(J_psi_1S_MM/1000,2) < %e",q2min[i],q2max[i]);
//TString curq2cut = Form("TMath::Power(J_psi_1S_MM/1000,2) >= %e && TMath::Power(J_psi_1S_MM/1000,2) < %e && (Lb_MassConsLambda > 5680 || Lb_MassConsLambda < 5590)",q2min[i],q2max[i]);
cout << "------------------- q2 bin: " << q2min[i] << " - " << q2max[i] << " -----------------------" << endl;
TFile * effFile = NULL;
TH1F * effDD = NULL, * effLL = NULL, * effLLB = NULL, * effDDB = NULL;
if(q2min[i] == 15 && q2max[i] == 20)
{
effFile = TFile::Open(effbase+"LbeffvscosThetaL_DD.root");
effDD = (TH1F *)effFile->Get("htoteff");
effFile = TFile::Open(effbase+"LbeffvscosThetaL_LL.root");
effLL = (TH1F *)effFile->Get("htoteff");
effFile = TFile::Open(effbase+"LbeffvscosThetaB_DD.root");
effDDB = (TH1F *)effFile->Get("htot_nodet_eff");
effFile = TFile::Open(effbase+"LbeffvscosThetaB_LL.root");
effLLB = (TH1F *)effFile->Get("htot_nodet_eff");
}
else
{
effFile = TFile::Open(effbase+"Lbeff2D_cosThetaL_vs_q2_DD.root");
TH2F * effDD2D = (TH2F *)effFile->Get("htot_eff");
effDD = (TH1F*)GetSliceX(effDD2D,(q2max[i]+q2min[i])/2.);
effFile = TFile::Open(effbase+"Lbeff2D_cosThetaL_vs_q2_LL.root");
TH2F * effLL2D = (TH2F *)effFile->Get("htot_eff");
effLL = (TH1F*)GetSliceX(effLL2D,(q2max[i]+q2min[i])/2.);
effFile = TFile::Open(effbase+"Lbeff2D_cosThetaB_vs_q2_DD.root");
TH2F * effDDB2D = (TH2F *)effFile->Get("hupper_eff");
effDDB = (TH1F*)GetSliceX(effDDB2D,(q2max[i]+q2min[i])/2.);
effFile = TFile::Open(effbase+"Lbeff2D_cosThetaB_vs_q2_LL.root");
TH2F * effLLB2D = (TH2F *)effFile->Get("hupper_eff");
effLLB = (TH1F*)GetSliceX(effLLB2D,(q2max[i]+q2min[i])/2.);
}
ceff->cd();
/** FIT EFFICIENCY **/
RooDataHist * hLL = new RooDataHist("hLL","hLL",*cosThetaL,effLL);
RooDataHist * hDD = new RooDataHist("hDD","hDD",*cosThetaL,effDD);
RooRealVar * c1LL = new RooRealVar("c1LL","",0.,-1.,1);
RooRealVar * c1DD = new RooRealVar("c1DD","",0.,-1.,1);
RooRealVar * c2LL = new RooRealVar("c2LL","",0.,-1.,1);
RooRealVar * c2DD = new RooRealVar("c2DD","",0.,-1.,1);
TString effLLstr = "(1 + c1LL*cosThetaL + c2LL*TMath::Power(cosThetaL,2))";
TString effDDstr = "(1 + c1DD*cosThetaL + c2DD*TMath::Power(cosThetaL,2))";
RooAbsPdf * effLLpdf = new RooGenericPdf("effLLpdf", "", effLLstr, RooArgSet(*cosThetaL, *c1LL, *c2LL));
RooAbsPdf * effDDpdf = new RooGenericPdf("effDDpdf", "", effDDstr, RooArgSet(*cosThetaL, *c1DD, *c2DD));
effLLpdf->fitTo(*hLL,PrintLevel(-1));
effDDpdf->fitTo(*hDD,PrintLevel(-1));
fixParams(effLLpdf,cosThetaL);
fixParams(effDDpdf,cosThetaL);
RooDataHist * hLLB = new RooDataHist("hLLB","hLLB",*cosThetaB,effLLB);
RooDataHist * hDDB = new RooDataHist("hDDB","hDDB",*cosThetaB,effDDB);
RooRealVar * cB1LL = new RooRealVar("cB1LL","",0,-1.,1);
RooRealVar * cB1DD = new RooRealVar("cB1DD","",0,-1.,1);
RooRealVar * cB2LL = new RooRealVar("cB2LL","",0,-1.,1);
RooRealVar * cB2DD = new RooRealVar("cB2DD","",0,-1.,1);
TString effLLBstr = "(1 + cB1LL*cosThetaB + cB2LL*TMath::Power(cosThetaB,2))";
TString effDDBstr = "(1 + cB1DD*cosThetaB + cB2DD*TMath::Power(cosThetaB,2))";
RooAbsPdf * effLLpdfB = new RooGenericPdf("effLLpdfB", "", effLLBstr, RooArgSet(*cosThetaB, *cB1LL, *cB2LL));
RooAbsPdf * effDDpdfB = new RooGenericPdf("effDDpdfB", "", effDDBstr, RooArgSet(*cosThetaB, *cB1DD, *cB2DD));
effLLpdfB->fitTo(*hLLB,PrintLevel(-1));
effDDpdfB->fitTo(*hDDB,PrintLevel(-1));
fixParams(effLLpdfB,cosThetaB);
fixParams(effDDpdfB,cosThetaB);
//cout << q2min[i] << " - " << q2max[i] << " LL cosThetaL -> " << c1LL->getVal() << " " << c2LL->getVal() << endl;
//cout << q2min[i] << " - " << q2max[i] << " DD cosThetaL -> " << c1DD->getVal() << " " << c2DD->getVal() << endl;
//cout << q2min[i] << " - " << q2max[i] << " LL cosThetaB -> " << cB1LL->getVal() << " " << cB2LL->getVal() << endl;
//cout << q2min[i] << " - " << q2max[i] << " DD cosThetaB -> " << cB1DD->getVal() << " " << cB2DD->getVal() << endl;
if(printeff) {
GetFrame(cosThetaL, hLL,effLLpdf,"-nochi2",0,NULL,0,"cos#theta_{l}","Tot. eff.")->Draw();
ceff->Print("DDeffFit"+q2name+".pdf");
GetFrame(cosThetaL, hDD,effDDpdf,"-nochi2",0,NULL,0,"cos#theta_{l}","Tot. eff.")->Draw();
ceff->Print("LLeffFit"+q2name+".pdf");
GetFrame(cosThetaB, hLLB,effLLpdfB,"-nochi2",0,NULL,0,"cos#theta_{#Lambda}","Tot. eff.")->Draw();
ceff->Print("DDeffFitB"+q2name+".pdf");
GetFrame(cosThetaB, hDDB,effDDpdfB,"-nochi2",0,NULL,0,"cos#theta_{#Lambda}","Tot. eff.")->Draw();
ceff->Print("LLeffFitB"+q2name+".pdf"); }
/** FIT AFB **/
afb->setVal(0);
afbB->setVal(0);
fL->setVal(0.7);
TString LLnorm = "1./( 1. + (2./3.)*afb*c1LL + (2./5.)*c2LL - (1./5.)*c2LL*fL )*"+effLLstr;
TString DDnorm = "1./( 1. + (2./3.)*afb*c1DD + (2./5.)*c2DD - (1./5.)*c2DD*fL )*"+effDDstr;
RooAbsPdf * corrPdfLL = new RooGenericPdf(Form("corrPdfLL_%i",i),LLnorm+"*"+afbLpdf,RooArgSet(*cosThetaL, *afb, *fL, *c1LL, *c2LL) );
RooAbsPdf * corrPdfDD = new RooGenericPdf(Form("corrPdfDD_%i",i),DDnorm+"*"+afbLpdf,RooArgSet(*cosThetaL, *afb, *fL, *c1DD, *c2DD) );
TString LLnormB = "1./( (2./3.)*( 2*afbB*cB1LL + cB2LL + 3.) )*"+effLLBstr;
TString DDnormB = "1./( (2./3.)*( 2*afbB*cB1DD + cB2DD + 3.) )*"+effDDBstr;
RooAbsPdf * corrPdfLLB = new RooGenericPdf(Form("corrPdfLLB_%i",i),LLnormB+"*"+afbBpdf,RooArgSet(*cosThetaB, *afbB, *cB1LL, *cB2LL) );
RooAbsPdf * corrPdfDDB = new RooGenericPdf(Form("corrPdfDDB_%i",i),DDnormB+"*"+afbBpdf,RooArgSet(*cosThetaB, *afbB, *cB1DD, *cB2DD) );
TCut cutLL = CutsDef::LLcut + (TCut)curq2cut;
TCut cutDD = CutsDef::DDcut + (TCut)curq2cut;
if(dodata=="genMC")
{
corrPdfLLB = new RooGenericPdf("corrPdfLL",afbBpdf,RooArgSet(*cosThetaB, *afbB, *cB1LL, *cB2LL) );
corrPdfDDB = new RooGenericPdf("corrPdfDD",afbBpdf,RooArgSet(*cosThetaB, *afbB, *cB1DD, *cB2DD) );
corrPdfLL = new RooGenericPdf("corrPdfLL",afbLpdf,RooArgSet(*cosThetaL, *afb, *fL, *c1LL, *c2LL) );
corrPdfDD = new RooGenericPdf("corrPdfDD",afbLpdf,RooArgSet(*cosThetaL, *afb, *fL, *c1DD, *c2DD) );
cutLL = (TCut)curq2cut;
cutDD = (TCut)curq2cut;
}
Analysis * anaLL = new Analysis(Form("LL_mass_%i",i),"Lb",data,&cutLL,MM);
anaLL->AddVariable(cosThetaL);
anaLL->AddVariable(cosThetaB);
anaLL->AddVariable("J_psi_1S_MM");
if(dodata!="data") anaLL->SetWeight(wstr);
RooDataSet * dataLL = anaLL->GetDataSet("-recalc-docuts");
Analysis * anaDD = new Analysis(Form("DD_mass_%i",i),"Lb",data,&cutDD,MM);
anaDD->AddVariable(cosThetaL);
anaDD->AddVariable(cosThetaB);
anaDD->AddVariable("J_psi_1S_MM");
if(dodata!="data") anaDD->SetWeight(wstr);
RooDataSet * dataDD = anaDD->GetDataSet("-recalc-docuts");
RooDataSet * sdataDD, * sdataLL;
if(dodata=="data")
{
sdataLL = anaLL->CalcSweight("",massModel.c_str(),"Exp");
if(printSw) {
GetFrame(MM,NULL,sdataLL,"-nochi2",30,NULL,0,"M(#Lambda#mu#mu) (MeV/c^{2})")->Draw();
ceff->Print("Mass_LL_sWeighted"+q2name+".pdf");
GetFrame(cosThetaL,NULL,sdataLL,"-nochi2",6,NULL,0,"cos#theta_{l}")->Draw();
ceff->Print("cosThetaL_LL_sWeighted"+q2name+".pdf");
GetFrame(cosThetaL,NULL,dataLL,"-nochi2",6,NULL,0,"cos#theta_{l}")->Draw();
ceff->Print("cosThetaL_LL_"+q2name+".pdf");
}
sdataDD = anaDD->CalcSweight("",massModel.c_str(),"Exp");
if(printSw) {
GetFrame(MM,NULL,sdataDD,"-nochi2",30,NULL,0,"M(#Lambda#mu#mu) (MeV/c^{2})")->Draw();
ceff->Print("Mass_DD_sWeighted"+q2name+".pdf");
GetFrame(cosThetaL,NULL,sdataDD,"-nochi2",10,NULL,0,"cos#theta_{l}")->Draw();
ceff->Print("cosThetaL_DD_sWeighted"+q2name+".pdf");
GetFrame(cosThetaL,NULL,dataDD,"-nochi2",10,NULL,0,"cos#theta_{l}")->Draw();
ceff->Print("cosThetaL_DD_"+q2name+".pdf");
}
}
else { sdataLL = dataLL; sdataDD = dataDD; }
histFile->cd();
TTree * LLTree = (TTree*)sdataLL->tree();
LLTree->SetName(Form("treeLL_%i",i));
LLlist->Add(LLTree);
TTree * DDTree = (TTree*)sdataDD->tree();
DDTree->SetName(Form("treeDD_%i",i));
DDlist->Add(DDTree);
// CREATE COMBINED DATASET
RooDataSet * combData;
if(dodata=="data") combData = new RooDataSet(Form("combData_%i",i),"combined data",RooArgSet(*cosThetaL,*cosThetaB,*nsig_sw),Index(*samples),Import("DD",*sdataDD),Import("LL",*sdataLL),WeightVar("nsig_sw"));
else combData = new RooDataSet(Form("combData_%i",i),"combined data",RooArgSet(*cosThetaL,*cosThetaB,*MCweight),Index(*samples),Import("DD",*sdataDD),Import("LL",*sdataLL),WeightVar(wstr));
// FIT COS LEPTON
RooSimultaneous * combModel = new RooSimultaneous(Form("combModel_%i",i),"",*samples);
combModel->addPdf(*corrPdfLL,"LL");
combModel->addPdf(*corrPdfDD,"DD");
combModel->fitTo(*combData,PrintLevel(-1),Verbose(kFALSE),SumW2Error(kTRUE));
if(fitsingle) corrPdfLL->fitTo(*sdataLL,PrintLevel(-1),Verbose(kFALSE),SumW2Error(kTRUE));
GetFrame(cosThetaL,corrPdfLL,sdataLL,"-sumW2err-nochi2-noCost",6,NULL,0,"cos#theta_{l}")->Draw();
ceff->Print("Afb_LL_"+q2name+".pdf");
if(fitsingle) corrPdfDD->fitTo(*sdataDD,PrintLevel(-1),Verbose(kFALSE),SumW2Error(kTRUE));
GetFrame(cosThetaL,corrPdfDD,sdataDD,"-sumW2err-nochi2-noCost",10,NULL,0,"cos#theta_{l}")->Draw();
ceff->Print("Afb_DD_"+q2name+".pdf");
Afb_vs_q2->SetPoint(i,(q2max[i] + q2min[i])/2.,afb->getVal());
Afb_vs_q2->SetPointError(i,(q2max[i] - q2min[i])/2.,afb->getError());
fL_vs_q2->SetPoint(i,(q2max[i] + q2min[i])/2.,fL->getVal());
fL_vs_q2->SetPointError(i,(q2max[i] - q2min[i])/2.,fL->getError());
// FIT COS HADRON
RooSimultaneous * combModelB = new RooSimultaneous(Form("combModelB_%i",i),"",*samples);
combModelB->addPdf(*corrPdfLLB,"LL");
combModelB->addPdf(*corrPdfDDB,"DD");
combModelB->fitTo(*combData,PrintLevel(-1),Verbose(kFALSE),SumW2Error(kTRUE));
if(fitsingle) corrPdfLLB->fitTo(*sdataLL,PrintLevel(-1),Verbose(kFALSE),SumW2Error(kTRUE));
GetFrame(cosThetaB,corrPdfLLB,sdataLL,"-sumW2err-nochi2-noCost",6,NULL,0,"cos#theta_{#Lambda}")->Draw();
ceff->Print("AfbB_LL_"+q2name+".pdf");
if(fitsingle) corrPdfDDB->fitTo(*sdataDD,PrintLevel(-1),Verbose(kFALSE),SumW2Error(kTRUE));
GetFrame(cosThetaB,corrPdfDDB,sdataDD,"-sumW2err-nochi2-noCost",10,NULL,0,"cos#theta_{#Lambda}")->Draw();
ceff->Print("AfbB_DD_"+q2name+".pdf");
AfbB_vs_q2->SetPoint(i,(q2max[i] + q2min[i])/2.,afbB->getVal());
AfbB_vs_q2->SetPointError(i,(q2max[i] - q2min[i])/2.,afbB->getError());
cout << endl << fixed << setprecision(6) << "AfbB = " << afbB->getVal() << " +/- " << afbB->getError() << endl;
cout << "Afb = " << afb->getVal() << " +/- " << afb->getError() << endl;
cout << "fL = " << fL->getVal() << " +/- " << fL->getError() << endl;
cout << endl;
cout << "------------------------ FELDMAN AND COUSINS ------------------------" << endl;
vector < RooDataSet * > datas;
vector < RooAbsPdf * > pdfs, pdfsB;
vector < TString > cat;
cat.push_back("LL");
cat.push_back("DD");
datas.push_back(sdataLL);
datas.push_back(sdataDD);
RooArgSet * origPars = new RooArgSet();
origPars->add(*origafb);
origPars->add(*origfL);
pdfs.push_back(corrPdfLL);
pdfs.push_back(corrPdfDD);
vector< double > afb_err, afbB_err, fL_err;
/*
double fLval = fL->getVal(), fLerr = fL->getError();
FeldmanCousins * FC = new FeldmanCousins(q2name,cat,datas,pdfs,cosThetaL,afb,"nsig_sw");
//FC->SetNPointsToScan(20);
//FC->SetNExp(1000);
if(q2min[i]==18) afb_err = FC->ExtractLimits(origPars,-0.3,0.3);
else if( (afb->getVal()-1.4*afb->getError()) > -1 && (afb->getVal()+1.4*afb->getError()) < 1 )
afb_err = FC->ExtractLimits(origPars,afb->getVal()-1.4*afb->getError(),afb->getVal()+1.4*afb->getError());
else afb_err = FC->ExtractLimits(origPars,-0.4,0.4);
//FeldmanCousins * FCfL = new FeldmanCousins(q2name,cat,datas,pdfs,cosThetaL,fL,"nsig_sw");
//if(q2min[i]==11) fL_err = FCfL->ExtractLimits(origPars,0.,0.6);
//else if (q2min[i]==18) fL_err = FCfL->ExtractLimits(origPars,0.75,0.992);
//( (fLval-1.3*fLerr) > 0 && (fLval+1.3*fLerr) <= 1 )
//else fL_err = FCfL->ExtractLimits(origPars,fLval-1.3*fLerr,fLval+1.3*fLerr);
afb_errs.push_back(afb_err);
//fL_errs.push_back(fL_err);
RooArgSet * origParsB = new RooArgSet();
origParsB->add(*origafbB);
pdfsB.push_back(corrPdfLLB);
pdfsB.push_back(corrPdfDDB);
FeldmanCousins * FCB = new FeldmanCousins(q2name,cat,datas,pdfsB,cosThetaB,afbB,"nsig_sw");
if( (afbB->getVal()-1.5*afbB->getError()) > -1 && (afbB->getVal()+1.5*afbB->getError()) < 1 )
afbB_err = FCB->ExtractLimits(origParsB,afbB->getVal()-1.5*afbB->getError(),afbB->getVal()+1.5*afbB->getError());
else afbB_err = FCB->ExtractLimits(origParsB,-0.4,0.4);
afbB_errs.push_back(afbB_err);
*/
delete effDD;
delete effLL;
delete effLLB;
delete effDDB;
}
cDD->Print("DDeff.pdf");
cLL->Print("LLeff.pdf");
cDDB->Print("DDBeff.pdf");
cLLB->Print("LLBeff.pdf");
Afb_vs_q2->GetXaxis()->SetTitle("q^{2}");
Afb_vs_q2->GetYaxis()->SetTitle("Afb");
Afb_vs_q2->SetMaximum(1);
Afb_vs_q2->SetMinimum(-1);
Afb_vs_q2->Draw("AP");
ceff->Print("Afb_vs_q2.pdf");
AfbB_vs_q2->GetXaxis()->SetTitle("q^{2}");
AfbB_vs_q2->GetYaxis()->SetTitle("AfbB");
AfbB_vs_q2->SetMaximum(1);
AfbB_vs_q2->SetMinimum(-1);
AfbB_vs_q2->Draw("AP");
ceff->Print("AfbB_vs_q2.pdf");
fL_vs_q2->GetXaxis()->SetTitle("q^{2}");
fL_vs_q2->GetYaxis()->SetTitle("fL");
fL_vs_q2->Draw("AP");
ceff->Print("fL_vs_q2.pdf");
for(int bb = 0; bb < Afb_vs_q2->GetN(); bb++)
{
double qq, qqerr, afbv, afbBv, fLv;
Afb_vs_q2->GetPoint(bb,qq,afbv);
qqerr = Afb_vs_q2->GetErrorX(bb);
AfbB_vs_q2->GetPoint(bb,qq,afbBv);
fL_vs_q2->GetPoint(bb,qq,fLv);
cout << fixed << setprecision(1) << qq-qqerr << " - " << qq+qqerr;
cout << fixed << setprecision(4);
//cout << " & $" << afbv << "_{-" << TMath::Abs(afb_errs[bb][0] - afbv) << "}^{+" << TMath::Abs(afb_errs[bb][1] - afbv) << "} \\text{(stat)} \\pm \\text{(sys)}$ ";
//cout << " & $" << afbBv << "_{-" << TMath::Abs(afbB_errs[bb][0] - afbBv) << "}^{+" << TMath::Abs(afbB_errs[bb][1]-afbBv) << "} \\text{(stat)} \\pm \\text{(sys)}$ " ;
//cout << " & $" << fLv << "_{-" << TMath::Abs(fL_errs[bb][0] - fLv) << "}^{+" << TMath::Abs(fL_errs[bb][1] - fLv) << "} \\text{(stat)} \\pm \\text{(sys)}$ ";
cout << " \\\\ " << endl;
}
histFile->cd();
TTree * finalLLtree = (TTree*)TTree::MergeTrees(LLlist);
TTree * finalDDtree = (TTree*)TTree::MergeTrees(DDlist);
finalLLtree->SetName("LL_data");
finalDDtree->SetName("DD_data");
finalLLtree->Write();
finalDDtree->Write();
delete ceff;
histFile->Write();
delete histFile;
}
//put very small data entries in a binned dataset to avoid unphysical pdfs, specifically for H->ZZ->4l
RooDataSet* makeData(RooDataSet* orig, RooSimultaneous* simPdf, const RooArgSet* observables, RooRealVar* firstPOI, double mass, double& mu_min)
{
double max_soverb = 0;
mu_min = -10e9;
map<string, RooDataSet*> data_map;
firstPOI->setVal(0);
RooCategory* cat = (RooCategory*)&simPdf->indexCat();
TList* datalist = orig->split(*(RooAbsCategory*)cat, true);
TIterator* dataItr = datalist->MakeIterator();
RooAbsData* ds;
RooRealVar* weightVar = new RooRealVar("weightVar","weightVar",1);
while ((ds = (RooAbsData*)dataItr->Next()))
{
string typeName(ds->GetName());
cat->setLabel(typeName.c_str());
RooAbsPdf* pdf = simPdf->getPdf(typeName.c_str());
cout << "pdf: " << pdf << endl;
RooArgSet* obs = pdf->getObservables(observables);
cout << "obs: " << obs << endl;
RooArgSet obsAndWeight(*obs, *weightVar);
obsAndWeight.add(*cat);
stringstream datasetName;
datasetName << "newData_" << typeName;
RooDataSet* thisData = new RooDataSet(datasetName.str().c_str(),datasetName.str().c_str(), obsAndWeight, WeightVar(*weightVar));
RooRealVar* firstObs = (RooRealVar*)obs->first();
//int ibin = 0;
int nrEntries = ds->numEntries();
for (int ib=0;ib<nrEntries;ib++)
{
const RooArgSet* event = ds->get(ib);
const RooRealVar* thisObs = (RooRealVar*)event->find(firstObs->GetName());
firstObs->setVal(thisObs->getVal());
firstPOI->setVal(0);
double b = pdf->expectedEvents(*firstObs)*pdf->getVal(obs);
firstPOI->setVal(1);
double s = pdf->expectedEvents(*firstObs)*pdf->getVal(obs) - b;
if (s > 0)
{
mu_min = max(mu_min, -b/s);
double soverb = s/b;
if (soverb > max_soverb)
{
max_soverb = soverb;
cout << "Found new max s/b: " << soverb << " in pdf " << pdf->GetName() << " at m = " << thisObs->getVal() << endl;
}
}
if (b == 0 && s != 0)
{
cout << "Expecting non-zero signal and zero bg at m=" << firstObs->getVal() << " in pdf " << pdf->GetName() << endl;
}
if (s+b <= 0)
{
cout << "expecting zero" << endl;
continue;
}
double weight = ds->weight();
if ((typeName.find("ATLAS_H_4mu") != string::npos ||
typeName.find("ATLAS_H_4e") != string::npos ||
typeName.find("ATLAS_H_2mu2e") != string::npos ||
typeName.find("ATLAS_H_2e2mu") != string::npos) && fabs(firstObs->getVal() - mass) < 10 && weight == 0)
{
cout << "adding event: " << firstObs->getVal() << endl;
thisData->add(*event, pow(10., -9.));
}
else
{
//weight = max(pow(10.0, -9), weight);
thisData->add(*event, weight);
}
}
data_map[string(ds->GetName())] = (RooDataSet*)thisData;
}
RooDataSet* newData = new RooDataSet("newData","newData",RooArgSet(*observables, *weightVar),
Index(*cat), Import(data_map), WeightVar(*weightVar));
orig->Print();
newData->Print();
//newData->tree()->Scan("*");
return newData;
}
RooWorkspace* makeInvertedANFit(TTree* tree, float forceSigma=-1, bool constrainMu=false, float forceMu=-1) {
RooWorkspace *ws = new RooWorkspace("ws","");
std::vector< TString (*)(TString, RooRealVar&, RooWorkspace&) > bkgPdfList;
bkgPdfList.push_back(makeSingleExp);
bkgPdfList.push_back(makeDoubleExp);
#if DEBUG==0
//bkgPdfList.push_back(makeTripleExp);
bkgPdfList.push_back(makeModExp);
bkgPdfList.push_back(makeSinglePow);
bkgPdfList.push_back(makeDoublePow);
bkgPdfList.push_back(makePoly2);
bkgPdfList.push_back(makePoly3);
#endif
RooRealVar mgg("mgg","m_{#gamma#gamma}",103,160,"GeV");
mgg.setBins(38);
mgg.setRange("sideband_low", 103,120);
mgg.setRange("sideband_high",131,160);
mgg.setRange("signal",120,131);
RooRealVar MR("MR","",0,3000,"GeV");
MR.setBins(60);
RooRealVar Rsq("t1Rsq","",0,1,"GeV");
Rsq.setBins(20);
RooRealVar hem1_M("hem1_M","",-1,2000,"GeV");
hem1_M.setBins(40);
RooRealVar hem2_M("hem2_M","",-1,2000,"GeV");
hem2_M.setBins(40);
RooRealVar ptgg("ptgg","p_{T}^{#gamma#gamma}",0,500,"GeV");
ptgg.setBins(50);
RooDataSet data("data","",tree,RooArgSet(mgg,MR,Rsq,hem1_M,hem2_M,ptgg));
RooDataSet* blind_data = (RooDataSet*)data.reduce("mgg<121 || mgg>130");
std::vector<TString> tags;
//fit many different background models
for(auto func = bkgPdfList.begin(); func != bkgPdfList.end(); func++) {
TString tag = (*func)("bonly",mgg,*ws);
tags.push_back(tag);
ws->pdf("bonly_"+tag+"_ext")->fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
RooFitResult* bres = ws->pdf("bonly_"+tag+"_ext")->fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
bres->SetName(tag+"_bonly_fitres");
ws->import(*bres);
//make blinded fit
RooPlot *fmgg_b = mgg.frame();
blind_data->plotOn(fmgg_b,RooFit::Range("sideband_low,sideband_high"));
TBox blindBox(121,fmgg_b->GetMinimum()-(fmgg_b->GetMaximum()-fmgg_b->GetMinimum())*0.015,130,fmgg_b->GetMaximum());
blindBox.SetFillColor(kGray);
fmgg_b->addObject(&blindBox);
ws->pdf("bonly_"+tag+"_ext")->plotOn(fmgg_b,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("sideband_low,sideband_high"));
fmgg_b->SetName(tag+"_blinded_frame");
ws->import(*fmgg_b);
delete fmgg_b;
//set all the parameters constant
RooArgSet* vars = ws->pdf("bonly_"+tag)->getVariables();
RooFIter iter = vars->fwdIterator();
RooAbsArg* a;
while( (a = iter.next()) ){
if(string(a->GetName()).compare("mgg")==0) continue;
static_cast<RooRealVar*>(a)->setConstant(kTRUE);
}
//make the background portion of the s+b fit
(*func)("b",mgg,*ws);
RooRealVar sigma(tag+"_s_sigma","",5,0,100);
if(forceSigma!=-1) {
sigma.setVal(forceSigma);
sigma.setConstant(true);
}
RooRealVar mu(tag+"_s_mu","",126,120,132);
if(forceMu!=-1) {
mu.setVal(forceMu);
mu.setConstant(true);
}
RooGaussian sig(tag+"_sig_model","",mgg,mu,sigma);
RooRealVar Nsig(tag+"_sb_Ns","",5,0,100);
RooRealVar Nbkg(tag+"_sb_Nb","",100,0,100000);
RooRealVar HiggsMass("HiggsMass","",125.1);
RooRealVar HiggsMassError("HiggsMassError","",0.24);
RooGaussian HiggsMassConstraint("HiggsMassConstraint","",mu,HiggsMass,HiggsMassError);
RooAddPdf fitModel(tag+"_sb_model","",RooArgList( *ws->pdf("b_"+tag), sig ),RooArgList(Nbkg,Nsig));
RooFitResult* sbres;
RooAbsReal* nll;
if(constrainMu) {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
} else {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE));
}
sbres->SetName(tag+"_sb_fitres");
ws->import(*sbres);
ws->import(fitModel);
RooPlot *fmgg = mgg.frame();
data.plotOn(fmgg);
fitModel.plotOn(fmgg);
ws->pdf("b_"+tag+"_ext")->plotOn(fmgg,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("Full"));
fmgg->SetName(tag+"_frame");
ws->import(*fmgg);
delete fmgg;
RooMinuit(*nll).migrad();
RooPlot *fNs = Nsig.frame(0,25);
fNs->SetName(tag+"_Nsig_pll");
RooAbsReal *pll = nll->createProfile(Nsig);
//nll->plotOn(fNs,RooFit::ShiftToZero(),RooFit::LineColor(kRed));
pll->plotOn(fNs);
ws->import(*fNs);
delete fNs;
RooPlot *fmu = mu.frame(125,132);
fmu->SetName(tag+"_mu_pll");
RooAbsReal *pll_mu = nll->createProfile(mu);
pll_mu->plotOn(fmu);
ws->import(*fmu);
delete fmu;
}
RooArgSet weights("weights");
RooArgSet pdfs_bonly("pdfs_bonly");
RooArgSet pdfs_b("pdfs_b");
RooRealVar minAIC("minAIC","",1E10);
//compute AIC stuff
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooAbsPdf *p_bonly = ws->pdf("bonly_"+*t);
RooAbsPdf *p_b = ws->pdf("b_"+*t);
RooFitResult *sb = (RooFitResult*)ws->obj(*t+"_bonly_fitres");
RooRealVar k(*t+"_b_k","",p_bonly->getParameters(RooArgSet(mgg))->getSize());
RooRealVar nll(*t+"_b_minNll","",sb->minNll());
RooRealVar Npts(*t+"_b_N","",blind_data->sumEntries());
RooFormulaVar AIC(*t+"_b_AIC","2*@0+2*@1+2*@1*(@1+1)/(@2-@1-1)",RooArgSet(nll,k,Npts));
ws->import(AIC);
if(AIC.getVal() < minAIC.getVal()) {
minAIC.setVal(AIC.getVal());
}
//aicExpSum+=TMath::Exp(-0.5*AIC.getVal()); //we will need this precomputed for the next step
pdfs_bonly.add(*p_bonly);
pdfs_b.add(*p_b);
}
ws->import(minAIC);
//compute the AIC weight
float aicExpSum=0;
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooFormulaVar *AIC = (RooFormulaVar*)ws->obj(*t+"_b_AIC");
aicExpSum+=TMath::Exp(-0.5*(AIC->getVal()-minAIC.getVal())); //we will need this precomputed for the next step
}
std::cout << "aicExpSum: " << aicExpSum << std::endl;
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooFormulaVar *AIC = (RooFormulaVar*)ws->obj(*t+"_b_AIC");
RooRealVar *AICw = new RooRealVar(*t+"_b_AICWeight","",TMath::Exp(-0.5*(AIC->getVal()-minAIC.getVal()))/aicExpSum);
if( TMath::IsNaN(AICw->getVal()) ) {AICw->setVal(0);}
ws->import(*AICw);
std::cout << *t << ": " << AIC->getVal()-minAIC.getVal() << " " << AICw->getVal() << std::endl;
weights.add(*AICw);
}
RooAddPdf bonly_AIC("bonly_AIC","",pdfs_bonly,weights);
RooAddPdf b_AIC("b_AIC","",pdfs_b,weights);
//b_AIC.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
//RooFitResult* bres = b_AIC.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
//bres->SetName("AIC_b_fitres");
//ws->import(*bres);
//make blinded fit
RooPlot *fmgg_b = mgg.frame(RooFit::Range("sideband_low,sideband_high"));
blind_data->plotOn(fmgg_b,RooFit::Range("sideband_low,sideband_high"));
TBox blindBox(121,fmgg_b->GetMinimum()-(fmgg_b->GetMaximum()-fmgg_b->GetMinimum())*0.015,130,fmgg_b->GetMaximum());
blindBox.SetFillColor(kGray);
fmgg_b->addObject(&blindBox);
bonly_AIC.plotOn(fmgg_b,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("sideband_low,sideband_high"));
fmgg_b->SetName("AIC_blinded_frame");
ws->import(*fmgg_b);
delete fmgg_b;
#if 1
RooRealVar sigma("AIC_s_sigma","",5,0,100);
if(forceSigma!=-1) {
sigma.setVal(forceSigma);
sigma.setConstant(true);
}
RooRealVar mu("AIC_s_mu","",126,120,132);
if(forceMu!=-1) {
mu.setVal(forceMu);
mu.setConstant(true);
}
RooGaussian sig("AIC_sig_model","",mgg,mu,sigma);
RooRealVar Nsig("AIC_sb_Ns","",5,0,100);
RooRealVar Nbkg("AIC_sb_Nb","",100,0,100000);
RooRealVar HiggsMass("HiggsMass","",125.1);
RooRealVar HiggsMassError("HiggsMassError","",0.24);
RooGaussian HiggsMassConstraint("HiggsMassConstraint","",mu,HiggsMass,HiggsMassError);
RooAddPdf fitModel("AIC_sb_model","",RooArgList( b_AIC, sig ),RooArgList(Nbkg,Nsig));
RooFitResult* sbres;
RooAbsReal *nll;
if(constrainMu) {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
} else {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE));
}
assert(nll!=0);
sbres->SetName("AIC_sb_fitres");
ws->import(*sbres);
ws->import(fitModel);
RooPlot *fmgg = mgg.frame();
data.plotOn(fmgg);
fitModel.plotOn(fmgg);
ws->pdf("b_AIC")->plotOn(fmgg,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("Full"));
fmgg->SetName("AIC_frame");
ws->import(*fmgg);
delete fmgg;
RooMinuit(*nll).migrad();
RooPlot *fNs = Nsig.frame(0,25);
fNs->SetName("AIC_Nsig_pll");
RooAbsReal *pll = nll->createProfile(Nsig);
//nll->plotOn(fNs,RooFit::ShiftToZero(),RooFit::LineColor(kRed));
pll->plotOn(fNs);
ws->import(*fNs);
delete fNs;
RooPlot *fmu = mu.frame(125,132);
fmu->SetName("AIC_mu_pll");
RooAbsReal *pll_mu = nll->createProfile(mu);
pll_mu->plotOn(fmu);
ws->import(*fmu);
delete fmu;
std::cout << "min AIC: " << minAIC.getVal() << std::endl;
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooFormulaVar *AIC = (RooFormulaVar*)ws->obj(*t+"_b_AIC");
RooRealVar *AICw = ws->var(*t+"_b_AICWeight");
RooRealVar* k = ws->var(*t+"_b_k");
printf("%s & %0.0f & %0.2f & %0.2f \\\\\n",t->Data(),k->getVal(),AIC->getVal()-minAIC.getVal(),AICw->getVal());
//std::cout << k->getVal() << " " << AIC->getVal()-minAIC.getVal() << " " << AICw->getVal() << std::endl;
}
#endif
return ws;
}
int main(int argc, char **argv)
{
bool printeff = true;
string fc = "none";
gROOT->ProcessLine(".x lhcbStyle.C");
if(argc > 1)
{
for(int a = 1; a < argc; a++)
{
string arg = argv[a];
string str = arg.substr(2,arg.length()-2);
if(arg.find("-E")!=string::npos) fc = str;
if(arg=="-peff") printeff = true;
}
}
int nexp = 100;
int nbins = 6;
double q2min[] = {8.,15.,11.0,15,16,18};
double q2max[] = {11.,20.,12.5,16,18,20};
TString datafilename = "/afs/cern.ch/work/p/pluca/weighted/Lmumu/candLb.root";
TreeReader * data = new TreeReader("candLb2Lmumu");
data->AddFile(datafilename);
TreeReader * datajpsi = new TreeReader("candLb2JpsiL");
datajpsi->AddFile(datafilename);
TFile * histFile = new TFile("Afb_bkgSys.root","recreate");
string options = "-quiet-noPlot-lin-stdAxis-XM(#Lambda#mu#mu) (MeV/c^{2})-noCost-noParams";
Analysis::SetPrintLevel("s");
RooRealVar * cosThetaL = new RooRealVar("cosThetaL","cosThetaL",0.,-1.,1.);
RooRealVar * cosThetaB = new RooRealVar("cosThetaB","cosThetaB",0.,-1.,1.);
RooRealVar * MM = new RooRealVar("Lb_MassConsLambda","Lb_MassConsLambda",5621.,5400.,6000.);
MM->setRange("Signal",5600,5640);
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
//TGraphAsymmErrors * fL_vs_q2 = new TGraphAsymmErrors();
//TCanvas * ceff = new TCanvas();
RooCategory * samples = new RooCategory("samples","samples");
samples->defineType("DD");
samples->defineType("LL");
RooRealVar * afb = new RooRealVar("afb","afb",0.,-0.75,0.75);
RooRealVar * fL = new RooRealVar("fL","fL",0.6,0.,1.);
TString afbLpdf = "((3./8.)*(1.-fL)*(1 + TMath::Power(cosThetaL,2)) + afb*cosThetaL + (3./4.)*fL*(1 - TMath::Power(cosThetaL,2)))";
RooRealVar * afbB = new RooRealVar("afbB","afbB",0.,-0.5,0.5);
TString afbBpdf = "(1 + 2*afbB*cosThetaB)";
RooAbsPdf * teoPdf = new RooGenericPdf("teoPdf",afbLpdf,RooArgSet(*cosThetaL,*afb,*fL));
RooAbsPdf * teoPdfB = new RooGenericPdf("teoPdfB",afbBpdf,RooArgSet(*cosThetaB,*afbB));
TreeReader * mydata = datajpsi;
Str2VarMap jpsiParsLL = getJpsiPars("LL", CutsDef::LLcut, histFile);
Str2VarMap jpsiParsDD = getJpsiPars("DD", CutsDef::DDcut, histFile);
vector<TH1 *> fLsysh, afbsysh, afbBsysh, fLsysh_frac, afbsysh_frac, afbBsysh_frac;
for(int i = 0; i < nbins; i++)
{
TString q2name = ((TString)Form("q2_%4.2f_%4.2f",q2min[i],q2max[i])).ReplaceAll(".","");
if(i>0) { mydata = data; MM->setRange(5400,6000); }
else { q2name = "jpsi"; MM->setRange(5500,5850); }
TString curq2cut = Form("TMath::Power(J_psi_1S_MM/1000,2) >= %e && TMath::Power(J_psi_1S_MM/1000,2) < %e",q2min[i],q2max[i]);
cout << "------------------- q2 bin: " << q2min[i] << " - " << q2max[i] << " -----------------------" << endl;
/** GET AND FIT EFFICIENCIES **/
RooAbsPdf * effDDpdf = NULL, * effLLpdf = NULL, * effLLBpdf = NULL, * effDDBpdf = NULL;
getEfficiencies(q2min[i],q2max[i],&effLLpdf,&effDDpdf,&effLLBpdf,&effDDBpdf,printeff);
cout << "Efficiencies extracted" << endl;
histFile->cd();
/** FIT AFB **/
afb->setVal(0);
afbB->setVal(-0.37);
fL->setVal(0.6);
RooAbsPdf * corrPdfLL = new RooProdPdf("sigPdfLL"+q2name,"corrPdfLL",*teoPdf,*effLLpdf);
RooAbsPdf * corrPdfDD = new RooProdPdf("sigPdfDD"+q2name,"corrPdfDD",*teoPdf,*effDDpdf);
RooAbsPdf * corrPdfLLB = new RooProdPdf("sigPdfLLB"+q2name,"corrPdfLLB",*teoPdfB,*effLLBpdf);
RooAbsPdf * corrPdfDDB = new RooProdPdf("sigPdfDDB"+q2name,"corrPdfDDB",*teoPdfB,*effDDBpdf);
TCut baseCut = "";
TCut cutLL = CutsDef::LLcut + (TCut)curq2cut + baseCut;
TCut cutDD = CutsDef::DDcut + (TCut)curq2cut + baseCut;
histFile->cd();
double fracDDv[2], fracLLv[2];
double nsigDD, nsigLL;
RooDataSet * dataLL = getDataAndFrac("LL",q2name,mydata,cutLL,MM,&fracLLv[0],jpsiParsLL,&nsigLL);
RooDataSet * dataDD = getDataAndFrac("DD",q2name,mydata,cutDD,MM,&fracDDv[0],jpsiParsDD,&nsigDD);
double nevts = nsigDD+nsigLL;
cout << fixed << setprecision(3) << fracDDv[0] << " " << fracDDv[1] << endl;
RooRealVar * fracLL = new RooRealVar("fracLL","fracLL",fracLLv[0]);
RooRealVar * fracDD = new RooRealVar("fracDD","fracDD",fracDDv[0]);
RooAbsPdf * bkgLL = NULL, * bkgLLB = NULL, * bkgDD = NULL, * bkgDDB = NULL;
buildBkgPdfs(q2min[i],q2max[i],"LL",CutsDef::LLcut,&bkgLL,&bkgLLB);
buildBkgPdfs(q2min[i],q2max[i],"DD",CutsDef::DDcut,&bkgDD,&bkgDDB);
cout << "Backgrounds extracted" << endl;
RooAbsPdf * modelLL = new RooAddPdf("modelLL","modelLL",RooArgSet(*corrPdfLL,*bkgLL),*fracLL);
RooAbsPdf * modelDD = new RooAddPdf("modelDD","modelDD",RooArgSet(*corrPdfDD,*bkgDD),*fracDD);
RooAbsPdf * modelLLB = new RooAddPdf("modelLLB","modelLLB",RooArgSet(*corrPdfLLB,*bkgLLB),*fracLL);
RooAbsPdf * modelDDB = new RooAddPdf("modelDDB","modelDDB",RooArgSet(*corrPdfDDB,*bkgDDB),*fracDD);
// CREATE COMBINED DATASET
RooDataSet * combData = new RooDataSet(Form("combData_%i",i),"combined data",RooArgSet(*MM,*cosThetaL,*cosThetaB),Index(*samples),Import("DD",*dataDD),Import("LL",*dataLL));
Str2VarMap params;
params["fL"] = fL;
params["afb"] = afb;
Str2VarMap paramsB;
paramsB["afbB"] = afbB;
// FIT COS LEPTON
RooSimultaneous * combModel = new RooSimultaneous(Form("combModel_%i",i),"",*samples);
combModel->addPdf(*modelLL,"LL");
combModel->addPdf(*modelDD,"DD");
RooFitResult * res = safeFit(combModel,combData,params,&isInAllowedArea);
// FIT COS HADRON
RooSimultaneous * combModelB = new RooSimultaneous(Form("combModelB_%i",i),"",*samples);
combModelB->addPdf(*modelLLB,"LL");
combModelB->addPdf(*modelDDB,"DD");
RooFitResult * resB = safeFit(combModelB,combData,paramsB,&isInAllowedAreaB);
cout << endl << fixed << setprecision(6) << "AfbB = " << afbB->getVal() << " +/- " << afbB->getError() << endl;
cout << "Afb = " << afb->getVal() << " +/- " << afb->getError() << endl;
cout << "fL = " << fL->getVal() << " +/- " << fL->getError() << endl;
cout << endl;
cout << "lepton: " << res->edm() << " " << res->covQual() << endl;
cout << "baryon: " << resB->edm() << " " << resB->covQual() << endl;
cout << endl;
TH1F * fLsys = new TH1F(Form("fLsys_%i",i),"fLsys",40,-1,1);
TH1F * afbsys = new TH1F(Form("afbsys_%i",i),"afbsys",40,-1,1);
TH1F * afbBsys = new TH1F(Form("afbBsys_%i",i),"afbBsys",40,-1,1);
TH1F * fLsys_frac = new TH1F(Form("fLsys_frac%i",i),"fLsys",40,-1,1);
TH1F * afbsys_frac = new TH1F(Form("afbsys_frac%i",i),"afbsys",40,-1,1);
TH1F * afbBsys_frac = new TH1F(Form("afbBsys_frac%i",i),"afbBsys",40,-1,1);
RooAbsPdf * mybkgDD_2 = NULL, * mybkgDDB_2 = NULL;
buildBkgPdfs(q2min[i],q2max[i],"DD",CutsDef::DDcut,&mybkgDD_2,&mybkgDDB_2,"RooKeyPdf");
//cout << nevts << endl;
//TRandom3 r(0);
for(int e = 0; e < nexp; e++)
{
histFile->cd();
RooAbsPdf * toypdf = (RooAbsPdf *)modelDD->Clone();
Analysis * toy = new Analysis("toy",cosThetaL,modelDD,nevts);
RooAbsPdf * toypdfB = (RooAbsPdf *)modelDDB->Clone();
Analysis * toyB = new Analysis("toyB",cosThetaB,modelDDB,nevts);
afb->setVal(0);
afbB->setVal(-0.37);
fL->setVal(0.6);
safeFit(toypdf,toy->GetDataSet("-recalc"),params,&isInAllowedArea);
safeFit(toypdfB,toyB->GetDataSet("-recalc"),paramsB,&isInAllowedAreaB);
double def_afb = afb->getVal();
double def_fL = fL->getVal();
double def_afbB = afbB->getVal();
afb->setVal(0);
afbB->setVal(-0.37);
fL->setVal(0.6);
RooAbsPdf * modelDD_2 = new RooAddPdf("modelDD_2","modelDD",RooArgSet(*corrPdfDD,*mybkgDD_2),*fracDD);
RooAbsPdf * modelDDB_2 = new RooAddPdf("modelDDB_2","modelDDB",RooArgSet(*corrPdfDDB,*mybkgDDB_2),*fracDD);
safeFit(modelDD_2,toy->GetDataSet("-recalc"),params,&isInAllowedArea);
safeFit(modelDDB_2,toyB->GetDataSet("-recalc"),paramsB,&isInAllowedAreaB);
double oth_afb = afb->getVal();
double oth_fL = fL->getVal();
double oth_afbB = afbB->getVal();
fLsys->Fill(oth_fL-def_fL);
afbsys->Fill(oth_afb-def_afb);
afbBsys->Fill(oth_afbB-def_afbB);
afb->setVal(0.);
afbB->setVal(-0.37);
fL->setVal(0.6);
//double rdm_frac = r.Gaus(fracDDv[0],fracDDv[1]);
double rdm_frac = fracDDv[0] + fracDDv[1];
RooRealVar * fracDD_2 = new RooRealVar("fracDD_2","fracDD_2",rdm_frac);
RooAbsPdf * modelDD_3 = new RooAddPdf("modelDD_3","modelDD",RooArgSet(*corrPdfDD,*bkgDD),*fracDD_2);
RooAbsPdf * modelDDB_3 = new RooAddPdf("modelDDB_3","modelDDB",RooArgSet(*corrPdfDDB,*bkgDDB),*fracDD_2);
safeFit(modelDD_3,toy->GetDataSet("-recalc"),params,&isInAllowedArea);
safeFit(modelDDB_3,toyB->GetDataSet("-recalc"),paramsB,&isInAllowedAreaB);
double frc_afb = afb->getVal();
double frc_fL = fL->getVal();
double frc_afbB = afbB->getVal();
fLsys_frac->Fill(frc_fL-def_fL);
afbsys_frac->Fill(frc_afb-def_afb);
afbBsys_frac->Fill(frc_afbB-def_afbB);
}
afbsysh.push_back(afbsys);
afbBsysh.push_back(afbBsys);
fLsysh.push_back(fLsys);
afbsysh_frac.push_back(afbsys_frac);
afbBsysh_frac.push_back(afbBsys_frac);
fLsysh_frac.push_back(fLsys_frac);
}
for(int q = 0; q < nbins; q++)
{
cout << fixed << setprecision(2) << "-------- Bin " << q2min[q] << "-" << q2max[q] << endl;
cout << fixed << setprecision(5) << "fL sys = " << fLsysh[q]->GetMean() << " +/- " << fLsysh[q]->GetMeanError() << endl;
cout << "Afb sys = " << afbsysh[q]->GetMean() << " +/- " << afbsysh[q]->GetMeanError() << endl;
cout << "AfbB sys = " << afbBsysh[q]->GetMean() << " +/- " << afbBsysh[q]->GetMeanError() << endl;
}
cout << "#################################################################" << endl;
for(int q = 0; q < nbins; q++)
{
cout << fixed << setprecision(2) << "-------- Bin " << q2min[q] << "-" << q2max[q] << endl;
cout << fixed << setprecision(5) << "fL sys = " << fLsysh_frac[q]->GetMean() << " +/- " << fLsysh_frac[q]->GetMeanError() << endl;
cout << "Afb sys = " << afbsysh_frac[q]->GetMean() << " +/- " << afbsysh_frac[q]->GetMeanError() << endl;
cout << "AfbB sys = " << afbBsysh_frac[q]->GetMean() << " +/- " << afbBsysh_frac[q]->GetMeanError() << endl;
}
cout << "#################################################################" << endl;
for(int q = 0; q < nbins; q++)
{
cout << fixed << setprecision(2) << "-------- Bin " << q2min[q] << "-" << q2max[q] << endl;
cout << fixed << setprecision(5) << "fL sys = " << TMath::Sqrt(TMath::Power(fLsysh_frac[q]->GetMean(),2) + TMath::Power(fLsysh[q]->GetMean(),2) ) << endl;
cout << "Afb sys = " << TMath::Sqrt(TMath::Power(afbsysh_frac[q]->GetMean(),2) + TMath::Power(afbsysh[q]->GetMean(),2) ) << endl;
cout << "AfbB sys = " << TMath::Sqrt(TMath::Power(afbBsysh_frac[q]->GetMean(),2) + TMath::Power(afbBsysh[q]->GetMean(),2) ) << endl;
}
}
