Add files via upload

src/python/espressomd/interactions.py

@@ -19,9 +19,9 @@
 
 import abc
 import enum
-from sympy import sympify, symbols,oo,nan
 import numpy as np
 from . import code_features
+import sympy as sp
 from .script_interface import ScriptObjectMap, ScriptInterfaceHelper, script_interface_register
 
 
@@ -343,56 +343,35 @@ class TabulatedNonBonded(NonBondedInteraction):
         force: array_like of :obj:`float`
             The force table.
 
+    set_analytical()
+        Set new parameters from a function f(dist_param) for a given inter-particle distance.
+
+        Parameters
+        ----------
+        min : :obj:'float',
+            The minimal interaction distance.
+        max : :obj:'float',
+            The maximal interaction distance.
+        f: expression of: obj: 'str' or 'sympy.Piecewise'
+            Analytical potential f(dist_param) 
+        steps: :obj: 'int'
+            Fineness of the potential
+        dist_param: obj: 'str', optional
+            Parameter for inter-particle distance (default: r)
+
+    
     """
+
     _so_name = "Interactions::InteractionTabulated"
-    _so_feature = "TABULATED"
+    _so_feature = "TABULATED"    
 
     def default_params(self):
         """Python dictionary of default parameters.
 
         """
         return {}
-
-    def set_params(self, **kwargs):
-        """Set new parameters.
 
-        """
-        params = self.default_params()
-        params.update(kwargs)
-
-        if "energy" not in params or "force" not in params:
-            required_keys = {"min", "max", "steps", "f"}
-            missing_keys = required_keys - params.keys()
-            if missing_keys:
-                raise ValueError(
-                    f"Missing keys for table generation: {missing_keys}. "
-                    f"To generate energy and force tables, provide {required_keys}."
-                )
-
-            # Berechnung von Energie- und Krafttabellen mit `get_table`
-            energy_tab, force_tab = self.get_table(
-                min=params["min"],
-                max=params["max"],
-                steps=params["steps"],
-                f=params["f"],
-                **{k: v for k, v in params.items() if k not in required_keys}  # Zusätzliche Parameter
-            )
-            params["energy"] = energy_tab
-            params["force"] = force_tab
-
-        relevant_keys = {"min", "max", "energy", "force"}
-        filtered_params = {k: params[k] for k in relevant_keys if k in params}
-
-        err_msg = f"setting {self.__class__.__name__} raised an error"
-        self.call_method("set_params", handle_errors_message=err_msg, **filtered_params)
-
-
-
-    def get_table(self, **kwargs):
-        """
-        Generate energy and force tables.
-        """
-        # Erforderliche Parameter extrahieren
+    def set_analytical(self,dist_param="r", **kwargs):
         try:
             min_val = kwargs["min"]
             max_val = kwargs["max"]
@@ -401,32 +380,37 @@ def get_table(self, **kwargs):
         except KeyError as e:
             raise ValueError(f"Missing required parameter: {e.args[0]}") from e
 
-        # Symbole und Ausdrücke vorbereiten
-        r = symbols("r")
-        energy = sympify(expression)
+
+        r = sp.symbols(dist_param)
+        if isinstance(expression, (sp.Expr, sp.Piecewise)):
+            energy = expression
+        else:
+            try:
+                energy = sp.sympify(expression)
+            except Exception as e:
+                raise ValueError("The provided function must be a sympy-compatible input or string.") from e
+
         force = -energy.diff(r)
 
-        # Zusätzliche Variablen ersetzen
         for var, value in kwargs.items():
-            if str(var) in expression:
-                symbol = symbols(var)
+            if str(var) in str(expression):
+                symbol = sp.symbols(var)
                 energy = energy.subs(symbol, value)
                 force = force.subs(symbol, value)
 
-        # Tabellen berechnen
         x_values = np.linspace(min_val, max_val, steps)
         energy_tab = [
             float(energy.subs(r, x))
             for x in x_values
-            if energy.subs(r, x).is_real and not energy.subs(r, x).has(oo, nan)
+            if energy.subs(r, x).is_real and not energy.subs(r, x).has(sp.oo, sp.nan)
         ]
         force_tab = [
             float(force.subs(r, x))
             for x in x_values
-            if force.subs(r, x).is_real and not force.subs(r, x).has(oo, nan)
+            if force.subs(r, x).is_real and not force.subs(r, x).has(sp.oo, sp.nan)
         ]
 
-        return energy_tab, force_tab
+        self.set_params(min=min_val,max=max_val,energy=energy_tab, force=force_tab)
 
     @property
     def cutoff(self):