Struct FourMomentum

pub struct FourMomentum<F: Field + 'static>(/* private fields */);

Struct which holds energy and three-momentum as a four-vector.

A four-momentum structure with helpful methods for boosts.

This is the basic structure of a Lorentz four-vector of the form $(E, \vec{p})$ where $E$ is the energy and $\vec{p}$ is the momentum.

Examples

use rustitude_core::prelude::*;

let vec_a = FourMomentum::new(1.3, 0.2, 0.3, 0.1);
let vec_b = FourMomentum::new(4.2, 0.5, 0.4, 0.5);

Implementations

impl<F: Field> FourMomentum<F>

pub fn new(e: F, px: F, py: F, pz: F) -> Self

Create a new FourMomentum from energy and momentum components.

Components are listed in the order $(E, p_x, p_y, p_z)$

pub fn e(&self) -> F

Returns the energy of the given FourMomentum.

pub fn px(&self) -> F

Returns the momentum along the $x$-axis of the given FourMomentum.

pub fn py(&self) -> F

Returns the momentum along the $y$-axis of the given FourMomentum.

pub fn pz(&self) -> F

Returns the momentum along the $z$-axis of the given FourMomentum.

pub fn set_e(&mut self, value: F)

Sets the energy of the given FourMomentum.

pub fn set_px(&mut self, value: F)

Sets the momentum along the $x$-axis of the given FourMomentum.

pub fn set_py(&mut self, value: F)

Sets the momentum along the $x$-axis of the given FourMomentum.

pub fn set_pz(&mut self, value: F)

Sets the momentum along the $x$-axis of the given FourMomentum.

pub fn m2(&self) -> F

Calculate the invariant $m^2$ for this FourMomentum instance.

Calculates $m^2 = E^2 - \vec{p}^2$

Examples

use rustitude_core::prelude::*;

let vec_a = FourMomentum::new(20.0, 1.0, 0.2, -0.1);
//assert_eq!(vec_a.m2(), 20.0 * 20.0 - (1.0 * 1.0 + 0.0 * 0.2 + (-0.1) * (-0.1)));

pub fn m(&self) -> F

Calculate the invariant $m$ for this FourMomentum instance.

Calculates $m = \sqrt{E^2 - \vec{p}^2}$

See Also:

FourMomentum::m2

pub fn boost_along(&self, other: &Self) -> Self

Boosts an instance of FourMomentum along the $\vec{\beta}$ vector of another FourMomentum.

Calculates $\mathbf{\Lambda} \cdot \mathbf{x}$

Examples

use rustitude_core::prelude::*;

let vec_a = FourMomentum::new(20.0, 1.0, -3.2, 4.0);
let vec_a_COM = vec_a.boost_along(&vec_a);
assert!(f64::abs(vec_a_COM.px()) < 1e-7);
assert!(f64::abs(vec_a_COM.py()) < 1e-7);
assert!(f64::abs(vec_a_COM.pz()) < 1e-7);

pub fn momentum(&self) -> Vector3<F>

Extract the 3-momentum as a nalgebra::Vector3<Field>

Examples

use rustitude_core::prelude::*;
use nalgebra::Vector3;

let vec_a = FourMomentum::new(20.0, 1.0, 0.2, -0.1);
assert_eq!(vec_a.momentum(), Vector3::new(1.0, 0.2, -0.1));

pub fn costheta(&self) -> F

Returns the $\cos(\theta)$ of the momentum 3-vector.

pub fn theta_cos(&self) -> F

Returns the $\cos(\theta)$ of the momentum 3-vector.

Alias for FourMomentum::costheta.

pub fn theta(&self) -> F

Returns the $\theta$ polar angle of the momentum 3-vector.

pub fn phi(&self) -> F

Returns the $\phi$ azimuthal angle of the momentum 3-vector.

pub fn beta3(&self) -> Vector3<F>

Construct the 3-vector $\vec{\beta}$ where

$\vec{\beta} = \frac{\vec{p}}{E}$

pub fn direction(&self) -> Vector3<F>

Constructs the 3-vector normal to the 3-momentum

pub fn boost_matrix(&self) -> Matrix4<F>

Construct the Lorentz boost matrix $\mathbf{\Lambda}$ where

\mathbf{\Lambda} = \begin{pmatrix}
\gamma & -\gamma \beta_x & -\gamma \beta_y & -\gamma \beta_z \\
-\gamma \beta_x & 1 + (\gamma - 1) \frac{\beta_x^2}{\vec{\beta}^2} & (\gamma - 1) \frac{\beta_x \beta_y}{\vec{\beta}^2} & (\gamma - 1) \frac{\beta_x \beta_z}{\vec{\beta}^2} \\
-\gamma \beta_y & (\gamma - 1) \frac{\beta_y \beta_x}{\vec{\beta}^2} & 1 + (\gamma - 1) \frac{\beta_y^2}{\vec{\beta}^2} & (\gamma - 1) \frac{\beta_y \beta_z}{\vec{\beta}^2} \\
-\gamma \beta_z & (\gamma - 1) \frac{\beta_z \beta_x}{\vec{\beta}^2} & (\gamma - 1) \frac{\beta_z \beta_y}{\vec{\beta}^2} & 1 + (\gamma - 1) \frac{\beta_z^2}{\vec{\beta}^2}
\end{pmatrix}

where $\vec{\beta} = \frac{\vec{p}}{E}$ and $\gamma = \frac{1}{\sqrt{1 - \vec{\beta}^2}}$.

Trait Implementations

impl<F: Field> Add for &FourMomentum<F>

type Output = <FourMomentum<F> as Add>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &FourMomentum<F>) -> Self::Output

Performs the + operation.

impl<F: Field> Add for FourMomentum<F>

type Output = FourMomentum<F>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<F: Clone + Field + 'static> Clone for FourMomentum<F>

fn clone(&self) -> FourMomentum<F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug + Field + 'static> Debug for FourMomentum<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Default + Field + 'static> Default for FourMomentum<F>

fn default() -> FourMomentum<F>

Returns the “default value” for a type.

impl<F: Field> Display for FourMomentum<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Field> From<&FourMomentum<F>> for Vector4<F>

fn from(val: &FourMomentum<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<&Matrix<F, Const<4>, Const<1>, ArrayStorage<F, 4, 1>>> for FourMomentum<F>

fn from(value: &Vector4<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<&Vec<F>> for FourMomentum<F>

fn from(value: &Vec<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<FourMomentum<F>> for Vector4<F>

fn from(val: FourMomentum<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<Matrix<F, Const<4>, Const<1>, ArrayStorage<F, 4, 1>>> for FourMomentum<F>

fn from(value: Vector4<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<Vec<F>> for FourMomentum<F>

fn from(value: Vec<F>) -> Self

Converts to this type from the input type.

impl<F: PartialEq + Field + 'static> PartialEq for FourMomentum<F>

fn eq(&self, other: &FourMomentum<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F: Field> Sub for &FourMomentum<F>

type Output = <FourMomentum<F> as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &FourMomentum<F>) -> Self::Output

Performs the - operation.

impl<F: Field> Sub for FourMomentum<F>

type Output = FourMomentum<F>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<F: Field> Sum for FourMomentum<F>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<F: Copy + Field + 'static> Copy for FourMomentum<F>

impl<F: Field> Eq for FourMomentum<F>

impl<F: Field + 'static> StructuralPartialEq for FourMomentum<F>