fix: sequence relative event condition (#456)

* feat: add clone methods to EventCondition classes

* fix: sequence relative event condition update

* patch: things

bindings/python/src/OpenSpaceToolkitAstrodynamicsPy/EventCondition.cpp

@@ -14,6 +14,7 @@ using namespace pybind11;
 using ostk::core::type::Real;
 using ostk::core::type::Shared;
 using ostk::core::type::String;
+using ostk::core::type::Unique;
 
 using ostk::mathematics::object::VectorXd;
 
@@ -35,6 +36,11 @@ class PyEventCondition : public EventCondition
     {
         PYBIND11_OVERRIDE_PURE_NAME(bool, EventCondition, "is_satisfied", isSatisfied, currentState, previousState);
     }
+
+    EventCondition* clone() const override
+    {
+        PYBIND11_OVERRIDE_PURE_NAME(EventCondition*, EventCondition, "clone", clone);
+    }
 };
 
 inline void OpenSpaceToolkitAstrodynamicsPy_EventCondition(pybind11::module& aModule)

bindings/python/test/test_event_condition.py

@@ -36,12 +36,13 @@ def event_condition(
     class MyEventCondition(EventCondition):
         def is_satisfied(
             self,
-            current_state_vector,
-            current_time,
-            previous_state_vector,
-            previous_time,
+            current_state,
+            previous_state,
         ):
-            return current_state_vector[0] > 0.0 and previous_state_vector[0] < 0.0
+            return (
+                current_state.get_position().get_coordinates()[2] > 0.0
+                and previous_state.get_position().get_coordinates()[2] < 0.0
+            )
 
     return MyEventCondition(name, evaluator, target)
 

include/OpenSpaceToolkit/Astrodynamics/EventCondition.hpp

@@ -5,6 +5,7 @@
 
 #include <OpenSpaceToolkit/Core/Type/Real.hpp>
 #include <OpenSpaceToolkit/Core/Type/String.hpp>
+#include <OpenSpaceToolkit/Core/Type/Unique.hpp>
 
 #include <OpenSpaceToolkit/Physics/Unit/Derived/Angle.hpp>
 #include <OpenSpaceToolkit/Physics/Unit/Length.hpp>
@@ -18,6 +19,7 @@ namespace astrodynamics
 
 using ostk::core::type::Real;
 using ostk::core::type::String;
+using ostk::core::type::Unique;
 
 using ostk::physics::unit::Angle;
 using ostk::physics::unit::Length;
@@ -118,6 +120,11 @@ class EventCondition
     ///                  printing
     virtual void print(std::ostream& anOutputStream, bool displayDecorator = true) const;
 
+    /// @brief Create a copy of this EventCondition
+    ///
+    /// @return Pointer to the cloned EventCondition
+    virtual EventCondition* clone() const = 0;
+
     /// @brief Check if the Event Condition is satisfied based on current state and previous
     ///                  state/time
     ///

include/OpenSpaceToolkit/Astrodynamics/EventCondition/AngularCondition.hpp

@@ -108,6 +108,11 @@ class AngularCondition : public EventCondition
     /// @return Boolean value indicating if the Event Condition is met
     virtual bool isSatisfied(const State& currentState, const State& previousState) const override;
 
+    /// @brief Create a copy of this AngularCondition
+    ///
+    /// @return Pointer to the cloned EventCondition
+    virtual AngularCondition* clone() const override;
+
     /// @brief Create an angular condition that is satisfied when the angle is within a range
     ///
     /// @param aName A string representing the name of the Angular Event Condition

include/OpenSpaceToolkit/Astrodynamics/EventCondition/LogicalCondition.hpp

@@ -85,6 +85,11 @@ class LogicalCondition : public EventCondition
     ///                  the printing process.
     virtual void print(std::ostream& anOutputStream, bool displayDecorator = true) const override;
 
+    /// @brief Create a copy of this LogicalCondition.
+    ///
+    /// @return Pointer to the cloned EventCondition
+    virtual LogicalCondition* clone() const override;
+
    private:
     typedef std::function<
         bool(const Array<Shared<EventCondition>>&, const State& currentState, const State& previousState)>

include/OpenSpaceToolkit/Astrodynamics/EventCondition/RealCondition.hpp

@@ -105,6 +105,11 @@ class RealCondition : public EventCondition
     /// @return Boolean value indicating if the Event Condition is met
     virtual bool isSatisfied(const State& currentState, const State& previousState) const override;
 
+    /// @brief clone the Real Condition
+    ///
+    /// @return Pointer to the cloned Real Condition
+    virtual RealCondition* clone() const override;
+
     /// @brief Convert criterion to string
     ///
     /// @param aCriterion An enum representing the criterion

src/OpenSpaceToolkit/Astrodynamics/EventCondition/AngularCondition.cpp

@@ -93,6 +93,11 @@ bool AngularCondition::isSatisfied(const State& currentState, const State& previ
     return comparator_(evaluator_(currentState), evaluator_(previousState), (target_.value + target_.valueOffset));
 }
 
+AngularCondition* AngularCondition::clone() const
+{
+    return new AngularCondition(*this);
+}
+
 AngularCondition AngularCondition::WithinRange(
     const String& aName, const std::function<Real(const State&)>& anEvaluator, const Pair<Angle, Angle>& aTargetRange
 )

src/OpenSpaceToolkit/Astrodynamics/EventCondition/LogicalCondition.cpp

@@ -59,6 +59,11 @@ void LogicalCondition::print(std::ostream& anOutputStream, bool displayDecorator
     displayDecorator ? ostk::core::utils::Print::Footer(anOutputStream) : void();
 }
 
+LogicalCondition* LogicalCondition::clone() const
+{
+    return new LogicalCondition(*this);
+}
+
 LogicalCondition::evaluationSignature LogicalCondition::GenerateEvaluator(const LogicalCondition::Type& aType)
 {
     switch (aType)

src/OpenSpaceToolkit/Astrodynamics/EventCondition/RealCondition.cpp

@@ -67,6 +67,11 @@ bool RealCondition::isSatisfied(const State& currentState, const State& previous
     return comparator_(evaluate(currentState), evaluate(previousState));
 }
 
+RealCondition* RealCondition::clone() const
+{
+    return new RealCondition(*this);
+}
+
 String RealCondition::StringFromCriterion(const Criterion& aCriterion)
 {
     switch (aCriterion)

src/OpenSpaceToolkit/Astrodynamics/Trajectory/Sequence.cpp

@@ -4,6 +4,8 @@
 #include <boost/log/expressions.hpp>
 #include <boost/log/trivial.hpp>
 
+#include <OpenSpaceToolkit/Core/Type/Unique.hpp>
+
 #include <OpenSpaceToolkit/Physics/Time/Duration.hpp>
 
 #include <OpenSpaceToolkit/Astrodynamics/Trajectory/Sequence.hpp>
@@ -15,6 +17,7 @@ namespace astrodynamics
 namespace trajectory
 {
 
+using ostk::core::type::Unique;
 using ostk::physics::time::Duration;
 
 Sequence::Solution::Solution(const Array<Segment::Solution>& aSegmentSolutionArray, const bool& anExecutionIsComplete)
@@ -322,6 +325,9 @@ Sequence::Solution Sequence::solveToCondition(
 
     Duration propagationDuration = Duration::Zero();
 
+    const Unique<EventCondition> sequenceCondition(anEventCondition.clone());
+    sequenceCondition->updateTarget(initialState);
+
     while (!eventConditionIsSatisfied && propagationDuration <= aMaximumPropagationDuration)
     {
         for (const Segment& segment : segments_)
@@ -350,7 +356,8 @@ Sequence::Solution Sequence::solveToCondition(
                 return {segmentSolutions, false};
             }
 
-            eventConditionIsSatisfied = anEventCondition.isSatisfied(segmentSolution.states.accessLast(), initialState);
+            eventConditionIsSatisfied =
+                sequenceCondition->isSatisfied(segmentSolution.states.accessLast(), initialState);
 
             // Terminate Sequence successfully if a provided event condition was satisfied
             if (eventConditionIsSatisfied)

test/OpenSpaceToolkit/Astrodynamics/EventCondition.test.cpp

@@ -16,6 +16,7 @@
 
 using ostk::core::type::Real;
 using ostk::core::type::String;
+using ostk::core::type::Unique;
 
 using ostk::physics::coordinate::Frame;
 using ostk::physics::coordinate::Position;
@@ -37,6 +38,8 @@ class TestCondition : public EventCondition
     {
     }
 
+    MOCK_METHOD(EventCondition*, clone, (), (const, override));
+
     MOCK_METHOD(bool, isSatisfied, (const State& currentState, const State& previousState), (const, override));
 };
 

test/OpenSpaceToolkit/Astrodynamics/EventCondition/AngularCondition.test.cpp

@@ -5,6 +5,7 @@
 #include <OpenSpaceToolkit/Core/Type/Real.hpp>
 #include <OpenSpaceToolkit/Core/Type/Shared.hpp>
 #include <OpenSpaceToolkit/Core/Type/String.hpp>
+#include <OpenSpaceToolkit/Core/Type/Unique.hpp>
 
 #include <OpenSpaceToolkit/Mathematics/Object/Vector.hpp>
 
@@ -23,6 +24,7 @@ using ostk::core::container::Pair;
 using ostk::core::type::Real;
 using ostk::core::type::Shared;
 using ostk::core::type::String;
+using ostk::core::type::Unique;
 
 using ostk::mathematics::object::VectorXd;
 
@@ -309,6 +311,11 @@ TEST_F(OpenSpaceToolkit_Astrodynamics_EventCondition_AngularCondition, isSatisfi
     }
 }
 
+TEST_F(OpenSpaceToolkit_Astrodynamics_EventCondition_AngularCondition, Clone)
+{
+    EXPECT_NO_THROW({ Unique<AngularCondition> clonedCondition(defaultCondition_.clone()); });
+}
+
 TEST_F(OpenSpaceToolkit_Astrodynamics_EventCondition_AngularCondition, StringFromCriterion)
 {
     EXPECT_TRUE(

test/OpenSpaceToolkit/Astrodynamics/EventCondition/LogicalCondition.test.cpp

@@ -6,6 +6,7 @@
 #include <OpenSpaceToolkit/Core/Type/Real.hpp>
 #include <OpenSpaceToolkit/Core/Type/Shared.hpp>
 #include <OpenSpaceToolkit/Core/Type/String.hpp>
+#include <OpenSpaceToolkit/Core/Type/Unique.hpp>
 
 #include <OpenSpaceToolkit/Mathematics/Object/Vector.hpp>
 
@@ -24,6 +25,7 @@ using ostk::core::container::Array;
 using ostk::core::type::Real;
 using ostk::core::type::Shared;
 using ostk::core::type::String;
+using ostk::core::type::Unique;
 
 using ostk::mathematics::object::VectorXd;
 
@@ -225,3 +227,8 @@ TEST_F(OpenSpaceToolkit_Astrodynamics_EventCondition_LogicalCondition, Or)
         EXPECT_FALSE(logicalCondition.isSatisfied(defaultState_, defaultState_));
     }
 }
+
+TEST_F(OpenSpaceToolkit_Astrodynamics_EventCondition_LogicalCondition, Clone)
+{
+    EXPECT_NO_THROW({ Unique<LogicalCondition> clonedCondition(defaultLogicalCondition_.clone()); });
+}

test/OpenSpaceToolkit/Astrodynamics/EventCondition/RealCondition.test.cpp

@@ -5,6 +5,7 @@
 #include <OpenSpaceToolkit/Core/Type/Real.hpp>
 #include <OpenSpaceToolkit/Core/Type/Shared.hpp>
 #include <OpenSpaceToolkit/Core/Type/String.hpp>
+#include <OpenSpaceToolkit/Core/Type/Unique.hpp>
 
 #include <OpenSpaceToolkit/Mathematics/Object/Vector.hpp>
 
@@ -22,6 +23,7 @@ using ostk::core::container::Array;
 using ostk::core::type::Real;
 using ostk::core::type::Shared;
 using ostk::core::type::String;
+using ostk::core::type::Unique;
 
 using ostk::mathematics::object::VectorXd;
 
@@ -214,6 +216,11 @@ TEST_F(OpenSpaceToolkit_Astrodynamics_EventCondition_RealCondition, DurationCond
     }
 }
 
+TEST_F(OpenSpaceToolkit_Astrodynamics_EventCondition_RealCondition, Clone)
+{
+    EXPECT_NO_THROW({ Unique<RealCondition> clonedCondition(defaultCondition_.clone()); });
+}
+
 TEST_F(OpenSpaceToolkit_Astrodynamics_EventCondition_RealCondition, StringFromCriterion)
 {
     {

test/OpenSpaceToolkit/Astrodynamics/Trajectory/Sequence.test.cpp

@@ -556,6 +556,33 @@ TEST_F(OpenSpaceToolkit_Astrodynamics_Trajectory_Sequence, SolveToCondition)
 
         EXPECT_FALSE(solution.executionIsComplete);
     }
+
+    // sequence completion due to duration condition (Regression test)
+    {
+        const Segment segment = Segment::Coast(
+            "Coast",
+            std::make_shared<RealCondition>(
+                RealCondition::DurationCondition(RealCondition::Criterion::StrictlyPositive, Duration::Seconds(10.0))
+            ),
+            defaultDynamics_,
+            defaultNumericalSolver_
+        );
+
+        const Sequence sequence = {
+            {segment},
+            defaultNumericalSolver_,
+            defaultDynamics_,
+            defaultMaximumPropagationDuration_,
+        };
+
+        const RealCondition eventCondition =
+            RealCondition::DurationCondition(RealCondition::Criterion::StrictlyPositive, Duration::Minutes(1.0));
+
+        const Sequence::Solution solution = sequence.solveToCondition(defaultState_, eventCondition);
+
+        EXPECT_TRUE(solution.executionIsComplete);
+        EXPECT_EQ(solution.segmentSolutions.getSize(), 6);
+    }
 }
 
 TEST_F(OpenSpaceToolkit_Astrodynamics_Trajectory_Sequence, Solve_2)