Momentum.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2013-2022  Laurent Forthomme
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CepGen_Physics_Momentum_h
#define CepGen_Physics_Momentum_h
 
#include <array>
#include <iosfwd>
 
namespace cepgen {
  class Vector;
  class Momentum : private std::array<double, 4> {
  public:
    explicit Momentum(double x = 0., double y = 0., double z = 0., double t = -1.);
    explicit Momentum(double* p);
    explicit Momentum(const Vector&);
 
    bool operator==(const Momentum&) const;                                         
    inline bool operator!=(const Momentum& oth) const { return !operator==(oth); }  
 
    //--- static definitions
 
    static Momentum fromPtEtaPhiE(double pt, double eta, double phi, double e = -1.);
    static Momentum fromPtEtaPhiM(double pt, double eta, double phi, double m);
    static Momentum fromPThetaPhiE(double p, double theta, double phi, double e = -1.);
    static Momentum fromPxPyPzE(double px, double py, double pz, double e);
    static Momentum fromPxPyPzM(double px, double py, double pz, double m);
    static Momentum fromPxPyYM(double px, double py, double rap, double m);
    static Momentum fromPtYPhiM(double pt, double rap, double phi, double m);
 
    //--- vector and scalar operators
 
    double threeProduct(const Momentum&) const;
    double fourProduct(const Momentum&) const;
    double crossProduct(const Momentum&) const;
    Momentum operator+(const Momentum&) const;
    Momentum& operator+=(const Momentum&);
    Momentum operator-() const;
    Momentum operator-(const Momentum&) const;
    Momentum& operator-=(const Momentum&);
    double operator*(const Momentum&) const;
    Momentum operator%(const Momentum&) const;
    double operator*=(const Momentum&);
    Momentum operator*(double c) const;
    Momentum& operator*=(double c);
    friend Momentum operator*(double, const Momentum&);
    friend std::ostream& operator<<(std::ostream&, const Momentum&);
 
    operator Vector() const;
 
    Momentum& betaGammaBoost(double gamma, double betagamma);
    Momentum& lorentzBoost(const Momentum& p);
 
    //--- setters and getters
 
    Momentum& setP(double px, double py, double pz, double e);
    Momentum& setP(double px, double py, double pz);
    Momentum& setPx(double px);
    inline double px() const { return (*this)[X]; }
    Momentum& setPy(double py);
    inline double py() const { return (*this)[Y]; }
    Momentum& setPz(double pz);
    inline double pz() const { return (*this)[Z]; }
    double pt() const;
    double pt2() const;
    Momentum transverse() const;
    std::array<double, 5> pVector() const;
    inline double p() const { return p_; }
    inline double p2() const { return p_ * p_; }
    Momentum& setEnergy(double);
    inline double energy() const { return (*this)[E]; }
    inline double energy2() const { return (*this)[E] * (*this)[E]; }
    double energyT() const;
    double energyT2() const;
    Momentum& setMass2(double);
    double mass2() const;
    Momentum& setMass(double);
    double mass() const;
    double massT2() const;
    double massT() const;
    double theta() const;
    double phi() const;
    double eta() const;
    double rapidity() const;
 
    double deltaEta(const Momentum&) const;
    double deltaPhi(const Momentum&) const;
    double deltaPt(const Momentum&) const;
    double deltaR(const Momentum&) const;
 
    double beta() const;
    double gamma2() const;
    double gamma() const;
 
    Momentum& computeEnergyFromMass(double on_shell_mass);
    Momentum& computePzFromMass(double on_shell_mass);
 
    Momentum& truncate(double tolerance = 1.e-10);
 
    Momentum& rotatePhi(double phi, double sign);
    Momentum& rotateThetaPhi(double theta_, double phi_);
    inline Momentum& mirrorX() {
      (*this)[X] *= -1.;
      return *this;
    }
    inline Momentum& mirrorY() {
      (*this)[Y] *= -1.;
      return *this;
    }
    inline Momentum& mirrorZ() {
      (*this)[Z] *= -1.;
      return *this;
    }
 
  private:
    enum coord_t { X = 0, Y = 1, Z = 2, E = 3 };
    Momentum& computeP();
    double p_{0.};
  };
}  // namespace cepgen
 
#endif