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]")