EffPurFromHistos.cc

Go to the documentation of this file.

#include "DQMOffline/RecoB/interface/EffPurFromHistos.h"
#include "DQMOffline/RecoB/interface/Tools.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "TStyle.h"
#include "TCanvas.h"

#include <iostream>
#include <math.h>

#include "DQMServices/Core/interface/DQMStore.h"
#include "DQMServices/Core/interface/MonitorElement.h"
#include "FWCore/ServiceRegistry/interface/Service.h" 

using namespace std;
using namespace RecoBTag;

EffPurFromHistos::EffPurFromHistos ( const std::string & ext, TH1F * h_d, TH1F * h_u,
                     TH1F * h_s, TH1F * h_c, TH1F * h_b, TH1F * h_g, TH1F * h_ni,
                     TH1F * h_dus, TH1F * h_dusg, TH1F * h_pu, 
                     const std::string& label, const unsigned int& mc, 
                     int nBin, double startO, double endO) :
        fromDiscriminatorDistr(false),
    mcPlots_(mc), doCTagPlots_(false), label_(label),
    histoExtension(ext), effVersusDiscr_d(h_d), effVersusDiscr_u(h_u),
    effVersusDiscr_s(h_s), effVersusDiscr_c(h_c), effVersusDiscr_b(h_b),
    effVersusDiscr_g(h_g), effVersusDiscr_ni(h_ni), effVersusDiscr_dus(h_dus),
    effVersusDiscr_dusg(h_dusg), effVersusDiscr_pu(h_pu), 
    nBinOutput(nBin), startOutput(startO), endOutput(endO)
{
  // consistency check
  check();
}

