def find_orbit(self, p, plane_change_flag):
r = self.vessel.position(self.ref_frame)
v = self.vessel.velocity(self.ref_frame)
rt = self.conn.space_center.target_vessel.position(self.ref_frame)
vt = self.conn.space_center.target_vessel.velocity(self.ref_frame)
rt2, vt2 = um.cse_rv(rt, vt, p, self.moon.gravitational_parameter)
if plane_change_flag:
v1 = np.sqrt(self.moon.gravitational_parameter *
(2 / um.magnitude(r) - 2 /
(um.magnitude(r) + um.magnitude(rt))))
v1 *= um.normalize(np.cross(np.cross(r, v), r))
else:
v1, v2 = um.cse_rr(r, rt2, p, -1,
self.moon.gravitational_parameter)
delta_velocity = v1 - v
uk.burn(self.conn,
self.ui,
self.ref_frame,
delta_velocity,
stopping_time=(0.1, 0.5, 0.1))
def descent_orbit(self):
target_time = self.calculate_descent_orbit_time()
self.conn.space_center.warp_to(self.conn.space_center.ut +
target_time - 15)
position = np.array(self.vessel.position(self.ref_frame))
velocity = np.array(self.vessel.velocity(self.ref_frame))
speed = np.sqrt(self.moon.gravitational_parameter *
(2 / np.linalg.norm(position) - 2 /
(np.linalg.norm(position) +
self.moon.equatorial_radius + self.periapsis)))
direction = um.normalize(
np.cross(
np.cross(np.array(self.vessel.position(self.ref_frame)),
np.array(self.vessel.velocity(self.ref_frame))),
np.array(self.vessel.position(self.ref_frame))))
delta_velocity = speed * direction - velocity
uk.burn(self.conn,
self.ui,
self.ref_frame,
delta_velocity,
stopping_time=(0.1, 0.5, 0.1))
def execute(self):
current_phase_time = int(self.time_start + self.time_launch)
while current_phase_time > self.conn.space_center.ut:
self.ui.update_phase_current_time(
int(current_phase_time - self.conn.space_center.ut))
current_phase_time = int(self.conn.space_center.ut +
self.launch_time_offset)
while self.vessel.control.throttle > 0.0:
self.ui.update_phase_current_time(
int(current_phase_time - self.conn.space_center.ut))
self.ui.update_phase_current('Low Kerbin Orbit')
self.ui.update_phase_next('TLI Burn')
self.ui.update_message('')
self.ui.update_phase_current_time(0)
self.conn.space_center.physics_warp_factor = 0
self.conn.space_center.warp_to(self.time_start + self.time_start_burn -
60)
self.ui.update_phase_current('TLI Burn')
self.ui.update_phase_next('Extract MEM')
attitude, time_wait = self.burn_wait(self.angle_burn)
uk.burn(self.conn,
self.ui,
self.ref_frame,
self.burn_delta_velocity * attitude,
delay=time_wait,
delta_velocity_offset=-4,
stopping_time=(10.0, 0.5, 10.0),
change_ui_phases=True,
phase_current='TLI Burn',
phase_next='Extract MEM')
self.ui.update_phase_current('Extract MEM')
self.ui.update_phase_next('MCC')
self.ui.update_next_action('Extract MEM')
self.ui.update_phase_current_time(0)
time.sleep(4)
self.conn.space_center.warp_to(self.conn.space_center.ut + 300)
while True:
if self.ui.button.clicked:
self.extract_lem()
self.ui.button.clicked = False
break
def match_speed(self, d, v):
while um.magnitude(self.target.position(
self.vessel.reference_frame)) > d:
pass
cv = np.array(self.vessel.velocity(self.ref_frame)) - np.array(
self.target.velocity(self.ref_frame))
cp = np.array(self.vessel.position(self.ref_frame)) - np.array(
self.target.position(self.ref_frame))
desv = um.normalize(-cp) * v
delta_velocity = desv - cv
uk.burn(self.conn,
self.ui,
self.ref_frame,
delta_velocity,
stopping_time=(0.25, 0.5, 0.25))
def change_inclination(self):
sma_1 = (self.vessel.orbit.semi_major_axis + self.apoapsis +
self.moon.equatorial_radius) / 2
sma_2 = self.apoapsis + self.moon.equatorial_radius
sma_3 = (self.apoapsis +
self.periapsis) / 2 + self.moon.equatorial_radius
period_1 = 2 * np.pi * (sma_1**3 /
self.moon.gravitational_parameter)**0.5
period_2 = 2 * np.pi * (sma_2**3 /
self.moon.gravitational_parameter)**0.5
period_3 = 2 * np.pi * (sma_3**3 /
self.moon.gravitational_parameter)**0.5
self.lan = self.longitude + (
period_1 / 2 + period_2 +
period_3 / 2) / self.moon.orbit.period * 360 + np.degrees(
self.moon.rotation_angle)
delta_longitude = um.safe_asin(
np.tan(np.radians(self.latitude)) / np.tan(self.inclination))
closest_normal = self.calculate_landing_normal(np.radians(self.lan),
delta_longitude)
angle_to_maneuver = self.calculate_angle_to_maneuver(closest_normal)
self.conn.space_center.warp_to(self.conn.space_center.ut +
angle_to_maneuver /
(2 * np.pi) * self.vessel.orbit.period -
15)
attitude = um.normalize(
np.cross(closest_normal,
np.array(self.vessel.position(self.ref_frame))))
delta_velocity = attitude * np.sqrt(
self.moon.gravitational_parameter *
(2 / np.linalg.norm(self.vessel.position(self.ref_frame)) -
1 / sma_1)) - self.vessel.velocity(self.ref_frame)
uk.burn(self.conn,
self.ui,
self.ref_frame,
delta_velocity,
stopping_time=(1.0, 0.5, 1.0))
def circularize(self):
self.conn.space_center.warp_to(self.conn.space_center.ut +
self.vessel.orbit.time_to_periapsis -
15)
circular_speed = np.sqrt(
self.moon.gravitational_parameter /
np.linalg.norm(np.array(self.vessel.position(self.ref_frame))))
circular_direction = um.normalize(
np.cross(
np.cross(np.array(self.vessel.position(self.ref_frame)),
np.array(self.vessel.velocity(self.ref_frame))),
np.array(self.vessel.position(self.ref_frame))))
delta_velocity = circular_speed * circular_direction - np.array(
self.vessel.velocity(self.ref_frame))
uk.burn(self.conn,
self.ui,
self.ref_frame,
delta_velocity,
stopping_time=(1.0, 0.5, 1.0))
def match_speed_mono(self, d, v):
while um.magnitude(self.target.position(
self.vessel.reference_frame)) > d:
pass
cv = np.array(self.vessel.velocity(self.ref_frame)) - np.array(
self.target.velocity(self.ref_frame))
cp = np.array(self.vessel.position(self.ref_frame)) - np.array(
self.target.position(self.ref_frame))
desv = um.normalize(-cp) * v
delta_velocity = desv - cv
uk.burn(self.conn,
self.ui,
self.ref_frame,
delta_velocity,
stopping_time=(0.25, 0.5, 0.25),
main_engine=False,
specified_thrust=4000,
specified_isp=240,
facing=-1)
self.vessel_attitude()
def execute_correction(self):
self.conn.space_center.warp_to(self.maneuver_time - 15)
delta_v = self.maneuver_velocity - np.array(self.vessel.velocity(self.ref_frame))
uk.burn(self.conn, self.ui, self.ref_frame, delta_v, stopping_time=(1.0, 0.5, 1.0))
def execute_correction_rcs(self):
uk.burn(self.conn, self.ui, self.ref_frame, self.delta_v, stopping_time=(1.0, 0.5, 1.0), main_engine=False, specified_thrust=4000, specified_isp=240)
def execute_correction(self):
uk.burn(self.conn, self.ui, self.ref_frame, self.delta_v, stopping_time=(1.0, 0.5, 1.0))
