Comparator Class Reference

#include <Comparator.h>

Public Types
enum	Mode {   NORMAL, SCALE, RATIO, GRAPH,   EFF }

Public Member Functions
	Comparator ()
	Comparator (const char *file0, const char *dir0, const char *file1, const char *dir1)
TDirectory *	dir0 ()
TDirectory *	dir1 ()
void	Draw (const char *key, Mode mode)
void	Draw (const char *key0, const char *key1, Mode mode)
void	DrawGaussSigmaOverMeanSlice (const char *key, const char *key2, const int rebinFactor, Mode mode)
void	DrawGaussSigmaOverMeanXSlice (const char *key, const int rebinFactor, const int binxmin, const int binxmax, const bool cst_binning, Mode mode)
void	DrawGaussSigmaSlice (const char *key, const int rebinFactor, Mode mode)
void	DrawGaussSigmaSlice (const char *key, const int rebinFactor, const int binxmin, const int binxmax, const bool cst_binning, Mode mode)
void	DrawMeanSlice (const char *key, const int rebinFactor, Mode mode)
void	DrawSigmaSlice (const char *key, const int rebinFactor, Mode mode)
void	DrawSlice (const char *key, int binxmin, int binxmax, Mode mode)
TH1 *	h0 ()
TH1 *	h1 ()
TH1 *	Histo (const char *key, unsigned dirIndex)
TLegend &	Legend ()
const TLegend &	Legend () const
void	SetAxis (int rebin, float xmin, float xmax)
void	SetAxis (int rebin)
void	SetDirs (const char *file0, const char *dir0, const char *file1, const char *dir1)
void	SetStyles (Style *s0, Style *s1, const char *leg0, const char *leg1)

Private Member Functions
void	Draw (TH1 *h0, TH1 *h1, Mode mode)

Private Attributes
TDirectory *	dir0_
TDirectory *	dir1_
TFile *	file0_
TFile *	file1_
TH1 *	h0_
TH1 *	h1_
TLegend	legend_
int	rebin_
bool	resetAxis_
Style *	s0_
Style *	s1_
float	xMax_
float	xMin_

Detailed Description

Definition at line 15 of file Comparator.h.

Member Enumeration Documentation

Mode

enum Comparator::Mode

Enumerator
NORMAL
SCALE
RATIO
GRAPH
EFF

Definition at line 17 of file Comparator.h.

{ NORMAL, SCALE, RATIO, GRAPH, EFF };

Constructor & Destructor Documentation

Comparator() [1/2]

Comparator::Comparator ( )

inline

Definition at line 19 of file Comparator.h.

: rebin_(-1), xMin_(0), xMax_(0), resetAxis_(false), s0_(nullptr), s1_(nullptr), legend_(0, 0, 1, 1) {}

Comparator() [2/2]

Comparator::Comparator ( const char *  file0, const char *  dir0, const char *  file1, const char *  dir1  )

inline

Definition at line 21 of file Comparator.h.

References dir0(), dir1(), timingPdfMaker::file1, and SetDirs().

      : rebin_(-1), xMin_(0), xMax_(0), resetAxis_(false), s0_(nullptr), s1_(nullptr), legend_(0, 0, 1, 1) {
    SetDirs(file0, dir0, file1, dir1);
  }

Member Function Documentation

dir0()

TDirectory* Comparator::dir0 ( )

inline

Definition at line 73 of file Comparator.h.

References dir0_.

Referenced by Comparator().

{ return dir0_; }

dir1()

TDirectory* Comparator::dir1 ( )

inline

Definition at line 74 of file Comparator.h.

References dir1_.

Referenced by Comparator().

{ return dir1_; }

Draw() [1/3]

void Comparator::Draw	(	const char *	key,
		Mode	mode
	)

Definition at line 306 of file Comparator.cc.

References crabWrapper::key, and ALCARECOPromptCalibProdSiPixelAli0T_cff::mode.

                                                {
  TH1::AddDirectory(false);
  TH1 *h0 = Histo(key, 0);
  TH1 *h1 = (TH1 *)Histo(key, 1)->Clone("h1");

  TH1::AddDirectory(true);
  Draw(h0, h1, mode);
}

Draw() [2/3]

void Comparator::Draw	(	const char *	key0,
		const char *	key1,
		Mode	mode
	)

Definition at line 315 of file Comparator.cc.