EffPurFromHistos::EffPurFromHistos (const FlavourHistograms<double> * dDiscriminatorFC, const std::string& label, 
                    const unsigned int& mc, DQMStore::IBooker & ibook, int nBin,
                    double startO, double endO) :
      fromDiscriminatorDistr(true), 
      mcPlots_(mc), doCTagPlots_(false), label_(label),
      nBinOutput(nBin), startOutput(startO), endOutput(endO)  
{
  histoExtension = "_"+dDiscriminatorFC->baseNameTitle();


  discrNoCutEffic.reset( new FlavourHistograms<double> (
    "totalEntries" + histoExtension, "Total Entries: " + dDiscriminatorFC->baseNameDescription(),
    dDiscriminatorFC->nBins(), dDiscriminatorFC->lowerBound(),
    dDiscriminatorFC->upperBound(), false, true, false, "b", label, mcPlots_, ibook ));

  // conditional discriminator cut for efficiency histos

  discrCutEfficScan.reset( new FlavourHistograms<double> (
    "effVsDiscrCut" + histoExtension, "Eff. vs Disc. Cut: " + dDiscriminatorFC->baseNameDescription(),
    dDiscriminatorFC->nBins(), dDiscriminatorFC->lowerBound(),
    dDiscriminatorFC->upperBound(), false, true, false, "b", label , mcPlots_, ibook ));
  discrCutEfficScan->SetMinimum(1E-4);
  if (mcPlots_){ 

    if(mcPlots_>2){
      effVersusDiscr_d =    discrCutEfficScan->histo_d   ();
      effVersusDiscr_u =    discrCutEfficScan->histo_u   ();
      effVersusDiscr_s =    discrCutEfficScan->histo_s   ();
      effVersusDiscr_g =    discrCutEfficScan->histo_g   ();
      effVersusDiscr_dus =  discrCutEfficScan->histo_dus ();
    }
    else{
      effVersusDiscr_d   =  0;
      effVersusDiscr_u   =  0; 
      effVersusDiscr_s   =  0;
      effVersusDiscr_g   =  0;
      effVersusDiscr_dus =  0;
    }
    effVersusDiscr_c =    discrCutEfficScan->histo_c   ();
    effVersusDiscr_b =    discrCutEfficScan->histo_b   ();
    effVersusDiscr_ni =   discrCutEfficScan->histo_ni  ();
    effVersusDiscr_dusg = discrCutEfficScan->histo_dusg();
    effVersusDiscr_pu = discrCutEfficScan->histo_pu();

  
    if(mcPlots_>2){
      effVersusDiscr_d->SetXTitle ( "Discriminant" );
      effVersusDiscr_d->GetXaxis()->SetTitleOffset ( 0.75 );
      effVersusDiscr_u->SetXTitle ( "Discriminant" );
      effVersusDiscr_u->GetXaxis()->SetTitleOffset ( 0.75 );
      effVersusDiscr_s->SetXTitle ( "Discriminant" );
      effVersusDiscr_s->GetXaxis()->SetTitleOffset ( 0.75 );
      effVersusDiscr_g->SetXTitle ( "Discriminant" );
      effVersusDiscr_g->GetXaxis()->SetTitleOffset ( 0.75 );
      effVersusDiscr_dus->SetXTitle ( "Discriminant" );
      effVersusDiscr_dus->GetXaxis()->SetTitleOffset ( 0.75 );
    }
    effVersusDiscr_c->SetXTitle ( "Discriminant" );
    effVersusDiscr_c->GetXaxis()->SetTitleOffset ( 0.75 );
    effVersusDiscr_b->SetXTitle ( "Discriminant" );
    effVersusDiscr_b->GetXaxis()->SetTitleOffset ( 0.75 );
    effVersusDiscr_ni->SetXTitle ( "Discriminant" );
    effVersusDiscr_ni->GetXaxis()->SetTitleOffset ( 0.75 );
    effVersusDiscr_dusg->SetXTitle ( "Discriminant" );
    effVersusDiscr_dusg->GetXaxis()->SetTitleOffset ( 0.75 );
    effVersusDiscr_pu->SetXTitle ( "Discriminant" );
    effVersusDiscr_pu->GetXaxis()->SetTitleOffset ( 0.75 );
  }
  else{
    effVersusDiscr_d =    0;
    effVersusDiscr_u =    0; 
    effVersusDiscr_s =    0;
    effVersusDiscr_c =    0; 
    effVersusDiscr_b =    0;
    effVersusDiscr_g =    0;
    effVersusDiscr_ni =   0;
    effVersusDiscr_dus =  0;
    effVersusDiscr_dusg = 0;
    effVersusDiscr_pu = 0;
  }

  // discr. for computation
  vector<TH1F*> discrCfHistos = dDiscriminatorFC->getHistoVector();

  // discr no cut
  vector<TH1F*> discrNoCutHistos = discrNoCutEffic->getHistoVector();

  // discr no cut
  vector<TH1F*> discrCutHistos = discrCutEfficScan->getHistoVector();

  const int& dimHistos = discrCfHistos.size(); // they all have the same size

  // DISCR-CUT LOOP:
  // fill the histos for eff-pur computations by scanning the discriminatorFC histogram

  // better to loop over bins -> discrCut no longer needed
  const int& nBins = dDiscriminatorFC->nBins();

  // loop over flavours
  for ( int iFlav = 0; iFlav < dimHistos; iFlav++ ) {
    if (discrCfHistos[iFlav] == 0) continue;
    discrNoCutHistos[iFlav]->SetXTitle ( "Discriminant" );
    discrNoCutHistos[iFlav]->GetXaxis()->SetTitleOffset ( 0.75 );

    // In Root histos, bin counting starts at 1 to nBins.
    // bin 0 is the underflow, and nBins+1 is the overflow.
    const double& nJetsFlav = discrCfHistos[iFlav]->GetEntries ();
    double sum = discrCfHistos[iFlav]->GetBinContent( nBins+1 ); //+1 to get the overflow.
    
    for ( int iDiscr = nBins; iDiscr > 0 ; --iDiscr ) {
      // fill all jets into NoCut histo
      discrNoCutHistos[iFlav]->SetBinContent ( iDiscr, nJetsFlav );
      discrNoCutHistos[iFlav]->SetBinError   ( iDiscr, sqrt(nJetsFlav) );
      sum += discrCfHistos[iFlav]->GetBinContent( iDiscr );
      discrCutHistos[iFlav]->SetBinContent ( iDiscr, sum );
      discrCutHistos[iFlav]->SetBinError   ( iDiscr, sqrt(sum) );
    }
  }


  // divide to get efficiency vs. discriminator cut from absolute numbers
  discrCutEfficScan->divide ( *discrNoCutEffic );  // does: histos including discriminator cut / flat histo
  discrCutEfficScan->setEfficiencyFlag();
}

EffPurFromHistos::~EffPurFromHistos () {}

void EffPurFromHistos::epsPlot(const std::string & name)
{
  if ( fromDiscriminatorDistr) {
    discrNoCutEffic->epsPlot(name);
    discrCutEfficScan->epsPlot(name);
  }
  plot(name, ".eps");
}

