Physics:PP/2/Relativistic Kinematics

From HandWiki
Jump to: navigation, search
<< Back
50% complete
   

Relativistic Kinematics

Modern experiments in particle and nuclear physics typically make use of relativistic kinematics. In this and following sections, we use Natural units: [math]c = \hbar = 1[/math], where [math]\hbar=\frac{h}{2 \pi}[/math] is reduced plank constant and [math]c[/math] is the speed of light.

Vector Notation

Space-time, momentum, and energy observables are defined as relativistic vectors defined in a four-dimensional Minkowski space. Scalar quantities are invariant under changes of (inertial) reference frame while vector quantities, such as the space-time position or the momentum of a particle, transform according to Lorentz transformations.

Within the context of special relativity, formulated in a flat Minkowski space, there is little need to distinguish between vectors (also called contravariant vectors) and 1-form (also called covariant vectors). Such a distinction is however essential in the context of general relativity. Herewith, we nonetheless distinguish the contravariant vector notation xμ and the covariant vector notation xμ indiscriminately. Within an inertial reference frame S, space-time coordinates are denoted with a contravariant four vector with components xμ defined according to:

[math] x^{\mu} = (x^0,x^1,x^2,x^3) \equiv (t,\vec x) [/math]

where t and [math]\vec x[/math] respectively represents the time and position of a point-like object measured in the reference frame S. The space-time position can also be specified with a 1-form or covariant vector xμ defined according to:

[math] x_{\mu} = (x_0,-x_1,-x_2,-x_3) \equiv (t,-\vec x) [/math]

We adopt the space-time metric tensor convention [math]g_{\mu,\nu}[/math], defined as

[math] g_{\mu,\nu} = g^{\mu,\nu} = \left( {\begin{array}{*{20}{c}} 1&0&0&0\\ 0&{ - 1}&0&0\\ 0&0&{ - 1}&0\\ 0&0&0&{ - 1} \end{array}} \right). [/math]

Covariant vectors are related to their contra-variant counterpart xμ according to

[math] x_{\mu} = \sum_{\nu=0}^3 g_{\mu,\nu} x^{\nu}. [/math]

Herewith, rather than specifying the sum explicit, we shall use the Einstein convention that stipulates that a repeated (Greek) index is summed from 0 to 3, inclusively, unless indicated otherwise. The above is then written:

[math] x_{\mu} = g_{\mu,\nu} x^{\nu}, [/math]

without explicitly mentioning the sum on the index [math]\mu [/math]. Similarly, the contravariant components of a vector x are obtained from its covariant components according to

[math] x^{\mu} = g^{\mu,\nu} x_{\nu}, [/math]

The scalar product of two four vectors a and b is herein denoted and calculated according to

[math] a · b = a^{\mu} b_{\mu} = g_{\mu,\nu} a^{\mu} b^{\nu} = g^{\mu,\nu} a_{\mu} b_{\nu}, [/math]

where, once again the Einstein convention is used. The square modulus [math]a^2[/math] of a four vector a is written

[math] a^2 = a · a = a^{\mu} a_{\mu} = a_0^2 - a_1^2 - a_2^2 - a_3^2. [/math]


Symbol/Notation used in online text

Lorentz transformation

Problems of interest in nuclear and particle physics typically involve collisions of beam particles (projectiles) onto a fixed-target or collisions of two beams traveling co-linearly, but in opposite directions. We adopt a right-handed coordinate system with the [math]z[/math]-axis, or third component of the momentum vector, corresponding to the beam axis. In this context, there are three natural and convenient choices of reference frames: the target rest frame, the projectile rest frame, and the center of mass (CM) rest frame. These correspond to reference frames where the target, the projectile, and the CM are at rest, respectively.

Given our choice of [math]z[/math]-axis, coordinate transformations between these three frames of reference leave the first and second components of the momentum invariant, while the third component and energy are transformed according to a Lorentz transformation (discussed below). It is thus convenient to introduce the notion of transverse momentum vector [math]\vec p_T[/math], defined as

[math] {\vec p}_T \equiv (p_x, p_y), [/math]

and its norm (magnitude)

[math] p_T = \sqrt{p_x^2+p_y^2}. [/math]

The four-momentum vector of a particle may thus also be written [math]p=(E, \vec p_T, p_z)[/math].

