TH1* GetOne(UShort_t sNN, const TString& trigger) { Long_t p = gROOT->ProcessLine(Form("Drawer::GetStack(0, \"pp\", %d, " "\"%s\", false, true)", sNN, trigger.Data())); THStack* s = (THStack*)p; TList* l = s->GetHists(); TH1* h = 0; TIter n(l); l->ls(); while ((h = static_cast<TH1*>(n()))) { TString m(h->GetName()); if (m.EqualTo("dndetaForward_all")) break; } if (h) { switch (sNN) { case 900: h->SetTitle("900GeV"); h->SetMarkerColor(kRed+2); break; case 2760: h->SetTitle("2.76TeV"); h->SetMarkerColor(kGreen+2); break; case 7000: h->SetTitle("7TeV"); h->SetMarkerColor(kBlue+2); break; case 8000: h->SetTitle("8TeV"); h->SetMarkerColor(kBlack); break; } } return h; }
void fancyMerge( std::string beam, std::string target, std::string energy, std::string physlist, bool doScale=false ) { std::string output = beam + target + energy + "GeV" + physlist + ".root" ; targetFile = TFile::Open( output.c_str(), "RECREATE" ); double scale = 1./32.; // std::string input = beam + target + model + energy + "GeV-1.root"; // std::string input = "../t23-bld/harp-histo-no-res-decays/" + beam + target + energy + "GeV" + physlist +"-1.root"; // std::string input = "../t23-bld/harp-histo/" + beam + target + energy + "GeV" + physlist +"-1.root"; std::string input = "../t23-bld/na49-histo/" + beam + target + energy + "GeV" + physlist +"-1.root"; TFile* iFile1 = TFile::Open( input.c_str() ); TIter next( iFile1->GetListOfKeys() ); TKey* key = (TKey*)next(); TH1* h = 0; while ( key ) { if ( !(TClass::GetClass(key->GetClassName())->InheritsFrom(TH1::Class())) ) continue; const char* kName = key->GetName(); h = (TH1*)key->ReadObj(); const char* hName = h->GetName(); std::cout << " histoname = " << hName << std::endl; TH1F* h1 = h->Clone(); for ( int id=2; id<=32; id++ ) { // std::string input_t = "../t23-bld/harp-histo-no-res-decays/" + beam + target + energy + "GeV" + physlist + "-" ; // std::string input_t = "../t23-bld/harp-histo/" + beam + target + energy + "GeV" + physlist + "-" ; std::string input_t = "../t23-bld/na49-histo/" + beam + target + energy + "GeV" + physlist + "-" ; char buf[5]; sprintf( buf, "%i", id ); input_t.append( buf ); input_t += ".root"; TFile* iFile_t = TFile::Open( input_t.c_str() ); TH1F* h_t = (TH1F*)iFile_t->Get( h->GetName() ); h1->Add( h_t ); iFile_t->Close(); } if ( doScale ) { if (!(strcmp(key->GetClassName(),"TProfile"))) h1->Scale( scale ); } targetFile->cd(); h1->Write(); key = (TKey*)next(); } targetFile->Close(); return; }
void counts(int run, int lumistart, int lumiend, string type, map<string,vector<tripletI> > &cnt, vector<tripletD> &cntref, string hlttype, bool docnt, bool doref) { TString filename = basedir + Form("/DQM_V0001_HLTpb_R000%i.root",run); TFile *f = new TFile(filename); if (!f->IsOpen()) { cout << "Error, could not open " << filename << endl; return; } TString tdirname = Form("DQMData/Run %i/HLT/Run summary/TriggerRates/",run) + TString(type); f->cd(tdirname); TProfile *hlumi = (TProfile*) f->Get(Form("DQMData/Run %i/HLT/Run summary/LumiMonitoring/lumiVsLS",run)); if (extrapol) extrapolate(hlumi); // if HLT: accept, error, pass L1 seed, pass prescaler, reject TIter next(gDirectory->GetListOfKeys()); TKey *key; while ((key = (TKey*)next())) { TClass *cl = gROOT->GetClass(key->GetClassName()); // it must be an histogram if (!cl->InheritsFrom("TH1")) continue; TH1 *h = (TH1*)key->ReadObj(); // the name must match one of the requested patterns bool match=false; TString hname(h->GetName()); for (vector<TRegexp>::const_iterator it=patterns.begin(); it!=patterns.end(); it++) { if (hname(*it).Length()!=0) { match=true; break; } } if (!match) continue; int nlumis = (lumiend+1-lumistart); if (extrapol) extrapolate(h); if (type != "HLT") fill(cnt[h->GetName()], h, run, lumistart, lumiend, docnt); else { string htitle(h->GetTitle()); if (htitle.find(hlttype) == string::npos) continue; else { TString thepath; Ssiz_t from=0; TString(htitle).Tokenize(thepath,from," "); fill(cnt[thepath.Data()], h, run, lumistart, lumiend, docnt); } } } if (doref) { fill(cntref, hlumi, run, lumistart, lumiend); } f->Close(); delete f; }
// echo object at mouse position void exec1() { //example of macro called when a pad is redrawn //one must create a TExec object in the following way // TExec ex("ex",".x exec1.C"); // ex.Draw(); // this macro prints the bin number and the bin content when one clicks //on the histogram contour of any histogram in a pad //Author: Rene Brun if (!gPad) { Error("exec1", "gPad is null, you are not supposed to run this macro"); return; } int event = gPad->GetEvent(); if (event != 11) return; int px = gPad->GetEventX(); TObject *select = gPad->GetSelected(); if (!select) return; if (select->InheritsFrom(TH1::Class())) { TH1 *h = (TH1*)select; Float_t xx = gPad->AbsPixeltoX(px); Float_t x = gPad->PadtoX(xx); Int_t binx = h->GetXaxis()->FindBin(x); printf("event=%d, hist:%s, bin=%d, content=%f\n",event,h->GetName(),binx,h->GetBinContent(binx)); } }
void initialize( const char* countdbfn = "counts.root" ) { XSWeightTool::update( "Xsection8TeV_bkg_v4.txt" ); XSWeightTool::update( "Xsection8TeV_sig_v4.txt" ); // XSWeightTool::print(); using namespace std; TFile* f = TFile::Open( countdbfn, "read" ); if( f == NULL || f->IsZombie() ) { return; } TIter next( f->GetListOfKeys() ); TKey *key; int nhist = 0; while( (key = (TKey*)next()) ) { nhist++; // cout << "Key " << nhist << endl; // cout << " Classname " << key->GetClassName() << endl; // cout << " Title " <<key->GetTitle() << endl; if( key->ReadObj()->InheritsFrom( TH1::Class() ) ) { TH1* h = (TH1*)( key->ReadObj() ); long run_num = TString( h->GetName() ).Atoi(); num_events[run_num] = h->GetBinContent( 1 ); // cout << " Run, # of events : " << run_num << ", " << h->GetBinContent( 21 ) << endl; } } // cout << "Done" << endl; }
// ----------------------------------------------------------------------------- // TH1* getHisto( std::string nameFile, std::string nameHist, std::string Dirname, int rebin ) { std::string name = nameFile; TFile* file = new TFile(name.c_str()); if (file) { std::cout << "Opened file: " << file->GetName() << std::endl; } else { std::cout << "Could not find file: " << name << std::endl; return 0; } TDirectory* dir = (TDirectory*)file->Get(Dirname.c_str()); if (dir) { std::cout << "Opened dir: " << dir->GetName() << std::endl; } else { std::cout << "Could not find dir: " << Dirname << std::endl; return 0; } int low = 375; TH1* hist = 0; if ( false || nameHist.find("HtMultiplicity_HT375") == std::string::npos ) { hist = (TH1*)dir->Get(nameHist.c_str()); } else { for ( uint ii = low; ii <= 975; ii+=100 ) { std::stringstream tmp; tmp << "HtMultiplicity_HT" << ii << nameHist.substr(20); if ( !hist ) { dir->cd(); TH1D* temp = (TH1D*)dir->Get( "HtMultiplicity_HT375_aT0" ); //TH1D* temp = (TH1D*)file->Get( tmp.str().c_str() ); if (temp) { hist = (TH1D*)temp->Clone(); } else { std::cout << "1 Unable to retrieve histo with name " << tmp.str() << std::endl; } } else { dir->cd(); TH1D* temp = (TH1D*)dir->Get( tmp.str().c_str() ); if (temp) { hist->Add( (TH1D*)temp ); } else { std::cout << "2 Unable to retrieve histo with name " << tmp.str() << std::endl; } } } } if (hist) { std::cout << "Opened histo: " << hist->GetName() << std::endl; } else { std::cout << "Could not find histo: " << nameHist << std::endl; return 0; } hist->SetLineWidth(3); if ( rebin > 0 ) { hist->Rebin(rebin); } hist->GetXaxis()->SetTitleSize(0.055); hist->GetYaxis()->SetTitleSize(0.055); hist->GetXaxis()->SetLabelSize(0.05); hist->GetYaxis()->SetLabelSize(0.05); hist->SetStats(kFALSE); return hist; }
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; }
TH1 *MillePedeTrees::CreateHist(const char *exp, const char *selection, const char *hDef, Option_t* opt) { TH1 *h = this->Draw(exp, selection, hDef, "goff"); TH1 *hResult = static_cast<TH1*>(h->Clone(Form("%sC", h->GetName()))); if (opt) hResult->SetOption(opt); return hResult; }
void DrawTree( TTree& tree, TH1& hist, const char* branchname, const std::string condition, const char* append = "") { gROOT->cd(); std::string plot = std::string(branchname); plot.append(append); plot.append(hist.GetName()); tree.Draw( plot.c_str(), condition.c_str(), "goff" ); }
TProfile *MillePedeTrees::CreateHistProf(const char *expX, const char *expY, const char *selection, const char *hDef, Option_t* opt) { const TString combExpr(Form("%s:%s", expY, expX)); TH1 *h = this->Draw(combExpr, selection, hDef, "goff prof"); TProfile *hResult = static_cast<TProfile*>(h->Clone(Form("%sClone", h->GetName()))); if (opt) hResult->SetOption(opt); return hResult; }
void HistoCompare::PVCompute(TH1 * oldHisto , TH1 * newHisto , TText * te ) { myoldHisto1 = oldHisto; mynewHisto1 = newHisto; myte = te; Double_t *res; Double_t mypv = myoldHisto1->Chi2Test(mynewHisto1,"WW",res); TString title = myoldHisto1->GetName(); printRes(title, mypv, myte); return; }
TH1* merge_histos(TList *sourcelist){ TH1 *htot; TFile *first_source = (TFile*)sourcelist->First(); TDirectory *current_sourcedir = gDirectory; //gain time, do not add the objects in the list in memory Bool_t status = TH1::AddDirectoryStatus(); TH1::AddDirectory(kFALSE); // loop over all keys in this directory TChain *globChain = 0; TIter nextkey( current_sourcedir->GetListOfKeys() ); TKey *key, *oldkey=0; while ( (key = (TKey*)nextkey())) { //keep only the highest cycle number for each key if (oldkey && !strcmp(oldkey->GetName(),key->GetName())) continue; // read object from first source file TObject *obj = key->ReadObj(); // if the object is named "tot_edp_hbcoil" merge it if ( obj->FindObject("Tot_Edep_HBCoil")) { // cout << "Merging histogram " << obj->GetName() << endl; htot = (TH1*)obj; // loop over all source files and add the content of the // correspondant histogram to the one pointed to by "h1" TFile *nextsource = (TFile*)sourcelist->After( first_source ); while ( nextsource ) { // make sure we are at the correct directory level by cd'ing to path TKey *key2 = (TKey*)gDirectory->GetListOfKeys()->FindObject(htot->GetName()); if (key2) { TH1 *htemp = (TH1*)key2->ReadObj(); htot->Add(htemp); delete htemp; } nextsource = (TFile*)sourcelist->After( nextsource ); } } } return htot; }
void showTauIsolation(TFile* inputFile, const TString& dqmDirectory, const TString& meName, const char* dqmSubDirectoryTauJet, const char* dqmSubDirectoryMuon, const char* dqmSubDirectoryElectron, TCanvas* canvas, TPostScript* ps, const char* outputFileLabel, bool useLogScale) { canvas->SetLogy(useLogScale); TLegend legend(0.74, 0.71, 0.89, 0.89, "", "brNDC"); legend.SetBorderSize(0); legend.SetFillColor(0); TH1* meTauJet = getMonitorElement(inputFile, dqmDirectory, dqmSubDirectoryTauJet, meName); meTauJet->SetMarkerStyle(20); meTauJet->SetMarkerColor(kRed); meTauJet->SetLineColor(kRed); meTauJet->Draw("e1p"); legend.AddEntry(meTauJet, "#tau-Jet", "p"); if ( dqmSubDirectoryMuon != "" ) { TH1* meMuon = getMonitorElement(inputFile, dqmDirectory, dqmSubDirectoryMuon, meName); meMuon->SetMarkerStyle(21); meMuon->SetMarkerColor(kBlue); meMuon->SetLineColor(kBlue); meMuon->Draw("e1psame"); legend.AddEntry(meMuon, "#mu", "p"); } if ( dqmSubDirectoryElectron != "" ) { TH1* meElectron = getMonitorElement(inputFile, dqmDirectory, dqmSubDirectoryElectron, meName); meElectron->SetMarkerStyle(23); meElectron->SetMarkerColor(kGreen); meElectron->SetLineColor(kGreen); meElectron->Draw("e1psame"); legend.AddEntry(meElectron, "e", "p"); } legend.Draw(); canvas->Update(); TString outputFileName = TString("plot").Append(meTauJet->GetName()).Append("_").Append(outputFileLabel).Append(".png"); canvas->Print(outputFileName.Data()); //ps->NewPage(); }
void exec1() { if (!gPad) { Error("exec1", "gPad is null, you are not supposed to run this macro"); return; } int event = gPad->GetEvent(); if (event != 11) return; int px = gPad->GetEventX(); TObject *select = gPad->GetSelected(); if (!select) return; if (select->InheritsFrom(TH1::Class())) { TH1 *h = (TH1*)select; Float_t xx = gPad->AbsPixeltoX(px); Float_t x = gPad->PadtoX(xx); Int_t binx = h->GetXaxis()->FindBin(x); printf("event=%d, hist:%s, bin=%d, content=%f\n",event,h->GetName(),binx,h->GetBinContent(binx)); } }
// Do the loop here, so that we can use options like "errors" void Draw( const TString & xTitle = "", const TString & yTitle = "", const bool errors = false ) { // Create a new THStack so that it handle tha maximum // THStack stack(name_, title_); THStack * stack = new THStack(name_, title_); int colorIndex = 0; if( !(histoList_.empty()) ) { std::vector<TH1*>::iterator histoIter = histoList_.begin(); for( ; histoIter != histoList_.end(); ++histoIter, ++colorIndex ) { TH1 * histo = *histoIter; if(errors) histo->Sumw2(); // histo->SetNormFactor(1); if( colorIndex < 4 ) histo->SetLineColor(colors_[colorIndex]); else histo->SetLineColor(colorIndex); // Draw and get the maximum value TString normalizedHistoName(histo->GetName()); TH1 * normalizedHisto = (TH1*)histo->Clone(normalizedHistoName+"clone"); normalizedHisto->Scale(1/normalizedHisto->Integral()); stack->Add(normalizedHisto); } // Take the maximum of all the drawed histograms // First we need to draw the histogram, or getAxis() will return 0... (see root code...) canvas_->Draw(); canvas_->cd(); stack->Draw("nostack"); stack->GetYaxis()->SetTitleOffset(1.2); stack->GetYaxis()->SetTitle(yTitle); stack->GetXaxis()->SetTitle(xTitle); stack->GetXaxis()->SetTitleColor(kBlack); stack->Draw("nostack"); legend_->Draw("same"); canvas_->Update(); canvas_->Draw(); canvas_->ForceUpdate(); //canvas_->Print("test.pdf"); canvas_->Write(); } }
TH1* getHistogram(TFile* inputFile, const TString& meName, TObjArray& processes, const TString& region) { TH1* histogram_sum = 0; int numProcesses = processes.GetEntries(); for ( int iProcess = 0; iProcess < numProcesses; ++iProcess ) { TObjString* process = dynamic_cast<TObjString*>(processes.At(iProcess)); assert(process); TH1* histogram = getHistogram(inputFile, meName, process->GetString(), region); if ( !histogram_sum ) { TString histogramName_sum = histogram->GetName(); histogramName_sum = histogramName_sum.ReplaceAll(process->GetString(), "sum"); histogram_sum = (TH1*)histogram->Clone(histogramName_sum.Data()); if ( !histogram_sum->GetSumw2N() ) histogram_sum->Sumw2(); } else { histogram_sum->Add(histogram); } } return histogram_sum; }
RooHistN::RooHistN(const TH1 &data, Double_t nominalBinWidth, Double_t nSigma, RooAbsData::ErrorType etype, Double_t xErrorFrac) : TGraphAsymmErrors(), _nominalBinWidth(nominalBinWidth), _nSigma(nSigma), _rawEntries(-1) { // Create a histogram from the contents of the specified TH1 object // which may have fixed or variable bin widths. Error bars are // calculated using Poisson 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 addBin(), 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 input histogram's name and title SetName(data.GetName()); SetTitle(data.GetTitle()); // calculate our nominal bin width if necessary if(_nominalBinWidth == 0) { const TAxis *axis= ((TH1&)data).GetXaxis(); if(axis->GetNbins() > 0) _nominalBinWidth= (axis->GetXmax() - axis->GetXmin())/axis->GetNbins(); } // TH1::GetYaxis() is not const (why!?) setYAxisLabel(const_cast<TH1&>(data).GetYaxis()->GetTitle()); // initialize our contents from the input histogram's contents Int_t nbin= data.GetNbinsX(); for(Int_t bin= 1; bin <= nbin; bin++) { Axis_t x= data.GetBinCenter(bin); Stat_t y= data.GetBinContent(bin); Stat_t dy = data.GetBinError(bin) ; if (etype==RooAbsData::Poisson) { addBin(x,roundBin(y),data.GetBinWidth(bin),xErrorFrac); } else { addBinWithError(x,y,dy,dy,data.GetBinWidth(bin),xErrorFrac); } } // add over/underflow bins to our event count _entries+= data.GetBinContent(0) + data.GetBinContent(nbin+1); }
void boostcontrolplots( TDirectory *boostdir ) { const Int_t nPlots = 4; Int_t width = 900; Int_t height = 600; char cn[100]; const TString titName = boostdir->GetName(); sprintf( cn, "cv_%s", titName.Data() ); TCanvas *c = new TCanvas( cn, Form( "%s Control Plots", titName.Data() ), width, height ); c->Divide(2,2); const TString titName = boostdir->GetName(); TString hname[nPlots]={"Booster_BoostWeight","Booster_MethodWeight","Booster_ErrFraction","Booster_OrigErrFraction"}; for (Int_t i=0; i<nPlots; i++){ Int_t color = 4; TPad * cPad = (TPad*)c->cd(i+1); TH1 *h = (TH1*) boostdir->Get(hname[i]); TString plotname = h->GetName(); h->SetMaximum(h->GetMaximum()*1.3); h->SetMinimum( 0 ); h->SetMarkerColor(color); h->SetMarkerSize( 0.7 ); h->SetMarkerStyle( 24 ); h->SetLineWidth(1); h->SetLineColor(color); h->Draw(); c->Update(); } // write to file TString fname = Form( "plots/%s_ControlPlots", titName.Data() ); TMVAGlob::imgconv( c, fname ); }
void writeFile(const char* inRootFile) { TFile inRoot(inRootFile); if(!inRoot.IsOpen()){ cout << "Cannot open " << inRootFile << endl; return; } TIterator* iterator = inRoot.GetListOfKeys()->MakeIterator(); TKey* key; TString outText = inRootFile; outText.Replace(0,outText.Last('/')+1,""); ofstream os(outText.Data()); char buf[500]; int count(0); while( (key=dynamic_cast<TKey*>(iterator->Next())) != 0){ cout << key->GetName() << endl; TH1* h = (TH1*)inRoot.Get(key->GetName()); if(h->GetDimension()!=1) continue; if(++count>1) break; int nBin = h->GetNbinsX(); os << "name: " << h->GetName() << endl << "title: " << h->GetTitle() << endl << "bins: " << h->GetNbinsX() << endl << "min: " << h->GetXaxis()->GetBinLowEdge(1) << ", max: " << h->GetXaxis()->GetBinUpEdge(h->GetNbinsX()) << endl; for(int i=1; i<=nBin; i++){ os << "bin: " << i << " value: " << (float)h->GetBinContent(i) << " error: " << (float)h->GetBinError(i) << endl; } } }
cmsListDir( const TObjString * firstdirname, const TDirectory * firstDir ) { TObjArray * dirs = new TObjArray ; dirs->AddLast(new TPair(firstdirname,firstDir)) ; TList * keys ; TKey * key ; TH1 * histo ; TIter nextDir(dirs) ; TPair * pair ; const TObjString * dirname ; const TDirectory * dir ; while (pair = (TPair *)nextDir()) { dirname = (TObjString *)pair->Key() ; dir = (TDirectory *)pair->Value() ; keys = dir->GetListOfKeys() ; TIter nextKey(keys) ; while (key = (TKey *)nextKey()) { obj = key->ReadObj() ; if (obj->IsA()->InheritsFrom("TDirectory")) { dirs->AddLast(new TPair(new TObjString(dirname->String()+"/"+obj->GetName()),obj)) ; } else if (obj->IsA()->InheritsFrom("TH1")) { histo = (TH1 *)obj ; std::cout <<"Histo "<<dirname->String()<<"/"<<histo->GetName() <<" has "<<histo->GetEffectiveEntries()<<" entries" <<" of mean value "<<histo->GetMean() <<std::endl ; } else { std::cout<<"What is "<<obj->GetName()<<" ?"<<std::endl ; } } } }
void patBJetTracks_efficiencies() { // define proper canvas style setNiceStyle(); gStyle->SetOptStat(0); // open file TFile* file = new TFile("analyzePatBJetTracks.root"); TLegend *legend[3] = { 0, 0, 0 }; // draw canvas with efficiencies TCanvas *canv; canv = new TCanvas("canv0", "hand-crafted track counting efficiencies", 800, 300); canv->Divide(3, 1); TH1 *total = (TH1*)file->Get(Form("%s/flavours", directory)); TH1 *effVsCutB = 0; unsigned int i = 0; for(const char **flavour = flavours; *flavour; flavour++, i++) { TH1 *h = (TH1*)file->Get(Form("%s/trackIPSig_%s", directory, *flavour)); TH1 *discrShape = (TH1*)h->Clone(Form("%s_discrShape", h->GetName())); discrShape->Scale(1.0 / discrShape->Integral()); discrShape->SetMaximum(discrShape->GetMaximum() * 5); TH1 *effVsCut = computeEffVsCut(h, total->GetBinContent(4 - i)); TH1 *effVsBEff = 0; if (flavour == flavours) // b-jets effVsCutB = effVsCut; else effVsBEff = computeEffVsBEff(effVsCut, effVsCutB); discrShape->SetTitle("discriminator shape"); effVsCut->SetTitle("efficiency versus discriminator cut"); if (effVsBEff) effVsBEff->SetTitle("mistag versus b efficiency"); setHistStyle(discrShape); setHistStyle(effVsCut); setHistStyle(effVsBEff); canv->cd(1); gPad->SetLogy(1); gPad->SetGridy(1); discrShape->SetLineColor(i + 1); discrShape->SetMarkerColor(i + 1); discrShape->Draw(i > 0 ? "same" : ""); if (!legend[0]) legend[0] = new TLegend(0.5, 0.7, 0.78, 0.88); legend[0]->AddEntry(discrShape, *flavour); canv->cd(2); gPad->SetLogy(1); gPad->SetGridy(1); effVsCut->SetLineColor(i + 1); effVsCut->SetMarkerColor(i + 1); effVsCut->Draw(i > 0 ? "same" : ""); if (!legend[1]) legend[1] = new TLegend(0.12, 0.12, 0.40, 0.30); legend[1]->AddEntry(effVsCut, *flavour); if (!effVsBEff) continue; canv->cd(3); gPad->SetLogy(1); gPad->SetGridx(1); gPad->SetGridy(1); effVsBEff->SetLineColor(i + 1); effVsBEff->SetMarkerColor(i + 1); effVsBEff->Draw(i > 1 ? "same" : ""); if (!legend[2]) legend[2] = new TLegend(0.12, 0.7, 0.40, 0.88); legend[2]->AddEntry(effVsBEff, *flavour); } canv->cd(1); legend[0]->Draw(); canv->cd(2); legend[1]->Draw(); canv->cd(3); legend[2]->Draw(); //////////////////////////////////////////// // canvas to compare negative tagger with light flavour mistag TCanvas *canv; canv = new TCanvas("canv1", "comparing light flavour mistag with negative tagger", 530, 300); canv->Divide(2, 1); TH1 *h1 = (TH1*)file->Get(Form("%s/trackIPSig_udsg", directory)); TH1 *h2 = (TH1*)file->Get(Form("%s/negativeIPSig_all", directory)); h2 = invertHisto(h2); // invert x-axis TH1 *discrShape1 = (TH1*)h1->Clone("discrShape1"); TH1 *discrShape2 = (TH1*)h2->Clone("discrShape2"); discrShape1->Scale(1.0 / discrShape1->Integral()); discrShape1->SetMaximum(discrShape1->GetMaximum() * 5); discrShape2->Scale(1.0 / discrShape2->Integral()); TH1 *effVsCut1 = computeEffVsCut(h1, total->GetBinContent(2)); TH1 *effVsCut2 = computeEffVsCut(h2, total->GetBinContent(1)); discrShape1->SetTitle("discriminator shape"); effVsCut1->SetTitle("efficiency versus discriminator cut"); setHistStyle(discrShape1); setHistStyle(discrShape2); setHistStyle(effVsCut1); setHistStyle(effVsCut2); canv->cd(1); gPad->SetLogy(1); gPad->SetGridy(1); discrShape1->SetLineColor(1); discrShape1->SetMarkerColor(1); discrShape2->SetLineColor(2); discrShape2->SetMarkerColor(2); discrShape1->Draw(); discrShape2->Draw("same"); TLegend *l = new TLegend(0.5, 0.7, 0.78, 0.88); l->AddEntry(discrShape1, "udsg"); l->AddEntry(discrShape2, "inv. neg"); l->Draw(); canv->cd(2); gPad->SetLogy(1); gPad->SetGridy(1); effVsCut1->SetLineColor(1); effVsCut1->SetMarkerColor(1); effVsCut2->SetLineColor(2); effVsCut2->SetMarkerColor(2); effVsCut1->Draw(); effVsCut2->Draw("same"); l = new TLegend(0.5, 0.7, 0.78, 0.88); l->AddEntry(effVsCut1, "udsg"); l->AddEntry(effVsCut2, "inv. neg"); l->Draw(); }
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 makeHist(const int sample, const int dataset=1) void makeHist(const string title="") { vector<Hist> hist2print; TPaveText *tx = new TPaveText(.05,.1,.95,.8); // tx->AddText("Using Deafult JERs for all jets"); // tx->AddText("Using b-Jet JERs"); /* string title("QCD MG:"); //if (sample==1) title += "NJet(70/50/30>=2/4/5), #slash{E}_{T}>175, Triplet>1, 80<TopMass<270, TOP+0.5*BJET>500, MT2>300, #Delta#Phi(.5,.5,.3), BJets>=1"; if (sample==1) title += "All Stop cuts applied (use default JERs for all jets)"; else if (sample==2) title += "All Stop cuts applied + Inverted #Delta#Phi (use default JERs for all jets)"; else if (sample==3) title += "All Stop cuts applied (use b-Jet JERs)"; else if (sample==4) title += "All Stop cuts applied + Inverted #Delta#Phi (use b-Jet JERs)"; else if (sample==5) title += "No cuts applied"; */ unsigned bitMaskArray[] = {0,1,2,3,129,130,131,195,257,258,269,323}; vector<unsigned> vBitMaskArray(bitMaskArray, bitMaskArray + sizeof(bitMaskArray) / sizeof(unsigned)); stringstream unclmet_title; unclmet_title << title << "Unclutered MET"; hist2print.push_back(Hist("met",title,2,0.0, 400.0,1)); hist2print.push_back(Hist("unclmet",unclmet_title.str().c_str(),2,0.0, 100.0,1)); hist2print.push_back(Hist("mht",title,2,0.0, 400.0,1)); hist2print.push_back(Hist("ht",title,2,0,2000,1)); hist2print.push_back(Hist("njet30eta5p0",title,1,0,15,1)); hist2print.push_back(Hist("nbjets",title,1,0,10,1)); // hist2print.push_back(Hist("bjetPt",title,2)); hist2print.push_back(Hist("M123",title,2)); // hist2print.push_back(Hist("M23overM123",title)); hist2print.push_back(Hist("MT2",title,2)); hist2print.push_back(Hist("MTb",title,4)); hist2print.push_back(Hist("MTt",title,4)); hist2print.push_back(Hist("MTb_p_MTt",title,2,400,1000,1)); //hist2print.push_back(Hist("jet1_pt",title,2)); //hist2print.push_back("bjetPt"); // hist2print.push_back(Hist("bjetMass",title,2,0,200)); // hist2print.push_back(Hist("dphimin",title,4)); TFile *outRootFile = new TFile("Merged.root"); /*TPad *c1=0, *c2=0; TCanvas *c = GetCanvas(c1, c2); if (c ==NULL|| c1 == 0 ||c2 == 0) { cout << " A drawing pad is null !"<< endl; cout << "c = " << c << endl; cout << "c1 = " << c1 << endl; cout << "c2 = " << c2 << endl; assert(false); }*/ TCanvas *c = new TCanvas("c1"); c->Range(0,0,1,1); c->SetBorderSize(2); c->SetFrameFillColor(0); // ------------>Primitives in pad: c1_1 TPad *c1_1 = new TPad("c1_1", "c1_1",0.01,0.30,0.99,0.99); c1_1->Draw(); c1_1->cd(); c1_1->SetBorderSize(2); c1_1->SetTickx(1); c1_1->SetTicky(1); c1_1->SetTopMargin(0.1); c1_1->SetBottomMargin(0.0); //c1_1->SetFrameFillColor(3); //c1_1->SetLogy(); c->cd(); // ------------>Primitives in pad: c1_2 TPad *c1_2 = new TPad("c1_2", "c1_2",0.01,0.01,0.99,0.30); c1_2->Draw(); c1_2->cd(); c1_2->SetBorderSize(2); c1_2->SetTickx(1); c1_2->SetTicky(1); c1_2->SetTopMargin(0.0); c1_2->SetBottomMargin(0.24); c1_2->SetFrameFillColor(0); c1_2->SetGridx(); c1_2->SetGridy(); c->cd(); gStyle->SetOptStat(0); gPad->Print("samples.eps["); for (unsigned i=0;i<vBitMaskArray.size(); ++i) { unsigned mask = vBitMaskArray.at(i); for (unsigned ihist=0; ihist < hist2print.size(); ++ihist) { stringstream path, reco_hist_name, gen_hist_name, smear_hist_name; stringstream reco_hist, gen_hist, smear_hist; stringstream folder; folder << "Hist/Mask"<< mask << "HT0to8000MHT0to8000/"; //cout << "folder = " << folder.str() << endl; /* if ((hist2print.at(ihist).Name()).find("Jet")) { reco_hist_name << folder.str() << "reco" << hist2print.at(ihist).Name() << "_copy"; reco_hist << folder.str() << "reco" << hist2print.at(ihist).Name(); smear_hist_name << folder.str() << "smeared" << hist2print.at(ihist).Name() << "_copy"; smear_hist << folder.str() << "smeared" << hist2print.at(ihist).Name(); gen_hist_name << folder.str() << "gen" << hist2print.at(ihist).Name() << "_copy"; gen_hist << folder.str() << "gen" << hist2print.at(ihist).Name(); } else */ { reco_hist_name << folder.str() << "reco_" << hist2print.at(ihist).Name() << "_copy"; reco_hist << folder.str() << "reco_" << hist2print.at(ihist).Name(); smear_hist_name << folder.str() << "smeared_" << hist2print.at(ihist).Name() << "_copy"; smear_hist << folder.str() << "smeared_" << hist2print.at(ihist).Name(); gen_hist_name << folder.str() << "gen_" << hist2print.at(ihist).Name() << "_copy"; gen_hist << folder.str() << "gen_" << hist2print.at(ihist).Name(); } TH1* hreco = (TH1*) (outRootFile->Get(reco_hist.str().c_str())); if (hreco == NULL) { cout << "hreco = " << reco_hist.str() << " was not found!" << endl; assert(false); } hreco->SetDirectory(0); TH1* hsmear = (TH1*) (outRootFile->Get(smear_hist.str().c_str())); if (hsmear == NULL) { cout << "hsmear = " << smear_hist.str() << " was not found!" << endl; assert(false); } hsmear->SetDirectory(0); TH1* hgen = (TH1*) (outRootFile->Get(gen_hist.str().c_str())); //->Clone(gen_hist_name.str().c_str())); if (hgen == NULL) { cout << "hgen = " << gen_hist.str() << " was not found!" << endl; assert(false); } hgen->SetDirectory(0); hreco->Sumw2(); hsmear->Sumw2(); hgen->Sumw2(); const int rebin = hist2print.at(ihist).Rebin(); const string title = hist2print.at(ihist).Title(); const double xmin = hist2print.at(ihist).Xmin(); const double xmax = hist2print.at(ihist).Xmax(); if (rebin>1) { hreco->Rebin(rebin); hsmear->Rebin(rebin); hgen->Rebin(rebin); } if (title.length()>0) { hreco->SetTitle(title.c_str()); hsmear->SetTitle(title.c_str()); hgen->SetTitle(title.c_str()); } if (xmin != LargeNegNum || xmax != LargeNegNum) { hreco->GetXaxis()->SetRangeUser(xmin,xmax); hsmear->GetXaxis()->SetRangeUser(xmin,xmax); hgen->GetXaxis()->SetRangeUser(xmin,xmax); } const double reco_max_y = hreco->GetBinContent(hreco->GetMaximumBin()); const double smear_max_y = hsmear->GetBinContent(hsmear->GetMaximumBin()); const double y_max = max(reco_max_y, smear_max_y); double y_min = 9999.0; for (unsigned bin=1; bin<hreco->GetNbinsX(); ++bin) { const double v1 = hreco->GetBinContent(bin); const double v2 = hsmear->GetBinContent(bin); const double minv = min(v1,v2); if (minv != 0 && minv < y_min) y_min = minv; } cout << hreco->GetName() << "->ymin/max = " << y_min << "(" << y_min/2.0 << ")/" << y_max << "(" << y_max*2.0 << ")" << endl; hreco->GetYaxis()->SetRangeUser(y_min/2.0, y_max*2.0); hsmear->GetYaxis()->SetRangeUser(y_min/2.0, y_max*2.0); hgen->SetLineColor(kBlue); hgen->SetMarkerColor(kBlue); hgen->SetMarkerStyle(24); hgen->SetLineWidth(2); hsmear->SetLineColor(kRed); hsmear->SetMarkerColor(kRed); hsmear->SetMarkerStyle(24); hsmear->SetLineWidth(2); hreco->SetLineWidth(2); hreco->SetMarkerStyle(kDot); hreco->SetLineColor(kBlack); hreco->SetMarkerColor(kBlack); //hreco->GetXaxis()->SetRangeUser(0,300); //hsmear->GetXaxis()->SetRangeUser(0,300); hreco->GetYaxis()->CenterTitle(1); hreco->SetLabelFont(42,"XYZ"); hreco->SetTitleFont(42,"XYZ"); hreco->GetYaxis()->SetTitleOffset(0.8); hreco->SetLabelSize(0.05,"XYZ"); hreco->SetTitleSize(0.06,"XYZ"); TH1 *hsmeartoreco_ratio = (TH1*) (hsmear->Clone("hsmear_copy")); hsmeartoreco_ratio->Divide(hreco); hsmeartoreco_ratio->SetTitle(""); hsmeartoreco_ratio->GetYaxis()->SetTitle("Smear/Reco"); hsmeartoreco_ratio->GetYaxis()->SetRangeUser(0,2.); hsmeartoreco_ratio->GetYaxis()->SetTitleOffset(0.4); hsmeartoreco_ratio->GetXaxis()->SetTitleOffset(0.9); hsmeartoreco_ratio->GetYaxis()->CenterTitle(1); hsmeartoreco_ratio->GetXaxis()->CenterTitle(1); hsmeartoreco_ratio->SetLabelSize(0.125,"XYZ"); hsmeartoreco_ratio->SetTitleSize(0.125,"XYZ"); // hsmeartoreco_ratio->SetLabelFont(labelfont,"XYZ"); // hsmeartoreco_ratio->SetTitleFont(titlefont,"XYZ"); hsmeartoreco_ratio->GetXaxis()->SetTickLength(0.07); stringstream recoleg,smearleg, genleg; const double sum_reco = hreco->Integral(1, hreco->GetNbinsX()+1); const double sum_smear = hsmear->Integral(1, hsmear->GetNbinsX()+1); const double sum_gen = hgen->Integral(1, hgen->GetNbinsX()+1); const double err_reco = StatErr(hreco); const double err_smear = StatErr(hsmear); cout << setprecision(1) << fixed; recoleg << "Reco (" << sum_reco << "#pm" << err_reco << ")"; smearleg << "Smear (" << sum_smear << "#pm" << err_smear << ")"; genleg << "Gen (" << sum_gen << ")"; cout << smear_hist_name.str() << "::reco/smear = " << sum_reco << "/" << sum_smear << endl; TLegend *l2 = new TLegend(0.6,0.6,0.9,0.9); l2->AddEntry(hreco, recoleg.str().c_str()); //l2->AddEntry(hgen, genleg.str().c_str()); l2->AddEntry(hsmear, smearleg.str().c_str()); c1_1->cd(); gPad->SetLogy(hist2print.at(ihist).LogY()); hreco->DrawCopy(); //hgen->DrawCopy("same"); hsmear->DrawCopy("same"); l2->Draw(); //tx->Draw(); c1_2->cd(); hsmeartoreco_ratio->DrawCopy(); c->cd(); gPad->Print("samples.eps"); } } gPad->Print("samples.eps]"); }
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 patBJetVertex_efficiencies() { // define proper canvas style setNiceStyle(); gStyle->SetOptStat(0); // open file TFile* file = new TFile("analyzePatBJetVertex.root"); unsigned int j = 0; for(const char **algo = algos; *algo; algo++, j++) { TLegend *legend[3] = { 0, 0, 0 }; // draw canvas with efficiencies TCanvas *canv; canv = new TCanvas(*algo, Form("%s efficiencies", algoNames[j]), 800, 300); canv->Divide(3, 1); TH1 *total = (TH1*)file->Get(Form("%s/flavours", directory)); TH1 *effVsCutB = 0; unsigned int i = 0; for(const char **flavour = flavours; *flavour; flavour++, i++) { TH1 *h = (TH1*)file->Get(Form("%s/%s_%s", directory, *algo, *flavour)); TH1 *discrShape = (TH1*)h->Clone(Form("%s_discrShape", h->GetName())); discrShape->Scale(1.0 / discrShape->Integral()); discrShape->SetMaximum(discrShape->GetMaximum() * 5); TH1 *effVsCut = computeEffVsCut(h, total->GetBinContent(4 - i)); TH1 *effVsBEff = 0; if (flavour == flavours) // b-jets effVsCutB = effVsCut; else effVsBEff = computeEffVsBEff(effVsCut, effVsCutB); discrShape->SetTitle("discriminator shape"); effVsCut->SetTitle("efficiency versus discriminator cut"); if (effVsBEff) effVsBEff->SetTitle("mistag versus b efficiency"); setHistStyle(discrShape); setHistStyle(effVsCut); setHistStyle(effVsBEff); canv->cd(1); gPad->SetLogy(1); gPad->SetGridy(1); discrShape->SetLineColor(i + 1); discrShape->SetMarkerColor(i + 1); discrShape->Draw(i > 0 ? "same" : ""); if (!legend[0]) legend[0] = new TLegend(0.5, 0.7, 0.78, 0.88); legend[0]->AddEntry(discrShape, *flavour); canv->cd(2); gPad->SetLogy(1); gPad->SetGridy(1); effVsCut->SetLineColor(i + 1); effVsCut->SetMarkerColor(i + 1); effVsCut->Draw(i > 0 ? "same" : ""); if (!legend[1]) legend[1] = new TLegend(0.3, 0.4, 0.58, 0.58); legend[1]->AddEntry(effVsCut, *flavour); if (!effVsBEff) continue; canv->cd(3); gPad->SetLogy(1); gPad->SetGridx(1); gPad->SetGridy(1); effVsBEff->SetLineColor(i + 1); effVsBEff->SetMarkerColor(i + 1); effVsBEff->Draw(i > 1 ? "same" : ""); if (!legend[2]) legend[2] = new TLegend(0.12, 0.7, 0.40, 0.88); legend[2]->AddEntry(effVsBEff, *flavour); } canv->cd(1); legend[0]->Draw(); canv->cd(2); legend[1]->Draw(); canv->cd(3); legend[2]->Draw(); } }
void plot_efficiencies( TFile* file, Int_t type = 2, TDirectory* BinDir) { // input: - Input file (result from TMVA), // - type = 1 --> plot efficiency(B) versus eff(S) // = 2 --> plot rejection (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 { // 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"; TString ftit = ytit + " versus " + xtit; if (TString(BinDir->GetName()).Contains("multicut")){ ftit += " Bin: "; ftit += (BinDir->GetTitle()); } // 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, *hkey; TString hNameRef = "effBvsS"; if (type == 2) hNameRef = "rejBvsS"; 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() ); while ((hkey = TMVAGlob::NextKey(nextKey,"TH1"))) { TH1 *h = (TH1*)hkey->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(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; }
//void MergeMetHists(const int Nfiles=0, // const std::string filenamebase="", // const std::string title="", const std::string name="", // const float LoX=-1, const float HiX=-1, const int rebin=1, // const std::string printfile="", bool debug=false) void MergeMetHists(const int Nfiles, const std::string filenamebase, const std::string title, const std::string name, const float LoX=-1, const float HiX=-1, const int rebin=1, const std::string printfile="", const int MetSig=4, bool debug=false, const bool logy=false) { assert (Nfiles>0 && "Number of files must be > 0"); assert (name.length()>0 && "Require hist name!"); assert (filenamebase.length()>0 && "Require base of the file name!"); std::cout << "MetSig=" << MetSig << std::endl; std::cout << "Searching for obj = " << name <<std::endl; std::string data_path, bg_path, def_path; std::string ue1_path, ue2_path, ue3_path, ue4_path, ue5_path, ue6_path; std::string ue7_path, ue8_path, ue9_path; std::string jer1_path, jer2_path, jer3_path, jer4_path, jer5_path; std::string jer6_path, jer7_path, jer8_path, jer9_path, jer10_path; data_path="/Ana/MyJetFilter/Hist/Ana_data/"; bg_path="/Ana/MyJetFilter/Hist/Ana_bckg/"; def_path="/Ana/MyJetFilter/Hist/Ana_def/"; ue1_path="/Ana/MyJetFilter/Hist/Ana_ue1/"; ue2_path="/Ana/MyJetFilter/Hist/Ana_ue2/"; ue3_path="/Ana/MyJetFilter/Hist/Ana_ue3/"; ue4_path="/Ana/MyJetFilter/Hist/Ana_ue4/"; ue5_path="/Ana/MyJetFilter/Hist/Ana_ue5/"; ue6_path="/Ana/MyJetFilter/Hist/Ana_ue6/"; ue7_path="/Ana/MyJetFilter/Hist/Ana_ue7/"; ue8_path="/Ana/MyJetFilter/Hist/Ana_ue8/"; ue9_path="/Ana/MyJetFilter/Hist/Ana_ue9/"; jer1_path="/Ana/MyJetFilter/Hist/Ana_jer1/"; jer2_path="/Ana/MyJetFilter/Hist/Ana_jer2/"; jer3_path="/Ana/MyJetFilter/Hist/Ana_jer3/"; jer4_path="/Ana/MyJetFilter/Hist/Ana_jer4/"; jer5_path="/Ana/MyJetFilter/Hist/Ana_jer5/"; jer6_path="/Ana/MyJetFilter/Hist/Ana_jer6/"; jer7_path="/Ana/MyJetFilter/Hist/Ana_jer7/"; jer8_path="/Ana/MyJetFilter/Hist/Ana_jer8/"; jer9_path="/Ana/MyJetFilter/Hist/Ana_jer9/"; jer10_path="/Ana/MyJetFilter/Hist/Ana_jer10/"; /* data_path="Ana_data"; bg_path="Ana_bckg"; def_path="Ana_def"; ue1_path="Ana_ue1"; ue2_path="Ana_ue2"; ue3_path="Ana_ue3"; ue4_path="Ana_ue4"; ue5_path="Ana_ue5"; ue6_path="Ana_ue6"; ue7_path="Ana_ue7"; ue8_path="Ana_ue8"; ue9_path="Ana_ue9"; jer1_path="Ana_jer1"; jer2_path="Ana_jer2"; jer3_path="Ana_jer3"; jer4_path="Ana_jer4"; jer5_path="Ana_jer5"; jer6_path="Ana_jer6"; jer7_path="Ana_jer7"; jer8_path="Ana_jer8"; jer9_path="Ana_jer9"; jer10_path="Ana_jer10"; */ std::vector<std::string> vPaths; vPaths.push_back(data_path); vPaths.push_back(bg_path); vPaths.push_back(def_path); vPaths.push_back(ue1_path); vPaths.push_back(ue2_path); vPaths.push_back(ue3_path); vPaths.push_back(ue4_path); vPaths.push_back(ue5_path); vPaths.push_back(ue6_path); vPaths.push_back(ue7_path); vPaths.push_back(ue8_path); vPaths.push_back(ue9_path); vPaths.push_back(jer1_path); vPaths.push_back(jer2_path); vPaths.push_back(jer3_path); vPaths.push_back(jer4_path); vPaths.push_back(jer5_path); vPaths.push_back(jer6_path); vPaths.push_back(jer7_path); vPaths.push_back(jer8_path); vPaths.push_back(jer9_path); vPaths.push_back(jer10_path); TFile *f = 0; TH1 *hist_data = 0, *hist_bg = 0; int iNHists = vPaths.size(); std::vector<TH1*> vHist; for (int n= 0; n < iNHists; ++n) { TH1 *temp=0; vHist.push_back(temp); } int NfilesOpened = 0; //for (int i=1; i<=1; ++i) for (int i=1; i<=Nfiles; ++i) { std::stringstream file; file << filenamebase << i; //file << "myhisto_PhoJetAna_Pyth_phojet22_1Njet15_test_040208.root"; f = new TFile (file.str().c_str()); if (f->IsZombie()) { std::cout << "ERROR::File " << file.str() << " did not open! Exiting." << std::endl; exit (1); } else { NfilesOpened++; if (debug) { std::cout << "File Added::"; f->Print(); } } gROOT->ls(); TFolder *fold = (TFolder*) gDirectory->FindObjectAny("Ana"); assert(fold != NULL && "folder null"); TFolder *dir = (TFolder*) fold->FindObjectAny("MyJetFilter"); assert(dir != NULL && "dir null"); TFolder *dir2 = (TFolder*) dir->FindObjectAny("Hist"); assert(dir2 != NULL && "Hist null"); //TH1 *h = dynamic_cast<TH1*> (dir3->FindObjectAny(name.c_str())); //assert (h!=NULL && "hist null"); //h->Draw(); //return; for (unsigned int iPath = 0; iPath < vPaths.size(); ++iPath) { //std::cout << "iPath = " << iPath << std::endl; TFolder *dir3 = (TFolder*) dir2->FindObjectAny(vPaths.at(iPath).c_str()); assert(dir3 != NULL && "data null"); //f->cd(); //gDirectory->pwd(); //f->cd(vPaths.at(iPath).c_str()); //gDirectory->pwd(); //if (iPath<2) f->ls(); //TH1 *hTemp = dynamic_cast<TH1*> (gDirectory->FindObjectAny(name.c_str())); std::stringstream histpath; histpath << vPaths.at(iPath) << name; //TFolder *ana = (TFolder*) gDirectory->FindObjectAny("Ana"); //assert(ana !=NULL && "Ana folder not found"); //std::cout << "histpath = " << histpath.str() << std::endl; TH1 *hTemp = dynamic_cast<TH1*> (dir3->FindObjectAny(name.c_str())); assert(hTemp != NULL && "object not found!"); if (hTemp->GetEntries()) // this has to be done to avoid crashes when adding hists which some how have 'sum=nan' instead of 'sum=0' when they do not have any entries. { if (! vHist.at(iPath)) { std::string name = hTemp->GetName() + std::string ("_Clone"); vHist.at(iPath) = dynamic_cast<TH1*>(hTemp->Clone (name.c_str())); assert(vHist.at(iPath) != NULL && "Data hist cast failed"); vHist.at(iPath)->SetDirectory(0); } else { vHist.at(iPath)->Add(hTemp); } } } delete f; } /* assert(vHist.size() == vPaths.size()); for (int k=0; k < vHist.size(); ++k) { vHist.at(k)->Print(); } */ DoSystematics(vHist); hist_data = vHist.at(0); hist_bg = vHist.at(1); /* std::cout << "NORMALIZING BG TO DATA " << std::endl; double data_int = hist_data->Integral(); double bg_int = hist_bg->Integral(); hist_bg->Scale(data_int/bg_int); std::cout << "SCALE = " << data_int/bg_int << std::endl; */ if (debug) { hist_data->Print("all"); hist_bg->Print("all"); } std::cout << "Total file added = " << NfilesOpened << std::endl; gStyle->SetOptStat(""); if (hist_data->GetEntries()) hist_data->Rebin(rebin); if (hist_bg->GetEntries()) hist_bg->Rebin(rebin); TH1 *hist_err_copy = NULL; std::string bgname = hist_bg->GetName() + std::string ("err_copy"); hist_err_copy = dynamic_cast<TH1*>(hist_bg->Clone (bgname.c_str())); hist_err_copy->SetDirectory(0); TH1 *hist_data_copy = NULL; std::string dataname = hist_data->GetName() + std::string ("data_copy"); hist_data_copy = dynamic_cast<TH1*>(hist_data->Clone (dataname.c_str())); hist_data_copy->SetDirectory(0); float x_loLim, x_hiLim; if (LoX >0) x_loLim = LoX; else x_loLim = hist_data->GetBinLowEdge(1); if (HiX >0) x_hiLim = HiX; else x_hiLim = max(FindUpLimit(hist_data), FindUpLimit(hist_bg)) + hist_data->GetBinWidth(1) * 2; if (debug) { std::cout << "min, max = " << x_loLim << ", " << x_hiLim << std::endl; } float y_hiLim = max(FindUpLimit(hist_data,"Y"), FindUpLimit(hist_bg,"Y")); if (logy) y_hiLim *= 10; else y_hiLim += y_hiLim * 0.1; gStyle->SetCanvasColor (10); gStyle->SetCanvasBorderSize (0); gStyle->SetCanvasBorderMode (0); gStyle->SetPadColor (10); gStyle->SetFillColor (10); gStyle->SetTitleFillColor (10); gStyle->SetTitleBorderSize (0); gStyle->SetStatColor (10); gStyle->SetStatBorderSize (1); gStyle->SetCanvasDefW(1200); gStyle->SetCanvasDefH(600); int labelfont = 10 * 4 + 2; //10 * font ID + precision (2 = scalable) int titlefont = 10 * 4 + 2; //10 * font ID + precision (2 = scalable) gStyle->SetLabelFont(labelfont,"X"); gStyle->SetLabelFont(labelfont,"Y"); gStyle->SetTitleFont(titlefont,"X"); gStyle->SetTitleFont(titlefont,"Y"); gStyle->SetLabelSize(0.04,"X"); gStyle->SetLabelSize(0.027,"Y"); //gStyle->SetLabelOffset(0.9); gStyle->SetTitleSize(0.03,"Y"); gStyle->SetTitleOffset(1.8,"Y"); //TGaxis::SetMaxDigits(3); hist_data->UseCurrentStyle(); hist_bg->UseCurrentStyle(); TCanvas *c1= new TCanvas; c1->Divide(2,1); c1->cd(1); if (logy) { if (hist_data->GetEntries() > 0 && hist_bg->GetEntries() > 0) gPad->SetLogy(); } gPad->SetTickx(); gPad->SetTicky(); gPad->SetGridx(); gPad->SetGridy(); TPaveText *tp = new TPaveText(0.02,0.92,0.98,0.99,"NDC"); tp->SetLineColor(10); tp->SetTextFont(titlefont); std::string tt(hist_data->GetTitle()); // hist_data->SetTitle(""); // hist_bg->SetTitle(""); if (title.length()>0) { //tt += " - "; tt += title; //tt = title; if (debug) { std::cout << tt << std::endl; } tp->AddText(tt.c_str()); } std::stringstream ytitle, xtitle; ytitle << "Events / " << setprecision(3) << hist_data->GetXaxis()->GetBinWidth(1) << " GeV"; if (debug) { std::cout << hist_data->GetBinWidth(1) <<std::endl; } if (name == "MetAll") xtitle << "#slash{E}_{T} (for all events) (GeV)"; else if (name == "Met") xtitle << "#slash{E}_{T} (after cuts) (GeV)"; else if (name == "MetSig") xtitle << "#slash{E}_{T} Significance (for all events)"; else if (name == "Njet15") xtitle << "Njets^{E_{T}>15GeV} (After #slash{E}_{T}-Sig cut)"; else if (name == "Njet20") xtitle << "Njets^{E_{T}>20GeV} (After #slash{E}_{T}-Sig cut)"; else if (name == "Njet25") xtitle << "Njets^{E_{T}>25GeV} (After #slash{E}_{T}-Sig cut)"; else if (name == "Njet30") xtitle << "Njets^{E_{T}>30GeV} (After #slash{E}_{T}-Sig cut)"; else if (name == "Njet35") xtitle << "Njets^{E_{T}>35GeV} (After #slash{E}_{T}-Sig cut)"; if (debug) { std::cout << "xtitle=" << xtitle.str() << std::endl; } if (debug) { hist_data->Print(); std::cout << "bin#\tLoEdge\tdata\tdata_err\tbg_cont\tbg_err"<<std::endl; for (unsigned bin = 0; bin <= (unsigned) hist_data_copy->GetNbinsX() + 1; ++ bin) { float val = hist_data->GetBinContent (bin); float err = hist_data->GetBinError(bin); float val2 = hist_bg->GetBinContent (bin); float err2 = hist_bg->GetBinError(bin); float loEdge = hist_data->GetBinLowEdge(bin); if (val>0 || err>0 || val2>0 || err2>0) std::cout << bin << "\t" << loEdge <<"\t" << val << "\t" << err << "\t\t" << val2 << "\t" << err2 << std::endl; } } hist_data->GetXaxis()->SetTitle(xtitle.str().c_str()); if (name.find("Njet") == std::string::npos) hist_data->GetYaxis()->SetTitle(ytitle.str().c_str()); hist_data->GetXaxis()->CenterTitle(true); hist_data->GetYaxis()->CenterTitle(true); hist_bg->GetXaxis()->SetTitle(xtitle.str().c_str()); if (name.find("Njet") == std::string::npos) hist_bg->GetYaxis()->SetTitle(ytitle.str().c_str()); hist_bg->GetXaxis()->CenterTitle(true); hist_bg->GetYaxis()->CenterTitle(true); //temp x_loLim = 0; x_hiLim = 200; hist_data->GetXaxis()->SetRangeUser(x_loLim, x_hiLim); hist_bg->GetXaxis()->SetRangeUser(x_loLim, x_hiLim); hist_data->SetMinimum(0.1); hist_bg->SetMinimum(0.1); hist_data->SetMaximum(y_hiLim); hist_bg->SetMaximum(y_hiLim); hist_data->SetMarkerStyle(8); hist_data->SetMarkerSize(1.0); hist_data->SetMarkerColor(kBlue); hist_data->SetLineColor(kBlue); hist_bg->SetMarkerColor(kRed); hist_bg->SetLineColor(kRed); hist_bg->SetFillColor(kRed); hist_data->SetTitleSize(0.04); hist_bg->SetTitleSize(0.04); TH1* hist_bg_copy = dynamic_cast<TH1*>(hist_bg->Clone ("hist_bg_BlkLine")); hist_bg_copy->SetLineColor(kBlack); hist_bg_copy->SetLineWidth(2); hist_bg_copy->SetFillColor(0); //hist_bg_copy->Draw("L"); //hist_bg->Draw("sameE2"); // hist_bg->SetFillColor(10); // hist_bg->SetLineColor(10); hist_bg->Draw("E2"); hist_bg_copy->Draw("SAME HIST"); hist_data->Draw("sameP"); //tp->Draw(); TLegend *leg = new TLegend (0.4,0.8,0.90,0.90); leg->SetTextFont(42); leg->SetTextSize(0.025); leg->SetBorderSize (1); leg->SetFillColor (10); //std::stringstream leg_data, leg_bg; //leg_data << "Data (E=" << hist_data->GetEntries() << " M=" << hist_data->GetMean() // << " R=" << hist_data->GetRMS() << ")"; //leg_bg << "Bkg (E=" << hist_bg->GetEntries() << " M=" << hist_bg->GetMean() // << " R=" << hist_bg->GetRMS() << ")"; //leg->AddEntry(hist_data,leg_data.str().c_str()); //leg->AddEntry(hist_bg,leg_bg.str().c_str()); //leg->AddEntry(hist_data,"Data (Measured) (DET Jets) "); //leg->AddEntry(hist_bg, "MC Prediction (HAD Jets, Norm to Data)"); leg->AddEntry(hist_data,"Data (Measured)"); leg->AddEntry(hist_bg, "MC Prediction"); leg->Draw(); // now to make the ratio plots for (unsigned bin = 0; bin <= (unsigned) hist_data_copy->GetNbinsX() + 1; ++ bin) { const float val = hist_err_copy->GetBinContent (bin); const float scale = val ? 1. / val : 0; hist_data_copy->SetBinContent (bin, (hist_data_copy->GetBinContent (bin) - val) * scale); hist_data_copy->SetBinError (bin, hist_data_copy->GetBinError (bin) * scale); }; for (unsigned bin = 0; bin <= (unsigned) hist_err_copy->GetNbinsX() + 1; ++ bin) { float value = hist_err_copy->GetBinContent (bin); float error = hist_err_copy->GetBinError (bin); hist_err_copy->SetBinError (bin, value ? error / value : 0); hist_err_copy->SetBinContent (bin, 0); }; /* TH1 *hist_ratio = NULL; std::string myname = hist_data->GetName() + std::string ("_copy"); hist_ratio = dynamic_cast<TH1*>(hist_data->Clone (myname.c_str())); hist_ratio->Divide(hist_bg); */ hist_data_copy->UseCurrentStyle(); hist_err_copy->UseCurrentStyle(); //new TCanvas(); c1->cd(2); gPad->SetTickx(); gPad->SetTicky(); gPad->SetGridx(); gPad->SetGridy(); hist_data_copy->SetTitle(""); hist_err_copy->SetTitle(""); //hist_data_copy->SetTitle(tt.c_str()); //hist_err_copy->SetTitle(tt.c_str()); hist_data_copy->GetXaxis()->SetTitle(xtitle.str().c_str()); hist_err_copy->GetXaxis()->SetTitle(xtitle.str().c_str()); hist_data_copy->GetXaxis()->SetRangeUser(x_loLim, x_hiLim); hist_err_copy->GetXaxis()->SetRangeUser(x_loLim, x_hiLim); float fRatioHist_ymax = 1.0; float fRatioHist_ymin = -1.0; hist_data_copy->SetMinimum(fRatioHist_ymin); hist_data_copy->SetMaximum(fRatioHist_ymax); hist_err_copy->SetMinimum(fRatioHist_ymin); hist_err_copy->SetMaximum(fRatioHist_ymax); std::stringstream ratio_ytitle; ratio_ytitle << "(Data Measured - MC Prediction) / MC Prediction"; hist_data_copy->GetYaxis()->SetTitle(ratio_ytitle.str().c_str()); hist_err_copy->GetYaxis()->SetTitle(ratio_ytitle.str().c_str()); //hist_data_copy->SetTitle(ratio_ytitle.str().c_str()); //hist_err_copy->SetTitle(ratio_ytitle.str().c_str()); hist_data_copy->GetXaxis()->CenterTitle(true); hist_data_copy->GetYaxis()->CenterTitle(true); hist_err_copy->GetXaxis()->CenterTitle(true); hist_err_copy->GetYaxis()->CenterTitle(true); // hist_data->GetYaxis()->SetRangeUser(; //// hist_bg->SetMinimum(0.1); hist_data_copy->SetLineColor(kBlue); hist_data_copy->SetMarkerColor(kBlue); hist_data_copy->SetMarkerStyle (8); hist_data_copy->SetMarkerSize(1.0); hist_err_copy->SetFillColor(kRed); hist_err_copy->SetFillStyle(3002); hist_data_copy->Draw("P"); hist_err_copy->Draw("same E2"); //tp->Draw(); c1->cd(); if (printfile.length()>0) { c1->Print(printfile.c_str()); } DebugSystError(hist_data,hist_bg, hist_data_copy, hist_err_copy); }
void loopPlot(){ gErrorIgnoreLevel=kFatal;//suppresses all info messages setTDRStyle();//TDR style //#####################EDIT THE OPTIONS############################## /// Boolean flags to steer the histogram making bool wantElectrons = false; // Will make histograms for electrons bool wantMuons = true; // Will make histograms for muons bool wantSideband = false; // Will make histograms for sideband region bool wantSignal = true; // Will make histograms for signal region bool wantFullRange = false; // Will not check signal or sideband, ie, pick all jet mass range int wantNXJets = 1; // Will make histograms for 1 or 2 jet topology int isZZchannel = 1; //plot label for zz (1) or ww (0) int flavour = 0; if(wantElectrons) flavour=11; if(wantMuons) flavour=13; /// Luminosity value in pb^-1 //double lumiValue = 19531.85;// for singleEle2012 // double lumiValue = 19747; // for doubleMu2012 //double lumiValue = 19788; // for doubleEle2012 double lumiValue = 19768.0; /// Should we scale the histograms to data? bool scaleToData = false; // Should we scale only wjets to make total MC = DATA? bool scaleOnlyWJets = false; /// Should we plot the Data/Bkg and Data-Bkg/Error ratios? bool makeRatio = false; /// Should we REDO histograms? bool redoHistograms = true; /// Should we put the signal MC stacked on top of the background (or just plot the signal alone)? bool isSignalStackOnBkg = false; /// Path to wherever the files with the trees are. //CA8 (cmgTuple_08032013_CA8) std::string pathToTrees="/afs/cern.ch/user/b/bonato/scratch0/PhysAnalysis/EXOVV_2012/analyzer_trees/productionv2i/fullsig/"; /// Path to wherever you want to put the histograms (figures) in. std::string outputDir = "./plots_productionv2i_fullsig_1JLP_MU"; /// Setup names of data files for trees. const int nDATA=4; std::string dataLabels[nDATA]={"DoubleMu_Run2012A_22Jan2013", "DoubleMuParked_Run2012B_22Jan2013", "DoubleMuParked_Run2012C_22Jan2013", "DoubleMuParked_Run2012D_22Jan2013"}; /* const int nDATA=4;//set to zero if you don't want to plot std::string dataLabels[nDATA]={"Photon_Run2012A_22Jan2013", "DoublePhotonHighPt_Run2012B_22Jan2013", "DoublePhotonHighPt_Run2012C_22Jan2013", "DoublePhotonHighPt_Run2012D_22Jan2013" }; */ /* const int nDATA=8;//set to zero if you don't want to plot std::string dataLabels[nDATA]={"DoubleMu_Run2012A_22Jan2013", "DoubleMuParked_Run2012B_22Jan2013", "DoubleMuParked_Run2012C_22Jan2013", "DoubleMuParked_Run2012D_22Jan2013", "Photon_Run2012A_22Jan2013", "DoublePhotonHighPt_Run2012B_22Jan2013", "DoublePhotonHighPt_Run2012C_22Jan2013", "DoublePhotonHighPt_Run2012D_22Jan2013" }; */ /* const int nDATA=7;//set to zero if you don't want to plot std::string dataLabels[nDATA]={"SingleElectron_Run2012A_13Jul2012_xww", "SingleElectron_Run2012A_recover_xww", "SingleElectron_Run2012B_13Jul2012_xww", "SingleElectron_Run2012C_24Aug2012_xww", "SingleElectron_Run2012C_PromptReco_xww", "SingleElectron_Run2012C_EcalRecove_xww", "SingleElectron_Run2012D_PromptReco_xww"}; const int nDATA=7;//set to zero if you don't want to plot std::string dataLabels[nDATA]={"SingleMu_Run2012A_13Jul2012_xww", "SingleMu_Run2012A_recover_xww", "SingleMu_Run2012B_13Jul2012_xww", "SingleMu_Run2012C_24Aug2012_xww", "SingleMu_Run2012C_PromptReco_xww", "SingleMu_Run2012C_EcalRecove_xww", "SingleMu_Run2012D_PromptReco_xww"}; */ /* const int nDATA=1;//set to zero if you don't want to plot std::string dataLabels[nDATA]={"data_xww"}; */ /* const int nDATA=0;//set to zero if you don't want to plot std::string dataLabels[nDATA]={}; */ std::vector<std::string> fData; for(int ii=0;ii<nDATA;ii++){ fData.push_back(pathToTrees+"treeEDBR_"+dataLabels[ii]+".root"); } /// Setup names of MC files for trees. const int nMC=6;//set to zero if you don't want to plot std::string mcLabels[nMC]={"TTBARpowheg", "WW", "WZ", "ZZ", "DYJetsPt70To100", "DYJetsPt100", }; double kFactorsMC_array[nMC] = {1, 1, 1, 1, 1, 1}; /* const int nMC=7;//set to zero if you don't want to plot std::string mcLabels[nMC]={"TTBARpowheg", "WW", "WZ", "ZZ", "DYJetsPt50To70", "DYJetsPt70To100", "DYJetsPt100"}; double kFactorsMC_array[nMC] = {1., 1., 1., 1., 1., 1., 1.}; */ /* const int nMC=5;//set to zero if you don't want to plot std::string mcLabels[nMC]={//"TTBAR_xww", "TTBARpowheg_xww", //"SingleTopBarTWchannel_xww", //"SingleTopTWchannel_xww", //"SingleTopBarSchannel_xww", //"SingleTopSchannel_xww", //"SingleTopBarTchannel_xww", //"SingleTopTchannel_xww", "SingleTop_xww", //"WW_xww", //"WZ_xww", //"ZZ_xww", "VV_xww", //"DYJetsPt50To70_xww", //"DYJetsPt70To100_xww", //"DYJetsPt100_xww", "DYJets_xww", //"WJetsPt50To70_xww", //"WJetsPt70To100_xww", // "WJetsPt180_xww", "WJetsPt100_xww", }; */ //WW, muon channel //double kFactorsMC_array[nMC] = {1, 1., 1., 1., 1.3}; //WW, electron channel std::vector<std::string> fMC; for(int ii=0;ii<nMC;ii++){ fMC.push_back(pathToTrees+"treeEDBR_"+mcLabels[ii]+".root"); } std::vector<double> kFactorsMC; //std::cout << "The contents of kFactorsMC are:" << std::endl; for (int index=0; index<nMC; index++) { //std::cout << kFactorsMC_array[index] << std::endl; kFactorsMC.push_back( kFactorsMC_array[index] ); } /// Setup names of MC signal files for trees. const int nMCSig=1;//set to zero if you don't want to plot std::string mcLabelsSig[nMCSig]={"BulkG_ZZ_lljj_c0p2_M1000" //"BulkG_WW_lvjj_c0p2_M1000_xww", //"BulkG_WW_lvjj_c0p2_M2000_xww" }; double kFactorsSig_array[nMCSig] = {1000.0}; std::vector<double> kFactorsMCSig; for (int index=0; index<nMCSig; index++) { kFactorsMCSig.push_back( kFactorsSig_array[index] ); } /* const int nMCSig=1;//set to zero if you don't want to plot std::string mcLabelsSig[nMCSig]={"BulkG_ZZ_lljj_c1p0_M1500"}; */ std::vector<std::string> fMCSig; for(int ii=0;ii<nMCSig;ii++){ fMCSig.push_back(pathToTrees+"treeEDBR_"+mcLabelsSig[ii]+".root"); } /// Setup names of files for histograms (data and MC) std::vector<std::string> fHistosData; std::vector<std::string> fHistosMC; std::vector<std::string> fHistosMCSig; char buffer[256]; printf("All strings set\n"); /// ---------------------------------------------------------------- /// This first part is the loop over trees to create histogram files /// ---------------------------------------------------------------- /// The EDBRHistoMaker, for reference /// ///EDBRHistoMaker::EDBRHistoMaker(TTree* tree, /// bool wantElectrons, /// bool wantMuons, /// bool wantSideband, /// bool wantSignal, /// int wantNXJets, /// bool isZZchannel) printf("\nStart making histograms\n\n"); //loop over data files and make histograms individually for each of them for(int i=0;i<nDATA;i++){ std::cout<<"\n-------\nRunning over "<<dataLabels[i].c_str()<<std::endl; std::cout<<"The file is " <<fData.at(i)<<std::endl; sprintf(buffer,"histos_%s.root",dataLabels[i].c_str()); fHistosData.push_back(buffer); if(redoHistograms) { TFile *fileData = TFile::Open(fData.at(i).c_str()); TTree *treeData = (TTree*)fileData->Get("SelectedCandidates"); EDBRHistoMaker* maker = new EDBRHistoMaker(treeData, wantElectrons, wantMuons, wantSideband, wantSignal, wantFullRange, wantNXJets, isZZchannel); maker->setUnitaryWeights(true); maker->Loop(buffer); //delete maker; // This class is badly written and deleting it isn't safe! fileData->Close(); } }//end loop on data files printf("Loop over data done\n"); //loop over MC files and make histograms individually for each of them for(int i=0;i<nMC;i++){ std::cout<<"\n-------\nRunning over "<<mcLabels[i].c_str()<<std::endl; std::cout<<"The file is " <<fMC.at(i)<<std::endl; sprintf(buffer,"histos_%s.root",mcLabels[i].c_str()); fHistosMC.push_back(buffer); if(redoHistograms){ TFile *fileMC = TFile::Open(fMC.at(i).c_str()); TTree *treeMC = (TTree*)fileMC->Get("SelectedCandidates"); EDBRHistoMaker* maker = new EDBRHistoMaker(treeMC, wantElectrons, wantMuons, wantSideband, wantSignal, wantFullRange, wantNXJets, isZZchannel); maker->setUnitaryWeights(false); maker->Loop(buffer); //delete maker; // This class is badly written and deleting it isn't safe! fileMC->Close(); } }//end loop on MC files printf("Loop over MC done\n"); //loop over MC signal files and make histograms individually for each of them for(int i=0;i<nMCSig;i++){ std::cout<<"\n-------\nRunning over "<<mcLabelsSig[i].c_str()<<std::endl; std::cout<<"The file is " <<fMCSig.at(i)<<std::endl; sprintf(buffer,"histos_%s.root",mcLabelsSig[i].c_str()); fHistosMCSig.push_back(buffer); if(redoHistograms){ TFile *fileMCSig = TFile::Open(fMCSig.at(i).c_str()); TTree *treeMCSig = (TTree*)fileMCSig->Get("SelectedCandidates"); EDBRHistoMaker* maker = new EDBRHistoMaker(treeMCSig, wantElectrons, wantMuons, wantSideband, wantSignal, wantFullRange, wantNXJets, isZZchannel); maker->setUnitaryWeights(false); maker->Loop(buffer); //delete maker; // This class is badly written and deleting it isn't safe! fileMCSig->Close(); } }//end loop on MC files printf("Loop over MC signal done\n"); /// ------------------------------------------------------------------ /// This second part is the loop over histograms to create stack plots /// ------------------------------------------------------------------ // EDBRHistoMaker::EDBRHistoMaker(TTree* tree, // bool wantElectrons, // bool wantMuons, // bool wantSideband, // bool wantSignal, // int wantNXJets, // bool isZZchannel){ printf("\nStart looping over histograms\n\n"); //make nice plots std::vector<std::string> listOfHistos; if(nMC>0){ // Open one of the histogram files just to get the list of histograms // produced, then loop over all the histograms inheriting // from TH1 contained in the file. sprintf(buffer,"histos_%s.root",mcLabels[0].c_str()); std::cout<<"Opening "<<buffer<<std::endl; TFile* oneFile = TFile::Open(buffer); TIter next(oneFile->GetListOfKeys()); TKey *key; while ((key = (TKey*)next())) { TClass *cl = gROOT->GetClass(key->GetClassName()); if (!cl->InheritsFrom("TH1")) continue; TH1 *hTMP = (TH1*)key->ReadObj(); std::string hName=hTMP->GetName(); // printf("Histogram found: %s\n",hName.c_str()); if(hName=="h_mj_vs_mzz")continue;//skip 2D histos bool isMJJhisto=(hName.find("mJJ")!=std::string::npos); bool isMZZhisto=(hName.find("mZZ")!=std::string::npos); if( !isMJJhisto && !isMZZhisto)continue;//skip all histos except MJJ and MZZ listOfHistos.push_back(hName); }//end while loop oneFile->Close(); }//end if fmc size >0 EDBRHistoPlotter *plotter=new EDBRHistoPlotter("./", fHistosData, fHistosMC, fHistosMCSig, lumiValue, wantNXJets, flavour, isZZchannel, scaleToData, scaleOnlyWJets, makeRatio, isSignalStackOnBkg, kFactorsMC,kFactorsMCSig); std::cout<<"Set output dir"<<std::endl; plotter->setOutDir(outputDir); plotter->setDebug(false); //colors are assigned in the same order of mcLabels //For ZZ ////// {"TTBAR","WW","WZ","ZZ","DYJetsPt50To70","DYJetsPt70To100","DYJetsPt100","WJetsPt50To70","WJetsPt70To100","WJetsPt100"}; std::vector<int> fColorsMC; fColorsMC.push_back(kGreen-3); //fColorsMC.push_back(kYellow-9); //fColorsMC.push_back(kYellow-6); //fColorsMC.push_back(kYellow-3); //fColorsMC.push_back(kYellow+3); //fColorsMC.push_back(kYellow+6); //fColorsMC.push_back(kYellow+9); fColorsMC.push_back(kMagenta-9); fColorsMC.push_back(kMagenta-6); fColorsMC.push_back(kMagenta-3); //fColorsMC.push_back(kBlue-3); fColorsMC.push_back(kBlue-6); fColorsMC.push_back(kBlue-9); //fColorsMC.push_back(kRed+3); //fColorsMC.push_back(kRed); //fColorsMC.push_back(kRed-4); //For WW //{ "TTBARpowheg_xww", "SingleTop_xww", "VV_xww", "DYJets_xww", "WJetsPt100_xww"} //std::vector<int> fColorsMC; //fColorsMC.push_back(kGreen-3); //fColorsMC.push_back(kYellow-9); //fColorsMC.push_back(kMagenta-9); //fColorsMC.push_back(kBlue-3); //fColorsMC.push_back(kRed-4); ////// {"BulkG_WW_lvjj_c1p0_M600_xww","BulkG_WW_lvjj_c1p0_M1000_xww","BulkG_WW_lvjj_c1p0_M1500_xww"}; std::vector<int> fColorsMCSig; // fColorsMCSig.push_back(kPink); fColorsMCSig.push_back(kOrange+7); fColorsMCSig.push_back(kMagenta); fColorsMCSig.push_back(kBlue+3); plotter->setFillColor(fColorsMC); plotter->setLineColor(fColorsMCSig); int numOfHistos = listOfHistos.size(); for(int i = 0; i != numOfHistos; ++i) plotter->makeStackPlots(listOfHistos.at(i)); printf("Plotting done\n"); delete plotter; }//end main
//------------------------------------------------------------------------------ THStack* PlotAlignmentValidation::addHists(const char *selection, const TString &residType, bool printModuleIds) { enum ResidType { xPrimeRes, yPrimeRes, xPrimeNormRes, yPrimeNormRes, xRes, yRes, xNormRes, /*yResNorm*/ ResXvsXProfile, ResXvsYProfile, ResYvsXProfile, ResYvsYProfile }; ResidType rType = xPrimeRes; if (residType == "xPrime") rType = xPrimeRes; else if (residType == "yPrime") rType = yPrimeRes; else if (residType == "xPrimeNorm") rType = xPrimeNormRes; else if (residType == "yPrimeNorm") rType = yPrimeNormRes; else if (residType == "x") rType = xRes; else if (residType == "y") rType = yRes; else if (residType == "xNorm") rType = xNormRes; // else if (residType == "yNorm") rType = yResNorm; else if (residType == "ResXvsXProfile") rType = ResXvsXProfile; else if (residType == "ResYvsXProfile") rType = ResYvsXProfile; else if (residType == "ResXvsYProfile") rType = ResXvsYProfile; else if (residType == "ResYvsYProfile") rType = ResYvsYProfile; else { std::cout << "PlotAlignmentValidation::addHists: Unknown residual type " << residType << std::endl; return 0; } cout << "PlotAlignmentValidation::addHists: using selection " << selection << endl; THStack * retHistoStack = new THStack(); double legendY = 0.80; TLegend * myLegend = new TLegend(0.17, legendY, 0.85, 0.88); setLegendStyle( *myLegend ); for(std::vector<TkOfflineVariables*>::iterator itSourceFile = sourceList.begin(); itSourceFile != sourceList.end(); ++itSourceFile) { // TFile *f = (*sourceList.begin())->getFile(); TFile *f = (*itSourceFile)->getFile(); // TTree *tree= (*sourceList.begin())->getTree(); TTree *tree= (*itSourceFile)->getTree(); int myLineColor = (*itSourceFile)->getLineColor(); int myLineStyle = (*itSourceFile)->getLineStyle(); TString myLegendName = (*itSourceFile)->getName(); if (!f || !tree) { std::cout << "PlotAlignmentValidation::addHists: no tree or no file" << std::endl; return 0; } // Todo: TLegend? // first loop on tree to find out which entries (i.e. modules) fulfill the selection // 'Entry$' gives the entry number in the tree Long64_t nSel = tree->Draw("Entry$", selection, "goff"); if (nSel == -1) return 0; // error in selection if (nSel == 0) { std::cout << "PlotAlignmentValidation::addHists: no selected module." << std::endl; return 0; } // copy entry numbers that fulfil the selection const std::vector<double> selected(tree->GetV1(), tree->GetV1() + nSel); TH1 *h = 0; // becomes result UInt_t nEmpty = 0;// selected, but empty hists Long64_t nentries = tree->GetEntriesFast(); std::vector<double>::const_iterator iterEnt = selected.begin(); // second loop on tree: // for each selected entry get the hist from the file and merge TkOffTreeVariables *treeMem = 0; // ROOT will initialise tree->SetBranchAddress("TkOffTreeVariables", &treeMem); for (Long64_t i = 0; i < nentries; i++){ if (i < *iterEnt - 0.1 // smaller index (with tolerance): skip || iterEnt == selected.end()) { // at the end: skip continue; } else if (TMath::Abs(i - *iterEnt) < 0.11) { ++iterEnt; // take this entry! } else std::cout << "Must not happen: " << i << " " << *iterEnt << std::endl; tree->GetEntry(i); if (printModuleIds) { std::cout << treeMem->moduleId << ": " << treeMem->entries << " entries" << std::endl; } if (treeMem->entries <= 0) { // little speed up: skip empty hists ++nEmpty; continue; } TString hName; switch(rType) { case xPrimeRes: hName = treeMem->histNameX.c_str(); break; case yPrimeRes: hName = treeMem->histNameY.c_str(); break; case xPrimeNormRes: hName = treeMem->histNameNormX.c_str(); break; case yPrimeNormRes: hName = treeMem->histNameNormY.c_str(); break; case xRes: hName = treeMem->histNameLocalX.c_str(); break; case yRes: hName = treeMem->histNameLocalY.c_str(); break; case xNormRes: hName = treeMem->histNameNormLocalX.c_str(); break; /*case yResNorm: hName = treeMem->histNameNormLocalY.c_str(); break;*/ case ResXvsXProfile: hName = treeMem->profileNameResXvsX.c_str(); break; case ResXvsYProfile: hName = treeMem->profileNameResXvsY.c_str(); break; case ResYvsXProfile: hName = treeMem->profileNameResYvsX.c_str(); break; case ResYvsYProfile: hName = treeMem->profileNameResYvsY.c_str(); break; } TKey *histKey = f->FindKeyAny(hName); TH1 *newHist = (histKey ? static_cast<TH1*>(histKey->ReadObj()) : 0); if (!newHist) { std::cout << "Hist " << hName << " not found in file, break loop." << std::endl; break; } newHist->SetLineColor(myLineColor); newHist->SetLineStyle(myLineStyle); if (!h) { // first hist: clone, but rename keeping only first part of name TString name(newHist->GetName()); Ssiz_t pos_ = 0; for (UInt_t i2 = 0; i2 < 3; ++i2) pos_ = name.Index("_", pos_+1); name = name(0, pos_); // only up to three '_' h = static_cast<TH1*>(newHist->Clone("summed_"+name)); // TString myTitle = Form("%s: %lld modules", selection, nSel); // h->SetTitle( myTitle ); } else { // otherwise just add h->Add(newHist); } delete newHist; } std::cout << "PlotAlignmentValidation::addHists" << "Result is merged from " << nSel-nEmpty << " modules, " << nEmpty << " hists were empty." << std::endl; if (nSel-nEmpty == 0) continue; myLegend->AddEntry(myLegendName, myLegendName, "L"); retHistoStack->Add(h); } myLegend->Draw(); return retHistoStack; }
//------------------------------------------------------------------------------ void PlotAlignmentValidation::plotOutlierModules(const char *outputFileName, std::string plotVariable, float plotVariable_cut ,int unsigned minHits) { Int_t counter=0; setNiceStyle(); gStyle->SetOptStat(111111); gStyle->SetStatY(0.9); //TList treelist=getTreeList(); TCanvas *c1 = new TCanvas("canv", "canv", 800, 500); //setCanvasStyle( *c1 ); outputFile = outputDir +'/'+ outputFileName; c1->Print( (outputFile+'[').Data() ); c1->Divide(2,1); TTree *tree= (*sourceList.begin())->getTree(); TkOffTreeVariables *treeMem = 0; // ROOT will initilise tree->SetBranchAddress("TkOffTreeVariables", &treeMem); Long64_t nentries = tree->GetEntriesFast(); for (Long64_t i = 0; i < nentries; i++){ tree->GetEntry(i); float var = 0; if (plotVariable == "chi2PerDofX") var =treeMem->chi2PerDofX; else if(plotVariable == "chi2PerDofY") var =treeMem->chi2PerDofY; else if(plotVariable == "fitMeanX") var =treeMem->fitMeanX; else if(plotVariable == "fitMeanY") var =treeMem->fitMeanY; else if(plotVariable == "fitSigmaX") var =treeMem->fitSigmaX; else if(plotVariable == "fitSigmaY") var =treeMem->fitSigmaY; else { cout<<"There is no variable "<<plotVariable<<" included in the tree."<<endl; break; } // cout<<"treeMem->entries "<<treeMem->entries<<endl; // cout<<"var "<<var<<endl; // cout<<"plotVariable_cut "<<plotVariable_cut<<endl; if (var > plotVariable_cut && treeMem->entries > minHits) { TFile *f=(*sourceList.begin())->getFile();//(TFile*)sourcelist->First(); if(f->FindKeyAny(treeMem->histNameX.c_str())!=0){ TH1 *h = (TH1*) f->FindKeyAny(treeMem->histNameX.c_str())->ReadObj();//f->FindObjectAny(treeMem->histNameX.c_str()); gStyle->SetOptFit(0111); cout<<"hist name "<<h->GetName()<<endl; TString path =(char*)strstr( gDirectory->GetPath(), "TrackerOfflineValidation" ); //cout<<"hist path "<<path<<endl; //cout<<"wrote text "<<endl; if(h) cout<<h->GetEntries()<<endl; //modules' location as title c1->cd(0); TPaveText * text=new TPaveText(0,0.95,0.99,0.99); text->AddText(path); text->SetFillColor(0); text->SetShadowColor(0); text->SetBorderSize( 0 ); text->Draw(); //residual histogram c1->cd(1); TPad *subpad = (TPad*)c1->GetPad(1); subpad->SetPad(0,0,0.5,0.94); h->Draw(); //norm. residual histogram h = (TH1*) f->FindObjectAny(treeMem->histNameNormX.c_str()); if(h) cout<<h->GetEntries()<<endl; c1->cd(2); TPad *subpad2 = (TPad*)c1->GetPad(2); subpad2->SetPad(0.5,0,0.99,0.94); h->Draw(); c1->Print(outputFile); counter++; } else{ cout<<"There are no residual histograms on module level stored!"<<endl; cout<<"Please make sure that moduleLevelHistsTransient = cms.bool(False) in the validation job!"<<endl; break; } } } c1->Print( (outputFile+"]").Data() ); if (counter == 0) cout<<"no bad modules found"<<endl; //read the number of entries in the t3 //TTree* tree=0; //tree=(TTree*)treeList->At(0); //c1->Close(); }