SpinOneLorentzRotation.h

// -*- C++ -*-
//
// SpinOneLorentzRotation.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_SpinOneLorentzRotation_H
#define ThePEG_SpinOneLorentzRotation_H
 
#include "ThePEG/Helicity/HelicityDefinitions.h"
#include "ThePEG/Helicity/LorentzRank3Tensor.fh"
#include "ThePEG/Helicity/LorentzTensor.fh"
#include "ThePEG/Helicity/LorentzRSSpinor.fh"
#include "ThePEG/Helicity/LorentzRSSpinorBar.fh"
#include "ThreeVector.h"
#include <vector>
 
namespace ThePEG {
 
class SpinOneLorentzRotation {
public:
 
 
  SpinOneLorentzRotation() {
    xx_() = yy_() = zz_() = tt_() = 1.0;
  }
  
  SpinOneLorentzRotation (double bx, double by, double bz, double gamma=-1.) 
  {
    setBoost(bx,by,bz,gamma);
  }
 
  explicit SpinOneLorentzRotation (const Boost & b, double gamma=-1.)
  {
    setBoost(b.x(), b.y(), b.z(),gamma);
  }
 
  bool isIdentity() const;
 
  SpinOneLorentzRotation inverse() const;
 
  SpinOneLorentzRotation & invert() { return *this = inverse(); }
 
  std::ostream & print( std::ostream & os ) const;
 
 
  SpinOneLorentzRotation & setBoost (double bx, double by, double bz, double gamma=-1.);
 
  SpinOneLorentzRotation & setBoost (const Boost & b, double gamma=-1.) {
    return setBoost(b.x(), b.y(), b.z(),gamma); 
  }
 
  SpinOneLorentzRotation & setRotate(double delta, const Axis & axis);
 
  SpinOneLorentzRotation & setRotateX (double angle);
 
  SpinOneLorentzRotation & setRotateY (double angle);
 
  SpinOneLorentzRotation & setRotateZ (double angle);
  
 
 
  double xx() const { return matrix_[ 0]; }
 
  double xy() const { return matrix_[ 1]; }
 
  double xz() const { return matrix_[ 2]; }
 
  double xt() const { return matrix_[ 3]; }
 
  double yx() const { return matrix_[ 4]; }
 
  double yy() const { return matrix_[ 5]; }
 
  double yz() const { return matrix_[ 6]; }
 
  double yt() const { return matrix_[ 7]; }
 
  double zx() const { return matrix_[ 8]; }
 
  double zy() const { return matrix_[ 9]; }
 
  double zz() const { return matrix_[10]; }
 
  double zt() const { return matrix_[11]; }
 
  double tx() const { return matrix_[12]; }
 
  double ty() const { return matrix_[13]; }
 
  double tz() const { return matrix_[14]; }
 
  double tt() const { return matrix_[15]; }
 
 
  template <typename Value>
  LorentzVector<Value>
  operator*(const LorentzVector<Value> & v) const {
    return LorentzVector<Value>
      (xx()*v.x() + xy()*v.y() + xz()*v.z() + xt()*v.t(),
       yx()*v.x() + yy()*v.y() + yz()*v.z() + yt()*v.t(),
       zx()*v.x() + zy()*v.y() + zz()*v.z() + zt()*v.t(),
       tx()*v.x() + ty()*v.y() + tz()*v.z() + tt()*v.t());
  }
 
  template <typename Value>
  Lorentz5Vector<Value>
  operator*(const Lorentz5Vector<Value> & v) const {
    return Lorentz5Vector<Value>
      (xx()*v.x() + xy()*v.y() + xz()*v.z() + xt()*v.t(),
       yx()*v.x() + yy()*v.y() + yz()*v.z() + yt()*v.t(),
       zx()*v.x() + zy()*v.y() + zz()*v.z() + zt()*v.t(),
       tx()*v.x() + ty()*v.y() + tz()*v.z() + tt()*v.t());
  }
 
  SpinOneLorentzRotation operator * (const SpinOneLorentzRotation & lt) const;
 
  SpinOneLorentzRotation & operator *= (const SpinOneLorentzRotation & lt) {
    return *this = *this * lt;
  }
 
  SpinOneLorentzRotation & transform   (const SpinOneLorentzRotation & lt) {
    return *this = lt * *this;
  }
 
  SpinOneLorentzRotation & rotateX(double delta) {
    SpinOneLorentzRotation tmp;
    tmp.setRotateX(delta);
    return *this = tmp * *this;
  }
 
  SpinOneLorentzRotation & rotateY(double delta) {
    SpinOneLorentzRotation tmp;
    tmp.setRotateY(delta);
    return *this = tmp * *this;
  }
 
  SpinOneLorentzRotation & rotateZ(double delta) {
    SpinOneLorentzRotation tmp;
    tmp.setRotateZ(delta);
    return *this = tmp * *this;
  }
  
  SpinOneLorentzRotation & rotate(double delta, const Axis & axis) {
    SpinOneLorentzRotation tmp;
    tmp.setRotate(delta, axis);
    return *this = tmp * *this;
  }
 
  SpinOneLorentzRotation & boostX(double beta) {
    return *this = SpinOneLorentzRotation(beta,0,0) * *this;
  }
 
  SpinOneLorentzRotation & boostY(double beta) {
    return *this = SpinOneLorentzRotation(0,beta,0) * *this;
  }
 
  SpinOneLorentzRotation & boostZ(double beta) {
    return *this = SpinOneLorentzRotation(0,0,beta) * *this;
  }
 
  SpinOneLorentzRotation & boost(double bx, double by, double bz,
                                 double gamma=-1.) {
    return *this = SpinOneLorentzRotation(bx,by,bz,gamma) * *this;
  }
 
  SpinOneLorentzRotation & boost(const Boost & b, double gamma=-1.) {
    return *this = SpinOneLorentzRotation(b.x(),b.y(),b.z(),gamma) * *this;
  }
 
private:
 
  template<typename Value> friend class Helicity::LorentzTensor;
  template<typename Value> friend class Helicity::LorentzRank3Tensor;
  template<typename Value> friend class Helicity::LorentzRSSpinor;
  template<typename Value> friend class Helicity::LorentzRSSpinorBar;
 
  array<double,16> matrix_ = {};
 
  SpinOneLorentzRotation (double xx, double xy, double xz, double xt,
                          double yx, double yy, double yz, double yt,
                          double zx, double zy, double zz, double zt,
                          double tx, double ty, double tz, double tt);
 
  double operator()(unsigned int i, unsigned int j) const {
    return matrix_[4*i + j];
  }
 
 
  double & xx_() { return matrix_[ 0]; }
  double & xy_() { return matrix_[ 1]; }
  double & xz_() { return matrix_[ 2]; }
  double & xt_() { return matrix_[ 3]; }
 
  double & yx_() { return matrix_[ 4]; }
  double & yy_() { return matrix_[ 5]; }
  double & yz_() { return matrix_[ 6]; }
  double & yt_() { return matrix_[ 7]; }
 
  double & zx_() { return matrix_[ 8]; }
  double & zy_() { return matrix_[ 9]; }
  double & zz_() { return matrix_[10]; }
  double & zt_() { return matrix_[11]; }
 
  double & tx_() { return matrix_[12]; }
  double & ty_() { return matrix_[13]; }
  double & tz_() { return matrix_[14]; }
  double & tt_() { return matrix_[15]; }
};
 
inline std::ostream & operator<< ( std::ostream & os,
                                   const  SpinOneLorentzRotation& lt ) {
  return lt.print(os);
}
 
}
 
#endif /* ThePEG_SpinOneLorentzRotation_H */