Objects.h

Go to the documentation of this file.

#ifndef DARWIN_EVENT_H
#define DARWIN_EVENT_H
 
#include <iostream>
#include <vector>
#include <Math/PtEtaPhiM4D.h>
#include <Math/Cylindrical3D.h>
#include <Math/Polar2D.h>
#include <TRandom3.h>
 
namespace Darwin::Physics {
 
struct Event {
    std::vector<float> weights;
    virtual float weight () const = 0; 
    virtual void clear (); 
    Event ();
    virtual ~Event () = default;
};
 
struct GenEvent : public Event {
    static size_t iWgt; 
    float weight () const final; 
    int process; 
    float hard_scale; 
    void clear () override; 
    GenEvent ();
};
 
struct RecEvent : public Event {
    static size_t iWgt; 
    float weight () const final; 
    int fill, 
        runNo, 
        lumi;  
    unsigned long long evtNo; 
    void clear () override; 
    RecEvent ();
};
 
struct Trigger {
    std::vector<bool> Bit; 
    std::vector<int> PreHLT,   
                     PreL1min, 
                     PreL1max; 
 
    void clear (); 
};
 
struct MET : public ROOT::Math::Polar2D<float> {
    float SumEt; 
    virtual void clear (); 
    MET ();
    virtual ~MET () = default;
};
 
//struct GenMET : public MET {
//  // TODO
//    void clear () override; //!< resets all members to the same values as in the constructor
//};
 
struct RecMET : public MET {
    // TODO: both corr and uncorr?
    std::vector<bool> Bit; 
    void clear () override; 
};
 
struct PileUp {
 
    static float MBxsec, 
                 MBxsecRelUnc; 
 
    float rho; 
    int nVtx; 
    float trpu; 
    int intpu; 
    float pthatMax; 
 
    float GetTrPU (const char = '0') const; 
    float GetIntPU (const char = '0') const; 
    float GetIntPU (TRandom3&, const char = '0') const; 
    void clear (); 
 
    PileUp ();
};
 
struct Vertex : public ROOT::Math::Cylindrical3D<float> {
    float chi2; 
    int ndf; 
    bool fake; 
 
    void clear (); 
    Vertex ();
};
 
struct FourVector : public ROOT::Math::PtEtaPhiM4D<float> {
 
    virtual float Rapidity () const; 
    virtual float AbsRap () const; 
 
    virtual void clear (); 
 
    virtual FourVector& operator+= (const ROOT::Math::PtEtaPhiM4D<float>&);
    virtual FourVector operator+ (const ROOT::Math::PtEtaPhiM4D<float>&) const;
 
    FourVector () = default;
    FourVector (const ROOT::Math::PtEtaPhiM4D<float>&);
    virtual ~FourVector () = default;
};
 
struct Jet : public FourVector {
 
    static float R; 
 
    char pdgID, 
         nBHadrons, 
         nCHadrons; 
 
    std::vector<float> scales, 
                       weights; 
 
    virtual float CorrPt  () const = 0; 
    virtual float CorrEta () const = 0; 
    // TODO: mass??
 
    virtual Jet& operator+= (const Jet&);
 
    virtual float weight () const = 0; 
    void clear () override; 
 
    Jet (); 
    virtual ~Jet () = default; 
};
 
struct GenJet : public Jet {
 
    static size_t iWgt, 
                  iScl; 
 
    float weight () const final; 
    float CorrPt  () const final; 
    float CorrEta () const final; 
 
    virtual GenJet operator+ (const GenJet&) const; 
 
    void clear () override; 
    ~GenJet () = default;
};
 
struct RecJet : public Jet {
 
    static size_t iWgt, 
                  iScl; 
 
    float weight () const final; 
    float CorrPt  () const final; 
    float CorrEta () const final; 
 
    virtual RecJet operator+ (const RecJet&) const; 
 
    float area; 
    std::vector<std::vector<float>> tags; 
 
    void clear () override; 
    RecJet ();
    ~RecJet () = default;
};
 
//template<typename First, typename Second> struct Comb {
//
//    First& first; //!< first decay product (typically with the highest energy)
//    Second& second; //!< second decay product
//
//    FourVector operator() () const //!< creates a 4-vec on the fly, using `iScl` internally
//    {
//        FourVector c1 = first(),
//                   c2 = second();
//        return c1 + c2;
//    }
//
//    void clear ()
//    {
//        first.clear();
//        second.clear();
//    }
//
//    inline float weight () //!< weight product of components, using `iWgt` internally
//    {
//        return first.weight() * second.weight();
//    }
//};
 
//template<typename Jet> Dijet : public Comb<Jet,Jet>, public FourVector {
//
//    Dijet (Jet& jet1, Jet& jet2) :
//        Comb<Jet,Jet>{jet1, jet2},
//        FourVector(Comb<Jet,Jet>::operator()()) 
//    { }
//    
//    inline float Ymax () { return max(first.AbsRap(), second.AbsRap()); }
//    inline float Dphi () { return DeltaPhi(first.Phi(), second.Phi()); }
//    inline float PtAve () { return Pt()/2; }
//
//};
//
//typedef Dijet<RecJet> RecDijet;
//typedef Dijet<GenJet> GenDijet;
 
//template<typename First, typename Second> struct CombFit : public Comb<First,Second> {
//    bool valid; //!< flag for convergence
//    float chi2; //!< output from fit
//    int ndf; //!< number of degrees of freedom
//    // TODO: covariance, etc.?
//};
//
//typedef Comb<RecJet,RecJet> RecVecBosonHad;
//typedef Comb<GenJet,GenJet> GenVecBosonHad;
//
//typedef Comb<RecVecBosonHad,RecJet> RecTop;
//typedef Comb<RecVecBosonHad,GenJet> GenTop;
//
//typedef CombFit<RecVecBosonHad,RecJet> RecTTbarFullHad;
//typedef CombFit<GenVecBosonHad,GenJet> GenTTbarFullHad;
 
}
 
std::ostream& operator<< (std::ostream&, const Darwin::Physics::GenEvent&);
 
std::ostream& operator<< (std::ostream&, const Darwin::Physics::RecEvent&);
 
std::ostream& operator<< (std::ostream&, const Darwin::Physics::FourVector&);
 
std::ostream& operator<< (std::ostream&, const Darwin::Physics::Jet&);
 
#endif