BFFiller

#include <BF.h>

Inheritance diagram for BFFiller:

Collaboration diagram for BFFiller:

Public Member Functions
	BFFiller (const BF &obs, TTreeReader &reader)
std::list< int >	fillRec (DistVariation &) override
void	match () override
void	fillMC (DistVariation &) override
Public Member Functions inherited from Filler
virtual	~Filler ()=default

Public Attributes
BF	obs
std::optional< TTreeReaderArray< GenMuon > >	genMuons
std::optional< TTreeReaderArray< GenPhoton > >	genPhotons
TTreeReaderArray< RecMuon >	recMuons
TTreeReaderArray< RecPhoton >	recPhotons
std::optional< TTreeReaderValue< GenEvent > >	gEv
TTreeReaderValue< RecEvent >	rEv

Private Attributes
std::optional< int >	irecbin
std::optional< float >	recZW

Constructor & Destructor Documentation

BFFiller()

BFFiller	(	const BF &	obs,
		TTreeReader &	reader
	)

Constructor.

    : obs(obs)
    , genMuons(initOptionalBranch<decltype(genMuons)>(reader, "genMuons"))
    , genPhotons(initOptionalBranch<decltype(genPhotons)>(reader, "genPhotons"))
    , recMuons(reader, "recMuons")
    , recPhotons(reader, "recPhotons")
    , gEv(initOptionalBranch<decltype(gEv)>(reader, "genEvent"))
    , rEv(reader, "recEvent")
{
}

Member Function Documentation

fillMC()

void fillMC ( DistVariation &  v )

overridevirtual

See Filler::fillMC

Todo:

no weight for gen photons?

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);
 
    optional<int> igenbin;
    optional<double> genZW;
 
    if (auto dimuon = selection(*genMuons, v); dimuon) {
 
        float mass = dimuon.CorrP4(v).M();
        genZW = dimuon.Weight(v);
 
        if (goodMass(mass)) { // fill dimuon mass
            igenbin = obs.genBinning->GetGlobalBinNumber(*obs.process, 1.);
            if (*igenbin == 0) cerr << red << mass << '\n' << def;
        }
        else if (mass >= 40 && genPhotons->GetSize() > 0) {
 
            bool found = false;
            FourVector p4 = dimuon.CorrP4(v);
            // note: here, we cannot use the `DAS::Di` template
            // since the number of additional photons is variable
            for (size_t i = 0; i < genPhotons->GetSize(); ++i) { // issue with iterators --> loop by hand
                const GenPhoton& p = genPhotons->At(i);
                if (!p.zAncestor) continue;
                if (p.p4.Pt() < 20) continue;
                if (abs(p.p4.Eta()) >= 2.5)  continue;
 
                p4 += p.CorrP4(v);
                found = true;
            }
 
            mass = p4.M();
            if (found && goodMass(mass)) {
                igenbin = obs.genBinning->GetGlobalBinNumber(*obs.process, 2.);
                if (*igenbin == 0) cerr << red << mass << '\n' << def;
            }
        }
    }
 
    if (igenbin) v.gen->Fill(*igenbin, gEvW * *genZW);
 
    if (igenbin && irecbin) {
        // Good events
        v.RM     ->Fill(*igenbin, *irecbin, gEvW * *genZW *      rEvW * *recZW);
        v.missOut->Fill(*igenbin,           gEvW * *genZW * (1 - rEvW * *recZW));
    } else if (igenbin && !irecbin)
        // Miss
        v.missOut->Fill(*igenbin,           gEvW * *genZW                      );
    else if (!igenbin && irecbin)
        // Fake
        v.fakeOut->Fill(          *irecbin, gEvW *                rEvW * *recZW);
}

fillRec()

list< int > fillRec ( DistVariation &  v )

overridevirtual

See Filler::fillRec

Reimplemented from Filler.

{
    irecbin.reset();
    recZW.reset();
 
    auto dimuon = selection(recMuons, v);
    if (!dimuon) return {};
 
    double evW = rEv->Weight(v);
    if (obs.isMC) evW *= (*gEv)->Weight(v);
 
    float mass = dimuon.CorrP4(v).M();
    recZW = dimuon.Weight(v);
 
    if (goodMass(mass)) { // fill dimuon mass
        irecbin = obs.recBinning->GetGlobalBinNumber(mass, 1.);
        if (*irecbin == 0) cerr << red << mass << '\n' << def;
 
        v.tmp->Fill(*irecbin, evW * *recZW);
        v.rec->Fill(*irecbin, evW * *recZW);
 
        return {*irecbin};
    }
 
    if (mass >= 40 && recPhotons.GetSize() > 0) { // fill dimuon+gamma mass
 
        bool found = false;
        FourVector p4 = dimuon.CorrP4(v);
        // note: here, we cannot use the `DAS::Di` template
        // since the number of additional photons is variable
        for (size_t i = 0; i < recPhotons.GetSize(); ++i) { // issue with iterators --> loop by hand
            const RecPhoton& p = recPhotons.At(i);
 
            if (p.CorrPt(v) < 20) continue;
            if (abs(p.p4.Eta()) > 2.5) continue;
 
            bool tooClose = false;
            for (size_t j = 0; j < recMuons.GetSize(); ++j) {
                const RecMuon& m = recMuons.At(j);
                using ROOT::Math::VectorUtil::DeltaR;
                tooClose |= DeltaR(p.p4,m.p4) < 0.1;
            }
            if (tooClose) continue;
 
            p4 += p.CorrP4(v);
            *recZW *= p.Weight(v);
            found = true;
        }
 
        mass = p4.M();
        if (found && goodMass(mass)) {
            irecbin = obs.recBinning->GetGlobalBinNumber(mass, 2.);
            if (*irecbin == 0) cerr << red << mass << '\n' << def;
 
            v.tmp->Fill(*irecbin, evW * *recZW);
            v.rec->Fill(*irecbin, evW * *recZW);
 
            return {*irecbin};
        }
    }
 
    return {};
}

match()

void match ( )

inlineoverridevirtual

Todo:

Needed?

Reimplemented from Filler.

{}

Member Data Documentation

genMuons

std::optional<TTreeReaderArray<GenMuon> > genMuons

genPhotons

std::optional<TTreeReaderArray<GenPhoton> > genPhotons

gEv

std::optional<TTreeReaderValue<GenEvent> > gEv

irecbin

std::optional<int> irecbin

private

obs

BF obs

Backreference to the observable.

recMuons

TTreeReaderArray<RecMuon> recMuons

recPhotons

TTreeReaderArray<RecPhoton> recPhotons

recZW

std::optional<float> recZW

private

rEv

TTreeReaderValue<RecEvent> rEv

---

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

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