irfpy.util.lorentztrans

Functions for Lorenz transformation

Code author: Yoshifumi Futaana

Todo

Consider importing to physics module

irfpy.util.lorentztrans.beta(v)

Return \(\beta\).

Return the parameter \(\beta\).

\[\beta = \frac{v}{c}\]

where \(v\) is the velocity of the object and \(c\) is the velocity of light.

Parameters:

v (float or np.array.) – Velocity (in meter) of the object.

>>> print('%.5f' % beta(3e7))  # About 0.1
0.10007

irfpy.util.lorentztrans.beta_u(*args)

Unitful version of beta().

irfpy.util.lorentztrans.gamma(v)

Return \(\gamma\).

Return the parameter \(\gamma\).

\[\gamma = \frac{1}{\sqrt{1 - \bigl(\frac{v}{c}\bigl)^2}}\]

where \(v\) is the velocity of the object and \(c\) is the velocity of light.

Parameters:

v (float or np.array.) – Velocity of the object.

>>> print('%.6f' % gamma(3e7))
1.005045

irfpy.util.lorentztrans.gamma_u(*args)

Unitful version of gamma().

irfpy.util.lorentztrans.gamma2vel(gamma)

Inverse function of gamma().

Parameters:

gamma – The parameter \(\gamma\).

Returns:

\(v\) in m/s.

The relation is

\[\gamma = \frac{1}{\sqrt{1 - \bigl(\frac{v}{c}\bigl)^2}}\]

so that

\[v = c \sqrt{1 - \frac{1}{\gamma^2}}\]

>>> print('%.3e' % gamma2vel(1.01))
4.208e+07

You may use unitful version:

>>> print('%.3e' % gamma2vel_u(1.01).rescale(u.km / u.s))
4.208e+04

irfpy.util.lorentztrans.transformx(x, t, v)

Lorenz transform along x.

An inertia frame, K(x, y, z), is Lorentz-transformed to K’(x’, y’, z’), another inertia frame. K’ is moving relative to K with velocity v along x axis.

The formulation is

\[\begin{split}x' &= \gamma(x-vt) \\ t' &= \gamma(t-\frac{v}{c^2}x)\end{split}\]

Parameters:

• x – The x coordinate in K frame.

• t – The t in K frame.

• v – The velocity of K’ relative to K.

Returns:

A tuple, (x’, t’).

A simple example for x=3e8, t=10, v=2e8. If you consider Galileo transform, the time does not change (t=10) and the position is \(x-vt=3e8 - 10\times 2e8=-17e9\). However, if you use the Lorentz transform, these values differ.

>>> x1, t1 = transformx(3e8, 10, 2e8)
>>> print('%.3e' % x1)
-2.282e+09
>>> print('%.3f' % t1)
12.528

Unitful version is also supported. Numpy array argument is also supported.

>>> x1u, t1u = transformx_u(np.array([3e8, 3e8]) * u.m, np.array([5, 10]) * u.s, np.array([2e8, 2e8]) * u.m/u.s)
>>> print(x1u)   
[-9.39669291e+08  -2.28205399e+09] m
>>> print(t1u)   
[  5.81576086  12.52768436] s

If velocity is very small, (almost) identical solution to Galilei transform can be obtained. Example is x=5, t=10, v=3. In this case time does not change (t=10). The position is \(5 - 3 \times 10 = -25\).

>>> x2, t2 = transformx(5, 10, 3)
>>> print('{:.2f}'.format(x2))
-25.00
>>> print('{:.2f}'.format(t2))
10.00

irfpy.util.lorentztrans.transformx_u(*args)

Unitful version of transformx()

irfpy.util.lorentztrans.doctests()