DistVariation

Description

Generic structure to hold the histograms and indices corresponding to one variation, for any observable using TUnfoldBinning.

This class is intended to be used in getUnfHist only.

#include <DistVariation.h>

Inheritance diagram for DistVariation:

Collaboration diagram for DistVariation:

Public Member Functions
	~DistVariation ()
	DistVariation (const TString &group, const TString &name, size_t index=0, int bit=0)
	DistVariation (const DistVariation &v)
	DistVariation (DistVariation &&v)
void	Write (TDirectory *d)
Public Member Functions inherited from Variation
	~Variation ()=default
	Variation (const TString &group, const TString &name, size_t index=0, int bit=0)
	Variation (const Variation &v)
	Variation (Variation &&v)

Public Attributes
std::unique_ptr< TH1 >	rec
std::unique_ptr< TH1 >	tmp
std::unique_ptr< TH1 >	gen
std::unique_ptr< TH1 >	missNoMatch
std::unique_ptr< TH1 >	missOut
std::unique_ptr< TH1 >	fakeNoMatch
std::unique_ptr< TH1 >	fakeOut
std::unique_ptr< TH2 >	cov
std::unique_ptr< TH2 >	RM
Public Attributes inherited from Variation
const TString	group
const TString	name
const std::size_t	index
const int	bit

Static Public Attributes
static bool	isMC = false
static TUnfoldBinning *	genBinning = nullptr
static TUnfoldBinning *	recBinning = nullptr

Constructor & Destructor Documentation

~DistVariation()

~DistVariation

(

)

Destructor.

{
    auto apply_to_all = [](auto&& f, auto&& ... x) { (f(x),...); };
 
    // 1D histograms
    auto check_bin_contents_1D = [](auto&& h) {
        if (!h) return;
        if (h->GetEntries() == 0) // TODO: fix move constructor (otherwise this is prompted when copying, which is misleading)
            cerr << orange << h->GetName() << " is empty" << def << '\n';
        if (h->GetBinContent(0) > 0)
            cerr << orange << h->GetName() << "'s underflow is not empty\n" << def;
        if (h->GetBinContent(h->GetNbinsX()+1) > 0)
            cerr << orange << h->GetName() << "'s overflow is not empty\n" << def;
    };
    apply_to_all(check_bin_contents_1D,
            rec, gen, missNoMatch, missOut, fakeNoMatch, fakeOut);
 
    // 2D histograms
    auto check_bin_contents_2D = [](auto&& h) {
        if (!h) return;
 
        int nBinsX = h->GetNbinsX();
        int nBinsY = h->GetNbinsY();
 
        bool underflowFilled = false,
             overflowFilled = false;
        for (int i = 1; i <= nBinsX; ++i) {
            underflowFilled |= h->GetBinContent(i,0) > 0;
            overflowFilled |= h->GetBinContent(i,nBinsY+1) > 0;
        }
        if (underflowFilled)
            cerr << orange << h->GetName() << "'s underflow on horizontal axis is not empty\n" << def;
        if (overflowFilled)
            cerr << orange << h->GetName() << "'s overflow on horizontal axis is not empty\n" << def;
 
        underflowFilled = false;
        overflowFilled = false;
        for (int i = 1; i <= nBinsX; ++i) {
            underflowFilled |= h->GetBinContent(0,i) > 0;
            overflowFilled |= h->GetBinContent(nBinsX+1,0) > 0;
        }
        if (underflowFilled)
            cerr << orange << h->GetName() << "'s underflow on vertical axis is not empty\n" << def;
        if (overflowFilled)
            cerr << orange << h->GetName() << "'s overflow on vertical axis is not empty\n" << def;
    };
    apply_to_all(check_bin_contents_2D, RM, cov);
 
    if (!RM) return;
 
    bool genClosure = true, recClosure = true;
    auto checkbin = [](const unique_ptr<TH1>& h, int i) {
        auto content = h->GetBinContent(i);
        bool ok = std::abs(content - 1) < feps || std::abs(content) < feps;
        if (!ok) cerr << orange << "| " << i << " " << content << "\n" << def;
        return ok;
    };
 
    auto RMx = unique_ptr<TH1>(RM->ProjectionX());
    RMx->Add(missNoMatch.get());
    RMx->Add(missOut.get());
    RMx->Divide(gen.get());
    for (int i = 1; i <= RMx->GetNbinsX(); ++i)
        genClosure &= checkbin(RMx, i);
 
    auto RMy = unique_ptr<TH1>(RM->ProjectionY());
    RMy->Add(fakeNoMatch.get());
    RMy->Add(fakeOut.get());
    RMy->Divide(rec.get());
    for (int i = 1; i <= RMy->GetNbinsX(); ++i)
        recClosure &= checkbin(RMy, i);
 
    if (!recClosure)
        cerr << red << name << " is not closing at rec level" << '\n' << def;
    if (!genClosure)
        cerr << red << name << " is not closing at gen level" << '\n' << def;
}

