Struct nyx_space::md::opti::multipleshooting::multishoot::MultipleShooting

pub struct MultipleShooting<'a, E: ErrorCtrl, T: MultishootNode<OT>, const VT: usize, const OT: usize> {
    pub prop: &'a Propagator<'a, SpacecraftDynamics<'a>, E>,
    pub targets: Vec<T>,
    pub x0: Spacecraft,
    pub xf: Orbit,
    pub current_iteration: usize,
    pub max_iterations: usize,
    pub improvement_threshold: f64,
    pub variables: [Variable; VT],
    pub all_dvs: Vec<SVector<f64, VT>>,
}

Multiple shooting is an optimization method. Source of implementation: “Low Thrust Optimization in Cislunar and Translunar space”, 2018 Nathan Re (Parrish) OT: size of the objectives for each node (e.g. 3 if the objectives are X, Y, Z). VT: size of the variables for targeter node (e.g. 4 if the objectives are thrust direction (x,y,z) and thrust level).

Fields

prop: &'a Propagator<'a, SpacecraftDynamics<'a>, E>

The propagator setup (kind, stages, etc.)

targets: Vec<T>

List of nodes of the optimal trajectory

x0: Spacecraft

Starting point, must be a spacecraft equipped with a thruster

xf: Orbit

Destination (Should this be the final node?)

current_iteration: usize

max_iterations: usize

The maximum number of iterations allowed

improvement_threshold: f64

Threshold after which the outer loop is considered to have converged, e.g. 0.01 means that a 1% of less improvement in case between two iterations will stop the iterations.

variables: [Variable; VT]

The kind of correction to apply to achieve the objectives

all_dvs: Vec<SVector<f64, VT>>

Implementations

impl<'a, E: ErrorCtrl> MultipleShooting<'a, E, Node, 3, 3>

pub fn linear_altitude_heuristic( x0: Spacecraft, xf: Orbit, node_count: usize, body_frame: Frame, prop: &'a Propagator<'a, SpacecraftDynamics<'_>, E>, cosm: Arc<Cosm> ) -> Result<Self, NyxError>

Builds a multiple shooting structure assuming that the optimal trajectory is near a linear heuristic in geodetic altitude and direction. For example, if x0 has an altitude of 100 km and xf has an altitude of 200 km, and 10 nodes are required over 10 minutes, then node 1 will be 110 km, node 2 220km, etc. body_frame must be a body fixed frame

impl<'a, E: ErrorCtrl> MultipleShooting<'a, E, Node, 3, 3>

pub fn equidistant_nodes( x0: Spacecraft, xf: Orbit, node_count: usize, prop: &'a Propagator<'a, SpacecraftDynamics<'_>, E> ) -> Result<Self, NyxError>

Builds a multiple shooting structure assuming that the optimal trajectory is a straight line between the start and end points. The position of the nodes will be update at each iteration of the outer loop. NOTE: this may cause some nodes to be below the surface of a celestial object if in low orbit

impl<'a, E: ErrorCtrl, T: MultishootNode<OT>, const VT: usize, const OT: usize> MultipleShooting<'a, E, T, VT, OT>

pub fn solve( &mut self, cost: CostFunction ) -> Result<MultipleShootingSolution<T, OT>, NyxError>

Solve the multiple shooting problem by finding the arrangement of nodes to minimize the cost function.

Trait Implementations

impl<'a, E: ErrorCtrl, T: MultishootNode<OT>, const VT: usize, const OT: usize> Display for MultipleShooting<'a, E, T, VT, OT>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.