int main(int argc, const char** argv){
bool ReDoCuts=false;
TCut TwelveCut = "gamma_CL>0.1&&BDT_response>0.36&&piplus_MC12TuneV3_ProbNNpi>0.2&&piminus_MC12TuneV3_ProbNNpi>0.2&&Kaon_MC12TuneV3_ProbNNk>0.4";
TCut ElevenCut = "gamma_CL>0.1&&BDT_response>0.30&&piplus_MC12TuneV3_ProbNNpi>0.2&&piminus_MC12TuneV3_ProbNNpi>0.2&&Kaon_MC12TuneV3_ProbNNk>0.4";
//______________________________MAKE CUT FILE FOR 2012___________________________________
if(ReDoCuts){
DataFile MCA(std::getenv("BUKETAPMCBDTRESPROOT"),MC,Twel,MagAll,buketap,"BDTApplied_SampleA");
DataFile MCB(std::getenv("BUKETAPMCBDTRESPROOT"),MC,Twel,MagAll,buketap,"BDTApplied_SampleB");
TreeReader* MC12Reader= new TreeReader("DecayTree");
MC12Reader->AddFile(MCA);
MC12Reader->AddFile(MCB);
MC12Reader->Initialize();
TFile* MC12Cut = new TFile("CutFile12.root","RECREATE");
TTree* MC12CutTree=MC12Reader->CopyTree(TwelveCut,-1,"DecayTree");
TRandom3 *MCRand = new TRandom3(224);
TH1I * MCnCands12= new TH1I("MCnCands12","MCnCands12",10,0,10);
TTree*MC12SingleTree=HandyFunctions::GetSingleTree(MCRand,MC12CutTree,MCnCands12,NULL);
MCnCands12->Write();
MC12SingleTree->Write();
MC12Cut->Close();
//________________________________MAKE CUT FILE FOR 2011__________________________________
DataFile MC11A(std::getenv("BUKETAPMCBDTRESPROOT"),MC,Elev,MagAll,buketap,"BDTApplied_SampleA");
DataFile MC11B(std::getenv("BUKETAPMCBDTRESPROOT"),MC,Elev,MagAll,buketap,"BDTApplied_SampleB");
TreeReader* MC11Reader= new TreeReader("DecayTree");
MC11Reader->AddFile(MC11A);
MC11Reader->AddFile(MC11B);
MC11Reader->Initialize();
TFile* MC11Cut = new TFile("CutFile11.root","RECREATE");
TTree* MC11CutTree=MC11Reader->CopyTree(ElevenCut,-1,"DecayTree");
TH1I * MCnCands11= new TH1I("MCnCands11","MCnCands11",10,0,10);
TTree* MC11SingleTree=HandyFunctions::GetSingleTree(MCRand,MC11CutTree,MCnCands11,NULL);
MCnCands11->Write();
MC11SingleTree->Write();
MC11Cut->Close();
//_________________________________ MAKE FLAT TREES ____________________________________
TFile* MC12Input = new TFile("CutFile12.root");
TTree* MC12InputTree=(TTree*)MC12Input->Get("DecayTree");
Float_t MCEta_Mass12[20]; MC12InputTree->SetBranchAddress("Bu_DTFNoFix_eta_prime_M",&MCEta_Mass12);
Int_t isSingle12; MC12InputTree->SetBranchAddress("isSingle",&isSingle12);
TFile* MC12FlatOut = new TFile("MCMinimalFile12.root","RECREATE");
TTree* MC12FlatTree = MC12InputTree->CloneTree(0);
Double_t MCBu_DTFNoFix_eta_Prime_MF12; MC12FlatTree->Branch("Bu_DTFNoFix_eta_prime_MF",&MCBu_DTFNoFix_eta_Prime_MF12,"Bu_DTFNoFix_eta_prime_MF/D");
Long64_t Entries12=MC12InputTree->GetEntries();
for(int i=0;i<Entries12;++i){
MC12InputTree->GetEntry(i);
if(isSingle12==0)continue;
MCBu_DTFNoFix_eta_Prime_MF12=MCEta_Mass12[0];
MC12FlatTree->Fill();
}
MC12FlatTree->Write();
MC12FlatOut->Close();
TFile* MC11Input = new TFile("CutFile11.root");
TTree* MC11InputTree=(TTree*)MC11Input->Get("DecayTree");
Float_t MCEta_Mass11[20]; MC11InputTree->SetBranchAddress("Bu_DTFNoFix_eta_prime_M",&MCEta_Mass11);
Int_t isSingle11; MC11InputTree->SetBranchAddress("isSingle",&isSingle11);
TFile* MC11FlatOut = new TFile("MCMinimalFile11.root","RECREATE");
TTree* MC11FlatTree = MC11InputTree->CloneTree(0);
Double_t MCBu_DTFNoFix_eta_Prime_MF11; MC11FlatTree->Branch("Bu_DTFNoFix_eta_prime_MF",&MCBu_DTFNoFix_eta_Prime_MF11,"Bu_DTFNoFix_eta_prime_MF/D");
Long64_t Entries11=MC11InputTree->GetEntries();
for(int i=0;i<Entries11;++i){
MC11InputTree->GetEntry(i);
if(isSingle11==0)continue;
MCBu_DTFNoFix_eta_Prime_MF11=MCEta_Mass11[0];
MC11FlatTree->Fill();
}
MC11FlatTree->Write();
MC11FlatOut->Close();
}
//_____________________________________________LOAD ROODATASETS___________________________________
TFile* MCFlatInput12= new TFile("MCMinimalFile12.root");
TTree* MCFlatInputTree12=(TTree*)MCFlatInput12->Get("DecayTree");
TFile* MCFlatInput11= new TFile("MCMinimalFile11.root");
TTree* MCFlatInputTree11=(TTree*)MCFlatInput11->Get("DecayTree");
RooRealVar MCBMass("Bu_DTF_MF","Bu_DTF_MF",5000.0,5600.0);
RooRealVar MCEtaMass("eta_prime_MM","eta_prime_MM",700.0,1200.0);
RooRealVar BDT_response("BDT_response","BDT_response",-1.0,1.0);
RooRealVar gamma_CL("gamma_CL","gamma_CL",0.1,1.0);
RooArgSet Args(MCBMass,MCEtaMass,BDT_response,gamma_CL);
RooDataSet* MCData12 = new RooDataSet("MCData12","MCData12",Args,Import(*MCFlatInputTree12));
std::cout <<" Data File 12 Loaded"<<std::endl;
RooDataSet* MCData11 = new RooDataSet("MCData11","MCData11",Args,Import(*MCFlatInputTree11));
std::cout<<" Data File 11 loaded"<<std::endl;
RooDataSet* MCDataAll= new RooDataSet("MCDataAll","MCDataAll",Args);
MCDataAll->append(*MCData12);
MCDataAll->append(*MCData11);
RooPlot* massFrame = MCBMass.frame(Title("Data Import Check"),Bins(50));
MCDataAll->plotOn(massFrame);
RooPlot *BDTFrame = BDT_response.frame(Title("BDT Cut Check"),Bins(50));
MCDataAll->plotOn(BDTFrame);
TCanvas C;
C.Divide(2,1);
C.cd(1);
massFrame->Draw();
C.cd(2);
BDTFrame->Draw();
C.SaveAs("ImportChecks.eps");
//________________________________MAKE MCROODATACATEGORIES__________________________________
RooDataSet* MCBData=(RooDataSet*)MCDataAll->reduce(RooArgSet(MCBMass));
MCBData->Print("v");
RooDataSet* MCEtaData=(RooDataSet*)MCDataAll->reduce(RooArgSet(MCEtaMass));
MCEtaData->Print("v");
RooCategory MCMassType("MCMassType","MCMassType") ;
MCMassType.defineType("B") ;
MCMassType.defineType("Eta") ;
// Construct combined dataset in (x,sample)
RooDataSet MCcombData("MCcombData","MC combined data",Args,Index(MCMassType),Import("B",*MCBData),Import("Eta",*MCEtaData));
//=============================================== MC FIT MODEL===================================
RooRealVar Mean("Mean","Mean",5279.29,5276.0,5284.00);
RooRealVar Sigma("Sigma","Sigma",20.54,17.0,24.8);
RooRealVar LAlpha("LAlpha","LAlpha",-1.064,-2.5,0.0);
RooRealVar RAlpha("RAlpha","RAlpha",1.88,0.0,5.0);
RooRealVar LN("LN","LN",13.0,0.0,40.0);
RooRealVar RN("RN","RN",2.56,0.0,6.0);
RooCBShape CBLeft("CBLeft","CBLeft",MCBMass,Mean,Sigma,LAlpha,LN);
RooCBShape CBRight("CBRight","CBRight",MCBMass,Mean,Sigma,RAlpha,RN);
RooRealVar FitFraction("FitFraction","FitFraction",0.5,0.0,1.0);
RooAddPdf DCB("DCB","DCB",RooArgList(CBRight,CBLeft),FitFraction);
RooRealVar SignalYield("SignalYield","SignalYield",4338.0,500.0,10000.0);
// RooExtendPdf ExtDCB("ExtDCB","ExtDCB",DCB,SignalYield);
//==============================ETA DCB ++++++++++++++++++++++++++++++
RooRealVar MCEtamean("MCEtamean","MCEtamean",958.0,955.0,960.0);
RooRealVar MCEtasigma("MCEtasigma","MCEtasigma",9.16,8.0,14.0);
RooRealVar EtaLAlpha("EtaLAlpha","EtaLAlpha",-1.45,-5.0,1.0);
RooRealVar EtaRAlpha("EtaRAlpha","EtaRAlpha",1.76,0.0,4.0);
RooRealVar EtaLN("EtaLN","EtaLN",0.1,0.0,20.0);
RooRealVar EtaRN("EtaRN","EtaRN",0.1,0.0,20.0);
RooCBShape EtaCBLeft("EtaCBLeft","EtaCBLeft",MCEtaMass,MCEtamean,MCEtasigma,EtaLAlpha,EtaLN);
RooCBShape EtaCBRight("EtaCBRight","EtaCBRight",MCEtaMass,MCEtamean,MCEtasigma,EtaRAlpha,EtaRN);
RooRealVar EtaFitFraction("EtaFitFraction","EtaFitFraction",0.22,0.1,1.0);
RooAddPdf EtaDCB("EteaDCB","EtaDCB",RooArgList(EtaCBRight,EtaCBLeft),EtaFitFraction);
RooProdPdf MCSignalPdf("MCSignalPdf","MCSignalPdf",RooArgSet(EtaDCB,DCB));
RooExtendPdf ExtendedMCSignalPdf("ExtendedMCSignalPdf","ExtendedMCSignalPdf",MCSignalPdf,SignalYield);
RooSimultaneous MCsimPdf("MCsimPdf","MC simultaneous pdf",MCMassType) ;
// MCsimPdf.addPdf(ExtDCB,"B");
// MCsimPdf.addPdf(ExtendedMCEtaDCB,"Eta");
//============================== DO the MC FIT =======================================
//MCsimPdf.fitTo(MCcombData,Extended(kTRUE),Minos(kTRUE));
//ExtendedMCEtaDCB.fitTo(*MCEtaData,Extended(kTRUE),Minos(kTRUE));
//ExtDCB.fitTo(*MCBData,Extended(
ExtendedMCSignalPdf.fitTo(*MCDataAll,Extended(kTRUE),Minos(kTRUE));
RooPlot* MCframe1 = MCBMass.frame(Range(5100.0,5500.0),Bins(50),Title("B mass projection"));
MCDataAll->plotOn(MCframe1);
ExtendedMCSignalPdf.plotOn(MCframe1);
ExtendedMCSignalPdf.paramOn(MCframe1);
RooPlot* MCframe2 = MCEtaMass.frame(Range(880.0,1020.0),Bins(50),Title("Eta mass projection")) ;
MCDataAll->plotOn(MCframe2);
ExtendedMCSignalPdf.plotOn(MCframe2);
ExtendedMCSignalPdf.paramOn(MCframe2);
TCanvas* MCc = new TCanvas("rf501_simultaneouspdf","rf403_simultaneouspdf",1200,1000) ;
gPad->SetLeftMargin(0.15) ; MCframe1->GetYaxis()->SetTitleOffset(1.4) ; MCframe1->Draw() ;
MCc->SaveAs("MCSimulCanvas.pdf");
TCanvas* MCcEta = new TCanvas(" Eta Canvas","Eta Canvas",1200,1000);
gPad->SetLeftMargin(0.15) ; MCframe2->GetYaxis()->SetTitleOffset(1.4) ; MCframe2->Draw() ;
MCcEta->SaveAs("MCEtaCanvas.pdf");
TFile* MCFits= new TFile("MCFitResult.root","RECREATE");
// TCanvas* DecMCB=HandyFunctions::DecoratePlot(MCframe1);
// TCanvas* DecMCEta=HandyFunctions::DecoratePlot(MCframe2);
//DecMCEta->Write();
// DecMCB->Write();
MCc->Write();
MCcEta->Write();
std::cout<<"MC Eta Chi2 = "<<MCframe2->chiSquare()<<std::endl;
std::cout<<"MC B Chi2 = "<<MCframe1->chiSquare()<<std::endl;
//___________________________________ CUT DOWN COLLISION DATA ______________________________
if(ReDoCuts){
DataFile TwelveA(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Twel,MagAll,buketap,"BDTApplied_SampleA");
DataFile TwelveB(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Twel,MagAll,buketap,"BDTApplied_SampleB");
DataFile ElevenA(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Elev,MagAll,buketap,"BDTApplied_SampleA");
DataFile ElevenB(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Elev,MagAll,buketap,"BDTApplied_SampleB");
TRandom3* DataRand= new TRandom3(224);
TH1I* DataNCand12= new TH1I("DataNCand12","DataNCand12",10,0,10);
TH1I* DataNCand11= new TH1I("DataNCand11","DataNCand11",10,0,10);
TreeReader* UncutDataReader12= new TreeReader("DecayTree");
UncutDataReader12->AddFile(TwelveA);
UncutDataReader12->AddFile(TwelveB);
UncutDataReader12->Initialize();
TFile* CutDataFile12 = new TFile("CutDataFile12.root","RECREATE");
TTree* CutDataTree12 = UncutDataReader12->CopyTree(TwelveCut,-1,"DecayTree");
TTree* SingleCutDataTree12=HandyFunctions::GetSingleTree(DataRand,CutDataTree12,DataNCand12,NULL);
SingleCutDataTree12->Write();
CutDataFile12->Close();
TreeReader* UncutDataReader11= new TreeReader("DecayTree");
UncutDataReader11->AddFile(ElevenB);
UncutDataReader11->AddFile(ElevenA);
UncutDataReader11->Initialize();
TFile* CutDataFile11 = new TFile("CutDataFile11.root","RECREATE");
TTree* CutDataTree11 = UncutDataReader11->CopyTree(ElevenCut,-1,"DecayTree");
TTree* SingleCutDataTree11=HandyFunctions::GetSingleTree(DataRand,CutDataTree11,DataNCand11,NULL);
SingleCutDataTree11->Write();
CutDataFile11->Close();
TFile* DataInput12 = new TFile("CutDataFile12.root");
TTree* DataInputTree12=(TTree*)DataInput12->Get("DecayTree");
DataInputTree12->SetBranchStatus("*",0);
DataInputTree12->SetBranchStatus("Bu_DTF_MF",1);
DataInputTree12->SetBranchStatus("Bu_DTFNoFix_eta_prime_M",1);
DataInputTree12->SetBranchStatus("eta_prime_MM",1);
DataInputTree12->SetBranchStatus("isSingle",1);
Float_t Eta_Mass12[20]; DataInputTree12->SetBranchAddress("Bu_DTFNoFix_eta_prime_M",&Eta_Mass12);
Int_t isSingle12; DataInputTree12->SetBranchAddress("isSingle",&isSingle12);
TFile* MinimalDataFile12 = new TFile("MinimalDataFile12.root","RECREATE");
TTree* MinimalDataTree12= DataInputTree12->CloneTree(0);
Double_t Bu_DTFNoFix_eta_prime_MF12; MinimalDataTree12->Branch("Bu_DTFNoFix_eta_prime_MF",&Bu_DTFNoFix_eta_prime_MF12,"Bu_DTFNoFix_eta_prime_MF/D");
Long64_t Entries12=DataInputTree12->GetEntries();
for(int i=0;i<Entries12;++i){
DataInputTree12->GetEntry(i);
if(isSingle12==0)continue;
Bu_DTFNoFix_eta_prime_MF12=Eta_Mass12[0];
MinimalDataTree12->Fill();
}
MinimalDataTree12->Write();
MinimalDataFile12->Close();
TFile* DataInput11 = new TFile("CutDataFile11.root");
TTree* DataInputTree11=(TTree*)DataInput11->Get("DecayTree");
DataInputTree11->SetBranchStatus("*",0);
DataInputTree11->SetBranchStatus("Bu_DTF_MF",1);
DataInputTree11->SetBranchStatus("Bu_DTFNoFix_eta_prime_M",1);
DataInputTree11->SetBranchStatus("eta_prime_MM",1);
DataInputTree11->SetBranchStatus("isSingle",1);
Float_t Eta_Mass11[20]; DataInputTree11->SetBranchAddress("Bu_DTFNoFix_eta_prime_M",&Eta_Mass11);
Int_t isSingle11; DataInputTree11->SetBranchAddress("isSingle",&isSingle11);
TFile* MinimalDataFile11 = new TFile("MinimalDataFile11.root","RECREATE");
TTree* MinimalDataTree11= DataInputTree11->CloneTree(0);
Double_t Bu_DTFNoFix_eta_prime_MF11; MinimalDataTree11->Branch("Bu_DTFNoFix_eta_prime_MF",&Bu_DTFNoFix_eta_prime_MF11,"Bu_DTFNoFix_eta_prime_MF/D");
Long64_t Entries11=DataInputTree11->GetEntries();
for(int i=0;i<Entries11;++i){
DataInputTree11->GetEntry(i);
if(isSingle11==0)continue;
Bu_DTFNoFix_eta_prime_MF11=Eta_Mass11[0];
MinimalDataTree11->Fill();
}
MinimalDataTree11->Write();
MinimalDataFile11->Close();
}
//___________________________________ LOAD DATA TO ROODATASET____________________________________
RooRealVar BMass("Bu_DTF_MF","Bu_DTF_MF",5000.0,5600.0);
RooRealVar EtaMass("eta_prime_MM","eta_prime_MM",870.0,1050.0);
RooArgSet MassArgs(BMass,EtaMass);
TFile* Data12File = new TFile("MinimalDataFile12.root");
TTree* DataTree12=(TTree*)Data12File->Get("DecayTree");
RooDataSet* Data12 = new RooDataSet("Data12","Data12",MassArgs,Import(*DataTree12));
TFile* Data11File = new TFile("MinimalDataFile11.root");
TTree* DataTree11=(TTree*)Data11File->Get("DecayTree");
RooDataSet* Data11 = new RooDataSet("Data11","Data11",MassArgs,Import(*DataTree11));
RooDataSet* AllData = new RooDataSet("AllData","AllData",MassArgs);
AllData->append(*Data12);
AllData->append(*Data11);
TCanvas ImportC;
RooPlot* ImportCheck = BMass.frame(Title("ImportCheck"),Bins(50));
AllData->plotOn(ImportCheck);
ImportCheck->Draw();
ImportC.SaveAs("Alldataimport.pdf");
std::cout<<" Data Loaded, Total Entries = "<<AllData->numEntries()<<std::endl;
AllData->Print("v");
RooDataSet* BData=(RooDataSet*)AllData->reduce(RooArgSet(BMass));
BData->Print("v");
RooDataSet* EtaData=(RooDataSet*)AllData->reduce(RooArgSet(EtaMass));
EtaData->Print("v");
//___________________________________Fit to Eta_Prime in BMass Sidebands______________________
RooDataSet* BSidebands=(RooDataSet*)AllData->reduce(Cut("(Bu_DTF_MF>5000.0&&Bu_DTF_MF<5179.0)||(Bu_DTF_MF>5379.0&&Bu_DTF_MF<5800.0)"));
TCanvas BSidebandCanvas;
RooPlot* BSidebandPlot = EtaMass.frame(Title("B sidebands"),Bins(30));
BSidebands->plotOn(BSidebandPlot);
BSidebandPlot->Draw();
BSidebandCanvas.SaveAs("BSidebandDataCheck.pdf");
RooRealVar BsbMean(" Mean","BsbMean",958.0,900.0,1020.0);
RooRealVar BsbSigma(" Sigma","BsbSigma",19.8,10.0,40.8);
RooRealVar BsbLAlpha(" Alpha","BsbLAlpha",-1.63,-10.0,0.0);
// RooRealVar BsbRAlpha("BsbRAlpha","BsbRAlpha",1.47,0.0,10.0);
RooRealVar BsbLN(" N","BsbLN",0.1,0.0,20.0);
// RooRealVar BsbRN("BsbRN","BsbRN",0.1,0.0,20.0);
RooCBShape BsbCBLeft("BsbCBLeft","BsbCBLeft",EtaMass,BsbMean,BsbSigma,BsbLAlpha,BsbLN);
// RooCBShape BsbCBRight("BsbCBRight","BsbCBRight",EtaMass,BsbMean,BsbSigma,BsbRAlpha,BsbRN);
// RooRealVar BsbFitFraction("BsbFitFraction","BsbFitFraction",0.5,0.0,1.0);
// RooAddPdf BsbDCB("BsbDCB","BsbDCB",RooArgList(BsbCBRight,BsbCBLeft),BsbFitFraction);
RooRealVar Bsbslope("Bsbslope","Bsbslope",0.5,0.0,1.0);
RooRealVar BsbP2("BsbP2","BsbP2",-0.5,-1.0,0.0);
RooChebychev BsbLinear("BsbLinear","BsbLinear",EtaMass,RooArgSet(Bsbslope,BsbP2));
RooRealVar BsbFitFraction("BsbFitFraction","BsbFitFraction",0.2,0.0,1.0);
RooAddPdf BsbBackground("BsbBackground","BsbBackground",RooArgList(BsbLinear,BsbCBLeft),BsbFitFraction);
RooRealVar BsbYield(" Yield","BsbYield",500.0,0.0,1000.0);
RooExtendPdf BsbExtDCB("BsbExtDCB","BsbExtDCB",BsbCBLeft,BsbYield);
BsbExtDCB.fitTo(*BSidebands,Extended(kTRUE),Minos(kTRUE));
TCanvas BSBFitCanvas;
RooPlot* BSBFitPlot = EtaMass.frame(Title("Eta fit in B Sidebands"),Bins(30));
BSidebands->plotOn(BSBFitPlot);
BsbExtDCB.plotOn(BSBFitPlot);
BsbExtDCB.paramOn(BSBFitPlot);
BSBFitPlot->Draw();
BSBFitCanvas.SaveAs("BSidebandFit.pdf");
TFile * SidebandFitFile= new TFile("SidebandFit.root","RECREATE");
BSBFitCanvas.Write();
SidebandFitFile->Close();
//___________________________________DO THE 2D FIT TO DATA___________________________________
const double PDGBMass= 5279.26;
BMass.setRange("SignalWindow",PDGBMass-(3*Sigma.getVal()),PDGBMass+(3*Sigma.getVal()));
RooRealVar DSignalYield("DSignalYield","DSignalYield",4000.0,0.0,10000.0);
//================================= B MASS SIGNAL PDF==============================
RooRealVar DMean("Mean","DMean",5279.29,5270.0,5290.00);
RooRealVar DSigma("Sigma","DSigma",19.8,10.0,40.8);
RooRealVar DLAlpha("DLAlpha","DLAlpha",LAlpha.getVal());
RooRealVar DRAlpha("DRAlpha","DRAlpha",RAlpha.getVal());
RooRealVar DLN("DLN","DLN",LN.getVal());
RooRealVar DRN("DRN","DRN",RN.getVal());
RooCBShape DCBLeft("DCBLeft","DCBLeft",BMass,DMean,DSigma,DLAlpha,DLN);
RooCBShape DCBRight("DCBRight","DCBRight",BMass,DMean,DSigma,DRAlpha,DRN);
RooRealVar DFitFraction("FitFraction","DFitFraction",0.5,0.0,1.0);
RooAddPdf DDCB("DDCB","DDCB",RooArgList(DCBRight,DCBLeft),DFitFraction);
//==============================B MASS BKG PDF==============================
RooRealVar slope("slope","slope",-0.5,-1.0,0.0);
RooChebychev bkg("bkg","Background",BMass,RooArgSet(slope));
//==============================Eta mass signal pdf================================
RooRealVar DEtamean("Etamean","DEtamean",958.0,945.0,980.0) ;
RooRealVar DEtasigma("Etasigma","DEtasigma",15.0,5.0,65.0) ;
RooRealVar DEtaLAlpha("DEtaLAlpha","DEtaLAlpha",EtaLAlpha.getVal());
RooRealVar DEtaRAlpha("DEtaRAlpha","DEtaRAlpha",EtaRAlpha.getVal());
RooRealVar DEtaLN("DEtaLN","DEtaLN",EtaLN.getVal());
RooRealVar DEtaRN("DEtaRN","DEtaRN",EtaRN.getVal());
RooCBShape EtaDCBLeft("EtaDCBLeft","EtaDCBLeft",EtaMass,DEtamean,DEtasigma,DEtaLAlpha,DEtaLN);
RooCBShape EtaDCBRight("EtaDCBRight","EtaDCBRight",EtaMass,DEtamean,DEtasigma,DEtaRAlpha,DEtaRN);
RooRealVar DEtaFitFraction("EtaFitFraction","DEtaFitFraction",0.5,0.0,1.0);
RooAddPdf EtaDDCB("EtaDDCB","EtaDDCB",RooArgList(EtaDCBRight,EtaDCBLeft),DEtaFitFraction);
RooProdPdf DSignalPdf("DSignalPdf","DSignalPdf",RooArgList(EtaDDCB,DDCB));
RooExtendPdf DExtSignalPdf("DExtSignalPdf","DExtSignalPdf",DSignalPdf,DSignalYield);
//=============================== Eta mass bkg pdf==================================
RooRealVar EtaBkgMean("EtaBkgMean","EtaBkgMean",958.0,900.0,1020.0);
RooRealVar EtaBkgSigma("EtaBkgSigma","EtaBkgSigma",19.8,10.0,40.8);
RooRealVar EtaBkgLAlpha("EtaBkgLAlpha","EtaBkgLAlpha",BsbLAlpha.getVal());
// RooRealVar EtaBkgRAlpha("EtaBkgRAlpha","EtaBkgRAlpha",BsbRAlpha.getVal());
RooRealVar EtaBkgLN("EtaBkgLN","EtaBkgLN",BsbLN.getVal());
// RooRealVar EtaBkgRN("EtaBkgRN","EtaBkgRN",BsbRN.getVal());
RooCBShape EtaBkgCBLeft("EtaBkgCBLeft","EtaBkgCBLeft",EtaMass,DEtamean,EtaBkgSigma,EtaBkgLAlpha,EtaBkgLN);
// RooCBShape EtaBkgCBRight("EtaBkgCBRight","EtaBkgCBRight",EtaMass,DEtamean,EtaBkgSigma,EtaBkgRAlpha,EtaBkgRN);
// RooRealVar EtaBkgFitFraction("EtaBkgFitFraction","EtaBkgFitFraction",0.5,0.0,1.0);
// RooAddPdf EtaBkgDCB("EtaBkgDCB","EtaBkgDCB",RooArgList(EtaBkgCBRight,EtaBkgCBLeft),EtaBkgFitFraction);
RooProdPdf DataBackgroundPDF("DataBackgroundPDF","DataBackgroundPDF",RooArgList(EtaBkgCBLeft,bkg));
RooRealVar DataBackgroundYield("BackgroundYield","DataBackgroundYield",500.0,0.0,10000.0);
RooExtendPdf ExtDataBackgroundPDF("ExtDataBackgroundPDF","ExtDataBackgroundPDF",DataBackgroundPDF,DataBackgroundYield);
RooAddPdf TotalPDF("TotalPDF","TotalPDF",RooArgList(ExtDataBackgroundPDF,DExtSignalPdf));
std::cout<<"Dependents = "<<std::endl;
RooArgSet* Dependents=TotalPDF.getDependents(AllData);
Dependents->Print("v");
std::cout<<"parameters= "<<std::endl;
RooArgSet* parameters=TotalPDF.getParameters(AllData);
parameters->Print("v");
RooCategory MassType("MassType","MassType") ;
MassType.defineType("B") ;
MassType.defineType("Eta") ;
// Construct combined dataset in (x,sample)
RooDataSet combData("combData","combined data",MassArgs,Index(MassType),Import("B",*BData),Import("Eta",*EtaData));
RooSimultaneous simPdf("simPdf","simultaneous pdf",MassType) ;
// Associate model with the physics state and model_ctl with the control state
// simPdf.addPdf(WholeFit,"B");
// simPdf.addPdf(WholeEtaFit,"Eta");
// simPdf.fitTo(combData,Extended(kTRUE)/*,Minos(kTRUE)*/);
TotalPDF.fitTo(*AllData,Extended(kTRUE),Minos(kTRUE));
RooPlot* frame1 = BMass.frame(Bins(50),Title("B mass projection"));
AllData->plotOn(frame1);
TotalPDF.plotOn(frame1,Components(ExtDataBackgroundPDF),LineStyle(kDashed),LineColor(kRed));
TotalPDF.plotOn(frame1);
TotalPDF.paramOn(frame1);
// The same plot for the control sample slice
RooPlot* frame2 = EtaMass.frame(Bins(50),Title("Eta mass projection")) ;
AllData->plotOn(frame2);
TotalPDF.plotOn(frame2,Components(ExtDataBackgroundPDF),LineStyle(kDashed),LineColor(kRed));
TotalPDF.plotOn(frame2);
TotalPDF.paramOn(frame2);
TCanvas* DecoratedCanvas =HandyFunctions::DecoratePlot(frame2);
TCanvas* DataBC= new TCanvas("BCanvas","BCanvas",1200,1000) ;
gPad->SetLeftMargin(0.15) ; frame1->GetYaxis()->SetTitleOffset(1.4) ; frame1->Draw() ;
TCanvas* EtaBC= new TCanvas("EtaCanvas","EtaCanvas",1200,1000) ;
gPad->SetLeftMargin(0.15) ; frame2->GetYaxis()->SetTitleOffset(1.4) ; frame2->Draw() ;
DataBC->SaveAs("DataBC.pdf");
EtaBC->SaveAs("EtaBC.pdf");
TFile * DataSimulFit = new TFile("DataSimulFit.root","RECREATE");
DataBC->Write();
EtaBC->Write();
DecoratedCanvas->Write();
}
int main (int argc, char **argv)
{
const char* chInFile = "ws.root";
const char* chOutFile = "ws_gen.root";
int numSignal = 10000;
int numBkg = 100000;
char option_char;
while ( (option_char = getopt(argc,argv, "i:o:s:b:")) != EOF )
switch (option_char)
{
case 'i': chInFile = optarg; break;
case 'o': chOutFile = optarg; break;
case 's': numSignal = atoi(optarg); break;
case 'b': numBkg = atoi(optarg); break;
case '?': fprintf (stderr,
"usage: %s [i<input file> o<output file>]\n", argv[0]);
}
cout << "In File = " << chInFile << endl;
cout << "Out File = " << chOutFile << endl;
cout << "Signal Events = " << numSignal << endl;
cout << "Bkg Events = " << numBkg << endl;
TFile inFile(chInFile,"READ");
RooWorkspace* ws = (RooWorkspace*) inFile.Get("rws");
TFile outFile(chOutFile,"RECREATE");
/*
ws->var("tau")->setVal(1.417);
ws->var("DG")->setVal(0.151);
ws->var("beta")->setVal(0.25);
ws->var("A02")->setVal(0.553);
ws->var("A1")->setVal(0.487);
ws->var("delta_l")->setVal(3.15);
ws->var("fs")->setVal(0.147);
*/
// ws->var("delta_l")->setConstant(kTRUE);
// ws->var("delta_p")->setConstant(kTRUE);
// ws->var("Dm")->setConstant(kTRUE);
//*ws->var("xs") = numSignal/(numSignal+numBkg);
// int numSignal = numEvents * ws->var("xs")->getVal();
// int numBkg = numEvents - numSignal;
ws->factory("Gaussian::dilutionGauss(d,0,0.276)");
//ws->factory("SUM::dSignalPDF(xds[0.109]*dilutionGauss,TruthModel(d))");
//ws->factory("SUM::dBkgPDF(xdb[0.109]*dilutionGauss,TruthModel(d))");
ws->factory("SUM::dSignalPDF(xds[1]*dilutionGauss,TruthModel(d))");
ws->factory("SUM::dBkgPDF(xdb[1]*dilutionGauss,TruthModel(d))");
/*
ws->factory("GaussModel::xetGaussianS(et,meanGaussEtS,sigmaGaussEtS)");
ws->factory("Decay::xerrorSignal(et,tauEtS,xetGaussianS,SingleSided]");
ws->factory("PROD::xsignalTimeAngle(timeAngle|et,xerrorSignal");
ws->factory("PROD::xsignal(massSignal,xsignalTimeAngle,DmConstraint)");
*/
RooDataSet* dSignalData = ws->pdf("dSignalPDF")->generate(RooArgSet(*ws->var("d")),numSignal);
RooDataSet *dataSignal = ws->pdf("signal")->generate(RooArgSet(*ws->var("m"),*ws->var("t"),*ws->var("et"),*ws->var("cpsi"),*ws->var("ctheta"),*ws->var("phi")), RooFit::ProtoData(*dSignalData));
ws->factory("GaussModel::xetGaussianPR(et,meanGaussEtPR,sigmaGaussEtPR)");
ws->factory("Decay::xerrBkgPR(et,tauEtPR,xetGaussianPR,SingleSided]");
ws->factory("GaussModel::xetGaussianNP(et,meanGaussEtNP,sigmaGaussEtNP)");
ws->factory("Decay::xerrBkgNP(et,tauEtNP,xetGaussianNP,SingleSided]");
/* Time */
ws->factory("GaussModel::xresolution(t,0,scale,et)");
ws->factory("Decay::xnegativeDecay(t,tauNeg,xresolution,Flipped)");
ws->factory("Decay::xpositiveDecay(t,tauPos,xresolution,SingleSided)");
ws->factory("Decay::xpositiveLongDecay(t,tauLngPos,xresolution,SingleSided)");
ws->factory("RSUM::xtBkgNP(xn*xnegativeDecay,xp*xpositiveDecay,xpositiveLongDecay");
/* Promt and Non-Prompt */
ws->factory("PROD::xtimeBkgNP(xtBkgNP|et,xerrBkgNP)");
ws->factory("PROD::xtimeBkgPR(xresolution|et,xerrBkgPR)");
ws->factory("PROD::xPrompt(massBkgPR,xtimeBkgPR,anglePR)");
ws->factory("PROD::xNonPrompt(massBkgNP,xtimeBkgNP,angleNP)");
ws->factory("SUM::xbackground(xprompt*xPrompt,xNonPrompt)");
RooDataSet* dBkgData = ws->pdf("dBkgPDF")->generate(RooArgSet(*ws->var("d")),numBkg);
RooDataSet* dataBkg = ws->pdf("xbackground")->generate(RooArgSet(*ws->var("m"),*ws->var("t"),*ws->var("et"),*ws->var("cpsi"),*ws->var("ctheta"),*ws->var("phi")), numBkg);
dataBkg->merge(dBkgData);
dataSignal->SetName("dataGenSignal");
dataBkg->SetName("dataGenBkg");
ws->import(*dataSignal);
ws->import(*dataBkg);
////ws->import(*dataBkg,RooFit::Rename("dataGenBkg"));
dataSignal->append(*dataBkg);
dataSignal->SetName("dataGen");
ws->import(*dataSignal);
//RooFitResult *fit_result = ws->pdf("model")->fitTo(*ws->data("data"), RooFit::Save(kTRUE), RooFit::ConditionalObservables(*ws->var("d")), RooFit::NumCPU(2), RooFit::PrintLevel(3));
/*
gROOT->SetStyle("Plain");
TCanvas canvas("canvas", "canvas", 400,400);
RooPlot *m_frame = ws->var("t")->frame();
dataSignal->plotOn(m_frame, RooFit::MarkerSize(0.3));
m_frame->Draw();
canvas.SaveAs("m_toy_plot.png");
*/
/*
gROOT->SetStyle("Plain");
TCanvas canvas("canvas", "canvas", 800,400);
canvas.Divide(2);
canvas.cd(1);
RooPlot *t_frame = ws->var("t")->frame();
ws->data("data")->plotOn(t_frame, RooFit::MarkerSize(0.3));
gPad->SetLogy(1);
t_frame->Draw();
canvas.cd(2);
RooPlot *et_frame = ws->var("et")->frame();
ws->data("data")->plotOn(et_frame,RooFit::MarkerSize(0.2));
ws->pdf("errorSignal")->plotOn(et_frame);
gPad->SetLogy(1);
et_frame->Draw();
canvas.SaveAs("t.png");
canvas.cd(2);
gPad->SetLogy(0);
RooPlot *cpsi_frame = ws.var("cpsi")->frame();
data->plotOn(cpsi_frame,RooFit::MarkerSize(0.2), RooFit::Rescale(1));
data2->plotOn(cpsi_frame,
RooFit::LineColor(kBlue), RooFit::DrawOption("L"));
cpsi_frame->Draw();
canvas.cd(3);
RooPlot *ctheta_frame = ws.var("ctheta")->frame();
data->plotOn(ctheta_frame,RooFit::MarkerSize(0.2), RooFit::Rescale(1));
data2->plotOn(ctheta_frame,
RooFit::LineColor(kBlue), RooFit::DrawOption("L"));
ctheta_frame->Draw();
canvas.cd(4);
RooPlot *phi_frame = ws.var("phi")->frame();
data->plotOn(phi_frame,RooFit::MarkerSize(0.2), RooFit::Rescale(1));
data2->plotOn(phi_frame,
RooFit::LineColor(kBlue), RooFit::DrawOption("L"));
phi_frame->Draw();
canvas.SaveAs("t.png");
*/
ws->data("dataGen")->Print();
ws->data("dataGenSignal")->Print();
ws->data("dataGenBkg")->Print();
ws->Write("rws");
outFile.Close();
inFile.Close();
}
int main(int argc, char* argv[]){
string bkgFileName;
string sigFileName;
string sigWSName;
string bkgWSName;
string outFileName;
string datFileName;
string outDir;
int cat;
int ntoys;
int jobn;
int seed;
float mu_low;
float mu_high;
float mu_step;
float expectSignal;
int expectSignalMass;
bool skipPlots=false;
int verbosity;
bool throwHybridToys=false;
vector<float> switchMass;
vector<string> switchFunc;
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "Show help")
("sigfilename,s", po::value<string>(&sigFileName), "Signal file name")
("bkgfilename,b", po::value<string>(&bkgFileName), "Background file name")
("sigwsname", po::value<string>(&sigWSName)->default_value("cms_hgg_workspace"), "Signal workspace name")
("bkgwsname", po::value<string>(&bkgWSName)->default_value("cms_hgg_workspace"), "Background workspace name")
("outfilename,o", po::value<string>(&outFileName)->default_value("BiasStudyOut.root"), "Output file name")
("datfile,d", po::value<string>(&datFileName)->default_value("config.dat"), "Name of datfile containing pdf info")
("outDir,D", po::value<string>(&outDir)->default_value("./"), "Name of out directory for plots")
("cat,c", po::value<int>(&cat), "Category")
("ntoys,t", po::value<int>(&ntoys)->default_value(0), "Number of toys to run")
("jobn,j", po::value<int>(&jobn)->default_value(0), "Job number")
("seed,r", po::value<int>(&seed)->default_value(0), "Set random seed")
("mulow,L", po::value<float>(&mu_low)->default_value(-3.), "Value of mu to start scan")
("muhigh,H", po::value<float>(&mu_high)->default_value(3.), "Value of mu to end scan")
("mustep,S", po::value<float>(&mu_step)->default_value(0.01), "Value of mu step size")
("expectSignal", po::value<float>(&expectSignal)->default_value(0.), "Inject signal into toy")
("expectSignalMass", po::value<int>(&expectSignalMass)->default_value(125), "Inject signal at this mass")
("skipPlots", "Skip full profile and toy plots")
("verbosity,v", po::value<int>(&verbosity)->default_value(0), "Verbosity level")
;
po::variables_map vm;
po::store(po::parse_command_line(argc,argv,desc),vm);
po::notify(vm);
if (vm.count("help")) { cout << desc << endl; exit(1); }
if (vm.count("skipPlots")) skipPlots=true;
if (expectSignalMass!=110 && expectSignalMass!=115 && expectSignalMass!=120 && expectSignalMass!=125 && expectSignalMass!=130 && expectSignalMass!=135 && expectSignalMass!=140 && expectSignalMass!=145 && expectSignalMass!=150){
cerr << "ERROR - expectSignalMass has to be integer in range (110,150,5)" << endl;
exit(1);
}
vector<pair<int,pair<string,string> > > toysMap;
vector<pair<int,pair<string,string> > > fabianMap;
vector<pair<int,pair<string,string> > > paulMap;
readDatFile(datFileName,cat,toysMap,fabianMap,paulMap);
cout << "Toy vector.." << endl;
printOptionsMap(toysMap);
cout << "Fabian vector.." << endl;
printOptionsMap(fabianMap);
cout << "Paul vector.." << endl;
printOptionsMap(paulMap);
TStopwatch sw;
sw.Start();
if (verbosity<1) {
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
RooMsgService::instance().setSilentMode(true);
}
TFile *bkgFile = TFile::Open(bkgFileName.c_str());
TFile *sigFile = TFile::Open(sigFileName.c_str());
//RooWorkspace *bkgWS = (RooWorkspace*)bkgFile->Get("cms_hgg_workspace");
RooWorkspace *bkgWS = (RooWorkspace*)bkgFile->Get(bkgWSName.c_str());
RooWorkspace *sigWS = (RooWorkspace*)sigFile->Get(sigWSName.c_str());
if (!bkgWS || !sigWS){
cerr << "ERROR - one of signal or background workspace is NULL" << endl;
exit(1);
}
RooRealVar *mass = (RooRealVar*)bkgWS->var("CMS_hgg_mass");
RooRealVar *mu = new RooRealVar("mu","mu",0.,mu_low,mu_high);
TFile *outFile = new TFile(outFileName.c_str(),"RECREATE");
TTree *muTree = new TTree("muTree","muTree");
int toyn;
vector<string> truthModel;
vector<double> muFab;
vector<double> muPaul;
vector<double> muChi2;
vector<double> muAIC;
vector<double> muFabErrLow;
vector<double> muPaulErrLow;
vector<double> muChi2ErrLow;
vector<double> muAICErrLow;
vector<double> muFabErrHigh;
vector<double> muPaulErrHigh;
vector<double> muChi2ErrHigh;
vector<double> muAICErrHigh;
muTree->Branch("jobn",&jobn);
muTree->Branch("toyn",&toyn);
muTree->Branch("truthModel",&truthModel);
muTree->Branch("muFab",&muFab);
muTree->Branch("muPaul",&muPaul);
muTree->Branch("muChi2",&muChi2);
muTree->Branch("muAIC",&muAIC);
muTree->Branch("muFabErrLow",&muFabErrLow);
muTree->Branch("muPaulErrLow",&muPaulErrLow);
muTree->Branch("muChi2ErrLow",&muChi2ErrLow);
muTree->Branch("muAICErrLow",&muAICErrLow);
muTree->Branch("muFabErrHigh",&muFabErrHigh);
muTree->Branch("muPaulErrHigh",&muPaulErrHigh);
muTree->Branch("muChi2ErrHigh",&muChi2ErrHigh);
muTree->Branch("muAICErrHigh",&muAICErrHigh);
//TH1F *muDistFab = new TH1F("muDistFab","muDistFab",int(20*(mu_high-mu_low)),mu_low,mu_high);
//TH1F *muDistPaul = new TH1F("muDistPaul","muDistPaul",int(20*(mu_high-mu_low)),mu_low,mu_high);
//TH1F *muDistChi2 = new TH1F("muDistChi2","muDistChi2",int(20*(mu_high-mu_low)),mu_low,mu_high);
//TH1F *muDistAIC = new TH1F("muDistAIC","muDistAIC",int(20*(mu_high-mu_low)),mu_low,mu_high);
mass->setBins(320);
RooDataSet *data = (RooDataSet*)bkgWS->data(Form("data_mass_cat%d",cat));
//RooDataSet *data = (RooDataSet*)bkgWS->data(Form("data_cat%d_7TeV",cat));
RooDataHist *dataBinned = new RooDataHist(Form("roohist_data_mass_cat%d",cat),Form("roohist_data_mass_cat%d",cat),RooArgSet(*mass),*data);
RooDataSet *sigMC = (RooDataSet*)sigWS->data(Form("sig_ggh_mass_m%d_cat%d",expectSignalMass,cat));
RooDataSet *sigMC_vbf = (RooDataSet*)sigWS->data(Form("sig_wzh_mass_m%d_cat%d",expectSignalMass,cat));
RooDataSet *sigMC_wzh = (RooDataSet*)sigWS->data(Form("sig_vbf_mass_m%d_cat%d",expectSignalMass,cat));
RooDataSet *sigMC_tth = (RooDataSet*)sigWS->data(Form("sig_tth_mass_m%d_cat%d",expectSignalMass,cat));
sigMC->append(*sigMC_vbf);
sigMC->append(*sigMC_wzh);
sigMC->append(*sigMC_tth);
//RooExtendPdf *ggh_pdf = (RooExtendPdf*)sigWS->pdf(Form("sigpdfsmrel_cat%d_7TeV_ggh",cat));
//RooExtendPdf *vbf_pdf = (RooExtendPdf*)sigWS->pdf(Form("sigpdfsmrel_cat%d_7TeV_vbf",cat));
//RooExtendPdf *wzh_pdf = (RooExtendPdf*)sigWS->pdf(Form("sigpdfsmrel_cat%d_7TeV_wzh",cat));
//RooExtendPdf *tth_pdf = (RooExtendPdf*)sigWS->pdf(Form("sigpdfsmrel_cat%d_7TeV_tth",cat));
//RooAbsPdf *sigPdf = new RooAddPdf(Form("sigpdfsmrel_cat%d_7TeV",cat),Form("sigpdfsmrel_cat%d_7TeV",cat),RooArgList(*ggh_pdf,*vbf_pdf,*wzh_pdf,*tth_pdf));
if (!dataBinned || !sigMC){
cerr << "ERROR -- one of data or signal is NULL" << endl;
exit(1);
}
// set of truth models to throw toys from
PdfModelBuilder toysModel;
toysModel.setObsVar(mass);
toysModel.setSignalModifier(mu);
// add truth pdfs from config datfile these need to be cached
// to throw a toy from the SB fit make sure that the cache happens at makeSBPdfs
for (vector<pair<int,pair<string,string> > >::iterator it=toysMap.begin(); it!=toysMap.end(); it++){
if (it->first==-1) { // this is a hyrbid toy
throwHybridToys=true;
vector<string> temp;
split(temp,it->second.first,boost::is_any_of(","));
split(switchFunc,it->second.second,boost::is_any_of(","));
for (unsigned int i=0; i<temp.size(); i++){
switchMass.push_back(atof(temp[i].c_str()));
}
continue;
}
if (it->first==-2) { // this is a keys pdf toy
double rho = lexical_cast<double>(it->second.first);
toysModel.setKeysPdfAttributes(data,rho);
toysModel.addBkgPdf("KeysPdf",0,Form("truth_%s_cat%d",it->second.second.c_str(),cat),false);
continue;
}
if (it->first==-3) { // this is read pdf from file
toysModel.addBkgPdf(it->second.second,it->first,it->second.first,false);
continue;
}
toysModel.addBkgPdf(it->second.second,it->first,Form("truth_%s_cat%d",it->second.first.c_str(),cat),false);
}
toysModel.setSignalPdfFromMC(sigMC);
//toysModel.setSignalPdf(sigPdf);
toysModel.makeSBPdfs(true);
map<string,RooAbsPdf*> toyBkgPdfs = toysModel.getBkgPdfs();
map<string,RooAbsPdf*> toySBPdfs = toysModel.getSBPdfs();
toysModel.setSeed(seed);
// fabians chosen model
PdfModelBuilder fabianModel;
fabianModel.setObsVar(mass);
fabianModel.setSignalModifier(mu);
// add pdfs from config datfile - should be no need to cache these
for (vector<pair<int,pair<string,string> > >::iterator it=fabianMap.begin(); it!=fabianMap.end(); it++){
fabianModel.addBkgPdf(it->second.second,it->first,Form("fabian_%s_cat%d",it->second.first.c_str(),cat),false);
}
fabianModel.setSignalPdfFromMC(sigMC);
//fabianModel.setSignalPdf(sigPdf);
fabianModel.makeSBPdfs(false);
map<string,RooAbsPdf*> fabianBkgPdfs = fabianModel.getBkgPdfs();
map<string,RooAbsPdf*> fabianSBPdfs = fabianModel.getSBPdfs();
// set of models to profile
PdfModelBuilder paulModel;
paulModel.setObsVar(mass);
paulModel.setSignalModifier(mu);
// add pdfs from config datfile - should be no need to cache these
for (vector<pair<int,pair<string,string> > >::iterator it=paulMap.begin(); it!=paulMap.end(); it++){
paulModel.addBkgPdf(it->second.second,it->first,Form("paul_%s_cat%d",it->second.first.c_str(),cat),false);
}
paulModel.setSignalPdfFromMC(sigMC);
//paulModel.setSignalPdf(sigPdf);
paulModel.makeSBPdfs(false);
map<string,RooAbsPdf*> paulBkgPdfs = paulModel.getBkgPdfs();
map<string,RooAbsPdf*> paulSBPdfs = paulModel.getSBPdfs();
// set up profile for Fabians models
ProfileMultiplePdfs fabianProfiler;
for (map<string,RooAbsPdf*>::iterator pdf=fabianSBPdfs.begin(); pdf!=fabianSBPdfs.end(); pdf++){
fabianProfiler.addPdf(pdf->second);
}
cout << "Fabian profiler pdfs:" << endl;
fabianProfiler.printPdfs();
// set up profile for Pauls models
ProfileMultiplePdfs paulProfiler;
for (map<string,RooAbsPdf*>::iterator pdf=paulSBPdfs.begin(); pdf!=paulSBPdfs.end(); pdf++){
paulProfiler.addPdf(pdf->second);
}
cout << "Paul profiler pdfs:" << endl;
paulProfiler.printPdfs();
if (!skipPlots) {
system(Form("mkdir -p %s/plots/truthToData",outDir.c_str()));
system(Form("mkdir -p %s/plots/envelopeNlls",outDir.c_str()));
system(Form("mkdir -p %s/plots/toys",outDir.c_str()));
}
// throw toys - only need to fit data once as result will be cached
cout << "------ FITTING TRUTH TO DATA ------" << endl;
// sometimes useful to do best fit first to get reasonable starting value
toysModel.setSignalModifierConstant(false);
toysModel.fitToData(dataBinned,false,false,true);
// -----
toysModel.setSignalModifierVal(expectSignal);
toysModel.setSignalModifierConstant(true);
toysModel.fitToData(dataBinned,false,true,true);
if (!skipPlots) toysModel.plotPdfsToData(dataBinned,80,Form("%s/plots/truthToData/datafit_mu%3.1f",outDir.c_str(),expectSignal),false);
toysModel.setSignalModifierConstant(false);
toysModel.saveWorkspace(outFile);
for (int toy=0; toy<ntoys; toy++){
cout << "---------------------------" << endl;
cout << "--- RUNNING TOY " << toy << " / " << ntoys << " ----" << endl;
cout << "---------------------------" << endl;
// wipe stuff for tree
truthModel.clear();
muFab.clear();
muPaul.clear();
muChi2.clear();
muAIC.clear();
muFabErrLow.clear();
muPaulErrLow.clear();
muChi2ErrLow.clear();
muAICErrLow.clear();
muFabErrHigh.clear();
muPaulErrHigh.clear();
muChi2ErrHigh.clear();
muAICErrHigh.clear();
// throw toy
map<string,RooAbsData*> toys;
if (throwHybridToys) {
toysModel.throwHybridToy(Form("truth_job%d_toy%d",jobn,toy),dataBinned->sumEntries(),switchMass,switchFunc,false,true,true,true);
toys = toysModel.getHybridToyData();
if (!skipPlots) toysModel.plotToysWithPdfs(Form("%s/plots/toys/job%d_toy%d",outDir.c_str(),jobn,toy),80,false);
if (!skipPlots) toysModel.plotHybridToy(Form("%s/plots/toys/job%d_toy%d",outDir.c_str(),jobn,toy),80,switchMass,switchFunc,false);
}
else {
toysModel.throwToy(Form("truth_job%d_toy%d",jobn,toy),dataBinned->sumEntries(),false,true,true,true);
toys = toysModel.getToyData();
if (!skipPlots) toysModel.plotToysWithPdfs(Form("%s/plots/toys/job%d_toy%d",outDir.c_str(),jobn,toy),80,false);
}
for (map<string,RooAbsData*>::iterator it=toys.begin(); it!=toys.end(); it++){
// ----- USEFUL DEBUG -----------
// --- this can be a useful check that the truth model values are being cached properly ---
//toysModel.fitToData(it->second,true,false,true);
//toysModel.plotPdfsToData(it->second,80,Form("%s/plots/toys/job%d_toy%d",outDir.c_str(),jobn,toy),true,"NONE");
if (!skipPlots) fabianProfiler.plotNominalFits(it->second,mass,80,Form("%s/plots/toys/job%d_toy%d_fit_fab",outDir.c_str(),jobn,toy));
if (!skipPlots) paulProfiler.plotNominalFits(it->second,mass,80,Form("%s/plots/toys/job%d_toy%d_fit_paul",outDir.c_str(),jobn,toy));
//continue;
// --------------------------------
cout << "Fitting toy for truth model " << distance(toys.begin(),it) << "/" << toys.size() << " (" << it->first << ") " << endl;
// get Fabian envelope
pair<double,map<string,TGraph*> > fabianMinNlls = fabianProfiler.profileLikelihood(it->second,mass,mu,mu_low,mu_high,mu_step);
pair<double,map<string,TGraph*> > fabianEnvelope = fabianProfiler.computeEnvelope(fabianMinNlls,Form("fabEnvelope_job%d_%s_cat%d_toy%d",jobn,it->first.c_str(),cat,toy),0.);
if (!skipPlots) fabianProfiler.plot(fabianEnvelope.second,Form("%s/plots/envelopeNlls/nlls_fab_%s_cat%d_toy%d",outDir.c_str(),it->first.c_str(),cat,toy));
// get Paul envelopes
pair<double,map<string,TGraph*> > paulMinNlls = paulProfiler.profileLikelihood(it->second,mass,mu,mu_low,mu_high,mu_step);
pair<double,map<string,TGraph*> > paulEnvelope = paulProfiler.computeEnvelope(paulMinNlls,Form("paulEnvelope_job%d_%s_cat%d_toy%d",jobn,it->first.c_str(),cat,toy),0.);
if (!skipPlots) paulProfiler.plot(paulEnvelope.second,Form("%s/plots/envelopeNlls/nlls_paul_%s_cat%d_toy%d",outDir.c_str(),it->first.c_str(),cat,toy));
pair<double,map<string,TGraph*> > chi2Envelope = paulProfiler.computeEnvelope(paulMinNlls,Form("chi2Envelope_job%d_%s_cat%d_toy%d",jobn,it->first.c_str(),cat,toy),1.);
if (!skipPlots) paulProfiler.plot(chi2Envelope.second,Form("%s/plots/envelopeNlls/nlls_chi2_%s_cat%d_toy%d",outDir.c_str(),it->first.c_str(),cat,toy));
pair<double,map<string,TGraph*> > aicEnvelope = paulProfiler.computeEnvelope(paulMinNlls,Form("aicEnvelope_job%d_%s_cat%d_toy%d",jobn,it->first.c_str(),cat,toy),2.);
if (!skipPlots) paulProfiler.plot(aicEnvelope.second,Form("%s/plots/envelopeNlls/nlls_aic_%s_cat%d_toy%d",outDir.c_str(),it->first.c_str(),cat,toy));
pair<double,pair<double,double> > muFabInfo = ProfileMultiplePdfs::getMinAndErrorAsymm(fabianEnvelope.second["envelope"],1.);
pair<double,pair<double,double> > muPaulInfo = ProfileMultiplePdfs::getMinAndErrorAsymm(paulEnvelope.second["envelope"],1.);
pair<double,pair<double,double> > muChi2Info = ProfileMultiplePdfs::getMinAndErrorAsymm(chi2Envelope.second["envelope"],1.);
pair<double,pair<double,double> > muAICInfo = ProfileMultiplePdfs::getMinAndErrorAsymm(aicEnvelope.second["envelope"],1.);
truthModel.push_back(it->first);
muFab.push_back(muFabInfo.first);
muPaul.push_back(muPaulInfo.first);
muChi2.push_back(muChi2Info.first);
muAIC.push_back(muAICInfo.first);
muFabErrLow.push_back(muFabInfo.second.first);
muPaulErrLow.push_back(muPaulInfo.second.first);
muChi2ErrLow.push_back(muChi2Info.second.first);
muAICErrLow.push_back(muAICInfo.second.first);
muFabErrHigh.push_back(muFabInfo.second.second);
muPaulErrHigh.push_back(muPaulInfo.second.second);
muChi2ErrHigh.push_back(muChi2Info.second.second);
muAICErrHigh.push_back(muAICInfo.second.second);
cout << "Fab mu = " << muFabInfo.first << " - " << muFabInfo.second.first << " + " << muFabInfo.second.second << endl;
cout << "Paul mu = " << muPaulInfo.first << " - " << muPaulInfo.second.first << " + " << muPaulInfo.second.second << endl;
cout << "Chi2 mu = " << muChi2Info.first << " - " << muChi2Info.second.first << " + " << muChi2Info.second.second << endl;
cout << "AIC mu = " << muAICInfo.first << " - " << muAICInfo.second.first << " + " << muAICInfo.second.second << endl;
outFile->cd();
fabianEnvelope.second["envelope"]->Write();
paulEnvelope.second["envelope"]->Write();
chi2Envelope.second["envelope"]->Write();
aicEnvelope.second["envelope"]->Write();
}
toyn=toy;
muTree->Fill();
}
outFile->cd();
muTree->Write();
cout << "Done." << endl;
cout << "Whole process took..." << endl;
cout << "\t "; sw.Print();
outFile->Close();
return 0;
}
int main (int argc, char **argv) {
TFile *tf = TFile::Open("tmp/DataSets.root");
RooWorkspace *w = (RooWorkspace*)tf->Get("w");
RooDataSet *Data = (RooDataSet*)w->data("Data2011")->Clone("Data");
Data->append( *((RooDataSet*)w->data("Data2012")) );
RooDataSet *Bs2Kst0Kst0_MC = (RooDataSet*)w->data("Bs2Kst0Kst0_MC2011")->Clone("Bs2KstKst0_MC");
Bs2Kst0Kst0_MC->append( *((RooDataSet*)w->data("Bs2Kst0Kst0_MC2012")) );
RooDataSet *Bs2Kst0Kst01430_MC = (RooDataSet*)w->data("Bs2Kst0Kst01430_MC2011")->Clone("Bs2KstKst0_MC");
Bs2Kst0Kst01430_MC->append( *((RooDataSet*)w->data("Bs2Kst0Kst01430_MC2012")) );
RooDataSet *Bs2Kst01430Kst01430_MC = (RooDataSet*)w->data("Bs2Kst01430Kst01430_MC2011")->Clone("Bs2KstKst0_MC");
Bs2Kst01430Kst01430_MC->append( *((RooDataSet*)w->data("Bs2Kst01430Kst01430_MC2012")) );
RooDataSet *Bd2Kst0Kst0_MC = (RooDataSet*)w->data("Bd2Kst0Kst0_MC2011")->Clone("Bs2KstKst0_MC");
Bd2Kst0Kst0_MC->append( *((RooDataSet*)w->data("Bd2Kst0Kst0_MC2012")) );
RooDataSet *Bd2PhiKst0_MC = (RooDataSet*)w->data("Bd2PhiKst0_MC2011")->Clone("Bs2KstKst0_MC");
Bd2PhiKst0_MC->append( *((RooDataSet*)w->data("Bd2PhiKst0_MC2012")) );
RooDataSet *Bs2PhiKst0_MC = (RooDataSet*)w->data("Bs2PhiKst0_MC2011")->Clone("Bs2KstKst0_MC");
Bs2PhiKst0_MC->append( *((RooDataSet*)w->data("Bs2PhiKst0_MC2012")) );
RooDataSet *Bd2RhoKst0_MC = (RooDataSet*)w->data("Bd2RhoKst0_MC2011")->Clone("Bs2KstKst0_MC");
Bd2RhoKst0_MC->append( *((RooDataSet*)w->data("Bd2RhoKst0_MC2012")) );
RooDataSet *Lb2ppipipi_MC = (RooDataSet*)w->data("Lb2ppipipi_MC2011")->Clone("Bs2KstKst0_MC");
Lb2ppipipi_MC->append( *((RooDataSet*)w->data("Lb2ppipipi_MC2012")) );
RooDataSet *Lb2pKpipi_MC = (RooDataSet*)w->data("Lb2pKpipi_MC2011")->Clone("Bs2KstKst0_MC");
Lb2pKpipi_MC->append( *((RooDataSet*)w->data("Lb2pKpipi_MC2012")) );
w->import(*Data);
w->import(*Bs2Kst0Kst0_MC);
w->import(*Bs2Kst0Kst01430_MC);
w->import(*Bs2Kst01430Kst01430_MC);
w->import(*Bd2Kst0Kst0_MC);
w->import(*Bd2PhiKst0_MC);
w->import(*Bs2PhiKst0_MC);
w->import(*Bd2RhoKst0_MC);
w->import(*Lb2ppipipi_MC);
w->import(*Lb2pKpipi_MC);
RooRealVar *mass = (RooRealVar*)w->var("B_s0_DTF_B_s0_M");
fitIpatia( w, "bs2kstkst_mc", "Bs2KstKst0_MC");
// Make the PDF here
RooRealVar *p1 = new RooRealVar("p1","p1",-0.002,-0.004,0.);
RooExponential *exp = new RooExponential("exp","exp",*mass,*p1);
//RooRealVar *m1 = new RooRealVar("m1","m1",5320,5380);
//RooRealVar *s1 = new RooRealVar("s1","s1",1,20);
//RooGaussian *sig = new RooGaussian("sig","sig",*mass,*m1,*s1);
RooRealVar *m2 = new RooRealVar("m2","m2",5320,5380);
RooRealVar *s2 = new RooRealVar("s2","s2",1,20);
RooGaussian *sig_bd = new RooGaussian("sig_bd","sig_bd",*mass,*m2,*s2);
//
RooRealVar *bs2kstkst_l = new RooRealVar( "bs2kstkst_l" ,"", -5, -20, -1.);
RooConstVar *bs2kstkst_zeta = new RooConstVar( "bs2kstkst_zeta","",0. );
RooConstVar *bs2kstkst_fb = new RooConstVar( "bs2kstkst_fb" ,"",0. );
RooRealVar *bs2kstkst_sigma = new RooRealVar( "bs2kstkst_sigma","",15 ,10 ,20 );
RooRealVar *bs2kstkst_mu = new RooRealVar( "bs2kstkst_mu" ,"",5350 ,5380 );
RooRealVar *bs2kstkst_a = new RooRealVar( "bs2kstkst_a" ,"",2.5 , 0 ,10 );
RooRealVar *bs2kstkst_n = new RooRealVar( "bs2kstkst_n" ,"",2.5 , 0 ,10 );
RooRealVar *bs2kstkst_a2 = new RooRealVar( "bs2kstkst_a2" ,"",2.5 , 0 ,10 );
RooRealVar *bs2kstkst_n2 = new RooRealVar( "bs2kstkst_n2" ,"",2.5 , 0 ,10 );
RooIpatia2 *sig = new RooIpatia2("sig","sig",*mass,*bs2kstkst_l,*bs2kstkst_zeta,*bs2kstkst_fb,*bs2kstkst_sigma,*bs2kstkst_mu,*bs2kstkst_a,*bs2kstkst_n,*bs2kstkst_a2,*bs2kstkst_n2);
RooRealVar *bkg_y = new RooRealVar("bkg_y","bkg_y",10e3,10e5);
RooRealVar *sig_y = new RooRealVar("sig_y","sig_y",0,20e3);
RooRealVar *sig_bd_y = new RooRealVar("sig_bd_y","sig_bd_y",0,3000);
RooArgList *pdfs = new RooArgList();
RooArgList *yields = new RooArgList();
pdfs->add( *exp );
pdfs->add( *sig );
pdfs->add( *sig_bd );
yields->add( *bkg_y );
yields->add( *sig_y );
yields->add( *sig_bd_y );
RooAddPdf *pdf = new RooAddPdf("pdf","pdf",*pdfs,*yields);
pdf->fitTo(*Data, Extended() );
RooPlot *plot = mass->frame();
Data->plotOn(plot);
// set fit params constant;
pdf->plotOn(plot);
TCanvas *c = new TCanvas();
plot->Draw();
c->Print("tmp/mass.pdf");
// Plots Kst Ms with no sweights
TCanvas *c1 = new TCanvas("c1","c1",800,1200);
c1->Divide(1,2);
c1->cd(1);
RooPlot *c1p1 = w->var("B_s0_DTF_KST1_M")->frame();
Data->plotOn(c1p1);
c1p1->Draw();
c1->cd(2);
RooPlot *c1p2 = w->var("B_s0_DTF_KST2_M")->frame();
Data->plotOn(c1p2);
c1p2->Draw();
c1->Print("tmp/nosw.pdf");
// set fit params constant
p1->setConstant(true);
//m1->setConstant(true);
//s1->setConstant(true);
bs2kstkst_l->setConstant(true);
//bs2kstkst_zeta->setConstant(true);
//bs2kstkst_fb->setConstant(true);
bs2kstkst_sigma->setConstant(true);
bs2kstkst_mu->setConstant(true);
bs2kstkst_a->setConstant(true);
bs2kstkst_n->setConstant(true);
bs2kstkst_a2->setConstant(true);
bs2kstkst_n2->setConstant(true);
m2->setConstant(true);
s2->setConstant(true);
RooStats::SPlot *sData = new RooStats::SPlot("sData","sData", *Data, pdf, *yields);
w->import(*sData);
w->import(*Data,Rename("Data_wsweights"));
RooDataSet *swdata = new RooDataSet("Data_wsweights", "Data", Data, *Data->get(), 0 , "sig_y_sw");
// Plots Kst Ms with no sweights
TCanvas *c2 = new TCanvas("c2","c2",800,1200);
c2->Divide(1,2);
c2->cd(1);
RooPlot *c2p1 = w->var("B_s0_DTF_KST1_M")->frame();
swdata->plotOn(c2p1);
c2p1->Draw();
c2->cd(2);
RooPlot *c2p2 = w->var("B_s0_DTF_KST2_M")->frame();
swdata->plotOn(c2p2);
c2p2->Draw();
c2->Print("tmp/withsw.pdf");
tf->Close();
return 0;
}
void fitbkgdataCard(TString configCard="template.config",
bool dobands = true, // create baerror bands for BG models
bool dosignal = false, // plot the signal model (needs to be present)
bool blinded = true, // blind the data in the plots?
bool verbose = true ) {
gROOT->Macro("MitStyle.C");
gStyle->SetErrorX(0);
gStyle->SetOptStat(0);
gROOT->ForceStyle();
TString projectDir;
std::vector<TString> catdesc;
std::vector<TString> catnames;
std::vector<int> polorder;
double massmin = -1.;
double massmax = -1.;
double theCMenergy = -1.;
bool readStatus = readFromConfigCard( configCard,
projectDir,
catnames,
catdesc,
polorder,
massmin,
massmax,
theCMenergy
);
if( !readStatus ) {
std::cerr<<" ERROR: Could not read from card > "<<configCard.Data()<<" <."<<std::endl;
return;
}
TFile *fdata = new TFile(TString::Format("%s/CMS-HGG-data.root",projectDir.Data()),"READ");
if( !fdata ) {
std::cerr<<" ERROR: Could not open file "<<projectDir.Data()<<"/CMS-HGG-data.root."<<std::endl;
return;
}
if( !gSystem->cd(TString::Format("%s/databkg/",projectDir.Data())) ) {
std::cerr<<" ERROR: Could not change directory to "<<TString::Format("%s/databkg/",projectDir.Data()).Data()<<"."<<std::endl;
return;
}
// ----------------------------------------------------------------------
// load the input workspace....
RooWorkspace* win = (RooWorkspace*)fdata->Get("cms_hgg_workspace_data");
if( !win ) {
std::cerr<<" ERROR: Could not load workspace > cms_hgg_workspace_data < from file > "<<TString::Format("%s/CMS-HGG-data.root",projectDir.Data()).Data()<<" <."<<std::endl;
return;
}
RooRealVar *intLumi = win->var("IntLumi");
RooRealVar *hmass = win->var("CMS_hgg_mass");
if( !intLumi || !hmass ) {
std::cerr<<" ERROR: Could not load needed variables > IntLumi < or > CMS_hgg_mass < forom input workspace."<<std::endl;
return;
}
//win->Print();
hmass->setRange(massmin,massmax);
hmass->setBins(4*(int)(massmax-massmin));
hmass->SetTitle("m_{#gamma#gamma}");
hmass->setUnit("GeV");
hmass->setRange("fitrange",massmin,massmax);
hmass->setRange("blind1",100.,110.);
hmass->setRange("blind2",150.,180.);
// ----------------------------------------------------------------------
// some auxiliray vectro (don't know the meaning of all of them ... yet...
std::vector<RooAbsData*> data_vec;
std::vector<RooAbsPdf*> pdfShape_vec; // vector to store the NOT-EXTENDED PDFs (aka pdfshape)
std::vector<RooAbsPdf*> pdf_vec; // vector to store the EXTENDED PDFs
std::vector<RooAbsReal*> normu_vec; // this holds the normalization vars for each Cat (needed in bands for combined cat)
RooArgList normList; // list of range-limityed normalizations (needed for error bands on combined category)
//std::vector<RooRealVar*> coeffv;
//std::vector<RooAbsReal*> normu_vecv; // ???
// ----------------------------------------------------------------------
// define output works
RooWorkspace *wOut = new RooWorkspace("wbkg","wbkg") ;
// util;ities for the combined fit
RooCategory finalcat ("finalcat", "finalcat") ;
RooSimultaneous fullbkgpdf("fullbkgpdf","fullbkgpdf",finalcat);
RooDataSet datacomb ("datacomb", "datacomb", RooArgList(*hmass,finalcat)) ;
RooDataSet *datacombcat = new RooDataSet("data_combcat","",RooArgList(*hmass)) ;
// add the 'combcat' to the list...if more than one cat
if( catnames.size() > 1 ) {
catnames.push_back("combcat");
catdesc.push_back("Combined");
}
for (UInt_t icat=0; icat<catnames.size(); ++icat) {
TString catname = catnames.at(icat);
finalcat.defineType(catname);
// check if we're in a sub-cat or the comb-cat
RooDataSet *data = NULL;
RooDataSet *inData = NULL;
if( icat < (catnames.size() - 1) || catnames.size() == 1) { // this is NOT the last cat (which is by construction the combination)
inData = (RooDataSet*)win->data(TString("data_mass_")+catname);
if( !inData ) {
std::cerr<<" ERROR: Could not find dataset > data_mass_"<<catname.Data()<<" < in input workspace."<<std::endl;
return;
}
data = new RooDataSet(TString("data_")+catname,"",*hmass,Import(*inData)); // copy the dataset (why?)
// append the data to the combined data...
RooDataSet *datacat = new RooDataSet(TString("datacat")+catname,"",*hmass,Index(finalcat),Import(catname,*data)) ;
datacomb.append(*datacat);
datacombcat->append(*data);
// normalization for this category
RooRealVar *nbkg = new RooRealVar(TString::Format("CMS_hgg_%s_bkgshape_norm",catname.Data()),"",800.0,0.0,25e3);
// we keep track of the normalizario vars only for N-1 cats, naming convetnions hystoric...
if( catnames.size() > 2 && icat < (catnames.size() - 2) ) {
RooRealVar* cbkg = new RooRealVar(TString::Format("cbkg%s",catname.Data()),"",0.0,0.0,1e3);
cbkg->removeRange();
normu_vec.push_back(cbkg);
normList.add(*cbkg);
}
/// generate the Bernstrin polynomial (FIX-ME: add possibility ro create other models...)
fstBernModel* theBGmodel = new fstBernModel(hmass, polorder[icat], icat, catname); // using my dedicated class...
std::cout<<" model name is "<<theBGmodel->getPdf()->GetName()<<std::endl;
RooAbsPdf* bkgshape = theBGmodel->getPdf(); // the BG shape
RooAbsPdf* bkgpdf = new RooExtendPdf(TString("bkgpdf")+catname,"",*bkgshape,*nbkg); // the extended PDF
// add the extedned PDF to the RooSimultaneous holding all models...
fullbkgpdf.addPdf(*bkgpdf,catname);
// store the NON-EXTENDED PDF for usgae to compute the error bands later..
pdfShape_vec.push_back(bkgshape);
pdf_vec .push_back(bkgpdf);
data_vec .push_back(data);
} else {
data = datacombcat; // we're looking at the last cat (by construction the combination)
data_vec.push_back(data);
// sum up all the cts PDFs for combined PDF
RooArgList subpdfs;
for (int ipdf=0; ipdf<pdf_vec.size(); ++ipdf) {
subpdfs.add(*pdf_vec.at(ipdf));
}
RooAddPdf* bkgpdf = new RooAddPdf(TString("bkgpdf")+catname,"",subpdfs);
pdfShape_vec.push_back(bkgpdf);
pdf_vec .push_back(bkgpdf); // I don't think this is really needed though....
}
// generate the binned dataset (to be put into the workspace... just in case...)
RooDataHist *databinned = new RooDataHist(TString("databinned_")+catname,"",*hmass,*data);
wOut->import(*data);
wOut->import(*databinned);
}
std::cout<<" ***************** "<<std::endl;
// fit the RooSimultaneous to the combined dataset -> (we could also fit each cat separately)
fullbkgpdf.fitTo(datacomb,Strategy(1),Minos(kFALSE),Save(kTRUE));
RooFitResult *fullbkgfitres = fullbkgpdf.fitTo(datacomb,Strategy(2),Minos(kFALSE),Save(kTRUE));
// in principle we're done now, so store the results in the output workspace
wOut->import(datacomb);
wOut->import(fullbkgpdf);
wOut->import(*fullbkgfitres);
std::cout<<" ***************** "<<std::endl;
if( verbose ) wOut->Print();
std::cout<<" ***************** "<<std::endl;
wOut->writeToFile("bkgdatawithfit.root") ;
if( verbose ) {
printf("IntLumi = %5f\n",intLumi->getVal());
printf("ndata:\n");
for (UInt_t icat=0; icat<catnames.size(); ++icat) {
printf("%i ",data_vec.at(icat)->numEntries());
}
printf("\n");
}
// --------------------------------------------------------------------------------------------
// Now comesd the plotting
// chage the Statistics style...
gStyle->SetOptStat(1110);
// we want to plot in 1GeV bins (apparently...)
UInt_t nbins = (UInt_t) (massmax-massmin);
// here we'll store the curves for the bands...
std::vector<RooCurve*> fitcurves;
// loop again over the cats
TCanvas **canbkg = new TCanvas*[catnames.size()];
RooPlot** plot = new RooPlot*[catnames.size()];
TLatex** lat = new TLatex*[catnames.size()];
TLatex** lat2 = new TLatex*[catnames.size()];
std::cout<<" beofre plotting..."<<std::endl;
for (UInt_t icat=0; icat<catnames.size(); ++icat) {
TString catname = catnames.at(icat);
std::cout<<" trying to plot #"<<icat<<std::endl;
// plot the data and the fit
canbkg[icat] = new TCanvas;
plot [icat] = hmass->frame(Bins(nbins),Range("fitrange"));
std::cout<<" trying to plot #"<<icat<<std::endl;
// first plot the data invisibly... and put the fitted BG model on top...
data_vec .at(icat)->plotOn(plot[icat],RooFit::LineColor(kWhite),MarkerColor(kWhite),Invisible());
pdfShape_vec.at(icat)->plotOn(plot[icat],RooFit::LineColor(kRed),Range("fitrange"),NormRange("fitrange"));
std::cout<<" trying to plot #"<<icat<<std::endl;
// if toggled on, plot also the Data visibly
if( !blinded ) {
data_vec.at(icat)->plotOn(plot[icat]);
}
std::cout<<" trying to plot #"<<icat<<std::endl;
// some cosmetics...
plot[icat]->SetTitle("");
plot[icat]->SetMinimum(0.0);
plot[icat]->SetMaximum(1.40*plot[icat]->GetMaximum());
plot[icat]->GetXaxis()->SetTitle("m_{#gamma#gamma} (GeV/c^{2})");
plot[icat]->Draw();
std::cout<<" trying to plot #"<<icat<<std::endl;
// legend....
TLegend *legmc = new TLegend(0.68,0.70,0.97,0.90);
legmc->AddEntry(plot[icat]->getObject(2),"Data","LPE");
legmc->AddEntry(plot[icat]->getObject(1),"Bkg Model","L");
// this part computes the 1/2-sigma bands.
TGraphAsymmErrors *onesigma = NULL;
TGraphAsymmErrors *twosigma = NULL;
std::cout<<" trying *** to plot #"<<icat<<std::endl;
RooAddition* sumcatsnm1 = NULL;
if ( dobands ) { //&& icat == (catnames.size() - 1) ) {
onesigma = new TGraphAsymmErrors();
twosigma = new TGraphAsymmErrors();
// get the PDF for this cat from the vector
RooAbsPdf *thisPdf = pdfShape_vec.at(icat);
// get the nominal fir curve
RooCurve *nomcurve = dynamic_cast<RooCurve*>(plot[icat]->getObject(1));
fitcurves.push_back(nomcurve);
bool iscombcat = ( icat == (catnames.size() - 1) && catnames.size() > 1);
RooAbsData *datanorm = ( iscombcat ? &datacomb : data_vec.at(icat) );
// this si the nornmalization in the 'sliding-window' (i.e. per 'test-bin')
RooRealVar *nlim = new RooRealVar(TString::Format("nlim%s",catnames.at(icat).Data()),"",0.0,0.0,10.0);
nlim->removeRange();
if( iscombcat ) {
// ----------- HISTORIC NAMING ----------------------------------------
sumcatsnm1 = new RooAddition("sumcatsnm1","",normList); // summing all normalizations epect the last Cat
// this is the normlization of the last Cat
RooFormulaVar *nlast = new RooFormulaVar("nlast","","TMath::Max(0.1,@0-@1)",RooArgList(*nlim,*sumcatsnm1));
// ... and adding it ot the list of norms
normu_vec.push_back(nlast);
}
//if (icat == 1 && catnames.size() == 2) continue; // only 1 cat, so don't need combination
for (int i=1; i<(plot[icat]->GetXaxis()->GetNbins()+1); ++i) {
// this defines the 'binning' we use for the error bands
double lowedge = plot[icat]->GetXaxis()->GetBinLowEdge(i);
double upedge = plot[icat]->GetXaxis()->GetBinUpEdge(i);
double center = plot[icat]->GetXaxis()->GetBinCenter(i);
// get the nominal value at the center of the bin
double nombkg = nomcurve->interpolate(center);
nlim->setVal(nombkg);
hmass->setRange("errRange",lowedge,upedge);
// this is the new extended PDF whith the normalization restricted to the bin-area
RooAbsPdf *extLimPdf = NULL;
if( iscombcat ) {
extLimPdf = new RooSimultaneous("epdf","",finalcat);
// loop over the cats and generate temporary extended PDFs
for (int jcat=0; jcat<(catnames.size()-1); ++jcat) {
RooRealVar *rvar = dynamic_cast<RooRealVar*>(normu_vec.at(jcat));
if (rvar) rvar->setVal(fitcurves.at(jcat)->interpolate(center));
RooExtendPdf *ecpdf = new RooExtendPdf(TString::Format("ecpdf%s",catnames.at(jcat).Data()),"",*pdfShape_vec.at(jcat),*normu_vec.at(jcat),"errRange");
static_cast<RooSimultaneous*>(extLimPdf)->addPdf(*ecpdf,catnames.at(jcat));
}
} else
extLimPdf = new RooExtendPdf("extLimPdf","",*thisPdf,*nlim,"errRange");
RooAbsReal *nll = extLimPdf->createNLL(*datanorm,Extended(),NumCPU(1));
RooMinimizer minim(*nll);
minim.setStrategy(0);
double clone = 1.0 - 2.0*RooStats::SignificanceToPValue(1.0);
double cltwo = 1.0 - 2.0*RooStats::SignificanceToPValue(2.0);
if (iscombcat) minim.setStrategy(2);
minim.migrad();
if (!iscombcat) {
minim.minos(*nlim);
}
else {
minim.hesse();
nlim->removeAsymError();
}
if( verbose )
printf("errlo = %5f, errhi = %5f\n",nlim->getErrorLo(),nlim->getErrorHi());
onesigma->SetPoint(i-1,center,nombkg);
onesigma->SetPointError(i-1,0.,0.,-nlim->getErrorLo(),nlim->getErrorHi());
// to get the 2-sigma bands...
minim.setErrorLevel(0.5*pow(ROOT::Math::normal_quantile(1-0.5*(1-cltwo),1.0), 2)); // the 0.5 is because qmu is -2*NLL
// eventually if cl = 0.95 this is the usual 1.92!
if (!iscombcat) {
minim.migrad();
minim.minos(*nlim);
}
else {
nlim->setError(2.0*nlim->getError());
nlim->removeAsymError();
}
twosigma->SetPoint(i-1,center,nombkg);
twosigma->SetPointError(i-1,0.,0.,-nlim->getErrorLo(),nlim->getErrorHi());
// for memory clean-up
delete nll;
delete extLimPdf;
}
hmass->setRange("errRange",massmin,massmax);
if( verbose )
onesigma->Print("V");
// plot[icat] the error bands
twosigma->SetLineColor(kGreen);
twosigma->SetFillColor(kGreen);
twosigma->SetMarkerColor(kGreen);
twosigma->Draw("L3 SAME");
onesigma->SetLineColor(kYellow);
onesigma->SetFillColor(kYellow);
onesigma->SetMarkerColor(kYellow);
onesigma->Draw("L3 SAME");
plot[icat]->Draw("SAME");
// and add the error bands to the legend
legmc->AddEntry(onesigma,"#pm1 #sigma","F");
legmc->AddEntry(twosigma,"#pm2 #sigma","F");
}
std::cout<<" trying ***2 to plot #"<<icat<<std::endl;
// rest of the legend ....
legmc->SetBorderSize(0);
legmc->SetFillStyle(0);
legmc->Draw();
lat[icat] = new TLatex(103.0,0.9*plot[icat]->GetMaximum(),TString::Format("#scale[0.7]{#splitline{CMS preliminary}{#sqrt{s} = %.1f TeV L = %.2f fb^{-1}}}",theCMenergy,intLumi->getVal()));
lat2[icat] = new TLatex(103.0,0.75*plot[icat]->GetMaximum(),catdesc.at(icat));
lat[icat] ->Draw();
lat2[icat]->Draw();
// -------------------------------------------------------
// save canvas in different formats
canbkg[icat]->SaveAs(TString("databkg") + catname + TString(".pdf"));
canbkg[icat]->SaveAs(TString("databkg") + catname + TString(".eps"));
canbkg[icat]->SaveAs(TString("databkg") + catname + TString(".root"));
}
return;
}
int main(){
system("mkdir -p plots");
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
TFile *bkgFile = TFile::Open("comb_svn/hgg.inputbkgdata_8TeV_MVA.root");
TFile *sigFile = TFile::Open("comb_svn/hgg.inputsig_8TeV_nosplitVH_MVA.root");
RooWorkspace *bkgWS = (RooWorkspace*)bkgFile->Get("cms_hgg_workspace");
RooWorkspace *sigWS = (RooWorkspace*)sigFile->Get("wsig_8TeV");
RooRealVar *mass = (RooRealVar*)bkgWS->var("CMS_hgg_mass");
RooRealVar *mu = new RooRealVar("mu","mu",-5.,5.);
mass->setBins(320);
cout << mass->getBins() << endl;
RooDataSet *dataAll;
int firstCat=1;
int lastCat=1;
float mu_low=-1.;
float mu_high=3.;
float mu_step=0.01;
vector<pair<double,TGraph*> > minNlltrack;
for (int cat=firstCat; cat<=lastCat; cat++){
RooDataSet *data = (RooDataSet*)bkgWS->data(Form("data_mass_cat%d",cat));
if (cat==firstCat) dataAll = (RooDataSet*)data->Clone("data_mass_all");
else dataAll->append(*data);
RooDataHist *dataBinned = new RooDataHist(Form("roohist_data_mass_cat%d",cat),Form("roohist_data_mass_cat%d",cat),RooArgSet(*mass),*data);
RooDataSet *sigMC = (RooDataSet*)sigWS->data(Form("sig_mass_m125_cat%d",cat));
if (!dataBinned || !sigMC){
cerr << "ERROR -- one of data or signal is NULL" << endl;
exit(1);
}
// Construct PDFs for this category using PdfModelBuilder
PdfModelBuilder modelBuilder;
modelBuilder.setObsVar(mass);
modelBuilder.setSignalModifier(mu);
// For Standard Analysis
//if (cat>=0 && cat<=3) modelBuilder.addBkgPdf("Bernstein",5,Form("pol5_cat%d",cat));
//if (cat>=4 && cat<=5) modelBuilder.addBkgPdf("Bernstein",4,Form("pol4_cat%d",cat));
//if (cat>=6 && cat<=8) modelBuilder.addBkgPdf("Bernstein",3,Form("pol3_cat%d",cat));
// To Profile Multiple PDFs
if (cat==0 || cat==1 || cat==2 || cat==3){
modelBuilder.addBkgPdf("Bernstein",4,Form("pol4_cat%d",cat));
modelBuilder.addBkgPdf("Bernstein",5,Form("pol5_cat%d",cat));
modelBuilder.addBkgPdf("Bernstein",6,Form("pol6_cat%d",cat));
/*
modelBuilder.addBkgPdf("PowerLaw",1,Form("pow1_cat%d",cat));
modelBuilder.addBkgPdf("PowerLaw",3,Form("pow3_cat%d",cat));
modelBuilder.addBkgPdf("PowerLaw",5,Form("pow5_cat%d",cat));
modelBuilder.addBkgPdf("Exponential",1,Form("exp1_cat%d",cat));
modelBuilder.addBkgPdf("Exponential",3,Form("exp3_cat%d",cat));
modelBuilder.addBkgPdf("Exponential",5,Form("exp5_cat%d",cat));
modelBuilder.addBkgPdf("Laurent",1,Form("lau1_cat%d",cat));
modelBuilder.addBkgPdf("Laurent",3,Form("lau3_cat%d",cat));
modelBuilder.addBkgPdf("Laurent",5,Form("lau5_cat%d",cat));
*/
}
if (cat==4 || cat==5 || cat==6 || cat==7 || cat==8) {
modelBuilder.addBkgPdf("Bernstein",3,Form("pol3_cat%d",cat));
modelBuilder.addBkgPdf("Bernstein",4,Form("pol4_cat%d",cat));
/*
modelBuilder.addBkgPdf("PowerLaw",1,Form("pow1_cat%d",cat));
modelBuilder.addBkgPdf("PowerLaw",3,Form("pow3_cat%d",cat));
modelBuilder.addBkgPdf("Exponential",1,Form("exp1_cat%d",cat));
modelBuilder.addBkgPdf("Exponential",3,Form("exp3_cat%d",cat));
modelBuilder.addBkgPdf("Laurent",1,Form("lau1_cat%d",cat));
modelBuilder.addBkgPdf("Laurent",3,Form("lau3_cat%d",cat));
*/
}
map<string,RooAbsPdf*> bkgPdfs = modelBuilder.getBkgPdfs();
modelBuilder.setSignalPdfFromMC(sigMC);
modelBuilder.makeSBPdfs();
map<string,RooAbsPdf*> sbPdfs = modelBuilder.getSBPdfs();
modelBuilder.fitToData(dataBinned,true,true);
modelBuilder.fitToData(dataBinned,false,true);
modelBuilder.throwToy(Form("cat%d_toy0",cat),dataBinned->sumEntries(),true,true);
// Profile this category using ProfileMultiplePdfs
ProfileMultiplePdfs profiler;
for (map<string,RooAbsPdf*>::iterator pdf=sbPdfs.begin(); pdf!=sbPdfs.end(); pdf++) {
string bkgOnlyName = pdf->first.substr(pdf->first.find("sb_")+3,string::npos);
if (bkgPdfs.find(bkgOnlyName)==bkgPdfs.end()){
cerr << "ERROR -- couldn't find bkg only pdf " << bkgOnlyName << " for SB pdf " << pdf->first << endl;
pdf->second->fitTo(*dataBinned);
exit(1);
}
int nParams = bkgPdfs[bkgOnlyName]->getVariables()->getSize()-1;
profiler.addPdf(pdf->second,2*nParams);
//profiler.addPdf(pdf->second);
cout << pdf->second->GetName() << " nParams=" << pdf->second->getVariables()->getSize() << " nBkgParams=" << nParams << endl;
}
profiler.printPdfs();
//cout << "Continue?" << endl;
//string bus; cin >> bus;
profiler.plotNominalFits(dataBinned,mass,80,Form("cat%d",cat));
pair<double,map<string,TGraph*> > minNlls = profiler.profileLikelihood(dataBinned,mass,mu,mu_low,mu_high,mu_step);
pair<double,map<string,TGraph*> > correctedNlls = profiler.computeEnvelope(minNlls,Form("cat%d",cat),2.);
minNlltrack.push_back(make_pair(correctedNlls.first,correctedNlls.second["envelope"]));
//minNlls.second.insert(pair<string,TGraph*>("envelope",envelopeNll.second));
//map<string,TGraph*> minNLLs = profiler.profileLikelihoodEnvelope(dataBinned,mu,mu_low,mu_high,mu_step);
profiler.plot(correctedNlls.second,Form("cat%d_nlls",cat));
//profiler.print(minNLLs,mu_low,mu_high,mu_step);
/*
if (minNLLs.find("envelope")==minNLLs.end()){
cerr << "ERROR -- envelope TGraph not found in minNLLs" << endl;
exit(1);
}
*/
//minNlltrack.push_back(make_pair(profiler.getGlobalMinNLL(),minNLLs["envelope"]));
}
//exit(1);
TGraph *comb = new TGraph();
for (vector<pair<double,TGraph*> >::iterator it=minNlltrack.begin(); it!=minNlltrack.end(); it++){
if (it->second->GetN()!=minNlltrack.begin()->second->GetN()){
cerr << "ERROR -- unequal number of points for TGraphs " << it->second->GetName() << " and " << minNlltrack.begin()->second->GetName() << endl;
exit(1);
}
}
for (int p=0; p<minNlltrack.begin()->second->GetN(); p++){
double x,y,sumy=0;
for (vector<pair<double,TGraph*> >::iterator it=minNlltrack.begin(); it!=minNlltrack.end(); it++){
it->second->GetPoint(p,x,y);
sumy += (y+it->first);
}
comb->SetPoint(p,x,sumy);
}
pair<double,double> globalMin = getGraphMin(comb);
for (int p=0; p<comb->GetN(); p++){
double x,y;
comb->GetPoint(p,x,y);
comb->SetPoint(p,x,y-globalMin.second);
}
vector<double> fitVal = getValsFromLikelihood(comb);
cout << "Best fit.." << endl;
cout << "\t mu = " << Form("%4.3f",fitVal[0]) << " +/- (1sig) = " << fitVal[2]-fitVal[0] << " / " << fitVal[0]-fitVal[1] << endl;
cout << "\t " << " " << " +/- (2sig) = " << fitVal[4]-fitVal[0] << " / " << fitVal[0]-fitVal[3] << endl;
cout << comb->Eval(fitVal[0]) << " " << comb->Eval(fitVal[1]) << " " << comb->Eval(fitVal[2]) << " " << comb->Eval(fitVal[3]) << " " << comb->Eval(fitVal[4]) << endl;
double quadInterpVal = ProfileMultiplePdfs::quadInterpMinimum(comb);
cout << "quadInterp: mu = " << quadInterpVal << endl;
cout << "\t " << comb->Eval(quadInterpVal) << " " << comb->Eval(quadInterpVal-0.005) << " " << comb->Eval(quadInterpVal-0.01) << " " << comb->Eval(quadInterpVal+0.005) << " " << comb->Eval(quadInterpVal+0.01) << endl;
comb->SetLineWidth(2);
TCanvas *canv = new TCanvas();
comb->Draw("ALP");
canv->Print("plots/comb.pdf");
TFile *tempOut = new TFile("tempOut.root","RECREATE");
tempOut->cd();
comb->SetName("comb");
comb->Write();
tempOut->Close();
return 0;
}
string runQuickRejig(string oldfilename, int ncats){
string newfilename="TestWS.root";
TFile *oldFile = TFile::Open(oldfilename.c_str());
TFile *newFile = new TFile(newfilename.c_str(),"RECREATE");
RooWorkspace *oldWS = (RooWorkspace*)oldFile->Get("cms_hgg_workspace");
RooWorkspace *newWS = new RooWorkspace("wsig_8TeV");
RooRealVar *mass = (RooRealVar*)oldWS->var("CMS_hgg_mass");
RooDataSet *tot;
RooRealVar *normT1 = new RooRealVar("nT1","nT1",500,0,550);
RooRealVar *meanT1 = new RooRealVar("mT1","mT1",125,122,128);
RooRealVar *sigmaT1 = new RooRealVar("sT1","sT1",3.1,1.,10.);
RooGaussian *gausT1 = new RooGaussian("gT1","gT1",*mass,*meanT1,*sigmaT1);
RooRealVar *normT2 = new RooRealVar("nT2","nT2",2,0,500);
RooRealVar *meanT2 = new RooRealVar("mT2","mT2",125,122,128);
RooRealVar *sigmaT2 = new RooRealVar("sT2","sT2",1.7,0.,10.);
RooGaussian *gausT2 = new RooGaussian("gT2","gT2",*mass,*meanT2,*sigmaT2);
RooRealVar *normT3 = new RooRealVar("nT3","nT3",2,0,500);
RooRealVar *meanT3 = new RooRealVar("mT3","mT3",125,122,128);
RooRealVar *sigmaT3 = new RooRealVar("sT3","sT3",1.7,0.,10.);
RooGaussian *gausT3 = new RooGaussian("gT3","gT3",*mass,*meanT3,*sigmaT3);
RooAddPdf *gausT = new RooAddPdf("gT","gT",RooArgList(*gausT1,*gausT2,*gausT3),RooArgList(*normT1,*normT2,*normT3));
for (int cat=0; cat<ncats; cat++){
RooDataSet *thisData = (RooDataSet*)oldWS->data(Form("sig_ggh_mass_m125_cat%d",cat));
newWS->import(*thisData);
RooRealVar *norm1 = new RooRealVar(Form("n1%d",cat),Form("n1%d",cat),500,0,550);
RooRealVar *mean1 = new RooRealVar(Form("m1%d",cat),Form("m1%d",cat),125,122,128);
RooRealVar *sigma1 = new RooRealVar(Form("s1%d",cat),Form("s1%d",cat),3.1,1.,10.);
RooGaussian *gaus1 = new RooGaussian(Form("g1%d",cat),Form("g1%d",cat),*mass,*mean1,*sigma1);
RooRealVar *norm2 = new RooRealVar(Form("n2%d",cat),Form("n2%d",cat),2,0,500);
RooRealVar *mean2 = new RooRealVar(Form("m2%d",cat),Form("m2%d",cat),125,122,128);
RooRealVar *sigma2 = new RooRealVar(Form("s2%d",cat),Form("s2%d",cat),1.7,0.,10.);
RooGaussian *gaus2 = new RooGaussian(Form("g2%d",cat),Form("g2%d",cat),*mass,*mean2,*sigma2);
RooRealVar *norm3 = new RooRealVar(Form("n3%d",cat),Form("n3%d",cat),2,0,500);
RooRealVar *mean3 = new RooRealVar(Form("m3%d",cat),Form("m3%d",cat),125,122,128);
RooRealVar *sigma3 = new RooRealVar(Form("s3%d",cat),Form("s3%d",cat),1.7,0.,10.);
RooGaussian *gaus3 = new RooGaussian(Form("g3%d",cat),Form("g3%d",cat),*mass,*mean3,*sigma3);
RooAddPdf *gaus = new RooAddPdf(Form("g%d",cat),"g",RooArgList(*gaus1,*gaus2,*gaus3),RooArgList(*norm1,*norm2,*norm3));
gaus->fitTo(*thisData,SumW2Error(kTRUE));
newWS->import(*gaus);
if (cat==0) {
tot = thisData;
tot->SetName("sig_ggh_m125");
}
else tot->append(*thisData);
}
newWS->import(*tot);
gausT->fitTo(*tot,SumW2Error(kTRUE));
newWS->import(*gausT);
newWS->Write();
oldFile->Close();
newFile->Close();
delete newFile;
delete newWS;
return newfilename;
}