DistVariation() [1/3]

DistVariation	(	const TString &	group,
		const TString &	name,
		size_t	index = 0,
		int	bit = 0
	)

Normal constructor.

                                                                                              :
        DAS::Uncertainties::Variation(group, name, index, bit)
{
    cout << "|- Setting up " << __func__ << " `" << name << "`." << endl;
 
    if (!genBinning)
        BOOST_THROW_EXCEPTION( runtime_error("Particle-level binning has not been defined") );
    if (!recBinning)
        BOOST_THROW_EXCEPTION( runtime_error("Detector-level binning has not been defined") );
 
    // TH1 * TUnfoldBinning::CreateHistogram
    //      (const char * histogramName,
    //       Bool_t       originalAxisBinning = kFALSE, // no physical axis
    //       Int_t **     binMap = nullptr, // mapping from global bins to hist bins (unused here)
    //       const char * histogramTitle = nullptr,
    //       const char * axisSteering = nullptr  // needed for underflow and overflow (not done here)
    //      )
    auto makeRec = [this,name](TString subname, TString title) {
        auto h = unique_ptr<TH1>(recBinning->CreateHistogram(name + subname,
                                        false, nullptr, title + " (detector level)"));
        h->GetXaxis()->SetTitle("rec");
        return h;
    };
    rec = makeRec("rec", "all");
    tmp = makeRec("tmp", "temporary object to calculate covariance");
 
    // TH2D * TUnfoldBinning::CreateErrorMatrixHistogram
    //      (const char * histogramName,
    //       Bool_t       originalAxisBinning,
    //       Int_t **     binMap = nullptr,
    //       const char * histogramTitle = nullptr,
    //       const char * axisSteering = nullptr 
    //      )
    cov = unique_ptr<TH2>(recBinning->CreateErrorMatrixHistogram(name + "cov",
                                        false, nullptr, "covariance matrix (detector level)"));
    cov->GetXaxis()->SetTitle("rec");
    cov->GetYaxis()->SetTitle("rec");
 
    if (!isMC) return;
    auto makeGen = [this,name](TString subname, TString title) {
        auto h = unique_ptr<TH1>(genBinning->CreateHistogram(name + subname,
                                        false, nullptr, title + " (particle level)"));
        h->GetXaxis()->SetTitle("gen");
        return h;
    };
    gen         = makeGen("gen"        , "all");
    missNoMatch = makeGen("missNoMatch", "truly unmatched");
    missOut     = makeGen("missOut"    , "matched out of the phase space");
    fakeNoMatch = makeRec("fakeNoMatch", "truly unmatched");
    fakeOut     = makeRec("fakeOut"    , "matched out of the phase space");
 
    // TH2D * TUnfoldBinning::CreateHistogramOfMigrations (TUnfoldBinning const * xAxis,
    //                                                     TUnfoldBinning const * yAxis,
    //                                                     char const *           histogramName,
    //                                                     Bool_t                 originalXAxisBinning = kFALSE,
    //                                                     Bool_t                 originalYAxisBinning = kFALSE,
    //                                                     char const *           histogramTitle = nullptr 
    //                                                    )
    RM = unique_ptr<TH2>(TUnfoldBinning::CreateHistogramOfMigrations(genBinning, recBinning,
                                        name + "RM", false, false, "response matrix"));
    RM->GetXaxis()->SetTitle("gen");
    RM->GetYaxis()->SetTitle("rec");
}

