LorentzVector.hh

Go to the documentation of this file.

#pragma once

#include "external/delphes/delphes/Forward.hh"
#include "external/exroot/exroot/Forward.hh"

#include "boca/math/LorentzVectorBase.hh"

class TLorentzVector;

namespace boca
{

template<typename Value_>
class LorentzVector : public LorentzVectorBase<Value_>
{
    using LorentzVectorBase<Value_>::LorentzVectorBase;
};

template<>
class LorentzVector<Momentum> : public LorentzVectorBase<Momentum>
{

public:

    using LorentzVectorBase<Momentum>::LorentzVectorBase;

    LorentzVector();

//     LorentzVector(LorentzVectorBase<Momentum> const& lorentz_vector);

    LorentzVector(TLorentzVector const &lorentzvector);

    LorentzVector(exroot::Electron const &electron);

    LorentzVector(exroot::GenJet const &jet);

    LorentzVector(exroot::GenParticle const &particle);

    LorentzVector(exroot::Jet const &jet);

    LorentzVector(exroot::LHEFParticle const &particle);

    LorentzVector(exroot::Muon const &muon);

    LorentzVector(exroot::Photon const &photon);

    LorentzVector(exroot::Tau const &tau);


    void SetVectE(Vector3<Momentum> const& vector, const boca::Energy &energy);

    void SetVectM(Vector3<Momentum> const &spatial, boca::Mass const& mass);

    void SetPtEtaPhiM(Momentum const &pt, boca::Angle const &eta, boca::Angle const &phi, boca::Mass const &mass);

    void SetPtEtaPhiE(Momentum const &pt, boca::Angle const &eta, boca::Angle const &phi, boca::Energy const &energy);

    template<typename Particle>
    void LorentzVectorByEnergy(const Particle &particle)
    {
        SetPtEtaPhiE(particle.PT * GeV, particle.Eta * rad, particle.Phi * rad, particle.E * GeV);
    }

    template<typename Particle>
    void LorentzVectorByMass(const Particle &particle, boca::Mass const &mass)
    {
        SetPtEtaPhiM(particle.PT * GeV, particle.Eta * rad, particle.Phi * rad, mass);
    }

    template<typename Particle>
    void LorentzVectorByMass(const Particle &particle)
    {
        LorentzVectorByMass(particle, particle.Mass * GeV);
    }

    template<typename Particle>
    void LorentzVectorByM(const Particle &particle)
    {
        LorentzVectorByMass(particle, particle.M * GeV);
    }


    Momentum Px() const;

    Momentum Py() const;

    Momentum Pz() const;

    boca::Energy E() const;

    boca::Energy Energy() const;

    Momentum &Px() ;

    Momentum &Py() ;

    Momentum &Pz() ;

    boca::Energy &E() ;

    boca::Energy &Energy() ;


    Momentum P() const;

    EnergySquare Et2() const;

    boca::Energy Et() const;

    template<typename Value,  typename = OnlyIfNotQuantity<Value>>
    EnergySquare Et2(Vector3<Value> const &vector) const
    {
        return ScalarT2(vector);
    }

    template<typename Value,  typename = OnlyIfNotQuantity<Value>>
    boca::Energy Et(Vector3<Value> const &vector) const
    {
        return ScalarT(vector);
    }

    MassSquare M2() const;

    boca::Mass M() const;

    boca::Mass Mass() const;

    MassSquare Mt2() const;

    boca::Mass Mt() const;

    Momentum Pt() const;

    template<typename Value,  typename = OnlyIfNotQuantity<Value>>
    Momentum Pt(Vector3<Value> const &vector) const
    {
        return Perp(vector);
    }

};

template<>
class LorentzVector<Length> : public LorentzVectorBase<Length>
{
public:

    using LorentzVectorBase<Length>::LorentzVectorBase;

    LorentzVector();

    LorentzVector(::delphes::Track &track);

    LorentzVector(::delphes::GenParticle &particle);


    void Smearing(const boca::Length &amount);

};

}