void labelBins( TH1F* hist ) { TAxis* xaxis = hist->GetXaxis() ; for ( int mbi=0; mbi<hist->GetNbinsX(); mbi++ ) { char label[1000] ; sprintf( label, "MET%d", mbi+1 ) ; xaxis->SetBinLabel( mbi+1, label ) ; } // mbi. }
// Report cut flow findings to screen void DileptonAnalyzer::reportCutFlow( TFile & outputFile ) { // Store in a TProfile TProfile *cutFlow = new TProfile("cutFlow","Cut flow for final set of analysis cuts",20,0.5,20.5,-9.9e9,9.9e9); TAxis *cutFlowAxis = cutFlow->GetXaxis(); for ( unsigned int iCut = 0; iCut < cutNamesInOrder_.size(); iCut++ ) { cutFlow->Fill( iCut+1, cutFlowMap_[cutNamesInOrder_[iCut]]); cutFlowAxis->SetBinLabel( iCut+1, cutNamesInOrder_[iCut]); } outputFile.cd(); cutFlow->Write(); }
AndSelection::AndSelection(const ptree & cfg, InputManager & in, OutputManager & out): cutflow(0), cutflow_raw(0){ // get selections as string: std::string ids = cfg.get<string>("selections"); vector<string> vids; boost::split(vids, ids, boost::algorithm::is_space(), boost::algorithm::token_compress_on); for(const string & id : vids){ sel_handles.push_back(in.get_handle<bool>(id)); } string hname = cfg.get<string>("cutflow_hname", ""); if(!hname.empty()){ cutflow = new TH1D(hname.c_str(), hname.c_str(), vids.size()+1, 0, vids.size()+1); cutflow_raw = new TH1D((hname + "_raw").c_str(), (hname + "_raw").c_str(), vids.size()+1, 0, vids.size()+1); for(TH1D * h : {cutflow, cutflow_raw}){ h->Sumw2(); TAxis * x = h->GetXaxis(); x->SetBinLabel(1, "before cuts"); for(auto i=0ul; i < vids.size(); ++i){ x->SetBinLabel(i+2, vids[i].c_str()); } out.put(h->GetName(), h); } } weight_handle = in.get_handle<double>("weight"); }
TH1F* bookHist(const char* hname, const char* htitle, int nBinsMET, int nBinsHT, int sampleIndex ) { int nbins = nBinsMET*(nBinsHT+1) + 1 ; TH1F* retVal = new TH1F( hname, htitle, nbins, 0.5+0.05*(sampleIndex-5), nbins+0.5+0.05*(sampleIndex-5) ) ; TAxis* xaxis = retVal->GetXaxis() ; for ( int mbi=0; mbi<nBinsMET; mbi++ ) { for ( int hbi=0; hbi<nBinsHT; hbi++ ) { int histbin = 1 + (nBinsHT+1)*mbi + hbi + 1 ; char binlabel[1000] ; sprintf( binlabel, "M%d_H%d", mbi+1, hbi+1 ) ; xaxis->SetBinLabel( histbin, binlabel ) ; } // hbi. } // mbi. retVal->SetLabelSize(0.055,"x") ; xaxis->LabelsOption("v") ; return retVal ; }
TH1F* bookHist(const char* hname, const char* htitle, const char* selstring, int nbjet, int nBinsMET, int nBinsHT ) { int nbins = nBinsMET*(nBinsHT+1) + 1 ; TH1F* retVal = new TH1F( hname, htitle, nbins, 0.5 + 0.1*(nbjet-2), nbins+0.5 + 0.1*(nbjet-2) ) ; TAxis* xaxis = retVal->GetXaxis() ; for ( int mbi=0; mbi<nBinsMET; mbi++ ) { for ( int hbi=0; hbi<nBinsHT; hbi++ ) { int histbin = 1 + (nBinsHT+1)*mbi + hbi + 1 ; char binlabel[1000] ; sprintf( binlabel, "%s_M%d_H%d_%db", selstring, mbi+1, hbi+1, nbjet ) ; xaxis->SetBinLabel( histbin, binlabel ) ; } // hbi. } // mbi. retVal->SetLabelSize(0.055,"x") ; xaxis->LabelsOption("v") ; return retVal ; }
void DileptonAnalyzer::storeSignalEfficiencies( TFile & outputFile ) { // Store in a TProfile TProfile *sigEffOne = new TProfile("SignalEfficOneDecay","Signal efficiencies when one exotic decays in this channel",10,0.5,10.5,-9.9e9,9.9e9); TAxis *sigEffOneAxis = sigEffOne->GetXaxis(); TProfile *sigEffTwo = new TProfile("SignalEfficTwoDecay","Signal efficiencies when two exotic decays in this channel",10,0.5,10.5,-9.9e9,9.9e9); TAxis *sigEffTwoAxis = sigEffTwo->GetXaxis(); // Fill set of 3 bins in each TProfile for each exotic for ( int iExotic = 0; iExotic < nSignalParticles_; iExotic++ ) { TString axisTitle; sigEffOne->Fill( iExotic*nSignalParticles_+1, numEvents_oneSensitiveDecay_[iExotic] ); axisTitle.Form("Number of events coming into macro for exotic %d",signalPdgId_[iExotic]); sigEffOneAxis->SetBinLabel( iExotic*nSignalParticles_+1, axisTitle.Data()); sigEffOne->Fill( iExotic*nSignalParticles_+2, numExoticsRECO_oneSensitiveDecay_[iExotic] ); axisTitle.Form("Number of candidates RECO'd for exotic %d",signalPdgId_[iExotic]); sigEffOneAxis->SetBinLabel( iExotic*nSignalParticles_+2, axisTitle.Data()); sigEffOne->Fill( iExotic*nSignalParticles_+3, numExoticsCorrectRECO_oneSensitiveDecay_[iExotic] ); axisTitle.Form("Number of exotics correctly RECO'd for exotic %d",signalPdgId_[iExotic]); sigEffOneAxis->SetBinLabel( iExotic*nSignalParticles_+3, axisTitle.Data()); sigEffTwo->Fill( iExotic*nSignalParticles_+1, numEvents_twoSensitiveDecay_[iExotic] ); axisTitle.Form("Number of events coming into macro for exotic %d",signalPdgId_[iExotic]); sigEffTwoAxis->SetBinLabel( iExotic*nSignalParticles_+1, axisTitle.Data()); sigEffTwo->Fill( iExotic*nSignalParticles_+2, numExoticsRECO_twoSensitiveDecay_[iExotic] ); axisTitle.Form("Number of candidates RECO'd for exotic %d",signalPdgId_[iExotic]); sigEffTwoAxis->SetBinLabel( iExotic*nSignalParticles_+2, axisTitle.Data()); sigEffTwo->Fill( iExotic*nSignalParticles_+3, numExoticsCorrectRECO_twoSensitiveDecay_[iExotic] ); axisTitle.Form("Number of exotics correctly RECO'd for exotic %d",signalPdgId_[iExotic]); sigEffTwoAxis->SetBinLabel( iExotic*nSignalParticles_+3, axisTitle.Data()); } outputFile.cd(); sigEffOne->Write(); sigEffTwo->Write(); }
int looperCR2lep( analysis* myAnalysis, sample* mySample, int nEvents = -1, bool fast = true) { // Benchmark TBenchmark *bmark = new TBenchmark(); bmark->Start("benchmark"); // Setup TChain *chain = mySample->GetChain(); TString sampleName = mySample->GetLabel(); const int nSigRegs = myAnalysis->GetSigRegionsAll().size(); const int nVariations = mySample->IsData() ? 0 : myAnalysis->GetSystematics(false).size(); bool isFastsim = mySample->IsSignal(); cout << "\nSample: " << sampleName.Data() << " (CR2L"; if( myContext.GetJesDir() == contextVars::kUp ) cout << ", JES up"; else if( myContext.GetJesDir() == contextVars::kDown ) cout << ", JES down"; cout << ")" << endl; myContext.SetUseRl( true ); ///////////////////////////////////////////////////////// // Histograms TDirectory *rootdir = gDirectory->GetDirectory("Rint:"); // Use TDirectories to assist in memory management TDirectory *histdir = new TDirectory( "histdir", "histdir", "", rootdir ); TDirectory *systdir = new TDirectory( "systdir", "systdir", "", rootdir ); TDirectory *zerodir = new TDirectory( "zerodir", "zerodir", "", rootdir ); TH1::SetDefaultSumw2(); TH1D* h_bkgtype_sum[nSigRegs][nVariations+1]; TH1D* h_evttype_sum[nSigRegs][nVariations+1]; TH2D* h_sigyields[nSigRegs][nVariations+1]; TH1D* h_bkgtype[nSigRegs][nVariations+1]; // per-file versions for zeroing TH1D* h_evttype[nSigRegs][nVariations+1]; TH1D *h_mt[nSigRegs]; TH1D *h_met[nSigRegs]; TH1D *h_mt2w[nSigRegs]; TH1D *h_chi2[nSigRegs]; TH1D *h_htratio[nSigRegs]; TH1D *h_mindphi[nSigRegs]; TH1D *h_ptb1[nSigRegs]; TH1D *h_drlb1[nSigRegs]; TH1D *h_ptlep[nSigRegs]; TH1D *h_metht[nSigRegs]; TH1D *h_dphilw[nSigRegs]; TH1D *h_njets[nSigRegs]; TH1D *h_nbtags[nSigRegs]; TH1D *h_ptj1[nSigRegs]; TH1D *h_j1btag[nSigRegs]; TH1D *h_modtop[nSigRegs]; TH1D *h_dphilmet[nSigRegs]; TH1D *h_mlb[nSigRegs]; vector<TString> regNames = myAnalysis->GetSigRegionLabelsAll(); vector<sigRegion*> sigRegions = myAnalysis->GetSigRegionsAll(); vector<systematic*> variations = myAnalysis->GetSystematics(false); for( int i=0; i<nSigRegs; i++ ) { TString plotLabel = sampleName + "_" + regNames.at(i); systdir->cd(); for( int j=1; j<=nVariations; j++ ) { TString varName = variations.at(j-1)->GetNameLong(); h_bkgtype_sum[i][j] = new TH1D( "bkgtype_" + plotLabel + "_" + varName, "Yield by background type", 5, 0.5, 5.5); h_evttype_sum[i][j] = new TH1D( "evttype_" + regNames.at(i) + "_" + varName, "Yield by event type", 6, 0.5, 6.5); h_sigyields[i][j] = new TH2D( "sigyields_" + regNames.at(i) + "_" + varName, "Signal yields by mass point", 37,99,1024, 19,-1,474 ); } histdir->cd(); h_bkgtype_sum[i][0] = new TH1D( "bkgtype_" + plotLabel, "Yield by background type", 5, 0.5, 5.5); h_evttype_sum[i][0] = new TH1D( "evttype_" + regNames.at(i), "Yield by event type", 6, 0.5, 6.5); h_sigyields[i][0] = new TH2D( "sigyields_" + regNames.at(i), "Signal yields by mass point", 37,99,1024, 19,-1,474 ); h_mt[i] = new TH1D( "mt_" + plotLabel, "Transverse mass", 80, 0, 800); h_met[i] = new TH1D( "met_" + plotLabel, "MET", 40, 0, 1000); h_mt2w[i] = new TH1D( "mt2w_" + plotLabel, "MT2W", 50, 0, 500); h_chi2[i] = new TH1D( "chi2_" + plotLabel, "Hadronic #chi^{2}", 50, 0, 15); h_htratio[i] = new TH1D( "htratio_" + plotLabel, "H_{T} ratio", 50, 0, 1); h_mindphi[i] = new TH1D( "mindphi_" + plotLabel, "min #Delta#phi(j12,MET)", 63, 0, 3.15); h_ptb1[i] = new TH1D( "ptb1_" + plotLabel, "p_{T} (b1)", 50, 0, 500); h_drlb1[i] = new TH1D( "drlb1_" + plotLabel, "#DeltaR (lep, b1)", 50, 0, 5); h_ptlep[i] = new TH1D( "ptlep_" + plotLabel, "p_{T} (lep)", 50, 0, 500); h_metht[i] = new TH1D( "metht_" + plotLabel, "MET/sqrt(HT)", 50, 0, 100); h_dphilw[i] = new TH1D( "dphilw_" + plotLabel, "#Delta#phi (lep,W)", 63, 0, 3.15); h_njets[i] = new TH1D( "njets_" + plotLabel, "Number of jets", 16, -0.5, 15.5); h_nbtags[i] = new TH1D( "nbtags_" + plotLabel, "Number of b-tags", 7, -0.5, 6.5); h_ptj1[i] = new TH1D( "ptj1_" + plotLabel, "Leading jet p_{T}", 40, 0, 1000); h_j1btag[i] = new TH1D( "j1btag_" + plotLabel, "Is leading jet b-tagged?", 2, -0.5, 1.5); h_modtop[i] = new TH1D( "modtop_" + plotLabel, "Modified topness", 30, -15., 15.); h_dphilmet[i] = new TH1D( "dphilmet_"+ plotLabel, "#Delta#phi (lep1, MET)", 63, 0., 3.15); h_mlb[i] = new TH1D( "mlb_" + plotLabel, "M_{lb}", 50, 0., 500.); for( int j=0; j<=nVariations; j++ ) { TAxis* axis = h_bkgtype_sum[i][j]->GetXaxis(); axis->SetBinLabel( 1, "2+lep" ); axis->SetBinLabel( 2, "1lepW" ); axis->SetBinLabel( 3, "1lepTop" ); axis->SetBinLabel( 4, "ZtoNuNu" ); axis->SetBinLabel( 5, "Other" ); axis = h_evttype_sum[i][j]->GetXaxis(); axis->SetBinLabel( 1, "Data" ); axis->SetBinLabel( 2, "Signals" ); axis->SetBinLabel( 3, "2+lep" ); axis->SetBinLabel( 4, "1lepW" ); axis->SetBinLabel( 5, "1lepTop" ); axis->SetBinLabel( 6, "ZtoNuNu" ); } } TH1D *h_yields_sum = new TH1D( Form("srYields_%s", sampleName.Data()), "Yield by signal region", nSigRegs, 0.5, float(nSigRegs)+0.5); for( int i=0; i<nSigRegs; i++ ) h_yields_sum->GetXaxis()->SetBinLabel( i+1, regNames.at(i) ); // Set up copies of histograms, in order to zero out negative yields zerodir->cd(); TH1D* h_yields = (TH1D*)h_yields_sum->Clone( "tmp_" + TString(h_yields_sum->GetName()) ); for( int i=0; i<nSigRegs; i++ ) { for( int j=0; j<=nVariations; j++ ) { h_bkgtype[i][j] = (TH1D*)h_bkgtype_sum[i][j]->Clone( "tmp_" + TString(h_bkgtype_sum[i][j]->GetName()) ); h_evttype[i][j] = (TH1D*)h_evttype_sum[i][j]->Clone( "tmp_" + TString(h_evttype_sum[i][j]->GetName()) ); } } // Set up cutflow variables double yield_total = 0; double yield_unique = 0; double yield_filter = 0; double yield_vtx = 0; double yield_1goodlep = 0; double yield_lepSel = 0; double yield_2lepveto = 0; double yield_trkVeto = 0; double yield_2lepCR = 0; double yield_tauVeto = 0; double yield_njets = 0; double yield_1bjet = 0; double yield_METcut = 0; double yield_MTcut = 0; double yield_dPhi = 0; double yield_chi2 = 0; int yGen_total = 0; int yGen_unique = 0; int yGen_filter = 0; int yGen_vtx = 0; int yGen_1goodlep = 0; int yGen_lepSel = 0; int yGen_2lepveto = 0; int yGen_trkVeto = 0; int yGen_tauVeto = 0; int yGen_2lepCR = 0; int yGen_njets = 0; int yGen_1bjet = 0; int yGen_METcut = 0; int yGen_MTcut = 0; int yGen_dPhi = 0; int yGen_chi2 = 0; //////////////////////////////////////////////////////////////////// // Set up data-specific filters if( mySample->IsData() ) { set_goodrun_file_json( "reference-files/Cert_271036-284044_13TeV_23Sep2016ReReco_Collisions16_JSON.txt" ); duplicate_removal::clear_list(); } ///////////////////////////////////////////////////////////////////// // Loop over events to Analyze unsigned int nEventsTotal = 0; unsigned int nEventsChain = chain->GetEntries(); if( nEvents >= 0 ) nEventsChain = nEvents; TObjArray *listOfFiles = chain->GetListOfFiles(); TIter fileIter(listOfFiles); TFile *currentFile = 0; // File Loop while ( (currentFile = (TFile*)fileIter.Next()) ) { // Get File Content TFile file( currentFile->GetTitle() ); TString filename = file.GetName(); TTree *tree = (TTree*)file.Get("t"); if(fast) TTreeCache::SetLearnEntries(10); if(fast) tree->SetCacheSize(128*1024*1024); cms3.Init(tree); // Load event weight histograms TH2F* hNEvts = (TH2F*)file.Get("histNEvts"); TH3D* hCounterSMS = (TH3D*)file.Get("h_counterSMS"); TH1D* hCounter = (TH1D*)file.Get("h_counter"); myHelper.Setup( isFastsim, hCounter, hNEvts, hCounterSMS ); // Reset zeroing histograms for( int i=0; i<nSigRegs; i++ ) { for( int j=0; j<=nVariations; j++ ) { h_bkgtype[i][j]->Reset(); h_evttype[i][j]->Reset(); } } h_yields->Reset(); // Loop over Events in current file if( nEventsTotal >= nEventsChain ) continue; unsigned int nEventsTree = tree->GetEntriesFast(); for( unsigned int event = 0; event < nEventsTree; ++event) { // Get Event Content if( nEventsTotal >= nEventsChain ) continue; if(fast) tree->LoadTree(event); cms3.GetEntry(event); ++nEventsTotal; // Progress CMS3::progress( nEventsTotal, nEventsChain ); //////////////////////////////////////////////////////////////////////////////////////////////////////// // Analysis Code // ---------------------------------------------------------------------------------------------------// /////////////////////////////////////////////////////////////// // Special filters to more finely categorize background events if( sampleName == "tt2l" && gen_nfromtleps_() != 2 ) continue; //Require 2 leps from top in "tt2l" events else if( sampleName == "tt1l" && gen_nfromtleps_() != 1 ) continue; //Require 1 lep from top in "tt1l" events // Stitch W+NJets samples together by removing the MET<200 events from the non-nupT samples if( sampleName.Contains("wjets") && filename.Contains("JetsToLNu_madgraph") && nupt()>=200. ) continue; //FastSim anomalous event filter if( isFastsim && !context::filt_fastsimjets() ) continue; if( !mySample->PassSelections() ) continue; ///////////////////////////////// // Set event weight double evtWeight = 1.; // Data should have a weight of 1.0 if( is_data() || mySample->IsData() ) evtWeight = 1.; else { // Weight background MC using scale1fb evtWeight = myAnalysis->GetLumi() * scale1fb(); // Weight signal MC using xsec and nEvents if( mySample->IsSignal() ) { myHelper.PrepSignal(); double nEvtsSample = hNEvts->GetBinContent( hNEvts->FindBin( mass_stop(), mass_lsp() ) ); evtWeight = myAnalysis->GetLumi() * 1000. * xsec() / nEvtsSample; } // Apply scale factors to correct the shape of the MC evtWeight *= myHelper.TrigEff2l(); evtWeight *= myHelper.LepSF(); evtWeight *= myHelper.BtagSF(); if( isFastsim ) evtWeight *= myHelper.LepSFfastsim(); if( !isFastsim ) evtWeight *= myHelper.PileupSF(); if( mySample->GetLabel() == "tt2l" || filename.Contains("W_5f_powheg_pythia8") ) { evtWeight *= myHelper.MetResSF(); // evtWeight *= myHelper.TopSystPtSF(); } else if( mySample->GetLabel() == "tt1l" || mySample->GetLabel() == "wjets" ) evtWeight *= myHelper.MetResSF(); if( mySample->GetLabel() == "tt2l" || mySample->GetLabel() == "tt1l" || mySample->IsSignal() ) evtWeight *= myHelper.ISRnJetsSF(); // Correct event weight when samples are merged together if( filename.Contains("ttbar_diLept_madgraph_pythia8_ext1_25ns") ) evtWeight *= 23198554./(23198554.+5689986.); else if( filename.Contains("ttbar_diLept_madgraph_pythia8_25ns") ) evtWeight *= 5689986./(23198554.+5689986.); else if( filename.Contains("t_tW_5f_powheg_pythia8_noHadDecays_25ns") ) evtWeight *= 4473156./(4473156.+3145334.); else if( filename.Contains("t_tW_5f_powheg_pythia8_noHadDecays_ext1_25ns") ) evtWeight *= 3145334./(4473156.+3145334.); else if( filename.Contains("t_tbarW_5f_powheg_pythia8_noHadDecays_25ns") ) evtWeight *= 5029568./(5029568.+3146940.); else if( filename.Contains("t_tbarW_5f_powheg_pythia8_noHadDecays_ext1_25ns") ) evtWeight *= 3146940./(5029568.+3146940.); } // Count the number of events processed yield_total += evtWeight; yGen_total++; // Remove duplicate events in data if( is_data() ) { duplicate_removal::DorkyEventIdentifier id( run(), evt(), ls() ); if( is_duplicate(id) ) continue; yield_unique += evtWeight; yGen_unique++; } // MET filters, bad event filters, and triggers for data if( is_data() ) { if( !goodrun( run(), ls() ) ) continue; if( !filt_met() ) continue; if( !filt_badChargedCandidateFilter() ) continue; if( !filt_badMuonFilter() ) continue; if( !context::filt_jetWithBadMuon() ) continue; if( !filt_pfovercalomet() ) continue; if( !HLT_MET() && !HLT_MET110_MHT110() && !HLT_MET120_MHT120() ) { if( !(HLT_SingleEl() && (abs(lep1_pdgid())==11 || abs(lep2_pdgid())==11) ) && !(HLT_SingleMu() && (abs(lep1_pdgid())==13 || abs(lep2_pdgid())==13) ) ) continue; } yield_filter += evtWeight; yGen_filter++; } // First vertex must be good if( nvtxs() < 1 ) continue; yield_vtx += evtWeight; yGen_vtx++; // Must have at least 1 good lepton if( ngoodleps() < 1 ) continue; yield_1goodlep += evtWeight; yGen_1goodlep++; // Lep 1 must pass lepton selections // if( abs(lep1_pdgid())==11 ) { // if( lep1_p4().pt() < 20. ) continue; // if( fabs(lep1_p4().eta()) > 1.4442 ) continue; // if( !lep1_passMediumID() ) continue; // } // else if( abs(lep1_pdgid())==13 ) { // if( lep1_p4().pt() < 20. ) continue; // if( fabs(lep1_p4().eta()) > 2.4 ) continue; // if( !lep1_passTightID() ) continue; // } yield_lepSel += evtWeight; yGen_lepSel++; /////////////////// // Make 2-lepton CR int countGoodLeps = 0; // Count the number of veto leptons if( nvetoleps() >= 2 && lep2_p4().pt() > 10. ) countGoodLeps += nvetoleps(); if( countGoodLeps > 1 ) { yield_2lepveto += evtWeight; yGen_2lepveto++; } // If we fail the track veto, count another good lepton // if( !PassTrackVeto() ) { // countGoodLeps++; // yield_trkVeto += evtWeight; // yGen_trkVeto++; // } // If we fail the tau veto, count another good lepton // if( !PassTauVeto() ) { // countGoodLeps++; // yield_tauVeto += evtWeight; // yGen_tauVeto++; // } if( countGoodLeps < 2 ) continue; yield_2lepCR += evtWeight; yGen_2lepCR++; //////////////////// //////////////////// // N-jet requirement if( context::ngoodjets() < 2 ) continue; yield_njets += evtWeight; yGen_njets++; j1pt = context::ak4pfjets_p4().at(0).pt(); // B-tag requirement if( context::ngoodbtags() < 1 ) continue; yield_1bjet += evtWeight; yGen_1bjet++; j1_isBtag = context::ak4pfjets_passMEDbtag().at(0); // Baseline MET cut (with 2nd lepton pT added to MET) if( context::Met() < 250. ) continue; yield_METcut += evtWeight; yGen_METcut++; // MT cut (with 2nd lepton pT added to MET) if( context::MT_met_lep() < 150. ) continue; yield_MTcut += evtWeight; yGen_MTcut++; // Min delta-phi between MET and j1/j2 (with 2nd lepton pT added to MET) if( context::Mindphi_met_j1_j2() < 0.5 ) continue; yield_dPhi += evtWeight; yGen_dPhi++; // Chi^2 cut // if( hadronic_top_chi2() >= 10. ) continue; yield_chi2 += evtWeight; yGen_chi2++; ////////////////////////////////////////////////////////// // Classify event based on number of leptons / neutrinos // Order of evaluation matters, because some events fall into multiple categories int bkgType = -99; if( filename.Contains("ZZTo2L2Nu") && isZtoNuNu() ) bkgType = 1; // Force ZZto2L2Nu to be 2lep else if( isZtoNuNu() ) bkgType = 4; // Z to nu nu else if( is2lep() ) bkgType = 1; // 2 or more leptons else if( is1lepFromTop() ) bkgType = 3; // 1 lepton from top quark else if( is1lepFromW() ) bkgType = 2; // 1 lepton from a W not from top else bkgType = 5; // Other int evtType = -99; if( mySample->IsData() ) evtType = 1; else if( mySample->IsSignal() ) evtType = 2; else evtType = 2+bkgType; // Quickly calculate some variables double metSqHT = context::Met() / sqrt( context::ak4_HT() ); const TVector3 lepVec( lep1_p4().x(), lep1_p4().y(), lep1_p4().z() ); const TVector3 metVec( context::Met()*cos(context::MetPhi()), context::Met()*sin(context::MetPhi()), 0 ); const TVector3 wVec = lepVec + metVec; double dPhiLepW = fabs( lepVec.DeltaPhi(wVec) ); double drLepLeadb = ROOT::Math::VectorUtil::DeltaR( lep1_p4(), context::ak4pfjets_leadMEDbjet_p4() ); lep1pt = lep1_p4().Pt(); myMlb = context::Mlb_closestb(); /////////////////////////////////////////// // Signal region cuts and histo filling // If the event passes the SR cuts, store which background type this event is, and fill histograms for( int i=0; i<nSigRegs; i++ ) { if( !sigRegions.at(i)->PassAllCuts() ) continue; // Make some corrections that depend on the signal region double fillWeight = evtWeight; bool is_corridor = sigRegions.at(i)->GetLabel().Contains("corr"); myHelper.SetCorridor( is_corridor ); if( !is_data() && is_corridor ) fillWeight *= sfhelp::MetResCorrectionCorridor(); else if( !is_data() && !is_corridor ) fillWeight *= sfhelp::BtagCorrectionTight(); h_bkgtype[i][0]->Fill( bkgType, fillWeight ); h_evttype[i][0]->Fill( evtType, fillWeight ); if( mySample->IsSignal() ) h_sigyields[i][0]->Fill( mass_stop(), mass_lsp(), fillWeight ); h_mt[i]->Fill( context::MT_met_lep(), fillWeight ); h_met[i]->Fill( context::Met(), fillWeight ); h_mt2w[i]->Fill( context::MT2W(), fillWeight ); h_chi2[i]->Fill( hadronic_top_chi2(), fillWeight ); h_htratio[i]->Fill( context::ak4_htratiom(), fillWeight ); h_mindphi[i]->Fill( context::Mindphi_met_j1_j2(), fillWeight ); h_ptb1[i]->Fill( context::ak4pfjets_leadMEDbjet_p4().pt(), fillWeight ); h_drlb1[i]->Fill( drLepLeadb, fillWeight ); h_ptlep[i]->Fill( lep1_p4().pt(), fillWeight ); h_metht[i]->Fill( metSqHT, fillWeight ); h_dphilw[i]->Fill( dPhiLepW, fillWeight ); h_njets[i]->Fill( context::ngoodjets(), fillWeight ); h_nbtags[i]->Fill( context::ngoodbtags(), fillWeight ); h_ptj1[i]->Fill( j1pt, fillWeight ); h_j1btag[i]->Fill( j1_isBtag, fillWeight ); h_modtop[i]->Fill( context::TopnessMod(), fillWeight ); h_dphilmet[i]->Fill( context::lep1_dphiMET(), fillWeight ); h_mlb[i]->Fill( myMlb, fillWeight ); h_yields->Fill( double(i+1), fillWeight ); // Special systematic variation histograms for( int j=1; j<=nVariations; j++ ) { h_bkgtype[i][j]->Fill( bkgType, fillWeight * variations.at(j-1)->GetWeight() ); h_evttype[i][j]->Fill( evtType, fillWeight * variations.at(j-1)->GetWeight() ); if( mySample->IsSignal() ) h_sigyields[i][j]->Fill( mass_stop(), mass_lsp(), fillWeight * variations.at(j-1)->GetWeight() ); } } // ---------------------------------------------------------------------------------------------------// //////////////////////////////////////////////////////////////////////////////////////////////////////// } //End of loop over events in file // Clean Up delete tree; file.Close(); // Zero negative values in each signal region for( int i=0; i<nSigRegs; i++ ) { for( int j=0; j<=nVariations; j++ ) { bool negsFound = false; // First zero any decay modes with negative yields for( int k=1; k<= h_bkgtype[i][j]->GetNbinsX(); k++ ) { if( h_bkgtype[i][j]->GetBinContent(k) < 0.0 ) { h_bkgtype[i][j]->SetBinContent(k, 0.); h_bkgtype[i][j]->SetBinError(k, 0.); negsFound = true; } if( h_evttype[i][j]->GetBinContent(k+2) < 0.0 ) { h_evttype[i][j]->SetBinContent(k+2, 0.); h_evttype[i][j]->SetBinError(k+2, 0.); } } // If any negative yields were found in any decay mode, recalculate the total yield if( j==0 && negsFound ) { double newYield, newErr; newYield = h_bkgtype[i][0]->IntegralAndError( 0, -1, newErr ); h_yields->SetBinContent(i+1, newYield); h_yields->SetBinError(i+1, newErr); } // Add zeroed histograms to total histograms h_bkgtype_sum[i][j]->Add( h_bkgtype[i][j] ); h_evttype_sum[i][j]->Add( h_evttype[i][j] ); } } h_yields_sum->Add( h_yields ); } // End loop over files in the chain cout << "Cutflow yields: (yield) (gen evts)" << endl; printf("Total number of events: %10.2f %9i\n", yield_total , yGen_total ); if( mySample->IsData() ) { printf("Events passing duplicate removal: %10.2f %9i\n", yield_unique , yGen_unique ); printf("Events passing filters and trigger: %10.2f %9i\n", yield_filter , yGen_filter ); } printf("Events with 1st vertex good: %10.2f %9i\n", yield_vtx , yGen_vtx ); printf("Events with at least 1 good lepton: %10.2f %9i\n", yield_1goodlep , yGen_1goodlep ); printf("Events passing lepton selection: %10.2f %9i\n", yield_lepSel , yGen_lepSel ); printf("\nEvents passing 2-lep requirement: %10.2f %9i\n", yield_2lepCR , yGen_2lepCR ); printf(" Events with veto lepton: %10.2f %9i\n", yield_2lepveto , yGen_2lepveto ); printf(" Events with isolated track: %10.2f %9i\n", yield_trkVeto , yGen_trkVeto ); printf(" Events with identified tau: %10.2f %9i\n\n", yield_tauVeto , yGen_tauVeto ); printf("Events with at least 2 jets: %10.2f %9i\n", yield_njets , yGen_njets ); printf("Events with at least 1 b-tag: %10.2f %9i\n", yield_1bjet , yGen_1bjet ); printf("Events with MET > 250 GeV: %10.2f %9i\n", yield_METcut , yGen_METcut ); printf("Events with MT > 150 GeV: %10.2f %9i\n", yield_MTcut , yGen_MTcut ); printf("Events with min dPhi > 0.5: %10.2f %9i\n", yield_dPhi , yGen_dPhi ); // printf("Events with chi2 < 10: %10.2f %9i\n", yield_chi2 , yGen_chi2 ); printf("Yield after preselection: %10.2f %9i\n", yield_chi2 , yGen_chi2 ); if ( nEventsChain != nEventsTotal ) { cout << Form( "ERROR: number of events from files (%d) is not equal to total number of events (%d)", nEventsChain, nEventsTotal ) << endl; } /////////////////////////////////////////////////////////////////////////////// // Store histograms and clean them up TFile* plotfile = new TFile( myAnalysis->GetPlotFileName(), "READ"); TFile* systfile = new TFile( myAnalysis->GetSystFileName(), "READ"); TFile* sourcefile; // Certain histograms are cumulative across multiple samples. For those histograms, add what the // looper has just collected to the cumulative version stored in our output files for( int j=0; j<=nVariations; j++ ) { if( j==0 ) sourcefile = plotfile; else sourcefile = systfile; for( int i=0; i<nSigRegs; i++ ) { // Build up cumulative histo of SUSY scan yields TH2D* hTemp2 = (TH2D*)sourcefile->Get( h_sigyields[i][j]->GetName() ); if( hTemp2 != 0 ) h_sigyields[i][j]->Add( hTemp2 ); // Build up cumulative histo of yields by signal/background type TH1D* hTemp = (TH1D*)sourcefile->Get( h_evttype_sum[i][j]->GetName() ); if( hTemp != 0 ) h_evttype_sum[i][j]->Add( hTemp ); } } delete plotfile; delete systfile; // Take all histograms in histdir and write them to plotfile plotfile = new TFile( myAnalysis->GetPlotFileName(), "UPDATE"); plotfile->cd(); histdir->GetList()->Write( "", TObject::kOverwrite ); delete plotfile; // Take all histograms in systdir and write them to systfile systfile = new TFile( myAnalysis->GetSystFileName(), "UPDATE"); systfile->cd(); systdir->GetList()->Write( "", TObject::kOverwrite ); delete systfile; // Cleanup zerodir->Close(); histdir->Close(); systdir->Close(); // return bmark->Stop("benchmark"); cout << endl; cout << nEventsTotal << " Events Processed" << endl; cout << "------------------------------" << endl; cout << "CPU Time: " << Form( "%.01f", bmark->GetCpuTime("benchmark") ) << endl; cout << "Real Time: " << Form( "%.01f", bmark->GetRealTime("benchmark") ) << endl; cout << endl; delete bmark; return 0; }
void SampleDiagnostics::write() const { if (passedRate == 0) { std::cerr << "WARNING : No accumulated rate for " << name << ". Maybe you just didn't run over it/them?" << std::endl; return; } //.. Histogram output ....................................................... const Int_t numDatasets = static_cast<Int_t>(size()); const UInt_t numBins = numDatasets + 3; TH2* hCorrelation = new TH2F("h_correlation_" + name, name, numBins, 0, numBins, numBins, 0, numBins); TH2* hSharedRate = new TH2F("h_shared_rate_" + name, name, numBins, 0, numBins, numBins, 0, numBins); //........................................................................... Double_t overhead = 0; Double_t overheadErr = 0; for (Int_t iSet = 0, xBin = 1; iSet < numDatasets; ++iSet, ++xBin) { const Dataset& dataset = at(iSet); if (!dataset.isNewTrigger) { overhead += dataset.rate; overheadErr += dataset.rateUncertainty2; // I think this is over-estimating it because the values are NOT uncorrelated, but oh well } if (iSet == firstNewTrigger) ++xBin; if (dataset.rate == 0) continue; for (Int_t jSet = 0, yBin = 1; jSet <= numDatasets; ++jSet, ++yBin) { if (jSet == firstNewTrigger) ++yBin; if (jSet == numDatasets) ++yBin; hCorrelation->SetBinContent (xBin, yBin, commonRates[iSet][jSet] / dataset.rate); hCorrelation->SetBinError (xBin, yBin, ratioError(commonRates[iSet][jSet], commonRateUncertainties2[iSet][jSet], dataset.rate, dataset.rateUncertainty2)); hSharedRate ->SetBinContent (xBin, yBin, commonRates[iSet][jSet]); hSharedRate ->SetBinError (xBin, yBin, TMath::Sqrt(commonRateUncertainties2[iSet][jSet])); } // end loop over other datasets // Rightmost column is the fraction of rate out of the total hCorrelation->SetBinContent (numBins, xBin, dataset.rate / passedRate); hCorrelation->SetBinError (numBins, xBin, ratioError(dataset.rate, dataset.rateUncertainty2, passedRate, passedRateUncertainty2)); hSharedRate ->SetBinContent (numBins, xBin, dataset.rate); hSharedRate ->SetBinError (numBins, xBin, TMath::Sqrt(dataset.rateUncertainty2)); } // end loop over datasets // Top-right cell is the total overhead for the _current_ datasets (not including new triggers) hSharedRate ->SetBinContent (numBins, numBins, overhead); hSharedRate ->SetBinError (numBins, numBins, TMath::Sqrt(overheadErr)); overheadErr = ratioError (overhead, overheadErr, passedRate, passedRateUncertainty2); overhead /= passedRate; // Can only do this after error is computed overhead -= 1; hCorrelation->SetBinContent (numBins, numBins, overhead); hCorrelation->SetBinError (numBins, numBins, overheadErr); //........................................................................... // Histogram format hCorrelation->SetTitle (TString::Format("%s (overhead = %.3g%% #pm %.3g%%)" , hCorrelation->GetTitle(), 100*overhead, 100*overheadErr)); hSharedRate ->SetTitle (TString::Format("%s (total rate = %.3g #pm %.3g Hz)", hSharedRate ->GetTitle(), passedRate, TMath::Sqrt(passedRateUncertainty2))); hCorrelation->SetZTitle ("(X #cap Y) / X"); hSharedRate->SetZTitle ("X #cap Y"); hCorrelation->SetOption ("colz"); hSharedRate->SetOption ("colz"); hCorrelation->SetStats (kFALSE); hSharedRate->SetStats (kFALSE); hCorrelation->SetMinimum(0); hSharedRate->SetMinimum(0); hCorrelation->SetMaximum(1); std::vector<TAxis*> axes; axes.push_back(hCorrelation->GetXaxis()); axes.push_back(hCorrelation->GetYaxis()); axes.push_back(hSharedRate ->GetXaxis()); axes.push_back(hSharedRate ->GetYaxis()); const UInt_t numAxes = axes.size(); for (UInt_t iAxis = 0; iAxis < numAxes; ++iAxis) { TAxis* axis = axes[iAxis]; for (Int_t iSet = 0, bin = 1; iSet < numDatasets; ++iSet, ++bin) { if (iSet == firstNewTrigger) ++bin; axis->SetBinLabel(bin, at(iSet).name); } // end loop over datasets axis->SetLabelSize (0.04f); axis->LabelsOption ("v"); axis->SetTitle (iAxis % 2 == 0 ? "X" : "Y"); } // end loop over axes to format hCorrelation->GetXaxis()->SetBinLabel(numBins, "rate / total"); hCorrelation->GetYaxis()->SetBinLabel(numBins, "overlap / rate"); hSharedRate ->GetXaxis()->SetBinLabel(numBins, "rate"); hSharedRate ->GetYaxis()->SetBinLabel(numBins, "overlap"); if (gDirectory->GetDirectory("unnormalized") == 0) gDirectory->mkdir("unnormalized"); gDirectory->cd("unnormalized"); hSharedRate ->Write(); gDirectory->cd("/"); hCorrelation->Write(); //........................................................................... }
void constrained_scan( const char* wsfile = "outputfiles/ws.root", const char* new_poi_name="mu_bg_4b_msig_met1", double constraintWidth=1.5, int npoiPoints = 20, double poiMinVal = 0., double poiMaxVal = 10.0, double ymax = 9., int verbLevel=1 ) { TString outputdir("outputfiles") ; gStyle->SetOptStat(0) ; TFile* wstf = new TFile( wsfile ) ; RooWorkspace* ws = dynamic_cast<RooWorkspace*>( wstf->Get("ws") ); ws->Print() ; RooDataSet* rds = (RooDataSet*) ws->obj( "hbb_observed_rds" ) ; cout << "\n\n\n ===== RooDataSet ====================\n\n" << endl ; rds->Print() ; rds->printMultiline(cout, 1, kTRUE, "") ; RooRealVar* rv_sig_strength = ws->var("sig_strength") ; if ( rv_sig_strength == 0x0 ) { printf("\n\n *** can't find sig_strength in workspace.\n\n" ) ; return ; } RooAbsPdf* likelihood = ws->pdf("likelihood") ; if ( likelihood == 0x0 ) { printf("\n\n *** can't find likelihood in workspace.\n\n" ) ; return ; } printf("\n\n Likelihood:\n") ; likelihood -> Print() ; /////rv_sig_strength -> setConstant( kFALSE ) ; rv_sig_strength -> setVal(0.) ; rv_sig_strength -> setConstant( kTRUE ) ; likelihood->fitTo( *rds, Save(false), PrintLevel(0), Hesse(true), Strategy(1) ) ; //RooFitResult* fitResult = likelihood->fitTo( *rds, Save(true), PrintLevel(0), Hesse(true), Strategy(1) ) ; //double minNllSusyFloat = fitResult->minNll() ; //double susy_ss_atMinNll = rv_sig_strength -> getVal() ; RooMsgService::instance().getStream(1).removeTopic(Minimization) ; RooMsgService::instance().getStream(1).removeTopic(Fitting) ; //-- Construct the new POI parameter. RooAbsReal* new_poi_rar(0x0) ; new_poi_rar = ws->var( new_poi_name ) ; if ( new_poi_rar == 0x0 ) { printf("\n\n New POI %s is not a variable. Trying function.\n\n", new_poi_name ) ; new_poi_rar = ws->function( new_poi_name ) ; if ( new_poi_rar == 0x0 ) { printf("\n\n New POI %s is not a function. I quit.\n\n", new_poi_name ) ; return ; } else { printf("\n Found it.\n\n") ; } } else { printf("\n\n New POI %s is a variable with current value %.1f.\n\n", new_poi_name, new_poi_rar->getVal() ) ; } double startPoiVal = new_poi_rar->getVal() ; RooAbsReal* nll = likelihood -> createNLL( *rds, Verbose(true) ) ; RooRealVar* rrv_poiValue = new RooRealVar( "poiValue", "poiValue", 0., -10000., 10000. ) ; RooRealVar* rrv_constraintWidth = new RooRealVar("constraintWidth","constraintWidth", 0.1, 0.1, 1000. ) ; rrv_constraintWidth -> setVal( constraintWidth ) ; rrv_constraintWidth -> setConstant(kTRUE) ; RooMinuit* rminuit( 0x0 ) ; RooMinuit* rminuit_uc = new RooMinuit( *nll ) ; rminuit_uc->setPrintLevel(verbLevel-1) ; rminuit_uc->setNoWarn() ; rminuit_uc->migrad() ; rminuit_uc->hesse() ; RooFitResult* rfr_uc = rminuit_uc->fit("mr") ; double floatParInitVal[10000] ; char floatParName[10000][100] ; int nFloatParInitVal(0) ; RooArgList ral_floats = rfr_uc->floatParsFinal() ; TIterator* floatParIter = ral_floats.createIterator() ; { RooRealVar* par ; while ( (par = (RooRealVar*) floatParIter->Next()) ) { sprintf( floatParName[nFloatParInitVal], "%s", par->GetName() ) ; floatParInitVal[nFloatParInitVal] = par->getVal() ; nFloatParInitVal++ ; } } printf("\n\n Unbiased best value for new POI %s is : %7.1f\n\n", new_poi_rar->GetName(), new_poi_rar->getVal() ) ; double best_poi_val = new_poi_rar->getVal() ; char minuit_formula[10000] ; sprintf( minuit_formula, "%s+%s*(%s-%s)*(%s-%s)", nll->GetName(), rrv_constraintWidth->GetName(), new_poi_rar->GetName(), rrv_poiValue->GetName(), new_poi_rar->GetName(), rrv_poiValue->GetName() ) ; printf("\n\n Creating new minuit variable with formula: %s\n\n", minuit_formula ) ; RooFormulaVar* new_minuit_var = new RooFormulaVar("new_minuit_var", minuit_formula, RooArgList( *nll, *rrv_constraintWidth, *new_poi_rar, *rrv_poiValue, *new_poi_rar, *rrv_poiValue ) ) ; printf("\n\n Current value is %.2f\n\n", new_minuit_var->getVal() ) ; rminuit = new RooMinuit( *new_minuit_var ) ; RooAbsReal* plot_var = nll ; printf("\n\n Current value is %.2f\n\n", plot_var->getVal() ) ; rminuit->setPrintLevel(verbLevel-1) ; if ( verbLevel <=0 ) { rminuit->setNoWarn() ; } if ( poiMinVal < 0. && poiMaxVal < 0. ) { printf("\n\n Automatic determination of scan range.\n\n") ; if ( startPoiVal <= 0. ) { printf("\n\n *** POI starting value zero or negative %g. Quit.\n\n\n", startPoiVal ) ; return ; } poiMinVal = startPoiVal - 3.5 * sqrt(startPoiVal) ; poiMaxVal = startPoiVal + 6.0 * sqrt(startPoiVal) ; if ( poiMinVal < 0. ) { poiMinVal = 0. ; } printf(" Start val = %g. Scan range: %g to %g\n\n", startPoiVal, poiMinVal, poiMaxVal ) ; } //---------------------------------------------------------------------------------------------- double poiVals_scanDown[1000] ; double nllVals_scanDown[1000] ; //-- Do scan down from best value. printf("\n\n +++++ Starting scan down from best value.\n\n") ; double minNllVal(1.e9) ; for ( int poivi=0; poivi < npoiPoints/2 ; poivi++ ) { ////double poiValue = poiMinVal + poivi*(poiMaxVal-poiMinVal)/(1.*(npoiPoints-1)) ; double poiValue = best_poi_val - poivi*(best_poi_val-poiMinVal)/(1.*(npoiPoints/2-1)) ; rrv_poiValue -> setVal( poiValue ) ; rrv_poiValue -> setConstant( kTRUE ) ; //+++++++++++++++++++++++++++++++++++ rminuit->migrad() ; rminuit->hesse() ; RooFitResult* rfr = rminuit->save() ; //+++++++++++++++++++++++++++++++++++ if ( verbLevel > 0 ) { rfr->Print("v") ; } float fit_minuit_var_val = rfr->minNll() ; printf(" %02d : poi constraint = %.2f : allvars : MinuitVar, createNLL, PV, POI : %.5f %.5f %.5f %.5f\n", poivi, rrv_poiValue->getVal(), fit_minuit_var_val, nll->getVal(), plot_var->getVal(), new_poi_rar->getVal() ) ; cout << flush ; poiVals_scanDown[poivi] = new_poi_rar->getVal() ; nllVals_scanDown[poivi] = plot_var->getVal() ; if ( nllVals_scanDown[poivi] < minNllVal ) { minNllVal = nllVals_scanDown[poivi] ; } delete rfr ; } // poivi printf("\n\n +++++ Resetting floats to best fit values.\n\n") ; for ( int pi=0; pi<nFloatParInitVal; pi++ ) { RooRealVar* par = ws->var( floatParName[pi] ) ; par->setVal( floatParInitVal[pi] ) ; } // pi. printf("\n\n +++++ Starting scan up from best value.\n\n") ; //-- Now do scan up. double poiVals_scanUp[1000] ; double nllVals_scanUp[1000] ; for ( int poivi=0; poivi < npoiPoints/2 ; poivi++ ) { double poiValue = best_poi_val + poivi*(poiMaxVal-best_poi_val)/(1.*(npoiPoints/2-1)) ; rrv_poiValue -> setVal( poiValue ) ; rrv_poiValue -> setConstant( kTRUE ) ; //+++++++++++++++++++++++++++++++++++ rminuit->migrad() ; rminuit->hesse() ; RooFitResult* rfr = rminuit->save() ; //+++++++++++++++++++++++++++++++++++ if ( verbLevel > 0 ) { rfr->Print("v") ; } float fit_minuit_var_val = rfr->minNll() ; printf(" %02d : poi constraint = %.2f : allvars : MinuitVar, createNLL, PV, POI : %.5f %.5f %.5f %.5f\n", poivi, rrv_poiValue->getVal(), fit_minuit_var_val, nll->getVal(), plot_var->getVal(), new_poi_rar->getVal() ) ; cout << flush ; poiVals_scanUp[poivi] = new_poi_rar->getVal() ; nllVals_scanUp[poivi] = plot_var->getVal() ; if ( nllVals_scanUp[poivi] < minNllVal ) { minNllVal = nllVals_scanUp[poivi] ; } delete rfr ; } // poivi double poiVals[1000] ; double nllVals[1000] ; int pointCount(0) ; for ( int pi=0; pi<npoiPoints/2; pi++ ) { poiVals[pi] = poiVals_scanDown[(npoiPoints/2-1)-pi] ; nllVals[pi] = nllVals_scanDown[(npoiPoints/2-1)-pi] ; pointCount++ ; } for ( int pi=1; pi<npoiPoints/2; pi++ ) { poiVals[pointCount] = poiVals_scanUp[pi] ; nllVals[pointCount] = nllVals_scanUp[pi] ; pointCount++ ; } npoiPoints = pointCount ; printf("\n\n --- TGraph arrays:\n") ; for ( int i=0; i<npoiPoints; i++ ) { printf(" %2d : poi = %6.1f, nll = %g\n", i, poiVals[i], nllVals[i] ) ; } printf("\n\n") ; double nllDiffVals[1000] ; double poiAtMinlnL(-1.) ; double poiAtMinusDelta2(-1.) ; double poiAtPlusDelta2(-1.) ; for ( int poivi=0; poivi < npoiPoints ; poivi++ ) { nllDiffVals[poivi] = 2.*(nllVals[poivi] - minNllVal) ; double poiValue = poiMinVal + poivi*(poiMaxVal-poiMinVal)/(1.*npoiPoints) ; if ( nllDiffVals[poivi] < 0.01 ) { poiAtMinlnL = poiValue ; } if ( poiAtMinusDelta2 < 0. && nllDiffVals[poivi] < 2.5 ) { poiAtMinusDelta2 = poiValue ; } if ( poiAtMinlnL > 0. && poiAtPlusDelta2 < 0. && nllDiffVals[poivi] > 2.0 ) { poiAtPlusDelta2 = poiValue ; } } // poivi printf("\n\n Estimates for poi at delta ln L = -2, 0, +2: %g , %g , %g\n\n", poiAtMinusDelta2, poiAtMinlnL, poiAtPlusDelta2 ) ; //--- Main canvas TCanvas* cscan = (TCanvas*) gDirectory->FindObject("cscan") ; if ( cscan == 0x0 ) { printf("\n Creating canvas.\n\n") ; cscan = new TCanvas("cscan","Delta nll") ; } char gname[1000] ; TGraph* graph = new TGraph( npoiPoints, poiVals, nllDiffVals ) ; sprintf( gname, "scan_%s", new_poi_name ) ; graph->SetName( gname ) ; double poiBest(-1.) ; double poiMinus1stdv(-1.) ; double poiPlus1stdv(-1.) ; double poiMinus2stdv(-1.) ; double poiPlus2stdv(-1.) ; double twoDeltalnLMin(1e9) ; int nscan(1000) ; for ( int xi=0; xi<nscan; xi++ ) { double x = poiVals[0] + xi*(poiVals[npoiPoints-1]-poiVals[0])/(nscan-1) ; double twoDeltalnL = graph -> Eval( x, 0, "S" ) ; if ( poiMinus1stdv < 0. && twoDeltalnL < 1.0 ) { poiMinus1stdv = x ; printf(" set m1 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;} if ( poiMinus2stdv < 0. && twoDeltalnL < 4.0 ) { poiMinus2stdv = x ; printf(" set m2 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;} if ( twoDeltalnL < twoDeltalnLMin ) { poiBest = x ; twoDeltalnLMin = twoDeltalnL ; } if ( twoDeltalnLMin < 0.3 && poiPlus1stdv < 0. && twoDeltalnL > 1.0 ) { poiPlus1stdv = x ; printf(" set p1 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;} if ( twoDeltalnLMin < 0.3 && poiPlus2stdv < 0. && twoDeltalnL > 4.0 ) { poiPlus2stdv = x ; printf(" set p2 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;} if ( xi%100 == 0 ) { printf( " %4d : poi=%6.2f, 2DeltalnL = %6.2f\n", xi, x, twoDeltalnL ) ; } } printf("\n\n POI estimate : %g +%g -%g [%g,%g], two sigma errors: +%g -%g [%g,%g]\n\n", poiBest, (poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv), poiMinus1stdv, poiPlus1stdv, (poiPlus2stdv-poiBest), (poiBest-poiMinus2stdv), poiMinus2stdv, poiPlus2stdv ) ; printf(" %s val,pm1sig,pm2sig: %7.2f %7.2f %7.2f %7.2f %7.2f\n", new_poi_name, poiBest, (poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv), (poiPlus2stdv-poiBest), (poiBest-poiMinus2stdv) ) ; char htitle[1000] ; sprintf(htitle, "%s profile likelihood scan: -2ln(L/Lm)", new_poi_name ) ; TH1F* hscan = new TH1F("hscan", htitle, 10, poiMinVal, poiMaxVal ) ; hscan->SetMinimum(0.) ; hscan->SetMaximum(ymax) ; hscan->DrawCopy() ; graph->SetLineColor(4) ; graph->SetLineWidth(3) ; graph->Draw("CP") ; gPad->SetGridx(1) ; gPad->SetGridy(1) ; cscan->Update() ; TLine* line = new TLine() ; line->SetLineColor(2) ; line->DrawLine(poiMinVal, 1., poiPlus1stdv, 1.) ; line->DrawLine(poiMinus1stdv,0., poiMinus1stdv, 1.) ; line->DrawLine(poiPlus1stdv ,0., poiPlus1stdv , 1.) ; TText* text = new TText() ; text->SetTextSize(0.04) ; char tstring[1000] ; sprintf( tstring, "%s = %.1f +%.1f -%.1f", new_poi_name, poiBest, (poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv) ) ; text -> DrawTextNDC( 0.15, 0.85, tstring ) ; sprintf( tstring, "68%% interval [%.1f, %.1f]", poiMinus1stdv, poiPlus1stdv ) ; text -> DrawTextNDC( 0.15, 0.78, tstring ) ; char hname[1000] ; sprintf( hname, "hscanout_%s", new_poi_name ) ; TH1F* hsout = new TH1F( hname,"scan results",4,0.,4.) ; double obsVal(-1.) ; hsout->SetBinContent(1, obsVal ) ; hsout->SetBinContent(2, poiPlus1stdv ) ; hsout->SetBinContent(3, poiBest ) ; hsout->SetBinContent(4, poiMinus1stdv ) ; TAxis* xaxis = hsout->GetXaxis() ; xaxis->SetBinLabel(1,"Observed val.") ; xaxis->SetBinLabel(2,"Model+1sd") ; xaxis->SetBinLabel(3,"Model") ; xaxis->SetBinLabel(4,"Model-1sd") ; char outrootfile[10000] ; sprintf( outrootfile, "%s/scan-ff-%s.root", outputdir.Data(), new_poi_name ) ; char outpdffile[10000] ; sprintf( outpdffile, "%s/scan-ff-%s.pdf", outputdir.Data(), new_poi_name ) ; cscan->Update() ; cscan->Draw() ; printf("\n Saving %s\n", outpdffile ) ; cscan->SaveAs( outpdffile ) ; //--- save in root file printf("\n Saving %s\n", outrootfile ) ; TFile fout(outrootfile,"recreate") ; graph->Write() ; hsout->Write() ; fout.Close() ; delete ws ; wstf->Close() ; } // constrained_scan.
//------------------------------------------------------------------------------ // // drawXS // //------------------------------------------------------------------------------ void drawXS(UInt_t theCharge = WInclusive) { gStyle->SetEndErrorSize(5); // 7 TeV inclusive //---------------------------------------------------------------------------- xs_value[WInclusive][EEE] = 23.00; xs_value[WInclusive][EEM] = 19.67; xs_value[WInclusive][MME] = 19.81; xs_value[WInclusive][MMM] = 21.02; xs_value[WInclusive][all] = 20.76; xs_stat[WInclusive][EEE] = 3.10; xs_stat[WInclusive][EEM] = 2.73; xs_stat[WInclusive][MME] = 2.60; xs_stat[WInclusive][MMM] = 2.30; xs_stat[WInclusive][all] = 1.32; xs_syst[WInclusive][EEE] = 1.39; xs_syst[WInclusive][EEM] = 1.50; xs_syst[WInclusive][MME] = 1.55; xs_syst[WInclusive][MMM] = 1.47; xs_syst[WInclusive][all] = 1.13; xs_lumi[WInclusive][EEE] = 0.51; xs_lumi[WInclusive][EEM] = 0.43; xs_lumi[WInclusive][MME] = 0.44; xs_lumi[WInclusive][MMM] = 0.46; xs_lumi[WInclusive][all] = 0.46; // 7 TeV W+ //---------------------------------------------------------------------------- xs_value[WPlus][EEE] = 13.39; xs_value[WPlus][EEM] = 13.18; xs_value[WPlus][MME] = 14.14; xs_value[WPlus][MMM] = 11.43; xs_value[WPlus][all] = 12.73; xs_stat[WPlus][EEE] = 2.39; xs_stat[WPlus][EEM] = 2.24; xs_stat[WPlus][MME] = 2.19; xs_stat[WPlus][MMM] = 1.71; xs_stat[WPlus][all] = 1.04; xs_syst[WPlus][EEE] = 0.75; xs_syst[WPlus][EEM] = 0.64; xs_syst[WPlus][MME] = 0.74; xs_syst[WPlus][MMM] = 0.53; xs_syst[WPlus][all] = 0.59; xs_lumi[WPlus][EEE] = 0.29; xs_lumi[WPlus][EEM] = 0.29; xs_lumi[WPlus][MME] = 0.31; xs_lumi[WPlus][MMM] = 0.25; xs_lumi[WPlus][all] = 0.28; // 7 TeV W- //---------------------------------------------------------------------------- xs_value[WMinus][EEE] = 9.49; xs_value[WMinus][EEM] = 6.51; xs_value[WMinus][MME] = 5.73; xs_value[WMinus][MMM] = 9.48; xs_value[WMinus][all] = 7.46; xs_stat[WMinus][EEE] = 1.95; xs_stat[WMinus][EEM] = 1.58; xs_stat[WMinus][MME] = 1.40; xs_stat[WMinus][MMM] = 1.52; xs_stat[WMinus][all] = 0.79; xs_syst[WMinus][EEE] = 0.60; xs_syst[WMinus][EEM] = 0.37; xs_syst[WMinus][MME] = 0.37; xs_syst[WMinus][MMM] = 0.50; xs_syst[WMinus][all] = 0.40; xs_lumi[WMinus][EEE] = 0.21; xs_lumi[WMinus][EEM] = 0.14; xs_lumi[WMinus][MME] = 0.13; xs_lumi[WMinus][MMM] = 0.21; xs_lumi[WMinus][all] = 0.16; // Do the work //---------------------------------------------------------------------------- TGraphErrors* gStat = new TGraphErrors(nChannel); TGraphErrors* gSyst = new TGraphErrors(nChannel); TGraphErrors* gLumi = new TGraphErrors(nChannel); for (UInt_t i=0; i<nChannel; i++) { Double_t errorSquared = (xs_stat[theCharge][i] * xs_stat[theCharge][i]); gStat->SetPointError(i, sqrt(errorSquared) / xs_nlo[theCharge], 0.0); errorSquared += (xs_syst[theCharge][i] * xs_syst[theCharge][i]); gSyst->SetPointError(i, sqrt(errorSquared) / xs_nlo[theCharge], 0.0); errorSquared += (xs_lumi[theCharge][i] * xs_lumi[theCharge][i]); gLumi->SetPointError(i, sqrt(errorSquared) / xs_nlo[theCharge], 0.0); gStat->SetPoint(i, xs_value[theCharge][i] / xs_nlo[theCharge], nChannel-i-1); gSyst->SetPoint(i, xs_value[theCharge][i] / xs_nlo[theCharge], nChannel-i-1); gLumi->SetPoint(i, xs_value[theCharge][i] / xs_nlo[theCharge], nChannel-i-1); } // Cosmetics //---------------------------------------------------------------------------- gStat->SetLineWidth (2); gStat->SetMarkerSize (1.3); gStat->SetMarkerStyle(kFullCircle); gSyst->SetLineColor (kRed); gSyst->SetLineWidth (2); gSyst->SetMarkerSize (1.3); gSyst->SetMarkerStyle(kFullCircle); gLumi->SetLineColor (kBlue); gLumi->SetLineWidth (2); gLumi->SetMarkerSize (1.3); gLumi->SetMarkerStyle(kFullCircle); // Draw //---------------------------------------------------------------------------- TString suffix = "7TeV_" + sCharge[theCharge]; TCanvas* canvas = new TCanvas("ratioNLO_" + suffix, "ratioNLO_" + suffix); canvas->SetLeftMargin(canvas->GetRightMargin()); Double_t xmin = 0.0; Double_t xmax = 2.0; Double_t ylegend = 1.2; Double_t ymin = -0.6; Double_t ymax = nChannel + ymin + ylegend; TH2F* h2 = new TH2F("h2_" + suffix, "", 100, xmin, xmax, 100, ymin, ymax); h2->Draw(); // NLO WZ cross-section //---------------------------------------------------------------------------- TBox* nlo = new TBox(1. - xs_nlo_left [theCharge] / xs_nlo[theCharge], ymin, 1. + xs_nlo_right[theCharge] / xs_nlo[theCharge], ymax - ylegend); nlo->SetLineColor(0); nlo->SetFillColor(kGray); nlo->SetFillStyle(1001); nlo->Draw("e2,same"); TLine* line = new TLine(1., ymin, 1., ymax - ylegend); line->SetLineColor(kGray+1); line->SetLineWidth(2); line->Draw("same"); // Cross sections //---------------------------------------------------------------------------- gLumi->Draw("p,same"); gSyst->Draw("p,same"); gStat->Draw("p,same"); // Labels //---------------------------------------------------------------------------- for (UInt_t i=0; i<nChannel; i++) { Double_t x = gStat->GetX()[i]; Double_t y = gStat->GetY()[i]; Double_t gStatError = gStat->GetErrorX(i); Double_t gSystError = gSyst->GetErrorX(i); Double_t gLumiError = gLumi->GetErrorX(i); DrawTLatex(42, xmin+0.06, y+0.15, 0.035, 12, Form("%s %.2f #pm %.2f", lChannel[i].Data(), x, gLumiError), 0); gLumiError = sqrt(gLumiError*gLumiError - gSystError*gSystError); gSystError = sqrt(gSystError*gSystError - gStatError*gStatError); DrawTLatex(42, xmin+0.06, y-0.15, 0.025, 12, Form("%.2f #pm %.2f #pm %.2f #pm %.2f", x, gStatError, gSystError, gLumiError), 0); } DrawTLatex(42, 0.050, 0.975, _bigLabelSize, 13, "CMS Preliminary"); DrawTLatex(42, 0.940, 0.983, _bigLabelSize, 33, Form("#sqrt{s} = 7 TeV, L = %.1f fb^{-1}", luminosity/1e3)); TString swz = ""; if (theCharge == WPlus) swz = "W^{+}Z"; else if (theCharge == WMinus) swz = "W^{-}Z"; else swz = "W^{#pm}Z"; h2->GetXaxis()->CenterTitle(); h2->GetXaxis()->SetTitleOffset(1.4); h2->GetXaxis()->SetTitle(Form("#sigma_{%s}^{exp} / #sigma_{%s}^{theory}", swz.Data(), swz.Data())); h2->GetYaxis()->SetTitle(""); // Remove y-axis labels //---------------------------------------------------------------------------- TAxis* yaxis = h2->GetYaxis(); for (Int_t j=1; j<yaxis->GetNbins(); j++) yaxis->SetBinLabel(j, ""); // Additional legend //---------------------------------------------------------------------------- DrawLegend(0.645, 0.840, gStat, " stat.", "lp"); DrawLegend(0.645, 0.795, nlo, " theory", "f"); DrawLegend(0.800, 0.840, gSyst, " syst.", "l"); DrawLegend(0.800, 0.795, gLumi, " lumi.", "l"); // Save //---------------------------------------------------------------------------- canvas->Update(); canvas->GetFrame()->DrawClone(); canvas->RedrawAxis(); canvas->SaveAs(Form("pdf/ratioNLO_%s.pdf", suffix.Data())); canvas->SaveAs(Form("png/ratioNLO_%s.png", suffix.Data())); }
void ws_constrained_profile3D( const char* wsfile = "rootfiles/ws-data-unblind.root", const char* new_poi_name = "n_M234_H4_3b", int npoiPoints = 20, double poiMinVal = 0., double poiMaxVal = 20., double constraintWidth = 1.5, double ymax = 10., int verbLevel=0 ) { gStyle->SetOptStat(0) ; //--- make output directory. char command[10000] ; sprintf( command, "basename %s", wsfile ) ; TString wsfilenopath = gSystem->GetFromPipe( command ) ; wsfilenopath.ReplaceAll(".root","") ; char outputdirstr[1000] ; sprintf( outputdirstr, "outputfiles/scans-%s", wsfilenopath.Data() ) ; TString outputdir( outputdirstr ) ; printf("\n\n Creating output directory: %s\n\n", outputdir.Data() ) ; sprintf(command, "mkdir -p %s", outputdir.Data() ) ; gSystem->Exec( command ) ; //--- Tell RooFit to shut up about anything less important than an ERROR. RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR) ; if ( verbLevel > 0 ) { printf("\n\n Verbose level : %d\n\n", verbLevel) ; } TFile* wstf = new TFile( wsfile ) ; RooWorkspace* ws = dynamic_cast<RooWorkspace*>( wstf->Get("ws") ); if ( verbLevel > 0 ) { ws->Print() ; } RooDataSet* rds = (RooDataSet*) ws->obj( "ra2b_observed_rds" ) ; if ( verbLevel > 0 ) { printf("\n\n\n ===== RooDataSet ====================\n\n") ; rds->Print() ; rds->printMultiline(cout, 1, kTRUE, "") ; } ModelConfig* modelConfig = (ModelConfig*) ws->obj( "SbModel" ) ; RooAbsPdf* likelihood = modelConfig->GetPdf() ; RooRealVar* rrv_mu_susy_all0lep = ws->var("mu_susy_all0lep") ; if ( rrv_mu_susy_all0lep == 0x0 ) { printf("\n\n\n *** can't find mu_susy_all0lep in workspace. Quitting.\n\n\n") ; return ; } //-- do BG only. rrv_mu_susy_all0lep->setVal(0.) ; rrv_mu_susy_all0lep->setConstant( kTRUE ) ; //-- do a prefit. printf("\n\n\n ====== Pre fit with unmodified nll var.\n\n") ; RooFitResult* dataFitResultSusyFixed = likelihood->fitTo(*rds, Save(true),Hesse(false),Minos(false),Strategy(1),PrintLevel(verbLevel)); int dataSusyFixedFitCovQual = dataFitResultSusyFixed->covQual() ; if ( dataSusyFixedFitCovQual < 2 ) { printf("\n\n\n *** Failed fit! Cov qual %d. Quitting.\n\n", dataSusyFixedFitCovQual ) ; return ; } double dataFitSusyFixedNll = dataFitResultSusyFixed->minNll() ; if ( verbLevel > 0 ) { dataFitResultSusyFixed->Print("v") ; } printf("\n\n Nll value, from fit result : %.3f\n\n", dataFitSusyFixedNll ) ; delete dataFitResultSusyFixed ; //-- Construct the new POI parameter. RooAbsReal* new_poi_rar(0x0) ; new_poi_rar = ws->var( new_poi_name ) ; if ( new_poi_rar == 0x0 ) { printf("\n\n New POI %s is not a variable. Trying function.\n\n", new_poi_name ) ; new_poi_rar = ws->function( new_poi_name ) ; if ( new_poi_rar == 0x0 ) { printf("\n\n New POI %s is not a function. I quit.\n\n", new_poi_name ) ; return ; } } else { printf("\n\n New POI %s is a variable with current value %.1f.\n\n", new_poi_name, new_poi_rar->getVal() ) ; } if ( npoiPoints <=0 ) { printf("\n\n Quitting now.\n\n" ) ; return ; } double startPoiVal = new_poi_rar->getVal() ; //--- The RooNLLVar is NOT equivalent to what minuit uses. // RooNLLVar* nll = new RooNLLVar("nll","nll", *likelihood, *rds ) ; // printf("\n\n Nll value, from construction : %.3f\n\n", nll->getVal() ) ; //--- output of createNLL IS what minuit uses, so use that. RooAbsReal* nll = likelihood -> createNLL( *rds, Verbose(true) ) ; RooRealVar* rrv_poiValue = new RooRealVar( "poiValue", "poiValue", 0., -10000., 10000. ) ; /// rrv_poiValue->setVal( poiMinVal ) ; /// rrv_poiValue->setConstant(kTRUE) ; RooRealVar* rrv_constraintWidth = new RooRealVar("constraintWidth","constraintWidth", 0.1, 0.1, 1000. ) ; rrv_constraintWidth -> setVal( constraintWidth ) ; rrv_constraintWidth -> setConstant(kTRUE) ; if ( verbLevel > 0 ) { printf("\n\n ======= debug likelihood print\n\n") ; likelihood->Print("v") ; printf("\n\n ======= debug nll print\n\n") ; nll->Print("v") ; } //---------------------------------------------------------------------------------------------- RooMinuit* rminuit( 0x0 ) ; RooMinuit* rminuit_uc = new RooMinuit( *nll ) ; rminuit_uc->setPrintLevel(verbLevel-1) ; rminuit_uc->setNoWarn() ; rminuit_uc->migrad() ; rminuit_uc->hesse() ; RooFitResult* rfr_uc = rminuit_uc->fit("mr") ; double floatParInitVal[10000] ; char floatParName[10000][100] ; int nFloatParInitVal(0) ; RooArgList ral_floats = rfr_uc->floatParsFinal() ; TIterator* floatParIter = ral_floats.createIterator() ; { RooRealVar* par ; while ( (par = (RooRealVar*) floatParIter->Next()) ) { sprintf( floatParName[nFloatParInitVal], "%s", par->GetName() ) ; floatParInitVal[nFloatParInitVal] = par->getVal() ; nFloatParInitVal++ ; } } //------- printf("\n\n Unbiased best value for new POI %s is : %7.1f\n\n", new_poi_rar->GetName(), new_poi_rar->getVal() ) ; double best_poi_val = new_poi_rar->getVal() ; char minuit_formula[10000] ; sprintf( minuit_formula, "%s+%s*(%s-%s)*(%s-%s)", nll->GetName(), rrv_constraintWidth->GetName(), new_poi_rar->GetName(), rrv_poiValue->GetName(), new_poi_rar->GetName(), rrv_poiValue->GetName() ) ; printf("\n\n Creating new minuit variable with formula: %s\n\n", minuit_formula ) ; RooFormulaVar* new_minuit_var = new RooFormulaVar("new_minuit_var", minuit_formula, RooArgList( *nll, *rrv_constraintWidth, *new_poi_rar, *rrv_poiValue, *new_poi_rar, *rrv_poiValue ) ) ; printf("\n\n Current value is %.2f\n\n", new_minuit_var->getVal() ) ; rminuit = new RooMinuit( *new_minuit_var ) ; RooAbsReal* plot_var = nll ; printf("\n\n Current value is %.2f\n\n", plot_var->getVal() ) ; rminuit->setPrintLevel(verbLevel-1) ; if ( verbLevel <=0 ) { rminuit->setNoWarn() ; } //---------------------------------------------------------------------------------------------- //-- If POI range is -1 to -1, automatically determine the range using the set value. if ( poiMinVal < 0. && poiMaxVal < 0. ) { printf("\n\n Automatic determination of scan range.\n\n") ; if ( startPoiVal <= 0. ) { printf("\n\n *** POI starting value zero or negative %g. Quit.\n\n\n", startPoiVal ) ; return ; } poiMinVal = startPoiVal - 3.5 * sqrt(startPoiVal) ; poiMaxVal = startPoiVal + 6.0 * sqrt(startPoiVal) ; if ( poiMinVal < 0. ) { poiMinVal = 0. ; } printf(" Start val = %g. Scan range: %g to %g\n\n", startPoiVal, poiMinVal, poiMaxVal ) ; } //---------------------------------------------------------------------------------------------- double poiVals_scanDown[1000] ; double nllVals_scanDown[1000] ; //-- Do scan down from best value. printf("\n\n +++++ Starting scan down from best value.\n\n") ; double minNllVal(1.e9) ; for ( int poivi=0; poivi < npoiPoints/2 ; poivi++ ) { ////double poiValue = poiMinVal + poivi*(poiMaxVal-poiMinVal)/(1.*(npoiPoints-1)) ; double poiValue = best_poi_val - poivi*(best_poi_val-poiMinVal)/(1.*(npoiPoints/2-1)) ; rrv_poiValue -> setVal( poiValue ) ; rrv_poiValue -> setConstant( kTRUE ) ; //+++++++++++++++++++++++++++++++++++ rminuit->migrad() ; rminuit->hesse() ; RooFitResult* rfr = rminuit->save() ; //+++++++++++++++++++++++++++++++++++ if ( verbLevel > 0 ) { rfr->Print("v") ; } float fit_minuit_var_val = rfr->minNll() ; printf(" %02d : poi constraint = %.2f : allvars : MinuitVar, createNLL, PV, POI : %.5f %.5f %.5f %.5f\n", poivi, rrv_poiValue->getVal(), fit_minuit_var_val, nll->getVal(), plot_var->getVal(), new_poi_rar->getVal() ) ; cout << flush ; poiVals_scanDown[poivi] = new_poi_rar->getVal() ; nllVals_scanDown[poivi] = plot_var->getVal() ; if ( nllVals_scanDown[poivi] < minNllVal ) { minNllVal = nllVals_scanDown[poivi] ; } delete rfr ; } // poivi printf("\n\n +++++ Resetting floats to best fit values.\n\n") ; for ( int pi=0; pi<nFloatParInitVal; pi++ ) { RooRealVar* par = ws->var( floatParName[pi] ) ; par->setVal( floatParInitVal[pi] ) ; } // pi. printf("\n\n +++++ Starting scan up from best value.\n\n") ; //-- Now do scan up. double poiVals_scanUp[1000] ; double nllVals_scanUp[1000] ; for ( int poivi=0; poivi < npoiPoints/2 ; poivi++ ) { double poiValue = best_poi_val + poivi*(poiMaxVal-best_poi_val)/(1.*(npoiPoints/2-1)) ; rrv_poiValue -> setVal( poiValue ) ; rrv_poiValue -> setConstant( kTRUE ) ; //+++++++++++++++++++++++++++++++++++ rminuit->migrad() ; rminuit->hesse() ; RooFitResult* rfr = rminuit->save() ; //+++++++++++++++++++++++++++++++++++ if ( verbLevel > 0 ) { rfr->Print("v") ; } float fit_minuit_var_val = rfr->minNll() ; printf(" %02d : poi constraint = %.2f : allvars : MinuitVar, createNLL, PV, POI : %.5f %.5f %.5f %.5f\n", poivi, rrv_poiValue->getVal(), fit_minuit_var_val, nll->getVal(), plot_var->getVal(), new_poi_rar->getVal() ) ; cout << flush ; poiVals_scanUp[poivi] = new_poi_rar->getVal() ; nllVals_scanUp[poivi] = plot_var->getVal() ; if ( nllVals_scanUp[poivi] < minNllVal ) { minNllVal = nllVals_scanUp[poivi] ; } delete rfr ; } // poivi double poiVals[1000] ; double nllVals[1000] ; int pointCount(0) ; for ( int pi=0; pi<npoiPoints/2; pi++ ) { poiVals[pi] = poiVals_scanDown[(npoiPoints/2-1)-pi] ; nllVals[pi] = nllVals_scanDown[(npoiPoints/2-1)-pi] ; pointCount++ ; } for ( int pi=1; pi<npoiPoints/2; pi++ ) { poiVals[pointCount] = poiVals_scanUp[pi] ; nllVals[pointCount] = nllVals_scanUp[pi] ; pointCount++ ; } npoiPoints = pointCount ; printf("\n\n --- TGraph arrays:\n") ; for ( int i=0; i<npoiPoints; i++ ) { printf(" %2d : poi = %6.1f, nll = %g\n", i, poiVals[i], nllVals[i] ) ; } printf("\n\n") ; double nllDiffVals[1000] ; double poiAtMinlnL(-1.) ; double poiAtMinusDelta2(-1.) ; double poiAtPlusDelta2(-1.) ; for ( int poivi=0; poivi < npoiPoints ; poivi++ ) { nllDiffVals[poivi] = 2.*(nllVals[poivi] - minNllVal) ; double poiValue = poiMinVal + poivi*(poiMaxVal-poiMinVal)/(1.*npoiPoints) ; if ( nllDiffVals[poivi] < 0.01 ) { poiAtMinlnL = poiValue ; } if ( poiAtMinusDelta2 < 0. && nllDiffVals[poivi] < 2.5 ) { poiAtMinusDelta2 = poiValue ; } if ( poiAtMinlnL > 0. && poiAtPlusDelta2 < 0. && nllDiffVals[poivi] > 2.0 ) { poiAtPlusDelta2 = poiValue ; } } // poivi printf("\n\n Estimates for poi at delta ln L = -2, 0, +2: %g , %g , %g\n\n", poiAtMinusDelta2, poiAtMinlnL, poiAtPlusDelta2 ) ; //--- Main canvas TCanvas* cscan = (TCanvas*) gDirectory->FindObject("cscan") ; if ( cscan == 0x0 ) { printf("\n Creating canvas.\n\n") ; cscan = new TCanvas("cscan","Delta nll") ; } char gname[1000] ; TGraph* graph = new TGraph( npoiPoints, poiVals, nllDiffVals ) ; sprintf( gname, "scan_%s", new_poi_name ) ; graph->SetName( gname ) ; double poiBest(-1.) ; double poiMinus1stdv(-1.) ; double poiPlus1stdv(-1.) ; double poiMinus2stdv(-1.) ; double poiPlus2stdv(-1.) ; double twoDeltalnLMin(1e9) ; int nscan(1000) ; for ( int xi=0; xi<nscan; xi++ ) { double x = poiVals[0] + xi*(poiVals[npoiPoints-1]-poiVals[0])/(nscan-1) ; double twoDeltalnL = graph -> Eval( x, 0, "S" ) ; if ( poiMinus1stdv < 0. && twoDeltalnL < 1.0 ) { poiMinus1stdv = x ; printf(" set m1 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;} if ( poiMinus2stdv < 0. && twoDeltalnL < 4.0 ) { poiMinus2stdv = x ; printf(" set m2 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;} if ( twoDeltalnL < twoDeltalnLMin ) { poiBest = x ; twoDeltalnLMin = twoDeltalnL ; } if ( twoDeltalnLMin < 0.3 && poiPlus1stdv < 0. && twoDeltalnL > 1.0 ) { poiPlus1stdv = x ; printf(" set p1 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;} if ( twoDeltalnLMin < 0.3 && poiPlus2stdv < 0. && twoDeltalnL > 4.0 ) { poiPlus2stdv = x ; printf(" set p2 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;} if ( xi%100 == 0 ) { printf( " %4d : poi=%6.2f, 2DeltalnL = %6.2f\n", xi, x, twoDeltalnL ) ; } } printf("\n\n POI estimate : %g +%g -%g [%g,%g], two sigma errors: +%g -%g [%g,%g]\n\n", poiBest, (poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv), poiMinus1stdv, poiPlus1stdv, (poiPlus2stdv-poiBest), (poiBest-poiMinus2stdv), poiMinus2stdv, poiPlus2stdv ) ; printf(" %s val,pm1sig,pm2sig: %7.2f %7.2f %7.2f %7.2f %7.2f\n", new_poi_name, poiBest, (poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv), (poiPlus2stdv-poiBest), (poiBest-poiMinus2stdv) ) ; char htitle[1000] ; sprintf(htitle, "%s profile likelihood scan: -2ln(L/Lm)", new_poi_name ) ; TH1F* hscan = new TH1F("hscan", htitle, 10, poiMinVal, poiMaxVal ) ; hscan->SetMinimum(0.) ; hscan->SetMaximum(ymax) ; hscan->DrawCopy() ; graph->SetLineColor(4) ; graph->SetLineWidth(3) ; graph->Draw("CP") ; gPad->SetGridx(1) ; gPad->SetGridy(1) ; cscan->Update() ; TLine* line = new TLine() ; line->SetLineColor(2) ; line->DrawLine(poiMinVal, 1., poiPlus1stdv, 1.) ; line->DrawLine(poiMinus1stdv,0., poiMinus1stdv, 1.) ; line->DrawLine(poiPlus1stdv ,0., poiPlus1stdv , 1.) ; TText* text = new TText() ; text->SetTextSize(0.04) ; char tstring[1000] ; sprintf( tstring, "%s = %.1f +%.1f -%.1f", new_poi_name, poiBest, (poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv) ) ; text -> DrawTextNDC( 0.15, 0.85, tstring ) ; sprintf( tstring, "68%% interval [%.1f, %.1f]", poiMinus1stdv, poiPlus1stdv ) ; text -> DrawTextNDC( 0.15, 0.78, tstring ) ; char hname[1000] ; sprintf( hname, "hscanout_%s", new_poi_name ) ; TH1F* hsout = new TH1F( hname,"scan results",4,0.,4.) ; double obsVal(-1.) ; hsout->SetBinContent(1, obsVal ) ; hsout->SetBinContent(2, poiPlus1stdv ) ; hsout->SetBinContent(3, poiBest ) ; hsout->SetBinContent(4, poiMinus1stdv ) ; TAxis* xaxis = hsout->GetXaxis() ; xaxis->SetBinLabel(1,"Observed val.") ; xaxis->SetBinLabel(2,"Model+1sd") ; xaxis->SetBinLabel(3,"Model") ; xaxis->SetBinLabel(4,"Model-1sd") ; char outrootfile[10000] ; sprintf( outrootfile, "%s/scan-ff-%s.root", outputdir.Data(), new_poi_name ) ; char outpdffile[10000] ; sprintf( outpdffile, "%s/scan-ff-%s.pdf", outputdir.Data(), new_poi_name ) ; cscan->Update() ; cscan->Draw() ; printf("\n Saving %s\n", outpdffile ) ; cscan->SaveAs( outpdffile ) ; //--- save in root file printf("\n Saving %s\n", outrootfile ) ; TFile fout(outrootfile,"recreate") ; graph->Write() ; hsout->Write() ; fout.Close() ; delete ws ; wstf->Close() ; }
int main(int argc, char *argv[]) { using namespace boost::program_options; using namespace std; string programName(argv[0]); string descString(programName); descString += " [options] "; descString += "data_file \nAllowed options"; options_description desc(descString); desc.add_options()(kHelpCommandOpt, "produce help message")(kAutoLoadCommandOpt, "automatic library loading (avoid root warnings)")( kDataFileCommandOpt, value<string>(), "data file")(kAlphabeticOrderCommandOpt, "sort by alphabetic order (default: sort by size)")( kPlotCommandOpt, value<string>(), "produce a summary plot")( kPlotTopCommandOpt, value<int>(), "plot only the <arg> top size branches")( kSavePlotCommandOpt, value<string>(), "save plot into root file <arg>")(kVerboseCommandOpt, "verbose printout"); positional_options_description p; p.add(kDataFileOpt, -1); variables_map vm; try { store(command_line_parser(argc, argv).options(desc).positional(p).run(), vm); notify(vm); } catch (const error &) { return 7000; } if (vm.count(kHelpOpt)) { cout << desc << std::endl; return 0; } if (!vm.count(kDataFileOpt)) { string shortDesc("ConfigFileNotFound"); cerr << programName << ": no data file given" << endl; return 7001; } gROOT->SetBatch(); if (vm.count(kAutoLoadOpt) != 0) { gSystem->Load("libFWCoreFWLite"); FWLiteEnabler::enable(); } string fileName = vm[kDataFileOpt].as<string>(); TFile file(fileName.c_str()); if (!file.IsOpen()) { cerr << programName << ": unable to open data file " << fileName << endl; return 7002; } TObject *o = file.Get("Events"); if (o == 0) { cerr << programName << ": no object \"Events\" found in file: " << fileName << endl; return 7003; } TTree *events = dynamic_cast<TTree *>(o); if (events == 0) { cerr << programName << ": object \"Events\" is not a TTree in file: " << fileName << endl; return 7004; } TObjArray *branches = events->GetListOfBranches(); if (branches == 0) { cerr << programName << ": tree \"Events\" in file " << fileName << " contains no branches" << endl; return 7004; } bool verbose = vm.count(kVerboseOpt) > 0; BranchVector v; const size_t n = branches->GetEntries(); cout << fileName << " has " << n << " branches" << endl; for (size_t i = 0; i < n; ++i) { TBranch *b = dynamic_cast<TBranch *>(branches->At(i)); assert(b != 0); string name(b->GetName()); if (name == "EventAux") continue; size_type s = GetTotalSize(b, verbose); v.push_back(make_pair(b->GetName(), s)); } if (vm.count(kAlphabeticOrderOpt)) { sort(v.begin(), v.end(), sortByName()); } else { sort(v.begin(), v.end(), sortByCompressedSize()); } bool plot = (vm.count(kPlotOpt) > 0); bool save = (vm.count(kSavePlotOpt) > 0); int top = n; if (vm.count(kPlotTopOpt) > 0) top = vm[kPlotTopOpt].as<int>(); TH1F uncompressed("uncompressed", "branch sizes", top, -0.5, -0.5 + top); TH1F compressed("compressed", "branch sizes", top, -0.5, -0.5 + top); int x = 0; TAxis *cxAxis = compressed.GetXaxis(); TAxis *uxAxis = uncompressed.GetXaxis(); for (BranchVector::const_iterator b = v.begin(); b != v.end(); ++b) { const string &name = b->first; size_type size = b->second; cout << size << " " << name << endl; if (x < top) { cxAxis->SetBinLabel(x + 1, name.c_str()); uxAxis->SetBinLabel(x + 1, name.c_str()); compressed.Fill(x, size.second); uncompressed.Fill(x, size.first); x++; } } // size_type branchSize = GetTotalBranchSize( events ); // cout << "total branches size: " << branchSize.first << " bytes (uncompressed), " // << branchSize.second << " bytes (compressed)"<< endl; size_type totalSize = GetTotalSize(events); cout << "total tree size: " << totalSize.first << " bytes (uncompressed), " << totalSize.second << " bytes (compressed)" << endl; double mn = DBL_MAX; for (int i = 1; i <= top; ++i) { double cm = compressed.GetMinimum(i), um = uncompressed.GetMinimum(i); if (cm > 0 && cm < mn) mn = cm; if (um > 0 && um < mn) mn = um; } mn *= 0.8; double mx = max(compressed.GetMaximum(), uncompressed.GetMaximum()); mx *= 1.2; uncompressed.SetMinimum(mn); uncompressed.SetMaximum(mx); compressed.SetMinimum(mn); // compressed.SetMaximum( mx ); cxAxis->SetLabelOffset(-0.32); cxAxis->LabelsOption("v"); cxAxis->SetLabelSize(0.03); uxAxis->SetLabelOffset(-0.32); uxAxis->LabelsOption("v"); uxAxis->SetLabelSize(0.03); compressed.GetYaxis()->SetTitle("Bytes"); compressed.SetFillColor(kBlue); compressed.SetLineWidth(2); uncompressed.GetYaxis()->SetTitle("Bytes"); uncompressed.SetFillColor(kRed); uncompressed.SetLineWidth(2); if (plot) { string plotName = vm[kPlotOpt].as<string>(); gROOT->SetStyle("Plain"); gStyle->SetOptStat(kFALSE); gStyle->SetOptLogy(); TCanvas c; uncompressed.Draw(); compressed.Draw("same"); c.SaveAs(plotName.c_str()); } if (save) { string fileName = vm[kSavePlotOpt].as<string>(); TFile f(fileName.c_str(), "RECREATE"); compressed.Write(); uncompressed.Write(); f.Close(); } return 0; }