References ALCARECOPromptCalibProdSiPixelAli0T_cff::mode.

                                                                   {
  TH1 *h0 = nullptr;
  TH1 *h1 = nullptr;
  if (mode != EFF) {
    h0 = Histo(key0, 0);
    h1 = Histo(key1, 1);
  } else {
    h0 = Histo(key0, 0);
    TH1 *h0b = Histo(key1, 0);
    h1 = Histo(key0, 1);
    TH1 *h1b = Histo(key1, 1);
    if (rebin_ > 1) {
      h0->Rebin(rebin_);
      h1->Rebin(rebin_);
      h0b->Rebin(rebin_);
      h1b->Rebin(rebin_);
    }
    if (resetAxis_) {
      h0->GetXaxis()->SetRangeUser(xMin_, xMax_);
      h1->GetXaxis()->SetRangeUser(xMin_, xMax_);
      h0b->GetXaxis()->SetRangeUser(xMin_, xMax_);
      h1b->GetXaxis()->SetRangeUser(xMin_, xMax_);
    }

    h0b->Sumw2();
    h0->Sumw2();
    h0->Divide(h0, h0b, 1., 1., "B");
    h1b->Sumw2();
    h1->Sumw2();
    h1->Divide(h1, h1b, 1., 1., "B");
  }
  Draw(h0, h1, mode);
}

Draw() [3/3]

void Comparator::Draw ( TH1 *  h0, TH1 *  h1, Mode  mode  )

private

Definition at line 369 of file Comparator.cc.

