def animate(self):
fig = plt.figure()
self.ax = fig.add_subplot(111, projection='3d')
self.W_S_plus = [
load_manifold('../../../data/raw/manifolds/L' + str(1) + '_' +
self.orbitType + '_' + str(self.orbitIds[0]) +
'_W_S_plus.txt'),
load_manifold('../../../data/raw/manifolds/L' + str(2) + '_' +
self.orbitType + '_' + str(self.orbitIds[1]) +
'_W_S_plus.txt')
]
self.W_S_min = [
load_manifold('../../../data/raw/manifolds/L' + str(1) + '_' +
self.orbitType + '_' + str(self.orbitIds[0]) +
'_W_S_min.txt'),
load_manifold('../../../data/raw/manifolds/L' + str(2) + '_' +
self.orbitType + '_' + str(self.orbitIds[1]) +
'_W_S_min.txt')
]
self.W_U_plus = [
load_manifold('../../../data/raw/manifolds/L' + str(1) + '_' +
self.orbitType + '_' + str(self.orbitIds[0]) +
'_W_U_plus.txt'),
load_manifold('../../../data/raw/manifolds/L' + str(2) + '_' +
self.orbitType + '_' + str(self.orbitIds[1]) +
'_W_U_plus.txt')
]
self.W_U_min = [
load_manifold('../../../data/raw/manifolds/L' + str(1) + '_' +
self.orbitType + '_' + str(self.orbitIds[0]) +
'_W_U_min.txt'),
load_manifold('../../../data/raw/manifolds/L' + str(2) + '_' +
self.orbitType + '_' + str(self.orbitIds[1]) +
'_W_U_min.txt')
]
self.numberOfOrbitsPerManifold = len(
set(self.W_S_plus[0].index.get_level_values(0)))
color_palette_green = sns.dark_palette(
'green', n_colors=self.numberOfOrbitsPerManifold)
color_palette_red = sns.dark_palette(
'red', n_colors=self.numberOfOrbitsPerManifold)
self.lines = [
plt.plot([], [],
color=color_palette_red[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
]
self.lines.extend([
plt.plot([], [],
color=color_palette_green[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
plt.plot([], [],
color=color_palette_red[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
plt.plot([], [],
color=color_palette_green[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
plt.plot([], [],
color=color_palette_red[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
plt.plot([], [],
color=color_palette_green[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
plt.plot([], [],
color=color_palette_green[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
plt.plot([], [],
color=color_palette_red[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
# Text object to display absolute normalized time of trajectories within the manifolds
self.timeText = self.ax.text2D(0.05,
0.05,
s='$\|t\| \\approx 0$',
transform=self.ax.transAxes,
size=self.timeTextSize)
# Plot zero velocity surface
x_range = np.arange(self.xLim[0], self.xLim[1], 0.001)
y_range = np.arange(self.yLim[0], self.yLim[1], 0.001)
x_mesh, y_mesh = np.meshgrid(x_range, y_range)
z_mesh = cr3bp_velocity(x_mesh, y_mesh, c_level)
if z_mesh.min() < 0:
plt.contour(x_mesh,
y_mesh,
z_mesh, [z_mesh.min(), 0],
colors='black',
alpha=0.3)
# Plot both orbits
for k in range(2):
orbit_df = load_orbit('../../../data/raw/orbits/L' + str(k + 1) +
'_' + self.orbitType + '_' +
str(self.orbitIds[k]) + '.txt')
plt.plot(orbit_df['x'],
orbit_df['y'],
orbit_df['z'],
color=self.orbitColor,
alpha=self.orbitAlpha,
linewidth=self.orbitLinewidth)
# Plot both primaries
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
bodies_df = load_bodies_location()
for body in bodies_df:
x = bodies_df[body]['r'] * np.outer(
np.cos(u), np.sin(v)) + bodies_df[body]['x']
y = bodies_df[body]['r'] * np.outer(np.sin(u), np.sin(v))
z = bodies_df[body]['r'] * np.outer(np.ones(np.size(u)), np.cos(v))
self.ax.plot_surface(x, y, z, color='black')
# Plot Lagrange points 1 and 2
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2']
for lagrange_point_nr in lagrange_point_nrs:
self.ax.scatter3D(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x',
s=self.lagrangePointMarkerSize)
title = self.orbitTypeForTitle + ' $\{ \mathcal{W}^{S \pm}, \mathcal{W}^{U \pm} \}$ - Spatial overview at C = ' + str(
c_level)
self.ax.set_xlim3d(self.xLim)
self.ax.set_ylim3d(self.yLim)
self.ax.set_zlim3d(self.zLim)
plt.axis('off')
fig.tight_layout()
fig.subplots_adjust(top=0.9)
plt.suptitle(title, size=self.suptitleSize)
self.initialElevation = self.ax.elev
self.initialAzimuth = self.ax.azim
# Determine the maximum value of t
t_max = 0
for lagrange_point_idx in [0, 1]:
for index in range(self.numberOfOrbitsPerManifold):
t_max = max(
t_max,
abs(self.W_S_plus[lagrange_point_idx].xs(index).tail(
1).index.values[0]))
t_max = max(
t_max,
abs(self.W_S_min[lagrange_point_idx].xs(index).tail(
1).index.values[0]))
t_max = max(
t_max,
abs(self.W_U_plus[lagrange_point_idx].xs(index).tail(
1).index.values[0]))
t_max = max(
t_max,
abs(self.W_U_min[lagrange_point_idx].xs(index).tail(
1).index.values[0]))
print('Maximum value for t = ' + str(t_max) + ', animation t: = ')
# Introduce a new time-vector for linearly spaced time throughout the animation
self.t = np.linspace(0, t_max, np.round(t_max / 0.01) + 1)
animation_function = animation.FuncAnimation(
fig,
self.update_lines,
init_func=self.initiate_lines,
frames=len(self.t),
interval=1,
blit=True)
empty_writer_object = animation.writers['ffmpeg']
animation_writer = empty_writer_object(
fps=30, metadata=dict(artist='Koen Langemeijer'))
file_name = '../../../data/animations/manifolds/spatial_manifolds_rotating_no_axes_' + orbit_type + '_' + str(
c_level) + '.mp4'
animation_function.save(file_name, writer=animation_writer)
def plot_horizontal_to_axial_to_vertical(self):
fig = plt.figure(figsize=self.figSize)
ax1 = fig.add_subplot(2, 2, 1, projection='3d')
ax2 = fig.add_subplot(2, 2, 2)
ax3 = fig.add_subplot(2, 2, 3)
ax4 = fig.add_subplot(2, 2, 4)
horizontal_color = self.plottingColors['tripleLine'][2]
axial_color = self.plottingColors['tripleLine'][0]
vertical_color = self.plottingColors['tripleLine'][1]
# Plot bifurcations
line_width = 2
plot_alpha = 1
df = load_orbit('../../data/raw/orbits/L1_horizontal_' +
str(self.horizontalBifurcations[1]) + '.txt')
l1, = ax1.plot(df['x'],
df['y'],
df['z'],
color=horizontal_color,
alpha=plot_alpha,
linewidth=1,
label='Horizontal Lyapunov')
ax1.plot(df['x'],
df['y'],
df['z'],
color=horizontal_color,
alpha=plot_alpha,
linewidth=line_width)
ax2.plot(df['x'],
df['y'],
color=horizontal_color,
alpha=plot_alpha,
linewidth=line_width)
ax3.plot(df['y'],
df['z'],
color=horizontal_color,
alpha=plot_alpha,
linewidth=line_width)
ax4.plot(df['x'],
df['z'],
color=horizontal_color,
alpha=plot_alpha,
linewidth=line_width)
number_of_orbits = 10
line_width = 1
plot_alpha = 0.5
for i in [
int(i)
for i in (np.linspace(100, self.axialMaxId, number_of_orbits))
]:
df = load_orbit('../../data/raw/orbits/L1_axial_' + str(i) +
'.txt')
l2, = ax1.plot(df['x'],
df['y'],
df['z'],
color=axial_color,
alpha=plot_alpha,
linewidth=line_width,
label='Axial')
ax2.plot(df['x'],
df['y'],
color=axial_color,
alpha=plot_alpha,
linewidth=line_width)
ax3.plot(df['y'],
df['z'],
color=axial_color,
alpha=plot_alpha,
linewidth=line_width)
ax4.plot(df['x'],
df['z'],
color=axial_color,
alpha=plot_alpha,
linewidth=line_width)
# Plot bifurcations
line_width = 2
plot_alpha = 1
df = load_orbit('../../data/raw/orbits/L1_vertical_' +
str(self.verticalBifurcations[0]) + '.txt')
l3, = ax1.plot(df['x'],
df['y'],
df['z'],
color=vertical_color,
alpha=plot_alpha,
linewidth=1,
label='Vertical Lyapunov')
ax1.plot(df['x'],
df['y'],
df['z'],
color=vertical_color,
alpha=plot_alpha,
linewidth=line_width)
ax2.plot(df['x'],
df['y'],
color=vertical_color,
alpha=plot_alpha,
linewidth=line_width)
ax3.plot(df['y'],
df['z'],
color=vertical_color,
alpha=plot_alpha,
linewidth=line_width)
ax4.plot(df['x'],
df['z'],
color=vertical_color,
alpha=plot_alpha,
linewidth=line_width)
# Lagrange points and bodies
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2']
for lagrange_point_nr in lagrange_point_nrs:
ax1.scatter(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x')
ax2.scatter(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
color='black',
marker='x')
ax3.scatter(lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x')
ax4.scatter(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x')
bodies_df = load_bodies_location()
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
for body in ['Moon']:
x = bodies_df[body]['r'] * np.outer(
np.cos(u), np.sin(v)) + bodies_df[body]['x']
y = bodies_df[body]['r'] * np.outer(np.sin(u), np.sin(v))
z = bodies_df[body]['r'] * np.outer(np.ones(np.size(u)), np.cos(v))
ax1.plot_surface(x, y, z, color='black')
ax2.contourf(x, y, z, colors='black')
ax3.contourf(y, z, x, colors='black')
ax4.contourf(x, z, y, colors='black')
ax1.set_xlabel('x [-]')
ax1.set_ylabel('y [-]')
ax1.set_zlabel('z [-]')
ax1.grid(True, which='both', ls=':')
ax2.set_xlabel('x [-]')
ax2.set_ylabel('y [-]')
ax2.grid(True, which='both', ls=':')
ax3.set_xlabel('y [-]')
ax3.set_ylabel('z [-]')
ax3.grid(True, which='both', ls=':')
ax4.set_xlabel('x [-]')
ax4.set_ylabel('z [-]')
ax4.grid(True, which='both', ls=':')
plt.tight_layout()
plt.subplots_adjust(top=0.9)
ax1.legend(frameon=True, handles=[l1, l2, l3])
plt.suptitle(
'$L_1$ Bifurcation - Axial family connecting horizontal and vertical Lyapunov orbits',
size=self.suptitleSize)
if self.lowDPI:
plt.savefig('../../data/figures/orbits/L1_bifurcation_axial.png',
transparent=True,
dpi=self.dpi)
else:
plt.savefig('../../data/figures/orbits/L1_bifurcation_axial.pdf',
transparent=True)
plt.close()
pass
eigenvectors_S = pd.read_table(
'../../data/verification/ver_halo_1_W_S_plus.txt',
delim_whitespace=True,
header=None).filter(list(range(6)))
eigenvectors_U = pd.read_table(
'../../data/verification/ver_halo_1_W_U_plus.txt',
delim_whitespace=True,
header=None).filter(list(range(6)))
eigenvectors_S.columns = ['x', 'y', 'z', 'xdot', 'ydot', 'zdot']
eigenvectors_U.columns = ['x', 'y', 'z', 'xdot', 'ydot', 'zdot']
eigenvectors_indices = [np.floor(i * len(orbit) / 20) for i in range(20)]
plt.figure(figsize=(30, 40))
plt.plot(orbit['x'], orbit['y'], color='blue', linewidth=4)
plt.scatter((load_lagrange_points_location()['L2']['x'] - 1) * 384400e-4,
load_lagrange_points_location()['L2']['y'] * 384400e-4,
color='grey',
s=100)
plt.scatter(0, 0, color='grey', s=1000)
v_U = [0.46173686071464, -0.12104697597009]
v_S = [0.048496125209463, 0.38642078136333]
for idx, eigenvectors_index in enumerate(eigenvectors_indices):
x_S = [
orbit.xs(eigenvectors_index)['x'] - 1 * eigenvectors_S.xs(idx)['x'],
orbit.xs(eigenvectors_index)['x'] + 1 * eigenvectors_S.xs(idx)['x']
]
y_S = [
def animate(self):
self.W_S_plus = [
load_manifold_refactored(
'../../../data/raw/manifolds/refined_for_c/L' + str(1) + '_' +
self.orbitType + '_' + str(self.orbitIds[0]) +
'_W_S_plus.txt'),
load_manifold_refactored(
'../../../data/raw/manifolds/refined_for_c/L' + str(2) + '_' +
self.orbitType + '_' + str(self.orbitIds[1]) + '_W_S_plus.txt')
]
self.W_S_min = [
load_manifold_refactored(
'../../../data/raw/manifolds/refined_for_c/L' + str(1) + '_' +
self.orbitType + '_' + str(self.orbitIds[0]) + '_W_S_min.txt'),
load_manifold_refactored(
'../../../data/raw/manifolds/refined_for_c/L' + str(2) + '_' +
self.orbitType + '_' + str(self.orbitIds[1]) + '_W_S_min.txt')
]
self.W_U_plus = [
load_manifold_refactored(
'../../../data/raw/manifolds/refined_for_c/L' + str(1) + '_' +
self.orbitType + '_' + str(self.orbitIds[0]) +
'_W_U_plus.txt'),
load_manifold_refactored(
'../../../data/raw/manifolds/refined_for_c/L' + str(2) + '_' +
self.orbitType + '_' + str(self.orbitIds[1]) + '_W_U_plus.txt')
]
self.W_U_min = [
load_manifold_refactored(
'../../../data/raw/manifolds/refined_for_c/L' + str(1) + '_' +
self.orbitType + '_' + str(self.orbitIds[0]) + '_W_U_min.txt'),
load_manifold_refactored(
'../../../data/raw/manifolds/refined_for_c/L' + str(2) + '_' +
self.orbitType + '_' + str(self.orbitIds[1]) + '_W_U_min.txt')
]
self.numberOfOrbitsPerManifold = len(
set(self.W_S_plus[0].index.get_level_values(0)))
color_palette_green = sns.dark_palette(
'green', n_colors=self.numberOfOrbitsPerManifold)
color_palette_red = sns.dark_palette(
'red', n_colors=self.numberOfOrbitsPerManifold)
self.lines = [
self.ax.plot([], [],
color=color_palette_red[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
]
self.lines.extend([
self.ax.plot([], [],
color=color_palette_green[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
self.ax.plot([], [],
color=color_palette_red[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
self.ax.plot([], [],
color=color_palette_green[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
self.ax.plot([], [],
color=color_palette_red[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
self.ax.plot([], [],
color=color_palette_green[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
self.ax.plot([], [],
color=color_palette_green[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
self.lines.extend([
self.ax.plot([], [],
color=color_palette_red[idx],
alpha=self.orbitAlpha)[0]
for idx in range(self.numberOfOrbitsPerManifold)
])
# Text object to display absolute normalized time of trajectories within the manifolds
self.timeText = self.ax.text2D(0.05,
0.05,
s='$\|t\| \\approx 0$',
transform=self.ax.transAxes,
size=self.timeTextSize)
# Plot zero velocity surface
x_range = np.arange(self.xLim[0], self.xLim[1], 0.001)
y_range = np.arange(self.yLim[0], self.yLim[1], 0.001)
x_mesh, y_mesh = np.meshgrid(x_range, y_range)
z_mesh = cr3bp_velocity(x_mesh, y_mesh, self.cLevel)
if z_mesh.min() < 0:
# plt.contour(x_mesh, y_mesh, z_mesh, [z_mesh.min(), 0], colors='black', alpha=0.3)
self.ax.contour(x_mesh,
y_mesh,
z_mesh,
list(np.linspace(z_mesh.min(), 0, 10)),
cmap='gist_gray_r',
alpha=0.5)
# Plot both orbits
for k in range(2):
orbit_df = load_orbit('../../../data/raw/orbits/refined_for_c/L' +
str(k + 1) + '_' + self.orbitType + '_' +
str(self.orbitIds[k]) + '.txt')
self.ax.plot(orbit_df['x'],
orbit_df['y'],
orbit_df['z'],
color=self.orbitColor,
alpha=self.orbitAlpha,
linewidth=self.orbitLinewidth)
# Plot both primaries
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
bodies_df = load_bodies_location()
for body in bodies_df:
x = bodies_df[body]['r'] * np.outer(
np.cos(u), np.sin(v)) + bodies_df[body]['x']
y = bodies_df[body]['r'] * np.outer(np.sin(u), np.sin(v))
z = bodies_df[body]['r'] * np.outer(np.ones(np.size(u)), np.cos(v))
self.ax.plot_surface(x, y, z, color='black')
# Plot Lagrange points 1 and 2
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2']
for lagrange_point_nr in lagrange_point_nrs:
self.ax.scatter3D(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x',
s=self.lagrangePointMarkerSize)
title = self.orbitTypeForTitle + ' $\{ \mathcal{W}^{S \pm}, \mathcal{W}^{U \pm} \}$ - Orthographic projection (C = ' + str(
self.cLevel) + ')'
self.ax.set_xlim(self.xLim)
self.ax.set_ylim(self.yLim)
self.ax.set_zlim(self.zLim)
self.ax.set_xlabel('x [-]')
self.ax.set_ylabel('y [-]')
self.ax.set_zlabel('z [-]')
self.ax.grid(True, which='both', ls=':')
# self.fig.tight_layout()
self.fig.subplots_adjust(top=0.9)
self.fig.suptitle(title, size=self.suptitleSize)
# Fix overlap between labels and ticks
self.ax.xaxis._axinfo['label']['space_factor'] = 6.0
self.ax.yaxis._axinfo['label']['space_factor'] = 6.0
self.ax.zaxis._axinfo['label']['space_factor'] = 6.0
# Determine the maximum value of t
t_max = 0
for lagrange_point_idx in [0, 1]:
for index in range(self.numberOfOrbitsPerManifold):
t_max = max(
t_max,
abs(self.W_S_plus[lagrange_point_idx].xs(index).head(
1).index.values[0]))
t_max = max(
t_max,
abs(self.W_S_min[lagrange_point_idx].xs(index).head(
1).index.values[0]))
t_max = max(
t_max,
abs(self.W_U_plus[lagrange_point_idx].xs(index).tail(
1).index.values[0]))
t_max = max(
t_max,
abs(self.W_U_min[lagrange_point_idx].xs(index).tail(
1).index.values[0]))
print('Maximum value for t = ' + str(t_max) + ', animation t: = ')
# Introduce a new time-vector for linearly spaced time throughout the animation
self.t = np.linspace(0, t_max, np.round(t_max / 0.04) + 1)
self.animation_function = animation.FuncAnimation(
self.fig,
self.update_lines,
init_func=self.initiate_lines,
frames=len(self.t),
interval=1,
blit=True)
self.empty_writer_object = animation.writers['ffmpeg']
self.animation_writer = self.empty_writer_object(
fps=30, metadata=dict(artist='Koen Langemeijer'))
self.file_name = '../../../data/animations/manifolds/spatial_manifolds_zoom_' + self.orbitType + '_' + str(
self.cLevel) + '.mp4'
self.animation_function.save(self.file_name,
writer=self.animation_writer)
pass
ax1.set_zlim([-0.15, 0.15])
ax1.set_xlabel('x')
ax1.set_ylabel('y')
ax1.set_zlabel('z')
ax1.set_title('3D view', size=20)
phi = np.linspace(0, 2 * np.pi, 100)
theta = np.linspace(0, np.pi, 100)
bodies = load_bodies_location()
for body in bodies:
x_body = bodies[body]['r'] * np.outer(np.cos(phi), np.sin(theta)) + bodies[body]['x']
y_body = bodies[body]['r'] * np.outer(np.sin(phi), np.sin(theta)) + bodies[body]['y']
z_body = bodies[body]['r'] * np.cos(theta) + bodies[body]['z']
ax1.plot_surface(x_body, y_body, z_body, color='black')
lagrange_points = load_lagrange_points_location()
for lagrange_point in ['L1', 'L2']:
ax1.scatter3D(lagrange_points[lagrange_point]['x'],
lagrange_points[lagrange_point]['y'],
lagrange_points[lagrange_point]['z'], color='grey', marker='d', alpha=0.75)
ax1.text(lagrange_points[lagrange_point]['x'],
lagrange_points[lagrange_point]['y'],
lagrange_points[lagrange_point]['z'], lagrange_point, size=16)
# Plot 2: 2D-view of orbit
if orbit_type == 'horizontal' or orbit_type == 'halo':
line2 = ax2.plot(orbit[0]['x'].values, orbit[0]['y'].values, color='darkblue')
ax2.set_xlabel('x')
ax2.set_ylabel('y')
def animate(self):
fig = plt.figure()
self.ax = fig.add_subplot(111, projection='3d')
self.horizontalLyapunov = [
load_orbit('../../../data/raw/orbits/refined_for_c/L' + str(1) +
'_horizontal_' +
str(self.orbitIds['horizontal'][1][self.cLevel]) +
'_100.txt'),
load_orbit('../../../data/raw/orbits/refined_for_c/L' + str(2) +
'_horizontal_' +
str(self.orbitIds['horizontal'][2][self.cLevel]) +
'_100.txt')
]
self.verticalLyapunov = [
load_orbit('../../../data/raw/orbits/refined_for_c/L' + str(1) +
'_vertical_' +
str(self.orbitIds['vertical'][1][self.cLevel]) +
'_100.txt'),
load_orbit('../../../data/raw/orbits/refined_for_c/L' + str(2) +
'_vertical_' +
str(self.orbitIds['vertical'][2][self.cLevel]) +
'_100.txt')
]
self.halo = [
load_orbit('../../../data/raw/orbits/refined_for_c/L' + str(1) +
'_halo_' + str(self.orbitIds['halo'][1][self.cLevel]) +
'_100.txt'),
load_orbit('../../../data/raw/orbits/refined_for_c/L' + str(2) +
'_halo_' + str(self.orbitIds['halo'][2][self.cLevel]) +
'_100.txt')
]
self.lines = [
plt.plot([], [],
color=self.orbitColors['horizontal'],
linewidth=self.orbitLinewidth,
alpha=self.orbitAlpha,
marker='o',
markevery=[-1])[0],
plt.plot([], [],
color=self.orbitColors['horizontal'],
linewidth=self.orbitLinewidth,
alpha=self.orbitAlpha,
marker='o',
markevery=[-1])[0],
plt.plot([], [],
color=self.orbitColors['vertical'],
linewidth=self.orbitLinewidth,
alpha=self.orbitAlpha,
marker='o',
markevery=[-1])[0],
plt.plot([], [],
color=self.orbitColors['vertical'],
linewidth=self.orbitLinewidth,
alpha=self.orbitAlpha,
marker='o',
markevery=[-1])[0],
plt.plot([], [],
color=self.orbitColors['halo'],
linewidth=self.orbitLinewidth,
alpha=self.orbitAlpha,
marker='o',
markevery=[-1])[0],
plt.plot([], [],
color=self.orbitColors['halo'],
linewidth=self.orbitLinewidth,
alpha=self.orbitAlpha,
marker='o',
markevery=[-1])[0]
]
# Text object to display absolute normalized time of trajectories within the manifolds
self.timeText = self.ax.text2D(0.05,
0.05,
s='$\|t\| \\approx 0$',
transform=self.ax.transAxes,
size=self.timeTextSize)
# Plot zero velocity surface
x_range = np.arange(self.xLim[0], self.xLim[1], 0.001)
y_range = np.arange(self.yLim[0], self.yLim[1], 0.001)
x_mesh, y_mesh = np.meshgrid(x_range, y_range)
z_mesh = cr3bp_velocity(x_mesh, y_mesh, self.cLevel)
if z_mesh.min() < 0:
# plt.contour(x_mesh, y_mesh, z_mesh, [z_mesh.min(), 0], colors='black', alpha=0.3)
self.ax.contour(x_mesh,
y_mesh,
z_mesh,
list(np.linspace(z_mesh.min(), 0, 10)),
cmap='gist_gray_r',
alpha=0.5)
# Plot both orbits
for k in range(2):
plt.plot(self.horizontalLyapunov[k]['x'],
self.horizontalLyapunov[k]['y'],
self.horizontalLyapunov[k]['z'],
color=self.orbitColors['horizontal'],
alpha=self.orbitAlpha,
linewidth=self.orbitLinewidth,
linestyle=':')
plt.plot(self.verticalLyapunov[k]['x'],
self.verticalLyapunov[k]['y'],
self.verticalLyapunov[k]['z'],
color=self.orbitColors['vertical'],
alpha=self.orbitAlpha,
linewidth=self.orbitLinewidth,
linestyle=':')
plt.plot(self.halo[k]['x'],
self.halo[k]['y'],
self.halo[k]['z'],
color=self.orbitColors['halo'],
alpha=self.orbitAlpha,
linewidth=self.orbitLinewidth,
linestyle=':')
# Plot both primaries
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
bodies_df = load_bodies_location()
for body in bodies_df:
x = bodies_df[body]['r'] * np.outer(
np.cos(u), np.sin(v)) + bodies_df[body]['x']
y = bodies_df[body]['r'] * np.outer(np.sin(u), np.sin(v))
z = bodies_df[body]['r'] * np.outer(np.ones(np.size(u)), np.cos(v))
self.ax.plot_surface(x, y, z, color='black')
# Plot Lagrange points 1 and 2
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2']
for lagrange_point_nr in lagrange_point_nrs:
self.ax.scatter3D(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x',
s=self.lagrangePointMarkerSize)
title = 'Types of periodic libration point motion - Rotating spatial overview at C = ' + str(
c_level)
self.ax.set_xlim3d(self.xLim)
self.ax.set_ylim3d(self.yLim)
self.ax.set_zlim3d(self.zLim)
self.ax.set_xlabel('x [-]')
self.ax.set_ylabel('y [-]')
self.ax.set_zlabel('z [-]')
self.ax.grid(True, which='both', ls=':')
fig.tight_layout()
fig.subplots_adjust(top=0.9)
plt.suptitle(title, size=self.suptitleSize)
# Fix overlap between labels and ticks
self.ax.xaxis._axinfo['label']['space_factor'] = 2.0
self.ax.yaxis._axinfo['label']['space_factor'] = 2.0
self.ax.zaxis._axinfo['label']['space_factor'] = 2.0
self.initialElevation = self.ax.elev
self.initialAzimuth = self.ax.azim
# Determine the maximum value of t
t_max = 0
for lagrange_point_idx in [0, 1]:
t_max = max(
t_max, self.horizontalLyapunov[lagrange_point_idx].tail(1)
['time'].values[0])
t_max = max(
t_max, self.verticalLyapunov[lagrange_point_idx].tail(1)
['time'].values[0])
t_max = max(
t_max, self.halo[lagrange_point_idx].tail(1)['time'].values[0])
print('Maximum value for t = ' + str(t_max) + ', animation t: = ')
# Introduce a new time-vector for linearly spaced time throughout the animation
self.t = np.linspace(0, t_max, np.round(t_max / 0.005) + 1)
animation_function = animation.FuncAnimation(
fig,
self.update_lines,
init_func=self.initiate_lines,
frames=len(self.t),
interval=1,
blit=True)
empty_writer_object = animation.writers['ffmpeg']
animation_writer = empty_writer_object(
fps=30, metadata=dict(artist='Koen Langemeijer'))
file_name = '../../../data/animations/orbits/spatial_orbits_rotating_' + str(
self.cLevel) + '.mp4'
animation_function.save(file_name, writer=animation_writer)
def plot_family(self):
c_normalized = [(value - min(self.C)) / (max(self.C) - min(self.C))
for value in self.C]
colors = matplotlib.colors.ListedColormap(
sns.color_palette("viridis_r"))(c_normalized)
# colors = matplotlib.colors.ListedColormap(sns.dark_palette("blue", reverse=True))(c_normalized)
sm = plt.cm.ScalarMappable(cmap=matplotlib.colors.ListedColormap(
sns.color_palette("viridis", len(self.C))),
norm=plt.Normalize(vmin=min(self.C),
vmax=max(self.C)))
# sm = plt.cm.ScalarMappable(cmap=sns.dark_palette("blue", as_cmap=True, reverse=True), norm=plt.Normalize(vmin=min(self.C), vmax=max(self.C)))
# clean the array of the scalar mappable
sm._A = []
# Plot 1: 3d overview
fig1 = plt.figure(figsize=self.figSize)
ax1 = fig1.gca()
# Plot 2: subplots
if self.orbitType == 'horizontal':
fig2 = plt.figure(figsize=(self.figSize[0], self.figSize[1] / 2))
ax2 = fig2.add_subplot(1, 2, 1, projection='3d')
ax5 = fig2.add_subplot(1, 2, 2)
else:
fig2 = plt.figure(figsize=self.figSize)
ax2 = fig2.add_subplot(2, 2, 1, projection='3d')
ax3 = fig2.add_subplot(2, 2, 4)
ax4 = fig2.add_subplot(2, 2, 3)
ax5 = fig2.add_subplot(2, 2, 2)
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2']
# Lagrange points and bodies
for lagrange_point_nr in lagrange_point_nrs:
ax1.scatter(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
color='black',
marker='x')
ax2.scatter(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x')
ax5.scatter(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
color='black',
marker='x')
if self.orbitType != 'horizontal':
ax3.scatter(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x')
ax4.scatter(lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x')
bodies_df = load_bodies_location()
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
x = bodies_df['Moon']['r'] * np.outer(
np.cos(u), np.sin(v)) + bodies_df['Moon']['x']
y = bodies_df['Moon']['r'] * np.outer(np.sin(u), np.sin(v))
z = bodies_df['Moon']['r'] * np.outer(np.ones(np.size(u)), np.cos(v))
ax1.contourf(x, y, z, colors='black')
ax2.plot_surface(x, y, z, color='black')
ax5.contourf(x, y, z, colors='black')
if self.orbitType != 'horizontal':
ax3.contourf(x, z, y, colors='black')
ax4.contourf(y, z, x, colors='black')
# Determine color for plot
# colorOrderOfLinearInstability = ['whitesmoke', 'silver', 'dimgrey']
plot_alpha = 1
line_width = 0.5
# Plot every 100th member, including the ultimate member of the family
spacing_factor = 100
orbitIdsPlot = list(range(0, len(self.C) - 1, spacing_factor))
if orbitIdsPlot[-1] != len(self.C) - 1:
orbitIdsPlot.append(len(self.C) - 1)
# Plot orbits
for i in orbitIdsPlot:
# plot_color = colorOrderOfLinearInstability[self.orderOfLinearInstability[i]]
nan_correction = sum(
[1 for nan in self.indexNanEntries if nan < i])
plot_color = colors[self.plotColorIndexBasedOnC[i -
nan_correction]]
df = load_orbit('../../data/raw/orbits/extended/L' +
str(self.lagrangePointNr) + '_' + self.orbitType +
'_' + str(i) + '.txt')
ax1.plot(df['x'],
df['y'],
color=plot_color,
alpha=plot_alpha,
linewidth=line_width)
ax2.plot(df['x'],
df['y'],
df['z'],
color=plot_color,
alpha=plot_alpha,
linewidth=line_width)
ax5.plot(df['x'],
df['y'],
color=plot_color,
alpha=plot_alpha,
linewidth=line_width)
if self.orbitType != 'horizontal':
ax3.plot(df['x'],
df['z'],
color=plot_color,
alpha=plot_alpha,
linewidth=line_width)
ax4.plot(df['y'],
df['z'],
color=plot_color,
alpha=plot_alpha,
linewidth=line_width)
# # Plot the bifurcations
# for i in self.orbitIdBifurcations:
# # plot_color = 'b'
# nan_correction = sum([1 for nan in self.indexNanEntries if nan < i])
# plot_color = colors[self.plotColorIndexBasedOnC[i - nan_correction]]
# df = load_orbit('../../data/raw/orbits/extended/L' + str(self.lagrangePointNr) + '_' + self.orbitType + '_' + str(i) + '.txt')
# ax1.plot(df['x'], df['y'], color=plot_color, linewidth=3)
# ax2.plot(df['x'], df['y'], df['z'], color=plot_color, linewidth=3)
# ax5.plot(df['x'], df['y'], color=plot_color, linewidth=3)
# if self.orbitType != 'horizontal':
# ax3.plot(df['x'], df['z'], color=plot_color, linewidth=3)
# ax4.plot(df['y'], df['z'], color=plot_color, linewidth=3)
ax1.set_xlabel('x [-]')
ax1.set_ylabel('y [-]')
ax1.grid(True, which='both', ls=':')
ax2.set_xlabel('x [-]')
ax2.set_ylabel('y [-]')
ax2.set_zlabel('z [-]')
ax2.set_zlim([-1.2, 1.2])
ax2.grid(True, which='both', ls=':')
ax2.view_init(30, -120)
if self.orbitType != 'horizontal':
ax3.set_xlabel('x [-]')
ax3.set_ylabel('z [-]')
ax3.set_ylim([-1.2, 1.2])
ax3.grid(True, which='both', ls=':')
ax4.set_xlabel('y [-]')
ax4.set_ylabel('z [-]')
ax4.set_ylim([-1.2, 1.2])
ax4.grid(True, which='both', ls=':')
ax5.set_xlabel('x [-]')
ax5.set_ylabel('y [-]')
ax5.grid(True, which='both', ls=':')
fig2.tight_layout()
if self.orbitType == 'horizontal':
fig2.subplots_adjust(top=0.8)
else:
fig2.subplots_adjust(top=0.9)
if self.orbitType != 'horizontal':
cax, kw = matplotlib.colorbar.make_axes([ax2, ax3, ax4, ax5])
else:
cax, kw = matplotlib.colorbar.make_axes([ax2, ax5])
cbar = plt.colorbar(sm, cax=cax, label='C [-]', **kw)
plt.suptitle('$L_' + str(self.lagrangePointNr) + '$ ' +
self.orbitTypeForTitle + ' - Orthographic projection',
size=self.suptitleSize)
fig1.suptitle('$L_' + str(self.lagrangePointNr) + '$ ' +
self.orbitTypeForTitle + ': family',
size=self.suptitleSize)
fig2.savefig('../../data/figures/orbits/extended/L' +
str(self.lagrangePointNr) + '_' + self.orbitType +
'_family_subplots.pdf',
transparent=True)
plt.close(fig2)
plt.close()
pass
def animate(self):
fig = plt.figure()
self.ax = fig.add_subplot(111, projection='3d')
self.lines = [
plt.plot([], [],
color=self.orbitColor,
alpha=self.orbitAlpha,
marker='o',
markevery=[-1])[0] for idx in range(6)
]
# Text object to display absolute normalized time of trajectories within the manifolds
self.timeText = self.ax.text2D(0.05,
0.95,
s='$\|t\| \\approx 0$',
transform=self.ax.transAxes,
size=self.timeTextSize)
# Plot zero velocity surface
x_range = np.arange(-5, 5, 0.001)
y_range = np.arange(-5, 5, 0.001)
x_mesh, y_mesh = np.meshgrid(x_range, y_range)
z_mesh = cr3bp_velocity(x_mesh, y_mesh, self.cLevel)
# self.ax.plot_surface(x_mesh, y_mesh, -z_mesh, alpha=0.1, linewidth=0,
# cmap=matplotlib.colors.ListedColormap(sns.color_palette("Blues", n_colors=100)),
# vmin=self.zLim[0], vmax=-z_mesh.min(), rstride=50, cstride=50)
self.ax.plot_surface(x_mesh,
y_mesh,
-z_mesh,
alpha=0.2,
linewidth=0,
color='black')
self.ax.plot_wireframe(x_mesh,
y_mesh,
-z_mesh,
alpha=1,
linewidth=0.5,
color='black',
rstride=50,
cstride=50)
# Plot both primaries
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
bodies_df = load_bodies_location()
for body in bodies_df:
x = self.orbitalBodiesEnlargementFactor * bodies_df[body][
'r'] * np.outer(np.cos(u), np.sin(v)) + bodies_df[body]['x']
y = self.orbitalBodiesEnlargementFactor * bodies_df[body][
'r'] * np.outer(np.sin(u), np.sin(v))
z = self.orbitalBodiesEnlargementFactor * bodies_df[body][
'r'] * np.outer(np.ones(np.size(u)), np.cos(v))
self.ax.plot_surface(x, y, z, color='black', zorder=3)
# Plot Lagrange points 1 and 2
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2']
for lagrange_point_nr in lagrange_point_nrs:
self.ax.scatter3D(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x',
s=self.lagrangePointMarkerSize,
zorder=1)
title = 'Rotating reference frame - Spatial overview at C = ' + str(
self.cLevel)
self.ax.set_xlim3d(self.xLim)
self.ax.set_ylim3d(self.yLim)
self.ax.set_zlim3d(self.zLim)
fig.tight_layout()
fig.subplots_adjust(top=0.9)
plt.suptitle(title, size=self.suptitleSize)
# self.ax.elev = 60
self.initialElevation = self.ax.elev
self.initialAzimuth = self.ax.azim
self.ax.set_aspect('equal')
# plt.show()
plt.axis('off')
# Determine the maximum value of t
t_max = 1
print('Maximum value for t = ' + str(t_max) + ', animation t: = ')
# Introduce a new time-vector for linearly spaced time throughout the animation
# self.t = np.linspace(0, t_max, np.round(t_max / 0.05) + 1)
self.t = np.linspace(0, t_max, np.round(t_max / 0.005) + 1)
animation_function = animation.FuncAnimation(
fig,
self.update_lines,
init_func=self.initiate_lines,
frames=len(self.t),
interval=1,
blit=True)
empty_writer_object = animation.writers['ffmpeg']
animation_writer = empty_writer_object(
fps=30, metadata=dict(artist='Koen Langemeijer'))
file_name = '../../../data/animations/reference_frame/spatial_rotating_reference_frame_' + str(
self.cLevel) + '.mp4'
animation_function.save(file_name, writer=animation_writer)
def plot_2d_shooting_conditions(self):
fig = plt.figure(figsize=self.figSize)
ax = fig.gca()
orbit_types = ['horizontal', 'vertical', 'halo']
lagrange_point_nrs = [1, 2]
x = []
z = []
ydot = []
c = []
for idx, orbit_type in enumerate(orbit_types):
for lagrange_point_nr in lagrange_point_nrs:
if orbit_type == 'vertical':
initial_conditions_file_path = '../../data/raw/orbits/extended/L' + str(
lagrange_point_nr) + '_' + orbit_type + '_initial_conditions.txt'
else:
initial_conditions_file_path = '../../data/raw/orbits/L' + str(
lagrange_point_nr) + '_' + orbit_type + '_initial_conditions.txt'
initial_conditions_incl_m_df = load_initial_conditions_incl_M(initial_conditions_file_path)
plot_label = orbit_type.capitalize()
if plot_label == 'Horizontal' or plot_label == 'Vertical':
plot_label += ' Lyapunov'
x.extend(list(initial_conditions_incl_m_df[2].values))
z.extend(list(initial_conditions_incl_m_df[4].values))
c.extend(list(initial_conditions_incl_m_df[0].values))
sc = ax.scatter(x, z, c=c, cmap='viridis', s=20)
cb = plt.colorbar(sc)
cb.set_label('$C \enskip [-]$')
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2', 'L3']
# Lagrange points and bodies
for lagrange_point_nr in lagrange_point_nrs:
ax.scatter(lagrange_points_df[lagrange_point_nr]['x'], lagrange_points_df[lagrange_point_nr]['z'], color='black', marker='x')
bodies_df = load_bodies_location()
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
for body in bodies_df:
x = bodies_df[body]['r'] * np.outer(np.cos(u), np.sin(v)) + bodies_df[body]['x']
y = bodies_df[body]['r'] * np.outer(np.sin(u), np.sin(v))
z = bodies_df[body]['r'] * np.outer(np.ones(np.size(u)), np.cos(v))
ax.contourf(x, z, y, colors='black')
ax.legend(frameon=True, loc='upper right')
ax.set_xlabel('x [-]')
ax.set_ylabel('z [-]')
ax.grid(True, which='both', ls=':')
fig.tight_layout()
fig.subplots_adjust(top=0.9)
plt.suptitle('$L_1, L_2$ - Shooting conditions for H-L, halo, and V-L', size=self.suptitleSize)
if self.lowDPI:
fig.savefig('../../data/figures/orbits/extended/orbit_shooting_conditions_2d.png', transparent=True, dpi=self.dpi)
else:
fig.savefig('../../data/figures/orbits/extended/orbit_shooting_conditions_2d.pdf', transparent=True)
pass
def plot_2d_3d_shooting_conditions(self):
fig = plt.figure(figsize=self.figSize)
ax1 = fig.add_subplot(1, 2, 1, projection='3d')
ax2 = fig.add_subplot(1, 2, 2)
orbit_types = ['horizontal', 'vertical', 'halo']
lagrange_point_nrs = [1, 2]
x = []
z = []
c = []
lines = []
linewidth = 2
for lagrange_point_nr in lagrange_point_nrs:
for idx, orbit_type in enumerate(orbit_types):
initial_conditions_file_path = '../../data/raw/orbits/L' + str(
lagrange_point_nr) + '_' + orbit_type + '_initial_conditions.txt'
initial_conditions_incl_m_df = load_initial_conditions_incl_M(initial_conditions_file_path)
plot_label = orbit_type.capitalize()
if plot_label == 'Horizontal' or plot_label == 'Vertical':
plot_label += ' Lyapunov'
line, = ax1.plot(initial_conditions_incl_m_df[2].values, initial_conditions_incl_m_df[6].values,
initial_conditions_incl_m_df[4].values, label=plot_label, linewidth=linewidth,
color=self.plottingColors['tripleLine'][idx])
# ax2.plot(initial_conditions_incl_m_df[2].values, initial_conditions_incl_m_df[4].values,
# linewidth=linewidth, color=self.plottingColors['tripleLine'][idx])
lines.append(line)
x.extend(list(initial_conditions_incl_m_df[2].values))
z.extend(list(initial_conditions_incl_m_df[4].values))
c.extend(list(initial_conditions_incl_m_df[0].values))
sc = ax2.scatter(x, z, c=c, cmap='viridis', s=10)
cb = plt.colorbar(sc)
cb.set_label('$C \enskip [-]$')
# Lagrange points and bodies
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2']
for lagrange_point_nr in lagrange_point_nrs:
ax1.scatter(lagrange_points_df[lagrange_point_nr]['x'], lagrange_points_df[lagrange_point_nr]['z'],
color='black', marker='x')
ax2.scatter(lagrange_points_df[lagrange_point_nr]['x'], lagrange_points_df[lagrange_point_nr]['z'],
color='black', marker='x')
bodies_df = load_bodies_location()
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
for body in bodies_df:
x = bodies_df[body]['r'] * np.outer(np.cos(u), np.sin(v)) + bodies_df[body]['x']
y = bodies_df[body]['r'] * np.outer(np.sin(u), np.sin(v))
z = bodies_df[body]['r'] * np.outer(np.ones(np.size(u)), np.cos(v))
ax1.plot_surface(x, y, z, color='black')
ax2.contourf(x, z, y, colors='black')
# print(ax1.elev)
# print(ax1.azim)
# ax1.view_init(10, -40)
# plt.plot(ax1.get_xlim(), [0, 0], 'black', linewidth=0.5)
# plt.plot(ax2.get_xlim(), [0, 0], 'black', linewidth=0.5)
ax1.legend(frameon=True, loc='upper right', handles=lines[:3])
ax1.set_xlabel('x [-]')
ax1.set_ylabel('$\dot{y}$ [-]')
ax1.set_zlabel('z [-]')
ax1.grid(True, which='both', ls=':')
ax2.set_xlabel('x [-]')
ax2.set_ylabel('z [-]')
ax2.grid(True, which='both', ls=':')
ax2.set_ylim([-0.4, 0.8])
fig.tight_layout()
fig.subplots_adjust(top=0.9)
plt.suptitle('$L_1, L_2$ - Shooting conditions', size=self.suptitleSize)
fig.savefig('../../data/figures/orbits/orbit_shooting_conditions_2d_3d.pdf', transparent=True)
pass
def plot_image_trajectories_with_angle(self, theta):
line_width_near_heteroclinic = 2
print('Theta:')
# for theta in self.thetaRangeList:
print(theta)
df_s = load_manifold_refactored('../../data/raw/poincare_sections/' +
str(self.numberOfOrbitsPerManifold) +
'/L2_' + self.orbitType +
'_W_S_min_3.1_' + str(int(theta)) +
'_full.txt')
df_u = load_manifold_refactored('../../data/raw/poincare_sections/' +
str(self.numberOfOrbitsPerManifold) +
'/L1_' + self.orbitType +
'_W_U_plus_3.1_' + str(int(theta)) +
'_full.txt')
fig = plt.figure(figsize=self.figSize)
ax0 = fig.add_subplot(111, projection='3d')
plot_alpha = 1
# Plot near-heteroclinic connection
index_near_heteroclinic_s = int(
self.minimumImpulse.loc[theta]['taus'] *
self.numberOfOrbitsPerManifold)
index_near_heteroclinic_u = int(
self.minimumImpulse.loc[theta]['tauu'] *
self.numberOfOrbitsPerManifold)
portrait_s = []
portrait_u = []
for i in range(0, 5000, 10):
portrait_s.append(df_s.xs(i).head(1))
portrait_u.append(df_u.xs(i).tail(1))
pass
portrait_s = pd.concat(portrait_s)
portrait_u = pd.concat(portrait_u)
plt.plot(portrait_s['x'],
portrait_s['y'],
portrait_s['z'],
color='g',
linewidth=0.5)
plt.plot(portrait_u['x'],
portrait_u['y'],
portrait_u['z'],
color='r',
linewidth=0.5)
# for i in range(0, 5000, 10):
# ax0.scatter(df_s.xs(i).head(1)['x'], df_s.xs(i).head(1)['y'],
# df_s.xs(i).head(1)['z'], color='g', s=0.1)
# ax0.scatter(df_u.xs(i).tail(1)['x'], df_u.xs(i).tail(1)['y'],
# df_u.xs(i).tail(1)['z'], color='r', s=0.1)
# (T1)
ax0.plot(df_s.xs(index_near_heteroclinic_s)['x'],
df_s.xs(index_near_heteroclinic_s)['y'],
df_s.xs(index_near_heteroclinic_s)['z'],
color='g',
alpha=plot_alpha,
linewidth=line_width_near_heteroclinic)
ax0.plot(df_u.xs(index_near_heteroclinic_u)['x'],
df_u.xs(index_near_heteroclinic_u)['y'],
df_u.xs(index_near_heteroclinic_u)['z'],
color='r',
alpha=plot_alpha,
linewidth=line_width_near_heteroclinic)
# # (T4)
# ax0.plot(df_s.xs(index_near_heteroclinic_s)['x'], -df_s.xs(index_near_heteroclinic_s)['y'], df_s.xs(index_near_heteroclinic_s)['z'], color='r', alpha=plot_alpha, linewidth=line_width_near_heteroclinic)
# ax0.plot(df_u.xs(index_near_heteroclinic_u)['x'], -df_u.xs(index_near_heteroclinic_u)['y'], df_u.xs(index_near_heteroclinic_u)['z'], color='g', alpha=plot_alpha, linewidth=line_width_near_heteroclinic)
#
# # (T3)
# ax0.plot(df_s.xs(index_near_heteroclinic_s)['x'], df_s.xs(index_near_heteroclinic_s)['y'],
# -df_s.xs(index_near_heteroclinic_s)['z'], color='g', alpha=plot_alpha,
# linewidth=line_width_near_heteroclinic)
# ax0.plot(df_u.xs(index_near_heteroclinic_u)['x'], df_u.xs(index_near_heteroclinic_u)['y'],
# -df_u.xs(index_near_heteroclinic_u)['z'], color='r', alpha=plot_alpha,
# linewidth=line_width_near_heteroclinic)
# # (T2)
# ax0.plot(df_s.xs(index_near_heteroclinic_s)['x'], -df_s.xs(index_near_heteroclinic_s)['y'],
# -df_s.xs(index_near_heteroclinic_s)['z'], color='r', alpha=plot_alpha,
# linewidth=line_width_near_heteroclinic)
# ax0.plot(df_u.xs(index_near_heteroclinic_u)['x'], -df_u.xs(index_near_heteroclinic_u)['y'],
# -df_u.xs(index_near_heteroclinic_u)['z'], color='g', alpha=plot_alpha,
# linewidth=line_width_near_heteroclinic)
bodies_df = load_bodies_location()
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
# for body in ['Moon']:
for body in ['Earth', 'Moon']:
x = bodies_df[body]['r'] * np.outer(
np.cos(u), np.sin(v)) + bodies_df[body]['x']
y = bodies_df[body]['r'] * np.outer(np.sin(u), np.sin(v))
z = bodies_df[body]['r'] * np.outer(np.ones(np.size(u)), np.cos(v))
ax0.plot_surface(x, y, z, color='black')
# Lagrange points and bodies
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2']
for lagrange_point_nr in lagrange_point_nrs:
ax0.scatter(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x')
# Create cubic bounding box to simulate equal aspect ratio
max_range = np.array([
max(df_s['x'].max(), df_u['x'].max()) -
min(df_s['x'].min(), df_u['x'].min()),
max(df_s['y'].max(), df_u['y'].max()) -
min(df_s['y'].min(), df_u['y'].min()),
max(df_s['z'].max(), df_u['z'].max()) -
min(df_s['z'].min(), df_u['z'].min())
]).max()
Xb = 0.3 * max_range * np.mgrid[-1:2:2, -1:2:2, -1:2:2][0].flatten(
) + 0.2 * (max(df_s['x'].max(), df_u['x'].max()) +
min(df_s['x'].min(), df_u['x'].min()))
Yb = 0.3 * max_range * np.mgrid[-1:2:2, -1:2:2, -1:2:2][1].flatten(
) + 0.5 * (max(df_s['y'].max(), df_u['y'].max()) +
min(df_s['y'].min(), df_u['y'].min()))
Zb = 0.3 * max_range * np.mgrid[-1:2:2, -1:2:2, -1:2:2][2].flatten(
) + 0.5 * (max(df_s['z'].max(), df_u['z'].max()) +
min(df_s['z'].min(), df_u['z'].min()))
# Comment or uncomment following both lines to test the fake bounding box:
if self.orbitType != 'halo':
for xb, yb, zb in zip(Xb, Yb, Zb):
ax0.plot([xb], [yb], [zb], 'w')
arc_length = 0.2
surface_alpha = 0.1
surface_color = 'black'
x_range = np.arange(1 - self.massParameter - arc_length * 0.75,
1 - self.massParameter, 0.001)
z_range = np.arange(-arc_length * 0.75, arc_length * 0.75, 0.001)
x_mesh, z_mesh = np.meshgrid(x_range, z_range)
y_mesh = -abs(x_mesh -
(1 - self.massParameter)) / np.tan(35 * np.pi / 180)
# Plot poincare plane
ax0.plot_surface(x_mesh,
y_mesh,
z_mesh,
alpha=surface_alpha,
color=surface_color)
ax0.plot_wireframe(x_mesh,
y_mesh,
z_mesh,
color=surface_color,
rstride=500,
cstride=500,
linewidth=1)
# Plot line at angle
plt.plot(
[1 - self.massParameter, np.min(x_mesh)], [0, np.min(y_mesh)],
[0, 0],
color='k',
linestyle=':',
linewidth=1)
# Plot line orthogonal to collinear points
plt.plot([1 - self.massParameter, 1 - self.massParameter],
[0, np.min(y_mesh)], [0, 0],
color='k',
linestyle=':',
linewidth=1)
# Plot line from primary to L2
plt.plot([-self.massParameter, lagrange_points_df['L2']['x']], [0, 0],
[0, 0],
color='k',
linestyle=':',
linewidth=1)
# Indicate connection on plane
ax0.scatter(df_u.xs(index_near_heteroclinic_u).tail(1)['x'],
df_u.xs(index_near_heteroclinic_u).tail(1)['y'],
df_u.xs(index_near_heteroclinic_u).tail(1)['z'],
s=20,
linewidth=line_width_near_heteroclinic,
facecolors='none',
edgecolors='r')
# Set viewpoint
ax0.set_xlim(lagrange_points_df['L1']['x'],
lagrange_points_df['L2']['x'])
ax0.set_ylim(-0.15, 0.05)
ax0.set_zlim(-0.1, 0.1)
print(ax0.azim)
print(ax0.elev)
# ax0.view_init(elev=15, azim=220) # Single line
ax0.view_init(elev=5, azim=220) # View from Earth
# ax0.view_init(elev=5, azim=340) # View from outside
plt.tight_layout()
fig.subplots_adjust(right=1.1)
plt.axis('off')
# plt.show()
plt.savefig('../../data/figures/cover_page_angle.pdf',
transparent=True)
plt.close()
pass
def plot_image_trajectories(self, theta):
line_width_near_heteroclinic = 3
print('Theta:')
# for theta in self.thetaRangeList:
print(theta)
df_s = load_manifold_refactored('../../data/raw/poincare_sections/' +
str(self.numberOfOrbitsPerManifold) +
'/L2_' + self.orbitType +
'_W_S_min_3.1_' + str(int(theta)) +
'_full.txt')
df_u = load_manifold_refactored('../../data/raw/poincare_sections/' +
str(self.numberOfOrbitsPerManifold) +
'/L1_' + self.orbitType +
'_W_U_plus_3.1_' + str(int(theta)) +
'_full.txt')
print(df_s)
fig = plt.figure(figsize=self.figSize)
ax0 = fig.add_subplot(111, projection='3d')
plot_alpha = 1
# Plot near-heteroclinic connection
index_near_heteroclinic_s = int(
self.minimumImpulse.loc[theta]['taus'] *
self.numberOfOrbitsPerManifold)
index_near_heteroclinic_u = int(
self.minimumImpulse.loc[theta]['tauu'] *
self.numberOfOrbitsPerManifold)
# for i in range(0, 5000, 50):
# ax0.plot(df_s.xs(i)['x'], df_s.xs(i)['y'],
# df_s.xs(i)['z'], color='g', alpha=plot_alpha,
# linewidth=0.5)
# ax0.plot(df_u.xs(i)['x'], df_u.xs(i)['y'],
# df_u.xs(i)['z'], color='r', alpha=plot_alpha,
# linewidth=0.5)
# (T1)
ax0.plot(df_s.xs(index_near_heteroclinic_s)['x'],
df_s.xs(index_near_heteroclinic_s)['y'],
df_s.xs(index_near_heteroclinic_s)['z'],
color='g',
alpha=plot_alpha,
linewidth=line_width_near_heteroclinic)
ax0.plot(df_u.xs(index_near_heteroclinic_u)['x'],
df_u.xs(index_near_heteroclinic_u)['y'],
df_u.xs(index_near_heteroclinic_u)['z'],
color='r',
alpha=plot_alpha,
linewidth=line_width_near_heteroclinic)
# # (T4)
# ax0.plot(df_s.xs(index_near_heteroclinic_s)['x'], -df_s.xs(index_near_heteroclinic_s)['y'], df_s.xs(index_near_heteroclinic_s)['z'], color='r', alpha=plot_alpha, linewidth=line_width_near_heteroclinic)
# ax0.plot(df_u.xs(index_near_heteroclinic_u)['x'], -df_u.xs(index_near_heteroclinic_u)['y'], df_u.xs(index_near_heteroclinic_u)['z'], color='g', alpha=plot_alpha, linewidth=line_width_near_heteroclinic)
#
# # (T3)
# ax0.plot(df_s.xs(index_near_heteroclinic_s)['x'], df_s.xs(index_near_heteroclinic_s)['y'],
# -df_s.xs(index_near_heteroclinic_s)['z'], color='g', alpha=plot_alpha,
# linewidth=line_width_near_heteroclinic)
# ax0.plot(df_u.xs(index_near_heteroclinic_u)['x'], df_u.xs(index_near_heteroclinic_u)['y'],
# -df_u.xs(index_near_heteroclinic_u)['z'], color='r', alpha=plot_alpha,
# linewidth=line_width_near_heteroclinic)
# # (T2)
# ax0.plot(df_s.xs(index_near_heteroclinic_s)['x'], -df_s.xs(index_near_heteroclinic_s)['y'],
# -df_s.xs(index_near_heteroclinic_s)['z'], color='r', alpha=plot_alpha,
# linewidth=line_width_near_heteroclinic)
# ax0.plot(df_u.xs(index_near_heteroclinic_u)['x'], -df_u.xs(index_near_heteroclinic_u)['y'],
# -df_u.xs(index_near_heteroclinic_u)['z'], color='g', alpha=plot_alpha,
# linewidth=line_width_near_heteroclinic)
bodies_df = load_bodies_location()
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
# for body in ['Earth', 'Moon']:
for body in ['Moon']:
x = bodies_df[body]['r'] * np.outer(
np.cos(u), np.sin(v)) + bodies_df[body]['x']
y = bodies_df[body]['r'] * np.outer(np.sin(u), np.sin(v))
z = bodies_df[body]['r'] * np.outer(np.ones(np.size(u)), np.cos(v))
ax0.plot_surface(x, y, z, color='black')
# Lagrange points and bodies
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2']
for lagrange_point_nr in lagrange_point_nrs:
ax0.scatter(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x')
# Create cubic bounding box to simulate equal aspect ratio
max_range = np.array([
max(df_s['x'].max(), df_u['x'].max()) -
min(df_s['x'].min(), df_u['x'].min()),
max(df_s['y'].max(), df_u['y'].max()) -
min(df_s['y'].min(), df_u['y'].min()),
max(df_s['z'].max(), df_u['z'].max()) -
min(df_s['z'].min(), df_u['z'].min())
]).max()
Xb = 0.3 * max_range * np.mgrid[-1:2:2, -1:2:2, -1:2:2][0].flatten(
) + 0.2 * (max(df_s['x'].max(), df_u['x'].max()) +
min(df_s['x'].min(), df_u['x'].min()))
Yb = 0.3 * max_range * np.mgrid[-1:2:2, -1:2:2, -1:2:2][1].flatten(
) + 0.5 * (max(df_s['y'].max(), df_u['y'].max()) +
min(df_s['y'].min(), df_u['y'].min()))
Zb = 0.3 * max_range * np.mgrid[-1:2:2, -1:2:2, -1:2:2][2].flatten(
) + 0.5 * (max(df_s['z'].max(), df_u['z'].max()) +
min(df_s['z'].min(), df_u['z'].min()))
# Comment or uncomment following both lines to test the fake bounding box:
if self.orbitType != 'halo':
for xb, yb, zb in zip(Xb, Yb, Zb):
ax0.plot([xb], [yb], [zb], 'w')
# azim=150
# elev=25
print(ax0.azim)
print(ax0.elev)
ax0.view_init(elev=15, azim=220) # Single line
# ax0.view_init(elev=20, azim=240) # Manifold lines
plt.tight_layout()
plt.axis('off')
# plt.show()
plt.savefig('../../data/figures/cover_page.pdf', transparent=True)
plt.close()
pass
def plot(self):
colors = sns.color_palette("Blues", n_colors=6)
# Plot: 3d overview
fig = plt.figure(figsize=(7 * (1 + np.sqrt(5)) / 2, 7))
ax = fig.gca(projection='3d')
# Plot both primaries
u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)
bodies_df = load_bodies_location()
for body in bodies_df:
x = bodies_df[body]['r'] * np.outer(
np.cos(u), np.sin(v)) + bodies_df[body]['x']
y = bodies_df[body]['r'] * np.outer(np.sin(u), np.sin(v))
z = bodies_df[body]['r'] * np.outer(np.ones(np.size(u)), np.cos(v))
ax.plot_surface(x, y, z, color='black')
# Plot Lagrange points 1 and 2
lagrange_points_df = load_lagrange_points_location()
lagrange_point_nrs = ['L1', 'L2']
for lagrange_point_nr in lagrange_point_nrs:
ax.scatter3D(lagrange_points_df[lagrange_point_nr]['x'],
lagrange_points_df[lagrange_point_nr]['y'],
lagrange_points_df[lagrange_point_nr]['z'],
color='black',
marker='x',
s=50)
# ax.annotate('Moon', xy=(-0.002,0.004),
# xytext=(-0.002, 0.04), fontsize=20, ha = 'center', va = 'top',
# arrowprops=dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0'),
# )
# ax.annotate('$L_1$', xy=(-0.023, 0.012),
# xytext=(-0.023, 0.04), fontsize=20, ha='center', va='top',
# arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0'),
# )
# ax.annotate('$L_2$', xy=(0.023, -0.004),
# xytext=(0.023, 0.04), fontsize=20, ha='center', va='top',
# arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0'),
# )
# params = {'legend.fontsize': 16}
# plt.rcParams.update(params)
C = 3.1
# x_range = np.arange(0.7, 1.3, 0.001)
# y_range = np.arange(-0.3, 0.3, 0.001)
x_range = np.arange(0.8, 1.2, 0.001)
y_range = np.arange(-0.2, 0.2, 0.001)
X, Y = np.meshgrid(x_range, y_range)
Z = cr3bp_velocity(X, Y, C)
if Z.min() < 0:
plt.contourf(X, Y, Z, 0, colors='black', alpha=0.05, zorder=1000)
linewidth = 2
df = load_orbit('../../data/raw_equal_energy/horizontal_L1_577.txt')
ax.plot(df['x'],
df['y'],
df['z'],
color=sns.color_palette("viridis", 3)[0],
alpha=0.75,
linestyle='-',
label='Horizontal Lyapunov',
linewidth=linewidth)
df = load_orbit('../../data/raw_equal_energy/halo_L1_799.txt')
ax.plot(df['x'],
df['y'],
df['z'],
color=sns.color_palette("viridis", 3)[2],
alpha=0.75,
linestyle='-',
label='Halo',
linewidth=linewidth)
df = load_orbit('../../data/raw_equal_energy/vertical_L1_1163.txt')
ax.plot(df['x'],
df['y'],
df['z'],
color=sns.color_palette("viridis", 3)[1],
alpha=0.75,
linestyle='-',
label='Vertical Lyapunov',
linewidth=linewidth)
ax.legend(frameon=True, loc='lower right')
df = load_orbit('../../data/raw_equal_energy/horizontal_L2_760.txt')
ax.plot(df['x'],
df['y'],
df['z'],
color=sns.color_palette("viridis", 3)[0],
alpha=0.75,
linestyle='-',
linewidth=linewidth)
df = load_orbit('../../data/raw_equal_energy/vertical_L2_1299.txt')
ax.plot(df['x'],
df['y'],
df['z'],
color=sns.color_palette("viridis", 3)[1],
alpha=0.75,
linestyle='-',
linewidth=linewidth)
df = load_orbit('../../data/raw_equal_energy/halo_L2_651.txt')
ax.plot(df['x'],
df['y'],
df['z'],
color=sns.color_palette("viridis", 3)[2],
alpha=0.75,
linestyle='-',
linewidth=linewidth)
ax.set_xlabel('x [-]')
ax.set_ylabel('y [-]')
ax.set_zlabel('z [-]')
ax.grid(True, which='both', ls=':')
# ax.view_init(25, -60)
ax.view_init(20, -60)
# ax.set_xlim([0.7, 1.3])
# ax.set_ylim([-0.3, 0.3])
# ax.set_zlim([-0.3, 0.3])
ax.set_xlim([0.8, 1.2])
ax.set_ylim([-0.2, 0.2])
ax.set_zlim([-0.2, 0.2])
plt.tight_layout()
# plt.show()
# fig.savefig('../../../data/figures/family_of_equal_energy.png')
fig.savefig('../../data/figures/new_family_of_equal_energy.pdf',
transparent=True)
# tikz_save('../../../data/figures/family_of_equal_energy.tex')
plt.close()
pass