Add beta_angle_deg to Python

Author: ChristopherRabotin

Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["anise", "anise-cli", "anise-gui", "anise-py", "anise/fuzz"]
 
 [workspace.package]
-version = "0.6.0"
+version = "0.6.1"
 edition = "2021"
 authors = ["Christopher Rabotin <christopher.rabotin@gmail.com>"]
 description = "ANISE provides a toolkit and files for Attitude, Navigation, Instrument, Spacecraft, and Ephemeris data. It's a modern replacement of NAIF SPICE file."
@@ -45,7 +45,7 @@ pyo3-log = "0.12"
 numpy = "0.25"
 ndarray = ">= 0.15, < 0.17"
 
-anise = { version = "0.6.0", path = "anise", default-features = false }
+anise = { version = "0.6.1", path = "anise", default-features = false }
 
 [profile.bench]
 debug = true

anise-py/anise.pyi

@@ -92,6 +92,17 @@ The obstructing body _should_ be a tri-axial ellipsoid body, e.g. IAU_MOON_FRAME
 6. Compute the elevation, and ensure it is between +/- 180 degrees.
 7. Compute the azimuth with a quadrant check, and ensure it is between 0 and 360 degrees."""
 
+    def beta_angle_deg(self, state: Orbit, ab_corr: Aberration=None) -> float:
+        """Computes the Beta angle (β) for a given orbital state, in degrees. A Beta angle of 0° indicates that the orbit plane is edge-on to the Sun, leading to maximum eclipse time. Conversely, a Beta angle of +90° or -90° means the orbit plane is face-on to the Sun, resulting in continuous sunlight exposure and no eclipses.
+
+The Beta angle (β) is defined as the angle between the orbit plane of a spacecraft and the vector from the central body (e.g., Earth) to the Sun. In simpler terms, it measures how much of the time a satellite in orbit is exposed to direct sunlight.
+The mathematical formula for the Beta angle is: β=arcsin(h⋅usun\u200b)
+Where:
+- h is the unit vector of the orbital momentum.
+- usun\u200b is the unit vector pointing from the central body to the Sun.
+
+Original code from GMAT, <https://github.com/ChristopherRabotin/GMAT/blob/GMAT-R2022a/src/gmatutil/util/CalculationUtilities.cpp#L209-L219>"""
+
     def bpc_domain(self, id: int) -> typing.Tuple:
         """Returns the applicable domain of the request id, i.e. start and end epoch that the provided id has loaded data."""
 

anise-py/src/lib.rs

@@ -12,8 +12,9 @@ use ::anise::almanac::metaload::{MetaAlmanac, MetaFile};
 use ::anise::almanac::Almanac;
 use ::anise::astro::Aberration;
 use hifitime::leap_seconds::{LatestLeapSeconds, LeapSecondsFile};
-use hifitime::prelude::*;
+use hifitime::python::{PyDurationError, PyHifitimeError, PyParsingError};
 use hifitime::ut1::Ut1Provider;
+use hifitime::{prelude::*, MonthName, Polynomial};
 
 use pyo3::prelude::*;
 use pyo3::py_run;
