physpyx 0.1.0__tar.gz

physpyx-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.3
+Name: physpyx
+Version: 0.1.0
+Summary: Provides a way to use python code in LaTeX
+Author: Jérôme Dufour
+Author-email: Jérôme Dufour <jerome.dufour@eduvaud.ch>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: Unix
+Classifier: Environment :: X11 Applications :: Qt
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Dist: numpy>=2.3.4
+Requires-Dist: pint>=0.25.1
+Requires-Dist: scipy>=1.17.0
+Requires-Python: >=3.13
+Project-URL: Repository, https://bitbucket.org/jdufour/physpyx/src/master/
+Project-URL: Changelog, https://bitbucket.org/jdufour/physpyx/src/master/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# PhysPyX
+

physpyx-0.1.0/README.md

@@ -0,0 +1,2 @@
+# PhysPyX
+

physpyx-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "physpyx"
+version = "0.1.0"
+authors = [
+	{ name="Jérôme Dufour", email="jerome.dufour@eduvaud.ch" },
+]
+description = "Provides a way to use python code in LaTeX"
+classifiers = [
+	"Programming Language :: Python :: 3",
+	"License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+	"Operating System :: Unix",
+	"Environment :: X11 Applications :: Qt",
+	"Topic :: Education",
+  "Topic :: Scientific/Engineering :: Physics"
+]
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+  "numpy>=2.3.4",
+  "pint>=0.25.1",
+  "scipy>=1.17.0",
+]
+
+[dependency-groups]
+dev = [
+  "mypy>=1.18.1",
+  "ipdb>=0.13.13",
+]
+docs = [
+	"sphinx>=7.1.2",
+	"sphinx-rtd-theme>=3.0.2",
+	"sphinx-argparse>=0.5.2",
+	"myst-parser>=4.0.1",
+	"sphinx-autodoc2>=0.5.0",
+	"sphinx-autobuild>=2025.8.25",
+]
+
+[build-system]
+requires = [ "uv-build" ]
+build-backend = "uv_build"
+
+[project.urls]
+Repository = "https://bitbucket.org/jdufour/physpyx/src/master/"
+Changelog = "https://bitbucket.org/jdufour/physpyx/src/master/CHANGELOG.md"
+

physpyx-0.1.0/src/physpyx/__init__.py

@@ -0,0 +1,5 @@
+from .nuclide import NuclideTable
+from .physpyx import PhysPyX
+from .qty import Qty
+
+__all__ = ["NuclideTable", "PhysPyX", "Qty"]

physpyx-0.1.0/src/physpyx/astronomy.py

@@ -0,0 +1,120 @@
+from typing import Iterator
+import numpy as np
+from numpy.typing import NDArray
+from scipy.special import ellipk, ellipkinc
+from scipy.optimize import newton
+
+
+class Orbit:
+    # https://en.wikipedia.org/wiki/Kepler_orbit
+    def __init__(
+        self,
+        *,
+        a: float,  # demi-grand axe
+        mu: float,  # gravitationnal constant x total mass, named alpha in the wiki page
+        e: float | None = None,  # eccentricite (e=0 -> cercle, e=1 -> parabola)
+        b: float | None = None,  # demi-petit axe
+    ):
+        self.a = a
+        self.mu = mu
+        if (e is None and b is None) or (e is not None and b is not None):
+            raise ValueError("Need to provide either 'e' or 'b'")
+        elif e is None and b is not None:
+            self.e = np.sqrt(1 - b * b / a / a)
+            self.b = b
+        elif b is None and e is not None:
+            self.e = e
+            self.b = self.a * np.sqrt(1.0 - self.e * self.e)
+        else:
+            raise ValueError
+
+        self.c = self.a * self.e  # linear eccentricity
+        self.p = self.a * (1.0 - self.e * self.e)  # semi-latus
+        self.T = 2 * np.pi * self.a * np.sqrt(self.a / self.mu)  # period
+
+        self.v0 = np.sqrt(self.mu / self.p)
+        self.F = np.sqrt(self.a * self.a - self.b * self.b)  # foyer
+
+        self.theta = 0
+        self.x = np.array([self.p / (1 + self.e), 0])
+        self.v = self.v0 * np.array([0, self.e + 1])
+
+    def __str__(self):
+        return (
+            f"T={self.T}, "
+            f"a={self.a}, "
+            f"b={self.b}, "
+            f"c={self.c}, "
+            f"e={self.e}, "
+            f"mu={self.mu}, "
+            f"F={self.F}, "
+            f"T^2/a^3={4 * np.pi * np.pi / self.mu}"
+        )
+
+    def step(self, dt: float) -> None:
+        self.theta = np.arctan2(self.x[1], self.x[0])
+        self.v = self.v0 * np.array([-np.sin(self.theta), self.e + np.cos(self.theta)])
+        r = self.p / (1 + self.e * np.cos(self.theta))
+        self.x = r * np.array([np.cos(self.theta), np.sin(self.theta)]) + self.v * dt
+
+    def run(
+        self,
+        steps: int,
+        every: int = 1,
+    ) -> Iterator[NDArray]:
+        if steps % every:
+            raise ValueError(f"{every} is not a divisor {steps} steps")
+
+        dt = self.T / steps
+        for i in range(0, steps + 1):
+            if i % every == 0:
+                yield self.x
+            self.step(dt)
+
+    def even_spacing(self, n: int) -> Iterator[NDArray]:
+        m = self.e * self.e
+        P = 4 * self.a * ellipk([m])[0]
+
+        def func(phi, arc_length):
+            return self.a * ellipkinc(phi, m) - arc_length
+
+        for i in range(n + 1):
+            phi = np.pi / 2 - newton(func, x0=np.pi / 2 * i / n, args=[P * i / n])
+            r = self.b / np.sqrt(1 - (self.e * np.cos(phi)) ** 2)
+            yield np.array([-self.F + r * np.cos(phi), r * np.sin(phi)])
+
+    def get_acceleration(self) -> NDArray:
+        x = np.sqrt(self.x.dot(self.x))
+        return -self.mu / (x * x * x) * self.x
+
+    def get_circle_tangent_to_ellipse(self) -> tuple[NDArray, float]:
+        # get the norm of the velocity
+        vt = np.sqrt(self.v.dot(self.v))
+
+        # define unit vectors tangent and perp to ellipse
+        vec_t = self.v / vt
+        vec_p = np.array([-vec_t[1], vec_t[0]])
+
+        # compute cetripetal acceleration
+        a = self.get_acceleration()
+        ac = a.dot(vec_p)
+
+        # compute radius of circle
+        r = vt * vt / ac
+        if self.v[0]:
+            m = -self.v[0] / self.v[1]
+            beta = r / np.sqrt(1 + m * m)
+            if self.x[0] > -self.c:
+                x0 = self.x[0] - beta
+                y0 = self.x[1] - m * beta
+            else:
+                x0 = self.x[0] + beta
+                y0 = self.x[1] + m * beta
+        else:
+            y0 = 0
+            if self.x[0] > -self.c:
+                x0 = self.x[0] - r
+            else:
+                x0 = self.x[0] + r
+
+        return np.array([x0, y0]), r