amplitude

Amplitude module for the helicity formalism.

Its responsibility is the construction of complicated helicity formalism amplitude models using a recipe (see IntensityBuilder). These models are encapsulated in an IntensityTF class, which can be evaluated as a regular callable.

class DynamicsProperties(orbit_angular_momentum: float, resonance_mass: float, resonance_width: float, inv_mass_name: str, inv_mass_name_prod1: str, inv_mass_name_prod2: str, meson_radius: Optional[float])[source]

Bases: tuple

Data structure representing dynamic properties.

inv_mass_name: str

Alias for field number 3

inv_mass_name_prod1: str

Alias for field number 4

inv_mass_name_prod2: str

Alias for field number 5

meson_radius: Optional[float]

Alias for field number 6

orbit_angular_momentum: float

Alias for field number 0

resonance_mass: float

Alias for field number 1

resonance_width: float

Alias for field number 2

class IntensityBuilder(particles: expertsystem.particle.ParticleCollection, kinematics: tensorwaves.physics.helicity_formalism.kinematics.HelicityKinematics, phsp_data: Optional[numpy.ndarray] = None)[source]

Bases: object

Builds Intensities from helicity formalism recipe files.

Parameters

  • particles – Contains info of various particles.

  • kinematics – A helicity kinematics instance. Note that this kinematics instance will be modified in the process.

  • phsp_data – A phase space event collection, required if a normalization of the Intensity is performed.

create_dynamics(decaying_state: expertsystem.particle.Particle, dynamics_properties: tensorwaves.physics.helicity_formalism.amplitude.DynamicsProperties) → Callable[source]

Create a dynamics function callable.

create_element(intensity_node: expertsystem.amplitude.model.Node) → Callable[source]

Create a computation element from the recipe.

The recipe can only contain names registered in the pool of known element builders.

create_intensity(model: expertsystem.amplitude.model.AmplitudeModel) → tensorwaves.physics.helicity_formalism.amplitude.IntensityTF[source]

Create an IntensityTF instance based on a recipe.

Parameters

model – Contains builder instructions. These recipe files can be generated via the expert system (see Create amplitude models).

get_normalization_data() → Tuple[dict, float][source]

Return phase space dataset and its volume.

get_parameter(name: str) → tensorflow.python.ops.variables.Variable[source]
register_dynamics_builder(dynamics_name: Type[expertsystem.amplitude.model.Dynamics], builder: Callable[[str, tensorwaves.physics.helicity_formalism.amplitude.DynamicsProperties], Callable]) → None[source]

Register custom dynamics function builders.

register_parameter(name: str, value: float) → tensorflow.python.ops.variables.Variable[source]
class IntensityTF(tf_model: Callable, parameters: Dict[str, tensorflow.python.ops.variables.Variable])[source]

Bases: tensorwaves.interfaces.Function

Implementation of the Function interface using tensorflow.

Initialize the intensity based on a tensorflow model.

Parameters

  • tf_model – A callable with potential tensorflow code.

  • parameters – The collection of parameters of the model.

__call__(dataset: Dict[str, numpy.ndarray]) → numpy.ndarray[source]

Evaluate the Intensity.

Parameters

dataset – Contains all required kinematic variables.

Returns

List of intensity values.

property parameters

Get dict of parameters.

update_parameters(new_parameters: dict) → None[source]

Update the collection of parameters.

helicity_formalism kinematics