Di.h

Go to the documentation of this file.

#pragma once
 
// C
#include <cmath>
 
// STD
#include <algorithm>
#include <iostream>
#include <type_traits>
 
// ROOT
#include <Math/VectorUtil.h>
 
// Darwin
#include <colours.h>
#include <Variation.h>
#include <GenericObject.h>
 
namespace Darwin::Physics {
 
template<typename Obj1, typename Obj2> struct Di : public std::pair<Obj1*, Obj2*>,
                                                   public ScaledObject,
                                                   public WeightedObject {
 
    using std::pair<Obj1*, Obj2*>::pair;   
    using std::pair<Obj1*, Obj2*>::first,  
          std::pair<Obj1*, Obj2*>::second; 
 
    explicit operator bool () const { return first && second; }
 
    inline void Clear () { first = nullptr; second = nullptr; }
 
    inline FourVector CorrP4 (const Variation& v = nominal) const override { return first->CorrP4(v) + second->CorrP4(v); }
    inline float      CorrPt (const Variation& v = nominal) const override { return CorrP4(v).Pt(); }
 
    inline float Rapidity (const Variation& v = nominal) const override { return CorrP4(v).Rapidity(); }
    inline float AbsRap   (const Variation& v = nominal) const override { return std::abs(Rapidity(v)); }
 
    inline float DeltaEta (const Variation& v = nominal) const { return second->CorrP4(v).Eta() - first->CorrP4(v).Eta(); }
    inline float DeltaPhi (const Variation& v = nominal) const { return ROOT::Math::VectorUtil::DeltaPhi(first->CorrP4(v),
                                                                                                         second->CorrP4(v)); }
    inline float DeltaR   (const Variation& v = nominal) const { return ROOT::Math::VectorUtil::DeltaR  (first->CorrP4(v),
                                                                                                         second->CorrP4(v)); }
 
    inline float Yboost (const Variation& v = nominal) const { return (first->Rapidity(v) + second->Rapidity(v))/2; }
    inline float Ystar  (const Variation& v = nominal) const { return (first->Rapidity(v) - second->Rapidity(v))/2; }
 
    inline float Ymax (const Variation& v = nominal) const { return std::max(first->AbsRap(v), second->AbsRap(v)); }
    inline float HT   (const Variation& v = nominal) const { return (first->CorrPt(v) + second->CorrPt(v))/2; }
 
    inline double Weight (const Variation& v = nominal) const override { return first->Weight(v) * second->Weight(v); }
 
    Di () = default;
    virtual ~Di () = default;
};
 
} // end of Darwin::Physics namespace
 
template<typename Obj1, typename Obj2,
    class = typename std::enable_if_t<std::is_base_of_v<Darwin::Physics::ScaledObject, Obj1>>,
    class = typename std::enable_if_t<std::is_base_of_v<Darwin::Physics::ScaledObject, Obj2>>>
inline auto operator+ (Obj1& o1, Obj2& o2)
{
    return Darwin::Physics::Di<Obj1,Obj2>{&o1,&o2};
}
 
template<typename Obj1, typename Obj2>
std::ostream& operator<< (std::ostream& s, const Darwin::Physics::Di<Obj1,Obj2>& di)
{
    if (di)
        return s << '[' << *di.first << ", " << *di.second << "] = " << di.CorrP4();
    else
        return s << red << "invalid system" << normal;
}