References DMR_cfg::cerr, Styles::FormatHisto(), SiStripPI::max, SiStripPI::min, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, RATIO, AlCaHLTBitMon_QueryRunRegistry::string, and submitPVValidationJobs::text.

                                                 {
  if (!(h0 && h1)) {
    cerr << "invalid histo" << endl;
    return;
  }

  TH1::AddDirectory(false);
  h0_ = (TH1 *)h0->Clone("h0_");
  h1_ = (TH1 *)h1->Clone("h1_");
  TH1::AddDirectory(true);

  // unsetting the title, since the title of projections
  // is still the title of the 2d histo
  // and this is better anyway
  h0_->SetTitle("");
  h1_->SetTitle("");

  // h0_->SetStats(1);
  // h1_->SetStats(1);

  if (mode != EFF) {
    if (rebin_ > 1) {
      h0_->Rebin(rebin_);
      h1_->Rebin(rebin_);
    }
    if (resetAxis_) {
      h0_->GetXaxis()->SetRangeUser(xMin_, xMax_);
      h1_->GetXaxis()->SetRangeUser(xMin_, xMax_);
    }
  }

  if (mode != GRAPH) {
    TPaveStats *ptstats = new TPaveStats(0.7385057, 0.720339, 0.9396552, 0.8792373, "brNDC");
    ptstats->SetName("stats");
    ptstats->SetBorderSize(1);
    ptstats->SetLineColor(2);
    ptstats->SetFillColor(10);
    ptstats->SetTextAlign(12);
    ptstats->SetTextColor(2);
    ptstats->SetOptStat(1111);
    ptstats->SetOptFit(0);
    ptstats->Draw();
    h0_->GetListOfFunctions()->Add(ptstats);
    ptstats->SetParent(h0_->GetListOfFunctions());

    // std::cout << "FL: h0_->GetMean() = " << h0_->GetMean() << std::endl;
    // std::cout << "FL: h0_->GetRMS() = " << h0_->GetRMS() << std::endl;
    // std::cout << "FL: h1_->GetMean() = " << h1_->GetMean() << std::endl;
    // std::cout << "FL: h1_->GetRMS() = " << h1_->GetRMS() << std::endl;
    // std::cout << "FL: test2" << std::endl;
    TPaveStats *ptstats2 = new TPaveStats(0.7399425, 0.529661, 0.941092, 0.6885593, "brNDC");
    ptstats2->SetName("stats");
    ptstats2->SetBorderSize(1);
    ptstats2->SetLineColor(4);
    ptstats2->SetFillColor(10);
    ptstats2->SetTextAlign(12);
    ptstats2->SetTextColor(4);
    TText *text = ptstats2->AddText("h1_");
    text->SetTextSize(0.03654661);

    std::ostringstream oss3;
    oss3 << h1_->GetEntries();
    const std::string txt_entries = "Entries = " + oss3.str();
    text = ptstats2->AddText(txt_entries.c_str());
    std::ostringstream oss;
    oss << h1_->GetMean();
    const std::string txt_mean = "Mean  = " + oss.str();
    text = ptstats2->AddText(txt_mean.c_str());
    std::ostringstream oss2;
    oss2 << h1_->GetRMS();
    const std::string txt_rms = "RMS  = " + oss2.str();
    text = ptstats2->AddText(txt_rms.c_str());
    ptstats2->SetOptStat(1111);
    ptstats2->SetOptFit(0);
    ptstats2->Draw();
    h1_->GetListOfFunctions()->Add(ptstats2);
    ptstats2->SetParent(h1_->GetListOfFunctions());
  } else {
    TPaveStats *ptstats = new TPaveStats(0.0, 0.0, 0.0, 0.0, "brNDC");
    ptstats->Draw();
    h0_->GetListOfFunctions()->Add(ptstats);
    ptstats->SetParent(h0_->GetListOfFunctions());
  }

  float min = -999.;
  float max = +999.;
  switch (mode) {
    case SCALE:
      h1_->Scale(h0_->GetEntries() / h1_->GetEntries());
      break;
    case NORMAL:
      if (s0_)
        Styles::FormatHisto(h0_, s0_);
      if (s1_)
        Styles::FormatHisto(h1_, s1_);

      if (h1_->GetMaximum() > h0_->GetMaximum()) {
        h0_->SetMaximum(h1_->GetMaximum() * 1.15);
      }

      h0_->Draw();
      h1_->Draw("same");

      break;
    case EFF:
      if (s0_)
        Styles::FormatHisto(h0_, s0_);
      if (s1_)
        Styles::FormatHisto(h1_, s1_);

      // rather arbitrary but useful
      max = h0_->GetMaximum();
      if (h1_->GetMaximum() > max)
        max = h1_->GetMaximum();
      if (max > 0.8)
        max = 1;

      max *= 1.1;

      min = h0_->GetMinimum();
      if (h1_->GetMinimum() < min)
        min = h1_->GetMinimum();
      if (min > 0.2)
        min = 0.;

      min *= 0.8;
      h0_->SetMaximum(max);
      h0_->SetMinimum(min);

      h0_->Draw("E");
      h1_->Draw("Esame");
      break;
    case GRAPH:
      if (s0_)
        Styles::FormatHisto(h0_, s0_);
      if (s1_)
        Styles::FormatHisto(h1_, s1_);

      if (h1_->GetMaximum() > h0_->GetMaximum()) {
        h0_->SetMaximum(h1_->GetMaximum() * 1.15);
      }
      if (h1_->GetMinimum() < h0_->GetMinimum()) {
        h0_->SetMinimum(h1_->GetMinimum() * 1.15);
      }
      h0_->SetMarkerStyle(21);
      h0_->SetMarkerColor(2);
      h1_->SetMarkerStyle(21);
      h1_->SetMarkerColor(4);

      h0_->Draw("E1");
      h1_->Draw("E1same");
      break;
    case RATIO:
      h0_->Sumw2();
      h1_->Sumw2();
      h0_->Divide(h1_);
      if (s0_)
        Styles::FormatHisto(h0_, s0_);
      h0_->Draw();
      break;
    default:
      break;
  }
}

DrawGaussSigmaOverMeanSlice()

void Comparator::DrawGaussSigmaOverMeanSlice	(	const char *	key,
		const char *	key2,
		const int	rebinFactor,
		Mode	mode
	)

Definition at line 276 of file Comparator.cc.

References TH2Analyzer::Average(), DeadROC_duringRun::dir, hcalSimParameters_cfi::hb, crabWrapper::key, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, and TH2Analyzer::SigmaGauss().

                                                                                                                {
  TDirectory *dir = dir1_;
  dir->cd();

  TH2D *h2_b = (TH2D *)dir->Get(key2);
  TH2Analyzer TH2Ana_b(h2_b, rebinFactor);
  TH1D *meanslice = TH2Ana_b.Average();

  TH2D *h2 = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Ana(h2, rebinFactor);

  TH1D *ha = TH2Ana.SigmaGauss();
  ha->Divide(meanslice);

  dir = dir0_;
  dir->cd();
  TH2D *h2b = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Anab(h2b, rebinFactor);

  TH2D *h2b_b = (TH2D *)dir->Get(key2);
  TH2Analyzer TH2Anab_b(h2b_b, rebinFactor);
  TH1D *meansliceb = TH2Anab_b.Average();

  TH1D *hb = TH2Anab.SigmaGauss();
  hb->Divide(meansliceb);

  Draw(hb, ha, mode);
  // Draw(meansliceb,meanslice,mode);
}

