void annconvergencetest( TDirectory *lhdir ) { TCanvas* c = new TCanvas( "MLPConvergenceTest", "MLP Convergence Test", 150, 0, 600, 580*0.8 ); TH1* estimatorHistTrain = (TH1*)lhdir->Get( "estimatorHistTrain" ); TH1* estimatorHistTest = (TH1*)lhdir->Get( "estimatorHistTest" ); Double_t m1 = estimatorHistTrain->GetMaximum(); Double_t m2 = estimatorHistTest ->GetMaximum(); Double_t max = TMath::Max( m1, m2 ); m1 = estimatorHistTrain->GetMinimum(); m2 = estimatorHistTest ->GetMinimum(); Double_t min = TMath::Min( m1, m2 ); estimatorHistTrain->SetMaximum( max + 0.1*(max - min) ); estimatorHistTrain->SetMinimum( min - 0.1*(max - min) ); estimatorHistTrain->SetLineColor( 2 ); estimatorHistTrain->SetLineWidth( 2 ); estimatorHistTrain->SetTitle( TString("MLP Convergence Test") ); estimatorHistTest->SetLineColor( 4 ); estimatorHistTest->SetLineWidth( 2 ); estimatorHistTrain->GetXaxis()->SetTitle( "Epochs" ); estimatorHistTrain->GetYaxis()->SetTitle( "Estimator" ); estimatorHistTrain->GetXaxis()->SetTitleOffset( 1.20 ); estimatorHistTrain->GetYaxis()->SetTitleOffset( 1.65 ); estimatorHistTrain->Draw(); estimatorHistTest ->Draw("same"); // need a legend TLegend *legend= new TLegend( 1 - c->GetRightMargin() - 0.45, 1-c->GetTopMargin() - 0.20, 1 - c->GetRightMargin() - 0.05, 1-c->GetTopMargin() - 0.05 ); legend->AddEntry(estimatorHistTrain,"Training Sample","l"); legend->AddEntry(estimatorHistTest,"Test sample","l"); legend->Draw("same"); legend->SetMargin( 0.3 ); c->cd(); TMVAGlob::plot_logo(); // don't understand why this doesn't work ... :-( c->Update(); TString fname = "plots/annconvergencetest"; TMVAGlob::imgconv( c, fname ); }
void ratioPlots( TCanvas* c1, TH1* h_r, TH1* h_i, string xTitle, string yTitle, string savePath, double fitMin=-100000, double fitMax=100000, bool doubleColFit=0 ){ double xMaximum = h_r->GetXaxis()->GetBinUpEdge(h_r->GetXaxis()->GetLast()); double xMinimum = h_r->GetXaxis()->GetBinLowEdge(h_r->GetXaxis()->GetFirst()); double yMaximum; double yMinimum; h_i->Sumw2(); h_r->Sumw2(); TLine* line1 = new TLine(xMinimum,1,xMaximum,1); line1->SetLineColor(1); line1->SetLineWidth(2); line1->SetLineStyle(7); TF1* fpol1 = new TF1("fpol1", "pol1", fitMin, fitMax); fpol1->SetLineColor(2); fpol1->SetLineWidth(3); fpol1->SetLineStyle(7); TH1* hRatio = (TH1*)h_r->Clone("clone_record"); hRatio->Divide(h_i); yMaximum = hRatio->GetMaximum(); yMinimum = hRatio->GetMinimum(0); hRatio->GetYaxis()->SetRangeUser(yMinimum/2.5,yMaximum+yMaximum/5); hRatio->SetXTitle(xTitle.c_str()); hRatio->SetYTitle(yTitle.c_str()); hRatio->SetLineColor(9); hRatio->SetLineWidth(2); hRatio->SetMarkerStyle(8); hRatio->Draw("e"); hRatio->Fit("fpol1", "L"); line1->Draw("SAME"); if(doubleColFit){ double p0=fpol1->GetParameter(0); double p1=fpol1->GetParameter(1); double endPoint=double(fitMax*p1)+p0; double p1new=(endPoint-1)/(fitMax-fitMin); char fun[100], text[100]; sprintf(fun,"x*(%f)+1",p1new); sprintf(text,"Tangent: %f",p1new); TF1* fnew = new TF1("fnew", fun, fitMin, fitMax); fnew->SetLineColor(2); fnew->SetLineWidth(3); fnew->Draw("SAME"); TText* Title = new TText( fitMax/12, yMinimum, text); Title->SetTextColor(2); Title->SetTextSize(0.035); Title->Draw("SAME"); } c1->SaveAs(savePath.c_str()); c1->cd(); }
// Draw pT balance plots void PlotOnCanvas(TH1& genHist, TH1& recoHist, TString plotname) { TLine* line1 = new TLine(1.0, genHist.GetMinimum(), 1.0, genHist.GetMaximum()); line1->SetLineColor(4); line1->SetLineWidth(2); TCanvas canvas("canvas", "", 880, 600); gStyle->SetOptStat(0); genHist.Draw("hist"); line1->Draw(); recoHist.Draw("same"); recoHist.Draw("HIST same"); leg_hist = new TLegend(0.6,0.65,0.85,0.85); leg_hist->AddEntry(&genHist,"Generator level","l"); leg_hist->AddEntry(&recoHist,"Calorimeter level","l"); leg_hist->SetFillColor(0); leg_hist->Draw(); canvas.SaveAs(plotname+TString(".eps")); canvas.SaveAs(plotname+TString(".gif")); canvas.SaveAs(plotname+TString(".root")); delete line1; delete leg_hist; }
void Test(TH1* h, TH1* s, const char* test) { // Check that hist and sparse are equal, print the test result cout << test << ": "; // What exactly is "equal"? // Define it as the max of 1/1000 of the "amplitude" of the // original hist, or 1E-4, whatever is larger. Double_t epsilon = 1E-4; Double_t diffH = h->GetMaximum() - h->GetMinimum(); if (diffH < 0.) diffH = -diffH; if (diffH / 1000. > epsilon) epsilon = diffH / 1000.; TH1* diff = (TH1*)s->Clone("diff"); diff->Add(h, -1); Double_t max = diff->GetMaximum(); Double_t min = diff->GetMinimum(); if (max < -min) max = -min; if (max < epsilon) cout << "SUCCESS"; else { cout << "FAIL: delta=" << max; TCanvas* c = new TCanvas(test, test); c->Divide(1,3); c->cd(1); h->Draw(); c->cd(2); s->Draw(); c->cd(3); diff->Draw(); TFile f("runsparse.root", "UPDATE"); c->Write(); delete c; } cout <<endl; delete diff; }
TH1F *stabilityHist(TGraphErrors *g_data, double& y_err_mean){ //------------------------------ Double_t *Y=g_data->GetY(); Double_t *EY = g_data->GetEY(); TH1 *obj = (TH1*) g_data->GetYaxis()->GetParent(); TH1F *hist_corr = new TH1F("hist_"+TString(g_data->GetName()),"", g_data->GetN(), obj->GetMinimum(), obj->GetMaximum()); hist_corr->GetXaxis()->SetLabelSize(0); hist_corr->GetYaxis()->SetLabelSize(0); for(int i =0; i < g_data->GetN(); i++){ hist_corr -> Fill(Y[i]); y_err_mean+=EY[i]; } y_err_mean/=g_data->GetN(); return hist_corr; }
//____________________________________________________________________ TH1* One(TDirectory* newDir, TDirectory* oldDir, Double_t c1, Double_t c2) { TString name; name.Form("cent%03dd%02d_%03dd%02d", Int_t(c1), Int_t(c1*100)%100, Int_t(c2), Int_t(c2*100)%100); TDirectory* newSubDir = GetD(newDir, name); TDirectory* oldSubDir = GetD(oldDir, name); if (!newSubDir || !oldSubDir) return 0; Int_t newDim = 0; if (TString(newDir->GetName()).Contains("etaipz")) newDim = 3; else if (TString(newDir->GetName()).Contains("eta")) newDim = 2; else if (TString(newDir->GetName()).Contains("const")) newDim = 1; Int_t oldDim = 0; if (TString(oldDir->GetName()).Contains("etaipz")) oldDim = 3; else if (TString(oldDir->GetName()).Contains("eta")) oldDim = 2; else if (TString(oldDir->GetName()).Contains("const")) oldDim = 1; TDirectory* newSubSubDir = GetD(newSubDir, Form("results%dd",newDim)); TDirectory* oldSubSubDir = GetD(oldSubDir, Form("results%dd",oldDim)); if (!newSubSubDir || !oldSubSubDir) return 0; TH1* newRes = GetH1(newSubSubDir, "result"); TH1* oldRes = GetH1(oldSubSubDir, "result"); if (!newRes || !oldRes) return 0; TH1* ratio = static_cast<TH1*>(newRes->Clone(name)); ratio->SetDirectory(0); ratio->SetTitle(Form("%5.1f - %5.1f%%", c1, c2)); ratio->SetYTitle("New / Old"); ratio->Divide(oldRes); fMin = TMath::Min(fMin, ratio->GetMinimum()); fMax = TMath::Max(fMax, ratio->GetMaximum()); Printf("Calculated %s/%s", newDir->GetName(), oldDir->GetName()); if (!fLegend) return ratio; TLegendEntry* e = fLegend->AddEntry("", Form("%3.0f - %3.0f%%", c1, c2), "f"); e->SetFillStyle(1001); e->SetFillColor(ratio->GetMarkerColor()); return ratio; }
void pidHistogramMaker::distributionReport( string pType ){ uint nBinsPt = ptBins.size() - 1; string rName = speciesName( pType, 0 ); taskProgress tp( pType + " distribution report", nBinsPt ); book->cd( "tof" ); for ( uint i = 0; i < nBinsPt; i ++ ){ tp.showProgress( i ); // momentum value used for finding nice range double p = ptBins[ i ]; double p2 = ptBins[ i + 1 ]; double avgP = 0.2; avgP = (ptBins[ i ] + ptBins[ i + 1])/2.0; string name = speciesName( pType, 0, i, 0 ); book->cd( "dedx_tof" ); TH2 * pTof = book->get2D( name ); book->cd( "scratch" ); TH2 * pDedx = (TH2*)pTof->Clone( "pDedx__" ); // start a new page on the report file pReport[ rName ]->newPage( 2, 2 ); // get information on plot ranges double tofLow, tofHigh, dedxLow, dedxHigh; autoViewport( pType, p, &tofLow, &tofHigh, &dedxLow, &dedxHigh, tofPadding, dedxPadding, tofScalePadding, dedxScalePadding ); if ( true ) { // show the tof proj string title = "#beta^{-1} : " + ts(ptBins[ i ], 4) + " < pT < " + ts(ptBins[i+1], 4); vector<string> others = otherSpecies( pType ); vector< double > tofMean = enhanceTof( pType, others, avgP ); vector< double > dedxMean = enhanceDedx( pType, others, avgP ); pReport[ rName ]->cd( 1, 1 ); //hdt->GetXaxis()->SetRangeUser( -.06, .06 ); // Make the all tof tracks histogram string hName = sTofName( pType, 0, i ); book->cd( "scratch" ); TH1* hTof = (TH1D*)pTof->ProjectionY( "_py" ); book->cd( "tof" ); book->add( hName, (TH1*)hTof->Clone( hName.c_str() ) ); book->style( hName )->set( "style.tof" ) ->set( "title", title )->draw(); TLine * l1 = new TLine( tofMean[ 0 ], hTof->GetMinimum(), tofMean[ 0 ], hTof->GetMaximum() ); l1->Draw(); TLine * l2 = new TLine( tofMean[ 1 ], hTof->GetMinimum(), tofMean[ 1 ], hTof->GetMaximum() ); l2->Draw(); pReport[ rName ]->cd( 2, 1 ); pTof->GetXaxis()->SetRangeUser( -.06, .06 ); // Make the all tof tracks histogram hName = sTofName( pType, 0, i, 0, pType ); book->cd( "scratch" ); hTof = (TH1D*)pTof->ProjectionY( "_py" ); book->cd( "tof" ); book->add( hName, (TH1*)hTof->Clone( hName.c_str() ) ); book->style( hName )->set( "style.tof" ) ->set( "title", title + " " + pType + " enhanced" )->draw(); for ( int j = 0; j < dedxMean.size(); j++ ){ pReport[ rName ]->cd( j+1, 2 ); pTof->GetXaxis()->SetRangeUser( dedxMean[j]-0.06, dedxMean[j]+0.06 ); // Make the all tof tracks histogram hName = sTofName( pType, 0, i, 0, others[ j ] ); book->cd( "scratch" ); hTof = (TH1D*)pTof->ProjectionY( "_py" ); book->cd( "tof" ); book->add( hName, (TH1*)hTof->Clone( hName.c_str() ) ); book->style( hName )->set( "style.tof" ) ->set( "title", title + " " + others[ j ] + " enhanced" )->draw(); } } pReport[ rName ]->savePage(); pReport[ rName ]->newPage( 2, 2 ); if ( true ) { // show the dedx proj string title = "dEdx : " + ts(ptBins[ i ], 4) + " < pT < " + ts(ptBins[i+1], 4); pTof->GetXaxis()->SetRange( 1, pTof->GetXaxis()->GetNbins() ); pTof->GetYaxis()->SetRange( 1, pTof->GetYaxis()->GetNbins() ); vector<string> others = otherSpecies( pType ); vector< double > tofMean = enhanceTof( pType, others, avgP ); vector< double > dedxMean = enhanceDedx( pType, others, avgP ); pReport[ rName ]->cd( 1, 1 ); // Make the all dedx tracks histogram string hName = sDedxName( pType, 0, i ); book->cd( "scratch" ); TH1* hDedx = (TH1D*)pTof->ProjectionX( "_px" ); book->cd( "dedx" ); book->add( hName, (TH1*)hDedx->Clone( hName.c_str() ) ); book->style( hName )->set( "style.dedx" ) ->set( "title", title )->draw(); TLine * l1 = new TLine( dedxMean[ 0 ], hDedx->GetMinimum(), dedxMean[ 0 ], hDedx->GetMaximum() ); l1->Draw(); TLine * l2 = new TLine( dedxMean[ 1 ], hDedx->GetMinimum(), dedxMean[ 1 ], hDedx->GetMaximum() ); l2->Draw(); pReport[ rName ]->cd( 2, 1 ); pTof->GetYaxis()->SetRangeUser( -.012, .012 ); // Make the all tof tracks histogram hName = sDedxName( pType, 0, i, 0, pType ); book->cd( "scratch" ); hDedx = (TH1D*)pTof->ProjectionX( "_px" ); book->cd( "dedx" ); book->add( hName, (TH1*)hDedx->Clone( hName.c_str() ) ); book->style( hName )->set( "style.dedx" ) ->set( "title", title + " " + pType + " enhanced" )->draw(); for ( int j = 0; j < dedxMean.size(); j++ ){ pReport[ rName ]->cd( j+1, 2 ); pTof->GetYaxis()->SetRangeUser( tofMean[j]-0.012, tofMean[j]+0.012 ); // Make the all tof tracks histogram hName = sDedxName( pType, 0, i, 0, others[ j ] ); book->cd( "scratch" ); hDedx = (TH1D*)pTof->ProjectionX( "_px" ); book->cd( "dedx" ); book->add( hName, (TH1*)hDedx->Clone( hName.c_str() ) ); book->style( hName )->set( "style.dedx" ) ->set( "title", title + " " + others[ j ] + " enhanced" )->draw(); } } pReport[ rName ]->savePage(); } }
void proc_pileup(const AliVdMMetaData& vdmMetaData, AliVdMScanData& allData, const char* classAC, const char* classAnotC, const char* classCnotA, const std::vector<Double_t>& par0) { typedef std::map<Short_t, TGraphErrors> map_t; // BCID -> TGraphErrors map_t gAnotC, gCnotA; // one-arm/two-arm ratios // (1) fill one-arm/two-arm ratio graphs for all BCIDs for (Int_t iScan=0; iScan<4; ++iScan) { AliVdMTree& vtAND = allData.GetMap(iScan)[classAC]; AliVdMTree& vtAnotC = allData.GetMap(iScan)[classAnotC]; AliVdMTree& vtCnotA = allData.GetMap(iScan)[classCnotA]; vtAND.Zip3([&gAnotC,&gCnotA](const AliVdMTree::DefaultBranchData& d, AliVdMTree::branchMap_t& mapAC, AliVdMTree::branchMap_t& mapAnotC, AliVdMTree::branchMap_t& mapCnotA) { AliVdMTree::ValErr v1 = mapAnotC["rate"]; v1 /= mapAC["rate"]; // v1 /= mapAC["relBkgd"]; v1 *= mapAnotC["relBkgd"]; if (!v1.isInf() && v1.val()) { const Int_t m1 = gAnotC[d.BCID()].GetN(); gAnotC[d.BCID()].SetPoint (m1, mapAC["mu"].val(), v1.val()); gAnotC[d.BCID()].SetPointError(m1, mapAC["mu"].err(), v1.err()); } AliVdMTree::ValErr v2 = mapCnotA["rate"]; v2 /= mapAC["rate"]; // v2 /= mapAC["relBkgd"]; v2 *= mapCnotA["relBkgd"]; if (!v2.isInf() && v2.val()) { const Int_t m2 = gCnotA[d.BCID()].GetN(); gCnotA[d.BCID()].SetPoint (m2, mapAC["mu"].val(), v2.val()); gCnotA[d.BCID()].SetPointError(m2, mapAC["mu"].err(), v2.err()); } }, vtAnotC, vtCnotA); } // (2) fit model AliVdMPileup pileupModel; TString pn = TString::Format("pileup_%s.pdf", classAC); TCanvas *c1 = new TCanvas; c1->SaveAs(pn+"["); const AliTriggerBCMask& bcMask = vdmMetaData.GetTriggerBCMask(); const Int_t nBCs = bcMask.GetNUnmaskedBCs(); TH1 *hPar[5] = { SetAttr(new TH1D("hrA", ";BCID;r_{A}", nBCs,0,nBCs), kRed), SetAttr(new TH1D("hrC", ";BCID;r_{C}", nBCs,0,nBCs), kBlue), SetAttr(new TH1D("hbkgdA", ";BCID;bkgd_{A}", nBCs,0,nBCs), kRed), SetAttr(new TH1D("hbkgdC", ";BCID;bkgd_{C}", nBCs,0,nBCs), kBlue), SetAttr(new TH1D("hChi2NDF", ";BCID;#chi^{2}/n.d.f.", nBCs,0,nBCs), kBlue) }; for (Int_t bc=0, counter=0; bc<3564; ++bc) { if (bcMask.GetMask(bc)) continue; const TString binLabel = TString::Format("%d", bc); for (Int_t i=0; i<5; ++i) hPar[i]->GetXaxis()->SetBinLabel(1+counter, binLabel); c1->Clear(); c1->SetLogx(); c1->SetLogy(); TH1 *hf = c1->DrawFrame(1e-6, 0.01, 0.5, 20); hf->SetTitle(TString::Format("BCID=%d %s;two-arm #mu;one-arm/two-arm", bc, classAC)); pileupModel.DoFit(&gAnotC[bc], &gCnotA[bc], &par0[0]); SetAttr(&gAnotC[bc], kBlue); SetAttr(&gCnotA[bc], kRed); gAnotC[bc].Draw("PE"); gCnotA[bc].Draw("PE"); TF1 *fAnotC = SetAttr(new TF1("fAnotC", &pileupModel, &AliVdMPileup::fcnAnotC, 1e-6, 0.5, 5), kBlue); fAnotC->SetParameters(pileupModel.GetPar()); fAnotC->SetNpx(1000); fAnotC->Draw("same"); TF1 *fCnotA = SetAttr(new TF1("fCnotA", &pileupModel, &AliVdMPileup::fcnCnotA, 1e-6, 0.5, 5), kRed); fCnotA->SetParameters(pileupModel.GetPar()); fCnotA->SetNpx(1000); fCnotA->Draw("same"); TLegend *leg = new TLegend(0.6, 0.75, 0.9, 0.9); leg->AddEntry(&gCnotA[bc], "AnotC/AandC", "PEL"); leg->AddEntry(&gAnotC[bc], "CnotA/AandC", "PEL"); leg->Draw(); TPaveText *pt = new TPaveText(0.6, 0.4, 0.9, 0.7, "NDC NB"); pt->SetFillStyle(0); pt->AddText(TString::Format("#chi^{2}/n.d.f = %.0f/%.0f = %.2f", pileupModel.GetChi2(), pileupModel.GetNDF(), pileupModel.GetChi2()/pileupModel.GetNDF())); { double curval,err, lowlim, uplim; int iuint; TString name; for (Int_t ivar=0; ivar<4; ++ivar) { gMinuit->mnpout(ivar, name, curval, err, lowlim, uplim,iuint); hPar[ivar]->SetBinContent(1+counter, curval); hPar[ivar]->SetBinError(1+counter, err); if (ivar==0) { hf->SetMinimum(0.5*curval); } if (ivar==1) { hf->SetMinimum(TMath::Min(hf->GetMinimum(), 0.5*curval)); } if (ivar < 2) pt->AddText(TString::Format("%s = %.4f#pm%.4f", name.Data(), curval, err)); else pt->AddText(TString::Format("%s = %.1e#pm%.1e", name.Data(), curval, err)); pt->GetLine(1+ivar)->SetTextColor(ivar%2 ? kRed : kBlue); } hPar[4]->SetBinContent(1+counter, pileupModel.GetChi2()/pileupModel.GetNDF()); } pt->Draw(); c1->SaveAs(pn); Printf("%f / %f", pileupModel.GetChi2(), pileupModel.GetNDF()); ++counter; } gStyle->SetOptStat("n"); gStyle->SetOptFit(111); TCanvas *c2 = new TCanvas; for (Int_t i=0; i<4; ++i) { FitPol0(hPar[i])->Draw(); c2->SaveAs(pn); } hPar[4]->SetMinimum(0); hPar[4]->Draw(); c2->SaveAs(pn+")"); }
void drawPlots(canvasSet_t& cs,bool savePlots2file) { wCanvas_t *wc0 = cs.canvases[0]; unsigned npads = wc0->npadsx*wc0->npadsy; unsigned npadsall = cs.ncanvases*npads; if (!npads) { if (gl_verbose) cout << "Nothing to draw, guess I'm done." << endl; return; // no pads to draw on. } else if (!wc0->pads.size()) { /******************************************************** * CHECK MULTIPAD OPTION, ASSIGN HISTOS TO PADS/CANVASES ********************************************************/ if (wc0->multipads.size()) { npadsall = assignHistos2Multipad(cs); } else { cerr << "npads>0, but no pad specs supplied, exiting." << endl; return; // no pads to draw on. } } else if (cs.ncanvases>1) { npadsall = assignPads2Canvases(cs); } else { npadsall = std::min(npadsall,(unsigned)wc0->pads.size()); } wc0->c1->cd(); if (gl_verbose) cout << "Drawing on " << npadsall << " pad(s)" << endl; wLegend_t *wleg = NULL; /*************************************************** * LOOP OVER PADS... ***************************************************/ //vector<vector<string> >::const_iterator it; for (unsigned ipad = 0; ipad< npadsall; ipad++) { if (gl_verbose) cout << "Drawing pad# " << ipad+1 << endl; unsigned ipadc = ipad % npads; unsigned cnum = (ipad / npads) + 1; wCanvas_t *wc = cs.canvases[cnum-1]; if (!ipadc) { if (cnum-1) { // first canvas already created wc->c1 = new TCanvas(wc->title.c_str(),wc->title.c_str(), wc->padxdim*wc->npadsx, wc->padydim*wc->npadsy); float left = wc->leftmargin; float bot = wc->bottommargin; float rhgt = 1-wc->rightmargin; float top = 1-wc->topmargin; wc->motherpad = new TPad("mother","",left,bot,rhgt,top); wc->c1->SetFillColor(wc->fillcolor); wc->motherpad->SetFillColor(wc->fillcolor); wc->motherpad->Draw(); wc->motherpad->cd(); wc->motherpad->Divide(wc->npadsx,wc->npadsy); // , wc->padxmargin,wc->padymargin); } /*************************************************** * CHECK FOR LATEX OBJECTS ON THE CANVAS ***************************************************/ wc->c1->cd(); for (unsigned j=0; j<wc->latex_ids.size(); j++) { string& lid = wc->latex_ids[j]; map<string,TLatex *>::const_iterator it = glmap_id2latex.find(lid); if (it == glmap_id2latex.end()) { cerr << "ERROR: latex id " << lid << " never defined in layout" << endl; exit (-1); } TLatex *ltx = it->second; ltx->Draw(); wc->c1->Update(); } } wPad_t *& wp = wc->pads[ipadc]; wp->vp = wc->motherpad->cd(ipadc+1); if (!wp->histo_ids.size() && !wp->stack_ids.size() && !wp->graph_ids.size() && !wp->macro_ids.size()) { cerr << "ERROR: pad #" << ipadc+1 << " has no ids defined for it"; cerr << ", continuing to the next" << endl; continue; } #if 0 /*************************************************** * Draw the frame first: * (Fix up frame since it can't be auto-scaled:) ***************************************************/ string& hid0 = wp->histo_ids[0]; map<string,wTH1 *>::const_iterator it = glmap_id2histo.find(hid0); if (it == glmap_id2histo.end()) { cerr << "ERROR: id0 " << hid0 << " never defined in layout" << endl; return; } wTH1 *myHisto = it->second; TH1 *h = myHisto->histo(); if (wp->hframe->histo()->GetXaxis()->GetXmin() <= wp->hframe->histo()->GetXaxis()->GetXmax()) wp->hframe->histo()->GetXaxis()->SetRangeUser(h->GetXaxis()->GetXmin(), h->GetXaxis()->GetXmax()); if (wp->hframe->histo()->GetYaxis()->GetXmin() <= wp->hframe->histo()->GetYaxis()->GetXmax()) wp->hframe->histo()->GetYaxis()->SetRangeUser(h->GetYaxis()->GetXmin(), h->GetYaxis()->GetXmax()); wp->hframe->SetStats(0); //wp->hframe->Draw("AXIS"); #endif /*************************************************** * Check for external macros to run on the pad ***************************************************/ for (size_t i=0; i<wp->macro_ids.size(); i++) { map<string,string>::const_iterator it = glmap_objpath2id.find(wp->macro_ids[i]); if (it != glmap_objpath2id.end()) { string path = it->second; int error; gROOT->Macro(path.c_str(), &error, kTRUE); // update current pad if (error) { static const char *errorstr[] = { "kNoError","kRecoverable","kDangerous","kFatal","kProcessing" }; cerr << "ERROR: error returned from macro: " << errorstr[error] << endl; } } else { cerr << "ERROR: macro id " << wp->macro_ids[i]; cerr << " never defined in layout" << endl; } } /*************************************************** * Check for existence of a legend, create it ***************************************************/ bool drawlegend = false; if (wp->legid.size()) { map<string,wLegend_t *>::const_iterator it=glmap_id2legend.find(wp->legid); if (it != glmap_id2legend.end()) { drawlegend = true; wleg = it->second; } else { cerr << "ERROR: legend id " << wp->legid; cerr << " never defined in layout" << endl; } } else { // Maybe gPad already *has* a legend from macros... TPave *testing = (TPave *)gPad->GetPrimitive("TPave"); if (testing && !strcmp(testing->IsA()->GetName(),"TLegend")) { TLegend *pullTheOtherOne = (TLegend *)testing; if (gl_verbose) cout << "Found legend from macro" << endl; wleg = new wLegend_t(); wleg->leg = pullTheOtherOne; drawlegend = true; } } /*************************************************** * LOOP OVER STACKS DEFINED FOR PAD... ***************************************************/ if (wp->stack_ids.size()) { wStack_t *ws=NULL; for (unsigned j = 0; j < wp->stack_ids.size(); j++) { string& sid = wp->stack_ids[j]; map<string,wStack_t *>::const_iterator it = glmap_id2stack.find(sid); if (it == glmap_id2stack.end()) { cerr << "ERROR: stack id " << sid << " never defined in layout" << endl; exit (-1); } bool firstInPad = !j; ws = it->second; if (!ws) { cerr<< "find returned NULL stack pointer for " << sid << endl; continue; } // Add the histos in the stack to any legend that exists // if (drawlegend) { for (size_t i=0; i<ws->v_histos.size(); i++) { wTH1 *wh = ws->v_histos[i]; wh->ApplySavedStyle(); if(wh->GetLegendEntry().size()) wh->Add2Legend(wleg->leg); } } string drawopt(""); if (ws->sum->GetDrawOption().size()) { drawopt = ws->sum->GetDrawOption(); cout << "drawopt stored with histo = " << drawopt << endl; } drawInPad(wp, ws, firstInPad, drawopt); wp->vp->Update(); } } // stack loop /*************************************************** * LOOP OVER HISTOS DEFINED FOR PAD... ***************************************************/ for (unsigned j = 0; j < wp->histo_ids.size(); j++) { string& hid = wp->histo_ids[j]; map<string,wTH1 *>::const_iterator it = glmap_id2histo.find(hid); if (it == glmap_id2histo.end()) { cerr << "ERROR: histo id " << hid << " never defined in layout" << endl; exit (-1); } wTH1 *myHisto = it->second; if (myHisto) { bool firstInPad = !j && !wp->stack_ids.size(); if (gl_verbose) { cout << "Drawing " << hid << " => "; cout << myHisto->histo()->GetName() << endl; cout << "firstInPad = " << firstInPad << endl; } drawInPad(wp,*myHisto,firstInPad); myHisto->DrawFits("same"); if (drawlegend && myHisto->GetLegendEntry().size()) { if (wleg->drawoption.size()) myHisto->SetDrawOption(wleg->drawoption); myHisto->Add2Legend(wleg->leg); } if (myHisto->statsAreOn()) { myHisto->DrawStats(); wp->vp->Update(); } myHisto->ApplySavedStyle(); wp->vp->Update(); } } // histos loop /*************************************************** * LOOP OVER HISTOS DEFINED FOR ALTERNATE Y-AXIS ***************************************************/ Float_t rightmax=0.0,rightmin=0.0; Float_t scale=0.0; for (unsigned j = 0; j < wp->altyh_ids.size(); j++) { string& hid = wp->altyh_ids[j]; map<string,wTH1 *>::const_iterator it = glmap_id2histo.find(hid); if (it == glmap_id2histo.end()) { cerr << "ERROR: histo id " << hid << " never defined in layout" << endl; exit (-1); } wTH1 *myHisto = it->second; TH1 *h = myHisto->histo(); if (!j) { //scale second set of histos to the pad coordinates rightmin = h->GetMinimum(); rightmax = 1.1*h->GetMaximum(); scale = gPad->GetUymax()/rightmax; } TH1 *scaled=(TH1 *)h->Clone(Form("%s_%d",h->GetName(),ipad)); scaled->Scale(scale); scaled->Draw("same"); //draw an axis on the right side TGaxis *axis = new TGaxis(gPad->GetUxmax(), gPad->GetUymin(), gPad->GetUxmax(), gPad->GetUymax(), rightmin,rightmax,505,"+L"); axis->Draw(); gPad->Update(); if (drawlegend && myHisto->GetLegendEntry().size()) { if (wleg->drawoption.size()) myHisto->SetDrawOption(wleg->drawoption); myHisto->Add2Legend(wleg->leg); } } /*************************************************** * LOOP OVER GRAPHS DEFINED FOR PAD... ***************************************************/ #if 0 TMultiGraph *mg; if (graph_ids.size()) mg = new TMultiGraph(); #endif for( unsigned j = 0; j < wp->graph_ids.size(); j++ ) { string& gid = wp->graph_ids[j]; wGraph_t *wg = findGraph(gid); bool firstInPad = !j && !wp->histo_ids.size() && !wp->macro_ids.size(); if( firstInPad && wg->gr && wg->gr->IsA()==TGraph::Class() ) wg->drawopt += string("A"); // no histos drawn, need to draw the frame ourselves. if( wg && wg->gr ) { // "pre-draw" in order to define the plot elements wg->gr->Draw(wg->drawopt.c_str()); if (firstInPad) { // Now we can set the axis attributes and range: wg->gr->GetXaxis()->ImportAttributes(wg->xax); wg->gr->GetYaxis()->ImportAttributes(wg->yax); cout << wg->xax->GetXmin() << " " << wg->xax->GetXmax() << endl; if( wg->xax->GetXmax()>wg->xax->GetXmin() ) wg->gr->GetXaxis()->SetLimits(wg->xax->GetXmin(),wg->xax->GetXmax()); if( wg->yax->GetXmax()>wg->yax->GetXmin() ) wg->gr->GetYaxis()->SetRangeUser(wg->yax->GetXmin(),wg->yax->GetXmax()); } // draw for good drawInPad<TGraph>(wp,wg->gr,wg->drawopt.c_str(),firstInPad); wp->vp->Update(); if( wg->fitfn ) wg->gr->Fit(wg->fitfn); if( drawlegend && wg->leglabel.size() ) wleg->leg->AddEntry(wg->gr,wg->leglabel.c_str(),wg->legdrawopt.c_str()); } if( wg && wg->gr2d ) { drawInPad<TGraph2D>(wp,wg->gr2d,wg->drawopt.c_str(),firstInPad); if (firstInPad) { // Now we can set the axis attributes and range: wg->gr2d->GetXaxis()->ImportAttributes(wg->xax); wg->gr2d->GetYaxis()->ImportAttributes(wg->yax); cout << wg->xax->GetXmin() << " " << wg->xax->GetXmax() << endl; if( wg->xax->GetXmax()>wg->xax->GetXmin() ) wg->gr2d->GetXaxis()->SetLimits(wg->xax->GetXmin(),wg->xax->GetXmax()); if( wg->yax->GetXmax()>wg->yax->GetXmin() ) wg->gr2d->GetYaxis()->SetRangeUser(wg->yax->GetXmin(),wg->yax->GetXmax()); } if (wg->contours) { //cout << "setting contours "; wg->contours->Print(); wg->gr2d->GetHistogram()->SetContour(wg->contours->GetNoElements(), wg->contours->GetMatrixArray()); wg->gr2d->SetLineStyle (wg->lstyle); wg->gr2d->SetLineColor (wg->lcolor); wg->gr2d->SetLineWidth (wg->lwidth); } wp->vp->Modified(); wp->vp->Update(); if( drawlegend && wg->leglabel.size() ) wleg->leg->AddEntry(wg->gr2d,wg->leglabel.c_str(),wg->legdrawopt.c_str()); } } // graph loop /*************************************************** * LOOP OVER LINES DEFINED FOR PAD... ***************************************************/ for( unsigned j = 0; j < wp->line_ids.size(); j++ ) { string drawopt("L"); string& lid = wp->line_ids[j]; map<string,TLine *>::const_iterator it2 = glmap_id2line.find(lid); if (it2 == glmap_id2line.end()) { cerr << "ERROR: line id " << lid << " never defined in layout" << endl; exit (-1); } TLine *line = it2->second; if (!j && !wp->histo_ids.size() && !wp->macro_ids.size()) drawopt += string("A"); // no histos drawn, need to draw the frame ourselves. if (line) { drawInPad<TLine>(wp,line,drawopt.c_str()); //if (drawlegend) //wleg->leg->AddEntry(line,lid.c_str(),"L"); } } /*************************************************** * LOOP OVER BOXES DEFINED FOR PAD... ***************************************************/ for (unsigned j = 0; j < wp->box_ids.size(); j++) { string drawopt("L"); string& bid = wp->box_ids[j]; map<string,TBox *>::const_iterator it2 = glmap_id2box.find(bid); if (it2 == glmap_id2box.end()) { cerr << "ERROR: box id " << bid << " never defined in layout" << endl; exit (-1); } TBox *box = it2->second; if (box) { drawInPad<TBox>(wp,box,drawopt.c_str()); } } /*************************************************** * Draw the legend ***************************************************/ if (drawlegend) { wleg->leg->Draw("same"); wp->vp->Update(); } /*************************************************** * Draw each latex/label object ***************************************************/ for (unsigned j=0; j<wp->latex_ids.size(); j++) { string& lid = wp->latex_ids[j]; map<string,TLatex *>::const_iterator it2 = glmap_id2latex.find(lid); if (it2 == glmap_id2latex.end()) { cerr << "ERROR: latex id " << lid << " never defined in layout" << endl; exit (-1); } if (gl_verbose) cout << "Drawing latex object " << lid << endl; TLatex *ltx = it2->second; ltx->Draw(); wp->vp->Update(); } for (unsigned j = 0; j < wp->label_ids.size(); j++) { string& lid = wp->label_ids[j]; map<string,wLabel_t *>::const_iterator it2 = glmap_id2label.find(lid); if (it2 == glmap_id2label.end()) { cerr << "ERROR: label id " << lid << " never defined in layout" << endl; exit (-1); } if (gl_verbose) cout << "Drawing label object " << lid << endl; wLabel_t *wlab = it2->second; drawStandardText(wlab->text, wlab->x1ndc, wlab->y1ndc,-1,-1,wlab->textsize); wp->vp->Update(); } wc->c1->Update(); } // pad loop //prdFixOverlay(); if (savePlots2file) { wc0 = cs.canvases[0]; if (!wc0->savenamefmts.size()) // define a default wc0->savenamefmts.push_back("%F_%C.png"); for (size_t i=0; i<cs.canvases.size(); i++) { wCanvas_t *wc = cs.canvases[i]; wc->c1->cd(); for (size_t j=0; j<wc0->savenamefmts.size(); j++) saveCanvas2File(wc,wc0->savenamefmts[j]); } } } // drawPlots
void recurseOverKeys(TDirectory *target, TString imageType) { // TString path( (char*)strstr( target->GetPath(), ":" ) ); // path.Remove( 0, 2 ); // cout << path << endl; // sourceFile->cd( path ); target->cd(); TDirectory *current_sourcedir = gDirectory; TKey *key; TIter nextkey(current_sourcedir->GetListOfKeys()); TCanvas *canvasDefault = new TCanvas(); while ( (key = (TKey*)nextkey() ) ) { TObject* obj = key->ReadObj(); if (obj->IsA()->InheritsFrom("TH1") ) { // ************************** // Plot & Save this Histogram TH1* h = (TH1*)obj; h->SetStats(displayStatsBox); TString histName = h->GetName(); // Now to label the X-axis! // if (autoLabelXaxis) { // if ( histName.Contains("Phi") ) { // h->GetXaxis()->SetTitle("#phi"); // } else if ( histName.Contains("Eta") ) { // h->GetXaxis()->SetTitle("#eta"); // } else if ( histName.Contains("Pt") ) { // h->GetXaxis()->SetTitle("p_{T} (GeV)"); // } else if ( histName.Contains("Et") ) { // h->GetXaxis()->SetTitle("E_{T} (GeV)"); // } // } // h->SetLineColor(lineColor); // h->SetLineWidth(lineWidth); // ******************************** // A trick to decide whether to have log or no-log y axis // get hist max y value if (autoLogYaxis) { Double_t testYvalue = h->GetMaximum(); //cout << testYvalue << endl; if (testYvalue > 1.0) { Double_t maxy = log10(testYvalue); // get hist min y value Double_t miny = log10(h->GetMinimum(1.0)); // log scale if more than 3 powers of 10 between low and high bins if ( (maxy-miny) > 3.0 ) { canvasDefault->SetLogy(1); } } } // End of log or no-log y axis decision // ******************************** h->Draw(drawOptions1D); canvasDefault->Modified(); canvasDefault->Update(); // gPad->Print(outputFolder+path+"/"+histName+outputType); TString outputFolder = "images/"; gPad->Print(outputFolder+histName+"."+imageType); // To store the root file name in image file name: //canvasDefault->Print(outputFolder+histFileName+histName+outputType); // if (printOutput) cout << outputFolder+path+"/"+histName+outputType << endl; canvasDefault->SetLogy(0); // reset to no-log - prevents errors // ************************** } else if ( obj->IsA()->InheritsFrom( "TDirectory" ) ) { // it's a subdirectory cout << "Found subdirectory " << obj->GetName() << endl; // gSystem->MakeDirectory(outputFolder+path+"/"+obj->GetName()); // obj is now the starting point of another round of merging // obj still knows its depth within the target file via // GetPath(), so we can still figure out where we are in the recursion recurseOverKeys((TDirectory*)obj, imageType); } // end of IF a TDriectory } // end of LOOP over keys }
//________________________________________________________ void GFHistManager::DrawReally(Int_t layer) { if(layer < 0 || layer > fDepth-1) { this->Warning("DrawReally","Layer %d does not exist, possible are 0 to %d.", layer, fDepth-1); return; } this->MakeCanvases(layer); TIter canIter(static_cast<TObjArray*>(fCanArrays->At(layer))); TIter histIter(static_cast<TObjArray*>(fHistArrays->At(layer))); Int_t histNo = 0; // becomes number of histograms in layer while(TCanvas* can = static_cast<TCanvas*>(canIter.Next())){ Int_t nPads = this->NumberOfSubPadsOf(can); if (fNoX[layer] * fNoY[layer] != nPads && !(nPads == 0 && fNoX[layer] * fNoY[layer] == 1)) { this->Warning("Update", "inconsistent number of pads %d, expect %d*%d", nPads, fNoX[layer], fNoY[layer]); } for(Int_t i = 0; i <= nPads; ++i){ if (i == 0 && nPads != 0) i = 1; can->cd(i); if(GFHistArray* histsOfPad = static_cast<GFHistArray*>(histIter.Next())){ TIter hists(histsOfPad); TH1* firstHist = static_cast<TH1*>(hists.Next()); firstHist->Draw(); this->DrawFuncs(firstHist); while(TH1* h = static_cast<TH1*>(hists.Next())){ h->Draw(Form("SAME%s%s", (fSameWithStats ? "S" : ""), h->GetOption())); this->DrawFuncs(h); } if(histsOfPad->GetEntriesFast() > 1){ const Double_t max = this->MaxOfHists(histsOfPad); if(//firstHist->GetMaximumStored() != -1111. && ???? max > firstHist->GetMaximumStored()){ firstHist->SetMaximum((fLogY[layer] ? 1.1 : 1.05) * max); } const Double_t min = this->MinOfHists(histsOfPad); if(!(gStyle->GetHistMinimumZero() && min > 0.)) { firstHist->SetMinimum(min * 1.05); } } if(fLogY[layer] && (firstHist->GetMinimum() > 0. || (firstHist->GetMinimum() == 0. && firstHist->GetMinimumStored() == -1111.)))gPad->SetLogy(); // draw other objects: this->DrawObjects(layer, histNo); // make hist style differ if(fDrawDiffStyle) GFHistManager::MakeDifferentStyle(histsOfPad); // draw legends on top of all if(fLegendArrays && layer <= fLegendArrays->GetLast() && fLegendArrays->At(layer)){ this->DrawLegend(layer, histNo); } gPad->Modified(); this->ColourFuncs(histsOfPad); if (fSameWithStats) { gPad->Update(); // not nice to need this here, makes use over network impossible... this->ColourStatsBoxes(histsOfPad); } histNo++; } } // loop over pads } // loop over canvases }
int ratio5() { // Constants and arrays Int_t multi = 2; const Int_t n_at = 3; Int_t at[n_at] = { 500, 510, 550 }; //for ( int ii = 0; ii < n_at; ++ii ) { at[ii] = 500 + ii * 10; } TString eq = "Gt"; const Int_t n = 4; float pt[n] = { 50., 40., 30., 20. }; Int_t colour[n] = { 1, 2, 3, 4 }; const Int_t m = 2; Int_t style[m] = { kOpenSquare, kFullSquare }; const Int_t ngr = 1000; double x3[ngr]; double r[ngr]; int count = 0; // General style gStyle->SetOptStat(0); // // Canvas for RECO curves // TCanvas* reco_canvas = new TCanvas("Reco"); // reco_canvas->SetFillColor(0); // reco_canvas->SetLineColor(0); // reco_canvas->SetLogy(); // TLegend* reco_legend = new TLegend( 0.5, 0.7, 0.88, 0.88, NULL, "brNDC" ); // reco_legend->SetFillColor(0); // reco_legend->SetLineColor(0); // bool empty = true; // double reco_max = 1.e-15.; // double reco_min = 1.e15; // Loop through pt bins for ( Int_t i = 0; i < 1; ++i ) { std::stringstream pt_can; pt_can << "PtBin" << pt[i]; // Canvas for Pt bin TCanvas* pt_canvas = new TCanvas(TString(pt_can.str()),""); pt_canvas->SetFillColor(0); pt_canvas->SetLineColor(0); pt_canvas->SetLogy(); TLegend* pt_legend = new TLegend( 0.82, 0.5, 0.98, 0.9, NULL, "brNDC" ); pt_legend->SetFillColor(0); pt_legend->SetLineColor(0); bool empty = true; double pt_max = 1.e-15.; double pt_min = 1.e15; std::vector<TH1*> pt_ratio; pt_canvas->SetRightMargin(0.2); // Open files std::stringstream ss; ss << "results/4/Reco" << pt[i] << "_QCDPythia6.root"; TString name(ss.str()); TFile* file = new TFile(name); if ( file->IsZombie() || !(file->IsOpen()) ) { continue; } file->cd(); // Loop through AlphaT thresolds for ( Int_t iat = 0; iat < n_at; ++iat ) { // Loop through RECO and GEN for ( Int_t j = 0; j < m; ++j ) { // Define names of histos to open std::stringstream pre; std::stringstream post; if ( j == 0 ) { pre << "Ratio" << at[iat] << "/GenHt" << eq << "PreAlphaT" << at[iat] << "_" << multi; post << "Ratio" << at[iat] << "/GenHt" << eq << "PostAlphaT" << at[iat] << "_" << multi; std::cout << pre.str() << std::endl; std::cout << post.str() << std::endl; } else if ( j == 1 ) { pre << "Ratio" << at[iat] << "/Ht" << eq << "PreAlphaT" << at[iat] << "_" << multi; post << "Ratio" << at[iat] << "/Ht" << eq << "PostAlphaT" << at[iat] << "_" << multi; std::cout << pre.str() << std::endl; std::cout << post.str() << std::endl; } // Create ratio histo TH1* denominator = his( (TH1*)file->Get(TString(pre.str())), 45, 200., 650. ); TH1* numerator = his( (TH1*)file->Get(TString(post.str())), 45, 200., 650. ); int rebin = 5; numerator->Rebin(rebin); denominator->Rebin(rebin); TH1* ratio = (TH1*)numerator->Clone(); ratio->Divide(denominator); //ratio->Divide(numerator,denominator,1.,1.,"b"); //@@ poisson errors ratio->SetMarkerStyle(style[j]); ratio->SetMarkerSize(1.2); ratio->SetMarkerColor(iat+1);//colour[iat]); ratio->SetBarOffset(0.1*i); //ratio->GetXaxis()->SetRangeUser(100.,550.); ratio->GetYaxis()->SetRangeUser(1.e-7,1.e-1); ratio->GetXaxis()->SetTitle("HT_{reco} [GeV]"); ratio->GetYaxis()->SetTitle("R(#alpha_{T})"); if ( ratio->GetMaximum() > 0. && ratio->GetMaximum() > pt_max ) { pt_max = ratio->GetMaximum(); } if ( ratio->GetMinimum() > 0. && ratio->GetMinimum() < pt_min ) { pt_min = ratio->GetMinimum(); } pt_ratio.push_back(ratio); if ( empty ) { ratio->Draw(""); empty = false; } else { ratio->Draw("same"); } //ratio->GetYaxis()->SetRangeUser(pt_min/1.1,pt_max*1.1); // Text for legend std::stringstream pt_leg; if ( j == 0 ) { pt_leg << "#alpha_{T} = " << at[iat]/1000. << ", GEN"; } else if ( j == 1 ) { pt_leg << "#alpha_{T} = " << at[iat]/1000. << ", RECO"; } pt_legend->AddEntry( ratio, TString(pt_leg.str()), "lep" ); // // Draw histos on canvas for RECO only // if ( j == 1 ) { // reco_canvas->cd(); // if ( i == 0 ) ratio->Draw(""); // else ratio->Draw("same"); // std::stringstream reco_leg; // reco_leg << "p_{T}^{min} = " << pt[i]; // reco_legend->AddEntry( ratio, TString(reco_leg.str()), "lep" ); // } } } // if (0) { // int nbins = ratio->GetNbinsX(); // int bin_width = ratio->GetBinWidth(1); // double lower = 0.; // double upper = 1400.; // int bin_lower = int( ( lower - ratio->GetBinLowEdge(1) ) / bin_width ); // for ( Int_t ii = bin_lower; ii < ratio->GetNbinsX()-1; ++ii ) { // if ( ratio->GetBinContent(ii) > 0. ) { // lower = ratio->GetBinCenter(ii); // break; // } // } // int bin_upper = int( ( upper - ratio->GetBinLowEdge(1) ) / bin_width ); // for ( Int_t ii = bin_upper; ii > 0; --ii ) { // if ( ratio->GetBinContent(ii) > 0. ) { // upper = ratio->GetBinCenter(ii); // break; // } // } // if (0) { // std::cout << " bin_width: " << bin_width // << " bin_lower: " << bin_lower // << " bin_upper: " << bin_upper // << " lower: " << lower // << " upper: " << upper // << std::endl; // } // TF1* fit = new TF1(sample[i],"expo",lower,upper); // fit->SetLineColor(colour[i]); // fit->SetLineWidth(1); // ratio->Fit(sample[i],"QR","same"); // } pt_canvas->cd(); // for ( Int_t iii = 0; iii < pt_ratio.size(); ++iii ) { // TH1* ratio = pt_ratio[iii]; // if ( !ratio ) { continue; } // if ( ii == 0 ) { ratio->Draw(""); } // else { ratio->Draw("same"); } // ratio->GetYaxis()->SetRangeUser(pt_min/1.1,pt_max*1.1); // } pt_legend->Draw("same"); pt_canvas->Update(); pt_canvas->SaveAs(TString(pt_can.str()+".png")); // pt_canvas->SaveAs(TString(pt_can.str()+".C")); } // reco_canvas->cd(); // reco_legend->Draw("same"); // reco_canvas->Update(); // reco_canvas->SaveAs(TString("Reco.png")); // reco_canvas->SaveAs(TString("Reco.C")); // TCanvas* c2 = new TCanvas("C2"); // c2->SetLogy(); // c2->SetFillColor(0); // gStyle->SetOptStat(0); // if ( count > 0 ) { // TGraph* graph = new TGraph(count,x3,r); // graph->Draw("a*"); // } }
//////////////////////////////////////////////////////////// // // Plot a page with several histograms // void PlotNHistograms(const TString& pdfFile, TDirectory* rdir, TDirectory* sdir, const TString& rcollname, const TString& scollname, const char* canvasName, const char* canvasTitle, const TString& refLabel, const TString& newLabel, unsigned int nhistos, const TString* hnames, const TString* htitles, const char** drawopt, bool* logy = 0, bool* logx = 0, bool* doKolmo = 0, Double_t* norm = 0, Double_t* minx = 0, Double_t* maxx = 0, Double_t* miny = 0, Double_t* maxy = 0) { if (DEBUGP) { cout << " + Plotting histograms for " << canvasTitle << endl; cerr << " + Plotting histograms for " << canvasTitle << endl; } TH1* rh_raw = 0; TH1* rh = 0; TH1* sh_raw = 0; TH1* sh = 0; TCanvas* canvas = 0; if (nhistos >4) canvas = new TCanvas(canvasName, canvasTitle, 1000, 1400); else canvas = new TCanvas(canvasName, canvasTitle, 1000, 1050); canvas->Draw(); canvas->Divide(2,(nhistos+1)/2); //This way we print in 2 columns for (unsigned int i = 0; i < nhistos; i++) { if (DEBUGP) cout << " [" << i << "] histogram name: " << flush << hnames[i] << endl; //draw option for the new histogram TString drawoption = drawopt[i]; // Skip histogram if no name is provided if (hnames[i] == "") continue; // Get Histograms // + Reference release rdir->cd(rcollname); if (DEBUGP) cout << " Getting object for reference sample " << (rcollname + "/" + hnames[i]) << endl; rdir->GetObject(rcollname + "/" + hnames[i], rh_raw); if (! rh_raw) { cout << "WARNING: Could not find a reference histogram or profile named " << hnames[i] << " in " << rdir->GetName() << endl; cout << " Skipping" << endl; continue; } //If it is a 2D project it in Y... is this what we always want? if (TString(rh_raw->IsA()->GetName()) == "TH2F") { if (DEBUGP) cout << " It is a TH2F object... project in Y!" << endl; TH1* proj = ((TH2F*) rh_raw)->ProjectionY(); rh_raw = proj; } // + New release sdir->cd(scollname); if (DEBUGP) cout << " Getting object for target sample " << (scollname + "/" + hnames[i]) << endl; sdir->GetObject(scollname + "/" + hnames[i], sh_raw); if (! sh_raw) { cout << "WARNING: Could not find a signal histogram or profile named " << hnames[i] << " in " << sdir->GetName() << endl; cout << " Skipping" << endl; continue; } //If it is a 2D project it in Y... is this what we always want? if (TString(sh_raw->IsA()->GetName()) == "TH2F") { if (DEBUGP) cout << hnames[i] << " is a TH2F object... project in Y!" << endl; TH1* proj = ((TH2F*) sh_raw)->ProjectionY(); sh_raw = proj; } rh = AddOverflow(rh_raw); sh = AddOverflow(sh_raw); // Set styles if (DEBUGP) cout << " Setting style..." << endl; SetHistogramStyle(rh, 21, 4); SetHistogramStyle(sh, 20, 2); //Change titles if (htitles) { rh->SetTitle(htitles[i]); sh->SetTitle(htitles[i]); rh->GetYaxis()->SetTitle(htitles[i]); sh->GetYaxis()->SetTitle(htitles[i]); } // SET X AXIS RANGE in plots Bool_t ChangeXRange = false ; Double_t Xleft = rh->GetXaxis()->GetXmin(); Double_t Xright = rh->GetXaxis()->GetXmax(); if (DEBUGP) cout << "ref histo Xleft, Xright = "<< Xleft << ", "<< Xright << endl; if (sh->GetXaxis()->GetXmin() < rh->GetXaxis()->GetXmin()) { Xleft = sh->GetXaxis()->GetXmin(); ChangeXRange = true; if (DEBUGP) cout << "automatic reset MIN (new < ref) Xleft = "<< Xleft << endl; } if (sh->GetXaxis()->GetXmax() > rh->GetXaxis()->GetXmax()) { Xright = sh->GetXaxis()->GetXmax(); ChangeXRange = true; if (DEBUGP) cout << "automatic reset MAX (new > ref) Xright = "<< Xright << endl; } if (minx[i]!=0) { ChangeXRange = true ; Xleft = minx[i]; if (DEBUGP) cout << "user reset Xleft = "<< Xleft << endl; } if (maxx[i]!=0) { ChangeXRange = true ; Xright = maxx[i]; if (DEBUGP) cout << "user reset Xright = "<< Xleft << endl; } if (ChangeXRange) { if (DEBUGP) { cout << "Ref histo Xmin, Xmax = "<< rh->GetXaxis()->GetXmin() << ", " << rh->GetXaxis()->GetXmax() <<endl; cout << "New histo Xmin, Xmax = "<< sh->GetXaxis()->GetXmin() << ", " << sh->GetXaxis()->GetXmax() <<endl; } rh->GetXaxis()->SetRangeUser(Xleft,Xright); sh->GetXaxis()->SetRangeUser(Xleft,Xright); if (DEBUGP) { cout << "reset Ref histo Xmin, Xmax = "<< rh->GetXaxis()->GetXmin() << ", " << rh->GetXaxis()->GetXmax() <<endl; cout << "reset New histo Xmin, Xmax = "<< sh->GetXaxis()->GetXmin() << ", " << sh->GetXaxis()->GetXmax() <<endl; cout << "resetting Ref and New histo Xleft, Xright = "<< Xleft << ", " << Xright <<endl; } } // =============================================================================================== // Normalize if (norm[i] < 0.) ; // Default: do not normalize at all ! else if (norm[i] == 0.) NormalizeHistogramsToFirst(rh,sh); else if (norm[i] == 1.) NormalizeHistogramsToOne(rh,sh); else if (norm[i] == 2.) NormalizeHistogramsAsDensity(rh,sh); // =============================================================================================== // =============================================================================================== // SET Y AXIS RANGE in plots // // MINIMUM // Double_t Ybottom; // if user-defined range force it ! if (miny[i]!=0) { Ybottom = miny[i]; if (DEBUGP) cout << "setting Minimum Y to user defined value: "<< miny[i] << endl; } else if (logy[i]) { // automatic setting for log scale Double_t yminr = rh->GetMinimum(0.); // min value larger than zero Double_t ymins = sh->GetMinimum(0.); Ybottom = yminr < ymins ? yminr*0.5 : ymins*0.5; if (DEBUGP) cout << "LOG scale, yminr, ymins: "<<yminr<<", "<<ymins <<" ==>> Ybottom = "<<Ybottom<< endl; } else { // automatic setting for linear scale Double_t yminr = rh->GetMinimum(); // min value larger than zero Double_t ymins = sh->GetMinimum(); Ybottom = yminr < ymins ? yminr-0.1*abs(yminr) : ymins-0.1*abs(ymins) ; // limit the scale to -1,+1 for relative pt bias to avoid failing fits if ((hnames[i] == "ptres_vs_eta_Mean") && (Ybottom <-1.)) Ybottom = -1.; if ((hnames[i] == "ptres_vs_pt_Mean") && (Ybottom <-1.)) Ybottom = -1.; if (DEBUGP) cout << "LIN scale, yminr, ymins: "<<yminr<<", "<<ymins <<" ==>> Ybottom = "<<Ybottom<< endl; } /////////////////// // MAXIMUM // Double_t Ytop; // if user-defined range force it ! if (maxy[i]!=0) { Ytop = maxy[i]; if (DEBUGP) cout << "setting Maximum Y to user defined value: "<< maxy[i] << endl; } else { Double_t ymaxr = rh->GetMaximum(); // max value Double_t ymaxs = sh->GetMaximum(); Ytop = ymaxr > ymaxs ? ymaxr : ymaxs ; // automatic setting for log scale if (logy[i]) { Ytop = Ytop*2; if (DEBUGP) cout << "LOG scale, ymaxr, ymaxs: "<<ymaxr<<", "<<ymaxs <<" ==>> Ytop = "<<Ytop<< endl; } else { Ytop = Ytop+0.1*abs(Ytop); // limit the scale to -1,+1 for relative pt bias to avoid failing fits if ((hnames[i] == "ptres_vs_eta_Mean") && (Ytop >1.)) Ytop = 1.; if ((hnames[i] == "ptres_vs_pt_Mean") && (Ytop >1.)) Ytop = 1.; if (DEBUGP) cout << "LIN scale, ymaxr, ymaxs: "<<ymaxr<<", "<<ymaxs <<" ==>> Ytop = "<<Ytop<< endl; } } // +++++++++++++++++++++++++++++++++++++++++ rh->GetYaxis()->SetRangeUser(Ybottom,Ytop); sh->GetYaxis()->SetRangeUser(Ybottom,Ytop); // +++++++++++++++++++++++++++++++++++++++++ // Move to subpad canvas->cd(i+1); TPad* pad1 = NULL; TPad* pad2 = NULL; pad1 = new TPad("pad1", "pad1", 0, 0.3, 1, 1.0); pad2 = new TPad("pad2", "pad2", 0, 0.0, 1, 0.3); pad1->SetTopMargin (0.08); pad1->SetBottomMargin(0.01); pad1->Draw(); pad2->SetTopMargin (0.05); pad2->SetBottomMargin(0.45); pad2->Draw();// Set stat boxes pad1->cd(); // Check Logy if (logy[i]) gPad->SetLogy(); if (logx[i]) {gPad->SetLogx(); pad2->SetLogx();} // Set stat boxes if (DEBUGP) cout << " Setting statistics..." << endl; setStats(sh, rh, -1, 0, false); // /////////// DRAW histograms ////////////////////////////////////// // // FIRST plot: reference (blue) SECOND plot: new (red) if (DEBUGP) cout << " Drawing histograms..." << endl; if (ChangeXRange) { sh->Draw(drawoption); rh->Draw("same"+drawoption); sh->Draw("same"+drawoption); } else { rh->Draw(drawoption); sh->Draw("same"+drawoption); } // Perform Kolmogorov test if needed if (doKolmo) { if (doKolmo[i]) { if (DEBUGP) cout << " Performing Kolmogorov test..." << endl; // TPad* c1_1 = canvas->GetPad(i+1); double kstest = KolmogorovTest(sh,rh); if(kstest<0.7) gPad->SetFillColor(kBlue-10); } } pad2->cd(); TH1* ratioplot = PlotRatiosHistograms(rh, sh); SetHistogramStyle(ratioplot, 21, 4); ratioplot->Draw("ep"); } // End loop // Draw Legend if (DEBUGP) cout << " Drawing legend..." << endl; canvas->cd(); TLegend* l = 0; if (nhistos > 4) l = new TLegend(0.20,0.665,0.80,0.685); else l = new TLegend(0.20,0.50,0.80,0.53); l->SetTextSize(0.011); l->SetLineColor(1); l->SetLineWidth(1); l->SetLineStyle(1); l->SetFillColor(0); l->SetBorderSize(2); l->AddEntry(rh,refLabel,"LPF"); l->AddEntry(sh,newLabel,"LPF"); l->Draw(); // Print Canvas canvas->SaveAs(pdfFile+".pdf"); canvas->SaveAs(pdfFile+".png"); // Clean memory // delete l; delete canvas; if (DEBUGP) cout << " ... plotted histograms for " << canvasTitle << endl; }
void DrawTwoInPad(TVirtualPad* p, Int_t sub, TH1* h1, TH1* h2, Bool_t ratio, Bool_t logy=false, Bool_t legend=false) { TVirtualPad* pp = p->cd(sub); pp->SetRightMargin(0.02); pp->SetLeftMargin(0.10); TVirtualPad* ppp = pp; if (ratio) { pp->Divide(1,2,0,0); ppp = pp->cd(1); ppp->SetRightMargin(0.02); } if (logy) ppp->SetLogy(); TH1* hs[] = { h1, h2, 0 }; if (h1->GetMaximum() < h2->GetMaximum()) { hs[0] = h2; hs[1] = h1; } TH1** ph = hs; Double_t size = (ratio ? 0.1 : 0.05); Double_t off = (ratio ? 0.6 : 0.5); h1->SetFillStyle(3004); h2->SetFillStyle(3005); while (*ph) { TString opt("hist"); if (ph != hs) opt.Append(" same"); TH1* copy = (*ph)->DrawCopy(opt); copy->GetXaxis()->SetLabelSize(2*size); copy->GetYaxis()->SetLabelSize(size); copy->GetYaxis()->SetTitleSize(size); copy->GetYaxis()->SetTitleOffset(off); copy->SetYTitle(copy->GetTitle()); copy->SetTitle(""); copy->SetDirectory(0); ph++; } TString s1 = h1->GetYaxis()->GetTitle(); TString s2 = h2->GetYaxis()->GetTitle(); if (legend) { TLegend* l = new TLegend(0.6, 0.1, 0.9, 0.9); l->SetBorderSize(0); TLegendEntry* e = l->AddEntry("dummy", s1, "lf"); l->SetFillColor(kWhite); e->SetFillColor(kBlack); e->SetFillStyle(h1->GetFillStyle()); e = l->AddEntry("dummy", s2, "lf"); e->SetFillColor(kBlack); e->SetFillStyle(h2->GetFillStyle()); l->Draw(); } if (!ratio) return; ppp = pp->cd(2); ppp->SetRightMargin(0.02); TH1* r = static_cast<TH1*>(h1->Clone(Form("ratio%s", h1->GetName()))); r->SetDirectory(0); r->SetTitle(""); r->GetXaxis()->SetLabelSize(size); r->GetYaxis()->SetLabelSize(size); r->GetYaxis()->SetTitleSize(0.9*size); r->GetYaxis()->SetTitleOffset(0.9*off); r->SetMarkerStyle(20); r->SetMarkerColor(h1->GetFillColor()+1); r->SetFillStyle(3007); r->SetYTitle(Form("#frac{%s}{%s}", s1.Data(), s2.Data())); // r->Add(h2, -1); // r->Divide(h1); if (!r->IsA()->InheritsFrom(TProfile::Class())) { r->GetSumw2()->Set(0); // r->Sumw2(false); h2->GetSumw2()->Set(0); // h2->Sumw2(false); } r->Divide(h2); Printf("%s", r->GetName()); for (UShort_t bin = 1; bin <= r->GetNbinsX(); bin++) { Printf(" bin # %2d: Diff=%g+/-%g", bin, r->GetBinContent(bin), r->GetBinError(bin)); r->SetBinError(bin, 0); } r->GetSumw2()->Set(0); //r->Sumw2(false); r->SetMarkerSize(4); r->SetMaximum(r->GetMaximum()*1.2); r->SetMinimum(r->GetMinimum()*0.8); r->Draw("hist text30"); p->Modified(); p->Update(); p->cd(); }