Add equality checks in Python

Author: ChristopherRabotin

anise-py/src/lib.rs

@@ -10,7 +10,7 @@
 
 use ::anise::almanac::metaload::{MetaAlmanac, MetaFile};
 use ::anise::almanac::Almanac;
-use ::anise::analysis::event::{Event, EventArc, EventDetails};
+use ::anise::analysis::event::{Event, EventArc, EventDetails, EventEdge};
 use ::anise::analysis::prelude::OrbitalElement;
 use ::anise::analysis::python::{
     PyFrameSpec, PyOrthogonalFrame, PyScalarExpr, PyStateSpec, PyVectorExpr,
@@ -67,6 +67,7 @@ fn analysis(_py: Python, sm: &Bound<PyModule>) -> PyResult<()> {
     sm.add_class::<Plane>()?;
     sm.add_class::<Event>()?;
     sm.add_class::<EventDetails>()?;
+    sm.add_class::<EventEdge>()?;
     sm.add_class::<EventArc>()?;
     sm.add_class::<ReportScalars>()?;
     Ok(())

anise-py/tests/test_analysis.py

@@ -3,6 +3,7 @@
 from anise.time import Epoch, TimeSeries, Unit
 from anise.constants import Frames
 from anise.astro import Frame
+from pathlib import Path
 
 
 def test_analysis_gen_report():
@@ -173,6 +174,7 @@ def test_analysis_event():
     """
     Tests event finding for apoapsis, periapsis, eclipses, and other criteria.
     """
+    data_path = Path(__file__).parent.joinpath("..", "..", "data")
     almanac = (
         Almanac(str(data_path.joinpath("de440s.bsp")))
         .load(str(data_path.joinpath("pck08.pca")))
@@ -241,19 +243,23 @@ def test_analysis_event():
     ]
     assert all((dt - period).abs() < Unit.Minute * 5 for dt in dts_peri)
 
+    tick = Epoch.system_now()
     # Find sunset/sunrise arcs
     sunset_arcs = almanac.report_event_arcs(
         lro_state_spec, sunset_nadir, start_epoch, end_epoch
     )
-    assert sunset_arcs[1].rise.edge == analysis.EventEdge.Rising()
-    assert sunset_arcs[1].fall.edge == analysis.EventEdge.Falling()
+    print(f"{len(sunset_arcs)} sunset arcs found in {Epoch.system_now().timedelta(tick)}")
+    assert sunset_arcs[1].rise.edge == analysis.EventEdge.Rising
+    assert sunset_arcs[1].fall.edge == analysis.EventEdge.Falling
     assert len(sunset_arcs) == 309
 
     # Find eclipse arcs in a short time span
+    tick = Epoch.system_now()
     eclipse_arcs = almanac.report_event_arcs(
         lro_state_spec, eclipse, start_epoch, start_epoch + Unit.Hour * 3
     )
     assert len(eclipse_arcs) == 2
+    print("Eclipse arcs found in ", Epoch.system_now().timedelta(tick))
 
     # Validate the eclipse periods
     for arc in eclipse_arcs:

anise/src/analysis/elements.rs

@@ -22,6 +22,7 @@ use crate::prelude::Orbit;
 /// Orbital element defines all of the supported orbital elements in ANISE, which are all built from a State.
 #[allow(non_camel_case_types, clippy::upper_case_acronyms)]
 #[cfg_attr(feature = "python", pyclass)]
+#[cfg_attr(feature = "python", pyo3(module = "anise.analysis"))]
 #[derive(Copy, Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub enum OrbitalElement {
     /// Argument of Latitude (deg)
@@ -274,4 +275,10 @@ impl OrbitalElement {
         self.evaluate(orbit)
             .map_err(|e| PyException::new_err(e.to_string()))
     }
+    fn __eq__(&self, other: &Self) -> bool {
+        self == other
+    }
+    fn __ne__(&self, other: &Self) -> bool {
+        self != other
+    }
 }

anise/src/analysis/event.rs

@@ -37,6 +37,7 @@ use pyo3::types::PyType;
 /// :type value_precision: float
 /// :type ab_corr: Aberration, optional
 #[cfg_attr(feature = "python", pyclass)]
+#[cfg_attr(feature = "python", pyo3(module = "anise.analysis"))]
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct Event {
     /// The state parameter
@@ -283,6 +284,13 @@ impl Event {
     fn __repr__(&self) -> String {
         format!("{self}@{self:p}")
     }
+
+    fn __eq__(&self, other: &Self) -> bool {
+        self == other
+    }
+    fn __ne__(&self, other: &Self) -> bool {
+        self != other
+    }
 }
 
 impl fmt::Display for Event {
@@ -304,6 +312,7 @@ impl fmt::Display for Event {
 /// `EventEdge` is used to describe the nature of a trajectory event, particularly in terms of its temporal dynamics relative to a specified condition or threshold. This enum helps in distinguishing whether the event is occurring at a rising edge, a falling edge, or if the edge is unclear due to insufficient data or ambiguous conditions.
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "python", pyclass)]
+#[cfg_attr(feature = "python", pyo3(module = "anise.analysis"))]
 pub enum EventEdge {
     /// Represents a rising edge of the event. This indicates that the event is transitioning from a lower to a higher evaluation of the event. For example, in the context of elevation, a rising edge would indicate an increase in elevation from a lower angle.
     Rising,
@@ -317,6 +326,17 @@ pub enum EventEdge {
     Unclear,
 }
 
+#[cfg(feature = "python")]
+#[cfg_attr(feature = "python", pymethods)]
+impl EventEdge {
+    fn __eq__(&self, other: &Self) -> bool {
+        self == other
+    }
+    fn __ne__(&self, other: &Self) -> bool {
+        self != other
+    }
+}
+
 /// Represents the details of an event occurring along a trajectory.
 ///
 /// `EventDetails` encapsulates the state at which a particular event occurs in a trajectory, along with additional information about the nature of the event. This struct is particularly useful for understanding the dynamics of the event, such as whether it represents a rising or falling edge, or if the edge is unclear.
@@ -325,7 +345,7 @@ pub enum EventEdge {
 /// S: Interpolatable - A type that represents the state of the trajectory. This type must implement the `Interpolatable` trait, ensuring that it can be interpolated and manipulated according to the trajectory's requirements.
 #[derive(Clone, PartialEq)]
 #[cfg_attr(feature = "python", pyclass)]
-#[cfg_attr(feature = "python", pyo3(get_all))]
+#[cfg_attr(feature = "python", pyo3(module = "anise.analysis", get_all))]
 pub struct EventDetails {
     /// The state of the trajectory at the found event.
     /// :rtype: Orbit
@@ -444,6 +464,12 @@ impl EventDetails {
     fn __repr__(&self) -> String {
         format!("{self}@{self:p}")
     }
+    fn __eq__(&self, other: &Self) -> bool {
+        self == other
+    }
+    fn __ne__(&self, other: &Self) -> bool {
+        self != other
+    }
 }
 
 impl fmt::Display for EventDetails {
@@ -473,7 +499,7 @@ impl fmt::Debug for EventDetails {
 }
 
 #[cfg_attr(feature = "python", pyclass)]
-#[cfg_attr(feature = "python", pyo3(get_all))]
+#[cfg_attr(feature = "python", pyo3(module = "anise.analysis", get_all))]
 #[derive(Clone, PartialEq)]
 pub struct EventArc {
     /// rise event of this arc

anise/src/analysis/python.rs

@@ -112,9 +112,8 @@ impl Almanac {
         })
     }
 
-    /// Find all event arcs, i.e. the start and stop time of when a given event occurs.
-    ///
-    /// **Performance:** for robustness, this function calls the memory and computationally intensive [report_events_slow] function.
+    /// Find all event arcs, i.e. the start and stop time of when a given event occurs. This function
+    /// calls the memory and computationally intensive [report_events_slow] function.
     #[pyo3(name = "report_event_arcs")]
     fn py_report_event_arcs(
         &self,
@@ -535,6 +534,23 @@ impl PyStateSpec {
         spec.to_s_expr()
             .map_err(|e| PyException::new_err(e.to_string()))
     }
+    /// Evaluate the orbital element enum variant for the provided orbit
+    #[pyo3(name = "evaluate", signature=(epoch, almanac))]
+    fn py_evaluate(&self, epoch: Epoch, almanac: &Almanac) -> Result<Orbit, PyErr> {
+        let spec = StateSpec::from(self.clone());
+        spec.evaluate(epoch, almanac)
+            .map_err(|e| PyException::new_err(e.to_string()))
+    }
+    fn __eq__(&self, other: &Self) -> bool {
+        let me = StateSpec::from(self.clone());
+        let other = StateSpec::from(other.clone());
+        me == other
+    }
+    fn __ne__(&self, other: &Self) -> bool {
+        let me = StateSpec::from(self.clone());
+        let other = StateSpec::from(other.clone());
+        me != other
+    }
 }
 
 /// FrameSpec allows defining a frame that can be computed from another set of loaded frames, which include a center.

anise/src/analysis/report.rs

@@ -30,6 +30,7 @@ use super::python::{PyScalarExpr, PyStateSpec};
 // :type state_spec: StateSpec
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[cfg_attr(feature = "python", pyclass)]
+#[cfg_attr(feature = "python", pyo3(module = "anise.analysis"))]
 pub struct ReportScalars {
     pub scalars: Vec<(ScalarExpr, Option<String>)>,
     pub state_spec: StateSpec,

anise/src/analysis/search.rs

@@ -355,9 +355,8 @@ impl Almanac {
         Ok(events)
     }
 
-    /// Find all event arcs, i.e. the start and stop time of when a given event occurs.
-    ///
-    /// **Performance:** for robustness, this function calls the memory and computationally intensive [report_events_slow] function.
+    /// Find all event arcs, i.e. the start and stop time of when a given event occurs. This function
+    /// calls the memory and computationally intensive [report_events_slow] function.
     pub fn report_event_arcs(
         &self,
         state_spec: &StateSpec,
@@ -430,7 +429,7 @@ impl Almanac {
             if event_value >= 0.0 {
                 // We're in an arc.
                 if let Some(next_value) = crossing.next_value {
-                    if next_value < 0.0 {
+                    if next_value < 0.0 && rise.is_some() {
                         // At the next immediate step, the event ends, so this marks the end of the arc.
                         arcs.push(EventArc {
                             rise: rise.clone().unwrap(),