def __init__(self, rocket):
self.rocket = rocket
rocket.lunar_guidance_live() #calculate apollo guidance
#create the problem instance
time_init = [0.0, rocket.t[-1]]
n = 12
num_states = self.num_states = 5
num_controls = self.num_controls = 2
max_iteration = 10
prob = self.prob = Problem(time_init, [n], [num_states], [num_controls], max_iteration)
prob.dynamics = [self._og_dynamics]
prob.cost = self._og_cost
prob.runing_cost = self._og_running_cost
prob.equality = self._og_equality
prob.inequality = self._og_inequality
#prob.knot_states_smooth = [True]
# generate intial guess of trajectory
self._initial_guess_apollo() #assigns the initial guess trajectory - one with no thrust
return
# ========================
plt.close("all")
# Program Starting Point
time_init = [0.0, 0.3]
n = [50]
num_states = [3]
num_controls = [1]
max_iteration = 30
flag_savefig = True
savefig_file = "04_Goddard/04_0knot_"
# ------------------------
# set OpenGoddard class for algorithm determination
prob = Problem(time_init, n, num_states, num_controls, max_iteration)
# ------------------------
# create instance of operating object
# Nondimensionalization of parameters
obj = Rocket()
# ========================
# Initial parameter guess
# altitude profile
H_init = Guess.cubic(prob.time_all_section, 1.0, 0.0, 1.010, 0.0)
# Guess.plot(prob.time_all_section, H_init, "Altitude", "time", "Altitude")
# if(flag_savefig):plt.savefig(savefig_file + "guess_alt" + ".png")
# velocity
# ========================
plt.close("all")
plt.ion()
# Program Starting Point
time_init = [0.0, 300, 600]
n = [25, 25]
num_states = [3, 3]
num_controls = [1, 1]
max_iteration = 30
flag_savefig = True
savefig_file = "06_Rocket_Ascent/TwoStage_"
# ------------------------
# set OpenGoddard class for algorithm determination
prob = Problem(time_init, n, num_states, num_controls, max_iteration)
# ------------------------
# create instance of operating object
obj = Rocket()
unit_R = obj.Re
unit_v = np.sqrt(obj.GMe / obj.Re)
unit_m = obj.M0
unit_t = unit_R / unit_v
unit_T = unit_m * unit_R / unit_t**2
prob.set_unit_states_all_section(0, unit_R)
prob.set_unit_states_all_section(1, unit_v)
prob.set_unit_states_all_section(2, unit_m)
prob.set_unit_controls_all_section(0, unit_T)
prob.set_unit_time(unit_t)
# ======================== # Program Starting Point time_init = [0.0, 200, 800] n = [20, 30] num_states = [5, 5] num_controls = [2, 2] max_iteration = 90 flag_savefig = True savefig_file = "./11_Polar_TSTO_Taiki/TSTO_" # ------------------------ # set OpenGoddard class for algorithm determination prob = Problem(time_init, n, num_states, num_controls, max_iteration) # ------------------------ # create instance of operating object obj = Rocket() unit_R = obj.Re unit_theta = 1 unit_V = np.sqrt(obj.GMe / obj.Re) unit_m = obj.M0[0] unit_t = unit_R / unit_V unit_T = unit_m * unit_R / unit_t**2 prob.set_unit_states_all_section(0, unit_R) prob.set_unit_states_all_section(1, unit_theta) prob.set_unit_states_all_section(2, unit_V) prob.set_unit_states_all_section(3, unit_V)
def global_mesh_refine(self, prob = None, new_nodes = None, maxIterator = None, **kwargs):
""" Refines the mesh. Does not modify current prob
Parameters
----------
new_nodes : type
Description of parameter `new_nodes`.
maxIterator : type
Description of parameter `maxIterator`.
**kwargs : type
Description of parameter `**kwargs`.
Returns
-------
type
Description of returned object.
"""
if prob is None:
prob = self.prob
#else refine the provided problem
#get parameters from previous prob
time_init = prob.time_knots()
if new_nodes is None:
new_nodes = [2*n for n in prob.nodes]
num_of_states = prob.number_of_states
num_of_controls = prob.number_of_controls
if maxIterator is None:
maxIterator = prob.maxIterator
# construct new problem
new_prob = Problem(time_init, new_nodes, num_of_states, num_of_controls, maxIterator, **kwargs)
#assume the equations are the same as before
new_prob.dynamics = prob.dynamics
new_prob.knot_states_smooth = prob.knot_states_smooth
new_prob.cost = prob.cost
new_prob.cost_derivative = prob.cost_derivative
new_prob.equality = prob.equality
new_prob.inequality = prob.inequality
#add in the initial guesses - linear interp on previous solution
t_previous = prob.time_update() #update total
t_previous_section = prob.time
t_new = new_prob.time_all_section
t_new_section = new_prob.time
for sec in range(len(new_nodes)):
for i in range(num_of_states[sec]):
new_prob.set_states(i, sec, np.interp(t_new_section[sec], t_previous_section[sec], prob.states(i, sec)))
for i in range(num_of_controls[sec]):
new_prob.set_controls(i, sec, np.interp(t_new_section[sec], t_previous_section[sec], prob.controls(i, sec)))
return new_prob
plt.close("all")
plt.ion()
# Program Starting Point
time_init = [0.0, 10.0]
n = [100]
num_states = [3]
num_controls = [4]
max_iteration = 10
flag_savefig = True
savefig_dir = "10_Low_Thrust_Orbit_Transfer/"
# ------------------------
# set OpenGoddard class for algorithm determination
prob = Problem(time_init, n, num_states, num_controls, max_iteration)
obj = Orbiter()
# ========================
# Initial parameter guess
r_init = Guess.linear(prob.time_all_section, obj.r0, obj.rf)
# Guess.plot(prob.time_all_section, r_init, "r", "time", "r")
# if(flag_savefig):plt.savefig(savefig_dir + "guess_r" + savefig_add + ".png")
vr_init = Guess.linear(prob.time_all_section, obj.vr0, obj.vrf)
# Guess.plot(prob.time_all_section, vr_init, "vr", "time", "vr")
# if(flag_savefig):plt.savefig(savefig_dir + "guess_vr" + savefig_add + ".png")
vt_init = Guess.linear(prob.time_all_section, obj.vt0, obj.vtf)
# Guess.plot(prob.time_all_section, theta_init, "vt", "time", "vt")
# if(flag_savefig):plt.savefig(savefig_dir + "guess_vt" + savefig_add + ".png")
# ========================
plt.close("all")
# Program Starting Point
time_init = [0.0, 2.0]
n = [20]
num_states = [4]
num_controls = [1]
max_iteration = 50
flag_savefig = True
savefig_dir = "03_2d_simple_rocket/"
# ------------------------
# set OpenGoddard class for algorithm determination
prob = Problem(time_init, n, num_states, num_controls, max_iteration)
obj = Rocket()
# ========================
# Main Process
# Assign problem to SQP solver
prob.dynamics = [dynamics]
prob.knot_states_smooth = []
prob.cost = cost
prob.cost_derivative = None
prob.equality = equality
prob.inequality = inequality
prob.solve(obj)
# ========================
plt.close("all")
plt.ion()
# Program Starting Point
time_init = [0.0, 600.0]
n = [30]
num_states = [3]
num_controls = [1]
max_iteration = 10
flag_savefig = True
savefig_dir = "01_Brachistochrone/Tokyo_"
# ------------------------
# set OpenGoddard class for algorithm determination
prob = Problem(time_init, n, num_states, num_controls, max_iteration)
obj = Ball()
# obj.make_scales()
unit_x = 300000
unit_y = 100000
unit_t = 100
unit_v = unit_x / unit_t
prob.set_unit_states_all_section(0, unit_x)
prob.set_unit_states_all_section(1, unit_y)
prob.set_unit_states_all_section(2, unit_v)
prob.set_unit_controls_all_section(0, 1.0)
prob.set_unit_time(unit_t)
# ========================
# Initial parameter guess