def test_number_of_lines_for_osculating_orbit():
op1 = OrbitPlotter()
ss = iss
l1 = op1.plot(ss)
assert len(l1) == 2
def test_number_of_lines_for_osculating_orbit():
op1 = OrbitPlotter()
ss = iss
l1 = op1.plot(ss)
assert len(l1) == 2
def test_set_frame():
op = OrbitPlotter()
p = [1, 0, 0] * u.one
q = [0, 1, 0] * u.one
w = [0, 0, 1] * u.one
op.set_frame(p, q, w)
assert op._frame == (p, q, w)
def test_axes_labels_and_title():
ax = plt.gca()
op = OrbitPlotter(ax)
ss = iss
op.plot(ss)
assert ax.get_xlabel() == "$x$ (km)"
assert ax.get_ylabel() == "$y$ (km)"
def test_axes_labels_and_title():
ax = plt.gca()
op = OrbitPlotter(ax)
ss = iss
op.plot(ss)
assert ax.get_xlabel() == "$x$ (km)"
assert ax.get_ylabel() == "$y$ (km)"
def test_set_frame():
op = OrbitPlotter()
p = [1, 0, 0] * u.one
q = [0, 1, 0] * u.one
w = [0, 0, 1] * u.one
op.set_frame(p, q, w)
assert op._frame == (p, q, w)
def test_plot_trajectory_sets_label():
op = OrbitPlotter()
earth = Orbit.from_body_ephem(Earth)
mars = Orbit.from_body_ephem(Mars)
trajectory = earth.sample()
op.plot(mars, label="Mars")
op.plot_trajectory(trajectory, label="Earth")
legend = plt.gca().get_legend()
assert legend.get_texts()[1].get_text() == "Earth"
def test_color():
op = OrbitPlotter()
ss = iss
c = "#FF0000"
op.plot(ss, label='ISS', color=c)
ax = plt.gca()
assert ax.get_legend().get_lines()[0].get_c() == c
for element in ax.get_lines():
assert element.get_c() == c
def test_legend():
op = OrbitPlotter()
ss = iss
op.plot(ss, label='ISS')
legend = plt.gca().get_legend()
ss.epoch.out_subfmt = 'date_hm'
label = '{} ({})'.format(ss.epoch.iso, 'ISS')
assert legend.get_texts()[0].get_text() == label
def test_color():
op = OrbitPlotter()
ss = iss
c = "#FF0000"
op.plot(ss, label="ISS", color=c)
ax = plt.gca()
assert ax.get_legend().get_lines()[0].get_c() == c
for element in ax.get_lines():
assert element.get_c() == c
def test_legend():
op = OrbitPlotter()
ss = iss
op.plot(ss, label="ISS")
legend = plt.gca().get_legend()
ss.epoch.out_subfmt = "date_hm"
label = "{} ({})".format(ss.epoch.iso, "ISS")
assert legend.get_texts()[0].get_text() == label
def test_legend():
op = OrbitPlotter()
ss = iss
op.plot(ss, label='ISS')
legend = plt.gca().get_legend()
ss.epoch.out_subfmt = 'date_hm'
label = '{} ({})'.format(ss.epoch.iso, 'ISS')
assert legend.get_texts()[0].get_text() == label
def mission_plot(date_launch, date_arrival, planet):
color_planet_e = 'royalblue'
color_trans = 'dimgrey'
color_orbit_trans = 'orchid'
r0, v0, rf, vf, va, vb, rr_planet1, rr_planet2, times_vector = transit(
date_launch, date_arrival, 'earth', planet)
# Obliczenie orbit transferowych oraz orbit planet
ss0_trans = Orbit.from_vectors(Sun, r0, va, date_launch)
ssf_trans = Orbit.from_vectors(Sun, rf, vb, date_arrival)
ss_e = Orbit.from_vectors(Sun, r0, v0, date_launch)
ss_p = Orbit.from_vectors(Sun, rf, vf, date_arrival)
pl_planet, color_planet = planets2plot(planet)
#wykres orbit 2D
orb = OrbitPlotter()
orb.plot(ss_p, label=pl_planet, color=color_planet)
orb.plot(ss_e, label=Earth, color=color_planet_e)
orb.plot(ssf_trans, label='Orbita transferowa', color=color_orbit_trans)
#wykres orbit i trajektorii lotu 3D
frame = myplot.OrbitPlotter3D()
frame.set_attractor(Sun)
frame.plot_trajectory(rr_planet1, label=Earth, color=color_planet_e)
frame.plot(ss_e, label=Earth, color=color_planet_e)
frame.plot(ss_p, label=pl_planet, color=color_planet)
frame.plot_trajectory(rr_planet2, label=pl_planet, color=color_planet)
frame.plot_trajectory(ss0_trans.sample(times_vector),
label="Mission trajectory",
color=color_trans)
frame.set_view(30 * u.deg, 260 * u.deg, distance=3 * u.km)
frame.show(title="Mission to Solar System Planet")
def test_set_frame_raises_error_if_frame_exists():
op = OrbitPlotter()
p = [1, 0, 0] * u.one
q = [0, 1, 0] * u.one
w = [0, 0, 1] * u.one
op.set_frame(p, q, w)
with pytest.raises(NotImplementedError):
op.set_frame(p, q, w)
def test_plot_trajectory_sets_label():
op = OrbitPlotter()
earth = Orbit.from_body_ephem(Earth)
mars = Orbit.from_body_ephem(Mars)
trajectory = earth.sample()
op.plot(mars, label="Mars")
op.plot_trajectory(trajectory, label="Earth")
legend = plt.gca().get_legend()
assert legend.get_texts()[1].get_text() == "Earth"
def test_number_of_lines_for_osculating_orbit():
_, (ax1, ax2) = plt.subplots(ncols=2)
op1 = OrbitPlotter(ax1)
op2 = OrbitPlotter(ax2)
ss = iss
l1 = op1.plot(ss, osculating=False)
l2 = op2.plot(ss, osculating=True)
assert len(l1) == 1
assert len(l2) == 2
import numpy as np
import matplotlib.pyplot as plt
plt.ion() # To immediately show plots
from astropy import units as u
from poliastro.bodies import Earth, Mars, Sun
from poliastro.twobody import Orbit
plt.style.use("seaborn") # Recommended
h = 625*u.km
r_circ = Earth.R + h
circ = Orbit.circular(Earth,h)
T_circ = circ.state.period
N = 9
delay = T_circ/N
T_ph = T_circ + delay
a_ph = np.power(T_ph/2/np.pi * np.sqrt(Earth.k),(2/3))
rp=Earth.R + h
ra = 2*a_ph - rp
e_ph = (ra-rp)/(ra+rp)
phasing = Orbit.from_classical(Earth,a_ph,e_ph,0*u.deg,0*u.deg,0*u.deg,0*u.deg)
from poliastro.plotting import OrbitPlotter
op = OrbitPlotter()
op.plot(circ, label="Final circular orbit")
op.plot(phasing, label="Phasing orbit")
def heatmap_orbit(ss_orig, xticks, yticks):
ss_orig = ss_orig.propagate(0.001 * u.s)
earth_radius = 6371 #km
best_i = 0
best_j = 0
best_angle = 0
best_periapsis = 100000 * u.km
superiour_periapsis = best_periapsis
best_ss = ss_orig
op = OrbitPlotter()
#Plot original orbit
#op.plot(ss,label = "Original orbit")
#plt.show()
period = ss_orig.state.period
myData = []
top_line = []
original_distance = ss_orig.r_p.value - earth_radius
top_line.append(ss_orig.r_p)
angle_myData = []
for time in time_range(period, yticks):
row = []
ss_prop = ss_orig.propagate(time)
#We find the angle to the debris
pos = functions.orbit_to_position(ss_prop)
first_angle = functions.vec_to_angle_2d(pos[0], pos[1])
angle_myData.append(first_angle)
#Reset best periapsis:
best_periapsis = 10000000 * u.km
#We try different angles but always with the same magnitude
#The angle is relative to the orbit.
#This means that 0 degrees is a head on collision
#90 degrees is a collision so that it will line up towards earth
#180 degrees is a collision from behind, which is hard to accomplish.
xlabels = []
for angle in range(-180, 180, int(360 / yticks)):
xlabels.append(angle)
orbit_vector = functions.get_vector_orbit(ss_prop)
new_angle = functions.vec_to_angle_2d(orbit_vector[0].value,
orbit_vector[1].value)
new_angle = new_angle - 180 + angle
#The angle is normalized, meaning it will have the same length no matter what.
x, y = functions.angle_to_vec_2d(new_angle)
ss = functions.orbit_impulse(ss_prop,
[x * 10, y * 10, 0] * u.m / u.s)
#The periapsis tells us the closest point to earth.
periapsis_radius = ss.r_p
#We insert the radius
row.append(periapsis_radius.value - earth_radius)
if periapsis_radius < best_periapsis:
best_periapsis = periapsis_radius
best_x = x
best_y = y
best_angle = angle
#If this is within the karman line, the debris will be destroyed
#print(periapsis_radius - earth_radius* u.km)
print()
x = best_x
y = best_y
print(x)
print(y)
print(best_angle)
ss = functions.orbit_impulse(ss_prop, [x * 10, y * 10, 0] * u.m / u.s)
#The periapsis tells us the closest point to earth.
periapsis_radius = ss.r_p
if periapsis_radius < superiour_periapsis:
superiour_periapsis = periapsis_radius
best_ss = ss
#If this is within the karman line, the debris will be destroyed
print(periapsis_radius - earth_radius * u.km)
#Plot the best result
label = "angle: {}, length: {:4.4f}".format(
best_angle, periapsis_radius - earth_radius * u.km)
op.plot(ss, label=label)
#Save the row into the data.
myData.append(row)
op2 = OrbitPlotter()
pos = functions.orbit_to_position(best_ss)
first_angle = functions.vec_to_angle_2d(pos[0], pos[1])
print(first_angle)
print(best_ss.r_p.value - earth_radius)
op2.plot(ss_orig, label="original")
op2.plot(best_ss, label="Best outcome")
plt.show()
#Sort myData:
new_data = [x for _, x in sorted(zip(angle_myData, myData))]
ylabels = sorted(angle_myData)
ax = sns.heatmap(
new_data,
linewidth=0,
cmap="RdYlGn_r",
center=original_distance,
cbar_kws={'label': 'Distance to periapsis minus radius of earth [km]'})
xticks = ax.get_xticks()
xlabels2 = ax.get_xticklabels()
for i, value in enumerate(xticks):
xlabels2[i] = str(round(float(xlabels[int(value)]), 1))
ax.set_xticklabels(xlabels2)
yticks = ax.get_yticks()
ylabels2 = ax.get_yticklabels()
for i, value in enumerate(yticks):
ylabels2[i] = str(round(float(ylabels[int(value)]), 1))
ax.set_yticklabels(ylabels2)
ax.set_xlabel("Angle of impact [Degrees]")
ax.set_ylabel("Angle of debris [Degrees]")
for tick in ax.get_xticklabels():
tick.set_rotation(45)
for tick in ax.get_yticklabels():
tick.set_rotation(0)
plt2.show()
myFile = open('saved_values.csv', 'w')
with myFile:
writer = csv.writer(myFile)
writer.writerows(myData)
# DeltaV of New Horizons mission
dv_NH_1 = 16.26 * u.km / u.s
ss_trans, t, T, t_trans = Earth_to_Jupiter(dv_NH_1)
print("Time from now to the next launch window = %2.3f d" % t.to(u.d).value)
print("Time between launch windows = %2.3f d" % T.to(u.d).value)
print("Transfer time from Earth to Jupiter = %2.3f d" % t_trans.to(u.d).value)
# Plotting
fig, ax = plt.subplots()
ax.grid(True)
ax.set_title("Transfer orbit from Earth to Jupiter with deltaV = %2.2f Km/s" %
dv_NH_1.value)
op = OrbitPlotter(ax)
op.plot(ss_Earth, label="Now")
op.plot(ss_Jupiter, label="Now")
op.plot(ss_trans, label="Now")
op.plot(ss_Earth.propagate(t), label="At launch")
op.plot(ss_Jupiter.propagate(t), label="At launch")
op.plot(ss_Earth.propagate(t + t_trans), label="At arrival")
op.plot(ss_Jupiter.propagate(t + t_trans), label="At arrival")
op.plot(ss_trans.propagate(t_trans), label="At arrival")
plt.show()
# Second plot, for different delta_V values
def test_orbitplotter_has_axes():
ax = "Unused axes"
op = OrbitPlotter(ax)
assert op.ax is ax
hoh = Maneuver.hohmann(ss_i, 36000 * u.km)
hoh.get_total_cost()
hoh.get_total_time()
print(hoh.get_total_cost())
print(hoh.get_total_time())
hoh.impulses[0]
hoh[0]
tuple(val.decompose([u.km, u.s]) for val in hoh[1])
ss_f = ss_i.apply_maneuver(hoh)
#plot(ss_f)
from poliastro.plotting import OrbitPlotter
op = OrbitPlotter()
ss_a, ss_f = ss_i.apply_maneuver(hoh, intermediate=True)
#op.plot(ss_i, label="Initial orbit")
#op.plot(ss_a, label="Transfer orbit")
#op.plot(ss_f, label="Final orbit")
from astropy import time
epoch = time.Time("2015-05-09 10:43")
Orbit.from_body_ephem(Earth, epoch)
from astropy.coordinates import solar_system_ephemeris
solar_system_ephemeris.set("jpl")
date_launch = time.Time('2011-11-26 15:02', scale='utc')
date_arrival = time.Time('2012-08-06 05:17', scale='utc')
# State of the Earth the day of the flyby
ss_efly = Orbit.from_body_ephem(Earth, date_flyby)
r_efly, v_efly = ss_efly.rv()
# Assume that the insertion velocity is tangential to that of the Earth
dv = C_3**.5 * v_e0 / norm(v_e0)
man = Maneuver.impulse(dv)
# Inner Cruise 1
ic1 = ss_e0.apply_maneuver(man)
print("Position and Velocity of IC1: ",ic1.rv())
ic1.period.to(u.year)
op = OrbitPlotter()
op.plot(ss_e0)
op.plot(ic1)
# We propagate until the aphelion
ss_aph = ic1.propagate(ic1.period / 2)
print("Space Shuttle at Aphelion: ",ss_aph.epoch)
# Let's compute the Lambert solution to do the flyby of the Earth
time_of_flight = date_flyby - ss_aph.epoch
print("Time of Flight: ",time_of_flight)
(v_aph, v_fly), = izzo.lambert(Sun.k, ss_aph.r, ss_efly.r, time_of_flight)
# Check the delta-V
from poliastro.examples import molniya
from poliastro.plotting import plot, OrbitPlotter, BODY_COLORS
from poliastro.bodies import Sun, Earth, Mars
from poliastro.twobody import Orbit
date = time.Time("2018-02-07 12:00", scale='utc')
start = dt.datetime(2018, 2, 1, 12, 0)
length = 1
days_dt = [
dt.datetime(2018, 2, 1, 12, 0) + dt.timedelta(days=1 * n)
for n in range(length)
]
days_as = [time.Time(day, scale='tdb') for day in days_dt]
op = OrbitPlotter(num_points=1000)
r_p = Sun.R + 165 * u.km
r_a = Sun.R + 215 * u.km
a = (r_p + r_a) / 2
roadster = Orbit.from_classical(attractor=Sun,
a=0.9860407221838553 * u.AU,
ecc=0.2799145376150214 * u.one,
inc=1.194199764898942 * u.deg,
raan=49 * u.deg,
argp=286 * u.deg,
nu=23 * u.deg,
epoch=date)
for date in days_as:
else:
asteroids = int(args.asteroids)
tempo = datetime.datetime(2000, 1, 1, 0, 0, 0)
#help(Orbit.from_classical)
offset = float(0)
for frame in range(60 * 60):
offset = offset + 1
astratempo = time.Time(tempo, scale='utc') #, value=J2000.000)
print("Rendering frame " + str(frame) + " for " + str(astratempo) + "...")
#plot Icaurs and Mars
op = OrbitPlotter(bgcolor=(0, 0, 0),
linewidth=0.01,
markersize=3,
audivision=12)
roid_orbits = []
for i in range(asteroids):
line = read_lines[i]
# pull out the e, i, arg_p
line_e = float(line[71:79]) * u.one
line_inc = float(line[60:68]) * u.deg
line_pera = float(line[38:46]) * u.deg
line_semax = float(line[93:103]) * u.AU
line_name = line[167:194]
line_raan = float(line[49:57]) * u.deg
line_ma = (float(line[27:35]) + offset) * u.deg
#x = Orbit.from_classical(Sun, line_semax, line_e, line_inc, line_raan, line_pera, line_ma, epoch=astratempo)
# print ("a: " + str(perDiff(a, aJPL)) + "%")
# print ("e: " + str(perDiff(e, eJPL)) + "%")
# print ("i: " + str(perDiff(i, iJPL)) + "%")
# print ("Lon ascending node: " + str(perDiff(lOmega[0], lOmegaJPL)) + "%")
# print ("Perihelion: " + str(perDiff(aPerihelion, omegaJPL)) + "%")
# print ("M: " + str(perDiff(M, MJPL)) + "%")
a = a * units.AU
ecc = e * units.one
inc = i * units.deg
raan = lOmega[0] * units.deg
argp = aPerihelion * units.deg
nu = v * units.deg
epoch = time.Time(t2, format='jd', scale='utc')
earth_orbit = Orbit.from_body_ephem(Earth)
earth_orbit = earth_orbit.propagate(time.Time(t2, format='jd', scale='tdb'),
rtol=1e-10)
magellan_orbit = neows.orbit_from_name('2018ez2')
magellan_orbit = magellan_orbit.propagate(time.Time(t2,
format='jd',
scale='tdb'),
rtol=1e-10)
estimated_orbit = Orbit.from_classical(Sun, a, ecc, inc, raan, argp, nu, epoch)
op = OrbitPlotter()
op.plot(earth_orbit, label='Earth')
op.plot(magellan_orbit, label='2018 EZ2')
op.plot(estimated_orbit, label='Estimated')
plt.show()
def mission_plot(date_launch, date_arrival, date_assist, planet):
color_planet_e = 'royalblue'
color_trans = 'dimgrey'
color_orbit_trans = 'orchid'
if nr in [1, 2]:
r0, v0, rf, vf, va, vb, rr_planet1, rr_planet2, times_vector = transit(
date_launch, date_arrival, 'earth', planet)
# Obliczenie orbit transferowych oraz orbit planet
ss0_trans = Orbit.from_vectors(Sun, r0, va, date_launch)
ssf_trans = Orbit.from_vectors(Sun, rf, vb, date_arrival)
ss_e = Orbit.from_vectors(Sun, r0, v0, date_launch)
ss_p = Orbit.from_vectors(Sun, rf, vf, date_arrival)
pl_planet, color_planet = planets2plot(planet)
#wykres orbit 2D
orb = OrbitPlotter()
orb.plot(ss_p, label=pl_planet, color=color_planet)
orb.plot(ss_e, label=Earth, color=color_planet_e)
orb.plot(ssf_trans,
label='Orbita transferowa',
color=color_orbit_trans)
#wykres orbit i trajektorii lotu 3D
frame = myplot.OrbitPlotter3D()
frame.set_attractor(Sun)
frame.plot_trajectory(rr_planet1, label=Earth, color=color_planet_e)
frame.plot(ss_e, label=Earth, color=color_planet_e)
frame.plot(ss_p, label=pl_planet, color=color_planet)
frame.plot_trajectory(rr_planet2, label=pl_planet, color=color_planet)
frame.plot_trajectory(ss0_trans.sample(times_vector),
label="Mission trajectory",
color=color_trans)
frame.set_view(30 * u.deg, 260 * u.deg, distance=3 * u.km)
frame.show(title="Mission to Solar System Planet")
if nr == 3:
if as3 == 0:
if as2 == 0:
r0, v0, rf, vf, va, vb, rr_planet1, rr_planet2, times_vector = transit(
date_launch, date_assist[0], 'earth', as1)
r02, v02, rf2, vf2, va2, vb2, rr_planet12, rr_planet22, times_vector2 = transit(
date_assist[0], date_arrival, as1, planet)
ss0_trans = Orbit.from_vectors(Sun, r0, va, date_launch)
ssf_trans = Orbit.from_vectors(Sun, rf, vb, date_assist[0])
ss0_trans2 = Orbit.from_vectors(Sun, r02, va2, date_assist[0])
ssf_trans2 = Orbit.from_vectors(Sun, rf2, vb2, date_arrival)
ss_e = Orbit.from_vectors(Sun, r0, v0, date_launch)
ss_p1 = Orbit.from_vectors(Sun, rf, vf, date_assist[0])
ss_p2 = Orbit.from_vectors(Sun, rf2, vf2, date_arrival)
orb = OrbitPlotter()
orb.plot(ss_e, label=Earth, color=color_planet_e)
pl_planet, color_planet = planets2plot(as1)
orb.plot(ss_p1, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(planet)
orb.plot(ss_p2, label=pl_planet, color=color_planet)
frame = myplot.OrbitPlotter3D()
frame.set_attractor(Sun)
frame.plot_trajectory(rr_planet1,
label=Earth,
color=color_planet_e)
frame.plot(ss_e, label=Earth, color=color_planet_e)
pl_planet, color_planet = planets2plot(as1)
frame.plot(ss_p1, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(planet)
frame.plot(ss_p2, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(as1)
frame.plot_trajectory(rr_planet12,
label=pl_planet,
color=color_planet)
#frame.plot_trajectory(ss0_trans.sample(times_vector), label="Mission trajectory", color=color_trans)
pl_planet, color_planet = planets2plot(planet)
frame.plot_trajectory(rr_planet22,
label=pl_planet,
color=color_planet)
#frame.plot_trajectory(ss0_trans2.sample(times_vector2), label="Mission trajectory2", color=color_trans)
frame.set_view(30 * u.deg, 260 * u.deg, distance=3 * u.km)
frame.show(
title=
" Mission: from Earth to Solar System Planet with gravity assist"
)
else:
r0, v0, rf, vf, va, vb, rr_planet1, rr_planet2, times_vector = transit(
date_launch, date_assist[0], 'earth', as1)
r02, v02, rf2, vf2, va2, vb2, rr_planet12, rr_planet22, times_vector2 = transit(
date_assist[0], date_assist[1], as1, as2)
r03, v03, rf3, vf3, va3, vb3, rr_planet13, rr_planet23, times_vector3 = transit(
date_assist[1], date_arrival, as2, planet)
ss0_trans = Orbit.from_vectors(Sun, r0, va, date_launch)
ssf_trans = Orbit.from_vectors(Sun, rf, vb, date_assist[0])
ss0_trans2 = Orbit.from_vectors(Sun, r02, va2, date_assist[0])
ssf_trans2 = Orbit.from_vectors(Sun, rf2, vb2, date_assist[1])
ss0_trans3 = Orbit.from_vectors(Sun, r03, va3, date_assist[1])
ssf_trans3 = Orbit.from_vectors(Sun, rf3, vb3, date_arrival)
ss_e = Orbit.from_vectors(Sun, r0, v0, date_launch)
ss_p1 = Orbit.from_vectors(Sun, rf, vf, date_assist[0])
ss_p2 = Orbit.from_vectors(Sun, rf2, vf2, date_assist[1])
ss_p3 = Orbit.from_vectors(Sun, rf3, vf3, date_arrival)
orb = OrbitPlotter()
orb.plot(ss_e, label=Earth, color=color_planet_e)
pl_planet, color_planet = planets2plot(as1)
orb.plot(ss_p1, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(as2)
orb.plot(ss_p2, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(planet)
orb.plot(ss_p3, label=pl_planet, color=color_planet)
frame = myplot.OrbitPlotter3D()
frame.set_attractor(Sun)
frame.plot_trajectory(rr_planet1,
label=Earth,
color=color_planet_e)
frame.plot(ss_e, label=Earth, color=color_planet_e)
pl_planet, color_planet = planets2plot(as1)
frame.plot(ss_p1, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(as2)
frame.plot(ss_p2, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(planet)
frame.plot(ss_p3, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(as1)
frame.plot_trajectory(rr_planet2,
label=pl_planet,
color=color_planet)
#frame.plot_trajectory(ss0_trans.sample(times_vector), label="Mission trajectory", color=color_trans)
pl_planet, color_planet = planets2plot(as2)
frame.plot_trajectory(rr_planet22,
label=pl_planet,
color=color_planet)
#frame.plot_trajectory(ss0_trans2.sample(times_vector2), label="Mission trajectory2", color=color_trans)
pl_planet, color_planet = planets2plot(planet)
frame.plot_trajectory(rr_planet23,
label=pl_planet,
color=color_planet)
#frame.plot_trajectory(ss0_trans3.sample(times_vector3), label="Mission trajectory3", color=color_trans)
frame.set_view(30 * u.deg, 260 * u.deg, distance=3 * u.km)
frame.show(
title=
" Mission: from Earth to Solar System Planet with gravity assist"
)
else:
r0, v0, rf, vf, va, vb, rr_planet1, rr_planet2, times_vector = transit(
date_launch, date_assist[0], 'earth', as1)
r02, v02, rf2, vf2, va2, vb2, rr_planet12, rr_planet22, times_vector2 = transit(
date_assist[0], date_assist[1], as1, as2)
r03, v03, rf3, vf3, va3, vb3, rr_planet13, rr_planet23, times_vector3 = transit(
date_assist[1], date_assist[2], as2, as3)
r04, v04, rf4, vf4, va4, vb4, rr_planet14, rr_planet24, times_vector4 = transit(
date_assist[2], date_arrival, as3, planet)
ss0_trans = Orbit.from_vectors(Sun, r0, va, date_launch)
ssf_trans = Orbit.from_vectors(Sun, rf, vb, date_assist[0])
ss0_trans2 = Orbit.from_vectors(Sun, r02, va2, date_assist[0])
ssf_trans2 = Orbit.from_vectors(Sun, rf2, vb2, date_assist[1])
ss0_trans3 = Orbit.from_vectors(Sun, r03, va3, date_assist[1])
ssf_trans3 = Orbit.from_vectors(Sun, rf3, vb3, date_assist[2])
ss0_trans4 = Orbit.from_vectors(Sun, r04, va4, date_assist[2])
ssf_trans4 = Orbit.from_vectors(Sun, rf4, vb4, date_arrival)
ss_e = Orbit.from_vectors(Sun, r0, v0, date_launch)
ss_p1 = Orbit.from_vectors(Sun, rf, vf, date_assist[0])
ss_p2 = Orbit.from_vectors(Sun, rf2, vf2, date_assist[1])
ss_p3 = Orbit.from_vectors(Sun, rf3, vf3, date_assist[2])
ss_p4 = Orbit.from_vectors(Sun, rf4, vf4, date_arrival)
orb = OrbitPlotter()
orb.plot(ss_e, label=Earth, color=color_planet_e)
pl_planet, color_planet = planets2plot(as1)
orb.plot(ss_p1, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(as2)
orb.plot(ss_p2, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(as3)
orb.plot(ss_p3, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(planet)
orb.plot(ss_p4, label=pl_planet, color=color_planet)
frame = myplot.OrbitPlotter3D()
frame.set_attractor(Sun)
frame.plot_trajectory(rr_planet1,
label=Earth,
color=color_planet_e)
frame.plot(ss_e, label=Earth, color=color_planet_e)
pl_planet, color_planet = planets2plot(as1)
frame.plot(ss_p1, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(as2)
frame.plot(ss_p2, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(as3)
frame.plot(ss_p3, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(planet)
frame.plot(ss_p4, label=pl_planet, color=color_planet)
pl_planet, color_planet = planets2plot(as1)
frame.plot_trajectory(rr_planet2,
label=pl_planet,
color=color_planet)
#frame.plot_trajectory(ss0_trans.sample(times_vector), label="Mission trajectory", color=color_trans)
pl_planet, color_planet = planets2plot(as2)
frame.plot_trajectory(rr_planet22,
label=pl_planet,
color=color_planet)
#frame.plot_trajectory(ss0_trans2.sample(times_vector2), label="Mission trajectory2", color=color_trans)
pl_planet, color_planet = planets2plot(as3)
frame.plot_trajectory(rr_planet23,
label=pl_planet,
color=color_planet)
#frame.plot_trajectory(ss0_trans3.sample(times_vector3), label="Mission trajectory3", color=color_trans)
pl_planet, color_planet = planets2plot(planet)
frame.plot_trajectory(rr_planet24,
label=pl_planet,
color=color_planet)
#frame.plot_trajectory(ss0_trans4.sample(times_vector4), label="Mission trajectory4", color=color_trans)
frame.set_view(30 * u.deg, 260 * u.deg, distance=3 * u.km)
frame.show(
title=
"Mission: from Earth to Solar System Planet with gravity assist"
)
#Solve for Lambert's Problem (Determining Translunar Trajectory)
(v0, v), = iod.lambert(Earth.k, ss0.r, ssf.r, tof)
ss0_trans = Orbit.from_vectors(Earth, ss0.r, v0, date_launch)
dv = (ss0_trans.v - ss0.v)
dv = dv.to(u.m / u.s)
man = Maneuver.impulse(dv)
ss_f = ss0.apply_maneuver(man)
print(
"The required Delta-V to perform the Translunar Injection maneuver is: " +
str(dv))
#Plotting Solution in 2D - Earth close-up
plt.ion()
op = OrbitPlotter()
op.plot(ss0, label="Apollo")
op.plot(ssf, label="Moon")
op.plot(ss0_trans, label="Transfer")
plt.xlim(-7000, 7000)
plt.ylim(-7000, 7000)
plt.gcf().autofmt_xdate()
#Plotting Solution in 2D - Moon close-up
plt.ion()
op = OrbitPlotter()
op.plot(ss0, label="Apollo")
op.plot(ssf, label="Moon")
op.plot(ss0_trans, label="Transfer")
plt.xlim(-394000, -392000)
plt.ylim(24000, 26000)
def test_dark_mode_plots_dark_plot():
op = OrbitPlotter(dark=True)
assert op.ax.get_facecolor() == (0.0, 0.0, 0.0, 1.0)
op = OrbitPlotter()
assert op.ax.get_facecolor() == (1.0, 1.0, 1.0, 1)
inc = 7.77 * u.deg
raan = 66.51 * u.deg
argp = 307.23 * u.deg
nu = np.rad2deg(ang.M_to_nu(np.deg2rad(297.53 * u.deg), ecc))
asteroid = Orbit.from_classical(Sun, a, ecc, inc, raan, argp, nu, start_date)
asteroid = propagate(asteroid, 150 * 3600 * 24 * u.second)
#for earth
a = 1 * u.AU
ecc = 0.0167086 * u.one
nu = np.rad2deg(ang.M_to_nu(np.deg2rad(358.617 * u.deg), ecc))
inc = 7.155 * u.deg
raan = -11.26064 * u.deg
argp = 114.207 * u.deg
earth = Orbit.from_classical(Sun, a, ecc, inc, raan, argp, nu, start_date)
op = OrbitPlotter()
op.plot(asteroid, label='asteroid')
op.plot(earth, label='earth')
plt.show()
day = 3600 * 24 * u.second
hour = 3600 * u.second
minute = 60 * u.second
tol = 1
pool = {}
def init():
global flight, old_dv, new_dv, temp, itera, flag
flight = 15 * 3600 * 24 * u.second
