6.2. SimsFlanagan Method¶
The SimsFlanagan method is the most commonly used direct method. It consists in dividing the trajectory into two separate parts: a forward propagation subleg from departure to half of the time of flight, and a backward propagation subleg from arrival to half of the time of flight. Those two sublegs are themselves divided into a given number of segments, so that the lowthrust trajectory is modelled as a succession of impulsive shots, which are applied at the middle of each trajectory segment. The direction and magnitude of the impulsive shots are left as free parameters, but are constrained to ensure they do not overshoot the maximum allowable thrust magnitude. The SimsFlanagan method thus transforms the twoboundary problem into a parametrised optimisation problem, which is defined as follows:
 Objective
 Minimisation of the deltaV required by the trajectory.
 Constraints
 The state vectors obtained with respectively forward propagation from departure, and backward propagation from arrival should match at half of the time of flight.
 The thrust magnitude shall not exceed its maximum value (provided as input by the user).
 Design parameters
 Socalled thrust throttles: direction and magnitude of the impulsive shots applied at the middle of each trajectory segment.
6.2.1. SimsFlanagan optimisation problem¶
The SimsFlanagan method has been implemented in the class SimsFlanagan
, which is derived from the base class LowThrustLeg
.

class
SimsFlanagan
¶
This class creates the SimsFlanagan problem and runs the associated optimisation problem. It inherits from the base class LowThrustLeg
and is defined as follows:
SimsFlanagan(
const Eigen::Vector6d& stateAtDeparture,
const Eigen::Vector6d& stateAtArrival,
const double maximumThrust,
const std::function< double ( const double ) > specificImpulseFunction,
const int numberSegments,
const double timeOfFlight,
simulation_setup::NamedBodyMap bodyMap,
const std::string bodyToPropagate,
const std::string centralBody,
pagmo::algorithm optimisationAlgorithm,
const int numberOfGenerations,
const int numberOfIndividualsPerPopulation,
const double relativeToleranceConstraints = 1.0e6,
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.
specificImpulseFunction
 Function returning the specific impulse value at a given time.
numberSegments
 Total number of segments into which the trajectory leg is subdivided (this includes both the forward and backward propagation legs into which the whole trajectory is divided into).
timeOfFlight
 Time of flight required for the trajectory.
bodyMap
 Map of pointers to
Body
objects involved in the lowthrust trajectory.
bodyToPropagate
 Name of the spacecraft to be propagated.
centralBody
 Name of the central body of the lowthrust trajectory.
optimisationSettings
 Settings for the SimsFlanagan optimisation (includes algorithm to be used, number of generations, number of individuals per population, tolerance with respect to contraints, and possibly initial guess)
The SimsFlanagan
class is directly derived from the base class LowThrustLeg
, and all the methods contained in that base class are thus available from any SimsFlanagan
object (see LowThrust 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 SimsFlanagan
automatically calls the method performOptimisation
, which tries to find the solution to the SimsFlanagan parametrised optimisation problem, using the optimisation settings provided by the user. This method creates an object of the class SimsFlanaganProblem
, which defines the SimsFlanagan optimisation problem so that it is compatible with the PAGMO library. The performOptimisation
function then runs the optimisation algorithm and saves the identified optimum in the simsFlanaganLeg_
private variable, which can be retrieved from the getOptimalSimsFlanaganLeg
method.
6.2.2. SimsFlanagan trajectory model¶
Trying the solve the SimsFlanagan parametrised optimisation problem, as presented above, implies considering many different parametrised trajectories with various thrust profiles, and trying to converge towards the best performing one (in terms of constraints satisfaction, and deltaV budget). Each individual parametrised trajectory whose performance is to be assessed with respect to the trajectory design optimisation objective is created as an object of the following class.

class
SimsFlanaganModel
¶
This class models the lowthrust trajectory as described by the SimsFlanagan method: forward and backward propagation legs from departure and arrival respectively, matching at half of the time of flight, and lowthrust profile discretised as a succession of impulsive shots applied along the trajectory. This class does not solve the parametrised optimisation problem, but can simply propagate the trajectory defined by a set of userdefined impulsive shots. The class is defined as:
The input parameters of this class constructor are:
stateAtDeparture
 State of the spacecraft at departure.
stateAtArrival
 State of the spacecraft at arrival.
maximumThrust
 Maximum thrust magnitude per impulsive shot.
specificImpulseFunction
 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 lowthrust trajectory.
throttles
 Vector containing the thrust vectors (normalised with respect to the maximum thrust value) for each of the impulsive shots.
bodyToPropagate
 Name of the spacecraft to be propagated.
centralBody
 Name of the central body of the lowthrust trajectory.
6.2.3. Using shapebased trajectory as an initial guess¶
It can be rather difficult to reach convergence when trying to solve the parametrised SimsFlanagan optimisation problem. This is mostly due to the fact that the constant thrust vector of each of the trajectory segment can be arbitrarily chosen, so that the parameters search space is extremely large. This is why it is recommended to use a good initial guess as a starting point for the SimsFlanagan trajectory design method. The shaping methods which have been implemented in Tudat are good candidates to compute a preliminary trajectory design in an efficient way. As the design parameters for the SimsFlanagan method are the thrust vectors of the trajectory segments, the initial guess must be provided as a set of n thrust vectors, constant in magnitude and directions (n being the number of segments of the SimsFlanagan trajectory). One can use the function getInitialGuessFunctionFromShaping
to approximate a thrust profile delivered by a shaping method by a set of n successive, constant thrust vectors.
std::function< Eigen::Vector3d( const double ) > getInitialGuessFunctionFromShaping(
std::shared_ptr< shape_based_methods::ShapeBasedMethodLeg > shapeBasedLeg,
const int numberSegmentsSimsFlanagan,
const double timeOfFlight,
std::function< double( const double ) > specificImpulseFunction,
std::shared_ptr< numerical_integrators::IntegratorSettings< double > > integratorSettings )
The input parameters of this function are the following ones:
shapeBasedLeg
 Pointer to a
ShapeBasedObject
from which the thrust profile of the shapebased trajectory used as initial guess is to be retrieved.
numberSegmentsSimsFlanagan
int
object defining the number of segments into which the trajectory is to be subdivided when using the SimsFlanagan method.
timeOfFlight
 Expected timeofflight for the trajectory.
specificImpulseFunction
 Function returning the specific impulse of the spacecraft as a function of time.
integratorSettings
 Integrator settings to be used to retrieve the thrust profile of the shapebased trajectory.
Below is an example of how a thrust profile derived from a shapebased trajectory is approximated to a set of succcessive, constant thrust vectors which can be used as an initial guess for the SimsFlanagan thrust throttles. It is based on an EarthMars transfer, and the shaping method used to get the rough preliminary design is hodographic shaping.