Lorentz Transforms

[szabo137]

The Lorentz Vector interface should be extended by a function performing a certain Lorentz transformation.

In general, this may include the following transformations:

• [ ] Lorentz transforms from LorentzVector (actually the relative FourVelocity)
• [ ] Lorentz transforms from (relative) ThreeVelocity
• [ ] Lorentz Boosts w.r.t. a certain axis from beta and rapidity
• [ ] Rotations in 3D

[szabo137]

Proposal: boost interface

Lorentz boosts are linear transformations acting on Lorentz vectors, especially four-momenta. This could be implemented using a two step procedure:

1. Initialization of the boost
2. Application of the boost to a vector

Boosts itself can be defined in two variants:

I) general boost II) axis aligned boost

Finally, boosts can be initialized using various parametrisations: beta vector, gamma vectors, rapidities, pseudo-rapidities, ...

implementation

The implementation could be based on a little type hierarchy:

AbstractCoordiateTransform
<:AbstractLorentzTransform
<:AbstractLorentzBoost
<:AbstractLorentzAxisBoost

The specific boosts can then be inherited from the respective abstract type

Boost<:AbstractLorentzBoost
BoostX<:AbstractLorentzAxisBoost
...

The respective construction could be done in two ways, either using a type to indicate the base:

Boost(BoostBetaBase(), (beta_x, beta_y, beta_z)

BoostX(RapidityBase(),rapidity_x) 

However, I think the more convenient way to construct these boosts is the usage of special types for the initializing arguments:

Boost(BetaVector(beta_x, beta_y, beta_z))

Boost(RapidityVector(...))

BoostX(Rapidity(rapidity_x))

Once constructed, each boost (or in general each transformation) should implement the private function

_transform(
    boost::AbstractLorentzBoost,
    p::AbstractFourMomentum 
)

Finally, this can then be used to implement the application of the boost:

function (boost::AbstractLorentzBoost)(p::AbstractFourMomentum)
    _transform(boost, p)
end 

This leads to the following user story:

boost=Boost(BetaVector(0.0, 0.2, 0.5)) # probably the default constructor 
p=rand(SFourMomentum)

p_prime = boost(p)

[szabo137]

Side notes:

• The constructors could be extended with more convenient calls, e.g. Boost(RestFrame(), p) which is a boost to the rest frame of p.
• since every boost is invertable, it is conceivable to implement Base.inv(boost) -> Boost which returns the inverting boost.
• initialized boosts can also applied conveniently to other types: obviously ParticleStateful but also PhaseSpacePoint, where the boost is applied to all involved four-momenta.