DrawGaussSigmaOverMeanXSlice()

void Comparator::DrawGaussSigmaOverMeanXSlice	(	const char *	key,
		const int	rebinFactor,
		const int	binxmin,
		const int	binxmax,
		const bool	cst_binning,
		Mode	mode
	)

Definition at line 195 of file Comparator.cc.

References DeadROC_duringRun::dir, fitFunction_f(), hcalSimParameters_cfi::hb, crabWrapper::key, TH2Analyzer::MeanX(), ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, TH2Analyzer::RMS(), and TH2Analyzer::SigmaGauss().

                                                                                                                     {
  TDirectory *dir = dir1_;
  dir->cd();
  TH2D *h2 = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Ana(h2, binxmin, binxmax, rebinFactor, cst_binning);
  TH1D *hrms = TH2Ana.RMS();

  TH1D *meanXslice = TH2Ana.MeanX();
  // for( int i=1; i<=meanXslice->GetNbinsX(); ++i) {
  //  std::cout << "meanXslice->GetBinContent(" << i << ") = "
  //          << meanXslice->GetBinContent(i) << std::endl;
  //  std::cout << "meanXslice->GetBinError(" << i << ") = "
  //          << meanXslice->GetBinError(i) << std::endl;
  //}
  // Draw(meanXslice,meanXslice,mode);
  hrms->Divide(meanXslice);

  TF1 *fitXfcndgssrms3 = new TF1("fitXfcndgssrms3",
                                 fitFunction_f,
                                 hrms->GetXaxis()->GetBinLowEdge(1),
                                 hrms->GetXaxis()->GetBinUpEdge(hrms->GetNbinsX()),
                                 4);
  fitXfcndgssrms3->SetNpx(500);
  fitXfcndgssrms3->SetLineWidth(3);
  fitXfcndgssrms3->SetLineStyle(2);
  fitXfcndgssrms3->SetLineColor(4);
  hrms->Fit(fitXfcndgssrms3, "0R");

  TH1D *ha = TH2Ana.SigmaGauss();
  ha->Divide(meanXslice);
  TF1 *fitXfcndgsse3 = new TF1("fitXfcndgsse3",
                               fitFunction_f,
                               ha->GetXaxis()->GetBinLowEdge(1),
                               ha->GetXaxis()->GetBinUpEdge(ha->GetNbinsX()),
                               4);
  fitXfcndgsse3->SetNpx(500);
  fitXfcndgsse3->SetLineWidth(3);
  fitXfcndgsse3->SetLineStyle(1);
  fitXfcndgsse3->SetLineColor(4);
  ha->Fit(fitXfcndgsse3, "0R");

  dir = dir0_;
  dir->cd();
  TH2D *h2b = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Anab(h2b, binxmin, binxmax, rebinFactor, cst_binning);
  TH1D *hrmsb = TH2Anab.RMS();
  hrmsb->Divide(meanXslice);
  TF1 *fitXfcndgssrmsb3 = new TF1("fitXfcndgssrmsb3",
                                  fitFunction_f,
                                  hrmsb->GetXaxis()->GetBinLowEdge(1),
                                  hrmsb->GetXaxis()->GetBinUpEdge(hrmsb->GetNbinsX()),
                                  4);
  fitXfcndgssrmsb3->SetNpx(500);
  fitXfcndgssrmsb3->SetLineWidth(3);
  fitXfcndgssrmsb3->SetLineStyle(2);
  fitXfcndgssrmsb3->SetLineColor(2);
  hrmsb->Fit(fitXfcndgssrmsb3, "0R");

  TH1D *hb = TH2Anab.SigmaGauss();
  hb->Divide(meanXslice);
  TF1 *fitXfcndgsseb3 = new TF1("fitXfcndgsseb3",
                                fitFunction_f,
                                hb->GetXaxis()->GetBinLowEdge(1),
                                hb->GetXaxis()->GetBinUpEdge(hb->GetNbinsX()),
                                4);
  fitXfcndgsseb3->SetNpx(500);
  fitXfcndgsseb3->SetLineWidth(3);
  fitXfcndgsseb3->SetLineStyle(1);
  fitXfcndgsseb3->SetLineColor(2);
  hb->Fit(fitXfcndgsseb3, "0R");

  Draw(hb, ha, mode);
  // Draw(hrms,ha,mode);
  // Draw(ha,ha,mode);
  fitXfcndgssrms3->Draw("same");
  fitXfcndgsse3->Draw("same");
  fitXfcndgssrmsb3->Draw("same");
  fitXfcndgsseb3->Draw("same");
}

