ZmmY.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <list>
 
#if !defined(__CLING__) || defined(__ROOTCLING__)
#include "Core/Objects/interface/Event.h"
#include "Core/Objects/interface/Lepton.h"
#include "Core/Objects/interface/Photon.h"
#include "Core/Unfolding/interface/Observable.h"
#include "Core/Unfolding/interface/ZmmYCommon.h"
#endif
 
namespace DAS::Unfolding::ZmmY {
 
#if !defined(__CLING__) || defined(__ROOTCLING__)
 
// Base class for ZmmY observable fillers
struct ZmmYFiller : public Filler {
    // Common event info
    EventInfo<RecMuon, RecPhoton> rInfo;
    std::vector<GenMuon> * genMuons;
    std::vector<RecMuon> * recMuons;
    std::vector<GenPhoton> * genPhotons;
    std::vector<RecPhoton> * recPhotons;
    GenEvent * gEv;
    RecEvent * rEv;
 
    ZmmYFiller(Darwin::Tools::Flow& flow, bool isMC)
        : 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"))
    {}
 
    // Unified GetBinNumber method for both Rec and Gen events (1D and 2D)
    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;
 
    // Pure virtual getter for the observable
    virtual const Observable* getObs() const = 0;
 
    // Virtual for dimension of the observable
    virtual int getObsDimension() const { return 1; }
 
