Student

environment.yml

@@ -9,7 +9,7 @@ dependencies:
   - myst-parser # for markdown math in docs
   - pykep>=2.6 # core non-optional dependency
   - pyquaternion>=0.9.9 # core non-optional dependency
-  - pytest # for tests
+  - pytest<8.0.0 # for tests
   - pytest-asyncio # for tests involving activities
   - python>=3.8 # core non-optional dependency
   - scikit-spatial>=6.5.0 # core non-optional dependency

paseos/actors/actor_builder.py

@@ -13,7 +13,8 @@
 from ..thermal.thermal_model import ThermalModel
 from ..power.power_device_type import PowerDeviceType
 from ..radiation.radiation_model import RadiationModel
-from paseos.geometric_model.geometric_model import GeometricModel
+from .spacecraft_body_model import SpacecraftBodyModel
+from ..attitude.attitude_model import AttitudeModel
 
 
 class ActorBuilder:
@@ -307,32 +308,49 @@ def set_position(actor: BaseActor, position: list):
         logger.debug(f"Setting position {position} on actor {actor}")
 
     @staticmethod
-    def set_geometric_model(
+    def set_spacecraft_body_model(
         actor: SpacecraftActor, mass: float, vertices=None, faces=None, scale: float = 1
     ):
         """Define geometry of the spacecraft actor. This is done in the spacecraft body reference frame, and can be
-        transformed to the inertial/PASEOS reference frame using the reference frane transformations in the attitude
+        transformed to the inertial/PASEOS reference frame using the reference frame transformations in the attitude
         model. When used in the attitude model, the geometric model is in the body reference frame.
 
         Args:
             actor (SpacecraftActor): Actor to update.
             mass (float): Mass of the spacecraft in kg.
-            vertices (list): List of all vertices of the mesh in terms of distance (in m) from origin of body frame.
-                Coordinates of the corners of the object. If not selected, it will default to a cube that can be scaled.
+            vertices (list): List of coordinates [x, y, z] of the vertices of the mesh w.r.t. the body frame [m].
+                If not selected, it will default to a cube that can be scaled.
                 by the scale. Uses Trimesh to create the mesh from this and the list of faces.
             faces (list): List of the indexes of the vertices of a face. This builds the faces of the satellite by
                 defining the three vertices to form a triangular face. For a cuboid each face is split into two
                 triangles. Uses Trimesh to create the mesh from this and the list of vertices.
             scale (float): Parameter to scale the cuboid by, defaults to 1.
         """
+        # check for spacecraft actor
+        assert isinstance(
+            actor, SpacecraftActor
+        ), "Body model is only supported for SpacecraftActors."
+
         assert mass > 0, "Mass is > 0"
 
+        # Check if the actor already has mass.
+        if actor.mass:
+            logger.warning("The actor already had a mass. Overriding old mass value.")
+
         actor._mass = mass
-        geometric_model = GeometricModel(
-            local_actor=actor, actor_mass=mass, vertices=vertices, faces=faces, scale=scale
+
+        # Check if the actor already had a has_spacecraft_body_model.
+        if actor.has_spacecraft_body_model:
+            logger.warning(
+                "The actor already had a spacecraft body model. Overriding old body bodel."
+            )
+
+        # Create a spacraft body model
+        actor._spacecraft_body_model = SpacecraftBodyModel(
+            actor_mass=mass, vertices=vertices, faces=faces, scale=scale
         )
-        actor._mesh = geometric_model.set_mesh()
-        actor._moment_of_inertia = geometric_model.find_moment_of_inertia
+
+        # Check if the actor has a moment of inertia
 
     @staticmethod
     def set_power_devices(
@@ -519,6 +537,81 @@ def set_thermal_model(
             power_consumption_to_heat_ratio=power_consumption_to_heat_ratio,
         )
 
+    @staticmethod
+    def set_attitude_disturbances(
+        actor: SpacecraftActor,
+        aerodynamic: bool = False,
+        gravitational: bool = False,
+        magnetic: bool = False,
+    ):
+        """Enables the attitude disturbances to be considered in the attitude modelling for an actor.
+
+        Args:
+            actor (SpacecraftActor): The actor to add to.
+            aerodynamic (bool): Whether to consider aerodynamic disturbances in the attitude model. Defaults to False.
+            gravitational (bool): Whether to consider gravity disturbances in the attitude model. Defaults to False.
+            magnetic (bool): Whether to consider magnetic disturbances in the attitude model. Defaults to False.
+        """
+        # check for spacecraft actor
+        assert isinstance(
+            actor, SpacecraftActor
+        ), "Attitude disturbances are only supported for SpacecraftActors."
+
+        assert (
+            actor.has_attitude_model
+        ), "The actor has no attitude model. Impossible to set attitude disturbances."
+
+        # Create a list with user specified disturbances which are considered in the attitude modelling.
+        disturbance_list = []
+
+        if aerodynamic:
+            disturbance_list.append("aerodynamic")
+        if gravitational:
+            disturbance_list.append("gravitational")
+        if magnetic:
+            disturbance_list.append("magnetic")
+        # Set attitude models.
+        actor._attitude_model._disturbances = disturbance_list
+
+    @staticmethod
+    def set_attitude_model(
+        actor: SpacecraftActor,
+        actor_initial_attitude_in_rad: list[float] = [0.0, 0.0, 0.0],
+        actor_initial_angular_velocity: list[float] = [0.0, 0.0, 0.0],
+        actor_pointing_vector_body: list[float] = [0.0, 0.0, 1.0],
+        actor_residual_magnetic_field: list[float] = [0.0, 0.0, 0.0],
+    ):
+        """Add an attitude model to the actor based on initial conditions: attitude (roll, pitch & yaw angles)
+        and angular velocity vector, modeling the evolution of the user specified pointing vector.
+
+        Args:
+            actor (SpacecraftActor): Actor to model.
+            actor_initial_attitude_in_rad (list of floats): Actor's initial attitude. Defaults to [0.0, 0.0, 0.0].
+            actor_initial_angular_velocity (list of floats): Actor's initial angular velocity. Defaults to [0.0, 0.0, 0.0].
+            actor_pointing_vector_body (list of floats): Actor's pointing vector. Defaults to [0.0, 0.0, 1.0].
+            actor_residual_magnetic_field (list of floats): Actor's residual magnetic dipole moment vector.
+            Defaults to [0.0, 0.0, 0.0].
+        """
+        # check for spacecraft actor
+        assert isinstance(
+            actor, SpacecraftActor
+        ), "Attitude model is only supported for SpacecraftActors"
+
+        # Check if actor has already an attitude model.
+        if actor.has_attitude_model:
+            logger.warning(
+                "The actor already had an attitude model. Overriding old attitude model."
+            )
+
+        # Set attitude model.
+        actor._attitude_model = AttitudeModel(
+            local_actor=actor,
+            actor_initial_attitude_in_rad=actor_initial_attitude_in_rad,
+            actor_initial_angular_velocity=actor_initial_angular_velocity,
+            actor_pointing_vector_body=actor_pointing_vector_body,
+            actor_residual_magnetic_field=actor_residual_magnetic_field,
+        )
+
     @staticmethod
     def add_comm_device(actor: BaseActor, device_name: str, bandwidth_in_kbps: float):
         """Creates a communication device.
@@ -539,7 +632,10 @@ def add_comm_device(actor: BaseActor, device_name: str, bandwidth_in_kbps: float
 
     @staticmethod
     def add_custom_property(
-        actor: BaseActor, property_name: str, initial_value: Any, update_function: Callable
+        actor: BaseActor,
+        property_name: str,
+        initial_value: Any,
+        update_function: Callable,
     ):
         """Adds a custom property to the actor. This e.g. allows tracking any physical
         the user would like to track.

paseos/actors/base_actor.py

@@ -47,6 +47,9 @@ class BaseActor(ABC):
     # Tracks the current activity
     _current_activity = None
 
+    # Mass
+    _mass = None
+
     # The following variables are used to track last evaluated state vectors to avoid recomputation.
     _previous_position = None
     _time_of_previous_position = None
@@ -148,6 +151,15 @@ def has_radiation_model(self) -> bool:
         """
         return hasattr(self, "_radiation_model") and self._radiation_model is not None
 
+    @property
+    def has_spacecraft_body_model(self) -> bool:
+        """Returns true if actor's body is modeled, else false.
+
+        Returns:
+            bool: bool indicating presence.
+        """
+        return hasattr(self, "_spacecraft_body_model") and self._spacecraft_body_model is not None
+
     @property
     def has_thermal_model(self) -> bool:
         """Returns true if actor's temperature is modeled, else false.
@@ -157,6 +169,15 @@ def has_thermal_model(self) -> bool:
         """
         return hasattr(self, "_thermal_model") and self._thermal_model is not None
 
+    @property
+    def has_attitude_model(self) -> bool:
+        """Returns true if actor's attitude is modeled, else false.
+
+        Returns:
+            bool: bool indicating presence.
+        """
+        return hasattr(self, "_attitude_model") and self._attitude_model is not None
+
     @property
     def mass(self) -> float:
         """Returns actor's mass in kg.

paseos/actors/spacecraft_actor.py

@@ -1,5 +1,6 @@
-from loguru import logger
+import numpy as np
 import pykep as pk
+from loguru import logger
 
 from paseos.actors.base_actor import BaseActor
 from paseos.power import discharge_model
@@ -19,8 +20,10 @@ class SpacecraftActor(BaseActor):
     # Actor's mass in kg
     _mass = None
 
+    _spacecraft_body_model = None
     _thermal_model = None
     _radiation_model = None
+    _attitude_model = None
 
     # If radiation randomly restarted the device
     _was_interrupted = False
@@ -104,6 +107,46 @@ def mass(self) -> float:
         """
         return self._mass
 
+    @property
+    def body_mesh(self) -> np.array:
+        """Gives the mesh of the satellite.
+
+        Returns:
+            np.array: Mesh of the satellite.
+        """
+        return self._spacecraft_body_model._body_mesh
+
+    @property
+    def attitude_disturbances(self) -> list:
+        """Gives attitude disturbances list.
+
+        Returns:
+            list: attitude disturbances list.
+        """
+        return self._attitude_model._disturbances
+
+    @property
+    def body_moment_of_inertia(self) -> np.array:
+        """Gives the moment of inertia of the actor, assuming constant density.
+
+        Returns:
+            np.array: Mass moments of inertia for the actor
+
+        I is the moment of inertia, in the form of [[Ixx Ixy Ixz]
+                                                    [Iyx Iyy Iyx]
+                                                    [Izx Izy Izz]]
+        """
+        return self._spacecraft_body_model._body_moment_of_inertia
+
+    @property
+    def body_center_of_gravity(self) -> np.array:
+        """Gives the volumetric center of mass of the actor.
+
+        Returns:
+            np.array: Coordinates of the center of gravity of the mesh.
+        """
+        return self._spacecraft_body_model._body_center_of_gravity
+
     @property
     def temperature_in_K(self) -> float:
         """Returns the current temperature of the actor in K.
@@ -164,3 +207,47 @@ def charge(self, duration_in_s: float):
         self = charge_model.charge(self, duration_in_s)
 
         logger.debug(f"New battery level is {self.battery_level_in_Ws}")
+
+    @property
+    def attitude_in_rad(self):
+        """Returns the current attitude of the actor in radians.
+
+        Returns:
+            list[floats]: actor attitude in radians.
+        """
+        if type(self._attitude_model._actor_attitude_in_rad) is np.ndarray:
+            return np.ndarray.tolist(self._attitude_model._actor_attitude_in_rad)
+        else:
+            return self._attitude_model._actor_attitude_in_rad
+
+    @property
+    def attitude_in_deg(self):
+        """Returns the current attitude of the actor in degrees.
+
+        Returns:
+            list[floats]: actor attitude in degrees.
+        """
+        if type(self._attitude_model._actor_attitude_in_rad) is np.ndarray:
+            return np.ndarray.tolist(self._attitude_model._actor_attitude_in_rad * 180 / np.pi)
+        else:
+            return np.ndarray.tolist(
+                np.array(self._attitude_model._actor_attitude_in_rad) * 180 / np.pi
+            )
+
+    @property
+    def pointing_vector(self):
+        """Returns the spacecraft pointing vector in the Earth-centered inertial frame.
+
+        Returns:
+            np.ndarray (x, y, z).
+        """
+        return self._attitude_model._actor_pointing_vector_eci
+
+    @property
+    def angular_velocity(self):
+        """Returns the spacecraft angular velocity vector in the Earth-centered inertial frame.
+
+        Returns:
+            np.ndarray (owega_x, omega_y, omega_z).
+        """
+        return self._attitude_model._actor_angular_velocity_eci

paseos/actors/spacecraft_body.py

@@ -0,0 +1,51 @@
+import trimesh
+
+
+def create_body_mesh(vertices=None, faces=None, scale=1):
+    """Creates the mesh of the satellite. If no vertices input is given, it defaults to a cuboid scaled by the
+    scale value. The default without scale values is a cube with 1m sides. This uses the python module Trimesh.
+    Args:
+        vertices (list): List of all vertices of the mesh in terms of distance (in m) from origin of body frame.
+            Coordinates of the corners of the object. If not selected, it will default to a cube that can be scaled
+            by the scale. Uses Trimesh to create the mesh from this and the list of faces.
+        faces (list): List of the indexes of the vertices of a face. This builds the faces of the satellite by
+            defining the three vertices to form a triangular face. For a cuboid each face is split into two
+            triangles. Uses Trimesh to create the mesh from this and the list of vertices.
+        scale (float): Parameter to scale the cuboid by, defaults to 1.
+
+    Returns:
+        mesh: Trimesh mesh of the satellite
+    """
+    if vertices is None:
+        # Defines the corners of the mesh, values are in meters, from the origin of the body frame.
+        vertices = [
+            [-0.5, -0.5, -0.5],
+            [-0.5, -0.5, 0.5],
+            [-0.5, 0.5, -0.5],
+            [-0.5, 0.5, 0.5],
+            [0.5, -0.5, -0.5],
+            [0.5, -0.5, 0.5],
+            [0.5, 0.5, -0.5],
+            [0.5, 0.5, 0.5],
+        ]
+        # List of three vertices to form a triangular face of the satellite.
+        # Two triangular faces are used per side of the cuboid.
+        faces = [
+            [0, 1, 3],
+            [0, 3, 2],
+            [0, 2, 6],
+            [0, 6, 4],
+            [1, 5, 3],
+            [3, 5, 7],
+            [2, 3, 7],
+            [2, 7, 6],
+            [4, 6, 7],
+            [4, 7, 5],
+            [0, 4, 1],
+            [1, 4, 5],
+        ]
+
+    # Set mesh
+    mesh = trimesh.Trimesh(vertices, faces).apply_scale(scale)
+
+    return mesh