def fitness(self, x): # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T and the cartesian components of vinf T, Vinfx, Vinfy, Vinfz = self._decode_times_and_vinf(x) # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) DV = list([0.0] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = self.seq[i].eph(t_P[i]) # 3 - We start with the first leg v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian(r_P[0], v0, x[5] * T[0] * DAY2SEC, self.common_mu) # Lambert arc to reach seq[1] dt = (1 - x[5]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, self.common_mu, False, False) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # 4 - And we proceed with each successive leg for i in range(1, self.__n_legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[8 + (i - 1) * 4] * self.seq[i].radius, x[7 + (i - 1) * 4], self.seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[9 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[9 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, self.common_mu, False, False) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) # Last Delta-v if self.__add_vinf_arr: DV[-1] = norm([a - b for a, b in zip(v_end_l, v_P[-1])]) if self.__add_vinf_dep: DV[0] += x[3] if self._obj_dim == 1: return (sum(DV), ) else: return (sum(DV), sum(T))
def fitness(self, x): # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T and the cartesian components of vinf T, Vinfx, Vinfy, Vinfz = self._decode_times_and_vinf(x) # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) DV = list([0.0] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = self.seq[i].eph(t_P[i]) # 3 - We start with the first leg v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian( r_P[0], v0, x[5] * T[0] * DAY2SEC, self.common_mu) # Lambert arc to reach seq[1] dt = (1 - x[5]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, self.common_mu, False, False) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # 4 - And we proceed with each successive leg for i in range(1, self.__n_legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[ 8 + (i - 1) * 4] * self.seq[i].radius, x[7 + (i - 1) * 4], self.seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian( r_P[i], v_out, x[9 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[9 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, self.common_mu, False, False) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) # Last Delta-v if self.__add_vinf_arr: DV[-1] = norm([a - b for a, b in zip(v_end_l, v_P[-1])]) if self.__add_vinf_dep: DV[0] += x[3] if self._obj_dim == 1: return (sum(DV),) else: return (sum(DV), sum(T))
def plot_orbits(self, pop, ax=None): import matplotlib.pylab as plt from mpl_toolkits.mplot3d import Axes3D A1, A2 = self._ast1, self._ast2 if ax is None: fig = plt.figure() axis = fig.add_subplot(111, projection='3d') else: axis = ax plot_planet(A1, ax=axis, s=10, t0=epoch(self.lb[0])) plot_planet(A2, ax=axis, s=10, t0=epoch(self.ub[0])) for ind in pop: if ind.cur_f[0] == self._UNFEASIBLE: continue dep, arr = ind.cur_x rdep, vdep = A1.eph(epoch(dep)) rarr, varr = A2.eph(epoch(arr)) l = lambert_problem(rdep, rarr, (arr - dep) * DAY2SEC, A1.mu_central_body, False, 1) axis = plot_lambert(l, ax=axis, alpha=0.8, color='k') if ax is None: plt.show() return axis
def _dv_mga(pl1, pl2, tof, max_revs, rvt_outs, rvt_ins, rvt_pls, dvs, lps=None): rvt_pl = rvt_pls[-1] # current planet v_in = rvt_pl._v if rvt_ins[-1] is None else rvt_ins[-1]._v rvt_pl2 = rvt_planet(pl2, rvt_pl._t + tof) rvt_pls.append(rvt_pl2) r = rvt_pl._r vpl = rvt_pl._v r2 = rvt_pl2._r lp = lambert_problem(r, r2, tof, rvt_pl._mu, False, max_revs) lp = lambert_problem_multirev_ga(v_in, lp, pl1, vpl) if not lps is None: lps.append(lp) v_out = lp.get_v1()[0] rvt_out = rvt(r, v_out, rvt_pl._t, rvt_pl._mu) rvt_outs.append(rvt_out) rvt_in = rvt(r2, lp.get_v2()[0], rvt_pl._t + tof, rvt_pl._mu) rvt_ins.append(rvt_in) vr_in = [a - b for a, b in zip(v_in, vpl)] vr_out = [a - b for a, b in zip(v_out, vpl)] dv = fb_vel(vr_in, vr_out, pl1) dvs.append(dv)
def plot_orbits(self, pop, ax=None): import matplotlib.pylab as plt from mpl_toolkits.mplot3d import Axes3D A1, A2 = self._ast1, self._ast2 if ax is None: fig = plt.figure() axis = fig.add_subplot(111, projection='3d') else: axis = ax plot_planet(A1, axes=axis, s=10, t0=epoch(self.lb[0])) plot_planet(A2, axes=axis, s=10, t0=epoch(self.ub[0])) for ind in pop: if ind.cur_f[0] == self._UNFEASIBLE: continue dep, arr = ind.cur_x rdep, vdep = A1.eph(epoch(dep)) rarr, varr = A2.eph(epoch(arr)) l = lambert_problem(rdep, rarr, (arr - dep) * DAY2SEC, A1.mu_central_body, False, 1) axis = plot_lambert(l, axes=axis, alpha=0.8, color='k') if ax is None: plt.show() return axis
def _compute_dvs(self, x: List[float]) -> Tuple[ float, # DVlaunch List[float], # DVs float, # DVarrival, List[Any], # Lambert legs float, #DVlaunch_tot List[float], # T List[Tuple[List[float], List[float]]], # ballistic legs List[float], # epochs of ballistic legs ]: # 1 - we 'decode' the times of flights and compute epochs (mjd2000) T: List[float] = self._decode_tofs(x) # [T1, T2 ...] ep = np.insert(T, 0, x[0]) # [t0, T1, T2 ...] ep = np.cumsum(ep) # [t0, t1, t2, ...] # 2 - we compute the ephemerides r = [0] * len(self.seq) v = [0] * len(self.seq) for i in range(len(self.seq)): r[i], v[i] = self.seq[i].eph(float(ep[i])) l = list() ballistic_legs: List[Tuple[List[float], List[float]]] = [] ballistic_ep: List[float] = [] # 3 - we solve the lambert problems vi = v[0] for i in range(self._n_legs): lp = lambert_problem_multirev( vi, lambert_problem(r[i], r[i + 1], T[i] * DAY2SEC, self._common_mu, False, self.max_revs)) l.append(lp) vi = lp.get_v2()[0] ballistic_legs.append((r[i], lp.get_v1()[0])) ballistic_ep.append(ep[i]) # 4 - we compute the various dVs needed at fly-bys to match incoming # and outcoming DVfb = list() for i in range(len(l) - 1): vin = [a - b for a, b in zip(l[i].get_v2()[0], v[i + 1])] vout = [a - b for a, b in zip(l[i + 1].get_v1()[0], v[i + 1])] DVfb.append(fb_vel(vin, vout, self.seq[i + 1])) # 5 - we add the departure and arrival dVs DVlaunch_tot = np.linalg.norm( [a - b for a, b in zip(v[0], l[0].get_v1()[0])]) DVlaunch = max(0, DVlaunch_tot - self.vinf) DVarrival = np.linalg.norm( [a - b for a, b in zip(v[-1], l[-1].get_v2()[0])]) if self.orbit_insertion: # In this case we compute the insertion DV as a single pericenter # burn DVper = np.sqrt(DVarrival * DVarrival + 2 * self.seq[-1].mu_self / self.rp_target) DVper2 = np.sqrt(2 * self.seq[-1].mu_self / self.rp_target - self.seq[-1].mu_self / self.rp_target * (1. - self.e_target)) DVarrival = np.abs(DVper - DVper2) return (DVlaunch, DVfb, DVarrival, l, DVlaunch_tot, T, ballistic_legs, ballistic_ep)
def pretty(self, x): # 1 - we 'decode' the chromosome recording the various deep space # manouvres timing (days) in the list T T = list([0] * (self.N_max - 1)) for i in range(len(T)): T[i] = log(x[2 + 4 * i]) total = sum(T) T = [x[1] * time / total for time in T] # 2 - We compute the starting and ending position r_start, v_start = self.start.eph(epoch(x[0])) if self.phase_free: r_target, v_target = self.target.eph(epoch(x[-1])) else: r_target, v_target = self.target.eph(epoch(x[0] + x[1])) # 3 - We loop across inner impulses rsc = r_start vsc = v_start for i, time in enumerate(T[:-1]): theta = 2 * pi * x[3 + 4 * i] phi = acos(2 * x[4 + 4 * i] - 1) - pi / 2 Vinfx = x[5 + 4 * i] * cos(phi) * cos(theta) Vinfy = x[5 + 4 * i] * cos(phi) * sin(theta) Vinfz = x[5 + 4 * i] * sin(phi) # We apply the (i+1)-th impulse vsc = [a + b for a, b in zip(vsc, [Vinfx, Vinfy, Vinfz])] rsc, vsc = propagate_lagrangian( rsc, vsc, T[i] * DAY2SEC, self.__common_mu) cw = (ic2par(rsc, vsc, self.start.mu_central_body)[2] > pi / 2) # We now compute the remaining two final impulses # Lambert arc to reach seq[1] dt = T[-1] * DAY2SEC l = lambert_problem(rsc, r_target, dt, self.__common_mu, cw, False) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] DV1 = norm([a - b for a, b in zip(v_beg_l, vsc)]) DV2 = norm([a - b for a, b in zip(v_end_l, v_target)]) DV_others = list(x[5::4]) DV_others.extend([DV1, DV2]) print("Total DV (m/s): ", sum(DV_others)) print("Dvs (m/s): ", DV_others) print("Tofs (days): ", T)
def fitness(self, x): # 1 - we 'decode' the chromosome into the various deep space # manouvres times (days) in the list T T = list([0] * (self.N_max - 1)) for i in range(len(T)): T[i] = log(x[2 + 4 * i]) total = sum(T) T = [x[1] * time / total for time in T] # 2 - We compute the starting and ending position r_start, v_start = self.start.eph(epoch(x[0])) if self.phase_free: r_target, v_target = self.target.eph(epoch(x[-1])) else: r_target, v_target = self.target.eph(epoch(x[0] + x[1])) # 3 - We loop across inner impulses rsc = r_start vsc = v_start for i, time in enumerate(T[:-1]): theta = 2 * pi * x[3 + 4 * i] phi = acos(2 * x[4 + 4 * i] - 1) - pi / 2 Vinfx = x[5 + 4 * i] * cos(phi) * cos(theta) Vinfy = x[5 + 4 * i] * cos(phi) * sin(theta) Vinfz = x[5 + 4 * i] * sin(phi) # We apply the (i+1)-th impulse vsc = [a + b for a, b in zip(vsc, [Vinfx, Vinfy, Vinfz])] rsc, vsc = propagate_lagrangian( rsc, vsc, T[i] * DAY2SEC, self.__common_mu) cw = (ic2par(rsc, vsc, self.start.mu_central_body)[2] > pi / 2) # We now compute the remaining two final impulses # Lambert arc to reach seq[1] dt = T[-1] * DAY2SEC l = lambert_problem(rsc, r_target, dt, self.__common_mu, cw, False) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] DV1 = norm([a - b for a, b in zip(v_beg_l, vsc)]) DV2 = norm([a - b for a, b in zip(v_end_l, v_target)]) DV_others = sum(x[5::4]) if self.obj_dim == 1: return (DV1 + DV2 + DV_others,) else: return (DV1 + DV2 + DV_others, x[1])
def _objfun_impl(self, x): from math import sqrt # 1 - We check that the transfer time is positive if x[0] >= x[1]: if self.f_dimension == 1: return (self._UNFEASIBLE, ) else: return (self._UNFEASIBLE, self._UNFEASIBLE) # 2 - We compute the asteroid positions r1, v1 = self._ast1.eph(x[0]) r2, v2 = self._ast2.eph(x[1]) # 3 - We compute Lambert arc l = lambert_problem(r1, r2, (x[1] - x[0]) * DAY2SEC, self._ast1.mu_central_body, False, 0) # 4 - We compute the two impulses v1l = l.get_v1()[0] v2l = l.get_v2()[0] DV1 = [a - b for a, b in zip(v1, v1l)] DV2 = [a - b for a, b in zip(v2, v2l)] a1, a2, tau, dv = damon(DV1, DV2, (x[1] - x[0]) * DAY2SEC) Isp = self._Isp g0 = 9.80665 Tmax = self._Tmax ms = self._ms MIMA = 2 * Tmax / norm(a1) / (1. + exp(-norm(a1) * (x[1] - x[0]) * DAY2SEC / Isp / g0)) DV1 = sum([l * l for l in DV1]) DV2 = sum([l * l for l in DV2]) totDV = sqrt(DV1) + sqrt(DV2) totDT = x[1] - x[0] if ms > MIMA: if self.f_dimension == 1: return (self._UNFEASIBLE, ) else: return (self._UNFEASIBLE, self._UNFEASIBLE) if self.f_dimension == 1: return (totDV, ) else: return (totDV, x[1])
def _objfun_impl(self, x): from math import sqrt # 1 - We check that the transfer time is positive if x[0] >= x[1]: if self.f_dimension == 1: return (self._UNFEASIBLE, ) else: return (self._UNFEASIBLE, self._UNFEASIBLE) # 2 - We compute the asteroid positions r1, v1 = self._ast1.eph(x[0]) r2, v2 = self._ast2.eph(x[1]) # 3 - We compute Lambert arc l = lambert_problem( r1, r2, (x[1] - x[0]) * DAY2SEC, self._ast1.mu_central_body, False, 0) # 4 - We compute the two impulses v1l = l.get_v1()[0] v2l = l.get_v2()[0] DV1 = [a - b for a, b in zip(v1, v1l)] DV2 = [a - b for a, b in zip(v2, v2l)] a1, a2, tau, dv = damon(DV1, DV2, (x[1] - x[0]) * DAY2SEC) Isp = self._Isp g0 = 9.80665 Tmax = self._Tmax ms = self._ms MIMA = 2 * Tmax / norm(a1) / (1. + exp(-norm(a1) * (x[1] - x[0]) * DAY2SEC / Isp / g0)) DV1 = sum([l * l for l in DV1]) DV2 = sum([l * l for l in DV2]) totDV = sqrt(DV1) + sqrt(DV2) totDT = x[1] - x[0] if ms > MIMA: if self.f_dimension == 1: return (self._UNFEASIBLE, ) else: return (self._UNFEASIBLE, self._UNFEASIBLE) if self.f_dimension == 1: return (totDV, ) else: return (totDV, x[1])
def _compute_dvs(self, x): # 1 - we 'decode' the times of flights and compute epochs (mjd2000) T = self._decode_tofs(x) # [T1, T2 ...] ep = np.insert(T, 0, x[0]) # [t0, T1, T2 ...] ep = np.cumsum(ep) # [t0, t1, t2, ...] # 2 - we compute the ephemerides r = [0] * len(self.seq) v = [0] * len(self.seq) for i in range(len(self.seq)): r[i], v[i] = self.seq[i].eph(ep[i]) # 3 - we solve the lambert problems l = list() for i in range(self._n_legs): l.append( lambert_problem(r[i], r[i + 1], T[i] * DAY2SEC, self._common_mu, False, 0)) # 4 - we compute the various dVs needed at fly-bys to match incoming # and outcoming DVfb = list() for i in range(len(l) - 1): vin = [a - b for a, b in zip(l[i].get_v2()[0], v[i + 1])] vout = [a - b for a, b in zip(l[i + 1].get_v1()[0], v[i + 1])] DVfb.append(fb_vel(vin, vout, self.seq[i + 1])) # 5 - we add the departure and arrival dVs DVlaunch_tot = np.linalg.norm( [a - b for a, b in zip(v[0], l[0].get_v1()[0])]) DVlaunch = max(0, DVlaunch_tot - self.vinf) DVarrival = np.linalg.norm( [a - b for a, b in zip(v[-1], l[-1].get_v2()[0])]) if self.orbit_insertion: # In this case we compute the insertion DV as a single pericenter # burn DVper = np.sqrt(DVarrival * DVarrival + 2 * self.seq[-1].mu_self / self.rp_target) DVper2 = np.sqrt(2 * self.seq[-1].mu_self / self.rp_target - self.seq[-1].mu_self / self.rp_target * (1. - self.e_target)) DVarrival = np.abs(DVper - DVper2) return (DVlaunch, DVfb, DVarrival, l, DVlaunch_tot)
def plot(self, x, axes=None): """ ax = prob.plot_trajectory(x, axes=None) - x: encoded trajectory - axes: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from pykep.orbit_plots import plot_planet, plot_lambert, plot_kepler if axes is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axes = fig.gca(projection='3d') axes.scatter(0, 0, 0, color='y') # 1 - we 'decode' the chromosome recording the various deep space # manouvres timing (days) in the list T T = list([0] * (self.N_max - 1)) for i in range(len(T)): T[i] = log(x[2 + 4 * i]) total = sum(T) T = [x[1] * time / total for time in T] # 2 - We compute the starting and ending position r_start, v_start = self.start.eph(epoch(x[0])) if self.phase_free: r_target, v_target = self.target.eph(epoch(x[-1])) else: r_target, v_target = self.target.eph(epoch(x[0] + x[1])) plot_planet(self.start, t0=epoch(x[0]), color=(0.8, 0.6, 0.8), legend=True, units=AU, ax=axes, s=0) plot_planet(self.target, t0=epoch(x[0] + x[1]), color=(0.8, 0.6, 0.8), legend=True, units=AU, ax=axes, s=0) DV_list = x[5::4] maxDV = max(DV_list) DV_list = [s / maxDV * 30 for s in DV_list] colors = ['b', 'r'] * (len(DV_list) + 1) # 3 - We loop across inner impulses rsc = r_start vsc = v_start for i, time in enumerate(T[:-1]): theta = 2 * pi * x[3 + 4 * i] phi = acos(2 * x[4 + 4 * i] - 1) - pi / 2 Vinfx = x[5 + 4 * i] * cos(phi) * cos(theta) Vinfy = x[5 + 4 * i] * cos(phi) * sin(theta) Vinfz = x[5 + 4 * i] * sin(phi) # We apply the (i+1)-th impulse vsc = [a + b for a, b in zip(vsc, [Vinfx, Vinfy, Vinfz])] axes.scatter(rsc[0] / AU, rsc[1] / AU, rsc[2] / AU, color='k', s=DV_list[i]) plot_kepler(rsc, vsc, T[i] * DAY2SEC, self.__common_mu, N=200, color=colors[i], legend=False, units=AU, ax=axes) rsc, vsc = propagate_lagrangian(rsc, vsc, T[i] * DAY2SEC, self.__common_mu) cw = (ic2par(rsc, vsc, self.start.mu_central_body)[2] > pi / 2) # We now compute the remaining two final impulses # Lambert arc to reach seq[1] dt = T[-1] * DAY2SEC l = lambert_problem(rsc, r_target, dt, self.__common_mu, cw, False) plot_lambert(l, sol=0, color=colors[i + 1], legend=False, units=AU, ax=axes, N=200) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] DV1 = norm([a - b for a, b in zip(v_beg_l, vsc)]) DV2 = norm([a - b for a, b in zip(v_end_l, v_target)]) axes.scatter(rsc[0] / AU, rsc[1] / AU, rsc[2] / AU, color='k', s=min(DV1 / maxDV * 30, 40)) axes.scatter(r_target[0] / AU, r_target[1] / AU, r_target[2] / AU, color='k', s=min(DV2 / maxDV * 30, 40)) return axes
def plot(self, x, ax=None): """ ax = prob.plot(x, ax=None) - x: encoded trajectory - ax: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from pykep.orbit_plots import plot_planet, plot_lambert, plot_kepler if ax is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') else: axis = ax axis.scatter(0, 0, 0, color='y') # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T and the cartesian components of vinf T, Vinfx, Vinfy, Vinfz = self._decode_times_and_vinf(x) # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.n_legs + 1)) r_P = list([None] * (self.n_legs + 1)) v_P = list([None] * (self.n_legs + 1)) DV = list([None] * (self.n_legs + 1)) for i, planet in enumerate(self._seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(planet, t0=t_P[i], color=(0.8, 0.6, 0.8), legend=True, units=AU, axes=axis, N=150) # 3 - We start with the first leg v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian(r_P[0], v0, x[4] * T[0] * DAY2SEC, self.common_mu) plot_kepler(r_P[0], v0, x[4] * T[0] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU, axes=axis) # Lambert arc to reach seq[1] dt = (1 - x[4]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, self.common_mu, False, False) plot_lambert(l, sol=0, color='r', legend=False, units=AU, axes=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # 4 - And we proceed with each successive leg for i in range(1, self.n_legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[7 + (i - 1) * 4] * self._seq[i].radius, x[6 + (i - 1) * 4], self._seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) plot_kepler(r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU, axes=axis) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[8 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, self.common_mu, False, False) plot_lambert(l, sol=0, color='r', legend=False, units=AU, N=1000, axes=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) plt.show() return axis
def pretty(self, x): """ prob.plot(x) - x: encoded trajectory Prints human readable information on the trajectory represented by the decision vector x Example:: print(prob.pretty(x)) """ # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T and the cartesian components of vinf T, Vinfx, Vinfy, Vinfz = self._decode_times_and_vinf(x) # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.n_legs + 1)) r_P = list([None] * (self.n_legs + 1)) v_P = list([None] * (self.n_legs + 1)) DV = list([0.0] * (self.n_legs + 1)) for i in range(len(self._seq)): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = self._seq[i].eph(t_P[i]) # 3 - We start with the first leg print("First Leg: " + self._seq[0].name + " to " + self._seq[1].name) print("Departure: " + str(t_P[0]) + " (" + str(t_P[0].mjd2000) + " mjd2000) ") print("Duration: " + str(T[0]) + "days") print("VINF: " + str(x[3] / 1000) + " km/sec") v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian(r_P[0], v0, x[4] * T[0] * DAY2SEC, self.common_mu) print("DSM after " + str(x[4] * T[0]) + " days") # Lambert arc to reach seq[1] dt = (1 - x[4]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, self.common_mu, cw=False, max_revs=0) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) print("DSM magnitude: " + str(DV[0]) + "m/s") # 4 - And we proceed with each successive leg for i in range(1, self.n_legs): print("\nleg no. " + str(i + 1) + ": " + self._seq[i].name + " to " + self._seq[i + 1].name) print("Duration: " + str(T[i]) + "days") # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[7 + (i - 1) * 4] * self._seq[i].radius, x[6 + (i - 1) * 4], self._seq[i].mu_self) print("Fly-by epoch: " + str(t_P[i]) + " (" + str(t_P[i].mjd2000) + " mjd2000) ") print("Fly-by radius: " + str(x[7 + (i - 1) * 4]) + " planetary radii") # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) print("DSM after " + str(x[8 + (i - 1) * 4] * T[i]) + " days") # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[8 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, self.common_mu, cw=False, max_revs=0) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) print("DSM magnitude: " + str(DV[i]) + "m/s") # Last Delta-v print("\nArrival at " + self._seq[-1].name) DV[-1] = norm([a - b for a, b in zip(v_end_l, v_P[-1])]) print("Arrival epoch: " + str(t_P[-1]) + " (" + str(t_P[-1].mjd2000) + " mjd2000) ") print("Arrival Vinf: " + str(DV[-1]) + "m/s") if self._orbit_insertion: # In this case we compute the insertion DV as a single pericenter # burn DVper = np.sqrt(DV[-1] * DV[-1] + 2 * self._seq[-1].mu_self / self._rp_target) DVper2 = np.sqrt(2 * self._seq[-1].mu_self / self._rp_target - self._seq[-1].mu_self / self._rp_target * (1. - self._e_target)) DVinsertion = np.abs(DVper - DVper2) print("Insertion DV: " + str(DVinsertion) + "m/s") print("Total mission time: " + str(sum(T) / 365.25) + " years (" + str(sum(T)) + " days)")
def fitness(self, x): # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T and the cartesian components of vinf T, Vinfx, Vinfy, Vinfz = self._decode_times_and_vinf(x) # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.n_legs + 1)) r_P = list([None] * (self.n_legs + 1)) v_P = list([None] * (self.n_legs + 1)) DV = list([0.0] * (self.n_legs + 1)) for i in range(len(self._seq)): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = self._seq[i].eph(t_P[i]) # 3 - We start with the first leg v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian(r_P[0], v0, x[4] * T[0] * DAY2SEC, self.common_mu) # Lambert arc to reach seq[1] dt = (1 - x[4]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, self.common_mu, cw=False, max_revs=0) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # 4 - And we proceed with each successive leg for i in range(1, self.n_legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[7 + (i - 1) * 4] * self._seq[i].radius, x[6 + (i - 1) * 4], self._seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[8 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, self.common_mu, cw=False, max_revs=0) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) # Last Delta-v if self._add_vinf_arr: DV[-1] = norm([a - b for a, b in zip(v_end_l, v_P[-1])]) if self._orbit_insertion: # In this case we compute the insertion DV as a single pericenter # burn DVper = np.sqrt(DV[-1] * DV[-1] + 2 * self._seq[-1].mu_self / self._rp_target) DVper2 = np.sqrt(2 * self._seq[-1].mu_self / self._rp_target - self._seq[-1].mu_self / self._rp_target * (1. - self._e_target)) DV[-1] = np.abs(DVper - DVper2) if self._add_vinf_dep: DV[0] += x[3] if not self._multi_objective: return (sum(DV), ) else: return (sum(DV), sum(T))
def plot(self, x, axes=None): """ ax = prob.plot_trajectory(x, axes=None) - x: encoded trajectory - axes: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from pykep.orbit_plots import plot_planet, plot_lambert, plot_kepler if axes is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axes = fig.gca(projection='3d') axes.scatter(0, 0, 0, color='y') # 1 - we 'decode' the chromosome recording the various deep space # manouvres timing (days) in the list T T = list([0] * (self.N_max - 1)) for i in range(len(T)): T[i] = log(x[2 + 4 * i]) total = sum(T) T = [x[1] * time / total for time in T] # 2 - We compute the starting and ending position r_start, v_start = self.start.eph(epoch(x[0])) if self.phase_free: r_target, v_target = self.target.eph(epoch(x[-1])) else: r_target, v_target = self.target.eph(epoch(x[0] + x[1])) plot_planet(self.start, t0=epoch(x[0]), color=( 0.8, 0.6, 0.8), legend=True, units=AU, ax=axes, s=0) plot_planet(self.target, t0=epoch( x[0] + x[1]), color=(0.8, 0.6, 0.8), legend=True, units=AU, ax=axes, s=0) DV_list = x[5::4] maxDV = max(DV_list) DV_list = [s / maxDV * 30 for s in DV_list] colors = ['b', 'r'] * (len(DV_list) + 1) # 3 - We loop across inner impulses rsc = r_start vsc = v_start for i, time in enumerate(T[:-1]): theta = 2 * pi * x[3 + 4 * i] phi = acos(2 * x[4 + 4 * i] - 1) - pi / 2 Vinfx = x[5 + 4 * i] * cos(phi) * cos(theta) Vinfy = x[5 + 4 * i] * cos(phi) * sin(theta) Vinfz = x[5 + 4 * i] * sin(phi) # We apply the (i+1)-th impulse vsc = [a + b for a, b in zip(vsc, [Vinfx, Vinfy, Vinfz])] axes.scatter(rsc[0] / AU, rsc[1] / AU, rsc[2] / AU, color='k', s=DV_list[i]) plot_kepler(rsc, vsc, T[i] * DAY2SEC, self.__common_mu, N=200, color=colors[i], legend=False, units=AU, ax=axes) rsc, vsc = propagate_lagrangian( rsc, vsc, T[i] * DAY2SEC, self.__common_mu) cw = (ic2par(rsc, vsc, self.start.mu_central_body)[2] > pi / 2) # We now compute the remaining two final impulses # Lambert arc to reach seq[1] dt = T[-1] * DAY2SEC l = lambert_problem(rsc, r_target, dt, self.__common_mu, cw, False) plot_lambert(l, sol=0, color=colors[ i + 1], legend=False, units=AU, ax=axes, N=200) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] DV1 = norm([a - b for a, b in zip(v_beg_l, vsc)]) DV2 = norm([a - b for a, b in zip(v_end_l, v_target)]) axes.scatter(rsc[0] / AU, rsc[1] / AU, rsc[2] / AU, color='k', s=min(DV1 / maxDV * 30, 40)) axes.scatter(r_target[0] / AU, r_target[1] / AU, r_target[2] / AU, color='k', s=min(DV2 / maxDV * 30, 40)) return axes
def _compute_dvs(self, x: List[float]) -> Tuple[ List[float], # DVs List[Any], # Lambert legs List[float], # T List[Tuple[List[float], List[float]]], # ballistic legs List[float], # epochs of ballistic legs ]: # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T and the cartesian components of vinf T, Vinfx, Vinfy, Vinfz = self._decode_times_and_vinf(x) # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.n_legs + 1)) r_P = list([None] * (self.n_legs + 1)) v_P = list([None] * (self.n_legs + 1)) DV = list([0.0] * (self.n_legs + 1)) for i in range(len(self._seq)): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = self._seq[i].eph(t_P[i]) ballistic_legs: List[Tuple[List[float], List[float]]] = [] ballistic_ep: List[float] = [] lamberts = [] # 3 - We start with the first leg v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] ballistic_legs.append((r_P[0], v0)) ballistic_ep.append(t_P[0].mjd2000) r, v = propagate_lagrangian(r_P[0], v0, x[4] * T[0] * DAY2SEC, self.common_mu) # Lambert arc to reach seq[1] dt = (1 - x[4]) * T[0] * DAY2SEC l = lambert_problem_multirev( v, lambert_problem(r, r_P[1], dt, self.common_mu, cw=False, max_revs=self.max_revs)) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] lamberts.append(l) ballistic_legs.append((r, v_beg_l)) ballistic_ep.append(t_P[0].mjd2000 + x[4] * T[0]) # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # 4 - And we proceed with each successive leg for i in range(1, self.n_legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[7 + (i - 1) * 4] * self._seq[i].radius, x[6 + (i - 1) * 4], self._seq[i].mu_self) ballistic_legs.append((r_P[i], v_out)) ballistic_ep.append(t_P[i].mjd2000) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[8 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem_multirev( v, lambert_problem(r, r_P[i + 1], dt, self.common_mu, cw=False, max_revs=self.max_revs)) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] lamberts.append(l) # DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) ballistic_legs.append((r, v_beg_l)) ballistic_ep.append(t_P[i].mjd2000 + x[8 + (i - 1) * 4] * T[i]) # Last Delta-v if self._add_vinf_arr: DV[-1] = norm([a - b for a, b in zip(v_end_l, v_P[-1])]) if self._orbit_insertion: # In this case we compute the insertion DV as a single pericenter # burn DVper = np.sqrt(DV[-1] * DV[-1] + 2 * self._seq[-1].mu_self / self._rp_target) DVper2 = np.sqrt(2 * self._seq[-1].mu_self / self._rp_target - self._seq[-1].mu_self / self._rp_target * (1. - self._e_target)) DV[-1] = np.abs(DVper - DVper2) if self._add_vinf_dep: DV[0] += x[3] return (DV, lamberts, T, ballistic_legs, ballistic_ep)
def _fitness_impl(self, decoded_x, logging=False, plotting=False, ax=None): """ Computation of the objective function. """ saturn_distance_violated = 0 # decode x t0, u, v, dep_vinf, etas, T, betas, rps = decoded_x # convert incoming velocity vector theta, phi = 2.0 * pi * u, acos(2.0 * v - 1.0) - pi / 2.0 Vinfx = dep_vinf * cos(phi) * cos(theta) Vinfy = dep_vinf * cos(phi) * sin(theta) Vinfz = dep_vinf * sin(phi) # epochs and ephemerides of the planetary encounters t_P = list([None] * (self._n_legs + 1)) r_P = list([None] * (self._n_legs + 1)) v_P = list([None] * (self._n_legs + 1)) lamberts = list([None] * (self._n_legs)) v_outs = list([None] * (self._n_legs)) DV = list([0.0] * (self._n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(t0 + sum(T[0:i])) r_P[i], v_P[i] = self.seq[i].eph(t_P[i]) # first leg v_outs[0] = [Vinfx, Vinfy, Vinfz] # bug fixed # check first leg up to DSM saturn_distance_violated += self.check_distance( r_P[0], v_outs[0], t0, etas[0] * T[0]) r, v = propagate_lagrangian(r_P[0], v_outs[0], etas[0] * T[0] * DAY2SEC, self.common_mu) # Lambert arc to reach seq[1] dt = (1.0 - etas[0]) * T[0] * DAY2SEC lamberts[0] = lambert_problem(r, r_P[1], dt, self.common_mu, self.cw, 0) v_end_l = lamberts[0].get_v2()[0] v_beg_l = lamberts[0].get_v1()[0] # First DSM occuring at time eta0*T0 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # checking first leg after DSM saturn_distance_violated += self.check_distance( r, v_beg_l, etas[0] * T[0], T[0]) # successive legs for i in range(1, self._n_legs): # Fly-by v_outs[i] = fb_prop(v_end_l, v_P[i], rps[i - 1] * self.seq[i].radius, betas[i - 1], self.seq[i].mu_self) # checking next leg up to DSM saturn_distance_violated += self.check_distance( r_P[i], v_outs[i], T[i - 1], etas[i] * T[i]) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_outs[i], etas[i] * T[i] * DAY2SEC, self.common_mu) # Lambert arc to reach next body dt = (1 - etas[i]) * T[i] * DAY2SEC lamberts[i] = lambert_problem(r, r_P[i + 1], dt, self.common_mu, self.cw, 0) v_end_l = lamberts[i].get_v2()[0] v_beg_l = lamberts[i].get_v1()[0] # DSM occuring at time eta_i*T_i DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) # checking next leg after DSM saturn_distance_violated += self.check_distance( r, v_beg_l, etas[i] * T[i], T[i]) # single dv penalty for now if saturn_distance_violated > 0: DV[-1] += DV_PENALTY arr_vinf = norm([a - b for a, b in zip(v_end_l, v_P[-1])]) # last Delta-v if self._add_vinf_arr: DV[-1] = arr_vinf if self._add_vinf_dep: DV[0] += dep_vinf # pretty printing if logging: print("First leg: {} to {}".format(self.seq[0].name, self.seq[1].name)) print("Departure: {0} ({1:0.6f} mjd2000)".format( t_P[0], t_P[0].mjd2000)) print("Duration: {0:0.6f}d".format(T[0])) print("VINF: {0:0.3f}m/s".format(dep_vinf)) print("DSM after {0:0.6f}d".format(etas[0] * T[0])) print("DSM magnitude: {0:0.6f}m/s".format(DV[0])) for i in range(1, self._n_legs): print("\nleg {}: {} to {}".format(i + 1, self.seq[i].name, self.seq[i + 1].name)) print("Duration: {0:0.6f}d".format(T[i])) print("Fly-by epoch: {0} ({1:0.6f} mjd2000)".format( t_P[i], t_P[i].mjd2000)) print("Fly-by radius: {0:0.6f} planetary radii".format(rps[i - 1])) print("DSM after {0:0.6f}d".format(etas[i] * T[i])) print("DSM magnitude: {0:0.6f}m/s".format(DV[i])) print("\nArrival at {}".format(self.seq[-1].name)) print("Arrival epoch: {0} ({1:0.6f} mjd2000)".format( t_P[-1], t_P[-1].mjd2000)) print("Arrival Vinf: {0:0.3f}m/s".format(arr_vinf)) print("Total mission time: {0:0.6f}d ({1:0.3f} years)".format( sum(T), sum(T) / 365.25)) # plotting if plotting: ax.scatter(0, 0, 0, color='chocolate') for i, planet in enumerate(self.seq): plot_planet(planet, t0=t_P[i], color=pl2c[planet.name], legend=True, units=AU, ax=ax) for i in range(0, self._n_legs): plot_kepler(r_P[i], v_outs[i], etas[i] * T[i] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU, ax=ax) for l in lamberts: plot_lambert(l, sol=0, color='r', legend=False, units=AU, N=1000, ax=ax) # returning building blocks for objectives return (DV, T, arr_vinf, lamberts)
def plot(self, x, ax=None): """ ax = prob.plot(x, ax=None) - x: encoded trajectory - ax: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from pykep.orbit_plots import plot_planet, plot_lambert, plot_kepler if ax is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') else: axis = ax axis.scatter(0, 0, 0, color='y') # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T and the cartesian components of vinf T, Vinfx, Vinfy, Vinfz = self._decode_times_and_vinf(x) # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) DV = list([None] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(planet, t0=t_P[i], color=( 0.8, 0.6, 0.8), legend=True, units=AU, ax=axis) # 3 - We start with the first leg v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian( r_P[0], v0, x[5] * T[0] * DAY2SEC, self.common_mu) plot_kepler(r_P[0], v0, x[5] * T[0] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU, ax=axis) # Lambert arc to reach seq[1] dt = (1 - x[5]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, self.common_mu, False, False) plot_lambert(l, sol=0, color='r', legend=False, units=AU, ax=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # 4 - And we proceed with each successive leg for i in range(1, self.__n_legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[ 8 + (i - 1) * 4] * self.seq[i].radius, x[7 + (i - 1) * 4], self.seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian( r_P[i], v_out, x[9 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) plot_kepler(r_P[i], v_out, x[9 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU, ax=axis) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[9 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, self.common_mu, False, False) plot_lambert(l, sol=0, color='r', legend=False, units=AU, N=1000, ax=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) plt.show() return axis
def pretty(self, x): """ prob.plot(x) - x: encoded trajectory Prints human readable information on the trajectory represented by the decision vector x Example:: print(prob.pretty(x)) """ # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T and the cartesian components of vinf T, Vinfx, Vinfy, Vinfz = self._decode_times_and_vinf(x) # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) DV = list([None] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = self.seq[i].eph(t_P[i]) # 3 - We start with the first leg print("First Leg: " + self.seq[0].name + " to " + self.seq[1].name) print("Departure: " + str(t_P[0]) + " (" + str(t_P[0].mjd2000) + " mjd2000) ") print("Duration: " + str(T[0]) + "days") print("VINF: " + str(x[4] / 1000) + " km/sec") v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian( r_P[0], v0, x[5] * T[0] * DAY2SEC, self.common_mu) print("DSM after " + str(x[5] * T[0]) + " days") # Lambert arc to reach seq[1] dt = (1 - x[5]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, self.common_mu, False, False) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) print("DSM magnitude: " + str(DV[0]) + "m/s") # 4 - And we proceed with each successive leg for i in range(1, self.__n_legs): print("\nleg no. " + str(i + 1) + ": " + self.seq[i].name + " to " + self.seq[i + 1].name) print("Duration: " + str(T[i]) + "days") # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[ 8 + (i - 1) * 4] * self.seq[i].radius, x[7 + (i - 1) * 4], self.seq[i].mu_self) print( "Fly-by epoch: " + str(t_P[i]) + " (" + str(t_P[i].mjd2000) + " mjd2000) ") print( "Fly-by radius: " + str(x[8 + (i - 1) * 4]) + " planetary radii") # s/c propagation before the DSM r, v = propagate_lagrangian( r_P[i], v_out, x[9 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) print("DSM after " + str(x[9 + (i - 1) * 4] * T[i]) + " days") # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[9 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, self.common_mu, False, False) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) print("DSM magnitude: " + str(DV[i]) + "m/s") # Last Delta-v print("\nArrival at " + self.seq[-1].name) DV[-1] = norm([a - b for a, b in zip(v_end_l, v_P[-1])]) print( "Arrival epoch: " + str(t_P[-1]) + " (" + str(t_P[-1].mjd2000) + " mjd2000) ") print("Arrival Vinf: " + str(DV[-1]) + "m/s") print("Total mission time: " + str(sum(T) / 365.25) + " years")