transition

import qrules.transition

Find allowed transitions between an initial and final state.

class SolvingMode(value)

Bases: Enum

Types of modes for solving.

FAST = 1

Find “likeliest” solutions only.

FULL = 2

Find all possible solutions.

class ExecutionInfo(not_executed_node_rules: Dict[int, Set[str]] = _Nothing.NOTHING, violated_node_rules: Dict[int, Set[str]] = _Nothing.NOTHING, not_executed_edge_rules: Dict[int, Set[str]] = _Nothing.NOTHING, violated_edge_rules: Dict[int, Set[str]] = _Nothing.NOTHING)

Bases: object

not_executed_node_rules: Dict[int, Set[str]]

violated_node_rules: Dict[int, Set[str]]

not_executed_edge_rules: Dict[int, Set[str]]

violated_edge_rules: Dict[int, Set[str]]

extend(other_result: ExecutionInfo, intersect_violations: bool = False) → None

clear() → None

class ProblemSet(topology: Topology, initial_facts: InitialFacts, solving_settings: GraphSettings)

Bases: object

Particle reaction problem set as a graph-like data structure.

topology: Topology

Topology over which the problem set is defined.

initial_facts: InitialFacts

Information about the initial and final state.

solving_settings: GraphSettings

Solving settings, such as conservation rules and QN-domains.

to_qn_problem_set() → QNProblemSet

class StateTransitionManager(initial_state: Sequence[Union[str, Tuple[str, Sequence[float]]]], final_state: Sequence[Union[str, Tuple[str, Sequence[float]]]], particle_db: Optional[ParticleCollection] = None, allowed_intermediate_particles: Optional[List[str]] = None, interaction_type_settings: Optional[Dict[InteractionType, Tuple[EdgeSettings, NodeSettings]]] = None, formalism: str = 'helicity', topology_building: str = 'isobar', solving_mode: SolvingMode = SolvingMode.FAST, reload_pdg: bool = False, mass_conservation_factor: Optional[float] = 3.0, max_angular_momentum: int = 1, max_spin_magnitude: float = 2.0, number_of_threads: Optional[int] = None)

Bases: object

Main handler for decay topologies.

See also

Generate transitions and generate_transitions

topologies: Tuple[Topology, ...]

Topology instances over which the STM propagates quantum numbers.

set_allowed_intermediate_particles(name_patterns: Union[Iterable[str], str], regex: bool = False) → None

property formalism: str

add_final_state_grouping(fs_group: Union[List[str], List[List[str]]]) → None

get_allowed_interaction_types() → Union[List[InteractionType], Dict[int, List[InteractionType]]]

get_allowed_interaction_types(node_id: int) → List[InteractionType]

set_allowed_interaction_types(allowed_interaction_types: Iterable[InteractionType], node_id: Optional[int] = None) → None

create_problem_sets() → Dict[float, List[ProblemSet]]

find_solutions(problem_sets: Dict[float, List[ProblemSet]]) → ReactionInfo

Check for solutions for a specific set of interaction settings.

find_quantum_number_transitions(problem_sets: Dict[float, List[ProblemSet]]) → Dict[float, List[Tuple[QNProblemSet, QNResult]]]

Find allowed transitions purely in terms of quantum number sets.

class State(particle: Particle, spin_projection: SupportsFloat)

Bases: object

particle: Particle

spin_projection: float

StateTransition: TypeAlias = 'FrozenTransition[State, InteractionProperties]'

Transition of some initial State to a final State.

class ReactionInfo(transitions: Iterable[FrozenTransition[State, InteractionProperties]], formalism: str)

Bases: object

Ordered collection of StateTransition instances.

transitions: Tuple[FrozenTransition[State, InteractionProperties], ...]

formalism: str

initial_state: FrozenDict[int, Particle]

final_state: FrozenDict[int, Particle]

get_intermediate_particles() → ParticleCollection

Extract the names of the intermediate state particles.

group_by_topology() → Dict[Topology, List[FrozenTransition[State, InteractionProperties]]]