PtYFiller

#include <PtY.h>

Inheritance diagram for PtYFiller:

Collaboration diagram for PtYFiller:

Public Member Functions
	PtYFiller (const PtY &, Darwin::Tools::Flow &)
bool	selection (double pt, double absy)
std::list< int >	fillRec (DistVariation &) override
void	match () override
void	fillMC (DistVariation &) override
Public Member Functions inherited from Filler
virtual	~Filler ()=default

Public Attributes
PtY	obs
std::vector< GenJet > *	genJets
std::vector< RecJet > *	recJets
GenEvent *	gEv
RecEvent *	rEv
std::optional< DAS::JMEmatching< std::vector< DAS::RecJet >, std::vector< DAS::GenJet > > >	matching

Constructor & Destructor Documentation

PtYFiller()

PtYFiller	(	const PtY &	obs,
		Darwin::Tools::Flow &	flow
	)

Constructor.

    : obs(obs)
    , genJets(obs.isMC ? flow.GetBranchReadOnly<vector<GenJet>>("genJets") : nullptr)
    , recJets(flow.GetBranchReadOnly<vector<RecJet>>("recJets"))
    , gEv(obs.isMC ? flow.GetBranchReadOnly<GenEvent>("genEvent") : nullptr)
    , rEv(flow.GetBranchReadOnly<RecEvent>("recEvent"))
{
    JMEmatching<vector<RecJet>,vector<GenJet>>::maxDR = obs.maxDR;
}

Member Function Documentation

fillMC()

void fillMC ( DistVariation &  v )

overridevirtual

See Filler::fillMC

Todo:

use RM underflow?

Reimplemented from Filler.

{
    if (!obs.isMC)
        BOOST_THROW_EXCEPTION( runtime_error(__func__ + " should only be called for MC"s) );
 
    double rEvW = rEv->Weight(v),
           gEvW = gEv->Weight(v);
 
    for (const auto& [rec_it,gen_it]: matching->match_its) {
 
        double genpt = gen_it->CorrPt(v),
               geny  = gen_it->AbsRap();
 
        bool goodGen = selection(genpt, geny);
        auto igenbin = obs.genBinning->GetGlobalBinNumber(genpt,geny);
 
        double gJetW = gen_it->Weight(v);
 
        if (goodGen) v.gen->Fill(igenbin, gEvW * gJetW);
 
        double recpt = rec_it->CorrPt(v),
               recy  = rec_it->AbsRap();
 
        bool goodRec = selection(recpt, recy);
        auto irecbin = obs.recBinning->GetGlobalBinNumber(recpt,recy);
 
        double rJetW = rec_it->Weight(v);
 
        if      ( goodRec &&  goodGen) { v.RM         ->Fill(igenbin, irecbin, gEvW * gJetW *      rEvW * rJetW );
                                         v.missNoMatch->Fill(igenbin,          gEvW * gJetW * (1 - rEvW * rJetW)); }
        else if (!goodRec &&  goodGen)   v.missOut    ->Fill(igenbin,          gEvW * gJetW                     );
        else if ( goodRec && !goodGen)   v.fakeOut    ->Fill(         irecbin, gEvW * gJetW *      rEvW * rJetW );
    }
 
    for (const auto& gen_it: matching->miss_its) { 
 
        double pt = gen_it->CorrPt(v),
               y  = gen_it->AbsRap();
        if (!selection(pt,y)) continue;
 
        double gJetW = gen_it->Weight(v);
        auto igenbin = obs.genBinning->GetGlobalBinNumber(pt,y);
 
        v.missNoMatch->Fill(igenbin, gEvW * gJetW);
        v.gen        ->Fill(igenbin, gEvW * gJetW);
    }
 
    for (const auto& rec_it: matching->fake_its) {
 
        double pt = rec_it->CorrPt(v),
               y  = rec_it->AbsRap();
        if (!selection(pt,y)) continue;
 
        double rJetW = rec_it->Weight(v);
        auto irecbin = obs.recBinning->GetGlobalBinNumber(pt,y);
 
        v.fakeNoMatch->Fill(irecbin, gEvW * rEvW * rJetW);
    }
}

fillRec()

list< int > fillRec ( DistVariation &  v )

overridevirtual

See Filler::fillRec

Reimplemented from Filler.

{
    list<int> binIDs;
 
    double evW = rEv->Weight(v);
    if (obs.isMC) evW *= gEv->Weight(v);
 
    for (const RecJet& recJet: *recJets) {
        double pt = recJet.CorrPt(v),
               y  = recJet.AbsRap();
        if (!selection(pt,y)) continue;
 
        auto irecbin = obs.recBinning->GetGlobalBinNumber(pt,y);
 
        if (find(binIDs.begin(), binIDs.end(), irecbin) == binIDs.end())
            binIDs.push_back(irecbin);
 
        double jetW = recJet.Weight(v);
        v.tmp->Fill(irecbin, evW * jetW);
        v.rec->Fill(irecbin, evW * jetW);
    }
    return binIDs;
}

match()

void match ( )

overridevirtual

Using JME matching.

Reimplemented from Filler.

{
    matching.reset();
    matching.emplace(*recJets, *genJets);
}

selection()

bool selection ( double  pt, double  absy  )

inline

Jet selection.

    {
        return pt >= minpt && pt < maxpt && absy < maxy;
    }

Member Data Documentation

genJets

std::vector<GenJet>* genJets

gEv

GenEvent* gEv

matching

std::optional<DAS::JMEmatching<std::vector<DAS::RecJet>, std::vector<DAS::GenJet> > > matching

obs

PtY obs

Backreference to the observable.

recJets

std::vector<RecJet>* recJets

rEv

RecEvent* rEv

---

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

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