TString* saveResult(const char *filename){
// printf(" current dir == %s\n" , gDirectory->GetPath());
TDirectory *curr=(TDirectory*)gDirectory;
//======= TIME AND DATE ===============
time_t curtime; struct tm *loctime;
char ch[200];
char chroof[200];
curtime = time (NULL); loctime = localtime (&curtime);
// TString sr=s.Data(); // commandbox contents
// if ( sr.CompareTo("")==0 ){
sprintf(ch,"fit%04d%02d%02d_%02d%02d%02d",
1900+loctime->tm_year, 1+loctime->tm_mon,
loctime->tm_mday, loctime->tm_hour, loctime->tm_min, loctime->tm_sec);
sprintf(chroof,"roo%04d%02d%02d_%02d%02d%02d",
1900+loctime->tm_year, 1+loctime->tm_mon,
loctime->tm_mday, loctime->tm_hour, loctime->tm_min, loctime->tm_sec);
TString *stamp=new TString(ch); //tpad fit HERE
// }else{
// sprintf(ch,"shspe%04d%02d%02d_%02d%02d%02d_%s_.root",
// 1900+loctime->tm_year, 1+loctime->tm_mon,
// loctime->tm_mday, loctime->tm_hour, loctime->tm_min, loctime->tm_sec,
// sr.Data() );
// }
// printf("! ... saving RooFitResult into /%s/\n", filename );
printf("i ... names: /%s/ \n" , chroof );
TFile f(filename,"UPDATE") ;
fitresult->Write( chroof ) ; //write RooFitResult fitresult je GLOBALNI
f.Close() ;
curr->cd();
// printf("i ... returned to current dir == %s\n" , gDirectory->GetPath());
return stamp;
}//saveresult...
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 fitDebug(string cut, string filename, string hlt, bool binned, string outdir, int isoWeight, int isFPR){
// string outdir = "";
TChain data("myTrees_withWeight");
/*
if(hlt=="hltcut30")
data.Add("/afs/cern.ch/work/g/gdimperi/GammaJet/giulia_repo/CMSSW_5_3_14/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt30.root");
if(hlt=="hltcut50")
data.Add("/afs/cern.ch/work/g/gdimperi/GammaJet/giulia_repo/CMSSW_5_3_14/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt50.root");
if(hlt=="hltcut75")
data.Add("/afs/cern.ch/work/g/gdimperi/GammaJet/giulia_repo/CMSSW_5_3_14/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt75.root");
if(hlt=="hltcut90")
data.Add("/afs/cern.ch/work/g/gdimperi/GammaJet/giulia_repo/CMSSW_5_3_14/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt90.root");
if(hlt=="hltcut135")
data.Add("/afs/cern.ch/work/g/gdimperi/GammaJet/giulia_repo/CMSSW_5_3_14/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt135.root");
if(hlt=="hltcut150")
data.Add("/afs/cern.ch/work/g/gdimperi/GammaJet/giulia_repo/CMSSW_5_3_14/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt150.root");
*/
if(hlt=="hltcut30")
data.Add("/cmshome/gdimperi/GammaJet/CMSSW_6_0_1/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt30.root");
if(hlt=="hltcut50")
data.Add("/cmshome/gdimperi/GammaJet/CMSSW_6_0_1/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt50.root");
if(hlt=="hltcut75")
data.Add("/cmshome/gdimperi/GammaJet/CMSSW_6_0_1/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt75.root");
if(hlt=="hltcut90")
data.Add("/cmshome/gdimperi/GammaJet/CMSSW_6_0_1/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt90.root");
if(hlt=="hltcut135")
data.Add("/cmshome/gdimperi/GammaJet/CMSSW_6_0_1/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt135.root");
if(hlt=="hltcut150")
data.Add("/cmshome/gdimperi/GammaJet/CMSSW_6_0_1/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_hlt150.root");
RooRealVar combinedPfIso03Phot("combinedPfIso03Phot", "combinedPfIso03Phot", -7., 15.);
RooRealVar combinedPfIsoFPR03Phot("combinedPfIsoFPR03Phot", "combinedPfIsoFPR03Phot", -7., 15.);
RooRealVar etaPhot("etaPhot", "etaPhot", -2.5, 2.5);
RooRealVar mvaIdPhot("mvaIdPhot", "mvaIdPhot", -1.,1.);
RooRealVar isMatchedPhot("isMatchedPhot","isMatchedPhot", -1., 2.);
RooRealVar isIsolatedGenPhot("isIsolatedGenPhot","isIsolatedGenPhot", -1., 2.);
RooRealVar ptPhot("ptPhot", "ptPhot", 0., 1000.);
RooRealVar weight("weight","weight", 0., 100.);
RooRealVar isoW_EB("isoW_EB","isoW_EB", 0., 100.);
RooRealVar isoW1_EB("isoW1_EB","isoW1_EB", 0., 100.);
RooRealVar isoW2_EB("isoW2_EB","isoW2_EB", 0., 100.);
RooRealVar isoFPRW_EB("isoFPRW_EB","isoW_EB", 0., 100.);
RooRealVar isoFPRW1_EB("isoFPRW1_EB","isoFPRW1_EB", 0., 100.);
RooRealVar isoFPRW2_EB("isoFPRW2_EB","isoFPRW2_EB", 0., 100.);
RooProduct weight_times_isoWeight("weight_times_isoWeight", "weight_times_isoWeight", RooArgSet(weight,isoW_EB));
RooArgSet argSet("argSet");
//creating set of variables for the datasets
std::cout<<"Creating RooArgSet with variables for fit"<<std::endl;
argSet.add(combinedPfIso03Phot);
argSet.add(combinedPfIsoFPR03Phot);
argSet.add(etaPhot);
argSet.add(mvaIdPhot);
argSet.add(isMatchedPhot);
argSet.add(isIsolatedGenPhot);
argSet.add(ptPhot);
argSet.add(weight);
argSet.add(isoW_EB);
argSet.add(isoW1_EB);
argSet.add(isoW2_EB);
argSet.add(isoFPRW_EB);
argSet.add(isoFPRW1_EB);
argSet.add(isoFPRW2_EB);
//binning variables
//std::cout<<"Binning variables for eventual binned fit"<<std::endl;
//combinedPfIsoFPR03Phot.setBins(121);
//etaPhot.setBins(120);
//mvaIdPhot.setBins(180);
//isIsolatedGenPhot.setBins(3);
//ptPhot.setBins(1200);
//weight_times_isoWeight.setBins(10000000);
//creating complete dataset
std::cout<<"Reading trees of MC into a complete general dataset"<<std::endl;
RooDataSet* allSet;
if(isFPR){
if(isoWeight==0)
allSet = new RooDataSet("allSet", "allSet", argSet, WeightVar("isoFPRW_EB"), RooFit::Import(data));
if(isoWeight==1)
allSet = new RooDataSet("allSet", "allSet", argSet, WeightVar("isoFPRW1_EB"), RooFit::Import(data));
if(isoWeight==2)
allSet = new RooDataSet("allSet", "allSet", argSet, WeightVar("isoFPRW2_EB"), RooFit::Import(data));
}
else{
if(isoWeight==0)
allSet = new RooDataSet("allSet", "allSet", argSet, WeightVar("isoW_EB"), RooFit::Import(data));
if(isoWeight==1)
allSet = new RooDataSet("allSet", "allSet", argSet, WeightVar("isoW1_EB"), RooFit::Import(data));
if(isoWeight==2)
allSet = new RooDataSet("allSet", "allSet", argSet, WeightVar("isoW2_EB"), RooFit::Import(data));
}
//allSet.setWeightVar(weight_times_isoWeight);
std::cout<<"Complete dataset "<<allSet->GetName()<<" created"<<std::endl<<std::endl;
std::cout<<"******************** "<<std::endl;
std::cout<<" isWeighted = " << allSet->isWeighted() <<std::endl;
std::cout<<"******************** "<<std::endl<<std::endl;
//reducing complete dataset to interesting ones
RooDataSet* d_r = (RooDataSet*)allSet->reduce((cut+" && mvaIdPhot<0.6 && mvaIdPhot>-0.6").c_str());
d_r->SetName("d_r");
std::cout<<"Reduced dataset "<<d_r->GetName()<<" created with cut "<<cut<<" && -0.6 < mvaIdPhot < 0.6"<<std::endl;
std::cout<<"d_r entries: "<<d_r->sumEntries()<<std::endl;
//models for fit
//gaussian
RooRealVar gaussmean("gaussmean","gaussmean", -1., -10., 20.);
RooRealVar gausssigma("gausssigma", "gausssigma", 1., 0., 20.);
RooGaussian* my_gauss;
if(isFPR)
my_gauss = new RooGaussian("my_gauss", "my_gauss", combinedPfIsoFPR03Phot, gaussmean, gausssigma);
else
my_gauss = new RooGaussian("my_gauss", "my_gauss", combinedPfIso03Phot, gaussmean, gausssigma);
//crystalBall
RooRealVar cbmean("cbmean", "cbmean", -1., -5., 15.);
RooRealVar cbsigma("cbsigma", "cbsigma", 1., 0., 20.);
RooRealVar cbalpha("cbalpha", "cbaplha", -1., -1000., 0.);
RooRealVar cbn("cbn","cbn",10., 0., 1000.);
RooCBShape* my_cb;
if(isFPR)
my_cb = new RooCBShape("my_cb", "my_cb", combinedPfIsoFPR03Phot, cbmean, cbsigma, cbalpha, cbn);
else
my_cb = new RooCBShape("my_cb", "my_cb", combinedPfIso03Phot, cbmean, cbsigma, cbalpha, cbn);
RooRealVar frac("frac", "frac", 0.5, 0., 1.);
//adding gauss to cb for both fit regions
RooAddPdf my_add("my_add", "my_add", *my_cb, *my_gauss, frac);
//creating simultaneous fit model
//RooSimultaneous simPdf("simPdf", "simultaneous pdfs, scut and rcut", sample);
//simPdf.addPdf(my_add_s, "scut");
//simPdf.addPdf(my_add_r, "rcut");
//fit
RooFitResult* result;
//unbinned
if(!binned) result = my_add.fitTo(*d_r, Save(), Range(-5.,15.), SumW2Error(kFALSE));
//binned
//if(binned) result = simPdf.fitTo(srcut_h, Save(), Range(-5.,15.), SumW2Error(kFALSE));
//drawing results
RooPlot* frame_r;
if(isFPR)
frame_r = combinedPfIsoFPR03Phot.frame(RooFit::Title("Fit to combinedPfIsoFPR03Phot, rcut region"));
else
frame_r = combinedPfIso03Phot.frame(RooFit::Title("Fit to combinedPfIso03Phot, rcut region"));
if(!binned) d_r->plotOn(frame_r, Name("data_rcut"));
my_add.plotOn(frame_r,Name("pdf_r"),LineColor(kCyan)) ;
my_add.plotOn(frame_r, RooFit::LineColor(kMagenta), Components("my_cb"));
my_add.plotOn(frame_r, RooFit::LineColor(kMagenta), Components("my_gauss"));
frame_r->SetMinimum(0.00001);
TCanvas* c = new TCanvas();
c->SetTitle(frame_r->GetTitle());
frame_r->Draw("");
c->SaveAs((outdir+filename+"_r_dataReweight.png").c_str());
c->SaveAs((outdir+filename+"_r_dataReweight.root").c_str());
//Double_t chi2 = frame_r->chiSquare("pdf_r", "data_rcut", 6);
Double_t chi2 = frame_r->chiSquare("pdf_r", "data_rcut", 7);
Double_t prob = TMath::Prob(chi2,7);
TPaveLabel *t1_r = new TPaveLabel(0.6,0.4,0.83,0.5, Form("#chi^{2}/dof = %.3f", chi2),"brNDC");
t1_r->SetFillColor(0);
t1_r->SetLineWidth(0);
t1_r->SetLineColor(0);
t1_r->SetShadowColor(0);
TPaveLabel *t2_r = new TPaveLabel(0.6,0.5,0.83,0.60, Form("Prob(#chi^{2},dof) = %.3f", prob),"brNDC");
t2_r->SetFillColor(0);
t2_r->SetLineWidth(0);
t2_r->SetLineColor(0);
t2_r->SetShadowColor(0);
std::cout<<"ChiSquared value, rcut: "<<chi2<<std::endl;
c->SetLogy();
frame_r->Draw("");
t1_r->Draw();
t2_r->Draw();
c->SetTitle(frame_r->GetTitle());
c->SaveAs((outdir+filename+"_r_dataRewight_log.png").c_str());
c->SaveAs((outdir+filename+"_r_dataReweight_log.root").c_str());
TFile* f_fitRes = new TFile((outdir+"fitResult_"+filename+"_dataReweight.root").c_str(), "RECREATE");
result->Write();
// f_fitRes->Write();
f_fitRes->Close();
RooWorkspace* w_bg = new RooWorkspace("w_bg", "workspace");
w_bg->import(*d_r);
w_bg->import(my_add);
w_bg->import(combinedPfIsoFPR03Phot);
w_bg->import(combinedPfIso03Phot);
w_bg->Print();
w_bg->writeToFile((outdir+"workspace_"+filename+"_dataReweight.root").c_str());
}
void fitDebug_sig(string cut, string filename){
TChain mc("finalTree");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/G_Pt-120to170_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/G_Pt-170to300_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/G_Pt-30to50_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/G_Pt-50to80_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/G_Pt-80to120_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/QCDEM_Pt_170_250_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/QCDEM_Pt_20_30_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/QCDEM_Pt_250_350_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/QCDEM_Pt_30_80_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/QCDEM_Pt_350_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
mc.Add("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/QCDEM_Pt_80_170_8TeV_pythia6_hltcut30_hltiso0_mvaWP4.root");
RooRealVar combinedPfIso03Phot("combinedPfIso03Phot", "combinedPfIso03Phot", -7., 15.);
RooRealVar etaPhot("etaPhot", "etaPhot", -2.5, 2.5);
RooRealVar mvaIdPhot("mvaIdPhot", "mvaIdPhot", -1.,1.);
RooRealVar isMatchedPhot("isMatchedPhot","isMatchedPhot", -1., 2.);
RooRealVar ptPhot("ptPhot", "ptPhot", 0., 1000.);
RooRealVar weight("weight","weight", 0., 100.);
RooArgSet argSet("argSet");
argSet.add(combinedPfIso03Phot);
argSet.add(etaPhot);
argSet.add(mvaIdPhot);
argSet.add(isMatchedPhot);
argSet.add(ptPhot);
argSet.add(weight);
combinedPfIso03Phot.setBins(121);
etaPhot.setBins(120);
mvaIdPhot.setBins(180);
isMatchedPhot.setBins(3);
ptPhot.setBins(1200);
weight.setBins(1000);
std::cout<<"set binning"<<std::endl;
RooDataSet allSet("allSet", "allSet", argSet, RooFit::WeightVar("weight"), RooFit::Import(mc));
std::cout<<"created complete dataset"<<endl;
std::cout<<allSet.GetName()<<std::endl;
RooDataSet* d_s = (RooDataSet*)allSet.reduce((cut+" && mvaIdPhot>0.711099").c_str());
std::cout<<"d_s entries: "<<d_s->sumEntries()<<std::endl;
std::cout<<"created reduced dataset"<<std::endl;
TH1F* h_set_s = (TH1F*)d_s->createHistogram("h_set_s", combinedPfIso03Phot, RooFit::Binning(combinedPfIso03Phot.getBinning()));
std::cout<<"integral h_set_s"<<h_set_s->Integral()<<std::endl;
RooDataHist dh_s("dh_s", "dh_s", combinedPfIso03Phot, Import(*h_set_s));
std::cout<<dh_s.sum(kTRUE)<<std::endl;
std::cout<<"created reduced datahist, scut"<<std::endl;
RooRealVar crujffmean("crujffmean", "crujffmean", -1., -10., 0.);
RooRealVar crujffsigmaL("crujffsigmaL", "crujffsigmaL", 1., 0., 10.);
RooRealVar crujffsigmaR("crujffsigmaR", "crujffsigmaR", 1., 0., 10.);
RooRealVar crujffalphaL("crujffalphaL", "crujffalphaL", 0.8, 0., 10.);
RooRealVar crujffalphaR("crujffalphaR", "crujffalphaR", 0.8, 0., 10.);
RooCrujffPdf crujff_s("crujff_s", "crujff_s", combinedPfIso03Phot, crujffmean, crujffsigmaL, crujffsigmaR, crujffalphaL, crujffalphaR);
RooRealVar CBC_mean("CBC_mean", "CBC_mean", -1., -10., 0.);
RooRealVar CBC_sigma("CBC_sigma", "CBC_sigma", 1., 0., 10.);
RooRealVar CBC_alphaC("CBC_alphaC", "CBC_alphaC", 0.7, 0., 10.);
RooRealVar CBC_alphaCB("CBC_alphaCB", "CBC_alphaCB", 0.7, 0., 10.);
RooRealVar CBC_n("CBC_n", "CBC_n", 9., 0., 300.);
RooCBCrujffPdf CBCrujff_s("CBCrujff_s", "CBCrujff_s", combinedPfIso03Phot, CBC_mean, CBC_sigma, CBC_alphaC, CBC_alphaCB, CBC_n);
RooRealVar gaussmean("gaussmean","gaussmean", -1.33, -10., 0.);
RooRealVar gausssigma("gausssigma", "gausssigma", 1.1, 0., 5.);
RooGaussian my_gauss_s("my_gauss_s", "my_gauss_s", combinedPfIso03Phot, gaussmean, gausssigma);
RooRealVar nsig("nsig", "expexted number of ev for sig", 250000., 10., 100000000.);
RooRealVar nbg_s("nbg_s", "expexted number of ev for bg, scut", 250000., 10., 100000000.);
RooRealVar cbmean("cbmean", "cbmean", -0.872, -10., 1.);
RooRealVar cbsigma1("cbsigma1", "cbsigma1", 0.9, 0., 5.);
RooRealVar cbsigma2("cbsigma2", "cbsigma2", 1.1, 1.1, 1.1);
RooRealVar cbalpha_s("cbalpha_s", "cbaplha_s", -0.840, -10., 0.);
RooRealVar cbn_s("cbn_s","cbn_s", 9., 0., 300.);
RooCBShape my_cb_s("my_cb_s", "my_cb_s", combinedPfIso03Phot, cbmean, cbsigma1, cbalpha_s, cbn_s);
AsymmCBShapeVittorio my_asymm_cb("my_cb_s", "my_cb_s", combinedPfIso03Phot, gaussmean, cbsigma1, gausssigma, cbalpha_s, cbn_s);
RooRealVar frac_s("frac_s", "frac_s", 0.8, 0., 1.);
//Gaussian to constrain fraction f in [f*CB + (1-f)*Gauss]
RooGaussian frac_constraint("frac_constraint", "frac_constraint", frac_s, RooConst(0.977),RooConst(0.1));
RooAddPdf my_add_s("my_add_s", "my_add_s", my_asymm_cb, my_gauss_s, frac_s);
// RooExtendPdf ext_pdf_s("ext_pdf_s", "ext_pdf_s", my_add_s, nbg_s);
RooProdPdf my_add_s_constrained("my_add_s_constrained", "my_add_s_constrained", RooArgSet(my_add_s, frac_constraint));
/*RooDataSet* d = my_add_s.generate(RooArgSet(combinedPfIso03Phot), 100000);
RooDataHist* dh_s = d->binnedClone();*/
RooFitResult* result = CBCrujff_s.fitTo(*d_s/*, Constrain(frac_s)*/, Save(), Range(-5.,15.), /* Extended(kTRUE), */ SumW2Error(kTRUE));
RooPlot* frame_s = combinedPfIso03Phot.frame(RooFit::Title("Fit to combinedPfIso03Phot, scut region"));
d_s->plotOn(frame_s, Name("dh_s"));
CBCrujff_s.plotOn(frame_s,Name("pdf_s"),LineColor(kCyan)/*, Normalization(1.,RooAbsReal::RelativeExpected)*/) ;
//my_asymm_cb.plotOn(frame_s, Name("my_cb"),RooFit::LineColor(kMagenta), Normalization(frac_s.getVal()));
// my_gauss_s.plotOn(frame_s, Name("my_gaussian"), RooFit::LineColor(kMagenta), Normalization((1-frac_s.getVal())));
frame_s->SetMinimum(0.00001);
TLegend* a = new TLegend(0.63,0.68, 0.88, 0.88);
a->SetBorderSize(0);
a->SetFillColor(0);
a->SetFillStyle(0);
a->SetTextSize(0.038);
a->AddEntry(frame_s->findObject("dh_s"), "MC","p");
a->AddEntry(frame_s->findObject("pdf_s"), "fitting PDF","l");
// a->AddEntry(frame_s->findObject("my_cb"), "PDF components","l");
TCanvas* c = new TCanvas();
c->SetTitle(frame_s->GetTitle());
frame_s->Draw("");
a->Draw();
c->SaveAs((filename+"_s.png").c_str());
c->SaveAs((filename+"_s.root").c_str());
Double_t chi2 = frame_s->chiSquare("pdf_s", "dh_s", 8);
std::cout<<"ChiSquared value, scut: "<<chi2<<std::endl;
c->SetLogy();
c->SetTitle(frame_s->GetTitle());
frame_s->Draw("");
a->Draw();
c->SaveAs((filename+"_s_log.png").c_str());
c->SaveAs((filename+"_s_log.root").c_str());
RooWorkspace* w_sig = new RooWorkspace("w_sig", "workspace");
w_sig->import(dh_s);
w_sig->import(CBCrujff_s);
w_sig->Print();
w_sig->writeToFile(("workspace_"+filename+".root").c_str());
TFile* f_fitRes = new TFile(("fitResult_"+filename+".root").c_str(), "RECREATE");
result->Write();
// f_fitRes->Write();
f_fitRes->Close();
}
void makejpsifit(string inputFilename, string outFilename,
Int_t ptBin, Int_t etaBin,
double minMass, double maxMass,
double mean_bw, double gamma_bw, double cutoff_cb, double power_cb,
const char* plotOpt, const int nbins, Int_t isMC) {
TStyle *mystyle = RooHZZStyle("ZZ");
mystyle->cd();
//Create Data Set
RooRealVar mass("zmass","m(e^{+}e^{-})",minMass,maxMass,"GeV/c^{2}");
// Reading everything from root tree instead
TFile *tfile = TFile::Open(inputFilename.c_str());
TTree *ttree = (TTree*)tfile->Get("zeetree/probe_tree");
hzztree *zeeTree = new hzztree(ttree);
RooArgSet zMassArgSet(mass);
RooDataSet* data = new RooDataSet("data", "ntuple parameters", zMassArgSet);
for (int i = 0; i < zeeTree->fChain->GetEntries(); i++) {
if(i%100000==0) cout << "Processing Event " << i << endl;
zeeTree->fChain->GetEntry(i);
//*************************************************************************
//Electron Selection
//*************************************************************************
// already passed for this tree
//*************************************************************************
//Compute electron four vector;
//*************************************************************************
double ele1pt = zeeTree->l1pt;
double ele2pt = zeeTree->l2pt;
double ELECTRONMASS = 0.51e-3;
TLorentzVector ele1FourVector;
ele1FourVector.SetPtEtaPhiM(zeeTree->l1pt, zeeTree->l1eta, zeeTree->l1phi, ELECTRONMASS);
TLorentzVector ele2FourVector;
ele2FourVector.SetPtEtaPhiM(zeeTree->l2pt, zeeTree->l2eta, zeeTree->l2phi, ELECTRONMASS);
//*************************************************************************
//pt and eta cuts on electron
//*************************************************************************
if (! (ele1pt > 7 && ele2pt > 7
&& fabs( zeeTree->l1eta) < 2.5
&& fabs( zeeTree->l2eta) < 2.5 )) continue;
//*************************************************************************
//pt bins and eta bins
//*************************************************************************
Int_t Ele1PtBin = -1;
Int_t Ele1EtaBin = -1;
Int_t Ele2PtBin = -1;
Int_t Ele2EtaBin = -1;
if (ele1pt > 7 && ele1pt < 10) Ele1PtBin = 0;
else if (ele1pt < 20) Ele1PtBin = 1;
else Ele1PtBin = 2;
if (ele2pt > 7 && ele2pt < 10) Ele2PtBin = 0;
else if (ele2pt < 20) Ele2PtBin = 1;
else Ele2PtBin = 2;
if (fabs(zeeTree->l1sceta) < 1.479) Ele1EtaBin = 0;
else Ele1EtaBin = 1;
if (fabs(zeeTree->l2sceta) < 1.479) Ele2EtaBin = 0;
else Ele2EtaBin = 1;
if (!(Ele1PtBin == ptBin || Ele2PtBin == ptBin)) continue;
if (!(Ele1EtaBin == etaBin && Ele2EtaBin == etaBin)) continue;
//*************************************************************************
// restrict range of mass
//*************************************************************************
double zMass = (ele1FourVector+ele2FourVector).M();
if (zMass < minMass || zMass > maxMass) continue;
//*************************************************************************
//set mass variable
//*************************************************************************
zMassArgSet.setRealValue("zmass", zMass);
data->add(zMassArgSet);
}
// do binned fit to gain time...
mass.setBins(nbins);
RooDataHist *bdata = new RooDataHist("data_binned","data_binned", zMassArgSet, *data);
cout << "dataset size: " << data->numEntries() << endl;
// // Closing file
// treeFile->Close();
//====================== Parameters===========================
//Crystal Ball parameters
// RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", -.01, -10, 10, "GeV/c^{2}");
// RooRealVar cbSigma("sigma_{CB}", "CB Width", 1.7, 0.8, 5.0, "GeV/c^{2}");
// RooRealVar cbCut ("a_{CB}","CB Cut", 1.05, 1.0, 3.0);
// RooRealVar cbPower("n_{CB}","CB Order", 2.45, 0.1, 20.0);
RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", -.01, -10, 10, "GeV/c^{2}");
RooRealVar cbSigma("#sigma_{CB}", "CB Width", 1.5, 0.01, 5.0, "GeV/c^{2}");
RooRealVar cbCut ("a_{CB}","CB Cut", 1.0, 1.0, 3.0);
RooRealVar cbPower("n_{CB}","CB Order", 2.5, 0.1, 20.0);
cbCut.setVal(cutoff_cb);
cbPower.setVal(power_cb);
// Just checking
//cbCut.Print();
//cbPower.Print();
//Breit_Wigner parameters
RooRealVar bwMean("m_{JPsi}","BW Mean", 3.096916, "GeV/c^{2}");
bwMean.setVal(mean_bw);
RooRealVar bwWidth("#Gamma_{JPsi}", "BW Width", 92.9e-6, "GeV/c^{2}");
bwWidth.setVal(gamma_bw);
// Fix the Breit-Wigner parameters to PDG values
bwMean.setConstant(kTRUE);
bwWidth.setConstant(kTRUE);
// Exponential Background parameters
RooRealVar expRate("#lambda_{exp}", "Exponential Rate", -0.064, -1, 1);
RooRealVar c0("c_{0}", "c0", 1., 0., 50.);
//Number of Signal and Background events
RooRealVar nsig("N_{S}", "# signal events", 524, 0.1, 10000000000.);
RooRealVar nbkg("N_{B}", "# background events", 43, 1., 10000000.);
//============================ P.D.F.s=============================
// Mass signal for two decay electrons p.d.f.
RooBreitWigner bw("bw", "bw", mass, bwMean, bwWidth);
RooCBShape cball("cball", "Crystal Ball", mass, cbBias, cbSigma, cbCut, cbPower);
RooFFTConvPdf BWxCB("BWxCB", "bw X crystal ball", mass, bw, cball);
// Mass background p.d.f.
RooExponential bg("bg", "exp. background", mass, expRate);
// Mass model for signal electrons p.d.f.
RooAddPdf model("model", "signal", RooArgList(BWxCB), RooArgList(nsig));
TStopwatch t ;
t.Start() ;
double fitmin, fitmax;
if(isMC) {
fitmin = (etaBin==0) ? 3.00 : 2.7;
fitmax = (etaBin==0) ? 3.20 : 3.4;
} else {
fitmin = (etaBin==0) ? ( (ptBin>=2) ? 3.01 : 3.02 ) : 2.7;
fitmax = (etaBin==0) ? ( (ptBin==3) ? 3.23 : 3.22 ) : 3.4;
}
RooFitResult *fitres = model.fitTo(*bdata,Range(fitmin,fitmax),Hesse(1),Minos(1),Timer(1),Save(1));
fitres->SetName("fitres");
t.Print() ;
TCanvas* c = new TCanvas("c","Unbinned Invariant Mass Fit", 0,0,800,600);
//========================== Plotting ============================
//Create a frame
RooPlot* plot = mass.frame(Range(minMass,maxMass),Bins(nbins));
// Add data and model to canvas
int col = (isMC ? kAzure+4 : kGreen+1);
data->plotOn(plot);
model.plotOn(plot,LineColor(col));
data->plotOn(plot);
model.paramOn(plot, Format(plotOpt, AutoPrecision(1)), Parameters(RooArgSet(cbBias, cbSigma, cbCut, cbPower, bwMean, bwWidth, expRate, nsig, nbkg)), Layout(0.15,0.45,0.80));
plot->getAttText()->SetTextSize(.03);
plot->SetTitle("");
plot->Draw();
// Print Fit Values
TLatex *tex = new TLatex();
tex->SetNDC();
tex->SetTextSize(.1);
tex->SetTextFont(132);
// tex->Draw();
tex->SetTextSize(0.057);
if(isMC) tex->DrawLatex(0.65, 0.75, "J/#psi #rightarrow e^{+}e^{-} MC");
else tex->DrawLatex(0.65, 0.75, "J/#psi #rightarrow e^{+}e^{-} data");
tex->SetTextSize(0.030);
tex->DrawLatex(0.645, 0.65, Form("BW Mean = %.2f GeV/c^{2}", bwMean.getVal()));
tex->DrawLatex(0.645, 0.60, Form("BW #sigma = %.2f GeV/c^{2}", bwWidth.getVal()));
c->Update();
c->SaveAs((outFilename + ".pdf").c_str());
c->SaveAs((outFilename + ".png").c_str());
// tablefile << Form(Outfile + "& $ %f $ & $ %f $ & $ %f $\\ \hline",cbBias.getVal(), cbSigma.getVal(), cbCut.getVal());
// Output workspace with model and data
RooWorkspace *w = new RooWorkspace("JPsieeMassScaleAndResolutionFit");
w->import(model);
w->import(*bdata);
w->writeToFile((outFilename + ".root").c_str());
TFile *tfileo = TFile::Open((outFilename + ".root").c_str(),"update");
fitres->Write();
tfileo->Close();
}
int main(){
BaBarStyle p;
p.SetBaBarStyle();
//gROOT->SetStyle("Plain");
Bool_t doNorm = kTRUE;
Bool_t doComparison = kFALSE;
Bool_t doFract = kFALSE;
Bool_t doFit = kFALSE;
Bool_t doPlots = kFALSE;
//define DalitzSpace for generation
EvtPDL pdl;
pdl.readPDT("evt.pdl");
EvtDecayMode mode("D0 -> K- pi+ pi0");
EvtDalitzPlot dalitzSpace(mode);
RooRealVar m2Kpi_d0mass("m2Kpi_d0mass","m2Kpi_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AB),dalitzSpace.qAbsMax(EvtCyclic3::AB));
RooRealVar m2Kpi0_d0mass("m2Kpi0_d0mass","m2Kpi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AC),dalitzSpace.qAbsMax(EvtCyclic3::AC));
RooRealVar m2pipi0_d0mass("m2pipi0_d0mass","m2pipi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::BC),dalitzSpace.qAbsMax(EvtCyclic3::BC));
RooCategory D0flav("D0flav","D0flav");
D0flav.defineType("D0",-1);
D0flav.defineType("antiD0",1);
//this is just to plot the m23 pdf
Float_t total = pow(dalitzSpace.bigM(),2) + pow(dalitzSpace.mA(),2) + pow(dalitzSpace.mB(),2) + pow(dalitzSpace.mC(),2);
RooRealVar totalm("totalm","totalm",total);
RooFormulaVar mass13a("mass13a","@0-@1-@2",RooArgSet(totalm,m2Kpi_d0mass,m2pipi0_d0mass));
cout << "read the dataset" << endl;
TFile hello("DataSet_out_tmp.root");
gROOT->cd();
RooDataSet *data = (RooDataSet*)hello.Get("fulldata");
RooDataSet *data_1 = (RooDataSet*)data->reduce("D0flav == 1 && isWS == 0 && d0LifetimeErr < 0.5 && d0Lifetime > -2. && d0Lifetime < 4.");
RooDataSet *finaldata = (RooDataSet*)data_1->reduce("deltaMass > 0.1449 && deltaMass < 0.1459 && d0Mass > 1.8495 && d0Mass < 1.8795");
RooDataSet *leftdata = (RooDataSet*)(RooDataSet*)data_1->reduce("d0Mass > 1.74 && d0Mass < 1.79");
RooDataSet *rightdata = (RooDataSet*)data_1->reduce("d0Mass > 1.94 && d0Mass < 1.99");
//here we set the weights for the dataset
finaldata->setWeightVar(0);
leftdata->setWeightVar(0);
rightdata->setWeightVar(0);
//if you want to have a little dataset to test, uncomment next line and rename finaldata above
//RooDataSet *finaldata = finaldata_1->reduce(EventRange(1,1000));
cout << "*************************************************************" << endl;
cout << "The final data entry " << finaldata->numEntries() << endl;
cout << "*************************************************************" << endl;
//Construct signal pdf
string dirname = "configmaps/effmapping_RS_CP/";
RooKpipi0pdf *D0pdf = new RooKpipi0pdf("D0pdf","D0pdf",m2Kpi_d0mass,m2Kpi0_d0mass,&dalitzSpace,dirname,1);
RooKpipi0pdf *D0pdf23 = new RooKpipi0pdf("D0pdf23","D0pdf23",m2Kpi_d0mass,mass13a,&dalitzSpace,dirname,1);
if(doNorm) D0pdf->getManager()->calNorm();
//When we plot the 1D projection, need to calculate the 1D integral
//set the precision here
//cout << "config integrator " << endl;
RooNumIntConfig *cfg = RooAbsReal::defaultIntegratorConfig();
cfg->setEpsAbs(1E-3);
cfg->setEpsRel(1E-3);
cfg->method1D().setLabel("RooSegmentedIntegrator1D");
//cfg.getConfigSection("RooSegmentedIntegrator1D").setRealValue("numSeg",3);
//cfg->method1D()->Print("v");
D0pdf->setIntegratorConfig(*cfg);
D0pdf23->setIntegratorConfig(*cfg);
cout << "about to init" << endl;
m2Kpi_d0mass.setBins(150);
m2Kpi0_d0mass.setBins(150);
m2pipi0_d0mass.setBins(150);
//background description
//RooBkg combdalitz("combdalitz","combdalitz",m2Kpi_d0mass,m2Kpi0_d0mass,&dalitzSpace);
//RooBkg combdalitz23("combdalitz23","combdalitz23",m2Kpi_d0mass,mass13a,&dalitzSpace);
RooRealVar Nsig("Nsig","Nsig", 653962. + 2218.);
RooRealVar Nbkg("Nbkg","Nbkg", 2255. + 551.);
RooDataHist* dbdalitz = new RooDataHist("dbdalitz","dbdalitz",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*finaldata);
RooDataHist* dbdalitz23 = new RooDataHist("dbdalitz23","dbdalitz23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*finaldata);
////////////////////////////////////////
//background parametrization using sidebands histograms
////////////////////////////////////////
TH2F *lefth = m2Kpi_d0mass.createHistogram("lefth",m2Kpi0_d0mass);
leftdata->fillHistogram(lefth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass));
TH2F *righth = m2Kpi_d0mass.createHistogram("righth",m2Kpi0_d0mass);
rightdata->fillHistogram(righth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass));
TH2F *lefth23 = m2Kpi_d0mass.createHistogram("lefth23",m2pipi0_d0mass);
leftdata->fillHistogram(lefth23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass));
TH2F *righth23 = m2Kpi_d0mass.createHistogram("righth23",m2pipi0_d0mass);
rightdata->fillHistogram(righth23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass));
righth->Scale(lefth->Integral()/righth->Integral());
lefth->Sumw2();
righth->Sumw2();
righth23->Scale(lefth23->Integral()/righth23->Integral());
lefth23->Sumw2();
righth23->Sumw2();
RooDataHist *lefthist = new RooDataHist("lefthist","lefthist",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),lefth);
RooDataHist *righthist = new RooDataHist("righthist","righthist",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),righth);
RooDataHist *lefthist23 = new RooDataHist("lefthist23","lefthist23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),lefth23);
RooDataHist *righthist23 = new RooDataHist("righthist23","righthist23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),righth23);
RooHistPdf leftpdf("leftpdf","leftpdf",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*lefthist,4);
RooHistPdf rightpdf("rightpdf","rightpdf",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*righthist,4);
RooHistPdf leftpdf23("leftpdf23","leftpdf23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*lefthist23,4);
RooHistPdf rightpdf23("rightpdf23","rightpdf23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*righthist23,4);
RooRealVar fcomb("fcomb","fcomb",0.738);
RooAddPdf combdalitz("combdalitz","combdalitz",RooArgList(leftpdf,rightpdf),RooArgList(fcomb));
RooAddPdf combdalitz23("combdalitz23","combdalitz23",RooArgList(leftpdf23,rightpdf23),RooArgList(fcomb));
///////////////////////////////////////
RooAddPdf totpdf("totpdf","totpdf",RooArgList(*D0pdf,combdalitz),RooArgList(Nsig,Nbkg));
RooAddPdf totpdf23("totpdf23","totpdf23",RooArgList(*D0pdf23,combdalitz23),RooArgList(Nsig,Nbkg));
if(doFit){
// Start Minuit session on Chi2
RooChi2Var chi2("chi2","chi2",totpdf,*dbdalitz);
RooMinuit m2(chi2);
m2.migrad();
m2.hesse();
RooFitResult* fitRes = m2.save();
fitRes->Print("v");
RooArgSet results(fitRes->floatParsFinal());
RooArgSet conresults(fitRes->constPars());
results.add(conresults);
results.writeToFile("fit_isobar_RS.txt");
//save the stupid result
TFile f("fit_RSDalitz_result.root","RECREATE");
fitRes->Write();
f.Close();
}
if(doFract) {
cout << "Calculating fit fractions" << endl;
TFile f("fit_RSDalitz_result.root");
RooFitResult* fitRes = (RooFitResult*)f.Get("chi2");
//now calculate the fit fractions
const Int_t nRes = D0pdf->getManager()->getnRes();
//recalculate the normalization if necessary
D0pdf->getManager()->calNorm();
EvtComplex normarray[nRes][nRes];
const Int_t myRes = 12;
TH1F fitty[myRes];
//read the integral value from the cache file.
//In this way we don't need to compute the normalization everytime during MIGRAD
char int_name[50];
D0pdf->getManager()->getFileName(int_name);
ifstream f1;
f1.open(int_name);
if (!f1){
cout << "Error opening file " << endl;
assert(0);
}
Double_t re=0.,im=0.;
//Read in the cache file and store back to array
for(Int_t j=0;j<nRes;j++) {
char thname[100];
sprintf(thname,"thname_%d",j);
if(j < myRes) fitty[j] = TH1F(thname,thname,30,0.,1.);
for(Int_t k=0;k<nRes;k++){
f1 >> re >> im;
normarray[j][k] = EvtComplex(re,im);
}
}
EvtComplex mynorm[myRes][myRes];
Int_t m = 0, l = 0;
for(Int_t i=0;i<myRes;i++){
for(Int_t j=0;j<myRes;j++){
if(i==0) l = 7;
else if(i==1) l = 6;
else if(i==2) l = 11;
else if(i==3) l = 4;
else if(i==4) l = 5;
else if(i==5) l = 3;
else if(i==6) l = 9;
else if(i==7) l = 10;
else if(i==8) l = 12;
else if(i==9) l = 8;
else if(i==10) l = 2;
else if(i==11) l = 0;
if(j==0) m = 7;
else if(j==1) m = 6;
else if(j==2) m = 11;
else if(j==3) m = 4;
else if(j==4) m = 5;
else if(j==5) m = 3;
else if(j==6) m = 9;
else if(j==7) m = 10;
else if(j==8) m = 12;
else if(j==9) m = 8;
else if(j==10) m = 2;
else if(j==11) m = 0;
mynorm[i][j] = normarray[l][m];
}
}
//do 100 experiments and extract parameters using covariance matrix
for(Int_t l=0;l<300;l++){
RooArgList listpar = fitRes->randomizePars();
if(l==0) listpar.Print();
Double_t mynormD0 = 0.;
EvtComplex coeff_i(0.,0.), coeff_j(0.,0.);
for(Int_t i=0;i<2*myRes;i++){
for(Int_t j=0;j<2*myRes;j++){
if(i==(2*myRes - 2)) coeff_i = EvtComplex(1.,0.);
else coeff_i = EvtComplex(((RooAbsReal*)listpar.at(i))->getVal()*cos(((RooAbsReal*)listpar.at(i+1))->getVal()),
((RooAbsReal*)listpar.at(i))->getVal()*sin(((RooAbsReal*)listpar.at(i+1))->getVal()));
if(j==(2*myRes - 2)) coeff_j = EvtComplex(1.,0.);
else coeff_j = EvtComplex(((RooAbsReal*)listpar.at(j))->getVal()*cos(((RooAbsReal*)listpar.at(j+1))->getVal()),
((RooAbsReal*)listpar.at(j))->getVal()*sin(((RooAbsReal*)listpar.at(j+1))->getVal()));
mynormD0 += real(coeff_i*conj(coeff_j)*(mynorm[i/2][j/2]));
j++;
}
i++;
}
//now calculate the fit fractions
for(Int_t i=0;i<2*myRes;i++){
Double_t fitfrac = 0.;
if(i==(2*myRes - 2)) fitfrac = abs(mynorm[i/2][i/2])/mynormD0;
else fitfrac = abs2( ((RooAbsReal*)listpar.at(i))->getVal())*abs(mynorm[i/2][i/2])/mynormD0;
fitty[i/2].Fill(fitfrac);
i++;
}
}// nexperiments
Double_t tot_frac = 0.;
for(Int_t i=0;i<myRes;i++){
tot_frac += fitty[i].GetMean();
cout << "Resonance " << i << ": fit fraction = " << fitty[i].GetMean() << " +/- " << fitty[i].GetRMS() << endl;
}
cout << "Total fit fraction = " << tot_frac << endl;
cout << "///////////////////////////" << endl;
}
if(doPlots){
//Make the plots
// REMEBER: if you want roofit to consider the reweighted errors, you must put DataError(RooAbsData::SumW2))
//******************************************************
RooPlot* xframe = m2Kpi_d0mass.frame();
dbdalitz->plotOn(xframe,MarkerSize(0.1),DrawOption("z"));
totpdf.plotOn(xframe);
xframe->getAttLine()->SetLineWidth(1);
xframe->getAttLine()->SetLineStyle(1);
xframe->SetTitle("");
xframe->GetXaxis()->SetTitle("s_{12} [GeV^{2}/c^{4}]");
xframe->GetYaxis()->SetTitle("Events/4 MeV^{2}/c^{4}");
Double_t chi2Kpi = xframe->chiSquare();
RooPlot* yframe = m2Kpi0_d0mass.frame();
dbdalitz->plotOn(yframe,MarkerSize(0.1),DrawOption("z"));
totpdf.plotOn(yframe);
yframe->getAttLine()->SetLineWidth(1);
yframe->getAttLine()->SetLineStyle(1);
yframe->SetTitle("");
yframe->GetXaxis()->SetTitle("s_{13} [GeV^{2}/c^{4}]");
yframe->GetYaxis()->SetTitle("Events/5 MeV^{2}/c^{4}");
Double_t chi2Kpi0 = yframe->chiSquare();
/*
RooPlot* zframe = m2pipi0_d0mass.frame(0.,2.3);
dbdalitz23->plotOn(zframe,MarkerSize(0.1),DrawOption("z"));
totpdf23.plotOn(zframe);
zframe->getAttLine()->SetLineWidth(1);
zframe->getAttLine()->SetLineStyle(1);
zframe->SetTitle("");
zframe->GetXaxis()->SetTitle("m^{2}_{#pi^{+}#pi^{0}}");
Double_t chi2pipi0 = zframe->chiSquare();
cout << "Chi2 for Kpi = " << chi2Kpi << endl;
cout << "Chi2 for Kpi0 = " << chi2Kpi0 << endl;
cout << "Chi2 for pipi0 = " << chi2pipi0 << endl;
RooPlot* pullFramem12 = m2Kpi_d0mass.frame() ;
pullFramem12->SetTitle("");
pullFramem12->GetXaxis()->SetTitle("");
pullFramem12->addPlotable(xframe->pullHist()) ;
pullFramem12->SetMaximum(5.);
pullFramem12->SetMinimum(-5.);
RooPlot* pullFramem13 = m2Kpi0_d0mass.frame() ;
pullFramem13->SetTitle("");
pullFramem13->GetXaxis()->SetTitle("");
pullFramem13->addPlotable(yframe->pullHist()) ;
pullFramem13->SetMaximum(5.);
pullFramem13->SetMinimum(-5.);
RooPlot* pullFramem23 = m2pipi0_d0mass.frame() ;
pullFramem23->SetTitle("");
pullFramem23->GetXaxis()->SetTitle("");
pullFramem23->addPlotable(zframe->pullHist()) ;
pullFramem23->SetMaximum(5.);
pullFramem23->SetMinimum(-5.);
TCanvas *c2 = new TCanvas("c2","residuals",1200,200);
c2->Divide(3,1);
c2->cd(1);pullFramem12->Draw();
c2->cd(2);pullFramem13->Draw();
c2->cd(3);pullFramem23->Draw();
c2->SaveAs("RSresiduals.eps");
*/
totpdf.plotOn(xframe,Project(m2Kpi0_d0mass),Components(RooArgSet(combdalitz)),DrawOption("F"),FillColor(kRed));
totpdf.plotOn(yframe,Project(m2Kpi_d0mass),Components(RooArgSet(combdalitz)),DrawOption("F"),FillColor(kRed));
//totpdf23.plotOn(zframe,Project(m2Kpi_d0mass),Components(RooArgSet(combdalitz23)),DrawOption("F"),FillColor(kRed));
TPaveText *box_m12 = new TPaveText(2.5,2.5,2.7,2.7,"");
box_m12->AddText("(b)");
box_m12->SetFillColor(10);
TPaveText *box_m13 = new TPaveText(2.5,2.5,2.7,2.7,"");
box_m13->AddText("(c)");
box_m13->SetFillColor(10);
TCanvas c1("c1","c1",600,600);
c1.cd();
xframe->Draw();box_m12->Draw("SAME");
c1.SaveAs("RSfit_m2Kpi.eps");
TCanvas c2("c2","c2",600,600);
c2.cd();
yframe->Draw();box_m13->Draw("SAME");
c2.SaveAs("RSfit_m2Kpi0.eps");
/*
TCanvas *c1 = new TCanvas("c1","allevents",1200,400);
c1->Divide(3,1);
c1->cd(1);xframe->Draw();
//p.SetBaBarLabel(-1,-1,-1,"preliminary");
c1->cd(2);yframe->Draw();
//p.SetBaBarLabel(-1,-1,-1,"preliminary");
c1->cd(3);zframe->Draw();
//p.SetBaBarLabel(-1,-1,-1,"preliminary");
c1->SaveAs("RSsigfit.eps");
*/
}
if(doComparison){
RooDataSet *littledata = (RooDataSet*)finaldata->reduce(EventRange(1,70000));
RooArgSet VarList1(m2Kpi_d0mass,m2Kpi0_d0mass);
Int_t num_entries = littledata->numEntries();
RooDataSet* genpdf = D0pdf->generate(VarList1,num_entries);
Int_t nbinx = 20;
Int_t nbiny = 20;
m2Kpi_d0mass.setBins(nbinx);
m2Kpi0_d0mass.setBins(nbiny);
TH2F* pdfhist = new TH2F("pdfhist","pdfhist",nbinx,0.39,3.,nbiny,0.39,3.);
TH2F* datahist = new TH2F("datahist","datahist",nbinx,0.39,3.,nbiny,0.39,3.);
pdfhist = genpdf->createHistogram(m2Kpi_d0mass,m2Kpi0_d0mass);
datahist = finaldata->createHistogram(m2Kpi_d0mass,m2Kpi0_d0mass);
pdfhist->GetXaxis()->SetTitle("m_{K#pi}^{2}");
pdfhist->GetYaxis()->SetTitle("m_{K#pi^{0}}^{2}");
pdfhist->Scale(datahist->Integral()/pdfhist->Integral());
pdfhist->Add(datahist,-1.);
TCanvas c2;
c2.cd();pdfhist->Draw("LEGO2Z");
c2.SaveAs("RSsigdiff.eps");
TFile ftmp("prova.root","RECREATE");
ftmp.cd();pdfhist->Write();
ftmp.Close();
}
return 0;
}//end of the macro
float PurityFit::fit_specific( const TH1* h_, const TH1* sig_, const TH1* bkg_,
string name, // unique name of the result
string outname , // output file name, where to save results
map<string,float> *pars // to gather additional params
)
{
// 1) perform preliminary checks
if ( h_ == NULL ) { cout<<"[PurityFit]::[fit_specific]::[ERROR] no target histogram"<<endl; return -1;}
if ( sig_ == NULL ) { cout<<"[PurityFit]::[fit_specific]::[ERROR] no sig histogram"<<endl; return -1;}
if ( bkg_ == NULL ) { cout<<"[PurityFit]::[fit_specific]::[ERROR] no bkg histogram"<<endl; return -1;}
if (sig_ -> Integral() == 0 ) { cout<<"[PurityFit]::[fit_specific]::[ERROR] sig integrall is NULL"<<endl; return -2;}
if (bkg_ -> Integral() == 0 ) { cout<<"[PurityFit]::[fit_specific]::[ERROR] bkg integrall is NULL"<<endl; return -2;}
if (verbose_ >0) cout <<"[PurityFit]::[fit_specific]::[INFO] fitting "<<h_->GetName() << " " << sig_->GetName()<<" "<<bkg_->GetName()<<endl;
// 1.5) Clone
TH1 * sig = (TH1*)sig_ -> Clone(Form("%s_fitspecific_clone",sig_->GetName()));
TH1 * bkg = (TH1*)bkg_ -> Clone(Form("%s_fitspecific_clone",bkg_->GetName()));
TH1 * h = (TH1*)h_ -> Clone(Form("%s_fitspecific_clone",h_->GetName()));
// 1.6) check no negative entries otherwise 0
for(int i=1;i<=sig->GetNbinsX();++i)
if(sig->GetBinContent(i) <0) sig->SetBinContent(i,0);
for(int i=1;i<=bkg->GetNbinsX();++i)
if(bkg->GetBinContent(i) <0) bkg->SetBinContent(i,0);
// 2) scale templates: template normalization is meaningless
sig->Sumw2();
bkg->Sumw2();
if (bkg->Integral() <=0)
{
for(int i=1;i<=bkg->GetNbinsX();++i)
bkg->SetBinContent(i,1.0);
}
// 2.5) fit background with exponential
int nbins = h->GetNbinsX();
float xmin = h->GetBinLowEdge(1);
float xmax = h->GetBinLowEdge(nbins+1);
double prevChi2=-1;
vector<TCanvas*> cbkgs;
vector<TF1> expos;
double cached_pars[50]; //cache
for(int i=0;i< sizeof(cached_pars)/sizeof(double); ++i) cached_pars[i]=0;
int poln=0;
for( poln=0;poln<5; ++poln)
{
string formula = "TMath::Exp(-[0]*x) * ( ";
for(int i=0;i<=poln;++i)
{
if (i>0 ) formula += " + ";
formula += Form("[%d]",i+1);
if (i>0) formula += Form("*TMath::Power(x,%d)",i);
}
formula += ")";
cout <<"Considering Formula"<<formula<<endl;
TF1 expo(Form("expo%d",poln),formula.c_str(),xmin,xmax);
expo.SetParameter(0,0.01);
expo.SetParameter(1,0.05);
expo.SetParLimits(0,TMath::Min(bkg->Integral()*.1,0.001), bkg->Integral()*10);
expo.SetParLimits(1,1e-9, 1.);
if (poln>0)for(int k=0;k < poln+1;++k) expo.SetParameter(k, cached_pars[k]);
bkg->Fit( &expo ,"QN") ;
bkg->Fit( &expo ,"QNM") ;
expos.push_back(expo);
//cache parameters
for(int k=0;k < poln+1;++k) cached_pars[k]=expo.GetParameter(k);
double chi2=expo.GetChisquare();
double prob = 0 ;
if (poln > 0)
{
int n = 0;
for(int i=1;i<=bkg->GetNbinsX();++i) if ( bkg->GetBinContent(i)> 0 ) ++n;
int dof = n - (poln+2) + 1;
double f = (prevChi2 - chi2) / ( chi2 /dof) ;
prob= 1.- TMath::FDistI (f , 1, dof ) ;
}
prevChi2 = chi2;
cout<<"----------- BKG PARAMETERS ARE -------"<<endl;
cout << "Prob = "<<prob<<endl;
cout << "chi2 = "<<chi2<<endl;
cout<<" 0 : "<< expo.GetParameter(0) <<endl;
for(int i=0; i<=poln;++i)
cout<<" "<< i+1 <<" : "<< expo.GetParameter(i+1) <<endl;
cout<<"--------------------------------------"<<endl;
TCanvas *cbkg=new TCanvas( (string(name)+"_bkgfit"+ Form("pol%d",poln)).c_str(),"Canvas"); cbkgs.push_back(cbkg);
bkg->Clone("bkgForDraw")->Draw("P E"); // FIXME, memory leak
expo.DrawClone("L SAME");
if (prob >0.05 and poln> 0) break; // ---------------------- EXIT BEFORE UPDATING
}
poln -= 1; // the last has a negligible improvement
for(int i=1;i<=bkg->GetNbinsX() ;++i)
bkg->SetBinContent(i,expos[poln].Integral( bkg->GetBinLowEdge(i),bkg->GetBinLowEdge(i+1) ) ) ;
if (sig->Integral() >0)
sig -> Scale( 1./sig->Integral() );
if (bkg->Integral() >0)
bkg -> Scale( 1./bkg->Integral() );
// 3) estimate paramaters
// float fracEstimator=0.5;
// {
// // 3.1) compute frac as around the max of sig
// float sigMax= sig->GetMaximum();
// int sigBinMax= sig->GetMaximumBin();
// float sigInt= sig->Integral();
// float bkgUnderMax=bkg->GetBinContent(sigBinMax);
// float targetMax = h->GetMaximum();
// float targetInt = h->Integral();
// float frac1=(targetMax/targetInt)/( (sigMax-bkgUnderMax)/sigInt);
// // 3.2) compute frac as tail
// float bkgInt= bkg->Integral();
// int bkgN=bkg->GetNbinsX();
// int nTailSum= bkgN/10;
// float bkgTail=0;for(int i=0;i<nTailSum;i++) bkgTail+= bkg->GetBinContent(bkgN-i);
// int targetN=h->GetNbinsX();
// float targetTail=0;for(int i=0;i<nTailSum;i++) targetTail+= h->GetBinContent(targetN-i);
// float frac2=1.- (targetTail/targetInt)/(bkgTail/bkgInt);
// // 3.3) set estimator
// fracEstimator = frac1;
// if(fracEstimator<0.05 or fracEstimator>0.95) fracEstimator=frac2;
// if(fracEstimator<0.05 or fracEstimator>0.95) fracEstimator=0.8;
// }
// 4) create roofit variables
RooRealVar f("f","fraction",0.95,0.3,1.0);
//if ( TMath::IsNaN( fracEstimator ) )
// f.setVal(0.05);
//else
// f.setVal(fracEstimator);
f.setRange(0.3,1.0);
f.setConstant(false);
RooRealVar x("x","EtMiss",xmin,xmax);
// 5) create roo data hist
RooDataHist HistSig("sig","hist sig",x,sig);
RooDataHist HistBkg("bkg","hist bkg",x,bkg);
RooDataHist HistToFit("target","hist target",x,h);
// 6) create roo hist pdf
RooHistPdf PdfSig("pdfsig","pdfsig",x,HistSig,0);
RooHistPdf PdfBkg("pdfbkg","pdfbkg",x,HistBkg,10); //last number is interpolation
// 7) create model
RooAddPdf PdfModel("model","model",RooArgList(PdfSig,PdfBkg),f);
// 8) fit
RooFitResult *r;
RooPlot *frame=x.frame();
RooMsgService::instance().setSilentMode(true);
PdfModel.fitTo(HistToFit,
SumW2Error(kTRUE),
Save(),
PrintEvalErrors(-1),
PrintLevel(-1),
//Minos(kTRUE),
Warnings(0)
);
r = PdfModel.fitTo(HistToFit,
SumW2Error(kTRUE),
Save(),
PrintEvalErrors(-1),
PrintLevel(-1),
Minos(kTRUE),
Warnings(0)
);
cout <<" -------------- FLOATING -------------"<<endl;
r-> floatParsInit() . Print("V");
cout <<" -------------- FINAL ----------------"<<endl;
r-> floatParsFinal() . Print("V");
cout <<" -------------------------------------"<<endl;
// 8.5) save additional results
if (pars != NULL ) {
(*pars)["fracErrorHigh"] = f.getAsymErrorHi();
(*pars)["fracErrorLow" ] = f.getAsymErrorLo();
}
// 9) plot
HistToFit.plotOn(frame,DataError(RooAbsData::SumW2));
PdfModel.plotOn(frame, LineColor(kBlack));
PdfModel.plotOn(frame, Components(PdfBkg),LineColor(kRed));
PdfModel.plotOn(frame, Components(PdfSig),LineColor(kBlue),LineStyle(kDashed));
TCanvas *c=new TCanvas((string(name)+"_canvas").c_str(),"Canvas");
c->cd();
c->Draw();
frame->Draw();
TLatex* txt = new TLatex();//Form("Fraction=%.1f\%",f.getVal()*100) ;
txt->SetTextSize(0.03) ;
txt->SetTextColor(kBlack) ;
txt->SetNDC();
txt->SetTextAlign(22);
//txt->AddText(Form("Fraction=%.1f\%",f.getVal()*100) );
txt->DrawLatex(.3,.85,Form("Fraction=%.1f%%",float(f.getVal()*100)));
// get pt from name
{
size_t n = name.find("pt");
float ptmin = -1;
float ptmax = -1;
if (n != string::npos)
{
string pts = "";
//name[n+0] == 'p'
//name[n+1] =='t'
n +=2;
//all string are null terminated in C/C++
while ( name[n] != '_' and name[n] != '\0' ) { pts+=name[n]; ++n;}
ptmin = atof( pts.c_str() ) ;
pts="";
++n;
while ( name[n] != '_' and name[n] != '\0' ) { pts+=name[n]; ++n;}
ptmax = atof( pts.c_str() ) ;
txt->DrawLatex(.3,.82,Form("%.1f<P_{T}<%.1f",ptmin,ptmax));
}
} // end get pt from name
if ( outname != "")
{
TFile *fOut=TFile::Open(outname.c_str(),"UPDATE");
fOut->cd();
c->Write();
for( auto c : cbkgs ) c->Write();
r->Write(Form("%s_roofit",name.c_str() ) );
fOut->Close();
}
// delete the clone
for( auto c : cbkgs ) c->Delete();
cbkgs.clear();
sig -> Delete();
bkg -> Delete();
h -> Delete();
return f.getVal();
}
void fitDebug_Data(string cut, string filename, string ptMin, string ptMax, string hlt, int config, string inputdir, string inputdir_sig, string outdir, int isFPR, int isEB){
//string outdir = "fitData_weightedDataCS_FPR_config2/";
//string workdir_mc = "../fit_FPR/";
RooRealVar combinedPfIso03Phot("combinedPfIso03Phot", "combinedPfIso03Phot", -7., 15.);
RooRealVar combinedPfIsoFPR03Phot("combinedPfIsoFPR03Phot", "combinedPfIsoFPR03Phot", -7., 15.);
RooRealVar etaPhot("etaPhot", "etaPhot", -2.5, 2.5);
RooRealVar mvaIdPhot("mvaIdPhot", "mvaIdPhot", -1.,1.);
RooRealVar isMatchedPhot("isMatchedPhot","isMatchedPhot", -1., 2.);
RooRealVar ptPhot("ptPhot", "ptPhot", 0., 1000.);
RooArgSet argSet("argSet");
//creating set of variables for the datasets
std::cout<<"Creating RooArgSet with variables for fit"<<std::endl;
argSet.add(combinedPfIso03Phot);
argSet.add(combinedPfIsoFPR03Phot);
argSet.add(etaPhot);
argSet.add(mvaIdPhot);
argSet.add(isMatchedPhot);
argSet.add(ptPhot);
std::cout<<"set binning"<<std::endl;
//models from fitted MC
TFile* f_ws_sig;
TFile* f_ws_bg;
if(isEB) {
if(ptMin<65) f_ws_sig = new TFile((inputdir_sig+"workspace_fit_EB_sig_WP095_pt40_65.root").c_str(), "READ");
if(ptMin<90) f_ws_sig = new TFile((inputdir_sig+"workspace_fit_EB_sig_WP095_pt65_90.root").c_str(), "READ");
if(ptMin<135) f_ws_sig = new TFile((inputdir_sig+"workspace_fit_EB_sig_WP095_pt90_135.root").c_str(), "READ");
else f_ws_sig = new TFile((inputdir_sig+"workspace_fit_EB_sig_WP095_pt135_165.root").c_str(), "READ");
// f_ws_sig = new TFile((inputdir+"workspace_fit_EB_bg_WP095_pt"+ptMin+"_"+ptMax+".root").c_str(), "READ");
f_ws_bg = new TFile((inputdir+"workspace_fit_EB_bg_WP095_pt"+ptMin+"_"+ptMax+".root").c_str(), "READ");
}
else{
if(ptMin<65) f_ws_sig = new TFile((inputdir_sig+"workspace_fit_EE_sig_WP095_pt40_65.root").c_str(), "READ");
if(ptMin<90) f_ws_sig = new TFile((inputdir_sig+"workspace_fit_EE_sig_WP095_pt65_90.root").c_str(), "READ");
if(ptMin<135) f_ws_sig = new TFile((inputdir_sig+"workspace_fit_EE_sig_WP095_pt90_135.root").c_str(), "READ");
else f_ws_sig = new TFile((inputdir_sig+"workspace_fit_EE_sig_WP095_pt135_165.root").c_str(), "READ");
// f_ws_sig = new TFile((inputdir+"workspace_fit_EE_bg_WP095_pt"+ptMin+"_"+ptMax+".root").c_str(), "READ");
f_ws_bg = new TFile((inputdir+"workspace_fit_EE_bg_WP095_pt"+ptMin+"_"+ptMax+".root").c_str(), "READ");
}
RooWorkspace* w_sig =(RooWorkspace*)f_ws_sig->Get("w_sig");
w_sig->Print();
RooWorkspace* w_bg =(RooWorkspace*)f_ws_bg->Get("w_bg");
w_bg->Print();
//model for signal
RooRealVar data_CBC_mean("data_CBC_mean", "data_CBC_mean", w_sig->var("CBC_mean")->getVal(), -2., 3.);
data_CBC_mean.Print();
RooRealVar data_CBC_sigma("data_CBC_sigma", "data_CBC_sigma", w_sig->var("CBC_sigma")->getVal(), 0., 3.);
data_CBC_sigma.Print();
RooRealVar data_CBC_alphaCB("data_CBC_alphaCB", "data_CBC_alphaCB", w_sig->var("CBC_alphaCB")->getVal(), 0., 3.);
RooRealVar data_CBC_n("data_CBC_n", "data_CBC_n", w_sig->var("CBC_n")->getVal(), 0., 100.);
RooCBShape* model_sig;
if (isFPR)
model_sig = new RooCBShape("model_sig", "model_sig", combinedPfIsoFPR03Phot, data_CBC_mean, data_CBC_sigma, data_CBC_alphaCB, data_CBC_n);
else
model_sig = new RooCBShape("model_sig", "model_sig", combinedPfIso03Phot, data_CBC_mean, data_CBC_sigma, data_CBC_alphaCB, data_CBC_n);
if(config==0){
data_CBC_mean.setConstant(kTRUE);
data_CBC_sigma.setConstant(kTRUE);
data_CBC_alphaCB.setConstant(kTRUE);
data_CBC_n.setConstant(kTRUE);
}
if(config==1){
data_CBC_sigma.setConstant(kTRUE);
data_CBC_alphaCB.setConstant(kTRUE);
data_CBC_n.setConstant(kTRUE);
}
if(config==2){
data_CBC_alphaCB.setConstant(kTRUE);
data_CBC_n.setConstant(kTRUE);
}
if(config==3){
data_CBC_n.setConstant(kTRUE);
}
//model for background
//////////////////////////////////////////////////////////////////////////////////////////
//RooKeysPdf* model_bg = (RooKeysPdf*)w_bg->pdf("kest3"); //smoothing = 1.5
RooKeysPdf* model_bg = (RooKeysPdf*)w_bg->pdf("kest1"); //smoothing = 1
model_bg->SetName("model_bg");
model_bg->SetTitle("model_bg");
TChain data("myTrees_withWeight");
string input_dir="/cmshome/gdimperi/GammaJet/GammaJetAnalysis/CMSSW_5_3_11/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/";
if(hlt=="hltcut30")
data.Add((input_dir+"data2012ABCD_withWeights_hlt30.root").c_str());
if(hlt=="hltcut50")
data.Add((input_dir+"data2012ABCD_withWeights_hlt50.root").c_str());
if(hlt=="hltcut75")
data.Add((input_dir+"data2012ABCD_withWeights_hlt75.root").c_str());
if(hlt=="hltcut90")
data.Add((input_dir+"data2012ABCD_withWeights_hlt90.root").c_str());
if(hlt=="hltcut135")
data.Add((input_dir+"data2012ABCD_withWeights_hlt135.root").c_str());
if(hlt=="hltcut150")
data.Add((input_dir+"data2012ABCD_withWeights_hlt150.root").c_str());
RooDataSet allData("allData", "allData", argSet, RooFit::Import(data));
std::cout<<"created complete dataset for data"<<endl;
std::cout<<allData.GetName()<<std::endl;
RooDataSet* data_scut = (RooDataSet*)allData.reduce((cut+" && mvaIdPhot>0.83548").c_str());
RooDataSet* data_rcut = (RooDataSet*)allData.reduce((cut+" && mvaIdPhot<0.6 && mvaIdPhot>-0.6").c_str());
std::cout<<"data_scut entries: "<<data_scut->sumEntries()<<std::endl;
std::cout<<"data_rcut entries: "<<data_rcut->sumEntries()<<std::endl;
std::cout<<"created reduced dataset"<<std::endl;
/*
TH1F* h_set_scut = (TH1F*)data_scut->createHistogram("h_set_scut", combinedPfIsoFPR03Phot, RooFit::Binning(combinedPfIsoFPR03Phot.getBinning()));
TH1F* h_set_rcut = (TH1F*)data_rcut->createHistogram("h_set_rcut", combinedPfIsoFPR03Phot, RooFit::Binning(combinedPfIsoFPR03Phot.getBinning()));
RooDataHist datah_scut("datah_scut", "datah_scut", combinedPfIsoFPR03Phot, Import(*h_set_scut));
RooDataHist datah_rcut("datah_rcut", "datah_rcut", combinedPfIsoFPR03Phot, Import(*h_set_rcut));
*/
//adding and extending models
//option 1: adding sig and bg and extending their sum
RooRealVar frac_scut("frac_scut", "frac_scut", 0.5, 0., 1.);
RooAddPdf model_scut("model_scut", "model_scut", *model_sig, *model_bg, frac_scut);//using fit templates from MC
RooRealVar N_scut("N_scut", "expected number of ev for scut", 20000., 1000., 10000000.);
RooExtendPdf ext_model_scut("ext_model_scut", "ext_model_scut", model_scut, N_scut);
RooFormulaVar N_sig("N_sig","N_sig","@0*@1",RooArgList(N_scut,frac_scut));
//option 2: extending separately sig and bg and then adding them together
/* RooRealVar N_sig("N_sig", "expected number of ev for signal", 14000., 10., 100000000.);
RooRealVar N_bg("N_bg", "expected number of ev for background", 14000., 10., 100000000.);
RooAddPdf ext_model_scut("ext_model_scut", "ext_model_scut", RooArgList(model_sig_scut, model_bg_scut), RooArgList(N_sig, N_bg));
*/
/*
RooAbsReal* nll = ext_model_scut.createNLL(*data_scut, Extended());
RooMinuit m(*nll);
m.setVerbose(kFALSE);
m.migrad();
std::cout<<"MIGRAD PARAMETERS"<<std::endl;
ext_model_scut.getParameters(combinedPfIsoFPR03Phot)->Print("s");
m.hesse();
m.minos();
std::cout<<"MINOS PARAMETERS"<<std::endl;
ext_model_scut.getParameters(combinedPfIsoFPR03Phot)->Print("s");
RooFitResult* result = m.save();
result->Print();*/
// ROOT::Math::MinimizerOptions::SetDefaultTolerance(1e-100);
RooFitResult* result = ext_model_scut.fitTo(*data_scut, Save(), Range(-5.,15.), Extended(kTRUE), SumW2Error(kFALSE));
//RooFitResult* result = cbmyc_d.fitTo(datah_scut, Save(), Range(-5.,15.), SumW2Error(kTRUE));
std::cout<<cut<<std::endl;
RooPlot* frame_s;
if(isFPR)
frame_s = combinedPfIsoFPR03Phot.frame(RooFit::Title("Fit to combinedPfIsoFPR03Phot, scut region"), Binning(100, -7., 15.));
else
frame_s = combinedPfIso03Phot.frame(RooFit::Title("Fit to combinedPfIso03Phot, scut region"), Binning(100, -7., 15.));
data_scut->plotOn(frame_s, Name("dh_s"));
ext_model_scut.plotOn(frame_s, Name("pdf_scut"), LineColor(kBlue), Normalization(1.0,RooAbsReal::RelativeExpected));
model_sig->plotOn(frame_s, Name("pdf_sig"), LineColor(kCyan), Normalization(frac_scut.getVal()/**N_scut.getVal()*/));
model_bg->plotOn(frame_s, Name("pdf_bg"), LineColor(kMagenta), Normalization((1-frac_scut.getVal())/**N_scut.getVal()*/));
frame_s->SetMinimum(0.00001);
if(isFPR)
frame_s->GetXaxis()->SetTitle("combinedPfIsoFPR03Phot [GeV]");
else
frame_s->GetXaxis()->SetTitle("combinedPfIso03Phot [GeV]");
// frame->SetMaximum(30000.);
TLegend* a = new TLegend(0.63,0.68, 0.88, 0.88);
a->SetBorderSize(0);
a->SetFillColor(0);
a->SetFillStyle(0);
a->SetTextSize(0.038);
a->AddEntry(frame_s->findObject("dh_s"), "Data","p");
a->AddEntry(frame_s->findObject("pdf_scut"), "fitting PDF","l");
a->AddEntry(frame_s->findObject("pdf_sig"), "sig component","l");
a->AddEntry(frame_s->findObject("pdf_bg"), "bkg component","l");
//Double_t chi2 = frame_s->chiSquare("pdf_scut", "dh_s", 7);
//Double_t prob = TMath::Prob(chi2, 7);
Double_t chi2 = frame_s->chiSquare("pdf_scut", "dh_s", 5);
Double_t prob = TMath::Prob(chi2, 5);
TPaveLabel *t1 = new TPaveLabel(0.6,0.40,0.80,0.50, Form("#chi^{2}/dof = %.3f", chi2),"brNDC");
TPaveLabel *t2 = new TPaveLabel(0.6,0.50,0.83,0.60, Form("Prob(chi2,dof) = %.3f", prob),"brNDC");
t1->SetFillColor(0);
t1->SetLineWidth(0);
t1->SetLineColor(0);
t1->SetShadowColor(0);
t2->SetFillColor(0);
t2->SetLineWidth(0);
t2->SetLineColor(0);
t2->SetShadowColor(0);
TCanvas* c = new TCanvas();
c->SetTitle(frame_s->GetTitle());
frame_s->Draw("");
t1->Draw();
t2->Draw();
a->Draw();
c->SaveAs((outdir+filename+"_s.png").c_str());
c->SaveAs((outdir+filename+"_s.pdf").c_str());
c->SaveAs((outdir+filename+"_s.root").c_str());
std::cout<<"ChiSquared value, scut: "<<chi2<<std::endl;
c->SetLogy();
c->SetTitle(frame_s->GetTitle());
frame_s->Draw("");
t1->Draw();
t2->Draw();
c->SaveAs((outdir+filename+"_s_log.png").c_str());
c->SaveAs((outdir+filename+"_s_log.pdf").c_str());
c->SaveAs((outdir+filename+"_s_log.root").c_str());
TFile* f_fitRes = new TFile((outdir+"fitResult_"+filename+"_fitResult.root").c_str(), "RECREATE");
result->Write();
f_fitRes->Write();
f_fitRes->Close();
RooRealVar N_sig_real("N_sig_real", "N_sig_real", N_sig.getVal(), 10., 10000000.);
N_sig_real.setError(N_sig.getPropagatedError(*result));
RooWorkspace* w_data = new RooWorkspace("w_data", "workspace");
w_data->import(*data_scut);
w_data->import(ext_model_scut);
w_data->import(combinedPfIsoFPR03Phot);
w_data->import(combinedPfIso03Phot);
w_data->import(N_sig_real);
w_data->Print();
w_data->writeToFile((outdir +"workspace_"+filename+".root").c_str());
}
void fitDebug_Data(string cut, string filename, string hlt, string ptMin, string ptMax){
RooRealVar combinedPfIso03Phot("combinedPfIso03Phot", "combinedPfIso03Phot", -7., 15.);
RooRealVar etaPhot("etaPhot", "etaPhot", -2.5, 2.5);
RooRealVar mvaIdPhot("mvaIdPhot", "mvaIdPhot", -1.,1.);
RooRealVar isMatchedPhot("isMatchedPhot","isMatchedPhot", -1., 2.);
RooRealVar ptPhot("ptPhot", "ptPhot", 0., 1000.);
RooRealVar weight("weight","weight", 0., 100.);
RooArgSet argSet("argSet");
argSet.add(combinedPfIso03Phot);
argSet.add(etaPhot);
argSet.add(mvaIdPhot);
argSet.add(isMatchedPhot);
argSet.add(ptPhot);
argSet.add(weight);
combinedPfIso03Phot.setBins(121);
etaPhot.setBins(120);
mvaIdPhot.setBins(180);
isMatchedPhot.setBins(3);
ptPhot.setBins(1200);
weight.setBins(1000);
std::cout<<"set binning"<<std::endl;
//models from fitted MC
TFile* f_ws_sig = new TFile(("../workspace_fit_EB_sig_WP095_pt"+ptMin+"_"+ptMax+".root").c_str(), "READ");
TFile* f_ws_bg = new TFile(("../workspace_fit_EB_bg_WP095_pt"+ptMin+"_"+ptMax+".root").c_str(), "READ");
RooWorkspace* w_sig =(RooWorkspace*)f_ws_sig->Get("w_sig");
w_sig->Print();
RooWorkspace* w_bg =(RooWorkspace*)f_ws_bg->Get("w_bg");
w_bg->Print();
//model for signal
RooRealVar data_CBC_mean("data_CBC_mean", "data_CBC_mean", w_sig->var("CBC_mean")->getVal(), -2., 3.);
data_CBC_mean.Print();
RooRealVar data_CBC_sigma("data_CBC_sigma", "data_CBC_sigma", w_sig->var("CBC_sigma")->getVal(), 0., 3.);
data_CBC_sigma.Print();
RooRealVar data_CBC_alphaCB("data_CBC_alphaCB", "data_CBC_alphaCB", w_sig->var("CBC_alphaCB")->getVal(), 0., 3.);
RooRealVar data_CBC_n("data_CBC_n", "data_CBC_n", w_sig->var("CBC_n")->getVal(), 0., 100.);
RooCBShape model_sig("model_sig", "model_sig", combinedPfIso03Phot, data_CBC_mean, data_CBC_sigma, data_CBC_alphaCB, data_CBC_n);
/*
// vittorio configuration
//data_data_CBC_mean.setConstant(kTRUE);
//data_CBC_sigma.setConstant(kTRUE);
//data_CBC_alphaC.setConstant(kTRUE);
data_CBC_alphaCB.setConstant(kTRUE);
data_CBC_n.setConstant(kTRUE);
*/
data_CBC_mean.setConstant(kTRUE);
data_CBC_sigma.setConstant(kTRUE);
data_CBC_alphaCB.setConstant(kTRUE);
data_CBC_n.setConstant(kTRUE);
//model for background
RooRealVar data_cbmean("data_cbmean", "data_cbmean", w_bg->var("cbmean")->getVal(), -1., 4.);
RooRealVar data_cbsigma("data_cbsigma", "data_cbsigma", w_bg->var("cbsigma")->getVal(), 1., 6.) ;
RooRealVar data_cbalpha_s("data_cbalpha_s", "data_cbalpha_s", w_bg->var("cbalpha_s")->getVal(), -5., 0.);
RooRealVar data_cbn_s("data_cbn_s", "data_cbn_s", w_bg->var("cbn_s")->getVal(), 0., 500.);
RooCBShape cb_bg("cb_bg", "cb_bg", combinedPfIso03Phot, data_cbmean, data_cbsigma, data_cbalpha_s, data_cbn_s);
RooRealVar data_gaussmean("data_gaussmean", "data_gaussmean", w_bg->var("gaussmean")->getVal(), -3., 1.);
RooRealVar data_gausssigma("data_gausssigma", "data_gausssigma", w_bg->var("gausssigma")->getVal(), 0., 5.);
RooGaussian gauss_bg("gauss_bg", "gauss_bg", combinedPfIso03Phot, data_gaussmean, data_gausssigma);
RooRealVar data_frac_s("data_frac_s", "data_frac_s", w_bg->var("frac_s")->getVal(), 0., 1.);
RooAddPdf model_bg("model_bg", "model_bg", cb_bg, gauss_bg, data_frac_s);
data_cbmean.setConstant(kTRUE);
data_cbsigma.setConstant(kTRUE);
data_cbalpha_s.setConstant(kTRUE);
data_cbn_s.setConstant(kTRUE);
data_frac_s.setConstant(kTRUE);
data_gaussmean.setConstant(kTRUE);
data_gausssigma.setConstant(kTRUE);
/*
// vittorio configuration
data_cbmean.setConstant(kTRUE);
data_cbsigma.setConstant(kTRUE);
data_cbalpha_s.setConstant(kTRUE);
data_cbn_s.setConstant(kTRUE);
data_frac_s.setConstant(kTRUE);
data_gaussmean.setConstant(kTRUE);
data_gausssigma.setConstant(kTRUE);
*/
//TChain data("finalTree");
TChain data("myTrees_withWeight");
/*
data.Add(("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/Photon-Run2012A-recover-06Aug2012_"+hlt+"_hltiso0_mvaWP4.root").c_str());
data.Add(("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/Photon_Run2012B-13Jul2012_"+hlt+"_hltiso0_mvaWP4.root").c_str());
data.Add(("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/Photon_Run2012C-24Aug2012_"+hlt+"_hltiso0_mvaWP4.root").c_str());
data.Add(("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/Photon_Run2012C-EcalRecover_11Dec2012_"+hlt+"_hltiso0_mvaWP4.root").c_str());
data.Add(("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/Photon_Run2012C-PromptReco-v2_"+hlt+"_hltiso0_mvaWP4.root").c_str());
data.Add(("root://pccmsrm27.cern.ch///cms/local/vtavolar/GammaJets/output_newPreselLooseIso2/Photon_Run2012D-PromptReco-v1_"+hlt+"_hltiso0_mvaWP4.root").c_str());
*/
data.Add(("/afs/cern.ch/work/g/gdimperi/GammaJet/giulia_repo/CMSSW_5_3_14/src/GammaJets/src/studioPesi/histo_v6/genIso4/isoWeight/tightPresel2/weights_rebin/data2012ABCD_withWeights_"+hlt+".root").c_str());
RooDataSet allData("allData", "allData", argSet, RooFit::Import(data));
std::cout<<"created complete dataset for data"<<endl;
std::cout<<allData.GetName()<<std::endl;
// RooDataSet* data_scut = (RooDataSet*)allData.reduce((cut+" && mvaIdPhot>0.711099").c_str());
// RooDataSet* data_rcut = (RooDataSet*)allData.reduce((cut+" && mvaIdPhot<0.711099").c_str());
RooDataSet* data_scut = (RooDataSet*)allData.reduce((cut+" && mvaIdPhot>0.83548").c_str());
RooDataSet* data_rcut = (RooDataSet*)allData.reduce((cut+" && mvaIdPhot<0.6 && mvaIdPhot>-0.6").c_str());
std::cout<<"data_scut entries: "<<data_scut->sumEntries()<<std::endl;
std::cout<<"data_rcut entries: "<<data_rcut->sumEntries()<<std::endl;
std::cout<<"created reduced dataset"<<std::endl;
TH1F* h_set_scut = (TH1F*)data_scut->createHistogram("h_set_scut", combinedPfIso03Phot, RooFit::Binning(combinedPfIso03Phot.getBinning()));
TH1F* h_set_rcut = (TH1F*)data_rcut->createHistogram("h_set_rcut", combinedPfIso03Phot, RooFit::Binning(combinedPfIso03Phot.getBinning()));
RooDataHist datah_scut("datah_scut", "datah_scut", combinedPfIso03Phot, Import(*h_set_scut));
RooDataHist datah_rcut("datah_rcut", "datah_rcut", combinedPfIso03Phot, Import(*h_set_rcut));
//adding and extending models
//option 1: adding sig and bg and extending their sum
RooRealVar frac_scut("frac_scut", "frac_scut", 0.5, 0., 1.);
RooAddPdf model_scut("model_scut", "model_scut", model_sig, model_bg, frac_scut);//using fit templates from MC
//vittorio
//RooRealVar N_scut("N_scut", "expected number of ev for scut", 20000., 1000., 100000.);
//giulia
RooRealVar N_scut("N_scut", "expected number of ev for scut", 10000., 1000., 100000.);
RooExtendPdf ext_model_scut("ext_model_scut", "ext_model_scut", model_scut, N_scut);
RooFormulaVar N_sig("N_sig","N_sig","@0*@1",RooArgList(N_scut,frac_scut));
//option 2: extending separately sig and bg and then adding them together
/* RooRealVar N_sig("N_sig", "expected number of ev for signal", 14000., 10., 100000000.);
RooRealVar N_bg("N_bg", "expected number of ev for background", 14000., 10., 100000000.);
RooAddPdf ext_model_scut("ext_model_scut", "ext_model_scut", RooArgList(model_sig_scut, model_bg_scut), RooArgList(N_sig, N_bg));
*/
/*
RooAbsReal* nll = ext_model_scut.createNLL(*data_scut, Extended());
RooMinuit m(*nll);
m.setVerbose(kFALSE);
m.migrad();
std::cout<<"MIGRAD PARAMETERS"<<std::endl;
ext_model_scut.getParameters(combinedPfIso03Phot)->Print("s");
m.hesse();
m.minos();
std::cout<<"MINOS PARAMETERS"<<std::endl;
ext_model_scut.getParameters(combinedPfIso03Phot)->Print("s");
RooFitResult* result = m.save();
result->Print();*/
// ROOT::Math::MinimizerOptions::SetDefaultTolerance(1e-100);
RooFitResult* result = ext_model_scut.fitTo(*data_scut, Save(), Range(-5.,15.), Extended(kTRUE), SumW2Error(kFALSE));
//RooFitResult* result = cbmyc_d.fitTo(datah_scut, Save(), Range(-5.,15.), SumW2Error(kTRUE));
std::cout<<cut<<std::endl;
RooPlot* frame_s = combinedPfIso03Phot.frame(RooFit::Title("Fit to combinedPfIso03Phot, scut region"));
data_scut->plotOn(frame_s, Name("dh_s"));
model_sig.plotOn(frame_s, Name("pdf_sig"), LineColor(kCyan), LineStyle(2) /*,Normalization(frac_scut.getVal()*N_scut.getVal())*/);
model_bg.plotOn(frame_s, Name("pdf_bg"), LineColor(kMagenta), LineStyle(2) /*,Normalization((1-frac_scut.getVal())*N_scut.getVal())*/);
/*
model_sig.plotOn(frame_s, Name("pdf_sig"), LineColor(kCyan), LineStyle(2) , Normalization(frac_scut.getVal()*N_scut.getVal()));
model_bg.plotOn(frame_s, Name("pdf_bg"), LineColor(kMagenta), LineStyle(2), Normalization((1-frac_scut.getVal())*N_scut.getVal()));
*/
// vittorio
ext_model_scut.plotOn(frame_s, Name("pdf_scut"), LineColor(kBlue), Normalization(1.0,RooAbsReal::RelativeExpected));
frame_s->SetMinimum(0.00001);
// frame->SetMaximum(30000.);
TCanvas* c = new TCanvas();
c->SetTitle(frame_s->GetTitle());
frame_s->Draw("");
c->SaveAs((filename+"_s.png").c_str());
c->SaveAs((filename+"_s.root").c_str());
Double_t chi2 = frame_s->chiSquare("pdf_scut", "dh_s", 4);
std::cout<<"ChiSquared value, scut: "<<chi2<<std::endl;
c->SetLogy();
c->SetTitle(frame_s->GetTitle());
frame_s->Draw("");
c->SaveAs((filename+"_s_log.png").c_str());
c->SaveAs((filename+"_s_log.root").c_str());
TFile* f_fitRes = new TFile(("fitResult_"+filename+".root").c_str(), "RECREATE");
result->Write();
f_fitRes->Write();
f_fitRes->Close();
RooRealVar N_sig_real("N_sig_real", "N_sig_real", N_sig.getVal(), 10., 10000000.);
N_sig_real.setError(N_sig.getPropagatedError(*result));
RooWorkspace* w_data = new RooWorkspace("w_data", "workspace");
w_data->import(*data_scut);
w_data->import(ext_model_scut);
w_data->import(combinedPfIso03Phot);
w_data->import(N_sig_real);
w_data->Print();
w_data->writeToFile(("workspace_"+filename+".root").c_str());
}
int main(int argc, char* argv[])
{
string name;
for(Int_t i=1;i<argc;i++){
char *pchar = argv[i];
switch(pchar[0]){
case '-':{
switch(pchar[1]){
case 'n':
name = argv[i+1];
cout << "Name of the configuration key " << name << endl;
break;
}
}
}
}
Bool_t doFit = kFALSE;
Bool_t extract = kFALSE;
Bool_t doFrac = kFALSE;
Bool_t doPlots = kTRUE;
Bool_t doChi2 = kFALSE;
BaBarStyle p;
p.SetBaBarStyle();
gROOT->GetStyle("BABAR")->SetPalette(1);
gROOT->GetStyle("BABAR")->SetPadTopMargin(0.04);
gROOT->GetStyle("BABAR")->SetPadLeftMargin(0.17);
gROOT->GetStyle("BABAR")->SetPadBottomMargin(0.19);
gROOT->GetStyle("BABAR")->SetTitleSize(0.08,"xyz"); // set the 3 axes title size
//define DalitzSpace for generation
EvtPDL pdl;
pdl.readPDT("evt.pdl");
EvtDecayMode mode("D0 -> K- pi+ pi0");
EvtDalitzPlot dalitzSpace(mode);
RooRealVar tau("tau","tau",0.4099);
RooRealVar m2Kpi_d0mass("m2Kpi_d0mass","m2Kpi_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AB),dalitzSpace.qAbsMax(EvtCyclic3::AB));
RooRealVar m2Kpi0_d0mass("m2Kpi0_d0mass","m2Kpi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AC),dalitzSpace.qAbsMax(EvtCyclic3::AC));
RooRealVar m2pipi0_d0mass("m2pipi0_d0mass","m2pipi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::BC),dalitzSpace.qAbsMax(EvtCyclic3::BC));
RooRealVar d0Lifetime("d0Lifetime","d0Lifetime",-2.,4.);
RooRealVar d0LifetimeErr("d0LifetimeErr","d0LifetimeErr",0.0000001,0.5);
RooCategory D0flav("D0flav","D0flav");
D0flav.defineType("D0",-1);
D0flav.defineType("antiD0",1);
RooRealVar scalefact1("scalefact1","scalefact1",3.20);
RooRealVar scalefact2("scalefact2","scalefact2",1.42);
RooRealVar scalefact3("scalefact3","scalefact3",0.94);
RooRealVar c1("c1","c1",-2.,2.);
RooRealVar c2("c2","c2",-2.,2.);
RooUnblindOffset c1_unblind("c1_unblind","c1 (unblind)","VaffanculoS",1.,c1) ;
RooUnblindOffset c2_unblind("c2_unblind","c2 (unblind)","VaffanculoS",1.,c2) ;
TFile fWS("DataSet_out_tmp.root");
gROOT->cd();
RooDataSet *data = (RooDataSet*)fWS.Get("fulldata");
RooDataSet *data_clean = (RooDataSet*)data->reduce("d0LifetimeErr < 0.5 && d0Lifetime > -2. && d0Lifetime < 4. && deltaMass > 0.1449 && deltaMass < 0.1459");
RooDataSet *dataWS_2 = (RooDataSet*)data_clean->reduce("isWS == 1");
RooDataSet *dataWS = (RooDataSet*)dataWS_2->reduce("d0Mass > 1.8495 && d0Mass < 1.8795");
RooDataSet *RSdata = (RooDataSet*)data_clean->reduce("isWS == 0 && d0Mass > 1.8495 && d0Mass < 1.8795");
Double_t low12,hig12,low13,hig13,low23,hig23;
Bool_t m12bool = dataWS->getRange(m2Kpi_d0mass,low12,hig12);
Bool_t m13bool = dataWS->getRange(m2Kpi0_d0mass,low13,hig13);
Bool_t m23bool = dataWS->getRange(m2pipi0_d0mass,low23,hig23);
m2Kpi_d0mass.setRange(low12,hig12);
m2Kpi0_d0mass.setRange(low13,hig13);
m2pipi0_d0mass.setRange(low23,hig23);
m2Kpi_d0mass.setBins(10);
m2Kpi0_d0mass.setBins(10);
d0Lifetime.setBins(8);
d0LifetimeErr.setBins(10);
m2pipi0_d0mass.setBins(10);
Float_t total = pow(dalitzSpace.bigM(),2) + pow(dalitzSpace.mA(),2) + pow(dalitzSpace.mB(),2) + pow(dalitzSpace.mC(),2);
RooRealVar totalm("totalm","totalm",total);
RooFormulaVar mass13a("mass13a","@0-@1-@2",RooArgSet(totalm,m2Kpi_d0mass,m2pipi0_d0mass));
//Construct signal pdf
RooRealVar bias("bias","bias",0.0047) ;
RooRealVar one("one","one",1.);
//consider the resolution or the truth model
RooGaussModel gm1("gm1","gauss model 1",d0Lifetime,bias,d0LifetimeErr,one,scalefact1) ;
RooGaussModel gm2("gm2","gauss model 2",d0Lifetime,bias,d0LifetimeErr,one,scalefact2) ;
RooGaussModel gm3("gm3","gauss model 3",d0Lifetime,bias,d0LifetimeErr,one,scalefact3) ;
RooRealVar N1("N1","N1",0.0052);
RooRealVar N2("N2","N2",0.179);
RooFormulaVar f2("f2","f2","(1-@0)*@1",RooArgList(N1,N2));
RooFormulaVar f3("f3","f3","(1-@0)*(1-@1)",RooArgList(N1,N2));
RooAddModel gm("gm","gm",RooArgList(gm2,gm3,gm1),RooArgList(f2,f3));
string dirname = "configmaps/effmapping_" + name + "/";
RooTimepdf TOTsigD0("TOTsigD0","TOTsigD0",d0Lifetime,m2Kpi_d0mass,m2Kpi0_d0mass,gm,&dalitzSpace,tau,c1,c2,-1,dirname);
//RooTimepdf TOTsigantiD0("TOTsigantiD0","TOTsigantiD0",d0Lifetime,m2Kpi_d0mass,m2Kpi0_d0mass,gm,&dalitzSpace,tau,c1_unblind,c2_unblind,1);
//RooSimultaneous TOTTime("TOTTime","TOTTime",D0flav);
//TOTTime.addPdf(TOTsigD0,"D0");
//TOTTime.addPdf(TOTsigantiD0,"antiD0");
RooTimepdf TOTsigD023("TOTsigD023","TOTsigD023",d0Lifetime,m2Kpi_d0mass,mass13a,gm,&dalitzSpace,tau,c1,c2,-1,dirname);
//////////////////////////
// BACKGROUND
/////////////////////////
//Mistag parametrization
m2Kpi_d0mass.setBins(150);
m2Kpi0_d0mass.setBins(150);
m2pipi0_d0mass.setBins(150);
d0Lifetime.setBins(70);
TH3F *mis_h = m2Kpi_d0mass.createHistogram("mis_h",m2Kpi0_d0mass,d0Lifetime,"");
RSdata->fillHistogram(mis_h,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime));
mis_h->Sumw2();
RooDataHist *mis_hist = new RooDataHist("mis_hist","mis_hist",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),mis_h);
RooHistPdf Tot_mis("Tot_mis","Tot_mis",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),*mis_hist);
TH3F *mis_h23 = m2Kpi_d0mass.createHistogram("mis_h",m2pipi0_d0mass,d0Lifetime,"");
RSdata->fillHistogram(mis_h23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass,d0Lifetime));
mis_h23->Sumw2();
RooDataHist *mis_hist23 = new RooDataHist("mis_hist23","mis_hist23",RooArgList(m2Kpi_d0mass,m2pipi0_d0mass,d0Lifetime),mis_h23);
RooHistPdf Tot_mis23("Tot_mis23","Tot_mis23",RooArgList(m2Kpi_d0mass,m2pipi0_d0mass,d0Lifetime),*mis_hist23);
m2Kpi_d0mass.setBins(10);
m2Kpi0_d0mass.setBins(10);
m2pipi0_d0mass.setBins(10);
d0Lifetime.setBins(8);
d0LifetimeErr.setBins(10);
RooArgSet observ(d0Lifetime,m2Kpi_d0mass,m2Kpi0_d0mass);
RooArgSet observ23(d0Lifetime,m2Kpi_d0mass,m2pipi0_d0mass);
RooArgSet tot_var(d0Lifetime,m2Kpi_d0mass,m2Kpi0_d0mass,d0LifetimeErr);
//combinatoric
RooDataSet *leftdata = (RooDataSet*)dataWS_2->reduce("d0Mass > 1.75 && d0Mass < 1.77");
RooDataSet *rightdata = (RooDataSet*)dataWS_2->reduce("d0Mass > 1.95 && d0Mass < 1.97");
RooDataSet *bkgdata = (RooDataSet*)dataWS_2->reduce("d0Mass > 1.95 || d0Mass < 1.77");
rightdata->setWeightVar(0);
leftdata->setWeightVar(0);
TH3F *lefth = m2Kpi_d0mass.createHistogram("lefth",m2Kpi0_d0mass,d0Lifetime,"");
leftdata->fillHistogram(lefth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime));
TH3F *righth = m2Kpi_d0mass.createHistogram("righth",m2Kpi0_d0mass,d0Lifetime,"");
rightdata->fillHistogram(righth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime));
righth->Scale(lefth->Integral()/righth->Integral());
lefth->Sumw2();
righth->Sumw2();
lefth->Add(righth);
lefth->Sumw2();
RooDataHist *lefthist = new RooDataHist("lefthist","lefthist",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),lefth);
RooHistPdf Tot_comb("Tot_comb","Tot_comb",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),*lefthist);
TH3F *lefth23 = m2Kpi_d0mass.createHistogram("lefth23",m2pipi0_d0mass,d0Lifetime,"");
leftdata->fillHistogram(lefth23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass,d0Lifetime));
TH3F *righth23 = m2Kpi_d0mass.createHistogram("righth23",m2pipi0_d0mass,d0Lifetime,"");
rightdata->fillHistogram(righth23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass,d0Lifetime));
righth23->Scale(lefth23->Integral()/righth23->Integral());
lefth23->Sumw2();
righth23->Sumw2();
lefth23->Add(righth23);
lefth23->Sumw2();
RooDataHist *lefthist23 = new RooDataHist("lefthist23","lefthist23",RooArgList(m2Kpi_d0mass,m2pipi0_d0mass,d0Lifetime),lefth23);
RooHistPdf Tot_comb23("Tot_comb23","Tot_comb23",RooArgList(m2Kpi_d0mass,m2pipi0_d0mass,d0Lifetime),*lefthist23);
RooRealVar Nsig("Nsig","Nsig",1508.);
RooRealVar Nmis("Nmis","Nmis",791.);
RooRealVar Ncomb("Ncomb","Ncomb",(663. + 47.));
d0LifetimeErr.setBins(100);
RooDataSet *ProtoData_err = (RooDataSet*)RSdata->reduce(RooArgSet(d0LifetimeErr));
TH1F *err_sig_h = (TH1F*)d0LifetimeErr.createHistogram("err_sig_h");
ProtoData_err->fillHistogram(err_sig_h,RooArgSet(d0LifetimeErr));
RooDataHist terr_sig("terr_sig","terr_sig",RooArgSet(d0LifetimeErr),err_sig_h);
RooHistPdf terr_sig_pdf("terr_sig_pdf","terr_sig_pdf",RooArgSet(d0LifetimeErr),terr_sig,3);
d0LifetimeErr.setBins(10);
RooDataSet *ProtoData_bkg = (RooDataSet*)bkgdata->reduce(RooArgSet(d0LifetimeErr));
TH1F *err_bkg_h = (TH1F*)d0LifetimeErr.createHistogram("err_bkg_h");
ProtoData_bkg->fillHistogram(err_bkg_h,RooArgSet(d0LifetimeErr));
err_bkg_h->Scale(err_sig_h->Integral()/err_bkg_h->Integral());
RooDataHist terr_bkg("terr_bkg","terr_bkg",RooArgSet(d0LifetimeErr),err_bkg_h);
RooHistPdf terr_bkg_pdf("terr_bkg_pdf","terr_bkg_pdf",RooArgSet(d0LifetimeErr),terr_bkg,3);
RooProdPdf totsig_norm("totsig_norm","totsig_norm",RooArgSet(terr_sig_pdf),Conditional(TOTsigD0,observ));
RooProdPdf totmis_norm("totmis_norm","totmis_norm",RooArgSet(terr_sig_pdf),Conditional(Tot_mis,observ));
RooProdPdf totbkg_norm("totbkg_norm","totbkg_norm",RooArgSet(terr_bkg_pdf),Conditional(Tot_comb,observ));
RooProdPdf totsig_norm23("totsig_norm23","totsig_norm23",RooArgSet(terr_sig_pdf),Conditional(TOTsigD023,observ23));
RooProdPdf totmis_norm23("totmis_norm23","totmis_norm23",RooArgSet(terr_sig_pdf),Conditional(Tot_mis23,observ23));
RooProdPdf totbkg_norm23("totbkg_norm23","totbkg_norm23",RooArgSet(terr_bkg_pdf),Conditional(Tot_comb23,observ23));
//Signal + background
RooAddPdf TOTpdf("TOTpdf","TOTpdf",RooArgList(totsig_norm,totmis_norm,totbkg_norm),RooArgList(Nsig,Nmis,Ncomb));
RooAddPdf TOTpdf23("TOTpdf23","TOTpdf23",RooArgList(totsig_norm23,totmis_norm23,totbkg_norm23),RooArgList(Nsig,Nmis,Ncomb));
if(doFit){
RooFitResult *theRes = TOTpdf.fitTo(*dataWS,Save(1),Minos(0),Extended(0));
string filename = "syst_root/fit_WS_" + name + ".root";
TFile fout(filename.c_str(),"RECREATE");
fout.cd();
theRes->Write();
fout.Close();
}
if(extract){
TFile f("fitWS.root");
RooFitResult* theRes = (RooFitResult*)f.Get("nll");
RooRealVar myc1("myc1","myc1",-10.,10.);
RooRealVar myc2("myc2","myc2",-10.,10.);
RooRealVar myratio("myratio","myratio",0.,0.,1.);
RooRealVar myx("myx","myx",0.,-1.,1.);
RooRealVar myy("myy","myy",0.,-1.,1.);
Double_t NrsNws = 2562./1132332.;
Double_t ratioerr = sqrt(pow(89.,2.) + pow(NrsNws,2.)*pow(2862.,2.))/1132332.;
RooDataSet *parFloat = new RooDataSet("parFloat","parFloat",RooArgList(myratio,myx,myy));
for(Int_t j=0;j<400;j++){
cout << "Performing step number " << j << endl;
RooArgList floated = theRes->randomizePars();
myc1.setVal(((RooAbsReal*)floated.find("c1"))->getVal());
myc2.setVal(((RooAbsReal*)floated.find("c2"))->getVal());
RooTimepdf mysigD0("mysigD0","mysigD0",d0Lifetime,m2Kpi_d0mass,m2Kpi0_d0mass,gm,&dalitzSpace,tau,myc1,myc2,-1,dirname);
Double_t myDenom = mysigD0.createIntegral(RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime))->getVal();
Double_t myNum = RooRandom::randomGenerator()->Gaus(NrsNws,ratioerr);
myratio.setVal(myNum/myDenom);
myx.setVal(myc2.getVal()*sqrt((myNum/myDenom)));
myy.setVal(myc1.getVal()*sqrt((myNum/myDenom)));
parFloat->add(RooArgSet(myratio,myx,myy));
}
TFile *f1 = new TFile("fitWS_float.root","RECREATE");
f1->cd();
parFloat->Write();
f1->Close();
}
if(doChi2){
m2Kpi_d0mass.setBins(40);
m2Kpi0_d0mass.setBins(40);
RooDataSet *dterr_ds = (RooDataSet*)dataWS->reduce(RooArgSet(d0LifetimeErr));
TH2F *dphist_data = (TH2F*)m2Kpi_d0mass.createHistogram("dphist_data",m2Kpi0_d0mass);
dataWS->fillHistogram(dphist_data,RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass));
RooDataSet *pdf_ds = (RooDataSet*)TOTpdf.generate(RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),dataWS->numEntries(),RooFit::ProtoData(*dterr_ds,1));
TH2F *dphist = (TH2F*)m2Kpi_d0mass.createHistogram("dphist",m2Kpi0_d0mass);
pdf_ds->fillHistogram(dphist,RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass));
Int_t binx = m2Kpi_d0mass.getBinning().numBins();
Int_t biny = m2Kpi0_d0mass.getBinning().numBins();
Double_t chi2 = 0.;
Int_t myBins = 0;
Int_t nBin = 1;
TH2F *pull_dal = (TH2F*)m2Kpi_d0mass.createHistogram("pull_dal",m2Kpi0_d0mass);
dphist->Sumw2();
dphist->Scale(dphist_data->Integral()/dphist->Integral());
dphist->Sumw2();
for(Int_t i=0;i<binx*biny;i++){
Double_t chi_tmp = (dphist->GetBinContent(i)-dphist_data->GetBinContent(i))/dphist->GetBinError(i);
Double_t nEv = dphist_data->GetBinContent(i);
if(nEv == 0.) chi_tmp = 0.;
pull_dal->SetBinContent(i,chi_tmp);
if(nBin > 1){
nBin--;
//Double_t chi_tmp = (dphist->GetBinContent(i)-dphist_data->GetBinContent(i))/dphist->GetBinError(i);
//pull_dal->SetBinContent(i,chi_tmp);
continue;
}
if(nEv == 0.) continue;
Double_t ndata = dphist_data->GetBinContent(i);
Double_t npdf = dphist->GetBinContent(i);
Double_t err = dphist->GetBinError(i);
myBins++;
while(nEv < 9.){
if(dphist_data->GetBinContent(i+nBin) == 0. || dphist->GetBinError(i+nBin) == 0.){
nBin++;
continue;
}
ndata += dphist_data->GetBinContent(i+nBin);
npdf += dphist->GetBinContent(i+nBin);
err += sqrt(pow(err,2.) + pow(dphist->GetBinError(i+nBin),2.));
nEv += dphist_data->GetBinContent(i+nBin);
nBin++;
}
chi2 += pow((ndata-npdf)/err,2.);
}
Double_t chi2_root = dphist_data->Chi2Test(dphist,"UW");
cout << "chi2 = " << chi2 << endl;
cout << "chi2/ndof = " << chi2/(myBins -1.) << endl;
cout << "mybins = " << myBins << endl;
cout << "chi2 for root = " << chi2_root << endl;
dphist_data->Sumw2();
dphist->Sumw2();
dphist_data->Add(dphist,-1.);
dphist_data->SetMaximum(15.);
dphist_data->SetMinimum(-15.);
TCanvas c;
c.Divide(1,2);
c.cd(1);dphist_data->Draw("COLZ");
c.cd(2);pull_dal->Draw("COLZ");
c.SaveAs("WScomparison.eps");
TFile fp("prova.root","RECREATE");
dphist_data->Write();
pull_dal->Write();
fp.Close();
}
if(doPlots){
m2Kpi_d0mass.setBins(20);
m2Kpi0_d0mass.setBins(20);
m2pipi0_d0mass.setBins(20);
d0Lifetime.setBins(70);
RooDataHist *dshist = new RooDataHist("dshist","dshist",RooArgSet(d0LifetimeErr),*dataWS);
TH2F *lefth_t = m2Kpi_d0mass.createHistogram("lefth_t",m2Kpi0_d0mass);
leftdata->fillHistogram(lefth_t,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass));
TH2F *righth_t = m2Kpi_d0mass.createHistogram("righth_t",m2Kpi0_d0mass);
rightdata->fillHistogram(righth_t,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass));
righth_t->Scale(lefth_t->Integral()/righth_t->Integral());
lefth_t->Sumw2();
righth_t->Sumw2();
lefth_t->Add(righth);
lefth_t->Sumw2();
TH1F *left_t = (TH1F*)d0Lifetime.createHistogram("left_t");
leftdata->fillHistogram(left_t,RooArgList(d0Lifetime));
TH1F *right_t = (TH1F*)d0Lifetime.createHistogram("right_t");
rightdata->fillHistogram(right_t,RooArgList(d0Lifetime));
right_t->Scale(left_t->Integral()/right_t->Integral());
left_t->Sumw2();
right_t->Sumw2();
left_t->Add(right_t);
left_t->Sumw2();
RooDataHist *lefthist_d = new RooDataHist("lefthist_d","lefthist_d",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass),lefth_t);
RooDataHist *lefthist_t = new RooDataHist("lefthist_t","lefthist_t",RooArgList(d0Lifetime),left_t);
RooHistPdf left_plot("left_plot","left_plot",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*lefthist_d,6);
RooHistPdf left_t_plot("left_t_plot","left_t_plot",RooArgSet(d0Lifetime),*lefthist_t,6);
RooProdPdf tot_plot("tot_plot","tot_plot",left_plot,left_t_plot);
RooProdPdf totbkg_norm_plot("totbkg_norm_plot","totbkg_norm_plot",RooArgSet(terr_bkg_pdf),Conditional(tot_plot,observ));
RooAddPdf TOTpdf_plot("TOTpdf_plot","TOTpdf_plot",RooArgList(totsig_norm,totmis_norm,totbkg_norm_plot),RooArgList(Nsig,Nmis,Ncomb));
RooPlot* tframe = d0Lifetime.frame();
dataWS->plotOn(tframe,MarkerSize(0.1),DrawOption("z"));
//TOTpdf.plotOn(tframe,Project(RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass,d0LifetimeErr)),ProjWData(*dshist));
TOTpdf_plot.plotOn(tframe);
Double_t chi2t = tframe->chiSquare();
TOTpdf_plot.plotOn(tframe,Components(RooArgSet(totmis_norm,totbkg_norm_plot)),DrawOption("F"),FillColor(kBlue)); //FillColor(17));
TOTpdf_plot.plotOn(tframe,Components(RooArgSet(totbkg_norm_plot)),DrawOption("F"),FillColor(kRed)); //FillColor(14));
tframe->getAttLine()->SetLineWidth(1);
tframe->getAttLine()->SetLineStyle(1);
tframe->SetTitle("");
tframe->GetXaxis()->SetTitle("t_{K^{+}#pi^{-}#pi^{0}} [ps]");
tframe->GetYaxis()->SetTitle("Events/0.08 ps");
TPaveText *boxt = new TPaveText(2.5,2.5,2.7,2.7,"");
boxt->AddText("(d)");
boxt->SetFillColor(10);
cout << "Chi2 for t = " << chi2t << endl;
TCanvas ct("t","t",300,300);
ct.cd();tframe->Draw();boxt->Draw("SAME");
ct.SaveAs("WSfit_t.eps");
//When we plot the 1D projection, need to calculate the 1D integral
//set the precision here
//cout << "config integrator " << endl;
RooNumIntConfig *cfg = RooAbsReal::defaultIntegratorConfig();
cfg->setEpsAbs(1E-5);
cfg->setEpsRel(1E-5);
cfg->method1D().setLabel("RooSegmentedIntegrator1D");
//cfg.getConfigSection("RooSegmentedIntegrator1D").setRealValue("numSeg",3);
//cfg->method1D()->Print("v");
TOTsigD0.setIntegratorConfig(*cfg);
//TOTsigantiD0.setIntegratorConfig(*cfg);
TOTsigD023.setIntegratorConfig(*cfg);
//TOTsigantiD023.setIntegratorConfig(*cfg);
RooPlot* xframe = m2Kpi_d0mass.frame(53); //was 19
dataWS->plotOn(xframe,MarkerSize(0.1),DrawOption("z"));
TOTpdf.plotOn(xframe,Project(RooArgSet(m2Kpi0_d0mass,d0Lifetime,d0LifetimeErr)),ProjWData(*dshist));
xframe->getAttLine()->SetLineWidth(1);
xframe->getAttLine()->SetLineStyle(1);
xframe->SetTitle("");
xframe->GetXaxis()->SetTitle("m^{2}_{K^{+}#pi^{-}} [GeV^{2}/c^{4}]");
xframe->GetYaxis()->SetTitle("Events/0.05 GeV^{2}/c^{4}");
Double_t chi2Kpi = xframe->chiSquare();
TOTpdf.plotOn(xframe,Project(RooArgSet(m2Kpi0_d0mass,d0Lifetime,d0LifetimeErr)),ProjWData(*dshist),Components(RooArgSet(totmis_norm,totbkg_norm)),DrawOption("F"),FillColor(kBlue)); //FillColor(17));
TOTpdf.plotOn(xframe,Project(RooArgSet(m2Kpi0_d0mass,d0Lifetime,d0LifetimeErr)),ProjWData(*dshist),Components(RooArgSet(totbkg_norm)),DrawOption("F"),FillColor(kRed)); //FillColor(14));
dataWS->plotOn(xframe,MarkerSize(0.1),DrawOption("z"));
xframe->GetYaxis()->SetTitleOffset(1.3);
TPaveText *box_m12 = new TPaveText(2.5,2.5,2.7,2.7,"");
box_m12->AddText("(b)");
box_m12->SetFillColor(10);
TCanvas c1("c1","c1",300,300);
c1.cd();xframe->Draw();box_m12->Draw("SAME");
c1.SaveAs("WSfit_m2Kpi.eps");
m2Kpi0_d0mass.setBins(50);
RooPlot* yframe = m2Kpi0_d0mass.frame(49);
dataWS->plotOn(yframe,MarkerSize(0.1),DrawOption("z"));
TOTpdf.plotOn(yframe,Project(RooArgSet(m2Kpi_d0mass,d0Lifetime,d0LifetimeErr)),ProjWData(*dshist));
yframe->getAttLine()->SetLineWidth(1);
yframe->getAttLine()->SetLineStyle(1);
yframe->SetTitle("");
yframe->GetYaxis()->SetTitle("Events/0.05 GeV^{2}/c^{4}");
yframe->GetXaxis()->SetTitle("m^{2}_{K^{+}#pi^{0}} [GeV^{2}/c^{4}]");
Double_t chi2Kpi0 = yframe->chiSquare();
TOTpdf.plotOn(yframe,Project(RooArgSet(m2Kpi_d0mass,d0Lifetime,d0LifetimeErr)),ProjWData(*dshist),Components(RooArgSet(totmis_norm,totbkg_norm)),DrawOption("F"),FillColor(kBlue)); //FillColor(17));
TOTpdf.plotOn(yframe,Project(RooArgSet(m2Kpi_d0mass,d0Lifetime,d0LifetimeErr)),ProjWData(*dshist),Components(RooArgSet(totbkg_norm)),DrawOption("F"),FillColor(kRed)); //FillColor(14));
yframe->GetYaxis()->SetTitleOffset(1.3);
TPaveText *box_m13 = new TPaveText(2.5,2.5,2.7,2.7,"");
box_m13->AddText("(c)");
box_m13->SetFillColor(10);
TCanvas c2("c2","c2",300,300);
c2.cd();yframe->Draw();box_m13->Draw("SAME");
c2.SaveAs("WSfit_m2Kpi0.eps");
m2Kpi0_d0mass.setBins(20);
RooPlot* zframe = m2pipi0_d0mass.frame(50);
dataWS->plotOn(zframe,MarkerSize(0.1),DrawOption("z"));
TOTpdf23.plotOn(zframe,Project(RooArgSet(m2Kpi_d0mass,d0Lifetime,d0LifetimeErr)),ProjWData(*dshist));
zframe->getAttLine()->SetLineWidth(1);
zframe->getAttLine()->SetLineStyle(1);
zframe->SetTitle("");
zframe->GetYaxis()->SetTitle("Events/0.08 GeV^{2}/c^{4}");
zframe->GetXaxis()->SetTitle("m^{2}_{#pi^{-}#pi^{0}} [GeV/c^{2}]");
Double_t chi2pipi0 = zframe->chiSquare();
TOTpdf23.plotOn(zframe,Project(RooArgSet(m2Kpi_d0mass,d0Lifetime,d0LifetimeErr)),ProjWData(*dshist),Components(RooArgSet(totmis_norm23,totbkg_norm23)),DrawOption("F"),FillColor(kBlue));
TOTpdf23.plotOn(zframe,Project(RooArgSet(m2Kpi_d0mass,d0Lifetime,d0LifetimeErr)),ProjWData(*dshist),Components(RooArgSet(totbkg_norm23)),DrawOption("F"),FillColor(kRed));
cout << "Chi2 for Kpi = " << chi2Kpi << endl;
cout << "Chi2 for Kpi0 = " << chi2Kpi0 << endl;
cout << "Chi2 for pipi0 = " << chi2pipi0 << endl;
TCanvas *c = new TCanvas("c","allevents",1200,400);
c->Divide(3,1);
c->cd(1);xframe->Draw();
c->cd(2);yframe->Draw();
c->cd(3);zframe->Draw();
c->SaveAs("WSfit.eps");
}
if(doFrac){
cout << "Calculating fit fractions" << endl;
TFile f("fitWS.root");
RooFitResult* fitRes = (RooFitResult*)f.Get("nll");
//now calculate the fit fractions
const Int_t nRes = TOTsigD0.getManager()->getnRes();
//recalculate the normalization if necessary
//TOTsigD0.getManager()->calNorm();
EvtComplex normarray[nRes][nRes];
const Int_t myRes = 7;
TH1F fitty[myRes];
//read the integral value from the cache file.
//In this way we don't need to compute the normalization everytime during MIGRAD
char int_name[50];
TOTsigD0.getManager()->getFileName(int_name);
ifstream f1;
f1.open(int_name);
if (!f1){
cout << "Error opening file " << endl;
assert(0);
}
Double_t re=0.,im=0.;
//Read in the cache file and store back to array
for(Int_t j=0;j<nRes;j++) {
char thname[100];
sprintf(thname,"thname_%d",j);
if(j < myRes) fitty[j] = TH1F(thname,thname,30,0.,1.);
for(Int_t k=0;k<nRes;k++){
f1 >> re >> im;
normarray[j][k] = EvtComplex(re,im);
}
}
EvtComplex mynorm[myRes][myRes];
Int_t m = 0, l = 0;
for(Int_t i=0;i<myRes;i++){
for(Int_t j=0;j<myRes;j++){
if(i==0) l = 11;
else if(i==1) l = 5;
else if(i==2) l = 3;
else if(i==3) l = 10;
else if(i==4) l = 8;
else if(i==5) l = 2;
else if(i==6) l = 0;
if(j==0) m = 11;
else if(j==1) m = 5;
else if(j==2) m = 3;
else if(j==3) m = 10;
else if(j==4) m = 8;
else if(j==5) m = 2;
else if(j==6) m = 0;
mynorm[i][j] = normarray[l][m];
}
}
//do 100 experiments and extract parameters using covariance matrix
for(Int_t l=0;l<200;l++){
RooArgList listpar = fitRes->randomizePars();
if(l==0) listpar.Print();
Double_t mynormD0 = 0.;
EvtComplex coeff_i(0.,0.), coeff_j(0.,0.);
for(Int_t i=0;i<2*myRes;i++){
for(Int_t j=0;j<2*myRes;j++){
if(i==(2*myRes - 2)) coeff_i = EvtComplex(1.,0.);
else coeff_i = EvtComplex(((RooAbsReal*)listpar.at(i))->getVal()*cos(((RooAbsReal*)listpar.at(i+1))->getVal()),
((RooAbsReal*)listpar.at(i))->getVal()*sin(((RooAbsReal*)listpar.at(i+1))->getVal()));
if(j==(2*myRes - 2)) coeff_j = EvtComplex(1.,0.);
else coeff_j = EvtComplex(((RooAbsReal*)listpar.at(j))->getVal()*cos(((RooAbsReal*)listpar.at(j+1))->getVal()),
((RooAbsReal*)listpar.at(j))->getVal()*sin(((RooAbsReal*)listpar.at(j+1))->getVal()));
mynormD0 += real(coeff_i*conj(coeff_j)*(mynorm[i/2][j/2]));
j++;
}
i++;
}
//now calculate the fit fractions
for(Int_t i=0;i<2*myRes;i++){
Double_t fitfrac = 0.;
if(i==(2*myRes - 2)) fitfrac = abs(mynorm[i/2][i/2])/mynormD0;
else fitfrac = abs2( ((RooAbsReal*)listpar.at(i))->getVal())*abs(mynorm[i/2][i/2])/mynormD0;
fitty[i/2].Fill(fitfrac);
i++;
}
}// nexperiments
Double_t tot_frac = 0.;
for(Int_t i=0;i<myRes;i++){
tot_frac += fitty[i].GetMean();
cout << "Resonance " << i << ": fit fraction = " << fitty[i].GetMean() << " +/- " << fitty[i].GetRMS() << endl;
}
cout << "Total fit fraction = " << tot_frac << endl;
cout << "///////////////////////////" << endl;
}
return 0;
}