DrawGaussSigmaSlice() [1/2]

void Comparator::DrawGaussSigmaSlice	(	const char *	key,
		const int	rebinFactor,
		Mode	mode
	)

Definition at line 105 of file Comparator.cc.

References DeadROC_duringRun::dir, hcalSimParameters_cfi::hb, crabWrapper::key, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, and TH2Analyzer::SigmaGauss().

                                                                                      {
  TDirectory *dir = dir1_;
  dir->cd();
  TH2D *h2 = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Ana(h2, rebinFactor);
  TH1D *ha = TH2Ana.SigmaGauss();

  dir = dir0_;
  dir->cd();
  TH2D *h2b = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Anab(h2b, rebinFactor);
  TH1D *hb = TH2Anab.SigmaGauss();

  Draw(hb, ha, mode);
}

DrawGaussSigmaSlice() [2/2]

void Comparator::DrawGaussSigmaSlice	(	const char *	key,
		const int	rebinFactor,
		const int	binxmin,
		const int	binxmax,
		const bool	cst_binning,
		Mode	mode
	)

Definition at line 128 of file Comparator.cc.

References DeadROC_duringRun::dir, fitFunction_f(), hcalSimParameters_cfi::hb, crabWrapper::key, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, TH2Analyzer::RMS(), and TH2Analyzer::SigmaGauss().

                                                                                                                     {
  TDirectory *dir = dir1_;
  dir->cd();
  TH2D *h2 = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Ana(h2, binxmin, binxmax, rebinFactor, cst_binning);
  TH1D *hrms = TH2Ana.RMS();
  TF1 *fitfcndgssrms3 = new TF1("fitfcndgssrms3",
                                fitFunction_f,
                                hrms->GetXaxis()->GetBinLowEdge(1),
                                hrms->GetXaxis()->GetBinUpEdge(hrms->GetNbinsX()),
                                4);
  fitfcndgssrms3->SetNpx(500);
  fitfcndgssrms3->SetLineWidth(3);
  fitfcndgssrms3->SetLineStyle(2);
  fitfcndgssrms3->SetLineColor(4);
  hrms->Fit(fitfcndgssrms3, "0R");

  TH1D *ha = TH2Ana.SigmaGauss();
  TF1 *fitfcndgsse3 = new TF1("fitfcndgsse3",
                              fitFunction_f,
                              hrms->GetXaxis()->GetBinLowEdge(1),
                              hrms->GetXaxis()->GetBinUpEdge(hrms->GetNbinsX()),
                              4);
  fitfcndgsse3->SetNpx(500);
  fitfcndgsse3->SetLineWidth(3);
  fitfcndgsse3->SetLineStyle(1);
  fitfcndgsse3->SetLineColor(4);
  ha->Fit(fitfcndgsse3, "0R");

  dir = dir0_;
  dir->cd();
  TH2D *h2b = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Anab(h2b, binxmin, binxmax, rebinFactor, cst_binning);
  TH1D *hrmsb = TH2Anab.RMS();
  TF1 *fitfcndgssrmsb3 = new TF1("fitfcndgssrmsb3",
                                 fitFunction_f,
                                 hrms->GetXaxis()->GetBinLowEdge(1),
                                 hrms->GetXaxis()->GetBinUpEdge(hrms->GetNbinsX()),
                                 4);
  fitfcndgssrmsb3->SetNpx(500);
  fitfcndgssrmsb3->SetLineWidth(3);
  fitfcndgssrmsb3->SetLineStyle(2);
  fitfcndgssrmsb3->SetLineColor(2);
  hrmsb->Fit(fitfcndgssrmsb3, "0R");

  TH1D *hb = TH2Anab.SigmaGauss();
  TF1 *fitfcndgsseb3 = new TF1("fitfcndgsseb3",
                               fitFunction_f,
                               hrms->GetXaxis()->GetBinLowEdge(1),
                               hrms->GetXaxis()->GetBinUpEdge(hrms->GetNbinsX()),
                               4);
  fitfcndgsseb3->SetNpx(500);
  fitfcndgsseb3->SetLineWidth(3);
  fitfcndgsseb3->SetLineStyle(1);
  fitfcndgsseb3->SetLineColor(2);
  hb->Fit(fitfcndgsseb3, "0R");

  Draw(hb, ha, mode);
  // Draw(hrms,ha,mode);
  // Draw(ha,ha,mode);
  fitfcndgssrms3->Draw("same");
  fitfcndgsse3->Draw("same");
  fitfcndgssrmsb3->Draw("same");
  fitfcndgsseb3->Draw("same");
}

