def run_example2(): import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, DAY2SEC, planet_ss, AU, MU_SUN, lambert_problem from PyKEP.orbit_plots import plot_planet, plot_lambert mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') t1 = epoch(0) t2 = epoch(640) dt = (t2.mjd2000 - t1.mjd2000) * DAY2SEC ax.scatter([0], [0], [0], color='y') pl = planet_ss('earth') plot_planet(ax, pl, t0=t1, color=(0.8, 0.8, 1), legend=True, units=AU) rE, vE = pl.eph(t1) pl = planet_ss('mars') plot_planet(ax, pl, t0=t2, color=(0.8, 0.8, 1), legend=True, units=AU) rM, vM = pl.eph(t2) l = lambert_problem(rE, rM, dt, MU_SUN) plot_lambert(ax, l, color='b', legend=True, units=AU) plot_lambert(ax, l, sol=1, color='g', legend=True, units=AU) plot_lambert(ax, l, sol=2, color='g', legend=True, units=AU) plt.show()
def plot_orbits(self, pop, ax=None): import matplotlib.pylab as plt from mpl_toolkits.mplot3d import Axes3D A1, A2 = self._ast1, self._ast2 if ax is None: fig = plt.figure() axis = fig.add_subplot(111, projection='3d') else: axis = ax plot_planet(A1, ax=axis, s=10, t0=epoch(self.lb[0])) plot_planet(A2, ax=axis, s=10, t0=epoch(self.ub[0])) for ind in pop: if ind.cur_f[0] == self._UNFEASIBLE: continue dep, arr = ind.cur_x rdep, vdep = A1.eph(epoch(dep)) rarr, varr = A2.eph(epoch(arr)) l = lambert_problem(rdep, rarr, (arr - dep) * DAY2SEC, A1.mu_central_body, False, 1) axis = plot_lambert(l, ax=axis, alpha=0.8, color='k') if ax is None: plt.show() return axis
def plot(self, x): import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg # Making sure the leg corresponds to the requested chromosome self._compute_constraints_impl(x) start = epoch(x[0]) end = epoch(x[0] + x[1]) # Plotting commands fig = plt.figure() axis = fig.gca(projection='3d') # The Sun axis.scatter([0], [0], [0], color='y') # The leg plot_sf_leg(self.__leg, units=AU, N=10, ax=axis) # The planets plot_planet( self.__earth, start, units=AU, legend=True, color=(0.8, 0.8, 1), ax = axis) plot_planet( self.__mars, end, units=AU, legend=True, color=(0.8, 0.8, 1), ax = axis) plt.show()
def plot(self,x): import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_sf_leg mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') ax.scatter(0,0,0, color='y') # 1 - We decode the chromosome extracting the time of flights T = list([0]*(self.__n_legs)) for i in range(self.__n_legs): T[i] = x[2+i*8] #2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs+1)) r_P = list([None] * (self.__n_legs+1)) v_P = list([None] * (self.__n_legs+1)) for i,planet in enumerate(self.seq): t_P[i+1] = epoch(self.tf - sum(T[i+1:])) r_P[i+1],v_P[i+1] = self.seq[i].eph(t_P[i+1]) plot_planet(ax, self.seq[i], t_P[i+1], units=JR, legend = True,color='k') #And we insert a fake planet simulating the starting position t_P[0] = epoch(self.tf - sum(T)) theta = x[0] phi = x[1] r = [cos(phi)*sin(theta), cos(phi)*cos(theta), sin(phi)] #phi close to zero is in the moon orbit plane injection r = [JR*1000*d for d in r] r_P[0] = r v_P[0] = x[4:7] #3 - We iterate through legs to compute mismatches and throttles constraints ceq = list() cineq = list() m0 = self.__sc.mass for i in range(self.__n_legs): if i!=0: #First Leg v = [a+b for a,b in zip(v_P[i],x[(4 + i * 8):(7 + i * 8)])] else: v = v_P[i] x0 = sc_state(r_P[i],v,m0) v = [a+b for a,b in zip(v_P[i+1],x[(7 + i * 8):(10 + i * 8)])] if (i==self.__n_legs-1): #Last leg v = [a+b for a,b in zip(v_P[i+1],self.vf)] xe = sc_state(r_P[i+1], v ,x[3+8*i]) throttles = x[(8*self.__n_legs-1 + 3*sum(self.__n_seg[:i])):(8*self.__n_legs-1 + 3*sum(self.__n_seg[:i])+3*self.__n_seg[i])] self.__leg.set(t_P[i],x0,throttles,t_P[i+1],xe) plot_sf_leg(ax, self.__leg, units=JR,N=50) #update mass! m0 = x[3+8*i] ceq.extend(self.__leg.mismatch_constraints()) cineq.extend(self.__leg.throttles_constraints()) #raise Exception plt.show() return ax
def opt_dt(tt1, tt2): t1 = epoch(tt1) t2 = epoch(tt2) dt = (t2.mjd2000 - t1.mjd2000) * DAY2SEC rE, vE = plEarth.eph(t1) vE = array(vE) rM, vM = plMars.eph(t2) vM = array(vM) l = lambert_problem(rE, rM, dt, MU_SUN) vEl = array(l.get_v1()[0]) dvE = (vEl - vE) vMl = array(l.get_v2()[0]) dvM = (vMl - vM) ''' print "" print " detlal-V at Earth: " print " Earth: ",vE print " Ship: ",vEl print " delta ", dvE, linalg.norm(dvE) print "" print " detlal-V at Mars : " print " Mars: ", vM print " Ship: ", vMl dvM = (vM - vMl) print " delta ", dvM, linalg.norm(dvM) print " total delta-v ", linalg.norm(dvM)+linalg.norm(dvE) ''' print " dt ", (tt2 - tt1), " dv ", linalg.norm(dvM) + linalg.norm(dvE) plot_planet(ax, plMars, t0=t2, color=(0.8, 0.8, 1), units=AU) plot_lambert(ax, l, color=(1, 0, 0), units=AU)
def plot(self, ax=None, clusters=None, orbits=False, only_core=False): """Plots the clusters.""" if self.n_clusters < 1: return import matplotlib.pylab as plt from mpl_toolkits.mplot3d import Axes3D if ax is None: fig = plt.figure() axis = fig.add_subplot(111, projection='3d') else: axis = ax axis.view_init(elev=30.0, azim=135.0) axis.set_aspect('equal') if orbits: from PyKEP.orbit_plots import plot_planet members = self.core_members if only_core else self.members for label in members if clusters is None else clusters: for planet in members[label]: plot_planet( self._asteroids[planet], t0=self._epoch, s=0, ax=axis) X, labels = list(zip(*[(x, label) for (x, label) in zip(self._X, self.labels) if label > -.5 and (clusters is None or label in clusters)])) data = [[x[0], x[1], x[2]] for x in X] axis.scatter(*list(zip(*data)), c=labels, alpha=0.5) self._axis_equal_3d(axis) if ax is None: plt.show() return axis
def plot(self, ax=None, clusters=None, orbits=False, only_core=False): """Plots the clusters.""" if self.n_clusters < 1: return import matplotlib.pylab as plt from mpl_toolkits.mplot3d import Axes3D if ax is None: fig = plt.figure() axis = fig.add_subplot(111, projection='3d') else: axis = ax axis.view_init(elev=30.0, azim=135.0) axis.set_aspect('equal') if orbits: from PyKEP.orbit_plots import plot_planet members = self.core_members if only_core else self.members for label in members if clusters is None else clusters: for planet in members[label]: plot_planet(self._asteroids[planet], t0=self._epoch, s=0, ax=axis) X, labels = zip(*[(x, label) for (x, label) in zip(self._X, self.labels) if label > -.5 and (clusters is None or label in clusters)]) data = [[x[0], x[1], x[2]] for x in X] axis.scatter(*zip(*data), c=labels) self._axis_equal_3d(axis) if ax is None: plt.show()
def opt_dt(tt1, tt2): t1 = epoch(tt1) t2 = epoch(tt2) dt = (t2.mjd2000 - t1.mjd2000) * DAY2SEC rE, vE = plEarth.eph(t1) vE = array(vE) rM, vM = plMars.eph(t2) vM = array(vM) l = lambert_problem(rE, rM, dt, MU_SUN) vEl = array(l.get_v1()[0]) dvE = vEl - vE vMl = array(l.get_v2()[0]) dvM = vMl - vM """ print "" print " detlal-V at Earth: " print " Earth: ",vE print " Ship: ",vEl print " delta ", dvE, linalg.norm(dvE) print "" print " detlal-V at Mars : " print " Mars: ", vM print " Ship: ", vMl dvM = (vM - vMl) print " delta ", dvM, linalg.norm(dvM) print " total delta-v ", linalg.norm(dvM)+linalg.norm(dvE) """ print " dt ", (tt2 - tt1), " dv ", linalg.norm(dvM) + linalg.norm(dvE) plot_planet(ax, plMars, t0=t2, color=(0.8, 0.8, 1), units=AU) plot_lambert(ax, l, color=(1, 0, 0), units=AU)
def plot(self,x): import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg start = epoch(x[0]) end = epoch(x[0] + x[1]) r,v = self.__earth.eph(start) v = [a+b for a,b in zip(v,x[3:6])] x0 = sc_state(r,v,self.__sc.mass) r,v = self.__mars.eph(end) xe = sc_state(r, v ,x[2]) self.__leg.set(start,x0,x[-3 * self.__nseg:],end,xe) fig = plt.figure() ax = fig.gca(projection='3d') #The Sun ax.scatter([0],[0],[0], color='y') #The leg plot_sf_leg(ax, self.__leg, units=AU,N=10) #The planets plot_planet(ax, self.__earth, start, units=AU, legend = True,color=(0.8,0.8,1)) plot_planet(ax, self.__mars, end, units=AU, legend = True,color=(0.8,0.8,1)) plt.show()
def plot(self,x): import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU, DAY2SEC from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg start = epoch(x[0]) end = epoch(x[0] + x[1]) r,v = self.__earth.eph(start) v = [a+b for a,b in zip(v,x[4:7])] x0 = sc_state(r,v,self.__sc.mass) r,v = self.__mars.eph(end) xe = sc_state(r, v ,x[3]) self.__leg.set(start,x0,x[-3 * self.__nseg:],end,xe, x[2] * DAY2SEC) fig = plt.figure() axis = fig.gca(projection='3d') #The Sun axis.scatter([0],[0],[0], color='y') #The leg plot_sf_leg(self.__leg, units=AU,N=10, ax = axis) #The planets plot_planet(self.__earth, start, units=AU, legend = True,color=(0.8,0.8,1), ax = axis) plot_planet(self.__mars, end, units=AU, legend = True,color=(0.8,0.8,1), ax = axis) plt.show()
def run_example2(): import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, DAY2SEC, planet_ss, AU, MU_SUN, lambert_problem from PyKEP.orbit_plots import plot_planet, plot_lambert mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') t1 = epoch(0) t2 = epoch(640) dt = (t2.mjd2000 - t1.mjd2000) * DAY2SEC ax.scatter([0],[0],[0], color='y') pl = planet_ss('earth') plot_planet(ax,pl, t0=t1, color=(0.8,0.8,1), legend=True, units = AU) rE,vE = pl.eph(t1) pl = planet_ss('mars') plot_planet(ax,pl, t0=t2, color=(0.8,0.8,1), legend=True, units = AU) rM, vM = pl.eph(t2) l = lambert_problem(rE,rM,dt,MU_SUN) plot_lambert(ax,l, color='b', legend=True, units = AU) plot_lambert(ax,l,sol=1, color='g', legend=True, units = AU) plot_lambert(ax,l,sol=2, color='g', legend=True, units = AU) plt.show()
def plot(self,x): """ Plots the trajectory represented by the decision vector x Example:: prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg fig = plt.figure() ax = fig.gca(projection='3d') #Plotting the Sun ........ ax.scatter([0],[0],[0], color='y') #Plotting the legs ....... # 1 - We decode the chromosome extracting the time of flights T = list([0]*(self.__n_legs)) for i in range(self.__n_legs): T[i] = x[1+i*8] #2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs+1)) r_P = list([None] * (self.__n_legs+1)) v_P = list([None] * (self.__n_legs+1)) for i,planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i],v_P[i] = self.seq[i].eph(t_P[i]) #3 - We iterate through legs to compute mismatches and throttles constraints ceq = list() cineq = list() m0 = self.__sc.mass for i in range(self.__n_legs): #First Leg v = [a+b for a,b in zip(v_P[i],x[(3 + i * 8):(6 + i * 8)])] x0 = sc_state(r_P[i],v,m0) v = [a+b for a,b in zip(v_P[i+1],x[(6 + i * 8):(11 + i * 8)])] xe = sc_state(r_P[i+1], v ,x[2 + i * 8]) throttles = x[(1 +8 * self.__n_legs + 3*sum(self.__n_seg[:i])):(1 +8 * self.__n_legs + 3*sum(self.__n_seg[:i])+3*self.__n_seg[i])] self.__leg.set(t_P[i],x0,throttles,t_P[i+1],xe) #update mass! m0 = x[2+8*i] plot_sf_leg(ax, self.__leg, units=AU,N=10) #Plotting planets for i,planet in enumerate(self.seq): plot_planet(ax, planet, t_P[i], units=AU, legend = True,color=(0.7,0.7,1)) plt.show()
def _mga_part_plot(self, x): """ Plots the trajectory represented by the decision vector x Example:: prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler from PyKEP import epoch, propagate_lagrangian, lambert_problem, fb_prop, AU, MU_SUN, DAY2SEC from math import pi, acos, cos, sin from scipy.linalg import norm mpl.rcParams["legend.fontsize"] = 10 fig = plt.figure() ax = fig.gca(projection="3d", aspect="equal") ax.scatter(0, 0, 0, color="y") JR = 71492000.0 legs = len(x) / 4 seq = self.get_sequence() common_mu = seq[0].mu_central_body start_mjd2000 = self.t0.mjd2000 # 1 - we 'decode' the chromosome recording the various times of flight (days) in the list T T = x[3::4] # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (legs + 1)) r_P = list([None] * (legs + 1)) v_P = list([None] * (legs + 1)) for i, planet in enumerate(seq): t_P[i] = epoch(start_mjd2000 + sum(T[:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(ax, planet, t0=t_P[i], color=(0.8, 0.6, 0.8), legend=True, units=JR) v_end_l = [a + b for a, b in zip(v_P[0], self.vinf_in)] # 4 - And we iterate on the legs for i in xrange(0, legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[1 + 4 * i] * seq[i - 1].radius, x[4 * i], seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu) plot_kepler( ax, r_P[i], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu, N=500, color="b", legend=False, units=JR ) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[4 * i + 2]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, common_mu, False, False) plot_lambert(ax, l, sol=0, color="r", legend=False, units=JR, N=500) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] plt.show() return ax
def plot(self, x, ax=None): """ ax = prob.plot(x, ax=None) - x: encoded trajectory - ax: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg # Creating the axis if necessary if ax is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') else: axis = ax # Plotting the Sun ........ axis.scatter([0], [0], [0], color='y') # Computing the legs self._compute_constraints_impl(x) # Plotting the legs for leg in self.__legs: plot_sf_leg(leg, units=AU, N=10, ax=axis) # Plotting the PyKEP.planets both at departure and arrival dates for i in range(self.__num_legs): idx = i * self.__dim_leg plot_planet(self.__seq[i], epoch(x[idx]), units=AU, legend=True, color=(0.7, 0.7, 1), s=30, ax=axis) plot_planet(self.__seq[i + 1], epoch(x[idx] + x[idx + 1]), units=AU, legend=False, color=(0.7, 0.7, 1), s=30, ax=axis) plt.show() return axis
def _mga_1dsm_tof_plot(self, x): """ Plots the trajectory represented by the decision vector x """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler from PyKEP import epoch, propagate_lagrangian, lambert_problem, fb_prop, AU, MU_SUN, DAY2SEC from math import pi, acos, cos, sin from scipy.linalg import norm mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') ax.scatter(0, 0, 0, color='y') seq = self.get_sequence() # 2 - We plot the first leg r_P0, v_P0 = seq[0].eph(epoch(x[0])) plot_planet(ax, seq[0], t0=epoch(x[0]), color=(0.8, 0.6, 0.8), legend=True, units=AU) r_P1, v_P1 = seq[1].eph(epoch(x[0] + x[5])) theta = 2 * pi * x[1] phi = acos(2 * x[2] - 1) - pi / 2 Vinfx = x[3] * cos(phi) * cos(theta) Vinfy = x[3] * cos(phi) * sin(theta) Vinfz = x[3] * sin(phi) v0 = [a + b for a, b in zip(v_P0, [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian(r_P0, v0, x[4] * x[5] * DAY2SEC, seq[0].mu_central_body) plot_kepler(ax, r_P0, v0, x[4] * x[5] * DAY2SEC, seq[0].mu_central_body, N=100, color='b', legend=False, units=AU) # Lambert arc to reach seq[1] dt = (1 - x[4]) * x[5] * DAY2SEC l = lambert_problem(r, r_P1, dt, seq[0].mu_central_body) plot_lambert(ax, l, sol=0, color='r', legend=False, units=AU) v_end_l = l.get_v2()[0] vinf_in = [a - b for a, b in zip(v_end_l, v_P1)] _part_plot(x[6:], AU, ax, seq[1:], x[0] + x[5], vinf_in) return ax
def _mga_1dsm_tof_plot(self, x): """ Plots the trajectory represented by the decision vector x """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler from PyKEP import epoch, propagate_lagrangian, lambert_problem, fb_prop, AU, MU_SUN, DAY2SEC from math import pi, acos, cos, sin from scipy.linalg import norm mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') ax.scatter(0, 0, 0, color='y') seq = self.get_sequence() # 2 - We plot the first leg r_P0, v_P0 = seq[0].eph(epoch(x[0])) plot_planet(ax, seq[0], t0=epoch(x[0]), color=( 0.8, 0.6, 0.8), legend=True, units = AU) r_P1, v_P1 = seq[1].eph(epoch(x[0] + x[5])) theta = 2 * pi * x[1] phi = acos(2 * x[2] - 1) - pi / 2 Vinfx = x[3] * cos(phi) * cos(theta) Vinfy = x[3] * cos(phi) * sin(theta) Vinfz = x[3] * sin(phi) v0 = [a + b for a, b in zip(v_P0, [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian( r_P0, v0, x[4] * x[5] * DAY2SEC, seq[0].mu_central_body) plot_kepler( ax, r_P0, v0, x[4] * x[5] * DAY2SEC, seq[0].mu_central_body, N=100, color='b', legend=False, units=AU) # Lambert arc to reach seq[1] dt = (1 - x[4]) * x[5] * DAY2SEC l = lambert_problem(r, r_P1, dt, seq[0].mu_central_body) plot_lambert(ax, l, sol=0, color='r', legend=False, units=AU) v_end_l = l.get_v2()[0] vinf_in = [a - b for a, b in zip(v_end_l, v_P1)] _part_plot(x[6:], AU, ax, seq[1:], x[0] + x[5], vinf_in) return ax
def _part_plot(x, units, ax, seq, start_mjd2000, vinf_in): """ Plots the trajectory represented by a decision vector x = [beta,rp,eta,T] * N associated to a sequence seq, a start_mjd2000 and an incoming vinf_in """ from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler from PyKEP import epoch, propagate_lagrangian, lambert_problem, fb_prop, AU, MU_SUN, DAY2SEC from math import pi, acos, cos, sin from scipy.linalg import norm legs = len(x) / 4 common_mu = seq[0].mu_central_body # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T T = x[3::4] # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (legs + 1)) r_P = list([None] * (legs + 1)) v_P = list([None] * (legs + 1)) for i, planet in enumerate(seq): t_P[i] = epoch(start_mjd2000 + sum(T[:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(ax, planet, t0=t_P[i], color=(0.8, 0.6, 0.8), legend=True, units=units) v_end_l = [a + b for a, b in zip(v_P[0], vinf_in)] # 4 - And we iterate on the legs for i in range(0, legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[1 + 4 * i] * seq[i].radius, x[4 * i], seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu) plot_kepler(ax, r_P[i], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu, N=500, color='b', legend=False, units=units) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[4 * i + 2]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, common_mu, False, False) plot_lambert(ax, l, sol=0, color='r', legend=False, units=units, N=500) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0]
def plot_initial_geometry(ni=0.0, mu=0.5): """ Visualizes the initial spaceraft conditions for the gtoc6 problem. Given a point on the initial spheres, \ it assumes a velocity (almost) pointing toward Jupiter. THIS IS ONLY A VISUALIZATION, the initial velocityshould not be taken as realistic. """ from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from math import sin,cos,acos,pi from PyKEP.orbit_plots import plot_kepler, plot_planet from PyKEP import DAY2SEC, propagate_lagrangian, epoch from scipy.linalg import norm ep=epoch(0.0) days=300.0 r = [JR*1000*cos(ni)*cos(mu), JR*1000*cos(ni)*sin(mu),JR*1000*sin(ni)] VINF = 3400.0 v = [-d/norm(r)*3400 for d in r] v = [d+200 for d in v] fig = plt.figure() ax = fig.gca(projection='3d', aspect='equal') plot_planet(ax,io,color = 'r', units = JR, t0 = ep, legend=True) plot_planet(ax,europa,color = 'b', units = JR, t0 = ep, legend=True) plot_planet(ax,ganymede,color = 'k', units = JR, t0 = ep, legend=True) plot_planet(ax,callisto,color = 'y', units = JR, t0 = ep, legend=True) plot_kepler(ax,r,v,days*DAY2SEC,MU_JUPITER, N=200, units = JR, color = 'b') plt.plot([r[0]/JR],[r[1]/JR],[r[2]/JR],'o') plt.show()
def _part_plot(x, units, axis, seq, start_mjd2000, vinf_in): """ Plots the trajectory represented by a decision vector x = [beta,rp,eta,T] * N associated to a sequence seq, a start_mjd2000 and an incoming vinf_in """ from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler from PyKEP import epoch, propagate_lagrangian, lambert_problem, fb_prop, AU, MU_SUN, DAY2SEC from math import pi, acos, cos, sin from scipy.linalg import norm legs = len(x) // 4 common_mu = seq[0].mu_central_body # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T T = x[3::4] # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (legs + 1)) r_P = list([None] * (legs + 1)) v_P = list([None] * (legs + 1)) for i, planet in enumerate(seq): t_P[i] = epoch(start_mjd2000 + sum(T[:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(planet, t0=t_P[i], color=( 0.8, 0.6, 0.8), legend=True, units = units, ax=axis) v_end_l = [a + b for a, b in zip(v_P[0], vinf_in)] # 4 - And we iterate on the legs for i in range(0, legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[1 + 4 * i] * seq[i].radius, x[4 * i], seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian( r_P[i], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu) plot_kepler(r_P[i], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu, N=500, color='b', legend=False, units=units, ax=axis) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[4 * i + 2]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, common_mu, False, False) plot_lambert( l, sol=0, color='r', legend=False, units=units, N=500, ax=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0]
def plot(self, x): # Making sure the leg corresponds to the requested chromosome self._compute_constraints_impl(x) start = epoch(x[0]) end = epoch(x[0] + x[1]) # Plotting commands fig = plt.figure() axis = fig.gca(projection='3d') # The Sun axis.scatter([0], [0], [0], color='y') # The leg plot_sf_leg(self.leg, units=AU, N=10, ax=axis) # The planets plot_planet( self.earth, start, units=AU, legend=True, color=(0.8, 0.8, 1), ax = axis) plot_planet( self.mars, end, units=AU, legend=True, color=(0.8, 0.8, 1), ax = axis) plt.show()
def plot(self, x): import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg # Creating the axis ........ fig = plt.figure() axis = fig.gca(projection='3d') # Plotting the Sun ........ axis.scatter([0], [0], [0], color='y') # Computing the legs self._compute_constraints_impl(x) # Plotting the legs for leg in self.__legs: plot_sf_leg(leg, units=AU, N=10, ax=axis) # Plotting the PyKEP.planets both at departure and arrival dates for i in range(self.__num_legs): idx = i * self.__dim_leg plot_planet(self.__seq[i], epoch(x[idx]), units=AU, legend=True, color=(0.7, 0.7, 1), s=30, ax=axis) plot_planet(self.__seq[i + 1], epoch(x[idx] + x[idx + 1]), units=AU, legend=False, color=(0.7, 0.7, 1), s=30, ax=axis) plt.show() return axis
def plot(self, x): import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg t_E = epoch(x[0]) t_V = epoch(x[0] + x[1]) t_M = epoch(x[0] + x[1] + x[9]) rE, vE = self.__earth.eph(t_E) rV, vV = self.__venus.eph(t_V) rM, vM = self.__mercury.eph(t_M) #First Leg v = [a + b for a, b in zip(vE, x[3:6])] x0 = sc_state(rE, v, self.__sc.mass) v = [a + b for a, b in zip(vV, x[6:9])] xe = sc_state(rV, v, x[2]) self.__leg1.set( t_E, x0, x[-3 * (self.__nseg1 + self.__nseg2):-self.__nseg2 * 3], t_V, xe) #Second leg v = [a + b for a, b in zip(vV, x[11:14])] x0 = sc_state(rV, v, x[2]) v = [a + b for a, b in zip(vM, x[14:17])] xe = sc_state(rM, v, x[10]) self.__leg2.set(t_E, x0, x[(-3 * self.__nseg2):], t_V, xe) fig = plt.figure() axis = fig.gca(projection='3d') #The Sun axis.scatter([0], [0], [0], color='y') #The legs plot_sf_leg(self.__leg1, units=AU, N=10, ax=axis) plot_sf_leg(self.__leg2, units=AU, N=10, ax=axis) #The planets plot_planet(self.__earth, t_E, units=AU, legend=True, color=(0.7, 0.7, 1), ax=axis) plot_planet(self.__venus, t_V, units=AU, legend=True, color=(0.7, 0.7, 1), ax=axis) plot_planet(self.__mercury, t_M, units=AU, legend=True, color=(0.7, 0.7, 1), ax=axis) plt.show()
def _pl2pl_fixed_time_plot(self, x): from PyGMO import problem, algorithm, population from PyKEP import sims_flanagan, AU from PyKEP.orbit_plots import plot_planet, plot_sf_leg from PyKEP import phasing import matplotlib.pyplot as plt import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D fig = plt.figure() ax = fig.gca(projection='3d') ax.scatter(0, 0, 0, color='y') ast1, ast2 = self.get_sequence() leg = self.get_leg() t_i = self.get_t0() t_f = self.get_t1() # Get initial sc state sc = leg.get_spacecraft() r, v = ast1.eph(t_i) xi = sims_flanagan.sc_state(r, v, sc.mass) # Get final sc state r, v = ast2.eph(t_f) xf = sims_flanagan.sc_state(r, v, x[0]) # Update leg with final sc state and throttles leg.set(t_i, xi, x[1:], t_f, xf) # Plot asteroid orbits plot_planet(ast1, t0=t_i, color=(0.8, 0.6, 0.4), legend=True, units=AU, ax=ax) plot_planet(ast2, t0=t_f, color=(0.8, 0.6, 0.8), legend=True, units=AU, ax=ax) # Plot Sims-Flanagan leg plot_sf_leg(leg, units=AU, N=50, ax=ax) return ax
def plot_cluster_evolution(self, cluster_id=None, only_core=False, epochs=range(7500, 8400, 100), skip=100, alpha=0.3): """ Plots a cluster evolution at 9 prefixed epochs. """ if self.n_clusters < 1: print("No clusters have been found yet") return if cluster_id >= self.n_clusters or cluster_id < 0: print( "cluster_id should be larger then 0 and smaller than the number of clusters (-1)" ) return if len(epochs) != 9: print( "The epochs requested must be exactly 9 as to assemble 3x3 subplots" ) return import matplotlib.pylab as plt from mpl_toolkits.mplot3d import Axes3D from PyKEP.orbit_plots import plot_planet from PyKEP import epoch if only_core: ids = self.core_members[cluster_id] else: ids = self.members[cluster_id] fig = plt.figure() for i, ep in enumerate(epochs): axis = fig.add_subplot(3, 3, i + 1, projection='3d') plt.axis('off') plt.title(epoch(ep).__repr__()[:11]) for pl in self._asteroids[::skip]: axis = plot_planet(pl, ax=axis, alpha=0.05, s=0) for cluster_member in ids: r, v = self._asteroids[cluster_member].eph(epoch(ep)) axis.scatter([r[0]], [r[1]], [r[2]], marker='o', alpha=alpha) plt.draw() plt.show() return fig
def plot_initial_geometry(ni=0.0, mu=0.5): """ Visualizes the initial spaceraft conditions for the gtoc6 problem. Given a point on the initial spheres, \ it assumes a velocity (almost) pointing toward Jupiter. THIS IS ONLY A VISUALIZATION, the initial velocityshould not be taken as realistic. """ from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from math import sin, cos, acos, pi from PyKEP.orbit_plots import plot_kepler, plot_planet from PyKEP import DAY2SEC, propagate_lagrangian, epoch from scipy.linalg import norm ep = epoch(0.0) days = 300.0 r = [ JR * 1000 * cos(ni) * cos(mu), JR * 1000 * cos(ni) * sin(mu), JR * 1000 * sin(ni) ] VINF = 3400.0 v = [-d / norm(r) * 3400 for d in r] v = [d + 200 for d in v] fig = plt.figure() ax = fig.gca(projection='3d', aspect='equal') plot_planet(ax, io, color='r', units=JR, t0=ep, legend=True) plot_planet(ax, europa, color='b', units=JR, t0=ep, legend=True) plot_planet(ax, ganymede, color='k', units=JR, t0=ep, legend=True) plot_planet(ax, callisto, color='y', units=JR, t0=ep, legend=True) plot_kepler(ax, r, v, days * DAY2SEC, MU_JUPITER, N=200, units=JR, color='b') plt.plot([r[0] / JR], [r[1] / JR], [r[2] / JR], 'o') plt.show()
def plot_moons(epoch=epoch(0)): """ Plots the Galilean Moons of Jupiter at epoch USAGE: plot_moons(epoch = epoch(34654, epoch.epoch_type.MJD)): * epoch: the epoch one wants the galilean moons to be plotted at """ from PyKEP.orbit_plots import plot_planet from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt fig = plt.figure() ax = fig.gca(projection='3d') plot_planet(ax, io, color='r', units=JR, t0=epoch, legend=True) plot_planet(ax, europa, color='b', units=JR, t0=epoch, legend=True) plot_planet(ax, ganymede, color='k', units=JR, t0=epoch, legend=True) plot_planet(ax, callisto, color='y', units=JR, t0=epoch, legend=True) plt.show()
def plot_moons(epoch = epoch(0)): """ Plots the Galilean Moons of Jupiter at epoch USAGE: plot_moons(epoch = epoch(34654, epoch.epoch_type.MJD)): * epoch: the epoch one wants the galilean moons to be plotted at """ from PyKEP.orbit_plots import plot_planet from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt fig = plt.figure() ax = fig.gca(projection='3d') plot_planet(ax,io,color = 'r', units = JR, t0 = epoch, legend=True) plot_planet(ax,europa,color = 'b', units = JR, t0 = epoch, legend=True) plot_planet(ax,ganymede,color = 'k', units = JR, t0 = epoch, legend=True) plot_planet(ax,callisto,color = 'y', units = JR, t0 = epoch, legend=True) plt.show()
def plot_cluster_evolution(self, cluster_id=None, only_core=False, epochs=range(7500, 8400, 100), skip=100, alpha=0.3): """ Plots a cluster evolution at 9 prefixed epochs. """ if self.n_clusters < 1: print("No clusters have been found yet") return if cluster_id >= self.n_clusters or cluster_id < 0: print("cluster_id should be larger then 0 and smaller than the number of clusters (-1)") return if len(epochs) != 9: print("The epochs requested must be exactly 9 as to assemble 3x3 subplots") return import matplotlib.pylab as plt from mpl_toolkits.mplot3d import Axes3D from PyKEP.orbit_plots import plot_planet from PyKEP import epoch if only_core: ids = self.core_members[cluster_id] else: ids = self.members[cluster_id] fig = plt.figure() for i, ep in enumerate(epochs): axis = fig.add_subplot(3, 3, i + 1, projection='3d') plt.axis('off') plt.title(epoch(ep).__repr__()[:11]) for pl in self._asteroids[::skip]: axis = plot_planet(pl, ax=axis, alpha=0.05, s=0) for cluster_member in ids: r, v = self._asteroids[cluster_member].eph(epoch(ep)) axis.scatter([r[0]], [r[1]], [r[2]], marker='o', alpha=alpha) plt.draw() plt.show() return fig
def plot(self, x): import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg t_E = epoch(x[0]) t_V = epoch(x[0] + x[1]) t_M = epoch(x[0] + x[1] + x[9]) rE, vE = self.__earth.eph(t_E) rV, vV = self.__venus.eph(t_V) rM, vM = self.__mercury.eph(t_M) # First Leg v = [a + b for a, b in zip(vE, x[3:6])] x0 = sc_state(rE, v, self.__sc.mass) v = [a + b for a, b in zip(vV, x[6:9])] xe = sc_state(rV, v, x[2]) self.__leg1.set( t_E, x0, x[-3 * (self.__nseg1 + self.__nseg2):-self.__nseg2 * 3], t_V, xe) # Second leg v = [a + b for a, b in zip(vV, x[11:14])] x0 = sc_state(rV, v, x[2]) v = [a + b for a, b in zip(vM, x[14:17])] xe = sc_state(rM, v, x[10]) self.__leg2.set(t_E, x0, x[(-3 * self.__nseg2):], t_V, xe) fig = plt.figure() axis = fig.gca(projection='3d') # The Sun axis.scatter([0], [0], [0], color='y') # The legs plot_sf_leg(self.__leg1, units=AU, N=10, ax=axis) plot_sf_leg(self.__leg2, units=AU, N=10, ax=axis) # The planets plot_planet( self.__earth, t_E, units=AU, legend=True, color=(0.7, 0.7, 1), ax = axis) plot_planet( self.__venus, t_V, units=AU, legend=True, color=(0.7, 0.7, 1), ax = axis) plot_planet( self.__mercury, t_M, units=AU, legend=True, color=(0.7, 0.7, 1), ax = axis) plt.show()
def plot(self, x, ax=None): """ ax = prob.plot(x, ax=None) - x: encoded trajectory - ax: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler if ax is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') else: axis = ax axis.scatter(0, 0, 0, color='y') # 1 - we 'decode' the chromosome recording the various deep space # manouvres timing (days) in the list T T = list([0] * (self.N_max - 1)) for i in range(len(T)): T[i] = log(x[2 + 4 * i]) total = sum(T) T = [x[1] * time / total for time in T] # 2 - We compute the starting and ending position r_start, v_start = self.start.eph(epoch(x[0])) if self.phase_free: r_target, v_target = self.target.eph(epoch(x[-1])) else: r_target, v_target = self.target.eph(epoch(x[0] + x[1])) plot_planet(self.start, t0=epoch(x[0]), color=(0.8, 0.6, 0.8), legend=True, units=AU, ax=axis) plot_planet(self.target, t0=epoch(x[0] + x[1]), color=(0.8, 0.6, 0.8), legend=True, units=AU, ax=axis) # 3 - We loop across inner impulses rsc = r_start vsc = v_start for i, time in enumerate(T[:-1]): theta = 2 * pi * x[3 + 4 * i] phi = acos(2 * x[4 + 4 * i] - 1) - pi / 2 Vinfx = x[5 + 4 * i] * cos(phi) * cos(theta) Vinfy = x[5 + 4 * i] * cos(phi) * sin(theta) Vinfz = x[5 + 4 * i] * sin(phi) # We apply the (i+1)-th impulse vsc = [a + b for a, b in zip(vsc, [Vinfx, Vinfy, Vinfz])] plot_kepler(rsc, vsc, T[i] * DAY2SEC, self.__common_mu, N=200, color='b', legend=False, units=AU, ax=axis) rsc, vsc = propagate_lagrangian(rsc, vsc, T[i] * DAY2SEC, self.__common_mu) cw = (ic2par(rsc, vsc, self.start.mu_central_body)[2] > pi / 2) # We now compute the remaining two final impulses # Lambert arc to reach seq[1] dt = T[-1] * DAY2SEC l = lambert_problem(rsc, r_target, dt, self.__common_mu, cw, False) plot_lambert(l, sol=0, color='r', legend=False, units=AU, ax=axis, N=200) plt.show() return axis
print "" print " detlal-V at Mars : " print " Mars: ", vM print " Ship: ", vMl dvM = (vM - vMl) print " delta ", dvM, linalg.norm(dvM) print " total delta-v ", linalg.norm(dvM)+linalg.norm(dvE) """ print " dt ", (tt2 - tt1), " dv ", linalg.norm(dvM) + linalg.norm(dvE) plot_planet(ax, plMars, t0=t2, color=(0.8, 0.8, 1), units=AU) plot_lambert(ax, l, color=(1, 0, 0), units=AU) tt1 = 450 plot_planet(ax, plEarth, t0=epoch(tt1), color=(0.8, 0.8, 1), units=AU) plot_planet(ax, plMars, t0=epoch(tt1), color=(0.8, 0.8, 1), units=AU) for dtt in range(200, 350, 10): opt_dt(tt1, tt1 + dtt) def axisEqual3D(ax): extents = np.array([getattr(ax, "get_{}lim".format(dim))() for dim in "xyz"]) sz = extents[:, 1] - extents[:, 0] centers = np.mean(extents, axis=1) maxsize = max(abs(sz)) r = maxsize / 2 for ctr, dim in zip(centers, "xyz"): getattr(ax, "set_{}lim".format(dim))(ctr - r, ctr + r)
def _mga_incipit_plot_old(self, x, plot_leg_0=False): """ Plots the trajectory represented by the decision vector x Example:: prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler from PyKEP import epoch, propagate_lagrangian, lambert_problem, fb_prop, AU, MU_SUN, DAY2SEC from math import pi, acos, cos, sin from scipy.linalg import norm mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d', aspect='equal') ax.scatter(0, 0, 0, color='y') JR = 71492000.0 legs = len(x) / 4 seq = self.get_sequence() common_mu = seq[0].mu_central_body # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T T = x[3::4] # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * legs) r_P = list([None] * legs) v_P = list([None] * legs) DV = list([None] * legs) for i, planet in enumerate(seq): t_P[i] = epoch(x[0] + sum(T[:i + 1])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(ax, planet, t0=t_P[i], color=( 0.8, 0.6, 0.8), legend=True, units = JR) # 3 - We start with the first leg: a lambert arc theta = 2 * pi * x[1] phi = acos(2 * x[2] - 1) - pi / 2 # phi close to zero is in the moon orbit plane injection r = [cos(phi) * sin(theta), cos(phi) * cos(theta), sin(phi)] r = [JR * 1000 * d for d in r] l = lambert_problem(r, r_P[0], T[0] * DAY2SEC, common_mu, False, False) if (plot_leg_0): plot_lambert(ax, l, sol=0, color='k', legend=False, units=JR, N=500) # Lambert arc to reach seq[1] v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # 4 - And we proceed with each successive leg for i in range(1, legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i - 1], x[1 + 4 * i] * seq[i - 1].radius, x[4 * i], seq[i - 1].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian( r_P[i - 1], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu) plot_kepler(ax, r_P[i - 1], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu, N=500, color='b', legend=False, units=JR) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[4 * i + 2]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i], dt, common_mu, False, False) plot_lambert(ax, l, sol=0, color='r', legend=False, units=JR, N=500) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] plt.show() return ax
def plot(self, x, ax=None): """ ax = prob.plot(x, ax=None) - x: encoded trajectory - ax: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg # Creating the axis if necessary if ax is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') else: axis = ax # Plotting the Sun ........ axis.scatter([0], [0], [0], color='y') # Plotting the legs ....... # 1 - We decode the chromosome extracting the time of flights T = list([0] * (self.__n_legs)) for i in range(self.__n_legs): T[i] = x[1 + i * 8] # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = self.seq[i].eph(t_P[i]) # 3 - We iterate through legs to compute mismatches and throttles constraints ceq = list() cineq = list() m0 = self.__sc.mass for i in range(self.__n_legs): # First Leg v = [a + b for a, b in zip(v_P[i], x[(3 + i * 8):(6 + i * 8)])] x0 = sc_state(r_P[i], v, m0) v = [a + b for a, b in zip(v_P[i + 1], x[(6 + i * 8):(11 + i * 8)])] xe = sc_state(r_P[i + 1], v, x[2 + i * 8]) throttles = x[(1 + 8 * self.__n_legs + 3 * sum(self.__n_seg[:i])):(1 + 8 * self.__n_legs + 3 * sum(self.__n_seg[:i]) + 3 * self.__n_seg[i])] self.__leg.set(t_P[i], x0, throttles, t_P[i + 1], xe) # update mass! m0 = x[2 + 8 * i] plot_sf_leg(self.__leg, units=AU, N=10, ax=axis) # Plotting planets for i, planet in enumerate(self.seq): plot_planet(planet, t_P[i], units=AU, legend=True, color=(0.7, 0.7, 1), ax = axis) plt.show() return axis
def _mga_incipit_plot_old(self, x, plot_leg_0=False): """ Plots the trajectory represented by the decision vector x Example:: prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler from PyKEP import epoch, propagate_lagrangian, lambert_problem, fb_prop, AU, MU_SUN, DAY2SEC from math import pi, acos, cos, sin from scipy.linalg import norm mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d', aspect='equal') ax.scatter(0, 0, 0, color='y') JR = 71492000.0 legs = len(x) / 4 seq = self.get_sequence() common_mu = seq[0].mu_central_body # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T T = x[3::4] # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * legs) r_P = list([None] * legs) v_P = list([None] * legs) DV = list([None] * legs) for i, planet in enumerate(seq): t_P[i] = epoch(x[0] + sum(T[:i + 1])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(ax, planet, t0=t_P[i], color=(0.8, 0.6, 0.8), legend=True, units=JR) # 3 - We start with the first leg: a lambert arc theta = 2 * pi * x[1] phi = acos(2 * x[2] - 1) - pi / 2 # phi close to zero is in the moon orbit plane injection r = [cos(phi) * sin(theta), cos(phi) * cos(theta), sin(phi)] r = [JR * 1000 * d for d in r] l = lambert_problem(r, r_P[0], T[0] * DAY2SEC, common_mu, False, False) if (plot_leg_0): plot_lambert(ax, l, sol=0, color='k', legend=False, units=JR, N=500) # Lambert arc to reach seq[1] v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # 4 - And we proceed with each successive leg for i in range(1, legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i - 1], x[1 + 4 * i] * seq[i - 1].radius, x[4 * i], seq[i - 1].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i - 1], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu) plot_kepler(ax, r_P[i - 1], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu, N=500, color='b', legend=False, units=JR) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[4 * i + 2]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i], dt, common_mu, False, False) plot_lambert(ax, l, sol=0, color='r', legend=False, units=JR, N=500) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] plt.show() return ax
1.5 * AU, # a semimajor axis 0.5, # e eccentricity 30 * DEG2RAD, # i inclination i * 60 * DEG2RAD, # W longitude of accesing node 0 * 60 * DEG2RAD, # w argument of periapsis 0 * DEG2RAD # M mean anomaly ), MU_SUN, 398600.4418e9, 6378000, 6900000, 'testPlanet') pls.append(myPlanet) t1 = epoch(0) plot_planet(ax, earth, t0=t1, color=(0.8, 0.8, 0.8), legend=True, units=AU) for i in range(len(pls)): plot_planet(ax, pls[i], t0=t1, color=(1 - i / 5.0, 0, i / 5.0), legend=True, units=AU) # ================================================================================= def axisEqual3D(ax): extents = np.array( [getattr(ax, 'get_{}lim'.format(dim))() for dim in 'xyz']) sz = extents[:, 1] - extents[:, 0]
def plot(self, x, ax=None): """ ax = prob.plot(x, ax=None) - x: encoded trajectory - ax: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler if ax is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') else: axis = ax axis.scatter(0, 0, 0, color='y') # 1 - we 'decode' the chromosome recording the various deep space # manouvres timing (days) in the list T T = list([0] * (self.N_max - 1)) for i in range(len(T)): T[i] = log(x[2 + 4 * i]) total = sum(T) T = [x[1] * time / total for time in T] # 2 - We compute the starting and ending position r_start, v_start = self.start.eph(epoch(x[0])) if self.phase_free: r_target, v_target = self.target.eph(epoch(x[-1])) else: r_target, v_target = self.target.eph(epoch(x[0] + x[1])) plot_planet(self.start, t0=epoch(x[0]), color=(0.8, 0.6, 0.8), legend=True, units = AU, ax=axis) plot_planet(self.target, t0=epoch(x[0] + x[1]), color=(0.8, 0.6, 0.8), legend=True, units = AU, ax=axis) # 3 - We loop across inner impulses rsc = r_start vsc = v_start for i, time in enumerate(T[:-1]): theta = 2 * pi * x[3 + 4 * i] phi = acos(2 * x[4 + 4 * i] - 1) - pi / 2 Vinfx = x[5 + 4 * i] * cos(phi) * cos(theta) Vinfy = x[5 + 4 * i] * cos(phi) * sin(theta) Vinfz = x[5 + 4 * i] * sin(phi) # We apply the (i+1)-th impulse vsc = [a + b for a, b in zip(vsc, [Vinfx, Vinfy, Vinfz])] plot_kepler(rsc, vsc, T[ i] * DAY2SEC, self.__common_mu, N=200, color='b', legend=False, units=AU, ax=axis) rsc, vsc = propagate_lagrangian( rsc, vsc, T[i] * DAY2SEC, self.__common_mu) cw = (ic2par(rsc, vsc, self.start.mu_central_body)[2] > pi / 2) # We now compute the remaining two final impulses # Lambert arc to reach seq[1] dt = T[-1] * DAY2SEC l = lambert_problem(rsc, r_target, dt, self.__common_mu, cw, False) plot_lambert( l, sol=0, color='r', legend=False, units=AU, ax=axis, N=200) plt.show() return axis
pls = [] for i in range(5): myPlanet = planet( epoch(54000,epoch.epoch_type.MJD), ( 1.5 * AU, # a semimajor axis 0.5 , # e eccentricity 30 * DEG2RAD, # i inclination i*60 * DEG2RAD, # W longitude of accesing node 0*60 * DEG2RAD, # w argument of periapsis 0 * DEG2RAD # M mean anomaly ), MU_SUN, 398600.4418e9, 6378000, 6900000, 'testPlanet' ) pls.append(myPlanet) t1 = epoch(0) plot_planet(ax,earth, t0=t1, color=(0.8,0.8,0.8), legend=True, units = AU) for i in range(len(pls)): plot_planet(ax,pls[i], t0=t1, color=(1-i/5.0,0,i/5.0), legend=True, units = AU)
def plot_trajectory(self, x, units=AU, plot_segments=True, ax=None): """ ax = prob.plot_trajectory(self, x, units=AU, plot_segments=True, ax=None) - x: encoded trajectory - units: the length unit to be used in the plot - plot_segments: when true plots also the segments boundaries - [out] ax: matplotlib axis where to plot Plots the trajectory """ import matplotlib as mpl import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from PyKEP.orbit_plots import plot_planet, plot_taylor # Creating the axis if necessary if ax is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') else: axis = ax n_seg = self.__n_seg fwd_seg = self.__fwd_seg bwd_seg = self.__bwd_seg t0 = x[0] T = x[1] isp = self.__sc.isp veff = isp * G0 fwd_grid = t0 + T * self.__fwd_grid # days bwd_grid = t0 + T * self.__bwd_grid # days throttles = [x[3 + 3 * i : 6 + 3 * i] for i in range(n_seg)] alphas = [min(1., np.linalg.norm(t)) for t in throttles] times = np.concatenate((fwd_grid, bwd_grid)) rfwd, rbwd, vfwd, vbwd, mfwd, mbwd, ufwd, ubwd, fwd_dt, bwd_dt = self._propagate(x) # Plotting the Sun, the Earth and the target axis.scatter([0], [0], [0], color='y') plot_planet(self.__earth, epoch(t0), units=units, legend=True, color=(0.7, 0.7, 1), ax=axis) plot_planet(self.target, epoch(t0 + T), units=units, legend=True, color=(0.7, 0.7, 1), ax=axis) # Forward propagation xfwd = [0.0] * (fwd_seg + 1) yfwd = [0.0] * (fwd_seg + 1) zfwd = [0.0] * (fwd_seg + 1) xfwd[0] = rfwd[0][0] / units yfwd[0] = rfwd[0][1] / units zfwd[0] = rfwd[0][2] / units for i in range(fwd_seg): plot_taylor(rfwd[i], vfwd[i], mfwd[i], ufwd[i], fwd_dt[i], MU_SUN, veff, N=10, units=units, color=(alphas[i], 0, 1-alphas[i]), ax=axis) xfwd[i+1] = rfwd[i+1][0] / units yfwd[i+1] = rfwd[i+1][1] / units zfwd[i+1] = rfwd[i+1][2] / units if plot_segments: axis.scatter(xfwd[:-1], yfwd[:-1], zfwd[:-1], label='nodes', marker='o', s=1) # Backward propagation xbwd = [0.0] * (bwd_seg + 1) ybwd = [0.0] * (bwd_seg + 1) zbwd = [0.0] * (bwd_seg + 1) xbwd[-1] = rbwd[-1][0] / units ybwd[-1] = rbwd[-1][1] / units zbwd[-1] = rbwd[-1][2] / units for i in range(bwd_seg): plot_taylor(rbwd[-i-1], vbwd[-i-1], mbwd[-i-1], ubwd[-i-1], -bwd_dt[-i-1], MU_SUN, veff, N=10, units=units, color=(alphas[-i-1], 0, 1-alphas[-i-1]), ax=axis) xbwd[-i-2] = rbwd[-i-2][0] / units ybwd[-i-2] = rbwd[-i-2][1] / units zbwd[-i-2] = rbwd[-i-2][2] / units if plot_segments: axis.scatter(xbwd[1:], ybwd[1:], zbwd[1:], marker='o', s=1) if ax is None: # show only if axis is not set plt.show() return axis
print "" print " detlal-V at Mars : " print " Mars: ", vM print " Ship: ", vMl dvM = (vM - vMl) print " delta ", dvM, linalg.norm(dvM) print " total delta-v ", linalg.norm(dvM)+linalg.norm(dvE) ''' print " dt ", (tt2 - tt1), " dv ", linalg.norm(dvM) + linalg.norm(dvE) plot_planet(ax, plMars, t0=t2, color=(0.8, 0.8, 1), units=AU) plot_lambert(ax, l, color=(1, 0, 0), units=AU) tt1 = 450 plot_planet(ax, plEarth, t0=epoch(tt1), color=(0.8, 0.8, 1), units=AU) plot_planet(ax, plMars, t0=epoch(tt1), color=(0.8, 0.8, 1), units=AU) for dtt in range(200, 350, 10): opt_dt(tt1, tt1 + dtt) def axisEqual3D(ax): extents = np.array( [getattr(ax, 'get_{}lim'.format(dim))() for dim in 'xyz']) sz = extents[:, 1] - extents[:, 0] centers = np.mean(extents, axis=1) maxsize = max(abs(sz)) r = maxsize / 2 for ctr, dim in zip(centers, 'xyz'): getattr(ax, 'set_{}lim'.format(dim))(ctr - r, ctr + r)
def plot(self,x): """ Plots the trajectory represented by the decision vector x Example:: prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') ax.scatter(0,0,0, color='y') #1 - we 'decode' the chromosome recording the various times of flight (days) in the list T for convenience T = list([0]*(self.__n_legs)) for i in xrange(self.__n_legs): T[i] = (x[4+4*i]/sum(x[4::4]))*x[3] #2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs)) r_P = list([None] * (self.__n_legs)) v_P = list([None] * (self.__n_legs)) DV = list([None] * (self.__n_legs)) for i,planet in enumerate(self.seq): t_P[i] = epoch(x[0]+sum(T[:i+1])) r_P[i],v_P[i] = self.seq[i].eph(t_P[i]) plot_planet(ax, planet, t0=t_P[i], color=(0.8,0.6,0.8), legend=True, units = JR) #3 - We start with the first leg: a lambert arc theta = 2*pi*x[1] phi = acos(2*x[2]-1)-pi/2 r = [cos(phi)*sin(theta), cos(phi)*cos(theta), sin(phi)] #phi close to zero is in the moon orbit plane injection r = [JR*1000*d for d in r] l = lambert_problem(r,r_P[0],T[0]*DAY2SEC,self.common_mu, False, False) plot_lambert(ax,l, sol = 0, color='k', legend=False, units = JR, N=500) #Lambert arc to reach seq[1] v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] #First DSM occuring at the very beginning (will be cancelled by the optimizer) DV[0] = abs(norm(v_beg_l) - 3400) #4 - And we proceed with each successive leg for i in xrange(1,self.__n_legs): #Fly-by v_out = fb_prop(v_end_l,v_P[i-1],x[6+(i-1)*4]*self.seq[i-1].radius,x[5+(i-1)*4],self.seq[i-1].mu_self) #s/c propagation before the DSM r,v = propagate_lagrangian(r_P[i-1],v_out,x[4*i+3]*T[i]*DAY2SEC,self.common_mu) plot_kepler(ax,r_P[i-1],v_out,x[7+(i-1)*4]*T[i]*DAY2SEC,self.common_mu,N = 500, color='b', legend=False, units = JR) #Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1-x[7+(i-1)*4])*T[i]*DAY2SEC l = lambert_problem(r,r_P[i],dt,self.common_mu, False, False) plot_lambert(ax,l, sol = 0, color='r', legend=False, units = JR, N=500) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] #DSM occuring at time nu2*T2 DV[i] = norm([a-b for a,b in zip(v_beg_l,v)]) plt.show()
from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') t1 = epoch(0) n = len(ilist) for i in range(n): pl = planet_mpcorb(lines[ilist[i]]) #print ilist[i], pl.orbital_elements[1], pl.orbital_elements[4] #print ilist[i], pl.orbital_elements print "=====", lines[ilist[i]] plot_planet(ax, pl, t0=t1, color=(1.0 - i / float(n), 0.5, i / float(n)), legend=True, units=AU) #plot_planet(ax,pl, t0=t1, color=(1.0-i/float(n),0.5,i/float(n)), legend=False, units = AU) def axisEqual3D(ax): extents = np.array( [getattr(ax, 'get_{}lim'.format(dim))() for dim in 'xyz']) sz = extents[:, 1] - extents[:, 0] centers = np.mean(extents, axis=1) maxsize = max(abs(sz)) r = maxsize / 2 for ctr, dim in zip(centers, 'xyz'): getattr(ax, 'set_{}lim'.format(dim))(ctr - r, ctr + r)
from PyKEP import epoch, DAY2SEC, planet_ss, AU, MU_SUN, lambert_problem from PyKEP.orbit_plots import plot_planet, plot_lambert mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') t1 = epoch(0) t2 = epoch(740) dt = (t2.mjd2000 - t1.mjd2000) * DAY2SEC ax.scatter(0, 0, 0, color='y') pl = planet_ss('earth') plot_planet(ax, pl, t0=t1, color=(0.8, 0.8, 1), legend=True, units=AU) rE, vE = pl.eph(t1) pl = planet_ss('mars') plot_planet(ax, pl, t0=t2, color=(0.8, 0.8, 1), legend=True, units=AU) rM, vM = pl.eph(t2) l = lambert_problem(rE, rM, dt, MU_SUN) nmax = l.get_Nmax() print "max number of revolutions", nmax plot_lambert(ax, l, color=(1, 0, 0), legend=True, units=AU) for i in range(1, nmax * 2 + 1): print i plot_lambert(ax,
def plot(self, x): """ Plots the trajectory represented by the decision vector x Example:: prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') ax.scatter(0, 0, 0, color='y') #1 - we 'decode' the chromosome recording the various times of flight (days) in the list T T = x[3::4] #2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs)) r_P = list([None] * (self.__n_legs)) v_P = list([None] * (self.__n_legs)) DV = list([None] * (self.__n_legs)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[:i + 1])) r_P[i], v_P[i] = self.seq[i].eph(t_P[i]) plot_planet(ax, planet, t0=t_P[i], color=(0.8, 0.6, 0.8), legend=True, units=JR) #3 - We start with the first leg: a lambert arc theta = 2 * pi * x[1] phi = acos(2 * x[2] - 1) - pi / 2 r = [cos(phi) * sin(theta), cos(phi) * cos(theta), sin(phi)] #phi close to zero is in the moon orbit plane injection r = [JR * 1000 * d for d in r] l = lambert_problem(r, r_P[0], T[0] * DAY2SEC, self.common_mu, False, False) plot_lambert(ax, l, sol=0, color='k', legend=False, units=JR, N=500) #Lambert arc to reach seq[1] v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] #First DSM occuring at the very beginning (will be cancelled by the optimizer) DV[0] = abs(norm(v_beg_l) - 3400) #4 - And we proceed with each successive leg for i in xrange(1, self.__n_legs): #Fly-by v_out = fb_prop(v_end_l, v_P[i - 1], x[1 + 4 * i] * self.seq[i - 1].radius, x[4 * i], self.seq[i - 1].mu_self) #s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i - 1], v_out, x[4 * i + 2] * T[i] * DAY2SEC, self.common_mu) plot_kepler(ax, r_P[i - 1], v_out, x[4 * i + 2] * T[i] * DAY2SEC, self.common_mu, N=500, color='b', legend=False, units=JR) #Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[4 * i + 2]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i], dt, self.common_mu, False, False) plot_lambert(ax, l, sol=0, color='r', legend=False, units=JR, N=500) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] #DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) plt.show() return ax
def plot(self, x): """ Plots the trajectory represented by the decision vector x Example:: prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg fig = plt.figure() ax = fig.gca(projection='3d') #Plotting the Sun ........ ax.scatter([0], [0], [0], color='y') #Plotting the legs ....... # 1 - We decode the chromosome extracting the time of flights T = list([0] * (self.__n_legs)) for i in range(self.__n_legs): T[i] = x[1 + i * 8] #2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = self.seq[i].eph(t_P[i]) #3 - We iterate through legs to compute mismatches and throttles constraints ceq = list() cineq = list() m0 = self.__sc.mass for i in range(self.__n_legs): #First Leg v = [a + b for a, b in zip(v_P[i], x[(3 + i * 8):(6 + i * 8)])] x0 = sc_state(r_P[i], v, m0) v = [ a + b for a, b in zip(v_P[i + 1], x[(6 + i * 8):(11 + i * 8)]) ] xe = sc_state(r_P[i + 1], v, x[2 + i * 8]) throttles = x[(1 + 8 * self.__n_legs + 3 * sum(self.__n_seg[:i])):( 1 + 8 * self.__n_legs + 3 * sum(self.__n_seg[:i]) + 3 * self.__n_seg[i])] self.__leg.set(t_P[i], x0, throttles, t_P[i + 1], xe) #update mass! m0 = x[2 + 8 * i] plot_sf_leg(ax, self.__leg, units=AU, N=10) #Plotting planets for i, planet in enumerate(self.seq): plot_planet(ax, planet, t_P[i], units=AU, legend=True, color=(0.7, 0.7, 1)) plt.show()
def plot(self, x, ax=None): """ ax = prob.plot(x, ax=None) - x: encoded trajectory - ax: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler if ax is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') else: axis = ax axis.scatter(0, 0, 0, color='y') # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T and the cartesian components of vinf T, Vinfx, Vinfy, Vinfz = self._decode_times_and_vinf(x) # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) DV = list([None] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(planet, t0=t_P[i], color=(0.8, 0.6, 0.8), legend=True, units=AU, ax=axis) # 3 - We start with the first leg v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian(r_P[0], v0, x[5] * T[0] * DAY2SEC, self.common_mu) plot_kepler(r_P[0], v0, x[5] * T[0] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU, ax=axis) # Lambert arc to reach seq[1] dt = (1 - x[5]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, self.common_mu, False, False) plot_lambert(l, sol=0, color='r', legend=False, units=AU, ax=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # 4 - And we proceed with each successive leg for i in range(1, self.__n_legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[8 + (i - 1) * 4] * self.seq[i].radius, x[7 + (i - 1) * 4], self.seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[9 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) plot_kepler(r_P[i], v_out, x[9 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU, ax=axis) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[9 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, self.common_mu, False, False) plot_lambert(l, sol=0, color='r', legend=False, units=AU, N=1000, ax=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) plt.show() return axis
def plot(self, x): import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_sf_leg mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') ax.scatter(0, 0, 0, color='y') # 1 - We decode the chromosome extracting the time of flights T = list([0] * (self.__n_legs)) for i in range(self.__n_legs): T[i] = x[2 + i * 8] #2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i + 1] = epoch(self.tf - sum(T[i + 1:])) r_P[i + 1], v_P[i + 1] = self.seq[i].eph(t_P[i + 1]) plot_planet(ax, self.seq[i], t_P[i + 1], units=JR, legend=True, color='k') #And we insert a fake planet simulating the starting position t_P[0] = epoch(self.tf - sum(T)) theta = x[0] phi = x[1] r = [cos(phi) * sin(theta), cos(phi) * cos(theta), sin(phi)] #phi close to zero is in the moon orbit plane injection r = [JR * 1000 * d for d in r] r_P[0] = r v_P[0] = x[4:7] #3 - We iterate through legs to compute mismatches and throttles constraints ceq = list() cineq = list() m0 = self.__sc.mass for i in range(self.__n_legs): if i != 0: #First Leg v = [a + b for a, b in zip(v_P[i], x[(4 + i * 8):(7 + i * 8)])] else: v = v_P[i] x0 = sc_state(r_P[i], v, m0) v = [ a + b for a, b in zip(v_P[i + 1], x[(7 + i * 8):(10 + i * 8)]) ] if (i == self.__n_legs - 1): #Last leg v = [a + b for a, b in zip(v_P[i + 1], self.vf)] xe = sc_state(r_P[i + 1], v, x[3 + 8 * i]) throttles = x[(8 * self.__n_legs - 1 + 3 * sum(self.__n_seg[:i])):( 8 * self.__n_legs - 1 + 3 * sum(self.__n_seg[:i]) + 3 * self.__n_seg[i])] self.__leg.set(t_P[i], x0, throttles, t_P[i + 1], xe) plot_sf_leg(ax, self.__leg, units=JR, N=50) #update mass! m0 = x[3 + 8 * i] ceq.extend(self.__leg.mismatch_constraints()) cineq.extend(self.__leg.throttles_constraints()) #raise Exception plt.show() return ax
def _mga_1dsm_tof_plot_old(self, x): """ Plots the trajectory represented by the decision vector x """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler from PyKEP import epoch, propagate_lagrangian, lambert_problem, fb_prop, AU, MU_SUN, DAY2SEC from math import pi, acos, cos, sin from scipy.linalg import norm mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') ax.scatter(0, 0, 0, color='y') seq = self.get_sequence() n = (len(seq) - 1) # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T T = x[5::4] # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (n + 1)) r_P = list([None] * (n + 1)) v_P = list([None] * (n + 1)) DV = list([None] * (n + 1)) for i, planet in enumerate(seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(ax, planet, t0=t_P[i], color=(0.8, 0.6, 0.8), legend=True, units=AU) # 3 - We start with the first leg theta = 2 * pi * x[1] phi = acos(2 * x[2] - 1) - pi / 2 Vinfx = x[3] * cos(phi) * cos(theta) Vinfy = x[3] * cos(phi) * sin(theta) Vinfz = x[3] * sin(phi) v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian(r_P[0], v0, x[4] * T[0] * DAY2SEC, seq[0].mu_central_body) plot_kepler(ax, r_P[0], v0, x[4] * T[0] * DAY2SEC, seq[0].mu_central_body, N=100, color='b', legend=False, units=AU) # Lambert arc to reach seq[1] dt = (1 - x[4]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, seq[0].mu_central_body) plot_lambert(ax, l, sol=0, color='r', legend=False, units=AU) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # 4 - And we proceed with each successive leg for i in range(1, n): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[7 + (i - 1) * 4] * seq[i].radius, x[6 + (i - 1) * 4], seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, seq[0].mu_central_body) plot_kepler(ax, r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, seq[0].mu_central_body, N=100, color='b', legend=False, units=AU) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[8 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, seq[0].mu_central_body) plot_lambert(ax, l, sol=0, color='r', legend=False, units=AU) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occurring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) return ax
def plot(self, x, ax=None): """ ax = prob.plot(x, ax=None) - x: encoded trajectory - ax: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP import epoch, AU from PyKEP.sims_flanagan import sc_state from PyKEP.orbit_plots import plot_planet, plot_sf_leg # Creating the axis if necessary if ax is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') else: axis = ax # Plotting the Sun ........ axis.scatter([0], [0], [0], color='y') # Plotting the legs ....... # 1 - We decode the chromosome extracting the time of flights T = list([0] * (self.__n_legs)) for i in range(self.__n_legs): T[i] = x[1 + i * 8] # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = self.seq[i].eph(t_P[i]) # 3 - We iterate through legs to compute mismatches and throttles constraints ceq = list() cineq = list() m0 = self.__sc.mass for i in range(self.__n_legs): # First Leg v = [a + b for a, b in zip(v_P[i], x[(3 + i * 8):(6 + i * 8)])] x0 = sc_state(r_P[i], v, m0) v = [ a + b for a, b in zip(v_P[i + 1], x[(6 + i * 8):(11 + i * 8)]) ] xe = sc_state(r_P[i + 1], v, x[2 + i * 8]) throttles = x[(1 + 8 * self.__n_legs + 3 * sum(self.__n_seg[:i])):( 1 + 8 * self.__n_legs + 3 * sum(self.__n_seg[:i]) + 3 * self.__n_seg[i])] self.__leg.set(t_P[i], x0, throttles, t_P[i + 1], xe) # update mass! m0 = x[2 + 8 * i] plot_sf_leg(self.__leg, units=AU, N=10, ax=axis) # Plotting planets for i, planet in enumerate(self.seq): plot_planet(planet, t_P[i], units=AU, legend=True, color=(0.7, 0.7, 1), ax=axis) plt.show() return axis
def _mga_part_plot_old(self, x): """ Plots the trajectory represented by the decision vector x Example:: prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler from PyKEP import epoch, propagate_lagrangian, lambert_problem, fb_prop, AU, MU_SUN, DAY2SEC from math import pi, acos, cos, sin from scipy.linalg import norm mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d', aspect='equal') ax.scatter(0, 0, 0, color='y') JR = 71492000.0 legs = len(x) / 4 seq = self.get_sequence() common_mu = seq[0].mu_central_body start_mjd2000 = self.t0.mjd2000 # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T T = x[3::4] # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (legs + 1)) r_P = list([None] * (legs + 1)) v_P = list([None] * (legs + 1)) for i, planet in enumerate(seq): t_P[i] = epoch(start_mjd2000 + sum(T[:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(ax, planet, t0=t_P[i], color=(0.8, 0.6, 0.8), legend=True, units=JR) v_end_l = [a + b for a, b in zip(v_P[0], self.vinf_in)] # 4 - And we iterate on the legs for i in range(0, legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[1 + 4 * i] * seq[i - 1].radius, x[4 * i], seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu) plot_kepler(ax, r_P[i], v_out, x[4 * i + 2] * T[i] * DAY2SEC, common_mu, N=500, color='b', legend=False, units=JR) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[4 * i + 2]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, common_mu, False, False) plot_lambert(ax, l, sol=0, color='r', legend=False, units=JR, N=500) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] plt.show() return ax
import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') t1 = epoch(0) n=len(ilist) for i in range(n): pl = planet_mpcorb(lines[ilist[i]]) #print ilist[i], pl.orbital_elements[1], pl.orbital_elements[4] #print ilist[i], pl.orbital_elements print "=====", lines[ilist[i]] plot_planet(ax,pl, t0=t1, color=(1.0-i/float(n),0.5,i/float(n)), legend=True, units = AU) #plot_planet(ax,pl, t0=t1, color=(1.0-i/float(n),0.5,i/float(n)), legend=False, units = AU) def axisEqual3D(ax): extents = np.array([getattr(ax, 'get_{}lim'.format(dim))() for dim in 'xyz']) sz = extents[:,1] - extents[:,0] centers = np.mean(extents, axis=1) maxsize = max(abs(sz)) r = maxsize/2 for ctr, dim in zip(centers, 'xyz'): getattr(ax, 'set_{}lim'.format(dim))(ctr - r, ctr + r) axisEqual3D(ax) show()
def _mga_1dsm_tof_plot_old(self, x): """ Plots the trajectory represented by the decision vector x """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler from PyKEP import epoch, propagate_lagrangian, lambert_problem, fb_prop, AU, MU_SUN, DAY2SEC from math import pi, acos, cos, sin from scipy.linalg import norm mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') ax.scatter(0, 0, 0, color='y') seq = self.get_sequence() n = (len(seq) - 1) # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T T = x[5::4] # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (n + 1)) r_P = list([None] * (n + 1)) v_P = list([None] * (n + 1)) DV = list([None] * (n + 1)) for i, planet in enumerate(seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(ax, planet, t0=t_P[i], color=( 0.8, 0.6, 0.8), legend=True, units = AU) # 3 - We start with the first leg theta = 2 * pi * x[1] phi = acos(2 * x[2] - 1) - pi / 2 Vinfx = x[3] * cos(phi) * cos(theta) Vinfy = x[3] * cos(phi) * sin(theta) Vinfz = x[3] * sin(phi) v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian( r_P[0], v0, x[4] * T[0] * DAY2SEC, seq[0].mu_central_body) plot_kepler( ax, r_P[0], v0, x[4] * T[0] * DAY2SEC, seq[0].mu_central_body, N=100, color='b', legend=False, units=AU) # Lambert arc to reach seq[1] dt = (1 - x[4]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, seq[0].mu_central_body) plot_lambert(ax, l, sol=0, color='r', legend=False, units=AU) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # 4 - And we proceed with each successive leg for i in range(1, n): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[7 + (i - 1) * 4] * seq[i].radius, x[6 + (i - 1) * 4], seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian( r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, seq[0]. mu_central_body) plot_kepler(ax, r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, seq[0].mu_central_body, N=100, color='b', legend=False, units=AU) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[8 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, seq[0].mu_central_body) plot_lambert(ax, l, sol=0, color='r', legend=False, units=AU) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occurring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) return ax
def plot(self, x): """ Plots the trajectory represented by the decision vector x Example:: prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') ax.scatter(0, 0, 0, color='y') #1 - we 'decode' the chromosome recording the various times of flight (days) in the list T T = list([0] * (self.__n_legs)) #a[-i] = x[-1-(i-1)*4] for i in xrange(self.__n_legs - 1): j = i + 1 T[-j] = (x[5] - sum(T[-(j - 1):])) * x[-1 - (j - 1) * 4] T[0] = x[5] - sum(T) #2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) DV = list([None] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(ax, planet, t0=t_P[i], color=(0.8, 0.6, 0.8), legend=True, units=AU) #3 - We start with the first leg theta = 2 * pi * x[1] phi = acos(2 * x[2] - 1) - pi / 2 Vinfx = x[3] * cos(phi) * cos(theta) Vinfy = x[3] * cos(phi) * sin(theta) Vinfz = x[3] * sin(phi) v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian(r_P[0], v0, x[4] * T[0] * DAY2SEC, self.common_mu) plot_kepler(ax, r_P[0], v0, x[4] * T[0] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU) #Lambert arc to reach seq[1] dt = (1 - x[4]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, self.common_mu, False, False) plot_lambert(ax, l, sol=0, color='r', legend=False, units=AU) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] #First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) #4 - And we proceed with each successive leg for i in range(1, self.__n_legs): #Fly-by v_out = fb_prop(v_end_l, v_P[i], x[7 + (i - 1) * 4] * self.seq[i].radius, x[6 + (i - 1) * 4], self.seq[i].mu_self) #s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) plot_kepler(ax, r_P[i], v_out, x[8 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU) #Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[8 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, self.common_mu, False, False) plot_lambert(ax, l, sol=0, color='r', legend=False, units=AU, N=1000) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] #DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) plt.show()
def plot(self, x, ax=None): """ ax = prob.plot(x, ax=None) - x: encoded trajectory - ax: matplotlib axis where to plot. If None figure and axis will be created - [out] ax: matplotlib axis where to plot Plots the trajectory represented by a decision vector x on the 3d axis ax Example:: ax = prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler if ax is None: mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') else: axis = ax axis.scatter(0, 0, 0, color='y') # 1 - we 'decode' the chromosome recording the various times of flight # (days) in the list T and the cartesian components of vinf T, Vinfx, Vinfy, Vinfz = self._decode_times_and_vinf(x) # 2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs + 1)) r_P = list([None] * (self.__n_legs + 1)) v_P = list([None] * (self.__n_legs + 1)) DV = list([None] * (self.__n_legs + 1)) for i, planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i], v_P[i] = planet.eph(t_P[i]) plot_planet(planet, t0=t_P[i], color=(0.8, 0.6, 0.8), legend=True, units = AU, ax=axis) # 3 - We start with the first leg v0 = [a + b for a, b in zip(v_P[0], [Vinfx, Vinfy, Vinfz])] r, v = propagate_lagrangian(r_P[0], v0, x[5] * T[0] * DAY2SEC, self.common_mu) plot_kepler(r_P[0], v0, x[5] * T[0] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU, ax=axis) # Lambert arc to reach seq[1] dt = (1 - x[5]) * T[0] * DAY2SEC l = lambert_problem(r, r_P[1], dt, self.common_mu, False, False) plot_lambert(l, sol=0, color='r', legend=False, units=AU, ax=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # First DSM occuring at time nu1*T1 DV[0] = norm([a - b for a, b in zip(v_beg_l, v)]) # 4 - And we proceed with each successive leg for i in range(1, self.__n_legs): # Fly-by v_out = fb_prop(v_end_l, v_P[i], x[8 + (i - 1) * 4] * self.seq[i].radius, x[7 + (i - 1) * 4], self.seq[i].mu_self) # s/c propagation before the DSM r, v = propagate_lagrangian(r_P[i], v_out, x[9 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu) plot_kepler(r_P[i], v_out, x[9 + (i - 1) * 4] * T[i] * DAY2SEC, self.common_mu, N=100, color='b', legend=False, units=AU, ax=axis) # Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1 - x[9 + (i - 1) * 4]) * T[i] * DAY2SEC l = lambert_problem(r, r_P[i + 1], dt, self.common_mu, False, False) plot_lambert(l, sol=0, color='r', legend=False, units=AU, N=1000, ax=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # DSM occuring at time nu2*T2 DV[i] = norm([a - b for a, b in zip(v_beg_l, v)]) plt.show() return axis
def AIO(self,x, doplot = True, doprint = True, rtrn_desc = True, dists_class = None): P = doprint plots_datas = list([None] * (self.__n)) PLDists = list([None] * (self.__n-1)) FBDates = list([None] * (self.__n-1)) #1 - we 'decode' the chromosome recording the various times of flight (days) in the list T T = list([0]*(self.__n)) #a[-i] = x[-1-(i-1)*4] for i in xrange(self.__n-1): j = i+1; T[-j] = (x[5] - sum(T[-(j-1):])) * x[-1-(j-1)*4] T[0] = x[5] - sum(T) #2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n+1)) r_P = list([None] * (self.__n+1)) v_P = list([None] * (self.__n+1)) DV = list([None] * (self.__n+1)) for i,planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i],v_P[i] = self.seq[i].eph(t_P[i]) #3 - We start with the first leg if P: print "First Leg: " + self.seq[0].name + " to " + self.seq[1].name theta = 2*pi*x[1] phi = acos(2*x[2]-1)-pi/2 Vinfx = x[3]*cos(phi)*cos(theta) Vinfy = x[3]*cos(phi)*sin(theta) Vinfz = x[3]*sin(phi) if P: print("Departure: " + str(t_P[0]) + " (" + str(t_P[0].mjd2000) + " mjd2000) \n" "Duration: " + str(T[0]) + " days\n" "VINF: " + str(x[3] / 1000) + " km/sec\n" "C3: " + str((x[3] / 1000)**2) + " km^2/s^2") v0 = [a+b for a,b in zip(v_P[0], [Vinfx,Vinfy,Vinfz])] r,v = propagate_lagrangian(r_P[0], v0, x[4]*T[0]*DAY2SEC, MU_SUN) if P: print "DSM after " + str(x[4]*T[0]) + " days" #Lambert arc to reach seq[1] dt = (1-x[4])*T[0]*DAY2SEC l = lambert_problem(r, r_P[1], dt, MU_SUN) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # Append data needed for potential plot generation plots_datas[0] = [v0, x[4]*T[0]*DAY2SEC, l] #First DSM occuring at time nu1*T1 DV[0] = norm([a-b for a,b in zip(v_beg_l,v)]) if P: print "DSM magnitude: " + str(DV[0]) + "m/s" #4 - And we proceed with each successive leg for i in range(1,self.__n): if P: print("\nleg no. " + str(i+1) + ": " + self.seq[i].name + " to " + self.seq[i+1].name + "\n" "Duration: " + str(T[i]) + "days") #Fly-by v_out = fb_prop(v_end_l, v_P[i], x[7+(i-1)*4]*self.seq[i].radius, x[6+(i-1)*4], self.seq[i].mu_self) PLDists[i-1] = (x[7+(i-1)*4] -1)*self.seq[i].radius/1000. FBDates[i-1] = t_P[i] if P: print("Fly-by epoch: " + str(t_P[i]) + " (" + str(t_P[i].mjd2000) + " mjd2000) \n" "Fly-by radius: " + str(x[7+(i-1)*4]) + " planetary radii\n" "Fly-by distance: " + str( (x[7+(i-1)*4] -1)*self.seq[i].radius/1000.) + " km") #s/c propagation before the DSM r,v = propagate_lagrangian(r_P[i], v_out, x[8+(i-1)*4]*T[i]*DAY2SEC, MU_SUN) if P: print "DSM after " + str(x[8+(i-1)*4]*T[i]) + " days" #Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1-x[8+(i-1)*4])*T[i]*DAY2SEC l = lambert_problem(r, r_P[i+1], dt, MU_SUN) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] # Append data needed for potential plot generation plots_datas[i] = [v_out, x[8+(i-1)*4]*T[i]*DAY2SEC, l] #DSM occuring at time nu2*T2 DV[i] = norm([a-b for a,b in zip(v_beg_l,v)]) if P: print "DSM magnitude: " + str(DV[i]) + "m/s" #Last Delta-v if P: print "\nArrival at " + self.seq[-1].name DV[-1] = norm([a-b for a,b in zip(v_end_l,v_P[-1])]) if P: print("Arrival Vinf: " + str(DV[-1]) + "m/s \n" "Total mission time: " + str(sum(T)/365.25) + " years (" + str(sum(T)) + " days) \n" "DSMs mag: " + str(sum(DV[:-1])) + "m/s \n" "Entry Vel: " + str(sqrt(2*(0.5*(DV[-1])**2 + 61933310.95))) + "m/s \n" "Entry epoch: " + str(epoch(t_P[0].mjd2000 + sum(T))) ) if doplot: import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure(figsize=(8, 8), dpi=80) ax = fig.gca(projection='3d') ax.scatter(0,0,0, color='y') for i,planet in enumerate(self.seq): plot_planet(ax, planet, t0=t_P[i], color=(0.8,0.6,0.8), legend=True, units = AU) for i, tpl in enumerate(plots_datas): plot_kepler(ax, r_P[i], tpl[0], tpl[1], MU_SUN ,N = 100, color='b', legend=False, units = AU) plot_lambert(ax, tpl[2], sol = 0, color='r', legend=False, units = AU) fig.tight_layout() plt.show() if dists_class is not None: for i, tpl in enumerate(plots_datas): dists_class.positions_kepler(r_P[i], tpl[0], tpl[1], MU_SUN ,index = 2*i) dists_class.positions_lambert(tpl[2], sol = 0, index = 2*(i+.5)) dists_class.set_launch_epoch(t_P[0].mjd2000) return dists_class if rtrn_desc: import numpy as np from math import atan2 desc = dict() for i in range(len(x)): desc[i] = x[i] theta = 2*pi*x[1] phi = acos(2*x[2]-1)-pi/2 axtl = 23.43929*DEG2RAD # Earth axial tlit mactran = np.matrix([ [1, 0, 0], [0, cos(axtl), -sin(axtl)], [0, sin(axtl), cos(axtl)] ]) # Macierz przejscia z helio do ECI macdegs = np.matrix([ [cos(phi)*cos(theta)], [cos(phi)*sin(theta)], [sin(phi)] ]) aaa = mactran.dot(macdegs) theta_earth = atan2(aaa[1,0], aaa[0,0]) # Rektascensja asym phi_earth = asin(aaa[2,0]) # Deklinacja asym desc['RA'] = 360+RAD2DEG*theta_earth desc['DEC'] = phi_earth*RAD2DEG desc['Ldate'] = str(t_P[0]) desc['C3'] = (x[3] / 1000)**2 desc['dVmag'] = sum(DV[:-1]) desc['VinfRE'] = DV[-1] desc['VRE'] = (DV[-1]**2 + 2*61933310.95)**.5 desc['REDate'] = str(epoch(t_P[0].mjd2000 + sum(T))) for i in range(1,self.__n): desc[self.seq[i].name[0].capitalize()+'Dist'] = PLDists[i-1] desc[self.seq[i].name[0].capitalize()+'FBDate'] = str(FBDates[i-1]) return desc
mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') t1 = epoch(0) t2 = epoch(740) dt = (t2.mjd2000 - t1.mjd2000) * DAY2SEC ax.scatter(0,0,0, color='y') pl = planet_ss('earth') plot_planet(ax,pl, t0=t1, color=(0.8,0.8,1), legend=True, units = AU) rE,vE = pl.eph(t1) pl = planet_ss('mars') plot_planet(ax,pl, t0=t2, color=(0.8,0.8,1), legend=True, units = AU) rM, vM = pl.eph(t2) l = lambert_problem(rE,rM,dt,MU_SUN) nmax = l.get_Nmax() print "max number of revolutions",nmax plot_lambert(ax,l , color=(1,0,0), legend=True, units = AU) for i in range(1,nmax*2+1): print i plot_lambert(ax,l,sol=i, color=(1,0,i/float(nmax*2)), legend=True, units = AU)
def plot(self,x): """ Plots the trajectory represented by the decision vector x Example:: prob.plot(x) """ import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from PyKEP.orbit_plots import plot_planet, plot_lambert, plot_kepler mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() axis = fig.gca(projection='3d') axis.scatter(0,0,0, color='y') #1 - we 'decode' the chromosome recording the various times of flight (days) in the list T T = list([0]*(self.__n_legs)) for i in range(0, self.__n_legs): T[i] = x[4+3*(self.__n_legs - 1) + i+1] #2 - We compute the epochs and ephemerides of the planetary encounters t_P = list([None] * (self.__n_legs+1)) r_P = list([None] * (self.__n_legs+1)) v_P = list([None] * (self.__n_legs+1)) DV = list([None] * (self.__n_legs+1)) for i,planet in enumerate(self.seq): t_P[i] = epoch(x[0] + sum(T[0:i])) r_P[i],v_P[i] = planet.eph(t_P[i]) plot_planet(planet, t0=t_P[i], color=(0.8,0.6,0.8), legend=True, units = AU, ax=axis) #3 - We start with the first leg theta = 2*pi*x[1] phi = acos(2*x[2]-1)-pi/2 Vinfx = x[3]*cos(phi)*cos(theta) Vinfy = x[3]*cos(phi)*sin(theta) Vinfz = x[3]*sin(phi) v0 = [a+b for a,b in zip(v_P[0],[Vinfx,Vinfy,Vinfz])] r,v = propagate_lagrangian(r_P[0],v0,x[4]*T[0]*DAY2SEC,self.common_mu) plot_kepler(r_P[0],v0,x[4]*T[0]*DAY2SEC,self.common_mu,N = 100, color='b', legend=False, units = AU, ax=axis) #Lambert arc to reach seq[1] dt = (1-x[4])*T[0]*DAY2SEC l = lambert_problem(r,r_P[1],dt,self.common_mu, False, False) plot_lambert(l, sol = 0, color='r', legend=False, units = AU, ax=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] #First DSM occurring at time nu1*T1 DV[0] = norm([a-b for a,b in zip(v_beg_l,v)]) #4 - And we proceed with each successive leg for i in range(1,self.__n_legs): #Fly-by v_out = fb_prop(v_end_l,v_P[i],x[6+(i-1)*3]*self.seq[i].radius,x[5+(i-1)*3],self.seq[i].mu_self) #s/c propagation before the DSM r,v = propagate_lagrangian(r_P[i],v_out,x[7+(i-1)*3]*T[i]*DAY2SEC,self.common_mu) plot_kepler(r_P[i],v_out,x[7+(i-1)*3]*T[i]*DAY2SEC,self.common_mu,N = 100, color='b', legend=False, units = AU, ax=axis) #Lambert arc to reach Earth during (1-nu2)*T2 (second segment) dt = (1-x[7+(i-1)*3])*T[i]*DAY2SEC l = lambert_problem(r,r_P[i+1],dt,self.common_mu, False, False) plot_lambert(l, sol = 0, color='r', legend=False, units = AU, N=1000, ax=axis) v_end_l = l.get_v2()[0] v_beg_l = l.get_v1()[0] #DSM occurring at time nu2*T2 DV[i] = norm([a-b for a,b in zip(v_beg_l,v)]) plt.show() return axis