A Lorentz transformation along the beam axis leaves the transverse momentum invariant. Consider the momentum, [math]p=(E,\vec p_T, p_z)[/math], of a particle in a reference frame [math]K[/math] (e.g., the target rest frame). The components [math]p'=(E',\vec p_T{'}, p_z{'})[/math] in a frame [math]K'[/math] (e.g., projectile rest frame) moving along [math]+z[/math] at a velocity [math]\beta[/math] relative to K are written:

[math] E' = \gamma (E-\beta p_z), \\ \vec p_T{'} = \vec p_T, \\ p_z{'} = \gamma (p_z - \beta E), [/math]

where [math]\gamma = (1-\beta^2)^{-½}[/math].

Transformations for motion along axes [math]x[/math] or [math]y[/math] are trivially obtained by substitution of the appropriate momentum components. Transformations for motion along an arbitrary direction, [math]\hat \beta[/math], at velocity [math]\beta[/math], requires one explicitly separates the momentum components parallel and perpendicular to [math]\hat \beta[/math]. One writes

[math] \vec p = \vec p_{T} + \vec p_{\parallel} , [/math]

with

[math] \vec p_{\parallel} = (\vec p \cdot \hat \beta) \hat \beta, \\ \vec p_{T} = \vec p - \vec p_{\parallel}. [/math]

The [math]\vec p_{T}[/math] component is unmodified by the transformation along [math]\hat \beta[/math], but the parallel component is boosted according to

[math] |\vec p_{\parallel}{\ '}| = \gamma \left( |\vec p_{\parallel}| + \beta E \right). [/math]

The boosted moment can consequently be written

[math] \label{eq:LorentzTransformAlongBeta} \vec p{\ '} = \vec p + \left[ (\gamma - 1) {\vec p} \cdot \hat \beta + \gamma E \right] \hat \beta. [/math]

Notation sa

Finally, when the code examples will be difficult to implement in the "Python" syntax, we will use the standard CLING interpretator from the ROOT.

Programming relativistic kinematics

Using Python / C++

In Python, one simple method to show a 4-momentum of particles is to use Python lists

pion=[0,0,0,0.139570]

where 0,0,0 represents the 3-momenta (pion at rest), while the last number is the pion mass in GeV. Although this looks simple, the difficult part is how to implement all kinematic transformations for such lists.

Instead simple lists like shown above, TLorentzVector can be used that stores relativistic four-vectors such as the space-time 4-vector or the energy-momentum 4-vector.

from ROOT import TLorentzVector
pion = TLorentzVector(0, 0, 0, 0.139570) # create the 4-vector (px,py,pz,e) for a pion at rest

The last value in the argument list is the pion mass in GeV, since the pion is at rest. As usual, you can learn about all methods associated with this class as this:

dir(pion)

One can also define particles using "Set" method. Let's create two pions, add them together, and calculate the invariant mass, angle between pions and pseudorapidity of the combined object:

from ROOT import TLorentzVector
pi1, pi2 = TLorentzVector(), TLorentzVector()
# Set the vector components (3-momenta and energy)
pi1.SetPxPyPzE(0.281,   0.282, 1.212, 2.974)
pi2.SetPxPyPzE(-0.123, -0.298, 2.123, 3.212)
p=pi1+pi2
mass=p.M()
y=p.Eta()

If you print mass, y and angle, you will see that the original particle (which presumably decays to these two pions) has a mass of 5.2 GeV and a large rapidity (3.7 units). You can learn more about the methods of the TLorentzVector C++ class from TLorentzVector ROOT documentation.

Using Jython / Java

Alternatively, you can use Python language to access a similar class of objects that deal with relativistic kinetics. The Java classes that implement are is called HepLorentzVector HepLorentzVector and LParticle LParticle.

from hephysics.particle import LParticle
pi1, pi2 = LParticle(0.281,   0.282, 1.212, 2.974), LParticle(-0.123, -0.298, 2.123, 3.212)
pi1.add(pi2)
print pi1.calcMass(), pi1.getEta()

You will see on the screen the same results as for the pyROOT. Note that LParticle LParticle is more complex than HepLorentzVector HepLorentzVector since it can hold the name of particles and implement various boosts.