LorentzRotation.h

// -*- C++ -*-
//
// LorentzRotation.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_LorentzRotation_H
#define THEPEG_LorentzRotation_H
//
// This is the declaration of the LorentzRotation class.
//
#include "SpinOneLorentzRotation.h"
#include "SpinHalfLorentzRotation.h"
#include "LorentzRotation.fh"
 
namespace ThePEG {
 
class LorentzRotation {
 
  friend LorentzRotation inverseOf ( const LorentzRotation & lt );
 
public:
 
 
  LorentzRotation() : _half(), _one() {}
 
  LorentzRotation (double bx, double by, double bz, double gamma=-1.) 
    : _half(bx,by,bz,gamma), _one(bx,by,bz,gamma) {}
 
  LorentzRotation (const Boost & b, double gamma=-1.)
    : _half(b,gamma), _one(b,gamma) {}
 
  bool isIdentity() const { 
    return _half.isIdentity() && _one.isIdentity(); 
  } 
 
  LorentzRotation inverse() const {
    LorentzRotation output;
    output._half = _half.inverse();
    output._one  =  _one.inverse();
    return output;
  }
 
  LorentzRotation & invert() {
    return *this=inverse();
  }
 
  std::ostream & print( std::ostream & os ) const;
 
 
  LorentzRotation & setBoost (double bx, double by, double bz, double gamma=-1.) {
    _half.setBoost(bx,by,bz,gamma);
    _one.setBoost(bx,by,bz,gamma);
    return *this;
  }
 
  LorentzRotation & setBoost (const Boost & b, double gamma=-1.) {
    _half.setBoost(b,gamma);
    _one.setBoost(b,gamma);
    return *this;
  }
 
  LorentzRotation & setBoostX (double boost) {
    _half.setBoostX(boost);
    _one.setBoost(boost,0,0);
    return *this;
  }
 
  LorentzRotation & setBoostY (double boost) {
    _half.setBoostY(boost);
    _one.setBoost(0,boost,0);
    return *this;
  }
 
  LorentzRotation & setBoostZ (double boost) {
    _half.setBoostZ(boost);
    _one.setBoost(0,0,boost);
    return *this;
  }
 
  LorentzRotation & setRotate(double delta, const Axis & axis) {
    _half.setRotate(delta,axis);
    _one.setRotate(delta,axis);
    return *this;
  }
 
  LorentzRotation & setRotateX (double angle) {
    _half.setRotateX(angle);
    _one.setRotateX(angle);
    return *this;
  }
 
  LorentzRotation & setRotateY (double angle) {
    _half.setRotateZ(angle);
    _one.setRotateZ(angle);
    return *this;
  }
 
  LorentzRotation & setRotateZ (double angle) {
    _half.setRotateZ(angle);
    _one.setRotateZ(angle);
    return *this;
  }
 
 
  const SpinHalfLorentzRotation & half() const { return _half; }
 
  const SpinOneLorentzRotation & one() const { return _one; }
 
  operator const SpinOneLorentzRotation & () const { return _one; }
 
 
  double xx() const { return _one.xx(); }
 
  double xy() const { return _one.xy(); }
 
  double xz() const { return _one.xz(); }
 
  double xt() const { return _one.xt(); }
 
  double yx() const { return _one.yx(); }
 
  double yy() const { return _one.yy(); }
 
  double yz() const { return _one.yz(); }
 
  double yt() const { return _one.yt(); }
 
  double zx() const { return _one.zx(); }
 
  double zy() const { return _one.zy(); }
 
  double zz() const { return _one.zz(); }
 
  double zt() const { return _one.zt(); }
 
  double tx() const { return _one.tx(); }
 
  double ty() const { return _one.ty(); }
 
  double tz() const { return _one.tz(); }
 
  double tt() const { return _one.tt(); }
 
  Complex s1s1() const { return _half.s1s1(); }
 
  Complex s1s2() const { return _half.s1s2(); }
 
  Complex s1s3() const { return _half.s1s3(); }
 
  Complex s1s4() const { return _half.s1s4(); }
 
  Complex s2s1() const { return _half.s2s1(); }
 
  Complex s2s2() const { return _half.s2s2(); }
 
  Complex s2s3() const { return _half.s2s3(); }
 
  Complex s2s4() const { return _half.s2s4(); }
 
  Complex s3s1() const { return _half.s3s1(); }
 
  Complex s3s2() const { return _half.s3s2(); }
 
  Complex s3s3() const { return _half.s3s3(); }
 
  Complex s3s4() const { return _half.s3s4(); }
 
  Complex s4s1() const { return _half.s4s1(); }
 
  Complex s4s2() const { return _half.s4s2(); }
 
  Complex s4s3() const { return _half.s4s3(); }
 
  Complex s4s4() const { return _half.s4s4(); }
 
 
 
  template <typename Value>
  LorentzVector<Value>
  operator*(const LorentzVector<Value> & lv) const { return one()*lv; }
 
  template <typename Value>
  Lorentz5Vector<Value>
  operator*(const Lorentz5Vector<Value> & lv) const { return one()*lv; }
 
  LorentzRotation operator * (const LorentzRotation & lt) const {
    LorentzRotation output;
    output._half = _half * lt._half;
    output._one  = _one * lt._one; 
    return output;
  }
 
  LorentzRotation & operator *= (const LorentzRotation & lt) {
    _one *=lt._one;
    _half*=lt._half;
    return *this;
  }
 
  LorentzRotation & transform(const LorentzRotation & lt) {
    _half.transform(lt._half);
    _one.transform(lt._one);
    return *this;
  }
 
  LorentzRotation & rotateX(double delta) {
    _half.rotateX(delta);
    _one.rotateX(delta);
    return *this;
  }
 
  LorentzRotation & rotateY(double delta) {
    _half.rotateY(delta);
    _one.rotateY(delta);
    return *this;
  }
 
  LorentzRotation & rotateZ(double delta) {
    _half.rotateZ(delta);
    _one.rotateZ(delta);
    return *this;
  }
  
  LorentzRotation & rotate(double delta, const Axis & axis) {
    _half.rotate(delta,axis);
    _one.rotate(delta,axis);
    return *this;
  }
 
  LorentzRotation & boostX(double beta) {
    _half.boostX(beta);
    _one.boostX(beta);
    return *this;
  }
 
  LorentzRotation & boostY(double beta) {
    _half.boostY(beta);
    _one.boostY(beta);
    return *this;
  }
 
  LorentzRotation & boostZ(double beta) {
    _half.boostZ(beta);
    _one.boostZ(beta);
    return *this;
  }
 
  LorentzRotation & boost(double bx, double by, double bz, double gamma=-1.) {
    _half.boost(bx,by,bz,gamma);
    _one.boost(bx,by,bz,gamma);
    return *this;
  }
 
  LorentzRotation & boost(const Boost & bv, double gamma=-1.) {
    _half.boost(bv,gamma);
    _one.boost(bv,gamma);
    return *this;
  }
 
private:
 
  SpinHalfLorentzRotation _half;
 
  SpinOneLorentzRotation _one;
 
};
 
inline LorentzRotation inverseOf ( const LorentzRotation & lt ) {
  return lt.inverse();
}
 
inline std::ostream & operator<< ( std::ostream & os,
                                   const  LorentzRotation& lt ) {
  return lt.print(os);
}
 
}
 
#endif /* THEPEG_LorentzRotation_H */