fourvector.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2012-2020
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
#ifndef SRC_INCLUDE_SMASH_FOURVECTOR_H_
#define SRC_INCLUDE_SMASH_FOURVECTOR_H_
 
#include <array>
#include <cmath>
#include <iosfwd>
#include <stdexcept>
 
#include "threevector.h"
 
namespace smash {
 
class FourVector {
 public:
  FourVector() : x_({0., 0., 0., 0.}) {}
 
  FourVector(double y0, double y1, double y2, double y3)
      : x_({y0, y1, y2, y3}) {}
 
  FourVector(double y0, ThreeVector vec)
      : x_({y0, vec.x1(), vec.x2(), vec.x3()}) {}
 
  double &operator[](std::size_t i) { return x_[i]; }
  double operator[](std::size_t i) const { return x_[i]; }
 
  double inline x0() const;
  void inline set_x0(double t);
  double inline x1() const;
  void inline set_x1(double x);
  double inline x2() const;
  void inline set_x2(double y);
  double inline x3() const;
  void inline set_x3(double z);
  ThreeVector inline threevec() const;
 
  ThreeVector inline velocity() const;
 
  double inline Dot(const FourVector &a) const;
 
  double inline sqr() const;
 
  double inline abs() const;
 
  double inline sqr3() const;
 
  double inline abs3() const;
 
  double inline tau() const;
 
  double inline eta() const;
 
  FourVector lorentz_boost(const ThreeVector &v) const;
 
  bool operator==(const FourVector &a) const;
 
  bool inline operator!=(const FourVector &a) const;
 
  bool inline operator<(const FourVector &a) const;
 
  bool inline operator>(const FourVector &a) const;
 
  bool inline operator<=(const FourVector &a) const;
 
  bool inline operator>=(const FourVector &a) const;
 
  FourVector inline operator+=(const FourVector &a);
 
  FourVector inline operator-=(const FourVector &a);
 
  FourVector inline operator*=(const double &a);
 
  FourVector inline operator/=(const double &a);
 
  using iterator = std::array<double, 4>::iterator;
  using const_iterator = std::array<double, 4>::const_iterator;
 
  iterator begin() { return x_.begin(); }
 
  iterator end() { return x_.end(); }
 
  const_iterator begin() const { return x_.begin(); }
  const_iterator end() const { return x_.end(); }
 
  const_iterator cbegin() const { return x_.cbegin(); }
  const_iterator cend() const { return x_.cend(); }
 
 private:
  std::array<double, 4> x_;
};
 
// Definitions of previous inline functions
 
double inline FourVector::x0(void) const { return x_[0]; }
 
void inline FourVector::set_x0(const double t) { x_[0] = t; }
 
double inline FourVector::x1() const { return x_[1]; }
 
void inline FourVector::set_x1(const double x) { x_[1] = x; }
 
double inline FourVector::x2() const { return x_[2]; }
 
void inline FourVector::set_x2(const double y) { x_[2] = y; }
 
double inline FourVector::x3() const { return x_[3]; }
 
void inline FourVector::set_x3(const double z) { x_[3] = z; }
 
ThreeVector inline FourVector::threevec() const {
  return ThreeVector(x_[1], x_[2], x_[3]);
}
 
ThreeVector inline FourVector::velocity() const { return threevec() / x0(); }
 
// use == operator for the inverse != check
bool inline FourVector::operator!=(const FourVector &a) const {
  return !(*this == a);
}
 
bool inline FourVector::operator<(const FourVector &a) const {
  return (x_[0] < a.x_[0]) && (x_[1] < a.x_[1]) && (x_[2] < a.x_[2]) &&
         (x_[3] < a.x_[3]);
}
 
// use < operator for the inverse by switching arguments
bool inline FourVector::operator>(const FourVector &a) const {
  return a < *this;
}
 
// use > operator for less equal
bool inline FourVector::operator<=(const FourVector &a) const {
  return !(*this > a);
}
 
// use < operator for greater equal
bool inline FourVector::operator>=(const FourVector &a) const {
  return !(*this < a);
}
 
FourVector inline FourVector::operator+=(const FourVector &a) {
  this->x_[0] += a.x_[0];
  this->x_[1] += a.x_[1];
  this->x_[2] += a.x_[2];
  this->x_[3] += a.x_[3];
  return *this;
}
 
// addition +operator uses +=
inline FourVector operator+(FourVector a, const FourVector &b) {
  a += b;
  return a;
}
 
FourVector inline FourVector::operator-=(const FourVector &a) {
  this->x_[0] -= a.x_[0];
  this->x_[1] -= a.x_[1];
  this->x_[2] -= a.x_[2];
  this->x_[3] -= a.x_[3];
  return *this;
}
 
// subtraction -operator uses -=
inline FourVector operator-(FourVector a, const FourVector &b) {
  a -= b;
  return a;
}
 
FourVector inline FourVector::operator*=(const double &a) {
  this->x_[0] *= a;
  this->x_[1] *= a;
  this->x_[2] *= a;
  this->x_[3] *= a;
  return *this;
}
 
// factor multiplication uses *=
inline FourVector operator*(FourVector a, double b) {
  a *= b;
  return a;
}
inline FourVector operator*(double b, FourVector a) {
  a *= b;
  return a;
}
 
FourVector inline FourVector::operator/=(const double &a) {
  const double a_inv = 1.0 / a;
  this->x_[0] *= a_inv;
  this->x_[1] *= a_inv;
  this->x_[2] *= a_inv;
  this->x_[3] *= a_inv;
  return *this;
}
 
// factor division uses /=
inline FourVector operator/(FourVector a, const double &b) {
  a /= b;
  return a;
}
 
double inline FourVector::Dot(const FourVector &a) const {
  return x_[0] * a.x_[0] - x_[1] * a.x_[1] - x_[2] * a.x_[2] - x_[3] * a.x_[3];
}
 
double inline FourVector::sqr() const {
  return x_[0] * x_[0] - x_[1] * x_[1] - x_[2] * x_[2] - x_[3] * x_[3];
}
 
double inline FourVector::abs() const {
  if (this->sqr() > -really_small) {
    return std::sqrt(std::abs(this->sqr()));
  } else {
    throw std::runtime_error(
        "Absolute value of 4-vector could not be "
        "determined, taking sqrt of negative value.");
  }
}
 
double inline FourVector::sqr3() const { return this->threevec().sqr(); }
 
double inline FourVector::abs3() const { return this->threevec().abs(); }
 
double inline FourVector::tau() const {
  return std::sqrt(this->x0() * this->x0() - this->x3() * this->x3());
}
 
double inline FourVector::eta() const {
  return std::atanh(this->x3() / this->x0());
}
 
std::ostream &operator<<(std::ostream &os, const FourVector &vec);
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_FOURVECTOR_H_