Struct RuleSet 

pub struct RuleSet {

    pub parity: bool,
    pub isospin: bool,
    pub isospin_projection: bool,
    pub c_parity: bool,
    pub g_parity: bool,
    pub charge: bool,
    pub strangeness: bool,
    pub charm: bool,
    pub bottomness: bool,
    pub topness: bool,
    pub baryon_number: bool,
    pub electron_lepton_number: bool,
    pub muon_lepton_number: bool,
    pub tau_lepton_number: bool,
    pub lepton_number: bool,
    pub identical_particle_symmetry: bool,
}

A collection of optional selection rules for testing whether a two-body decay channel is allowed.

Each boolean enables one conservation or symmetry check. Disabled checks are ignored. Enabled checks are treated permissively with respect to missing quantum numbers: if the required values are not known, that check does not reject the channel.

The purely angular-momentum constraints are not represented here. Those are handled separately when constructing candidate partial waves.

Fields

parity: bool

Enforce intrinsic parity conservation.

For a two-body final state this checks $P_\text{parent} = P_a P_b (-1)^L$.

isospin: bool

Enforce total isospin coupling.

This checks whether the two daughter isospins can couple to the parent isospin: $I_\text{parent} \in |I_a - I_b|, \ldots, I_a + I_b$.

isospin_projection: bool

Enforce conservation of the isospin projection $I_3$.

This checks $I_{3,\text{parent}} = I_{3,a} + I_{3,b}$.

c_parity: bool

Enforce charge-conjugation parity conservation when applicable.

This is only meaningful for states with a defined $C$ eigenvalue and final states that can be interpreted as $C$ eigenstates, such as suitable particle-antiparticle combinations.

g_parity: bool

Enforce G-parity conservation when applicable.

This is mainly useful for light-quark isospin multiplets where $G$-parity is defined. It should not be enabled blindly for arbitrary hadrons.

charge: bool

Enforce electric charge conservation.

This checks $Q_\text{parent} = Q_a + Q_b$.

strangeness: bool

Enforce strangeness conservation.

This checks $S_\text{parent} = S_a + S_b$.

Strong and electromagnetic interactions conserve strangeness; weak interactions generally do not.

charm: bool

Enforce charm conservation.

This checks $C_\text{parent} = C_a + C_b$, where $C$ here denotes charm quantum number, not charge conjugation.

bottomness: bool

Enforce bottomness conservation.

This checks $B'_\text{parent} = B'_a + B'_b$, where $B'$ denotes bottomness, not baryon number.

topness: bool

Enforce topness conservation.

This checks $T_\text{parent} = T_a + T_b$.

baryon_number: bool

Enforce baryon-number conservation.

This checks $B_\text{parent} = B_a + B_b$.

electron_lepton_number: bool

Enforce electron-family lepton-number conservation.

This checks $L_e(\text{parent}) = L_e(a) + L_e(b)$.

muon_lepton_number: bool

Enforce muon-family lepton-number conservation.

This checks $L_\mu(\text{parent}) = L_\mu(a) + L_\mu(b)$.

tau_lepton_number: bool

Enforce tau-family lepton-number conservation.

This checks $L_\tau(\text{parent}) = L_\tau(a) + L_\tau(b)$.

lepton_number: bool

Enforce total lepton-number conservation.

This checks $L_\text{parent} = L_a + L_b$, where $L = L_e + L_\mu + L_\tau$.

This is independent of the individual lepton-family checks. If both this and the family-specific checks are enabled, all enabled checks must pass.

identical_particle_symmetry: bool

Enforce exchange-symmetry constraints for identical final-state particles when enough information is available.

At minimum, this is useful for cases such as identical spin-zero bosons, where only even $L$ is allowed.

Implementations

impl RuleSet

pub fn angular() -> Self

Construct a rule set with no non-angular selection rules enabled.

This is useful when only the angular-momentum coupling constraints should be applied: $S \in |j_a - j_b|, \ldots, j_a + j_b$ and $J \in |L - S|, \ldots, L + S$.

pub fn strong() -> Self

Construct a rule set appropriate for ordinary strong two-body decays.

This enables parity, isospin, isospin projection, electric charge, flavor quantum numbers, baryon number, and identical-particle exchange symmetry.

Charge-conjugation parity and G-parity are left disabled because they are only meaningful for certain channels and should be enabled explicitly when applicable.

pub fn electromagnetic() -> Self

Construct a rule set appropriate for electromagnetic two-body decays.

This enables parity, electric charge, flavor quantum numbers, baryon number, isospin-projection conservation, and identical-particle exchange symmetry.

Total isospin is not enabled because electromagnetic interactions break isospin symmetry.

pub fn weak() -> Self

Construct a rule set appropriate for weak two-body decays.

This enables electric charge, baryon number, individual lepton-family numbers, total lepton number, and identical-particle exchange symmetry.

Parity, isospin, strangeness, charm, bottomness, and topness are not enabled because weak interactions can violate or change them.

pub fn check( &self, parent: &ParticleProperties, daughters: (&ParticleProperties, &ParticleProperties), l: OrbitalAngularMomentum, s: AngularMomentum, ) -> bool

Check whether a candidate two-body partial wave satisfies this rule set.

parent is the decaying particle, daughters are the two final-state particles, l is their relative orbital angular momentum, and s is their coupled spin.

Returns false if any enabled rule is definitely violated. Returns true if all enabled rules pass or if some enabled rules cannot be evaluated because the required quantum numbers are unknown.

The angular-momentum coupling itself should be checked before or during candidate partial-wave construction; this method only applies the selected conservation and symmetry rules.

Trait Implementations

impl Clone for RuleSet

fn clone(&self) -> RuleSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuleSet

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

Formats the value using the given formatter.

impl Default for RuleSet

fn default() -> RuleSet

Returns the “default value” for a type.

impl Hash for RuleSet

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 RuleSet

fn eq(&self, other: &RuleSet) -> 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 Eq for RuleSet

impl StructuralPartialEq for RuleSet