GenericObject.h

Go to the documentation of this file.

#pragma once
 
// C
#include <cmath>
 
// STD
#include <ostream>
#include <sstream>
#include <string_view>
#include <vector>
 
// ROOT
#include <Math/Vector4D.h>
 
// Darwin
#include <Variation.h>
#include <Weight.h>
 
namespace Darwin::Physics {
 
class WeightedObject {
protected:
    virtual ~WeightedObject () = default;
public:
    virtual double Weight (const Variation&) const = 0;
};
 
class AnonymousWeightableObject : public WeightedObject {
 
protected:
    virtual std::string_view WeightGroup () const = 0;
 
    AnonymousWeightableObject () = default;
    virtual ~AnonymousWeightableObject () = default;
 
public:
    Weights weights = {{1.,0}}; 
 
    virtual double Weight (const Variation& v) const
    try {
        if (v.Group() == WeightGroup()) {
            const struct Weight& w = weights.at(v.Index());
            if (w.i == v.Bit()) return w;
        }
        return weights.at(0);
    }
    catch (std::out_of_range& e) {
        std::stringstream s;
        s << e.what() << '\n'
          << v.Group() << ' ' << v.Name() << " is not available.";
        throw std::out_of_range(s.str());
    }
 
    virtual void Clear ()
    {
        weights = {{1.,0}};
    }
 
    bool operator== (const AnonymousWeightableObject& that) const
    {
        return this->weights == that.weights;
    }
};
 
using FourVector = ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<float>>;
 
class ScaledObject {
 
protected:
    virtual ~ScaledObject () = default;
 
public:
    virtual FourVector CorrP4 (const Variation& = nominal) const = 0;
    virtual float      CorrPt (const Variation& = nominal) const = 0;
 
    virtual float Rapidity (const Variation& = nominal) const = 0;
    virtual float AbsRap   (const Variation& = nominal) const = 0;
};
 
class AnonymousScalableObject : public ScaledObject {
 
protected:
    virtual std::string_view ScaleGroup () const = 0;
 
    AnonymousScalableObject () = default;
    virtual ~AnonymousScalableObject () = default;
 
public:
    FourVector p4 = FourVector(std::nan("pt"), std::nan("eta"), std::nan("phi"), std::nan("mass")); 
    std::vector<float> scales = {1.}; 
 
    FourVector CorrP4 (size_t i = 0) const { return p4      * scales.at(i); } 
    float      CorrPt (size_t i = 0) const { return p4.Pt() * scales.at(i); } 
 
    float Rapidity (const Variation& = nominal) const final { return       p4.Rapidity() ; }
    float AbsRap   (const Variation& = nominal) const final { return std::abs(Rapidity()); } 
 
    FourVector CorrP4 (const Variation& v) const final 
    {
        size_t i = v.Group() == ScaleGroup() ? v.Index() : 0;
        return AnonymousScalableObject::CorrP4(i);
    }
 
    float CorrPt (const Variation& v) const final 
    {
        size_t i = v.Group() == ScaleGroup() ? v.Index() : 0;
        return AnonymousScalableObject::CorrPt(i);
    }
 
    virtual void Clear ()
    {
        p4.SetCoordinates(std::nan("pt"), std::nan("eta"), std::nan("phi"), std::nan("mass"));
        scales = {1.};
    }
 
    bool operator== (const AnonymousScalableObject& that) const
    {
        return this->p4 == that.p4 && this->scales == that.scales;
    }
 
    bool operator< (const AnonymousScalableObject& that) const
    {
        return this->CorrPt() < that.CorrPt();
    }
 
    bool operator> (const AnonymousScalableObject& that) const
    {
        return this->CorrPt() > that.CorrPt();
    }
};
 
class AnonymousFinalStateObject : public AnonymousWeightableObject,
                                  public AnonymousScalableObject {
 
protected:
    AnonymousFinalStateObject () = default;
    virtual ~AnonymousFinalStateObject () = default;
 
public:
    void Clear () override
    {
        AnonymousWeightableObject::Clear();
        AnonymousScalableObject::Clear();
    }
 
    virtual bool operator== (const AnonymousFinalStateObject& that) const
    {
        return this->AnonymousWeightableObject::operator==((const AnonymousWeightableObject&) that)
            && this->AnonymousScalableObject  ::operator==((const AnonymousScalableObject  &) that);
    }
};
 
} // end of Darwin::Physics namespace
 
#if 0
inline std::ostream& operator<< (std::ostream& s, const Darwin::Physics::FourVector& p4)
{
    return s << '(' << p4.Pt() << ',' << p4.Eta() << ',' << p4.Phi() << ',' << p4.M() << ')';
}
#endif
 
inline std::ostream& operator<< (std::ostream& s, const Darwin::Physics::AnonymousWeightableObject& obj)
{
    for (const auto& w: obj.weights)
        s << w << ' ';
    return s;
}
 
inline std::ostream& operator<< (std::ostream& s, const Darwin::Physics::AnonymousScalableObject& obj)
{
    return s << obj.p4 << ' ';
    for (const auto& f: obj.scales)
        s << f << ' ';
    return s;
}
 
inline std::ostream& operator<< (std::ostream& s, const Darwin::Physics::AnonymousFinalStateObject& obj)
{
    return s << (const Darwin::Physics::AnonymousWeightableObject&) obj << "-- "
             << (const Darwin::Physics::AnonymousScalableObject  &) obj;
}