void binary( string inFile = "allSim.root", int cSpecies = 1, bool cutDedx = false ){ TCanvas * c = new TCanvas( "c", "c", 800, 800 ); string outName = "rpBinaryPid.pdf"; c->Print( (outName+"[").c_str() ); TFile * f = new TFile( inFile.c_str(), "READ" ); string rOutName = "rootBinaryPid.root"; TFile * fOut = new TFile( rOutName.c_str(), "RECREATE" ); vector<double>effVsP; vector<double>pureVsP; c->Divide( 2, 2 ); for ( int i = 0; i < 70; i++ ){ stringstream sstr; sstr << "h_dedx_tof_p3_b" << i; TH2* sum = (TH2*)f->Get( sstr.str().c_str() ); sstr.str(""); sstr << "h_dedx_tof_p0_b" << i; TH2* p0 = (TH2*)f->Get( sstr.str().c_str() ); sstr.str(""); sstr << "h_dedx_tof_p1_b" << i; TH2* p1 = (TH2*)f->Get( sstr.str().c_str() ); sstr.str(""); sstr << "h_dedx_tof_p2_b" << i; TH2* p2 = (TH2*)f->Get( sstr.str().c_str() ); pidBinary * pid = new pidBinary( sum, cSpecies, p0, p1, p2 ); pid->cutDedx( cutDedx ); c->cd( 3 ); gPad->SetLogz(1); sum->Draw("colz"); c->cd( 4 ); gPad->SetLogx(1); TH1* pX = sum->ProjectionX(); TH1* pY = sum->ProjectionY(); pY->SetFillColor( kBlue ); pY->SetLineColor( kBlue ); pY->Draw("hbar"); c->cd(1); gPad->SetLogy(1); pX->SetFillColor( kBlue ); pX->SetLineColor( kBlue ); pX->Draw("h"); c->cd(2); sstr.str(""); sstr << "eff_" << i; TH1D* eff = pid->efficiency( sstr.str(), 0.0, 5.0, 0.1 ); sstr.str(""); sstr << "pure_" << i; TH1D* pure = pid->purity( sstr.str(), 0.0, 5.0, 0.1 ); gStyle->SetOptStat( 0 ); eff->SetTitle( "Efficiecy (Blue), Purity (Red)" ); eff->GetYaxis()->SetRangeUser(0, 1.05); eff->SetLineWidth( 2 ); eff->Draw(); pure->SetLineColor( kRed ); pure->SetLineWidth( 2 ); pure->Draw("same"); effVsP.push_back( pid->efficiency() ); pureVsP.push_back( pid->purity( ) ); c->Print( outName.c_str()); } int nBins = (3.7 - 0.2) / 0.05; TH1D * hEffVsP = new TH1D( "hEffVsP", "Efficiency Vs. P; P [GeV]", nBins, 0.2, 3.7 ); for ( int i = 0; i < effVsP.size(); i++ ){ hEffVsP->SetBinContent( i, effVsP[ i ] ); } TH1D * hPureVsP = new TH1D( "hPureVsP", "Purity Vs. P; P [GeV]", nBins, 0.2, 3.7 ); for ( int i = 0; i < pureVsP.size(); i++ ){ hPureVsP->SetBinContent( i, pureVsP[ i ] ); } c->Divide( 1 ); c->cd( 0 ); hEffVsP->GetYaxis()->SetRangeUser( 0.0, 1.05); hEffVsP->SetLineWidth( 2 ); hEffVsP->SetTitle( "Efficiency (Blue), Purity (Red)" ); hEffVsP->Draw( ""); hPureVsP->SetLineColor( kRed ); hPureVsP->SetLineWidth( 2 ); hPureVsP->Draw( "same" ); c->Print( outName.c_str()); c->Print( (outName+"]").c_str() ); fOut->Write(); }
void EMCDistribution_PeakSample_Fast(bool full_gain = false) { const TString gain = "RAW"; TString hname = "EMCDistribution_" + gain + TString(full_gain ? "_FullGain" : "") + cuts; TH2 *h2 = NULL; { if (full_gain) { h2 = new TH2F(hname, Form(";Calibrated Tower Energy Sum (ADC);Count / bin"), 100, .05 * 100, 25 * 100, 64, -.5, 63.5); QAHistManagerDef::useLogBins(h2->GetXaxis()); } else { h2 = new TH2F(hname, Form(";Calibrated Tower Energy Sum (ADC);Count / bin"), 260, -.2 * 100, 5 * 100, 64, -.5, 63.5); } T->Draw( "TOWER_" + gain + "_CEMC[].get_bineta() + 8* TOWER_" + gain + "_CEMC[].get_binphi():(TOWER_RAW_CEMC[].signal_samples[10] - TOWER_RAW_CEMC[].signal_samples[0])*(-1)>>" + hname, "", "goff"); } TText *t; TCanvas *c1 = new TCanvas( "EMCDistribution_PeakSample_Fast_" + TString(full_gain ? "_FullGain" : "") + cuts, "EMCDistribution_PeakSample_Fast_" + TString(full_gain ? "_FullGain" : "") + cuts, 1800, 950); c1->Divide(8, 8, 0., 0.01); int idx = 1; TPad *p; for (int iphi = 8 - 1; iphi >= 0; iphi--) { for (int ieta = 0; ieta < 8; ieta++) { p = (TPad *) c1->cd(idx++); c1->Update(); p->SetLogy(); if (full_gain) { p->SetLogx(); } p->SetGridx(0); p->SetGridy(0); TString hname = Form("hEnergy_ieta%d_iphi%d", ieta, iphi) + TString(full_gain ? "_FullGain" : ""); TH1 *h = h2->ProjectionX(hname, ieta + 8 * iphi + 1, ieta + 8 * iphi + 1); // axis bin number is encoded as ieta+8*iphi+1 h->SetLineWidth(0); h->SetLineColor(kBlue + 3); h->SetFillColor(kBlue + 3); h->GetXaxis()->SetTitleSize(.09); h->GetXaxis()->SetLabelSize(.08); h->GetYaxis()->SetLabelSize(.08); h->Draw(); if (full_gain) h->Fit("x*gaus", "M"); else h->Fit("landau", "M"); double peak = -1; TF1 *fit = ((TF1 *) (h->GetListOfFunctions()->At(0))); if (fit) { fit->SetLineColor(kRed); peak = fit->GetParameter(1); } cout << Form("Finished <Col%d Row%d> = %.1f", ieta, iphi, peak) << endl; TText *t = new TText(.9, .9, Form("<Col%d Row%d> = %.1f", ieta, iphi, peak)); t->SetTextAlign(33); t->SetTextSize(.15); t->SetNDC(); t->Draw(); } } SaveCanvas(c1, TString(_file0->GetName()) + TString("_DrawPrototype4EMCalTower_") + TString(c1->GetName()), false); }
void plot_efficiencies( TFile* file, Int_t type = 2, TDirectory* BinDir=0) { // input: - Input file (result from TMVA), // - type = 1 --> plot efficiency(B) versus eff(S) // = 2 --> plot rejection (B) versus efficiency (S) // = 3 --> plot 1/eff(B) versus efficiency (S) Bool_t __PLOT_LOGO__ = kTRUE; Bool_t __SAVE_IMAGE__ = kTRUE; // the coordinates Float_t x1 = 0; Float_t x2 = 1; Float_t y1 = 0; Float_t y2 = 0.8; // reverse order if "rejection" if (type == 2) { Float_t z = y1; y1 = 1 - y2; y2 = 1 - z; // cout << "--- type==2: plot background rejection versus signal efficiency" << endl; } else if (type == 3) { y1 = 0; y2 = -1; // will be set to the max found in the histograms } else { // cout << "--- type==1: plot background efficiency versus signal efficiency" << endl; } // create canvas TCanvas* c = new TCanvas( "c", "the canvas", 200, 0, 650, 500 ); // global style settings c->SetGrid(); c->SetTicks(); // legend Float_t x0L = 0.107, y0H = 0.899; Float_t dxL = 0.457-x0L, dyH = 0.22; if (type == 2) { x0L = 0.15; y0H = 1 - y0H + dyH + 0.07; } TLegend *legend = new TLegend( x0L, y0H-dyH, x0L+dxL, y0H ); //legend->SetTextSize( 0.05 ); legend->SetHeader( "MVA Method:" ); legend->SetMargin( 0.4 ); TString xtit = "Signal efficiency"; TString ytit = "Background efficiency"; if (type == 2) ytit = "Background rejection"; if (type == 3) ytit = "1/(Background eff.)"; TString ftit = ytit + " versus " + xtit; TString hNameRef = "effBvsS"; if (type == 2) hNameRef = "rejBvsS"; if (type == 3) hNameRef = "invBeffvsSeff"; if (TString(BinDir->GetName()).Contains("multicut")){ ftit += " Bin: "; ftit += (BinDir->GetTitle()); } TList xhists; TList xmethods; UInt_t xnm = TMVAGlob::GetListOfMethods( xmethods ); TIter xnext(&xmethods); // loop over all methods TKey *xkey; while ((xkey = (TKey*)xnext())) { TDirectory * mDir = (TDirectory*)xkey->ReadObj(); TList titles; UInt_t ninst = TMVAGlob::GetListOfTitles(mDir,titles); TIter nextTitle(&titles); TKey *titkey; TDirectory *titDir; while ((titkey = TMVAGlob::NextKey(nextTitle,"TDirectory"))) { titDir = (TDirectory *)titkey->ReadObj(); TString methodTitle; TMVAGlob::GetMethodTitle(methodTitle,titDir); TIter nextKey( titDir->GetListOfKeys() ); TKey *hkey2; while ((hkey2 = TMVAGlob::NextKey(nextKey,"TH1"))) { TH1 *h = (TH1*)hkey2->ReadObj(); TString hname = h->GetName(); if (hname.Contains( hNameRef ) && hname.BeginsWith( "MVA_" )) { if (type==3 && h->GetMaximum() > y2) y2 = h->GetMaximum()*1.1; } } } } // draw empty frame if(gROOT->FindObject("frame")!=0) gROOT->FindObject("frame")->Delete(); TH2F* frame = new TH2F( "frame", ftit, 500, x1, x2, 500, y1, y2 ); frame->GetXaxis()->SetTitle( xtit ); frame->GetYaxis()->SetTitle( ytit ); TMVAGlob::SetFrameStyle( frame, 1.0 ); frame->Draw(); Int_t color = 1; Int_t nmva = 0; TKey *key; TList hists; TList methods; UInt_t nm = TMVAGlob::GetListOfMethods( methods ); // TIter next(file->GetListOfKeys()); TIter next(&methods); // loop over all methods while ((key = (TKey*)next())) { TDirectory * mDir = (TDirectory*)key->ReadObj(); TList titles; UInt_t ninst = TMVAGlob::GetListOfTitles(mDir,titles); TIter nextTitle(&titles); TKey *titkey; TDirectory *titDir; while ((titkey = TMVAGlob::NextKey(nextTitle,"TDirectory"))) { titDir = (TDirectory *)titkey->ReadObj(); TString methodTitle; TMVAGlob::GetMethodTitle(methodTitle,titDir); TIter nextKey( titDir->GetListOfKeys() ); TKey *hkey2; while ((hkey2 = TMVAGlob::NextKey(nextKey,"TH1"))) { TH1 *h = (TH1*)hkey2->ReadObj(); TString hname = h->GetName(); if (hname.Contains( hNameRef ) && hname.BeginsWith( "MVA_" )) { h->SetLineWidth(3); h->SetLineColor(color); color++; if (color == 5 || color == 10 || color == 11) color++; h->Draw("csame"); hists.Add(h); nmva++; } } } } while (hists.GetSize()) { TListIter hIt(&hists); TH1* hist(0); Double_t largestInt=-1; TH1* histWithLargestInt(0); while ((hist = (TH1*)hIt())!=0) { Double_t integral = hist->Integral(1,hist->FindBin(0.9999)); if (integral>largestInt) { largestInt = integral; histWithLargestInt = hist; } } if (histWithLargestInt == 0) { cout << "ERROR - unknown hist \"histWithLargestInt\" --> serious problem in ROOT file" << endl; break; } legend->AddEntry(histWithLargestInt,TString(histWithLargestInt->GetTitle()).ReplaceAll("MVA_",""),"l"); hists.Remove(histWithLargestInt); } // rescale legend box size // current box size has been tuned for 3 MVAs + 1 title if (type == 1) { dyH *= (1.0 + Float_t(nmva - 3.0)/4.0); legend->SetY1( y0H - dyH ); } else { dyH *= (Float_t(TMath::Min(10,nmva) - 3.0)/4.0); legend->SetY2( y0H + dyH); } // redraw axes frame->Draw("sameaxis"); legend->Draw("same"); // ============================================================ if (__PLOT_LOGO__) TMVAGlob::plot_logo(); // ============================================================ c->Update(); TString fname = "plots/" + hNameRef; if (TString(BinDir->GetName()).Contains("multicut")){ TString fprepend(BinDir->GetName()); fprepend.ReplaceAll("multicutMVA_",""); fname = "plots/" + fprepend + "_" + hNameRef; } if (__SAVE_IMAGE__) TMVAGlob::imgconv( c, fname ); return; }
RooHistN::RooHistN(const TH1 &data1, const TH1 &data2, Double_t nominalBinWidth, Double_t nSigma, Double_t xErrorFrac) : TGraphAsymmErrors(), _nominalBinWidth(nominalBinWidth), _nSigma(nSigma), _rawEntries(-1) { // Create a histogram from the asymmetry between the specified TH1 objects // which may have fixed or variable bin widths, but which must both have // the same binning. The asymmetry is calculated as (1-2)/(1+2). Error bars are // calculated using Binomial statistics. Prints a warning and rounds // any bins with non-integer contents. Use the optional parameter to // specify the confidence level in units of sigma to use for // calculating error bars. The nominal bin width specifies the // default used by addAsymmetryBin(), and is used to set the relative // normalization of bins with different widths. If not set, the // nominal bin width is calculated as range/nbins. initialize(); // copy the first input histogram's name and title SetName(data1.GetName()); SetTitle(data1.GetTitle()); // calculate our nominal bin width if necessary if(_nominalBinWidth == 0) { const TAxis *axis= ((TH1&)data1).GetXaxis(); if(axis->GetNbins() > 0) _nominalBinWidth= (axis->GetXmax() - axis->GetXmin())/axis->GetNbins(); } setYAxisLabel(Form("Asymmetry (%s - %s)/(%s + %s)", data1.GetName(),data2.GetName(),data1.GetName(),data2.GetName())); // initialize our contents from the input histogram contents Int_t nbin= data1.GetNbinsX(); if(data2.GetNbinsX() != nbin) { coutE(InputArguments) << "RooHistN::RooHistN: histograms have different number of bins" << endl; return; } for(Int_t bin= 1; bin <= nbin; bin++) { Axis_t x= data1.GetBinCenter(bin); if(fabs(data2.GetBinCenter(bin)-x)>1e-10) { coutW(InputArguments) << "RooHistN::RooHistN: histograms have different centers for bin " << bin << endl; } Stat_t y1= data1.GetBinContent(bin); Stat_t y2= data2.GetBinContent(bin); addAsymmetryBin(x,roundBin(y1),roundBin(y2),data1.GetBinWidth(bin),xErrorFrac); } // we do not have a meaningful number of entries _entries= -1; }
void EMCDistribution_ADC(bool log_scale = true) { TString gain = "RAW"; TText *t; TCanvas *c1 = new TCanvas( "EMCDistribution_ADC_" + gain + TString(log_scale ? "_Log" : "") + cuts, "EMCDistribution_ADC_" + gain + TString(log_scale ? "_Log" : "") + cuts, 1800, 1000); c1->Divide(8, 8, 0., 0.01); int idx = 1; TPad *p; for (int iphi = 8 - 1; iphi >= 0; iphi--) { for (int ieta = 0; ieta < 8; ieta++) { p = (TPad *) c1->cd(idx++); c1->Update(); if (log_scale) { p->SetLogz(); } p->SetGridx(0); p->SetGridy(0); TString hname = Form("hEnergy_ieta%d_iphi%d", ieta, iphi) + TString(log_scale ? "_Log" : ""); TH1 *h = NULL; if (log_scale) h = new TH2F(hname, Form(";Sample ID;ADC"), 31, -.5, 30.5, // 128+64, 0, 3096); 1 << 10, 0, 1 << 14); // else // h = new TH2F(hname, // Form(";Calibrated Tower Energy Sum (GeV);Count / bin"), 100, // -.050, .5,128,0,2048); h->SetLineWidth(0); h->SetLineColor(kBlue + 3); h->SetFillColor(kBlue + 3); h->GetXaxis()->SetTitleSize(.09); h->GetXaxis()->SetLabelSize(.08); h->GetYaxis()->SetLabelSize(.08); // h->GetYaxis()->SetRangeUser(2000,3000); // if (log_scale) // QAHistManagerDef::useLogBins(h->GetYaxis()); TString sdraw = "TOWER_" + gain + "_CEMC[].signal_samples[]:fmod(Iteration$,31)>>" + hname; TString scut = Form( "TOWER_%s_CEMC[].get_bineta()==%d && TOWER_%s_CEMC[].get_binphi()==%d", gain.Data(), ieta, gain.Data(), iphi); cout << "T->Draw(\"" << sdraw << "\",\"" << scut << "\");" << endl; T->Draw(sdraw, scut, "colz"); TText *t = new TText(.9, .9, Form("Col%d Row%d", ieta, iphi)); t->SetTextAlign(33); t->SetTextSize(.15); t->SetNDC(); t->Draw(); // return; } } SaveCanvas(c1, TString(_file0->GetName()) + TString("_DrawPrototype4EMCalTower_") + TString(c1->GetName()), false); }
void SetStyle(TH1& h, double size, int color, int style, int fillstyle=0, int linestyle=1){ h.SetMarkerSize(size); h.SetMarkerColor(color); h.SetLineColor(color); h.SetMarkerStyle(style); h.SetFillStyle(fillstyle); h.SetLineStyle(linestyle); h.GetXaxis()->SetTitleFont(42); h.GetYaxis()->SetTitleFont(42); h.GetXaxis()->SetTitleSize(0.048); h.GetYaxis()->SetTitleSize(0.048); h.GetXaxis()->CenterTitle(); h.GetYaxis()->CenterTitle(); }
void SetXRange(TH1 &h, double xmin, double xmax){ h.GetXaxis()->SetRangeUser(xmin,xmax); }
/*============================================================================*/ void gaus2peakfit(Char_t *s, Float_t x1, Float_t x2, Float_t x3, Float_t x4) { Double_t par[8],epar[8],x[2],y[2]; TH1 *hist; hist = (TH1 *) gROOT->FindObject(s); TCanvas *c1=(TCanvas*) gROOT->FindObject("c1"); if(c1==NULL)setcanvas(1); c1->Clear(); hist->SetAxisRange(x1-30,x4+30); hist->Draw(); //--**-- Linear background estimation --**--// x[0] = x1; x[1] = x4; Int_t bin1 = hist->FindBin(x1); y[0] = hist->GetBinContent(bin1); Int_t bin2 = hist->FindBin(x4); y[1] = hist->GetBinContent(bin2); TGraph *g = new TGraph(2,x,y); TF1 *fpol1 = new TF1("POL1","pol1",x1,x4); g->Fit(fpol1,"RQN"); par[6]=fpol1->GetParameter(0); par[7]=fpol1->GetParameter(1); //--**-- Two Gaussian Peak estimation without background --**--// fgaus1 = new TF1("m1","gaus",x1,x2); fgaus2 = new TF1("m2","gaus",x3,x4); hist->Fit(fgaus1,"R+QN"); hist->Fit(fgaus2,"R+QN"); fgaus1->GetParameters(&par[0]); fgaus2->GetParameters(&par[3]); //--**-- Final Peak Fit with Background --**--// func = new TF1("m","gaus(0)+gaus(3)+pol1(6)",x1,x4); func->SetParameters(par); hist->Fit(func,"R+QN"); func->SetLineWidth(0.5); func->SetLineStyle(1); func->SetLineColor(4); func->SetFillColor(4); func->Draw("same"); func->GetParameters(par); epar[0]=func->GetParError(0); epar[1]=func->GetParError(1); epar[2]=func->GetParError(2); epar[3]=func->GetParError(3); epar[4]=func->GetParError(4); epar[5]=func->GetParError(5); Double_t fwhm1 = par[2]*TMath::Sqrt(8*TMath::Log(2)); Double_t efwhm1 = epar[2]*TMath::Sqrt(8*TMath::Log(2)); Double_t N10 = par[0]*(TMath::Sqrt(TMath::TwoPi())*par[2]); Double_t r10 = epar[0]/par[0]; Double_t r12 = epar[2]/par[2]; Double_t eN10= N10*TMath::Sqrt(r10*r10+r12*r12); Double_t fwhm2 = par[5]*TMath::Sqrt(8*TMath::Log(2)); Double_t efwhm2 = epar[5]*TMath::Sqrt(8*TMath::Log(2)); Double_t N20 = par[3]*(TMath::Sqrt(TMath::TwoPi())*par[5]); Double_t r20 = epar[3]/par[3]; Double_t r22 = epar[5]/par[5]; Double_t eN20= N20*TMath::Sqrt(r20*r20+r22*r22); //printf("Peak = %f +- %f; FFHM = %f +- %f; Area = %f +- %f\n", // par[1],epar[1],fwhm1,efwhm1,N10,eN10); //printf("Peak = %f +- %f; FFHM = %f +- %f; Area = %f +- %f\n", // par[4],epar[4],fwhm2,efwhm2,N20,eN20); printf("%11.4f %11.4f %11.0f %11.0f\n", par[1],epar[1],N10,eN10); printf("%11.4f %11.4f %11.0f %11.0f\n", par[4],epar[4],N20,eN20); }
void CombinePreScale() { double jetptbin[] = {27, 33, 39, 47, 55, 64,74, 84, 97, 114, 133, 153, 174, 196, 220, 245, 272, 300, 429, 692, 1000}; int nbins = sizeof(jetptbin)/sizeof(double)-1; TString kDir="/scratch/xuq7/RpA/TreeAna"; TString algo ="akPu3PF"; //"AkPu3PF" ; TString residual = "NoResidual"; //"NoResidual" ; TString coll = "PPbNoGplus" ; // or "PbP" ; TString class = "HFsumEta4Bin1" ; // "" for inclusive ; TString effTab = "TrkEffHIN12017v5TrkCorr2DCut" ; //"HistIterTrkCorrtestFilterCut"; // "Trk" ; "HistIterTrkCorrtest" ; const int Nfile = 5 ; TFile * f ; TString name[]={"jetptEta","jetptphi","jetEtaphi","jetptchMax","jetptchSum","jetptneuMax","jetptneuSum","jetptphoMax","jetptphoSum","jetptchMaxpt","jetptchSumpt","jetptneuMaxpt","jetptneuSumpt","jetptphoMaxpt","jetptphoSumpt","jetptSumSumpt","jetptSumSumrawpt","jetptneuMaxr","jetptchN","jetptneuN","jetptphoN"}; TString etaname[]={"jetpt","rawptJES","jetptchMaxpt","jetptneuMaxr","jetptSumSumpt"}; int nname=sizeof(name)/sizeof(TString); int netaname=sizeof(etaname)/sizeof(TString); f = TFile::Open(Form("%s/AllTrigLumiDATAPPb%sDiJetMass.root",kDir.Data(),algo.Data()),"readonly"); TString outname ; outname ="Datacombined.root"; TFile * outf = new TFile(Form("%s/%s", kDir.Data(), outname.Data()), "RECREATE"); // f = TFile::Open("AllTrigLumiDATAPPbakPu3PFDiJetMass.root", "readonly"); for(int m=0;m<nname;m++){ TH1 *hCombined; TH1 *hTrkPt[5]; hTrkPt[0] = (TH1*)f->Get(Form("Jet20%s_0-100%%",name[m].Data())); hTrkPt[1] = (TH1*)f->Get(Form("Jet40%s_0-100%%",name[m].Data())); hTrkPt[2] = (TH1*)f->Get(Form("Jet60%s_0-100%%",name[m].Data())); hTrkPt[3] = (TH1*)f->Get(Form("Jet80%s_0-100%%",name[m].Data())); hTrkPt[4] = (TH1*)f->Get(Form("Jet100%s_0-100%%",name[m].Data())); for( int i = 0; i<5; i++) { if(i==0){ hCombined = (TH1*)hTrkPt[i]->Clone(Form("%sCombinedSpectra",name[m].Data())); hCombined->SetTitle(""); } else hCombined->Add(hTrkPt[i]); } hCombined->Write(); } double etaMin[8] = {-1.,-2.2,-1.2,-0.7,-0.3,0.3,0.7,1.2}; double etaMax[8] = { 1.,-1.2,-0.7,-0.3, 0.3,0.7,1.2,2.2}; TH1* hTrk[8][5]; TH1* hCombinedEtaBin[8]; for(int m=0;m<netaname;m++){ for(int ieta=0; ieta<8; ieta++){ if(ieta==0){ hTrk[ieta][0] = (TH1*)f->Get(Form("Jet20%s_0-100%%",etaname[m].Data())); hTrk[ieta][1] = (TH1*)f->Get(Form("Jet40%s_0-100%%",etaname[m].Data())); hTrk[ieta][2] = (TH1*)f->Get(Form("Jet60%s_0-100%%",etaname[m].Data())); hTrk[ieta][3] = (TH1*)f->Get(Form("Jet80%s_0-100%%",etaname[m].Data())); hTrk[ieta][4] = (TH1*)f->Get(Form("Jet100%s_0-100%%",etaname[m].Data())); } else { hTrk[ieta][0] = (TH1*)f->Get(Form("Jet20%sEtaBin%.f_%.f_Cen0-100%%",etaname[m].Data(), etaMin[ieta]*10, etaMax[ieta]*10)); hTrk[ieta][1] = (TH1*)f->Get(Form("Jet40%sEtaBin%.f_%.f_Cen0-100%%",etaname[m].Data(), etaMin[ieta]*10, etaMax[ieta]*10)); hTrk[ieta][2] = (TH1*)f->Get(Form("Jet60%sEtaBin%.f_%.f_Cen0-100%%",etaname[m].Data(), etaMin[ieta]*10, etaMax[ieta]*10)); hTrk[ieta][3] = (TH1*)f->Get(Form("Jet80%sEtaBin%.f_%.f_Cen0-100%%",etaname[m].Data(), etaMin[ieta]*10, etaMax[ieta]*10)); hTrk[ieta][4] = (TH1*)f->Get(Form("Jet100%sEtaBin%.f_%.f_Cen0-100%%",etaname[m].Data(), etaMin[ieta]*10, etaMax[ieta]*10)); } for(int i = 0; i<5; i++) { if(i==0) { hCombinedEtaBin[ieta] = (TH1*)hTrk[ieta][i]->Clone(Form("%sCombinedSpectraInEtaBin%.f_%.f",etaname[m].Data(), etaMin[ieta]*10, etaMax[ieta]*10)); hCombinedEtaBin[ieta]->SetTitle(""); } else hCombinedEtaBin[ieta]->Add(hTrk[ieta][i]); } hCombinedEtaBin[ieta]->Write(); } } outf->Close();//write into a root file }
void plot_fitter_validation() { TFile* fin = new TFile("fitter_validation_cafana.root"); const int dcpCols[] = {kBlack, kRed, kGreen+2, kBlue}; const std::string dcpStrs[] = {"0", "#pi/2", "#pi", "3#pi/2"}; for(std::string hcStr: {"fhc", "rhc"}){ const std::string HCStr = (hcStr == "fhc") ? "FHC" : "RHC"; for(std::string chanStr: {"numu", "nue"}){ const std::string CHANStr = (chanStr == "numu") ? "#nu_{#mu}" : "#nu_{e}"; for(std::string hieStr: {"nh", "ih"}){ const std::string HIEStr = (hieStr == "nh") ? "NH" : "IH"; new TCanvas; for(int deltaIdx2 = 0; deltaIdx2 < 4; ++deltaIdx2){ // For neutrinos 3pi/2 is the tallest histogram, draw it first, for // antineutrinos we need pi/2 first. const int deltaIdx = (hcStr == "fhc") ? 3-deltaIdx2 : (deltaIdx2+1)%4; const std::string dcpStr = TString::Format("%gpi", deltaIdx/2.).Data(); TH1* h = (TH1*)fin->Get((chanStr+"_"+hcStr+"_"+hieStr+"_"+dcpStr).c_str()); h->SetLineColor(dcpCols[deltaIdx]); h->Draw("same"); h->SetTitle(("5 yrs "+HCStr+" "+CHANStr+" "+HIEStr).c_str()); } // end for deltaIdx TLegend* leg = new TLegend(.6, .6, .85, .85); leg->SetFillStyle(0); for(int deltaIdx = 0; deltaIdx < 4; ++deltaIdx){ TH1* dummy = new TH1F("", "", 1, 0, 1); dummy->SetLineColor(dcpCols[deltaIdx]); leg->AddEntry(dummy, ("#delta_{CP}="+dcpStrs[deltaIdx]).c_str(), "l"); } leg->Draw("same"); gPad->Print((hcStr+"_"+chanStr+"_"+hieStr+".pdf").c_str()); } // end for hieStr } // end for chanStr } // end for hcStr TGraph* gNH = (TGraph*)fin->Get("sens_nh"); TGraph* gIH = (TGraph*)fin->Get("sens_ih"); TGraph* gNHOscErr = (TGraph*)fin->Get("sens_nh_oscerr"); TGraph* gIHOscErr = (TGraph*)fin->Get("sens_ih_oscerr"); TGraph* gNHFlux[10]; TGraph* gIHFlux[10]; for(int i = 0; i < 10; ++i){ gNHFlux[i] = (TGraph*)fin->Get(TString::Format("sens_nh_flux%d", i).Data()); gIHFlux[i] = (TGraph*)fin->Get(TString::Format("sens_ih_flux%d", i).Data()); } TGraph* gNHXSec[10]; TGraph* gIHXSec[10]; for(int i = 0; i < 10; ++i){ gNHXSec[i] = (TGraph*)fin->Get(TString::Format("sens_nh_xsec%d", i).Data()); gIHXSec[i] = (TGraph*)fin->Get(TString::Format("sens_ih_xsec%d", i).Data()); } TH2* axes = new TH2F("", ";#delta_{CP} / #pi;#sigma = #sqrt{#Delta#chi^{2}}", 100, 0, 2, 100, 0, 8); axes->GetXaxis()->CenterTitle(); axes->GetYaxis()->SetTitleOffset(.75); axes->GetYaxis()->CenterTitle(); axes->Draw(); gNH->Draw("l same"); gIH->Draw("l same"); gNHOscErr->Draw("l same"); gIHOscErr->Draw("l same"); TLegend* leg = new TLegend(.4, .65, .6, .875); leg->SetFillStyle(0); leg->AddEntry(gNH, "NH", "l"); leg->AddEntry(gIH, "IH", "l"); leg->AddEntry(gNHOscErr, "NH osc err", "l"); leg->AddEntry(gIHOscErr, "IH osc err", "l"); leg->Draw(); gPad->Print("mcd.pdf"); new TCanvas; axes->Draw(); for(int i = 0; i < 10; ++i){ gNHFlux[i]->Draw("l same"); gIHFlux[i]->Draw("l same"); } gNH->Draw("l same"); gIH->Draw("l same"); leg = new TLegend(.4, .65, .6, .875); leg->SetFillStyle(0); leg->AddEntry(gNH, "NH", "l"); leg->AddEntry(gIH, "IH", "l"); leg->AddEntry(gNHFlux[0], "NH flux err", "l"); leg->AddEntry(gIHFlux[0], "IH flux err", "l"); leg->Draw(); gPad->Print("mcd_flux.pdf"); new TCanvas; axes->Draw(); for(int i = 0; i < 10; ++i){ gNHXSec[i]->Draw("l same"); gIHXSec[i]->Draw("l same"); } gNH->Draw("l same"); gIH->Draw("l same"); leg = new TLegend(.4, .65, .6, .875); leg->SetFillStyle(0); leg->AddEntry(gNH, "NH", "l"); leg->AddEntry(gIH, "IH", "l"); leg->AddEntry(gNHXSec[0], "NH xsec err", "l"); leg->AddEntry(gIHXSec[0], "IH xsec err", "l"); leg->Draw(); gPad->Print("mcd_xsec.pdf"); }
/*============================================================================*/ void gaus1peakfit(Char_t *s, Float_t x1, Float_t x2, Float_t x3, Float_t x4) { Double_t par[5],epar[5],x[4],y[4]; TH1 *hist; hist = (TH1 *) gROOT->FindObject(s); setcanvas(1); TCanvas *c1=(TCanvas*) gROOT->FindObject("c1"); if(c1==NULL)setcanvas(1); c1->Clear(); hist->SetAxisRange(x1-30,x4+30); hist->Draw(); //--**-- Linear background estimation --**--// x[0] = x1; x[1] = x2; x[2] = x3; x[3] = x4; Int_t bin1 = hist->FindBin(x1); y[0] = hist->GetBinContent(bin1); Int_t bin2 = hist->FindBin(x2); y[1] = hist->GetBinContent(bin2); Int_t bin3 = hist->FindBin(x3); y[2] = hist->GetBinContent(bin3); Int_t bin4 = hist->FindBin(x4); y[3] = hist->GetBinContent(bin4); TGraph *g = new TGraph(4,x,y); TF1 *fpol1 = new TF1("POL1","pol1",x1,x4); g->Fit(fpol1,"RQN"); par[3]=fpol1->GetParameter(0); par[4]=fpol1->GetParameter(1); //--**-- Gaussian Peak estimation without background --**--// TF1 *fgaus = new TF1("GAUS","gaus",x2,x3); hist->Fit(fgaus,"RQN"); fgaus->GetParameters(&par[0]); //--**-- Final Peak Fit with Background --**--// TF1 *func = new TF1("FGAUS","gaus(0)+pol1(3)",x1,x4); func->SetParameters(par); hist->Fit(func,"R+QN"); func->GetParameters(par); epar[0]=func->GetParError(0); epar[1]=func->GetParError(1); epar[2]=func->GetParError(2); Double_t fwhm = par[2]*TMath::Sqrt(8*TMath::Log(2)); Double_t efwhm = epar[2]*TMath::Sqrt(8*TMath::Log(2)); Double_t N0 = par[0]*(TMath::Sqrt(TMath::TwoPi())*par[2]); Double_t r0 = epar[0]/par[0]; Double_t r2 = epar[2]/par[2]; Double_t eN0= N0*TMath::Sqrt(r0*r0+r2*r2); printf("Peak = %f +- %f; FFHM = %f +- %f; Area = %f +- %f\n", par[1],epar[1],fwhm,efwhm,N0,eN0); //printf("%11.4f %11.4f %11.0f %11.0f\n", // par[1],epar[1],N0,eN0); func->SetLineWidth(0.5); func->SetLineStyle(1); func->SetLineColor(4); func->SetFillColor(4); func->Draw("same"); }
void gluinoMass(double lumi=-1., double maxInstLumi=-1.) { if (lumi<0) lumi=877.; if (maxInstLumi<0) maxInstLumi=1300.; LimitPlots plots(lumi); //mchamp index 0 is used, corresponds to 0th mass point = 100 GeV plots.calculateCrossSections(7,4,0,39,9); // expected limit (1 and 2 sigma bands) TGraph* g_exp = plots.getExpMassLimitGluino(); TGraphAsymmErrors* g_exp1 = plots.getExpMassLimitGluino1Sig(); TGraphAsymmErrors* g_exp2 = plots.getExpMassLimitGluino2Sig(); // three points on counting expt curve TGraph* g_gluino = plots.getMassLimitGluino(); TGraph* g_stop = plots.getMassLimitStop(); // one point from lifetime fit TGraph* g_tp = plots.getMassLimitGluinoTP(); // theory prediction TGraph* g_thGluino = plots.getGluinoTheory(); TGraph* g_thStop = plots.getStopTheory(); TCanvas* canvas = new TCanvas("canvas"); //canvas->SetGrid(); canvas->SetLogy(); TH1 * h; h = canvas->DrawFrame(300., .02, 1000., 1e2); //h->SetTitle("Beamgap Expt;m_{#tilde{g}} [GeV/c^{2}]; Stopped HSCP Cross Section #times BR [pb]"); h->SetTitle("Beamgap Expt;m_{#tilde{g}} [GeV/c^{2}]; #sigma(pp #rightarrow #tilde{g}#tilde{g}) #times BR(#tilde{g} #rightarrow g#tilde{#chi}^{0}) [pb]"); // not covered region TBox* nc = new TBox(100., .1, 150., 5e2); nc->SetFillStyle(3354); nc->SetFillColor(kRed-4); //nc->Draw(); // details TPaveText* blurb = new TPaveText(300., 2, 550., 1e2); blurb->AddText("CMS Preliminary 2012"); std::stringstream label; label<<"#int L dt = "<<lumi<<" fb^{-1}"; blurb->AddText(label.str().c_str()); label.str(""); double peakInstLumi=maxInstLumi; int exponent=30; while (peakInstLumi>10) { peakInstLumi/=10.; ++exponent; } label<<"L^{max}_{inst} = "<<peakInstLumi<<" x 10^{"<<exponent<<"} cm^{-2}s^{-1}"; blurb->AddText(label.str().c_str()); label.str(""); label << "#sqrt{s} = " << ENERGY << " TeV"; blurb->AddText(label.str().c_str()); blurb->AddText("m_{#tilde{g}} - m_{#tilde{#chi}^{0}} = 100 GeV/c^{2}"); //blurb->AddText("m_{#tilde{t}} - m_{#tilde{#chi}^{0}} = 200 GeV/c^{2}"); blurb->SetTextFont(42); blurb->SetBorderSize(0); blurb->SetFillColor(0); blurb->SetShadowColor(0); blurb->SetTextAlign(12); blurb->SetTextSize(0.032); // legend TBox *legbg = new TBox(600., 2., 900., 1e2); legbg->Draw(); TLegend *leg = new TLegend(600., 2., 900., 1e2,"95% C.L. Limits",""); leg->SetTextSize(0.028); leg->SetBorderSize(0); leg->SetTextFont(42); leg->SetFillColor(0); leg->AddEntry(g_exp, "Expected: 10 #mus - 1000 s Counting Exp. ", "l"); leg->AddEntry(g_exp1, "Expected #pm1#sigma: 10 #mus - 1000 s Counting Exp. ", "f"); leg->AddEntry(g_exp2, "Expected #pm2#sigma: 10 #mus - 1000 s Counting Exp. ", "f"); // leg->AddEntry(graph3, "Obs.: 10^{6} s Counting Exp.", "l"); leg->AddEntry(g_gluino, "Obs.: 10 #mus - 1000 s Counting Exp. ", "l"); leg->AddEntry(g_tp, "Obs.: 10 #mus Timing Profile ", "l"); //leg->AddEntry(g_stop, "Obs.: 10 #mus - 1000 s Counting Exp. (#tilde{t})", "l"); //leg->AddEntry(graph_em, "Obs.: 10 #mus - 1000 s Counting Exp. (EM only)", "l"); // leg->AddEntry(graph1, "Obs.: 570 ns Counting Exp.", "l"); leg->Draw(); // 2 sigma expected band g_exp2->SetLineColor(0); g_exp2->SetLineStyle(0); g_exp2->SetLineWidth(0); g_exp2->SetFillColor(5); g_exp2->SetFillStyle(1001); g_exp2->Draw("3"); // 1 sigma expected band g_exp1->SetLineColor(0); g_exp1->SetLineStyle(0); g_exp1->SetLineWidth(0); g_exp1->SetFillColor(3); g_exp1->SetFillStyle(1001); g_exp1->Draw("3"); // expected line g_exp->SetLineStyle(2); g_exp->SetLineWidth(1); g_exp->Draw("l"); // plateau limit - 1 ms g_gluino->SetLineColor(1); g_gluino->SetLineStyle(1); g_gluino->SetLineWidth(2); g_gluino->Draw("l"); // stop curve g_stop->SetLineColor(1); g_stop->SetLineStyle(5); g_stop->SetLineWidth(2); //g_stop->Draw("l"); // 1 mus lifetime fit limit g_tp->SetLineColor(kRed); g_tp->SetLineStyle(1); g_tp->SetLineWidth(2); g_tp->Draw("l"); // theory line g_thGluino->SetLineColor(kBlue); g_thGluino->SetLineStyle(1); g_thGluino->SetLineWidth(2); g_thGluino->SetFillStyle(3001); g_thGluino->SetFillColor(kBlue-4); g_thGluino->Draw("l3"); g_thStop->SetLineColor(kRed); g_thStop->SetLineStyle(1); g_thStop->SetLineWidth(2); g_thStop->SetFillStyle(3001); g_thStop->SetFillColor(kRed-4); //g_thStop->Draw("l3"); // theory line label TLatex* th = new TLatex(600., .3, "NLO+NLL #tilde{g}"); th->SetTextColor(kBlue); th->SetTextFont(42); th->SetTextSize(0.035); th->Draw(); TLatex* ths = new TLatex(330., 2., "NLO+NLL #tilde{t}"); ths->SetTextColor(kRed); ths->SetTextFont(42); ths->SetTextSize(0.035); //ths->Draw(); // not explored label TText* ne = new TText(125., .2, "Not Sensitive"); ne->SetTextColor(kRed+1); ne->SetTextFont(42); ne->SetTextAngle(90); ne->SetTextSize(0.035); //ne->Draw(); blurb->Draw(); canvas->RedrawAxis(); canvas->Print("gluinoMassLimit.pdf"); canvas->Print("gluinoMassLimit.C"); plots.calculateIntercepts(); }
void makeSplitQCDhist_PythiaBinned(vector<string> folders, const string histname, const string htrange, const string htbinlabel, const hist_t histinfo) { const float scaleTo = fDATA_LUMI; // pb TLegend *leg = new TLegend(0.6,0.65,0.9,0.9); leg->SetTextFont(42); vector<TH1*> hists; new TCanvas(); gPad->SetLogy(); gPad->SetTickx(); gPad->SetTicky(); stringstream title; title << htrange << " [" << histinfo.name << "];" << histinfo.title; cout << title.str() << endl; TH1* Hist = GetHist(histname); Hist->SetTitle(title.str().c_str()); Hist->SetMarkerStyle(20); Hist->SetStats(0); Hist->Rebin(histinfo.rebin); Hist->Draw("P"); /* for (unsigned i = 0; i < folders.size(); ++i) { string njet(""); if (i==0) njet += "[2-3]"; else if (i==1) njet += "[4-5]"; else if (i==2) njet += "[6-7]"; else if (i==3) njet += "#geq 8"; */ /*if (i==0) njet += "3"; else if (i==1) njet += "4"; else if (i==2) njet += "5"; else if (i==3) njet += "6"; else if (i==4) njet += "7"; else if (i==5) njet += "8";*/ /* stringstream title, histName; title << htrange << ";" << histinfo.title; cout << title.str() << endl; histName << folders.at(i) << "/" << histname;; hists.push_back(GetHist(histName.str())); hists.at(i)->SetTitle(title.str().c_str()); hists.at(i)->SetMarkerStyle(20+i); hists.at(i)->SetMarkerColor(1+i*2); hists.at(i)->SetStats(0); hists.at(i)->Rebin(histinfo.rebin); if (histinfo.normalizeByBinWidth) NormByBinWidth(hists.at(i)); stringstream legname; legname << "Njets " << njet; leg->AddEntry(hists.at(i), legname.str().c_str()); if (i==0) hists.at(i)->Draw("P"); else hists.at(i)->Draw("same P"); } leg->Draw(); */ }
Double_t TTimeHists::Check(EHist hist) { // Check bin content of all bins Double_t check = 0.; Int_t* x = new Int_t[fDim]; memset(x, 0, sizeof(Int_t) * fDim); if (hist == kHist) { Long_t idx = 0; Long_t size = 1; for (Int_t d = 0; d < fDim; ++d) size *= (fBins + 2); while (x[0] <= fBins + 1) { Double_t v = -1.; if (fDim < 4) { Long_t histidx = x[0]; if (fDim == 2) histidx = fHist->GetBin(x[0], x[1]); else if (fDim == 3) histidx = fHist->GetBin(x[0], x[1], x[2]); v = fHist->GetBinContent(histidx); } else v = fHn->GetBinContent(x); Double_t checkx = 0.; if (v) for (Int_t d = 0; d < fDim; ++d) checkx += x[d]; check += checkx * v; if (fgDebug > 2 || (fgDebug > 1 && v)) { printf("%s%d", fDim < 4 ? "hist" : "arr", fDim); for (Int_t d = 0; d < fDim; ++d) printf("[%d]", x[d]); printf(" = %g\n", v); } ++x[fDim - 1]; // Adjust the bin idx // no wrapping for dim 0 - it's what we break on! for (Int_t d = fDim - 1; d > 0; --d) { if (x[d] > fBins + 1) { x[d] = 0; ++x[d - 1]; } } ++idx; } // while next bin } else { for (Long64_t i = 0; i < fSparse->GetNbins(); ++i) { Double_t v = fSparse->GetBinContent(i, x); Double_t checkx = 0.; for (Int_t d = 0; d < fDim; ++d) checkx += x[d]; check += checkx * v; if (fgDebug > 1) { printf("sparse%d", fDim); for (Int_t d = 0; d < fDim; ++d) printf("[%d]", x[d]); printf(" = %g\n", v); } } } check /= fNum; if (fgDebug > 0) printf("check %s%d = %g\n", hist == kHist ? (fDim < 4 ? "hist" : "arr") : "sparse", fDim, check); return check; }
void BasePlotter::writeStacked(string filename, const HistogramContainer& histContainer, string extension) const { // Check histContainer consistency if( ! histContainer.check() ) throw 1; if( extension[0] == '.' ) extension.erase(0,1); if( filename.find(".root") == string::npos ) filename.append( ".root" ); system(("mkdir -p " + configContainer.outputDir).c_str()); TFile* f = new TFile((configContainer.outputDir + filename).c_str(), "UPDATE"); unsigned int nSamples = histContainer.reducedNames.size(); TCanvas *c = new TCanvas(("Canv_stacked_" + histContainer.containerName).c_str(), "", 600, 600 + (120 * configContainer.plotRatio)); TPad *histPad=nullptr, *ratioPad=nullptr; if( configContainer.plotRatio || configContainer.plotSignificance ) { histPad = new TPad("pad1", "pad1", 0, 0.25, 1, 1); histPad->Draw(); ratioPad = new TPad("pad2", "pad2", 0, 0, 1, 0.3); ratioPad->Draw(); histPad->cd(); } TLegend* leg = nullptr; vector<TLatex*> latexVector; setCanvasAttributes( nSamples, leg, latexVector); vector<TH1F*> hStack; TH1* hData = nullptr, *hSignal = nullptr; // Add backgrounds to stack for( int iSample = nSamples-1; iSample > -1; --iSample ) { if( histContainer.sampleType[iSample] == SampleType::MC || histContainer.sampleType[iSample] == SampleType::FAKELEPTON || histContainer.sampleType[iSample] == SampleType::MCFAKELEPTON ) { TH1F *temp = (TH1F*) histContainer.histograms[iSample]->Clone(("stack_hist_"+histContainer.reducedNames[iSample]).c_str()); if( hStack.size() > 0 ) temp->Add(hStack[hStack.size()-1]); temp->SetLineColor(histContainer.color[iSample]); temp->SetFillColor(histContainer.color[iSample]); temp->SetFillStyle(1001); hStack.push_back(temp); string legendEntry = histContainer.reducedNames[iSample]; replace(legendEntry.begin(), legendEntry.end(), '_', ' '); leg->AddEntry(temp,legendEntry.c_str(),"f"); } } // Add signal to stack for( unsigned int iSample = 0; iSample < nSamples; ++iSample ) { if( histContainer.sampleType[iSample] == SampleType::SIGNAL ) { hSignal = histContainer.histograms[iSample]; hSignal->SetLineColor(histContainer.color[iSample]); string legendEntry = histContainer.reducedNames[iSample]; replace(legendEntry.begin(), legendEntry.end(), '_', ' '); if( configContainer.signalStacked ) { TH1F *temp = (TH1F*) histContainer.histograms[iSample]->Clone(("stack_hist_"+histContainer.reducedNames[iSample]).c_str()); if( hStack.size() > 0 ) temp->Add(hStack[hStack.size()-1]); temp->SetFillColor(histContainer.color[iSample]); temp->SetFillStyle(1001); hStack.push_back(temp); leg->AddEntry(temp,legendEntry.c_str(),"f"); } else { hSignal->SetLineWidth(2); leg->AddEntry(hSignal,legendEntry.c_str(),"l"); } } } // Add data for( unsigned int iSample = 0; iSample < nSamples; ++iSample ) { if( histContainer.sampleType[iSample] == SampleType::DATA && configContainer.unblind ) { histContainer.histograms[iSample]->SetLineColor(histContainer.color[iSample]); histContainer.histograms[iSample]->SetMarkerColor(histContainer.color[iSample]); histContainer.histograms[iSample]->SetMarkerSize(1); histContainer.histograms[iSample]->SetMarkerStyle(20); histContainer.histograms[iSample]->SetLineWidth(2); string legendEntry = histContainer.reducedNames[iSample]; replace(legendEntry.begin(), legendEntry.end(), '_', ' '); leg->AddEntry(histContainer.histograms[iSample],legendEntry.c_str(),"lp"); hData = histContainer.histograms[iSample]; } } // Set y-range float hMax = 0.; float hMin = 0.; bool maxMakesSense = true; if( configContainer.drawNormalized ) hMax = 1; else { if ( hStack.size() > 0 ) hMax = getMaximumIncludingErrors(hStack[hStack.size()-1]); if ( hData ) hMax = max( getMaximumIncludingErrors(hData) , hMax ); if ( hSignal ) hMax = max( getMaximumIncludingErrors(hSignal) , hMax ); } // Check consistency (for efficiency plot with fixed axis) if( histContainer.axisRanges.size() > 0 && hMax > histContainer.axisRanges[1] ) maxMakesSense = false; if( configContainer.logY ) { c->SetLogy(1); hMin = 0.05; hMax *= 500; } else hMax *= 1.55; if( histContainer.axisRanges.size() > 0 ) { if( maxMakesSense && (!configContainer.drawNormalized) ) { hMin = histContainer.axisRanges[0]; hMax = histContainer.axisRanges[1]; } else { cout << "Maximum range is too small for: " << histContainer.containerName << ". Set to default.\n"; } } // Draw stack for( int iHist = hStack.size()-1; iHist > -1; --iHist ) { if( configContainer.drawNormalized ) { hStack[iHist]->Scale(1./hStack[iHist]->Integral()); hStack[iHist]->GetYaxis()->SetRangeUser(hMin, getMaximumIncludingErrors(hStack[iHist])*1.5); } else hStack[iHist]->GetYaxis()->SetRangeUser(hMin, hMax); hStack[iHist]->Draw("hist same"); } // Draw uncertainty TH1F* hErr; if( configContainer.drawUncertainty && hStack.size() > 0 ) { hErr = (TH1F*) hStack[hStack.size()-1]->Clone("uncertainty") ; hErr->SetFillColor(15); hErr->SetLineColor( 0); hErr->SetFillStyle(3445); hErr->SetMarkerSize(0); // hErr->SetMarkerColor(kBlack); hErr->Draw("e2 same"); // leg->AddEntry( hErr , TString(" stat.#oplussyst.") , "f"); leg->AddEntry( hErr , TString("stat. error") , "f"); } // Draw signal if( hSignal && !configContainer.signalStacked ) { if( configContainer.drawNormalized ) { hSignal->Scale(1./hSignal->Integral()); hSignal->GetYaxis()->SetRangeUser(hMin, getMaximumIncludingErrors(hSignal)*1.5); } else hSignal->GetYaxis()->SetRangeUser(hMin, hMax); hSignal->Draw("e same"); } // Draw data if( hData ) { if( configContainer.drawNormalized ) { hData->Scale(1./hData->Integral()); hData->GetYaxis()->SetRangeUser(hMin, getMaximumIncludingErrors(hData)*1.5); } else hData->GetYaxis()->SetRangeUser(hMin, hMax); hData->Draw("e same"); } // Draw legend leg->Draw(); for( auto* text : latexVector ) { text->Draw("same"); } // Redraw axis gPad->RedrawAxis(); // Draw Ratio plot if( configContainer.plotRatio && hStack.size() > 0 && (hData || (hSignal && !configContainer.signalStacked)) ) { ratioPad->cd(); TH1F* hRatio; if( hData ) { hRatio = (TH1F*) hData->Clone("ratio"); hRatio->GetYaxis()->SetTitle("Data / MC"); } else { hRatio = (TH1F*) hSignal->Clone("ratio"); hRatio->GetYaxis()->SetTitle("Signal / Background"); } // if( configContainer.signalStacked || !hData ) // hRatio->Divide(hStack[hStack.size()-1]); // else // { TH1F* hAllMC = (TH1F*) hStack[hStack.size()-1]->Clone("allMC"); // hAllMC->Add( hSignal ); hRatio->Divide(hAllMC); // } hRatio->GetYaxis()->SetRangeUser(0, 2); hRatio->Draw("ep"); hRatio->GetXaxis()->SetTitle(""); TLine *line = new TLine(hRatio->GetXaxis()->GetXmin(),1,hRatio->GetXaxis()->GetXmax(),1); line->SetLineStyle(3); line->Draw(); // Print global ratio if( hData ) cout << "Data / MC: " << hData->Integral()/hStack[hStack.size()-1]->Integral() << endl; else cout << "Signal / Background: " << hSignal->Integral()/hStack[hStack.size()-1]->Integral() << endl; } //Draw significance plot if( configContainer.plotSignificance && !configContainer.plotRatio && hStack.size() > 0 && hSignal && !configContainer.signalStacked ) { ratioPad->cd(); TH1F* hRatio = (TH1F*) hSignal->Clone("ratio"); hRatio->GetYaxis()->UnZoom(); unsigned int nBins = hRatio->GetNbinsX(); for( unsigned int iBin = 1; iBin <= nBins; ++iBin ) { float denom = sqrt(hRatio->GetBinContent(iBin)+hStack[hStack.size()-1]->GetBinContent(iBin)); if( denom > 0 ) { hRatio->SetBinContent(iBin, hRatio->GetBinContent(iBin)/denom); float S = hSignal->GetBinContent(iBin), B = hStack[hStack.size()-1]->GetBinContent(iBin); hRatio->SetBinError(iBin, sqrt( pow(S/2./pow(B+S,1.5),2) * pow(hSignal->GetBinError(iBin),2) + pow((B+S/2.)/pow(B+S,1.5),2) * pow(hStack[hStack.size()-1]->GetBinError(iBin),2)) ); } else { hRatio->SetBinContent(iBin, 0); hRatio->SetBinError(iBin, 0); } } // hRatio->GetYaxis()->SetRangeUser(0, 2); hRatio->Draw("ep"); hRatio->GetYaxis()->SetTitle("S / #sqrt{S+B}"); hRatio->GetXaxis()->SetTitle(""); } // Redraw axis gPad->RedrawAxis(); c->Print((configContainer.outputDir + histContainer.containerName + "." + extension).c_str(), extension.c_str()); cout << "Wrote plot " << (histContainer.containerName + "." + extension) << endl; c->Write(); f->Close(); }
// input: - Input file (result from TMVA) // - use of TMVA plotting TStyle void deviations( TString fin = "TMVAReg.root", HistType htype = MVAType, Bool_t showTarget, Bool_t useTMVAStyle = kTRUE ) { // set style and remove existing canvas' TMVAGlob::Initialize( useTMVAStyle ); gStyle->SetNumberContours(999); // switches const Bool_t Save_Images = kTRUE; // checks if file with name "fin" is already open, and if not opens one TFile* file = TMVAGlob::OpenFile( fin ); // define Canvas layout here! Int_t xPad = 1; // no of plots in x Int_t yPad = 1; // no of plots in y Int_t noPad = xPad * yPad ; const Int_t width = 650; // size of canvas // this defines how many canvases we need TCanvas* c[100]; // counter variables Int_t countCanvas = 0; // search for the right histograms in full list of keys // TList* methods = new TMap(); TIter next(file->GetListOfKeys()); TKey *key(0); while ((key = (TKey*)next())) { if (!TString(key->GetName()).BeginsWith("Method_")) continue; if (!gROOT->GetClass(key->GetClassName())->InheritsFrom("TDirectory")) continue; TString methodName; TMVAGlob::GetMethodName(methodName,key); cout << "--- Plotting deviation for method: " << methodName << endl; TObjString *mN = new TObjString( methodName ); TDirectory* mDir = (TDirectory*)key->ReadObj(); TList* jobNames = new TList(); TIter keyIt(mDir->GetListOfKeys()); TKey *titkey; while ((titkey = (TKey*)keyIt())) { if (!gROOT->GetClass(titkey->GetClassName())->InheritsFrom("TDirectory")) continue; TDirectory *titDir = (TDirectory *)titkey->ReadObj(); TObjString *jN = new TObjString( titDir->GetName() ); if (!jobNames->Contains( jN )) jobNames->Add( jN ); else delete jN; TString methodTitle; TMVAGlob::GetMethodTitle(methodTitle,titDir); TString hname = "MVA_" + methodTitle; TIter dirKeyIt( titDir->GetListOfKeys() ); TKey* dirKey; Int_t countPlots = 0; while ((dirKey = (TKey*)dirKeyIt())){ if (dirKey->ReadObj()->InheritsFrom("TH2F")) { TString s(dirKey->ReadObj()->GetName()); if (s.Contains("_reg_") && ( (showTarget && s.Contains("_tgt")) || (!showTarget && !s.Contains("_tgt")) ) && s.Contains( (htype == CompareType ? "train" : "test" ))) { c[countCanvas] = new TCanvas( Form("canvas%d", countCanvas+1), Form( "Regression output deviation versus %s for method: %s", (showTarget ? "target" : "input variables"), methodName.Data() ), countCanvas*50+100, (countCanvas+1)*20, width, (Int_t)width*0.72 ); c[countCanvas]->SetRightMargin(0.10); // leave space for border TH1* h = (TH1*)dirKey->ReadObj(); h->SetTitle( Form("Output deviation for method: %s (%s sample)", hname.Data(), (htype == CompareType ? "training" : "test" )) ); // methodName.Data(), (htype == CompareType ? "training" : "test" )) ); h->Draw("colz"); TLine* l = new TLine( h->GetXaxis()->GetXmin(), 0, h->GetXaxis()->GetXmax(), 0 ); l->SetLineStyle(2); l->Draw(); // update and print cout << "plotting logo" << endl; TMVAGlob::plot_logo(1.058); c[countCanvas]->Update(); TString fname = Form( "plots/deviation_%s_%s_%s_c%i", methodName.Data(), (showTarget ? "target" : "vars"), (htype == CompareType ? "training" : "test" ), countPlots ); TMVAGlob::imgconv( c[countCanvas], fname ); countPlots++; countCanvas++; } } } } } }
// Main function to create the pdf's int main(int argc, char**argv){ TString version = "80X"; // Define binning for pdfs (details and more options in binningConfigurations.h) binClass bins; if(version.Contains("v2")) bins = getV2Binning(); if(version.Contains("80X")) bins = get76XBinning(); else return 1; // For different jet types (if _antib is added bTag is applied) for(TString jetType : {"AK4chs","AK4chs_antib"}){ //,"AK4","AK4_antib"}){ std::cout << "Building pdf's for " << jetType << "..." << std::endl; treeLooper t("QCD_AllPtBins", jetType); // Init tree (third argument is the directory path, if other than default in treeLooper.h) bins.setReference("pt", &t.pt); // Give the binning class a pointer to the variables used to bin in bins.setReference("eta", &t.eta); bins.setReference("rho", &t.rho); // Creation of the pdfs std::map<TString, TH1D*> pdfs; for(TString binName : bins.getAllBinNames()){ for(TString type : {"quark","gluon"}){ TString histName = "_" + type + "_" + binName; pdfs["axis2" + histName] = new TH1D("axis2" + histName, "axis2" + histName, 100, 0, 8); // Has been 200 bins before, but seemed to have a bit too much fluctuations still pdfs["mult" + histName] = new TH1D("mult" + histName, "mult" + histName, 140, 2.5, 142.5); pdfs["ptD" + histName] = new TH1D("ptD" + histName, "ptD" + histName, 100, 0, 1); // Also 200 before } } // Fill pdfs TString binName; while(t.next()){ if(!bins.getBinName(binName)) continue; // Find bin and return false if outside ranges if(t.jetIdLevel < 3) continue; // Select tight jets if(!t.matchedJet) continue; // Only matched jets if(t.nGenJetsInCone != 1 || t.nJetsForGenParticle != 1 || t.nGenJetsForGenParticle != 1) continue; // Use only jets matched to exactly one gen jet and gen particle, and no other jet candidates if((fabs(t.partonId) > 3 && t.partonId != 21)) continue; // Keep only udsg if(t.bTag) continue; // Anti-b tagging (always false if jetType does not contain "antib") if(!t.balanced) continue; // Take only two leading jets with pt3 < 0.15*(pt1+pt2) (surpresses small radiated jets with pt <<< pthat) if(t.mult < 3) continue; // Avoid jets with less than 3 particles (otherwise axis2=0) TString type = (t.partonId == 21? "gluon" : "quark"); // Define q/g TString histName = "_" + type + "_" + binName; pdfs["axis2" + histName]->Fill(t.axis2, t.weight); // "axis2" already contains the log pdfs["mult" + histName]->Fill(t.mult, t.weight); pdfs["ptD" + histName]->Fill(t.ptD, t.weight); } // Try to add statistics from neighbours (first make copy, so you don't get an iterative effect) std::map<TString, TH1D*> pdfsCopy; for(auto& pdf : pdfs) pdfsCopy[pdf.first] = (TH1D*) pdf.second->Clone(pdf.first + "clone"); for(TString binName : bins.getAllBinNames()){ for(TString var : {"axis2","mult","ptD"}){ for(TString neighbour : bins.getNeighbourBins(binName, var)){ // If neighbours are defined: add their statistics for(TString type : {"quark","gluon"}){ pdfs[var + "_" + type + "_" + binName]->Add(pdfsCopy[var + "_" + type + "_" + neighbour]); } } } } for(auto& copy : pdfsCopy) delete copy.second; // Store the mean and RMS of the original histogram (because they could be changed by rebinning operations) std::map<TString, float> mean; std::map<TString, float> rms; for(auto& pdf : pdfs){ if(pdf.second->GetEntries() == 0){ std::cout << "Error: no entries in " << pdf.first << std::endl; exit(1);} // Force to exit when no entries in pdfs: the binning configuration should be altered to avoid this mean[pdf.first] = pdf.second->GetMean(); rms[pdf.first] = pdf.second->GetRMS(); } // Check "smoothness" of the pdf: if fluctuations seem really big, we do a rebinning std::map<TString, int> rebinFactor; for(auto& pdf : pdfs){ bool isBelow = (mean[pdf.first] < mean[switchQG(pdf.first)]); // Define region between low(meanQ, meanG) - RMS <--> high(meanQ, meanG) + RMS TString low = isBelow? pdf.first : switchQG(pdf.first); // Most events will be within those borders, so we should not allow empty bins here TString high = isBelow? switchQG(pdf.first) : pdf.first; // (an empty bin for 1 of the three variables already results in L = 0 or 1) int leftBin = pdf.second->FindBin(mean[low] - rms[low]) - 1; int rightBin = pdf.second->FindBin(mean[high] + rms[high]) + 1; int leftBin2 = 0; // Define region of the peak: most extreme bins which exceed 80% of the maximum int rightBin2 = 0; // We will check for bins within this region which go below 70% for(int bin = 1; bin < pdf.second->GetNbinsX(); ++bin){ // In such cases the fluctuations are really high and a larger bin width is preferred if(pdf.second->GetBinContent(bin) > pdf.second->GetMaximum()*0.8){ // (Maybe the thresholds could still be optimized a bit more though) if(!leftBin2) leftBin2 = bin; else rightBin2 = bin; } } int leftBin3 = 0; // Define region of the peak: most extreme bins which exceed 90% of the maximum int rightBin3 = 0; // We will check for bins within this region which go below 80% for(int bin = 1; bin < pdf.second->GetNbinsX(); ++bin){ // In such cases the fluctuations are really high and a larger bin width is preferred if(pdf.second->GetBinContent(bin) > pdf.second->GetMaximum()*0.9){ // (Maybe the thresholds could still be optimized a bit more though) if(!leftBin3) leftBin3 = bin; else rightBin3 = bin; } } int emptyBins = 0; int maxEmptyBins = 0; for(int bin = 1; bin < pdf.second->GetNbinsX(); ++bin){ if( bin >= leftBin && bin <= rightBin && pdf.second->GetBinContent(bin) <= 0) ++emptyBins; else if(bin >= leftBin2 && bin <= rightBin2 && pdf.second->GetBinContent(bin) <= pdf.second->GetMaximum()*0.7) ++emptyBins; else if(bin >= leftBin3 && bin <= rightBin3 && pdf.second->GetBinContent(bin) <= pdf.second->GetMaximum()*0.8) ++emptyBins; else { if(emptyBins > maxEmptyBins) maxEmptyBins = emptyBins; emptyBins = 0; } } rebinFactor[pdf.first] = std::max(maxEmptyBins, emptyBins); } for(auto& pdf : pdfs) rebinFactor[pdf.first] = std::max(rebinFactor[pdf.first], rebinFactor[switchQG(pdf.first)]); // Use same rebin factor in quark and gluon pdf (otherwise bias if second derivate of pdf is non-zero) for(auto& pdf : pdfs){ if(rebinFactor[pdf.first] > 19) std::cout << "This pdf has a lot of emtpy bins and fluctuations:" << std::endl; if(rebinFactor[pdf.first] > 9) rebin(pdf.second, 20); else if(rebinFactor[pdf.first] > 4) rebin(pdf.second, 10); else if(rebinFactor[pdf.first] > 3) rebin(pdf.second, 5); else if(rebinFactor[pdf.first] > 1) rebin(pdf.second, 4); else if(rebinFactor[pdf.first] > 0) rebin(pdf.second, 2); } // Normalization of the pdf's for(auto& pdf : pdfs) pdf.second->Scale(1./pdf.second->Integral(0, pdf.second->GetNbinsX() + 1)); // Scale to integral=1 (also include underflow/overflow) // Try to average out leftover fluctuations and empty bins for(auto& pdf : pdfs){ if(pdf.first.Contains("gluon")) continue; TH1* tempQ = (TH1*) pdf.second->Clone(); TH1* tempG = (TH1*) pdfs[switchQG(pdf.first)]->Clone(); for(int i = 1; i < pdf.second->GetNbinsX() + 1; ++i){ // Do not consider underflow/overflow float contentQ = tempQ->GetBinContent(i); float contentG = tempG->GetBinContent(i); float width = tempQ->GetBinWidth(i); if((1.5*contentQ < tempQ->GetBinContent(i-1) && 1.5*contentQ < tempQ->GetBinContent(i+1)) || // Try to average out some extreme fluctuations (i.e. only allow a difference of max 50% between two neighbouring bins) (1.5*contentG < tempG->GetBinContent(i-1) && 1.5*contentG < tempG->GetBinContent(i+1)) || (contentQ < 1.5*tempQ->GetBinContent(i-1) && contentQ < 1.5*tempQ->GetBinContent(i+1)) || (contentG < 1.5*tempG->GetBinContent(i-1) && contentG < 1.5*tempG->GetBinContent(i+1))){ if(i-1 > 0 && i+1 < pdf.second->GetNbinsX() + 1){ contentQ += tempQ->GetBinContent(i-1) + tempQ->GetBinContent(i+1); contentG += tempG->GetBinContent(i-1) + tempG->GetBinContent(i+1); width += tempQ->GetBinWidth(i-1) + tempQ->GetBinWidth(i+1); } } int j = 1; while(contentQ <= 0 || contentG <= 0){ // Average empty bins if(tempQ->Integral(0, i-j) <= 0) break; // but not when surpassing the extreme edges of the pdf (see next part) if(tempG->Integral(0, i-j) <= 0) break; if(tempQ->Integral(i+j, tempQ->GetNbinsX()+1) <= 0) break; if(tempG->Integral(i+j, tempG->GetNbinsX()+1) <= 0) break; if(i-j == 0) break; if(i+j == pdf.second->GetNbinsX()) break; contentQ += tempQ->GetBinContent(i-j) + tempQ->GetBinContent(i+j); contentG += tempG->GetBinContent(i-j) + tempG->GetBinContent(i+j); width += tempQ->GetBinWidth(i-j) + tempQ->GetBinWidth(i+j); ++j; } pdf.second->SetBinContent(i, contentQ/width); pdfs[switchQG(pdf.first)]->SetBinContent(i, contentG/width); } delete tempQ; delete tempG; } // Now there are still empty bins left on the edges of the pdf, for which we assign extreme values to avoid a 0 // (relative though, so it does not dominate the pdf's when we want to inspect them in the ROOT file; 0.000001/0.000999 has the same effect as 0.001/0.999) for(auto& pdf : pdfs){ if(pdf.first.Contains("gluon")) continue; for(int i = 0; i <= pdf.second->GetNbinsX() + 1; ++i){ if(pdf.second->GetBinContent(i) <= 0 || pdfs[switchQG(pdf.first)]->GetBinContent(i) <= 0){ bool isBelow = (mean[pdf.first] < mean[switchQG(pdf.first)]); if(isBelow == pdf.second->GetBinCenter(i) < mean[pdf.first]){ pdf.second->SetBinContent(i, 0.000999); pdfs[switchQG(pdf.first)]->SetBinContent(i, 0.000001); } else { pdf.second->SetBinContent(i, 0.000001); pdfs[switchQG(pdf.first)]->SetBinContent(i, 0.000999); } } } } // Apply the likelihood weight for(auto& pdf : pdfs){ TString thisBin = pdf.first(pdf.first.Index(TRegexp("eta")), pdf.first.Length()); TString thisVar = pdf.first(0, pdf.first.Index(TRegexp("_"))); for(int i = 0; i < pdf.second->GetNbinsX() + 1; ++i){ pdf.second->SetBinContent(i, std::pow(pdf.second->GetBinContent(i), bins.getWeight(thisBin, (thisVar == "mult"? 0 : (thisVar == "ptD" ? 1 : 2 ))))); } } // Make file and write binnings TFile *pdfFile = new TFile("pdfQG_"+jetType + "_13TeV_" + version + ".root","RECREATE"); pdfFile->cd(); bins.writeBinsToFile(); // Write to file for(TString var : {"axis2","ptD","mult"}) pdfFile->mkdir(var); for(auto& pdf : pdfs){ for(TString var: {"axis2","ptD","mult"}) if(pdf.first.Contains(var)) pdfFile->cd(var); pdf.second->SetTitle(pdf.first); pdf.second->Write(); TString thisBin = pdf.first(pdf.first.Index(TRegexp("eta")), pdf.first.Length()); for(auto i : bins.getLinkedBins(thisBin)){ // Store copies for merged bins TString copyBin = pdf.first; copyBin.ReplaceAll(thisBin, i); pdf.second->Write(copyBin); } } for(auto& pdf : pdfs) delete pdf.second; for(auto& file : {pdfFile}){ file->Close(); delete file;} } return 0; }
void glauberCut(int from=0, int to=100){ char name[200]; TChain* t = new TChain("t"); char dfilelist[100]; sprintf(dfilelist,"filelist.txt"); ifstream lis(dfilelist); int cnt=0; int dnt=0; while(!lis.eof()) { string filename; lis >> filename; if(cnt>=from&&cnt<to) { cout << filename << endl; if(!filename.empty()) t->Add(filename.c_str()); dnt++; } cnt++; } double b; int ncoll; int npart,npartproj,nparttarg; int nHitBbc_n, nHitBbc_s, BBCTrig; int Centbin; double qBBC_n, qBBC_s, pTrigBBC; double vertex, ecc_std,ecc_rp, ecc_part,ecc_partr,r_ollitra,r_geo,r_arith,r_ollitrar,r_geor,r_arithr,e4; double e_gl[ETOT],ang_gl[ETOT]; double re_gl[ETOT],rang_gl[ETOT]; double pe_gl[ETOT],pang_gl[ETOT]; double pre_gl[ETOT],prang_gl[ETOT]; t->SetBranchAddress("b", &b ); t->SetBranchAddress("Centbin", &Centbin); t->SetBranchAddress("ncoll", &ncoll); t->SetBranchAddress("npart", &npart); t->SetBranchAddress("npartproj", &npartproj); t->SetBranchAddress("nparttarg", &nparttarg); /* t->SetBranchAddress("ecc_std", &ecc_std ); t->SetBranchAddress("ecc_rp", &ecc_rp ); t->SetBranchAddress("ecc_part", &ecc_part ); t->SetBranchAddress("e_gl", e_gl ); //r2 t->SetBranchAddress("ang_gl", ang_gl ); t->SetBranchAddress("pe_gl", pe_gl ); //no only Conside Npart t->SetBranchAddress("pang_gl", pang_gl); */ // t->SetBranchAddress("re_gl", re_gl ); //r3,2,3,4,5,6 // t->SetBranchAddress("rang_gl", rang_gl); t->SetBranchAddress("pre_gl", pre_gl); // t->SetBranchAddress("prang_gl", prang_gl); //t->SetBranchAddress("nux", &nux); //t->SetBranchAddress("nuy", &nuy); //t->SetBranchAddress("st_part", &st_part); int nevents = t->GetEntries(); cout<<"will run "<<nevents/1000000<<"M events"<<endl; TH1D* hecc [NCENT][NHAR]; TH1D* hcent[NCENT]; for(int icent=0; icent<NCENT; icent++){ sprintf(name,"hcent_%.2d", icent); hcent[icent] = new TH1D(name, name ,NCENT, 0-0.5, NCENT-0.5); } for(int icent=0; icent<NCENT; icent++){ for(int ihar=0; ihar<NHAR; ihar++){ sprintf(name, "hecc_ic%.2d_ih%d", icent, ihar); hecc[icent][ihar] = new TH1D(name, name, 100000, 0, 1); } } for(int iev=0; iev<nevents; iev++){ t->GetEntry(iev); if(iev%1000000==0) cout<<iev<<endl; if(Centbin!=0) continue; hcent[Centbin] ->Fill(Centbin); for(int ihar=0; ihar<NHAR; ihar++){ hecc[Centbin][ihar] ->Fill(pre_gl[ihar]); } } //end of events float steps[NSTEP] = {0}; float Ecut[NCENT][NHAR][NSTEP]; for(int is=0; is<NSTEP-1; is++){ steps[is] = (is+1)*1.0/NSTEP; } steps[NSTEP-1] = 1.01; for(int icent=0; icent<NCENT; icent++){ for(int ihar=0; ihar<NHAR; ihar++){ TH1* htmp; sprintf(name,"scale_%d_%d", icent, ihar); htmp = (TH1*)hecc[icent][ihar] ->Clone(name); htmp-> Scale(1.0/htmp->GetEntries()); double sum = 0; int cnt = 0; for(int ib=1; ib<=htmp->GetNbinsX(); ib++){ sum+= htmp->GetBinContent(ib); if(sum>steps[cnt]) { Ecut[icent][ihar][cnt] = htmp->GetBinCenter(ib); cnt++;} } Ecut[icent][ihar][NSTEP-1] = 1.01; cout<<icent<<" "<<ihar<<" "<<cnt<<" "<<sum<<endl; } } ofstream tout; sprintf(name,"ECut_cent0.txt"); tout.open(name); for(int cent=0; cent<NCENT; cent++){ tout<<"centb "<<cent<<endl; for(int ihar=0; ihar<NHAR; ihar++){ for(int iq=0; iq<NSTEP; iq++){ if(iq==0) tout<<"{"<<Ecut[cent][ihar][iq]<<", "; else if(iq<NSTEP-1) tout<<Ecut[cent][ihar][iq]<<", "; else if(iq ==NSTEP-1) tout<<Ecut[cent][ihar][iq]<<"}, "<<endl; } } } tout.close(); TFile* fout = new TFile("glauber_cut_cent0.root","recreate"); for(int icent=0; icent<NCENT; icent++){ for(int ihar=0; ihar<NHAR; ihar++){ hecc[icent][ihar] ->Write(); } } for(int icent=0; icent<NCENT; icent++){ hcent[icent] ->Write(); } fout->Close(); }
void SetRange(TH1 &h, double xmin, double ymin, double xmax, double ymax){ h.GetXaxis()->SetRangeUser(xmin,xmax); h.GetYaxis()->SetRangeUser(ymin,ymax); }
void GetEccenNpart_new(char* xname = "ile") { gStyle->SetOptStat(0); gStyle->SetTitle(0); char name[100]; TChain* ch = new TChain("t"); int n; //you need a file list of root ntuple: fxxxx.lis // sprintf(name,"f%s.lis",xname); cout << "open the filelist : " << name << endl; ifstream fin(name); string filename; while(!fin.eof()){ fin >> filename; if(filename.empty()) continue; cout << filename << endl; ch->AddFile(filename.c_str()); } fin.close(); double b; int ncoll; int npart; int nHitBbc_n, nHitBbc_s; double qBBC_n, qBBC_s; double vertex, ecc_std, ecc_rp, ecc_part,e4; double r_oll,r_geo,r_arith; ch->SetBranchAddress("b", &b ); ch->SetBranchAddress("vertex", &vertex ); ch->SetBranchAddress("ncoll", &ncoll ); ch->SetBranchAddress("npart", &npart ); ch->SetBranchAddress("ecc_std", &ecc_std ); ch->SetBranchAddress("ecc_rp", &ecc_rp ); ch->SetBranchAddress("ecc_part", &ecc_part ); ch->SetBranchAddress("r_ollitra", &r_oll ); ch->SetBranchAddress("r_geo", &r_geo ); ch->SetBranchAddress("r_arith", &r_arith ); ch->SetBranchAddress("e4", &e4 ); ch->SetBranchAddress("qBBC_n", &qBBC_n ); ch->SetBranchAddress("qBBC_s", &qBBC_s ); ch->SetBranchAddress("nHitBbc_n", &nHitBbc_n); ch->SetBranchAddress("nHitBbc_s", &nHitBbc_s); char fname[100]; sprintf(fname,"rootfile/g%s_cent.root",xname); TFile* fout = new TFile(fname,"recreate");//rootfile to save distributions TH1* hbbcq = new TH1D("hbbcq","hbbcq",12000,-0.5,2999.5); hbbcq->Sumw2(); TH1* hbbcqall = new TH1D("hbbcqall","hbbcqall",12000,-0.5,2999.5);hbbcqall->Sumw2(); TH1* hbbcqeff = new TH1D("hbbcqeff","hbbcqeff",12000,-0.5,2999.5);hbbcqeff->Sumw2(); n = ch->GetEntries(); cout << "events: "<< n << endl; //First loop determines the BBC trigger efficiency //as function of bbcq; for(int i=0; i<n; i++){ ch->GetEntry(i); if(nHitBbc_n>=2&&nHitBbc_s>=2){ hbbcq->Fill( (qBBC_n+qBBC_s)/100. );//divide by 100 to fit in 0-3000 range } hbbcqall->Fill( (qBBC_n+qBBC_s)/100. ); } hbbcqeff->Divide(hbbcq,hbbcqall); efficiency = hbbcq->Integral()/hbbcqall->Integral(); cout << "efficiency : " << efficiency << endl; //hbin contains the integrated fraction starting from 0 bbc charge, including the BBC trigger efficiency TH1* hbin = new TH1D("hbin","hbin",hbbcq->GetNbinsX(),-0.5,2999.5); TH1* hbbcqscale = (TH1*)hbbcq->Clone("hbbcqscale"); hbbcqscale->Scale(1.0/hbbcq->Integral()); for(int i=1; i<=hbbcqscale->GetNbinsX(); i++){ hbin->SetBinContent(i,hbbcqscale->Integral(1,i)); } //Following two lines defines the array of cuts and average bbc charge //for centrality percentitle in 5%, 10% and 20% steps double bbcq5[21],bbcq10[11],bbcq20[6]; double abbcq5[20],abbcq10[10],abbcq20[5]; //calculate the various variables for 5% step GetCentrality(hbin,20,bbcq5,hbbcq,abbcq5); cout << endl << endl; //calculate the various variables for 10% step GetCentrality(hbin,10,bbcq10,hbbcq,abbcq10); cout << endl << endl; //calculate the various variables for 20% step GetCentrality(hbin,5,bbcq20,hbbcq,abbcq20); cout << endl << endl; cout << " Find cuts for all the centralities " << endl << endl; const int nval=9;//number of variables to fill char* centname[3] = {"5pStep","10pStep","20pStep"}; char* varname[nval] = {"npart","ncoll","b","standard_ecc","reactionplane_ecc","participant_ecc","R_Ollitraut","R_Geo", "R_arith"}; double vup[nval] = {499.5,2999.5,19.995,1,1,1,4,4,4}; double vlo[nval] = {-0.5,-0.5,-0.005,-1,-1,-1,0,0,0}; int vNb[nval] = {500,3000,2000,200,200,200,400,400,400}; //initialize the histograms which are used to fill the distribution of variables for each centrality TH1* hvar[3][nval][20]; for(int i=0; i<3; i++){ int NC = 0; if(i==0) NC = 20; else if(i==1) NC = 10; else if(i==2) NC = 5; for(int ivar=0; ivar<nval; ivar++){ for(int icen=0; icen<NC; icen++){ sprintf(name,"hvar_%s_%s_cent%d",centname[i],varname[ivar],icen); hvar[i][ivar][icen] = new TH1D(name,name,vNb[ivar],vlo[ivar],vup[ivar]); } } } double qbbcsum; for(int i=0; i<n; i++){ if(i%1000000==0) cout << i << endl; ch->GetEntry(i); if(!(nHitBbc_n>=2&&nHitBbc_s>=2)) continue;//BBC trigger condition qbbcsum = (qBBC_n+qBBC_s)/100.; int centbin5 = FindBin(20,bbcq5,qbbcsum); int centbin10 = FindBin(10,bbcq10,qbbcsum); int centbin20 = FindBin(5,bbcq20,qbbcsum); if(centbin5==-1) continue; if(centbin10==-1) continue; if(centbin20==-1) continue; //find the weight according to the corresponding average efficiency. double weight = hbbcqeff->GetBinContent(hbbcqeff->FindBin(qbbcsum)); //5 percent step // hvar[0][0][centbin5]->Fill(npart,weight); hvar[0][1][centbin5]->Fill(ncoll,weight); hvar[0][2][centbin5]->Fill(b,weight); hvar[0][3][centbin5]->Fill(ecc_std,weight); hvar[0][4][centbin5]->Fill(ecc_rp,weight); hvar[0][5][centbin5]->Fill(ecc_part,weight); hvar[0][6][centbin5]->Fill(r_oll,weight); hvar[0][7][centbin5]->Fill(r_geo,weight); hvar[0][8][centbin5]->Fill(r_arith,weight); //10 percent step // hvar[1][0][centbin10]->Fill(npart,weight); hvar[1][1][centbin10]->Fill(ncoll,weight); hvar[1][2][centbin10]->Fill(b,weight); hvar[1][3][centbin10]->Fill(ecc_std,weight); hvar[1][4][centbin10]->Fill(ecc_rp,weight); hvar[1][5][centbin10]->Fill(ecc_part,weight); hvar[1][6][centbin10]->Fill(r_oll,weight); hvar[1][7][centbin10]->Fill(r_geo,weight); hvar[1][8][centbin10]->Fill(r_arith,weight); //20 percent step // hvar[2][0][centbin20]->Fill(npart,weight); hvar[2][1][centbin20]->Fill(ncoll,weight); hvar[2][2][centbin20]->Fill(b,weight); hvar[2][3][centbin20]->Fill(ecc_std,weight); hvar[2][4][centbin20]->Fill(ecc_rp,weight); hvar[2][5][centbin20]->Fill(ecc_part,weight); hvar[2][6][centbin20]->Fill(r_oll,weight); hvar[2][7][centbin20]->Fill(r_geo,weight); hvar[2][8][centbin20]->Fill(r_arith,weight); } //get mean and RMS values for the variables float var[3][nval+1][20]; float rms[3][nval+1][20]; for(int i=0; i<3; i++){ int NC = 0; if(i==0) NC = 20; else if(i==1) NC = 10; else if(i==2) NC = 5; for(int icen=0; icen<NC; icen++){ for(int ivar=0; ivar<nval; ivar++){ var[i][ivar][icen] = hvar[i][ivar][icen]->GetMean(); rms[i][ivar][icen] = hvar[i][ivar][icen]->GetRMS(); } var[i][nval][icen] = var[i][1][icen]/sigmann; rms[i][nval][icen] = rms[i][1][icen]/sigmann; } } //save to file for(int ivar=0; ivar<4; ivar++){ for(int icen=0; icen<16; icen++){ cout<<var[0][ivar][icen]<<","; } cout<<var[2][ivar][4]<<","; cout<<endl; } cout.precision(4); sprintf(name,"5pstepresults/t%s.txt",xname); ofstream f5(name); cout << " Bin % & npart & ncoll & b & ecc_std & ecc_rp & ecc_part & r_ollitrau & T_{AB}\\\\\\hline" << endl; for(int icen=0; icen<19; icen++){ for(int ivar=0; ivar<7; ivar++){ f5 << var[0][ivar][icen] << " "; } f5 << var[0][nval][icen] << " "; f5 <<endl<< " ("; /* for(int ivar=0; ivar<7; ivar++){ f5 << rms[0][ivar][icen] << " "; } f5 << rms[0][nval][icen] << " "; f5 << ")"<< endl; */ cout << icen*5 << "-" << icen*5+5; for(int ivar=0; ivar<7; ivar++){ cout <<" & " <<var[0][ivar][icen] ; } cout <<" & " <<var[0][nval][icen] ; cout <<"\\\\"<<endl; for(int ivar=0; ivar<7; ivar++){ if(ivar==0)cout <<" & ("<<rms[0][ivar][icen]; else cout <<" & "<<rms[0][ivar][icen]; } cout <<" & "<<rms[0][nval][icen]; cout << ")\\\\\\hline" << endl; // printf(" & %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f \\\\\n", // var[0][0][icen],var[0][1][icen],var[0][2][icen],var[0][3][icen],var[0][4][icen],var[0][5][icen],var[0][6][icen]); //printf(" (& %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f) \\\\\\hline\n", // rms[0][0][icen],rms[0][1][icen],rms[0][2][icen],rms[0][3][icen],rms[0][4][icen],rms[0][5][icen],rms[0][6][icen]); } f5.close(); cout << endl << endl; sprintf(name,"10pstepresults/t%s.txt",xname); ofstream f10(name); cout <<endl<< " Bin % & npart & ncoll & b & ecc_std & ecc_rp & ecc_part & r_ollitrau & T_{AB}\\\\\\hline" << endl; for(int icen=0; icen<10; icen++){ for(int ivar=0; ivar<7; ivar++){ f10 << var[1][ivar][icen] << " "; } f10 << var[1][nval][icen] << " "; f10 <<endl<<" ("; /*for(int ivar=0; ivar<7; ivar++){ f10 << rms[1][ivar][icen] << " "; } f10 << rms[1][nval][icen] << " "; f10 << ")" << endl; */ cout << icen*10 << "-" << icen*10+10; for(int ivar=0; ivar<7; ivar++){ cout <<" & " <<var[1][ivar][icen] ; } cout <<" & " <<var[1][nval][icen] ; cout <<"\\\\"<<endl; for(int ivar=0; ivar<7; ivar++){ if(ivar==0)cout <<" & ("<<rms[1][ivar][icen]; else cout <<" & "<<rms[1][ivar][icen]; } cout <<" & "<<rms[1][nval][icen]; cout << ")\\\\\\hline" << endl; //printf(" & %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f \\\\\n", // var[1][0][icen],var[1][1][icen],var[1][2][icen],var[1][3][icen],var[1][4][icen],var[1][5][icen],var[1][6][icen]); //printf(" (& %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f) \\\\\\hline\n", // rms[1][0][icen],rms[1][1][icen],rms[1][2][icen],rms[1][3][icen],rms[1][4][icen],rms[1][5][icen],rms[1][6][icen]); } f10.close(); cout << endl << endl; sprintf(name,"20pstepresults/t%s.txt",xname); ofstream f20(name); cout <<endl<< " Bin % & npart & ncoll & b & ecc_std & ecc_rp & ecc_part & r_ollitrau & T_{AB}\\\\\\hline" << endl; for(int icen=0; icen<5; icen++){ for(int ivar=0; ivar<7; ivar++){ f20 << var[2][ivar][icen] << " "; } f20 << var[2][nval][icen] << " "; f20 << endl<< " ("; /*for(int ivar=0; ivar<7; ivar++){ f20 << rms[2][ivar][icen] << " "; } f20 << rms[2][nval][icen] << " "; f20 << ")"<< endl; */ cout << icen*20 << "-" << icen*20+20; for(int ivar=0; ivar<7; ivar++){ cout <<" & " <<var[2][ivar][icen] ; } cout <<" & " <<var[2][nval][icen] ; cout <<"\\\\"<<endl; for(int ivar=0; ivar<7; ivar++){ if(ivar==0)cout <<" & ("<<rms[2][ivar][icen]; else cout <<" & "<<rms[2][ivar][icen]; } cout <<" & "<<rms[2][nval][icen]; cout << ")\\\\\\hline" << endl; //printf(" & %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f \\\\\n", // var[2][0][icen],var[2][1][icen],var[2][2][icen],var[2][3][icen],var[2][4][icen],var[2][5][icen],var[2][6][icen]); //printf(" (& %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f) \\\\\\hline\n", // rms[2][0][icen],rms[2][1][icen],rms[2][2][icen],rms[2][3][icen],rms[2][4][icen],rms[2][5][icen],rms[2][6][icen]); } f20.close(); fout->Write(); fout->Close(); return; }
void SetYRange(TH1 &h, double ymin, double ymax){ h.GetYaxis()->SetRangeUser(ymin,ymax); }
/////////////////////// // Begin Main function: void mkROOTaqgcMuLT0_Para(){ ////////////////////////////////////// // Set MC normalization scale factors: const double intLUMI = 19297; const double WWA_scale = 2.1*0.01362 * intLUMI/198777; const double WWA2_scale = 2.1*0.01409 * intLUMI/199183; const double LT0_p8m5_scale = 2.1*0.0809985 * intLUMI/184603 ; const double LT0_p5m5_scale = 2.1*0.0443325 * intLUMI/149975; const double LT0_p3m5_scale = 2.1*0.029308 * intLUMI/97015; const double LT0_m3m5_scale = 2.1*0.0290669 * intLUMI/154634; const double LT0_m5m5_scale = 2.1*0.0440545 * intLUMI/199930; const double LT0_m8m5_scale = 2.1*0.0806445 * intLUMI/196613; /////////////////////////////////////////////////////////////////////////////////// // Specify what kinematical distribution to observe, as well as histogram settings: // plotVar_t pv = {"Photon_Et[iPhoton12]",30,450,10,3,"Photon ET (GeV)"}; if ( !strlen(pv.plotvar) ) break; std::cout << TString(pv.plotvar) << "\t"<<pv.MINRange<<"\t" << pv.MAXRange<<"\t" << pv.NBINS<<"\tTHE CUT " << endl; //////////////////////////////// // Specify event selection cuts: TCut the_cutKfac("effwt*puwt*(iPhoton12>-1&&Photon_Et[iPhoton12]>30.&&Photon_dRlep[iPhoton12]>0.5&&i12Jet2>-1&&i12Jet1>-1&&JetPFCor_dRpho12[i12Jet1]>0.5&&JetPFCor_dRpho12[i12Jet2]>0.5&&abs(W_muon_eta)<2.1&&abs(JetPFCor_dphiMET[i12Jet1])>0.4&& abs(JetPFCor_dphiMET[i12Jet2])>0.4&&JetPFCor_bDiscriminatorCSV[i12Jet1]<0.679&&JetPFCor_bDiscriminatorCSV[i12Jet2]<0.679&&abs(JetPFCor_Eta[i12Jet1]-JetPFCor_Eta[i12Jet2])<1.4&&abs(Photon_Eta[iPhoton12])<1.44421&&W_muon_pt>25&&event_met_pfmet>35.&&c2jMass12>70.&&c2jMass12<100.&&W_mt>30.&&abs(W_muon_dz000)<0.02&&abs(W_muon_dzPV)<0.5&&((i12Jet3>-1)? JetPFCor_dRpho12[i12Jet3]>0.5: 1 )&&((i12Jet4>-1)? JetPFCor_dRpho12[i12Jet4]>0.5: 1 ))"); //mva2jWWAmuA1>0.32 /////////////////////////// // Create output ROOT file: TFile f("para_mu_LT0_WWA_PhotonEt.root", "RECREATE"); ////////////////////////////////////////////////// // Create file pointers for each sample ROOT file: TFile *wwaShape_file,*wwa2Shape_file; TFile *LT0_m8m5_file,*LT0_m5m5_file,*LT0_m3m5_file,*LT0_p3m5_file,*LT0_p5m5_file,*LT0_p8m5_file; ////////////////////////////// // Open each sample ROOT file: wwaShape_file = new TFile("InData_New/RD_mu_qq_wpwma_wp_qq_wm_lvl.root"); wwa2Shape_file = new TFile("InData_New/RD_mu_qq_wpwma_wp_lvl_wm_qq.root"); LT0_m8m5_file = new TFile("InData_New/RD_mu_LT0_m8m11MG_CMSSW532.root"); LT0_m5m5_file = new TFile("InData_New/RD_mu_LT0_m5m11MG_CMSSW532.root"); LT0_m3m5_file = new TFile("InData_New/RD_mu_LT0_m3m11MG_CMSSW532.root"); LT0_p3m5_file = new TFile("InData_New/RD_mu_LT0_p3m11MG_CMSSW532.root"); LT0_p5m5_file = new TFile("InData_New/RD_mu_LT0_p5m11MG_CMSSW532.root"); LT0_p8m5_file = new TFile("InData_New/RD_mu_LT0_p8m11MG_CMSSW532.root"); /////////////////////////////////////////////////// // Retrieve ROOT tree with kinematic distributions: TTree* treewwa = (TTree*) wwaShape_file->Get("WJet"); TTree* treewwa2 = (TTree*) wwa2Shape_file->Get("WJet"); TTree* treeLT0_m8m5 = (TTree*) LT0_m8m5_file->Get("WJet"); TTree* treeLT0_m5m5 = (TTree*) LT0_m5m5_file->Get("WJet"); TTree* treeLT0_m3m5 = (TTree*) LT0_m3m5_file->Get("WJet"); TTree* treeLT0_p3m5 = (TTree*) LT0_p3m5_file->Get("WJet"); TTree* treeLT0_p5m5 = (TTree*) LT0_p5m5_file->Get("WJet"); TTree* treeLT0_p8m5 = (TTree*) LT0_p8m5_file->Get("WJet"); //////////////////////////////////////////////////////////// // Create kinematic-distribution histograms for each sample: TH1* th1wwa = new TH1D("th1wwa", "th1wwa", pv.NBINS, pv.MINRange, pv.MAXRange); TH1* th1wwa2 = new TH1D("th1wwa2", "th1wwa2", pv.NBINS, pv.MINRange, pv.MAXRange); TH1* signal_lt0_80 = new TH1D("signal_lt0_80","signal_lt0_80",pv.NBINS, pv.MINRange, pv.MAXRange); TH1* signal_lt0_50 = new TH1D("signal_lt0_50","signal_lt0_50",pv.NBINS, pv.MINRange, pv.MAXRange); TH1* signal_lt0_30 = new TH1D("signal_lt0_30","signal_lt0_30",pv.NBINS, pv.MINRange, pv.MAXRange); TH1* signal_lt0_m30 = new TH1D("signal_lt0_m30","signal_lt0_-30",pv.NBINS, pv.MINRange, pv.MAXRange); TH1* signal_lt0_m50 = new TH1D("signal_lt0_m50","signal_lt0_-50",pv.NBINS, pv.MINRange, pv.MAXRange); TH1* signal_lt0_m80 = new TH1D("signal_lt0_m80","signal_lt0_-80",pv.NBINS, pv.MINRange, pv.MAXRange); ///////////////////////////////////////////////////////////////////////// // Specify histograms to store Sum of Squares of Weights for each sample: th1wwa->Sumw2(); th1wwa2->Sumw2(); /////////////////////////////////////////////////////////////////////////////////// // Fill kinematical distribution for each sample according to event selection cuts: std::cout<<"Fill SM WWA Histogram..."<<std::endl; treewwa->Draw(TString(pv.plotvar)+TString(">>th1wwa"), the_cutKfac, "goff"); th1wwa->AddBinContent(pv.NBINS,th1wwa->GetBinContent(pv.NBINS+1));th1wwa->SetBinContent(pv.NBINS+1,0.); treewwa2->Draw(TString(pv.plotvar)+TString(">>th1wwa2"), the_cutKfac, "goff"); th1wwa2->AddBinContent(pv.NBINS,th1wwa2->GetBinContent(pv.NBINS+1));th1wwa2->SetBinContent(pv.NBINS+1,0.); std::cout<<"Fill aQGC_1 WWA Histogram..."<<std::endl; treeLT0_m8m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_m80"), the_cutKfac, "goff"); std::cout<<"Fill aQGC_2 WWA Histogram..."<<std::endl; treeLT0_m5m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_m50"), the_cutKfac, "goff"); std::cout<<"Fill aQGC_3 WWA Histogram..."<<std::endl; treeLT0_m3m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_m30"), the_cutKfac, "goff"); std::cout<<"Fill aQGC_4 WWA Histogram..."<<std::endl; treeLT0_p3m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_30"), the_cutKfac, "goff"); std::cout<<"Fill aQGC_5 WWA Histogram..."<<std::endl; treeLT0_p5m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_50"), the_cutKfac, "goff"); std::cout<<"Fill aQGC_6 WWA Histogram..."<<std::endl; treeLT0_p8m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_80"), the_cutKfac, "goff"); signal_lt0_80->AddBinContent(pv.NBINS,signal_lt0_80->GetBinContent(pv.NBINS+1));signal_lt0_80->SetBinContent(pv.NBINS+1,0.); signal_lt0_50->AddBinContent(pv.NBINS,signal_lt0_50->GetBinContent(pv.NBINS+1));signal_lt0_50->SetBinContent(pv.NBINS+1,0.); signal_lt0_30->AddBinContent(pv.NBINS,signal_lt0_30->GetBinContent(pv.NBINS+1));signal_lt0_30->SetBinContent(pv.NBINS+1,0.); signal_lt0_m30->AddBinContent(pv.NBINS,signal_lt0_m30->GetBinContent(pv.NBINS+1));signal_lt0_m30->SetBinContent(pv.NBINS+1,0.); signal_lt0_m50->AddBinContent(pv.NBINS,signal_lt0_m50->GetBinContent(pv.NBINS+1));signal_lt0_m50->SetBinContent(pv.NBINS+1,0.); signal_lt0_m80->AddBinContent(pv.NBINS,signal_lt0_m80->GetBinContent(pv.NBINS+1));signal_lt0_m80->SetBinContent(pv.NBINS+1,0.); ///////////////////////// // Normalize each sample: std::cout<<"\nScale Histograms..."<<std::endl; th1wwa->Scale(WWA_scale); th1wwa2->Scale(WWA2_scale); signal_lt0_m80->Scale(LT0_m8m5_scale); signal_lt0_m50->Scale(LT0_m5m5_scale); signal_lt0_m30->Scale(LT0_m3m5_scale); signal_lt0_30->Scale(LT0_p3m5_scale); signal_lt0_50->Scale(LT0_p5m5_scale); signal_lt0_80->Scale(LT0_p8m5_scale); /////////////////////////// // Combine certain samples: th1wwa->Add(th1wwa2,1); signal_lt0_80->Divide(th1wwa); signal_lt0_50->Divide(th1wwa); signal_lt0_30->Divide(th1wwa); signal_lt0_m30->Divide(th1wwa); signal_lt0_m50->Divide(th1wwa); signal_lt0_m80->Divide(th1wwa); /////////////////////////// //Fill Parabolic Histogram: TH1* bin_1 = new TH1D("bin_1","bin_1",17, -8.5E-11, 8.5E-11); TH1* bin_2 = new TH1D("bin_2","bin_2",17, -8.5E-11, 8.5E-11); TH1* bin_3 = new TH1D("bin_3","bin_3",17, -8.5E-11, 8.5E-11); TH1* bin_4 = new TH1D("bin_4","bin_4",17, -8.5E-11, 8.5E-11); TH1* bin_5 = new TH1D("bin_5","bin_5",17, -8.5E-11, 8.5E-11); TH1* bin_6 = new TH1D("bin_6","bin_6",17, -8.5E-11, 8.5E-11); TH1* bin_7 = new TH1D("bin_7","bin_7",17, -8.5E-11, 8.5E-11); TH1* bin_8 = new TH1D("bin_8","bin_8",17, -8.5E-11, 8.5E-11); TH1* bin_9 = new TH1D("bin_9","bin_9",17, -8.5E-11, 8.5E-11); TH1* bin_10 = new TH1D("bin_10","bin_10",17, -8.5E-11, 8.5E-11); bin_1->SetBinContent(1,signal_lt0_m80->GetBinContent(1)); bin_1->SetBinContent(4,signal_lt0_m50->GetBinContent(1)); bin_1->SetBinContent(6,signal_lt0_m30->GetBinContent(1)); bin_1->SetBinContent(9,1); bin_1->SetBinContent(12,signal_lt0_30->GetBinContent(1)); bin_1->SetBinContent(14,signal_lt0_50->GetBinContent(1)); bin_1->SetBinContent(17,signal_lt0_80->GetBinContent(1)); bin_2->SetBinContent(1,signal_lt0_m80->GetBinContent(2)); bin_2->SetBinContent(4,signal_lt0_m50->GetBinContent(2)); bin_2->SetBinContent(6,signal_lt0_m30->GetBinContent(2)); bin_2->SetBinContent(9,1); bin_2->SetBinContent(12,signal_lt0_30->GetBinContent(2)); bin_2->SetBinContent(14,signal_lt0_50->GetBinContent(2)); bin_2->SetBinContent(17,signal_lt0_80->GetBinContent(2)); bin_3->SetBinContent(1,signal_lt0_m80->GetBinContent(3)); bin_3->SetBinContent(4,signal_lt0_m50->GetBinContent(3)); bin_3->SetBinContent(6,signal_lt0_m30->GetBinContent(3)); bin_3->SetBinContent(9,1); bin_3->SetBinContent(12,signal_lt0_30->GetBinContent(3)); bin_3->SetBinContent(14,signal_lt0_50->GetBinContent(3)); bin_3->SetBinContent(17,signal_lt0_80->GetBinContent(3)); bin_4->SetBinContent(1,signal_lt0_m80->GetBinContent(4)); bin_4->SetBinContent(4,signal_lt0_m50->GetBinContent(4)); bin_4->SetBinContent(6,signal_lt0_m30->GetBinContent(4)); bin_4->SetBinContent(9,1); bin_4->SetBinContent(12,signal_lt0_30->GetBinContent(4)); bin_4->SetBinContent(14,signal_lt0_50->GetBinContent(4)); bin_4->SetBinContent(17,signal_lt0_80->GetBinContent(4)); bin_5->SetBinContent(1,signal_lt0_m80->GetBinContent(5)); bin_5->SetBinContent(4,signal_lt0_m50->GetBinContent(5)); bin_5->SetBinContent(6,signal_lt0_m30->GetBinContent(5)); bin_5->SetBinContent(9,1); bin_5->SetBinContent(12,signal_lt0_30->GetBinContent(5)); bin_5->SetBinContent(14,signal_lt0_50->GetBinContent(5)); bin_5->SetBinContent(17,signal_lt0_80->GetBinContent(5)); bin_6->SetBinContent(1,signal_lt0_m80->GetBinContent(6)); bin_6->SetBinContent(4,signal_lt0_m50->GetBinContent(6)); bin_6->SetBinContent(6,signal_lt0_m30->GetBinContent(6)); bin_6->SetBinContent(9,1); bin_6->SetBinContent(12,signal_lt0_30->GetBinContent(6)); bin_6->SetBinContent(14,signal_lt0_50->GetBinContent(6)); bin_6->SetBinContent(17,signal_lt0_80->GetBinContent(6)); bin_7->SetBinContent(1,signal_lt0_m80->GetBinContent(7)); bin_7->SetBinContent(4,signal_lt0_m50->GetBinContent(7)); bin_7->SetBinContent(6,signal_lt0_m30->GetBinContent(7)); bin_7->SetBinContent(9,1); bin_7->SetBinContent(12,signal_lt0_30->GetBinContent(7)); bin_7->SetBinContent(14,signal_lt0_50->GetBinContent(7)); bin_7->SetBinContent(17,signal_lt0_80->GetBinContent(7)); bin_8->SetBinContent(1,signal_lt0_m80->GetBinContent(8)); bin_8->SetBinContent(4,signal_lt0_m50->GetBinContent(8)); bin_8->SetBinContent(6,signal_lt0_m30->GetBinContent(8)); bin_8->SetBinContent(9,1); bin_8->SetBinContent(12,signal_lt0_30->GetBinContent(8)); bin_8->SetBinContent(14,signal_lt0_50->GetBinContent(8)); bin_8->SetBinContent(17,signal_lt0_80->GetBinContent(8)); bin_9->SetBinContent(1,signal_lt0_m80->GetBinContent(9)); bin_9->SetBinContent(4,signal_lt0_m50->GetBinContent(9)); bin_9->SetBinContent(6,signal_lt0_m30->GetBinContent(9)); bin_9->SetBinContent(9,1); bin_9->SetBinContent(12,signal_lt0_30->GetBinContent(9)); bin_9->SetBinContent(14,signal_lt0_50->GetBinContent(9)); bin_9->SetBinContent(17,signal_lt0_80->GetBinContent(9)); bin_10->SetBinContent(1,signal_lt0_m80->GetBinContent(10)); bin_10->SetBinContent(4,signal_lt0_m50->GetBinContent(10)); bin_10->SetBinContent(6,signal_lt0_m30->GetBinContent(10)); bin_10->SetBinContent(9,1); bin_10->SetBinContent(12,signal_lt0_30->GetBinContent(10)); bin_10->SetBinContent(14,signal_lt0_50->GetBinContent(10)); bin_10->SetBinContent(17,signal_lt0_80->GetBinContent(10)); //////////////// // Fit function: Char_t para_fit[] = "[0]+[1]*x+[2]*x^2"; Char_t fitopt[] = "QMR"; Double_t xmin = -8E-5; Double_t xmax = 8E-5; Double_t p[3][10]; TF1 *pfit = new TF1("pfit",para_fit,xmin,xmax); // pfit->SetParLimits(1,0.0,1E15); // pfit->FixParameter(0,0.0); ///////////////// // Fit histogram: bin_1->Fit(pfit,fitopt,"sames",xmin,xmax); p[0][0] = pfit->GetParameter(0); p[1][0] = pfit->GetParameter(1); p[2][0] = pfit->GetParameter(2); bin_2->Fit(pfit,fitopt,"sames",xmin,xmax); p[0][1] = pfit->GetParameter(0); p[1][1] = pfit->GetParameter(1); p[2][1] = pfit->GetParameter(2); bin_3->Fit(pfit,fitopt,"sames",xmin,xmax); p[0][2] = pfit->GetParameter(0); p[1][2] = pfit->GetParameter(1); p[2][2] = pfit->GetParameter(2); bin_4->Fit(pfit,fitopt,"sames",xmin,xmax); p[0][3] = pfit->GetParameter(0); p[1][3] = pfit->GetParameter(1); p[2][3] = pfit->GetParameter(2); bin_5->Fit(pfit,fitopt,"sames",xmin,xmax); p[0][4] = pfit->GetParameter(0); p[1][4] = pfit->GetParameter(1); p[2][4] = pfit->GetParameter(2); bin_6->Fit(pfit,fitopt,"sames",xmin,xmax); p[0][5] = pfit->GetParameter(0); p[1][5] = pfit->GetParameter(1); p[2][5] = pfit->GetParameter(2); bin_7->Fit(pfit,fitopt,"sames",xmin,xmax); p[0][6] = pfit->GetParameter(0); p[1][6] = pfit->GetParameter(1); p[2][6] = pfit->GetParameter(2); bin_8->Fit(pfit,fitopt,"sames",xmin,xmax); p[0][7] = pfit->GetParameter(0); p[1][7] = pfit->GetParameter(1); p[2][7] = pfit->GetParameter(2); bin_9->Fit(pfit,fitopt,"sames",xmin,xmax); p[0][8] = pfit->GetParameter(0); p[1][8] = pfit->GetParameter(1); p[2][8] = pfit->GetParameter(2); bin_10->Fit(pfit,fitopt,"sames",xmin,xmax); p[0][9] = pfit->GetParameter(0); p[1][9] = pfit->GetParameter(1); p[2][9] = pfit->GetParameter(2); ///////////////////////////// // Fill parameter histograms: TH1* p0 = new TH1D("p0","Parameter 0",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* p1 = new TH1D("p1","Parameter 1",pv.NBINS,pv.MINRange,pv.MAXRange); for(Int_t i=1;i<=pv.NBINS;i++){ p0->SetBinContent(i,p[0][i-1]); p1->SetBinContent(i,p[1][i-1]); } /* /////////////////// // Fit pT-function: Char_t pt_fit[] = "[0]+[1]*x+[2]*x^2"; Char_t fitopt[] = "QMR"; Double_t xmin = 150;//45; Double_t xmax = 1050;//275; Double_t pt[2][3]; TF1 *ptfit = new TF1("ptfit",pt_fit,xmin,xmax); p0->Fit(ptfit,fitopt,"sames",xmin,xmax); pt[0][0] = ptfit->GetParameter(0); pt[0][1] = ptfit->GetParameter(1); pt[0][2] = ptfit->GetParameter(2); p1->Fit(ptfit,fitopt,"sames",xmin,xmax); pt[1][0] = ptfit->GetParameter(0); pt[1][1] = ptfit->GetParameter(1); pt[1][2] = ptfit->GetParameter(2); */ //////////////// // Closure test: // ratio = 1 + (pt[0][0]+pt[0][1]*pt+pt[0][2]*pt^2)*KOW + (pt[1][0]+pt[1][1]*pt+[1][2]*pt^2)*KOW^2 TH1* test = new TH1D("test","Test aQGC Photon ET",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* test2 = new TH1D("test2","Test aQGC Photon ET",pv.NBINS,pv.MINRange,pv.MAXRange); for(Int_t j=1;j<=pv.NBINS;j++){ Double_t value,bincent; TAxis* xaxis = test->GetXaxis(); bincent = xaxis->GetBinCenter(j); value = p[0][j-1]+p[1][j-1]*(8E-11)+p[2][j-1]*pow(8E-11,2); test->SetBinContent(j,value); test2->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-8E-11)+p[2][j-1]*pow(-8E-11,2)); } // test->SetBinContent(8,1+p[0][7]*(8E-11)+p[1][7]*pow(8E-11,2)); // test2->SetBinContent(8,1+p[0][7]*(-8E-11)+p[1][7]*pow(-8E-11,2)); TH1D* test_r = (TH1D*)test->Clone("test_r"); TH1D* test2_r = (TH1D*)test2->Clone("test2_r"); test_r->Divide(signal_lt0_80); test2_r->Divide(signal_lt0_m80); test->Multiply(th1wwa); test2->Multiply(th1wwa); test->Add(th1wwa,-1); test2->Add(th1wwa,-1); ///////////////////// // Simulate new aQGC: TH1* signal_lt0_18 = new TH1D("signal_lt0_18","signal_lt0_1p8",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_20 = new TH1D("signal_lt0_20","signal_lt0_2p0",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_22 = new TH1D("signal_lt0_22","signal_lt0_2p2",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_24 = new TH1D("signal_lt0_24","signal_lt0_2p4",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_26 = new TH1D("signal_lt0_26","signal_lt0_2p6",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_28 = new TH1D("signal_lt0_28","signal_lt0_2p8",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_32 = new TH1D("signal_lt0_32","signal_lt0_3p2",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_34 = new TH1D("signal_lt0_34","signal_lt0_3p4",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_36 = new TH1D("signal_lt0_36","signal_lt0_3p6",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_38 = new TH1D("signal_lt0_38","signal_lt0_3p8",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_m18 = new TH1D("signal_lt0_m18","signal_lt0_-1p8",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_m20 = new TH1D("signal_lt0_m20","signal_lt0_-2p0",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_m22 = new TH1D("signal_lt0_m22","signal_lt0_-2p2",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_m24 = new TH1D("signal_lt0_m24","signal_lt0_-2p4",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_m26 = new TH1D("signal_lt0_m26","signal_lt0_-2p6",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_m28 = new TH1D("signal_lt0_m28","signal_lt0_-2p8",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_m32 = new TH1D("signal_lt0_m32","signal_lt0_-3p2",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_m34 = new TH1D("signal_lt0_m34","signal_lt0_-3p4",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_m36 = new TH1D("signal_lt0_m36","signal_lt0_-3p6",pv.NBINS,pv.MINRange,pv.MAXRange); TH1* signal_lt0_m38 = new TH1D("signal_lt0_m38","signal_lt0_-3p8",pv.NBINS,pv.MINRange,pv.MAXRange); signal_lt0_18->Sumw2(); signal_lt0_20->Sumw2(); signal_lt0_22->Sumw2(); signal_lt0_24->Sumw2(); signal_lt0_26->Sumw2(); signal_lt0_28->Sumw2(); signal_lt0_32->Sumw2(); signal_lt0_34->Sumw2(); signal_lt0_36->Sumw2(); signal_lt0_38->Sumw2(); signal_lt0_m18->Sumw2(); signal_lt0_m20->Sumw2(); signal_lt0_m22->Sumw2(); signal_lt0_m24->Sumw2(); signal_lt0_m26->Sumw2(); signal_lt0_m28->Sumw2(); signal_lt0_m32->Sumw2(); signal_lt0_m34->Sumw2(); signal_lt0_m36->Sumw2(); signal_lt0_m38->Sumw2(); for(Int_t j=1;j<=pv.NBINS;j++){ Double_t bincent; TAxis* xaxis = test->GetXaxis(); bincent = xaxis->GetBinCenter(j); signal_lt0_m50->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-5.E-11)+p[2][j-1]*pow(-5.E-11,2)); signal_lt0_m30->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-3.E-11)+p[2][j-1]*pow(-3.E-11,2)); signal_lt0_m80->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-8.E-11)+p[2][j-1]*pow(-8.E-11,2)); signal_lt0_m28->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-2.8E-11)+p[2][j-1]*pow(-2.8E-11,2)); signal_lt0_m26->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-2.6E-11)+p[2][j-1]*pow(-2.6E-11,2)); signal_lt0_m24->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-2.4E-11)+p[2][j-1]*pow(-2.4E-11,2)); signal_lt0_m22->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-2.2E-11)+p[2][j-1]*pow(-2.2E-11,2)); signal_lt0_m20->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-2.E-11)+p[2][j-1]*pow(-2.E-11,2)); signal_lt0_m18->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-1.8E-11)+p[2][j-1]*pow(-1.8E-11,2)); signal_lt0_m32->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-3.2E-11)+p[2][j-1]*pow(-3.2E-11,2)); signal_lt0_m34->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-3.4E-11)+p[2][j-1]*pow(-3.4E-11,2)); signal_lt0_m36->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-3.6E-11)+p[2][j-1]*pow(-3.6E-11,2)); signal_lt0_m38->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-3.8E-11)+p[2][j-1]*pow(-3.8E-11,2)); signal_lt0_50->SetBinContent(j,p[0][j-1]+p[1][j-1]*(5.E-11)+p[2][j-1]*pow(5.E-11,2)); signal_lt0_30->SetBinContent(j,p[0][j-1]+p[1][j-1]*(3.E-11)+p[2][j-1]*pow(3.E-11,2)); signal_lt0_80->SetBinContent(j,p[0][j-1]+p[1][j-1]*(8.E-11)+p[2][j-1]*pow(8.E-11,2)); signal_lt0_28->SetBinContent(j,p[0][j-1]+p[1][j-1]*(2.8E-11)+p[2][j-1]*pow(2.8E-11,2)); signal_lt0_26->SetBinContent(j,p[0][j-1]+p[1][j-1]*(2.6E-11)+p[2][j-1]*pow(2.6E-11,2)); signal_lt0_24->SetBinContent(j,p[0][j-1]+p[1][j-1]*(2.4E-11)+p[2][j-1]*pow(2.4E-11,2)); signal_lt0_22->SetBinContent(j,p[0][j-1]+p[1][j-1]*(2.2E-11)+p[2][j-1]*pow(2.2E-11,2)); signal_lt0_20->SetBinContent(j,p[0][j-1]+p[1][j-1]*(2.E-11)+p[2][j-1]*pow(2.E-11,2)); signal_lt0_18->SetBinContent(j,p[0][j-1]+p[1][j-1]*(1.8E-11)+p[2][j-1]*pow(1.8E-11,2)); signal_lt0_32->SetBinContent(j,p[0][j-1]+p[1][j-1]*(3.2E-11)+p[2][j-1]*pow(3.2E-11,2)); signal_lt0_34->SetBinContent(j,p[0][j-1]+p[1][j-1]*(3.4E-11)+p[2][j-1]*pow(3.4E-11,2)); signal_lt0_36->SetBinContent(j,p[0][j-1]+p[1][j-1]*(3.6E-11)+p[2][j-1]*pow(3.6E-11,2)); signal_lt0_38->SetBinContent(j,p[0][j-1]+p[1][j-1]*(3.8E-11)+p[2][j-1]*pow(3.8E-11,2)); } /* signal_lt0_m50->SetBinContent(8,1+p[0][7]*(-5.E-11)+p[1][7]*pow(-5.E-11,2)); signal_lt0_m30->SetBinContent(8,1+p[0][7]*(-3.E-11)+p[1][7]*pow(-3.E-11,2)); signal_lt0_m80->SetBinContent(8,1+p[0][7]*(-8.E-11)+p[1][7]*pow(-8.E-11,2)); signal_lt0_m28->SetBinContent(8,1+p[0][7]*(-2.8E-11)+p[1][7]*pow(-2.8E-11,2)); signal_lt0_m26->SetBinContent(8,1+p[0][7]*(-2.6E-11)+p[1][7]*pow(-2.6E-11,2)); signal_lt0_m24->SetBinContent(8,1+p[0][7]*(-2.4E-11)+p[1][7]*pow(-2.4E-11,2)); signal_lt0_m22->SetBinContent(8,1+p[0][7]*(-2.2E-11)+p[1][7]*pow(-2.2E-11,2)); signal_lt0_m20->SetBinContent(8,1+p[0][7]*(-2.E-11)+p[1][7]*pow(-2.E-11,2)); signal_lt0_m18->SetBinContent(8,1+p[0][7]*(-1.8E-11)+p[1][7]*pow(-1.8E-11,2)); signal_lt0_m32->SetBinContent(8,1+p[0][7]*(-3.2E-11)+p[1][7]*pow(-3.2E-11,2)); signal_lt0_m34->SetBinContent(8,1+p[0][7]*(-3.4E-11)+p[1][7]*pow(-3.4E-11,2)); signal_lt0_m36->SetBinContent(8,1+p[0][7]*(-3.6E-11)+p[1][7]*pow(-3.6E-11,2)); signal_lt0_m38->SetBinContent(8,1+p[0][7]*(-3.8E-11)+p[1][7]*pow(-3.8E-11,2)); signal_lt0_50->SetBinContent(8,1+p[0][7]*(5.E-11)+p[1][7]*pow(5.E-11,2)); signal_lt0_30->SetBinContent(8,1+p[0][7]*(3.E-11)+p[1][7]*pow(3.E-11,2)); signal_lt0_80->SetBinContent(8,1+p[0][7]*(8.E-11)+p[1][7]*pow(8.E-11,2)); signal_lt0_28->SetBinContent(8,1+p[0][7]*(2.8E-11)+p[1][7]*pow(2.8E-11,2)); signal_lt0_26->SetBinContent(8,1+p[0][7]*(2.6E-11)+p[1][7]*pow(2.6E-11,2)); signal_lt0_24->SetBinContent(8,1+p[0][7]*(2.4E-11)+p[1][7]*pow(2.4E-11,2)); signal_lt0_22->SetBinContent(8,1+p[0][7]*(2.2E-11)+p[1][7]*pow(2.2E-11,2)); signal_lt0_20->SetBinContent(8,1+p[0][7]*(2.E-11)+p[1][7]*pow(2.E-11,2)); signal_lt0_18->SetBinContent(8,1+p[0][7]*(1.8E-11)+p[1][7]*pow(1.8E-11,2)); signal_lt0_32->SetBinContent(8,1+p[0][7]*(3.2E-11)+p[1][7]*pow(3.2E-11,2)); signal_lt0_34->SetBinContent(8,1+p[0][7]*(3.4E-11)+p[1][7]*pow(3.4E-11,2)); signal_lt0_36->SetBinContent(8,1+p[0][7]*(3.6E-11)+p[1][7]*pow(3.6E-11,2)); signal_lt0_38->SetBinContent(8,1+p[0][7]*(3.8E-11)+p[1][7]*pow(3.8E-11,2)); */ signal_lt0_m50->Multiply(th1wwa); signal_lt0_m30->Multiply(th1wwa); signal_lt0_m80->Multiply(th1wwa); signal_lt0_m28->Multiply(th1wwa); signal_lt0_m26->Multiply(th1wwa); signal_lt0_m24->Multiply(th1wwa); signal_lt0_m22->Multiply(th1wwa); signal_lt0_m20->Multiply(th1wwa); signal_lt0_m18->Multiply(th1wwa); signal_lt0_m32->Multiply(th1wwa); signal_lt0_m34->Multiply(th1wwa); signal_lt0_m36->Multiply(th1wwa); signal_lt0_m38->Multiply(th1wwa); signal_lt0_50->Multiply(th1wwa); signal_lt0_30->Multiply(th1wwa); signal_lt0_80->Multiply(th1wwa); signal_lt0_28->Multiply(th1wwa); signal_lt0_26->Multiply(th1wwa); signal_lt0_24->Multiply(th1wwa); signal_lt0_22->Multiply(th1wwa); signal_lt0_20->Multiply(th1wwa); signal_lt0_18->Multiply(th1wwa); signal_lt0_32->Multiply(th1wwa); signal_lt0_34->Multiply(th1wwa); signal_lt0_36->Multiply(th1wwa); signal_lt0_38->Multiply(th1wwa); signal_lt0_m50->Add(th1wwa,-1); signal_lt0_m30->Add(th1wwa,-1); signal_lt0_m80->Add(th1wwa,-1); signal_lt0_m28->Add(th1wwa,-1); signal_lt0_m26->Add(th1wwa,-1); signal_lt0_m24->Add(th1wwa,-1); signal_lt0_m22->Add(th1wwa,-1); signal_lt0_m20->Add(th1wwa,-1); signal_lt0_m18->Add(th1wwa,-1); signal_lt0_m32->Add(th1wwa,-1); signal_lt0_m34->Add(th1wwa,-1); signal_lt0_m36->Add(th1wwa,-1); signal_lt0_m38->Add(th1wwa,-1); signal_lt0_50->Add(th1wwa,-1); signal_lt0_30->Add(th1wwa,-1); signal_lt0_80->Add(th1wwa,-1); signal_lt0_28->Add(th1wwa,-1); signal_lt0_26->Add(th1wwa,-1); signal_lt0_24->Add(th1wwa,-1); signal_lt0_22->Add(th1wwa,-1); signal_lt0_20->Add(th1wwa,-1); signal_lt0_18->Add(th1wwa,-1); signal_lt0_32->Add(th1wwa,-1); signal_lt0_34->Add(th1wwa,-1); signal_lt0_36->Add(th1wwa,-1); signal_lt0_38->Add(th1wwa,-1); signal_lt0_m50->Scale(1.185/2.1); signal_lt0_m30->Scale(1.185/2.1); signal_lt0_m80->Scale(1.185/2.1); signal_lt0_m28->Scale(1.185/2.1); signal_lt0_m26->Scale(1.185/2.1); signal_lt0_m24->Scale(1.185/2.1); signal_lt0_m22->Scale(1.185/2.1); signal_lt0_m20->Scale(1.185/2.1); signal_lt0_m18->Scale(1.185/2.1); signal_lt0_m32->Scale(1.185/2.1); signal_lt0_m34->Scale(1.185/2.1); signal_lt0_m36->Scale(1.185/2.1); signal_lt0_m38->Scale(1.185/2.1); signal_lt0_50->Scale(1.185/2.1); signal_lt0_30->Scale(1.185/2.1); signal_lt0_80->Scale(1.185/2.1); signal_lt0_28->Scale(1.185/2.1); signal_lt0_26->Scale(1.185/2.1); signal_lt0_24->Scale(1.185/2.1); signal_lt0_22->Scale(1.185/2.1); signal_lt0_20->Scale(1.185/2.1); signal_lt0_18->Scale(1.185/2.1); signal_lt0_32->Scale(1.185/2.1); signal_lt0_34->Scale(1.185/2.1); signal_lt0_36->Scale(1.185/2.1); signal_lt0_38->Scale(1.185/2.1); /* signal_lt0_18->Sumw2(); signal_lt0_20->Sumw2(); signal_lt0_22->Sumw2(); signal_lt0_24->Sumw2(); signal_lt0_26->Sumw2(); signal_lt0_28->Sumw2(); signal_lt0_30->Sumw2(); signal_lt0_32->Sumw2(); signal_lt0_34->Sumw2(); signal_lt0_36->Sumw2(); signal_lt0_38->Sumw2(); signal_lt0_50->Sumw2(); signal_lt0_80->Sumw2(); signal_lt0_m18->Sumw2(); signal_lt0_m20->Sumw2(); signal_lt0_m22->Sumw2(); signal_lt0_m24->Sumw2(); signal_lt0_m26->Sumw2(); signal_lt0_m28->Sumw2(); signal_lt0_m30->Sumw2(); signal_lt0_m32->Sumw2(); signal_lt0_m34->Sumw2(); signal_lt0_m36->Sumw2(); signal_lt0_m38->Sumw2(); signal_lt0_m50->Sumw2(); signal_lt0_m80->Sumw2(); */ /* // Adding 35% Signal K-factor Systematic uncertainty for(int hi=1;hi<=pv.NBINS;hi++){ fperr = pow(signal_lt0_m18->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m18->GetBinContent(hi),2); signal_lt0_m18->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m20->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m20->GetBinContent(hi),2); signal_lt0_m20->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m22->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m22->GetBinContent(hi),2); signal_lt0_m22->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m24->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m24->GetBinContent(hi),2); signal_lt0_m24->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m26->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m26->GetBinContent(hi),2); signal_lt0_m26->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m28->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m28->GetBinContent(hi),2); signal_lt0_m28->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m30->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m30->GetBinContent(hi),2); signal_lt0_m30->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m32->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m32->GetBinContent(hi),2); signal_lt0_m32->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m34->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m34->GetBinContent(hi),2); signal_lt0_m34->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m36->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m36->GetBinContent(hi),2); signal_lt0_m36->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m38->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m38->GetBinContent(hi),2); signal_lt0_m38->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m50->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m50->GetBinContent(hi),2); signal_lt0_m50->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_m80->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_m80->GetBinContent(hi),2); signal_lt0_m80->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_18->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_18->GetBinContent(hi),2); signal_lt0_18->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_20->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_20->GetBinContent(hi),2); signal_lt0_20->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_22->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_22->GetBinContent(hi),2); signal_lt0_22->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_24->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_24->GetBinContent(hi),2); signal_lt0_24->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_26->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_26->GetBinContent(hi),2); signal_lt0_26->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_28->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_28->GetBinContent(hi),2); signal_lt0_28->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_30->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_30->GetBinContent(hi),2); signal_lt0_30->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_32->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_32->GetBinContent(hi),2); signal_lt0_32->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_34->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_34->GetBinContent(hi),2); signal_lt0_34->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_36->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_36->GetBinContent(hi),2); signal_lt0_36->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_38->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_38->GetBinContent(hi),2); signal_lt0_38->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_50->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_50->GetBinContent(hi),2); signal_lt0_50->SetBinError(hi,sqrt(fperr)); fperr = pow(signal_lt0_80->GetBinError(hi),2); fperr += pow(0.28,2)*pow(signal_lt0_80->GetBinContent(hi),2); signal_lt0_80->SetBinError(hi,sqrt(fperr)); } */ //////////////////////// // Set histogram labels: const double BINWIDTH = ((pv.MAXRange-pv.MINRange)/pv.NBINS); char tmpc[100]; sprintf(tmpc,"Events / %.1f GeV",BINWIDTH); if (pv.slog==1) sprintf(tmpc,"Events / %.1f",BINWIDTH); if (pv.slog==2) sprintf(tmpc,"Events / %.2f",BINWIDTH); if (pv.slog==3) sprintf(tmpc,"Events / %.0f GeV",BINWIDTH); if (pv.slog==6) sprintf(tmpc,"Events / %.2f rad",BINWIDTH); signal_lt0_80->SetYTitle(tmpc); signal_lt0_80->GetXaxis()->SetTitle(pv.xlabel); signal_lt0_80->GetYaxis()->CenterTitle(true); signal_lt0_50->SetYTitle(tmpc); signal_lt0_50->GetXaxis()->SetTitle(pv.xlabel); signal_lt0_50->GetYaxis()->CenterTitle(true); signal_lt0_30->SetYTitle(tmpc); signal_lt0_30->GetXaxis()->SetTitle(pv.xlabel); signal_lt0_30->GetYaxis()->CenterTitle(true); signal_lt0_m30->SetYTitle(tmpc); signal_lt0_m30->GetXaxis()->SetTitle(pv.xlabel); signal_lt0_m30->GetYaxis()->CenterTitle(true); signal_lt0_m50->SetYTitle(tmpc); signal_lt0_m50->GetXaxis()->SetTitle(pv.xlabel); signal_lt0_m50->GetYaxis()->CenterTitle(true); signal_lt0_m80->SetYTitle(tmpc); signal_lt0_m80->GetXaxis()->SetTitle(pv.xlabel); signal_lt0_m80->GetYaxis()->CenterTitle(true); ////////////////////////////////////////////////////////// // Save Observed Data, Background (+ SM WWA), Background + // Uncertainty, Background - Uncertainty, Anomalous Signal // histograms to output ROOT file: std::cout<<"Save Histograms..."<<std::endl; f.cd(); signal_lt0_80->Write(); signal_lt0_50->Write(); signal_lt0_30->Write(); signal_lt0_m30->Write(); signal_lt0_m50->Write(); signal_lt0_m80->Write(); bin_1->Write(); bin_2->Write(); bin_3->Write(); bin_4->Write(); bin_5->Write(); bin_6->Write(); bin_7->Write(); bin_8->Write(); bin_9->Write(); bin_10->Write(); p0->Write(); p1->Write(); test->Write(); test2->Write(); test_r->Write(); test2_r->Write(); signal_lt0_m28->Write(); signal_lt0_m26->Write(); signal_lt0_m24->Write(); signal_lt0_m22->Write(); signal_lt0_m20->Write(); signal_lt0_m18->Write(); signal_lt0_m32->Write(); signal_lt0_m34->Write(); signal_lt0_m36->Write(); signal_lt0_m38->Write(); signal_lt0_28->Write(); signal_lt0_26->Write(); signal_lt0_24->Write(); signal_lt0_22->Write(); signal_lt0_20->Write(); signal_lt0_18->Write(); signal_lt0_32->Write(); signal_lt0_34->Write(); signal_lt0_36->Write(); signal_lt0_38->Write(); //For conveners // th1wwa->Write(); // }// End Main function
void EMCDistribution(TString gain = "CALIB", bool log_scale = false) { TText *t; TCanvas *c1 = new TCanvas( "EMCDistribution_" + gain + TString(log_scale ? "_Log" : "") + cuts, "EMCDistribution_" + gain + TString(log_scale ? "_Log" : "") + cuts, 1800, 1000); c1->Divide(8, 8, 0., 0.01); int idx = 1; TPad *p; for (int iphi = 8 - 1; iphi >= 0; iphi--) { for (int ieta = 0; ieta < 8; ieta++) { p = (TPad *) c1->cd(idx++); c1->Update(); p->SetLogy(); p->SetGridx(0); p->SetGridy(0); TString hname = Form("hEnergy_ieta%d_iphi%d", ieta, iphi) + TString(log_scale ? "_Log" : ""); TH1 *h = NULL; if (log_scale) h = new TH1F(hname, Form(";Calibrated Tower Energy Sum (GeV);Count / bin"), 300, 5e-3, 3096); else // h = new TH1F(hname, // Form(";Calibrated Tower Energy Sum (GeV);Count / bin"), 196, // 1900, 2096); h = new TH1F(hname, Form(";Calibrated Tower Energy Sum (GeV);Count / bin"), 596, -96, 500); h->SetLineWidth(0); h->SetLineColor(kBlue + 3); h->SetFillColor(kBlue + 3); h->GetXaxis()->SetTitleSize(.09); h->GetXaxis()->SetLabelSize(.08); h->GetYaxis()->SetLabelSize(.08); if (log_scale) QAHistManagerDef::useLogBins(h->GetXaxis()); T->Draw( "TOWER_" + gain + "_CEMC[].get_energy_power_law_exp()>>" + hname, Form( "TOWER_%s_CEMC[].get_bineta()==%d && TOWER_%s_CEMC[].get_binphi()==%d", gain.Data(), ieta, gain.Data(), iphi), ""); TText *t = new TText(.9, .9, Form("Col%d Row%d", ieta, iphi)); t->SetTextAlign(33); t->SetTextSize(.15); t->SetNDC(); t->Draw(); // return; } } SaveCanvas(c1, TString(_file0->GetName()) + TString("_DrawPrototype4EMCalTower_") + TString(c1->GetName()), false); }
void calculateTriggerRates( TString inFile0Name = "root://eoscms//eos/cms/store/caf/user/velicanu/PA2013_merged_HiForest/pPb_hiForest2_1_15_test.root", // TString inFile0Name = "/castor/cern.ch/user/m/miheejo/openHLT/cms442/r181530_reco_v1_2/HIExpressPhysics_hiexp-hirun2011-r181530-reco-v1_2.root", // "/castor/cern.ch/user/k/kimy/openHLT//openhlt_run181531.root", // "/castor/cern.ch/user/v/velicanu/HIHLT_Validation_Test_GRIF_v10.root", Int_t runNum = 202792, TString outdir = "output", char *projectTitle = "HIpARun2013", string source = "data" ) { char szBuf[256]; int scale = 23; // event selectoin //Form("&&Run==%d&&LumiBlock>%d",runNum,goodLumiStart) // trigger under investigation // const int ntrigs = 8; // const char* triggerPath[ntrigs] = {"","HLT_HIMinBiasHfOrBSC", // "L1_SingleMu3_BptxAND","HLT_HIL1SingleMu3","HLT_HIL2Mu3", // "L1_DoubleMuOpen_BptxAND","HLT_HIL1DoubleMuOpen","HLT_HIL2DoubleMu3"}; const int ntrigs = 9; const char* triggerPath[ntrigs] = { "", "HLT_PAL1SingleMuOpen_v1", "HLT_PAL1SingleMu3_v1", "HLT_PAL1SingleMu7_v1", "HLT_PAL1SingleMu12_v1", "HLT_PAL1DoubleMu0_v1", "HLT_PADimuon0_NoVertexing_v1", "HLT_PAMu5_v1", "HLT_PAMu8_v1" }; TString str; TH1D *ahTemp[ntrigs]; double ahTempRate[ntrigs]; //Rates (Integrated over lumisections) // Load input TChain * HltTree = new TChain("hltanalysis/HltTree","HI OpenHLT Tree"); HltTree->Add(inFile0Name); cout << inFile0Name << endl; cout << " # entries: " << HltTree->GetEntries() << endl; int nEvents = HltTree->GetEntries(); for(int it=1; it<ntrigs; it++) { TH1D *ph = new TH1D("ph","",1100,0,1100); HltTree->Draw("LumiBlock>>ph",str.Format("%s",triggerPath[it])); TH1D *phLumi = (TH1D*)gDirectory->Get("ph"); phLumi->SetDirectory(0); phLumi->Scale(1./(phLumi->GetBinWidth(1)*23));// 1lumi unit=23 sec ahTempRate[it] = phLumi->Integral()/phLumi->GetNbinsX(); ahTemp[it] = phLumi; cout<< triggerPath[it]<<"\t"<<phLumi->GetEntries()<< "\t" << ahTempRate[it] << endl; } //---------------------------- // drawing part // axis // TH1D * phLumiAxis = new TH1D("phLumiAxis",";Lumi Section;dEvt/dLumiSec",1100,0,1100); TH1D * phLumiAxis = new TH1D("phLumiAxis",";Lumi Section;Rate [Hz]",1,0,1200); phLumiAxis->SetMinimum(0.01); phLumiAxis->SetMaximum(1e+3); gStyle->SetOptStat(kFALSE); // legend TLegend *l0= new TLegend(0.2,0.4,0.8,0.9); l0->SetHeader(str.Format("HICorePhysics_L1DoubleMuOpen: %d",nEvents)); l0->SetMargin(0.1); l0->SetFillStyle(0); l0->SetLineColor(0); l0->SetLineWidth(5.0); l0->SetTextSize(0.03); // canvas TCanvas *pcLumi = new TCanvas("pcLumi","pcLumi"); pcLumi->cd(); phLumiAxis->Draw(); pcLumi->SetLogy(); for(int it=1; it<ntrigs; it++) { TH1 *phLocal = (TH1 *)(ahTemp[it]->Clone("phLocal")); phLocal->SetDirectory(0); phLocal->SetLineColor(it); if (it >= 10) phLocal->SetLineColor(it+20); if(it==5) phLocal->SetLineColor(kOrange+2); phLocal->Draw("same"); l0->AddEntry(phLocal,str.Format("%s: %.2f%, %.2f Hz",triggerPath[it],100*phLocal->GetEntries()/nEvents,ahTempRate[it]),"l");; pcLumi->Update(); } l0->Draw("same"); pcLumi->SaveAs("TrigRate.pdf"); }
void EMCDistribution_SUM_RawADC(TString sTOWER = "Energy_Sum_col1_row2_5x5", TString CherenkovSignal = "C2_Inner") { TH1 *EnergySum_LG_full = new TH1F("EnergySum_LG_full", ";Tower Energy Sum (ADC);Count / bin", 210, -1000, 20000); TH1 *EnergySum_LG = new TH1F("EnergySum_LG", ";Tower Energy Sum (ADC);Count / bin", 210, -1000, 20000); // TH1 * EnergySum_HG = new TH1F("EnergySum_HG", // ";Low range Tower Energy Sum (ADC);Count / bin", 50, 0, 500); TH1 *C2_Inner_full = new TH1F("C2_Inner_full", CherenkovSignal + ";Cherenkov Signal (ADC);Count / bin", 180, -1000, 17000); TH1 *C2_Inner = new TH1F("C2_Inner", CherenkovSignal + ";Cherenkov Inner Signal (ADC);Count / bin", 180, -1000, 17000); EnergySum_LG_full->SetLineColor(kBlue + 3); EnergySum_LG_full->SetLineWidth(2); EnergySum_LG->SetLineColor(kGreen + 3); EnergySum_LG->SetLineWidth(3); EnergySum_LG->SetMarkerColor(kGreen + 3); C2_Inner_full->SetLineColor(kBlue + 3); C2_Inner_full->SetLineWidth(2); C2_Inner->SetLineColor(kGreen + 3); C2_Inner->SetLineWidth(3); C2_Inner->SetMarkerColor(kGreen + 3); TCut c2 = CherenkovSignal + ">2000"; T->Draw(sTOWER + ">>EnergySum_LG_full", "", "goff"); T->Draw(sTOWER + ">>EnergySum_LG", c2, "goff"); T->Draw(CherenkovSignal + ">>C2_Inner_full", "", "goff"); T->Draw(CherenkovSignal + ">>C2_Inner", c2, "goff"); TText *t; TCanvas *c1 = new TCanvas( "EMCDistribution_SUM_RawADC_" + sTOWER + "_" + CherenkovSignal + cuts, "EMCDistribution_SUM_RawADC_" + sTOWER + "_" + CherenkovSignal + cuts, 1800, 600); c1->Divide(3, 1); int idx = 1; TPad *p; p = (TPad *) c1->cd(idx++); c1->Update(); p->SetLogy(); p->SetGridx(0); p->SetGridy(0); C2_Inner_full->DrawClone(); C2_Inner->DrawClone("same"); p = (TPad *) c1->cd(idx++); c1->Update(); p->SetLogy(); p->SetGridx(0); p->SetGridy(0); TH1 *h = (TH1 *) EnergySum_LG_full->DrawClone(); // h->GetXaxis()->SetRangeUser(-1, h->GetMean() + 5 * h->GetRMS()); (TH1 *) EnergySum_LG->DrawClone("same"); p = (TPad *) c1->cd(idx++); c1->Update(); // p->SetLogy(); p->SetGridx(0); p->SetGridy(0); TH1 *h_full = (TH1 *) EnergySum_LG_full->DrawClone(); // h_full->GetXaxis()->SetRangeUser(0.5,32); TH1 *h = (TH1 *) EnergySum_LG->DrawClone("same"); TF1 *fgaus_g = new TF1("fgaus_LG_g", "gaus", h->GetMean() - 1 * h->GetRMS(), h->GetMean() + 4 * h->GetRMS()); fgaus_g->SetParameters(1, h->GetMean() - 2 * h->GetRMS(), h->GetMean() + 2 * h->GetRMS()); h->Fit(fgaus_g, "MR0N"); TF1 *fgaus = new TF1("fgaus_LG", "gaus", fgaus_g->GetParameter(1) - 1 * fgaus_g->GetParameter(2), fgaus_g->GetParameter(1) + 4 * fgaus_g->GetParameter(2)); fgaus->SetParameters(fgaus_g->GetParameter(0), fgaus_g->GetParameter(1), fgaus_g->GetParameter(2)); h->Fit(fgaus, "MR"); h->Sumw2(); h_full->Sumw2(); h_full->GetXaxis()->SetRangeUser(h->GetMean() - 4 * h->GetRMS(), h->GetMean() + 4 * h->GetRMS()); h_full->GetYaxis()->SetRangeUser(0, fgaus_g->GetParameter(0) * 4); h->SetLineWidth(2); h->SetMarkerStyle(kFullCircle); h_full->SetTitle( Form("#DeltaE/<E> = %.1f%%", 100 * fgaus->GetParameter(2) / fgaus->GetParameter(1))); // p = (TPad *) c1->cd(idx++); // c1->Update(); // p->SetLogy(); // p->SetGridx(0); // p->SetGridy(0); // // TH1 * h = (TH1 *) EnergySum_LG->DrawClone(); // h->GetXaxis()->SetRangeUser(0,500); // h->SetLineWidth(2); // h->SetLineColor(kBlue + 3); //// h->Sumw2(); // h->GetXaxis()->SetRangeUser(0, h->GetMean() + 5 * h->GetRMS()); // // p = (TPad *) c1->cd(idx++); // c1->Update(); //// p->SetLogy(); // p->SetGridx(0); // p->SetGridy(0); // // TH1 * h = (TH1 *) EnergySum_LG->DrawClone(); // h->GetXaxis()->SetRangeUser(0,500); // // TF1 * fgaus = new TF1("fgaus_HG", "gaus", 0, 100); // fgaus->SetParameters(1, h->GetMean() - 2 * h->GetRMS(), // h->GetMean() + 2 * h->GetRMS()); // h->Fit(fgaus, "M"); // // h->Sumw2(); // h->GetXaxis()->SetRangeUser(h->GetMean() - 4 * h->GetRMS(), // h->GetMean() + 4 * h->GetRMS()); // // h->SetLineWidth(2); // h->SetMarkerStyle(kFullCircle); // // h->SetTitle( // Form("#DeltaE/<E> = %.1f%%", // 100 * fgaus->GetParameter(2) / fgaus->GetParameter(1))); SaveCanvas(c1, TString(_file0->GetName()) + TString("_DrawPrototype4EMCalTower_") + TString(c1->GetName()), false); }
static PyObject * fill_hist_with_ndarray(PyObject *self, PyObject *args, PyObject* keywords) { using namespace std; PyObject *hist_ = NULL; PyObject *array_ = NULL; PyObject *weights_ = NULL; PyArrayObject *array = NULL; PyArrayObject *weights = NULL; TH1* hist = NULL; TH2* hist2d = NULL; TH3* hist3d = NULL; unsigned int dim = 1; unsigned int array_depth = 1; unsigned int i, n, k; char *array_data; char *weights_data = NULL; npy_intp array_stride_n; npy_intp array_stride_k = 1; npy_intp weights_stride = 1; static const char* keywordslist[] = { "hist", "array", "weights", NULL}; if(!PyArg_ParseTupleAndKeywords( args, keywords, "OO|O", const_cast<char **>(keywordslist), &hist_, &array_, &weights_)) { return NULL; } if(!PyCObject_Check(hist_)) { PyErr_SetString(PyExc_TypeError,"Unable to convert hist to PyCObject"); return NULL; } //this is not safe so be sure to know what you are doing type check in python first //this is a c++ limitation because void* have no vtable so dynamic cast doesn't work hist = static_cast<TH1*>(PyCObject_AsVoidPtr(hist_)); if (hist == NULL) { PyErr_SetString(PyExc_TypeError,"Unable to convert hist to TH1*"); return NULL; } dim = hist->GetDimension(); if (dim == 2) { hist2d = static_cast<TH2*>(PyCObject_AsVoidPtr(hist_)); if (hist2d == NULL) { PyErr_SetString(PyExc_TypeError,"Unable to convert hist to TH2*"); return NULL; } } else if (dim == 3) { hist3d = static_cast<TH3*>(PyCObject_AsVoidPtr(hist_)); if (hist3d == NULL) { PyErr_SetString(PyExc_TypeError,"Unable to convert hist to TH3*"); return NULL; } } else if (dim > 3) { PyErr_SetString(PyExc_ValueError,"dim must not be greater than 3"); return NULL; } if (dim > 1) array_depth = 2; array = (PyArrayObject *) PyArray_ContiguousFromAny( array_, PyArray_DOUBLE, array_depth, array_depth); if (array == NULL) { PyErr_SetString(PyExc_TypeError, "Unable to convert object to array"); return NULL; } if (dim > 1) { k = array->dimensions[1]; if (k != dim) { PyErr_SetString(PyExc_ValueError, "length of the second dimension must equal the dimension of the histogram"); Py_DECREF(array); return NULL; } array_stride_k = array->strides[1]; } n = array->dimensions[0]; array_stride_n = array->strides[0]; array_data = array->data; if (weights_) { weights = (PyArrayObject *) PyArray_ContiguousFromAny( weights_, PyArray_DOUBLE, 1, 1); if (weights == NULL) { PyErr_SetString(PyExc_TypeError, "Unable to convert object to array"); Py_DECREF(array); return NULL; } if (n != weights->dimensions[0]) { PyErr_SetString(PyExc_ValueError, "array and weights must have the same length"); Py_DECREF(weights); Py_DECREF(array); return NULL; } weights_data = weights->data; weights_stride = weights->strides[0]; } if (dim == 1) { // weighted fill if (weights) { for (i = 0; i < n; ++i) { hist->Fill( *(double *)(array_data + i * array_stride_n), *(double *)(weights_data + i * weights_stride)); } } else { // unweighted fill for (i = 0; i < n; ++i) { hist->Fill(*(double *)(array_data + i * array_stride_n)); } } } else if (dim == 2) { // weighted fill if (weights) { for (i = 0; i < n; ++i) { hist2d->Fill( *(double *)(array_data + i * array_stride_n), *(double *)(array_data + i * array_stride_n + array_stride_k), *(double *)(weights_data + i * weights_stride)); } } else { // unweighted fill for (i = 0; i < n; ++i) { hist2d->Fill( *(double *)(array_data + i * array_stride_n), *(double *)(array_data + i * array_stride_n + array_stride_k)); } } } else if (dim == 3) { // weighted fill if (weights) { for (i = 0; i < n; ++i) { hist3d->Fill( *(double *)(array_data + i * array_stride_n), *(double *)(array_data + i * array_stride_n + array_stride_k), *(double *)(array_data + i * array_stride_n + 2 * array_stride_k), *(double *)(weights_data + i * weights_stride)); } } else { // unweighted fill for (i = 0; i < n; ++i) { hist3d->Fill( *(double *)(array_data + i * array_stride_n), *(double *)(array_data + i * array_stride_n + array_stride_k), *(double *)(array_data + i * array_stride_n + 2 * array_stride_k)); } } } if (weights) Py_DECREF(weights); Py_DECREF(array); Py_RETURN_NONE; }
void Opt_ntuple_midmass_200(){ gROOT->Reset(); gROOT->SetStyle("Plain"); gStyle->SetHistLineWidth(2); gStyle->SetPalette(1); gStyle->SetOptStat(1111); TChain * f_chain = new TChain("MyTree"); f_chain->Add("/home/jalmond/Analysis/LQanalyzer/data/output/SSElectron_ntup/HNDiElectron_SKnonprompt_dilep_5_3_14.root"); f_chain->LoadTree(0) ; TChain * f_chainmc = new TChain("MyTree"); f_chainmc->Add("/home/jalmond/Analysis/LQanalyzer/data/output/SSElectron_ntup/HNDiElectron_mc_5_3_14.root"); f_chainmc->LoadTree(0) ; TChain * f_chainsig = new TChain("MyTree"); f_chainsig->Add("/home/jalmond/Analysis/LQanalyzer/data/output/SSElectron_ntup/HNDiElectron_SKHNee200_nocut_5_3_14.root"); TFile * file = new TFile("/home/jalmond/Analysis/LQanalyzer/data/output/SSElectron_ntup/HNDiElectron_SKHNee200_nocut_5_3_14.root"); cout << file << endl; float k_met=0., k_eemass=0., k_eejjmass=0., k_e1jjmass=0., k_e2jjmass=0., k_st=0., k_ht; float k_weight=0.; int k_njet; float k_el1pt=0., k_el2pt=0., k_j1pt=0., k_jjmass=0.; f_chain->SetBranchAddress("met", &k_met); f_chain->SetBranchAddress("ee_mass", &k_eemass); f_chain->SetBranchAddress("eejj_mass", &k_eejjmass); f_chain->SetBranchAddress("e1jj_mass", &k_e1jjmass); f_chain->SetBranchAddress("e2jj_mass", &k_e2jjmass); f_chain->SetBranchAddress("jj_mass", &k_jjmass); f_chain->SetBranchAddress("st", &k_st); f_chain->SetBranchAddress("ht", &k_ht); f_chain->SetBranchAddress("njet", &k_njet); f_chain->SetBranchAddress("el1_pt", &k_el1pt); f_chain->SetBranchAddress("el2_pt", &k_el2pt); f_chain->SetBranchAddress("jet1_pt", &k_j1pt); f_chain->SetBranchAddress("weight", &k_weight); f_chainmc->SetBranchAddress("met", &k_met); f_chainmc->SetBranchAddress("ee_mass", &k_eemass); f_chainmc->SetBranchAddress("eejj_mass", &k_eejjmass); f_chainmc->SetBranchAddress("e1jj_mass", &k_e1jjmass); f_chainmc->SetBranchAddress("e2jj_mass", &k_e2jjmass); f_chainmc->SetBranchAddress("jj_mass", &k_jjmass); f_chainmc->SetBranchAddress("st", &k_st); f_chainmc->SetBranchAddress("ht", &k_ht); f_chainmc->SetBranchAddress("njet", &k_njet); f_chainmc->SetBranchAddress("el1_pt", &k_el1pt); f_chainmc->SetBranchAddress("el2_pt", &k_el2pt); f_chainmc->SetBranchAddress("jet1_pt", &k_j1pt); f_chainmc->SetBranchAddress("weight", &k_weight); f_chainsig->SetBranchAddress("met", &k_met); f_chainsig->SetBranchAddress("ee_mass", &k_eemass); f_chainsig->SetBranchAddress("eejj_mass", &k_eejjmass); f_chainsig->SetBranchAddress("e1jj_mass", &k_e1jjmass); f_chainsig->SetBranchAddress("e2jj_mass", &k_e2jjmass); f_chainsig->SetBranchAddress("jj_mass", &k_jjmass); f_chainsig->SetBranchAddress("st", &k_st); f_chainsig->SetBranchAddress("ht", &k_ht); f_chainsig->SetBranchAddress("njet", &k_njet); f_chainsig->SetBranchAddress("el1_pt", &k_el1pt); f_chainsig->SetBranchAddress("el2_pt", &k_el2pt); f_chainsig->SetBranchAddress("jet1_pt", &k_j1pt); f_chainsig->SetBranchAddress("weight", &k_weight); float sum_event =0.; for(Int_t i = 0; i < f_chain->GetEntries(); i++){ f_chain->GetEntry(i) ; if( (i % 100000) == 0) cout << "Bkg: N processing = " << i << endl; sum_event+= k_weight; } for(Int_t i = 0; i < f_chainmc->GetEntries(); i++){ f_chainmc->GetEntry(i) ; if( (i % 100000) == 0) cout << "Bkg: N processing = " << i << endl; sum_event+= k_weight; } float sum_sigevent =0.; for(Int_t i = 0; i < f_chainsig->GetEntries(); i++){ f_chainsig->GetEntry(i) ; if( (i % 100000) == 0) cout << "Sig: N processing = " << i << endl; sum_sigevent+=k_weight; } cout << "Total bkg = " << sum_event << endl; cout << "Total sig = " << sum_sigevent << endl; std::vector<float> METcut; METcut.push_back(35.); int imet_opt=0; float imeejjmin_opt=0.; float imeejjmax_opt=0.; float ipt1_opt=0.; float ipt2_opt=0.; float sig_eff_opt=0.; float sig_eff_opt_presel=0.; float cut_sum_opt=0.; float opt_cut_sb=0.; float ieemin_opt=0.; float ieemax_opt=0.; float ie2jjmin_opt=0.; float ie2jjmax_opt=0.; float ie1jjmin_opt=0.; float ie1jjmax_opt=0.; float istmin_opt=0.; float istmax_opt=0.; float ihtmin_opt=0.; float ihtmax_opt=0.; float ijetpt_opt=0.; int injet_opt=0.; TH1* hnsig = (TH1F*)file->Get(("eventcutflow")); float nsig = float(hnsig->GetBinContent(2)); cout << "Number of signal events before any cut = " << nsig << endl; for(unsigned int imet=0; imet < METcut.size(); imet++){ float met_cut = METcut.at(imet); cout << "MET : "<< met_cut << endl; for(int imeejjmin= 20; imeejjmin < 27. ; imeejjmin++){ float meejjmin_cut = float(imeejjmin) * 10.; for(int imeejjmax= 0; imeejjmax <1. ; imeejjmax++){ float meejjmax_cut = 10000.+ float(imeejjmax)*20.; cout << meejjmin_cut << " < M(eejj) < "<< meejjmax_cut << endl; for(int ipt1= 9; ipt1 < 10. ; ipt1++){ float pt1_cut = 20. + float(ipt1)*5.; for(int ipt2= 0; ipt2 < 1. ; ipt2++){ float pt2_cut = 15. + float(ipt2)*5.; if(pt2_cut > pt1_cut) continue; cout << "pt1_cut = " << pt1_cut << " pt2_cut = " << pt2_cut << endl; for(int ieemin =0 ; ieemin < 6 ; ieemin++){ float eemin_cut = 10. + float(ieemin)* 5.; if(ieemin == 5) eemin_cut = 100.; for(int ieemax =0 ; ieemax <1 ; ieemax++){ float eemax_cut = 100000.; for(int ie1jjmin =8 ; ie1jjmin < 9 ; ie1jjmin++){ float e1jjmin_cut = 0. + float(ie1jjmin)* 10.; for(int ie1jjmax =0 ; ie1jjmax < 1 ; ie1jjmax++){ float e1jjmax_cut = 10000. + float(ie1jjmax)* 20.; for(int ie2jjmin =0 ; ie2jjmin < 2 ; ie2jjmin++){ float e2jjmin_cut = 120. + float(ie2jjmin)* 10.; for(int ie2jjmax =0 ; ie2jjmax < 15 ; ie2jjmax++){ float e2jjmax_cut = 200. + float(ie2jjmax)* 10.; if(ie2jjmax == 9) e2jjmax_cut = 10000.; for(int ihtmin =0 ; ihtmin < 1 ; ihtmin++){ float htmin_cut = 50. + float(ihtmin)*5.; for(int ihtmax =16 ; ihtmax < 17 ; ihtmax++){ float htmax_cut =10000. + float(ihtmax)*25.; for(int istmin =0 ; istmin < 1 ; istmin++){ float stmin_cut = float(istmin)*10.; for(int istmax =45 ; istmax < 46 ; istmax++){ float stmax_cut = 10000. + float(istmax) *10.; for(int ijpt =2 ; ijpt <3 ; ijpt++){ float jetpt_cut = 20. + float(ijpt)*5.; for(int injet = 14 ; injet< 15 ; injet ++){ /// Optmise cuts: float cut_sum=0.; float np_sum=0.; for(Int_t i = 0; i < f_chain->GetEntries(); i++){ f_chain->GetEntry(i) ; if(k_eemass > 80. && k_eemass < 100) continue; if(k_jjmass > 110.) continue; if(k_jjmass < 50.) continue; if(k_e1jjmass < e1jjmin_cut) continue; if(k_e1jjmass > e1jjmax_cut) continue; if(k_e2jjmass < e2jjmin_cut) continue; if(k_e2jjmass > e2jjmax_cut) continue; if(k_eemass < eemin_cut) continue; if(k_eemass > eemax_cut) continue; if(k_met > met_cut) continue; if(k_eejjmass < meejjmin_cut) continue; if(k_eejjmass > meejjmax_cut) continue; if(k_st < stmin_cut) continue; if(k_st > stmax_cut) continue; if(k_ht < htmin_cut) continue; if(k_ht > htmax_cut) continue; if(k_j1pt < jetpt_cut) continue; if(k_el1pt < pt1_cut) continue; if(k_el2pt < pt2_cut) continue; if(k_njet> injet) continue; cut_sum+=k_weight; np_sum+=k_weight; } for(Int_t i = 0; i < f_chainmc->GetEntries(); i++){ f_chainmc->GetEntry(i) ; if(k_jjmass > 110.) continue; if(k_jjmass < 50.) continue; if(k_eemass > 80. && k_eemass < 100) continue; if(k_eemass < eemin_cut) continue; if(k_eemass > eemax_cut) continue; if(k_e1jjmass < e1jjmin_cut) continue; if(k_e1jjmass > e1jjmax_cut) continue; if(k_e2jjmass < e2jjmin_cut) continue; if(k_e2jjmass > e2jjmax_cut) continue; if(k_met > met_cut) continue; if(k_eejjmass < meejjmin_cut) continue; if(k_eejjmass > meejjmax_cut) continue; if(k_st < stmin_cut) continue; if(k_st > stmax_cut) continue; if(k_ht < htmin_cut) continue; if(k_ht > htmax_cut) continue; if(k_j1pt < jetpt_cut) continue; if(k_el1pt < pt1_cut) continue; if(k_el2pt < pt2_cut) continue; if(k_njet> injet) continue; cut_sum+=k_weight; } float cut_sum_sig=0.; for(Int_t i = 0; i < f_chainsig->GetEntries(); i++){ f_chainsig->GetEntry(i) ; if(k_eemass > 80. && k_eemass < 100) continue; if(k_jjmass > 110.) continue; if(k_jjmass < 50.) continue; if(k_e1jjmass < e1jjmin_cut) continue; if(k_e1jjmass > e1jjmax_cut) continue; if(k_e2jjmass < e2jjmin_cut) continue; if(k_e2jjmass > e2jjmax_cut) continue; if(k_eemass < eemin_cut) continue; if(k_eemass > eemax_cut) continue; if(k_met > met_cut)continue; if(k_eejjmass < meejjmin_cut) continue; if(k_eejjmass > meejjmax_cut) continue; if(k_st < stmin_cut) continue; if(k_st > stmax_cut) continue; if(k_ht < htmin_cut) continue; if(k_ht > htmax_cut) continue; if(k_j1pt < jetpt_cut) continue; if(k_el1pt < pt1_cut) continue; if(k_el2pt < pt2_cut) continue; if(k_njet> injet) continue; cut_sum_sig+=k_weight; } float sig_eff = cut_sum_sig /nsig ; float total_bkg = cut_sum; float bkgtmp = total_bkg + (0.28* np_sum)* (0.28* np_sum); float denom = 1. + sqrt(bkgtmp); float punzi = sig_eff / denom; if( (punzi) > opt_cut_sb){ opt_cut_sb = punzi; imet_opt = imet; injet_opt = injet; imeejjmin_opt = meejjmin_cut; imeejjmax_opt = meejjmax_cut; ipt1_opt= pt1_cut; ipt2_opt= pt2_cut; ieemin_opt = eemin_cut; ieemax_opt = eemax_cut; ie1jjmin_opt = e1jjmin_cut; ie1jjmax_opt = e1jjmax_cut; ie2jjmin_opt = e2jjmin_cut; ie2jjmax_opt = e2jjmax_cut; istmin_opt = stmin_cut; istmax_opt = stmax_cut; ihtmin_opt = htmin_cut; ihtmax_opt = htmax_cut; ijetpt_opt = jetpt_cut; sig_eff_opt = sig_eff; sig_eff_opt_presel = cut_sum_sig / sum_sigevent; cut_sum_opt= cut_sum; cout << "Max punzi = " << punzi << " : nbkg = " << total_bkg << " : %sig = " << sig_eff_opt_presel*100. << endl; } } }//jetpt } } } } }//stmax }//stmin }//e2jjmax }//eemax }//eemin }//pt2 }//pt1 }// meejjmax }/// meejjmin }/// MET } //Opt cut cout << "Opt punzi = " << opt_cut_sb << endl; cout << "Opt cut : MET < " << METcut.at(imet_opt) << endl; cout << "Opt cut : njet < " << injet_opt<< endl; cout << "Opt cut : " << imeejjmin_opt << " < M(eejj) < " << imeejjmax_opt << endl; cout << "Opt cut : " << ie1jjmin_opt << " < M(e1jj) < " << ie1jjmax_opt << endl; cout << "Opt cut : " << ie2jjmin_opt << " < M(e2jj) < " << ie2jjmax_opt << endl; cout << "Opt cut : " << ieemin_opt << " < M(ee) < " << ieemax_opt<< endl; cout << "Opt cut : " << istmin_opt << " < ST < " << istmax_opt<< endl; cout << "Opt cut : " << ihtmin_opt << " < HT < " << ihtmax_opt<< endl; cout << "Opt pt1 = " << ipt1_opt << endl; cout << "Opt pt2 = " << ipt2_opt << endl; cout << "Opt jet1pt = " << ijetpt_opt << endl; cout << "Cut (opt) eff. bkg = " << cut_sum_opt/sum_event << " nbkg = " << cut_sum_opt << endl; cout << "Cut eff .sig = " << sig_eff_opt << " : wrt preselection "<< sig_eff_opt_presel*100 << endl; }
int main(int argc, char* argv[]) { TFile* dataFile=TFile::Open("pu_truth_data2015_50bins.root"); TFile* mcFile = TFile::Open("computed_mc_GJET_plus_QCD_pu_truth_50bins.root"); TH1* dataHisto = static_cast<TH1*>(dataFile->Get("pileup")); TH1* mcHisto = static_cast<TH1*>(mcFile->Get("pileup")); TFile f1("/cmshome/fpreiato/GammaJet/CMSSW_7_4_14/src/JetMETCorrections/GammaJetFilter/analysis/tuples/GJET_MC/PhotonJet_2ndLevel_GJet_Pt-15To6000_TuneCUETP8M1-Flat_13TeV_pythia8_25ns_ReReco.root"); TTree* AnalysisTree_mc = (TTree*) f1.Get("gammaJet/analysis"); uint64_t totalEvents_mc = AnalysisTree_mc->GetEntries(); /////////////////////////////////////////////////////////////////// // Normalize dataHisto->Scale(1.0 / dataHisto->Integral()); mcHisto->Scale(1.0 / mcHisto->Integral()); TCanvas *c1 = new TCanvas("c1","c1",800,800); dataHisto-> SetLineColor(kBlue); mcHisto -> SetLineColor(kRed); dataHisto -> Draw(); mcHisto -> Draw("same"); c1-> SaveAs("Plot/pileup_truth.png"); // c1-> SaveAs("pileup_truth.root"); // MC * data / MC = data, so the weights are data/MC: TH1* ratioHisto = static_cast<TH1*>(dataHisto->Clone()); ratioHisto->Divide(mcHisto); int NBins = ratioHisto->GetNbinsX(); for (int ibin = 1; ibin < NBins + 1; ++ibin) { std::cout << " " << ibin - 1 << " " << ratioHisto->GetBinContent(ibin) << std::endl; } TCanvas *c2 = new TCanvas("c2","c2",800,800); ratioHisto -> Draw(); c2-> SaveAs("Plot/ratioHisto.png"); // c2-> SaveAs("ratioHisto.root"); TH1D* mcHisto_reweighted = new TH1D("mcHisto_reweighted", "mc Reweighted", 50, 0, 50); for (uint64_t i = 0; i < totalEvents_mc; i++) { if(i == 0 || i % 5000 == 0) cout<< "Events processed "<< i <<endl; AnalysisTree_mc->GetEntry(i); Float_t interaction; AnalysisTree_mc->SetBranchAddress("ntrue_interactions", &interaction); //cout<< ptPhot << endl; int bin = ratioHisto ->GetXaxis()-> FindBin(interaction); float PUweight = ratioHisto -> GetBinContent(bin); double generator_weight; AnalysisTree_mc->SetBranchAddress("generator_weight", &generator_weight); if(generator_weight == 0) generator_weight = 1; float event_weight; AnalysisTree_mc->SetBranchAddress("evtWeightTot", &event_weight); double Weight = PUweight* generator_weight * event_weight; // cout<< "nvertex "<< nvertex_mc<<endl; // cout<< "PUWeight "<< PUweight<<endl; mcHisto_reweighted -> Fill(interaction, Weight); } mcHisto_reweighted ->Scale(1.0 / mcHisto_reweighted->Integral()); TCanvas *c3 = new TCanvas("c3","c3",800,800); dataHisto -> SetLineColor(kBlue); mcHisto_reweighted -> SetLineColor(kRed); dataHisto -> Draw(); mcHisto_reweighted -> Draw("same"); c3-> SaveAs("Plot/Histo_reweighted.png"); // c3-> SaveAs("Histo_reweighted.root"); }//main
TCanvas *trackSplitPlot(Int_t nFiles,TString *files,TString *names,TString xvar,TString yvar, Bool_t relative = kFALSE,Bool_t logscale = kFALSE,Bool_t resolution = kFALSE,Bool_t pull = kFALSE, TString saveas = "") { cout << xvar << " " << yvar << endl; if (xvar == "" && yvar == "") return 0; PlotType type; if (xvar == "") type = Histogram; else if (yvar == "") type = OrgHistogram; else if (resolution) type = Resolution; else if (nFiles < 1) type = ScatterPlot; else type = Profile; if (nFiles < 1) nFiles = 1; const Int_t n = nFiles; TStyle *tdrStyle = setTDRStyle(); tdrStyle->SetOptStat(0); if ((type == Histogram || type == OrgHistogram) && nFiles == 1) tdrStyle->SetOptStat(1110); if (type == ScatterPlot || (type == Histogram && !pull) || xvar == "runNumber") { tdrStyle->SetCanvasDefW(678); tdrStyle->SetPadRightMargin(0.115); } Bool_t nHits = (xvar[0] == 'n' && xvar[1] == 'H' && xvar[2] == 'i' && xvar[3] == 't' && xvar[4] == 's'); Int_t nBinsScatterPlotx = binsScatterPlotx; Int_t nBinsScatterPloty = binsScatterPloty; Int_t nBinsHistogram = binsHistogram; Int_t nBinsProfileResolution = binsProfileResolution; if (xvar == "runNumber") { nBinsProfileResolution = runNumberBins; nBinsHistogram = runNumberBins; } if (nHits) { nBinsHistogram = (int)(findMax(nFiles,files,xvar,'x') - findMin(nFiles,files,xvar,'x') + 1.1); //in case it's .99999 nBinsScatterPlotx = nBinsHistogram; nBinsProfileResolution = nBinsHistogram; } TH1 **p = new TH1*[n]; Int_t lengths[n]; stringstream sx,sy,srel,ssigma1,ssigma2,ssigmaorg; sx << xvar << "_org"; TString xvariable = sx.str(); TString xvariable2 = ""; if (xvar == "runNumber") xvariable = "runNumber"; if (nHits) { xvariable = xvar; xvariable2 = xvar; xvariable.Append("1_spl"); xvariable2.Append("2_spl"); } sy << "Delta_" << yvar; TString yvariable = sy.str(); TString relvariable = "1"; if (relative) { srel << yvar << "_org"; relvariable = srel.str(); } TString sigma1variable = "",sigma2variable = ""; if (pull) { ssigma1 << yvar << "1Err_spl"; ssigma2 << yvar << "2Err_spl"; } sigma1variable = ssigma1.str(); sigma2variable = ssigma2.str(); TString sigmaorgvariable = ""; if (pull && relative) ssigmaorg << yvar << "Err_org"; sigmaorgvariable = ssigmaorg.str(); Double_t xmin = -1,xmax = 1,ymin = -1,ymax = 1; if (type == Profile || type == ScatterPlot || type == OrgHistogram || type == Resolution) axislimits(nFiles,files,xvar,'x',relative,pull,xmin,xmax); if (type == Profile || type == ScatterPlot || type == Histogram || type == Resolution) axislimits(nFiles,files,yvar,'y',relative,pull,ymin,ymax); TString meansrmss[n]; for (Int_t i = 0; i < n; i++) { TFile *f = TFile::Open(files[i]); TTree *tree = (TTree*)f->Get("splitterTree"); stringstream sid; sid << "p" << i; TString id = sid.str(); TH1F **q = new TH1F*[nBinsProfileResolution]; if (type == ScatterPlot) p[i] = new TH2F(id,"",nBinsScatterPlotx,xmin,xmax,nBinsScatterPloty,ymin,ymax); if (type == Histogram) p[i] = new TH1F(id,"",nBinsHistogram,ymin,ymax); if (type == OrgHistogram) p[i] = new TH1F(id,"",nBinsHistogram,xmin,xmax); if (type == Resolution || type == Profile) { p[i] = new TH1F(id,"",nBinsProfileResolution,xmin,xmax); for (Int_t j = 0; j < nBinsProfileResolution; j++) { stringstream sid2; sid2 << "q" << j; TString id2 = sid2.str(); q[j] = new TH1F(id2,"",nBinsHistogram,ymin,ymax); } } p[i]->SetDirectory(0); lengths[i] = tree->GetEntries(); if (files[i].Contains("MC") && xvar == "runNumber") { p[i]->SetLineColor(kWhite); p[i]->SetMarkerColor(kWhite); f->Close(); continue; } Double_t x = 0, y = 0, rel = 1, sigma1 = 1, sigma2 = 1, //if !pull, we want to divide by sqrt(2) because we want the error from 1 track sigmaorg = 0; Int_t xint = 0, xint2 = 0; Int_t runNumber = 0; if (!relative && !pull && (yvar == "dz" || yvar == "dxy")) rel = 1e-4; //it's in cm but we want it in um, so divide by 1e-4 tree->SetBranchAddress("runNumber",&runNumber); if (type == Profile || type == ScatterPlot || type == Resolution || type == OrgHistogram) { if (xvar == "runNumber") tree->SetBranchAddress(xvariable,&xint); else if (nHits) { tree->SetBranchAddress(xvariable,&xint); tree->SetBranchAddress(xvariable2,&xint2); } else tree->SetBranchAddress(xvariable,&x); } if (type == Profile || type == ScatterPlot || type == Resolution || type == Histogram) tree->SetBranchAddress(yvariable,&y); if (relative && xvar != yvar) //if xvar == yvar, setting the branch here will undo setting it to x 2 lines earlier tree->SetBranchAddress(relvariable,&rel); if (pull) { tree->SetBranchAddress(sigma1variable,&sigma1); tree->SetBranchAddress(sigma2variable,&sigma2); } if (relative && pull) tree->SetBranchAddress(sigmaorgvariable,&sigmaorg); Int_t notincluded = 0; for (Int_t j = 0; j<lengths[i]; j++) { tree->GetEntry(j); if (xvar == "runNumber" || nHits) x = xint; if (xvar == "runNumber") runNumber = x; if (runNumber < minrun || (runNumber > maxrun && maxrun > 0)) { notincluded++; continue; } if (relative && xvar == yvar) { rel = x; } Double_t error = 0; if (relative && pull) error = sqrt((sigma1/rel)*(sigma1/rel) + (sigma2/rel)*(sigma2/rel) + (sigmaorg*y/(rel*rel))*(sigmaorg*x/(rel*rel))); else error = sqrt(sigma1 * sigma1 + sigma2 * sigma2); // = sqrt(2) if !pull, to get the error in 1 track y /= (rel * error); if (logscale) y = fabs(y); if (ymin <= y && y < ymax && xmin <= x && x < xmax) { if (type == Histogram) p[i]->Fill(y); if (type == ScatterPlot) p[i]->Fill(x,y); if (type == Resolution || type == Profile) { int which = (p[i]->Fill(x,0)) - 1; if (which >= 0) q[which]->Fill(y); //get which q[j] by filling p[i] (with nothing), which returns the bin number } if (type == OrgHistogram) p[i]->Fill(x); } if (nHits) { x = xint2; if (ymin <= y && y < ymax && xmin <= x && x < xmax) { if (type == Histogram) p[i]->Fill(y); if (type == ScatterPlot) p[i]->Fill(x,y); if (type == Resolution || type == Profile) { int which = (p[i]->Fill(x,0)) - 1; if (which >= 0) q[which]->Fill(y); //get which q[j] by filling p[i] (with nothing), which returns the bin number } if (type == OrgHistogram) p[i]->Fill(x); } } if (((j+1)/(int)(pow(10,(int)(log10(lengths[i]))-1)))*(int)(pow(10,(int)(log10(lengths[i]))-1)) == j + 1 || j + 1 == lengths[i]) { cout << j + 1 << "/" << lengths[i] << ": "; if (type == Profile || type == ScatterPlot || type == Resolution) cout << x << ", " << y << endl; if (type == OrgHistogram) cout << x << endl; if (type == Histogram) cout << y << endl; } } lengths[i] -= notincluded; meansrmss[i] = ""; if (type == Histogram || type == OrgHistogram) { cout << "Average = " << p[i]->GetMean() << endl; cout << "RMS = " << p[i]->GetRMS() << endl; stringstream meanrms; meanrms.precision(3); meanrms << "#mu=" << p[i]->GetMean() << ", #sigma=" << p[i]->GetRMS(); meansrmss[i] = meanrms.str(); } if (type == Resolution) { for (Int_t j = 0; j < nBinsProfileResolution; j++) { p[i]->SetBinContent(j+1,q[j]->GetRMS()); p[i]->SetBinError (j+1,q[j]->GetRMSError()); delete q[j]; } } if (type == Profile) { for (Int_t j = 0; j < nBinsProfileResolution; j++) { p[i]->SetBinContent(j+1,q[j]->GetMean()); p[i]->SetBinError (j+1,q[j]->GetMeanError()); delete q[j]; } } delete[] q; setAxisLabels(p[i],type,xvar,yvar,relative,pull); p[i]->SetLineColor(colors[i]); if (type == Resolution || type == Profile) { p[i]->SetMarkerColor(colors[i]); p[i]->SetMarkerStyle(20+i); } else { p[i]->SetMarkerStyle(1); } f->Close(); } TCanvas *c1 = TCanvas::MakeDefCanvas(); if (type == ScatterPlot || type == Profile || type == Resolution || type == OrgHistogram) c1->SetLogy((Bool_t)(logscale)); if (type == Histogram) c1->SetLogx((Bool_t)(logscale)); TH1 *maxp = p[0]; TGraphErrors *g[n]; TMultiGraph *list = new TMultiGraph(); if (type == ScatterPlot) p[0]->Draw("COLZ"); else if (type == Resolution || type == Profile) { for (Int_t i = 0; i < n; i++) { if (files[i].Contains("MC") && xvar == "runNumber") continue; g[i] = new TGraphErrors(p[i]); for (Int_t j = 0; j < g[i]->GetN(); j++) { if (g[i]->GetY()[j] == 0 && g[i]->GetEY()[j] == 0) { g[i]->RemovePoint(j); j--; } } list->Add(g[i]); } list->Draw("AP"); Double_t yaxismax = list->GetYaxis()->GetXmax(); Double_t yaxismin = list->GetYaxis()->GetXmin(); if (yaxismin > 0) { yaxismax += yaxismin; yaxismin = 0; } p[0]->GetYaxis()->SetRangeUser(yaxismin,yaxismax); p[0]->Draw("P"); } else if (type == Histogram || type == OrgHistogram) { Bool_t allthesame = true; for (Int_t i = 1; i < n && allthesame; i++) { if (lengths[i] != lengths[0]) allthesame = false; } if (!allthesame && xvar != "runNumber") for (Int_t i = 0; i < n; i++) { p[i]->Scale(1.0/lengths[i]); } maxp = (TH1F*)p[0]->Clone("maxp"); maxp->SetLineColor(kWhite); for (Int_t i = 1; i <= maxp->GetNbinsX(); i++) { for (Int_t j = 0; j < n; j++) { if (files[j].Contains("MC") && xvar == "runNumber") continue; maxp->SetBinContent(i,TMath::Max(maxp->GetBinContent(i),p[j]->GetBinContent(i))); } } maxp->Draw(); p[0]->Draw("same"); } TLegend *legend = new TLegend(.6,.7,.9,.9,"","br"); if (n == 1 && files[0].Contains("MC") && xvar == "runNumber") { placeholder(saveas,yvar == ""); return 0; } if (n>=2) { if (!(files[0].Contains("MC") && xvar == "runNumber") && files[0] != "") { if (type == Resolution || type == Profile) legend->AddEntry(p[0],names[0],"pl"); else if (type == Histogram || type == OrgHistogram) { legend->AddEntry(p[0],names[0],"l"); legend->AddEntry((TObject*)0,meansrmss[0],""); } } for (Int_t i = 1; i < n; i++) { if (files[i].Contains("MC") && xvar == "runNumber") continue; if (type == Resolution || type == Profile) { p[i]->Draw("same P"); legend->AddEntry(p[i],names[i],"pl"); } else if (type == Histogram || type == OrgHistogram) { p[i]->Draw("same"); legend->AddEntry(p[i],names[i],"l"); legend->AddEntry((TObject*)0,meansrmss[i],""); } } if (legend->GetListOfPrimitives()->At(0) == 0) { delete legend; placeholder(saveas,yvar == ""); return 0; } c1->Update(); Double_t x1min = .98*gPad->GetUxmin() + .02*gPad->GetUxmax(); Double_t x2max = .02*gPad->GetUxmin() + .98*gPad->GetUxmax(); Double_t y1min = .98*gPad->GetUymin() + .02*gPad->GetUymax(); Double_t y2max = .02*gPad->GetUymin() + .98*gPad->GetUymax(); Double_t width = .4*(x2max-x1min); Double_t height = (1./20)*legend->GetListOfPrimitives()->GetEntries()*(y2max-y1min); if (type == Histogram || type == OrgHistogram) { width *= 2; height /= 2; legend->SetNColumns(2); } Double_t newy2max = placeLegend(legend,width,height,x1min,y1min,x2max,y2max); maxp->GetYaxis()->SetRangeUser(gPad->GetUymin(),(newy2max-.02*gPad->GetUymin())/.98); legend->SetFillStyle(0); legend->Draw(); } if (saveas != "") { saveplot(c1,saveas); for (int i = 0; i < n; i++) { //delete p[i]; //delete g[i]; } //delete list; //delete maxp; //delete legend; } return c1; }
void makePlot(double canvasSizeX, double canvasSizeY, TH1* histogramTTH, TH1* histogramData, TH1* histogramTT, TH1* histogramTTV, TH1* histogramEWK, TH1* histogramRares, TH1* histogramBgrSum, TH1* histogramBgrUncertainty, const std::string& xAxisTitle, double xAxisOffset, bool useLogScale, double yMin, double yMax, const std::string& yAxisTitle, double yAxisOffset, const std::string& outputFileName) { TH1* histogramTTH_density = 0; if ( histogramTTH ) { if ( histogramData ) checkCompatibleBinning(histogramTTH, histogramData); histogramTTH_density = divideHistogramByBinWidth(histogramTTH); } TH1* histogramData_density = 0; if ( histogramData ) { histogramData_density = divideHistogramByBinWidth(histogramData); } TH1* histogramTT_density = 0; if ( histogramTT ) { if ( histogramData ) checkCompatibleBinning(histogramTT, histogramData); histogramTT_density = divideHistogramByBinWidth(histogramTT); } TH1* histogramTTV_density = 0; if ( histogramTTV ) { if ( histogramData ) checkCompatibleBinning(histogramTTV, histogramData); histogramTTV_density = divideHistogramByBinWidth(histogramTTV); } TH1* histogramEWK_density = 0; if ( histogramEWK ) { if ( histogramData ) checkCompatibleBinning(histogramEWK, histogramData); histogramEWK_density = divideHistogramByBinWidth(histogramEWK); } TH1* histogramRares_density = 0; if ( histogramRares ) { if ( histogramData ) checkCompatibleBinning(histogramRares, histogramData); histogramRares_density = divideHistogramByBinWidth(histogramRares); } TH1* histogramBgrSum_density = 0; if ( histogramBgrSum ) { if ( histogramData ) checkCompatibleBinning(histogramBgrSum, histogramData); histogramBgrSum_density = divideHistogramByBinWidth(histogramBgrSum); } TH1* histogramBgrUncertainty_density = 0; if ( histogramBgrUncertainty ) { if ( histogramData ) checkCompatibleBinning(histogramBgrUncertainty, histogramData); histogramBgrUncertainty_density = divideHistogramByBinWidth(histogramBgrUncertainty); } TCanvas* canvas = new TCanvas("canvas", "", canvasSizeX, canvasSizeY); canvas->SetFillColor(10); canvas->SetFillStyle(4000); canvas->SetFillColor(10); canvas->SetTicky(); canvas->SetBorderSize(2); canvas->SetLeftMargin(0.12); canvas->SetBottomMargin(0.12); TPad* topPad = new TPad("topPad", "topPad", 0.00, 0.35, 1.00, 1.00); topPad->SetFillColor(10); topPad->SetTopMargin(0.065); topPad->SetLeftMargin(0.15); topPad->SetBottomMargin(0.03); topPad->SetRightMargin(0.05); topPad->SetLogy(useLogScale); TPad* bottomPad = new TPad("bottomPad", "bottomPad", 0.00, 0.00, 1.00, 0.35); bottomPad->SetFillColor(10); bottomPad->SetTopMargin(0.02); bottomPad->SetLeftMargin(0.15); bottomPad->SetBottomMargin(0.31); bottomPad->SetRightMargin(0.05); bottomPad->SetLogy(false); canvas->cd(); topPad->Draw(); topPad->cd(); TAxis* xAxis_top = histogramData_density->GetXaxis(); xAxis_top->SetTitle(xAxisTitle.data()); xAxis_top->SetTitleOffset(xAxisOffset); xAxis_top->SetLabelColor(10); xAxis_top->SetTitleColor(10); TAxis* yAxis_top = histogramData_density->GetYaxis(); yAxis_top->SetTitle(yAxisTitle.data()); yAxis_top->SetTitleOffset(yAxisOffset); yAxis_top->SetTitleSize(0.085); yAxis_top->SetLabelSize(0.05); yAxis_top->SetTickLength(0.04); TLegend* legend = new TLegend(0.66, 0.45, 0.94, 0.92, NULL, "brNDC"); legend->SetFillStyle(0); legend->SetBorderSize(0); legend->SetFillColor(10); legend->SetTextSize(0.055); histogramData_density->SetTitle(""); histogramData_density->SetStats(false); histogramData_density->SetMaximum(yMax); histogramData_density->SetMinimum(yMin); histogramData_density->SetMarkerStyle(20); histogramData_density->SetMarkerSize(2); histogramData_density->SetMarkerColor(kBlack); histogramData_density->SetLineColor(kBlack); legend->AddEntry(histogramData_density, "Observed", "p"); histogramData_density->Draw("ep"); legend->AddEntry(histogramTTH_density, "t#bar{t}H", "l"); histogramTT_density->SetTitle(""); histogramTT_density->SetStats(false); histogramTT_density->SetMaximum(yMax); histogramTT_density->SetMinimum(yMin); histogramTT_density->SetFillColor(kMagenta - 10); legend->AddEntry(histogramTT_density, "t#bar{t}+jets", "f"); histogramTTV_density->SetFillColor(kOrange - 4); legend->AddEntry(histogramTTV_density, "t#bar{t}+V", "f"); histogramEWK_density->SetFillColor(kRed + 2); legend->AddEntry(histogramEWK_density, "EWK", "f"); histogramRares_density->SetFillColor(kBlue - 8); legend->AddEntry(histogramRares_density, "Rares", "f"); THStack* histogramStack_density = new THStack("stack", ""); histogramStack_density->Add(histogramRares_density); histogramStack_density->Add(histogramEWK_density); histogramStack_density->Add(histogramTTV_density); histogramStack_density->Add(histogramTT_density); histogramStack_density->Draw("histsame"); histogramBgrUncertainty_density->SetFillColor(kBlack); histogramBgrUncertainty_density->SetFillStyle(3344); histogramBgrUncertainty_density->Draw("e2same"); legend->AddEntry(histogramBgrUncertainty_density, "Uncertainty", "f"); histogramTTH_density->SetLineWidth(2); histogramTTH_density->SetLineStyle(1); histogramTTH_density->SetLineColor(kBlue); histogramTTH_density->Draw("histsame"); histogramData_density->Draw("epsame"); histogramData_density->Draw("axissame"); legend->Draw(); addLabel_CMS_luminosity(0.2050, 0.9225, 0.6850); canvas->cd(); bottomPad->Draw(); bottomPad->cd(); TH1* histogramRatio = (TH1*)histogramData->Clone("histogramRatio"); histogramRatio->Reset(); if ( !histogramRatio->GetSumw2N() ) histogramRatio->Sumw2(); checkCompatibleBinning(histogramRatio, histogramBgrSum); histogramRatio->Divide(histogramData, histogramBgrSum); int numBins_bottom = histogramRatio->GetNbinsX(); for ( int iBin = 1; iBin <= numBins_bottom; ++iBin ) { double binContent = histogramRatio->GetBinContent(iBin); if ( histogramData && histogramData->GetBinContent(iBin) >= 0. ) histogramRatio->SetBinContent(iBin, binContent - 1.0); else histogramRatio->SetBinContent(iBin, -10.); } histogramRatio->SetTitle(""); histogramRatio->SetStats(false); histogramRatio->SetMinimum(-0.50); histogramRatio->SetMaximum(+0.50); histogramRatio->SetMarkerStyle(histogramData_density->GetMarkerStyle()); histogramRatio->SetMarkerSize(histogramData_density->GetMarkerSize()); histogramRatio->SetMarkerColor(histogramData_density->GetMarkerColor()); histogramRatio->SetLineColor(histogramData_density->GetLineColor()); histogramRatio->Draw("ep"); TAxis* xAxis_bottom = histogramRatio->GetXaxis(); xAxis_bottom->SetTitle(xAxis_top->GetTitle()); xAxis_bottom->SetLabelColor(1); xAxis_bottom->SetTitleColor(1); xAxis_bottom->SetTitleOffset(1.20); xAxis_bottom->SetTitleSize(0.13); xAxis_bottom->SetLabelOffset(0.02); xAxis_bottom->SetLabelSize(0.10); xAxis_bottom->SetTickLength(0.055); TAxis* yAxis_bottom = histogramRatio->GetYaxis(); yAxis_bottom->SetTitle("#frac{Data - Simulation}{Simulation}"); yAxis_bottom->SetTitleOffset(0.80); yAxis_bottom->SetNdivisions(505); yAxis_bottom->CenterTitle(); yAxis_bottom->SetTitleSize(0.09); yAxis_bottom->SetLabelSize(0.10); yAxis_bottom->SetTickLength(0.04); TH1* histogramRatioUncertainty = (TH1*)histogramBgrUncertainty->Clone("histogramRatioUncertainty"); if ( !histogramRatioUncertainty->GetSumw2N() ) histogramRatioUncertainty->Sumw2(); checkCompatibleBinning(histogramRatioUncertainty, histogramBgrUncertainty); histogramRatioUncertainty->Divide(histogramBgrSum); int numBins = histogramRatioUncertainty->GetNbinsX(); for ( int iBin = 1; iBin <= numBins; ++iBin ) { double binContent = histogramRatioUncertainty->GetBinContent(iBin); histogramRatioUncertainty->SetBinContent(iBin, binContent - 1.0); } histogramRatioUncertainty->SetFillColor(histogramBgrUncertainty_density->GetFillColor()); //histogramRatioUncertainty->SetFillStyle(histogramBgrUncertainty_density->GetFillStyle()); histogramRatioUncertainty->SetFillStyle(3644); TF1* line = new TF1("line","0", xAxis_bottom->GetXmin(), xAxis_bottom->GetXmax()); line->SetLineStyle(3); line->SetLineWidth(1); line->SetLineColor(kBlack); line->Draw("same"); histogramRatioUncertainty->Draw("e2same"); histogramRatio->Draw("epsame"); canvas->Update(); size_t idx = outputFileName.find("."); std::string outputFileName_plot(outputFileName, 0, idx); if ( useLogScale ) outputFileName_plot.append("_log"); else outputFileName_plot.append("_linear"); if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data()); canvas->Print(std::string(outputFileName_plot).append(".png").data()); canvas->Print(std::string(outputFileName_plot).append(".pdf").data()); canvas->Print(std::string(outputFileName_plot).append(".root").data()); delete histogramTTH_density; delete histogramData_density; delete histogramTT_density; delete histogramTTV_density; delete histogramEWK_density; delete histogramRares_density; delete histogramBgrSum_density; //delete histogramBgrUncertainty_density; delete histogramStack_density; delete legend; delete topPad; delete histogramRatio; delete histogramRatioUncertainty; delete line; delete bottomPad; delete canvas; }