Ctrl+K

axisangle

axisangle#

import ampform.helicity.align.axisangle

Spin alignment with the “axis-angle” method.

See [1] and Wigner rotations.

class AxisAngleAlignment[source]#

Bases: SpinAlignment

Alignment amplitudes with the “axis-angle” method.

See [1] and Wigner rotations.

static formulate_amplitude(reaction: ReactionInfo) → Expr[source]#
static define_symbols(reaction: ReactionInfo) → dict[Symbol, Expr][source]#
formulate_axis_angle_alignment(transition: StateTransition) → PoolSum[source]#

Generate all Wigner-\(D\) combinations for a spin alignment sum.

Generate all Wigner-\(D\) function combinations that appear in [1], Eq.(45), but for a generic multibody decay. Each element in the returned list is a tuple of Wigner-\(D\) functions that appear in the summation, for a specific set of helicities were are summing over. To generate the full sum, make a multiply the Wigner-\(D\) functions in each tuple and sum over all these products.

formulate_rotation_chain(transition: StateTransition, rotated_state_id: int) → PoolSum[source]#

Formulate the spin alignment sum for a specific chain.

See Eq.(45) from [1]. The chain consists of a series of helicity rotations (see formulate_helicity_rotation_chain()) plus a Wigner rotation (see formulate_wigner_rotation()) in case there is more than one helicity rotation.

formulate_helicity_rotation_chain(transition: StateTransition, rotated_state_id: int, helicity_symbol: Symbol) → PoolSum[source]#

Formulate a Wigner-\(D\) for each helicity rotation up some state.

The helicity rotations are performed going through the decay Topology starting from the initial state up some rotated_state_id. Each rotation operates on the spin state and is therefore formulated as a WignerD function (see formulate_helicity_rotation()). See {doc}`/usage/helicity/spin-alignment` for more info.

formulate_wigner_rotation(transition: StateTransition, rotated_state_id: int, helicity_symbol: Symbol, m_prime: Symbol) → PoolSum[source]#

Formulate the spin rotation matrices for a Wigner rotation.

A Wigner rotation is the ‘average’ rotation that results form a chain of Lorentz boosts to a new reference frame with regard to a direct boost. See [1], p.6, especially Eq.(36).

Parameters:

  • transition – The Transition in which you want to rotate one of the spin states.

  • rotated_state_id – The state ID of a spin State that you want to rotate.

  • helicity_symbol – Optional Symbol for \(m\) in \(D^s_{mm'}\). Falls back to the value of spin_projection embedded in the provided transition.

  • m_prime – The summation symbol \(m'\) that should be used when summing over the Wigner-\(D\) functions for this rotation.

formulate_helicity_rotation(spin_magnitude, spin_projection, m_prime, alpha, beta, gamma, no_zero_spin: bool = False) → PoolSum[source]#

Formulate action of an Euler rotation on a spin state.

When rotation a spin state \(\left|s,m\right\rangle\) over Euler angles \(\alpha,\beta,\gamma\), the new state can be expressed in terms of other spin states \(\left|s,m'\right\rangle\) with the help of Wigner-\(D\) expansion coefficients:

(1)#\[R(\alpha,\beta,\gamma)\left|s,m\right\rangle = \sum^s_{m'=-s} D^s_{m',m}\left(\alpha,\beta,\gamma\right) \left|s,m'\right\rangle\]

See [1], Eq.(B.5).

This function gives the summation over these Wigner-\(D\) functions and can be used for spin alignment following [1], Eq.(45).

Parameters:

  • spin_magnitude – Spin magnitude \(s\) of spin state that is being rotated.

  • spin_projection – Spin projection component \(m\) of the spin state that is being rotated.

  • m_prime – A index Symbol or Dummy that represents \(m'\) helicities in Eq. (1).

  • alpha – First Euler angle.

  • beta – Second Euler angle.

  • gamma – Third Euler angle.

  • no_zero_spin – Skip value 0.0 in the generated spin projection range. Useful for massless particles.

Example

>>> a, b, c, i = sp.symbols("a b c i")
>>> formulate_helicity_rotation(0, 0, i, a, b, c)
PoolSum(WignerD(0, 0, i, a, b, c), (i, (0,)))
>>> formulate_helicity_rotation(1 / 2, -1 / 2, i, a, b, c)
PoolSum(WignerD(1/2, -1/2, i, a, b, c), (i, (-1/2, 1/2)))
get_opposite_helicity_sign(topology: Topology, state_id: int) → Literal[-1, 1][source]#
Contents