How can I find the closet distance between my trajectory and (384400,0,0)?

Also, how can I the distance from (384400,0,0) to the path at time t = 197465?

I realize that the arrays contain data, but is there a method to examine all points with coordinates (x,y,z) and retrieve what I need?

import numpy as np

from scipy.integrate import odeint

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

me = 5.974 * 10 ** (24) # mass of the earth

mm = 7.348 * 10 ** (22) # mass of the moon

G = 6.67259 * 10 ** (-20) # gravitational parameter

re = 6378.0 # radius of the earth in km

rm = 1737.0 # radius of the moon in km

r12 = 384400.0 # distance between the CoM of the earth and moon

M = me + mm

pi1 = me / M

pi2 = mm / M

mue = 398600.0 # gravitational parameter of earth km^3/sec2

mum = G * mm # grav param of the moon

mu = mue + mum

omega = np.sqrt(mu / r12 ** 3)

nu = -129.21 * np.pi / 180 # true anomaly angle in radian

x = 327156.0 - 4671

x position where the moon's SOI influences the spacecraft with an offset from the

Earth not being at (0,0) in the Earth-Moon system

y = 33050.0 # y location

vbo = 10.85 # velocity at burnout

gamma = 0 * np.pi / 180 # angle in radians of the flight path

vx = vbo * (np.sin(gamma) * np.cos(nu) - np.cos(gamma) * np.sin(nu))

velocity of the bo in the x direction

vy = vbo * (np.sin(gamma) * np.sin(nu) + np.cos(gamma) * np.cos(nu))

velocity of the bo in the y direction

xrel = (re + 300.0) * np.cos(nu) - pi2 * r12

spacecraft x location relative to the earth

yrel = (re + 300.0) * np.sin(nu)

r0 = [xrel, yrel, 0]

v0 = [vx, vy, 0]

u0 = [xrel, yrel, 0, vx, vy, 0]

def deriv(u, dt):

n1 = -((mue * (u[0] + pi2 * r12) / np.sqrt((u[0] + pi2 * r12) *

+ u[1] ** 2) ** 3)

- (mum * (u[0] - pi1 * r12) / np.sqrt((u[0] - pi1 * r12) *

+ u[1] ** 2) ** 3))

n2 = -((mue * u[1] / np.sqrt((u[0] + pi2 * r12) ** 2 + u[1] ** 2) ** 3)

- (mum * u[1] / np.sqrt((u[0] - pi1 * r12) ** 2 + u[1] ** 2) ** 3))

return [u[3], # dotu[0] = u[3]

u[4], # dotu[1] = u[4]

u[5], # dotu[2] = u[5]

2 * omega * u[5] + omega ** 2 * u[0] + n1, # dotu[3] = that

omega ** 2 * u[1] - 2 * omega * u[4] + n2, # dotu[4] = that

0] # dotu[5] = 0

dt = np.arange(0.0, 320000.0, 1) # 200000 secs to run the simulation

u = odeint(deriv, u0, dt)

x, y, z, x2, y2, z2 = u.T

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

ax.plot(x, y, z)

plt.show()

解决方案

To find the distance along each point in the trajectory:

my_x, my_y, my_z = (384400,0,0)

delta_x = x - my_x

delta_y = y - my_y

delta_z = z - my_z

distance = np.sqrt(np.power(delta_x, 2) +

np.power(delta_y, 2) +

np.power(delta_z, 2))

And then to find the min and that specific distance:

i = np.argmin(distance)

t_min = i / UNITS_SCALE # I can't tell how many units to a second. Is it 1.6?

d_197465 = distance[int(197465 * UNITS_SCALE)]

Not a rocket scientist myself and therefore have not thoroughly examined the items above: x, y, z; x2, y2; z2 = u.T. I assume these variables represent your trajectory's position and velocity.

Not a rocket scientist myself and therefore have not thoroughly examined the items above: x, y, z; x²,y²,z² = uᵀ. I assume these variables represent your trajectory's position and velocity.