6.3. Hybrid Method

The hybrid method implemented in TUDAT follows from the work done in the theses by Boudestijn (2014) and Jimenez-Lluva (2018). It aims at combining the advantages of direct and indirect methods, while limiting their respective drawbacks.

It makes use of the optimal control theory to reduce the set of free parameters compared to direct methods. As opposed to traditional indirect methods, the costates are not derived from analytically solving the two-point-boundary-value-problem. A linear interpolation is assumed between the initial and final values of the Modified Equinoctial Elements (MEE) costates, and those initial and final costate values are left as the only free parameters of the problem. The thrust profile along the low-thrust trajectory is defined from the MEE costates guidance and magnitude models.

The trajectory design problem is turned into a simplified optimisation problem, defined as follows:

  • Objective
    Minimisation of the deltaV required by the trajectory.
  • Constraints
    The state vector obtained at the end of the propagation should match with the targeted state at arrival.
  • Design parameters
    Initial and final values of the MEE costates.

6.3.1. Hybrid method optimisation problem

The hybrid method has been implemented in the class HybridMethod, which inherits from the base class LowThrustLeg.

class HybridMethod

This class defines the trajectory design problem as addressed by the hybrid method and runs the associated optimisation problem. The constructor is defined as follows:

HybridMethod(
        Eigen::Vector6d& stateAtDeparture,
        const Eigen::Vector6d& stateAtArrival,
        const double maximumThrust,
        const double specificImpulse,
        const double timeOfFlight,
        simulation_setup::NamedBodyMap& bodyMap,
        const std::string bodyToPropagate,
        const std::string centralBody,
        std::shared_ptr< numerical_integrators::IntegratorSettings< double > > integratorSettings,
        pagmo::algorithm optimisationAlgorithm,
        const int numberOfGenerations,
        const int numberOfIndividualsPerPopulation,
        const double relativeToleranceConstraints = 1.0e-6,
        std::pair< std::function< Eigen::Vector3d( const double ) >, double > initialGuessThrustModel = std::make_pair( nullptr, 0.0 ) )

where the input parameters are:

  • stateAtDeparture
    State of the spacecraft at departure.
  • stateAtArrival
    State of the spacecraft at arrival.
  • maximumThrust
    Maximum thrust magnitude per impulsive shot.
  • specificImpulse
    Function returning the specific impulse value at a given time.
  • timeOfFlight
    Time of flight required for the trajectory.
  • bodyMap
    Map of pointers to Body objects involved in the low-thrust trajectory.
  • bodyToPropagate
    Name of the spacecraft to be propagated.
  • centralBody
    Name of the central body of the low-thrust trajectory.
  • integratorSettings
    Integrator settings to propagate the spacecraft trajectory.
  • optimisationSettings
    Settings for the Sims-Flanagan optimisation (includes algorithm to be used, number of generations, number of individuals per population, tolerance with respect to contraints, and possibly initial guess)

The HybridMethod class is directly derived from the base class LowThrustLeg, and all the methods contained in that base class are thus available from any HybridMethod object (see Low-Thrust Trajectories for more details). This includes, among others, the methods allowing the user to retrieve the trajectory, mass, thrust, and thrust acceleration history along the trajectory.

The constructor of the class HybridMethod automatically calls the method performOptimisation, which tries to find the solution to the optimisation problem as defined by the hybrid method, using the optimisation settings provided by the user. This method creates the structure HybridMethodProblem, which defines the corresponding optimisation problem. It thus saves the identified optimum in the hybridMethodLeg_ private variable, which can be retrieved from the (TO BE COMPLETED) method.

6.3.2. Hybrid method trajectory model

Addressing a trajectory design problem with the hybrid method described above requires to run an optimisation algorithm to find the best trajectory, i.e. a trajectory which fulfills the departure and arrival boundary conditions, as well as the required time-of-flight, for the lowest deltaV. This requires the assessment of numerous trajectories to finally identify the best performing one. Each of the individual trajectories parsed by the optimisation algorithm is obtained out of a given set of initial and final MEE costates, and is defined as an object of the class described below.

class HybridMethodModel

This class models the low-thrust trajectory as described by the hybrid method. It simply propagates the trajectory assuming a simplified model with thrust and central body gravitational accelerations only. The thrust acceleration is derived from the optimal control theory, using a vector of costates functions which return the value of each costate as a function of time. The costate functions are directly derived from the linear interpolation between their initial and final values, which are provided by the user. This class does not solve the optimisation problem, but it defines the low-thrust trajectory corresponding to a given set of initial and final costate values. The class is defined as:

HybridMethodLeg( const Eigen::Vector6d& stateAtDeparture,
             const Eigen::Vector6d& stateAtArrival,
             const Eigen::VectorXd& initialCoStates,
             const Eigen::VectorXd& finalCoStates,
             const double maximumThrust,
             const double specificImpulse,
             const double timeOfFlight,
             simulation_setup::NamedBodyMap& bodyMap,
             const std::string bodyToPropagate,
             const std::string centralBody,
             std::shared_ptr< numerical_integrators::IntegratorSettings< double > > integratorSettings )

The input parameters of this class constructor are:

  • stateAtDeparture
    State of the spacecraft at departure.
  • stateAtArrival
    State of the spacecraft at arrival.
  • initialCoStates
    Vector containing the values of each of the MEE costates at departure.
  • finalCoStates
    Vector containing the values of each of the MEE costates at arrival.
  • maximumThrust
    Maximum thrust magnitude. The thrust model used in the hybrid method based on the optimal control theory is defined as a so-called “bang-bang” thrust model: the magnitude of the thrust vector is equal to either 0 or the maximum thrust value.
  • specificImpulse
    Specific Impulse value. The current implementation of the hybrid method does not allow for time-varying specific impulse.
  • timeOfFlight
    Time of flight required for the trajectory.
  • bodyMap
    Map of pointers to Body objects involved in the low-thrust trajectory.
  • bodyToPropagate
    Name of the spacecraft to be propagated.
  • centralBody
    Name of the central body of the low-thrust trajectory.
  • integratorSettings
    Integrator settings to be used to propagate the spacecraft trajectory.