Struct SelectionRules 

pub struct SelectionRules {
    pub rules: RuleSet,
    pub max_l: L,
}

Configuration for generating and filtering allowed two-body partial waves.

SelectionRules combines a maximum orbital angular momentum with a RuleSet. Candidate waves are generated from angular-momentum coupling and are then filtered by the enabled rules.

The generated waves satisfy $S \in |j_a - j_b|, \ldots, j_a + j_b$ and $J \in |L - S|, \ldots, L + S$, with $0 \le L \le L_\text{max}$.

Fields

rules: RuleSet

Conservation and symmetry rules used to filter candidate waves.

Angular-momentum compatibility is handled by SelectionRules::allowed_partial_waves. The RuleSet applies additional checks such as parity, charge, isospin, flavor quantum numbers, $C$-parity, $G$-parity, and identical-particle symmetry.

max_l: L

Maximum orbital angular momentum $L_\text{max}$ considered when generating candidate partial waves.

The solver scans all integer values $L = 0, 1, \ldots, L_\text{max}$.

Implementations

impl SelectionRules

pub fn new(rules: RuleSet, max_l: L) -> Self

Construct a partial-wave scanner from a rule set and maximum orbital angular momentum.

pub fn angular(max_l: L) -> Self

Construct a scanner which applies only angular-momentum coupling.

pub fn electromagnetic(max_l: L) -> Self

Construct a scanner configured for electromagnetic decays.

pub fn weak(max_l: L) -> Self

Construct a scanner configured for weak decays.

pub fn strong(max_l: L) -> Self

Construct a scanner configured for strong decays.

pub fn coupled_spins(a: J, b: J) -> Vec<S>

Return all possible coupled total spins from two daughter spins.

Given daughter spins $j_a$ and $j_b$, this returns $S = |j_a - j_b|, |j_a - j_b| + 1, \ldots, j_a + j_b$.

Internally angular momenta are stored as doubled values, so the returned sequence advances by two in the doubled representation.

pub fn scan_partial_waves( &self, parent: &ParticleProperties, daughters: (&ParticleProperties, &ParticleProperties), ) -> PartialWaveScan

Generate all candidates and retain detailed reports for accepted and rejected waves.

pub fn allowed_partial_waves( &self, parent: &ParticleProperties, daughters: (&ParticleProperties, &ParticleProperties), ) -> Vec<AllowedPartialWave>

Generate all allowed two-body partial waves for a parent and two daughters.

The parent spin is interpreted as the total angular momentum $J$ of the resonance. The daughter spins are coupled to possible total-spin values $S$, and each $S$ is combined with orbital angular momenta $L = 0, 1, \ldots, L_\text{max}$.

A candidate wave is kept when:

1. $L$ and $S$ can couple to the parent $J$.
2. The enabled RuleSet checks do not reject it.

Returns an empty vector if the parent spin or either daughter spin is unknown.

The returned AllowedPartialWave includes the underlying PartialWave together with channel-dependent inferred quantum numbers, such as final-state parity and, when meaningful, $C$-parity.

Trait Implementations

impl Clone for SelectionRules

fn clone(&self) -> SelectionRules

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SelectionRules

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

Formats the value using the given formatter.

impl Default for SelectionRules

fn default() -> Self

Returns the “default value” for a type.

impl Eq for SelectionRules

impl Hash for SelectionRules

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SelectionRules

fn eq(&self, other: &SelectionRules) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SelectionRules