Transverse.h

// -*- C++ -*-
//
// Transverse.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_Transverse_H
#define ThePEG_Transverse_H
// This is the declaration of the Transverse class.
 
#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/Vectors/Lorentz5Vector.h"
#include "Transverse.fh"
 
namespace ThePEG {
 
template <typename Value>
class Transverse: public pair<Value,Value> {
 
public:
 
  using Value2 = decltype(sqr(std::declval<Value>()));
 
  using BasePair = pair<Value,Value>;
 
public:
 
  Transverse() : BasePair(Value(), Value()) {}
 
  Transverse(const BasePair & p) : BasePair(p) {}
 
  Transverse(Value x, Value y) : BasePair(x, y) {}
 
  Transverse(const ThreeVector<Value> & p) : BasePair(p.x(), p.y()) {}
 
  Transverse(const LorentzVector<Value> & p) : BasePair(p.x(), p.y()) {}
 
  Transverse(const Lorentz5Vector<Value> & p) : BasePair(p.x(), p.y()) {}
 
  const Transverse & operator=(const BasePair & p) {
    BasePair::operator=(p);
    return *this;
  }
 
  const Transverse & operator=(const ThreeVector<Value> & p) {
    BasePair::operator=(BasePair(p.x(), p.y()));
    return *this;
  }
 
  const Transverse & operator=(const LorentzVector<Value> & p) {
    BasePair::operator=(BasePair(p.x(), p.y()));
    return *this;
  }
 
  const Transverse & operator=(const Lorentz5Vector<Value> & p) { 
    BasePair::operator=(BasePair(p.x(), p.y()));
    return *this;
  }
 
 
  Transverse operator-() const { return Transverse(-x(), -y()); }
 
  Transverse operator-(const Transverse & pt) const { 
    return Transverse(x() - pt.x(), y() - pt.y()); 
  }
 
  Transverse & operator-=(const Transverse & pt) {
    BasePair::first -= pt.x();
    BasePair::second -= pt.y();
    return *this;
  }
 
  Transverse operator+(const Transverse & pt) const {
    return Transverse(x() + pt.x(), y() + pt.y());
  }
 
  Transverse & operator+=(const Transverse & pt) {
    BasePair::first += pt.x();
    BasePair::second += pt.y();
    return *this;
  }
 
  inline Transverse & operator*=(double a) {
    BasePair::first *= a;
    BasePair::second *= a;
    return *this;
  }
 
  inline Transverse & operator/=(double a) {
    BasePair::first /= a;
    BasePair::second /= a;
    return *this;
  }
 
  Value x() const { return BasePair::first; }
 
  Value y() const { return BasePair::second; }
 
  Value2 pt2() const { return sqr(x()) + sqr(y()); }
 
  Value pt() const { return sqrt(pt2()); }
 
  double phi() const { return atan2(y(), x()); }
 
};
 
template <typename OStream, typename T, typename UT>
void ounitstream(OStream & os, const Transverse<T> & p, UT & u) {
  os << ounit(p.x(), u) << ounit(p.y(), u);
}
 
template <typename IStream, typename T, typename UT>
void iunitstream(IStream & is, Transverse<T> & p, UT & u) {
  T x, y;
  is >> iunit(x, u) >> iunit(y, u);
  p = Transverse<T>(x, y);
}
 
template <typename Value>
inline Transverse<Value>
operator*(Transverse<Value> a, double b) {
  return a *= b;
}
 
template <typename Value>
inline Transverse<Value>
operator*(double b, Transverse<Value> a) {
  return a *= b;
}
 
template <typename ValueA, typename ValueB>
inline auto operator*(ValueB a, const Transverse<ValueA> & v) 
-> Transverse<decltype(a*v.x())>
{
  return {a*v.x(), a*v.y()};
}
 
template <typename ValueA, typename ValueB>
inline auto operator*(const Transverse<ValueA> & v, ValueB a) 
-> Transverse<decltype(a*v.x())>
{
  return {a*v.x(), a*v.y()};
}
 
template <typename Value>
inline Transverse<double>
operator/(const Transverse<Value> & v, Value a) {
  return {v.x()/a, v.y()/a};
}
 
template <typename ValueA, typename ValueB>
inline auto operator/(const Transverse<ValueA> & v, ValueB b) 
-> Transverse<decltype(v.x()/b)>
{
  return {v.x()/b, v.y()/b};
}
 
}
 
#endif /* ThePEG_Transverse_H */