def _plot_traj(self, z, axes, units):
# states
x0 = self.leg.x0
xf = self.leg.xf
# times
t0 = pk.epoch(self.leg.t0)
tf = pk.epoch(self.leg.tf)
# Computes the osculating Keplerian elements at start and arrival
elem0 = list(pk.ic2par(x0[0:3], x0[3:6], self.leg.mu))
elemf = list(pk.ic2par(xf[0:3], xf[3:6], self.leg.mu))
# Converts the eccentric anomaly into eccentric anomaly
elem0[5] = elem0[5] - elem0[1] * np.sin(elem0[5])
elemf[5] = elemf[5] - elemf[1] * np.sin(elemf[5])
# Creates two virtual keplerian planets with the said elements
kep0 = pk.planet.keplerian(t0, elem0)
kepf = pk.planet.keplerian(tf, elemf)
# Plots the departure and arrival osculating orbits
pk.orbit_plots.plot_planet(kep0,
t0,
units=units,
color=(0.8, 0.8, 0.8),
axes=axes)
pk.orbit_plots.plot_planet(kepf,
tf,
units=units,
color=(0.8, 0.8, 0.8),
axes=axes)
def _plot_traj(self, z, axes, units):
# states
x0 = self.leg.x0
xf = self.leg.xf
# times
t0 = pk.epoch(self.leg.t0)
tf = pk.epoch(self.leg.tf)
# Computes the osculating Keplerian elements at start and arrival
elem0 = list(pk.ic2par(x0[0:3], x0[3:6], self.leg.mu))
elemf = list(pk.ic2par(xf[0:3], xf[3:6], self.leg.mu))
# Converts the eccentric anomaly into eccentric anomaly
elem0[5] = elem0[5] - elem0[1] * np.sin(elem0[5])
elemf[5] = elemf[5] - elemf[1] * np.sin(elemf[5])
# Creates two virtual keplerian planets with the said elements
kep0 = pk.planet.keplerian(t0, elem0)
kepf = pk.planet.keplerian(tf, elemf)
# Plots the departure and arrival osculating orbits
pk.orbit_plots.plot_planet(
kep0, t0, units=units, color=(0.8, 0.8, 0.8), ax=axes)
pk.orbit_plots.plot_planet(
kepf, tf, units=units, color=(0.8, 0.8, 0.8), ax=axes)
def _plot_traj(self, z, axes, units=pk.AU):
"""Plots spacecraft trajectory.
Args:
- z (``tuple``, ``list``, ``numpy.ndarray``): Decision chromosome.
- axes (``matplotlib.axes._subplots.Axes3DSubplot``): 3D axes to use for the plot
- units (``float``, ``int``): Length unit by which to normalise data.
Examples:
>>> prob.extract(pykep.trajopt.indirect_pt2or).plot_traj(pop.champion_x)
"""
# states
x0 = self.x0
# times
t0 = self.t0
tf = pk.epoch(t0.mjd2000 + z[0])
# Computes the osculating Keplerian elements at start
elem0 = list(pk.ic2par(x0[0:3], x0[3:6], self.leg.mu))
# Converts the eccentric anomaly into eccentric anomaly
elem0[5] = elem0[5] - elem0[1] * np.sin(elem0[5])
# Creates a virtual keplerian planet with the said elements
kep0 = pk.planet.keplerian(t0, elem0)
# Plots the departure and arrival osculating orbits
pk.orbit_plots.plot_planet(
kep0, t0, units=units, color=(0.8, 0.8, 0.8), ax=axes)
pk.orbit_plots.plot_planet(
self.pf, tf, units=units, color=(0.8, 0.8, 0.8), ax=axes)
def _plot_traj(self, z, axes, units=pk.AU):
"""Plots spacecraft trajectory.
Args:
- z (``tuple``, ``list``, ``numpy.ndarray``): Decision chromosome.
- axes (``matplotlib.axes._subplots.Axes3DSubplot``): 3D axes to use for the plot
- units (``float``, ``int``): Length unit by which to normalise data.
Examples:
>>> prob.extract(pykep.trajopt.indirect_pt2or).plot_traj(pop.champion_x)
"""
# times
t0 = pk.epoch(0)
tf = pk.epoch(z[1])
# Keplerian elements of the osculating orbit at start
elem0 = list(pk.ic2par(self.x0[0:3], self.x0[3:6], self.leg.mu))
# Eccentric to Mean Anomaly
elem0[5] = elem0[5] - elem0[1] * np.sin(elem0[5])
# Mean Anomaly at the target orbit
Mf = z[1] - self.elemf[1] * np.sin(z[1])
elemf = np.hstack([self.elemf[:5], [Mf]])
# Keplerian elements
kep0 = pk.planet.keplerian(t0, elem0)
kepf = pk.planet.keplerian(tf, self.elemf)
# plot departure and arrival
pk.orbit_plots.plot_planet(
kep0, t0, units=units, color=(0.8, 0.8, 0.8), ax=axes)
pk.orbit_plots.plot_planet(
kepf, tf, units=units, color=(0.8, 0.8, 0.8), ax=axes)
def from_cartesian_to_tle_elements(state):
r, v = state[0], state[1]
kepl_el = pykep.ic2par(r, v, pykep.MU_EARTH)
# these are returned as (a,e,i,W,w,E) --> [m], [-], [rad], [rad], [rad], [rad]
mean_motion = np.sqrt(pykep.MU_EARTH / ((kepl_el[0])**(3.0)))
eccentricity = kepl_el[1]
inclination = kepl_el[2]
argument_of_perigee = kepl_el[4]
raan = kepl_el[3]
mean_anomaly = kepl_el[5] - kepl_el[1] * np.sin(kepl_el[5]) + np.pi
return mean_motion, eccentricity, inclination, argument_of_perigee, raan, mean_anomaly
def from_cartesian_to_keplerian(state):
r, v = state[0], state[1]
kepl_el = pykep.ic2par(r, v, pykep.MU_EARTH)
# these are returned as (a,e,i,W,w,E) --> [L], [-], [rad], [rad], [rad], [rad]
semi_major_axis = kepl_el[0] # [0, inf)
eccentricity = kepl_el[1] # (0, 1)
inclination = kepl_el[2] # [0, pi]
argument_of_perigee = kepl_el[4]
raan = kepl_el[3] #right ascension ascending node
E = kepl_el[5] #eccentric anomaly
return semi_major_axis, eccentricity, inclination, argument_of_perigee, raan, E
def _plot_traj(self, z, axes, units=pk.AU):
"""Plots spacecraft trajectory.
Args:
- z (``tuple``, ``list``, ``numpy.ndarray``): Decision chromosome.
- atol (``float``, ``int``): Absolute integration solution tolerance.
- rtol (``float``, ``int``): Relative integration solution tolerance.
- units (``float``, ``int``): Length unit by which to normalise data.
Examples:
>>> prob.extract(pykep.trajopt.indirect_pt2or).plot_traj(pop.champion_x)
"""
# times
t0 = pk.epoch(0)
tf = pk.epoch(z[1])
# Keplerian elements of the osculating orbit at start
elem0 = list(pk.ic2par(self.x0[0:3], self.x0[3:6], self.leg.mu))
# Eccentric to Mean Anomaly
elem0[5] = elem0[5] - elem0[1] * np.sin(elem0[5])
# Mean Anomaly at the target orbit
Mf = z[1] - self.elemf[1] * np.sin(z[1])
elemf = np.hstack([self.elemf[:5], [Mf]])
# Keplerian elements
kep0 = pk.planet.keplerian(t0, elem0)
kepf = pk.planet.keplerian(tf, self.elemf)
# plot departure and arrival
pk.orbit_plots.plot_planet(kep0,
t0,
units=units,
color=(0.8, 0.8, 0.8),
ax=axes)
pk.orbit_plots.plot_planet(kepf,
tf,
units=units,
color=(0.8, 0.8, 0.8),
ax=axes)
def _plot_traj(self, z, axes, units=pk.AU):
"""Plots spacecraft trajectory.
Args:
- z (``tuple``, ``list``, ``numpy.ndarray``): Decision chromosome.
- atol (``float``, ``int``): Absolute integration solution tolerance.
- rtol (``float``, ``int``): Relative integration solution tolerance.
- units (``float``, ``int``): Length unit by which to normalise data.
Examples:
>>> prob.extract(pykep.trajopt.indirect_pt2or).plot_traj(pop.champion_x)
"""
# states
x0 = self.x0
# times
t0 = self.t0
tf = pk.epoch(t0.mjd2000 + z[0])
# Computes the osculating Keplerian elements at start
elem0 = list(pk.ic2par(x0[0:3], x0[3:6], self.leg.mu))
# Converts the eccentric anomaly into eccentric anomaly
elem0[5] = elem0[5] - elem0[1] * np.sin(elem0[5])
# Creates a virtual keplerian planet with the said elements
kep0 = pk.planet.keplerian(t0, elem0)
# Plots the departure and arrival osculating orbits
pk.orbit_plots.plot_planet(kep0,
t0,
units=units,
color=(0.8, 0.8, 0.8),
ax=axes)
pk.orbit_plots.plot_planet(self.pf,
tf,
units=units,
color=(0.8, 0.8, 0.8),
ax=axes)
input_dim = 7
output_indices = [8] # {u=7, phi=8, theta=9}
output_dim = 1 # 2
inputs = moc_data[:, input_indices]
# STATE TRANSFORMATION
# Compute additional variables
n_instances = len(inputs)
# Compute vector norms of position and velocity
r_mag = np.linalg.norm(inputs[:,:3], axis=1)
v_mag = np.linalg.norm(inputs[:,3:6], axis=1)
# Compute keplerian elems
inputs_kep = np.array([pykep.ic2par(inputs[i,:3], inputs[i,3:6], pykep.MU_SUN) for i in range(n_instances)])
# Augment state with 2 variables: position & velocity magnitude
if augment_dataset == 1:
input_dim = 9
inputs_aug = np.zeros((n_instances, input_dim))
inputs_aug[:, :3] = inputs[:,:3]
inputs_aug[:, 3] = r_mag
inputs_aug[:, 4:7] = inputs[:,3:6]
inputs_aug[:, 7] = v_mag
inputs_aug[:, 8] = inputs[:,6]
inputs = inputs_aug
# Transform dataset to keplerian elements
if augment_dataset == 2:
output_indices = [7] # {u=7, phi=8, theta=9}
output_dim = 1 # 2
inputs = moc_data[:, input_indices]
# STATE TRANSFORMATION
# Compute additional variables
n_instances = len(inputs)
# Compute vector norms of position and velocity
r_mag = np.linalg.norm(inputs[:, :3], axis=1)
v_mag = np.linalg.norm(inputs[:, 3:6], axis=1)
# Compute keplerian elems
inputs_kep = np.array([
pykep.ic2par(inputs[i, :3], inputs[i, 3:6], pykep.MU_SUN)
for i in range(n_instances)
])
# Augment state with 2 variables: position & velocity magnitude
if augment_dataset == 1:
input_dim = 9
inputs_aug = np.zeros((n_instances, input_dim))
inputs_aug[:, :3] = inputs[:, :3]
inputs_aug[:, 3] = r_mag
inputs_aug[:, 4:7] = inputs[:, 3:6]
inputs_aug[:, 7] = v_mag
inputs_aug[:, 8] = inputs[:, 6]
inputs = inputs_aug
def pretty(self, x):
lambert_legs = []
resos = []
rvt_outs, rvt_ins, rvt_pls, _, dvs = self._compute_dvs(
x, lambert_legs, resos)
rvt_outs = [
rvt.rotate(self._rotation_axis, self._theta) for rvt in rvt_outs
]
rvt_ins[1:] = [
rvt.rotate(self._rotation_axis, self._theta) for rvt in rvt_ins[1:]
]
rvt_pls = [
rvt.rotate(self._rotation_axis, self._theta) for rvt in rvt_pls
]
ep = [epoch(rvt_pl._t * SEC2DAY) for rvt_pl in rvt_pls]
b_legs = [[rvt_out._r, rvt_out._v] for rvt_out in rvt_outs]
Vinfx, Vinfy, Vinfz = [
a - b for a, b in zip(b_legs[0][1], self._seq[0].eph(ep[0])[1])
]
common_mu = rvt_outs[0]._mu
lambert_indices = [lam.best_i for lam in lambert_legs]
transfer_ang = _angle(rvt_outs[0]._r, rvt_outs[1]._r)
print("Multiple Gravity Assist (MGA) + Resonance problem: ")
print("Planet sequence: ", [pl.name for pl in self._seq])
print("Departure: ", self._seq[0].name)
print("\tEpoch: ", ep[0], " [mjd2000]")
print("\tSpacecraft velocity: ", b_legs[0][1], "[m/s]")
print("\tLaunch velocity: ", [Vinfx, Vinfy, Vinfz], "[m/s]")
_, _, transfer_i, _, _, _ = ic2par(*(b_legs[0]), common_mu)
print("\tTransfer Angle: ", np.degrees(transfer_ang), "deg")
print("\tOutgoing Inclination:", transfer_i * RAD2DEG, "[deg]")
print("\tNumber of Revolutions:", int((lambert_indices[0] + 1) / 2))
print("\tLambert Index:", int(lambert_indices[0]))
lambert_i = 0
reso_i = 0
for i in range(1, len(self._seq) - 1):
pl = self._seq[i]
e = ep[i]
dv = dvs[i]
leg = b_legs[i]
rtv_in = rvt_ins[i]
rtv_out = rvt_outs[i]
rtv_pl = rvt_pls[i]
vr_in = [a - b for a, b in zip(rtv_in._v, rtv_pl._v)]
vr_out = [a - b for a, b in zip(rtv_out._v, rtv_pl._v)]
v_inf = np.linalg.norm(vr_out)
deflection = _angle(vr_in, vr_out)
transfer_ang = _angle(
rtv_out._r, rvt_outs[i +
1]._r) if i < len(self._seq) - 2 else 0
print("Fly-by: ", pl.name)
print("\tEpoch: ", e, " [mjd2000]")
print("\tDV: ", dv, "[m/s]")
print("\tV_inf: ", v_inf, "[m/s]")
print("\tTransfer Angle: ", np.degrees(transfer_ang), "deg")
print("\tGA deflection: ", np.degrees(deflection), "deg")
eph = [
rotate_vector(v, self._rotation_axis, self._theta)
for v in pl.eph(e)
]
if i < len(self._seq) - 1:
assert np.linalg.norm([a - b
for a, b in zip(leg[0], eph[0])]) < 0.01
_, _, transfer_i, _, _, _ = ic2par(eph[0], leg[1], common_mu)
print("\tOutgoing Inclination:", transfer_i * RAD2DEG, "[deg]")
if pl != self._seq[i - 1]: # no lamberts for resonances
print("\tLambert Index:", str(lambert_indices[lambert_i]))
lambert_i += 1
else: # resonance at Venus
print("\tResonance:", str(resos[reso_i]._resonance))
print("\tResonance time error:",
str(resos[reso_i]._timing_error) + " sec")
reso_i += 1
print("Final Fly-by: ", self._seq[-1].name)
print("\tEpoch: ", ep[-1], " [mjd2000]")
print("\tSpacecraft velocity: ", rvt_outs[-1]._v, "[m/s]")
print("\tBeta: ", x[-1])
print("\tr_p: ", self._seq[-1].radius + self._safe_distance)
print("Resulting Solar orbit:")
a, e, i, _, _, _ = rvt_outs[-1].kepler()
print("Perihelion: ", (a * (1 - e)) / AU, " AU")
print("Aphelion: ", (a * (1 + e)) / AU, " AU")
print("Inclination: ", i * RAD2DEG, " degrees")
T = [
SEC2DAY * (rvt_outs[i + 1]._t - rvt_outs[i]._t)
for i in range(len(rvt_outs) - 1)
]
print("Time of flights: ", T, "[days]")
