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 */