fourvector.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2012-2019
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
#ifndef SRC_INCLUDE_FOURVECTOR_H_
#define SRC_INCLUDE_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_FOURVECTOR_H_