DrawMeanSlice()

void Comparator::DrawMeanSlice	(	const char *	key,
		const int	rebinFactor,
		Mode	mode
	)

Definition at line 73 of file Comparator.cc.

References TH2Analyzer::Average(), DeadROC_duringRun::dir, hcalSimParameters_cfi::hb, crabWrapper::key, and ALCARECOPromptCalibProdSiPixelAli0T_cff::mode.

                                                                                {
  TDirectory *dir = dir1_;
  dir->cd();
  TH2D *h2 = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Ana(h2, rebinFactor);
  TH1D *ha = TH2Ana.Average();

  dir = dir0_;
  dir->cd();
  TH2D *h2b = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Anab(h2b, rebinFactor);
  TH1D *hb = TH2Anab.Average();

  Draw(hb, ha, mode);
}

DrawSigmaSlice()

void Comparator::DrawSigmaSlice	(	const char *	key,
		const int	rebinFactor,
		Mode	mode
	)

Definition at line 89 of file Comparator.cc.

References DeadROC_duringRun::dir, hcalSimParameters_cfi::hb, crabWrapper::key, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, and TH2Analyzer::RMS().

                                                                                 {
  TDirectory *dir = dir1_;
  dir->cd();
  TH2D *h2 = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Ana(h2, rebinFactor);
  TH1D *ha = TH2Ana.RMS();

  dir = dir0_;
  dir->cd();
  TH2D *h2b = (TH2D *)dir->Get(key);
  TH2Analyzer TH2Anab(h2b, rebinFactor);
  TH1D *hb = TH2Anab.RMS();

  Draw(hb, ha, mode);
}

DrawSlice()

void Comparator::DrawSlice	(	const char *	key,
		int	binxmin,
		int	binxmax,
		Mode	mode
	)

Definition at line 42 of file Comparator.cc.

References DMR_cfg::cerr, crabWrapper::key, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, EgammaValidation_cff::num, and PointingDoubleMultiSkim_cfg::out1.

                                                                               {
  static int num = 0;

  ostringstream out0;
  out0 << "h0_2d_" << num;
  ostringstream out1;
  out1 << "h1_2d_" << num;
  num++;

  string name0 = out0.str();
  string name1 = out1.str();

  TH1 *h0 = Histo(key, 0);
  TH1 *h1 = Histo(key, 1);

  TH2 *h0_2d = dynamic_cast<TH2 *>(h0);
  TH2 *h1_2d = dynamic_cast<TH2 *>(h1);

  if (h0_2d->GetNbinsY() == 1 || h1_2d->GetNbinsY() == 1) {
    cerr << key << " is not 2D" << endl;
    return;
  }

  TH1::AddDirectory(false);

  TH1D *h0_slice = h0_2d->ProjectionY(name0.c_str(), binxmin, binxmax, "");
  TH1D *h1_slice = h1_2d->ProjectionY(name1.c_str(), binxmin, binxmax, "");
  TH1::AddDirectory(true);
  Draw(h0_slice, h1_slice, mode);
}

h0()

TH1* Comparator::h0 ( )

inline

Definition at line 62 of file Comparator.h.

References h0_.

{ return h0_; }

h1()

TH1* Comparator::h1 ( )

inline

Definition at line 63 of file Comparator.h.

References h1_.

{ return h1_; }

Histo()

TH1 * Comparator::Histo	(	const char *	key,
		unsigned	dirIndex
	)

Definition at line 349 of file Comparator.cc.

