ZPtYFiller

#include <ZPtY.h>

Inheritance diagram for ZPtYFiller:

Collaboration diagram for ZPtYFiller:

Public Member Functions
	ZPtYFiller (const ZPtY &, Darwin::Tools::Flow &)
std::list< int >	fillRec (DistVariation &) override
void	match () override
void	fillMC (DistVariation &) override
Public Member Functions inherited from Filler
virtual	~Filler ()=default

Public Attributes
ZPtY	obs
std::vector< GenMuon > *	genMuons
std::vector< RecMuon > *	recMuons
GenEvent *	gEv
RecEvent *	rEv

Constructor & Destructor Documentation

ZPtYFiller()

ZPtYFiller	(	const ZPtY &	obs,
		Darwin::Tools::Flow &	flow
	)

Constructor.

    : obs(obs)
    , genMuons(obs.isMC ? flow.GetBranchReadOnly<vector<GenMuon>>("genMuons") : nullptr)
    , recMuons(flow.GetBranchReadOnly<vector<RecMuon>>("recMuons"))
    , gEv(obs.isMC ? flow.GetBranchReadOnly<GenEvent>("genEvent") : nullptr)
    , rEv(flow.GetBranchReadOnly<RecEvent>("recEvent"))
{}

Member Function Documentation

fillMC()

void fillMC ( DistVariation &  v )

overridevirtual

See Filler::fillMC

Reimplemented from Filler.

{
    if (!obs.isMC)
        BOOST_THROW_EXCEPTION( runtime_error(__func__ + " should only be called for MC"s) );
 
    auto rEvW = rEv->Weight(v),
         gEvW = gEv->Weight(v);
 
    const auto genBin = getBinNumber(obs.genBinning, *genMuons, v);
    const auto recBin = getBinNumber(obs.recBinning, *recMuons, v);
 
    const double genMuW = genBin > 0 ? getWeight(*genMuons, v) : 0;
    const double recMuW = recBin > 0 ? getWeight(*recMuons, v) : 0;
 
    if (genBin > 0) v.gen->Fill(genBin, gEvW * genMuW);
 
    if (genBin > 0 && recBin > 0) {
        // Good events
        v.RM     ->Fill(genBin, recBin, gEvW * genMuW *      rEvW * recMuW);
        v.missOut->Fill(genBin,         gEvW * genMuW * (1 - rEvW * recMuW));
    } else if (genBin > 0 && recBin <= 0)
        // Miss
        v.missOut->Fill(genBin,         gEvW * genMuW                     );
    else if (genBin <= 0 && recBin >= 0)
        // Fake
        v.fakeOut->Fill(        recBin, gEvW *               rEvW * recMuW);
}

fillRec()

list< int > fillRec ( DistVariation &  v )

overridevirtual

See Filler::fillRec

Reimplemented from Filler.

{
    double evW = rEv->Weight(v);
    if (obs.isMC) evW *= gEv->Weight(v);
 
    const int bin = getBinNumber(obs.recBinning, *recMuons, v);
    if (bin <= 0) return {};
 
    const double muW = getWeight(*recMuons, v);
    v.tmp->Fill(bin, evW * muW);
    v.rec->Fill(bin, evW * muW);
 
    return {bin};
}

match()

void match ( )

inlineoverridevirtual

Matching is not needed.

Reimplemented from Filler.

{}

Member Data Documentation

genMuons

std::vector<GenMuon>* genMuons

gEv

GenEvent* gEv

obs

ZPtY obs

Backreference to the observable.

recMuons

std::vector<RecMuon>* recMuons

rEv

RecEvent* rEv

---

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

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