    // fillRec and fillMC use GetBinNumber and getObs
    std::list<int> fillRec(DistVariation& v) override;
    void match() override {}
    void fillMC(DistVariation& v) override;
 
protected:
    // Virtual method for observable value calculation (1D and 2D)
    virtual double computeObservableValue(const void* event, const Uncertainties::Variation& v, bool isGen) const {
        return 0.0;
    }
    virtual std::vector<double> computeObservableValue2D(const void* event, const Uncertainties::Variation& v, bool isGen) const {
        return {};
    }
};
 
// Binning
static const std::vector<double> recDrBins{0.05, 0.075, 0.1, 0.125, 0.15, 0.225, 0.3, 0.4, 0.5, 0.65, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.5, 3.0},
                                 genDrBins{0.05, 0.1, 0.15, 0.3, 0.5, 0.8, 1.2, 1.6, 2.0, 3.0};
static const int nRecDrBins = recDrBins.size()-1,
                 nGenDrBins = genDrBins.size()-1;
 
static const std::vector<double> recPtBins{5, 7.5, 10, 12.5, 15, 17.5, 20, 22.5, 25, 27.5, 30, 35, 40, 45, 50, 62, 75, 87, 100},
                                 genPtBins{5, 10, 15, 20, 25, 30, 40, 50, 75, 100};
static const int nRecPtBins = recPtBins.size()-1,
                 nGenPtBins = genPtBins.size()-1;
 
static const std::vector<double> recMassMMBins{30, 31.5, 33, 34.5, 36, 37.5, 39, 40.5, 42, 43.5, 45, 46.5, 48, 49.5, 51, 52.5, 54, 55.5, 57, 58.5, 60, 61.5, 63, 64.5, 66, 67.5, 69, 70.5, 72, 73.5, 75, 76.5, 78, 79.5, 81, 82.5, 84, 85.5, 87},
                                 genMassMMBins{30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87};
static const int nRecMassMMBins = recMassMMBins.size()-1,
                 nGenMassMMBins = genMassMMBins.size()-1;
 
static const std::vector<double> recMassMMGBins{30, 31.5, 33, 34.5, 36, 37.5, 39, 40.5, 42, 43.5, 45, 46.5, 48, 49.5, 51, 52.5, 54, 55.5, 57, 58.5, 60, 61.5, 63, 64.5, 66, 67.5, 69, 70.5, 72, 73.5, 75, 76.5, 78, 79.5, 81, 82.5, 84, 85.5, 87, 88.5, 90, 91.5, 93, 94.5, 96, 97.5, 99, 100.5, 102, 103.5, 105, 106.5, 108, 109.5, 111},
                                 genMassMMGBins{30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99, 102, 105, 108, 111};
static const int nRecMassMMGBins = recMassMMGBins.size()-1,
                 nGenMassMMGBins = genMassMMGBins.size()-1;
 
static const std::vector<double> recM2RatioBins{0.000, 0.250, 0.300, 0.350, 0.400, 0.450, 0.500, 0.550, 0.600, 0.650, 1.000},
                                 genM2RatioBins{0.000, 0.300, 0.400, 0.500, 0.600, 1.000},
                                 recMMuGamma2Bins{0.000, 0.025, 0.050, 0.075, 0.100, 0.125, 0.150, 0.175, 0.200, 0.225, 0.250, 0.275, 0.300, 0.325, 0.350, 0.375, 0.400, 0.425, 0.450, 0.475, 0.500},
                                 genMMuGamma2Bins{0.000, 0.050, 0.100, 0.150, 0.200, 0.250, 0.300, 0.350, 0.400, 0.450, 0.500};
static const int nRecM2RatioBins = recM2RatioBins.size()-1,
                 nGenM2RatioBins = genM2RatioBins.size()-1,
                 nRecMMuGamma2Bins = recMMuGamma2Bins.size()-1,
                 nGenMMuGamma2Bins = genMMuGamma2Bins.size()-1;
 
// Dr observable, filler and template helper for calculation
struct Dr final : public Observable {
    Dr ();
    std::unique_ptr<Filler> getFiller (Darwin::Tools::Flow&) const override;
};
struct DrFiller final : public ZmmYFiller {
    const Dr& obs;
    DrFiller (const Dr&, Darwin::Tools::Flow&);
    double computeObservableValue(const void* event, const Uncertainties::Variation& v, bool isGen) const override;
    const Observable* getObs() const override { return &obs; }
private:
    template<typename MUON, typename PHOTON>
    double computeDr(const EventInfo<MUON, PHOTON>& event, const Uncertainties::Variation& v) const;
};
 
// Pt observable, filler and template helper for calculation
struct Pt final : public Observable {
    Pt ();
    std::unique_ptr<Filler> getFiller (Darwin::Tools::Flow&) const override;
};
struct PtFiller final : public ZmmYFiller {
    const Pt& obs;
    PtFiller (const Pt&, Darwin::Tools::Flow&);
    double computeObservableValue(const void* event, const Uncertainties::Variation& v, bool isGen) const override;
    const Observable* getObs() const override { return &obs; }
private:
    template<typename MUON, typename PHOTON>
    double computePt(const EventInfo<MUON, PHOTON>& event, const Uncertainties::Variation& v) const;
};
 
// Mmm observable, filler and template helper for calculation
struct Mmm final : public Observable {
    Mmm ();
    std::unique_ptr<Filler> getFiller (Darwin::Tools::Flow&) const override;
};
struct MmmFiller final : public ZmmYFiller {
    const Mmm& obs;
    MmmFiller (const Mmm&, Darwin::Tools::Flow&);
    double computeObservableValue(const void* event, const Uncertainties::Variation& v, bool isGen) const override;
    const Observable* getObs() const override { return &obs; }
private:
    template<typename MUON, typename PHOTON>
    double computeMmm(const EventInfo<MUON, PHOTON>& event, const Uncertainties::Variation& v) const;
};
 
// MmmY observable, filler and template helper for calculation
struct MmmY final : public Observable {
    MmmY ();
    std::unique_ptr<Filler> getFiller (Darwin::Tools::Flow&) const override;
};
struct MmmYFiller final : public ZmmYFiller {
    const MmmY& obs;
    MmmYFiller (const MmmY&, Darwin::Tools::Flow&);
    double computeObservableValue(const void* event, const Uncertainties::Variation& v, bool isGen) const override;
    const Observable* getObs() const override { return &obs; }
private:
    template<typename MUON, typename PHOTON>
    double computeMmmY(const EventInfo<MUON, PHOTON>& event, const Uncertainties::Variation& v) const;
};
 
// Dalitz observable, filler and template helper for calculation
struct Dalitz final : public Observable {
    Dalitz ();
    std::unique_ptr<Filler> getFiller (Darwin::Tools::Flow&) const override;
};
struct DalitzFiller final : public ZmmYFiller {
    const Dalitz& obs;
    DalitzFiller (const Dalitz&, Darwin::Tools::Flow&);
    std::vector<double> computeObservableValue2D(const void* event, const Uncertainties::Variation& v, bool isGen) const override;
    const Observable* getObs() const override { return &obs; }
    int getObsDimension() const override { return 2; }
private:
    template<typename MUON, typename PHOTON>
    std::vector<double> computeDalitz(const EventInfo<MUON, PHOTON>& event, const Uncertainties::Variation& v) const;
};
 
#endif
 
} // end of DAS::Unfolding::ZmmY namespace