PtYFiller

#include <PtY.h>

Inheritance diagram for PtYFiller:

Collaboration diagram for PtYFiller:

Public Member Functions
	PtYFiller (const PtY &obs, TTreeReader &reader)
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::optional< TTreeReaderArray< GenJet > >	genJets
TTreeReaderArray< RecJet >	recJets
std::optional< TTreeReaderValue< GenEvent > >	gEv
TTreeReaderValue< RecEvent >	rEv
std::optional< JMEmatching< TTreeReaderArray< DAS::RecJet >, TTreeReaderArray< DAS::GenJet > > >	matching

Constructor & Destructor Documentation

PtYFiller()

PtYFiller	(	const PtY &	obs,
		TTreeReader &	reader
	)

Constructor.

    : obs(obs)
    , genJets(initOptionalBranch<decltype(genJets)>(reader, "genJets"))
    , recJets(reader, "recJets")
    , gEv(initOptionalBranch<decltype(gEv)>(reader, "genEvent"))
    , rEv(reader, "recEvent")
{
    JMEmatching<TTreeReaderArray<RecJet>,TTreeReaderArray<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.

Todo:

just write sth like std::optional<JMEmatching<TTreeReaderArray>>?

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::optional<TTreeReaderArray<GenJet> > genJets

gEv

std::optional<TTreeReaderValue<GenEvent> > gEv

matching

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

obs

PtY obs

Backreference to the observable.

recJets

TTreeReaderArray<RecJet> recJets

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/PtY.h
• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/Unfolding/src/PtY.cc