void EffPurFromHistos::psPlot(const std::string & name)
{
  plot(name, ".ps");
}

void EffPurFromHistos::plot(const std::string & name, const std::string & ext)
{
   std::string hX = "";
     std::string Title = "";
   if(!doCTagPlots_){
       hX = "FlavEffVsBEff";
         Title = "b";
   }
   else{
     hX = "FlavEffVsCEff";
         Title = "c";
   }
   TCanvas tc ((hX +histoExtension).c_str() ,
    ("Flavour misidentification vs. " + Title + "-tagging efficiency " + histoExtension).c_str());
   plot(&tc);
   tc.Print((name + hX + histoExtension + ext).c_str());
}

void EffPurFromHistos::plot (TPad * plotCanvas /* = 0 */) {

//fixme:
  bool btppNI = false;
  bool btppColour = true;

//   if ( !btppTitle ) gStyle->SetOptTitle ( 0 );
  setTDRStyle()->cd();

  if (plotCanvas)
    plotCanvas->cd();
  
  gPad->UseCurrentStyle();
  gPad->SetFillColor ( 0 );
  gPad->SetLogy  ( 1 );
  gPad->SetGridx ( 1 );
  gPad->SetGridy ( 1 );

  int col_c  ;
  int col_g  ;
  int col_dus;
  int col_ni ;

  int mStyle_c  ;
  int mStyle_g  ;
  int mStyle_dus;
  int mStyle_ni ;

  // marker size (same for all)
  float mSize = gPad->GetWh() * gPad->GetHNDC() / 500.; //1.2;

  if ( btppColour ) {
    col_c    = 6;
    col_g    = 3; // g in green
    col_dus  = 4; // uds in blue
    col_ni   = 5; // ni in ??
    mStyle_c   = 20;
    mStyle_g   = 20;
    mStyle_dus = 20;
    mStyle_ni  = 20;
  }
  else {
    col_c    = 1;
    col_g    = 1;
    col_dus  = 1;
    col_ni   = 1;
    mStyle_c   = 22;
    mStyle_g   = 29;
    mStyle_dus = 20;
    mStyle_ni  = 27;
  }
  
  TString Title = "";
  if(!doCTagPlots_){
        Title = "b";
  }
  else{
        Title = "c";
  } 
 
  // for the moment: plot c,dus,g
  if(mcPlots_>2){
    EffFlavVsXEff_dus ->getTH1F()->GetXaxis()->SetTitle ( Title + "-jet efficiency" );
    EffFlavVsXEff_dus ->getTH1F()->GetYaxis()->SetTitle ( "non " + Title + "-jet efficiency");
    EffFlavVsXEff_dus ->getTH1F()->GetYaxis()->SetTitleOffset ( 0.25 );
    EffFlavVsXEff_dus ->getTH1F()->SetMaximum     ( 1.1 );
    EffFlavVsXEff_dus ->getTH1F()->SetMinimum     ( 1.e-5 );
    EffFlavVsXEff_dus ->getTH1F()->SetMarkerColor ( col_dus );
    EffFlavVsXEff_dus ->getTH1F()->SetLineColor   ( col_dus );
    EffFlavVsXEff_dus ->getTH1F()->SetMarkerSize  ( mSize );
    EffFlavVsXEff_dus ->getTH1F()->SetMarkerStyle ( mStyle_dus );
    EffFlavVsXEff_dus ->getTH1F()->SetStats     ( false );
    EffFlavVsXEff_dus ->getTH1F()->Draw("pe");

    EffFlavVsXEff_g   ->getTH1F()->SetMarkerColor ( col_g );
    EffFlavVsXEff_g   ->getTH1F()->SetLineColor   ( col_g );
    EffFlavVsXEff_g   ->getTH1F()->SetMarkerSize  ( mSize );
    EffFlavVsXEff_g   ->getTH1F()->SetMarkerStyle ( mStyle_g );
    EffFlavVsXEff_g   ->getTH1F()->SetStats     ( false );
    EffFlavVsXEff_g   ->getTH1F()->Draw("peSame");
  }
  EffFlavVsXEff_c   ->getTH1F()->SetMarkerColor ( col_c );
  EffFlavVsXEff_c   ->getTH1F()->SetLineColor   ( col_c );
  EffFlavVsXEff_c   ->getTH1F()->SetMarkerSize  ( mSize );
  EffFlavVsXEff_c   ->getTH1F()->SetMarkerStyle ( mStyle_c );
  EffFlavVsXEff_c   ->getTH1F()->SetStats     ( false );
  EffFlavVsXEff_c   ->getTH1F()->Draw("peSame");

  if(mcPlots_>2){
    EffFlavVsXEff_d ->getTH1F()-> SetMinimum(0.01);
    EffFlavVsXEff_u ->getTH1F()-> SetMinimum(0.01);
    EffFlavVsXEff_s ->getTH1F()-> SetMinimum(0.01);
    EffFlavVsXEff_g ->getTH1F()-> SetMinimum(0.01);
    EffFlavVsXEff_dus ->getTH1F()-> SetMinimum(0.01);
  }
  EffFlavVsXEff_c ->getTH1F()-> SetMinimum(0.01);
  EffFlavVsXEff_b ->getTH1F()-> SetMinimum(0.01);
  EffFlavVsXEff_ni ->getTH1F()-> SetMinimum(0.01);
  EffFlavVsXEff_dusg ->getTH1F()-> SetMinimum(0.01);
  EffFlavVsXEff_pu ->getTH1F()-> SetMinimum(0.01);

  // plot separately u,d and s
//  EffFlavVsXEff_d ->GetXaxis()->SetTitle ( Title + "-jet efficiency" );
//  EffFlavVsXEff_d ->GetYaxis()->SetTitle ( "non " + Title + "-jet efficiency" );
//  EffFlavVsXEff_d ->GetYaxis()->SetTitleOffset ( 1.25 );
//  EffFlavVsXEff_d ->SetMaximum     ( 1.1 );
//  EffFlavVsXEff_d ->SetMinimum     ( 1.e-5 );
//  EffFlavVsXEff_d ->SetMarkerColor ( col_dus );
//  EffFlavVsXEff_d ->SetLineColor   ( col_dus );
//  EffFlavVsXEff_d ->SetMarkerSize  ( mSize );
//  EffFlavVsXEff_d ->SetMarkerStyle ( mStyle_dus );
//  EffFlavVsXEff_d ->SetStats     ( false );
//  EffFlavVsXEff_d ->Draw("pe");
//
//  EffFlavVsXEff_u   ->SetMarkerColor ( col_g );
//  EffFlavVsXEff_u   ->SetLineColor   ( col_g );
//  EffFlavVsXEff_u   ->SetMarkerSize  ( mSize );
//  EffFlavVsXEff_u   ->SetMarkerStyle ( mStyle_g );
//  EffFlavVsXEff_u   ->SetStats     ( false );
//  EffFlavVsXEff_u   ->Draw("peSame");
//
//  EffFlavVsXEff_s   ->SetMarkerColor ( col_c );
//  EffFlavVsXEff_s   ->SetLineColor   ( col_c );
//  EffFlavVsXEff_s   ->SetMarkerSize  ( mSize );
//  EffFlavVsXEff_s   ->SetMarkerStyle ( mStyle_c );
//  EffFlavVsXEff_s   ->SetStats     ( false );
//  EffFlavVsXEff_s   ->Draw("peSame");

  // only if asked: NI
  if ( btppNI ) {
    EffFlavVsXEff_ni   ->getTH1F()->SetMarkerColor ( col_ni );
    EffFlavVsXEff_ni   ->getTH1F()->SetLineColor   ( col_ni );
    EffFlavVsXEff_ni   ->getTH1F()->SetMarkerSize  ( mSize );
    EffFlavVsXEff_ni   ->getTH1F()->SetMarkerStyle ( mStyle_ni );
    EffFlavVsXEff_ni   ->getTH1F()->SetStats     ( false );
    EffFlavVsXEff_ni   ->getTH1F()->Draw("peSame");
  }
}


