monolith-pkg 0.1.0__tar.gz

monolith_pkg-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.3
+Name: monolith-pkg
+Version: 0.1.0
+Summary: Monolith package with C++ extensions
+Author: Aaron Berkhoff
+Author-email: aaronberkhoff@outlook.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: dev
+Requires-Dist: mypy (>=1.16.0,<2.0.0) ; extra == "dev"
+Requires-Dist: numpy (>=2.2.6,<3.0.0)
+Requires-Dist: pybind11 (>=2.11.0,<3.0.0) ; extra == "dev"
+Requires-Dist: pybind11-stubgen (>=2.5.5,<3.0.0) ; extra == "dev"

monolith_pkg-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[tool.poetry]
+name = "monolith-pkg"
+version = "0.1.0"
+description = "Monolith package with C++ extensions"
+authors = ["Aaron Berkhoff <aaronberkhoff@outlook.com>"]
+packages = [{include = "monolith", from = "python"}]
+include = [
+    {path = "python/monolith/dynamics*.so", format = "wheel"},
+    {path = "python/monolith/planets*.so", format = "wheel"},
+
+]
+
+[tool.poetry.dependencies]
+python = "^3.12"
+numpy = ">=2.2.6,<3.0.0"
+pybind11 = "^2.11.0"
+mypy = ">=1.16.0,<2.0.0"
+pybind11-stubgen = "^2.5.5"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.4.0"
+mypy = "^1.16.0"
+pylint = "^3.3.7"
+black = "^25.1.0"
+pre-commit = "^4.2.0"
+poetry = "^1.7.0"
+pybind11-stubgen = "^2.5.5"
+
+[tool.poetry.extras]
+dev = [
+    "pytest",
+    "mypy",
+    "pylint",
+    "black",
+    "pre-commit",
+    "poetry",
+    "pybind11",
+    "pybind11-stubgen",
+]
+
+# Include compiled C++ extensions
+# [[tool.poetry.include]]
+# path = "python/monolith/dynamics*.so"
+
+# [[tool.poetry.include]]
+# path = "python/monolith/planets*.so"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

monolith_pkg-0.1.0/python/monolith/dynamics_dep/__init__.py

@@ -0,0 +1,42 @@
+"""
+module for dynamics
+"""
+
+import torch
+
+
+class Dynamic:
+    def __init__(self, func=None):
+        self._func = func if func is not None else self.func
+
+    def __call__(self, state):
+        return self._func(state)
+
+    def __add__(self, other):
+        if not isinstance(other, Dynamic):
+            raise TypeError(
+                f"Cannot add object of type <{type(other)}> to type Dynamic"
+            )
+
+        return CombinedDynamics(self, other)
+
+    def __radd__(self, other):
+        if other == 0:
+            return self
+        return self.__add__(other)
+
+    def func(self, state):
+        return torch.zeros_like(state)  # Default: no dynamics
+
+
+class CombinedDynamics(Dynamic):
+
+    def __init__(self, *dynamics):
+        super().__init__()
+        self.dynamics = dynamics
+
+    def func(self, state):
+
+        for dyn in self.dynamics:
+
+            state @= dyn(state)

monolith_pkg-0.1.0/python/monolith/dynamics_dep/two_body.py

@@ -0,0 +1,64 @@
+import torch
+
+from monolith.dynamics_dep import Dynamic
+
+
+class TwoBody(Dynamic):
+    """
+    A class to represent a Keplerian dynamic.
+
+    Attributes
+    ----------
+    scenario : Scenario
+        The scenario of the dynamic.
+    agent : Agent
+        The agent of the dynamic.
+    stm : STM
+        The state transition matrix of the dynamic.
+    function : function
+        The function of the dynamic.
+    """
+
+    def __init__(self, central_body):
+        super.__init__(self)
+
+        """
+        Constructs all the necessary attributes for the Keplerian object.
+
+        Parameters
+        ----------
+        scenario : Scenario
+            The scenario of the dynamic.
+        agent : Agent
+            The agent of the dynamic.
+        stm : STM
+            The state transition matrix of the dynamic.
+
+        """
+
+        self.central_body = central_body
+
+    def func(self, state, time: float = None):
+        """
+        The function of the Keplerian dynamic.
+
+        Parameters
+        ----------
+        state : State
+            The state of the dynamic.
+        time : float
+            The time of the dynamic.
+
+        Returns
+        -------
+        State
+            The result of the function.
+        """
+
+        radius = torch.norm(state[0:3])
+
+        acceleration = -self.central_body.mu * state[0:3] / radius
+
+        dot = torch.stack([state[3:6], acceleration])
+
+        return acceleration