@@ -50,6 +51,12 @@ fn register_time_module(parent_module: &Bound<'_, PyModule>) -> PyResult<()> {
     sm.add_class::<LatestLeapSeconds>()?;
     sm.add_class::<LeapSecondsFile>()?;
     sm.add_class::<Ut1Provider>()?;
+    sm.add_class::<MonthName>()?;
+    sm.add_class::<PyHifitimeError>()?;
+    sm.add_class::<PyDurationError>()?;
+    sm.add_class::<PyParsingError>()?;
+    sm.add_class::<Polynomial>()?;
+    sm.add_class::<Weekday>()?;
 
     Python::with_gil(|py| {
         py_run!(py, sm, "import sys; sys.modules['anise.time'] = sm");

anise/src/almanac/eclipse.rs

@@ -53,12 +53,6 @@ impl Almanac {
     /// - `r1dotr2` is the dot product of `r1` and `r2`.
     /// - `tau` is a parameter that determines the intersection point along the line of sight.
     /// - The condition `(1.0 - tau) * r1sq + r1dotr2 * tau <= ob_mean_eq_radius_km^2` checks if the line of sight is within the obstructing body's radius, indicating an obstruction.
-    ///
-    /// :type observer: Orbit
-    /// :type observed: Orbit
-    /// :type obstructing_body: Frame
-    /// :type ab_corr: Aberration, optional
-    /// :rtype: bool
     pub fn line_of_sight_obstructed(
         &self,
         observer: Orbit,
@@ -115,12 +109,6 @@ impl Almanac {
     /// A 100%  percent occultation means that the back object is fully hidden from the observer because of the front frame (i.e. _umbra_ if the back object is the Sun).
     /// A value in between means that the back object is partially hidden from the observser (i.e. _penumbra_ if the back object is the Sun).
     /// Refer to the [MathSpec](https://nyxspace.com/nyxspace/MathSpec/celestial/eclipse/) for modeling details.
-    ///
-    /// :type back_frame: Frame
-    /// :type front_frame: Frame
-    /// :type observer: Orbit
-    /// :type ab_corr: Aberration, optional
-    /// :rtype: Occultation
     pub fn occultation(
         &self,
         mut back_frame: Frame,
@@ -311,10 +299,6 @@ impl Almanac {
     /// - usun​ is the unit vector pointing from the central body to the Sun.
     ///
     /// Original code from GMAT, <https://github.com/ChristopherRabotin/GMAT/blob/GMAT-R2022a/src/gmatutil/util/CalculationUtilities.cpp#L209-L219>
-    ///
-    /// :type state: Orbit
-    /// :type ab_corr: Aberration, optional
-    /// :rtype: float
     pub fn beta_angle_deg(&self, state: Orbit, ab_corr: Option<Aberration>) -> AlmanacResult<f64> {
         let u_sun = self.sun_unit_vector(state.epoch, state.frame, ab_corr)?;
         let orbit_mom = state.hvec().map_err(|e| AlmanacError::GenericError {

anise/src/almanac/python.rs

@@ -225,6 +225,27 @@ impl Almanac {
         self.solar_eclipsing(eclipsing_frame, observer, ab_corr)
     }
 
+    /// Computes the Beta angle (β) for a given orbital state, in degrees. A Beta angle of 0° indicates that the orbit plane is edge-on to the Sun, leading to maximum eclipse time. Conversely, a Beta angle of +90° or -90° means the orbit plane is face-on to the Sun, resulting in continuous sunlight exposure and no eclipses.
+    ///
+    /// The Beta angle (β) is defined as the angle between the orbit plane of a spacecraft and the vector from the central body (e.g., Earth) to the Sun. In simpler terms, it measures how much of the time a satellite in orbit is exposed to direct sunlight.
+    /// The mathematical formula for the Beta angle is: β=arcsin(h⋅usun​)
+    /// Where:
+    /// - h is the unit vector of the orbital momentum.
+    /// - usun​ is the unit vector pointing from the central body to the Sun.
+    ///
+    /// Original code from GMAT, <https://github.com/ChristopherRabotin/GMAT/blob/GMAT-R2022a/src/gmatutil/util/CalculationUtilities.cpp#L209-L219>
+    ///
+    /// :type state: Orbit
+    /// :type ab_corr: Aberration, optional
+    /// :rtype: float
+    #[pyo3(name = "beta_angle_deg", signature=(
+        state,
+        ab_corr=None,
+    ))]
+    fn py_beta_angle_deg(&self, state: Orbit, ab_corr: Option<Aberration>) -> AlmanacResult<f64> {
+        self.beta_angle_deg(state, ab_corr)
+    }
+
     /// Returns the Cartesian state needed to transform the `from_frame` to the `to_frame`.
     ///
     /// # SPICE Compatibility