LorentzTransformation.h

Go to the documentation of this file.

/*  YAP - Yet another PWA toolkit
    Copyright 2015, Technische Universitaet Muenchen,
    Authors: Daniel Greenwald, Johannes Rauch

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/


#ifndef yap_LorentzTransformation_h
#define yap_LorentzTransformation_h

#include "Matrix.h"
#include "FourVector.h"
#include "ThreeVector.h"

#include <algorithm>

namespace yap {

template <typename T>
const FourMatrix<T> lorentzTransformation(const ThreeMatrix<T>& R)
{
    FourMatrix<T> L = unitMatrix<T, 4>();
    for (unsigned i = 0; i < R.size(); ++i)
        std::copy(R[i].begin(), R[i].end(), L[i + 1].begin() + 1);
    return L;
}

template <typename T>
const FourMatrix<T> lorentzTransformation(const FourVector<T>& V)
{
    auto gamma = V[0] / abs(V); // E / m
    auto b = FourVector<T>((gamma + 1), gamma * vect(V) / V[0]) / sqrt(gamma + 1); // vect(V)/V[0] = beta

    return diagonalMatrix<T, 4>({ -1, 1, 1, 1}) + outer(b, b);
}

template <typename T>
constexpr FourMatrix<T> lorentzTransformation(const ThreeVector<T>& V)
{ return lorentzTransformation<T>(FourVector<T>(T(1), V)); }

template <typename T>
constexpr FourMatrix<T> lorentzTransformation(const std::vector<FourVector<T> >& fourVecs)
{ return lorentzTransformation(std::accumulate(fourVecs.begin(), fourVecs.end(), FourVector<T>({0, 0, 0, 0}))); }

template <typename T>
constexpr FourMatrix<T> lorentzTransformation(const ThreeMatrix<T>& R, const FourVector<T>& V)
{ return lorentzTransformation<T>(V) * lorentzTransformation<T>(R); }

template <typename T>
constexpr FourMatrix<T> lorentzTransformation(const ThreeMatrix<T>& R, const ThreeVector<T>& V)
{ return lorentzTransformation<T>(V) * lorentzTransformation<T>(R); }

template <typename T>
constexpr FourMatrix<T> lorentzTransformation(const FourVector<T>& V, const ThreeMatrix<T> R)
{ return lorentzTransformation<T>(R) * lorentzTransformation<T>(V); }

template <typename T>
constexpr FourMatrix<T> lorentzTransformation(const ThreeVector<T>& V, const ThreeMatrix<T>& R)
{ return lorentzTransformation<T>(R) * lorentzTransformation<T>(V); }

}
#endif