def amplitude_model(reaction: ReactionInfo) -> Tuple[str, HelicityModel]:
model_builder = get_builder(reaction)
for name in reaction.get_intermediate_particles().names:
model_builder.set_dynamics(name,
create_relativistic_breit_wigner_with_ff)
model = model_builder.formulate()
return reaction.formalism, model
def test_stable_final_state_ids(self, reaction: ReactionInfo):
builder: HelicityAmplitudeBuilder = get_builder(reaction)
assert builder.stable_final_state_ids is None
builder.stable_final_state_ids = (1, 2) # type: ignore[assignment]
assert builder.stable_final_state_ids == {1, 2}
with pytest.raises(
ValueError, match=r"^Final state IDs are \[0, 1, 2\].*"
):
builder.stable_final_state_ids = [1, 2, 3] # type: ignore[assignment]
def test_parity_amplitude_coupling(test_input: Input, n_parameters: int):
stm = StateTransitionManager(
initial_state=test_input.initial_state,
final_state=test_input.final_state,
allowed_intermediate_particles=test_input.intermediate_states,
number_of_threads=1,
)
problem_sets = stm.create_problem_sets()
reaction = stm.find_solutions(problem_sets)
model_builder = get_builder(reaction)
amplitude_model = model_builder.formulate()
assert len(amplitude_model.parameter_defaults) == n_parameters
def test_scalar_initial_state(self, reaction: ReactionInfo):
builder: HelicityAmplitudeBuilder = get_builder(reaction)
assert builder.scalar_initial_state_mass is False
initial_state_mass = sp.Symbol("m_012", real=True)
model = builder.formulate()
assert initial_state_mass in model.kinematic_variables
assert initial_state_mass not in model.parameter_defaults
builder.scalar_initial_state_mass = True
model = builder.formulate()
assert initial_state_mass not in model.kinematic_variables
assert initial_state_mass in model.parameter_defaults
def test_formulate(
self,
permutate_topologies,
reaction: ReactionInfo,
stable_final_state_ids,
):
# pylint: disable=too-many-locals
if reaction.formalism == "canonical-helicity":
n_amplitudes = 16
n_parameters = 4
else:
n_amplitudes = 8
n_parameters = 2
n_kinematic_variables = 9
n_symbols = 4 + n_parameters
if stable_final_state_ids is not None:
n_parameters += len(stable_final_state_ids)
n_kinematic_variables -= len(stable_final_state_ids)
model_builder: HelicityAmplitudeBuilder = get_builder(reaction)
model_builder.stable_final_state_ids = stable_final_state_ids
if permutate_topologies:
model_builder.adapter.permutate_registered_topologies()
n_kinematic_variables += 10
model = model_builder.formulate()
assert len(model.parameter_defaults) == n_parameters
assert len(model.components) == 4 + n_amplitudes
assert len(model.expression.free_symbols) == n_symbols
assert len(model.kinematic_variables) == n_kinematic_variables
variables = set(model.kinematic_variables)
paremeters = set(model.parameter_defaults)
assert model.expression.free_symbols <= variables | paremeters
final_state_masses = set(sp.symbols("m_(0:3)", real=True))
stable_final_state_masses = set()
if stable_final_state_ids is not None:
stable_final_state_masses = {
sp.Symbol(f"m_{i}", real=True) for i in stable_final_state_ids
}
unstable_final_state_masses = (
final_state_masses - stable_final_state_masses
)
assert stable_final_state_masses <= paremeters
assert unstable_final_state_masses <= variables
no_dynamics: sp.Expr = model.expression.doit()
no_dynamics = no_dynamics.subs(model.parameter_defaults)
assert len(no_dynamics.free_symbols) == 1
existing_theta = next(iter(no_dynamics.free_symbols))
theta = sp.Symbol("theta", real=True)
no_dynamics = no_dynamics.subs({existing_theta: theta})
no_dynamics = no_dynamics.trigsimp()
if reaction.formalism == "canonical-helicity":
assert (
no_dynamics
== 0.8 * sp.sqrt(10) * sp.cos(theta) ** 2
+ 4.4 * sp.cos(theta) ** 2
+ 0.8 * sp.sqrt(10)
+ 4.4
)
else:
assert no_dynamics == 8.0 - 4.0 * sp.sin(theta) ** 2