monolith_pkg-0.1.0/python/monolith/ode/__init__.py

@@ -0,0 +1,21 @@
+"""
+
+Module that holds Base ODE class and methods
+
+"""
+
+import torch
+
+
+class ODE:
+
+    def __init__(self, agents):
+
+        self.agents = agents
+        self.functions = [agent.dynamic for agent in agents]
+
+        pass
+
+    def solve(self):
+
+        pass

monolith_pkg-0.1.0/python/monolith/ode/ode87.py

@@ -0,0 +1,155 @@
+import torch
+from typing import Callable, Tuple
+
+
+class ODE78:
+    def __init__(self):
+        self.alpha = torch.tensor(
+            [
+                2 / 27,
+                1 / 9,
+                1 / 6,
+                5 / 12,
+                0.5,
+                5 / 6,
+                1 / 6,
+                2 / 3,
+                1 / 3,
+                1.0,
+                0.0,
+                1.0,
+            ],
+            dtype=torch.float64,
+        )
+
+        self.beta = torch.tensor(
+            [
+                [2 / 27] + [0] * 12,
+                [1 / 36, 1 / 12] + [0] * 11,
+                [1 / 24, 0, 1 / 8] + [0] * 10,
+                [5 / 12, 0, -25 / 16, 25 / 16] + [0] * 9,
+                [0.05, 0, 0, 0.25, 0.2] + [0] * 8,
+                [-25 / 108, 0, 0, 125 / 108, -65 / 27, 125 / 54] + [0] * 7,
+                [31 / 300, 0, 0, 0, 61 / 225, -2 / 9, 13 / 900] + [0] * 6,
+                [2, 0, 0, -53 / 6, 704 / 45, -107 / 9, 67 / 90, 3] + [0] * 5,
+                [
+                    -91 / 108,
+                    0,
+                    0,
+                    23 / 108,
+                    -976 / 135,
+                    311 / 54,
+                    -19 / 60,
+                    17 / 6,
+                    -1 / 12,
+                ]
+                + [0] * 4,
+                [
+                    2383 / 4100,
+                    0,
+                    0,
+                    -341 / 164,
+                    4496 / 1025,
+                    -301 / 82,
+                    2133 / 4100,
+                    45 / 82,
+                    45 / 164,
+                    18 / 41,
+                ]
+                + [0] * 3,
+                [3 / 205, 0, 0, 0, 0, -6 / 41, -3 / 205, -3 / 41, 3 / 41, 6 / 41, 0]
+                + [0] * 2,
+                [
+                    -1777 / 4100,
+                    0,
+                    0,
+                    -341 / 164,
+                    4496 / 1025,
+                    -289 / 82,
+                    2193 / 4100,
+                    51 / 82,
+                    33 / 164,
+                    12 / 41,
+                    0,
+                    1,
+                ],
+            ],
+            dtype=torch.float64,
+        )
+
+        self.chi = torch.tensor(
+            [
+                0,
+                0,
+                0,
+                0,
+                0,
+                34 / 105,
+                9 / 35,
+                9 / 35,
+                9 / 280,
+                9 / 280,
+                0,
+                41 / 840,
+                41 / 840,
+            ],
+            dtype=torch.float64,
+        )
+        self.psi = torch.tensor(
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1, -1], dtype=torch.float64
+        )
+        self.pow = 1 / 8
+
+    def integrate(
+        self,
+        func: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
+        t0: float,
+        tfinal: float,
+        dtmin: float,
+        y0: torch.Tensor,
+        tol: float,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+
+        t = torch.tensor(t0, dtype=torch.float64)
+        tf = torch.tensor(tfinal, dtype=torch.float64)
+        h = torch.sign(tf - t) * abs(dtmin)
+        hmin = abs(dtmin)
+        hmax = abs(tf - t)
+        y = y0.clone().double().reshape(-1, 1)
+        f = y.repeat(1, 13) * 0
+
+        forward = 1 if h.item() > 0 else -1
+        tout = [t]
+        yout = [y.view(-1).clone()]
+        varstep = tol != 0
+        tau = tol * max(torch.norm(y, p=float("inf")).item(), 1.0)
+
+        while t * forward < tf * forward:
+            if (t + h) * forward > tf * forward:
+                h = tf - t
+
+            f[:, 0] = func(t, y).view(-1)
+            for j in range(12):
+                yint = y + h * torch.matmul(f[:, : j + 1], self.beta[: j + 1, j])
+                f[:, j + 1] = func(t + self.alpha[j] * h, yint).view(-1)
+
+            if varstep:
+                gamma1 = h * 41 / 840 * torch.matmul(f, self.psi.view(-1, 1))
+                delta = torch.norm(gamma1, p=float("inf")).item()
+                tau = tol * max(torch.norm(y, p=float("inf")).item(), 1.0)
+            else:
+                delta = 0
+
+            if not varstep or delta <= tau or abs(h) == hmin:
+                t = t + h
+                y = y + h * torch.matmul(f, self.chi.view(-1, 1))
+                tout.append(t.clone())
+                yout.append(y.view(-1).clone())
+
+            if varstep and delta != 0.0:
+                h = forward * min(hmax, abs(0.8 * h * (tau / delta) ** self.pow))
+                if (t + h) * forward > tf * forward:
+                    h = tf - t
+                h = forward * max(abs(h), hmin)
+
+        return torch.stack(tout), torch.stack(yout)

monolith_pkg-0.1.0/python/monolith/states/__init__.py

@@ -0,0 +1,117 @@
+"""
+Author: Aaron Berkhoff:
+
+"""
+
+from typing import Optional
+from datetime import datetime
+import torch
+
+
+class State:
+    """
+    Object that stores state information:
+
+    Attributes:
+    ----------
+        position: torch tensor (3,1), optional
+        velocity: torch tensor (3,1), optional
+        acceleration: torch tensor (3,1), optional
+        attitude: torch tensor (4,1) or (3,1), optional
+        angular_velocity: torch tensor (3,1), optional
+        angular_acceleration: torch tensor (3,1), optional
+        latitude: torch tensor (1,1)
+        longitude: torch tensor (1,1)
+        altitude: torch tensor
+        time: datetime, optional
+        frame: str, optional:
+            The reference frame of the state ('inertial' or 'ECEF', default is 'inertial').
+        orbital_elements: monolith.orbital_elements, optional
+    """
+
+    position: Optional[torch.Tensor]
+    velocity: Optional[torch.Tensor]
+    acceleration: Optional[torch.Tensor]
+    attitude: Optional[torch.Tensor]
+    angular_velocity: Optional[torch.Tensor]
+    angular_acceleration: Optional[torch.Tensor]
+    latitude: Optional[torch.Tensor]
+    longitude: Optional[torch.Tensor]
+    altitude: Optional[torch.Tensor]
+    time: Optional[datetime]
+    orbital_elements: Optional[object]  # Replace with actual type if you have it
+
+    _supported_attributes = [
+        "position",
+        "velocity",
+        "acceleration",
+        "attitude",
+        "angular_velocity",
+        "angular_acceleration",
+        "latitude",
+        "longitude",
+        "altitude",
+        "time",
+        "orbital_elements",
+    ]
+
+    def __init__(self, frame="inertial", **kwargs):
+
+        # Initialize all known attributes to None
+        for attr in self._supported_attributes:
+            setattr(self, attr, None)
+
+        # Set attributes passed via kwargs
+        for key, value in kwargs.items():
+            if key in State._supported_attributes:
+                if isinstance(value, (list, tuple, float, int)):
+                    value = torch.tensor(value).view(-1, 1)
+                setattr(self, key, value)
+            else:
+                raise ValueError(f"kwarg <{key}> is not supported")
+
+        self.frame = frame
+
+    def get_full_state(self) -> torch.Tensor:
+        """
+        Concatenates all available tensor attributes in the documented order
+        into a single (N, 1) torch tensor.
+
+        Order:
+            position, velocity, acceleration, attitude,
+            angular_velocity, angular_acceleration,
+            latitude, longitude, altitude
+
+        Returns:
+            torch.Tensor: Concatenated state vector.
+        """
+        ordered_attrs = [
+            "position",
+            "velocity",
+            "acceleration",
+            "attitude",
+            "angular_velocity",
+            "angular_acceleration",
+            "latitude",
+            "longitude",
+            "altitude",
+        ]
+
+        tensors = []
+
+        for attr in ordered_attrs:
+            value = getattr(self, attr, None)
+            if isinstance(value, torch.Tensor):
+                tensors.append(value)
+
+        if tensors:
+            return torch.cat(tensors, dim=0)
+
+        raise ValueError("No tensor attributes are set on the State object.")
+
+    def placeholder(self, x):
+        """
+        Place holder
+        """
+
+        return False, x

monolith_pkg-0.1.0/python/monolith/utils/__init__.py

@@ -0,0 +1,6 @@
+"""
+Module that for utilities
+
+"""
+
+DATESTR = "%Y-%m-%dT%H:%M:%S.%f"  # Format for datetime strings compatible with SPICE