{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"source_hidden": true
},
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"%config Completer.use_jedi = False\n",
"%config InlineBackend.figure_formats = ['svg']"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Using composition"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"source_hidden": true
},
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"# !pip install matplotlib==3.3.3 sympy==1.7.1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"jupyter": {
"source_hidden": true
},
"tags": [
"hide-cell"
]
},
"outputs": [],
"source": [
"from typing import Tuple\n",
"\n",
"import attr\n",
"import sympy as sp\n",
"from helpers import (\n",
" StateTransitionGraph,\n",
" blatt_weisskopf,\n",
" determine_attached_final_state,\n",
" two_body_momentum_squared,\n",
")\n",
"\n",
"try:\n",
" from typing import Protocol\n",
"except ImportError:\n",
" from typing_extensions import Protocol # type: ignore"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A frozen `DynamicExpression` class keeps track of `variables`, `parameters`, and the dynamics `expression` in which they should appear:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"@attr.s(frozen=True)\n",
"class DynamicsExpression:\n",
" variables: Tuple[sp.Symbol, ...] = attr.ib()\n",
" parameters: Tuple[sp.Symbol, ...] = attr.ib()\n",
" expression: sp.Expr = attr.ib()\n",
"\n",
" def substitute(self) -> sp.Expr:\n",
" return self.expression(*self.variables, *self.parameters)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The `expression` attribute can be formulated as a simple Python function that takes `sympy.Symbol`s as arguments and returns a `sympy.Expr`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def relativistic_breit_wigner(\n",
" mass: sp.Symbol, mass0: sp.Symbol, gamma0: sp.Symbol\n",
") -> sp.Expr:\n",
" return gamma0 * mass0 / (mass0 ** 2 - mass ** 2 - gamma0 * mass0 * sp.I)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def relativistic_breit_wigner_with_form_factor(\n",
" mass: sp.Symbol,\n",
" mass0: sp.Symbol,\n",
" gamma0: sp.Symbol,\n",
" m_a: sp.Symbol,\n",
" m_b: sp.Symbol,\n",
" angular_momentum: sp.Symbol,\n",
" meson_radius: sp.Symbol,\n",
") -> sp.Expr:\n",
" q_squared = two_body_momentum_squared(mass, m_a, m_b)\n",
" q0_squared = two_body_momentum_squared(mass0, m_a, m_b)\n",
" ff2 = blatt_weisskopf(q_squared, meson_radius, angular_momentum)\n",
" ff02 = blatt_weisskopf(q0_squared, meson_radius, angular_momentum)\n",
" width = gamma0 * (mass0 / mass) * (ff2 / ff02)\n",
" width = width * sp.sqrt(q_squared / q0_squared)\n",
" return (\n",
" relativistic_breit_wigner(mass, mass0, width)\n",
" * mass0\n",
" * gamma0\n",
" * sp.sqrt(ff2)\n",
" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The `DynamicsExpression` container class enables us to provide the `expression` with correctly named `Symbol`s for the decay that is being described. Here, we use some naming scheme for an $f_0(980)$ decaying to final state edges 3 and 4 (say $\\pi^0\\pi^0$):"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"tags": [
"keep_output"
]
},
"outputs": [
{
"data": {
"text/latex": [
"$\\displaystyle \\frac{\\Gamma_{f(0)(980)} m_{f(0)(980)}}{- i \\Gamma_{f(0)(980)} m_{f(0)(980)} - m_{3+4}^{2} + m_{f(0)(980)}^{2}}$"
],
"text/plain": [
"\\Gamma_f(0)(980)*m_f(0)(980)/(-I*\\Gamma_f(0)(980)*m_f(0)(980) - m_3+4**2 + m_f(0)(980)**2)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"bw_decay_f0 = DynamicsExpression(\n",
" variables=sp.symbols(\"m_3+4\", seq=True),\n",
" parameters=sp.symbols(R\"m_f(0)(980) \\Gamma_f(0)(980)\"),\n",
" expression=relativistic_breit_wigner,\n",
")\n",
"bw_decay_f0.substitute()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For each dynamics expression, we have to provide a 'builder' function that can create a `DynamicsExpression` for a specific edge within the `StateTransitionGraph`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def relativistic_breit_wigner_from_graph(\n",
" graph: StateTransitionGraph, edge_id: int\n",
") -> DynamicsExpression:\n",
" edge_ids = determine_attached_final_state(graph, edge_id)\n",
" final_state_ids = map(str, edge_ids)\n",
" mass = sp.Symbol(f\"m_{{{'+'.join(final_state_ids)}}}\")\n",
" particle, _ = graph.get_edge_props(edge_id)\n",
" mass0 = sp.Symbol(f\"m_{{{particle.latex}}}\")\n",
" gamma0 = sp.Symbol(fR\"\\Gamma_{{{particle.latex}}}\")\n",
" return DynamicsExpression(\n",
" variables=(mass),\n",
" parameters=(mass0, gamma0),\n",
" expression=relativistic_breit_wigner(mass, mass0, gamma0),\n",
" )"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def relativistic_breit_wigner_with_form_factor_from_graph(\n",
" graph: StateTransitionGraph, edge_id: int\n",
") -> DynamicsExpression:\n",
" edge_ids = determine_attached_final_state(graph, edge_id)\n",
" final_state_ids = map(str, edge_ids)\n",
" mass = sp.Symbol(f\"m_{{{'+'.join(final_state_ids)}}}\")\n",
" particle, _ = graph.get_edge_props(edge_id)\n",
" mass0 = sp.Symbol(f\"m_{{{particle.latex}}}\")\n",
" gamma0 = sp.Symbol(fR\"\\Gamma_{{{particle.latex}}}\")\n",
" m_a = sp.Symbol(f\"m_{edge_ids[0]}\")\n",
" m_b = sp.Symbol(f\"m_{edge_ids[1]}\")\n",
" angular_momentum = particle.spin # helicity formalism only!\n",
" meson_radius = sp.Symbol(fR\"R_{{{particle.latex}}}\")\n",
" return DynamicsExpression(\n",
" variables=(mass),\n",
" parameters=(mass0, gamma0, m_a, m_b, angular_momentum, meson_radius),\n",
" expression=relativistic_breit_wigner_with_form_factor(\n",
" mass, mass0, gamma0, m_a, m_b, angular_momentum, meson_radius\n",
" ),\n",
" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The fact that `DynamicsExpression.expression` is just a Python function, allows one to inspect the dynamics formulation of these functions **independently**, purely in terms of SymPy:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"tags": [
"keep_output"
]
},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle \\frac{\\Gamma m_{0}}{- i \\Gamma m_{0} - m^{2} + m_{0}^{2}}$"
],
"text/plain": [
"\\Gamma*m_0/(-I*\\Gamma*m_0 - m**2 + m_0**2)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"m, m0, w0 = sp.symbols(R\"m m_0 \\Gamma\")\n",
"evaluated_bw = relativistic_breit_wigner(m, 1.0, 0.3)\n",
"sp.plot(sp.Abs(evaluated_bw), (m, 0, 2), axis_center=(0, 0), ylim=(0, 1))\n",
"sp.plot(sp.arg(evaluated_bw), (m, 0, 2), axis_center=(0, 0), ylim=(0, sp.pi))\n",
"relativistic_breit_wigner(m, m0, w0)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This closes the gap between the code and the theory that is being implemented."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Alternative signature"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"An alternative way to specify the expression is:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def expression(\n",
" variables: Tuple[sp.Symbol, ...], parameters: Tuple[sp.Symbol, ...]\n",
") -> sp.Expr:\n",
" pass"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here, one would however need to unpack the `variables` and `parameters`. The advantage is that the signature becomes more general."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Type checking"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There is no way to enforce the appropriate signature on the builder function, other than following a {class}`~typing.Protocol`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class DynamicsBuilder(Protocol):\n",
" def __call__(\n",
" self, graph: StateTransitionGraph, edge_id: int\n",
" ) -> DynamicsExpression:\n",
" ..."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This `DynamicsBuilder` protocol would be used in the syntax proposed at {ref}`adr/002:Considered solutions`.\n",
"\n",
"It carries another subtle problem, though: a {class}`~typing.Protocol` is only used in static type checking, while potential problems with the implementation of the builder and its respective expression only arrise at runtime."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.8"
}
},
"nbformat": 4,
"nbformat_minor": 4
}