helicity

import ampform.helicity

Generate an amplitude model with the helicity formalism.

class CanonicalAmplitudeBuilder(reaction_result: ReactionInfo)[source]

Bases: ampform.helicity.HelicityAmplitudeBuilder

Amplitude model generator for the canonical helicity formalism.

This class defines a full amplitude in the canonical formalism, using the helicity formalism as a foundation. The key here is that we take the full helicity intensity as a template, and just exchange the helicity amplitudes \(F\) as a sum of canonical amplitudes \(A\):

\[F^J_{\lambda_1,\lambda_2} = \sum_{LS} \mathrm{norm}(A^J_{LS})C^2.\]

Here, \(C\) stands for Clebsch-Gordan factor.

class HelicityAmplitudeBuilder(reaction: ReactionInfo)[source]

Bases: object

Amplitude model generator for the helicity formalism.

formulate() HelicityModel[source]
set_dynamics(particle_name: str, dynamics_builder: ResonanceDynamicsBuilder) None[source]
class HelicityModel(expression: Expr, parameter_defaults: Mapping[Symbol, Expr], components: Mapping[str, Union[float, complex, int]], adapter: HelicityAdapter, particles: ParticleCollection)[source]

Bases: object

property adapter: HelicityAdapter

Adapter for converting four-momenta to kinematic variables.

property components: OrderedDict[str, Expr]

A mapping for identifying main components in the expression.

Keys are the component names (str), formatted as LaTeX, and values are sub-expressions in the main expression. The mapping is an OrderedDict that orders the component names alphabetically with natural sort order.

property expression: Expr
property parameter_defaults: OrderedDict[Symbol, ParameterValue]

A mapping of suggested parameter values.

Keys are Symbol instances from the main expression that should be interpreted as parameters (as opposed to variables). The symbols are ordered alphabetically by name with natural sort order. Values have been extracted from the input ReactionInfo.

particles: ParticleCollection
sum_components(components: Iterable[str]) Expr[source]

Coherently or incoherently add components of a helicity model.

ParameterValue

Allowed value types for parameters.

alias of Union[float, complex, int]

extract_particle_collection(transitions: Iterable[StateTransition]) ParticleCollection[source]

Collect all particles from a collection of state transitions.

formulate_clebsch_gordan_coefficients(transition: StateTransition, node_id: int) Expr[source]

Compute the two Clebsch-Gordan coefficients for a state transition node.

In the canonical basis (also called partial wave basis), Clebsch-Gordan coefficients ensure that the projection of angular momentum is conserved ([3], p. 4). When calling generate_transitions() with formalism="canonical-helicity", AmpForm formulates the amplitude in the canonical basis from amplitudes in the helicity basis using the transformation in [1], Eq. (4.32). See also [3], Eq. (28).

This function produces the two Clebsch-Gordan coefficients in [1], Eq. (4.32). For a two-body decay \(1 \to 2, 3\), we get:

(1)\[C^{s_1,\lambda}_{L,0,S,\lambda} C^{S,\lambda}_{s_2,\lambda_2,s_3,-\lambda_3}\]

with:

  • \(s_i\) the intrinsic Spin.magnitude of each state \(i\),

  • \(\lambda_{2}, \lambda_{3}\) the helicities of the decay products (can be taken to be their spin_projection when following a constistent boosting procedure),

  • \(\lambda=\lambda_{2}-\lambda_{3}\),

  • \(L\) the total angular momentum of the final state pair (l_magnitude),

  • \(S\) the coupled spin magnitude of the final state pair (s_magnitude),

  • and \(C^{j_3,m_3}_{j_1,m_1,j_2,m_2} = \langle j1,m1;j2,m2|j3,m3\rangle\), as in Clebsch-Gordan Coefficients.

Example

>>> import qrules
>>> reaction = qrules.generate_transitions(
...     initial_state=[("J/psi(1S)", [+1])],
...     final_state=[("gamma", [-1]), "f(0)(980)"],
... )
>>> transition = reaction.transitions[1]  # angular momentum 2
>>> formulate_clebsch_gordan_coefficients(transition, node_id=0)
CG(1, -1, 0, 0, 1, -1)*CG(2, 0, 1, -1, 1, -1)
\[C^{s_1,\lambda}_{L,0,S,\lambda} C^{S,\lambda}_{s_2,\lambda_2,s_3,-\lambda_3} = C^{1,(-1-0)}_{2,0,1,(-1-0)} C^{1,(-1-0)}_{1,-1,0,0} = C^{1,-1}_{2,0,1,-1} C^{1,-1}_{1,-1,0,0}\]
../_images/graphviz_1.svg
formulate_wigner_d(transition: StateTransition, node_id: int) Expr[source]

Compute WignerD for a transition node.

Following [3], Eq. (10). For a two-body decay \(1 \to 2, 3\), we get

(2)\[D^{s_1}_{m_1,\lambda_2-\lambda_3}(-\phi,\theta,0)\]

with:

  • \(s_1\) the Spin.magnitude of the decaying state,

  • \(m_1\) the spin_projection of the decaying state,

  • \(\lambda_{2}, \lambda_{3}\) the helicities of the decay products in in the restframe of \(1\) (can be taken to be their intrinsic spin_projection when following a constistent boosting procedure),

  • and \(\phi\) and \(\theta\) the helicity angles (see also get_helicity_angle_label()).

Note that \(\lambda_2, \lambda_3\) are ordered by their number of children, then by their state ID (see TwoBodyDecay).

See [3], Eq. (30) for an example of Wigner-\(D\) functions in a sequential two-body decay.

Example

>>> import qrules
>>> reaction = qrules.generate_transitions(
...     initial_state=[("J/psi(1S)", [+1])],
...     final_state=[("gamma", [-1]), "f(0)(980)"],
... )
>>> transition = reaction.transitions[0]
>>> formulate_wigner_d(transition, node_id=0)
WignerD(1, 1, -1, -phi_0, theta_0, 0)
\[D^{s_1}_{m_1,\lambda_2-\lambda_3}\left(-\phi,\theta,0\right) = D^{1}_{+1,(-1-0)}\left(-\phi_0,\theta_0,0\right) = D^{1}_{1,-1}\left(-\phi_0,\theta_0,0\right)\]
../_images/graphviz_0.svg
get_prefactor(transition: StateTransition) float[source]

Calculate the product of all prefactors defined in this transition.

group_transitions(transitions: Iterable[StateTransition]) List[List[StateTransition]][source]

Match final and initial states in groups.

Each StateTransition corresponds to a specific state transition amplitude. This function groups together transitions, which have the same initial and final state (including spin). This is needed to determine the coherency of the individual amplitude parts.

Submodules and Subpackages