def test_velocity(self): for body in self.space_center.bodies.values(): if body.orbit is None: continue # Check body velocity in body's reference frame v = body.velocity(body.reference_frame) self.assertAlmostEqual((0, 0, 0), v) # Check body velocity in parent body's non-rotating reference frame v = body.velocity(body.orbit.body.non_rotating_reference_frame) self.assertAlmostEqual(body.orbit.speed, norm(v), places=2) # Check body velocity in parent body's reference frame v = body.velocity(body.orbit.body.reference_frame) if body.orbit.inclination == 0: self.assertAlmostEqual(0, v[1]) else: self.assertNotAlmostEqual(0, v[1]) angular_velocity = body.orbit.body.angular_velocity( body.orbit.body.non_rotating_reference_frame) self.assertAlmostEqual(0, angular_velocity[0]) self.assertAlmostEqual(0, angular_velocity[2]) rotational_speed = dot((0, 1, 0), angular_velocity) position = list(body.position(body.orbit.body.reference_frame)) position[1] = 0 radius = norm(position) rotational_speed *= radius # TODO: large error self.assertAlmostEqual(abs(rotational_speed + body.orbit.speed), norm(v), delta=500)
def test_velocity(self): for body in self.space_center.bodies.values(): if body.orbit is None: continue # Check body velocity in body's reference frame v = body.velocity(body.reference_frame) self.assertAlmostEqual((0, 0, 0), v) # Check body velocity in parent body's non-rotating reference frame v = body.velocity(body.orbit.body.non_rotating_reference_frame) self.assertAlmostEqual(body.orbit.speed, norm(v), places=3) # Check body velocity in parent body's reference frame v = body.velocity(body.orbit.body.reference_frame) if body.orbit.inclination == 0: self.assertAlmostEqual(0, v[1]) else: self.assertNotAlmostEqual(0, v[1]) angular_velocity = body.orbit.body.angular_velocity( body.orbit.body.non_rotating_reference_frame) self.assertAlmostEqual(0, angular_velocity[0]) self.assertAlmostEqual(0, angular_velocity[2]) rotational_speed = dot((0, 1, 0), angular_velocity) position = list(body.position(body.orbit.body.reference_frame)) position[1] = 0 radius = norm(position) rotational_speed *= radius #TODO: large error self.assertAlmostEqual(abs(rotational_speed + body.orbit.speed), norm(v), delta=500)
def test_transform_position_between_vessel_and_celestial_bodies(self): p0 = self.sc.transform_position((0, 0, 0), self.ref_vessel, self.ref_kerbin) p1 = self.sc.transform_position((0, 0, 0), self.ref_vessel, self.ref_sun) p2 = self.sc.transform_position((0, 0, 0), self.ref_kerbin, self.ref_sun) p3 = tuple(x-y for (x, y) in zip(p1, p2)) #TODO: sometimes there is a large difference?!?! but only sometimes... self.assertAlmostEqual(norm(p0), norm(p3), delta=5000)
def test_transform_position_between_celestial_bodies(self): pos = self.sc.transform_position( (0, 0, 0), self.ref_kerbin, self.ref_mun) self.assertAlmostEqual(norm(pos), self.mun.orbit.radius, places=3) pos = self.sc.transform_position( (0, 0, 0), self.ref_sun, self.ref_kerbin) self.assertAlmostEqual(norm(pos), self.kerbin.orbit.radius, places=3)
def test_transform_position_between_celestial_bodies(self): pos = self.sc.transform_position((0, 0, 0), self.ref_kerbin, self.ref_mun) self.assertAlmostEqual(norm(pos), self.mun.orbit.radius, places=3) pos = self.sc.transform_position((0, 0, 0), self.ref_sun, self.ref_kerbin) self.assertAlmostEqual(norm(pos), self.kerbin.orbit.radius, places=3)
def test_transform_velocity_between_vessel_and_celestial_bodies(self): v0 = self.sc.transform_velocity( (0, 0, 0), (0, 0, 0), self.ref_vessel, self.ref_nr_kerbin) v1 = self.sc.transform_velocity( (0, 0, 0), (0, 0, 0), self.ref_vessel, self.ref_nr_sun) v2 = self.sc.transform_velocity( (0, 0, 0), (0, 0, 0), self.ref_nr_kerbin, self.ref_nr_sun) v3 = tuple(x-y for (x, y) in zip(v1, v2)) self.assertAlmostEqual(norm(v0), norm(v3), places=3)
def test_transform_velocity_between_vessel_and_celestial_bodies(self): v0 = self.sc.transform_velocity((0, 0, 0), (0, 0, 0), self.ref_vessel, self.ref_nr_kerbin) v1 = self.sc.transform_velocity((0, 0, 0), (0, 0, 0), self.ref_vessel, self.ref_nr_sun) v2 = self.sc.transform_velocity((0, 0, 0), (0, 0, 0), self.ref_nr_kerbin, self.ref_nr_sun) v3 = tuple(x - y for (x, y) in zip(v1, v2)) self.assertAlmostEqual(norm(v0), norm(v3), places=3)
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.assertAlmostEqual(norm(velocity), flight.speed, delta=1) self.assertAlmostEqual(horizontal_speed, flight.horizontal_speed, delta=1) self.assertAlmostEqual(vertical_speed, flight.vertical_speed, delta=1)
def test_transform_velocity_between_celestial_bodies(self): v1 = self.sc.transform_velocity((0, 0, 0), (0, 0, 0), self.ref_nr_mun, self.ref_nr_kerbin) v2 = self.sc.transform_velocity((0, 0, 0), (0, 0, 0), self.ref_nr_kerbin, self.ref_nr_mun) self.assertAlmostEqual(self.mun.orbit.speed, norm(v1), places=3) self.assertAlmostEqual(self.mun.orbit.speed, norm(v2), places=3) self.assertAlmostEqual(v1, tuple(-x for x in v2), places=3) v1 = self.sc.transform_velocity((0, 0, 0), (0, 0, 0), self.ref_nr_kerbin, self.ref_nr_sun) v2 = self.sc.transform_velocity((0, 0, 0), (0, 0, 0), self.ref_nr_sun, self.ref_nr_kerbin) self.assertAlmostEqual(self.kerbin.orbit.speed, norm(v1), places=3) self.assertAlmostEqual(self.kerbin.orbit.speed, norm(v2), places=3) self.assertAlmostEqual(v1, tuple(-x for x in v2), places=3)
def test_transform_velocity_with_rotational_velocity(self): direction = 100000 + 600000 vel = self.sc.transform_velocity((direction, 0, 0), (0, 0, 0), self.ref_kerbin, self.ref_nr_kerbin) self.assertAlmostEqual(norm(vel), direction * self.kerbin.rotational_speed, places=3)
def check_object_velocity(self, obj, ref): # Check velocity vectors are unchanged by converting between the same reference frame self.assertAlmostEqual((1, 2, 3), self.space_center.transform_velocity((0, 0, 0), (1, 2, 3), ref, ref)) if obj.orbit is not None: # Check velocity of reference frame is same as orbital speed # in reference frame of body being orbited v = self.space_center.transform_velocity((0, 0, 0), (0, 0, 0), ref, obj.orbit.body.non_rotating_reference_frame) self.assertAlmostEqual(norm(v), obj.orbit.speed, delta=0.5)
def check_radius_and_speed(self, obj, orbit): # Compute position from orbital elements pos = compute_position(obj, orbit.body.non_rotating_reference_frame) # Compute radius from position radius = norm(pos) * 1000000 self.assertAlmostEqual(radius, orbit.radius, delta=1) # Compute speed from radius speed = math.sqrt(orbit.body.gravitational_parameter * ((2/radius)-(1/orbit.semi_major_axis))) self.assertAlmostEqual(speed, orbit.speed, delta=1)
def test_angular_velocity(self): for body in self.space_center.bodies.values(): # Check body's angular velocity relative to itself is zero av = body.angular_velocity(body.reference_frame) self.assertAlmostEqual((0, 0, 0), av) # Check body's angular velocity relative to it's own non-rotating reference frame av = body.angular_velocity(body.non_rotating_reference_frame) self.assertAlmostEqual((0, -1, 0), normalize(av)) self.assertAlmostEqual(body.rotational_speed, norm(av))
def check_radius_and_speed(self, obj, orbit): # Compute position from orbital elements pos = compute_position(obj, orbit.body.non_rotating_reference_frame) # Compute radius from position radius = norm(pos) * 1000000 self.assertAlmostEqual(radius, orbit.radius, delta=1) # Compute speed from radius speed = math.sqrt(orbit.body.gravitational_parameter * ((2 / radius) - (1 / orbit.semi_major_axis))) self.assertAlmostEqual(speed, orbit.speed, delta=1)
def check_object_surface_velocity(self, obj, ref): if obj.orbit is not None: # Check rotational component of velocity same as orbital speed v = self.space_center.transform_velocity((0, 0, 0), (0, 0, 0), ref, obj.orbit.body.reference_frame) #if obj.orbit.inclination == 0: # self.assertAlmostEqual(0, v[1]) #else: # self.assertNotAlmostEqual(0, v[1]) angular_velocity = obj.orbit.body.angular_velocity( obj.orbit.body.non_rotating_reference_frame) self.assertAlmostEqual(0, angular_velocity[0]) self.assertAlmostEqual(0, angular_velocity[2]) rotational_speed = dot((0, 1, 0), angular_velocity) position = list(obj.position(obj.orbit.body.reference_frame)) position[1] = 0 radius = norm(position) rotational_speed *= radius #TODO: large error self.assertAlmostEqual(abs(rotational_speed + obj.orbit.speed), norm(v), delta=200)
def check_object_velocity(self, obj, ref): # Check velocity vectors are unchanged by converting between the same reference frame self.assertAlmostEqual((1, 2, 3), self.space_center.transform_velocity( (0, 0, 0), (1, 2, 3), ref, ref)) if obj.orbit is not None: # Check velocity of reference frame is same as orbital speed # in reference frame of body being orbited v = self.space_center.transform_velocity( (0, 0, 0), (0, 0, 0), ref, obj.orbit.body.non_rotating_reference_frame) self.assertAlmostEqual(norm(v), obj.orbit.speed, delta=0.5)
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.assertAlmostEqual(speed, flight.speed, delta=0.5) self.assertAlmostEqual(vertical_speed, flight.vertical_speed, delta=0.5) self.assertAlmostEqual(horizontal_speed, flight.horizontal_speed, delta=0.5)
def check(self, node, delta_v): self.assertAlmostEqual(delta_v[0], node.prograde, places=3) self.assertAlmostEqual(delta_v[1], node.normal, places=3) self.assertAlmostEqual(delta_v[2], node.radial, places=3) self.assertAlmostEqual(norm(delta_v), node.delta_v, places=3) self.assertAlmostEqual(norm(delta_v), node.remaining_delta_v, delta=0.2) bv = node.burn_vector(node.reference_frame) self.assertAlmostEqual(norm(delta_v), norm(bv), places=3) self.assertAlmostEqual((0, 1, 0), normalize(bv), places=3) orbital_bv = node.burn_vector(node.orbital_reference_frame) self.assertAlmostEqual(norm(delta_v), norm(orbital_bv), places=3) self.assertAlmostEqual((-delta_v[2], delta_v[0], delta_v[1]), orbital_bv, places=3) direction = node.direction(node.reference_frame) self.assertAlmostEqual((0, 1, 0), direction, places=3) orbital_direction = node.direction(node.orbital_reference_frame) self.assertAlmostEqual(normalize( (-delta_v[2], delta_v[0], delta_v[1])), orbital_direction, places=3)
def check_object_position(self, obj, ref): # Check (0, 0, 0) position is at object position self.assertAlmostEqual((0, 0, 0), obj.position(ref)) # Check norm of object position is same as objects orbital radius if obj.orbit is not None: pos = obj.orbit.body.position(ref) self.assertAlmostEqual(obj.orbit.radius, norm(pos), delta=20) # Check position agrees with that calculated from bodies orbit if obj.name in ('Kerbin', 'Mun', 'Minmus', 'Test'): ref = obj.orbit.body.reference_frame expected_pos = compute_position(obj, ref) actual_pos = tuple(x / 1000000 for x in obj.position(ref)) self.assertAlmostEqual(expected_pos, actual_pos, delta=1)
def check_object_surface_velocity(self, obj, ref): if obj.orbit is not None: # Check rotational component of velocity same as orbital speed v = self.space_center.transform_velocity( (0, 0, 0), (0, 0, 0), ref, obj.orbit.body.reference_frame) # if obj.orbit.inclination == 0: # self.assertAlmostEqual(0, v[1]) # else: # self.assertNotAlmostEqual(0, v[1]) angular_velocity = obj.orbit.body.angular_velocity( obj.orbit.body.non_rotating_reference_frame) self.assertAlmostEqual(0, angular_velocity[0]) self.assertAlmostEqual(0, angular_velocity[2]) rotational_speed = dot((0, 1, 0), angular_velocity) position = list(obj.position(obj.orbit.body.reference_frame)) position[1] = 0 radius = norm(position) rotational_speed *= radius # TODO: large error self.assertAlmostEqual(abs(rotational_speed + obj.orbit.speed), norm(v), delta=200)
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.assertAlmostEqual(speed, flight.speed, delta=0.5) self.assertAlmostEqual(vertical_speed, flight.vertical_speed, delta=0.5) self.assertAlmostEqual(horizontal_speed, flight.horizontal_speed, delta=0.5)
def test_position(self): for body in self.space_center.bodies.values(): # Check body position in body's reference frame pos = body.position(body.reference_frame) self.assertAlmostEqual((0, 0, 0), pos) # Check body position in parent body's reference frame if body.orbit is not None: pos = body.position(body.orbit.body.reference_frame) if body.orbit.inclination == 0: self.assertAlmostEqual(0, pos[1]) else: self.assertNotAlmostEqual(0, pos[1]) # TODO: large error self.assertAlmostEqual(body.orbit.radius, norm(pos), delta=100)
def test_position(self): for body in self.space_center.bodies.values(): # Check body position in body's reference frame pos = body.position(body.reference_frame) self.assertAlmostEqual((0, 0, 0), pos) # Check body position in parent body's reference frame if body.orbit is not None: pos = body.position(body.orbit.body.reference_frame) if body.orbit.inclination == 0: self.assertAlmostEqual(0, pos[1]) else: self.assertNotAlmostEqual(0, pos[1]) #TODO: large error self.assertAlmostEqual(body.orbit.radius, norm(pos), delta=100)
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.assertAlmostEqual(1, norm(direction)) # Check vessel direction vector agrees with pitch angle pitch = 90 - rad2deg(math.acos(dot(up_direction, direction))) self.assertAlmostEqual(pitch, flight.pitch, delta=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.assertDegreesAlmostEqual( rad2deg(math.acos(dot(north_component, north_direction))), flight.heading, delta=1)
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 = 2245.75 self.assertAlmostEqual(speed, norm(flight.velocity), delta=0.5) position = self.vessel.position(ref) direction = vector(cross(normalize(position), (0, 1, 0))) velocity = direction * speed self.assertAlmostEqual(tuple(velocity), flight.velocity, delta=2) self.assertAlmostEqual(speed, flight.speed, delta=0.5) self.assertAlmostEqual(speed, flight.horizontal_speed, delta=0.5) self.assertAlmostEqual(0, flight.vertical_speed, delta=0.5) self.check_speeds(flight) self.check_orbital_vectors(flight)
def test_pre_attached_ports(self): """ Test ports that were pre-attached in the VAB """ bottom_port = next( p for p in self.parts.docking_ports if p.part.parent.title == 'Clamp-O-Tron Docking Port') top_port = bottom_port.part.parent.docking_port launch_clamp = bottom_port.part.children[0].launch_clamp self.assertEqual(self.State.docked, top_port.state) self.assertEqual(self.State.docked, bottom_port.state) self.assertEqual(top_port.part, bottom_port.docked_part) self.assertEqual(bottom_port.part, top_port.docked_part) # Undock mass_before = self.vessel.mass undocked = top_port.undock() mass_after = self.vessel.mass self.assertIsNone(bottom_port.docked_part) self.assertIsNone(top_port.docked_part) # Undocking self.assertNotEqual(self.vessel, undocked) self.assertLess(mass_after, mass_before) self.assertAlmostEqual(mass_after, mass_before - undocked.mass, places=2) self.assertEqual(self.State.undocking, top_port.state) self.assertEqual(self.State.undocking, bottom_port.state) self.assertIsNone(bottom_port.docked_part) self.assertIsNone(top_port.docked_part) # Drop the port launch_clamp.release() while (top_port.state == self.State.undocking or bottom_port.state == self.State.undocking): pass # Undocked self.assertEqual(self.State.ready, top_port.state) self.assertEqual(self.State.ready, bottom_port.state) self.assertIsNone(bottom_port.docked_part) self.assertIsNone(top_port.docked_part) distance = norm(top_port.position(bottom_port.reference_frame)) self.assertGreater(distance, top_port.reengage_distance) self.assertLess(distance, top_port.reengage_distance + 1)
def test_pre_attached_ports(self): """ Test ports that were pre-attached in the VAB """ bottom_port = next( p for p in self.parts.docking_ports if p.part.parent.title == 'Clamp-O-Tron Docking Port') top_port = bottom_port.part.parent.docking_port launch_clamp = bottom_port.part.children[0].launch_clamp self.assertEqual(self.State.docked, top_port.state) self.assertEqual(self.State.docked, bottom_port.state) self.assertEqual(top_port.part, bottom_port.docked_part) self.assertEqual(bottom_port.part, top_port.docked_part) # Undock mass_before = self.vessel.mass undocked = top_port.undock() mass_after = self.vessel.mass self.assertIsNone(bottom_port.docked_part) self.assertIsNone(top_port.docked_part) # Undocking self.assertNotEqual(self.vessel, undocked) self.assertLess(mass_after, mass_before) self.assertAlmostEqual( mass_after, mass_before - undocked.mass, places=2) self.assertEqual(self.State.undocking, top_port.state) self.assertEqual(self.State.undocking, bottom_port.state) self.assertIsNone(bottom_port.docked_part) self.assertIsNone(top_port.docked_part) # Drop the port launch_clamp.release() while (top_port.state == self.State.undocking or bottom_port.state == self.State.undocking): pass # Undocked self.assertEqual(self.State.ready, top_port.state) self.assertEqual(self.State.ready, bottom_port.state) self.assertIsNone(bottom_port.docked_part) self.assertIsNone(top_port.docked_part) distance = norm(top_port.position(bottom_port.reference_frame)) self.assertGreater(distance, top_port.reengage_distance) self.assertLess(distance, top_port.reengage_distance+1)
def check(self, node, delta_v): self.assertAlmostEqual(delta_v[0], node.prograde, places=3) self.assertAlmostEqual(delta_v[1], node.normal, places=3) self.assertAlmostEqual(delta_v[2], node.radial, places=3) self.assertAlmostEqual(norm(delta_v), node.delta_v, places=3) self.assertAlmostEqual(norm(delta_v), node.remaining_delta_v, delta=0.2) bv = node.burn_vector(node.reference_frame) self.assertAlmostEqual(norm(delta_v), norm(bv), places=3) self.assertAlmostEqual((0, 1, 0), normalize(bv), places=3) orbital_bv = node.burn_vector(node.orbital_reference_frame) self.assertAlmostEqual(norm(delta_v), norm(orbital_bv), places=3) self.assertAlmostEqual((-delta_v[2], delta_v[0], delta_v[1]), orbital_bv, places=3) direction = node.direction(node.reference_frame) self.assertAlmostEqual((0, 1, 0), direction, places=3) orbital_direction = node.direction(node.orbital_reference_frame) self.assertAlmostEqual(normalize((-delta_v[2], delta_v[0], delta_v[1])), orbital_direction, places=3)
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.assertAlmostEqual(1, norm(prograde)) self.assertAlmostEqual(1, norm(retrograde)) self.assertAlmostEqual(1, norm(normal)) self.assertAlmostEqual(1, norm(anti_normal)) self.assertAlmostEqual(1, norm(radial)) self.assertAlmostEqual(1, norm(anti_radial)) self.assertAlmostEqual(tuple(prograde), [-x for x in retrograde], places=2) self.assertAlmostEqual(tuple(radial), [-x for x in anti_radial], places=2) self.assertAlmostEqual(tuple(normal), [-x for x in anti_normal], places=2) self.assertAlmostEqual(0, dot(prograde, radial), places=2) self.assertAlmostEqual(0, dot(prograde, normal), places=2) self.assertAlmostEqual(0, dot(radial, normal), places=2)
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.assertAlmostEqual(1, norm(prograde)) self.assertAlmostEqual(1, norm(retrograde)) self.assertAlmostEqual(1, norm(normal)) self.assertAlmostEqual(1, norm(anti_normal)) self.assertAlmostEqual(1, norm(radial)) self.assertAlmostEqual(1, norm(anti_radial)) self.assertAlmostEqual( tuple(prograde), [-x for x in retrograde], places=2) self.assertAlmostEqual( tuple(radial), [-x for x in anti_radial], places=2) self.assertAlmostEqual( tuple(normal), [-x for x in anti_normal], places=2) self.assertAlmostEqual(0, dot(prograde, radial), places=2) self.assertAlmostEqual(0, dot(prograde, normal), places=2) self.assertAlmostEqual(0, dot(radial, normal), places=2)
def test_norm(self): self.assertAlmostEqual(0, norm((0, 0, 0))) self.assertAlmostEqual(1, norm((1, 0, 0))) self.assertAlmostEqual(2, norm((2, 0, 0))) self.assertAlmostEqual(math.sqrt(2), norm((1, 1, 0)))
def undock_and_dock(self, port1, port2): vessel = self.sc.active_vessel # Do it twice - once to undock pre-attached ports, once to undock ports docked in flight for _ in range(2): # Kill rotation vessel.control.sas = True self.wait(3) vessel.control.sas = False self.wait() self.assertEqual(self.state.docked, port1.state) self.assertEqual(self.state.docked, port2.state) self.assertEqual(port1.part, port2.docked_part) self.assertEqual(port2.part, port1.docked_part) # Undock mass_before = vessel.mass undocked = port1.undock() self.assertNotEqual(vessel, undocked) self.assertEqual(self.state.undocking, port1.state) self.assertEqual(self.state.undocking, port2.state) self.assertIsNone(port2.docked_part) self.assertIsNone(port1.docked_part) mass_after = vessel.mass self.assertLess(mass_after, mass_before) self.assertAlmostEqual(mass_after, mass_before - undocked.mass, places=2) # Move backwards to reengage distance vessel.control.rcs = True vessel.control.forward = -0.5 self.wait(0.5) vessel.control.forward = 0.0 while port1.state == self.state.undocking or port2.state == self.state.undocking: self.wait() self.assertEqual(self.state.ready, port1.state) self.assertEqual(self.state.ready, port2.state) self.assertIsNone(port2.docked_part) self.assertIsNone(port1.docked_part) distance = norm(port1.position(port2.reference_frame)) self.assertGreater(distance, port1.reengage_distance) self.assertLess(distance, port1.reengage_distance+1) self.wait(0.5) # Check undocking when not docked with self.assertRaises(krpc.error.RPCError) as cm: port1.undock() self.assertTrue('The docking port is not docked' in str(cm.exception)) with self.assertRaises(krpc.error.RPCError) as cm: port2.undock() self.assertTrue('The docking port is not docked' in str(cm.exception)) # Move forward vessel.control.forward = 0.5 self.wait(1) vessel.control.forward = 0.0 vessel.control.rcs = False while port1.state == self.state.ready or port2.state == self.state.ready: self.wait() # Docking self.assertEqual(self.state.docking, port1.state) self.assertEqual(self.state.docking, port2.state) while port1.state == self.state.docking or port2.state == self.state.docking: self.wait() # Docked self.assertEqual(self.state.docked, port1.state) self.assertEqual(self.state.docked, port2.state) self.assertEqual(port1.part, port2.docked_part) self.assertEqual(port2.part, port1.docked_part) # Get the new vessel vessel = self.sc.active_vessel
def undock_and_dock(self, port1, port2): vessel = self.sc.active_vessel # Do it twice - once to undock pre-attached ports, once to undock ports docked in flight for _ in range(2): # Kill rotation vessel.control.sas = True self.wait(3) vessel.control.sas = False self.wait() self.assertEqual(self.state.docked, port1.state) self.assertEqual(self.state.docked, port2.state) self.assertEqual(port1.part, port2.docked_part) self.assertEqual(port2.part, port1.docked_part) # Undock mass_before = vessel.mass undocked = port1.undock() self.assertNotEqual(vessel, undocked) self.assertEqual(self.state.undocking, port1.state) self.assertEqual(self.state.undocking, port2.state) self.assertIsNone(port2.docked_part) self.assertIsNone(port1.docked_part) mass_after = vessel.mass self.assertLess(mass_after, mass_before) self.assertAlmostEqual(mass_after, mass_before - undocked.mass, places=3) # Move backwards to reengage distance vessel.control.rcs = True vessel.control.forward = -0.5 self.wait(0.5) vessel.control.forward = 0.0 while port1.state == self.state.undocking or port2.state == self.state.undocking: self.wait() self.assertEqual(self.state.ready, port1.state) self.assertEqual(self.state.ready, port2.state) self.assertIsNone(port2.docked_part) self.assertIsNone(port1.docked_part) distance = norm(port1.position(port2.reference_frame)) self.assertGreater(distance, port1.reengage_distance) self.assertLess(distance, port1.reengage_distance + 1) self.wait(0.5) # Check undocking when not docked with self.assertRaises(krpc.error.RPCError) as cm: port1.undock() self.assertTrue( 'The docking port is not docked' in str(cm.exception)) with self.assertRaises(krpc.error.RPCError) as cm: port2.undock() self.assertTrue( 'The docking port is not docked' in str(cm.exception)) # Move forward vessel.control.forward = 0.5 self.wait(1) vessel.control.forward = 0.0 vessel.control.rcs = False while port1.state == self.state.ready or port2.state == self.state.ready: self.wait() # Docking self.assertEqual(self.state.docking, port1.state) self.assertEqual(self.state.docking, port2.state) while port1.state == self.state.docking or port2.state == self.state.docking: self.wait() # Docked self.assertEqual(self.state.docked, port1.state) self.assertEqual(self.state.docked, port2.state) self.assertEqual(port1.part, port2.docked_part) self.assertEqual(port2.part, port1.docked_part) # Get the new vessel vessel = self.sc.active_vessel
def test_transform_velocity_between_vessel_and_celestial_body(self): vel = self.sc.transform_velocity((0, 0, 0), (0, 0, 0), self.ref_vessel, self.ref_nr_kerbin) self.assertAlmostEqual(norm(vel), self.vessel.orbit.speed, places=3)
def test_transform_position_between_vessel_and_celestial_body(self): pos = self.sc.transform_position((0, 0, 0), self.ref_vessel, self.ref_kerbin) self.assertAlmostEqual(norm(pos), self.vessel.orbit.radius, places=2)
def test_transform_position_between_vessel_and_celestial_body(self): pos = self.sc.transform_position( (0, 0, 0), self.ref_vessel, self.ref_kerbin) self.assertAlmostEqual(norm(pos), self.vessel.orbit.radius, places=2)
def test_transform_velocity_with_rotational_velocity(self): direction = 100000 + 600000 vel = self.sc.transform_velocity( (direction, 0, 0), (0, 0, 0), self.ref_kerbin, self.ref_nr_kerbin) self.assertAlmostEqual( norm(vel), direction * self.kerbin.rotational_speed, places=3)
def test_transform_velocity_between_vessel_and_celestial_body(self): vel = self.sc.transform_velocity( (0, 0, 0), (0, 0, 0), self.ref_vessel, self.ref_nr_kerbin) self.assertAlmostEqual(norm(vel), self.vessel.orbit.speed, places=3)