DistVariation() [2/3]

DistVariation ( const DistVariation &  v )

inline

copy constructor

                                           :
        DAS::Uncertainties::Variation(v),
        rec        (std::unique_ptr<TH1>(dynamic_cast<TH1*>(v.rec        ->Clone()))),
        tmp        (std::unique_ptr<TH1>(dynamic_cast<TH1*>(v.tmp        ->Clone()))),
        gen        (std::unique_ptr<TH1>(dynamic_cast<TH1*>(v.gen        ->Clone()))),
        missNoMatch(std::unique_ptr<TH1>(dynamic_cast<TH1*>(v.missNoMatch->Clone()))),
        missOut    (std::unique_ptr<TH1>(dynamic_cast<TH1*>(v.missOut    ->Clone()))),
        fakeNoMatch(std::unique_ptr<TH1>(dynamic_cast<TH1*>(v.fakeNoMatch->Clone()))),
        fakeOut    (std::unique_ptr<TH1>(dynamic_cast<TH1*>(v.fakeOut    ->Clone()))),
        cov        (std::unique_ptr<TH2>(dynamic_cast<TH2*>(v.cov        ->Clone()))),
        RM         (std::unique_ptr<TH2>(dynamic_cast<TH2*>(v.RM         ->Clone())))
    { }

DistVariation() [3/3]

DistVariation ( DistVariation &&  v )

inline

move constructor

                                      :
        DAS::Uncertainties::Variation(v),
        rec(std::move(v.rec)), tmp(std::move(v.tmp)), gen(std::move(v.gen)),
        missNoMatch(std::move(v.missNoMatch)), missOut(std::move(v.missOut)),
        fakeNoMatch(std::move(v.fakeNoMatch)), fakeOut(std::move(v.fakeOut)),
        cov(std::move(v.cov)), RM(std::move(v.RM))
    { }

Member Function Documentation

Write()

void Write

(

TDirectory *

d

)

Create a subdirectory to the directory given in argument where all histograms are written.

{
    cout << "Writing " << name << endl;
    d->cd();
    TDirectory * dd = d->mkdir(name);
    dd->cd();
    auto write = [this,dd](auto&& h) {
        if (!h) return;
        TString n = h->GetName();
        n.ReplaceAll(name,"");
        h->SetDirectory(dd);
        h->Write(n);
    };
    auto apply_to_all = [](auto&& f, auto&& ... x) { (f(x),...); };
    apply_to_all(write,
            rec, gen, missNoMatch, missOut, fakeNoMatch, fakeOut, RM ,cov);
}

Member Data Documentation

cov

std::unique_ptr<TH2> cov

covariance matrix

fakeNoMatch

std::unique_ptr<TH1> fakeNoMatch

background (unmatched entries)

fakeOut

std::unique_ptr<TH1> fakeOut

background (migration out of phase space)

gen

std::unique_ptr<TH1> gen

generated-level distribution

genBinning

TUnfoldBinning * genBinning = nullptr

static

full binning at particle level

isMC

bool isMC = false

static

flag from metainfo

missNoMatch

std::unique_ptr<TH1> missNoMatch

losses (unmatched entries)

missOut

std::unique_ptr<TH1> missOut

losses (migration out of phase space)

rec

std::unique_ptr<TH1> rec

reconstructed-level distribution

recBinning

TUnfoldBinning * recBinning = nullptr

static

full binning at detector level

RM

std::unique_ptr<TH2> RM

response matrix

tmp

std::unique_ptr<TH1> tmp

temporary histogram help fill the covariance matrix

---

The documentation for this struct was generated from the following files:

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/Unfolding/interface/DistVariation.h
• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/Unfolding/src/DistVariation.cc