void EffPurFromHistos::check () {
  // number of bins

  int nBins_d    = 0;
  int nBins_u    = 0;
  int nBins_s    = 0;
  int nBins_g    = 0;
  int nBins_dus  = 0;
  if(mcPlots_>2){
    nBins_d    = effVersusDiscr_d    -> GetNbinsX();
    nBins_u    = effVersusDiscr_u    -> GetNbinsX();
    nBins_s    = effVersusDiscr_s    -> GetNbinsX();
    nBins_g    = effVersusDiscr_g    -> GetNbinsX();
    nBins_dus  = effVersusDiscr_dus  -> GetNbinsX();
  }
  const int& nBins_c    = effVersusDiscr_c    -> GetNbinsX();
  const int& nBins_b    = effVersusDiscr_b    -> GetNbinsX();
  const int& nBins_ni   = effVersusDiscr_ni   -> GetNbinsX();
  const int& nBins_dusg = effVersusDiscr_dusg -> GetNbinsX();
  const int& nBins_pu   = effVersusDiscr_pu   -> GetNbinsX();

  const bool& lNBins =
    ( (nBins_d == nBins_u    &&
       nBins_d == nBins_s    &&
       nBins_d == nBins_c    &&
       nBins_d == nBins_b    &&
       nBins_d == nBins_g    &&
       nBins_d == nBins_ni   &&
       nBins_d == nBins_dus  &&
       nBins_d == nBins_dusg)||
      (nBins_c == nBins_b    &&
       nBins_c == nBins_dusg &&
       nBins_c == nBins_ni   &&
       nBins_c == nBins_pu)    );

  if ( !lNBins ) {
    throw cms::Exception("Configuration")
      << "Input histograms do not all have the same number of bins!\n";
  }


  // start
  float sBin_d    = 0;
  float sBin_u    = 0;
  float sBin_s    = 0;
  float sBin_g    = 0;
  float sBin_dus  = 0;
  if(mcPlots_>2){
    sBin_d    = effVersusDiscr_d    -> GetBinCenter(1);
    sBin_u    = effVersusDiscr_u    -> GetBinCenter(1);
    sBin_s    = effVersusDiscr_s    -> GetBinCenter(1);
    sBin_g    = effVersusDiscr_g    -> GetBinCenter(1);
    sBin_dus  = effVersusDiscr_dus  -> GetBinCenter(1);
  }
  const float& sBin_c    = effVersusDiscr_c    -> GetBinCenter(1);
  const float& sBin_b    = effVersusDiscr_b    -> GetBinCenter(1);
  const float& sBin_ni   = effVersusDiscr_ni   -> GetBinCenter(1);
  const float& sBin_dusg = effVersusDiscr_dusg -> GetBinCenter(1);
  const float& sBin_pu   = effVersusDiscr_pu   -> GetBinCenter(1);

  const bool& lSBin =
    ( (sBin_d == sBin_u    &&
       sBin_d == sBin_s    &&
       sBin_d == sBin_c    &&
       sBin_d == sBin_b    &&
       sBin_d == sBin_g    &&
       sBin_d == sBin_ni   &&
       sBin_d == sBin_dus  &&
       sBin_d == sBin_dusg)||
      (sBin_c == sBin_b    &&
       sBin_c == sBin_dusg &&
       sBin_c == sBin_ni   &&
       sBin_c == sBin_pu)    );

  if ( !lSBin ) {
    throw cms::Exception("Configuration")
      << "EffPurFromHistos::check() : Input histograms do not all have the same start bin!\n";
  }


  // end
  float eBin_d    = 0;
  float eBin_u    = 0;
  float eBin_s    = 0;
  float eBin_g    = 0;
  float eBin_dus  = 0;
  if(mcPlots_>2){
    eBin_d    = effVersusDiscr_d    -> GetBinCenter( nBins_d - 1 );
    eBin_u    = effVersusDiscr_u    -> GetBinCenter( nBins_d - 1 );
    eBin_s    = effVersusDiscr_s    -> GetBinCenter( nBins_d - 1 );
    eBin_g    = effVersusDiscr_g    -> GetBinCenter( nBins_d - 1 );
    eBin_dus  = effVersusDiscr_dus  -> GetBinCenter( nBins_d - 1 );
  }
  const float& eBin_c    = effVersusDiscr_c    -> GetBinCenter( nBins_d - 1 );
  const float& eBin_b    = effVersusDiscr_b    -> GetBinCenter( nBins_d - 1 );
  const float& eBin_ni   = effVersusDiscr_ni   -> GetBinCenter( nBins_d - 1 );
  const float& eBin_dusg = effVersusDiscr_dusg -> GetBinCenter( nBins_d - 1 );
  const float& eBin_pu   = effVersusDiscr_pu   -> GetBinCenter( nBins_d - 1 );

  const bool& lEBin =
    ( (eBin_d == eBin_u    &&
       eBin_d == eBin_s    &&
       eBin_d == eBin_c    &&
       eBin_d == eBin_b    &&
       eBin_d == eBin_g    &&
       eBin_d == eBin_ni   &&
       eBin_d == eBin_dus  &&
       eBin_d == eBin_dusg)||
      (eBin_c == eBin_b    &&
       eBin_c == eBin_dusg &&
       eBin_c == eBin_ni   &&
       eBin_c == eBin_pu)     );

  if ( !lEBin ) {
    throw cms::Exception("Configuration")
      << "EffPurFromHistos::check() : Input histograms do not all have the same end bin!\n";
  }
}


