{ "cells": [ { "cell_type": "markdown", "id": "61fdf99d", "metadata": {}, "source": [ "# Section 5.2 - Mars SmallSat Constellation - Approach Trajectories" ] }, { "cell_type": "code", "execution_count": 1, "id": "29dc6009", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from astropy.time import Time\n", "from AMAT.arrival import Arrival" ] }, { "cell_type": "code", "execution_count": 2, "id": "4fb3cea5", "metadata": {}, "outputs": [], "source": [ "arrival = Arrival()\n", "arrival.set_vinf_vec_from_lambert_arc(lastFlybyPlanet='EARTH',\n", " arrivalPlanet='MARS',\n", " lastFlybyDate=Time(\"2020-07-30 00:00:00\", scale='tdb'),\n", " arrivalDate=Time(\"2021-02-18 00:00:00\", scale='tdb'),\n", " ephem_file='../../../spice-data/de432s.bsp')" ] }, { "cell_type": "code", "execution_count": 3, "id": "53f2f563", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Arrival v_inf vector, ICRF: [ 2.23930482 1.20086474 -0.73683367] km/s\n", "Arrival VINF MAG: 2.65 km/s.\n", "Arrival Declination: -1.65 deg.\n" ] } ], "source": [ "print(\"Arrival v_inf vector, ICRF: \"+str(arrival.v_inf_vec)+\" km/s\")\n", "print(\"Arrival VINF MAG: \"+str(round(arrival.v_inf_mag, 2))+\" km/s.\")\n", "print(\"Arrival Declination: \"+str(round(arrival.declination, 2))+\" deg.\")" ] }, { "cell_type": "code", "execution_count": 4, "id": "5ee00b2b", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from AMAT.approach import Approach" ] }, { "cell_type": "code", "execution_count": 5, "id": "57f8b29f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Small satellite #1\n", "Entry altitude, km: 120.0\n", "Entry longitude BI, deg: -89.76\n", "Entry latitude BI, deg: -0.71\n", "Atm. relative entry speed, km/s: 5.3586\n", "Atm. relative heading angle, deg: 9.3778\n", "Atm. relative EFPA, deg: -9.2475\n", "Inclination, deg: 1.6533397822244609\n", "----------------------------------------------------\n", "Small satellite #2\n", "Entry altitude, km: 120.0\n", "Entry longitude BI, deg: -87.42\n", "Entry latitude BI, deg: 19.48\n", "Atm. relative entry speed, km/s: 5.3775\n", "Atm. relative heading angle, deg: 15.1773\n", "Atm. relative EFPA, deg: -9.2147\n", "Inclination, deg: 22.557516345832322\n", "----------------------------------------------------\n", "Small satellite #3\n", "Entry altitude, km: 120.0\n", "Entry longitude BI, deg: -80.17\n", "Entry latitude BI, deg: 38.8\n", "Atm. relative entry speed, km/s: 5.4311\n", "Atm. relative heading angle, deg: 27.2459\n", "Atm. relative EFPA, deg: -9.1229\n", "Inclination, deg: 45.02384795300673\n", "----------------------------------------------------\n", "Small satellite #4\n", "Entry altitude, km: 120.0\n", "Entry longitude BI, deg: -62.53\n", "Entry latitude BI, deg: 55.34\n", "Atm. relative entry speed, km/s: 5.5111\n", "Atm. relative heading angle, deg: 49.4493\n", "Atm. relative EFPA, deg: -8.9893\n", "Inclination, deg: 67.50987984826553\n", "----------------------------------------------------\n", "Small satellite #5\n", "Entry altitude, km: 120.0\n", "Entry longitude BI, deg: -25.06\n", "Entry latitude BI, deg: 63.04\n", "Atm. relative entry speed, km/s: 5.6053\n", "Atm. relative heading angle, deg: 91.1531\n", "Atm. relative EFPA, deg: -8.8371\n", "Inclination, deg: 90.00000000000001\n", "----------------------------------------------------\n", "Host orbiter\n", "RP, km: 3639.5\n", "Inclination, deg: 90.00000000000001\n" ] } ], "source": [ "approach1 = Approach(\"MARS\", v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+52)*1e3, psi=1.5*np.pi,\n", " is_entrySystem=True, h_EI=120e3)\n", "\n", "approach2 = Approach(\"MARS\", v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+52)*1e3, psi=1.375*np.pi,\n", " is_entrySystem=True, h_EI=120e3)\n", "\n", "approach3 = Approach(\"MARS\", v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+52)*1e3, psi=1.25*np.pi,\n", " is_entrySystem=True, h_EI=120e3)\n", "\n", "approach4 = Approach(\"MARS\", v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+52)*1e3, psi=1.125*np.pi,\n", " is_entrySystem=True, h_EI=120e3)\n", "\n", "approach5 = Approach(\"MARS\", v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+52)*1e3, psi=1.0*np.pi,\n", " is_entrySystem=True, h_EI=120e3)\n", "\n", "\n", "space = Approach(\"MARS\",\n", " v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+250)*1e3, psi=np.pi)\n", "\n", "print('Small satellite #1')\n", "print(\"Entry altitude, km: \"+ str(approach1.h_EI/1e3))\n", "print(\"Entry longitude BI, deg: \"+ str(round(approach1.longitude_entry_bi*180/np.pi, 2)))\n", "print(\"Entry latitude BI, deg: \"+ str(round(approach1.latitude_entry_bi*180/np.pi, 2)))\n", "print(\"Atm. relative entry speed, km/s: \"+str(round(approach1.v_entry_atm_mag/1e3, 4)))\n", "print(\"Atm. relative heading angle, deg: \"+str(round(approach1.heading_entry_atm*180/np.pi, 4)))\n", "print(\"Atm. relative EFPA, deg: \"+str(round(approach1.gamma_entry_atm*180/np.pi, 4)))\n", "print(\"Inclination, deg: \"+str(approach1.i*180/np.pi))\n", "print('----------------------------------------------------')\n", "print('Small satellite #2')\n", "print(\"Entry altitude, km: \"+ str(approach2.h_EI/1e3))\n", "print(\"Entry longitude BI, deg: \"+ str(round(approach2.longitude_entry_bi*180/np.pi, 2)))\n", "print(\"Entry latitude BI, deg: \"+ str(round(approach2.latitude_entry_bi*180/np.pi, 2)))\n", "print(\"Atm. relative entry speed, km/s: \"+str(round(approach2.v_entry_atm_mag/1e3, 4)))\n", "print(\"Atm. relative heading angle, deg: \"+str(round(approach2.heading_entry_atm*180/np.pi, 4)))\n", "print(\"Atm. relative EFPA, deg: \"+str(round(approach2.gamma_entry_atm*180/np.pi, 4)))\n", "print(\"Inclination, deg: \"+str(approach2.i*180/np.pi))\n", "print('----------------------------------------------------')\n", "print('Small satellite #3')\n", "print(\"Entry altitude, km: \"+ str(approach3.h_EI/1e3))\n", "print(\"Entry longitude BI, deg: \"+ str(round(approach3.longitude_entry_bi*180/np.pi, 2)))\n", "print(\"Entry latitude BI, deg: \"+ str(round(approach3.latitude_entry_bi*180/np.pi, 2)))\n", "print(\"Atm. relative entry speed, km/s: \"+str(round(approach3.v_entry_atm_mag/1e3, 4)))\n", "print(\"Atm. relative heading angle, deg: \"+str(round(approach3.heading_entry_atm*180/np.pi, 4)))\n", "print(\"Atm. relative EFPA, deg: \"+str(round(approach3.gamma_entry_atm*180/np.pi, 4)))\n", "print(\"Inclination, deg: \"+str(approach3.i*180/np.pi))\n", "print('----------------------------------------------------')\n", "print('Small satellite #4')\n", "print(\"Entry altitude, km: \"+ str(approach4.h_EI/1e3))\n", "print(\"Entry longitude BI, deg: \"+ str(round(approach4.longitude_entry_bi*180/np.pi, 2)))\n", "print(\"Entry latitude BI, deg: \"+ str(round(approach4.latitude_entry_bi*180/np.pi, 2)))\n", "print(\"Atm. relative entry speed, km/s: \"+str(round(approach4.v_entry_atm_mag/1e3, 4)))\n", "print(\"Atm. relative heading angle, deg: \"+str(round(approach4.heading_entry_atm*180/np.pi, 4)))\n", "print(\"Atm. relative EFPA, deg: \"+str(round(approach4.gamma_entry_atm*180/np.pi, 4)))\n", "print(\"Inclination, deg: \"+str(approach4.i*180/np.pi))\n", "print('----------------------------------------------------')\n", "print('Small satellite #5')\n", "print(\"Entry altitude, km: \"+ str(approach5.h_EI/1e3))\n", "print(\"Entry longitude BI, deg: \"+ str(round(approach5.longitude_entry_bi*180/np.pi, 2)))\n", "print(\"Entry latitude BI, deg: \"+ str(round(approach5.latitude_entry_bi*180/np.pi, 2)))\n", "print(\"Atm. relative entry speed, km/s: \"+str(round(approach5.v_entry_atm_mag/1e3, 4)))\n", "print(\"Atm. relative heading angle, deg: \"+str(round(approach5.heading_entry_atm*180/np.pi, 4)))\n", "print(\"Atm. relative EFPA, deg: \"+str(round(approach5.gamma_entry_atm*180/np.pi, 4)))\n", "print(\"Inclination, deg: \"+str(approach5.i*180/np.pi))\n", "print('----------------------------------------------------')\n", "print('Host orbiter')\n", "print(\"RP, km: \"+str(space.rp*1e-3))\n", "print(\"Inclination, deg: \"+str(space.i*180/np.pi))" ] }, { "cell_type": "markdown", "id": "1a7365d8", "metadata": {}, "source": [ "Run the following code to generate the approach trajectory plot. The code is also available in the file ```section-5-2-mars-smallsat-constellation-approach-viz.py```." ] }, { "cell_type": "markdown", "id": "74e2d43a", "metadata": {}, "source": [ "```\n", "from mayavi import mlab\n", "import numpy as np\n", "from tvtk.tools import visual\n", "from AMAT.approach import Approach\n", "from astropy.time import Time\n", "from AMAT.arrival import Arrival\n", "from AMAT.vehicle import Vehicle\n", "\n", "def Arrow_From_A_to_B(x1, y1, z1, x2, y2, z2):\n", " ar1 = visual.arrow(x=x1, y=y1, z=z1)\n", " ar1.length_cone = 0.4\n", "\n", " arrow_length = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2 + (z2 - z1) ** 2)\n", " ar1.actor.scale = [arrow_length, arrow_length, arrow_length]\n", " ar1.pos = ar1.pos / arrow_length\n", " ar1.axis = [x2 - x1, y2 - y1, z2 - z1]\n", " return ar1\n", "\n", "arrival = Arrival()\n", "arrival.set_vinf_vec_from_lambert_arc(lastFlybyPlanet='EARTH',\n", " arrivalPlanet='MARS',\n", " lastFlybyDate=Time(\"2020-07-30 00:00:00\", scale='tdb'),\n", " arrivalDate=Time(\"2021-02-18 00:00:00\", scale='tdb'),\n", " ephem_file='../../../spice-data/de432s.bsp')\n", "\n", "\n", "\n", "probe1 = Approach(\"MARS\", v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+52)*1e3, psi=1.5*np.pi,\n", " is_entrySystem=True, h_EI=120e3)\n", "\n", "probe2 = Approach(\"MARS\", v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+52)*1e3, psi=1.375*np.pi,\n", " is_entrySystem=True, h_EI=120e3)\n", "\n", "probe3 = Approach(\"MARS\", v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+52)*1e3, psi=1.25*np.pi,\n", " is_entrySystem=True, h_EI=120e3)\n", "\n", "probe4 = Approach(\"MARS\", v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+52)*1e3, psi=1.125*np.pi,\n", " is_entrySystem=True, h_EI=120e3)\n", "\n", "probe5 = Approach(\"MARS\", v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+52)*1e3, psi=1.0*np.pi,\n", " is_entrySystem=True, h_EI=120e3)\n", "\n", "\n", "space = Approach(\"MARS\",\n", " v_inf_vec_icrf_kms=arrival.v_inf_vec,\n", " rp=(3389.5+250)*1e3, psi=np.pi)\n", "\n", "\n", "\n", "theta_star_arr_space = np.linspace(-2.00, 0.0, 101)\n", "pos_vec_bi_arr_space = space.pos_vec_bi(theta_star_arr_space)/3389.5e3\n", "\n", "x_arr_space = pos_vec_bi_arr_space[0][:]\n", "y_arr_space = pos_vec_bi_arr_space[1][:]\n", "z_arr_space = pos_vec_bi_arr_space[2][:]\n", "\n", "north_pole_bi_vec = probe1.ICRF_to_BI(arrival.north_pole)\n", "\n", "theta_star_arr_probe1 = np.linspace(-2, probe1.theta_star_entry, 101)\n", "pos_vec_bi_arr_probe1 = probe1.pos_vec_bi(theta_star_arr_probe1)/3389.5e3\n", "\n", "theta_star_arr_probe2 = np.linspace(-2, probe2.theta_star_entry, 101)\n", "pos_vec_bi_arr_probe2 = probe2.pos_vec_bi(theta_star_arr_probe2)/3389.5e3\n", "\n", "theta_star_arr_probe3 = np.linspace(-2, probe3.theta_star_entry, 101)\n", "pos_vec_bi_arr_probe3 = probe3.pos_vec_bi(theta_star_arr_probe3)/3389.5e3\n", "\n", "theta_star_arr_probe4 = np.linspace(-2, probe4.theta_star_entry, 101)\n", "pos_vec_bi_arr_probe4 = probe4.pos_vec_bi(theta_star_arr_probe4)/3389.5e3\n", "\n", "theta_star_arr_probe5 = np.linspace(-2, probe5.theta_star_entry, 101)\n", "pos_vec_bi_arr_probe5 = probe5.pos_vec_bi(theta_star_arr_probe5)/3389.5e3\n", "\n", "\n", "x_arr_probe1 = pos_vec_bi_arr_probe1[0][:]\n", "y_arr_probe1 = pos_vec_bi_arr_probe1[1][:]\n", "z_arr_probe1 = pos_vec_bi_arr_probe1[2][:]\n", "\n", "x_arr_probe2 = pos_vec_bi_arr_probe2[0][:]\n", "y_arr_probe2 = pos_vec_bi_arr_probe2[1][:]\n", "z_arr_probe2 = pos_vec_bi_arr_probe2[2][:]\n", "\n", "x_arr_probe3 = pos_vec_bi_arr_probe3[0][:]\n", "y_arr_probe3 = pos_vec_bi_arr_probe3[1][:]\n", "z_arr_probe3 = pos_vec_bi_arr_probe3[2][:]\n", "\n", "x_arr_probe4 = pos_vec_bi_arr_probe4[0][:]\n", "y_arr_probe4 = pos_vec_bi_arr_probe4[1][:]\n", "z_arr_probe4 = pos_vec_bi_arr_probe4[2][:]\n", "\n", "x_arr_probe5 = pos_vec_bi_arr_probe5[0][:]\n", "y_arr_probe5 = pos_vec_bi_arr_probe5[1][:]\n", "z_arr_probe5 = pos_vec_bi_arr_probe5[2][:]\n", "\n", "\n", "\n", "u = np.linspace(0, 2 * np.pi, 100)\n", "v = np.linspace(0, np.pi, 100)\n", "x = 1*np.outer(np.cos(u), np.sin(v))\n", "y = 1*np.outer(np.sin(u), np.sin(v))\n", "z = 1*np.outer(np.ones(np.size(u)), np.cos(v))\n", "\n", "x1 = 1.040381198513972*np.outer(np.cos(u), np.sin(v))\n", "y1 = 1.040381198513972*np.outer(np.sin(u), np.sin(v))\n", "z1 = 1.040381198513972*np.outer(np.ones(np.size(u)), np.cos(v))\n", "\n", "\n", "x_ring_1 = 1.1*np.cos(u)\n", "y_ring_1 = 1.1*np.sin(u)\n", "z_ring_1 = 0.0*np.cos(u)\n", "\n", "x_ring_2 = 1.2*np.cos(u)\n", "y_ring_2 = 1.2*np.sin(u)\n", "z_ring_2 = 0.0*np.cos(u)\n", "\n", "mlab.figure(bgcolor=(0,0,0))\n", "s1 = mlab.mesh(x, y, z, color=(0.7,0.3,0.0))\n", "s2 = mlab.mesh(x1, y1, z1, color=(0.7, 0.3,0.0), opacity=0.3)\n", "r1 = mlab.plot3d(x_ring_1, y_ring_1, z_ring_1, color=(1,1,1), line_width=1, tube_radius=None)\n", "#r2 = mlab.plot3d(x_ring_2, y_ring_2, z_ring_2, color=(1,1,1), line_width=1, tube_radius=None)\n", "\n", "p1 = mlab.plot3d(x_arr_probe1, y_arr_probe1, z_arr_probe1, color=(0,1,0), line_width=3, tube_radius=None)\n", "p2 = mlab.plot3d(x_arr_probe2, y_arr_probe2, z_arr_probe2, color=(0,1,0), line_width=3, tube_radius=None)\n", "p3 = mlab.plot3d(x_arr_probe3, y_arr_probe3, z_arr_probe3, color=(0,1,0), line_width=3, tube_radius=None)\n", "p4 = mlab.plot3d(x_arr_probe4, y_arr_probe4, z_arr_probe4, color=(0,1,0), line_width=3, tube_radius=None)\n", "p5 = mlab.plot3d(x_arr_probe5, y_arr_probe5, z_arr_probe5, color=(0,1,0), line_width=3, tube_radius=None)\n", "#p2 = mlab.plot3d(x_arr_space, y_arr_space, z_arr_space, color=(0,0,1), line_width=3, tube_radius=None)\n", "o1 = mlab.plot3d(x_arr_space, y_arr_space, z_arr_space, color=(0,0,1), line_width=3, tube_radius=None)\n", "\n", "\n", "mlab.plot3d([0, 1.2 * north_pole_bi_vec[0]],\n", " [0, 1.2 * north_pole_bi_vec[1]],\n", " [0, 1.2 * north_pole_bi_vec[2]])\n", "\n", "mlab.plot3d([0, 1.5 * probe1.S_vec_bi_unit[0]],\n", " [0, 1.5 * probe1.S_vec_bi_unit[1]],\n", " [0, 1.5 * probe1.S_vec_bi_unit[2]], color=(0, 1, 0))\n", "\n", "mlab.plot3d([0, 1.5 * probe1.R_vec_bi_unit[0]],\n", " [0, 1.5 * probe1.R_vec_bi_unit[1]],\n", " [0, 1.5 * probe1.R_vec_bi_unit[2]], color=(1, 0, 0))\n", "\n", "mlab.plot3d([0, 1.5 * probe1.T_vec_bi_unit[0]],\n", " [0, 1.5 * probe1.T_vec_bi_unit[1]],\n", " [0, 1.5 * probe1.T_vec_bi_unit[2]], color=(0, 0, 1))\n", "\n", "\n", "mlab.show()\n", "\n", "\n", "```" ] }, { "cell_type": "code", "execution_count": 6, "id": "1ac68319", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 6, "metadata": { "image/png": { "width": 1200 } }, "output_type": "execute_result" } ], "source": [ "from IPython.display import Image\n", "Image(filename='../../../plots/mars-smallsat-constellation-approach.png', width=1200)" ] }, { "cell_type": "code", "execution_count": 6, "id": "d1e014aa", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-1.912860725974833e-09\n", "7345715.666240079\n" ] } ], "source": [ "print(np.dot(approach1.b_mag*approach1.B_vec_bi_unit, approach1.R_vec_bi_unit))\n", "print(np.dot(approach1.b_mag*approach1.B_vec_bi_unit, approach1.T_vec_bi_unit))" ] }, { "cell_type": "code", "execution_count": 7, "id": "ded4eb1f", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "from matplotlib import rcParams" ] }, { "cell_type": "code", "execution_count": 8, "id": "c5009c24", "metadata": {}, "outputs": [], "source": [ "from mpl_toolkits.axes_grid1.inset_locator import zoomed_inset_axes\n", "from mpl_toolkits.axes_grid1.inset_locator import mark_inset" ] }, { "cell_type": "code", "execution_count": 13, "id": "07757735", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig = plt.figure()\n", "fig.set_size_inches([5, 5])\n", "\n", "plt.rc('font',family='Times New Roman')\n", "params = {'mathtext.default': 'regular' }\n", "plt.rcParams.update(params)\n", "\n", "theta_arr = np.linspace(0, 2*np.pi, 101)\n", "X_MARS = approach1.planetObj.RP*np.cos(theta_arr)/1e3\n", "Y_MARS = approach1.planetObj.RP*np.sin(theta_arr)/1e3\n", "\n", "plt.plot(X_MARS, Y_MARS, color='red', linestyle='dashed', linewidth=2.0, label='Mars surface')\n", "\n", "BR1 = np.dot(approach1.b_mag*approach1.B_vec_bi_unit, approach1.R_vec_bi_unit)\n", "BT1 = np.dot(approach1.b_mag*approach1.B_vec_bi_unit, approach1.T_vec_bi_unit)\n", "\n", "X_SS = (BT1/1e3)*np.cos(theta_arr)\n", "Y_SS = (BT1/1e3)*np.sin(theta_arr)\n", "plt.plot(X_SS, Y_SS, color='g', linestyle='dashed', linewidth=2.0, label='SmallSat |B| circle')\n", "\n", "BR2 = np.dot(approach2.b_mag*approach2.B_vec_bi_unit, approach2.R_vec_bi_unit)\n", "BT2 = np.dot(approach2.b_mag*approach2.B_vec_bi_unit, approach2.T_vec_bi_unit)\n", "\n", "BR3 = np.dot(approach3.b_mag*approach3.B_vec_bi_unit, approach3.R_vec_bi_unit)\n", "BT3 = np.dot(approach3.b_mag*approach3.B_vec_bi_unit, approach3.T_vec_bi_unit)\n", "\n", "BR4 = np.dot(approach4.b_mag*approach4.B_vec_bi_unit, approach4.R_vec_bi_unit)\n", "BT4 = np.dot(approach4.b_mag*approach4.B_vec_bi_unit, approach4.T_vec_bi_unit)\n", "\n", "BR5 = np.dot(approach5.b_mag*approach5.B_vec_bi_unit, approach5.R_vec_bi_unit)\n", "BT5 = np.dot(approach5.b_mag*approach5.B_vec_bi_unit, approach5.T_vec_bi_unit)\n", "\n", "BR6 = np.dot(space.b_mag*space.B_vec_bi_unit, space.R_vec_bi_unit)\n", "BT6 = np.dot(space.b_mag*space.B_vec_bi_unit, space.T_vec_bi_unit)\n", "\n", "X_HS = (BR6/1e3)*np.cos(theta_arr)\n", "Y_HS = (BR6/1e3)*np.sin(theta_arr)\n", "plt.plot(X_HS, Y_HS, color='m', linestyle='dashed', linewidth=2.0, label='Host |B| circle')\n", "\n", "\n", "\n", "plt.scatter(BT1/1e3, BR1/1e3, marker=\"o\", s=40, color='g', zorder=100, label='SmallSat aim points')\n", "plt.scatter(BT2/1e3, BR2/1e3, marker=\"o\", s=40, color='g', zorder=100)\n", "plt.scatter(BT3/1e3, BR3/1e3, marker=\"o\", s=40, color='g', zorder=100)\n", "plt.scatter(BT4/1e3, BR4/1e3, marker=\"o\", s=40, color='g', zorder=100)\n", "plt.scatter(BT5/1e3, BR5/1e3, marker=\"o\", s=40, color='g', zorder=100)\n", "plt.scatter(BT6/1e3, BR6/1e3, marker=\"*\", s=100, color='m', zorder=100, label='Host orbiter aim point')\n", "\n", "plt.gca().invert_yaxis()\n", "plt.gca().set_aspect('equal')\n", "\n", "plt.xlabel('B.T, km' ,fontsize=12)\n", "plt.ylabel('B.R, km' ,fontsize=12)\n", "\n", "plt.yticks(fontsize=12)\n", "plt.xticks(fontsize=12)\n", "ax = plt.gca()\n", "ax.tick_params(direction='in')\n", "ax.yaxis.set_ticks_position('both')\n", "ax.xaxis.set_ticks_position('both')\n", "\n", "plt.legend(loc='lower right', fontsize=10, framealpha=1)\n", "\n", "\n", "ax=plt.gca()\n", "ax.xaxis.set_tick_params(direction='in', which='both')\n", "ax.yaxis.set_tick_params(direction='in', which='both')\n", "ax.xaxis.set_tick_params(width=1, length=4)\n", "ax.yaxis.set_tick_params(width=1, length=4)\n", "ax.xaxis.set_tick_params(width=1, length=4, which='minor')\n", "ax.yaxis.set_tick_params(width=1, length=4, which='minor')\n", "ax.xaxis.grid(which='major', color='k', linestyle='dotted', linewidth=0.5)\n", "ax.xaxis.grid(which='minor', color='k', linestyle='dotted', linewidth=0.0)\n", "ax.yaxis.grid(which='major', color='k', linestyle='dotted', linewidth=0.5)\n", "ax.yaxis.grid(which='minor', color='k', linestyle='dotted', linewidth=0.0)\n", "\n", "plt.annotate('', xy=(BT2/1e3, BR2/1e3), xytext=(BT1/1e3, BR1/1e3),\n", " va=\"center\", ha=\"center\",\n", " arrowprops=dict(arrowstyle='->, head_width=0.2', facecolor='blue'), fontsize=10, color='k',\n", " bbox=dict(boxstyle='round,pad=0.2', fc='w', ec='k', alpha=1))\n", "\n", "plt.annotate('', xy=(BT3/1e3, BR3/1e3), xytext=(BT2/1e3, BR2/1e3),\n", " va=\"center\", ha=\"center\",\n", " arrowprops=dict(arrowstyle='->, head_width=0.2', facecolor='blue'), fontsize=10, color='k',\n", " bbox=dict(boxstyle='round,pad=0.2', fc='w', ec='k', alpha=1))\n", "\n", "plt.annotate('', xy=(BT4/1e3, BR4/1e3), xytext=(BT3/1e3, BR3/1e3),\n", " va=\"center\", ha=\"center\",\n", " arrowprops=dict(arrowstyle='->, head_width=0.2', facecolor='blue'), fontsize=10, color='k',\n", " bbox=dict(boxstyle='round,pad=0.2', fc='w', ec='k', alpha=1))\n", "\n", "plt.annotate('', xy=(BT5/1e3, BR5/1e3), xytext=(BT4/1e3, BR4/1e3),\n", " va=\"center\", ha=\"center\",\n", " arrowprops=dict(arrowstyle='->, head_width=0.2', facecolor='blue'), fontsize=10, color='k',\n", " bbox=dict(boxstyle='round,pad=0.2', fc='w', ec='k', alpha=1))\n", "\n", "\n", "plt.text(5800, -1000, r'$\\Delta V_1$', fontsize=12)\n", "plt.text(4700, -3500, r'$\\Delta V_2$', fontsize=12)\n", "plt.text(3000, -5500, r'$\\Delta V_3$', fontsize=12)\n", "plt.text(1000, -6200, r'$\\Delta V_4$', fontsize=12)\n", "\n", "\n", "for axis in ['top', 'bottom', 'left', 'right']:\n", " ax.spines[axis].set_linewidth(2)\n", " \n", "plt.xlim([-8000, 8000])\n", "\n", "\n", "axins = zoomed_inset_axes(ax, 8, loc=2, axes_kwargs={'zorder':2})\n", "axins.set_xlim(-300,300)\n", "axins.set_ylim(-7800, -7200)\n", "axins.plot(X_SS, Y_SS, color='g', linestyle='dashed', linewidth=2.0)\n", "axins.plot(X_HS, Y_HS, color='m', linestyle='dashed', linewidth=2.0)\n", "axins.scatter(BT5/1e3, BR5/1e3, marker=\"o\", s=100, color='g')\n", "axins.scatter(BT6/1e3, BR6/1e3, marker=\"*\", s=200, color='m')\n", "axins.annotate('', xy=(BT6/1e3, 0.999*BR6/1e3), xytext=(BT5/1e3, BR5/1e3),\n", " va=\"center\", ha=\"center\",\n", " arrowprops=dict(arrowstyle='->, head_width=0.3', facecolor='blue'), fontsize=10, color='k',\n", " bbox=dict(boxstyle='round,pad=0.2', fc='w', ec='k', alpha=1))\n", "axins.text(50, -7450, r'$\\Delta V_5$', rotation=0, fontsize=12)\n", "\n", "axins.invert_yaxis()\n", "patch, pp1, pp2 = mark_inset(ax, axins,loc1=1,loc2=1, fc=\"none\", ec=\"k\", linestyle='solid', linewidth = 1, zorder=0.0)\n", "pp1.loc1 = 1\n", "pp1.loc2 = 4\n", "pp2.loc1 = 4\n", "pp2.loc2 = 1\n", "plt.draw()\n", "\n", "axins.yaxis.get_major_locator().set_params(nbins=1)\n", "axins.xaxis.get_major_locator().set_params(nbins=1)\n", "\n", "plt.setp(axins.get_xticklabels(), visible=True)\n", "plt.setp(axins.get_yticklabels(), visible=False)\n", "\n", "axins.xaxis.set_tick_params(direction='in', which='both')\n", "axins.yaxis.set_tick_params(direction='in', which='both')\n", "\n", "\n", "\n", "for axis in ['top', 'bottom', 'left', 'right']:\n", " axins.spines[axis].set_linewidth(1.5)\n", "\n", "axins.tick_params(axis='both', which='major', labelsize=10)\n", "\n", "plt.draw()\n", "\n", "plt.savefig('../../../data/mdpi-aerospace/smallsat-mission-concepts/mars/mars-smallsat-const-b-plane.png', dpi= 300,bbox_inches='tight')\n", "plt.savefig('../../../data/mdpi-aerospace/smallsat-mission-concepts/mars/mars-smallsat-const-b-plane.pdf', dpi=300,bbox_inches='tight')\n", "plt.savefig('../../../data/mdpi-aerospace/smallsat-mission-concepts/mars/mars-smallsat-const-b-plane.eps', dpi=300,bbox_inches='tight')\n", "\n", "\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.16" } }, "nbformat": 4, "nbformat_minor": 5 }