refactor: adapt to latest version of sympy expertsystem

docs/usage.ipynb

@@ -60,7 +60,6 @@
     "import graphviz\n",
     "import matplotlib.pyplot as plt\n",
     "import pandas as pd\n",
-    "from expertsystem.amplitude.dynamics import set_resonance_dynamics\n",
     "from expertsystem.amplitude.dynamics.builder import (\n",
     "    create_relativistic_breit_wigner_with_ff,\n",
     ")\n",
@@ -100,20 +99,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "model = es.generate_amplitudes(result)\n",
-    "model.expression.top"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "model_builder = es.amplitude.get_builder(result)\n",
     "for name in result.get_intermediate_particles().names:\n",
-    "    set_resonance_dynamics(\n",
-    "        model, name, create_relativistic_breit_wigner_with_ff\n",
-    "    )"
+    "    model_builder.set_dynamics(name, create_relativistic_breit_wigner_with_ff)\n",
+    "model = model_builder.generate()"
    ]
   },
   {
@@ -126,7 +115,7 @@
    },
    "outputs": [],
    "source": [
-    "display(*model.expression.dynamics)"
+    "next(iter(model.components.values())).doit()"
    ]
   },
   {
@@ -139,16 +128,7 @@
    },
    "outputs": [],
    "source": [
-    "display(*sorted(model.parameters, key=lambda s: s.name))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "list(model.expression.dynamics.values())[1]"
+    "sorted(model.parameters, key=lambda s: s.name)"
    ]
   },
   {
@@ -176,7 +156,7 @@
    "outputs": [],
    "source": [
     "sympy_model = SympyModel(\n",
-    "    expression=model.expression.full_expression,\n",
+    "    expression=model.expression,\n",
     "    parameters={k: v.value for k, v in model.parameters.items()},\n",
     "    variables={},\n",
     ")\n",
@@ -199,20 +179,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "kin = HelicityKinematics(\n",
-    "    ParticleReactionKinematicsInfo(\n",
-    "        initial_state_names=[\n",
-    "            x.name for x in model.kinematics.initial_state.values()\n",
-    "        ],\n",
-    "        final_state_names=[\n",
-    "            x.name for x in model.kinematics.final_state.values()\n",
-    "        ],\n",
-    "        particles=model.particles,\n",
-    "        fs_id_event_pos_mapping=dict(\n",
-    "            {k: i for i, k in enumerate(model.kinematics.final_state.keys())}\n",
-    "        ),\n",
-    "    )\n",
-    ")\n",
+    "kin = HelicityKinematics.from_model(model)\n",
     "kin.register_subsystem(SubSystem([[3, 4], [2]], [], []))\n",
     "kin.register_subsystem(SubSystem([[3], [4]], [2], []))\n",
     "kin.register_invariant_mass([2, 4]);"
@@ -289,7 +256,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Optimize the amplitude model"
+    "## Optimize the amplitude model"
    ]
   },
   {

src/tensorwaves/physics/helicity_formalism/kinematics.py

@@ -17,6 +17,7 @@
 
 import amplitf.kinematics as tfa_kin
 import numpy as np
+from expertsystem.amplitude.helicity import HelicityModel
 from expertsystem.particle import ParticleCollection
 
 from tensorwaves.interfaces import Kinematics
@@ -73,13 +74,33 @@ def __init__(
 
         self._fs_id_event_pos_mapping = fs_id_event_pos_mapping
 
+    @staticmethod
+    def from_model(
+        model: HelicityModel,
+    ) -> "ParticleReactionKinematicsInfo":
+        return ParticleReactionKinematicsInfo(
+            initial_state_names=[
+                p.name for p in model.kinematics.initial_state.values()
+            ],
+            final_state_names=[
+                p.name for p in model.kinematics.final_state.values()
+            ],
+            particles=model.particles,
+            fs_id_event_pos_mapping=dict(
+                zip(
+                    model.kinematics.final_state,
+                    range(len(model.kinematics.final_state)),
+                )
+            ),
+        )
+
     @property
-    def initial_state_masses(self) -> List[float]:
-        return [p.mass for p in self._initial_state_particles]
+    def initial_state_masses(self) -> Tuple[float, ...]:
+        return tuple(p.mass for p in self._initial_state_particles)
 
     @property
-    def final_state_masses(self) -> List[float]:
-        return [p.mass for p in self._final_state_particles]
+    def final_state_masses(self) -> Tuple[float, ...]:
+        return tuple(p.mass for p in self._final_state_particles)
 
     @property
     def total_invariant_mass(self) -> float:
@@ -182,6 +203,11 @@ def __init__(self, reaction_info: ParticleReactionKinematicsInfo):
         self._registered_inv_masses: Dict[Tuple, str] = dict()
         self._registered_subsystems: Dict[SubSystem, Tuple[str, str]] = dict()
 
+    @staticmethod
+    def from_model(model: HelicityModel) -> "HelicityKinematics":
+        reaction_info = ParticleReactionKinematicsInfo.from_model(model)
+        return HelicityKinematics(reaction_info)
+
     @property
     def reaction_kinematics_info(self) -> ParticleReactionKinematicsInfo:
         return self._reaction_info

tests/conftest.py

@@ -3,7 +3,6 @@
 import expertsystem as es
 import numpy as np
 import pytest
-from expertsystem.amplitude.dynamics import set_resonance_dynamics
 from expertsystem.amplitude.dynamics.builder import (
     create_relativistic_breit_wigner_with_ff,
 )
@@ -153,13 +152,14 @@ def __create_model(formalism: str) -> SympyModel:
         allowed_interaction_types=["EM", "strong"],
         number_of_threads=1,
     )
-    model = es.generate_amplitudes(result)
+    model_builder = es.amplitude.get_builder(result)
     for name in result.get_intermediate_particles().names:
-        set_resonance_dynamics(
-            model, name, create_relativistic_breit_wigner_with_ff
+        model_builder.set_dynamics(
+            name, create_relativistic_breit_wigner_with_ff
         )
+    model = model_builder.generate()
     return SympyModel(
-        expression=model.expression.full_expression,
+        expression=model.expression,
         parameters={
             k: v.value if isinstance(v, ParameterProperties) else v
             for k, v in model.parameters.items()