void EffPurFromHistos::compute (DQMStore::IBooker & ibook)
{
  if (!mcPlots_) {

    EffFlavVsXEff_d = 0;
    EffFlavVsXEff_u = 0; 
    EffFlavVsXEff_s = 0; 
    EffFlavVsXEff_c = 0; 
    EffFlavVsXEff_b = 0; 
    EffFlavVsXEff_g = 0; 
    EffFlavVsXEff_ni = 0; 
    EffFlavVsXEff_dus = 0; 
    EffFlavVsXEff_dusg = 0; 
    EffFlavVsXEff_pu = 0; 
    return; 
 
  }

  // to have shorter names ......
  const std::string & hE = histoExtension;
  std::string hX = "";
    TString Title = "";
    if(!doCTagPlots_){
       hX = "FlavEffVsBEff_";
       Title = "b";
    }
  else{
     hX = "FlavEffVsCEff_";
     Title = "c";
  }
    
  // create histograms from base name and extension as given from user
  // BINNING MUST BE IDENTICAL FOR ALL OF THEM!!
  HistoProviderDQM prov("Btag",label_,ibook);
  if(mcPlots_>2){
    EffFlavVsXEff_d    = (prov.book1D ( hX + "D"    + hE , hX + "D"    + hE , nBinOutput , startOutput , endOutput ));
    EffFlavVsXEff_d->setEfficiencyFlag();
    EffFlavVsXEff_u    = (prov.book1D ( hX + "U"    + hE , hX + "U"    + hE , nBinOutput , startOutput , endOutput )) ;
    EffFlavVsXEff_u->setEfficiencyFlag();
    EffFlavVsXEff_s    = (prov.book1D ( hX + "S"    + hE , hX + "S"    + hE , nBinOutput , startOutput , endOutput )) ;
    EffFlavVsXEff_s->setEfficiencyFlag();
    EffFlavVsXEff_g    = (prov.book1D ( hX + "G"    + hE , hX + "G"    + hE , nBinOutput , startOutput , endOutput )) ;
    EffFlavVsXEff_g->setEfficiencyFlag();
    EffFlavVsXEff_dus  = (prov.book1D ( hX + "DUS"  + hE , hX + "DUS"  + hE , nBinOutput , startOutput , endOutput )) ;
    EffFlavVsXEff_dus->setEfficiencyFlag();
  }
  else {
    EffFlavVsXEff_d = 0;
    EffFlavVsXEff_u = 0;
    EffFlavVsXEff_s = 0;
    EffFlavVsXEff_g = 0;
    EffFlavVsXEff_dus = 0;
  }
  EffFlavVsXEff_c    = (prov.book1D ( hX + "C"    + hE , hX + "C"    + hE , nBinOutput , startOutput , endOutput )) ;
  EffFlavVsXEff_c->setEfficiencyFlag();
  EffFlavVsXEff_b    = (prov.book1D ( hX + "B"    + hE , hX + "B"    + hE , nBinOutput , startOutput , endOutput )) ;
  EffFlavVsXEff_b->setEfficiencyFlag();
  EffFlavVsXEff_ni   = (prov.book1D ( hX + "NI"   + hE , hX + "NI"   + hE , nBinOutput , startOutput , endOutput )) ;
  EffFlavVsXEff_ni->setEfficiencyFlag();
  EffFlavVsXEff_dusg = (prov.book1D ( hX + "DUSG" + hE , hX + "DUSG" + hE , nBinOutput , startOutput , endOutput )) ;
  EffFlavVsXEff_dusg->setEfficiencyFlag();
  EffFlavVsXEff_pu   = (prov.book1D ( hX + "PU"   + hE , hX + "PU"   + hE , nBinOutput , startOutput , endOutput )) ;
  EffFlavVsXEff_pu->setEfficiencyFlag();
    

  if(mcPlots_>2){
    EffFlavVsXEff_d->getTH1F()->SetXTitle ( Title + "-jet efficiency" );
    EffFlavVsXEff_d->getTH1F()->SetYTitle ( "non " + Title + "-jet efficiency" );
    EffFlavVsXEff_d->getTH1F()->GetXaxis()->SetTitleOffset ( 0.75 );
    EffFlavVsXEff_d->getTH1F()->GetYaxis()->SetTitleOffset ( 0.75 );
    EffFlavVsXEff_u->getTH1F()->SetXTitle ( Title + "-jet efficiency" );
    EffFlavVsXEff_u->getTH1F()->SetYTitle ( "non " + Title + "-jet efficiency" );
    EffFlavVsXEff_u->getTH1F()->GetXaxis()->SetTitleOffset ( 0.75 );
    EffFlavVsXEff_u->getTH1F()->GetYaxis()->SetTitleOffset ( 0.75 );
    EffFlavVsXEff_s->getTH1F()->SetXTitle ( Title + "-jet efficiency" );
    EffFlavVsXEff_s->getTH1F()->SetYTitle ( "non " + Title + "-jet efficiency" );
    EffFlavVsXEff_s->getTH1F()->GetXaxis()->SetTitleOffset ( 0.75 );
    EffFlavVsXEff_s->getTH1F()->GetYaxis()->SetTitleOffset ( 0.75 );
    EffFlavVsXEff_g->getTH1F()->SetXTitle ( Title + "-jet efficiency" );
    EffFlavVsXEff_g->getTH1F()->SetYTitle ( "non " + Title + "-jet efficiency" );
    EffFlavVsXEff_g->getTH1F()->GetXaxis()->SetTitleOffset ( 0.75 );
    EffFlavVsXEff_g->getTH1F()->GetYaxis()->SetTitleOffset ( 0.75 );
    EffFlavVsXEff_dus->getTH1F()->SetXTitle ( Title + "-jet efficiency" );
    EffFlavVsXEff_dus->getTH1F()->SetYTitle ( "non " + Title + "-jet efficiency" );
    EffFlavVsXEff_dus->getTH1F()->GetXaxis()->SetTitleOffset ( 0.75 );
    EffFlavVsXEff_dus->getTH1F()->GetYaxis()->SetTitleOffset ( 0.75 );
  }
  EffFlavVsXEff_c->getTH1F()->SetXTitle ( Title + "-jet efficiency" );
  EffFlavVsXEff_c->getTH1F()->SetYTitle ( "c-jet efficiency" );
  EffFlavVsXEff_c->getTH1F()->GetXaxis()->SetTitleOffset ( 0.75 );
  EffFlavVsXEff_c->getTH1F()->GetYaxis()->SetTitleOffset ( 0.75 );
  EffFlavVsXEff_b->getTH1F()->SetXTitle ( Title + "-jet efficiency" );
  EffFlavVsXEff_b->getTH1F()->SetYTitle ( "b-jet efficiency" );
  EffFlavVsXEff_b->getTH1F()->GetXaxis()->SetTitleOffset ( 0.75 );
  EffFlavVsXEff_b->getTH1F()->GetYaxis()->SetTitleOffset ( 0.75 );
  EffFlavVsXEff_ni->getTH1F()->SetXTitle ( Title + "-jet efficiency" );
  EffFlavVsXEff_ni->getTH1F()->SetYTitle ( "non " + Title + "-jet efficiency" );
  EffFlavVsXEff_ni->getTH1F()->GetXaxis()->SetTitleOffset ( 0.75 );
  EffFlavVsXEff_ni->getTH1F()->GetYaxis()->SetTitleOffset ( 0.75 );
  EffFlavVsXEff_dusg->getTH1F()->SetXTitle ( Title + "-jet efficiency" );
  EffFlavVsXEff_dusg->getTH1F()->SetYTitle ( "non " + Title + "-jet efficiency" );
  EffFlavVsXEff_dusg->getTH1F()->GetXaxis()->SetTitleOffset ( 0.75 );
  EffFlavVsXEff_dusg->getTH1F()->GetYaxis()->SetTitleOffset ( 0.75 );
  EffFlavVsXEff_pu->getTH1F()->SetXTitle ( Title + "-jet efficiency" );
  EffFlavVsXEff_pu->getTH1F()->SetYTitle ( "non " + Title + "-jet efficiency" );
  EffFlavVsXEff_pu->getTH1F()->GetXaxis()->SetTitleOffset ( 0.75 );
  EffFlavVsXEff_pu->getTH1F()->GetYaxis()->SetTitleOffset ( 0.75 );

  // loop over eff. vs. discriminator cut b-histo and look in which bin the closest entry is;
  // use fact that eff decreases monotonously

  // any of the histos to be created can be taken here:
  MonitorElement * EffFlavVsXEff = EffFlavVsXEff_b;

  const int& nBinX = EffFlavVsXEff->getTH1F()->GetNbinsX();

  for ( int iBinX = 1; iBinX <= nBinX; iBinX++ ) {  // loop over the bins on the x-axis of the histograms to be filled

    const float& effXBinWidth = EffFlavVsXEff->getTH1F()->GetBinWidth  ( iBinX );
    const float& effXMid      = EffFlavVsXEff->getTH1F()->GetBinCenter ( iBinX ); // middle of b-efficiency bin
    const float& effXLeft     = effXMid - 0.5*effXBinWidth;              // left edge of bin
    const float& effXRight    = effXMid + 0.5*effXBinWidth;              // right edge of bin
    // find the corresponding bin in the efficiency versus discriminator cut histo: closest one in efficiency

    int binClosest = -1;
    if(!doCTagPlots_){
      binClosest = findBinClosestYValue ( effVersusDiscr_b , effXMid , effXLeft , effXRight );
    }
    else{
      binClosest = findBinClosestYValue ( effVersusDiscr_c , effXMid , effXLeft , effXRight );
    }

    const bool&  binFound   = ( binClosest > 0 ) ;
    //
    if ( binFound ) {
      // fill the histos
      if(mcPlots_>2){
    EffFlavVsXEff_d    -> Fill ( effXMid , effVersusDiscr_d   ->GetBinContent ( binClosest ) );
    EffFlavVsXEff_u    -> Fill ( effXMid , effVersusDiscr_u   ->GetBinContent ( binClosest ) );
    EffFlavVsXEff_s    -> Fill ( effXMid , effVersusDiscr_s   ->GetBinContent ( binClosest ) );
    EffFlavVsXEff_g    -> Fill ( effXMid , effVersusDiscr_g   ->GetBinContent ( binClosest ) );
    EffFlavVsXEff_dus  -> Fill ( effXMid , effVersusDiscr_dus ->GetBinContent ( binClosest ) );
      }
      EffFlavVsXEff_c    -> Fill ( effXMid , effVersusDiscr_c   ->GetBinContent ( binClosest ) );
      EffFlavVsXEff_b    -> Fill ( effXMid , effVersusDiscr_b   ->GetBinContent ( binClosest ) );
      EffFlavVsXEff_ni   -> Fill ( effXMid , effVersusDiscr_ni  ->GetBinContent ( binClosest ) );
      EffFlavVsXEff_dusg -> Fill ( effXMid , effVersusDiscr_dusg->GetBinContent ( binClosest ) );
      EffFlavVsXEff_pu   -> Fill ( effXMid , effVersusDiscr_pu  ->GetBinContent ( binClosest ) );

      if(mcPlots_>2){
    EffFlavVsXEff_d  ->getTH1F()  -> SetBinError ( iBinX , effVersusDiscr_d   ->GetBinError ( binClosest ) );
    EffFlavVsXEff_u  ->getTH1F()  -> SetBinError ( iBinX , effVersusDiscr_u   ->GetBinError ( binClosest ) );
    EffFlavVsXEff_s  ->getTH1F()  -> SetBinError ( iBinX , effVersusDiscr_s   ->GetBinError ( binClosest ) );
    EffFlavVsXEff_g  ->getTH1F()  -> SetBinError ( iBinX , effVersusDiscr_g   ->GetBinError ( binClosest ) );
    EffFlavVsXEff_dus->getTH1F()  -> SetBinError ( iBinX , effVersusDiscr_dus ->GetBinError ( binClosest ) );
      }
      EffFlavVsXEff_c  ->getTH1F()  -> SetBinError ( iBinX , effVersusDiscr_c   ->GetBinError ( binClosest ) );
      EffFlavVsXEff_b  ->getTH1F()  -> SetBinError ( iBinX , effVersusDiscr_b   ->GetBinError ( binClosest ) );
      EffFlavVsXEff_ni ->getTH1F()  -> SetBinError ( iBinX , effVersusDiscr_ni  ->GetBinError ( binClosest ) );
      EffFlavVsXEff_dusg->getTH1F() -> SetBinError ( iBinX , effVersusDiscr_dusg->GetBinError ( binClosest ) );
      EffFlavVsXEff_pu ->getTH1F()  -> SetBinError ( iBinX , effVersusDiscr_pu  ->GetBinError ( binClosest ) );
    }
  }
}


#include <typeinfo>