def check_speeds(self, flight):
up_direction = vector(flight.up_direction)
velocity = vector(flight.velocity)
vertical_speed = dot(velocity, up_direction)
horizontal_speed = norm(velocity) - vertical_speed
self.assertClose(norm(velocity), flight.speed, error=1)
self.assertClose(horizontal_speed, flight.horizontal_speed, error=1)
self.assertClose(vertical_speed, flight.vertical_speed, error=1)
def check_speed(self, flight, ref):
up = normalize(vector(self.vessel.position(ref)) - vector(self.vessel.orbit.body.position(ref)))
v = self.vessel.velocity(ref)
speed = norm(v)
vertical_speed = dot(v, up)
horizontal_speed = math.sqrt(speed*speed - vertical_speed*vertical_speed)
self.assertClose(speed, flight.speed, error=0.5)
self.assertClose(vertical_speed, flight.vertical_speed, error=0.5)
self.assertClose(horizontal_speed, flight.horizontal_speed, error=0.5)
def check_direction(self, direction, pitch, heading):
self.vessel.control.sas = False
self.ap.set_direction(direction)
while self.ap.error > 0.1:
time.sleep(0.25)
self.vessel.control.sas = True
self.ap.disengage()
# Check resulting direction vector
flight = self.vessel.flight()
self.assertClose(vector(direction), vector(flight.direction), error=0.1)
def check_speed(self, flight, ref):
up = normalize(vector(self.vessel.position(ref)) - vector(self.vessel.orbit.body.position(ref)))
v = self.vessel.velocity(ref)
speed = norm(v)
vertical_speed = dot(v, up)
horizontal_speed = speed - abs(vertical_speed)
self.assertClose(speed, flight.speed, error=0.5)
self.assertClose(vertical_speed, flight.vertical_speed, error=0.5)
self.assertClose(horizontal_speed, flight.horizontal_speed, error=0.5)
def test_basic_direction(self):
direction = normalize([10,20,30])
roll = 42
self.vessel.control.sas = False
self.ap.set_direction(direction, roll=roll)
while self.ap.error > 0.1:
time.sleep(0.25)
self.vessel.control.sas = True
self.ap.disengage()
flight = self.vessel.flight()
self.assertClose(vector(direction), vector(flight.direction), error=0.1)
self.assertClose(roll, flight.roll, error=0.5)
def check_directions(self, flight):
""" Check flight.direction against flight.heading and flight.pitch """
direction = vector(flight.direction)
up_direction = (1,0,0)
north_direction = (0,1,0)
self.assertClose(1, norm(direction))
# Check vessel direction vector agrees with pitch angle
pitch = 90 - rad2deg(math.acos(dot(up_direction, direction)))
self.assertClose(flight.pitch, pitch, error=2)
# Check vessel direction vector agrees with heading angle
up_component = dot(direction, up_direction) * vector(up_direction)
north_component = normalize(vector(direction) - up_component)
self.assertCloseDegrees(flight.heading, rad2deg(math.acos(dot(north_component, north_direction))), error=1)
def check_directions(self, flight):
""" Check flight.direction against flight.heading and flight.pitch """
direction = vector(flight.direction)
up_direction = (1,0,0)
north_direction = (0,1,0)
self.assertClose(1, norm(direction))
# Check vessel direction vector agrees with pitch angle
pitch = 90 - rad2deg(math.acos(dot(up_direction, direction)))
self.assertClose(flight.pitch, pitch, error=2)
# Check vessel direction vector agrees with heading angle
up_component = dot(direction, up_direction) * vector(up_direction)
north_component = normalize(vector(direction) - up_component)
self.assertCloseDegrees(flight.heading, rad2deg(math.acos(dot(north_component, north_direction))), error=1)
def test_set_magnitude(self):
node = self.control.add_node(self.conn.space_center.ut, 1, -2, 3)
magnitude = 128
node.delta_v = magnitude
v = vector(normalize([1,-2,3])) * magnitude
self.check(node, v)
node.remove()
def test_set_magnitude(self):
node = self.control.add_node(self.conn.space_center.ut, 1, -2, 3)
magnitude = 128
node.delta_v = magnitude
v = vector(normalize([1,-2,3])) * magnitude
self.check(node, v)
node.remove()
def check_speeds(self, flight):
""" Check flight.velocity agrees with flight.*_speed """
up_direction = (0,1,0)
velocity = vector(flight.velocity)
vertical_speed = dot(velocity, up_direction)
horizontal_speed = norm(velocity) - vertical_speed
self.assertClose(norm(velocity), flight.speed, error=1)
self.assertClose(horizontal_speed, flight.horizontal_speed, error=1)
self.assertClose(vertical_speed, flight.vertical_speed, error=1)
def check_speeds(self, flight):
""" Check flight.velocity agrees with flight.*_speed """
up_direction = (0,1,0)
velocity = vector(flight.velocity)
vertical_speed = dot(velocity, up_direction)
horizontal_speed = norm(velocity) - vertical_speed
self.assertClose(norm(velocity), flight.speed, error=1)
self.assertClose(horizontal_speed, flight.horizontal_speed, error=1)
self.assertClose(vertical_speed, flight.vertical_speed, error=1)
def test_maneuver_flight(self):
# Create a node with burn vector pointing north
# and check that orbital flight vectors
node = self.vessel.control.add_node(self.conn.space_center.ut, 100, 0, 0)
self.assertClose([ 0, 0, 100], vector(node.vector))
self.assertClose([ 0, 0, 1], vector(self.maneuver_flight.prograde), error=0.01)
self.assertClose([ 0, 0, -1], vector(self.maneuver_flight.retrograde), error=0.01)
self.assertClose([ 0,-1, 0], vector(self.maneuver_flight.radial), error=0.01)
self.assertClose([ 0, 1, 0], vector(self.maneuver_flight.radial_neg), error=0.01)
self.assertClose([ 1, 0, 0], vector(self.maneuver_flight.normal), error=0.01)
self.assertClose([-1, 0, 0], vector(self.maneuver_flight.normal_neg), error=0.01)
self.check_directions(self.maneuver_flight, check_against_orbital=False)
self.check_speeds(self.maneuver_flight)
self.check_orbital_vectors(self.maneuver_flight)
def test_flight_orbit_body_non_rotating_reference_frame(self):
ref = self.vessel.orbit.body.non_rotating_reference_frame
flight = self.vessel.flight(ref)
self.check_properties_not_affected_by_reference_frame(flight)
speed = 2246.1
self.assertClose(speed, norm(flight.velocity), error=0.5)
position = self.vessel.position(ref)
direction = vector(cross(normalize(position), (0,1,0)))
velocity = direction * speed
self.assertClose(velocity, flight.velocity, error=2)
self.assertClose(speed, flight.speed, error=0.5)
self.assertClose(speed, flight.horizontal_speed, error=0.5)
self.assertClose(0, flight.vertical_speed, error=0.5)
self.check_speeds(flight)
self.check_orbital_vectors(flight)
def test_flight_orbit_body_non_rotating_reference_frame(self):
ref = self.vessel.orbit.body.non_rotating_reference_frame
flight = self.vessel.flight(ref)
self.check_properties_not_affected_by_reference_frame(flight)
speed = 2246.1
self.assertClose(speed, norm(flight.velocity), error=0.5)
position = self.vessel.position(ref)
direction = vector(cross(normalize(position), (0,1,0)))
velocity = direction * speed
self.assertClose(velocity, flight.velocity, error=2)
self.assertClose(speed, flight.speed, error=0.5)
self.assertClose(speed, flight.horizontal_speed, error=0.5)
self.assertClose(0, flight.vertical_speed, error=0.5)
self.check_speeds(flight)
self.check_orbital_vectors(flight)
def test_surface_flight(self):
self.assertClose(0, self.orbital_flight.g_force)
self.assertClose(100000, self.surface_flight.mean_altitude, error=50)
self.assertClose(100000, self.surface_flight.surface_altitude, error=50)
self.assertClose(100930, self.surface_flight.bedrock_altitude, error=50)
self.assertClose(930, self.surface_flight.elevation, error=50)
self.assertClose([-2042.5, 0, 0], vector(self.surface_flight.velocity), error=0.5)
self.assertClose(2042.5, self.surface_flight.speed, error=0.5)
self.assertClose(2042.5, self.surface_flight.horizontal_speed, error=0.5)
self.assertClose(0, self.surface_flight.vertical_speed, error=0.5)
self.assertClose(27, self.surface_flight.pitch, error=1)
self.assertClose(116, self.surface_flight.heading, error=1)
self.assertClose(39, self.surface_flight.roll, error=1)
self.check_directions(self.surface_flight)
self.check_speeds(self.surface_flight)
self.check_orbital_vectors(self.surface_flight)
def check_orbital_vectors(self, flight):
# Check orbital direction vectors
prograde = vector(flight.prograde)
retrograde = vector(flight.retrograde)
normal = vector(flight.normal)
normal_neg = vector(flight.normal_neg)
radial = vector(flight.radial)
radial_neg = vector(flight.radial_neg)
self.assertClose(1, norm(prograde))
self.assertClose(1, norm(retrograde))
self.assertClose(1, norm(normal))
self.assertClose(1, norm(normal_neg))
self.assertClose(1, norm(radial))
self.assertClose(1, norm(radial_neg))
self.assertClose(prograde, [-x for x in retrograde], error=0.01)
self.assertClose(radial, [-x for x in radial_neg], error=0.01)
self.assertClose(normal, [-x for x in normal_neg], error=0.01)
self.assertClose(0, dot(prograde, radial), error=0.01)
self.assertClose(0, dot(prograde, normal), error=0.01)
self.assertClose(0, dot(radial, normal), error=0.01)
def check_orbital_vectors(self, flight):
""" Check orbital direction vectors """
prograde = vector(flight.prograde)
retrograde = vector(flight.retrograde)
normal = vector(flight.normal)
anti_normal = vector(flight.anti_normal)
radial = vector(flight.radial)
anti_radial = vector(flight.anti_radial)
self.assertClose(1, norm(prograde))
self.assertClose(1, norm(retrograde))
self.assertClose(1, norm(normal))
self.assertClose(1, norm(anti_normal))
self.assertClose(1, norm(radial))
self.assertClose(1, norm(anti_radial))
self.assertClose(prograde, [-x for x in retrograde], error=0.01)
self.assertClose(radial, [-x for x in anti_radial], error=0.01)
self.assertClose(normal, [-x for x in anti_normal], error=0.01)
self.assertClose(0, dot(prograde, radial), error=0.01)
self.assertClose(0, dot(prograde, normal), error=0.01)
self.assertClose(0, dot(radial, normal), error=0.01)
def check_orbital_vectors(self, flight):
""" Check orbital direction vectors """
prograde = vector(flight.prograde)
retrograde = vector(flight.retrograde)
normal = vector(flight.normal)
anti_normal = vector(flight.anti_normal)
radial = vector(flight.radial)
anti_radial = vector(flight.anti_radial)
self.assertClose(1, norm(prograde))
self.assertClose(1, norm(retrograde))
self.assertClose(1, norm(normal))
self.assertClose(1, norm(anti_normal))
self.assertClose(1, norm(radial))
self.assertClose(1, norm(anti_radial))
self.assertClose(prograde, [-x for x in retrograde], error=0.01)
self.assertClose(radial, [-x for x in anti_radial], error=0.01)
self.assertClose(normal, [-x for x in anti_normal], error=0.01)
self.assertClose(0, dot(prograde, radial), error=0.01)
self.assertClose(0, dot(prograde, normal), error=0.01)
self.assertClose(0, dot(radial, normal), error=0.01)
def check_directions(self, flight, check_against_orbital=True):
direction = vector(flight.direction)
up_direction = vector(flight.up_direction)
north_direction = vector(flight.north_direction)
self.assertClose(1, norm(direction))
self.assertClose(1, norm(up_direction))
self.assertClose(1, norm(north_direction))
self.assertClose(0, dot(up_direction, north_direction))
# Check vessel direction vector agrees with pitch angle
pitch = 90 - rad2deg(math.acos(dot(up_direction, direction)))
self.assertClose(flight.pitch, pitch, error=2)
# Check vessel direction vector agrees with heading angle
up_component = dot(direction, up_direction) * vector(up_direction)
north_component = vector(direction) - up_component
north_component = north_component / norm(north_component)
self.assertClose(flight.heading, rad2deg(math.acos(dot(north_component, north_direction))), error=1)
if check_against_orbital == True:
# Check vessel directions agree with orbital directions
# (we are in a 0 degree inclined orbit, so they should do)
self.assertClose(1, dot(up_direction, vector(flight.radial)))
self.assertClose(1, dot(north_direction, vector(flight.normal)))
def check(self, node, v):
self.assertEqual(v[0], node.prograde)
self.assertEqual(v[1], node.normal)
self.assertEqual(v[2], node.radial)
self.assertEqual([0,0,norm(v)], vector(node.vector))
self.assertEqual(norm(v), node.delta_v)
