int main() { const double PDGLbMass=5619.51; const double RareUpperBlind=PDGLbMass+125.0; const double RareLowerBlind=PDGLbMass-125.0; const double Rare2UpperBlind=PDGLbMass+175.0; const double Rare2LowerBlind=PDGLbMass-175.0; bool blind=true; bool remakecc=false; bool remakerare=false; bool remakerare2=false; bool sweight=false; TRandom3* MultiCandRand=new TRandom3(224); //dont change seed TH1I* ControlChannelMultiCands= new TH1I("ControlChannelMultiCands","ControlChannelMultiCands",10,0,10); TH1I* RareChannelMultiCands= new TH1I("RareChannelMultiCands","RareChannelMultiCands",10,0,10); TH1I* Rare2ChannelMultiCands= new TH1I("RareChannel2MultiCands","RareChannel2MultiCands",10,0,10); //_______________________________________ MAKE CONTROL CHANNEL ROODATASET______________________________________ if(remakecc) { std::string ControlDataPath=std::getenv("BUKETAPDATABDTRESPROOT"); DataFile CC12A(ControlDataPath,Data,Twel,MagAll,buketap,"BDTApplied_SampleA"); DataFile CC12B(ControlDataPath,Data,Twel,MagAll,buketap,"BDTApplied_SampleB"); DataFile CC11A(ControlDataPath,Data,Elev,MagAll,buketap,"BDTApplied_SampleA"); DataFile CC11B(ControlDataPath,Data,Elev,MagAll,buketap,"BDTApplied_SampleB"); TreeReader* CC12Reader= new TreeReader("DecayTree"); CC12Reader->AddFile(CC12A); CC12Reader->AddFile(CC12B); CC12Reader->Initialize(ControlCuts::BranchesToKeep,"contains"); TFile* Minimal12File= new TFile("MinimalCC12.root","RECREATE"); TTree* Minimal12Tree=CC12Reader->CopyTree(ControlCuts::AllCuts12,-1,"DecayTree"); TTree* MinimalFlagged12Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal12Tree,ControlChannelMultiCands,NULL); MinimalFlagged12Tree->Write(); Minimal12File->Close(); TreeReader* CC11Reader= new TreeReader("DecayTree"); CC11Reader->AddFile(CC11A); CC11Reader->AddFile(CC11B); CC11Reader->Initialize(ControlCuts::BranchesToKeep,"contains"); TFile* Minimal11File= new TFile("MinimalCC11.root","RECREATE"); TTree* Minimal11Tree=CC11Reader->CopyTree(ControlCuts::AllCuts11,-1,"DecayTree"); TTree* MinimalFlagged11Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal11Tree,ControlChannelMultiCands,NULL); MinimalFlagged11Tree->Write(); Minimal11File->Close(); TreeReader* FlaggedReader= new TreeReader("DecayTree"); FlaggedReader->AddFile("MinimalCC12.root"); FlaggedReader->AddFile("MinimalCC11.root"); FlaggedReader->Initialize(); TFile* CCSingleFile= new TFile("CCSingleFile.root","RECREATE"); TTree* SingleTree=FlaggedReader->CopyTree("isSingle==1",-1,"DecayTree"); SingleTree->Write(); CCSingleFile->Close(); } //_____________________________________Make Rare Mode One Data__________________________________________________ if(remakerare) { std::string RareDataPath=std::getenv("LBPKETAPPIPIGDATABDTRESPROOT"); DataFile Rare12A(RareDataPath,Data,Twel,MagAll,lbpketappipig,"BDTApplied_SampleA_NB"); DataFile Rare12B(RareDataPath,Data,Twel,MagAll,lbpketappipig,"BDTApplied_SampleB_NB"); DataFile Rare11A(RareDataPath,Data,Elev,MagAll,lbpketappipig,"BDTApplied_SampleA_NB"); DataFile Rare11B(RareDataPath,Data,Elev,MagAll,lbpketappipig,"BDTApplied_SampleB_NB"); TreeReader* Rare12Reader= new TreeReader("DecayTree"); Rare12Reader->AddFile(Rare12A); Rare12Reader->AddFile(Rare12B); Rare12Reader->Initialize(pipigCuts::BranchesToKeep,"contains"); TFile* Minimal12File= new TFile("MinimalRare12.root","RECREATE"); TTree* Minimal12Tree=Rare12Reader->CopyTree(pipigCuts::AllCuts12,-1,"DecayTree"); TTree* MinimalFlagged12Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal12Tree,RareChannelMultiCands,NULL); MinimalFlagged12Tree->Write(); Minimal12File->Close(); TreeReader* Rare11Reader= new TreeReader("DecayTree"); Rare11Reader->AddFile(Rare11A); Rare11Reader->AddFile(Rare11B); Rare11Reader->Initialize(pipigCuts::BranchesToKeep,"contains"); TFile* Minimal11File= new TFile("MinimalRare11.root","RECREATE"); TTree* Minimal11Tree=Rare11Reader->CopyTree(pipigCuts::AllCuts11,-1,"DecayTree"); TTree* MinimalFlagged11Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal11Tree,RareChannelMultiCands,NULL); MinimalFlagged11Tree->Write(); Minimal11File->Close(); TreeReader* FlaggedReader= new TreeReader("DecayTree"); FlaggedReader->AddFile("MinimalRare12.root"); FlaggedReader->AddFile("MinimalRare11.root"); FlaggedReader->Initialize(); TFile* RareSingleFile= new TFile("RareSingleFile.root","RECREATE"); TTree* SingleTree=FlaggedReader->CopyTree("isSingle==1",-1,"DecayTree"); SingleTree->Write(); RareSingleFile->Close(); } //___________________________________ Make Rare mode Two Data________________________________________________ if(remakerare2) { std::string Rare2DataPath=std::getenv("LBPKETAPETADATABDTRESPROOT"); DataFile Rare212A(Rare2DataPath,Data,Twel,MagAll,lbpketapeta,"BDTApplied_SampleA_NB"); DataFile Rare212B(Rare2DataPath,Data,Twel,MagAll,lbpketapeta,"BDTApplied_SampleB_NB"); DataFile Rare211A(Rare2DataPath,Data,Elev,MagAll,lbpketapeta,"BDTApplied_SampleA_NB"); DataFile Rare211B(Rare2DataPath,Data,Elev,MagAll,lbpketapeta,"BDTApplied_SampleB_NB"); TreeReader* Rare212Reader= new TreeReader("DecayTree"); Rare212Reader->AddFile(Rare212A); Rare212Reader->AddFile(Rare212B); Rare212Reader->Initialize(etapetaCuts::BranchesToKeep,"contains"); TFile* Minimal12File= new TFile("MinimalRare212.root","RECREATE"); TTree* Minimal12Tree=Rare212Reader->CopyTree(etapetaCuts::AllCuts12,-1,"DecayTree"); TTree* MinimalFlagged12Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal12Tree,Rare2ChannelMultiCands,NULL); MinimalFlagged12Tree->Write(); Minimal12File->Close(); TreeReader* Rare211Reader= new TreeReader("DecayTree"); Rare211Reader->AddFile(Rare211A); Rare211Reader->AddFile(Rare211B); Rare211Reader->Initialize(etapetaCuts::BranchesToKeep,"contains"); TFile* Minimal11File= new TFile("MinimalRare211.root","RECREATE"); TTree* Minimal11Tree=Rare211Reader->CopyTree(etapetaCuts::AllCuts11,-1,"DecayTree"); TTree* MinimalFlagged11Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal11Tree,Rare2ChannelMultiCands,NULL); MinimalFlagged11Tree->Write(); Minimal11File->Close(); TreeReader* FlaggedReader= new TreeReader("DecayTree"); FlaggedReader->AddFile("MinimalRare212.root"); FlaggedReader->AddFile("MinimalRare211.root"); FlaggedReader->Initialize(); TFile* Rare2SingleFile= new TFile("Rare2SingleFile.root","RECREATE"); TTree* SingleTree=FlaggedReader->CopyTree("isSingle==1",-1,"DecayTree"); SingleTree->Write(); Rare2SingleFile->Close(); } //____________________________________ Shared Parameters_______________________________________________________ RooRealVar DataMCRatio("DataMCRatio","DataMCRatio",1.0,0.5,1.5); RooRealVar CCMean("CCMean","CCMean",5279.0,5250.0,5310.0); RooFormulaVar LambdabMean("LambdabMean","LambdabMean","@0+339.72",RooArgList(CCMean)); //RooRealVar LambdabMean("LambdabMean","LambdabMean",5619.0,5615.0,5630.0); // RooFormulaVar CCMean("CCMean","CCMean","@0 - 339.72",RooArgList(LambdabMean)); std::vector<RooRealVar*> FreeParameters; FreeParameters.push_back(&DataMCRatio); // FreeParameters.push_back(&LambdabMean); //____________________________________ Control Channel PDF______________________________________________________ TFile* CCInputFile = new TFile("CCSingleFile.root"); TTree* CCInputTree=(TTree*)CCInputFile->Get("DecayTree"); RooRealVar CCBMass("Bu_DTF_MF","Bu_DTF_MF",5000.0,5550.0); RooRealVar CCEtaMass("eta_prime_MM","eta_prime_MM",880.0,1040.0); RooArgSet CCArgs(CCBMass,CCEtaMass); RooDataSet* CCData=new RooDataSet("CCData","CCData",CCArgs,Import(*CCInputTree)); //++++++++++++++++++++++++++++++Signal PDF+++++++++++++++++++++++++++++++++ TFile *CCMCFitResultFile = new TFile("CCFitResult.root"); RooFitResult* CCMCFitResult=NULL; try { CCMCFitResult=SafeGetFitResult(CCMCFitResultFile,"CCFitResult"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } CCMCFitResult->Print("v"); RooRealVar* CCMCSigma=NULL; RooRealVar* CCMCLAlphaFix=NULL; RooRealVar* CCMCRAlphaFix=NULL; RooRealVar* CCMCLNFix=NULL; RooRealVar* CCMCRNFix=NULL; try { CCMCSigma=SafeGetVar(CCMCFitResult,"CCSigma"); CCMCLAlphaFix=SafeGetVar(CCMCFitResult,"CCLAlpha"); CCMCRAlphaFix=SafeGetVar(CCMCFitResult,"CCRAlpha"); CCMCLNFix=SafeGetVar(CCMCFitResult,"CCLN"); CCMCRNFix=SafeGetVar(CCMCFitResult,"CCRN"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } RooRealVar CCMCSigmaFix("CCMCSigmaFix","CCMCSigmaFix",CCMCSigma->getVal()); CCMCSigmaFix.setConstant(kTRUE); RooFormulaVar CCSigma("CCSigma","CCSigma","@0*@1",RooArgList(DataMCRatio,CCMCSigmaFix)); RooRealVar CCLAlpha("CCLAlpha","CCLAlpha",CCMCLAlphaFix->getVal()); RooRealVar CCRAlpha("CCRAlpha","CCRAlpha",CCMCRAlphaFix->getVal()); RooRealVar CCLN("CCLN","CCLN",CCMCLNFix->getVal()); RooRealVar CCRN("CCRN","CCRN",CCMCRNFix->getVal()); RooCBShape CCDCBLeft("CCDCBLeft","CCDCBLeft",CCBMass,CCMean,CCSigma,CCLAlpha,CCLN); RooCBShape CCDCBRight("CCDCBRight","CCDCBRight",CCBMass,CCMean,CCSigma,CCRAlpha,CCRN); RooRealVar CCFitFraction("CCFitFraction","CCFitFraction",0.5,0.0,1.0); FreeParameters.push_back(&CCFitFraction); RooAddPdf CCDCB("CCDCB","CCDCB",RooArgList(CCDCBRight,CCDCBLeft),CCFitFraction); RooRealVar CCEtamean("CCEtamean","CCEtamean",958.0,955.0,960.0); RooRealVar CCEtasigma("CCEtasigma","CCEtasigma",9.16,9.0,15.0); RooRealVar* CCMCEtaLAlpha=NULL; RooRealVar* CCMCEtaRAlpha=NULL; RooRealVar* CCMCEtaLN=NULL; RooRealVar* CCMCEtaRN=NULL; try { CCMCEtaLAlpha=SafeGetVar(CCMCFitResult,"CCEtaLAlpha"); CCMCEtaRAlpha=SafeGetVar(CCMCFitResult,"CCEtaRAlpha"); CCMCEtaLN=SafeGetVar(CCMCFitResult,"CCEtaLN"); CCMCEtaRN=SafeGetVar(CCMCFitResult,"CCEtaRN"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } RooRealVar CCEtaLAlpha("CCEtaLAlpha","CCEtaLAlpha",CCMCEtaLAlpha->getVal()); RooRealVar CCEtaRAlpha("CCEtaRAlpha","CCEtaRAlpha",CCMCEtaRAlpha->getVal()); RooRealVar CCEtaLN("CCEtaLN","CCEtaLN",CCMCEtaLN->getVal()); RooRealVar CCEtaRN("CCEtaRN","CCEtaRN",CCMCEtaRN->getVal()); RooCBShape CCEtaDCBLeft("CCEtaCBLeft","CCEtaCBLeft",CCEtaMass,CCEtamean,CCEtasigma,CCEtaLAlpha,CCEtaLN); RooCBShape CCEtaDCBRight("CCEtaCBRight","CCEtaCBRight",CCEtaMass,CCEtamean,CCEtasigma,CCEtaRAlpha,CCEtaRN); RooRealVar CCEtaFitFraction("CCEtaFitFraction","CCEtaFitFraction",0.22,0.1,1.0); FreeParameters.push_back(&CCEtaFitFraction); RooAddPdf CCEtaDCB("CCEteaDCB","CCEtaDCB",RooArgList(CCEtaDCBRight,CCEtaDCBLeft),CCEtaFitFraction); RooProdPdf CCSignalPdf("CCSignalPdf","CCSignalPdf",RooArgSet(CCEtaDCB,CCDCB)); RooRealVar CCSignalYield("CCSignalYield","CCSignalYield",10000.0,1000.0,20000.0); RooExtendPdf CCExtendedSignalPdf("CCExtendedSignalPdf","CCExtendedSignalPdf",CCSignalPdf,CCSignalYield); //+++++++++++++++++++++++++++++++++ COMB NO ETAP PDF++++++++++++++++++++++++++++++++++++++++ RooRealVar CCNoEtaBSlope("CCNoEtaBSlope","CCNoEtaBSlope",-0.6,-0.8,-0.4); FreeParameters.push_back(&CCNoEtaBSlope); RooRealVar CCNoEtaBCurve("CCNoEtaBCurve","CCNoEtaBCurve",-0.1,-0.30,-0.05); FreeParameters.push_back(&CCNoEtaBCurve); RooChebychev CCNoEtaBLine("CCNoEtaBLine","CCNoEtaBLine",CCBMass,RooArgList(CCNoEtaBSlope,CCNoEtaBCurve)); RooRealVar CCNoEtaEtaP1("CCNoEtaEtaP1","CCNoEtaEtaP1",-0.1,-1.0,0.0); FreeParameters.push_back(&CCNoEtaEtaP1); RooRealVar CCNoEtaEtaP2("CCNoEtaEtaP2","CCNoEtaEtaP2",-0.1,-0.8,0.0); FreeParameters.push_back(&CCNoEtaEtaP2); RooChebychev CCNoEtaQuad("CCNoEtaQuad","CCNoEtaQuad",CCEtaMass,RooArgList(CCNoEtaEtaP1,CCNoEtaEtaP2)); RooProdPdf CCNoEtaBkgPdf("CCNoEtaBkgPdf","CCNoEtaBkgPdf",RooArgSet(CCNoEtaQuad,CCNoEtaBLine)); RooRealVar CCNoEtaBkgYield("CCNoEtaBkgYield","CCNoEtaBkgYield",2400.0,500.0,15000.0); RooExtendPdf ExtCCNoEtaBkgPdf("ExtCCNoEtaBkgPdf","ExtCCNoEtaBkgPdf",CCNoEtaBkgPdf,CCNoEtaBkgYield); //++++++++++++++++++++++++++++++++++ COMB TRUE ETAP PDF++++++++++++++++++++++++++++++++++ RooRealVar CCTrueEtaBSlope("CCTrueEtaBSlope","CCTrueEtaBSlope",-0.1,-1.0,0.0); FreeParameters.push_back(&CCTrueEtaBSlope); RooChebychev CCTrueEtaBLine("CCTrueEtaBLine","CCTrueEtaBLine",CCBMass,RooArgList(CCTrueEtaBSlope)); RooRealVar CCTrueEtaEtaLAlpha("CCTrueEtaEtaLAlpha","CCTrueEtaEtaLAlpha",CCMCEtaLAlpha->getVal()); RooRealVar CCTrueEtaEtaRAlpha("CCTrueEtaEtaRAlpha","CCTrueEtaEtaRAlpha",CCMCEtaRAlpha->getVal()); RooRealVar CCTrueEtaEtaLN("CCTrueEtaEtaLN","CCTrueEtaEtaLN",CCMCEtaLN->getVal()); RooRealVar CCTrueEtaEtaRN("CCTrueEtaEtaRN","CCTrueEtaEtaRN",CCMCEtaRN->getVal()); //RooCBShape CCTrueEtaEtaCBLeft("CCTrueEtaEtaCBLeft","CCTrueEtaEtaCBLeft",CCEtaMass,CCEtamean,CCEtasigma,CCTrueEtaEtaLAlpha,CCTrueEtaEtaLN); RooCBShape CCTrueEtaEtaCBRight("CCTrueEtaEtaCBRight","CCTrueEtaEtaCBRight",CCEtaMass,CCEtamean,CCEtasigma,CCTrueEtaEtaRAlpha,CCTrueEtaEtaRN); // RooRealVar CCTrueEtaEtaFitFraction("CCTrueEtaEtaFitFraction","CCTrueEtaEtaFitFraction",0.4,0.0,1.0); //RooAddPdf CCTrueEtaEtaDCB("CCTrueEtaEtaDCB","CCTrueEtaEtaDCB",RooArgList(CCTrueEtaEtaCBRight,CCTrueEtaEtaCBLeft),CCTrueEtaEtaFitFraction); RooProdPdf CCTrueEtaEtaBkgPdf("CCTrueEtaEtaBkgPdf","CCTrueEtaEtaBkgPdf",RooArgSet(CCTrueEtaEtaCBRight,CCTrueEtaBLine)); RooRealVar CCTrueEtaBkgYield("CCTrueEtaBkgYield","CCTrueEtaBkgYield",800.0,20.0,10000.0); RooExtendPdf ExtCCTrueEtaBkgPdf("ExtCCTrueEtaBkgPdf","ExtCCTrueEtaBkgPdf",CCTrueEtaEtaBkgPdf,CCTrueEtaBkgYield); RooAddPdf CCTotalPdf("CCTotalPdf","CCTotalPdf",RooArgList(ExtCCTrueEtaBkgPdf,ExtCCNoEtaBkgPdf,CCExtendedSignalPdf)); //_________________________________Rare1 Fit_____________________________ TFile * RareInputFile = new TFile("RareSingleFile.root"); TTree* RareInputTree=NULL; try { RareInputTree=SafeGetTree(RareInputFile,"DecayTree"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } RooRealVar LbMass("Lambda_b0_DTF_MF","Lambda_b0_DTF_MF",5200.0,6000.0); RooRealVar RareLambda_b0_PE("Lambda_b0_PE","Lambda_b0_PE",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareLambda_b0_PX("Lambda_b0_PX","Lambda_b0_PX",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareLambda_b0_PY("Lambda_b0_PY","Lambda_b0_PY",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareLambda_b0_PZ("Lambda_b0_PZ","Lambda_b0_PZ",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareProton_PE("Proton_PE","Proton_PE",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareProton_PX("Proton_PX","Proton_PX",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareProton_PY("Proton_PY","Proton_PY",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareProton_PZ("Proton_PZ","Proton_PZ",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareKaon_PE("Kaon_PE","Kaon_PE",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareKaon_PX("Kaon_PX","Kaon_PX",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareKaon_PY("Kaon_PY","Kaon_PY",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar RareKaon_PZ("Kaon_PZ","Kaon_PZ",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rareeta_prime_PE("eta_prime_PE","eta_prime_PE",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rareeta_prime_PX("eta_prime_PX","eta_prime_PX",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rareeta_prime_PY("eta_prime_PY","eta_prime_PY",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rareeta_prime_PZ("eta_prime_PZ","eta_prime_PZ",-RooNumber::infinity(),RooNumber::infinity()); RooArgSet RareArgs(LbMass,RareLambda_b0_PE,RareLambda_b0_PX,RareLambda_b0_PY,RareLambda_b0_PZ,RareProton_PE,RareProton_PX,RareProton_PY,RareProton_PZ); RareArgs.add(RareKaon_PE); RareArgs.add(RareKaon_PX); RareArgs.add(RareKaon_PY); RareArgs.add(RareKaon_PZ); RareArgs.add(Rareeta_prime_PE); RareArgs.add(Rareeta_prime_PX); RareArgs.add(Rareeta_prime_PY); RareArgs.add(Rareeta_prime_PZ); RooDataSet* RareData= new RooDataSet("RareData","RareData",RareArgs,Import(*RareInputTree)); TFile * RareFitResultFile = new TFile("RareFitResult.root"); RooFitResult* RareMCFitResult=NULL; try { RareMCFitResult=SafeGetFitResult(RareFitResultFile,"RareFitResult"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } RareMCFitResult->Print("v"); RooRealVar* RareMCRAlpha=NULL; RooRealVar* RareMCFitFraction=NULL; RooRealVar* RareMCLAlpha=NULL; RooRealVar* RareMCLN=NULL; RooRealVar* RareMCRN=NULL; RooRealVar* RareMCSigma=NULL; try { RareMCRAlpha=SafeGetVar(RareMCFitResult,"RareAlpha"); RareMCFitFraction=SafeGetVar(RareMCFitResult,"RareFitFraction"); RareMCLAlpha=SafeGetVar(RareMCFitResult,"RareLAlpha"); RareMCLN=SafeGetVar(RareMCFitResult,"RareLN"); RareMCRN=SafeGetVar(RareMCFitResult,"RareRN"); RareMCSigma=SafeGetVar(RareMCFitResult,"RareSigma"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } //++++++++++++++++++++++++++++++Rare Signal PDF++++++++++++++++++++++++++++ RooRealVar RareMCSigmaFix("RareMCSigmaFix","RareMCSigmaFix",RareMCSigma->getVal()); RareMCSigmaFix.setConstant(); RooFormulaVar RareSigma("RareSigma","RareSigma","@0*@1",RooArgSet(RareMCSigmaFix,DataMCRatio)); RooRealVar RareLAlpha("RareLAlpha","RareLAlpha",RareMCLAlpha->getVal()); RooRealVar RareRAlpha("RareRAlpha","RareRAlpha",RareMCRAlpha->getVal()); RooRealVar RareRN("RareRN","RareRN",RareMCRN->getVal()); RooRealVar RareLN("RareLN","RareLN",RareMCLN->getVal()); RooRealVar RareFitFraction("RareFitFraction","RareFitFraction",RareMCFitFraction->getVal()); RooCBShape RareDCBLeft("DCBLeft","DCBLeft",LbMass,LambdabMean,RareSigma,RareLAlpha,RareLN); RooCBShape RareDCBRight("DCBRight","DCBRight",LbMass,LambdabMean,RareSigma,RareRAlpha,RareRN); RooAddPdf RareDCB("RareDCB","RareDCB",RooArgList(RareDCBLeft,RareDCBRight),RareFitFraction); RooRealVar RareYield("RareYield","RareYield",40.0,-100.0,1000.0); RooExtendPdf RareSignalPdf("RareSignalPdf","RareSignalPdf",RareDCB,RareYield); //++++++++++++++++++++++++++++++Rare Combinatorial Bkg+++++++++++++++++++++++++++++++++++ RooRealVar Rarep1("Rarep1","Rarep1",-1.1,-5.0,-0.1); FreeParameters.push_back(&Rarep1); RooRealVar Rarep2("Rarep2","Rarep2",0.5,0.001,10.0); FreeParameters.push_back(&Rarep2); RooChebychev RarePoly("RarePoly","RarePoly",LbMass,RooArgList(Rarep1,Rarep2)); RooRealVar RareBkgYield("RareBkgYield","RareBkgYield",2000.0,0.0,10000.0); RooExtendPdf RareBkgPdf("RareBkgPdf","RareBkgPdf",RarePoly,RareBkgYield); //++++++++++++++++++++++++++++Rare PKPhi Bkg+++++++++++++++++++++++++++++++++ TFile* PKPhiMCFitresultFile= new TFile("PkPhiFitResultFile.root"); RooFitResult* PKPhiMCFitResult=NULL; try { PKPhiMCFitResult=SafeGetFitResult(PKPhiMCFitresultFile,"PkPhiFitResult"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } PKPhiMCFitResult->Print("v"); RooRealVar* PkPhiMean=NULL; RooRealVar* PkPhiSigma=NULL; RooRealVar* PkPhiLAlpha=NULL; RooRealVar* PkPhiRAlpha=NULL; RooRealVar* PkPhiLN=NULL; RooRealVar* PkPhiRN=NULL; try { PkPhiMean=SafeGetVar(PKPhiMCFitResult,"PkPhiMean"); PkPhiSigma=SafeGetVar(PKPhiMCFitResult,"PkPhiSigma"); PkPhiLAlpha=SafeGetVar(PKPhiMCFitResult,"PkPhiLAlpha"); PkPhiLN=SafeGetVar(PKPhiMCFitResult,"PkPhiLN"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } RooRealVar RarePkPhiMean("RarePkPhiMean","RarePkPhiMean",PkPhiMean->getVal()); RooRealVar RarePkPhiSigma("RarePkPhiSigma","RarePkPhiSigma",PkPhiSigma->getVal()); RooRealVar RarePkPhiLN("RarePkPhiLN","RarePkPhiLN",PkPhiLN->getVal()); RooRealVar RarePkPhiLAlpha("RarePkPhiLAlpha","RarePkPhiLAlpha",PkPhiLAlpha->getVal()); RooCBShape RarePkPhiModel("RarePkPhiModel","RarePkPhiModel",LbMass,RarePkPhiMean,RarePkPhiSigma,RarePkPhiLAlpha,RarePkPhiLN); RooRealVar RarePkPhiYield("RarePkPhiYield","RarePkPhiYield",50.0,1.0,150.0); RooExtendPdf RarePkPhiPdf("RarePkPhiPdf","RarePkPhiPdf",RarePkPhiModel,RarePkPhiYield); RooAddPdf RarePdf("RarePdf","RarePdf",RooArgList(RarePkPhiPdf,RareBkgPdf,RareSignalPdf)); /*RarePdf.fitTo(*RareData,Extended(kTRUE)); RooPlot* RareFrame=LbMass.frame(Bins(35),Range(5200.0,6100.0)); TCanvas RareCanvas; RareData->plotOn(RareFrame); RarePdf.plotOn(RareFrame); RareFrame->Draw(); RareCanvas.SaveAs("RareCanvas.pdf");*/ //________________________________ Fit Rare 2_______________________________ TFile* Rare2InputFile = new TFile("Rare2SingleFile.root"); TTree* Rare2InputTree=NULL; try { Rare2InputTree=SafeGetTree(Rare2InputFile,"DecayTree"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } RooRealVar Rare2Lambda_b0_PE("Lambda_b0_PE","Lambda_b0_PE",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Lambda_b0_PX("Lambda_b0_PX","Lambda_b0_PX",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Lambda_b0_PY("Lambda_b0_PY","Lambda_b0_PY",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Lambda_b0_PZ("Lambda_b0_PZ","Lambda_b0_PZ",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Proton_PE("Proton_PE","Proton_PE",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Proton_PX("Proton_PX","Proton_PX",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Proton_PY("Proton_PY","Proton_PY",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Proton_PZ("Proton_PZ","Proton_PZ",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Kaon_PE("Kaon_PE","Kaon_PE",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Kaon_PX("Kaon_PX","Kaon_PX",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Kaon_PY("Kaon_PY","Kaon_PY",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2Kaon_PZ("Kaon_PZ","Kaon_PZ",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2eta_prime_PE("eta_prime_PE","eta_prime_PE",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2eta_prime_PX("eta_prime_PX","eta_prime_PX",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2eta_prime_PY("eta_prime_PY","eta_prime_PY",-RooNumber::infinity(),RooNumber::infinity()); RooRealVar Rare2eta_prime_PZ("eta_prime_PZ","eta_prime_PZ",-RooNumber::infinity(),RooNumber::infinity()); RooArgSet Rare2Args(LbMass,Rare2Lambda_b0_PE,Rare2Lambda_b0_PX,Rare2Lambda_b0_PY,Rare2Lambda_b0_PZ,Rare2Proton_PE,Rare2Proton_PX,Rare2Proton_PY,Rare2Proton_PZ); Rare2Args.add(Rare2Kaon_PE); Rare2Args.add(Rare2Kaon_PX); Rare2Args.add(Rare2Kaon_PY); Rare2Args.add(Rare2Kaon_PZ); Rare2Args.add(Rare2eta_prime_PE); Rare2Args.add(Rare2eta_prime_PX); Rare2Args.add(Rare2eta_prime_PY); Rare2Args.add(Rare2eta_prime_PZ); RooDataSet* Rare2Data=new RooDataSet("Rare2Data","Rare2Data",Rare2Args,Import(*Rare2InputTree)); TFile* Rare2MCFitResultFile= new TFile("RareTwoFitResult.root"); RooFitResult* Rare2MCFitResult=NULL; try { Rare2MCFitResult=SafeGetFitResult(Rare2MCFitResultFile,"RareTwoFitResult"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } //++++++++++++++++++++++++++++++Signal PDF++++++++++++++++++++++++++++++++ RooRealVar* Rare2MCFitFraction=NULL; RooRealVar* Rare2MCLAlpha=NULL; RooRealVar* Rare2MCLN=NULL; RooRealVar* Rare2MCRN=NULL; RooRealVar* Rare2MCRAlpha=NULL; RooRealVar* Rare2MCSigma=NULL; try { Rare2MCFitFraction=SafeGetVar(Rare2MCFitResult,"Rare2FitFraction"); Rare2MCLAlpha=SafeGetVar(Rare2MCFitResult,"Rare2LAlpha"); Rare2MCLN=SafeGetVar(Rare2MCFitResult,"Rare2LN"); Rare2MCRN=SafeGetVar(Rare2MCFitResult,"Rare2RN"); Rare2MCRAlpha=SafeGetVar(Rare2MCFitResult,"Rare2RAlpha"); Rare2MCSigma=SafeGetVar(Rare2MCFitResult,"Rare2Sigma"); } catch(std::exception &e) { std::cout<<e.what()<<std::endl; return 1; } RooRealVar Rare2SigmaFix("Rare2SigmaFix","Rare2SigmaFix",Rare2MCSigma->getVal()); RooFormulaVar Rare2Sigma("Rare2Sigma","Rare2Sigma","@0*@1",RooArgList(Rare2SigmaFix,DataMCRatio)); RooRealVar Rare2LN("Rare2LN","Rare2LN",Rare2MCLN->getVal()); RooRealVar Rare2RN("Rare2RN","Rare2RN",Rare2MCRN->getVal()); RooRealVar Rare2RAlpha("Rare2RAlpha","Rare2RAlpha",Rare2MCRAlpha->getVal()); RooRealVar Rare2LAlpha("Rare2LAlpha","Rare2LAlpha",Rare2MCLAlpha->getVal()); RooRealVar Rare2FitFraction("Rare2FitFraction","Rare2FitFraction",Rare2MCFitFraction->getVal()); RooCBShape Rare2CBLeft("Rare2CBLeft","Rare2CBLeft",LbMass,LambdabMean,Rare2Sigma,Rare2LAlpha,Rare2LN); RooCBShape Rare2CBRight("Rare2CBRight","Rare2CBRight",LbMass,LambdabMean,Rare2Sigma,Rare2RAlpha,Rare2RN); RooAddPdf Rare2DCB("Rare2DCB","Rare2DCB",RooArgList(Rare2CBLeft,Rare2CBRight),Rare2FitFraction); RooRealVar Rare2SignalYield("Rare2SignalYield","Rare2SignalYield",100.0,-100.0,1000.0); RooExtendPdf Rare2SignalPdf("Rare2SignalPdf","Rare2SignalPdf",Rare2DCB,Rare2SignalYield); //++++++++++++++++++++++++++++++Rare 2 Bkg pdf++++++++++++++++++++++++++++++ RooRealVar Rare2K("K","K",-0.003,-0.1,0.0); RooExponential Rare2BkgExp("Rare2BkgExp","Rare2BkgExp",LbMass,Rare2K); RooRealVar Rare2BkgYield("Rare2BkgYield","Rare2BkgYield",2000.0,0.0,100000.0); RooExtendPdf Rare2BkgPdf("Rare2BkgPdf","Rare2BkgPdf",Rare2BkgExp,Rare2BkgYield); RooAddPdf Rare2Pdf("Rare2Pdf","Rare2Pdf",RooArgList(Rare2SignalPdf,Rare2BkgPdf)); //___________________________________ SImultaneous Part ________________________________________________________ RooCategory Channel("Channel","Channel"); Channel.defineType("Rare"); Channel.defineType("Rare2"); Channel.defineType("Control"); RooDataSet* AllData = new RooDataSet("AllData","AllData",RooArgSet(LbMass,CCBMass,CCEtaMass),Index(Channel),Import("Rare",*RareData),Import("Rare2",*Rare2Data),Import("Control",*CCData)); RooSimultaneous SimPdf("SimPdf","SimPdf",Channel); SimPdf.addPdf(Rare2Pdf,"Rare2"); SimPdf.addPdf(RarePdf,"Rare"); SimPdf.addPdf(CCTotalPdf,"Control"); RooDataSet* BlindedData=NULL; RooFitResult* SimResult=NULL; if(blind) { LbMass.setRange("RLSB",5200.0,RareLowerBlind); LbMass.setRange("RUSB",RareUpperBlind,6000.0); LbMass.setRange("R2LSB",5200.0,Rare2LowerBlind); LbMass.setRange("R2USB",Rare2UpperBlind,6000.0); LbMass.setRange("RDLSB",5200.0,5493.33333); LbMass.setRange("RDUSB",RareUpperBlind,6000.0); std::string CutString="Lambda_b0_DTF_MF<"+std::to_string(RareLowerBlind)+"||Lambda_b0_DTF_MF>"+std::to_string(Rare2UpperBlind); BlindedData=(RooDataSet*)AllData->reduce(CutString.data()); RooMsgService::instance().setSilentMode(kTRUE); RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL) ; } RooArgSet MinosPars(Rare2SignalYield,RareYield,CCSignalYield); SimResult = SimPdf.fitTo(*AllData,Save(kTRUE),Extended(kTRUE),Minos(MinosPars)); SimPdf.Print("v"); RooPlot* NominalLikelihoodRareYield=RareYield.frame(Title("Likelihood scan of RareYield"),Range(50,150)); RooAbsReal* nll = SimPdf.createNLL(*AllData,NumCPU(2),Extended(kTRUE)); TCanvas C; nll->plotOn(NominalLikelihoodRareYield,ShiftToZero()); NominalLikelihoodRareYield->Draw(); C.SaveAs("NominalLikelihood.pdf"); // HandyFunctions::SetlhcbStyle(); //_______________________________ Plot B+ Canvas_____________________________________________________________ RooPlot* CCBFrame= CCBMass.frame(Bins(50),Range(5000.0,5500.0),Title("Control Channel B+ Mass Projection")); AllData->plotOn(CCBFrame,Cut("Channel==Channel::Control")); SimPdf.plotOn(CCBFrame,Slice(Channel,"Control"),Components("ExtCCTrueEtaBkgPdf"),LineColor(kMagenta),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(CCBFrame,Slice(Channel,"Control"),Components("ExtCCNoEtaBkgPdf"),LineColor(kGreen),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(CCBFrame,Slice(Channel,"Control"),Components("CCExtendedSignalPdf"),LineColor(kRed),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(CCBFrame,Slice(Channel,"Control"),ProjWData(Channel,*AllData)); TCanvas* CCBCanvas=HandyFunctions::DecoratePlot(CCBFrame); /*(TCanvas* CCBCanvas= new TCanvas("CCBCanvas","CCBCanvas",1600,900); CCBFrame->Draw(); CCBCanvas->SaveAs("CCBCanvas.eps");*/ //________________________________Plot Eta Canvas_____________________________________________________________ RooPlot* CCEtaFrame=CCEtaMass.frame(Bins(50),Range(880.0,1040.0),Title("Control Channel Eta' Projection")); AllData->plotOn(CCEtaFrame,Cut("Channel==Channel::Control")); SimPdf.plotOn(CCEtaFrame,Slice(Channel,"Control"),Components("ExtCCTrueEtaBkgPdf"),LineColor(kMagenta),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(CCEtaFrame,Slice(Channel,"Control"),Components("ExtCCNoEtaBkgPdf"),LineColor(kGreen),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(CCEtaFrame,Slice(Channel,"Control"),Components("CCExtendedSignalPdf"),LineColor(kRed),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(CCEtaFrame,Slice(Channel,"Control"),ProjWData(Channel,*AllData)); TCanvas* CCEtaCanvas=HandyFunctions::DecoratePlot(CCEtaFrame); /*TCanvas* CCEtaCanvas=new TCanvas("CCEtaCanvas","CCEtaCanvas",1600,900); CCEtaFrame->Draw(); CCEtaCanvas->Print("CCEtaCanvas.eps");*/ //________________________________Plot Rare Canvas_____________________________________________________________ RooPlot* RareFrame=LbMass.frame(Bins(30),Range(5200.0,6000.0),Title("#Lambda_{b} -> p K (#eta' -> #pi #pi #gamma) ;M(#Lambda_{b})")); if(blind) { double sidebandsN = RareData ->sumEntries("1","RLSB,RUSB"); double LowsidebandsN = RareData ->sumEntries("1","RLSB"); RareData->plotOn(RareFrame,CutRange("RDLSB,RDUSB"),Name("RareDataPlotted")); RarePdf.plotOn(RareFrame,Range("RLSB,RUSB"),Components("RarePkPhiPdf"),Name("RarePkPhiBkg"),LineColor(kMagenta),LineStyle(kDashed),Normalization(sidebandsN,RooAbsReal::NumEvent)); RarePdf.plotOn(RareFrame,Range("RLSB,RUSB"),Components("RareBkgPdf"),Name("RareCombBkg"),LineColor(kGreen),LineStyle(kDashed),Normalization(sidebandsN,RooAbsReal::NumEvent)); RarePdf.plotOn(RareFrame,Range("RLSB,RUSB"),Normalization(sidebandsN,RooAbsReal::NumEvent)); } else { AllData->plotOn(RareFrame,Cut("Channel==Channel::Rare")); SimPdf.plotOn(RareFrame,Slice(Channel,"Rare"),Components("RarePkPhiPdf"),LineColor(kMagenta),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(RareFrame,Slice(Channel,"Rare"),Components("RareBkgPdf"),LineColor(kGreen),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(RareFrame,Slice(Channel,"Rare"),Components("RareSignalPdf"),LineColor(kRed),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(RareFrame,Slice(Channel,"Rare"),ProjWData(Channel,*AllData)); } int i=RareFrame->numItems(); std::cout<<"_________________________________________"<<std::endl; for(int j=0; j<i; j++) { std::cout<<RareFrame->nameOf(j)<<std::endl; } TLegend * RareLegend = new TLegend(0.66,0.7,0.9,0.9); RareLegend->AddEntry(RareFrame->findObject("RarePkPhiBkg"),"#Lambda_{b} -> p K #phi bkg","l"); RareLegend->AddEntry(RareFrame->findObject("RareCombBkg"),"Combinatorial Background","l"); std::cout<<"++++++++++++++++++++++++++++++++++++++++++++"<<std::endl; RooHist* Pulls=RareFrame->pullHist(0,"RarePdf_Norm[Lambda_b0_DTF_MF]"); TCanvas* RareCanvas=HandyFunctions::DecoratePlot(RareFrame,"DecoratedRareCanvas"); RareCanvas->Print("RareCanvas.pdf"); TCanvas * PullCanvas=new TCanvas("RarePullCanvas","RarePullCanvas",1200,1000); Pulls->Draw("AP"); PullCanvas->SaveAs("RarePulls.pdf"); TCanvas *RareNoPullCanvas = new TCanvas("RareFitCanvas","RareFitCanvas",1600,900); RareFrame->Draw(); RareLegend->Draw(); RareNoPullCanvas->Print("RareNoPullCanvasPrinted.eps"); //_______________________________Plot Rare2 Canvas_____________________________________________________________ RooPlot* Rare2Frame=LbMass.frame(Bins(25),Range(5200.0,6000.),Title("#Lambda_{b} -> p K (#eta' -> #pi #pi #eta);M(#Lambda_{b})")); if(blind) { double Rare2sidebandsN= Rare2Data->sumEntries("1","R2LSB,R2USB"); Rare2Data->plotOn(Rare2Frame,CutRange("R2LSB,R2USB")); Rare2Pdf.plotOn(Rare2Frame,Range("R2LSB,R2USB"),Normalization(Rare2sidebandsN,RooAbsReal::NumEvent)); } else { AllData->plotOn(Rare2Frame,Cut("Channel==Channel::Rare2")); SimPdf.plotOn(Rare2Frame,Slice(Channel,"Rare2"),Components("Rare2BkgPdf"),LineColor(kGreen),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(Rare2Frame,Slice(Channel,"Rare2"),Components("Rare2SignalPdf"),LineColor(kRed),LineStyle(kDashed),ProjWData(Channel,*AllData)); SimPdf.plotOn(Rare2Frame,Slice(Channel,"Rare2"),ProjWData(Channel,*AllData)); } TCanvas* NoPullRare2= new TCanvas("NoPullRare2","NoPullRare2",1800,1000); Rare2Frame->Draw(); NoPullRare2->SaveAs("PiPiEtaFit.eps"); TCanvas* Rare2Canvas=HandyFunctions::DecoratePlot(Rare2Frame,"DecoratedRare2Canvas"); Rare2Canvas->SaveAs("Rare2Canvas.pdf"); if(blind) { RooArgSet NotBlind(CCEtamean,CCSignalYield,DataMCRatio,CCNoEtaBkgYield,CCTrueEtaBkgYield,CCMean,RareBkgYield,Rare2BkgYield,RarePkPhiYield); cout << "Fit complete" << endl; cout << "covQual:" << SimResult->covQual() << endl; cout << "EDM:" << SimResult->edm() << endl; cout << "FCN at min:" << SimResult->minNll() << endl; NotBlind.Print("s"); } TFile* DataFitResults= new TFile("DataFitResults.root","RECREATE"); RareNoPullCanvas->Write(); CCBCanvas->Write(); CCEtaCanvas->Write(); RareCanvas->Write(); Rare2Canvas->Write(); SimResult->Write("DataFitResult"); DataFitResults->Close(); RooWorkspace* Wkspc= new RooWorkspace("w","workspace"); Wkspc->import(SimPdf); // Wkspc->writeToFile("BigFitWorkspace.root"); Wkspc->writeToFile("TestBigFitWorkspace.root"); for(auto Var : FreeParameters) { Var->setConstant(); } RooStats::SPlot* sDataMass; if(sweight) { sDataMass = new RooStats::SPlot("sData","An SPlot",*RareData,&RarePdf,RooArgList(RarePkPhiYield,RareYield,RareBkgYield)); std::cout<<" Check SWeights: "<<std::endl; std::cout<<" BkgYield= "<<RareBkgYield.getVal()<<std::endl; std::cout<<" Bkg yield from sweights = "<<sDataMass->GetYieldFromSWeight("RareBkgYield")<<std::endl; } }
void fitWe(const TString outputDir="test", // output directory const Double_t lumi=18.7, // integrated luminosity (/fb) const Int_t Ecm=8, // center-of-mass energy const Int_t doPU=1 // option for PU-reweighting ) { gBenchmark->Start("fitWe"); //-------------------------------------------------------------------------------------------------------------- // Settings //============================================================================================================== // MET histogram binning and range const Int_t NBINS = 50; const Double_t METMAX = 100; const Double_t PT_CUT = 25; const Double_t ETA_CUT = 2.5; // file format for output plots const TString format("png"); // file name with recoil correction TString recoilfname("../RecoilSyst/ZeeData/fits.root"); // file name(s) with PU weights TString pufname(""); if(doPU>0) { if(doPU==1) { pufname = "Utils/PileupReweighting.Summer11DYmm_To_Run2011A.root"; } else { cout << "Invalid option for PU re-weighting! Aborting..." << endl; assert(0); } } // // input ntuple file names // enum { eData, eWenu, eEWK }; // data type enum vector<TString> fnamev; vector<Int_t> typev; fnamev.push_back("../Selection/Wenu/ntuples/data_m23_select.root"); typev.push_back(eData); fnamev.push_back("../Selection/Wenu/ntuples/we_select.root"); typev.push_back(eWenu); fnamev.push_back("../Selection/Wenu/ntuples/ewk_select.root"); typev.push_back(eEWK); fnamev.push_back("../Selection/Wenu/ntuples/top_select.root"); typev.push_back(eEWK); //-------------------------------------------------------------------------------------------------------------- // Main analysis code //============================================================================================================== // Create output directory gSystem->mkdir(outputDir,kTRUE); CPlot::sOutDir = outputDir; // Get pile-up weights TFile *pufile = 0; TH1D *puWeights = 0; if(doPU>0) { pufile = new TFile(pufname); assert(pufile); puWeights = (TH1D*)pufile->Get("puWeights"); assert(puWeights); } // Access recoil corrections //RecoilCorrector recoilCorr(recoilfname); // // Declare MET histograms // TH1D *hDataMet = new TH1D("hDataMet", "",NBINS,0,METMAX); hDataMet->Sumw2(); TH1D *hDataMetm = new TH1D("hDataMetm","",NBINS,0,METMAX); hDataMetm->Sumw2(); TH1D *hDataMetp = new TH1D("hDataMetp","",NBINS,0,METMAX); hDataMetp->Sumw2(); TH1D *hWenuMet = new TH1D("hWenuMet", "",NBINS,0,METMAX); hWenuMet->Sumw2(); TH1D *hWenuMetp = new TH1D("hWenuMetp","",NBINS,0,METMAX); hWenuMetp->Sumw2(); TH1D *hWenuMetm = new TH1D("hWenuMetm","",NBINS,0,METMAX); hWenuMetm->Sumw2(); TH1D *hEWKMet = new TH1D("hEWKMet", "",NBINS,0,METMAX); hEWKMet->Sumw2(); TH1D *hEWKMetp = new TH1D("hEWKMetp", "",NBINS,0,METMAX); hEWKMetp->Sumw2(); TH1D *hEWKMetm = new TH1D("hEWKMetm", "",NBINS,0,METMAX); hEWKMetm->Sumw2(); // // Declare variables to read in ntuple // UInt_t runNum, lumiSec, evtNum; UInt_t npv, npu; Float_t genWPt, genWPhi; Float_t scale1fb; Float_t met, metPhi, sumEt, mt, u1, u2; Int_t q; LorentzVector *lep=0; LorentzVector *sc=0; TFile *infile=0; TTree *intree=0; // // Loop over files // for(UInt_t ifile=0; ifile<fnamev.size(); ifile++) { // Read input file and get the TTrees cout << "Processing " << fnamev[ifile] << "..." << endl; infile = new TFile(fnamev[ifile]); assert(infile); intree = (TTree*)infile->Get("Events"); assert(intree); intree->SetBranchAddress("runNum", &runNum); // event run number intree->SetBranchAddress("lumiSec", &lumiSec); // event lumi section intree->SetBranchAddress("evtNum", &evtNum); // event number intree->SetBranchAddress("npv", &npv); // number of primary vertices intree->SetBranchAddress("npu", &npu); // number of in-time PU events (MC) intree->SetBranchAddress("genVPt", &genWPt); // GEN W boson pT (signal MC) intree->SetBranchAddress("genVPhi", &genWPhi); // GEN W boson phi (signal MC) intree->SetBranchAddress("scale1fb", &scale1fb); // event weight per 1/fb (MC) intree->SetBranchAddress("met", &met); // MET intree->SetBranchAddress("metPhi", &metPhi); // phi(MET) intree->SetBranchAddress("sumEt", &sumEt); // Sum ET intree->SetBranchAddress("mt", &mt); // transverse mass intree->SetBranchAddress("u1", &u1); // parallel component of recoil intree->SetBranchAddress("u2", &u2); // perpendicular component of recoil intree->SetBranchAddress("q", &q); // lepton charge intree->SetBranchAddress("lep", &lep); // lepton 4-vector intree->SetBranchAddress("sc", &sc); // electron Supercluster 4-vector // // loop over events // for(UInt_t ientry=0; ientry<intree->GetEntries(); ientry++) { intree->GetEntry(ientry); if(mt< 40) continue; // LUCA ADD TLorentzVector muPosP, muNegP, JpsiP; muPosP.SetPtEtaPhiM(lep->Pt(),lep->Eta(),lep->Phi(),lep->M()); // always use the muon muNegP.SetPtEtaPhiM(met,0,metPhi,0); // always use the neutrino JpsiP = muPosP + muNegP; // if(JpsiP.Pt() < 15 // || JpsiP.Pt() > 25 ) continue; if(sc->Pt() < PT_CUT) continue; if(fabs(sc->Eta()) > ETA_CUT) continue; if(typev[ifile]==eData) { hDataMet->Fill(met); if(q>0) { hDataMetp->Fill(met); } else { hDataMetm->Fill(met); } } else { Double_t weight = 1; weight *= scale1fb*lumi; if(puWeights) weight *= puWeights->GetBinContent(npu+1); if(typev[ifile]==eWenu) { Double_t corrMet=met, corrMetPhi=metPhi; // apply recoil corrections to W MC //recoilCorr.Correct(corrMet,corrMetPhi,genWPt,genWPhi,lep->Pt(),lep->Phi()); hWenuMet->Fill(corrMet,weight); if(q>0) { hWenuMetp->Fill(corrMet,weight); } else { hWenuMetm->Fill(corrMet,weight); } } if(typev[ifile]==eEWK) { hEWKMet->Fill(met,weight); if(q>0) { hEWKMetp->Fill(met,weight); } else { hEWKMetm->Fill(met,weight); } } } } } delete infile; infile=0, intree=0; // // Declare fit parameters for signal and background yields // Note: W signal and EWK+top PDFs are constrained to the ratio described in MC // RooRealVar nSig("nSig","nSig",0.7*(hDataMet->Integral()),0,hDataMet->Integral()); RooRealVar nQCD("nQCD","nQCD",0.3*(hDataMet->Integral()),0,hDataMet->Integral()); RooRealVar cewk("cewk","cewk",0.1,0,5) ; cewk.setVal(hEWKMet->Integral()/hWenuMet->Integral()); cewk.setConstant(kTRUE); RooFormulaVar nEWK("nEWK","nEWK","cewk*nSig",RooArgList(nSig,cewk)); RooRealVar nSigp("nSigp","nSigp",0.7*(hDataMetp->Integral()),0,hDataMetp->Integral()); RooRealVar nQCDp("nQCDp","nQCDp",0.3*(hDataMetp->Integral()),0,hDataMetp->Integral()); RooRealVar cewkp("cewkp","cewkp",0.1,0,5) ; cewkp.setVal(hEWKMetp->Integral()/hWenuMetp->Integral()); cewkp.setConstant(kTRUE); RooFormulaVar nEWKp("nEWKp","nEWKp","cewkp*nSigp",RooArgList(nSigp,cewkp)); RooRealVar nSigm("nSigm","nSigm",0.7*(hDataMetm->Integral()),0,hDataMetm->Integral()); RooRealVar nQCDm("nQCDm","nQCDm",0.3*(hDataMetm->Integral()),0,hDataMetm->Integral()); RooRealVar cewkm("cewkm","cewkm",0.1,0,5) ; cewkm.setVal(hEWKMetm->Integral()/hWenuMetm->Integral()); cewkm.setConstant(kTRUE); RooFormulaVar nEWKm("nEWKm","nEWKm","cewkm*nSigm",RooArgList(nSigm,cewkm)); // // Construct PDFs for fitting // RooRealVar pfmet("pfmet","pfmet",0,METMAX); pfmet.setBins(NBINS); // Signal PDFs RooDataHist wenuMet ("wenuMET", "wenuMET", RooArgSet(pfmet),hWenuMet); RooHistPdf pdfWe ("we", "we", pfmet,wenuMet, 1); RooDataHist wenuMetp("wenuMETp","wenuMETp",RooArgSet(pfmet),hWenuMetp); RooHistPdf pdfWep("wep","wep",pfmet,wenuMetp,1); RooDataHist wenuMetm("wenuMETm","wenuMETm",RooArgSet(pfmet),hWenuMetm); RooHistPdf pdfWem("wem","wem",pfmet,wenuMetm,1); // EWK+top PDFs RooDataHist ewkMet ("ewkMET", "ewkMET", RooArgSet(pfmet),hEWKMet); RooHistPdf pdfEWK ("ewk", "ewk", pfmet,ewkMet, 1); RooDataHist ewkMetp("ewkMETp","ewkMETp",RooArgSet(pfmet),hEWKMetp); RooHistPdf pdfEWKp("ewkp","ewkp",pfmet,ewkMetp,1); RooDataHist ewkMetm("ewkMETm","ewkMETm",RooArgSet(pfmet),hEWKMetm); RooHistPdf pdfEWKm("ewkm","ewkm",pfmet,ewkMetm,1); // QCD Pdfs CPepeModel1 qcd("qcd",pfmet); CPepeModel1 qcdp("qcdp",pfmet); CPepeModel1 qcdm("qcdm",pfmet); // Signal + Background PDFs RooAddPdf pdfMet ("pdfMet", "pdfMet", RooArgList(pdfWe,pdfEWK,*(qcd.model)), RooArgList(nSig,nEWK,nQCD)); RooAddPdf pdfMetp("pdfMetp","pdfMetp",RooArgList(pdfWep,pdfEWKp,*(qcdp.model)),RooArgList(nSigp,nEWKp,nQCDp)); RooAddPdf pdfMetm("pdfMetm","pdfMetm",RooArgList(pdfWem,pdfEWKm,*(qcdm.model)),RooArgList(nSigm,nEWKm,nQCDm)); // // Perform fits // RooDataHist dataMet("dataMet", "dataMet", RooArgSet(pfmet),hDataMet); RooFitResult *fitRes = pdfMet.fitTo(dataMet,Extended(),Minos(kTRUE),Save(kTRUE)); RooDataHist dataMetp("dataMetp","dataMetp",RooArgSet(pfmet),hDataMetp); RooFitResult *fitResp = pdfMetp.fitTo(dataMetp,Extended(),Minos(kTRUE),Save(kTRUE)); RooDataHist dataMetm("dataMetm","dataMetm",RooArgSet(pfmet),hDataMetm); RooFitResult *fitResm = pdfMetm.fitTo(dataMetm,Extended(),Minos(kTRUE),Save(kTRUE)); // // Use histogram version of fitted PDFs to make ratio plots // (Will also use PDF histograms later for Chi^2 and KS tests) // TH1D *hPdfMet = (TH1D*)(pdfMet.createHistogram("hPdfMet", pfmet)); hPdfMet->Scale((nSig.getVal()+nEWK.getVal()+nQCD.getVal())/hPdfMet->Integral()); TH1D *hMetDiff = makeDiffHist(hDataMet,hPdfMet,"hMetDiff"); hMetDiff->SetMarkerStyle(kFullCircle); hMetDiff->SetMarkerSize(0.9); TH1D *hPdfMetp = (TH1D*)(pdfMetp.createHistogram("hPdfMetp", pfmet)); hPdfMetp->Scale((nSigp.getVal()+nEWKp.getVal()+nQCDp.getVal())/hPdfMetp->Integral()); TH1D *hMetpDiff = makeDiffHist(hDataMetp,hPdfMetp,"hMetpDiff"); hMetpDiff->SetMarkerStyle(kFullCircle); hMetpDiff->SetMarkerSize(0.9); TH1D *hPdfMetm = (TH1D*)(pdfMetm.createHistogram("hPdfMetm", pfmet)); hPdfMetm->Scale((nSigm.getVal()+nEWKm.getVal()+nQCDm.getVal())/hPdfMetm->Integral()); TH1D *hMetmDiff = makeDiffHist(hDataMetm,hPdfMetm,"hMetmDiff"); hMetmDiff->SetMarkerStyle(kFullCircle); hMetmDiff->SetMarkerSize(0.9); //-------------------------------------------------------------------------------------------------------------- // Make plots //============================================================================================================== TCanvas *c = MakeCanvas("c","c",800,800); c->Divide(1,2,0,0); c->cd(1)->SetPad(0,0.3,1.0,1.0); c->cd(1)->SetTopMargin(0.1); c->cd(1)->SetBottomMargin(0.01); c->cd(1)->SetLeftMargin(0.18); c->cd(1)->SetRightMargin(0.07); c->cd(1)->SetTickx(1); c->cd(1)->SetTicky(1); c->cd(2)->SetPad(0,0,1.0,0.3); c->cd(2)->SetTopMargin(0.05); c->cd(2)->SetBottomMargin(0.45); c->cd(2)->SetLeftMargin(0.18); c->cd(2)->SetRightMargin(0.07); c->cd(2)->SetTickx(1); c->cd(2)->SetTicky(1); gStyle->SetTitleOffset(1.400,"Y"); char ylabel[100]; // string buffer for y-axis label // label for lumi char lumitext[100]; if(lumi<0.1) sprintf(lumitext,"%.1f pb^{-1} at #sqrt{s} = %i TeV",lumi*1000.,Ecm); else sprintf(lumitext,"%.2f fb^{-1} at #sqrt{s} = %i TeV",lumi,Ecm); // plot colors Int_t linecolorW = kOrange-3; Int_t fillcolorW = kOrange-2; Int_t linecolorEWK = kOrange+10; Int_t fillcolorEWK = kOrange+7; Int_t linecolorQCD = kViolet+2; Int_t fillcolorQCD = kViolet-5; Int_t ratioColor = kGray+2; // // Dummy histograms for TLegend // (I can't figure out how to properly pass RooFit objects...) // TH1D *hDummyData = new TH1D("hDummyData","",0,0,10); hDummyData->SetMarkerStyle(kFullCircle); hDummyData->SetMarkerSize(0.9); TH1D *hDummyW = new TH1D("hDummyW","",0,0,10); hDummyW->SetLineColor(linecolorW); hDummyW->SetFillColor(fillcolorW); hDummyW->SetFillStyle(1001); TH1D *hDummyEWK = new TH1D("hDummyEWK","",0,0,10); hDummyEWK->SetLineColor(linecolorEWK); hDummyEWK->SetFillColor(fillcolorEWK); hDummyEWK->SetFillStyle(1001); TH1D *hDummyQCD = new TH1D("hDummyQCD","",0,0,10); hDummyQCD->SetLineColor(linecolorQCD); hDummyQCD->SetFillColor(fillcolorQCD); hDummyQCD->SetFillStyle(1001); // // W MET plot // RooPlot *weframe = pfmet.frame(Bins(NBINS)); dataMet.plotOn(weframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP")); pdfMet.plotOn(weframe,FillColor(fillcolorW),DrawOption("F")); pdfMet.plotOn(weframe,LineColor(linecolorW)); pdfMet.plotOn(weframe,Components(RooArgSet(pdfEWK,*(qcd.model))),FillColor(fillcolorEWK),DrawOption("F")); pdfMet.plotOn(weframe,Components(RooArgSet(pdfEWK,*(qcd.model))),LineColor(linecolorEWK)); pdfMet.plotOn(weframe,Components(RooArgSet(*(qcd.model))),FillColor(fillcolorQCD),DrawOption("F")); pdfMet.plotOn(weframe,Components(RooArgSet(*(qcd.model))),LineColor(linecolorQCD)); pdfMet.plotOn(weframe,Components(RooArgSet(pdfWe)),LineColor(linecolorW),LineStyle(2)); dataMet.plotOn(weframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP")); sprintf(ylabel,"Events / %.1f GeV",hDataMet->GetBinWidth(1)); CPlot plotMet("fitmet",weframe,"","",ylabel); plotMet.SetLegend(0.68,0.57,0.93,0.77); plotMet.GetLegend()->AddEntry(hDummyData,"data","PL"); plotMet.GetLegend()->AddEntry(hDummyW,"W#rightarrowe#nu","F"); plotMet.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F"); plotMet.GetLegend()->AddEntry(hDummyQCD,"QCD","F"); plotMet.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0); plotMet.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0); plotMet.SetYRange(0.1,1.1*(hDataMet->GetMaximum())); // plotMet.Draw(c,kFALSE,format,1); plotMet.Draw(c,kTRUE,format,1); CPlot plotMetDiff("fitmet","","#slash{E}_{T} [GeV]","#chi"); plotMetDiff.AddHist1D(hMetDiff,"EX0",ratioColor); plotMetDiff.SetYRange(-8,8); plotMetDiff.AddLine(0, 0,METMAX, 0,kBlack,1); plotMetDiff.AddLine(0, 5,METMAX, 5,kBlack,3); plotMetDiff.AddLine(0,-5,METMAX,-5,kBlack,3); plotMetDiff.Draw(c,kTRUE,format,2); plotMet.SetName("fitmetlog"); plotMet.SetLogy(); plotMet.SetYRange(1e-3*(hDataMet->GetMaximum()),10*(hDataMet->GetMaximum())); plotMet.Draw(c,kTRUE,format,1); // // W+ MET plot // RooPlot *wepframe = pfmet.frame(Bins(NBINS)); dataMetp.plotOn(wepframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP")); pdfMetp.plotOn(wepframe,FillColor(fillcolorW),DrawOption("F")); pdfMetp.plotOn(wepframe,LineColor(linecolorW)); pdfMetp.plotOn(wepframe,Components(RooArgSet(pdfEWKp,*(qcdp.model))),FillColor(fillcolorEWK),DrawOption("F")); pdfMetp.plotOn(wepframe,Components(RooArgSet(pdfEWKp,*(qcdp.model))),LineColor(linecolorEWK)); pdfMetp.plotOn(wepframe,Components(RooArgSet(*(qcdp.model))),FillColor(fillcolorQCD),DrawOption("F")); pdfMetp.plotOn(wepframe,Components(RooArgSet(*(qcdp.model))),LineColor(linecolorQCD)); pdfMetp.plotOn(wepframe,Components(RooArgSet(pdfWep)),LineColor(linecolorW),LineStyle(2)); dataMetp.plotOn(wepframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP")); sprintf(ylabel,"Events / %.1f GeV",hDataMetp->GetBinWidth(1)); CPlot plotMetp("fitmetp",wepframe,"","",ylabel); plotMetp.SetLegend(0.68,0.57,0.93,0.77); plotMetp.GetLegend()->AddEntry(hDummyData,"data","PL"); plotMetp.GetLegend()->AddEntry(hDummyW,"W^{+}#rightarrowe^{+}#nu","F"); plotMetp.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F"); plotMetp.GetLegend()->AddEntry(hDummyQCD,"QCD","F"); plotMetp.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0); plotMetp.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0); plotMetp.SetYRange(0.1,1.1*(hDataMetp->GetMaximum())); plotMetp.Draw(c,kFALSE,format,1); CPlot plotMetpDiff("fitmetp","","#slash{E}_{T} [GeV]","#chi"); plotMetpDiff.AddHist1D(hMetpDiff,"EX0",ratioColor); plotMetpDiff.SetYRange(-8,8); plotMetpDiff.AddLine(0, 0,METMAX, 0,kBlack,1); plotMetpDiff.AddLine(0, 5,METMAX, 5,kBlack,3); plotMetpDiff.AddLine(0,-5,METMAX,-5,kBlack,3); plotMetpDiff.Draw(c,kTRUE,format,2); plotMetp.SetName("fitmetplog"); plotMetp.SetLogy(); plotMetp.SetYRange(1e-3*(hDataMetp->GetMaximum()),10*(hDataMetp->GetMaximum())); plotMetp.Draw(c,kTRUE,format,1); // // W- MET plot // RooPlot *wemframe = pfmet.frame(Bins(NBINS)); dataMetm.plotOn(wemframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP")); pdfMetm.plotOn(wemframe,FillColor(fillcolorW),DrawOption("F")); pdfMetm.plotOn(wemframe,LineColor(linecolorW)); pdfMetm.plotOn(wemframe,Components(RooArgSet(pdfEWKm,*(qcdm.model))),FillColor(fillcolorEWK),DrawOption("F")); pdfMetm.plotOn(wemframe,Components(RooArgSet(pdfEWKm,*(qcdm.model))),LineColor(linecolorEWK)); pdfMetm.plotOn(wemframe,Components(RooArgSet(*(qcdm.model))),FillColor(fillcolorQCD),DrawOption("F")); pdfMetm.plotOn(wemframe,Components(RooArgSet(*(qcdm.model))),LineColor(linecolorQCD)); pdfMetm.plotOn(wemframe,Components(RooArgSet(pdfWem)),LineColor(linecolorW),LineStyle(2)); dataMetm.plotOn(wemframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP")); sprintf(ylabel,"Events / %.1f GeV",hDataMetm->GetBinWidth(1)); CPlot plotMetm("fitmetm",wemframe,"","",ylabel); plotMetm.SetLegend(0.68,0.57,0.93,0.77); plotMetm.GetLegend()->AddEntry(hDummyData,"data","PL"); plotMetm.GetLegend()->AddEntry(hDummyW,"W^{-}#rightarrowe^{-}#bar{#nu}","F"); plotMetm.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F"); plotMetm.GetLegend()->AddEntry(hDummyQCD,"QCD","F"); plotMetm.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0); plotMetm.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0); plotMetm.SetYRange(0.1,1.1*(hDataMetm->GetMaximum())); plotMetm.Draw(c,kFALSE,format,1); CPlot plotMetmDiff("fitmetm","","#slash{E}_{T} [GeV]","#chi"); plotMetmDiff.AddHist1D(hMetmDiff,"EX0",ratioColor); plotMetmDiff.SetYRange(-8,8); plotMetmDiff.AddLine(0, 0,METMAX, 0,kBlack,1); plotMetmDiff.AddLine(0, 5,METMAX, 5,kBlack,3); plotMetmDiff.AddLine(0,-5,METMAX,-5,kBlack,3); plotMetmDiff.Draw(c,kTRUE,format,2); plotMetm.SetName("fitmetmlog"); plotMetm.SetLogy(); plotMetm.SetYRange(1e-3*(hDataMetm->GetMaximum()),10*(hDataMetm->GetMaximum())); plotMetm.Draw(c,kTRUE,format,1); //-------------------------------------------------------------------------------------------------------------- // Output //============================================================================================================== cout << "*" << endl; cout << "* SUMMARY" << endl; cout << "*--------------------------------------------------" << endl; // // Write fit results // ofstream txtfile; char txtfname[100]; ios_base::fmtflags flags; Double_t chi2prob, chi2ndf; Double_t ksprob, ksprobpe; chi2prob = hDataMet->Chi2Test(hPdfMet,"PUW"); chi2ndf = hDataMet->Chi2Test(hPdfMet,"CHI2/NDFUW"); ksprob = hDataMet->KolmogorovTest(hPdfMet); ksprobpe = hDataMet->KolmogorovTest(hPdfMet,"DX"); sprintf(txtfname,"%s/fitresWe.txt",CPlot::sOutDir.Data()); txtfile.open(txtfname); assert(txtfile.is_open()); flags = txtfile.flags(); txtfile << setprecision(10); txtfile << " *** Yields *** " << endl; txtfile << "Selected: " << hDataMet->Integral() << endl; txtfile << " Signal: " << nSig.getVal() << " +/- " << nSig.getPropagatedError(*fitRes) << endl; txtfile << " QCD: " << nQCD.getVal() << " +/- " << nQCD.getPropagatedError(*fitRes) << endl; txtfile << " Other: " << nEWK.getVal() << " +/- " << nEWK.getPropagatedError(*fitRes) << endl; txtfile << endl; txtfile.flags(flags); fitRes->printStream(txtfile,RooPrintable::kValue,RooPrintable::kVerbose); txtfile << endl; printCorrelations(txtfile, fitRes); txtfile << endl; printChi2AndKSResults(txtfile, chi2prob, chi2ndf, ksprob, ksprobpe); txtfile.close(); chi2prob = hDataMetp->Chi2Test(hPdfMetp,"PUW"); chi2ndf = hDataMetp->Chi2Test(hPdfMetp,"CHI2/NDFUW"); ksprob = hDataMetp->KolmogorovTest(hPdfMetp); ksprobpe = hDataMetp->KolmogorovTest(hPdfMetp,"DX"); sprintf(txtfname,"%s/fitresWep.txt",CPlot::sOutDir.Data()); txtfile.open(txtfname); assert(txtfile.is_open()); flags = txtfile.flags(); txtfile << setprecision(10); txtfile << " *** Yields *** " << endl; txtfile << "Selected: " << hDataMetp->Integral() << endl; txtfile << " Signal: " << nSigp.getVal() << " +/- " << nSigp.getPropagatedError(*fitResp) << endl; txtfile << " QCD: " << nQCDp.getVal() << " +/- " << nQCDp.getPropagatedError(*fitResp) << endl; txtfile << " Other: " << nEWKp.getVal() << " +/- " << nEWKp.getPropagatedError(*fitResp) << endl; txtfile << endl; txtfile.flags(flags); fitResp->printStream(txtfile,RooPrintable::kValue,RooPrintable::kVerbose); txtfile << endl; printCorrelations(txtfile, fitResp); txtfile << endl; printChi2AndKSResults(txtfile, chi2prob, chi2ndf, ksprob, ksprobpe); txtfile.close(); chi2prob = hDataMetm->Chi2Test(hPdfMetm,"PUW"); chi2ndf = hDataMetm->Chi2Test(hPdfMetm,"CHI2/NDFUW"); ksprob = hDataMetm->KolmogorovTest(hPdfMetm); ksprobpe = hDataMetm->KolmogorovTest(hPdfMetm,"DX"); sprintf(txtfname,"%s/fitresWem.txt",CPlot::sOutDir.Data()); txtfile.open(txtfname); assert(txtfile.is_open()); flags = txtfile.flags(); txtfile << setprecision(10); txtfile << " *** Yields *** " << endl; txtfile << "Selected: " << hDataMetm->Integral() << endl; txtfile << " Signal: " << nSigm.getVal() << " +/- " << nSigm.getPropagatedError(*fitResm) << endl; txtfile << " QCD: " << nQCDm.getVal() << " +/- " << nQCDm.getPropagatedError(*fitResm) << endl; txtfile << " Other: " << nEWKm.getVal() << " +/- " << nEWKm.getPropagatedError(*fitResm) << endl; txtfile << endl; txtfile.flags(flags); fitResm->printStream(txtfile,RooPrintable::kValue,RooPrintable::kVerbose); txtfile << endl; printCorrelations(txtfile, fitResm); txtfile << endl; printChi2AndKSResults(txtfile, chi2prob, chi2ndf, ksprob, ksprobpe); txtfile.close(); makeHTML(outputDir); cout << endl; cout << " <> Output saved in " << outputDir << "/" << endl; cout << endl; gBenchmark->Show("fitWe"); }
void fit2015( TString FileName ="/afs/cern.ch/user/a/anstahll/work/public/ExpressStream2015/ppData/OniaTree_262163_262328.root", int oniamode = 2, // oniamode-> 3: Z, 2: Upsilon and 1: J/Psi bool isData = true, // isData = false for MC, true for Data bool isPbPb = false, // isPbPb = false for pp, true for PbPb bool doFit = false , bool inExcStat = true // if inExcStat is true, then the excited states are fitted ) { InputOpt opt; SetOptions(&opt, isData, isPbPb, oniamode,inExcStat); if (isPbPb) { FileName = "/afs/cern.ch/user/a/anstahll/work/public/ExpressStream2015/PbPbData/OniaTree_262548_262893.root"; } else { FileName = "/afs/cern.ch/user/a/anstahll/work/public/ExpressStream2015/ppData/OniaTree_262163_262328.root"; } int nbins = 1; //ceil((opt.dMuon->M->Max - opt.dMuon->M->Min)/binw); if (oniamode==1){ nbins = 140; } else if (oniamode==2) { nbins = 70; } else if (oniamode==3) { nbins = 40; } RooWorkspace myws; TH1F* hDataOS = new TH1F("hDataOS","hDataOS", nbins, opt.dMuon.M.Min, opt.dMuon.M.Max); makeWorkspace2015(myws, FileName, opt, hDataOS); RooRealVar* mass = (RooRealVar*) myws.var("invariantMass"); RooDataSet* dataOS_fit = (RooDataSet*) myws.data("dataOS"); RooDataSet* dataSS_fit = (RooDataSet*) myws.data("dataSS"); RooAbsPdf* pdf = NULL; if (oniamode==3) { doFit=false; } if (doFit) { int sigModel=0, bkgModel=0; if (isData) { if (oniamode==1){ sigModel = inExcStat ? 2 : 3; bkgModel = 1; } else { sigModel = inExcStat ? 1 : 3; // gaussian bkgModel = 2; } } else { if (oniamode==1){ sigModel = inExcStat ? 2 : 3; // gaussian bkgModel = 2; } else { sigModel = inExcStat ? 2 : 3; // gaussian bkgModel = 3; } } if (opt.oniaMode==1) buildModelJpsi2015(myws, sigModel, bkgModel,inExcStat); else if (opt.oniaMode==2) buildModelUpsi2015(myws, sigModel, bkgModel,inExcStat); pdf =(RooAbsPdf*) myws.pdf("pdf"); RooFitResult* fitObject = pdf->fitTo(*dataOS_fit,Save(),Hesse(kTRUE),Extended(kTRUE)); // Fit } RooPlot* frame = mass->frame(Bins(nbins),Range(opt.dMuon.M.Min, opt.dMuon.M.Max)); RooPlot* frame2 = NULL; dataSS_fit->plotOn(frame, Name("dataSS_FIT"), MarkerColor(kRed), LineColor(kRed), MarkerSize(1.2)); dataOS_fit->plotOn(frame, Name("dataOS_FIT"), MarkerColor(kBlue), LineColor(kBlue), MarkerSize(1.2)); if (doFit) { pdf->plotOn(frame,Name("thePdf"),Normalization(dataOS_fit->sumEntries(),RooAbsReal::NumEvent)); RooHist *hpull = frame -> pullHist(0,0,true); hpull -> SetName("hpull"); frame2 = mass->frame(Title("Pull Distribution"),Bins(nbins),Range(opt.dMuon.M.Min,opt.dMuon.M.Max)); frame2 -> addPlotable(hpull,"PX"); } drawPlot(frame,frame2, pdf, opt, doFit,inExcStat); TString OutputFileName = ""; if (isPbPb) { FileName = "/afs/cern.ch/user/a/anstahll/work/public/ExpressStream2015/PbPbData/OniaTree_262548_262893.root"; opt.RunNb.Start=262548; opt.RunNb.End=262893; if (oniamode==1) {OutputFileName = (TString)("JPSIPbPbDataset.root");} if (oniamode==2) {OutputFileName = (TString)("YPbPbDataset.root");} if (oniamode==3) {OutputFileName = (TString)("ZPbPbDataset.root");} } else { FileName = "/afs/cern.ch/user/a/anstahll/work/public/ExpressStream2015/ppData/OniaTree_262163_262328.root"; opt.RunNb.Start=262163; opt.RunNb.End=262328; if (oniamode==1) {OutputFileName = (TString)("JPSIppDataset.root");} if (oniamode==2) {OutputFileName = (TString)("YppDataset.root");} if (oniamode==3) {OutputFileName = (TString)("ZppDataset.root");} } TFile* oFile = new TFile(OutputFileName,"RECREATE"); oFile->cd(); hDataOS->Write("hDataOS"); dataOS_fit->Write("dataOS_FIT"); oFile->Write(); oFile->Close(); }
bool fitCharmoniaMassModel( RooWorkspace& myws, // Local Workspace const RooWorkspace& inputWorkspace, // Workspace with all the input RooDatasets struct KinCuts& cut, // Variable containing all kinematic cuts map<string, string>& parIni, // Variable containing all initial parameters struct InputOpt& opt, // Variable with run information (kept for legacy purpose) string outputDir, // Path to output directory // Select the type of datasets to fit string DSTAG, // Specifies the type of datasets: i.e, DATA, MCJPSINP, ... bool isPbPb = false, // isPbPb = false for pp, true for PbPb bool importDS = true, // Select if the dataset is imported in the local workspace // Select the type of object to fit bool incJpsi = true, // Includes Jpsi model bool incPsi2S = true, // Includes Psi(2S) model bool incBkg = true, // Includes Background model // Select the fitting options bool doFit = true, // Flag to indicate if we want to perform the fit bool cutCtau = false, // Apply prompt ctau cuts bool doConstrFit = false, // Do constrained fit bool doSimulFit = false, // Do simultaneous fit bool wantPureSMC = false, // Flag to indicate if we want to fit pure signal MC const char* applyCorr ="", // Flag to indicate if we want corrected dataset and which correction uint loadFitResult = false, // Load previous fit results string inputFitDir = "", // Location of the fit results int numCores = 2, // Number of cores used for fitting // Select the drawing options bool setLogScale = true, // Draw plot with log scale bool incSS = false, // Include Same Sign data bool zoomPsi = false, // Zoom Psi(2S) peak on extra pad double binWidth = 0.05, // Bin width used for plotting bool getMeanPT = false // Compute the mean PT (NEED TO FIX) ) { if (DSTAG.find("_")!=std::string::npos) DSTAG.erase(DSTAG.find("_")); // Check if input dataset is MC bool isMC = false; if (DSTAG.find("MC")!=std::string::npos) { if (incJpsi && incPsi2S) { cout << "[ERROR] We can only fit one type of signal using MC" << endl; return false; } isMC = true; } wantPureSMC = (isMC && wantPureSMC); bool cutSideBand = (incBkg && (!incPsi2S && !incJpsi)); bool applyWeight_Corr = ( strcmp(applyCorr,"") ); // Define the mass range setMassCutParameters(cut, incJpsi, incPsi2S, isMC); parIni["invMassNorm"] = Form("RooFormulaVar::%s('( -1.0 + 2.0*( @0 - @1 )/( @2 - @1) )', {%s, mMin[%.6f], mMax[%.6f]})", "invMassNorm", "invMass", cut.dMuon.M.Min, cut.dMuon.M.Max ); // Apply the ctau cuts to reject non-prompt charmonia if (cutCtau) { setCtauCuts(cut, isPbPb); } string COLL = (isPbPb ? "PbPb" : "PP" ); string plotLabelPbPb, plotLabelPP; if (doSimulFit || !isPbPb) { // Set models based on initial parameters struct OniaModel model; if (!setMassModel(model, parIni, false, incJpsi, incPsi2S, incBkg)) { return false; } // Import the local datasets double numEntries = 1000000; string label = ((DSTAG.find("PP")!=std::string::npos) ? DSTAG.c_str() : Form("%s_%s", DSTAG.c_str(), "PP")); if (wantPureSMC) label += "_NoBkg"; if (applyWeight_Corr) label += Form("_%s",applyCorr); string dsName = Form("dOS_%s", label.c_str()); if (importDS) { if ( !(myws.data(dsName.c_str())) ) { int importID = importDataset(myws, inputWorkspace, cut, label, cutSideBand); if (importID<0) { return false; } else if (importID==0) { doFit = false; } } numEntries = myws.data(dsName.c_str())->sumEntries(); if (numEntries<=0) { doFit = false; } } else if (doFit && !(myws.data(dsName.c_str()))) { cout << "[ERROR] No local dataset was found to perform the fit!" << endl; return false; } if (myws.data(dsName.c_str())) numEntries = myws.data(dsName.c_str())->sumEntries(); // Set global parameters setMassGlobalParameterRange(myws, parIni, cut, incJpsi, incPsi2S, incBkg, wantPureSMC); // Build the Fit Model if (!buildCharmoniaMassModel(myws, model.PP, parIni, false, doConstrFit, doSimulFit, incBkg, incJpsi, incPsi2S, numEntries)) { return false; } // Define plot names if (incJpsi) { plotLabelPP += Form("_Jpsi_%s", parIni["Model_Jpsi_PP"].c_str()); } if (incPsi2S) { plotLabelPP += Form("_Psi2S_%s", parIni["Model_Psi2S_PP"].c_str()); } if (incBkg) { plotLabelPP += Form("_Bkg_%s", parIni["Model_Bkg_PP"].c_str()); } if (wantPureSMC) plotLabelPP +="_NoBkg"; if (applyWeight_Corr) plotLabelPP +=Form("_%s",applyCorr); } if (doSimulFit || isPbPb) { // Set models based on initial parameters struct OniaModel model; if (!setMassModel(model, parIni, true, incJpsi, incPsi2S, incBkg)) { return false; } // Import the local datasets double numEntries = 1000000; string label = ((DSTAG.find("PbPb")!=std::string::npos) ? DSTAG.c_str() : Form("%s_%s", DSTAG.c_str(), "PbPb")); if (wantPureSMC) label += "_NoBkg"; if (applyWeight_Corr) label += Form("_%s",applyCorr); string dsName = Form("dOS_%s", label.c_str()); if (importDS) { if ( !(myws.data(dsName.c_str())) ) { int importID = importDataset(myws, inputWorkspace, cut, label, cutSideBand); if (importID<0) { return false; } else if (importID==0) { doFit = false; } } numEntries = myws.data(dsName.c_str())->sumEntries(); if (numEntries<=0) { doFit = false; } } else if (doFit && !(myws.data(dsName.c_str()))) { cout << "[ERROR] No local dataset was found to perform the fit!" << endl; return false; } if (myws.data(dsName.c_str())) numEntries = myws.data(dsName.c_str())->sumEntries(); // Set global parameters setMassGlobalParameterRange(myws, parIni, cut, incJpsi, incPsi2S, incBkg, wantPureSMC); // Build the Fit Model if (!buildCharmoniaMassModel(myws, model.PbPb, parIni, true, doConstrFit, doSimulFit, incBkg, incJpsi, incPsi2S, numEntries)) { return false; } // Define plot names if (incJpsi) { plotLabelPbPb += Form("_Jpsi_%s", parIni["Model_Jpsi_PbPb"].c_str()); } if (incPsi2S) { plotLabelPbPb += Form("_Psi2S_%s", parIni["Model_Psi2S_PbPb"].c_str()); } if (incBkg) { plotLabelPbPb += Form("_Bkg_%s", parIni["Model_Bkg_PbPb"].c_str()); } if (wantPureSMC) plotLabelPbPb += "_NoBkg"; if (applyWeight_Corr) plotLabelPbPb += Form("_%s",applyCorr); } if (doSimulFit) { // Create the combided datasets RooCategory* sample = new RooCategory("sample","sample"); sample->defineType("PbPb"); sample->defineType("PP"); RooDataSet* combData = new RooDataSet("combData","combined data", *myws.var("invMass"), Index(*sample), Import("PbPb", *((RooDataSet*)myws.data("dOS_DATA_PbPb"))), Import("PP", *((RooDataSet*)myws.data("dOS_DATA_PP"))) ); myws.import(*sample); // Create the combided models RooSimultaneous* simPdf = new RooSimultaneous("simPdf", "simultaneous pdf", *sample); simPdf->addPdf(*myws.pdf("pdfMASS_Tot_PbPb"), "PbPb"); simPdf->addPdf(*myws.pdf("pdfMASS_Tot_PP"), "PP"); myws.import(*simPdf); // check if we have already done this fit. If yes, do nothing and return true. string FileName = ""; setMassFileName(FileName, (inputFitDir=="" ? outputDir : inputFitDir), DSTAG, (plotLabelPP + plotLabelPbPb), cut, isPbPb, cutSideBand, doSimulFit); if (gSystem->AccessPathName(FileName.c_str()) && inputFitDir!="") { cout << "[WARNING] User Input File : " << FileName << " was not found!" << endl; if (loadFitResult) return false; setMassFileName(FileName, outputDir, DSTAG, (plotLabelPP + plotLabelPbPb), cut, isPbPb, cutSideBand, doSimulFit); } bool found = true; bool skipFit = !doFit; RooArgSet *newpars = myws.pdf("simPdf")->getParameters(*(myws.var("invMass"))); myws.saveSnapshot("simPdf_parIni", *newpars, kTRUE); found = found && isFitAlreadyFound(newpars, FileName, "simPdf"); if (loadFitResult) { if ( loadPreviousFitResult(myws, FileName, DSTAG, false, (!isMC && !cutSideBand && loadFitResult==1), loadFitResult==1) ) { skipFit = true; } else { skipFit = false; } if ( loadPreviousFitResult(myws, FileName, DSTAG, true, (!isMC && !cutSideBand && loadFitResult==1), loadFitResult==1) ) { skipFit = true; } else { skipFit = false; } if (skipFit) { cout << "[INFO] This simultaneous mass fit was already done, so I'll load the fit results." << endl; } myws.saveSnapshot("simPdf_parLoad", *newpars, kTRUE); } else if (found) { cout << "[INFO] This simultaneous mass fit was already done, so I'll just go to the next one." << endl; return true; } // Do the simultaneous fit if (skipFit==false) { RooFitResult* fitResult = simPdf->fitTo(*combData, Offset(kTRUE), Extended(kTRUE), NumCPU(numCores), Range("MassWindow"), Save()); //, Minimizer("Minuit2","Migrad") fitResult->Print("v"); myws.import(*fitResult, "fitResult_simPdf"); // Create the output files int nBins = min(int( round((cut.dMuon.M.Max - cut.dMuon.M.Min)/binWidth) ), 1000); drawMassPlot(myws, outputDir, opt, cut, parIni, plotLabelPP, DSTAG, false, incJpsi, incPsi2S, incBkg, cutCtau, doSimulFit, false, setLogScale, incSS, zoomPsi, nBins, getMeanPT); drawMassPlot(myws, outputDir, opt, cut, parIni, plotLabelPbPb, DSTAG, true, incJpsi, incPsi2S, incBkg, cutCtau, doSimulFit, false, setLogScale, incSS, zoomPsi, nBins, getMeanPT); // Save the results string FileName = ""; setMassFileName(FileName, outputDir, DSTAG, (plotLabelPP + plotLabelPbPb), cut, isPbPb, cutSideBand, doSimulFit); myws.saveSnapshot("simPdf_parFit", *newpars, kTRUE); saveWorkSpace(myws, Form("%smass%s/%s/result", outputDir.c_str(), (cutSideBand?"SB":""), DSTAG.c_str()), FileName); // Delete the objects used during the simultaneous fit delete sample; delete combData; delete simPdf; } } else { // Define pdf and plot names string pdfName = Form("pdfMASS_Tot_%s", COLL.c_str()); string plotLabel = (isPbPb ? plotLabelPbPb : plotLabelPP); // Import the local datasets string label = ((DSTAG.find(COLL.c_str())!=std::string::npos) ? DSTAG.c_str() : Form("%s_%s", DSTAG.c_str(), COLL.c_str())); if (wantPureSMC) label += "_NoBkg"; if (applyWeight_Corr) label += Form("_%s",applyCorr); string dsName = Form("dOS_%s", label.c_str()); // check if we have already done this fit. If yes, do nothing and return true. string FileName = ""; setMassFileName(FileName, (inputFitDir=="" ? outputDir : inputFitDir), DSTAG, plotLabel, cut, isPbPb, cutSideBand); if (gSystem->AccessPathName(FileName.c_str()) && inputFitDir!="") { cout << "[WARNING] User Input File : " << FileName << " was not found!" << endl; if (loadFitResult) return false; setMassFileName(FileName, outputDir, DSTAG, plotLabel, cut, isPbPb, cutSideBand); } bool found = true; bool skipFit = !doFit; RooArgSet *newpars = myws.pdf(pdfName.c_str())->getParameters(*(myws.var("invMass"))); found = found && isFitAlreadyFound(newpars, FileName, pdfName.c_str()); if (loadFitResult) { if ( loadPreviousFitResult(myws, FileName, DSTAG, isPbPb, (!isMC && !cutSideBand && loadFitResult==1), loadFitResult==1) ) { skipFit = true; } else { skipFit = false; } if (skipFit) { cout << "[INFO] This mass fit was already done, so I'll load the fit results." << endl; } myws.saveSnapshot(Form("%s_parLoad", pdfName.c_str()), *newpars, kTRUE); } else if (found) { cout << "[INFO] This mass fit was already done, so I'll just go to the next one." << endl; return true; } // Fit the Datasets if (skipFit==false) { bool isWeighted = myws.data(dsName.c_str())->isWeighted(); RooFitResult* fitResult(0x0); if (doConstrFit) { cout << "[INFO] Performing constrained fit" << endl; if (isPbPb) { cout << "[INFO] Constrained variables: alpha, n, ratio of sigmas" << endl; fitResult = myws.pdf(pdfName.c_str())->fitTo(*myws.data(dsName.c_str()), Extended(kTRUE), SumW2Error(isWeighted), Range(cutSideBand ? parIni["BkgMassRange_FULL_Label"].c_str() : "MassWindow"), ExternalConstraints(RooArgSet(*(myws.pdf("sigmaAlphaConstr")),*(myws.pdf("sigmaNConstr")),*(myws.pdf("sigmaRSigmaConstr")))), NumCPU(numCores), Save()); } else { cout << "[INFO] Constrained variables: alpha, n, ratio of sigmas" << endl; fitResult = myws.pdf(pdfName.c_str())->fitTo(*myws.data(dsName.c_str()), Extended(kTRUE), SumW2Error(isWeighted), Range(cutSideBand ? parIni["BkgMassRange_FULL_Label"].c_str() : "MassWindow"), ExternalConstraints(RooArgSet(*(myws.pdf("sigmaAlphaConstr")),*(myws.pdf("sigmaNConstr")))), NumCPU(numCores), Save()); } } else { fitResult = myws.pdf(pdfName.c_str())->fitTo(*myws.data(dsName.c_str()), Extended(kTRUE), SumW2Error(isWeighted), Range(cutSideBand ? parIni["BkgMassRange_FULL_Label"].c_str() : "MassWindow"), NumCPU(numCores), Save()); } fitResult->Print("v"); myws.import(*fitResult, Form("fitResult_%s", pdfName.c_str())); // Create the output files int nBins = min(int( round((cut.dMuon.M.Max - cut.dMuon.M.Min)/binWidth) ), 1000); drawMassPlot(myws, outputDir, opt, cut, parIni, plotLabel, DSTAG, isPbPb, incJpsi, incPsi2S, incBkg, cutCtau, doSimulFit, wantPureSMC, setLogScale, incSS, zoomPsi, nBins, getMeanPT); // Save the results string FileName = ""; setMassFileName(FileName, outputDir, DSTAG, plotLabel, cut, isPbPb, cutSideBand); myws.saveSnapshot(Form("%s_parFit", pdfName.c_str()), *newpars, kTRUE); saveWorkSpace(myws, Form("%smass%s/%s/result", outputDir.c_str(), (cutSideBand?"SB":""), DSTAG.c_str()), FileName); } } return true; };