void reweight_eta_1d(TH1F* weight_eta,TH1F* weight_etao,TH2F*weight_etan,TH2F* weight_eta2o,TH2F* weight_etanr,TH2F*weight_eta2,RooDataSet **dset, RooDataSet *dsetdestination, int numvar){
if (!(*dset)) return;
TH1F *hnum = new TH1F("hnum","hnum",n_etabins_forreweighting,etabins_forreweighting);
TH1F *hden = new TH1F("hden","hden",n_etabins_forreweighting,etabins_forreweighting);
// TH1F *hnum = new TH1F("hnum","hnum",25,0.,2.5);
// TH1F *hden = new TH1F("hden","hden",25,0.,2.5);
hnum->Sumw2();
hden->Sumw2();
const char* etaname=Form("rooeta%d",numvar);
for (int i=0; i<(*dset)->numEntries(); i++){
hden->Fill(fabs((*dset)->get(i)->getRealValue(etaname)),(*dset)->store()->weight(i));
}
for (int i=0; i<dsetdestination->numEntries(); i++){
hnum->Fill(fabs(dsetdestination->get(i)->getRealValue(etaname)),dsetdestination->store()->weight(i));
}
hnum->Scale(1.0/hnum->Integral());
hden->Scale(1.0/hden->Integral());
hnum->Divide(hden);
TH1F *h = hnum;
RooDataSet *newdset = new RooDataSet(**dset,Form("%s_etarew",(*dset)->GetName()));
newdset->reset();
for (int i=0; i<(*dset)->numEntries(); i++){
RooArgSet args = *((*dset)->get(i));
float oldw = (*dset)->store()->weight(i);
float eta = args.getRealValue(etaname);
float neww = oldw*h->GetBinContent(h->FindBin(fabs(eta)));
if(debug){
weight_eta->Fill(neww);
weight_etao->Fill(oldw);
weight_etan->Fill(h->FindBin(fabs(eta)),neww);
weight_eta2o->Fill(h->FindBin(fabs(eta)),oldw);
if(oldw!=0 && neww!=0)weight_etanr->Fill(h->FindBin(fabs(eta)),oldw/neww);
else {weight_etanr->Fill(-10,1);}
// weight_pt2->Fill(pt,neww/oldw);
if(oldw!=0 && neww!=0)weight_eta2->Fill(fabs(eta),oldw/neww);
else {weight_eta2->Fill(-10,1);}
}
newdset->add(args,neww);
}
newdset->SetName((*dset)->GetName());
newdset->SetTitle((*dset)->GetTitle());
delete hnum; delete hden;
RooDataSet *old_dset = *dset;
*dset=newdset;
std::cout << "Eta 1d rew: norm from " << old_dset->sumEntries() << " to " << newdset->sumEntries() << std::endl;
delete old_dset;
};
void makeDataset( TString fname, TString tname, TString outfname ) {
RooWorkspace *w = new RooWorkspace("w","w");
w->factory( "Dst_M[1950.,2070.]" );
w->factory( "D0_M[1810.,1920.]" );
w->factory( "D0_LTIME_ps[0.00,5.]" );
RooArgSet *observables = new RooArgSet();
observables->add( *w->var("Dst_M") );
observables->add( *w->var("D0_M") );
observables->add( *w->var("D0_LTIME_ps") );
w->defineSet("observables", *observables);
w->var("Dst_M")->setBins(240);
w->var("D0_M")->setBins(220);
w->var("D0_LTIME_ps")->setBins(200);
double Dst_M = -999.;
double D0_M = -999.;
double D0_LTIME_ps = -999.;
TFile *tf = TFile::Open(fname);
TTree *tree = (TTree*)tf->Get(tname);
tree->SetBranchAddress( "Dst_M", &Dst_M );
tree->SetBranchAddress( "D0_M" , &D0_M );
tree->SetBranchAddress( "D0_LTIME_ps", &D0_LTIME_ps );
RooDataSet *data = new RooDataSet("Data","Data",*observables);
RooDataHist *dataH = new RooDataHist("DataHist","Data",*observables);
for ( int ev=0; ev<tree->GetEntries(); ev++) {
tree->GetEntry(ev);
if ( ev%10000 == 0 ) cout << ev << " / " << tree->GetEntries() << endl;
if ( Dst_M < w->var("Dst_M")->getMin() || Dst_M > w->var("Dst_M")->getMax() ) continue;
if ( D0_M < w->var("D0_M")->getMin() || D0_M > w->var("D0_M")->getMax() ) continue;
if ( D0_LTIME_ps < w->var("D0_LTIME_ps")->getMin() || D0_LTIME_ps > w->var("D0_LTIME_ps")->getMax() ) continue;
w->var("Dst_M")->setVal(Dst_M);
w->var("D0_M")->setVal(D0_M);
w->var("D0_LTIME_ps")->setVal(D0_LTIME_ps);
data->add( *observables );
dataH->add( *observables );
}
tf->Close();
w->import(*data);
w->import(*dataH);
w->writeToFile(outfname);
}
void reweight_diphotonpt_1d(TH1F*weight_diphopt,TH1F*weight_diphopto,TH2F*weight_diphoptn,TH2F*weight_diphopt2o,TH2F*weight_diphoptnr, TH2F* weight_diphopt2,RooDataSet **dset, RooDataSet *dsetdestination){
if (!(*dset)) return;
if (!(dsetdestination)) return;
///numerator and denominator
TH1F *hnum = new TH1F("hnum","hnum",n_diphoptbins_forreweighting,diphoptbins_forreweighting);
TH1F *hden = new TH1F("hden","hden",n_diphoptbins_forreweighting,diphoptbins_forreweighting);
hnum->Sumw2();
hden->Sumw2();
// RooAbsData->get*() Load a given row of data
//getRealValue Get value of a RooAbsReal stored in set with given name. If none is found, value of defVal is returned.
for (int i=0; i<(*dset)->numEntries(); i++){
hden->Fill(fabs((*dset)->get(i)->getRealValue("roodiphopt")),(*dset)->store()->weight(i));
}
for (int i=0; i<dsetdestination->numEntries(); i++){
hnum->Fill(fabs(dsetdestination->get(i)->getRealValue("roodiphopt")),dsetdestination->store()->weight(i));
}
//normalize to one
hnum->Scale(1.0/hnum->Integral());
hden->Scale(1.0/hden->Integral());
hnum->Divide(hden);
TH1F *h = hnum;
RooDataSet *newdset = new RooDataSet(**dset,Form("%s_diphoptrew",(*dset)->GetName()));
newdset->reset();
assert(newdset);
for (int i=0; i<(*dset)->numEntries(); i++){
RooArgSet args = *((*dset)->get(i));
float oldw = (*dset)->store()->weight(i);
float diphopt = fabs((*dset)->get(i)->getRealValue("roodiphopt"));
float neww = oldw*h->GetBinContent(h->FindBin(fabs(diphopt)));
newdset->add(args,neww);
if(debug){
weight_diphopt->Fill(neww);
weight_diphopto->Fill(oldw);
weight_diphopt2o->Fill((h->FindBin(fabs(diphopt))),oldw);
weight_diphoptn->Fill((h->FindBin(fabs(diphopt))),neww);
if(oldw!=0)weight_diphoptnr->Fill(h->FindBin(fabs(diphopt)),oldw/neww);
else {weight_diphoptnr->Fill(-10,1);}//cout << "dipho weight old 0" << endl;}
if(oldw!=0)weight_diphopt2->Fill(diphopt,oldw/neww);
else {weight_diphopt2->Fill(-10,1);}//cout << "dipho weight old 0" << endl;}
}
}
newdset->SetName((*dset)->GetName());
newdset->SetTitle((*dset)->GetTitle());
delete hnum; delete hden;
RooDataSet *old_dset = *dset;
*dset=newdset;
std::cout << "Diphoton Pt 1d rew: norm from " << old_dset->sumEntries() << " to " << newdset->sumEntries() << std::endl;
delete old_dset;
};
//2d reweighting of rho and its sigma
void reweight_rhosigma(TH1F* weight_rho, TH1F* weight_rhoo,TH2F*weight_rhon,TH2F*weight_rho2o,TH2F* weight_rhonr, TH2F* weight_rho2,TH2F*weight_sigman,TH2F*weight_sigma2o,TH2F* weight_sigmanr, TH2F* weight_sigma2,RooDataSet **dset, RooDataSet *dsetdestination, bool deleteold){
if (!(*dset)) return;
// TH2F *hnum = new TH2F("hnum","hnum",n_rhobins_forreweighting,rhobins_forreweighting,n_sigmabins_forreweighting,sigmabins_forreweighting);
// TH2F *hden = new TH2F("hden","hden",n_rhobins_forreweighting,rhobins_forreweighting,n_sigmabins_forreweighting,sigmabins_forreweighting);
TH2F *hnum = new TH2F("hnum","hnum",100,0,100,20,0,20);
TH2F *hden = new TH2F("hden","hden",100,0,100,20,0,20);
hnum->Sumw2();
hden->Sumw2();
for (int i=0; i<(*dset)->numEntries(); i++){
hden->Fill(fabs((*dset)->get(i)->getRealValue("roorho")),fabs((*dset)->get(i)->getRealValue("roosigma")),(*dset)->store()->weight(i));
}
for (int i=0; i<dsetdestination->numEntries(); i++){
hnum->Fill(fabs(dsetdestination->get(i)->getRealValue("roorho")),fabs(dsetdestination->get(i)->getRealValue("roosigma")),dsetdestination->store()->weight(i));
}
hnum->Scale(1.0/hnum->Integral());
hden->Scale(1.0/hden->Integral());
//data/MC
hnum->Divide(hden);
TH2F *h = hnum;
RooDataSet *newdset = new RooDataSet(**dset,Form("%s_rhosigmarew",(*dset)->GetName()));
newdset->reset();
for (int i=0; i<(*dset)->numEntries(); i++){
RooArgSet args = *((*dset)->get(i));
float oldw = (*dset)->store()->weight(i);
float rho = args.getRealValue("roorho");
float sigma = args.getRealValue("roosigma");
float neww = oldw*h->GetBinContent(h->FindBin(rho,sigma));
if(debug){
weight_rho->Fill(neww);
weight_rhoo->Fill(oldw);
weight_rho2o->Fill(h->GetXaxis()->FindBin(rho),oldw);
weight_rhon->Fill(h->GetXaxis()->FindBin(rho),neww);
if(oldw!=0)weight_rhonr->Fill(h->GetXaxis()->FindBin(rho),oldw/neww);
else {weight_rhonr->Fill(-10,1);}//cout << "dipho weight old 0" << endl;}
if(oldw!=0)weight_rho2->Fill(rho,oldw/neww);
weight_sigma2o->Fill(h->GetYaxis()->FindBin(sigma),oldw);
weight_sigman->Fill(h->GetYaxis()->FindBin(sigma),neww);
if(oldw!=0)weight_sigmanr->Fill(h->GetYaxis()->FindBin(sigma),oldw/neww);
else {weight_sigmanr->Fill(-10,1);}//cout << "dipho weight old 0" << endl;}
if(oldw!=0)weight_sigma2->Fill(sigma,oldw/neww);
}
newdset->add(args,neww);
}
newdset->SetName((*dset)->GetName());
newdset->SetTitle((*dset)->GetTitle());
delete hnum; delete hden;
RooDataSet *old_dset = *dset;
*dset=newdset;
std::cout << "RhoSigma2D rew: norm from " << old_dset->sumEntries() << " to " << newdset->sumEntries() << std::endl;
if (deleteold) delete old_dset;
};
//
// single measurement (LM0 or LM1)
//
void RA4Single (StatMethod method, double* sig, double* bkg) {
// RooWorkspace* wspace = createWorkspace();
RA4WorkSpace ra4WSpace("wspace",true,true,true);
ra4WSpace.addChannel(RA4WorkSpace::MuChannel);
ra4WSpace.finalize();
double lm0_mc[4] = { 1.09, 7.68, 3.78, 21.13 };
double lm1_mc[4] = { 0.05 , 0.34 , 1.12 , 3.43 };
double* lm_mc = sig ? sig : lm0_mc;
double bkg_mc[4] = { 14.73, 18.20, 8.48, 10.98 };
ra4WSpace.setBackground(RA4WorkSpace::MuChannel,bkg_mc[0],bkg_mc[1],bkg_mc[2],bkg_mc[3]);
ra4WSpace.setSignal(RA4WorkSpace::MuChannel,lm_mc[0],lm_mc[1],lm_mc[2],lm_mc[3],1.,1.,1.,1.);
// setBackgrounds(wspace,bkg);
// setSignal(wspace,lm_mc);
RooWorkspace* wspace = ra4WSpace.workspace();
// wspace->Print("v");
// RooArgSet allVars = wspace->allVars();
// // allVars.printLatex(std::cout,1);
// TIterator* it = allVars.createIterator();
// RooRealVar* var;
// while ( var=(RooRealVar*)it->Next() ) {
// var->Print("v");
// var->printValue(std::cout);
// }
////////////////////////////////////////////////////////////
// Generate toy data
// generate toy data assuming current value of the parameters
// import into workspace.
// add Verbose() to see how it's being generated
// wspace->var("s")->setVal(0.);
// RooDataSet* data = wspace->pdf("model")->generate(*wspace->set("obs"),1);
// data->Print("v");
// // wspace->import(*data);
// wspace->var("s")->setVal(lm_mc[3]);
RooDataSet* data = new RooDataSet("data","data",*wspace->set("obs"));
data->add(*wspace->set("obs"));
data->Print("v");
MyLimit limit = computeLimit(wspace,data,method,true);
std::cout << "Limit [ " << limit.lowerLimit << " , "
<< limit.upperLimit << " ] ; isIn = " << limit.isInInterval << std::endl;
}
RooDataSet *th22dataset(TH2F *hist){
RooRealVar *v1 = new RooRealVar("constTerm","",0.01,0,0.02);
RooRealVar *v2 = new RooRealVar("alpha","",0.0,0,0.2);
RooRealVar *nll = new RooRealVar("nll",0,0,1e20);
RooArgSet argSet(*v1,*v2, *nll);
RooDataSet *dataset = new RooDataSet(TString(hist->GetName())+"_dataset", "", argSet,"nll");
for(Int_t iBinX=1; iBinX <= hist->GetNbinsX(); iBinX++){
for(Int_t iBinY=1; iBinY <= hist->GetNbinsY(); iBinY++){
Double_t binContent=hist->GetBinContent(iBinX, iBinY);
if(binContent!=0){
v1->setVal(hist->GetXaxis()->GetBinCenter(iBinX));
v2->setVal(hist->GetYaxis()->GetBinCenter(iBinY));
nll->setVal(binContent);
dataset->add(argSet);
}
}
}
return dataset;
}
RooDataSet* makeFakeDataXY()
{
RooRealVar x("x","x",-10,10) ;
RooRealVar y("y","y",-10,10) ;
RooArgSet coord(x,y) ;
RooDataSet* d = new RooDataSet("d","d",RooArgSet(x,y)) ;
for (int i=0 ; i<10000 ; i++) {
Double_t tmpy = gRandom->Gaus(0,10) ;
Double_t tmpx = gRandom->Gaus(0.5*tmpy,1) ;
if (fabs(tmpy)<10 && fabs(tmpx)<10) {
x = tmpx ;
y = tmpy ;
d->add(coord) ;
}
}
return d ;
}
void ztonunu1() {
// RooMsgService::instance().addStream(DEBUG,Topic(Tracing),ClassName("RooPoisson"),OutputFile("debug.log")) ;
float acc_mm_mean( 0.98 ) ; float acc_mm_err( 0.02 ) ;
float acc_ee_mean( 0.98 ) ; float acc_ee_err( 0.02 ) ;
float eff_mm_mean( 0.77 ) ; float eff_mm_err( 0.08 ) ;
float eff_ee_mean( 0.76 ) ; float eff_ee_err( 0.08 ) ;
RooRealVar* rv_Nsbee = new RooRealVar( "Nsbee" ,"Nsbee" , 0., 100. ) ;
RooRealVar* rv_Nsbmm = new RooRealVar( "Nsbmm" ,"Nsbmm" , 0., 100. ) ;
RooRealVar* rv_Nsigee = new RooRealVar( "Nsigee" ,"Nsigee" , 0., 100. ) ;
RooRealVar* rv_Nsigmm = new RooRealVar( "Nsigmm" ,"Nsigmm" , 0., 100. ) ;
rv_Nsbee->setVal( 5 ) ;
rv_Nsbmm->setVal( 3 ) ;
rv_Nsigee->setVal( 4 ) ;
rv_Nsigmm->setVal( 3 ) ;
RooRealVar* rv_mu_Znnsb = new RooRealVar( "mu_Znnsb" , "mu_Znnsb" , 0., 100. ) ;
RooRealVar* rv_mu_Znnsig = new RooRealVar( "mu_Znnsig" , "mu_Znnsig" , 0., 100. ) ;
rv_mu_Znnsb->setVal( 37 ) ; // starting value
rv_mu_Znnsig->setVal( 17. ) ; // starting value
RooRealVar* rv_bfRatio = new RooRealVar( "bfRatio", "bfRatio", 0., 10. ) ;
rv_bfRatio->setVal( 5.95 ) ;
rv_bfRatio->setConstant( kTRUE ) ;
RooRealVar* rv_acc_mm = new RooRealVar( "acc_mm", "acc_mm", 0.001, 1.000 ) ;
RooRealVar* rv_acc_ee = new RooRealVar( "acc_ee", "acc_ee", 0.001, 1.000 ) ;
RooRealVar* rv_eff_mm = new RooRealVar( "eff_mm", "eff_mm", 0.001, 1.000 ) ;
RooRealVar* rv_eff_ee = new RooRealVar( "eff_ee", "eff_ee", 0.001, 1.000 ) ;
rv_acc_mm->setVal( acc_mm_mean ) ;
rv_acc_ee->setVal( acc_ee_mean ) ;
rv_eff_mm->setVal( eff_mm_mean ) ;
rv_eff_ee->setVal( eff_ee_mean ) ;
RooRealVar* rv_lumi_ratio = new RooRealVar( "lumi_ratio", "lumi_ratio", 0., 10. ) ;
rv_lumi_ratio -> setVal( 686./869. ) ;
rv_lumi_ratio -> setConstant( kTRUE) ;
RooFormulaVar* rv_mu_Zeesb = new RooFormulaVar( "mu_Zeesb",
"mu_Znnsb * ( acc_ee * eff_ee / (bfRatio*lumi_ratio) )",
RooArgSet( *rv_mu_Znnsb, *rv_acc_ee, *rv_eff_ee, *rv_bfRatio, *rv_lumi_ratio ) ) ;
RooFormulaVar* rv_mu_Zmmsb = new RooFormulaVar( "mu_Zmmsb",
"mu_Znnsb * ( acc_mm * eff_mm / (bfRatio*lumi_ratio) )",
RooArgSet( *rv_mu_Znnsb, *rv_acc_mm, *rv_eff_mm, *rv_bfRatio, *rv_lumi_ratio ) ) ;
RooFormulaVar* rv_mu_Zeesig = new RooFormulaVar( "mu_Zeesig",
"mu_Znnsig * ( acc_ee * eff_ee / (bfRatio*lumi_ratio) )",
RooArgSet( *rv_mu_Znnsig, *rv_acc_ee, *rv_eff_ee, *rv_bfRatio, *rv_lumi_ratio ) ) ;
RooFormulaVar* rv_mu_Zmmsig = new RooFormulaVar( "mu_Zmmsig",
"mu_Znnsig * ( acc_mm * eff_mm / (bfRatio*lumi_ratio) )",
RooArgSet( *rv_mu_Znnsig, *rv_acc_mm, *rv_eff_mm, *rv_bfRatio, *rv_lumi_ratio ) ) ;
RooFormulaVar* rv_n_sbee = new RooFormulaVar( "n_sbee" , "mu_Zeesb" , RooArgSet( *rv_mu_Zeesb ) ) ;
RooFormulaVar* rv_n_sbmm = new RooFormulaVar( "n_sbmm" , "mu_Zmmsb" , RooArgSet( *rv_mu_Zmmsb ) ) ;
RooFormulaVar* rv_n_sigee = new RooFormulaVar( "n_sigee" , "mu_Zeesig" , RooArgSet( *rv_mu_Zeesig ) ) ;
RooFormulaVar* rv_n_sigmm = new RooFormulaVar( "n_sigmm" , "mu_Zmmsig" , RooArgSet( *rv_mu_Zmmsig ) ) ;
RooGaussian* pdf_acc_mm = new RooGaussian( "pdf_acc_mm", "Gaussian pdf for Z to mumu acceptance",
*rv_acc_mm, RooConst( acc_mm_mean ), RooConst( acc_mm_err ) ) ;
RooGaussian* pdf_acc_ee = new RooGaussian( "pdf_acc_ee", "Gaussian pdf for Z to ee acceptance",
*rv_acc_ee, RooConst( acc_ee_mean ), RooConst( acc_ee_err ) ) ;
RooGaussian* pdf_eff_mm = new RooGaussian( "pdf_eff_mm", "Gaussian pdf for Z to mumu efficiency",
*rv_eff_mm, RooConst( eff_mm_mean ), RooConst( eff_mm_err ) ) ;
RooGaussian* pdf_eff_ee = new RooGaussian( "pdf_eff_ee", "Gaussian pdf for Z to ee efficiency",
*rv_eff_ee, RooConst( eff_ee_mean ), RooConst( eff_ee_err ) ) ;
RooPoisson* pdf_Nsbee = new RooPoisson( "pdf_Nsbee" , "Nsb , Z to ee Poisson PDF", *rv_Nsbee , *rv_n_sbee ) ;
RooPoisson* pdf_Nsbmm = new RooPoisson( "pdf_Nsbmm" , "Nsb , Z to mm Poisson PDF", *rv_Nsbmm , *rv_n_sbmm ) ;
RooPoisson* pdf_Nsigee = new RooPoisson( "pdf_Nsigee" , "Nsig, Z to ee Poisson PDF", *rv_Nsigee , *rv_n_sigee ) ;
RooPoisson* pdf_Nsigmm = new RooPoisson( "pdf_Nsigmm" , "Nsig, Z to mm Poisson PDF", *rv_Nsigmm , *rv_n_sigmm ) ;
RooArgSet pdflist ;
pdflist.add( *pdf_acc_mm ) ;
pdflist.add( *pdf_acc_ee ) ;
pdflist.add( *pdf_eff_mm ) ;
pdflist.add( *pdf_eff_ee ) ;
pdflist.add( *pdf_Nsbee ) ;
pdflist.add( *pdf_Nsbmm ) ;
pdflist.add( *pdf_Nsigee ) ;
pdflist.add( *pdf_Nsigmm ) ;
RooProdPdf* znnLikelihood = new RooProdPdf( "znnLikelihood", "Z to nunu likelihood", pdflist ) ;
RooArgSet observedParametersList ;
observedParametersList.add( *rv_Nsbee ) ;
observedParametersList.add( *rv_Nsbmm ) ;
observedParametersList.add( *rv_Nsigee ) ;
observedParametersList.add( *rv_Nsigmm ) ;
RooDataSet* dsObserved = new RooDataSet( "ztonn_rds", "Z to nunu dataset", observedParametersList ) ;
dsObserved->add( observedParametersList ) ;
//// RooDataSet* dsObserved = znnLikelihood->generate( observedParametersList, 1) ;
RooWorkspace* znnWorkspace = new RooWorkspace("ztonn_ws") ;
znnWorkspace->import( *znnLikelihood ) ;
znnWorkspace->import( *dsObserved ) ;
znnWorkspace->Print() ;
dsObserved->printMultiline(cout, 1, kTRUE, "") ;
RooFitResult* fitResult = znnLikelihood->fitTo( *dsObserved, Verbose(true), Save(true) ) ;
printf("\n\n----- Constant parameters:\n") ;
RooArgList constPars = fitResult->constPars() ;
for ( int pi=0; pi<constPars.getSize(); pi++ ) {
constPars[pi].Print() ;
} // pi.
printf("\n\n----- Floating parameters:\n") ;
RooArgList floatPars = fitResult->floatParsFinal() ;
for ( int pi=0; pi<floatPars.getSize(); pi++ ) {
floatPars[pi].Print() ;
} // pi.
printf("\n\n") ;
ProfileLikelihoodCalculator plc_znn_sb( *dsObserved, *znnLikelihood, RooArgSet( *rv_mu_Znnsb ) ) ;
ProfileLikelihoodCalculator plc_znn_sig( *dsObserved, *znnLikelihood, RooArgSet( *rv_mu_Znnsig ) ) ;
plc_znn_sb.SetTestSize(0.32) ;
plc_znn_sig.SetTestSize(0.32) ;
ConfInterval* sb_znn_interval = plc_znn_sb.GetInterval() ;
float sbZnnLow = ((LikelihoodInterval*) sb_znn_interval)->LowerLimit(*rv_mu_Znnsb) ;
float sbZnnHigh = ((LikelihoodInterval*) sb_znn_interval)->UpperLimit(*rv_mu_Znnsb) ;
printf("\n\n znn SB interval %6.1f to %6.1f\n", sbZnnLow, sbZnnHigh ) ;
ConfInterval* sig_znn_interval = plc_znn_sig.GetInterval() ;
float sigZnnLow = ((LikelihoodInterval*) sig_znn_interval)->LowerLimit(*rv_mu_Znnsig) ;
float sigZnnHigh = ((LikelihoodInterval*) sig_znn_interval)->UpperLimit(*rv_mu_Znnsig) ;
printf("\n\n znn SIG interval %6.1f to %6.1f\n", sigZnnLow, sigZnnHigh ) ;
TCanvas* c_prof_sb = new TCanvas("c_prof_sb","SB Z to nunu profile") ;
LikelihoodIntervalPlot plot_znn_sb((LikelihoodInterval*)sb_znn_interval) ;
plot_znn_sb.Draw() ;
c_prof_sb->SaveAs("znn_sb_profile.png") ;
TCanvas* c_prof_sig = new TCanvas("c_prof_sig","sig Z to nunu profile") ;
LikelihoodIntervalPlot plot_znn_sig((LikelihoodInterval*)sig_znn_interval) ;
plot_znn_sig.Draw() ;
c_prof_sig->SaveAs("znn_sig_profile.png") ;
}
// The actual job
void backgroundFits_qqzz_1Dw(int channel, int sqrts, int VBFtag)
{
if(sqrts==7)return;
TString schannel;
if (channel == 1) schannel = "4mu";
else if (channel == 2) schannel = "4e";
else if (channel == 3) schannel = "2e2mu";
else cout << "Not a valid channel: " << schannel << endl;
TString ssqrts = (long) sqrts + TString("TeV");
cout << "schannel = " << schannel << " sqrts = " << sqrts << " VBFtag = " << VBFtag << endl;
TString outfile;
if(VBFtag<2) outfile = "CardFragments/qqzzBackgroundFit_" + ssqrts + "_" + schannel + "_" + Form("%d",int(VBFtag)) + ".txt";
if(VBFtag==2) outfile = "CardFragments/qqzzBackgroundFit_" + ssqrts + "_" + schannel + ".txt";
ofstream of(outfile,ios_base::out);
of << "### background functions ###" << endl;
gSystem->AddIncludePath("-I$ROOFITSYS/include");
gROOT->ProcessLine(".L ../CreateDatacards/include/tdrstyle.cc");
setTDRStyle(false);
gStyle->SetPadLeftMargin(0.16);
TString filepath;
if (sqrts==7) {
filepath = filePath7TeV;
} else if (sqrts==8) {
filepath = filePath8TeV;
}
TChain* tree = new TChain("SelectedTree");
tree->Add( filepath+ "/" + (schannel=="2e2mu"?"2mu2e":schannel) + "/HZZ4lTree_ZZTo*.root");
RooRealVar* MC_weight = new RooRealVar("MC_weight","MC_weight",0.,2.) ;
RooRealVar* ZZMass = new RooRealVar("ZZMass","ZZMass",100.,1000.);
RooRealVar* NJets30 = new RooRealVar("NJets30","NJets30",0.,100.);
RooArgSet ntupleVarSet(*ZZMass,*NJets30,*MC_weight);
RooDataSet *set = new RooDataSet("set","set",ntupleVarSet,WeightVar("MC_weight"));
Float_t myMC,myMass;
Short_t myNJets;
int nentries = tree->GetEntries();
tree->SetBranchAddress("ZZMass",&myMass);
tree->SetBranchAddress("MC_weight",&myMC);
tree->SetBranchAddress("NJets30",&myNJets);
for(int i =0;i<nentries;i++) {
tree->GetEntry(i);
if(VBFtag==1 && myNJets<2)continue;
if(VBFtag==0 && myNJets>1)continue;
ntupleVarSet.setRealValue("ZZMass",myMass);
ntupleVarSet.setRealValue("MC_weight",myMC);
ntupleVarSet.setRealValue("NJets30",(double)myNJets);
set->add(ntupleVarSet, myMC);
}
double totalweight = 0.;
double totalweight_z = 0.;
for (int i=0 ; i<set->numEntries() ; i++) {
//set->get(i) ;
RooArgSet* row = set->get(i) ;
//row->Print("v");
totalweight += set->weight();
if (row->getRealValue("ZZMass") < 200) totalweight_z += set->weight();
}
cout << "nEntries: " << set->numEntries() << ", totalweight: " << totalweight << ", totalweight_z: " << totalweight_z << endl;
gSystem->Load("libHiggsAnalysisCombinedLimit.so");
//// ---------------------------------------
//Background
RooRealVar CMS_qqzzbkg_a0("CMS_qqzzbkg_a0","CMS_qqzzbkg_a0",115.3,0.,200.);
RooRealVar CMS_qqzzbkg_a1("CMS_qqzzbkg_a1","CMS_qqzzbkg_a1",21.96,0.,200.);
RooRealVar CMS_qqzzbkg_a2("CMS_qqzzbkg_a2","CMS_qqzzbkg_a2",122.8,0.,200.);
RooRealVar CMS_qqzzbkg_a3("CMS_qqzzbkg_a3","CMS_qqzzbkg_a3",0.03479,0.,1.);
RooRealVar CMS_qqzzbkg_a4("CMS_qqzzbkg_a4","CMS_qqzzbkg_a4",185.5,0.,200.);
RooRealVar CMS_qqzzbkg_a5("CMS_qqzzbkg_a5","CMS_qqzzbkg_a5",12.67,0.,200.);
RooRealVar CMS_qqzzbkg_a6("CMS_qqzzbkg_a6","CMS_qqzzbkg_a6",34.81,0.,100.);
RooRealVar CMS_qqzzbkg_a7("CMS_qqzzbkg_a7","CMS_qqzzbkg_a7",0.1393,0.,1.);
RooRealVar CMS_qqzzbkg_a8("CMS_qqzzbkg_a8","CMS_qqzzbkg_a8",66.,0.,200.);
RooRealVar CMS_qqzzbkg_a9("CMS_qqzzbkg_a9","CMS_qqzzbkg_a9",0.07191,0.,1.);
RooRealVar CMS_qqzzbkg_a10("CMS_qqzzbkg_a10","CMS_qqzzbkg_a10",94.11,0.,200.);
RooRealVar CMS_qqzzbkg_a11("CMS_qqzzbkg_a11","CMS_qqzzbkg_a11",-5.111,-100.,100.);
RooRealVar CMS_qqzzbkg_a12("CMS_qqzzbkg_a12","CMS_qqzzbkg_a12",4834,0.,10000.);
RooRealVar CMS_qqzzbkg_a13("CMS_qqzzbkg_a13","CMS_qqzzbkg_a13",0.2543,0.,1.);
if (channel == 1){
///* 4mu
CMS_qqzzbkg_a0.setVal(103.854);
CMS_qqzzbkg_a1.setVal(10.0718);
CMS_qqzzbkg_a2.setVal(117.551);
CMS_qqzzbkg_a3.setVal(0.0450287);
CMS_qqzzbkg_a4.setVal(185.262);
CMS_qqzzbkg_a5.setVal(7.99428);
CMS_qqzzbkg_a6.setVal(39.7813);
CMS_qqzzbkg_a7.setVal(0.0986891);
CMS_qqzzbkg_a8.setVal(49.1325);
CMS_qqzzbkg_a9.setVal(0.0389984);
CMS_qqzzbkg_a10.setVal(98.6645);
CMS_qqzzbkg_a11.setVal(-7.02043);
CMS_qqzzbkg_a12.setVal(5694.66);
CMS_qqzzbkg_a13.setVal(0.0774525);
//*/
}
else if (channel == 2){
///* 4e
CMS_qqzzbkg_a0.setVal(111.165);
CMS_qqzzbkg_a1.setVal(19.8178);
CMS_qqzzbkg_a2.setVal(120.89);
CMS_qqzzbkg_a3.setVal(0.0546639);
CMS_qqzzbkg_a4.setVal(184.878);
CMS_qqzzbkg_a5.setVal(11.7041);
CMS_qqzzbkg_a6.setVal(33.2659);
CMS_qqzzbkg_a7.setVal(0.140858);
CMS_qqzzbkg_a8.setVal(56.1226);
CMS_qqzzbkg_a9.setVal(0.0957699);
CMS_qqzzbkg_a10.setVal(98.3662);
CMS_qqzzbkg_a11.setVal(-6.98701);
CMS_qqzzbkg_a12.setVal(10.0536);
CMS_qqzzbkg_a13.setVal(0.110576);
//*/
}
else if (channel == 3){
///* 2e2mu
CMS_qqzzbkg_a0.setVal(110.293);
CMS_qqzzbkg_a1.setVal(11.8334);
CMS_qqzzbkg_a2.setVal(116.91);
CMS_qqzzbkg_a3.setVal(0.0433151);
CMS_qqzzbkg_a4.setVal(185.817);
CMS_qqzzbkg_a5.setVal(10.5945);
CMS_qqzzbkg_a6.setVal(29.6208);
CMS_qqzzbkg_a7.setVal(0.0826);
CMS_qqzzbkg_a8.setVal(53.1346);
CMS_qqzzbkg_a9.setVal(0.0882081);
CMS_qqzzbkg_a10.setVal(85.3776);
CMS_qqzzbkg_a11.setVal(-13.3836);
CMS_qqzzbkg_a12.setVal(7587.95);
CMS_qqzzbkg_a13.setVal(0.325621);
//*/
}
else {
cout << "disaster" << endl;
}
RooqqZZPdf_v2* bkg_qqzz = new RooqqZZPdf_v2("bkg_qqzz","bkg_qqzz",*ZZMass,
CMS_qqzzbkg_a0,CMS_qqzzbkg_a1,CMS_qqzzbkg_a2,CMS_qqzzbkg_a3,CMS_qqzzbkg_a4,
CMS_qqzzbkg_a5,CMS_qqzzbkg_a6,CMS_qqzzbkg_a7,CMS_qqzzbkg_a8,
CMS_qqzzbkg_a9,CMS_qqzzbkg_a10,CMS_qqzzbkg_a11,CMS_qqzzbkg_a12,CMS_qqzzbkg_a13);
RooArgSet myASet(*ZZMass, CMS_qqzzbkg_a0,CMS_qqzzbkg_a1,CMS_qqzzbkg_a2,CMS_qqzzbkg_a3,CMS_qqzzbkg_a4,
CMS_qqzzbkg_a5,CMS_qqzzbkg_a6,CMS_qqzzbkg_a7);
myASet.add(CMS_qqzzbkg_a8);
myASet.add(CMS_qqzzbkg_a9);
myASet.add(CMS_qqzzbkg_a10);
myASet.add(CMS_qqzzbkg_a11);
myASet.add(CMS_qqzzbkg_a12);
myASet.add(CMS_qqzzbkg_a13);
RooFitResult *r1 = bkg_qqzz->fitTo( *set, Save(kTRUE), SumW2Error(kTRUE) );//, Save(kTRUE), SumW2Error(kTRUE)) ;
cout << endl;
cout << "------- Parameters for " << schannel << " sqrts=" << sqrts << endl;
cout << " a0_bkgd = " << CMS_qqzzbkg_a0.getVal() << endl;
cout << " a1_bkgd = " << CMS_qqzzbkg_a1.getVal() << endl;
cout << " a2_bkgd = " << CMS_qqzzbkg_a2.getVal() << endl;
cout << " a3_bkgd = " << CMS_qqzzbkg_a3.getVal() << endl;
cout << " a4_bkgd = " << CMS_qqzzbkg_a4.getVal() << endl;
cout << " a5_bkgd = " << CMS_qqzzbkg_a5.getVal() << endl;
cout << " a6_bkgd = " << CMS_qqzzbkg_a6.getVal() << endl;
cout << " a7_bkgd = " << CMS_qqzzbkg_a7.getVal() << endl;
cout << " a8_bkgd = " << CMS_qqzzbkg_a8.getVal() << endl;
cout << " a9_bkgd = " << CMS_qqzzbkg_a9.getVal() << endl;
cout << " a10_bkgd = " << CMS_qqzzbkg_a10.getVal() << endl;
cout << " a11_bkgd = " << CMS_qqzzbkg_a11.getVal() << endl;
cout << " a12_bkgd = " << CMS_qqzzbkg_a12.getVal() << endl;
cout << " a13_bkgd = " << CMS_qqzzbkg_a13.getVal() << endl;
cout << "}" << endl;
cout << "---------------------------" << endl;
of << "qqZZshape a0_bkgd " << CMS_qqzzbkg_a0.getVal() << endl;
of << "qqZZshape a1_bkgd " << CMS_qqzzbkg_a1.getVal() << endl;
of << "qqZZshape a2_bkgd " << CMS_qqzzbkg_a2.getVal() << endl;
of << "qqZZshape a3_bkgd " << CMS_qqzzbkg_a3.getVal() << endl;
of << "qqZZshape a4_bkgd " << CMS_qqzzbkg_a4.getVal() << endl;
of << "qqZZshape a5_bkgd " << CMS_qqzzbkg_a5.getVal() << endl;
of << "qqZZshape a6_bkgd " << CMS_qqzzbkg_a6.getVal() << endl;
of << "qqZZshape a7_bkgd " << CMS_qqzzbkg_a7.getVal() << endl;
of << "qqZZshape a8_bkgd " << CMS_qqzzbkg_a8.getVal() << endl;
of << "qqZZshape a9_bkgd " << CMS_qqzzbkg_a9.getVal() << endl;
of << "qqZZshape a10_bkgd " << CMS_qqzzbkg_a10.getVal() << endl;
of << "qqZZshape a11_bkgd " << CMS_qqzzbkg_a11.getVal() << endl;
of << "qqZZshape a12_bkgd " << CMS_qqzzbkg_a12.getVal() << endl;
of << "qqZZshape a13_bkgd " << CMS_qqzzbkg_a13.getVal() << endl;
of << endl << endl;
of.close();
cout << endl << "Output written to: " << outfile << endl;
double qqzznorm;
if (channel == 1) qqzznorm = 20.5836;
else if (channel == 2) qqzznorm = 13.8871;
else if (channel == 3) qqzznorm = 32.9883;
else { cout << "disaster!" << endl; }
ZZMass->setRange("fullrange",100.,1000.);
ZZMass->setRange("largerange",100.,600.);
ZZMass->setRange("zoomrange",100.,200.);
double rescale = qqzznorm/totalweight;
double rescale_z = qqzznorm/totalweight_z;
cout << "rescale: " << rescale << ", rescale_z: " << rescale_z << endl;
// Plot m4l and
RooPlot* frameM4l = ZZMass->frame(Title("M4L"),Range(100,600),Bins(250)) ;
set->plotOn(frameM4l, MarkerStyle(20), Rescale(rescale)) ;
//set->plotOn(frameM4l) ;
RooPlot* frameM4lz = ZZMass->frame(Title("M4L"),Range(100,200),Bins(100)) ;
set->plotOn(frameM4lz, MarkerStyle(20), Rescale(rescale)) ;
int iLineColor = 1;
string lab = "blah";
if (channel == 1) { iLineColor = 2; lab = "4#mu"; }
if (channel == 3) { iLineColor = 4; lab = "2e2#mu"; }
if (channel == 2) { iLineColor = 6; lab = "4e"; }
bkg_qqzz->plotOn(frameM4l,LineColor(iLineColor),NormRange("largerange")) ;
bkg_qqzz->plotOn(frameM4lz,LineColor(iLineColor),NormRange("zoomrange")) ;
//second shape to compare with (if previous comparison code unceommented)
//bkg_qqzz_bkgd->plotOn(frameM4l,LineColor(1),NormRange("largerange")) ;
//bkg_qqzz_bkgd->plotOn(frameM4lz,LineColor(1),NormRange("zoomrange")) ;
double normalizationBackground_qqzz = bkg_qqzz->createIntegral( RooArgSet(*ZZMass), Range("fullrange") )->getVal();
cout << "Norm all = " << normalizationBackground_qqzz << endl;
frameM4l->GetXaxis()->SetTitle("m_{4l} [GeV]");
frameM4l->GetYaxis()->SetTitle("a.u.");
frameM4lz->GetXaxis()->SetTitle("m_{4l} [GeV]");
frameM4lz->GetYaxis()->SetTitle("a.u.");
char lname[192];
sprintf(lname,"qq #rightarrow ZZ #rightarrow %s", lab.c_str() );
char lname2[192];
sprintf(lname2,"Shape Model, %s", lab.c_str() );
// dummy!
TF1* dummyF = new TF1("dummyF","1",0.,1.);
TH1F* dummyH = new TH1F("dummyH","",1, 0.,1.);
dummyF->SetLineColor( iLineColor );
dummyF->SetLineWidth( 2 );
dummyH->SetLineColor( kBlue );
TLegend * box2 = new TLegend(0.4,0.70,0.80,0.90);
box2->SetFillColor(0);
box2->SetBorderSize(0);
box2->AddEntry(dummyH,"Simulation (POWHEG+Pythia) ","pe");
box2->AddEntry(dummyH,lname,"");
box2->AddEntry(dummyH,"","");
box2->AddEntry(dummyF,lname2,"l");
TPaveText *pt = new TPaveText(0.15,0.955,0.4,0.99,"NDC");
pt->SetFillColor(0);
pt->SetBorderSize(0);
pt->AddText("CMS Preliminary 2012");
TPaveText *pt2 = new TPaveText(0.84,0.955,0.99,0.99,"NDC");
pt2->SetFillColor(0);
pt2->SetBorderSize(0);
TString entag;entag.Form("#sqrt{s} = %d TeV",sqrts);
pt2->AddText(entag.Data());
TCanvas *c = new TCanvas("c","c",800,600);
c->cd();
frameM4l->Draw();
frameM4l->GetYaxis()->SetRangeUser(0,0.4);
if(channel == 3)frameM4l->GetYaxis()->SetRangeUser(0,0.7);
box2->Draw();
pt->Draw();
pt2->Draw();
TString outputPath = "bkgFigs";
outputPath = outputPath+ (long) sqrts + "TeV/";
TString outputName;
if(VBFtag<2) outputName = outputPath + "bkgqqzz_" + schannel + "_" + Form("%d",int(VBFtag));
if(VBFtag==2) outputName = outputPath + "bkgqqzz_" + schannel;
c->SaveAs(outputName + ".eps");
c->SaveAs(outputName + ".png");
TCanvas *c2 = new TCanvas("c2","c2",1000,500);
c2->Divide(2,1);
c2->cd(1);
frameM4l->Draw();
box2->Draw("same");
c2->cd(2);
frameM4lz->Draw();
box2->Draw("same");
if (VBFtag<2) outputName = outputPath + "bkgqqzz_" + schannel + "_z" + "_" + Form("%d",int(VBFtag));
if (VBFtag==2) outputName = outputPath + "bkgqqzz_" + schannel + "_z";
c2->SaveAs(outputName + ".eps");
c2->SaveAs(outputName + ".png");
/* TO make the ratio btw 2 shapes, if needed for compairson
TCanvas *c3 = new TCanvas("c3","c3",1000,500);
if(sqrts==7)
sprintf(outputName, "bkgFigs7TeV/bkgqqzz_%s_ratio.eps",schannel.c_str());
else if(sqrts==8)
sprintf(outputName, "bkgFigs8TeV/bkgqqzz_%s_ratio.eps",schannel.c_str());
const int nPoints = 501.;
double masses[nPoints] ;
int j=0;
for (int i=100; i<601; i++){
masses[j] = i;
j++;
}
cout<<j<<endl;
double effDiff[nPoints];
for (int i = 0; i < nPoints; i++){
ZZMass->setVal(masses[i]);
double eval = (bkg_qqzz_bkgd->getVal(otherASet)-bkg_qqzz->getVal(myASet))/(bkg_qqzz->getVal(myASet));
//cout<<bkg_qqzz_bkgd->getVal(otherASet)<<" "<<bkg_qqzz->getVal(myASet)<<" "<<eval<<endl;
effDiff[i]=eval;
}
TGraph* grEffDiff = new TGraph( nPoints, masses, effDiff );
grEffDiff->SetMarkerStyle(20);
grEffDiff->Draw("AL");
//c3->SaveAs(outputName);
*/
if (VBFtag<2) outputName = outputPath + "bkgqqzz_" + schannel + "_z" + "_" + Form("%d",int(VBFtag)) + ".root";
if (VBFtag==2) outputName = outputPath + "bkgqqzz_" + schannel + "_z" + ".root";
TFile* outF = new TFile(outputName,"RECREATE");
outF->cd();
c2->Write();
frameM4l->Write();
frameM4lz->Write();
outF->Close();
delete c;
delete c2;
}
// implementation
void TwoBinInstructional( void ){
// let's time this example
TStopwatch t;
t.Start();
// set RooFit random seed for reproducible results
RooRandom::randomGenerator()->SetSeed(4357);
// make model
RooWorkspace * pWs = new RooWorkspace("ws");
// derived from data
pWs->factory("xsec[0.2,0,2]"); // POI
pWs->factory("bg_b[10,0,50]"); // data driven nuisance
// predefined nuisances
pWs->factory("lumi[100,0,1000]");
pWs->factory("eff_a[0.2,0,1]");
pWs->factory("eff_b[0.05,0,1]");
pWs->factory("tau[0,1]");
pWs->factory("xsec_bg_a[0.05]"); // constant
pWs->var("xsec_bg_a")->setConstant(1);
// channel a (signal): lumi*xsec*eff_a + lumi*bg_a + tau*bg_b
pWs->factory("prod::sig_a(lumi,xsec,eff_a)");
pWs->factory("prod::bg_a(lumi,xsec_bg_a)");
pWs->factory("prod::tau_bg_b(tau, bg_b)");
pWs->factory("Poisson::pdf_a(na[14,0,100],sum::mu_a(sig_a,bg_a,tau_bg_b))");
// channel b (control): lumi*xsec*eff_b + bg_b
pWs->factory("prod::sig_b(lumi,xsec,eff_b)");
pWs->factory("Poisson::pdf_b(nb[11,0,100],sum::mu_b(sig_b,bg_b))");
// nuisance constraint terms (systematics)
pWs->factory("Lognormal::l_lumi(lumi,nom_lumi[100,0,1000],sum::kappa_lumi(1,d_lumi[0.1]))");
pWs->factory("Lognormal::l_eff_a(eff_a,nom_eff_a[0.20,0,1],sum::kappa_eff_a(1,d_eff_a[0.05]))");
pWs->factory("Lognormal::l_eff_b(eff_b,nom_eff_b[0.05,0,1],sum::kappa_eff_b(1,d_eff_b[0.05]))");
pWs->factory("Lognormal::l_tau(tau,nom_tau[0.50,0,1],sum::kappa_tau(1,d_tau[0.05]))");
//pWs->factory("Lognormal::l_bg_a(bg_a,nom_bg_a[0.05,0,1],sum::kappa_bg_a(1,d_bg_a[0.10]))");
// complete model PDF
pWs->factory("PROD::model(pdf_a,pdf_b,l_lumi,l_eff_a,l_eff_b,l_tau)");
// Now create sets of variables. Note that we could use the factory to
// create sets but in that case many of the sets would be duplicated
// when the ModelConfig objects are imported into the workspace. So,
// we create the sets outside the workspace, and only the needed ones
// will be automatically imported by ModelConfigs
// observables
RooArgSet obs(*pWs->var("na"), *pWs->var("nb"), "obs");
// global observables
RooArgSet globalObs(*pWs->var("nom_lumi"), *pWs->var("nom_eff_a"), *pWs->var("nom_eff_b"),
*pWs->var("nom_tau"),
"global_obs");
// parameters of interest
RooArgSet poi(*pWs->var("xsec"), "poi");
// nuisance parameters
RooArgSet nuis(*pWs->var("lumi"), *pWs->var("eff_a"), *pWs->var("eff_b"), *pWs->var("tau"), "nuis");
// priors (for Bayesian calculation)
pWs->factory("Uniform::prior_xsec(xsec)"); // for parameter of interest
pWs->factory("Uniform::prior_bg_b(bg_b)"); // for data driven nuisance parameter
pWs->factory("PROD::prior(prior_xsec,prior_bg_b)"); // total prior
// create data
pWs->var("na")->setVal(14);
pWs->var("nb")->setVal(11);
RooDataSet * pData = new RooDataSet("data","",obs);
pData->add(obs);
pWs->import(*pData);
//pData->Print();
// signal+background model
ModelConfig * pSbModel = new ModelConfig("SbModel");
pSbModel->SetWorkspace(*pWs);
pSbModel->SetPdf(*pWs->pdf("model"));
pSbModel->SetPriorPdf(*pWs->pdf("prior"));
pSbModel->SetParametersOfInterest(poi);
pSbModel->SetNuisanceParameters(nuis);
pSbModel->SetObservables(obs);
pSbModel->SetGlobalObservables(globalObs);
// set all but obs, poi and nuisance to const
SetConstants(pWs, pSbModel);
pWs->import(*pSbModel);
// background-only model
// use the same PDF as s+b, with xsec=0
// POI value under the background hypothesis
Double_t poiValueForBModel = 0.0;
ModelConfig* pBModel = new ModelConfig(*(RooStats::ModelConfig *)pWs->obj("SbModel"));
pBModel->SetName("BModel");
pBModel->SetWorkspace(*pWs);
pWs->import(*pBModel);
// find global maximum with the signal+background model
// with conditional MLEs for nuisance parameters
// and save the parameter point snapshot in the Workspace
// - safer to keep a default name because some RooStats calculators
// will anticipate it
RooAbsReal * pNll = pSbModel->GetPdf()->createNLL(*pData);
RooAbsReal * pProfile = pNll->createProfile(RooArgSet());
pProfile->getVal(); // this will do fit and set POI and nuisance parameters to fitted values
RooArgSet * pPoiAndNuisance = new RooArgSet();
if(pSbModel->GetNuisanceParameters())
pPoiAndNuisance->add(*pSbModel->GetNuisanceParameters());
pPoiAndNuisance->add(*pSbModel->GetParametersOfInterest());
cout << "\nWill save these parameter points that correspond to the fit to data" << endl;
pPoiAndNuisance->Print("v");
pSbModel->SetSnapshot(*pPoiAndNuisance);
delete pProfile;
delete pNll;
delete pPoiAndNuisance;
// Find a parameter point for generating pseudo-data
// with the background-only data.
// Save the parameter point snapshot in the Workspace
pNll = pBModel->GetPdf()->createNLL(*pData);
pProfile = pNll->createProfile(poi);
((RooRealVar *)poi.first())->setVal(poiValueForBModel);
pProfile->getVal(); // this will do fit and set nuisance parameters to profiled values
pPoiAndNuisance = new RooArgSet();
if(pBModel->GetNuisanceParameters())
pPoiAndNuisance->add(*pBModel->GetNuisanceParameters());
pPoiAndNuisance->add(*pBModel->GetParametersOfInterest());
cout << "\nShould use these parameter points to generate pseudo data for bkg only" << endl;
pPoiAndNuisance->Print("v");
pBModel->SetSnapshot(*pPoiAndNuisance);
delete pProfile;
delete pNll;
delete pPoiAndNuisance;
// inspect workspace
pWs->Print();
// save workspace to file
pWs->writeToFile("ws_twobin.root");
// clean up
delete pWs;
delete pData;
delete pSbModel;
delete pBModel;
} // ----- end of tutorial ----------------------------------------
void MakeWorkspace( void ){
//
// this function implements a RooFit model for a counting experiment
//
// create workspace
RooWorkspace * pWs = new RooWorkspace("myWS");
// observable: number of events
pWs->factory( "n[0.0]" );
// integrated luminosity with systematics
pWs->factory( "lumi_nom[5000.0, 4000.0, 6000.0]" );
pWs->factory( "lumi_kappa[1.045]" );
pWs->factory( "cexpr::alpha_lumi('pow(lumi_kappa,beta_lumi)',lumi_kappa,beta_lumi[0,-5,5])" );
pWs->factory( "prod::lumi(lumi_nom,alpha_lumi)" );
pWs->factory( "Gaussian::constr_lumi(beta_lumi,glob_lumi[0,-5,5],1)" );
// cross section - parameter of interest
pWs->factory( "xsec[0.001,0.0,0.1]" );
// selection efficiency * acceptance with systematics
pWs->factory( "efficiency_nom[0.1, 0.05, 0.15]" );
pWs->factory( "efficiency_kappa[1.10]" );
pWs->factory( "cexpr::alpha_efficiency('pow(efficiency_kappa,beta_efficiency)',efficiency_kappa,beta_efficiency[0,-5,5])" );
pWs->factory( "prod::efficiency(efficiency_nom,alpha_efficiency)" );
pWs->factory( "Gaussian::constr_efficiency(beta_efficiency,glob_efficiency[0,-5,5],1)" );
// signal yield
pWs->factory( "prod::nsig(lumi,xsec,efficiency)" );
// background yield with systematics
pWs->factory( "nbkg_nom[10.0, 5.0, 15.0]" );
pWs->factory( "nbkg_kappa[1.10]" );
pWs->factory( "cexpr::alpha_nbkg('pow(nbkg_kappa,beta_nbkg)',nbkg_kappa,beta_nbkg[0,-5,5])" );
pWs->factory( "prod::nbkg(nbkg_nom,alpha_lumi,alpha_nbkg)" );
pWs->factory( "Gaussian::constr_nbkg(beta_nbkg,glob_nbkg[0,-5,5],1)" );
// full event yield
pWs->factory("sum::yield(nsig,nbkg)");
// Core model: Poisson probability with mean signal+bkg
pWs->factory( "Poisson::model_core(n,yield)" );
// define Bayesian prior PDF for POI
pWs->factory( "Uniform::prior(xsec)" );
// model with systematics
pWs->factory( "PROD::model(model_core,constr_lumi,constr_efficiency,constr_nbkg)" );
// create set of observables (will need it for datasets and ModelConfig later)
RooRealVar * pObs = pWs->var("n"); // get the pointer to the observable
RooArgSet obs("observables");
obs.add(*pObs);
// create the dataset
pObs->setVal(11); // this is your observed data: we counted ten events
RooDataSet * data = new RooDataSet("data", "data", obs);
data->add( *pObs );
// import dataset into workspace
pWs->import(*data);
// create set of global observables (need to be defined as constants)
pWs->var("glob_lumi")->setConstant(true);
pWs->var("glob_efficiency")->setConstant(true);
pWs->var("glob_nbkg")->setConstant(true);
RooArgSet globalObs("global_obs");
globalObs.add( *pWs->var("glob_lumi") );
globalObs.add( *pWs->var("glob_efficiency") );
globalObs.add( *pWs->var("glob_nbkg") );
// create set of parameters of interest (POI)
RooArgSet poi("poi");
poi.add( *pWs->var("xsec") );
// create set of nuisance parameters
RooArgSet nuis("nuis");
nuis.add( *pWs->var("beta_lumi") );
nuis.add( *pWs->var("beta_efficiency") );
nuis.add( *pWs->var("beta_nbkg") );
// create signal+background Model Config
RooStats::ModelConfig sbHypo("SbHypo");
sbHypo.SetWorkspace( *pWs );
sbHypo.SetPdf( *pWs->pdf("model") );
sbHypo.SetObservables( obs );
sbHypo.SetGlobalObservables( globalObs );
sbHypo.SetParametersOfInterest( poi );
sbHypo.SetNuisanceParameters( nuis );
sbHypo.SetPriorPdf( *pWs->pdf("prior") ); // this is optional
// fix all other variables in model:
// everything except observables, POI, and nuisance parameters
// must be constant
pWs->var("lumi_nom")->setConstant(true);
pWs->var("efficiency_nom")->setConstant(true);
pWs->var("nbkg_nom")->setConstant(true);
pWs->var("lumi_kappa")->setConstant(true);
pWs->var("efficiency_kappa")->setConstant(true);
pWs->var("nbkg_kappa")->setConstant(true);
RooArgSet fixed("fixed");
fixed.add( *pWs->var("lumi_nom") );
fixed.add( *pWs->var("efficiency_nom") );
fixed.add( *pWs->var("nbkg_nom") );
fixed.add( *pWs->var("lumi_kappa") );
fixed.add( *pWs->var("efficiency_kappa") );
fixed.add( *pWs->var("nbkg_kappa") );
// set parameter snapshot that corresponds to the best fit to data
RooAbsReal * pNll = sbHypo.GetPdf()->createNLL( *data );
RooAbsReal * pProfile = pNll->createProfile( globalObs ); // do not profile global observables
pProfile->getVal(); // this will do fit and set POI and nuisance parameters to fitted values
RooArgSet * pPoiAndNuisance = new RooArgSet("poiAndNuisance");
pPoiAndNuisance->add(*sbHypo.GetNuisanceParameters());
pPoiAndNuisance->add(*sbHypo.GetParametersOfInterest());
sbHypo.SetSnapshot(*pPoiAndNuisance);
delete pProfile;
delete pNll;
delete pPoiAndNuisance;
// import S+B ModelConfig into workspace
pWs->import( sbHypo );
// create background-only Model Config from the S+B one
RooStats::ModelConfig bHypo = sbHypo;
bHypo.SetName("BHypo");
bHypo.SetWorkspace(*pWs);
// set parameter snapshot for bHypo, setting xsec=0
// it is useful to understand how this block of code works
// but you can also use it as a recipe to make a parameter snapshot
pNll = bHypo.GetPdf()->createNLL( *data );
RooArgSet poiAndGlobalObs("poiAndGlobalObs");
poiAndGlobalObs.add( poi );
poiAndGlobalObs.add( globalObs );
pProfile = pNll->createProfile( poiAndGlobalObs ); // do not profile POI and global observables
((RooRealVar *)poi.first())->setVal( 0 ); // set xsec=0 here
pProfile->getVal(); // this will do fit and set nuisance parameters to profiled values
pPoiAndNuisance = new RooArgSet( "poiAndNuisance" );
pPoiAndNuisance->add( nuis );
pPoiAndNuisance->add( poi );
bHypo.SetSnapshot(*pPoiAndNuisance);
delete pProfile;
delete pNll;
delete pPoiAndNuisance;
// import model config into workspace
pWs->import( bHypo );
// print out the workspace contents
pWs->Print();
// save workspace to file
pWs -> SaveAs("workspace.root");
return;
}
int main(int argc, char* argv[])
{
char *filename;
Int_t nexp = 0, nev = 0, SEED = 0;
Double_t c1val = 0., c2val = 0.;
Double_t c1pval = 0., c2pval = 0.;
Double_t c1mval = 0., c2mval = 0.;
for(Int_t i=1;i<argc;i++){
char *pchar = argv[i];
switch(pchar[0]){
case '-':{
switch(pchar[1]){
case 'f':
filename = argv[i+1];
cout << "File name used in this toy " << filename << endl;
break;
case 'e':
nexp = atoi(argv[i+1]);
cout << "Number of experiments " << nexp << endl;
break;
case 'n':
nev = atoi(argv[i+1]);
cout << "Number of events per experiment " << nev << endl;
break;
case 's':
SEED = atoi(argv[i+1]);
break;
case '1':
c1pval = atof(argv[i+1]);
cout << "The c1 value is " << c1pval << endl;
break;
case '2':
c1mval = atof(argv[i+1]);
cout << "The c1 value is " << c1mval << endl;
break;
case '3':
c2pval = atof(argv[i+1]);
cout << "The c2 values is " << c2pval << endl;
break;
case '4':
c2mval = atof(argv[i+1]);
cout << "The c2 values is " << c2mval << endl;
break;
case 'x':
c1val = atof(argv[i+1]);
cout << "The c1 value is " << c1pval << endl;
break;
case 'y':
c2val = atof(argv[i+1]);
cout << "The c2 values is " << c2pval << endl;
break;
}
}
}
}
//set the seed and the generator used by EvtGen
RooRandom::randomGenerator()->SetSeed(SEED);
cout << " Toy seed ............. " << (RooRandom::randomGenerator()->GetSeed()) << endl;
//define DalitzSpace for generation
EvtPDL pdl;
pdl.readPDT("evt.pdl");
EvtDecayMode mode("D0 -> K- pi+ pi0");
EvtDalitzPlot dalitzSpace(mode);
Bool_t doGen = kFALSE;
Bool_t doFit = kTRUE;
Bool_t extract = kFALSE;
RooRealVar tau("tau","tau",0.4099);
RooRealVar m2Kpi_d0mass("m2Kpi_d0mass","m2Kpi_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AB),dalitzSpace.qAbsMax(EvtCyclic3::AB));
RooRealVar m2Kpi0_d0mass("m2Kpi0_d0mass","m2Kpi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AC),dalitzSpace.qAbsMax(EvtCyclic3::AC));
RooRealVar d0Lifetime("d0Lifetime","d0Lifetime",-2.,4.);
RooRealVar d0LifetimeErr("d0LifetimeErr","d0LifetimeErr",0.0000001,0.5);
RooCategory D0flav("D0flav","D0flav");
D0flav.defineType("D0",-1);
D0flav.defineType("antiD0",1);
RooRealVar scalefact1("scalefact1","scalefact1",3.20);
RooRealVar scalefact2("scalefact2","scalefact2",1.42);
RooRealVar scalefact3("scalefact3","scalefact3",0.94);
RooRealVar c1("c1","c1",c1val,-3.,3.);
RooRealVar c2("c2","c2",c2val,-3.,3.);
RooRealVar c1p("c1p","c1p",c1pval,-3.,3.);
RooRealVar c2p("c2p","c2p",c2pval,-3.,3.);
RooRealVar c1m("c1m","c1m",c1mval,-3.,3.);
RooRealVar c2m("c2m","c2m",c2mval,-3.,3.);
c1p.setConstant(kTRUE);
c2p.setConstant(kTRUE);
m2Kpi_d0mass.setBins(10);
m2Kpi0_d0mass.setBins(10);
d0Lifetime.setBins(8);
d0LifetimeErr.setBins(10);
//Construct signal pdf
RooRealVar bias("bias","bias",0.0047);
RooRealVar one("one","one",1.);
//consider the resolution or the truth model
RooGaussModel gm1("gm1","gauss model 1",d0Lifetime,bias,d0LifetimeErr,one,scalefact1) ;
RooGaussModel gm2("gm2","gauss model 2",d0Lifetime,bias,d0LifetimeErr,one,scalefact2) ;
RooGaussModel gm3("gm3","gauss model 3",d0Lifetime,bias,d0LifetimeErr,one,scalefact3) ;
//RooTruthModel gm("gm","truth model",d0Lifetime);
RooRealVar N1("N1","N1",0.0052);
RooRealVar N2("N2","N2",0.179);
RooFormulaVar f2("f2","f2","(1-@0)*@1",RooArgList(N1,N2));
RooFormulaVar f3("f3","f3","(1-@0)*(1-@1)",RooArgList(N1,N2));
RooAddModel gm("gm","gm",RooArgList(gm2,gm3,gm1),RooArgList(f2,f3));
string dirname = "configmaps/effmapping_std/";
RooTimepdf TOTsigD0("TOTsigD0","TOTsigD0",d0Lifetime,m2Kpi_d0mass,m2Kpi0_d0mass,gm,&dalitzSpace,tau,c1p,c2p,-1,dirname);
RooTimepdf TOTsigantiD0("TOTsigantiD0","TOTsigantiD0",d0Lifetime,m2Kpi_d0mass,m2Kpi0_d0mass,gm,&dalitzSpace,tau,c1p,c2p,-1,dirname);
RooSimultaneous TOTTime("TOTTime","TOTTime",D0flav);
TOTTime.addPdf(TOTsigD0,"D0");
TOTTime.addPdf(TOTsigantiD0,"antiD0");
//////////////////////////
// BACKGROUND
/////////////////////////
TFile RSfile("DataSet_out_reduced_RS.root");
gROOT->cd();
RooDataSet *RSdata = (RooDataSet*)RSfile.Get("fulldata");
m2Kpi_d0mass.setBins(150);
m2Kpi0_d0mass.setBins(150);
d0Lifetime.setBins(70);
d0LifetimeErr.setBins(20);
/*
TH3F *mis_h = m2Kpi_d0mass.createHistogram("mis_h",m2Kpi0_d0mass,d0Lifetime,"");
RSdata->fillHistogram(mis_h,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime));
mis_h->Sumw2();
RooDataHist *mis_hist = new RooDataHist("mis_hist","mis_hist",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),mis_h);
RooHistPdf Tot_mis("Tot_mis","Tot_mis",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),*mis_hist);
*/
TH3F *mis_hp = m2Kpi_d0mass.createHistogram("mis_hp",m2Kpi0_d0mass,d0Lifetime,"");
RSdata->fillHistogram(mis_hp,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),"D0flav == 1");
mis_hp->Sumw2();
RooDataHist *mis_histp = new RooDataHist("mis_histp","mis_histp",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),mis_hp);
RooHistPdf Tot_misp("Tot_misp","Tot_misp",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),*mis_histp);
TH3F *mis_hm = m2Kpi_d0mass.createHistogram("mis_hm",m2Kpi0_d0mass,d0Lifetime,"");
RSdata->fillHistogram(mis_hm,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),"D0flav == -1");
mis_hm->Sumw2();
RooDataHist *mis_histm = new RooDataHist("mis_histm","mis_histm",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),mis_hm);
RooHistPdf Tot_mism("Tot_mism","Tot_mism",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),*mis_histm);
RooSimultaneous Tot_mis("Tot_mis","Tot_mis",D0flav);
Tot_mis.addPdf(Tot_misp,"D0");
Tot_mis.addPdf(Tot_mism,"antiD0");
cout << "///////////////" << endl;
cout << "Sample of D0bar RS : " << mis_histp->numEntries(kTRUE) << endl;
cout << "Sample of D0 RS : " << mis_histm->numEntries(kTRUE) << endl;
cout << "///////////////" << endl;
m2Kpi_d0mass.setBins(10);
m2Kpi0_d0mass.setBins(10);
d0Lifetime.setBins(8);
d0LifetimeErr.setBins(10);
RooArgSet observ(d0Lifetime,m2Kpi_d0mass,m2Kpi0_d0mass);
RooArgSet tot_var(d0Lifetime,m2Kpi_d0mass,m2Kpi0_d0mass,d0LifetimeErr,D0flav);
TFile WSfile("DataSet_out_reduced_WS.root");
gROOT->cd();
RooDataSet *databkg = (RooDataSet*)WSfile.Get("fulldata");
RooDataSet *leftdata = (RooDataSet*)databkg->reduce("d0Mass > 1.74 && d0Mass < 1.78");
RooDataSet *rightdata = (RooDataSet*)databkg->reduce("d0Mass > 1.94 && d0Mass < 1.98");
databkg->setWeightVar(0);
rightdata->setWeightVar(0);
leftdata->setWeightVar(0);
TH3F *lefth = m2Kpi_d0mass.createHistogram("lefth",m2Kpi0_d0mass,d0Lifetime,"");
leftdata->fillHistogram(lefth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime));
TH3F *righth = m2Kpi_d0mass.createHistogram("righth",m2Kpi0_d0mass,d0Lifetime,"");
rightdata->fillHistogram(righth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime));
righth->Scale(lefth->Integral()/righth->Integral());
lefth->Sumw2();
righth->Sumw2();
lefth->Add(righth);
lefth->Sumw2();
RooDataHist *lefthist = new RooDataHist("lefthist","lefthist",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),lefth);
RooHistPdf Tot_comb("Tot_comb","Tot_comb",RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime),*lefthist);
Float_t totnonorm = 1508. + 791. + 663. + 47.;
Float_t ratio = nev/totnonorm;
RooRealVar Nsig("Nsig","Nsig",1508.*ratio);
RooRealVar Nmis("Nmis","Nmis",791.*ratio);
RooRealVar Ncomb("Ncomb","Ncomb",(663. + 47.)*ratio);
d0LifetimeErr.setBins(100);
RooDataSet *ProtoData_err = (RooDataSet*)RSdata->reduce(RooArgSet(d0LifetimeErr));
TH1F *err_sig_h = (TH1F*)d0LifetimeErr.createHistogram("err_sig_h");
ProtoData_err->fillHistogram(err_sig_h,RooArgSet(d0LifetimeErr));
RooDataHist terr_sig("terr_sig","terr_sig",RooArgSet(d0LifetimeErr),err_sig_h);
RooHistPdf terr_sig_pdf("terr_sig_pdf","terr_sig_pdf",RooArgSet(d0LifetimeErr),terr_sig,3);
d0LifetimeErr.setBins(10);
RooDataSet *ProtoData_bkg = (RooDataSet*)databkg->reduce(RooArgSet(d0LifetimeErr));
TH1F *err_bkg_h = (TH1F*)d0LifetimeErr.createHistogram("err_bkg_h");
ProtoData_bkg->fillHistogram(err_bkg_h,RooArgSet(d0LifetimeErr));
err_bkg_h->Scale(err_sig_h->Integral()/err_bkg_h->Integral());
RooDataHist terr_bkg("terr_bkg","terr_bkg",RooArgSet(d0LifetimeErr),err_bkg_h);
RooHistPdf terr_bkg_pdf("terr_bkg_pdf","terr_bkg_pdf",RooArgSet(d0LifetimeErr),terr_bkg,3);
RooDataSet *ProtoData_flav_1 = (RooDataSet*)RSdata->reduce(RooArgSet(D0flav));
RooDataSet *ProtoData_flav = (RooDataSet*)ProtoData_flav_1->reduce(EventRange(1,(Int_t)((1508 + 791)*ratio)));
//RooDataHist flav_sig("flav_sig","flav_sig",RooArgSet(D0flav),*ProtoData_flav);
//RooHistPdf flav_sig_pdf("flav_sig_pdf","flav_sig_pdf",RooArgSet(D0flav),flav_sig);
RooDataSet *ProtoData_flav_bkg_1 = (RooDataSet*)databkg->reduce(RooArgSet(D0flav));
RooDataSet *ProtoData_flav_bkg = (RooDataSet*)ProtoData_flav_bkg_1->reduce(EventRange(1,(Int_t)((663 + 47)*ratio)));
//RooDataHist flav_bkg("flav_bkg","flav_bkg",RooArgSet(D0flav),*ProtoData_flav_bkg);
//RooHistPdf flav_bkg_pdf("flav_bkg_pdf","flav_bkg_pdf",RooArgSet(D0flav),flav_bkg);
ProtoData_flav->append(*ProtoData_flav_bkg);
RooProdPdf totsig_norm("totsig_norm","totsig_norm",RooArgSet(terr_sig_pdf),Conditional(TOTTime,observ));
RooProdPdf totmis_norm("totmis_norm","totmis_norm",RooArgSet(terr_sig_pdf),Conditional(Tot_mis,observ));
RooProdPdf totbkg_norm("totbkg_norm","totbkg_norm",RooArgSet(terr_bkg_pdf),Conditional(Tot_comb,observ));
/*
RooProdPdf totsig_norm("totsig_norm","totsig_norm",RooArgSet(terr_sig_pdf),Conditional(TOTsigD0,observ));
RooProdPdf totmis_norm("totmis_norm","totmis_norm",RooArgSet(terr_sig_pdf),Conditional(Tot_mis,observ));
RooProdPdf totbkg_norm("totbkg_norm","totbkg_norm",RooArgSet(terr_bkg_pdf),Conditional(Tot_comb,observ));
*/
//Signal + background
RooAddPdf TOTpdf("TOTpdf","TOTpdf",RooArgList(totsig_norm,totmis_norm,totbkg_norm),RooArgList(Nsig,Nmis,Ncomb));
RooMCStudy mgr(totsig_norm,tot_var,FitOptions(Save(1),Extended(0),Minos(0)),Extended(0),ConditionalObservables(D0flav),RooFit::ProtoData(*ProtoData_flav,1));
//RooMCStudy mgr(totsig_norm,tot_var,FitOptions(ConditionalObservables(RooArgSet(D0flav)),Save(1),Extended(0)),Extended(0),RooFit::ProtoData(*ConditDataset,1));
TString dataname(filename);
dataname.Append(".dat");
TString toyname(filename);
toyname.Append("_fixed.root");
if(doGen && !doFit) mgr.generate(nexp,nev,kFALSE,dataname);
if(doFit && !doGen) mgr.fit(nexp,dataname);
if(doGen && doFit) mgr.generateAndFit(nexp,nev,kFALSE,dataname);
if(doFit){
TFile f(toyname,"RECREATE");
f.cd();
(RooFitResult*)mgr.fitResult(0)->Write();
mgr.fitParDataSet().tree().Write();
f.Close();
}
if(extract){
RooFitResult *theRes = (RooFitResult*)mgr.fitResult(0);
RooRealVar myc1("myc1","myc1",-10.,10.);
RooRealVar myc2("myc2","myc2",-10.,10.);
RooRealVar myratio("myratio","myratio",0.,0.,1.);
RooRealVar myx("myx","myx",0.,-1.,1.);
RooRealVar myy("myy","myy",0.,-1.,1.);
Double_t NrsNws = 2760./1198329;
Double_t ratioerr = sqrt(pow(96.,2.) + pow(NrsNws,2.)*pow(2760.,2.))/1198329.;
RooDataSet *parFloat = new RooDataSet("parFloat","parFloat",RooArgList(myratio,myx,myy));
RooTimepdf mysigD0("mysigD0","mysigD0",d0Lifetime,m2Kpi_d0mass,m2Kpi0_d0mass,gm,&dalitzSpace,tau,c1,c2,-1,dirname);
Double_t myDenom = mysigD0.createIntegral(RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime))->getVal();
cout << "x' " << c2.getVal()*sqrt(NrsNws/myDenom) << endl;
cout << "y' " << c1.getVal()*sqrt(NrsNws/myDenom) << endl;
cout << "r0^2 " << NrsNws/myDenom << endl;
for(Int_t j=0;j<1000;j++){
cout << "Performing step number " << j << endl;
RooArgList floated = theRes->randomizePars();
myc1.setVal(((RooAbsReal*)floated.find("c1"))->getVal());
myc2.setVal(((RooAbsReal*)floated.find("c2"))->getVal());
Double_t myDenom = mysigD0.createIntegral(RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass,d0Lifetime))->getVal();
Double_t myNum = RooRandom::randomGenerator()->Gaus(NrsNws,ratioerr);
myratio.setVal(myNum/myDenom);
myx.setVal(myc2.getVal()*sqrt((myNum/myDenom)));
myy.setVal(myc1.getVal()*sqrt((myNum/myDenom)));
parFloat->add(RooArgSet(myratio,myx,myy));
}
TString floatname(filename);
floatname.Append("_float.root");
TFile *f1 = new TFile(floatname,"RECREATE");
f1->cd();
parFloat->Write();
f1->Close();
}
return 0;
}
int main(int argc, char *argv[]){
OptionParser(argc,argv);
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
RooMsgService::instance().setSilentMode(true);
system(Form("mkdir -p %s",outdir_.c_str()));
vector<string> procs;
split(infilenames_,infilenamesStr_,boost::is_any_of(","));
TPython::Exec("import os,imp,re");
const char * env = gSystem->Getenv("CMSSW_BASE") ;
std::string globeRt = env;
TPython::Exec(Form("buildSMHiggsSignalXSBR = imp.load_source('*', '%s/src/flashggFinalFit/Signal/python/buildSMHiggsSignalXSBR.py')",globeRt.c_str()));
TPython::Eval(Form("buildSMHiggsSignalXSBR.Init%dTeV()", 13));
for (unsigned int i =0 ; i<infilenames_.size() ; i++){
int mH =(int) TPython::Eval(Form("int(re.search('_M(.+?)_','%s').group(1))",infilenames_[i].c_str()));
double WH_XS = (double)TPython::Eval(Form("buildSMHiggsSignalXSBR.getXS(%d,'%s')",mH,"WH"));
double ZH_XS = (double)TPython::Eval(Form("buildSMHiggsSignalXSBR.getXS(%d,'%s')",mH,"ZH"));
float tot_XS = WH_XS + ZH_XS;
float wFrac= WH_XS /tot_XS ;
float zFrac= ZH_XS /tot_XS ;
std::cout << "mass "<< mH << " wh fraction "<< WH_XS /tot_XS << ", zh fraction "<< ZH_XS /tot_XS <<std::endl;
TFile *infile = TFile::Open(infilenames_[i].c_str());
string outname =(string) TPython::Eval(Form("'%s'.split(\"/\")[-1].replace(\"VH\",\"WH_VH\")",infilenames_[i].c_str()));
TFile *outfile = TFile::Open(outname.c_str(),"RECREATE") ;
TDirectory* saveDir = outfile->mkdir("tagsDumper");
saveDir->cd();
RooWorkspace *inWS = (RooWorkspace*) infile->Get("tagsDumper/cms_hgg_13TeV");
RooRealVar *intLumi = (RooRealVar*)inWS->var("IntLumi");
RooWorkspace *outWS = new RooWorkspace("cms_hgg_13TeV");
outWS->import(*intLumi);
std::list<RooAbsData*> data = (inWS->allData()) ;
std::cout <<" [INFO] Reading WS dataset contents: "<< std::endl;
for (std::list<RooAbsData*>::const_iterator iterator = data.begin(), end = data.end(); iterator != end; ++iterator ) {
RooDataSet *dataset = dynamic_cast<RooDataSet *>( *iterator );
if (dataset) {
string zhname =(string) TPython::Eval(Form("'%s'.replace(\"wzh\",\"zh\")",dataset->GetName()));
string whname =(string) TPython::Eval(Form("'%s'.replace(\"wzh\",\"wh\")",dataset->GetName()));
RooDataSet *datasetZH = (RooDataSet*) dataset->emptyClone(zhname.c_str(),zhname.c_str());
RooDataSet *datasetWH = (RooDataSet*) dataset->emptyClone(whname.c_str(),whname.c_str());
TRandom3 r;
r.Rndm();
double x[dataset->numEntries()];
r.RndmArray(dataset->numEntries(),x);
for (int j =0; j < dataset->numEntries() ; j++){
if( x[j] < wFrac){
dataset->get(j);
datasetWH->add(*(dataset->get(j)),dataset->weight());
} else{
dataset->get(j);
datasetZH->add(*(dataset->get(j)),dataset->weight());
}
}
float w =datasetWH->sumEntries();
float z =datasetZH->sumEntries();
if(verbose_){
std::cout << "Original dataset " << *dataset <<std::endl;
std::cout << "WH dataset " << *datasetWH <<std::endl;
std::cout << "ZH dataset " << *datasetZH <<std::endl;
std::cout << "********************************************" <<std::endl;
std::cout << "WH fraction (obs) : WH " << w/(w+z) <<", ZH "<< z/(w+z) << std::endl;
std::cout << "WH fraction (exp) : WH " << wFrac <<", ZH "<< zFrac << std::endl;
std::cout << "********************************************" <<std::endl;
std::cout << "" <<std::endl;
std::cout << "" <<std::endl;
std::cout << "" <<std::endl;
std::cout << "********************************************" <<std::endl;
}
outWS->import(*datasetWH);
outWS->import(*datasetZH);
}
RooDataHist *datahist = dynamic_cast<RooDataHist *>( *iterator );
if (datahist) {
string zhname =(string) TPython::Eval(Form("'%s'.replace(\"wzh\",\"zh\")",datahist->GetName()));
string whname =(string) TPython::Eval(Form("'%s'.replace(\"wzh\",\"wh\")",datahist->GetName()));
RooDataHist *datahistZH = (RooDataHist*) datahist->emptyClone(zhname.c_str(),zhname.c_str());
RooDataHist *datahistWH = (RooDataHist*) datahist->emptyClone(whname.c_str(),whname.c_str());
TRandom3 r;
r.Rndm();
double x[datahist->numEntries()];
r.RndmArray(datahist->numEntries(),x);
for (int j =0; j < datahist->numEntries() ; j++){
datahistWH->add(*(datahist->get(j)),datahist->weight()*wFrac);
datahistZH->add(*(datahist->get(j)),datahist->weight()*zFrac);
}
float w =datahistWH->sumEntries();
float z =datahistZH->sumEntries();
if(verbose_){
std::cout << "Original datahist " << *datahist <<std::endl;
std::cout << "WH datahist " << *datahistWH <<std::endl;
std::cout << "ZH datahist " << *datahistZH <<std::endl;
std::cout << "********************************************" <<std::endl;
std::cout << "WH fraction (obs) : WH " << w/(w+z) <<", ZH "<< z/(w+z) << std::endl;
std::cout << "WH fraction (exp) : WH " << wFrac <<", ZH "<< zFrac << std::endl;
std::cout << "********************************************" <<std::endl;
std::cout << "" <<std::endl;
std::cout << "" <<std::endl;
std::cout << "" <<std::endl;
std::cout << "********************************************" <<std::endl;
}
outWS->import(*datahistWH);
outWS->import(*datahistZH);
}
}
saveDir->cd();
outWS->Write();
outfile->Close();
infile->Close();
}
}
///
/// Perform the 1d Prob scan.
/// Saves chi2 values and the prob-Scan p-values in a root tree
/// For the datasets stuff, we do not yet have a MethodDatasetsProbScan class, so we do it all in
/// MethodDatasetsProbScan
/// \param nRun Part of the root tree file name to facilitate parallel production.
///
int MethodDatasetsProbScan::scan1d(bool fast, bool reverse)
{
if (fast) return 0; // tmp
if ( arg->debug ) cout << "MethodDatasetsProbScan::scan1d() : starting ... " << endl;
// Set limit to all parameters.
this->loadParameterLimits(); /// Default is "free", if not changed by cmd-line parameter
// Define scan parameter and scan range.
RooRealVar *parameterToScan = w->var(scanVar1);
float parameterToScan_min = hCL->GetXaxis()->GetXmin();
float parameterToScan_max = hCL->GetXaxis()->GetXmax();
// do a free fit
RooFitResult *result = this->loadAndFit(this->pdf); // fit on data
assert(result);
RooSlimFitResult *slimresult = new RooSlimFitResult(result,true);
slimresult->setConfirmed(true);
solutions.push_back(slimresult);
double freeDataFitValue = w->var(scanVar1)->getVal();
// Define outputfile
system("mkdir -p root");
TString probResName = Form("root/scan1dDatasetsProb_" + this->pdf->getName() + "_%ip" + "_" + scanVar1 + ".root", arg->npoints1d);
TFile* outputFile = new TFile(probResName, "RECREATE");
// Set up toy root tree
this->probScanTree = new ToyTree(this->pdf, arg);
this->probScanTree->init();
this->probScanTree->nrun = -999; //\todo: why does this branch even exist in the output tree of the prob scan?
// Save parameter values that were active at function
// call. We'll reset them at the end to be transparent
// to the outside.
RooDataSet* parsFunctionCall = new RooDataSet("parsFunctionCall", "parsFunctionCall", *w->set(pdf->getParName()));
parsFunctionCall->add(*w->set(pdf->getParName()));
// start scan
cout << "MethodDatasetsProbScan::scan1d_prob() : starting ... with " << nPoints1d << " scanpoints..." << endl;
ProgressBar progressBar(arg, nPoints1d);
for ( int i = 0; i < nPoints1d; i++ )
{
progressBar.progress();
// scanpoint is calculated using min, max, which are the hCL x-Axis limits set in this->initScan()
// this uses the "scan" range, as expected
// don't add half the bin size. try to solve this within plotting method
float scanpoint = parameterToScan_min + (parameterToScan_max - parameterToScan_min) * (double)i / ((double)nPoints1d - 1);
if (arg->debug) cout << "DEBUG in MethodDatasetsProbScan::scan1d_prob() " << scanpoint << " " << parameterToScan_min << " " << parameterToScan_max << endl;
this->probScanTree->scanpoint = scanpoint;
if (arg->debug) cout << "DEBUG in MethodDatasetsProbScan::scan1d_prob() - scanpoint in step " << i << " : " << scanpoint << endl;
// don't scan in unphysical region
// by default this means checking against "free" range
if ( scanpoint < parameterToScan->getMin() || scanpoint > parameterToScan->getMax() + 2e-13 ) {
cout << "it seems we are scanning in an unphysical region: " << scanpoint << " < " << parameterToScan->getMin() << " or " << scanpoint << " > " << parameterToScan->getMax() + 2e-13 << endl;
exit(EXIT_FAILURE);
}
// FIT TO REAL DATA WITH FIXED HYPOTHESIS(=SCANPOINT).
// THIS GIVES THE NUMERATOR FOR THE PROFILE LIKELIHOOD AT THE GIVEN HYPOTHESIS
// THE RESULTING NUISANCE PARAMETERS TOGETHER WITH THE GIVEN HYPOTHESIS ARE ALSO
// USED WHEN SIMULATING THE TOY DATA FOR THE FELDMAN-COUSINS METHOD FOR THIS HYPOTHESIS(=SCANPOINT)
// Here the scanvar has to be fixed -> this is done once per scanpoint
// and provides the scanner with the DeltaChi2 for the data as reference
// additionally the nuisances are set to the resulting fit values
parameterToScan->setVal(scanpoint);
parameterToScan->setConstant(true);
RooFitResult *result = this->loadAndFit(this->pdf); // fit on data
assert(result);
if (arg->debug) {
cout << "DEBUG in MethodDatasetsProbScan::scan1d_prob() - minNll data scan at scan point " << scanpoint << " : " << 2 * result->minNll() << ": "<< 2 * pdf->getMinNll() << endl;
}
this->probScanTree->statusScanData = result->status();
// set chi2 of fixed fit: scan fit on data
// CAVEAT: chi2min from fitresult gives incompatible results to chi2min from pdf
// this->probScanTree->chi2min = 2 * result->minNll();
this->probScanTree->chi2min = 2 * pdf->getMinNll();
this->probScanTree->covQualScanData = result->covQual();
this->probScanTree->scanbest = freeDataFitValue;
// After doing the fit with the parameter of interest constrained to the scanpoint,
// we are now saving the fit values of the nuisance parameters. These values will be
// used to generate toys according to the PLUGIN method.
this->probScanTree->storeParsScan(); // \todo : figure out which one of these is semantically the right one
this->pdf->deleteNLL();
// also save the chi2 of the free data fit to the tree:
this->probScanTree->chi2minGlobal = this->getChi2minGlobal();
this->probScanTree->chi2minBkg = this->getChi2minBkg();
this->probScanTree->genericProbPValue = this->getPValueTTestStatistic(this->probScanTree->chi2min - this->probScanTree->chi2minGlobal);
this->probScanTree->fill();
if(arg->debug && pdf->getBkgPdf())
{
float pval_cls = this->getPValueTTestStatistic(this->probScanTree->chi2min - this->probScanTree->chi2minBkg, true);
cout << "DEBUG in MethodDatasetsProbScan::scan1d() - p value CLs: " << pval_cls << endl;
}
// reset
setParameters(w, pdf->getParName(), parsFunctionCall->get(0));
//setParameters(w, pdf->getObsName(), obsDataset->get(0));
} // End of npoints loop
probScanTree->writeToFile();
if (bkgOnlyFitResult) bkgOnlyFitResult->Write();
if (dataFreeFitResult) dataFreeFitResult->Write();
outputFile->Close();
std::cout << "Wrote ToyTree to file" << std::endl;
delete parsFunctionCall;
// This is kind of a hack. The effect is supposed to be the same as callincg
// this->sethCLFromProbScanTree(); here, but the latter gives a segfault somehow....
// \todo: use this->sethCLFromProbScanTree() directly after figuring out the cause of the segfault.
this->loadScanFromFile();
return 0;
}
void embeddedToysVBF_1DKD(int nEvts=50, int nToys=100,
sample mySample = kScalar_fa3_0){
RooRealVar* kd = new RooRealVar("psMELA","psMELA",0,1);
kd->setBins(50);
RooPlot* kdframe1 = kd->frame();
// 0- template
TFile f1("ggH2j_KDdistribution_ps.root", "READ");
TH2F *h_KD_ps = (TH2F*)f1.Get("h_KD");
h_KD_ps->SetName("h_KD_ps");
RooDataHist rdh_KD_ps("rdh_KD_ps","rdh_KD_ps",RooArgList(*kd),h_KD_ps);
RooHistPdf pdf_KD_ps("pdf_KD_ps","pdf_KD_ps",RooArgList(*kd),rdh_KD_ps);
// 0+ template
TFile f2("ggH2j_KDdistribution_sm.root", "READ");
TH2F *h_KD_sm = (TH2F*)f2.Get("h_KD");
h_KD_sm->SetName("h_KD_sm");
RooDataHist rdh_KD_sm("rdh_KD_sm","rdh_KD_sm",RooArgList(*kd),h_KD_sm);
RooHistPdf pdf_KD_sm("pdf_KD_sm","pdf_KD_sm",RooArgList(*kd),rdh_KD_sm);
RooRealVar rrv_fa3("fa3","fa3",0.5,0.,1.); //free parameter of the model
RooAddPdf model("model","ps+sm",pdf_KD_ps,pdf_KD_sm,rrv_fa3);
rrv_fa3.setConstant(kFALSE);
TCanvas* c = new TCanvas("modelPlot","modelPlot",400,400);
rdh_KD_ps.plotOn(kdframe1,LineColor(kBlack));
pdf_KD_ps.plotOn(kdframe1,LineColor(kBlack));
rdh_KD_sm.plotOn(kdframe1,LineColor(kBlue));
pdf_KD_sm.plotOn(kdframe1,LineColor(kBlue));
model.plotOn(kdframe1,LineColor(kRed));
kdframe1->Draw();
c->SaveAs("model1DPlot.png");
c->SaveAs("model1DPlot.eps");
double fa3Val=-99;
if (mySample == kScalar_fa3_0)
fa3Val=0.;
else if (mySample == kScalar_fa3_1)
fa3Val=1;
else{
cout<<"fa3Val not correct!"<<endl;
return 0;
}
TCanvas* c = new TCanvas("modelPlot","modelPlot",400,400);
rdh_KD_ps.plotOn(kdframe1,LineColor(kBlack));
pdf_KD_ps.plotOn(kdframe1,LineColor(kBlack));
rdh_KD_sm.plotOn(kdframe1,LineColor(kBlue));
pdf_KD_sm.plotOn(kdframe1,LineColor(kBlue));
model.plotOn(kdframe1,LineColor(kRed));
kdframe1->Draw();
TChain* myChain = new TChain("newTree");
myChain->Add(inputFileNames[mySample]);
if(!myChain || myChain->GetEntries()<=0) {
cout<<"error in the tree"<<endl;
return 0;
}
RooDataSet* data = new RooDataSet("data","data",myChain,RooArgSet(*kd),"");
cout << "Number of events in data: " << data->numEntries() << endl;
// initialize tree to save toys to
TTree* results = new TTree("results","toy results");
double fa3,fa3Error, fa3Pull;
double fa2,fa2Error, fa2Pull;
double phia2, phia2Error, phia2Pull;
double phia3, phia3Error, phia3Pull;
results->Branch("fa3",&fa3,"fa3/D");
results->Branch("fa3Error",&fa3Error,"fa3Error/D");
results->Branch("fa3Pull",&fa3Pull,"fa3Pull/D");
//---------------------------------
RooDataSet* toyData;
int embedTracker=0;
RooArgSet *tempEvent;
RooFitResult *toyfitresults;
RooRealVar *r_fa3;
for(int i = 0 ; i<nToys ; i++){
cout <<i<<"<-----------------------------"<<endl;
//if(toyData) delete toyData;
toyData = new RooDataSet("toyData","toyData",RooArgSet(*kd));
if(nEvts+embedTracker > data->sumEntries()){
cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl;
toyData = NULL;
abort();
return 0;
}
for(int iEvent=0; iEvent<nEvts; iEvent++){
if(iEvent==1)
cout << "generating event: " << iEvent << " embedTracker: " << embedTracker << endl;
tempEvent = (RooArgSet*) data->get(embedTracker);
toyData->add(*tempEvent);
embedTracker++;
}
toyfitresults =model.fitTo(*toyData,Save());
cout<<toyfitresults<<endl;
r_fa3 = (RooRealVar *) toyfitresults->floatParsFinal().find("fa3");
fa3 = r_fa3->getVal();
fa3Error = r_fa3->getError();
fa3Pull = (r_fa3->getVal() - fa3Val) / r_fa3->getError();
// fill TTree
results->Fill();
//model.clear();
}
char nEvtsString[100];
sprintf(nEvtsString,"_%iEvts",nEvts);
// write tree to output file (ouputFileName set at top)
TFile *outputFile = new TFile("embeddedToysVBF_fa3Corr_"+sampleName[mySample]+nEvtsString+".root","RECREATE");
results->Write();
outputFile->Close();
}
void KinZfitter::MakeModel(/*RooWorkspace &w,*/ KinZfitter::FitInput &input, KinZfitter::FitOutput &output) {
//lep
RooRealVar pTRECO1_lep("pTRECO1_lep", "pTRECO1_lep", input.pTRECO1_lep, 5, 500);
RooRealVar pTRECO2_lep("pTRECO2_lep", "pTRECO2_lep", input.pTRECO2_lep, 5, 500);
RooRealVar pTMean1_lep("pTMean1_lep", "pTMean1_lep",
input.pTRECO1_lep, max(5.0, input.pTRECO1_lep-2*input.pTErr1_lep), input.pTRECO1_lep+2*input.pTErr1_lep);
RooRealVar pTMean2_lep("pTMean2_lep", "pTMean2_lep",
input.pTRECO2_lep, max(5.0, input.pTRECO2_lep-2*input.pTErr2_lep), input.pTRECO2_lep+2*input.pTErr2_lep);
RooRealVar pTSigma1_lep("pTSigma1_lep", "pTSigma1_lep", input.pTErr1_lep);
RooRealVar pTSigma2_lep("pTSigma2_lep", "pTSigma2_lep", input.pTErr2_lep);
RooRealVar theta1_lep("theta1_lep", "theta1_lep", input.theta1_lep);
RooRealVar theta2_lep("theta2_lep", "theta2_lep", input.theta2_lep);
RooRealVar phi1_lep("phi1_lep", "phi1_lep", input.phi1_lep);
RooRealVar phi2_lep("phi2_lep", "phi2_lep", input.phi2_lep);
RooRealVar m1("m1", "m1", input.m1);
RooRealVar m2("m2", "m2", input.m2);
//gamma
RooRealVar pTRECO1_gamma("pTRECO1_gamma", "pTRECO1_gamma", input.pTRECO1_gamma, 5, 500);
RooRealVar pTRECO2_gamma("pTRECO2_gamma", "pTRECO2_gamma", input.pTRECO2_gamma, 5, 500);
RooRealVar pTMean1_gamma("pTMean1_gamma", "pTMean1_gamma",
input.pTRECO1_gamma, max(0.5, input.pTRECO1_gamma-2*input.pTErr1_gamma), input.pTRECO1_gamma+2*input.pTErr1_gamma);
RooRealVar pTMean2_gamma("pTMean2_gamma", "pTMean2_gamma",
input.pTRECO2_gamma, max(0.5, input.pTRECO2_gamma-2*input.pTErr2_gamma), input.pTRECO2_gamma+2*input.pTErr2_gamma);
RooRealVar pTSigma1_gamma("pTSigma1_gamma", "pTSigma1_gamma", input.pTErr1_gamma);
RooRealVar pTSigma2_gamma("pTSigma2_gamma", "pTSigma2_gamma", input.pTErr2_gamma);
RooRealVar theta1_gamma("theta1_gamma", "theta1_gamma", input.theta1_gamma);
RooRealVar theta2_gamma("theta2_gamma", "theta2_gamma", input.theta2_gamma);
RooRealVar phi1_gamma("phi1_gamma", "phi1_gamma", input.phi1_gamma);
RooRealVar phi2_gamma("phi2_gamma", "phi2_gamma", input.phi2_gamma);
//gauss
RooGaussian gauss1_lep("gauss1_lep", "gauss1_lep", pTRECO1_lep, pTMean1_lep, pTSigma1_lep);
RooGaussian gauss2_lep("gauss2_lep", "gauss2_lep", pTRECO2_lep, pTMean2_lep, pTSigma2_lep);
RooGaussian gauss1_gamma("gauss1_gamma", "gauss1_gamma", pTRECO1_gamma, pTMean1_gamma, pTSigma1_gamma);
RooGaussian gauss2_gamma("gauss2_gamma", "gauss2_gamma", pTRECO2_gamma, pTMean2_gamma, pTSigma2_gamma);
TString makeE_lep = "TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1)))+@2*@2)";
RooFormulaVar E1_lep("E1_lep", makeE_lep, RooArgList(pTMean1_lep, theta1_lep, m1)); //w.import(E1_lep);
RooFormulaVar E2_lep("E2_lep", makeE_lep, RooArgList(pTMean2_lep, theta2_lep, m2)); //w.import(E2_lep);
TString makeE_gamma = "TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1))))";
RooFormulaVar E1_gamma("E1_gamma", makeE_gamma, RooArgList(pTMean1_gamma, theta1_gamma)); //w.import(E1_gamma);
RooFormulaVar E2_gamma("E2_gamma", makeE_gamma, RooArgList(pTMean2_gamma, theta2_gamma)); //w.import(E2_gamma);
//dotProduct 3d
TString dotProduct_3d = "@0*@1*( ((TMath::Cos(@2))*(TMath::Cos(@3)))/((TMath::Sin(@2))*(TMath::Sin(@3)))+(TMath::Cos(@4-@5)))";
RooFormulaVar p1v3D2("p1v3D2", dotProduct_3d, RooArgList(pTMean1_lep, pTMean2_lep, theta1_lep, theta2_lep, phi1_lep, phi2_lep));
RooFormulaVar p1v3Dph1("p1v3Dph1", dotProduct_3d, RooArgList(pTMean1_lep, pTMean1_gamma, theta1_lep, theta1_gamma, phi1_lep, phi1_gamma));
RooFormulaVar p2v3Dph1("p2v3Dph1", dotProduct_3d, RooArgList(pTMean2_lep, pTMean1_gamma, theta2_lep, theta1_gamma, phi2_lep, phi1_gamma));
RooFormulaVar p1v3Dph2("p1v3Dph2", dotProduct_3d, RooArgList(pTMean1_lep, pTMean2_gamma, theta1_lep, theta2_gamma, phi1_lep, phi2_gamma));
RooFormulaVar p2v3Dph2("p2v3Dph2", dotProduct_3d, RooArgList(pTMean2_lep, pTMean2_gamma, theta2_lep, theta2_gamma, phi2_lep, phi2_gamma));
RooFormulaVar ph1v3Dph2("ph1v3Dph2", dotProduct_3d, RooArgList(pTMean1_gamma, pTMean2_gamma, theta1_gamma, theta2_gamma, phi1_gamma, phi2_gamma));
TString dotProduct_4d = "@0*@1-@2";
RooFormulaVar p1D2("p1D2", dotProduct_4d, RooArgList(E1_lep, E2_lep, p1v3D2)); //w.import(p1D2);
RooFormulaVar p1Dph1("p1Dph1", dotProduct_4d, RooArgList(E1_lep, E1_gamma, p1v3Dph1));// w.import(p1Dph1);
RooFormulaVar p2Dph1("p2Dph1", dotProduct_4d, RooArgList(E2_lep, E1_gamma, p2v3Dph1)); // w.import(p2Dph1);
RooFormulaVar p1Dph2("p1Dph2", dotProduct_4d, RooArgList(E1_lep, E2_gamma, p1v3Dph2)); //w.import(p1Dph2);
RooFormulaVar p2Dph2("p2Dph2", dotProduct_4d, RooArgList(E2_lep, E2_gamma, p2v3Dph2)); //w.import(p2Dph2);
RooFormulaVar ph1Dph2("ph1Dph2", dotProduct_4d, RooArgList(E1_gamma, E2_gamma, ph1v3Dph2)); // w.import(ph1Dph2);
RooRealVar bwMean("bwMean", "m_{Z^{0}}", 91.187); //w.import(bwMean);
RooRealVar bwGamma("bwGamma", "#Gamma", 2.5);
RooProdPdf* PDFRelBW;
RooFormulaVar* mZ;
RooGenericPdf* RelBW;
//mZ
mZ = new RooFormulaVar("mZ", "TMath::Sqrt(2*@0+@1*@1+@2*@2)", RooArgList(p1D2, m1, m2));
RelBW = new RooGenericPdf("RelBW","1/( pow(mZ*mZ-bwMean*bwMean,2)+pow(mZ,4)*pow(bwGamma/bwMean,2) )", RooArgSet(*mZ,bwMean,bwGamma) );
PDFRelBW = new RooProdPdf("PDFRelBW", "PDFRelBW", RooArgList(gauss1_lep, gauss2_lep, *RelBW));
if (input.nFsr == 1) {
mZ = new RooFormulaVar("mZ", "TMath::Sqrt(2*@0+2*@1+2*@2+@3*@3+@4*@4)", RooArgList(p1D2, p1Dph1, p2Dph1, m1, m2));
RelBW = new RooGenericPdf("RelBW","1/( pow(mZ*mZ-bwMean*bwMean,2)+pow(mZ,4)*pow(bwGamma/bwMean,2) )", RooArgSet(*mZ,bwMean,bwGamma) );
// PDFRelBW = new RooProdPdf("PDFRelBW", "PDFRelBW", RooArgList(gauss1_lep, gauss2_lep, gauss1_gamma, *RelBW));
}
if (input.nFsr == 2) {
mZ = new RooFormulaVar("mZ", "TMath::Sqrt(2*@0+2*@1+2*@2+2*@3+2*@4+2*@5+@6*@6+@7*@7)", RooArgList(p1D2,p1Dph1,p2Dph1,p1Dph2,p2Dph2,ph1Dph2, m1, m2));
RelBW = new RooGenericPdf("RelBW","1/( pow(mZ*mZ-bwMean*bwMean,2)+pow(mZ,4)*pow(bwGamma/bwMean,2) )", RooArgSet(*mZ,bwMean,bwGamma) );
// PDFRelBW = new RooProdPdf("PDFRelBW", "PDFRelBW", RooArgList(gauss1_lep, gauss2_lep, gauss1_gamma, gauss2_gamma, *RelBW));
}
//true shape
RooRealVar sg("sg", "sg", sgVal_);
RooRealVar a("a", "a", aVal_);
RooRealVar n("n", "n", nVal_);
RooCBShape CB("CB","CB",*mZ,bwMean,sg,a,n);
RooRealVar f("f","f", fVal_);
RooRealVar mean("mean","mean",meanVal_);
RooRealVar sigma("sigma","sigma",sigmaVal_);
RooRealVar f1("f1","f1",f1Val_);
RooAddPdf *RelBWxCB;
RelBWxCB = new RooAddPdf("RelBWxCB","RelBWxCB", *RelBW, CB, f);
RooGaussian *gauss;
gauss = new RooGaussian("gauss","gauss",*mZ,mean,sigma);
RooAddPdf *RelBWxCBxgauss;
RelBWxCBxgauss = new RooAddPdf("RelBWxCBxgauss","RelBWxCBxgauss", *RelBWxCB, *gauss, f1);
RooProdPdf *PDFRelBWxCBxgauss;
PDFRelBWxCBxgauss = new RooProdPdf("PDFRelBWxCBxgauss","PDFRelBWxCBxgauss",
RooArgList(gauss1_lep, gauss2_lep, *RelBWxCBxgauss) );
//make fit
RooArgSet *rastmp;
rastmp = new RooArgSet(pTRECO1_lep, pTRECO2_lep);
/*
if(input.nFsr == 1) {
rastmp = new RooArgSet(pTRECO1_lep, pTRECO2_lep, pTRECO1_gamma);
}
if(input.nFsr == 2) {
rastmp = new RooArgSet(pTRECO1_lep, pTRECO2_lep, pTRECO1_gamma, pTRECO2_gamma);
}
*/
RooDataSet* pTs = new RooDataSet("pTs","pTs", *rastmp);
pTs->add(*rastmp);
RooFitResult* r;
if (mass4lRECO_ > 140) {
r = PDFRelBW->fitTo(*pTs,RooFit::Save(),RooFit::PrintLevel(-1));
} else {
r = PDFRelBWxCBxgauss->fitTo(*pTs,RooFit::Save(),RooFit::PrintLevel(-1));
}
//save fit result
const TMatrixDSym& covMatrix = r->covarianceMatrix();
const RooArgList& finalPars = r->floatParsFinal();
for (int i=0 ; i<finalPars.getSize(); i++){
TString name = TString(((RooRealVar*)finalPars.at(i))->GetName());
if(debug_) cout<<"name list of RooRealVar for covariance matrix "<<name<<endl;
}
int size = covMatrix.GetNcols();
output.covMatrixZ.ResizeTo(size,size);
output.covMatrixZ = covMatrix;
output.pT1_lep = pTMean1_lep.getVal();
output.pT2_lep = pTMean2_lep.getVal();
output.pTErr1_lep = pTMean1_lep.getError();
output.pTErr2_lep = pTMean2_lep.getError();
/*
if (input.nFsr >= 1) {
output.pT1_gamma = pTMean1_gamma.getVal();
output.pTErr1_gamma = pTMean1_gamma.getError();
}
if (input.nFsr == 2) {
output.pT2_gamma = pTMean2_gamma.getVal();
output.pTErr2_gamma = pTMean2_gamma.getError();
}
*/
delete rastmp;
delete pTs;
delete PDFRelBW;
delete mZ;
delete RelBW;
delete RelBWxCB;
delete gauss;
delete RelBWxCBxgauss;
delete PDFRelBWxCBxgauss;
}
void createWorkspace(const std::string &infilename, int nState, bool correctCtau, bool drawRapPt2D) {
gROOT->SetStyle("Plain");
gStyle->SetTitleBorderSize(0);
delete gRandom;
gRandom = new TRandom3(23101987);
// Set some strings
const std::string workspacename = "ws_masslifetime",
treename = "selectedData";
// Get the tree from the data file
TFile *f = TFile::Open(infilename.c_str());
TTree *tree = (TTree*)f->Get(treename.c_str());
// Set branch addresses in tree to be able to import tree to roofit
TLorentzVector* chic = new TLorentzVector;
tree->SetBranchAddress("chic",&chic);
TLorentzVector* chic_rf = new TLorentzVector;
tree->SetBranchAddress("chic_rf",&chic_rf);
TLorentzVector* jpsi = new TLorentzVector;
tree->SetBranchAddress("jpsi",&jpsi);
double lifetime = 0;
tree->SetBranchAddress("Jpsict",&lifetime);
double lifetimeErr = 0;
tree->SetBranchAddress("JpsictErr",&lifetimeErr);
char lifetimeTitle[200];
sprintf(lifetimeTitle,"l^{#psi} [mm]");
if(correctCtau) sprintf(lifetimeTitle,"l^{#chi} [mm]");
// define variables necessary for J/Psi(Psi(2S)) mass,lifetime fit
RooRealVar* JpsiMass =
new RooRealVar("JpsiMass", "M^{#psi} [GeV]", onia::massMin, onia::massMax);
RooRealVar* JpsiPt =
new RooRealVar("JpsiPt", "p^{#psi}_{T} [GeV]", 0. ,1000.);
RooRealVar* JpsiRap =
new RooRealVar("JpsiRap", "y^{#psi}", -2., 2.);
RooRealVar* chicMass =
new RooRealVar("chicMass", "M^{#chi} [GeV]", onia::chimassMin, onia::chimassMax);
RooRealVar* chicRap =
new RooRealVar("chicRap", "y^{#chi}", -onia::chirap, onia::chirap);
RooRealVar* chicPt =
new RooRealVar("chicPt", "p^{#chi}_{T} [GeV]", 0. ,100.);
RooRealVar* Jpsict =
new RooRealVar("Jpsict", lifetimeTitle, onia::ctVarMin, onia::ctVarMax);
RooRealVar* JpsictErr =
new RooRealVar("JpsictErr", Form("Error on %s",lifetimeTitle), 0.0001, 1.);
// Set bins
Jpsict->setBins(10000,"cache");
JpsiMass->setBins(10000,"cache");
JpsiPt->setBins(100);
JpsiRap->setBins(10000,"cache");
chicMass->setBins(10000,"cache");
//JpsictErr->setBins(100);
JpsictErr->setBins(10000,"cache");
// The list of data variables
RooArgList dataVars(*JpsiMass,*JpsiPt,*JpsiRap,*chicMass,*chicRap,*chicPt,*Jpsict,*JpsictErr);
// construct dataset to contain events
RooDataSet* fullData = new RooDataSet("fullData","The Full Data From the Input ROOT Trees",dataVars);
int entries = tree->GetEntries();
cout << "entries " << entries << endl;
int numEntriesTotal=0;
int numEntriesInAnalysis=0;
int numEntriesNotInAnalysis=0;
/*
/// Read in 2011 data ctauErr-histos
char saveDir[200];
char PlotID[200];
char savename[200];
sprintf(saveDir,"/afs/hephy.at/scratch/k/knuenz/ChicPol/macros/polFit/Figures/CtauErrModel");
gSystem->mkdir(saveDir);
sprintf(PlotID,"2014May26_MoreLbins");
sprintf(saveDir,"%s/%s",saveDir,PlotID);
gSystem->mkdir(saveDir);
sprintf(savename,"%s/CtauErrModel_histograms.root",saveDir);
TFile *infile = new TFile(savename,"READ");
cout<<"opened file"<<endl;
const int nPT=5;
const int nRAP=2;
const int nL=15;
const double bordersPT[nPT+1] = {0., 12., 16., 20., 30., 100.};
const double bordersRAP[nRAP+1] = {0., 0.6, 2.};
const double bordersL[nL+1] = {onia::ctVarMin, -0.05, -0.03, -0.02, -0.015, -0.01, -0.005, 0., 0.005, 0.01, 0.015, 0.02, 0.03, 0.05, 0.1, onia::ctVarMax};
TH1D* h_ctauerr_2011[nRAP+1][nPT+1][nL+1];
TH1D* h_ctauerr_2012[nRAP+1][nPT+1][nL+1];
for(int iRAP = 0; iRAP < nRAP+1; iRAP++){
for(int iPT = 0; iPT < nPT+1; iPT++){
for(int iL = 0; iL < nL+1; iL++){
h_ctauerr_2011[iRAP][iPT][iL] = (TH1D*)infile->Get(Form("h_ctauerr_2011_rap%d_pt%d_l%d",iRAP, iPT, iL));
h_ctauerr_2012[iRAP][iPT][iL] = (TH1D*)infile->Get(Form("h_ctauerr_2012_rap%d_pt%d_l%d",iRAP, iPT, iL));
}
}
}
cout<<"opened hists"<<endl;
/// Finished reading in 2011 data ctauErr-histos
*/
// loop through events in tree and save them to dataset
for (int ientries = 0; ientries < entries; ientries++) {
numEntriesTotal++;
if (ientries%10000==0) std::cout << "event " << ientries << " of " << entries << std::endl;
tree->GetEntry(ientries);
double M_jpsi =jpsi->M();
double pt_jpsi =jpsi->Pt();
double y_jpsi =jpsi->Rapidity();
double M =chic_rf->M();
//double M =chic->M()-jpsi->M()+onia::MpsiPDG;
double y=chic->Rapidity();
double pt=chic->Pt();
//if (ientries%3==0){
// M_jpsi = gRandom->Uniform(JpsiMass->getMin(), JpsiMass->getMax());
//}
//double JpsictErrRand = h_JpsictErr->GetRandom();
//double JpsictErrRand2 = h_JpsictErr->GetRandom();
//double JpsictMeanRand=0.;
////double pTcorrection=(pt-20.)*0.002;
//
////JpsictErrRand-=pTcorrection;
//if(JpsictErrRand<0) JpsictErrRand=0.001;
////JpsictErrRand2-=pTcorrection;
//if(JpsictErrRand2<0) JpsictErrRand2=0.001;
//
//if (ientries%1000000==0){
// double exponent=0.4;
// JpsictMeanRand=gRandom->Exp(exponent);
//}
//
//
//lifetime = gRandom->Gaus(JpsictMeanRand,0.8*JpsictErrRand);
//lifetimeErr = JpsictErrRand2;
//if (ientries%3==0){
// lifetime = gRandom->Gaus(JpsictMeanRand,1.5*JpsictErrRand);
//}
//
//double resCorrFactor=1.08;
//if(lifetime<0)
// lifetimeErr/=resCorrFactor;
/*
int iRAPindex=0;
int iPTindex=0;
int iLindex=0;
for(int iRAP = 1; iRAP < nRAP+1; iRAP++){
for(int iPT = 1; iPT < nPT+1; iPT++){
for(int iL = 1; iL < nL+1; iL++){
Double_t ptMin = bordersPT[iPT-1];;
Double_t ptMax = bordersPT[iPT];;
Double_t rapMin = bordersRAP[iRAP-1];;
Double_t rapMax = bordersRAP[iRAP]; ;
Double_t lMin = bordersL[iL-1];;
Double_t lMax = bordersL[iL]; ;
if(pt_jpsi>ptMin && pt_jpsi<ptMax && TMath::Abs(y_jpsi)>rapMin && TMath::Abs(y_jpsi)<rapMax && lifetime>lMin && lifetime<lMax){
iRAPindex=iRAP;
iPTindex=iPT;
iLindex=iL;
}
}
}
}
double lifetimeErrRand = h_ctauerr_2011[iRAPindex][iPTindex][iLindex]->GetRandom();
lifetimeErr = lifetimeErrRand;
if (ientries%10000==0){
std::cout << "Test output: lifetimeErr " << lifetimeErr << " randomly drawn from from " << h_ctauerr_2011[iRAPindex][iPTindex][iLindex]->GetName() << std::endl;
}
*/
if (
M > chicMass->getMin() && M < chicMass->getMax()
&& pt > chicPt->getMin() && pt < chicPt->getMax()
&& y > chicRap->getMin() && y < chicRap->getMax()
&& M_jpsi > JpsiMass->getMin() && M_jpsi < JpsiMass->getMax()
&& pt_jpsi > JpsiPt->getMin() && pt_jpsi < JpsiPt->getMax()
&& y_jpsi > JpsiRap->getMin() && y_jpsi < JpsiRap->getMax()
&& lifetime > Jpsict->getMin() && lifetime < Jpsict->getMax()
&& lifetimeErr > JpsictErr->getMin() && lifetimeErr < JpsictErr->getMax()
) {
chicPt ->setVal(pt);
chicRap ->setVal(y);
chicMass ->setVal(M);
JpsiMass ->setVal(M_jpsi);
JpsiPt ->setVal(pt_jpsi);
JpsiRap ->setVal(y_jpsi);
Jpsict ->setVal(lifetime);
JpsictErr ->setVal(lifetimeErr);
//cout<<"JpsiRap->getVal() "<<JpsiRap->getVal()<<endl;
fullData->add(dataVars);
numEntriesInAnalysis++;
}
else {
numEntriesNotInAnalysis++;
//if (M < chicMass->getMin() || M > chicMass->getMax()) cout << "M " << M << endl;
//if (pt < chicPt->getMin() || pt > chicPt->getMax()) cout << "pt " << pt << endl;
//if (y < chicRap->getMin() || y > chicRap->getMax()) cout << "y " << y << endl;
//if (lifetime < Jpsict->getMin() || lifetime > Jpsict->getMax()) cout << "lifetime " << lifetime << endl;
//if (lifetimeErr < JpsictErr->getMin() || lifetimeErr > JpsictErr->getMax()) cout << "lifetimeErr " << lifetimeErr << endl;
//cout << "M " << M << endl;
//cout << "pt " << pt << endl;
//cout << "y " << y << endl;
//cout << "lifetime " << lifetime << endl;
//cout << "lifetimeErr " << lifetimeErr << endl;
//cout << " " << endl;
}
}//ientries
//infile->Close();
cout << "entries entering all bins " << fullData->sumEntries() << endl;
cout << "numEntriesTotal " << numEntriesTotal << endl;
cout << "numEntriesInAnalysis " << numEntriesInAnalysis << endl;
cout << "numEntriesNotInAnalysis " << numEntriesNotInAnalysis << endl;
//------------------------------------------------------------------------------------------------------------------
// Define workspace and import datasets
////Get datasets binned in pT an y
for(int iRap = 0; iRap <= onia::kNbRapForPTBins; iRap++) {
Double_t yMin;
Double_t yMax;
if(iRap==0) {
yMin = onia::rapForPTRange[0];
yMax = onia::rapForPTRange[onia::kNbRapForPTBins];
} else {
yMin = onia::rapForPTRange[iRap-1];
yMax = onia::rapForPTRange[iRap];
}
for(int iPT = 0; iPT <= onia::kNbPTBins[iRap]; iPT++) {
//for(int iPT = 0; iPT <= 0; iPT++)
Double_t ptMin;
Double_t ptMax;
if(iPT==0) {
ptMin = onia::pTRange[iRap][0];
ptMax = onia::pTRange[iRap][onia::kNbPTBins[0]];
} else {
ptMin = onia::pTRange[iRap][iPT-1];
ptMax = onia::pTRange[iRap][iPT];
}
// output file name and workspace
std::stringstream outfilename;
outfilename << "tmpFiles/backupWorkSpace/ws_createWorkspace_Chi_rap" << iRap << "_pt" << iPT << ".root";
RooWorkspace* ws = new RooWorkspace(workspacename.c_str());
// define pt and y cuts on dataset
std::stringstream cutString;
if(onia::KinParticleChi && !onia::KinParticleChiButJpsiRap) {
cutString << "(chicPt >= " << ptMin << " && chicPt < "<< ptMax << ") && "
<< "(TMath::Abs(chicRap) >= " << yMin << " && TMath::Abs(chicRap) < " << yMax << ")";
}
if(!onia::KinParticleChi) {
cutString << "(JpsiPt >= " << ptMin << " && JpsiPt < "<< ptMax << ") && "
<< "(TMath::Abs(JpsiRap) >= " << yMin << " && TMath::Abs(JpsiRap) < " << yMax << ")";
}
if(onia::KinParticleChi && onia::KinParticleChiButJpsiRap) {
cutString << "(chicPt >= " << ptMin << " && chicPt < "<< ptMax << ") && "
<< "(TMath::Abs(JpsiRap) >= " << yMin << " && TMath::Abs(JpsiRap) < " << yMax << ")";
}
cout << "cutString: " << cutString.str().c_str() << endl;
// get the dataset for the fit
RooDataSet* binData = (RooDataSet*)fullData->reduce(cutString.str().c_str());
std::stringstream name;
name << "jpsi_data_rap" << iRap << "_pt" << iPT;
binData->SetNameTitle(name.str().c_str(), "Data For Fitting");
cout << "numEvents = " << binData->sumEntries() << endl;
double chicMeanPt = binData->mean(*chicPt);
RooRealVar var_chicMeanPt("var_chicMeanPt","var_chicMeanPt",chicMeanPt);
if(!ws->var("var_chicMeanPt")) ws->import(var_chicMeanPt);
else ws->var("var_chicMeanPt")->setVal(chicMeanPt);
cout << "chicMeanPt = " << chicMeanPt << endl;
double jpsiMeanPt = binData->mean(*JpsiPt);
RooRealVar var_jpsiMeanPt("var_jpsiMeanPt","var_jpsiMeanPt",jpsiMeanPt);
if(!ws->var("var_jpsiMeanPt")) ws->import(var_jpsiMeanPt);
else ws->var("var_jpsiMeanPt")->setVal(jpsiMeanPt);
cout << "jpsiMeanPt = " << jpsiMeanPt << endl;
std::stringstream cutStringPosRapChic;
cutStringPosRapChic << "chicRap > 0";
RooDataSet* binDataPosRapChic = (RooDataSet*)binData->reduce(cutStringPosRapChic.str().c_str());
double chicMeanAbsRap = binDataPosRapChic->mean(*chicRap);
cout << "chicMeanAbsRap = " << chicMeanAbsRap << endl;
RooRealVar var_chicMeanAbsRap("var_chicMeanAbsRap","var_chicMeanAbsRap",chicMeanAbsRap);
if(!ws->var("var_chicMeanAbsRap")) ws->import(var_chicMeanAbsRap);
else ws->var("var_chicMeanAbsRap")->setVal(chicMeanAbsRap);
std::stringstream cutStringPosRapJpsi;
cutStringPosRapJpsi << "JpsiRap > 0";
RooDataSet* binDataPosRapJpsi = (RooDataSet*)binData->reduce(cutStringPosRapJpsi.str().c_str());
double jpsiMeanAbsRap = binDataPosRapJpsi->mean(*JpsiRap);
cout << "jpsiMeanAbsRap = " << jpsiMeanAbsRap << endl;
RooRealVar var_jpsiMeanAbsRap("var_jpsiMeanAbsRap","var_jpsiMeanAbsRap",jpsiMeanAbsRap);
if(!ws->var("var_jpsiMeanAbsRap")) ws->import(var_jpsiMeanAbsRap);
else ws->var("var_jpsiMeanAbsRap")->setVal(jpsiMeanAbsRap);
// Import variables to workspace
ws->import(*binData);
ws->writeToFile(outfilename.str().c_str());
}//iPT
}//iRap
////---------------------------------------------------------------
////--Integrating rapidity and pt bins, in +/- 3*sigma mass window
////---------------------------------------------------------------
if(drawRapPt2D) {
double yMin = onia::rapForPTRange[0];
double yMax = 1.6;//onia::rapForPTRange[onia::kNbRapForPTBins];
double ptMin = onia::pTRange[0][0];
double ptMax = onia::pTRange[0][onia::kNbPTBins[0]];
std::stringstream cutRapPt;
cutRapPt << "(chicPt > " << ptMin << " && chicPt < "<< ptMax << ") && "
<< "(TMath::Abs(chicRap) > " << yMin << " && TMath::Abs(chicRap) < " << yMax << ")";
cout<<"cutRapPt: "<<cutRapPt.str().c_str()<<endl;
RooDataSet* rapPtData = (RooDataSet*)fullData->reduce(cutRapPt.str().c_str());
std::stringstream nameRapPt;
nameRapPt << "data_rap0_pt0";
rapPtData->SetNameTitle(nameRapPt.str().c_str(), "Data For full rap and pt");
// output file name and workspace
std::stringstream outfilename;
outfilename << "tmpFiles/backupWorkSpace/ws_createWorkspace_Chi_rap0_pt0.root";
RooWorkspace* ws_RapPt = new RooWorkspace(workspacename.c_str());
//Import variables to workspace
ws_RapPt->import(*rapPtData);
ws_RapPt->writeToFile(outfilename.str().c_str());
TH2D* rapPt;
TH1D* rap1p2;
double MassMin;
double MassMax;
rap1p2 = new TH1D("rap1p2","rap1p2",30,1.2, 1.8);
if(nState==4) {
rapPt = new TH2D( "rapPt", "rapPt", 52,-1.3,1.3,144,0,72);
MassMin=3.011;//massPsi1S-onia::nSigMass*sigma1S;
MassMax=3.174;//massPsi1S+onia::nSigMass*sigma1S;
// sigma 27.2 MeV
// mean 3.093 GeV
}
if(nState==5) {
rapPt = new TH2D( "rapPt", "rapPt", 64,-1.6,1.6,144,0,72); // rap<1.5
//rapPt = new TH2D( "rapPt", "rapPt", 52,-1.3,1.3,144,0,72); // rap<1.2
MassMin=3.576;//massPsi2S-onia::nSigMass*sigma2S;
MassMax=3.786;//massPsi2S+onia::nSigMass*sigma2S;
// sigma 34.9 MeV // pT > 7
// sigma 34.3 MeV // pT > 10
// mean 3.681 GeV
}
cout<<"Plotting rap-Pt for Psi"<<nState-3<<"S"<<endl;
cout<<"MassMin for rap-Pt plot = "<<MassMin<<endl;
cout<<"MassMax for rap-Pt plot = "<<MassMax<<endl;
TTree *rapPtTree = (TTree*)rapPtData->tree();
std::stringstream cutMass;
cutMass<<"(chicMass > " << MassMin << " && chicMass < "<< MassMax << ")";
//following two methods can only be used in root_v30, 34 does not work
rapPtTree->Draw("chicPt:chicRap>>rapPt",cutMass.str().c_str(),"colz");
cout<<"debug"<<endl;
rapPtTree->Draw("TMath::Abs(chicRap)>>rap1p2",cutMass.str().c_str());
TCanvas* c2 = new TCanvas("c2","c2",1200,1500);
rapPt->SetYTitle("p_{T}(#mu#mu) [GeV]");
rapPt->SetXTitle("y(#mu#mu)");
gStyle->SetPalette(1);
gPad->SetFillColor(kWhite);
rapPt->SetTitle(0);
rapPt->SetStats(0);
gPad->SetLeftMargin(0.15);
gPad->SetRightMargin(0.17);
rapPt->GetYaxis()->SetTitleOffset(1.5);
rapPt->Draw("colz");
TLine* rapPtLine;
for(int iRap=0; iRap<onia::kNbRapForPTBins+1; iRap++) {
rapPtLine= new TLine( -onia::rapForPTRange[iRap], onia::pTRange[0][0], -onia::rapForPTRange[iRap], onia::pTRange[0][onia::kNbPTBins[iRap]] );
rapPtLine->SetLineWidth( 2 );
rapPtLine->SetLineStyle( 1 );
rapPtLine->SetLineColor( kWhite );
rapPtLine->Draw();
rapPtLine= new TLine( onia::rapForPTRange[iRap], onia::pTRange[0][0], onia::rapForPTRange[iRap], onia::pTRange[0][onia::kNbPTBins[iRap]] );
rapPtLine->SetLineWidth( 2 );
rapPtLine->SetLineStyle( 1 );
rapPtLine->SetLineColor( kWhite );
rapPtLine->Draw();
int pTBegin = 0;
if(nState==5) pTBegin = 1;
for(int iPt=pTBegin; iPt<onia::kNbPTBins[iRap+1]+1; iPt++) {
rapPtLine= new TLine( -onia::rapForPTRange[onia::kNbRapForPTBins], onia::pTRange[0][iPt], onia::rapForPTRange[onia::kNbRapForPTBins], onia::pTRange[0][iPt] );
rapPtLine->SetLineWidth( 2 );
rapPtLine->SetLineStyle( 1 );
rapPtLine->SetLineColor( kWhite );
rapPtLine->Draw();
}
}
char savename[200];
sprintf(savename,"Figures/rapPt_Chi.pdf");
c2->SaveAs(savename);
TCanvas* c3 = new TCanvas("c3","c3",1500,1200);
rap1p2->SetYTitle("Events");
rap1p2->SetXTitle("y(#mu#mu)");
rap1p2->SetTitle(0);
rap1p2->SetStats(0);
rap1p2->GetYaxis()->SetTitleOffset(1.2);
rap1p2->Draw();
sprintf(savename,"Figures/rap_Chi_1p2.pdf");
c3->SaveAs(savename);
}
f->Close();
}
void embeddedToysWithBackgDetEffects_1DKD(int nEvts=600, int nToys=3000,
sample mySample = kScalar_fa3p5,
bool bkg, bool sigFloating, int counter){
RooRealVar* kd = new RooRealVar("psMELA","psMELA",0,1);
kd->setBins(1000);
RooPlot* kdframe1 = kd->frame();
// 0- template
TFile f1("KDdistribution_ps_analytical_detEff.root", "READ");
TH1F *h_KD_ps = (TH1F*)f1.Get("h_KD");
h_KD_ps->SetName("h_KD_ps");
RooDataHist rdh_KD_ps("rdh_KD_ps","rdh_KD_ps",RooArgList(*kd),h_KD_ps);
RooHistPdf pdf_KD_ps("pdf_KD_ps","pdf_KD_ps",RooArgList(*kd),rdh_KD_ps);
// 0+ template
TFile f2("KDdistribution_sm_analytical_detEff.root", "READ");
TH1F *h_KD_sm = (TH1F*)f2.Get("h_KD");
h_KD_sm->SetName("h_KD_sm");
RooDataHist rdh_KD_sm("rdh_KD_sm","rdh_KD_sm",RooArgList(*kd),h_KD_sm);
RooHistPdf pdf_KD_sm("pdf_KD_sm","pdf_KD_sm",RooArgList(*kd),rdh_KD_sm);
// backg template
TFile f3("KDdistribution_bkg_analytical_detEff.root", "READ");
TH1F *h_KD_bkg = (TH1F*)f3.Get("h_KD");
h_KD_bkg->SetName("h_KD_bkg");
RooDataHist rdh_KD_bkg("rdh_KD_bkg","rdh_KD_bkg",RooArgList(*kd),h_KD_bkg);
RooHistPdf pdf_KD_bkg("pdf_KD_bkg","pdf_KD_bkg",RooArgList(*kd),rdh_KD_bkg);
//Define signal model with 0+, 0- mixture
RooRealVar rrv_fa3("fa3","fa3",0.5,0.,1.); //free parameter of the model
RooFormulaVar rfv_fa3Obs("fa3obs","1/ (1 + (1/@0 - 1)*0.99433)",RooArgList(rrv_fa3));
RooAddPdf modelSignal("modelSignal","ps+sm",pdf_KD_ps,pdf_KD_sm,rfv_fa3Obs);
rrv_fa3.setConstant(kFALSE);
//Define signal+bakground model
RooRealVar rrv_BoverTOT("BoverTOT","BoverTOT",1/(3.75+1),0.,10.);
RooAddPdf model("model","background+modelSignal",pdf_KD_bkg,modelSignal,rrv_BoverTOT);
if(sigFloating)
rrv_BoverTOT.setConstant(kFALSE);
else
rrv_BoverTOT.setConstant(kTRUE);
//Set the values of free parameters to compute pulls
double fa3Val=-99;
if (mySample == kScalar_fa3p0)
fa3Val=0.;
else if (mySample == kScalar_fa3p1)
fa3Val=0.1;
else if (mySample == kScalar_fa3p5 || mySample == kScalar_fa3p5phia390)
fa3Val=0.5;
else if (mySample == kScalar_fa3p25)
fa3Val=0.25;
else{
cout<<"fa3Val not correct!"<<endl;
return 0;
}
double sigFracVal=1 - 1/(3.75+1);
//Plot the models
TCanvas* c = new TCanvas("modelPlot_detBkg","modelPlot_detBkg",400,400);
rdh_KD_ps.plotOn(kdframe1,LineColor(kBlack),MarkerColor(kBlack));
pdf_KD_ps.plotOn(kdframe1,LineColor(kBlack),RooFit::Name("pseudo"));
//rdh_KD_sm.plotOn(kdframe1,LineColor(kBlue),MarkColor(kBlue));
pdf_KD_sm.plotOn(kdframe1,LineColor(kBlue),RooFit::Name("SM"));
//rdh_KD_bkg.plotOn(kdframe1,LineColor(kGreen),LineColor(kGreen));
pdf_KD_bkg.plotOn(kdframe1,LineColor(kGreen),RooFit::Name("bkg"));
modelSignal.plotOn(kdframe1,LineColor(kRed),RooFit::Name("signal_fa3p5"));
model.plotOn(kdframe1,LineColor(kOrange),RooFit::Name("signal+background"));
TLegend *leg = new TLegend (0.7,0.6,0.95,0.8);
leg->AddEntry(kdframe1->findObject("pseudo"),"0-","L");
leg->AddEntry(kdframe1->findObject("SM"),"0+","L");
leg->AddEntry(kdframe1->findObject("bkg"),"bkg","L");
leg->AddEntry(kdframe1->findObject("signal_fa3p5"),"signal fa3=0.5","L");
leg->AddEntry(kdframe1->findObject("signal+background"),"signal + bkg","L");
kdframe1->Draw();
leg->SetFillColor(kWhite);
leg->Draw("same");
c->SaveAs("modelPlot_detBkg.eps");
c->SaveAs("modelPlot_detBkg.png");
//Load the trees into the datasets
TChain* myChain = new TChain("SelectedTree");
myChain->Add(inputFileNames[mySample]);
if(!myChain || myChain->GetEntries()<=0) {
cout<<"error in the tree"<<endl;
return 0;
}
RooDataSet* data = new RooDataSet("data","data",myChain,RooArgSet(*kd),"");
TChain* myChain_bkg = new TChain("SelectedTree");
myChain_bkg->Add("samples/analyticalpsMELA/withResolution/pwgevents_mllCut10_smeared_withDiscriminants_2e2mu_cutDetector.root");
myChain_bkg->Add("samples/analyticalpsMELA/withResolution/pwgevents_mllCut4_wResolution_withDiscriminants_cutDetector.root");
if(!myChain_bkg || myChain_bkg->GetEntries()<=0) {
cout<<"error in the tree"<<endl;
return 0;
}
RooDataSet* data_bkg = new RooDataSet("data_bkg","data_bkg",myChain_bkg,RooArgSet(*kd),"");
cout << "Number of events in data sig: " << data->numEntries() << endl;
cout << "Number of events in data bkg: " << data_bkg->numEntries() << endl;
// Initialize tree to save toys to
TTree* results = new TTree("results","toy results");
double fa3,fa3Error, fa3Pull;
double sigFrac,sigFracError, sigFracPull;
double significance;
results->Branch("fa3",&fa3,"fa3/D");
results->Branch("fa3Error",&fa3Error,"fa3Error/D");
results->Branch("fa3Pull",&fa3Pull,"fa3Pull/D");
results->Branch("sigFrac",&sigFrac,"sigFrac/D");
results->Branch("sigFracError",&sigFracError,"sigFracError/D");
results->Branch("sigFracPull",&sigFracPull,"sigFracPull/D");
results->Branch("significance",&significance,"significance/D");
//---------------------------------
RooDataSet* toyData;
RooDataSet* toyData_bkgOnly;
int embedTracker=nEvts*counter;
int embedTracker_bkg=TMath::Ceil(nEvts/3.75*counter);
RooArgSet *tempEvent;
RooFitResult *toyfitresults;
RooFitResult *toyfitresults_sigBkg;
RooFitResult *toyfitresults_bkgOnly;
RooRealVar *r_fa3;
RooRealVar *r_sigFrac;
for(int i = 0 ; i<nToys ; i++){
cout <<i<<"<-----------------------------"<<endl;
//if(toyData) delete toyData;
toyData = new RooDataSet("toyData","toyData",RooArgSet(*kd));
toyData_bkgOnly = new RooDataSet("toyData_bkgOnly","toyData_bkgOnly",RooArgSet(*kd));
if(nEvts+embedTracker > data->sumEntries()){
cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl;
toyData = NULL;
abort();
return 0;
}
if(nEvts+embedTracker_bkg > data_bkg->sumEntries()){
cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl;
toyData = NULL;
abort();
return 0;
}
for(int iEvent=0; iEvent<nEvts; iEvent++){
if(iEvent==1)
cout << "generating event: " << iEvent << " embedTracker: " << embedTracker << endl;
tempEvent = (RooArgSet*) data->get(embedTracker);
toyData->add(*tempEvent);
embedTracker++;
}
if(bkg){
for(int iEvent=0; iEvent<nEvts/3.75; iEvent++){
if(iEvent==1)
cout << "generating bkg event: " << iEvent << " embedTracker bkg: " << embedTracker_bkg << endl;
tempEvent = (RooArgSet*) data_bkg->get(embedTracker_bkg);
toyData->add(*tempEvent);
toyData_bkgOnly->add(*tempEvent);
embedTracker_bkg++;
}
}
if(bkg)
toyfitresults =model.fitTo(*toyData,Save());
else
toyfitresults =modelSignal.fitTo(*toyData,Save());
//cout<<toyfitresults<<endl;
r_fa3 = (RooRealVar *) toyfitresults->floatParsFinal().find("fa3");
fa3 = r_fa3->getVal();
fa3Error = r_fa3->getError();
fa3Pull = (r_fa3->getVal() - fa3Val) / r_fa3->getError();
if(sigFloating){
r_sigFrac = (RooRealVar *) toyfitresults->floatParsFinal().find("BoverTOT");
sigFrac = 1-r_sigFrac->getVal();
sigFracError = r_sigFrac->getError();
sigFracPull = (1-r_sigFrac->getVal() - sigFracVal) / r_sigFrac->getError();
}
// fill TTree
results->Fill();
}
char nEvtsString[100];
sprintf(nEvtsString,"_%iEvts_%iiter",nEvts, counter);
// write tree to output file (ouputFileName set at top)
TFile *outputFile = new TFile("embeddedToys1DKD_fa3Corr_WithBackgDetEffects_"+sampleName[mySample]+nEvtsString+".root","RECREATE");
results->Write();
outputFile->Close();
}
Pull(){
TFile *root_file = new TFile("toymc.root");
RooWorkspace *ws2 = new RooWorkspace();
ws2->factory("{DG[0.09,-0.1,0.3],tau[1.5,1.2,1.7],beta[0.25,0.0,0.5],delta_l[0.2,-2,2],delta_p[2.95,1,5.0],delta_s[0.2,-2,2],fs[0.2,0,0.4],s[1.0,0.8,1.2]}");
ws2->factory("{A02[0.6,0.5,0.7],Al2[0.3,0.2,0.4]}");
RooDataSet* data = new RooDataSet("data","data", ws2->argSet("DG,tau,beta,delta_l,delta_p,delta_s,fs,s,A02,Al2"));
for(int i=0; i<10; i++){
TString fit_name = "fit_";
fit_name+=i;
RooFitResult *fit_result = (RooFitResult*) root_file->Get(fit_name);
if (fit_result->status() != 0){
cout << fit_result->status() << endl;
continue;
}
//cout << fit_result->minNll() << endl;
// if ( fit_result->minNll() < 17500 )
data->add(fit_result->floatParsFinal());
}
gROOT->SetStyle("Plain");
ws2->factory("Gaussian::A02_gauss(A02,mean_A02[0.6,0.5,0.7],sigma_A02[0.15,0.0001,1.0])");
ws2->pdf("A02_gauss")->fitTo(*data, RooFit::PrintLevel(-1));
TCanvas *canvas_A02 = new TCanvas("canvas_A02", "canvas_A02", 600,600);
RooPlot *A02_plot = ws2->var("A02")->frame();
data->plotOn(A02_plot,RooFit::MarkerSize(0.3));
// ws2->pdf("A02_gauss")->plotOn(A02_plot);
// ws2->pdf("A02_gauss")->paramOn(A02_plot);
A02_plot->Draw();
ws2->factory("Gaussian::Al2_gauss(Al2,mean_Al2[0.3,0.2,0.4],sigma_Al2[0.15,0.001,1.0])");
ws2->pdf("Al2_gauss")->fitTo(*data, RooFit::PrintLevel(-1));
TCanvas *canvas_Al2 = new TCanvas("canvas_Al2", "canvas_Al2", 600,600);
RooPlot *Al2_plot = ws2->var("Al2")->frame();
data->plotOn(Al2_plot,RooFit::MarkerSize(0.3));
// ws2->pdf("Al2_gauss")->plotOn(Al2_plot);
// ws2->pdf("Al2_gauss")->paramOn(Al2_plot);
Al2_plot->Draw();
ws2->factory("Gaussian::DG_gauss(DG,mean_DG[0.09,0.0,0.2],sigma_DG[0.15,0.01,1.0])");
ws2->pdf("DG_gauss")->fitTo(*data, RooFit::PrintLevel(-1));
TCanvas *canvas_DG = new TCanvas("canvas_DG", "canvas_DG", 600,600);
RooPlot *DG_plot = ws2->var("DG")->frame();
data->plotOn(DG_plot,RooFit::MarkerSize(0.3));
// ws2->pdf("DG_gauss")->plotOn(DG_plot);
// ws2->pdf("DG_gauss")->paramOn(DG_plot);
DG_plot->Draw();
ws2->factory("Gaussian::beta_gauss(beta,mean_beta[0.25,0.2,0.3],sigma_beta[0.15,0.001,1.0])");
ws2->pdf("beta_gauss")->fitTo(*data, RooFit::PrintLevel(-1));
TCanvas *canvas_beta = new TCanvas("canvas_beta", "canvas_beta", 600,600);
RooPlot *beta_plot = ws2->var("beta")->frame();
data->plotOn(beta_plot,RooFit::MarkerSize(0.3));
// ws2->pdf("beta_gauss")->plotOn(beta_plot);
// ws2->pdf("beta_gauss")->paramOn(beta_plot);
beta_plot->Draw();
ws2->factory("Gaussian::tau_gauss(tau,mean_tau[1.5,1,2],sigma_tau[0.1,0.01,1.0])");
ws2->pdf("tau_gauss")->fitTo(*data, RooFit::PrintLevel(-1));
TCanvas *canvas_tau = new TCanvas("canvas_tau", "canvas_tau", 600,600);
RooPlot *tau_plot = ws2->var("tau")->frame();
data->plotOn(tau_plot,RooFit::MarkerSize(0.3));
// ws2->pdf("tau_gauss")->plotOn(tau_plot);
// ws2->pdf("tau_gauss")->paramOn(tau_plot);
tau_plot->Draw();
ws2->factory("Gaussian::s_gauss(s,mean_s[1,0,2],sigma_s[0.15,0.01,1.0])");
ws2->pdf("s_gauss")->fitTo(*data, RooFit::PrintLevel(-1));
TCanvas *canvas_s = new TCanvas("canvas_s", "canvas_s", 600,600);
RooPlot *s_plot = ws2->var("s")->frame();
data->plotOn(s_plot,RooFit::MarkerSize(0.3));
// ws2->pdf("s_gauss")->plotOn(s_plot);
// ws2->pdf("s_gauss")->paramOn(s_plot);
s_plot->Draw();
ws2->factory("Gaussian::fs_gauss(fs,mean_fs[0.2,0,2],sigma_fs[0.15,0.01,1.0])");
ws2->pdf("fs_gauss")->fitTo(*data, RooFit::PrintLevel(-1));
TCanvas *canvas_fs = new TCanvas("canvas_fs", "canvas_fs", 600,600);
RooPlot *fs_plot = ws2->var("fs")->frame();
data->plotOn(fs_plot,RooFit::MarkerSize(0.3));
// ws2->pdf("fs_gauss")->plotOn(fs_plot);
// ws2->pdf("fs_gauss")->paramOn(fs_plot);
fs_plot->Draw();
// ws2->factory("Gaussian::delta_s_gauss(delta_s,mean_delta_s[0.2,0,2],sigma_delta_s[0.15,0.1,1.0])");
// ws2->pdf("delta_s_gauss")->fitTo(*data, RooFit::PrintLevel(-1));
TCanvas *canvas_delta_s = new TCanvas("canvas_delta_s", "canvas_delta_s", 600,600);
RooPlot *delta_s_plot = ws2->var("delta_s")->frame();
data->plotOn(delta_s_plot,RooFit::MarkerSize(0.3));
// ws2->pdf("delta_s_gauss")->plotOn(delta_s_plot);
// ws2->pdf("delta_s_gauss")->paramOn(delta_s_plot);
delta_s_plot->Draw();
// ws2->factory("Gaussian::delta_p_gauss(delta_p,mean_delta_p[2.95,0,4],sigma_delta_p[0.15,0.1,1.0])");
// ws2->pdf("delta_p_gauss")->fitTo(*data, RooFit::PrintLevel(-1));
TCanvas *canvas_delta_p = new TCanvas("canvas_delta_p", "canvas_delta_p", 600,600);
RooPlot *delta_p_plot = ws2->var("delta_p")->frame();
data->plotOn(delta_p_plot,RooFit::MarkerSize(0.3));
// ws2->pdf("delta_p_gauss")->plotOn(delta_p_plot);
// ws2->pdf("delta_p_gauss")->paramOn(delta_p_plot);
delta_p_plot->Draw();
// ws2->factory("Gaussian::delta_l_gauss(delta_l,mean_delta_l[1,0,2],sigma_delta_l[0.25,0.2,2.0])");
// ws2->pdf("delta_l_gauss")->fitTo(*data, RooFit::PrintLevel(-1));
TCanvas *canvas_delta_l = new TCanvas("canvas_delta_l", "canvas_delta_l", 600,600);
RooPlot *delta_l_plot = ws2->var("delta_l")->frame();
data->plotOn(delta_l_plot,RooFit::MarkerSize(0.3));
// ws2->pdf("delta_l_gauss")->plotOn(delta_l_plot);
// ws2->pdf("delta_l_gauss")->paramOn(delta_l_plot);
delta_l_plot->Draw();
}
void makejpsifit(string inputFilename, string outFilename,
Int_t ptBin, Int_t etaBin,
double minMass, double maxMass,
double mean_bw, double gamma_bw, double cutoff_cb, double power_cb,
const char* plotOpt, const int nbins, Int_t isMC) {
TStyle *mystyle = RooHZZStyle("ZZ");
mystyle->cd();
//Create Data Set
RooRealVar mass("zmass","m(e^{+}e^{-})",minMass,maxMass,"GeV/c^{2}");
// Reading everything from root tree instead
TFile *tfile = TFile::Open(inputFilename.c_str());
TTree *ttree = (TTree*)tfile->Get("zeetree/probe_tree");
hzztree *zeeTree = new hzztree(ttree);
RooArgSet zMassArgSet(mass);
RooDataSet* data = new RooDataSet("data", "ntuple parameters", zMassArgSet);
for (int i = 0; i < zeeTree->fChain->GetEntries(); i++) {
if(i%100000==0) cout << "Processing Event " << i << endl;
zeeTree->fChain->GetEntry(i);
//*************************************************************************
//Electron Selection
//*************************************************************************
// already passed for this tree
//*************************************************************************
//Compute electron four vector;
//*************************************************************************
double ele1pt = zeeTree->l1pt;
double ele2pt = zeeTree->l2pt;
double ELECTRONMASS = 0.51e-3;
TLorentzVector ele1FourVector;
ele1FourVector.SetPtEtaPhiM(zeeTree->l1pt, zeeTree->l1eta, zeeTree->l1phi, ELECTRONMASS);
TLorentzVector ele2FourVector;
ele2FourVector.SetPtEtaPhiM(zeeTree->l2pt, zeeTree->l2eta, zeeTree->l2phi, ELECTRONMASS);
//*************************************************************************
//pt and eta cuts on electron
//*************************************************************************
if (! (ele1pt > 7 && ele2pt > 7
&& fabs( zeeTree->l1eta) < 2.5
&& fabs( zeeTree->l2eta) < 2.5 )) continue;
//*************************************************************************
//pt bins and eta bins
//*************************************************************************
Int_t Ele1PtBin = -1;
Int_t Ele1EtaBin = -1;
Int_t Ele2PtBin = -1;
Int_t Ele2EtaBin = -1;
if (ele1pt > 7 && ele1pt < 10) Ele1PtBin = 0;
else if (ele1pt < 20) Ele1PtBin = 1;
else Ele1PtBin = 2;
if (ele2pt > 7 && ele2pt < 10) Ele2PtBin = 0;
else if (ele2pt < 20) Ele2PtBin = 1;
else Ele2PtBin = 2;
if (fabs(zeeTree->l1sceta) < 1.479) Ele1EtaBin = 0;
else Ele1EtaBin = 1;
if (fabs(zeeTree->l2sceta) < 1.479) Ele2EtaBin = 0;
else Ele2EtaBin = 1;
if (!(Ele1PtBin == ptBin || Ele2PtBin == ptBin)) continue;
if (!(Ele1EtaBin == etaBin && Ele2EtaBin == etaBin)) continue;
//*************************************************************************
// restrict range of mass
//*************************************************************************
double zMass = (ele1FourVector+ele2FourVector).M();
if (zMass < minMass || zMass > maxMass) continue;
//*************************************************************************
//set mass variable
//*************************************************************************
zMassArgSet.setRealValue("zmass", zMass);
data->add(zMassArgSet);
}
// do binned fit to gain time...
mass.setBins(nbins);
RooDataHist *bdata = new RooDataHist("data_binned","data_binned", zMassArgSet, *data);
cout << "dataset size: " << data->numEntries() << endl;
// // Closing file
// treeFile->Close();
//====================== Parameters===========================
//Crystal Ball parameters
// RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", -.01, -10, 10, "GeV/c^{2}");
// RooRealVar cbSigma("sigma_{CB}", "CB Width", 1.7, 0.8, 5.0, "GeV/c^{2}");
// RooRealVar cbCut ("a_{CB}","CB Cut", 1.05, 1.0, 3.0);
// RooRealVar cbPower("n_{CB}","CB Order", 2.45, 0.1, 20.0);
RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", -.01, -10, 10, "GeV/c^{2}");
RooRealVar cbSigma("#sigma_{CB}", "CB Width", 1.5, 0.01, 5.0, "GeV/c^{2}");
RooRealVar cbCut ("a_{CB}","CB Cut", 1.0, 1.0, 3.0);
RooRealVar cbPower("n_{CB}","CB Order", 2.5, 0.1, 20.0);
cbCut.setVal(cutoff_cb);
cbPower.setVal(power_cb);
// Just checking
//cbCut.Print();
//cbPower.Print();
//Breit_Wigner parameters
RooRealVar bwMean("m_{JPsi}","BW Mean", 3.096916, "GeV/c^{2}");
bwMean.setVal(mean_bw);
RooRealVar bwWidth("#Gamma_{JPsi}", "BW Width", 92.9e-6, "GeV/c^{2}");
bwWidth.setVal(gamma_bw);
// Fix the Breit-Wigner parameters to PDG values
bwMean.setConstant(kTRUE);
bwWidth.setConstant(kTRUE);
// Exponential Background parameters
RooRealVar expRate("#lambda_{exp}", "Exponential Rate", -0.064, -1, 1);
RooRealVar c0("c_{0}", "c0", 1., 0., 50.);
//Number of Signal and Background events
RooRealVar nsig("N_{S}", "# signal events", 524, 0.1, 10000000000.);
RooRealVar nbkg("N_{B}", "# background events", 43, 1., 10000000.);
//============================ P.D.F.s=============================
// Mass signal for two decay electrons p.d.f.
RooBreitWigner bw("bw", "bw", mass, bwMean, bwWidth);
RooCBShape cball("cball", "Crystal Ball", mass, cbBias, cbSigma, cbCut, cbPower);
RooFFTConvPdf BWxCB("BWxCB", "bw X crystal ball", mass, bw, cball);
// Mass background p.d.f.
RooExponential bg("bg", "exp. background", mass, expRate);
// Mass model for signal electrons p.d.f.
RooAddPdf model("model", "signal", RooArgList(BWxCB), RooArgList(nsig));
TStopwatch t ;
t.Start() ;
double fitmin, fitmax;
if(isMC) {
fitmin = (etaBin==0) ? 3.00 : 2.7;
fitmax = (etaBin==0) ? 3.20 : 3.4;
} else {
fitmin = (etaBin==0) ? ( (ptBin>=2) ? 3.01 : 3.02 ) : 2.7;
fitmax = (etaBin==0) ? ( (ptBin==3) ? 3.23 : 3.22 ) : 3.4;
}
RooFitResult *fitres = model.fitTo(*bdata,Range(fitmin,fitmax),Hesse(1),Minos(1),Timer(1),Save(1));
fitres->SetName("fitres");
t.Print() ;
TCanvas* c = new TCanvas("c","Unbinned Invariant Mass Fit", 0,0,800,600);
//========================== Plotting ============================
//Create a frame
RooPlot* plot = mass.frame(Range(minMass,maxMass),Bins(nbins));
// Add data and model to canvas
int col = (isMC ? kAzure+4 : kGreen+1);
data->plotOn(plot);
model.plotOn(plot,LineColor(col));
data->plotOn(plot);
model.paramOn(plot, Format(plotOpt, AutoPrecision(1)), Parameters(RooArgSet(cbBias, cbSigma, cbCut, cbPower, bwMean, bwWidth, expRate, nsig, nbkg)), Layout(0.15,0.45,0.80));
plot->getAttText()->SetTextSize(.03);
plot->SetTitle("");
plot->Draw();
// Print Fit Values
TLatex *tex = new TLatex();
tex->SetNDC();
tex->SetTextSize(.1);
tex->SetTextFont(132);
// tex->Draw();
tex->SetTextSize(0.057);
if(isMC) tex->DrawLatex(0.65, 0.75, "J/#psi #rightarrow e^{+}e^{-} MC");
else tex->DrawLatex(0.65, 0.75, "J/#psi #rightarrow e^{+}e^{-} data");
tex->SetTextSize(0.030);
tex->DrawLatex(0.645, 0.65, Form("BW Mean = %.2f GeV/c^{2}", bwMean.getVal()));
tex->DrawLatex(0.645, 0.60, Form("BW #sigma = %.2f GeV/c^{2}", bwWidth.getVal()));
c->Update();
c->SaveAs((outFilename + ".pdf").c_str());
c->SaveAs((outFilename + ".png").c_str());
// tablefile << Form(Outfile + "& $ %f $ & $ %f $ & $ %f $\\ \hline",cbBias.getVal(), cbSigma.getVal(), cbCut.getVal());
// Output workspace with model and data
RooWorkspace *w = new RooWorkspace("JPsieeMassScaleAndResolutionFit");
w->import(model);
w->import(*bdata);
w->writeToFile((outFilename + ".root").c_str());
TFile *tfileo = TFile::Open((outFilename + ".root").c_str(),"update");
fitres->Write();
tfileo->Close();
}
// The actual job
void backgroundFits_ggzz_1Dw(int channel, int sqrts, int VBFtag)
{
TString schannel;
if (channel == 1) schannel = "4mu";
else if (channel == 2) schannel = "4e";
else if (channel == 3) schannel = "2e2mu";
else cout << "Not a valid channel: " << schannel << endl;
TString ssqrts = (long) sqrts + TString("TeV");
cout << "schannel = " << schannel << " sqrts = " << sqrts << " VBFtag = "<< VBFtag << endl;
TString outfile;
outfile = "CardFragments/ggzzBackgroundFit_" + ssqrts + "_" + schannel + "_" + Form("%d",int(VBFtag)) + ".txt";
ofstream of(outfile,ios_base::out);
gSystem->AddIncludePath("-I$ROOFITSYS/include");
gROOT->ProcessLine(".L ../CreateDatacards/include/tdrstyle.cc");
setTDRStyle(false);
gStyle->SetPadLeftMargin(0.16);
TString filepath;filepath.Form("AAAOK/ZZ%s/ZZ4lAnalysis.root",schannel.Data());
TFile *f = TFile::Open(filepath);
TTree *tree = f->Get("ZZTree/candTree");
RooRealVar* MC_weight = new RooRealVar("MC_weight","MC_weight",0.,2.) ;
RooRealVar* ZZMass = new RooRealVar("ZZMass","ZZMass",100,100.,1000.);
RooRealVar* NJets30 = new RooRealVar("NJets30","NJets30",0.,5.);
RooArgSet ntupleVarSet(*ZZMass,*NJets30,*MC_weight);
RooDataSet *set = new RooDataSet("set","set",ntupleVarSet,WeightVar("MC_weight"));
//RooArgSet ntupleVarSet(*ZZMass,*NJets30);
//RooDataSet *set = new RooDataSet("set","set",ntupleVarSet);
Float_t myMC,myMass;
Int_t myNJets;
int nentries = tree->GetEntries();
Float_t myPt,myJetPt,myJetEta,myJetPhi,myJetMass,myFisher;
Int_t myExtralep,myBJets;
tree->SetBranchAddress("ZZMass",&myMass);
tree->SetBranchAddress("genHEPMCweight",&myMC);
tree->SetBranchAddress("nCleanedJetsPt30",&myNJets);
tree->SetBranchAddress("ZZPt",&myPt);
tree->SetBranchAddress("nExtraLep",&myExtralep);
tree->SetBranchAddress("nCleanedJetsPt30BTagged",&myBJets);
tree->SetBranchAddress("DiJetDEta",&myFisher);
for(int i =0;i<nentries;i++) {
tree->GetEntry(i);
if(myMass<100.)continue;
int cat = category(myExtralep,myPt, myMass,myNJets, myBJets,/* jetpt, jeteta, jetphi, jetmass,*/myFisher);
if(VBFtag != cat )continue;
ntupleVarSet.setRealValue("ZZMass",myMass);
ntupleVarSet.setRealValue("MC_weight",myMC);
ntupleVarSet.setRealValue("NJets30",(double)cat);
set->add(ntupleVarSet, myMC);
}
//RooRealVar* ZZLD = new RooRealVar("ZZLD","ZZLD",0.,1.);
//char cut[10];
//sprintf(cut,"ZZLD>0.5");
//RooDataSet* set = new RooDataSet("set","set",tree,RooArgSet(*ZZMass,*MC_weight,*ZZLD),cut,"MC_weight");
double totalweight = 0.;
for (int i=0 ; i<set->numEntries() ; i++) {
set->get(i) ;
totalweight += set->weight();
//cout << CMS_zz4l_mass->getVal() << " = " << set->weight() << endl ;
}
cout << "nEntries: " << set->numEntries() << ", totalweight: " << totalweight << endl;
gSystem->Load("libHiggsAnalysisCombinedLimit.so");
//// ---------------------------------------
//Background
RooRealVar CMS_qqzzbkg_a0("CMS_qqzzbkg_a0","CMS_qqzzbkg_a0",115.3,0.,200.);
RooRealVar CMS_qqzzbkg_a1("CMS_qqzzbkg_a1","CMS_qqzzbkg_a1",21.96,0.,200.);
RooRealVar CMS_qqzzbkg_a2("CMS_qqzzbkg_a2","CMS_qqzzbkg_a2",122.8,0.,200.);
RooRealVar CMS_qqzzbkg_a3("CMS_qqzzbkg_a3","CMS_qqzzbkg_a3",0.03479,0.,1.);
RooRealVar CMS_qqzzbkg_a4("CMS_qqzzbkg_a4","CMS_qqzzbkg_a4",185.5,0.,200.);
RooRealVar CMS_qqzzbkg_a5("CMS_qqzzbkg_a5","CMS_qqzzbkg_a5",12.67,0.,200.);
RooRealVar CMS_qqzzbkg_a6("CMS_qqzzbkg_a6","CMS_qqzzbkg_a6",34.81,0.,100.);
RooRealVar CMS_qqzzbkg_a7("CMS_qqzzbkg_a7","CMS_qqzzbkg_a7",0.1393,0.,1.);
RooRealVar CMS_qqzzbkg_a8("CMS_qqzzbkg_a8","CMS_qqzzbkg_a8",66.,0.,200.);
RooRealVar CMS_qqzzbkg_a9("CMS_qqzzbkg_a9","CMS_qqzzbkg_a9",0.07191,0.,1.);
RooggZZPdf_v2* bkg_ggzz = new RooggZZPdf_v2("bkg_ggzz","bkg_ggzz",*ZZMass,
CMS_qqzzbkg_a0,CMS_qqzzbkg_a1,CMS_qqzzbkg_a2,CMS_qqzzbkg_a3,CMS_qqzzbkg_a4,
CMS_qqzzbkg_a5,CMS_qqzzbkg_a6,CMS_qqzzbkg_a7,CMS_qqzzbkg_a8,CMS_qqzzbkg_a9);
//// ---------------------------------------
RooFitResult *r1 = bkg_ggzz->fitTo( *set, Save(kTRUE), SumW2Error(kTRUE) );//, Save(kTRUE), SumW2Error(kTRUE)) ;
cout << endl;
cout << "------- Parameters for " << schannel << " sqrts=" << sqrts << endl;
cout << " a0_bkgd = " << CMS_qqzzbkg_a0.getVal() << endl;
cout << " a1_bkgd = " << CMS_qqzzbkg_a1.getVal() << endl;
cout << " a2_bkgd = " << CMS_qqzzbkg_a2.getVal() << endl;
cout << " a3_bkgd = " << CMS_qqzzbkg_a3.getVal() << endl;
cout << " a4_bkgd = " << CMS_qqzzbkg_a4.getVal() << endl;
cout << " a5_bkgd = " << CMS_qqzzbkg_a5.getVal() << endl;
cout << " a6_bkgd = " << CMS_qqzzbkg_a6.getVal() << endl;
cout << " a7_bkgd = " << CMS_qqzzbkg_a7.getVal() << endl;
cout << " a8_bkgd = " << CMS_qqzzbkg_a8.getVal() << endl;
cout << " a9_bkgd = " << CMS_qqzzbkg_a9.getVal() << endl;
cout << "---------------------------" << endl << endl;
of << "ggZZshape a0_bkgd " << CMS_qqzzbkg_a0.getVal() << endl;
of << "ggZZshape a1_bkgd " << CMS_qqzzbkg_a1.getVal() << endl;
of << "ggZZshape a2_bkgd " << CMS_qqzzbkg_a2.getVal() << endl;
of << "ggZZshape a3_bkgd " << CMS_qqzzbkg_a3.getVal() << endl;
of << "ggZZshape a4_bkgd " << CMS_qqzzbkg_a4.getVal() << endl;
of << "ggZZshape a5_bkgd " << CMS_qqzzbkg_a5.getVal() << endl;
of << "ggZZshape a6_bkgd " << CMS_qqzzbkg_a6.getVal() << endl;
of << "ggZZshape a7_bkgd " << CMS_qqzzbkg_a7.getVal() << endl;
of << "ggZZshape a8_bkgd " << CMS_qqzzbkg_a8.getVal() << endl;
of << "ggZZshape a9_bkgd " << CMS_qqzzbkg_a9.getVal() << endl;
of << endl;
of.close();
cout << endl << "Output written to: " << outfile << endl;
int iLineColor = 1;
string lab = "blah";
if (channel == 1) { iLineColor = 2; lab = "4#mu"; }
if (channel == 3) { iLineColor = 4; lab = "2e2#mu"; }
if (channel == 2) { iLineColor = 6; lab = "4e"; }
char lname[192];
sprintf(lname,"gg #rightarrow ZZ #rightarrow %s", lab.c_str() );
char lname2[192];
sprintf(lname2,"Shape Model, %s", lab.c_str() );
// dummy!
TF1* dummyF = new TF1("dummyF","1",0.,1.);
TH1F* dummyH = new TH1F("dummyH","",1, 0.,1.);
dummyF->SetLineColor( iLineColor );
dummyF->SetLineWidth( 2 );
TLegend * box2 = new TLegend(0.5,0.70,0.90,0.90);
box2->SetFillColor(0);
box2->SetBorderSize(0);
box2->AddEntry(dummyH,"Simulation (GG2ZZ) ","pe");
box2->AddEntry(dummyH,lname,"");
box2->AddEntry(dummyH,"","");
box2->AddEntry(dummyF,lname2,"l");
TPaveText *pt = new TPaveText(0.15,0.955,0.4,0.99,"NDC");
pt->SetFillColor(0);
pt->SetBorderSize(0);
pt->AddText("CMS Preliminary 2012");
TPaveText *pt2 = new TPaveText(0.84,0.955,0.99,0.99,"NDC");
pt2->SetFillColor(0);
pt2->SetBorderSize(0);
// Plot m4l and
RooPlot* frameM4l = ZZMass->frame(Title("M4L"),Bins(200)) ;
set->plotOn(frameM4l, MarkerStyle(24)) ;
bkg_ggzz->plotOn(frameM4l,LineColor(iLineColor)) ;
set->plotOn(frameM4l) ;
//comaprison with different shape, if needed (uncommenting also the code above)
//bkg_ggzz_bkgd->plotOn(frameM4l,LineColor(1),NormRange("largerange")) ;
frameM4l->GetXaxis()->SetTitle("m_{4l} [GeV]");
frameM4l->GetYaxis()->SetTitle("a.u.");
//frameM4l->GetYaxis()->SetRangeUser(0,0.03);
//if(channel == 3)frameM4l->GetYaxis()->SetRangeUser(0,0.05);
//if(VBFtag<2){
// if(channel == 3)frameM4l->GetYaxis()->SetRangeUser(0,0.01);
// else frameM4l->GetYaxis()->SetRangeUser(0,0.005);
//}
frameM4l->GetXaxis()->SetRangeUser(100,1000);
TCanvas *c = new TCanvas("c","c",800,600);
c->cd();
frameM4l->Draw();
box2->Draw();
pt->Draw();
pt2->Draw();
TString outputPath = "bkgFigs";
outputPath = outputPath+ (long) sqrts + "TeV/";
TString outputName;
outputName = outputPath + "bkgggzz_" + schannel + "_" + Form("%d",int(VBFtag));
c->SaveAs(outputName + ".eps");
c->SaveAs(outputName + ".png");
c->SaveAs(outputName + ".root");
delete c;
frameM4l->GetXaxis()->SetRangeUser(100,200);
TCanvas *c = new TCanvas("c","c",800,600);
c->cd();
frameM4l->Draw();
box2->Draw();
pt->Draw();
pt2->Draw();
TString outputPath = "bkgFigs";
outputPath = outputPath+ (long) sqrts + "TeV/";
TString outputName;
outputName = outputPath + "bkgggzz_lowZoom_" + schannel + "_" + Form("%d",int(VBFtag));
c->SaveAs(outputName + ".eps");
c->SaveAs(outputName + ".png");
c->SaveAs(outputName + ".root");
delete c;
}
///
/// Find the global minimum in a more thorough way.
/// First fit with external start parameters, then
/// for each parameter that starts with "d" or "r" (typically angles and ratios):
/// - at upper scan range, rest at start parameters
/// - at lower scan range, rest at start parameters
/// This amounts to a maximum of 1+2^n fits, where n is the number
/// of parameters to be varied.
///
/// \param w Workspace holding the pdf.
/// \param name Name of the pdf without leading "pdf_".
/// \param forceVariables Apply the force method for these variables only. Format
/// "var1,var2,var3," (list must end with comma). Default is to apply for all angles,
/// all ratios except rD_k3pi and rD_kpi, and the k3pi coherence factor.
///
RooFitResult* Utils::fitToMinForce(RooWorkspace *w, TString name, TString forceVariables)
{
bool debug = true;
TString parsName = "par_"+name;
TString obsName = "obs_"+name;
TString pdfName = "pdf_"+name;
RooFitResult *r = 0;
int printlevel = -1;
RooMsgService::instance().setGlobalKillBelow(ERROR);
// save start parameters
if ( !w->set(parsName) ){
cout << "MethodProbScan::scan2d() : ERROR : parsName not found: " << parsName << endl;
exit(1);
}
RooDataSet *startPars = new RooDataSet("startParsForce", "startParsForce", *w->set(parsName));
startPars->add(*w->set(parsName));
// set up parameters and ranges
RooArgList *varyPars = new RooArgList();
TIterator* it = w->set(parsName)->createIterator();
while ( RooRealVar* p = (RooRealVar*)it->Next() )
{
if ( p->isConstant() ) continue;
if ( forceVariables=="" && ( false
|| TString(p->GetName()).BeginsWith("d") ///< use these variables
// || TString(p->GetName()).BeginsWith("r")
|| TString(p->GetName()).BeginsWith("k")
|| TString(p->GetName()) == "g"
) && ! (
TString(p->GetName()) == "rD_k3pi" ///< don't use these
|| TString(p->GetName()) == "rD_kpi"
// || TString(p->GetName()) == "dD_kpi"
|| TString(p->GetName()) == "d_dk"
|| TString(p->GetName()) == "d_dsk"
))
{
varyPars->add(*p);
}
else if ( forceVariables.Contains(TString(p->GetName())+",") )
{
varyPars->add(*p);
}
}
delete it;
int nPars = varyPars->getSize();
if ( debug ) cout << "Utils::fitToMinForce() : nPars = " << nPars << " => " << pow(2.,nPars) << " fits" << endl;
if ( debug ) cout << "Utils::fitToMinForce() : varying ";
if ( debug ) varyPars->Print();
//////////
r = fitToMinBringBackAngles(w->pdf(pdfName), false, printlevel);
//////////
int nErrors = 0;
// We define a binary mask where each bit corresponds
// to parameter at max or at min.
for ( int i=0; i<pow(2.,nPars); i++ )
{
if ( debug ) cout << "Utils::fitToMinForce() : fit " << i << " \r" << flush;
setParameters(w, parsName, startPars->get(0));
for ( int ip=0; ip<nPars; ip++ )
{
RooRealVar *p = (RooRealVar*)varyPars->at(ip);
float oldMin = p->getMin();
float oldMax = p->getMax();
setLimit(w, p->GetName(), "force");
if ( i/(int)pow(2.,ip) % 2==0 ) { p->setVal(p->getMin()); }
if ( i/(int)pow(2.,ip) % 2==1 ) { p->setVal(p->getMax()); }
p->setRange(oldMin, oldMax);
}
// check if start parameters are sensible, skip if they're not
double startParChi2 = getChi2(w->pdf(pdfName));
if ( startParChi2>2000 ){
nErrors += 1;
continue;
}
// refit
RooFitResult *r2 = fitToMinBringBackAngles(w->pdf(pdfName), false, printlevel);
// In case the initial fit failed, accept the second one.
// If both failed, still select the second one and hope the
// next fit succeeds.
if ( !(r->edm()<1 && r->covQual()==3) ){
delete r;
r = r2;
}
else if ( r2->edm()<1 && r2->covQual()==3 && r2->minNll()<r->minNll() ){
// better minimum found!
delete r;
r = r2;
}
else{
delete r2;
}
}
if ( debug ) cout << endl;
if ( debug ) cout << "Utils::fitToMinForce() : nErrors = " << nErrors << endl;
RooMsgService::instance().setGlobalKillBelow(INFO);
// (re)set to best parameters
setParameters(w, parsName, r);
delete startPars;
return r;
}
void fitSingleMass( const std::string& basedir, float mass, const std::string& width, TGraphErrors* gr_mean, TGraphErrors* gr_sigma, TGraphErrors* gr_width, TGraphErrors* gr_alpha1, TGraphErrors* gr_n1, TGraphErrors* gr_alpha2, TGraphErrors* gr_n2 ) {
std::string outdir = "genSignalShapes";
system( Form("mkdir -p %s", outdir.c_str()) );
std::string dataset( Form( "GluGluSpin0ToZGamma_ZToLL_W_%s_M_%.0f_TuneCUEP8M1_13TeV_pythia8", width.c_str(), mass ) );
std::cout << "-> Starting: " << dataset << std::endl;
system( Form("ls %s/%s/crab_%s/*/0000/genAna_1.root >> toBeAdded.txt", basedir.c_str(), dataset.c_str(), dataset.c_str() ) );
TChain* tree = new TChain("mt2");
ifstream ifs("toBeAdded.txt");
while( ifs.good() ) {
std::string fileName;
ifs >> fileName;
TString fileName_tstr(fileName);
if( !fileName_tstr.Contains("pnfs") ) continue;
tree->Add(Form("$DCAP/%s/mt2", fileName.c_str()) );
}
system( "rm toBeAdded.txt" );
if( tree->GetEntries()==0 ) return;
int ngenPart;
tree->SetBranchAddress( "ngenPart", &ngenPart );
float genPart_pt[100];
tree->SetBranchAddress( "genPart_pt", genPart_pt );
float genPart_eta[100];
tree->SetBranchAddress( "genPart_eta", genPart_eta );
float genPart_phi[100];
tree->SetBranchAddress( "genPart_phi", genPart_phi );
float genPart_mass[100];
tree->SetBranchAddress( "genPart_mass", genPart_mass );
int genPart_pdgId[100];
tree->SetBranchAddress( "genPart_pdgId", genPart_pdgId );
int genPart_motherId[100];
tree->SetBranchAddress( "genPart_motherId", genPart_motherId );
int genPart_status[100];
tree->SetBranchAddress( "genPart_status", genPart_status );
RooRealVar* x = new RooRealVar("boss_mass", "boss_mass", mass, 0.5*mass, 1.5*mass );
RooDataSet* data = new RooDataSet( "data", "data", RooArgSet(*x) );
int nentries = tree->GetEntries();
for( int iEntry = 0; iEntry<nentries; ++iEntry ) {
if( iEntry % 25000 == 0 ) std::cout << " Entry: " << iEntry << " / " << nentries << std::endl;
tree->GetEntry(iEntry);
TLorentzVector leptPlus;
TLorentzVector leptMinus;
TLorentzVector photon;
bool foundLeptPlus = false;
bool foundLeptMinus = false;
bool foundPhoton = false;
bool tauEvent = false;
for( int iPart=0; iPart<ngenPart; ++iPart ) {
if( genPart_status[iPart]!=1 ) continue;
if( abs(genPart_pdgId[iPart])==15 ) {
tauEvent = true;
break;
}
if( (genPart_pdgId[iPart]==+11 || genPart_pdgId[iPart]==+13) && genPart_motherId[iPart]==23 ) {
leptMinus.SetPtEtaPhiM( genPart_pt[iPart], genPart_eta[iPart], genPart_phi[iPart], genPart_mass[iPart] );
foundLeptMinus = true;
}
if( (genPart_pdgId[iPart]==-11 || genPart_pdgId[iPart]==-13) && genPart_motherId[iPart]==23 ) {
leptPlus.SetPtEtaPhiM( genPart_pt[iPart], genPart_eta[iPart], genPart_phi[iPart], genPart_mass[iPart] );
foundLeptPlus = true;
}
if( genPart_pdgId[iPart]==22 && genPart_motherId[iPart]==25 ) {
photon.SetPtEtaPhiM( genPart_pt[iPart], genPart_eta[iPart], genPart_phi[iPart], genPart_mass[iPart] );
foundPhoton = true;
}
} // for genparts
if( tauEvent ) continue;
if( !foundLeptPlus || !foundLeptMinus || !foundPhoton ) continue;
if( photon.Pt() < 40. ) continue;
float ptMax = TMath::Max( leptPlus.Pt(), leptMinus.Pt() );
float ptMin = TMath::Min( leptPlus.Pt(), leptMinus.Pt() );
if( ptMax<25. ) continue;
if( ptMin<20. ) continue;
if( fabs( photon.Eta() ) > 2.5 ) continue;
if( fabs( photon.Eta())>1.44 && fabs( photon.Eta())<1.57 ) continue;
if( fabs( leptPlus.Eta() ) > 2.4 ) continue;
if( fabs( leptMinus.Eta() ) > 2.4 ) continue;
if( photon.DeltaR( leptPlus ) < 0.4 ) continue;
if( photon.DeltaR( leptMinus ) < 0.4 ) continue;
TLorentzVector zBoson = leptPlus + leptMinus;
if( zBoson.M() < 50. ) continue;
TLorentzVector boss = zBoson + photon;
if( boss.M() < 200. ) continue;
if( photon.Pt()/boss.M()< 40./150. ) continue;
x->setVal(boss.M());
data->add(RooArgSet(*x));
}
//RooRealVar* bw_mean = new RooRealVar( "bw_mean", "Breit-Wigner Mean" , mass, 0.2*mass, 1.8*mass );
//RooRealVar* bw_gamma = new RooRealVar( "bw_gamma", "Breit-Wigner Width", 0.01*mass, 0., 0.3*mass );
//RooBreitWigner* model = new RooBreitWigner( "bw", "Breit-Wigner", *x, *bw_mean, *bw_gamma);
// Crystal-Ball
RooRealVar mean( "mean", "mean", mass, 0.9*mass, 1.1*mass );
RooRealVar sigma( "sigma", "sigma", 0.015*mass, 0., 0.07*mass );
RooRealVar alpha1( "alpha1", "alpha1", 1.2, 0., 2.5 );
RooRealVar n1( "n1", "n1", 3., 0., 5. );
RooRealVar alpha2( "alpha2", "alpha2", 1.2, 0., 2.5 );
RooRealVar n2( "n2", "n2", 3., 0., 10. );
RooDoubleCBShape* model = new RooDoubleCBShape( "cb", "cb", *x, mean, sigma, alpha1, n1, alpha2, n2 );
model->fitTo( *data );
int npoints = gr_mean->GetN();
gr_mean ->SetPoint( npoints, mass, mean.getVal() );
gr_sigma ->SetPoint( npoints, mass, sigma.getVal() );
gr_width ->SetPoint( npoints, mass, sigma.getVal()/mean.getVal() );
gr_alpha1->SetPoint( npoints, mass, alpha1.getVal() );
gr_alpha2->SetPoint( npoints, mass, alpha2.getVal() );
gr_n1 ->SetPoint( npoints, mass, n1.getVal() );
gr_n2 ->SetPoint( npoints, mass, n2.getVal() );
gr_mean ->SetPointError( npoints, 0., mean.getError() );
gr_sigma ->SetPointError( npoints, 0., sigma.getError() );
gr_width ->SetPointError( npoints, 0., sigma.getError()/mean.getVal() );
gr_alpha1->SetPointError( npoints, 0., alpha1.getError() );
gr_alpha2->SetPointError( npoints, 0., alpha2.getError() );
gr_n1 ->SetPointError( npoints, 0., n1.getError() );
gr_n2 ->SetPointError( npoints, 0., n2.getError() );
//gr_mean ->SetPoint ( npoints, mass, bw_mean->getVal() );
//gr_gamma->SetPoint ( npoints, mass, bw_gamma->getVal() );
//gr_width->SetPoint ( npoints, mass, bw_gamma->getVal()/bw_mean->getVal() );
//gr_mean ->SetPointError( npoints, 0., bw_mean->getError() );
//gr_gamma->SetPointError( npoints, 0., bw_gamma->getError()/bw_mean->getVal() );
//gr_width->SetPointError( npoints, 0., bw_gamma->getError()/bw_mean->getVal() );
RooPlot* plot = x->frame();
data->plotOn(plot);
model->plotOn(plot);
TCanvas* c1 = new TCanvas( "c1", "", 600, 600 );
c1->cd();
plot->Draw();
c1->SaveAs( Form("%s/fit_m%.0f_%s.eps", outdir.c_str(), mass, width.c_str()) );
c1->SaveAs( Form("%s/fit_m%.0f_%s.pdf", outdir.c_str(), mass, width.c_str()) );
c1->SetLogy();
c1->SaveAs( Form("%s/fit_m%.0f_%s_log.eps", outdir.c_str(), mass, width.c_str()) );
c1->SaveAs( Form("%s/fit_m%.0f_%s_log.pdf", outdir.c_str(), mass, width.c_str()) );
//delete bw_mean;
//delete bw_gamma;
delete c1;
delete data;
delete model;
delete plot;
delete x;
}
void fitMass1(int iCharge,double iEtaMin,double iEtaMax,double iPhiMin,double iPhiMax,double &iRes,double &iShift,double &iResErr,double &iShiftErr) {
Prep();
RooRealVar l1Sigma("sigma1","sigma1",1.7 ,0.,15.); //l1Sigma.setConstant(kTRUE);
RooRealVar l2Sigma("sigma2","sigma2",1.15,0.,15.); l2Sigma.setConstant(kTRUE);
RooRealVar l3Sigma("sigma3","sigma3",2.8,0.,35.); l3Sigma.setConstant(kTRUE);
RooRealVar lN ("n" ,"n" ,1.5,-15,15.); lN.setConstant(kTRUE);
RooRealVar lExp ("exp" ,"exp" ,-0.003,-15,15.); //lExp.setConstant(kTRUE);
RooRealVar lR1Mean("mean","mean",90.8,60,150); //lR1Mean.setConstant(kTRUE);
RooRealVar lRXVar("XVar","mass(GeV/c^{2})",90,60,120); //lRXVar.setBins(500);
RooRealVar lRYield("Yield","mass(GeV/c^{2})",10000,0,20000);
RooVoigtianShape lGAdd("Add","Add",lRXVar,lR1Mean,l1Sigma,l2Sigma,lN,l3Sigma,true);
//RooExtendPdf lGEx("Ex","Ex",lGAdd,lRYield);
//RooAddPdf lGAdd("XAdd","XAdd",lGAdd1,lExpF,lCFrac);
RooDataSet *lData = new RooDataSet("crap" ,"crap",RooArgSet(lRXVar));
RooDataSet *lXData = new RooDataSet("xcrap","xcrap",RooArgSet(lRXVar));
RooDataSet *lYData = new RooDataSet("ycrap","ycrap",RooArgSet(lRXVar));
TFile *lFile = new TFile("../Efficiency/Data/mTPNT8_v1.root");//G39TP.root");
//TFile *lFile = new TFile("../Efficiency/Data/ZTP8_v2.root");//G39TP.root");
TTree *lTree = (TTree*) lFile->FindObjectAny("WNtupleIdEffNT");
float lMt = 0; lTree->SetBranchAddress("mt" ,&lMt);
int lCharge = 0; lTree->SetBranchAddress("charge",&lCharge);
float lEta = 0; lTree->SetBranchAddress("eta" ,&lEta);
float lPhi = 0; lTree->SetBranchAddress("phi" ,&lPhi);
float lPt = 0; lTree->SetBranchAddress("pt" ,&lPt);
float lOPt = 0; lTree->SetBranchAddress("jetpt" ,&lOPt);
float lOPhi = 0; lTree->SetBranchAddress("jetphi",&lOPhi);
float lOEta = 0; lTree->SetBranchAddress("jeteta",&lOEta);
float lTrkIso = 0; lTree->SetBranchAddress("trkiso",&lTrkIso);
float lEcalIso = 0; lTree->SetBranchAddress("ecaliso",&lEcalIso);
float lHcalIso = 0; lTree->SetBranchAddress("hcaliso",&lHcalIso);
float lChi2 = 0; lTree->SetBranchAddress("chi2" ,&lChi2);
int lNHit = 0; lTree->SetBranchAddress("nhit" ,&lNHit);
Muon lMuon; lTree->SetBranchAddress("muon" ,&lMuon);
for(int i0 = 0; i0 < lTree->GetEntries();i0++) {
if(i0 > 200000) break;
lTree->GetEntry(i0);
if(fabs(lPt) < 25 || fabs(lOPt) < 25) continue;
if(lMt < 60) continue;
if(lChi2 > 10) continue;
if(lNHit < 10) continue;
if(lMuon.NSeg < 2) continue;
if(lMuon.NPixel == 0) continue;
if(lMuon.NValid == 0) continue;
if(lMuon.Type != 3) continue;
if((lTrkIso+lEcalIso+lHcalIso)/lPt > 0.15) continue;
if(lCharge > 0 && iCharge < 0) continue;
if(lCharge < 0 && iCharge > 0) continue;
//if(lEta < iEtaMin || lEta > iEtaMax) continue;
if(lPhi < iPhiMin || lPhi > iPhiMax) continue;
//if(lEta < iPhiMin || lEta > iPhiMax) continue;
if(lCharge > 0) lRXVar.setVal(correct(lMt,lPhi,lOPhi,lEta,lOEta));
if(lCharge < 0) lRXVar.setVal(correct(lMt,lOPhi,lPhi,lOEta,lEta));
//cout << "====> " << lMt << " ---> " << lRXVar.getVal() << " --- " << endl;
//lXData->add(RooArgSet(lRXVar));
//lRXVar.setVal(fabs(lMt));
lYData->add(RooArgSet(lRXVar));
}
/*
RooHistPdf *lMYPdf = new RooHistPdf ("MY","MY",RooArgList(lRXVar),*lYData->binnedClone());
TFile *lQFile = new TFile("../Efficiency/Data/mTPNT8_v1.root");//G39TP.root");
TTree *lQTree = (TTree*) lQFile->FindObjectAny("WNtupleIdEffNT");
lQTree->SetBranchAddress("mt" ,&lMt);
lQTree->SetBranchAddress("charge",&lCharge);
lQTree->SetBranchAddress("eta" ,&lEta);
lQTree->SetBranchAddress("phi" ,&lPhi);
lQTree->SetBranchAddress("pt" ,&lPt);
lQTree->SetBranchAddress("jetpt" ,&lOPt);
lQTree->SetBranchAddress("jetphi",&lOPhi);
lQTree->SetBranchAddress("jeteta",&lOEta);
for(int i0 = 0; i0 < lQTree->GetEntries();i0++) {
lQTree->GetEntry(i0);
//if(lOPt*lPt < 0) continue;
if(lMt < 60) continue;
// if(lCharge > 0 && iCharge < 0) continue;
//if(lCharge < 0 && iCharge > 0) continue;
//if(lEta < iEtaMin || lEta > iEtaMax) continue;
//if(lPhi < iPhiMin || lPhi > iPhiMax) continue;
if(lCharge > 0) lRXVar.setVal(correct(lMt,lPhi,lOPhi,lEta,lOEta));
if(lCharge < 0) lRXVar.setVal(correct(lMt,lOPhi,lPhi,lOEta,lEta));
lXData->add(RooArgSet(lRXVar));
lRXVar.setVal(lMt);
lData->add(RooArgSet(lRXVar));
}
RooHistPdf *lMPdf = new RooHistPdf ("MH","MH",RooArgList(lRXVar),*lXData->binnedClone());
*/
lGAdd.fitTo(*lYData,Strategy(1),Minos());
if(lR1Mean.getError() < 0.01) lGAdd.fitTo(*lYData,Strategy(2),Minos());
lRXVar.setBins(60);
iShift = 1./(lR1Mean.getVal()/91.2); iShiftErr = lR1Mean.getError()*91.2/lR1Mean.getVal()/lR1Mean.getVal();
iRes = l1Sigma.getVal(); iResErr = l1Sigma.getError();
return;
TH1F *lH0 = new TH1F("A","A",1,-5,5); lH0->SetMarkerStyle(21);
TH1F *lH1 = new TH1F("B","B",1,-5,5); lH1->SetLineColor(kRed);
TH1F *lH2 = new TH1F("C","C",1,-5,5); lH2->SetLineColor(kBlue);
TLegend *lL = new TLegend(0.5,0.5,0.8,0.8); lL->SetFillColor(0); lL->SetBorderSize(0);
lL->AddEntry(lH0,"data" ,"lp");
lL->AddEntry(lH1,"MC-corrected" ,"l");
lL->AddEntry(lH2,"MC" ,"l");
RooPlot *lFrame1 = lRXVar.frame(RooFit::Title("XXX")) ;
lYData->plotOn(lFrame1);
lGAdd.plotOn(lFrame1);
//lXData->plotOn(lFrame1,MarkerColor(kRed));
//lMPdf->plotOn(lFrame1,LineColor(kRed));
//lMYPdf->plotOn(lFrame1,LineColor(kBlue));
TCanvas *iC =new TCanvas("A","A",800,600);
iC->cd(); lFrame1->Draw();
//lL->Draw();
iC->SaveAs("Crap.png");
//cin.get();
}
//put very small data entries in a binned dataset to avoid unphysical pdfs, specifically for H->ZZ->4l
RooDataSet* makeData(RooDataSet* orig, RooSimultaneous* simPdf, const RooArgSet* observables, RooRealVar* firstPOI, double mass, double& mu_min)
{
double max_soverb = 0;
mu_min = -10e9;
map<string, RooDataSet*> data_map;
firstPOI->setVal(0);
RooCategory* cat = (RooCategory*)&simPdf->indexCat();
TList* datalist = orig->split(*(RooAbsCategory*)cat, true);
TIterator* dataItr = datalist->MakeIterator();
RooAbsData* ds;
RooRealVar* weightVar = new RooRealVar("weightVar","weightVar",1);
while ((ds = (RooAbsData*)dataItr->Next()))
{
string typeName(ds->GetName());
cat->setLabel(typeName.c_str());
RooAbsPdf* pdf = simPdf->getPdf(typeName.c_str());
cout << "pdf: " << pdf << endl;
RooArgSet* obs = pdf->getObservables(observables);
cout << "obs: " << obs << endl;
RooArgSet obsAndWeight(*obs, *weightVar);
obsAndWeight.add(*cat);
stringstream datasetName;
datasetName << "newData_" << typeName;
RooDataSet* thisData = new RooDataSet(datasetName.str().c_str(),datasetName.str().c_str(), obsAndWeight, WeightVar(*weightVar));
RooRealVar* firstObs = (RooRealVar*)obs->first();
//int ibin = 0;
int nrEntries = ds->numEntries();
for (int ib=0;ib<nrEntries;ib++)
{
const RooArgSet* event = ds->get(ib);
const RooRealVar* thisObs = (RooRealVar*)event->find(firstObs->GetName());
firstObs->setVal(thisObs->getVal());
firstPOI->setVal(0);
double b = pdf->expectedEvents(*firstObs)*pdf->getVal(obs);
firstPOI->setVal(1);
double s = pdf->expectedEvents(*firstObs)*pdf->getVal(obs) - b;
if (s > 0)
{
mu_min = max(mu_min, -b/s);
double soverb = s/b;
if (soverb > max_soverb)
{
max_soverb = soverb;
cout << "Found new max s/b: " << soverb << " in pdf " << pdf->GetName() << " at m = " << thisObs->getVal() << endl;
}
}
if (b == 0 && s != 0)
{
cout << "Expecting non-zero signal and zero bg at m=" << firstObs->getVal() << " in pdf " << pdf->GetName() << endl;
}
if (s+b <= 0)
{
cout << "expecting zero" << endl;
continue;
}
double weight = ds->weight();
if ((typeName.find("ATLAS_H_4mu") != string::npos ||
typeName.find("ATLAS_H_4e") != string::npos ||
typeName.find("ATLAS_H_2mu2e") != string::npos ||
typeName.find("ATLAS_H_2e2mu") != string::npos) && fabs(firstObs->getVal() - mass) < 10 && weight == 0)
{
cout << "adding event: " << firstObs->getVal() << endl;
thisData->add(*event, pow(10., -9.));
}
else
{
//weight = max(pow(10.0, -9), weight);
thisData->add(*event, weight);
}
}
data_map[string(ds->GetName())] = (RooDataSet*)thisData;
}
RooDataSet* newData = new RooDataSet("newData","newData",RooArgSet(*observables, *weightVar),
Index(*cat), Import(data_map), WeightVar(*weightVar));
orig->Print();
newData->Print();
//newData->tree()->Scan("*");
return newData;
}
void fitMass2(int iCharge,double iEtaMin,double iEtaMax,double iPhiMin,double iPhiMax,double &iRes,double &iShift,double &iResErr,double &iShiftErr) {
Prep();
RooRealVar lXVar ("XVar","mass(GeV/c^{2})",60,60,120); lXVar.setBins(1000);
RooRealVar lSPar ("SPar","SPar", 1.,0., 2.);
RooFormulaVar lXShift("uparshift","@0*@1",RooArgList(lXVar,lSPar));
TFile *lMCFile = new TFile("../Efficiency/Data/ZTP8_v2.root");
TTree *lMCTree = (TTree*) lMCFile->FindObjectAny("WNtupleIdEffNT");
TH1F *lMass = new TH1F("M","M",100,60,120);
int lCharge = 0; lMCTree->SetBranchAddress("charge",&lCharge);
float lEta = 0; lMCTree->SetBranchAddress("eta" ,&lEta);
float lPhi = 0; lMCTree->SetBranchAddress("phi" ,&lPhi);
float lMt = 0; lMCTree->SetBranchAddress("mt" ,&lMt);
float lPt = 0; lMCTree->SetBranchAddress("pt" ,&lPt);
float lOPt = 0; lMCTree->SetBranchAddress("jetpt" ,&lOPt);
float lOEta = 0; lMCTree->SetBranchAddress("jeteta",&lOEta);
float lOPhi = 0; lMCTree->SetBranchAddress("jetphi",&lOPhi);
float lTrkIso = 0; lMCTree->SetBranchAddress("trkiso",&lTrkIso);
float lEcalIso = 0; lMCTree->SetBranchAddress("ecaliso",&lEcalIso);
float lHcalIso = 0; lMCTree->SetBranchAddress("hcaliso",&lHcalIso);
float lChi2 = 0; lMCTree->SetBranchAddress("chi2" ,&lChi2);
unsigned int lNHit = 0; lMCTree->SetBranchAddress("nhit" ,&lNHit);
Muon lMuon; lMCTree->SetBranchAddress("muon" ,&lMuon);
double lVPt = 0; double lEt = 0; double lPx = 0; double lPy = 0;
for(int i0 = 0; i0 < lMCTree->GetEntries(); i0++) {
lMCTree->GetEntry(i0);
if(lMt < 60) continue;
if(lChi2 > 10) continue;
if(lNHit < 10) continue;
if(lMuon.NSeg < 2) continue;
if(lMuon.NPixel == 0) continue;
if(lMuon.NValid == 0) continue;
if(lMuon.Type != 3) continue;
if((lTrkIso+lEcalIso+lHcalIso)/lPt > 0.15) continue;
//if(lCharge > 0 && iCharge < 0) continue;
//if(lCharge < 0 && iCharge > 0) continue;
//if(lEta < iPhiMin || lEta > iPhiMax) continue;
//if(fabs(lEta) < 1.2) continue;
//if(lEta < iEtaMin || lEta > iEtaMax) continue;
//if(lPhi*lOPhi > 0 || lEta*lOEta > 0) continue;
if(lPhi < iPhiMin || lPhi > iPhiMax) continue;
lEt = lOPt + lPt; lPx = fabs(lPt)*cos(lPhi) + fabs(lOPt)*cos(lOPhi); lPy = fabs(lPt)*sin(lPhi) + fabs(lOPt)*sin(lOPhi);
lVPt = sqrt(lPx*lPx + lPy*lPy);
//if(lVPt < iPhiMin || lVPt > iPhiMax) continue;
lMass->Fill(fabs(lMt)); //lMass->Fill(lPt);
}
RooDataHist *lMHist = new RooDataHist("M" ,"M" ,RooArgSet(lXVar),lMass);
RooHistPdf *lMPdf = new RooHistPdf ("MH","MH",lXShift,lXVar,*lMHist,5);
RooRealVar l1Sigma("sigma1","sigma1",0.2,0.,15.); //l1Sigma.setConstant(kTRUE);
RooRealVar lR0Mean("xmean","xmean",0,-10,10); lR0Mean.setConstant(kTRUE);
RooRealVar lExp ("exp" ,"exp" ,-0.006,-15,15.); //lExp.setConstant(kTRUE);
RooRealVar lFrac ("frac","frac" ,0.9,0.,1);
RooGaussian lGaus1("gaus1","gaus1",lXVar,lR0Mean,l1Sigma);
RooExponential lExpF("Exp","Exp" ,lXVar,lExp);
RooFFTConvPdf lConv("Conv","Conv",lXVar,*lMPdf,lGaus1); //lConv.setBufferStrategy(RooFFTConvPdf::Flat);
RooAddPdf lGAdd("Add","Add" ,lConv,lExpF,lFrac);
RooDataSet *lData = new RooDataSet("crap","crap",RooArgSet(lXVar));
TFile *lFile = new TFile("../Efficiency/Data/mTPNT8_v1.root");
TTree *lTree = (TTree*) lFile->FindObjectAny("WNtupleIdEffNT");
lTree->SetBranchAddress("charge",&lCharge);
lTree->SetBranchAddress("eta" ,&lEta);
lTree->SetBranchAddress("phi" ,&lPhi);
lTree->SetBranchAddress("mt" ,&lMt);
lTree->SetBranchAddress("pt" ,&lPt);
lTree->SetBranchAddress("jetpt" ,&lOPt);
lTree->SetBranchAddress("jeteta",&lOEta);
lTree->SetBranchAddress("jetphi",&lOPhi);
lTree->SetBranchAddress("trkiso",&lTrkIso);
lTree->SetBranchAddress("ecaliso",&lEcalIso);
lTree->SetBranchAddress("hcaliso",&lHcalIso);
lTree->SetBranchAddress("chi2" ,&lChi2);
lTree->SetBranchAddress("nhit" ,&lNHit);
lTree->SetBranchAddress("muon" ,&lMuon);
for(int i0 = 0; i0 < lTree->GetEntries();i0++) {
lTree->GetEntry(i0);
if(lMt < 60) continue;
if(lCharge > 0 && iCharge < 0) continue;
if(lCharge < 0 && iCharge > 0) continue;
if(lChi2 > 10) continue;
if(lNHit < 10) continue;
if(lMuon.NSeg < 2) continue;
if(lMuon.NPixel == 0) continue;
if(lMuon.NValid == 0) continue;
if(lMuon.Type != 3) continue;
if((lTrkIso+lEcalIso+lHcalIso)/lPt > 0.15) continue;
//if(fabs(lEta) < 1.2) continue;
//if(lPhi*lOPhi > 0 || lEta*lOEta > 0) continue;
//if(lEta < iPhiMin || lEta > iPhiMax) continue;
if(lPhi < iPhiMin || lPhi > iPhiMax) continue;
lEt = lOPt + lPt; lPx = fabs(lPt)*cos(lPhi) + fabs(lOPt)*cos(lOPhi); lPy = fabs(lPt)*sin(lPhi) + fabs(lOPt)*sin(lOPhi);
lVPt = sqrt(lPx*lPx + lPy*lPy);
//if(lVPt < iPhiMin || lVPt > iPhiMax) continue;
lXVar.setVal(fabs(lMt));
if(lCharge > 0) lXVar.setVal(correct(lMt,lPhi,lOPhi,lEta,lOEta));
if(lCharge < 0) lXVar.setVal(correct(lMt,lOPhi,lPhi,lOEta,lEta));
lData->add(RooArgSet(lXVar));
}
/*
TFile *lQFile = new TFile("");
TTree *lQTree = (TTree*) lQFile->FindObjectAny("WNtupleIdEffNT");
lQTree->SetBranchAddress("mt" ,&lMt);
lQTree->SetBranchAddress("charge",&lCharge);
lQTree->SetBranchAddress("eta" ,&lEta);
lQTree->SetBranchAddress("phi" ,&lPhi);
for(int i0 = 0; i0 < lQTree->GetEntries();i0++) {
lQTree->GetEntry(i0);
if(lMt < 60) continue;
if(lCharge > 0 && iCharge < 0) continue;
if(lCharge < 0 && iCharge > 0) continue;
if(lEta < iEtaMin || lEta > iEtaMax) continue;
if(lPhi < iPhiMin || lPhi > iPhiMax) continue;
lXVar.setVal(lMt);
//lData->add(RooArgSet(lXVar));
}
*/
lConv.fitTo(*lData,Strategy(1));
if(l1Sigma.getError() > 1) lConv.fitTo(*lData,Strategy(2));
lXVar.setBins(60);
RooPlot *lFrame1 = lXVar.frame(RooFit::Title("XXX")) ;
lData->plotOn(lFrame1);
lConv.plotOn(lFrame1);
//lGAdd.plotOn(lFrame1,Components("Exp"),LineColor(kRed));
TCanvas *iC =new TCanvas("A","A",800,600);
iC->cd(); lFrame1->Draw();
iC->SaveAs("Crap.png");
//cin.get();
iRes = l1Sigma.getVal(); iResErr = l1Sigma.getError();
iShift = lSPar.getVal(); iShiftErr = lSPar.getError();
}
int main (int argc, char **argv)
{
const char* chInFile = "ws.root";
const char* chOutFile = "ws_data.root";
const char* chRootFile = "BDT20.root";
const char* chCut = "";
char option_char;
while ( (option_char = getopt(argc,argv, "i:o:r:c:")) != EOF )
switch (option_char)
{
case 'i': chInFile = optarg; break;
case 'o': chOutFile = optarg; break;
case 'r': chRootFile = optarg; break;
case 'c': chCut = optarg; break;
case '?': fprintf (stderr,
"usage: %s [i<input file> o<output file>]\n", argv[0]);
}
cout << "In Ws = " << chInFile << endl;
cout << "Out Ws = " << chOutFile << endl;
cout << "Data From = " << chRootFile << endl;
cout << "Extra Cut = " << chCut << endl;
TFile* in_file = new TFile(chInFile);
RooWorkspace *rws = (RooWorkspace*) in_file->Get("rws");
TFile* tree_file = new TFile(chRootFile);
TTree* tree = (TTree*) tree_file->Get("tree");
TFile* out_file = new TFile(chOutFile, "RECREATE");
RooArgSet allVars(*rws->var("m"),*rws->var("t"),*rws->var("et"),*rws->var("cpsi"),*rws->var("ctheta"),*rws->var("phi"),*rws->var("d"));
RooDataSet* data = new RooDataSet("data","data",allVars);
RooDataSet* dataBkg = new RooDataSet("dataBkg","dataBkg",allVars);
TCut* cut = new TCut("5.17<bs_mass && bs_mass<5.57 && bs_epdl<0.02 && bs_pdl<0.40 && bs_pdl>-0.15 && 1.01<phi_mass && phi_mass<1.03");
*cut += chCut;
tree->Draw(">>entry_list", *cut, "entrylist");
TEntryList* event_list = (TEntryList*) out_file->Get("entry_list");
Double_t dM, dT, dEt, dCpsi, dCtheta, dPhi, dd;
Int_t ddDefined;
tree->SetBranchAddress("bs_mass", &dM);
tree->SetBranchAddress("bs_pdl", &dT);
tree->SetBranchAddress("bs_epdl", &dEt);
tree->SetBranchAddress("bs_angle_cpsi", &dCpsi);
tree->SetBranchAddress("bs_angle_ctheta", &dCtheta);
tree->SetBranchAddress("bs_angle_phi", &dPhi);
tree->SetBranchAddress("newtag_ost", &dd);
tree->SetBranchAddress("newtag_ost_defined", &ddDefined);
for (Long_t i=0; i<event_list->GetN(); i++){
tree->GetEntry(event_list->GetEntry(i));
*rws->var("m")=dM;
*rws->var("t")=dT/0.0299792458;
*rws->var("et")=dEt/0.0299792458;
*rws->var("cpsi")=dCpsi;
*rws->var("ctheta")=dCtheta;
*rws->var("phi")=dPhi;
*rws->var("d")=0;
////rws->cat("dilution")->setIndex(0);
if ( ddDefined==1 ){
////rws->cat("dilution")->setIndex(1);
*rws->var("d")=dd;
}
data->add(allVars);
if (dM<5.29 || dM>5.44)
dataBkg->add(allVars);
}
rws->import(*data);
rws->import(*dataBkg);
rws->Write("rws");
out_file->Close();
in_file->Close();
tree_file->Close();
cout << endl << "Done." << endl;
}
void testConditional() {
RooRealVar lRXVar("XVar","XVar",90,60,120); lRXVar.setBins(2000);
RooRealVar lSPar0("spar0","spar0",1.,0,10); //lSPar0.setConstant(kTRUE);
RooRealVar lS1Par0("s1par0","s1par0",1.0 ,0,10); //lSPar0.setConstant(kTRUE);
RooRealVar lS1Par1("s1par1","s1par1",0.02 ,-5,5); //lSPar1.setConstant(kTRUE);
RooRealVar lS1Par2("s1par2","s1par2",-0.05,-5,5); //lSPar2.setConstant(kTRUE);
RooRealVar lS1Par3("s1par3","s1par3", 0.0 ,-5,5); //lSPar3.setConstant(kTRUE);
RooRealVar lS1Par4("s1par4","s1par4",0.06,-5,5); //lSPar4.setConstant(kTRUE);
RooRealVar lS2Par0("s2par0","s2par0",1.26979,0,10); //lSPar0.setConstant(kTRUE);
RooRealVar lS2Par1("s2par1","s2par1",0.0127 ,-5,5); //lSPar1.setConstant(kTRUE);
RooRealVar lS2Par2("s2par2","s2par2",-0.057,-5,5); //lSPar2.setConstant(kTRUE);
RooRealVar lS2Par3("s2par3","s2par3",-0.19 ,-5,5); //lSPar3.setConstant(kTRUE);
RooRealVar lS2Par4("s2par4","s2par4",0.06 ,-5,5); //SPar4.setConstant(kTRUE);
RooRealVar lMPar0("mpar0","mpar0",0.,-5,5);
RooRealVar lMPar1("mpar1","mpar1",0.,-5,5);
RooRealVar lMPar2("mpar2","mpar2",0.,-5,5); //lMPar2.setConstant(kTRUE);
RooRealVar lMPar3("mpar3","mpar3",0.,-5,5);
RooRealVar lMPar4("mpar4","mpar4",0.,-5,5);// lMPar4.setConstant(kTRUE);
RooRealVar lMPar5("mpar5","mpar5",0.,-5,5);
RooRealVar lMPar6("mpar6","mpar6",0.,-5,5);
RooRealVar lRPhi ("phi","phi" ,0,-3.14,3.14);
RooRealVar lRPhi2("phi2","phi2" ,0,-3.14,3.14);
RooFormulaVar l1SigmaEta1("sigma1eta1","(@0+@1*@5+@2*@5*@5+@3*@5*@5*@5+@4*@5*@5*@5*@5)",RooArgList(lS1Par0,lS1Par1,lS1Par2,lS1Par3,lS1Par4,lRPhi));//,lSPar3,lSPar4,lRPhi2));
RooFormulaVar l1SigmaEta2("sigma1eta2","(@0+@1*@5+@2*@5*@5+@3*@5*@5*@5+@4*@5*@5*@5*@5)",RooArgList(lS1Par0,lS1Par1,lS1Par2,lS1Par3,lS1Par4,lRPhi2));//,lSPar3,lSPar4,lRPhi2));
//RooFormulaVar l1Sigma ("sigma1" ,"sqrt(@0*@0+@1*@1)" ,RooArgList(l1SigmaEta1,l1SigmaEta2));
RooRealVar l1Sigma("sigma1","sigma1",1.47,0.,3.); l1Sigma.setConstant(kTRUE);
RooRealVar l2Sigma("sigma2","sigma2",1.1 ,0.,3.); l2Sigma.setConstant(kTRUE);
RooRealVar l3Sigma("sigma3","sigma3",2.8,0.,15.); l3Sigma.setConstant(kTRUE);
RooRealVar lN ("n" ,"n" ,1.5,-15,15.); lN.setConstant(kTRUE);
//RooRealVar lR1Mean("mean","mean",91.2,60,250); lR1Mean.setConstant(kTRUE);
//RooFormulaVar lR1Mean("mean","91.2*sqrt((1+@1*sin(@3+@2))*(1+@1*sin(@6+@2)))+@0",RooArgList(lMPar0,lMPar1,lMPar2,lRPhi,lMPar3,lMPar4,lRPhi2)); //l1Sigma.setConstant(kTRUE);
RooFormulaVar lR1Mean("mean","91.2*sqrt((1+@1*sin(@3+@2))*(1+@4*sin(@6+@5)))+@0",RooArgList(lMPar0,lMPar1,lMPar2,lRPhi,lMPar3,lMPar4,lRPhi2)); //l1Sigma.setConstant(kTRUE);
//RooFormulaVar lR1Mean("mean","91.2*sqrt((1+@1*@3+@2*@3*@3+@7*@3*@3*@3)*(1+@4*@6+@5*@6*@6+@8*@6*@6*@6))+@0",RooArgList(lMPar0,lMPar1,lMPar2,lRPhi,lMPar3,lMPar4,lRPhi2,lMPar5,lMPar6)); //l1Sigma.setConstant(kTRUE);
RooVoigtianShape lConv("XXX","XXX",lRXVar,lR1Mean,l1Sigma,l2Sigma,lN,l3Sigma,false);
RooDataSet *lData = new RooDataSet("crap","crap",RooArgSet(lRXVar,lRPhi,lRPhi2));
TFile *lFile = new TFile("../Efficiency/Data/mTPNT8_v1.root");
//TFile *lFile = new TFile("../Efficiency/Data/ZTP8_v2.root");
TTree *lTree = (TTree*) lFile->FindObjectAny("WNtupleIdEffNT");
float lMt = 0; lTree->SetBranchAddress("mt" ,&lMt);
int lCharge = 0; lTree->SetBranchAddress("charge",&lCharge);
float lEta = 0; lTree->SetBranchAddress("eta" ,&lEta);
float lPhi = 0; lTree->SetBranchAddress("phi" ,&lPhi);
float lPt = 0; lTree->SetBranchAddress("pt" ,&lPt);
float lOPt = 0; lTree->SetBranchAddress("jetpt" ,&lOPt);
float lOPhi = 0; lTree->SetBranchAddress("jetphi",&lOPhi);
float lOEta = 0; lTree->SetBranchAddress("jeteta",&lOEta);
float lTrkIso = 0; lTree->SetBranchAddress("trkiso",&lTrkIso);
float lEcalIso = 0; lTree->SetBranchAddress("ecaliso",&lEcalIso);
float lHcalIso = 0; lTree->SetBranchAddress("hcaliso",&lHcalIso);
float lChi2 = 0; lTree->SetBranchAddress("chi2" ,&lChi2);
int lNHit = 0; lTree->SetBranchAddress("nhit" ,&lNHit);
Muon lMuon; lTree->SetBranchAddress("muon" ,&lMuon);
for(int i0 = 0; i0 < lTree->GetEntries();i0++) {
if(i0 > 50000) continue;
lTree->GetEntry(i0);
if(lMt < 60) continue;
if(lChi2 > 10) continue;
if(lNHit < 10) continue;
if(lMuon.NSeg < 2) continue;
if(lMuon.NPixel == 0) continue;
if(lMuon.NValid == 0) continue;
if(lMuon.Type != 3) continue;
if((lTrkIso+lEcalIso+lHcalIso)/lPt > 0.15) continue;
if(lMt < 60 || fabs(lEta) > 2.1 || fabs(lOEta) > 2.1 || fabs(lPt) < 25 || fabs(lOPt) < 25) continue;
lRXVar.setVal(lMt);
//if(lCharge > 0) lRXVar.setVal(correct(lMt,lPhi,lOPhi,0,0));//lEta ,lOEta));
//if(lCharge < 0) lRXVar.setVal(correct(lMt,lOPhi,lPhi,0,0));//lOEta,lEta));
//lRPhi.setVal(lEta); lRPhi2.setVal(lOEta);
//if(lCharge < 0) {lRPhi.setVal(lOEta); lRPhi2.setVal(lEta);}
lRPhi.setVal(lPhi); lRPhi2.setVal(lOPhi);
if(lCharge < 0) {lRPhi.setVal(lOPhi); lRPhi2.setVal(lPhi);}
lData->add(RooArgSet(lRXVar,lRPhi,lRPhi2));//,lRPhi2));
}
lConv.fitTo(*lData,ConditionalObservables(RooArgSet(lRXVar,lRPhi,lRPhi2)),Strategy(1),Minos());
//lConv.fitTo(*lData,Strategy(1));
lRXVar.setBins(50);
RooPlot *lFrame1 = lRXVar.frame(RooFit::Title("XXX")) ;
lData->plotOn(lFrame1);
lConv.plotOn(lFrame1);
TCanvas *iC =new TCanvas("A","A",800,600);
iC->cd(); lFrame1->Draw();
iC->SaveAs("Crap.png");
}
int KinZfitter::PerZ1Likelihood(double & l1, double & l2, double & lph1, double & lph2)
{
l1= 1.0; l2 = 1.0;
lph1 = 1.0; lph2 = 1.0;
if(debug_) cout<<"start Z1 refit"<<endl;
TLorentzVector Z1_1 = p4sZ1_[0]; TLorentzVector Z1_2 = p4sZ1_[1];
double RECOpT1 = Z1_1.Pt(); double RECOpT2 = Z1_2.Pt();
double pTerrZ1_1 = pTerrsZ1_[0]; double pTerrZ1_2 = pTerrsZ1_[1];
if(debug_)cout<<"pT1 "<<RECOpT1<<" pTerrZ1_1 "<<pTerrZ1_1<<endl;
if(debug_)cout<<"pT2 "<<RECOpT2<<" pTerrZ1_2 "<<pTerrZ1_2<<endl;
//////////////
TLorentzVector Z1_ph1, Z1_ph2;
double pTerrZ1_ph1, pTerrZ1_ph2;
double RECOpTph1, RECOpTph2;
TLorentzVector nullFourVector(0, 0, 0, 0);
Z1_ph1=nullFourVector; Z1_ph2=nullFourVector;
RECOpTph1 = 0; RECOpTph2 = 0;
pTerrZ1_ph1 = 0; pTerrZ1_ph2 = 0;
if(p4sZ1ph_.size()>=1){
Z1_ph1 = p4sZ1ph_[0]; pTerrZ1_ph1 = pTerrsZ1ph_[0];
RECOpTph1 = Z1_ph1.Pt();
if(debug_) cout<<"put in Z1 fsr photon 1 pT "<<RECOpTph1<<" pT err "<<pTerrZ1_ph1<<endl;
}
if(p4sZ1ph_.size()==2){
//if(debug_) cout<<"put in Z1 fsr photon 2"<<endl;
Z1_ph2 = p4sZ1ph_[1]; pTerrZ1_ph2 = pTerrsZ1ph_[1];
RECOpTph2 = Z1_ph2.Pt();
}
RooRealVar* pT1RECO = new RooRealVar("pT1RECO","pT1RECO", RECOpT1, 5, 500);
RooRealVar* pT2RECO = new RooRealVar("pT2RECO","pT2RECO", RECOpT2, 5, 500);
double RECOpT1min = max(5.0, RECOpT1-2*pTerrZ1_1);
double RECOpT2min = max(5.0, RECOpT2-2*pTerrZ1_2);
RooRealVar* pTph1RECO = new RooRealVar("pTph1RECO","pTph1RECO", RECOpTph1, 5, 500);
RooRealVar* pTph2RECO = new RooRealVar("pTph2RECO","pTph2RECO", RECOpTph2, 5, 500);
double RECOpTph1min = max(0.5, RECOpTph1-2*pTerrZ1_ph1);
double RECOpTph2min = max(0.5, RECOpTph2-2*pTerrZ1_ph2);
// observables pT1,2,ph1,ph2
RooRealVar* pT1 = new RooRealVar("pT1", "pT1FIT", RECOpT1, RECOpT1min, RECOpT1+2*pTerrZ1_1 );
RooRealVar* pT2 = new RooRealVar("pT2", "pT2FIT", RECOpT2, RECOpT2min, RECOpT2+2*pTerrZ1_2 );
RooRealVar* m1 = new RooRealVar("m1","m1", Z1_1.M());
RooRealVar* m2 = new RooRealVar("m2","m2", Z1_2.M());
if(debug_) cout<<"m1 "<<m1->getVal()<<" m2 "<<m2->getVal()<<endl;
double Vtheta1, Vphi1, Vtheta2, Vphi2;
Vtheta1 = (Z1_1).Theta(); Vtheta2 = (Z1_2).Theta();
Vphi1 = (Z1_1).Phi(); Vphi2 = (Z1_2).Phi();
RooRealVar* theta1 = new RooRealVar("theta1","theta1",Vtheta1);
RooRealVar* phi1 = new RooRealVar("phi1","phi1",Vphi1);
RooRealVar* theta2 = new RooRealVar("theta2","theta2",Vtheta2);
RooRealVar* phi2 = new RooRealVar("phi2","phi2",Vphi2);
// dot product to calculate (p1+p2+ph1+ph2).M()
RooFormulaVar E1("E1","TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1)))+@2*@2)",
RooArgList(*pT1,*theta1,*m1));
RooFormulaVar E2("E2","TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1)))+@2*@2)",
RooArgList(*pT2,*theta2,*m2));
if(debug_) cout<<"E1 "<<E1.getVal()<<"; E2 "<<E2.getVal()<<endl;
/////
RooRealVar* pTph1 = new RooRealVar("pTph1", "pTph1FIT", RECOpTph1, RECOpTph1min, RECOpTph1+2*pTerrZ1_ph1 );
RooRealVar* pTph2 = new RooRealVar("pTph2", "pTph2FIT", RECOpTph2, RECOpTph2min, RECOpTph2+2*pTerrZ1_ph2 );
double Vthetaph1, Vphiph1, Vthetaph2, Vphiph2;
Vthetaph1 = (Z1_ph1).Theta(); Vthetaph2 = (Z1_ph2).Theta();
Vphiph1 = (Z1_ph1).Phi(); Vphiph2 = (Z1_ph2).Phi();
RooRealVar* thetaph1 = new RooRealVar("thetaph1","thetaph1",Vthetaph1);
RooRealVar* phiph1 = new RooRealVar("phiph1","phiph1",Vphiph1);
RooRealVar* thetaph2 = new RooRealVar("thetaph2","thetaph2",Vthetaph2);
RooRealVar* phiph2 = new RooRealVar("phiph2","phi2",Vphiph2);
RooFormulaVar Eph1("Eph1","TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1))))",
RooArgList(*pTph1,*thetaph1));
RooFormulaVar Eph2("Eph2","TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1))))",
RooArgList(*pTph2,*thetaph2));
//// dot products of 4-vectors
// 3-vector DOT
RooFormulaVar* p1v3D2 = new RooFormulaVar("p1v3D2",
"@0*@1*( ((TMath::Cos(@2))*(TMath::Cos(@3)))/((TMath::Sin(@2))*(TMath::Sin(@3)))+(TMath::Cos(@4-@5)))",
RooArgList(*pT1,*pT2,*theta1,*theta2,*phi1,*phi2));
if(debug_) cout<<"p1 DOT p2 is "<<p1v3D2->getVal()<<endl;
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar p1D2("p1D2","@0*@1-@2",RooArgList(E1,E2,*p1v3D2));
//lep DOT fsrPhoton1
// 3-vector DOT
RooFormulaVar* p1v3Dph1 = new RooFormulaVar("p1v3Dph1",
"@0*@1*( (TMath::Cos(@2)*TMath::Cos(@3))/(TMath::Sin(@2)*TMath::Sin(@3))+TMath::Cos(@4-@5))",
RooArgList(*pT1,*pTph1,*theta1,*thetaph1,*phi1,*phiph1));
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar p1Dph1("p1Dph1","@0*@1-@2",RooArgList(E1,Eph1,*p1v3Dph1));
// 3-vector DOT
RooFormulaVar* p2v3Dph1 = new RooFormulaVar("p2v3Dph1",
"@0*@1*( (TMath::Cos(@2)*TMath::Cos(@3))/(TMath::Sin(@2)*TMath::Sin(@3))+TMath::Cos(@4-@5))",
RooArgList(*pT2,*pTph1,*theta2,*thetaph1,*phi2,*phiph1));
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar p2Dph1("p2Dph1","@0*@1-@2",RooArgList(E2,Eph1,*p2v3Dph1));
// lep DOT fsrPhoton2
// 3-vector DOT
RooFormulaVar* p1v3Dph2 = new RooFormulaVar("p1v3Dph2",
"@0*@1*( (TMath::Cos(@2)*TMath::Cos(@3))/(TMath::Sin(@2)*TMath::Sin(@3))+TMath::Cos(@4-@5))",
RooArgList(*pT1,*pTph2,*theta1,*thetaph2,*phi1,*phiph2));
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar p1Dph2("p1Dph2","@0*@1-@2",RooArgList(E1,Eph2,*p1v3Dph2));
// 3-vector DOT
RooFormulaVar* p2v3Dph2 = new RooFormulaVar("p2v3Dph2",
"@0*@1*( (TMath::Cos(@2)*TMath::Cos(@3))/(TMath::Sin(@2)*TMath::Sin(@3))+TMath::Cos(@4-@5))",
RooArgList(*pT2,*pTph2,*theta2,*thetaph2,*phi2,*phiph2));
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar p2Dph2("p2Dph2","@0*@1-@2",RooArgList(E2,Eph2,*p2v3Dph2));
// fsrPhoton1 DOT fsrPhoton2
// 3-vector DOT
RooFormulaVar* ph1v3Dph2 = new RooFormulaVar("ph1v3Dph2",
"@0*@1*( (TMath::Cos(@2)*TMath::Cos(@3))/(TMath::Sin(@2)*TMath::Sin(@3))+TMath::Cos(@4-@5))",
RooArgList(*pTph1,*pTph2,*thetaph1,*thetaph2,*phiph1,*phiph2));
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar ph1Dph2("ph1Dph2","@0*@1-@2",RooArgList(Eph1,Eph2,*ph1v3Dph2));
// mZ1
RooFormulaVar* mZ1;
mZ1 = new RooFormulaVar("mZ1","TMath::Sqrt(2*@0+@1*@1+@2*@2)",RooArgList(p1D2,*m1,*m2));
if(p4sZ1ph_.size()==1)
mZ1 = new RooFormulaVar("mZ1","TMath::Sqrt(2*@0+2*@1+2*@2+@3*@3+@4*@4)",
RooArgList(p1D2, p1Dph1, p2Dph1, *m1,*m2));
if(p4sZ1ph_.size()==2)
mZ1 = new RooFormulaVar("mZ1","TMath::Sqrt(2*@0+2*@1+2*@2+2*@3+2*@4+2*@5+@6*@6+@7*@7)",
RooArgList(p1D2,p1Dph1,p2Dph1,p1Dph2,p2Dph2,ph1Dph2, *m1,*m2));
if(debug_) cout<<"mZ1 is "<<mZ1->getVal()<<endl;
// pTerrs, 1,2,ph1,ph2
RooRealVar sigmaZ1_1("sigmaZ1_1", "sigmaZ1_1", pTerrZ1_1);
RooRealVar sigmaZ1_2("sigmaZ1_2", "sigmaZ1_2", pTerrZ1_2);
RooRealVar sigmaZ1_ph1("sigmaZ1_ph1", "sigmaZ1_ph1", pTerrZ1_ph1);
RooRealVar sigmaZ1_ph2("sigmaZ1_ph2", "sigmaZ1_ph2", pTerrZ1_ph2);
// resolution for decay products
RooGaussian gauss1("gauss1","gaussian PDF", *pT1RECO, *pT1, sigmaZ1_1);
RooGaussian gauss2("gauss2","gaussian PDF", *pT2RECO, *pT2, sigmaZ1_2);
RooGaussian gaussph1("gaussph1","gaussian PDF", *pTph1RECO, *pTph1, sigmaZ1_ph1);
RooGaussian gaussph2("gaussph2","gaussian PDF", *pTph2RECO, *pTph2, sigmaZ1_ph2);
RooRealVar bwMean("bwMean", "m_{Z^{0}}", 91.187);
RooRealVar bwGamma("bwGamma", "#Gamma", 2.5);
RooRealVar sg("sg", "sg", sgVal_);
RooRealVar a("a", "a", aVal_);
RooRealVar n("n", "n", nVal_);
RooCBShape CB("CB","CB",*mZ1,bwMean,sg,a,n);
RooRealVar f("f","f", fVal_);
RooRealVar mean("mean","mean",meanVal_);
RooRealVar sigma("sigma","sigma",sigmaVal_);
RooRealVar f1("f1","f1",f1Val_);
RooGenericPdf RelBW("RelBW","1/( pow(mZ1*mZ1-bwMean*bwMean,2)+pow(mZ1,4)*pow(bwGamma/bwMean,2) )", RooArgSet(*mZ1,bwMean,bwGamma) );
RooAddPdf RelBWxCB("RelBWxCB","RelBWxCB", RelBW, CB, f);
RooGaussian gauss("gauss","gauss",*mZ1,mean,sigma);
RooAddPdf RelBWxCBxgauss("RelBWxCBxgauss","RelBWxCBxgauss", RelBWxCB, gauss, f1);
RooProdPdf *PDFRelBWxCBxgauss;
PDFRelBWxCBxgauss = new RooProdPdf("PDFRelBWxCBxgauss","PDFRelBWxCBxgauss",
RooArgList(gauss1, gauss2, RelBWxCBxgauss) );
if(p4sZ1ph_.size()==1)
PDFRelBWxCBxgauss = new RooProdPdf("PDFRelBWxCBxgauss","PDFRelBWxCBxgauss",
RooArgList(gauss1, gauss2, gaussph1, RelBWxCBxgauss) );
if(p4sZ1ph_.size()==2)
PDFRelBWxCBxgauss = new RooProdPdf("PDFRelBWxCBxgauss","PDFRelBWxCBxgauss",
RooArgList(gauss1, gauss2, gaussph1, gaussph2, RelBWxCBxgauss) );
// observable set
RooArgSet *rastmp;
rastmp = new RooArgSet(*pT1RECO,*pT2RECO);
if(p4sZ1ph_.size()==1)
rastmp = new RooArgSet(*pT1RECO,*pT2RECO,*pTph1RECO);
if(p4sZ1ph_.size()>=2)
rastmp = new RooArgSet(*pT1RECO,*pT2RECO,*pTph1RECO,*pTph2RECO);
RooDataSet* pTs = new RooDataSet("pTs","pTs", *rastmp);
pTs->add(*rastmp);
//RooAbsReal* nll;
//nll = PDFRelBWxCBxgauss->createNLL(*pTs);
//RooMinuit(*nll).migrad();
RooFitResult* r = PDFRelBWxCBxgauss->fitTo(*pTs,RooFit::Save(),RooFit::PrintLevel(-1));
const TMatrixDSym& covMatrix = r->covarianceMatrix();
const RooArgList& finalPars = r->floatParsFinal();
for (int i=0 ; i<finalPars.getSize(); i++){
TString name = TString(((RooRealVar*)finalPars.at(i))->GetName());
if(debug_) cout<<"name list of RooRealVar for covariance matrix "<<name<<endl;
}
int size = covMatrix.GetNcols();
//TMatrixDSym covMatrixTest_(size);
covMatrixZ1_.ResizeTo(size,size);
covMatrixZ1_ = covMatrix;
if(debug_) cout<<"save the covariance matrix"<<endl;
l1 = pT1->getVal()/RECOpT1; l2 = pT2->getVal()/RECOpT2;
double pTerrZ1REFIT1 = pT1->getError(); double pTerrZ1REFIT2 = pT2->getError();
pTerrsZ1REFIT_.push_back(pTerrZ1REFIT1);
pTerrsZ1REFIT_.push_back(pTerrZ1REFIT2);
if(p4sZ1ph_.size()>=1){
if(debug_) cout<<"set refit result for Z1 fsr photon 1"<<endl;
lph1 = pTph1->getVal()/RECOpTph1;
double pTerrZ1phREFIT1 = pTph1->getError();
if(debug_) cout<<"scale "<<lph1<<" pterr "<<pTerrZ1phREFIT1<<endl;
pTerrsZ1phREFIT_.push_back(pTerrZ1phREFIT1);
}
if(p4sZ1ph_.size()==2){
lph2 = pTph2->getVal()/RECOpTph2;
double pTerrZ1phREFIT2 = pTph2->getError();
pTerrsZ1phREFIT_.push_back(pTerrZ1phREFIT2);
}
//delete nll;
delete r;
delete mZ1;
delete pT1; delete pT2; delete pTph1; delete pTph2;
delete pT1RECO; delete pT2RECO; delete pTph1RECO; delete pTph2RECO;
delete ph1v3Dph2; delete p1v3Dph1; delete p2v3Dph1; delete p1v3Dph2; delete p2v3Dph2;
delete PDFRelBWxCBxgauss;
delete pTs;
delete rastmp;
if(debug_) cout<<"end Z1 refit"<<endl;
return 0;
}
void new_RA4(){
// let's time this challenging example
TStopwatch t;
t.Start();
// set RooFit random seed for reproducible results
RooRandom::randomGenerator()->SetSeed(4357);
// make model
RooWorkspace* wspace = new RooWorkspace("wspace");
wspace->factory("Gaussian::sigCons(prime_SigEff[0,-5,5], nom_SigEff[0,-5,5], 1)");
wspace->factory("expr::SigEff('1.0*pow(1.20,@0)',prime_SigEff)"); // // 1+-20%, 1.20=exp(20%)
wspace->factory("Poisson::on(non[0,50], sum::splusb(prod::SigUnc(s[0,0,50],SigEff),mainb[8.8,0,50],dilep[0.9,0,20],tau[2.3,0,20],QCD[0.,0,10],MC[0.1,0,4]))");
wspace->factory("Gaussian::mcCons(prime_rho[0,-5,5], nom_rho[0,-5,5], 1)");
wspace->factory("expr::rho('1.0*pow(1.39,@0)',prime_rho)"); // // 1+-39%
wspace->factory("Poisson::off(noff[0,200], prod::rhob(mainb,rho,mu_plus_e[0.74,0.01,10],1.08))");
wspace->factory("Gaussian::mcCons2(mu_plus_enom[0.74,0.01,4], mu_plus_e, sigmatwo[.05])");
wspace->factory("Gaussian::dilep_pred(dilep_nom[0.9,0,20], dilep, sigma3[2.2])");
wspace->factory("Gaussian::tau_pred(tau_nom[2.3,0,20], tau, sigma4[0.5])");
wspace->factory("Gaussian::QCD_pred(QCD_nom[0.0,0,10], QCD, sigma5[1.0])");
wspace->factory("Gaussian::MC_pred(MC_nom[0.1,0.01,4], MC, sigma7[0.14])");
wspace->factory("PROD::model(on,off,mcCons,mcCons2,sigCons,dilep_pred,tau_pred,QCD_pred,MC_pred)");
RooArgSet obs(*wspace->var("non"), *wspace->var("noff"), *wspace->var("mu_plus_enom"), *wspace->var("dilep_nom"), *wspace->var("tau_nom"), "obs");
obs.add(*wspace->var("QCD_nom")); obs.add(*wspace->var("MC_nom"));
RooArgSet globalObs(*wspace->var("nom_SigEff"), *wspace->var("nom_rho"), "global_obs");
// fix global observables to their nominal values
wspace->var("nom_SigEff")->setConstant();
wspace->var("nom_rho")->setConstant();
RooArgSet poi(*wspace->var("s"), "poi");
RooArgSet nuis(*wspace->var("mainb"), *wspace->var("prime_rho"), *wspace->var("prime_SigEff"), *wspace->var("mu_plus_e"), *wspace->var("dilep"), *wspace->var("tau"), "nuis");
nuis.add(*wspace->var("QCD")); nuis.add(*wspace->var("MC"));
wspace->factory("Uniform::prior_poi({s})");
wspace->factory("Uniform::prior_nuis({mainb,mu_plus_e,dilep,tau,QCD,MC})");
wspace->factory("PROD::prior(prior_poi,prior_nuis)");
wspace->var("non")->setVal(8); //observed
//wspace->var("non")->setVal(12); //expected observation
wspace->var("noff")->setVal(7); //observed events in control region
wspace->var("mu_plus_enom")->setVal(0.74);
wspace->var("dilep_nom")->setVal(0.9);
wspace->var("tau_nom")->setVal(2.3);
wspace->var("QCD")->setVal(0.0);
wspace->var("MC")->setVal(0.1);
RooDataSet * data = new RooDataSet("data","",obs);
data->add(obs);
wspace->import(*data);
/////////////////////////////////////////////////////
// Now the statistical tests
// model config
ModelConfig* pSbModel = new ModelConfig("SbModel");
pSbModel->SetWorkspace(*wspace);
pSbModel->SetPdf(*wspace->pdf("model"));
pSbModel->SetPriorPdf(*wspace->pdf("prior"));
pSbModel->SetParametersOfInterest(poi);
pSbModel->SetNuisanceParameters(nuis);
pSbModel->SetObservables(obs);
pSbModel->SetGlobalObservables(globalObs);
wspace->import(*pSbModel);
// set all but obs, poi and nuisance to const
SetConstants(wspace, pSbModel);
wspace->import(*pSbModel);
Double_t poiValueForBModel = 0.0;
ModelConfig* pBModel = new ModelConfig(*(RooStats::ModelConfig *)wspace->obj("SbModel"));
pBModel->SetName("BModel");
pBModel->SetWorkspace(*wspace);
wspace->import(*pBModel);
RooAbsReal * pNll = pSbModel->GetPdf()->createNLL(*data);
RooAbsReal * pProfile = pNll->createProfile(RooArgSet());
pProfile->getVal(); // this will do fit and set POI and nuisance parameters to fitted values
RooArgSet * pPoiAndNuisance = new RooArgSet();
//if(pSbModel->GetNuisanceParameters())
// pPoiAndNuisance->add(*pSbModel->GetNuisanceParameters());
pPoiAndNuisance->add(*pSbModel->GetParametersOfInterest());
cout << "\nWill save these parameter points that correspond to the fit to data" << endl;
pPoiAndNuisance->Print("v");
pSbModel->SetSnapshot(*pPoiAndNuisance);
delete pProfile;
delete pNll;
delete pPoiAndNuisance;
pNll = pBModel->GetPdf()->createNLL(*data);
pProfile = pNll->createProfile(poi);
((RooRealVar *)poi.first())->setVal(poiValueForBModel);
pProfile->getVal(); // this will do fit and set nuisance parameters to profiled values
pPoiAndNuisance = new RooArgSet();
//if(pBModel->GetNuisanceParameters())
// pPoiAndNuisance->add(*pBModel->GetNuisanceParameters());
pPoiAndNuisance->add(*pBModel->GetParametersOfInterest());
cout << "\nShould use these parameter points to generate pseudo data for bkg only" << endl;
pPoiAndNuisance->Print("v");
pBModel->SetSnapshot(*pPoiAndNuisance);
delete pProfile;
delete pNll;
delete pPoiAndNuisance;
// inspect workspace
wspace->Print();
// save workspace to file
wspace->writeToFile("tight.root");
//wspace->writeToFile("tight_median.root");
// clean up
delete wspace;
delete data;
delete pSbModel;
delete pBModel;
}