def test_convertAngleForm():
vector0 = np.array([90,0,0])
vector1 = AL_BF.convert3dvector(vector0, "cartesian")
print(vector1) # validated
vector0 = np.array([90,90,90])
vector1 = AL_BF.convert3dvector(vector0, "cartesian")
print(vector1) # validated
vector0 = np.array([155, 0.78, 0.61])
vector1 = AL_BF.convert3dvector(vector0, "polar")
print(vector1) # validated
print(np.arcsin(-0.7071067811865475))
vector0 = np.array([-90,-90,-90])
vector1 = AL_BF.convert3dvector(vector0, "cartesian")
print(vector1*AL_BF.rad2deg(1))
def findValidLambert():
SF = CONFIG.SimsFlan_config()
earthephem = pk.planet.jpl_lp('earth')
marsephem = pk.planet.jpl_lp('mars')
counter = 0
valid = False
while valid == False:
decv = np.zeros(len(SF.bnds))
for i in range(6,8):
decv[i] = np.random.uniform(low = SF.bnds[i][0], \
high = SF.bnds[i][1], size = 1)
r_E, v_E = earthephem.eph(decv[6])
r_M, v_M = marsephem.eph(decv[6] + AL_BF.sec2days(decv[7]) )
# Create transfer in the first moment
nrevs = 2
l = pk.lambert_problem(r1 = r_E, r2 = r_M, tof = decv[7], \
cw = False, mu = Cts.mu_S_m, max_revs=nrevs)
v1 = np.array(l.get_v1())
v2 = np.array(l.get_v2())
v_i_prev = 1e12 # Excessive random value
for rev in range(len(v1)):
v_i = np.linalg.norm(v1[rev] - np.array(v_E)) # Relative velocities for the bounds
v_i2 = np.linalg.norm(v2[rev] - np.array(v_M))
# Change to polar for the bounds
if v_i >= SF.bnds[0][0] and v_i <= SF.bnds[0][1] and \
v_i2 >= SF.bnds[3][0] and v_i2 <= SF.bnds[3][1]:
print('decv')
print(v1[rev]-v_E,v2[rev]-v_M)
decv[0:3] = AL_BF.convert3dvector(v1[rev]-v_E, "cartesian")
decv[3:6] = AL_BF.convert3dvector(v2[rev]-v_M, "cartesian")
print(decv[0:6])
valid = True
print('rev', rev, v1[rev], v2[rev])
counter += 1
print(counter)
return decv, l
def propagateSimsFlanaganForward():
"Test the propagation of SimsFlanagan forward using the velocities from Lambert"
### Using ephemeris
# Lambert trajectory obtain terminal velocity vectors
SF = CONFIG.SimsFlan_config()
# Create bodies
sun = AL_2BP.Body('sun', 'yellow', mu = Cts.mu_S_m)
earth = AL_2BP.Body('earth', 'blue', mu = Cts.mu_E_m)
mars = AL_2BP.Body('mars', 'red', mu = Cts.mu_M_m)
# Calculate trajectory of the bodies based on ephem
earthephem = pk.planet.jpl_lp('earth')
marsephem = pk.planet.jpl_lp('mars')
decv, l = findValidLambert()
print(decv)
r_M, v_M = marsephem.eph(decv[6] + AL_BF.sec2days(decv[7]) )
Fit = Propagate(Nimp = SF.Nimp)
Fit.prop(decv, plot = True)
print("Final", Fit.rv_final)
print("Theoretical final", r_M, AL_BF.convert3dvector(decv[3:6], "polar")+v_M)
def test_Exposin():
# Verify with example
print("VERIFICATION")
r1 = 1
r2 = 5
psi = np.pi/2
k2 = 1/4
# eSin = AL_Sh.shapingMethod(sun.mu / Cts.AU_m**3)
# gammaOptim_v = eSin.start(r1, r2, psi, 365*1.5, k2) # verified
# Ni = 1
# print(gammaOptim_v)
# eSin.plot_sphere(r1, r2, psi, gammaOptim_v[Ni], Ni) # verified
# Real life case
sun = AL_2BP.Body('sun', 'yellow', mu = Cts.mu_S_m)
earth = AL_2BP.Body('earth', 'blue', mu = Cts.mu_E_m)
mars = AL_2BP.Body('mars', 'red', mu = Cts.mu_M_m)
# Calculate trajectory of the bodies based on ephem
earthephem = pk.planet.jpl_lp('earth')
marsephem = pk.planet.jpl_lp('mars')
date0 = np.array([27,1,2018,0])
t0 = AL_Eph.DateConv(date0,'calendar') #To JD
t_t = 350
r_E, v_E = earthephem.eph( t0.JD_0 )
r_M, v_M = marsephem.eph(t0.JD_0+ t_t )
r_1 = r_E
r_2 = r_M
r_1_norm = np.linalg.norm( r_1 )
r_2_norm = np.linalg.norm( r_2 )
dot = np.dot(r_1[0:2], r_2[0:2]) # dot product between [x1, y1] and [x2, y2]
det = r_1[0]*r_2[1] - r_2[0]*r_1[1] # determinant
psi = np.arctan2(det, dot)
psi = AL_BF.convertRange(psi, 'rad', 0 ,2*np.pi)
k2 = 1/12
eSin = AL_Sh.shapingMethod(sun.mu / AL_BF.AU**3)
gammaOptim_v = eSin.calculategamma1(r_1_norm / AL_BF.AU, r_2_norm / AL_BF.AU, psi, \
t_t, k2, plot = False)
Ni = 1
eSin.calculateExposin(Ni, gammaOptim_v[Ni],r_1_norm / AL_BF.AU, r_2_norm / AL_BF.AU, psi )
eSin.plot_sphere(r_1_norm / AL_BF.AU, r_2_norm / AL_BF.AU, psi)
v1, v2 = eSin.terminalVel(r_1_norm / AL_BF.AU, r_2_norm / AL_BF.AU, psi)
t, a_T = eSin.calculateThrustProfile(r_1_norm / AL_BF.AU, r_2_norm / AL_BF.AU, psi)
# print('a', a_T*AL_BF.AU)
print("body coord", v1, v2)
# print(v1[0]*Cts.AU_m, v1[1], v2[0]*Cts.AU_m, v2[1])
# To heliocentric coordinates (2d approximation)
def to_helioc(r, vx, vy):
v_body = np.array([vx, vy, 0])
# Convert to heliocentric
angle = np.arctan2(r[1], r[0])
v_h = AL_BF.rot_matrix(v_body, angle, 'z')
return v_h
v_1 = to_helioc(r_1, v1[0]*AL_BF.AU, v1[1]*AL_BF.AU)
v_2 = to_helioc(r_2, v2[0]*AL_BF.AU, v2[1]*AL_BF.AU)
# def to_helioc(r, v, gamma):
# v_body = np.array([v*np.sin(gamma), \
# v*np.cos(gamma),\
# 0])
# # Convert to heliocentric
# angle = np.arctan2(r[1], r[0])
# v_h = AL_BF.rot_matrix(v_body, angle, 'z')
# return v_h
# v_1 = to_helioc(r_1, v1[0]*Cts.AU_m, v1[1])
# v_2 = to_helioc(r_2, v2[0]*Cts.AU_m, v2[1])
print("Helioc vel", v_1, v_2)
print("with respect to body ", v_1-v_E, v_2-v_M)
v_1_E = np.linalg.norm(v_1-v_E)
v_2_M = np.linalg.norm(v_2-v_M)
print("Final vel", v_1_E, v_2_M)
################################################3
# Propagate with terminal velocity vectors
SF = CONFIG.SimsFlan_config()
Fit = Fitness(Nimp = SF.Nimp)
decv = np.zeros(len(SF.bnds))
decv[6] = t0.JD_0
decv[7] = AL_BF.days2sec(t_t)
decv[0:3] = AL_BF.convert3dvector(v_1-v_E,'cartesian')
decv[3:6] = AL_BF.convert3dvector(v_2- v_M,'cartesian')
print('decv', decv[0:9])
for i in range(SF.Nimp):
# Acceleration on segment is average of extreme accelerations
t_i = AL_BF.days2sec(t_t) / (SF.Nimp+1) *i
t_i1 = AL_BF.days2sec(t_t) / (SF.Nimp+1) *(i+1)
#find acceleration at a certain time
a_i = eSin.accelerationAtTime(t_i)
a_i1 = eSin.accelerationAtTime(t_i1)
a = (a_i+a_i1)/2 # find the acceleration at a certain time
print("a", a_i, a_i1, a)
deltav_i = AL_BF.days2sec(t_t) / (SF.Nimp+1) * a*AL_BF.AU
print(deltav_i)
decv[8+3*i] = deltav_i /100
decv[8+3*i+1] = 0
decv[8+3*i+2] = 0
Fit.calculateFeasibility(decv, plot = True, thrust = 'tangential')
Fit.printResult()
def adaptDecisionVector(self, DecV, optMode=True):
"""
adaptDecisionVector: modify decision vector to input in the problem
"""
self.DecV = DecV
v0 = np.array(DecV[0:3]) # vector, [magnitude, angle, angle]
vf = np.array(DecV[3:6]) # vector, [magnitude, angle, angle]
self.t0, self.t_t = DecV[6:8]
# Delta V
if optMode == True:
DeltaV_list = np.array(DecV[8:]).reshape(
-1, 3) # make a Nimp x 3 matrix
else:
DeltaV_list = DecV[8:][0]
########################################################################
# INITIAL CALCULATION OF VARIABLES
########################################################################
# Modify from magnitude angle angle to cartesian
self.DeltaV_list = np.zeros(np.shape(DeltaV_list))
DeltaV_sum = np.zeros(len(
self.DeltaV_list)) # Magnitude of the impulses
for i in range(len(self.DeltaV_list)):
self.DeltaV_list[i, :] = AL_BF.convert3dvector(
DeltaV_list[i, :], "polar")
DeltaV_sum[i] = np.linalg.norm(self.DeltaV_list[i])
# Write velocity as x,y,z vector
v0_cart = AL_BF.convert3dvector(v0, "polar")
vf_cart = AL_BF.convert3dvector(vf, "polar")
# Sum of all the Delta V = DeltaV max * sum Delta V_list
# Assumption: the DeltaV_max is calculated as if mass is constant and
# equal to the dry mass as it is the largest contribution. This means
# that the DelaV_max is actually smaller than it will be obtained in this
# problem
# = Thrust for segment
self.DeltaV_max = self.Spacecraft.T / self.Spacecraft.m_dry * \
self.t_t / (self.Nimp + 1)
# Total DeltaV
DeltaV_total = sum(DeltaV_sum) * self.DeltaV_max
#Calculate total mass of fuel for the given impulses
self.m0 = \
self.Spacecraft.MassChangeInverse(self.Spacecraft.m_dry, DeltaV_total)
self.m_fuel = self.m0 - self.Spacecraft.m_dry
# Times and ephemeris
# t_0 = AL_Eph.DateConv(self.date0,'calendar') #To JD
self.t_1 = AL_Eph.DateConv(self.t0 + AL_BF.sec2days(self.t_t), 'JD_0')
self.r_p0, self.v_p0 = self.departureephem.eph(self.t0)
self.r_p1, self.v_p1 = self.arrivalephem.eph(self.t_1.JD_0)
# Change from relative to heliocentric velocity
self.v0 = v0_cart + self.v_p0
self.vf = vf_cart + self.v_p1
# Create state vector for initial and final point
self.SV_0 = np.append(self.r_p0, self.v0)
self.SV_f = np.append(self.r_p1, self.vf) # - to propagate backwards
self.SV_f_corrected = np.append(self.r_p1,
-self.vf) # - to propagate backwards