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;
}
Flower *executeCreateFlower(Edge *minEdge, std::vector<Flower *> &freeFlowers)
{
minEdge->type = Edge::Type::FULL_BLOCKING;
// Determine K flower's path to root.
std::vector<Flower*> kPathToRoot;
for (Flower *kFlower(freeFlowers.front()); kFlower != nullptr; kFlower = kFlower->parent) {
kPathToRoot.push_back(kFlower);
}
// Determine H flower's path to root.
std::vector<Flower*> hPathToRoot;
for (Flower *hFlower(freeFlowers.back()); hFlower != nullptr; hFlower = hFlower->parent) {
hPathToRoot.push_back(hFlower);
}
// Find the W flower, which is the LCA of K flower and H flower.
Flower *wFlower(nullptr);
std::vector<Flower*>::reverse_iterator kRIt(kPathToRoot.rbegin()), hRIt(hPathToRoot.rbegin()),
kREnd(kPathToRoot.rend()), hREnd(hPathToRoot.rend());
for (; (kRIt != kREnd) && (hRIt != hREnd); ++kRIt, ++hRIt) {
if (*kRIt != *hRIt) {
break;
}
wFlower = *kRIt;
}
// Create and initialize Z flower, which is the new flower.
Flower *zFlower(new Flower());
zFlower->parent = wFlower->parent;
zFlower->stemSubFlower = wFlower;
// Replace W flower with Z flower in Z flower's parent.
if (zFlower->parent != nullptr) {
std::vector<Flower *> &parentChildren(zFlower->parent->children);
parentChildren.erase(std::remove(parentChildren.begin(), parentChildren.end(), wFlower), parentChildren.end());
parentChildren.push_back(zFlower);
}
// Populate subflowers of Z flower in the following order W, K_p, ..., K_1, K, H, H_1, ..., H_q.
zFlower->subFlowers.push_back(wFlower);
for (; kRIt != kREnd; ++kRIt) {
zFlower->subFlowers.push_back(*kRIt);
}
for (std::vector<Flower*>::iterator hIt(hPathToRoot.begin()); *hIt != wFlower; ++hIt) {
zFlower->subFlowers.push_back(*hIt);
}
// Populate children and edges of Z flower.
std::vector<Flower *> zBlueFlowers(zFlower->blueSubFlowers());
STD_VECTOR_FOREACH_(Flower *, zFlower->subFlowers, subFlowerIt, subFlowerEnd) {
Flower *subFlower(*subFlowerIt);
// Add the children of subflowers into Z flower's children only if the child is not part of Z flower.
STD_VECTOR_FOREACH_(Flower *, subFlower->children, childFlowerIt, childFlowerEnd) {
Flower *childFlower(*childFlowerIt);
if (std::find(zBlueFlowers.begin(), zBlueFlowers.end(), childFlower->blueStem()) == zBlueFlowers.end()) {
zFlower->children.push_back(childFlower);
}
}
// Add the edges of subflowers into Z flower's edges only if the edge is outgoing from Z flower.
STD_VECTOR_FOREACH_(Edge *, subFlower->edges, subEdgeIt, subEdgeEnd) {
Edge *subEdge(*subEdgeIt);
bool areBothEdgeBlueFlowersInZFlower(
std::find(zBlueFlowers.begin(), zBlueFlowers.end(), subEdge->blueFlowers.front()) != zBlueFlowers.end()
&& std::find(zBlueFlowers.begin(), zBlueFlowers.end(), subEdge->blueFlowers.back()) != zBlueFlowers.end());
if (!areBothEdgeBlueFlowersInZFlower) {
zFlower->edges.push_back(subEdge);
subEdge->flowers.push_back(zFlower);
}
}
}
// Replace parent in the new children of Z Flower.
STD_VECTOR_FOREACH_(Flower *, zFlower->children, flowerIt, flowerEnd) {
(*flowerIt)->parent = zFlower;
}
// Set subflower parameters.
STD_VECTOR_FOREACH_(Flower *, zFlower->subFlowers, flowerIt, flowerEnd) {
Flower *subflower(*flowerIt);
subflower->type = Flower::Type::INTERNAL;
subflower->parent = nullptr;
subflower->children.clear();
}
return zFlower;
}