ZmmYFiller

#include <ZmmY.h>

Inheritance diagram for ZmmYFiller:

Collaboration diagram for ZmmYFiller:

Public Member Functions
	ZmmYFiller (Darwin::Tools::Flow &flow, bool isMC)
template<typename MUON , typename PHOTON >
int	GetBinNumber (const TUnfoldBinning *binning, const EventInfo< MUON, PHOTON > &event, const Uncertainties::Variation &v) const
template<typename MUON , typename PHOTON >
int	GetBinNumber2D (const TUnfoldBinning *binning, const EventInfo< MUON, PHOTON > &event, const Uncertainties::Variation &v) const
virtual const Observable *	getObs () const =0
virtual int	getObsDimension () const
std::list< int >	fillRec (DistVariation &v) override
void	match () override
void	fillMC (DistVariation &v) override
Public Member Functions inherited from Filler
virtual	~Filler ()=default

Public Attributes
EventInfo< RecMuon, RecPhoton >	rInfo
std::vector< GenMuon > *	genMuons
std::vector< RecMuon > *	recMuons
std::vector< GenPhoton > *	genPhotons
std::vector< RecPhoton > *	recPhotons
GenEvent *	gEv
RecEvent *	rEv

Protected Member Functions
virtual double	computeObservableValue (const void *event, const Uncertainties::Variation &v, bool isGen) const
virtual std::vector< double >	computeObservableValue2D (const void *event, const Uncertainties::Variation &v, bool isGen) const

Constructor & Destructor Documentation

ZmmYFiller()

ZmmYFiller ( Darwin::Tools::Flow &  flow, bool  isMC  )

inline

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

Member Function Documentation

computeObservableValue()

virtual double computeObservableValue ( const void *  event, const Uncertainties::Variation &  v, bool  isGen  ) const

inlineprotectedvirtual

Reimplemented in MmmYFiller, MmmFiller, PtFiller, and DrFiller.

                                                                                                                {
        return 0.0;
    }

computeObservableValue2D()

virtual std::vector<double> computeObservableValue2D ( const void *  event, const Uncertainties::Variation &  v, bool  isGen  ) const

inlineprotectedvirtual

Reimplemented in DalitzFiller.

                                                                                                                             {
        return {};
    }

fillMC()

void fillMC ( DistVariation &  )

overridevirtual

Fill RM, gen, miss, fake histograms for a given variation.

Reimplemented from Filler.

{
    if (!getObs()->isMC)
        BOOST_THROW_EXCEPTION( runtime_error(__func__ + " should only be called for MC"s) );
    auto gInfo = EventInfo(gEv, nullptr, *genMuons, *genPhotons, v);
    int genBin = 0, recBin = 0;
    if (getObsDimension() == 1) {
        genBin = GetBinNumber(getObs()->genBinning, gInfo, v);
        recBin = GetBinNumber(getObs()->recBinning, rInfo, v);
    } else if (getObsDimension() == 2) {
        genBin = GetBinNumber2D(getObs()->genBinning, gInfo, v);
        recBin = GetBinNumber2D(getObs()->recBinning, rInfo, v);
    }
 
    if (genBin > 0) v.gen->Fill(genBin, gInfo.weight);
 
    if (genBin > 0 && recBin > 0) {
        v.RM     ->Fill(genBin, recBin,                rInfo.weight);
        v.missOut->Fill(genBin,         gInfo.weight - rInfo.weight);
    } else if (genBin > 0 && recBin <= 0)
        v.missOut->Fill(genBin,         gInfo.weight               );
    else if (genBin <= 0 && recBin >= 0)
        v.fakeOut->Fill(        recBin,                rInfo.weight);
}

fillRec()

std::list< int > fillRec ( DistVariation &  )

overridevirtual

For a given variation, fills the detector level distribution, as well as a temporary histogram (reset at each event) to calculate the covariance matrix later on. The bin IDs are returned to avoid looping over many empty bins.

Reimplemented from Filler.

{
    rInfo = EventInfo(gEv, rEv, *recMuons, *recPhotons, v);
    int bin = 0;
    if (getObsDimension() == 1) {
        bin = GetBinNumber(getObs()->recBinning, rInfo, v);
    } else if (getObsDimension() == 2) {
        bin = GetBinNumber2D(getObs()->recBinning, rInfo, v);
    }
    if (bin <= 0) return {};
    v.tmp->Fill(bin, rInfo.weight);
    v.rec->Fill(bin, rInfo.weight);
    return {bin};
}

GetBinNumber()

int GetBinNumber	(	const TUnfoldBinning *	binning,
		const EventInfo< MUON, PHOTON > &	event,
		const Uncertainties::Variation &	v
	)		const

                                                                                                                                        {
    if (event.category != EventCategory::MuMuGamma) return 0;
    const double value = computeObservableValue(static_cast<const void*>(&event), v, std::is_same<MUON, GenMuon>::value);
    return binning->GetGlobalBinNumber(value);
}

GetBinNumber2D()

int GetBinNumber2D	(	const TUnfoldBinning *	binning,
		const EventInfo< MUON, PHOTON > &	event,
		const Uncertainties::Variation &	v
	)		const

                                                                                                                                          {
    if (event.category != EventCategory::MuMuGamma) return 0;
    const auto values = computeObservableValue2D(static_cast<const void*>(&event), v, std::is_same<MUON, GenMuon>::value);
    if (values.size() != 2) return 0;
    return binning->GetGlobalBinNumber(values[0], values[1]);
}

getObs()

virtual const Observable* getObs ( ) const

pure virtual

Implemented in DalitzFiller, MmmYFiller, MmmFiller, PtFiller, and DrFiller.

getObsDimension()

virtual int getObsDimension ( ) const

inlinevirtual

Reimplemented in DalitzFiller.

{ return 1; }

match()

void match ( )

inlineoverridevirtual

Implementation of matching algorithm.

Reimplemented from Filler.

{}

Member Data Documentation

genMuons

std::vector<GenMuon>* genMuons

genPhotons

std::vector<GenPhoton>* genPhotons

gEv

GenEvent* gEv

recMuons

std::vector<RecMuon>* recMuons

recPhotons

std::vector<RecPhoton>* recPhotons

rEv

RecEvent* rEv

rInfo

EventInfo<RecMuon, RecPhoton> rInfo

---

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

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