References cms::cuda::assert(), DMR_cfg::cerr, DeadROC_duringRun::dir, h, crabWrapper::key, and mitigatedMETSequence_cff::U.

                                                         {
  if (dirIndex > 1U) {  // dirIndex >= 0, since dirIndex is unsigned
    cerr << "bad dir index: " << dirIndex << endl;
    return nullptr;
  }
  TDirectory *dir = nullptr;
  if (dirIndex == 0)
    dir = dir0_;
  if (dirIndex == 1)
    dir = dir1_;
  assert(dir);

  dir->cd();

  TH1 *h = (TH1 *)dir->Get(key);
  if (!h)
    cerr << "no key " << key << " in directory " << dir->GetName() << endl;
  return h;
}

Legend() [1/2]

TLegend& Comparator::Legend ( )

inline

Definition at line 65 of file Comparator.h.

References legend_.

{ return legend_; }

Legend() [2/2]

const TLegend& Comparator::Legend ( ) const

inline

Definition at line 66 of file Comparator.h.

References legend_.

{ return legend_; }

SetAxis() [1/2]

void Comparator::SetAxis ( int  rebin, float  xmin, float  xmax  )

inline

Definition at line 31 of file Comparator.h.

References rebin_, resetAxis_, TrackerOfflineValidation_Dqm_cff::xmax, xMax_, TrackerOfflineValidation_Dqm_cff::xmin, and xMin_.

                                                  {
    rebin_ = rebin;
    xMin_ = xmin;
    xMax_ = xmax;
    resetAxis_ = true;
  }

SetAxis() [2/2]

void Comparator::SetAxis ( int  rebin )

inline

Definition at line 39 of file Comparator.h.

References rebin_, and resetAxis_.

                          {
    rebin_ = rebin;
    resetAxis_ = false;
  }

SetDirs()

void Comparator::SetDirs	(	const char *	file0,
		const char *	dir0,
		const char *	file1,
		const char *	dir1
	)

set the 2 files, and the directory within each file, in which the histograms will be compared

Definition at line 17 of file Comparator.cc.

References L1TDiffHarvesting_cfi::dir1, beamvalidation::exit(), and timingPdfMaker::file1.

Referenced by Comparator().

                                                                                                 {
  file0_ = new TFile(file0);
  if (file0_->IsZombie())
    exit(1);
  dir0_ = file0_->GetDirectory(dir0);
  if (!dir0_)
    exit(1);

  file1_ = new TFile(file1);
  if (file1_->IsZombie())
    exit(1);
  dir1_ = file1_->GetDirectory(dir1);
  if (!dir1_)
    exit(1);
}

SetStyles()

void Comparator::SetStyles	(	Style *	s0,
		Style *	s1,
		const char *	leg0,
		const char *	leg1
	)

Definition at line 33 of file Comparator.cc.

                                                                                   {
  s0_ = s0;
  s1_ = s1;

  legend_.Clear();
  legend_.AddEntry(s0_, leg0, "mlf");
  legend_.AddEntry(s1_, leg1, "mlf");
}

Member Data Documentation

dir0_

TDirectory* Comparator::dir0_

private

Definition at line 90 of file Comparator.h.

Referenced by dir0().

dir1_

TDirectory* Comparator::dir1_

private

Definition at line 92 of file Comparator.h.

Referenced by dir1().

file0_

TFile* Comparator::file0_

private

Definition at line 89 of file Comparator.h.

file1_

TFile* Comparator::file1_

private

Definition at line 91 of file Comparator.h.

h0_

TH1* Comparator::h0_

private

Definition at line 94 of file Comparator.h.

Referenced by h0().

h1_

TH1* Comparator::h1_

private

Definition at line 95 of file Comparator.h.

Referenced by h1().

legend_

TLegend Comparator::legend_

private

Definition at line 100 of file Comparator.h.

Referenced by Legend().

rebin_

int Comparator::rebin_

private

Definition at line 84 of file Comparator.h.

Referenced by SetAxis().

resetAxis_

bool Comparator::resetAxis_

private

Definition at line 87 of file Comparator.h.

Referenced by SetAxis().

s0_

Style* Comparator::s0_

private

Definition at line 97 of file Comparator.h.

s1_

Style* Comparator::s1_

private

Definition at line 98 of file Comparator.h.

xMax_

float Comparator::xMax_

private

Definition at line 86 of file Comparator.h.

Referenced by SetAxis().

xMin_

float Comparator::xMin_

private

Definition at line 85 of file Comparator.h.

Referenced by SetAxis().