def setUp(self): self.vs = VelocitySpeed() self.vs.weight_unit = ut.TONNE self.vs.tables = { 'v2': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (127, 134, 139, 145, 151, 156, 161, 166, 171, 176), '15': (122, 128, 134, 139, 144, 149, 154, 159, 164, 168), '20': (118, 124, 129, 134, 140, 144, 149, 154, 159, 164), }, 'vref': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (114, 121, 128, 134, 141, 147, 153, 158, 164, 169), '15': (109, 116, 122, 129, 131, 135, 146, 151, 157, 162), '20': (105, 111, 118, 124, 130, 135, 141, 147, 152, 158), }, 'vapp': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (114, 121, 128, 134, 141, 147, 153, 158, 164, 169), '15': (109, 116, 122, 129, 131, 135, 146, 151, 157, 162), '20': (105, 111, 118, 124, 130, 135, 141, 147, 152, 158), }, 'vmo': { 'altitude': ( 0, 12000, 29000, 41000), 'speed': (335, 335, 310, 310), }, 'mmo': 0.800, } self.vs.fallback = { 'v2': {'5': 122, '15': 117, '20': 113}, 'vref': {'5': 109, '15': 104, '20': 100}, 'vapp': {'5': 109, '15': 104, '20': 100}, }
def setUp(self): self.vs = VelocitySpeed() self.vs.weight_unit = ut.TONNE self.vs.tables = { 'v2': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (127, 134, 139, 145, 151, 156, 161, 166, 171, 176), '15': (122, 128, 134, 139, 144, 149, 154, 159, 164, 168), '20': (118, 124, 129, 134, 140, 144, 149, 154, 159, 164), }, 'vref': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (114, 121, 128, 134, 141, 147, 153, 158, 164, 169), '15': (109, 116, 122, 129, 131, 135, 146, 151, 157, 162), '20': (105, 111, 118, 124, 130, 135, 141, 147, 152, 158), }, 'vapp': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (114, 121, 128, 134, 141, 147, 153, 158, 164, 169), '15': (109, 116, 122, 129, 131, 135, 146, 151, 157, 162), '20': (105, 111, 118, 124, 130, 135, 141, 147, 152, 158), }, 'vmo': { 'altitude': (0, 12000, 29000, 41000), 'speed': (335, 335, 310, 310), }, 'mmo': 0.800, 'vls_clean': { 'altitude': (0, 10000, 20000, 30000, 40000), 'weight': { 240: (209, 222, 237, 245, np.nan), 220: (200, 207, 226, 233, np.nan), 200: (190, 192, 214, 220, 243), 180: (181, 181, 200, 206, 221), 160: (170, 171, 182, 194, 203), 140: (159, 159, 163, 181, 187), 120: (148, 148, 148, 164, 171), } }, } self.vs.fallback = { 'v2': { '5': 122, '15': 117, '20': 113 }, 'vref': { '5': 109, '15': 104, '20': 100 }, 'vapp': { '5': 109, '15': 104, '20': 100 }, }
def setUp(self): self.velocity_speed = VelocitySpeed() self.velocity_speed.weight_unit = ut.TONNE self.velocity_speed.tables = { 'v2': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (127, 134, 139, 145, 151, 156, 161, 166, 171, 176), '15': (122, 128, 134, 139, 144, 149, 154, 159, 164, 168), '20': (118, 124, 129, 134, 140, 144, 149, 154, 159, 164), }, 'vref': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (114, 121, 128, 134, 141, 147, 153, 158, 164, 169), '15': (109, 116, 122, 129, 141, 135, 146, 151, 157, 162), '20': (105, 111, 118, 124, 130, 135, 141, 147, 152, 158), }, }
class TestVelocitySpeed(unittest.TestCase): def setUp(self): self.velocity_speed = VelocitySpeed() self.velocity_speed.weight_unit = ut.TONNE self.velocity_speed.tables = { 'v2': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (127, 134, 139, 145, 151, 156, 161, 166, 171, 176), '15': (122, 128, 134, 139, 144, 149, 154, 159, 164, 168), '20': (118, 124, 129, 134, 140, 144, 149, 154, 159, 164), }, 'vref': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (114, 121, 128, 134, 141, 147, 153, 158, 164, 169), '15': (109, 116, 122, 129, 141, 135, 146, 151, 157, 162), '20': (105, 111, 118, 124, 130, 135, 141, 147, 152, 158), }, } def test_v2(self): self.velocity_speed.interpolate = False self.assertEquals(self.velocity_speed.v2('20', 119000), 129) self.assertEquals(self.velocity_speed.v2('20', 120000), 129) self.assertEquals(self.velocity_speed.v2('20', 121000), 134) #self.assertRaises(KeyError, self.velocity_speed.v2, '14', 165000) def test_v2_interpolated(self): self.velocity_speed.interpolate = True self.assertEquals(self.velocity_speed.v2('20', 145000), 142) self.assertEquals(self.velocity_speed.v2('20', 120000), 129) self.assertEquals(self.velocity_speed.v2('5', 165000), 163.5) self.assertEquals(self.velocity_speed.v2('20', 94000), None) #self.assertRaises(KeyError, self.velocity_speed.v2, '14', 165000) def test_v2_minimum(self): self.velocity_speed.interpolate = True self.velocity_speed.minimum_speed = 125 self.assertEquals(self.velocity_speed.v2('15', 100500), 125) self.velocity_speed.interpolate = False self.assertEquals(self.velocity_speed.v2('15', 100500), 128) #self.assertRaises(KeyError, self.velocity_speed.v2, '14', 165000) def test_v2_out_of_range(self): self.velocity_speed.interpolate = True self.velocity_speed.minimum_speed = 125 result = self.velocity_speed.v2('30', 100000) self.assertEqual(result, None) def test_vref(self): self.velocity_speed.minimum_speed = False self.assertEquals(self.velocity_speed.vref('15', 119000), 122) self.assertEquals(self.velocity_speed.vref('15', 120000), 122) self.assertEquals(self.velocity_speed.vref('15', 121000), 129) #self.assertRaises(KeyError, self.velocity_speed.vref, '14', 121000) def test_vref_interpolated(self): self.velocity_speed.interpolate = True self.assertEquals(self.velocity_speed.vref('5', 120000), 128) self.assertEquals(self.velocity_speed.vref('15', 120000), 122) self.assertEquals(self.velocity_speed.vref('20', 145000), 132.5) self.assertEquals(self.velocity_speed.vref('20', 94000), None) #self.assertRaises(KeyError, self.velocity_speed.vref, '14', 165000) def test_vref_minimum(self): self.velocity_speed.interpolate = True self.velocity_speed.minimum_speed = 115 self.assertEquals(self.velocity_speed.vref('15', 100500), 115) self.velocity_speed.interpolate = False self.assertEquals(self.velocity_speed.vref('15', 100500), 116)
class TestVelocitySpeed(unittest.TestCase): def setUp(self): self.vs = VelocitySpeed() self.vs.weight_unit = ut.TONNE self.vs.tables = { 'v2': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (127, 134, 139, 145, 151, 156, 161, 166, 171, 176), '15': (122, 128, 134, 139, 144, 149, 154, 159, 164, 168), '20': (118, 124, 129, 134, 140, 144, 149, 154, 159, 164), }, 'vref': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (114, 121, 128, 134, 141, 147, 153, 158, 164, 169), '15': (109, 116, 122, 129, 131, 135, 146, 151, 157, 162), '20': (105, 111, 118, 124, 130, 135, 141, 147, 152, 158), }, 'vapp': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (114, 121, 128, 134, 141, 147, 153, 158, 164, 169), '15': (109, 116, 122, 129, 131, 135, 146, 151, 157, 162), '20': (105, 111, 118, 124, 130, 135, 141, 147, 152, 158), }, 'vmo': { 'altitude': (0, 12000, 29000, 41000), 'speed': (335, 335, 310, 310), }, 'mmo': 0.800, 'vls_clean': { 'altitude': (0, 10000, 20000, 30000, 40000), 'weight': { 240: (209, 222, 237, 245, np.nan), 220: (200, 207, 226, 233, np.nan), 200: (190, 192, 214, 220, 243), 180: (181, 181, 200, 206, 221), 160: (170, 171, 182, 194, 203), 140: (159, 159, 163, 181, 187), 120: (148, 148, 148, 164, 171), } }, } self.vs.fallback = { 'v2': { '5': 122, '15': 117, '20': 113 }, 'vref': { '5': 109, '15': 104, '20': 100 }, 'vapp': { '5': 109, '15': 104, '20': 100 }, } def test__v2(self): # Test where weight argument is a single value: self.assertEqual(self.vs.v2('5', 165000), 164) self.assertEqual(self.vs.v2('15', 120000), 134) self.assertEqual(self.vs.v2('20', 145000), 142) # Test where weight argument is a masked array: weight = np.ma.arange(120, 130, 2) * 1000 weight[2] = np.ma.masked v2_05 = np.ma.array((139, 140, 141, 143, 144)) v2_15 = np.ma.array((134, 135, 136, 137, 138)) v2_20 = np.ma.array((129, 130, 131, 132, 133)) v2_05[2] = np.ma.masked v2_15[2] = np.ma.masked v2_20[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.v2('5', weight), v2_05) ma_test.assert_masked_array_equal(self.vs.v2('15', weight), v2_15) ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__minimum_speed(self): self.vs.minimum_speed = 125 # Test where weight argument is a single value: self.assertEqual(self.vs.v2('15', 100500), 125) # Test where weight argument is a masked array: weight = np.ma.arange(100, 110, 2) * 1000 weight[2] = np.ma.masked v2_15 = np.ma.array((125, 125, 125, 126, 127)) v2_15[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.v2('15', weight), v2_15) def test__v2__out_of_range(self): # Test where weight argument is a single value: self.assertIs(self.vs.v2('20', 95000), np.ma.masked) self.assertIs(self.vs.v2('20', 99999), np.ma.masked) self.assertIs(self.vs.v2('20', 190001), np.ma.masked) self.assertIs(self.vs.v2('20', 195000), np.ma.masked) self.assertIsNot(self.vs.v2('20', 100000), np.ma.masked) self.assertIsNot(self.vs.v2('20', 190000), np.ma.masked) self.assertEqual(self.vs.v2('20', 100000), 118) self.assertEqual(self.vs.v2('20', 190000), 164) # Test where weight argument is a masked array: weight = np.ma.arange(95, 200, 20) * 1000 v2_15 = np.ma.array((0, 131, 142, 152, 162, 0)) v2_15[0] = np.ma.masked v2_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.v2('15', weight), v2_15) def test__v2__fallback__weight_not_recorded(self): self.assertTrue('20' in self.vs.tables['v2']) self.assertTrue('20' in self.vs.fallback['v2']) # Test where weight argument is a single value: self.assertEqual(self.vs.v2('20'), 113) self.assertIsNot(self.vs.v2('20'), np.ma.masked) # Test where weight argument is a masked array: # Note: Pass in masked zeroed array of desired shape to get array. weight = np.ma.repeat(0, 6) weight.mask = True v2_20 = np.ma.repeat(113, 6) v2_20.mask = False ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__fallback__weight_fully_masked(self): self.assertTrue('20' in self.vs.tables['v2']) self.assertTrue('20' in self.vs.fallback['v2']) # Test where weight argument is a single value: self.assertEqual(self.vs.v2('20', np.ma.masked), 113) self.assertIsNot(self.vs.v2('20', np.ma.masked), np.ma.masked) # Test where weight argument is a masked array: # Note: Array with fallback using weight array shape if fully masked. weight = np.ma.repeat(120, 6) * 1000 weight.mask = True v2_20 = np.ma.repeat(113, 6) v2_20.mask = False ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__fallback__detent_in_fallback_only(self): del self.vs.tables['v2']['20'] self.assertFalse('20' in self.vs.tables['v2']) self.assertTrue('20' in self.vs.fallback['v2']) # Test where weight argument is a single value: self.assertEqual(self.vs.v2('20'), 113) self.assertIsNot(self.vs.v2('20'), np.ma.masked) self.assertEqual(self.vs.v2('20', 100000), 113) self.assertIsNot(self.vs.v2('20', 100000), np.ma.masked) self.assertEqual(self.vs.v2('20', 120000), 113) self.assertIsNot(self.vs.v2('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked v2_20 = np.ma.repeat(113, weight.size) v2_20.mask = False ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__fallback__detent_not_available(self): del self.vs.tables['v2']['20'] del self.vs.fallback['v2']['20'] self.assertFalse('20' in self.vs.tables['v2']) self.assertFalse('20' in self.vs.fallback['v2']) # Test where weight argument is a single value: self.assertIs(self.vs.v2('20'), np.ma.masked) self.assertIs(self.vs.v2('20', 100000), np.ma.masked) self.assertIs(self.vs.v2('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked v2_20 = np.ma.repeat(0, weight.size) v2_20.mask = True ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__fallback__no_weight_based_table(self): del self.vs.tables['v2'] self.assertFalse('v2' in self.vs.tables) self.assertTrue('20' in self.vs.fallback['v2']) # Test where weight argument is a single value: self.assertEqual(self.vs.v2('20'), 113) self.assertIsNot(self.vs.v2('20'), np.ma.masked) self.assertEqual(self.vs.v2('20', 100000), 113) self.assertIsNot(self.vs.v2('20', 100000), np.ma.masked) self.assertEqual(self.vs.v2('20', 120000), 113) self.assertIsNot(self.vs.v2('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked v2_20 = np.ma.repeat(113, weight.size) v2_20.mask = False ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__weight_unit__invalid(self): invalid = set(ut.available()) - set( (None, ut.KG, ut.LB, ut.SLUG, ut.TONNE)) for unit in invalid: self.vs.weight_unit = unit self.assertRaises(KeyError, self.vs.v2, '15', 120000) def test__v2__weight_scale__1000_lb(self): self.vs.weight_scale = 1000 self.vs.weight_unit = ut.LB # Test where weight argument is a single value: self.assertIs(self.vs.v2('20', 43091), np.ma.masked) self.assertIs(self.vs.v2('20', 88451), np.ma.masked) self.assertIsNot(self.vs.v2('20', 54431), np.ma.masked) self.assertAlmostEqual(self.vs.v2('20', 54431), 129, places=3) # Test where weight argument is a masked array: weight = np.ma.array((43091, 52163, 61239, 70307, 79379, 88451)) v2_15 = np.ma.array((0, 131, 142, 152, 162, 0)) v2_15[0] = np.ma.masked v2_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.v2('15', weight), v2_15) def test__vref(self): # Test where weight argument is a single value: self.assertEqual(self.vs.vref('5', 120000), 128) self.assertEqual(self.vs.vref('15', 120000), 122) self.assertEqual(self.vs.vref('20', 145000), 132) # Test where weight argument is a masked array: weight = np.ma.arange(120, 130, 2) * 1000 weight[2] = np.ma.masked vref_05 = np.ma.array((128, 129, 130, 132, 133)) vref_15 = np.ma.array((122, 123, 125, 126, 128)) vref_20 = np.ma.array((118, 119, 120, 122, 123)) vref_05[2] = np.ma.masked vref_15[2] = np.ma.masked vref_20[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vref('5', weight), vref_05) ma_test.assert_masked_array_equal(self.vs.vref('15', weight), vref_15) ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__minimum_speed(self): self.vs.minimum_speed = 112 # Test where weight argument is a single value: self.assertEqual(self.vs.vref('15', 100500), 112) # Test where weight argument is a masked array: weight = np.ma.arange(100, 110, 2) * 1000 weight[2] = np.ma.masked vref_15 = np.ma.array((112, 112, 112, 113, 115)) vref_15[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vref('15', weight), vref_15) def test__vref__out_of_range(self): # Test where weight argument is a single value: self.assertIs(self.vs.vref('20', 95000), np.ma.masked) self.assertIs(self.vs.vref('20', 99999), np.ma.masked) self.assertIs(self.vs.vref('20', 190001), np.ma.masked) self.assertIs(self.vs.vref('20', 195000), np.ma.masked) self.assertIsNot(self.vs.vref('20', 100000), np.ma.masked) self.assertIsNot(self.vs.vref('20', 190000), np.ma.masked) self.assertEqual(self.vs.vref('20', 100000), 105) self.assertEqual(self.vs.vref('20', 190000), 158) # Test where weight argument is a masked array: weight = np.ma.arange(95, 200, 20) * 1000 vref_15 = np.ma.array((0, 119, 130, 140, 154, 0)) vref_15[0] = np.ma.masked vref_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vref('15', weight), vref_15) def test__vref__fallback__weight_not_recorded(self): self.assertTrue('20' in self.vs.tables['vref']) self.assertTrue('20' in self.vs.fallback['vref']) # Test where weight argument is a single value: self.assertEqual(self.vs.vref('20'), 100) self.assertIsNot(self.vs.vref('20'), np.ma.masked) # Test where weight argument is a masked array: # Note: Pass in masked zeroed array of desired shape to get array. weight = np.ma.repeat(0, 6) weight.mask = True vref_20 = np.ma.repeat(100, 6) vref_20.mask = False ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__fallback__weight_fully_masked(self): self.assertTrue('20' in self.vs.tables['vref']) self.assertTrue('20' in self.vs.fallback['vref']) # Test where weight argument is a single value: self.assertEqual(self.vs.vref('20', np.ma.masked), 100) self.assertIsNot(self.vs.vref('20', np.ma.masked), np.ma.masked) # Test where weight argument is a masked array: # Note: Array with fallback using weight array shape if fully masked. weight = np.ma.repeat(120, 6) * 1000 weight.mask = True vref_20 = np.ma.repeat(100, 6) vref_20.mask = False ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__fallback__detent_in_fallback_only(self): del self.vs.tables['vref']['20'] self.assertFalse('20' in self.vs.tables['vref']) self.assertTrue('20' in self.vs.fallback['vref']) # Test where weight argument is a single value: self.assertEqual(self.vs.vref('20'), 100) self.assertIsNot(self.vs.vref('20'), np.ma.masked) self.assertEqual(self.vs.vref('20', 100000), 100) self.assertIsNot(self.vs.vref('20', 100000), np.ma.masked) self.assertEqual(self.vs.vref('20', 120000), 100) self.assertIsNot(self.vs.vref('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vref_20 = np.ma.repeat(100, weight.size) vref_20.mask = False ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__fallback__detent_not_available(self): del self.vs.tables['vref']['20'] del self.vs.fallback['vref']['20'] self.assertFalse('20' in self.vs.tables['vref']) self.assertFalse('20' in self.vs.fallback['vref']) # Test where weight argument is a single value: self.assertIs(self.vs.vref('20'), np.ma.masked) self.assertIs(self.vs.vref('20', 100000), np.ma.masked) self.assertIs(self.vs.vref('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vref_20 = np.ma.repeat(0, weight.size) vref_20.mask = True ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__fallback__no_weight_based_table(self): del self.vs.tables['vref'] self.assertFalse('vref' in self.vs.tables) self.assertTrue('20' in self.vs.fallback['vref']) # Test where weight argument is a single value: self.assertEqual(self.vs.vref('20'), 100) self.assertIsNot(self.vs.vref('20'), np.ma.masked) self.assertEqual(self.vs.vref('20', 100000), 100) self.assertIsNot(self.vs.vref('20', 100000), np.ma.masked) self.assertEqual(self.vs.vref('20', 120000), 100) self.assertIsNot(self.vs.vref('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vref_20 = np.ma.repeat(100, weight.size) vref_20.mask = False ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__weight_unit__invalid(self): invalid = set(ut.available()) - set( (None, ut.KG, ut.LB, ut.SLUG, ut.TONNE)) for unit in invalid: self.vs.weight_unit = unit self.assertRaises(KeyError, self.vs.vref, '15', 120000) def test__vref__weight_scale__1000_lb(self): self.vs.weight_scale = 1000 self.vs.weight_unit = ut.LB # Test where weight argument is a single value: self.assertIs(self.vs.vref('20', 43091), np.ma.masked) self.assertIs(self.vs.vref('20', 88451), np.ma.masked) self.assertIsNot(self.vs.vref('20', 54431), np.ma.masked) self.assertAlmostEqual(self.vs.vref('20', 54431), 118, places=3) # Test where weight argument is a masked array: weight = np.ma.array((43091, 52163, 61239, 70307, 79379, 88451)) vref_15 = np.ma.array((0, 119, 130, 141, 154, 0)) vref_15[0] = np.ma.masked vref_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vref('15', weight), vref_15) def test__vapp(self): # Test where weight argument is a single value: self.assertEqual(self.vs.vapp('5', 120000), 128) self.assertEqual(self.vs.vapp('15', 120000), 122) self.assertEqual(self.vs.vapp('20', 145000), 132) # Test where weight argument is a masked array: weight = np.ma.arange(120, 130, 2) * 1000 weight[2] = np.ma.masked vapp_05 = np.ma.array((128, 129, 130, 132, 133)) vapp_15 = np.ma.array((122, 123, 125, 126, 128)) vapp_20 = np.ma.array((118, 119, 120, 122, 123)) vapp_05[2] = np.ma.masked vapp_15[2] = np.ma.masked vapp_20[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vapp('5', weight), vapp_05) ma_test.assert_masked_array_equal(self.vs.vapp('15', weight), vapp_15) ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__minimum_speed(self): self.vs.minimum_speed = 112 # Test where weight argument is a single value: self.assertEqual(self.vs.vapp('15', 100500), 112) # Test where weight argument is a masked array: weight = np.ma.arange(100, 110, 2) * 1000 weight[2] = np.ma.masked vapp_15 = np.ma.array((112, 112, 112, 113, 115)) vapp_15[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vapp('15', weight), vapp_15) def test__vapp__out_of_range(self): # Test where weight argument is a single value: self.assertIs(self.vs.vapp('20', 95000), np.ma.masked) self.assertIs(self.vs.vapp('20', 99999), np.ma.masked) self.assertIs(self.vs.vapp('20', 190001), np.ma.masked) self.assertIs(self.vs.vapp('20', 195000), np.ma.masked) self.assertIsNot(self.vs.vapp('20', 100000), np.ma.masked) self.assertIsNot(self.vs.vapp('20', 190000), np.ma.masked) self.assertEqual(self.vs.vapp('20', 100000), 105) self.assertEqual(self.vs.vapp('20', 190000), 158) # Test where weight argument is a masked array: weight = np.ma.arange(95, 200, 20) * 1000 vapp_15 = np.ma.array((0, 119, 130, 140, 154, 0)) vapp_15[0] = np.ma.masked vapp_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vapp('15', weight), vapp_15) def test__vapp__fallback__weight_not_recorded(self): self.assertTrue('20' in self.vs.tables['vapp']) self.assertTrue('20' in self.vs.fallback['vapp']) # Test where weight argument is a single value: self.assertEqual(self.vs.vapp('20'), 100) self.assertIsNot(self.vs.vapp('20'), np.ma.masked) # Test where weight argument is a masked array: # Note: Pass in masked zeroed array of desired shape to get array. weight = np.ma.repeat(0, 6) weight.mask = True vapp_20 = np.ma.repeat(100, 6) vapp_20.mask = False ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__fallback__weight_fully_masked(self): self.assertTrue('20' in self.vs.tables['vapp']) self.assertTrue('20' in self.vs.fallback['vapp']) # Test where weight argument is a single value: self.assertEqual(self.vs.vapp('20', np.ma.masked), 100) self.assertIsNot(self.vs.vapp('20', np.ma.masked), np.ma.masked) # Test where weight argument is a masked array: # Note: Array with fallback using weight array shape if fully masked. weight = np.ma.repeat(120, 6) * 1000 weight.mask = True vapp_20 = np.ma.repeat(100, 6) vapp_20.mask = False ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__fallback__detent_in_fallback_only(self): del self.vs.tables['vapp']['20'] self.assertFalse('20' in self.vs.tables['vapp']) self.assertTrue('20' in self.vs.fallback['vapp']) # Test where weight argument is a single value: self.assertEqual(self.vs.vapp('20'), 100) self.assertIsNot(self.vs.vapp('20'), np.ma.masked) self.assertEqual(self.vs.vapp('20', 100000), 100) self.assertIsNot(self.vs.vapp('20', 100000), np.ma.masked) self.assertEqual(self.vs.vapp('20', 120000), 100) self.assertIsNot(self.vs.vapp('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vapp_20 = np.ma.repeat(100, weight.size) vapp_20.mask = False ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__fallback__detent_not_available(self): del self.vs.tables['vapp']['20'] del self.vs.fallback['vapp']['20'] self.assertFalse('20' in self.vs.tables['vapp']) self.assertFalse('20' in self.vs.fallback['vapp']) # Test where weight argument is a single value: self.assertIs(self.vs.vapp('20'), np.ma.masked) self.assertIs(self.vs.vapp('20', 100000), np.ma.masked) self.assertIs(self.vs.vapp('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vapp_20 = np.ma.repeat(0, weight.size) vapp_20.mask = True ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__fallback__no_weight_based_table(self): del self.vs.tables['vapp'] self.assertFalse('vapp' in self.vs.tables) self.assertTrue('20' in self.vs.fallback['vapp']) # Test where weight argument is a single value: self.assertEqual(self.vs.vapp('20'), 100) self.assertIsNot(self.vs.vapp('20'), np.ma.masked) self.assertEqual(self.vs.vapp('20', 100000), 100) self.assertIsNot(self.vs.vapp('20', 100000), np.ma.masked) self.assertEqual(self.vs.vapp('20', 120000), 100) self.assertIsNot(self.vs.vapp('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vapp_20 = np.ma.repeat(100, weight.size) vapp_20.mask = False ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__weight_unit__invalid(self): invalid = set(ut.available()) - set( (None, ut.KG, ut.LB, ut.SLUG, ut.TONNE)) for unit in invalid: self.vs.weight_unit = unit self.assertRaises(KeyError, self.vs.vapp, '15', 120000) def test__vapp__weight_scale__1000_lb(self): self.vs.weight_scale = 1000 self.vs.weight_unit = ut.LB # Test where weight argument is a single value: self.assertIs(self.vs.vapp('20', 43091), np.ma.masked) self.assertIs(self.vs.vapp('20', 88451), np.ma.masked) self.assertIsNot(self.vs.vapp('20', 54431), np.ma.masked) self.assertAlmostEqual(self.vs.vapp('20', 54431), 118, places=3) # Test where weight argument is a masked array: weight = np.ma.array((43091, 52163, 61239, 70307, 79379, 88451)) vapp_15 = np.ma.array((0, 119, 130, 141, 154, 0)) vapp_15[0] = np.ma.masked vapp_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vapp('15', weight), vapp_15) def test__vmo__none(self): self.vs.tables['vmo'] = None # Test where altitude argument is a single value: self.assertIs(self.vs.vmo(00000), np.ma.masked) self.assertIs(self.vs.vmo(10000), np.ma.masked) self.assertIs(self.vs.vmo(20000), np.ma.masked) self.assertIs(self.vs.vmo(30000), np.ma.masked) self.assertIs(self.vs.vmo(40000), np.ma.masked) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 vmo = np.ma.repeat(0, 5) vmo.mask = True ma_test.assert_masked_array_equal(self.vs.vmo(altitude), vmo) def test__vmo__fixed(self): self.vs.tables['vmo'] = 350 # Test where altitude argument is a single value: self.assertEqual(self.vs.vmo(00000), 350) self.assertEqual(self.vs.vmo(10000), 350) self.assertEqual(self.vs.vmo(20000), 350) self.assertEqual(self.vs.vmo(30000), 350) self.assertEqual(self.vs.vmo(40000), 350) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked vmo = np.ma.repeat(350, 5) vmo.mask = False ma_test.assert_masked_array_equal(self.vs.vmo(altitude), vmo) def test__vmo__stepped(self): self.vs.tables['vmo'] = { 'altitude': (0, 20000, 20000, 40000), 'speed': (350, 350, 300, 300), } # Test where altitude argument is a single value: self.assertEqual(self.vs.vmo(00000), 350) self.assertEqual(self.vs.vmo(19999), 350) self.assertEqual(self.vs.vmo(20000), 300) self.assertEqual(self.vs.vmo(20001), 300) self.assertEqual(self.vs.vmo(40000), 300) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked vmo = np.ma.array([350] * 2 + [300] * 3) vmo[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vmo(altitude), vmo) def test__vmo__interpolated(self): self.vs.tables['vmo'] = { 'altitude': (0, 20000, 40000), 'speed': (350, 330, 310), } # Test where altitude argument is a single value: self.assertEqual(self.vs.vmo(00000), 350) self.assertEqual(self.vs.vmo(10000), 340) self.assertEqual(self.vs.vmo(20000), 330) self.assertEqual(self.vs.vmo(30000), 320) self.assertEqual(self.vs.vmo(40000), 310) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked vmo = np.ma.arange(350, 300, -10) vmo[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vmo(altitude), vmo) def test__mmo__none(self): self.vs.tables['mmo'] = None # Test where altitude argument is a single value: self.assertIs(self.vs.mmo(00000), np.ma.masked) self.assertIs(self.vs.mmo(10000), np.ma.masked) self.assertIs(self.vs.mmo(20000), np.ma.masked) self.assertIs(self.vs.mmo(30000), np.ma.masked) self.assertIs(self.vs.mmo(40000), np.ma.masked) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 mmo = np.ma.repeat(0, 5) mmo.mask = True ma_test.assert_masked_array_equal(self.vs.mmo(altitude), mmo) def test__mmo__fixed(self): self.vs.tables['mmo'] = 0.850 # Test where altitude argument is a single value: self.assertEqual(self.vs.mmo(00000), 0.850) self.assertEqual(self.vs.mmo(10000), 0.850) self.assertEqual(self.vs.mmo(20000), 0.850) self.assertEqual(self.vs.mmo(30000), 0.850) self.assertEqual(self.vs.mmo(40000), 0.850) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked mmo = np.ma.repeat(0.850, 5) mmo.mask = False ma_test.assert_masked_array_equal(self.vs.mmo(altitude), mmo) def test__mmo__stepped(self): self.vs.tables['mmo'] = { 'altitude': (0, 20000, 20000, 40000), 'speed': (0.850, 0.850, 0.800, 0.800), } # Test where altitude argument is a single value: self.assertEqual(self.vs.mmo(00000), 0.850) self.assertEqual(self.vs.mmo(19999), 0.850) self.assertEqual(self.vs.mmo(20000), 0.800) self.assertEqual(self.vs.mmo(20001), 0.800) self.assertEqual(self.vs.mmo(40000), 0.800) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked mmo = np.ma.array([0.850] * 2 + [0.800] * 3) mmo[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.mmo(altitude), mmo) def test__mmo__interpolated(self): self.vs.tables['mmo'] = { 'altitude': (0, 20000, 40000), 'speed': (0.860, 0.830, 0.800), } # Test where altitude argument is a single value: self.assertEqual(self.vs.mmo(00000), 0.860) self.assertEqual(self.vs.mmo(10000), 0.845) self.assertEqual(self.vs.mmo(20000), 0.830) self.assertEqual(self.vs.mmo(30000), 0.815) self.assertEqual(self.vs.mmo(40000), 0.800) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked mmo = np.ma.arange(860, 785, -15) / 1000.0 mmo[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.mmo(altitude), mmo) def test__vls_clean__arrays(self): altitude = np.ma.concatenate( (np.ma.ones(5) * 10000, np.ma.ones(5) * 20000)) weight = np.ma.ones(10) * 160000 result = self.vs._determine_vspeed('vls_clean', weight=weight, altitude=altitude) expected = np.ma.concatenate( (np.ma.ones(5) * 171, np.ma.ones(5) * 182)) ma_test.assert_masked_array_equal(expected, result) def test__vls_clean__scalar_values(self): altitude = 10000 weight = 200000 result = self.vs._determine_vspeed('vls_clean', weight=weight, altitude=altitude) expected = 192 self.assertEqual(expected, result) def test__vls_clean__altitude_none(self): altitude = None weight = np.ma.ones(10) * 160000 result = self.vs._determine_vspeed('vls_clean', weight=weight, altitude=altitude) expected = np.ma.ones(10) expected.mask = True ma_test.assert_masked_array_equal(expected, result) def test__vls_clean__weight_none(self): altitude = np.ma.concatenate( (np.ma.ones(5) * 10000, np.ma.ones(5) * 20000)) weight = None result = self.vs._determine_vspeed('vls_clean', weight=weight, altitude=altitude) expected = np.ma.ones(1) expected.mask = True ma_test.assert_masked_array_equal(expected, result) def test__vls_clean__values_outside_table(self): altitude = np.ma.concatenate( (np.ma.ones(5) * 31000, np.ma.ones(5) * 20000)) weight = np.ma.concatenate( (np.ma.ones(5) * 220000, np.ma.ones(5) * 100000)) result = self.vs._determine_vspeed('vls_clean', weight=weight, altitude=altitude) expected = np.ma.ones(10) expected.mask = True ma_test.assert_masked_array_equal(expected, result)
class TestVelocitySpeed(unittest.TestCase): def setUp(self): self.vs = VelocitySpeed() self.vs.weight_unit = ut.TONNE self.vs.tables = { 'v2': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (127, 134, 139, 145, 151, 156, 161, 166, 171, 176), '15': (122, 128, 134, 139, 144, 149, 154, 159, 164, 168), '20': (118, 124, 129, 134, 140, 144, 149, 154, 159, 164), }, 'vref': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (114, 121, 128, 134, 141, 147, 153, 158, 164, 169), '15': (109, 116, 122, 129, 131, 135, 146, 151, 157, 162), '20': (105, 111, 118, 124, 130, 135, 141, 147, 152, 158), }, 'vapp': { 'weight': (100, 110, 120, 130, 140, 150, 160, 170, 180, 190), '5': (114, 121, 128, 134, 141, 147, 153, 158, 164, 169), '15': (109, 116, 122, 129, 131, 135, 146, 151, 157, 162), '20': (105, 111, 118, 124, 130, 135, 141, 147, 152, 158), }, 'vmo': { 'altitude': ( 0, 12000, 29000, 41000), 'speed': (335, 335, 310, 310), }, 'mmo': 0.800, } self.vs.fallback = { 'v2': {'5': 122, '15': 117, '20': 113}, 'vref': {'5': 109, '15': 104, '20': 100}, 'vapp': {'5': 109, '15': 104, '20': 100}, } def test__v2(self): # Test where weight argument is a single value: self.assertEquals(self.vs.v2('5', 165000), 164) self.assertEquals(self.vs.v2('15', 120000), 134) self.assertEquals(self.vs.v2('20', 145000), 142) # Test where weight argument is a masked array: weight = np.ma.arange(120, 130, 2) * 1000 weight[2] = np.ma.masked v2_05 = np.ma.array((139, 140, 141, 143, 144)) v2_15 = np.ma.array((134, 135, 136, 137, 138)) v2_20 = np.ma.array((129, 130, 131, 132, 133)) v2_05[2] = np.ma.masked v2_15[2] = np.ma.masked v2_20[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.v2('5', weight), v2_05) ma_test.assert_masked_array_equal(self.vs.v2('15', weight), v2_15) ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__minimum_speed(self): self.vs.minimum_speed = 125 # Test where weight argument is a single value: self.assertEquals(self.vs.v2('15', 100500), 125) # Test where weight argument is a masked array: weight = np.ma.arange(100, 110, 2) * 1000 weight[2] = np.ma.masked v2_15 = np.ma.array((125, 125, 125, 126, 127)) v2_15[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.v2('15', weight), v2_15) def test__v2__out_of_range(self): # Test where weight argument is a single value: self.assertIs(self.vs.v2('20', 95000), np.ma.masked) self.assertIs(self.vs.v2('20', 99999), np.ma.masked) self.assertIs(self.vs.v2('20', 190001), np.ma.masked) self.assertIs(self.vs.v2('20', 195000), np.ma.masked) self.assertIsNot(self.vs.v2('20', 100000), np.ma.masked) self.assertIsNot(self.vs.v2('20', 190000), np.ma.masked) self.assertEquals(self.vs.v2('20', 100000), 118) self.assertEquals(self.vs.v2('20', 190000), 164) # Test where weight argument is a masked array: weight = np.ma.arange(95, 200, 20) * 1000 v2_15 = np.ma.array((0, 131, 142, 152, 162, 0)) v2_15[0] = np.ma.masked v2_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.v2('15', weight), v2_15) def test__v2__fallback__weight_not_recorded(self): self.assertTrue('20' in self.vs.tables['v2']) self.assertTrue('20' in self.vs.fallback['v2']) # Test where weight argument is a single value: self.assertEqual(self.vs.v2('20'), 113) self.assertIsNot(self.vs.v2('20'), np.ma.masked) # Test where weight argument is a masked array: # Note: Pass in masked zeroed array of desired shape to get array. weight = np.ma.repeat(0, 6) weight.mask = True v2_20 = np.ma.repeat(113, 6) v2_20.mask = False ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__fallback__weight_fully_masked(self): self.assertTrue('20' in self.vs.tables['v2']) self.assertTrue('20' in self.vs.fallback['v2']) # Test where weight argument is a single value: self.assertEqual(self.vs.v2('20', np.ma.masked), 113) self.assertIsNot(self.vs.v2('20', np.ma.masked), np.ma.masked) # Test where weight argument is a masked array: # Note: Array with fallback using weight array shape if fully masked. weight = np.ma.repeat(120, 6) * 1000 weight.mask = True v2_20 = np.ma.repeat(113, 6) v2_20.mask = False ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__fallback__detent_in_fallback_only(self): del self.vs.tables['v2']['20'] self.assertFalse('20' in self.vs.tables['v2']) self.assertTrue('20' in self.vs.fallback['v2']) # Test where weight argument is a single value: self.assertEqual(self.vs.v2('20'), 113) self.assertIsNot(self.vs.v2('20'), np.ma.masked) self.assertEqual(self.vs.v2('20', 100000), 113) self.assertIsNot(self.vs.v2('20', 100000), np.ma.masked) self.assertEqual(self.vs.v2('20', 120000), 113) self.assertIsNot(self.vs.v2('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked v2_20 = np.ma.repeat(113, weight.size) v2_20.mask = False ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__fallback__detent_not_available(self): del self.vs.tables['v2']['20'] del self.vs.fallback['v2']['20'] self.assertFalse('20' in self.vs.tables['v2']) self.assertFalse('20' in self.vs.fallback['v2']) # Test where weight argument is a single value: self.assertIs(self.vs.v2('20'), np.ma.masked) self.assertIs(self.vs.v2('20', 100000), np.ma.masked) self.assertIs(self.vs.v2('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked v2_20 = np.ma.repeat(0, weight.size) v2_20.mask = True ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__fallback__no_weight_based_table(self): del self.vs.tables['v2'] self.assertFalse('v2' in self.vs.tables) self.assertTrue('20' in self.vs.fallback['v2']) # Test where weight argument is a single value: self.assertEqual(self.vs.v2('20'), 113) self.assertIsNot(self.vs.v2('20'), np.ma.masked) self.assertEqual(self.vs.v2('20', 100000), 113) self.assertIsNot(self.vs.v2('20', 100000), np.ma.masked) self.assertEqual(self.vs.v2('20', 120000), 113) self.assertIsNot(self.vs.v2('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked v2_20 = np.ma.repeat(113, weight.size) v2_20.mask = False ma_test.assert_masked_array_equal(self.vs.v2('20', weight), v2_20) def test__v2__weight_unit__invalid(self): invalid = set(ut.available()) - set((None, ut.KG, ut.LB, ut.TONNE)) for unit in invalid: self.vs.weight_unit = unit self.assertRaises(KeyError, self.vs.v2, '15', 120000) def test__v2__weight_scale__1000_lb(self): self.vs.weight_scale = 1000 self.vs.weight_unit = ut.LB # Test where weight argument is a single value: self.assertIs(self.vs.v2('20', 43091), np.ma.masked) self.assertIs(self.vs.v2('20', 88451), np.ma.masked) self.assertIsNot(self.vs.v2('20', 54431), np.ma.masked) self.assertAlmostEqual(self.vs.v2('20', 54431), 129, places=3) # Test where weight argument is a masked array: weight = np.ma.array((43091, 52163, 61239, 70307, 79379, 88451)) v2_15 = np.ma.array((0, 131, 142, 152, 162, 0)) v2_15[0] = np.ma.masked v2_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.v2('15', weight), v2_15) def test__vref(self): # Test where weight argument is a single value: self.assertEquals(self.vs.vref('5', 120000), 128) self.assertEquals(self.vs.vref('15', 120000), 122) self.assertEquals(self.vs.vref('20', 145000), 132) # Test where weight argument is a masked array: weight = np.ma.arange(120, 130, 2) * 1000 weight[2] = np.ma.masked vref_05 = np.ma.array((128, 129, 130, 132, 133)) vref_15 = np.ma.array((122, 123, 125, 126, 128)) vref_20 = np.ma.array((118, 119, 120, 122, 123)) vref_05[2] = np.ma.masked vref_15[2] = np.ma.masked vref_20[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vref('5', weight), vref_05) ma_test.assert_masked_array_equal(self.vs.vref('15', weight), vref_15) ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__minimum_speed(self): self.vs.minimum_speed = 112 # Test where weight argument is a single value: self.assertEquals(self.vs.vref('15', 100500), 112) # Test where weight argument is a masked array: weight = np.ma.arange(100, 110, 2) * 1000 weight[2] = np.ma.masked vref_15 = np.ma.array((112, 112, 112, 113, 115)) vref_15[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vref('15', weight), vref_15) def test__vref__out_of_range(self): # Test where weight argument is a single value: self.assertIs(self.vs.vref('20', 95000), np.ma.masked) self.assertIs(self.vs.vref('20', 99999), np.ma.masked) self.assertIs(self.vs.vref('20', 190001), np.ma.masked) self.assertIs(self.vs.vref('20', 195000), np.ma.masked) self.assertIsNot(self.vs.vref('20', 100000), np.ma.masked) self.assertIsNot(self.vs.vref('20', 190000), np.ma.masked) self.assertEquals(self.vs.vref('20', 100000), 105) self.assertEquals(self.vs.vref('20', 190000), 158) # Test where weight argument is a masked array: weight = np.ma.arange(95, 200, 20) * 1000 vref_15 = np.ma.array((0, 119, 130, 140, 154, 0)) vref_15[0] = np.ma.masked vref_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vref('15', weight), vref_15) def test__vref__fallback__weight_not_recorded(self): self.assertTrue('20' in self.vs.tables['vref']) self.assertTrue('20' in self.vs.fallback['vref']) # Test where weight argument is a single value: self.assertEqual(self.vs.vref('20'), 100) self.assertIsNot(self.vs.vref('20'), np.ma.masked) # Test where weight argument is a masked array: # Note: Pass in masked zeroed array of desired shape to get array. weight = np.ma.repeat(0, 6) weight.mask = True vref_20 = np.ma.repeat(100, 6) vref_20.mask = False ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__fallback__weight_fully_masked(self): self.assertTrue('20' in self.vs.tables['vref']) self.assertTrue('20' in self.vs.fallback['vref']) # Test where weight argument is a single value: self.assertEqual(self.vs.vref('20', np.ma.masked), 100) self.assertIsNot(self.vs.vref('20', np.ma.masked), np.ma.masked) # Test where weight argument is a masked array: # Note: Array with fallback using weight array shape if fully masked. weight = np.ma.repeat(120, 6) * 1000 weight.mask = True vref_20 = np.ma.repeat(100, 6) vref_20.mask = False ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__fallback__detent_in_fallback_only(self): del self.vs.tables['vref']['20'] self.assertFalse('20' in self.vs.tables['vref']) self.assertTrue('20' in self.vs.fallback['vref']) # Test where weight argument is a single value: self.assertEqual(self.vs.vref('20'), 100) self.assertIsNot(self.vs.vref('20'), np.ma.masked) self.assertEqual(self.vs.vref('20', 100000), 100) self.assertIsNot(self.vs.vref('20', 100000), np.ma.masked) self.assertEqual(self.vs.vref('20', 120000), 100) self.assertIsNot(self.vs.vref('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vref_20 = np.ma.repeat(100, weight.size) vref_20.mask = False ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__fallback__detent_not_available(self): del self.vs.tables['vref']['20'] del self.vs.fallback['vref']['20'] self.assertFalse('20' in self.vs.tables['vref']) self.assertFalse('20' in self.vs.fallback['vref']) # Test where weight argument is a single value: self.assertIs(self.vs.vref('20'), np.ma.masked) self.assertIs(self.vs.vref('20', 100000), np.ma.masked) self.assertIs(self.vs.vref('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vref_20 = np.ma.repeat(0, weight.size) vref_20.mask = True ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__fallback__no_weight_based_table(self): del self.vs.tables['vref'] self.assertFalse('vref' in self.vs.tables) self.assertTrue('20' in self.vs.fallback['vref']) # Test where weight argument is a single value: self.assertEqual(self.vs.vref('20'), 100) self.assertIsNot(self.vs.vref('20'), np.ma.masked) self.assertEqual(self.vs.vref('20', 100000), 100) self.assertIsNot(self.vs.vref('20', 100000), np.ma.masked) self.assertEqual(self.vs.vref('20', 120000), 100) self.assertIsNot(self.vs.vref('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vref_20 = np.ma.repeat(100, weight.size) vref_20.mask = False ma_test.assert_masked_array_equal(self.vs.vref('20', weight), vref_20) def test__vref__weight_unit__invalid(self): invalid = set(ut.available()) - set((None, ut.KG, ut.LB, ut.TONNE)) for unit in invalid: self.vs.weight_unit = unit self.assertRaises(KeyError, self.vs.vref, '15', 120000) def test__vref__weight_scale__1000_lb(self): self.vs.weight_scale = 1000 self.vs.weight_unit = ut.LB # Test where weight argument is a single value: self.assertIs(self.vs.vref('20', 43091), np.ma.masked) self.assertIs(self.vs.vref('20', 88451), np.ma.masked) self.assertIsNot(self.vs.vref('20', 54431), np.ma.masked) self.assertAlmostEqual(self.vs.vref('20', 54431), 118, places=3) # Test where weight argument is a masked array: weight = np.ma.array((43091, 52163, 61239, 70307, 79379, 88451)) vref_15 = np.ma.array((0, 119, 130, 141, 154, 0)) vref_15[0] = np.ma.masked vref_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vref('15', weight), vref_15) def test__vapp(self): # Test where weight argument is a single value: self.assertEquals(self.vs.vapp('5', 120000), 128) self.assertEquals(self.vs.vapp('15', 120000), 122) self.assertEquals(self.vs.vapp('20', 145000), 132) # Test where weight argument is a masked array: weight = np.ma.arange(120, 130, 2) * 1000 weight[2] = np.ma.masked vapp_05 = np.ma.array((128, 129, 130, 132, 133)) vapp_15 = np.ma.array((122, 123, 125, 126, 128)) vapp_20 = np.ma.array((118, 119, 120, 122, 123)) vapp_05[2] = np.ma.masked vapp_15[2] = np.ma.masked vapp_20[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vapp('5', weight), vapp_05) ma_test.assert_masked_array_equal(self.vs.vapp('15', weight), vapp_15) ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__minimum_speed(self): self.vs.minimum_speed = 112 # Test where weight argument is a single value: self.assertEquals(self.vs.vapp('15', 100500), 112) # Test where weight argument is a masked array: weight = np.ma.arange(100, 110, 2) * 1000 weight[2] = np.ma.masked vapp_15 = np.ma.array((112, 112, 112, 113, 115)) vapp_15[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vapp('15', weight), vapp_15) def test__vapp__out_of_range(self): # Test where weight argument is a single value: self.assertIs(self.vs.vapp('20', 95000), np.ma.masked) self.assertIs(self.vs.vapp('20', 99999), np.ma.masked) self.assertIs(self.vs.vapp('20', 190001), np.ma.masked) self.assertIs(self.vs.vapp('20', 195000), np.ma.masked) self.assertIsNot(self.vs.vapp('20', 100000), np.ma.masked) self.assertIsNot(self.vs.vapp('20', 190000), np.ma.masked) self.assertEquals(self.vs.vapp('20', 100000), 105) self.assertEquals(self.vs.vapp('20', 190000), 158) # Test where weight argument is a masked array: weight = np.ma.arange(95, 200, 20) * 1000 vapp_15 = np.ma.array((0, 119, 130, 140, 154, 0)) vapp_15[0] = np.ma.masked vapp_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vapp('15', weight), vapp_15) def test__vapp__fallback__weight_not_recorded(self): self.assertTrue('20' in self.vs.tables['vapp']) self.assertTrue('20' in self.vs.fallback['vapp']) # Test where weight argument is a single value: self.assertEqual(self.vs.vapp('20'), 100) self.assertIsNot(self.vs.vapp('20'), np.ma.masked) # Test where weight argument is a masked array: # Note: Pass in masked zeroed array of desired shape to get array. weight = np.ma.repeat(0, 6) weight.mask = True vapp_20 = np.ma.repeat(100, 6) vapp_20.mask = False ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__fallback__weight_fully_masked(self): self.assertTrue('20' in self.vs.tables['vapp']) self.assertTrue('20' in self.vs.fallback['vapp']) # Test where weight argument is a single value: self.assertEqual(self.vs.vapp('20', np.ma.masked), 100) self.assertIsNot(self.vs.vapp('20', np.ma.masked), np.ma.masked) # Test where weight argument is a masked array: # Note: Array with fallback using weight array shape if fully masked. weight = np.ma.repeat(120, 6) * 1000 weight.mask = True vapp_20 = np.ma.repeat(100, 6) vapp_20.mask = False ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__fallback__detent_in_fallback_only(self): del self.vs.tables['vapp']['20'] self.assertFalse('20' in self.vs.tables['vapp']) self.assertTrue('20' in self.vs.fallback['vapp']) # Test where weight argument is a single value: self.assertEqual(self.vs.vapp('20'), 100) self.assertIsNot(self.vs.vapp('20'), np.ma.masked) self.assertEqual(self.vs.vapp('20', 100000), 100) self.assertIsNot(self.vs.vapp('20', 100000), np.ma.masked) self.assertEqual(self.vs.vapp('20', 120000), 100) self.assertIsNot(self.vs.vapp('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vapp_20 = np.ma.repeat(100, weight.size) vapp_20.mask = False ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__fallback__detent_not_available(self): del self.vs.tables['vapp']['20'] del self.vs.fallback['vapp']['20'] self.assertFalse('20' in self.vs.tables['vapp']) self.assertFalse('20' in self.vs.fallback['vapp']) # Test where weight argument is a single value: self.assertIs(self.vs.vapp('20'), np.ma.masked) self.assertIs(self.vs.vapp('20', 100000), np.ma.masked) self.assertIs(self.vs.vapp('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vapp_20 = np.ma.repeat(0, weight.size) vapp_20.mask = True ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__fallback__no_weight_based_table(self): del self.vs.tables['vapp'] self.assertFalse('vapp' in self.vs.tables) self.assertTrue('20' in self.vs.fallback['vapp']) # Test where weight argument is a single value: self.assertEqual(self.vs.vapp('20'), 100) self.assertIsNot(self.vs.vapp('20'), np.ma.masked) self.assertEqual(self.vs.vapp('20', 100000), 100) self.assertIsNot(self.vs.vapp('20', 100000), np.ma.masked) self.assertEqual(self.vs.vapp('20', 120000), 100) self.assertIsNot(self.vs.vapp('20', 120000), np.ma.masked) # Test where weight argument is a masked array: weight = np.ma.arange(100, 200, 10) * 1000 weight[5] = np.ma.masked vapp_20 = np.ma.repeat(100, weight.size) vapp_20.mask = False ma_test.assert_masked_array_equal(self.vs.vapp('20', weight), vapp_20) def test__vapp__weight_unit__invalid(self): invalid = set(ut.available()) - set((None, ut.KG, ut.LB, ut.TONNE)) for unit in invalid: self.vs.weight_unit = unit self.assertRaises(KeyError, self.vs.vapp, '15', 120000) def test__vapp__weight_scale__1000_lb(self): self.vs.weight_scale = 1000 self.vs.weight_unit = ut.LB # Test where weight argument is a single value: self.assertIs(self.vs.vapp('20', 43091), np.ma.masked) self.assertIs(self.vs.vapp('20', 88451), np.ma.masked) self.assertIsNot(self.vs.vapp('20', 54431), np.ma.masked) self.assertAlmostEqual(self.vs.vapp('20', 54431), 118, places=3) # Test where weight argument is a masked array: weight = np.ma.array((43091, 52163, 61239, 70307, 79379, 88451)) vapp_15 = np.ma.array((0, 119, 130, 141, 154, 0)) vapp_15[0] = np.ma.masked vapp_15[5] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vapp('15', weight), vapp_15) def test__vmo__none(self): self.vs.tables['vmo'] = None # Test where altitude argument is a single value: self.assertIs(self.vs.vmo(00000), np.ma.masked) self.assertIs(self.vs.vmo(10000), np.ma.masked) self.assertIs(self.vs.vmo(20000), np.ma.masked) self.assertIs(self.vs.vmo(30000), np.ma.masked) self.assertIs(self.vs.vmo(40000), np.ma.masked) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 vmo = np.ma.repeat(0, 5) vmo.mask = True ma_test.assert_masked_array_equal(self.vs.vmo(altitude), vmo) def test__vmo__fixed(self): self.vs.tables['vmo'] = 350 # Test where altitude argument is a single value: self.assertEqual(self.vs.vmo(00000), 350) self.assertEqual(self.vs.vmo(10000), 350) self.assertEqual(self.vs.vmo(20000), 350) self.assertEqual(self.vs.vmo(30000), 350) self.assertEqual(self.vs.vmo(40000), 350) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked vmo = np.ma.repeat(350, 5) vmo.mask = False ma_test.assert_masked_array_equal(self.vs.vmo(altitude), vmo) def test__vmo__stepped(self): self.vs.tables['vmo'] = { 'altitude': ( 0, 20000, 20000, 40000), 'speed': (350, 350, 300, 300), } # Test where altitude argument is a single value: self.assertEqual(self.vs.vmo(00000), 350) self.assertEqual(self.vs.vmo(19999), 350) self.assertEqual(self.vs.vmo(20000), 300) self.assertEqual(self.vs.vmo(20001), 300) self.assertEqual(self.vs.vmo(40000), 300) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked vmo = np.ma.array([350] * 2 + [300] * 3) vmo[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vmo(altitude), vmo) def test__vmo__interpolated(self): self.vs.tables['vmo'] = { 'altitude': ( 0, 20000, 40000), 'speed': (350, 330, 310), } # Test where altitude argument is a single value: self.assertEqual(self.vs.vmo(00000), 350) self.assertEqual(self.vs.vmo(10000), 340) self.assertEqual(self.vs.vmo(20000), 330) self.assertEqual(self.vs.vmo(30000), 320) self.assertEqual(self.vs.vmo(40000), 310) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked vmo = np.ma.arange(350, 300, -10) vmo[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.vmo(altitude), vmo) def test__mmo__none(self): self.vs.tables['mmo'] = None # Test where altitude argument is a single value: self.assertIs(self.vs.mmo(00000), np.ma.masked) self.assertIs(self.vs.mmo(10000), np.ma.masked) self.assertIs(self.vs.mmo(20000), np.ma.masked) self.assertIs(self.vs.mmo(30000), np.ma.masked) self.assertIs(self.vs.mmo(40000), np.ma.masked) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 mmo = np.ma.repeat(0, 5) mmo.mask = True ma_test.assert_masked_array_equal(self.vs.mmo(altitude), mmo) def test__mmo__fixed(self): self.vs.tables['mmo'] = 0.850 # Test where altitude argument is a single value: self.assertEqual(self.vs.mmo(00000), 0.850) self.assertEqual(self.vs.mmo(10000), 0.850) self.assertEqual(self.vs.mmo(20000), 0.850) self.assertEqual(self.vs.mmo(30000), 0.850) self.assertEqual(self.vs.mmo(40000), 0.850) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked mmo = np.ma.repeat(0.850, 5) mmo.mask = False ma_test.assert_masked_array_equal(self.vs.mmo(altitude), mmo) def test__mmo__stepped(self): self.vs.tables['mmo'] = { 'altitude': ( 0, 20000, 20000, 40000), 'speed': (0.850, 0.850, 0.800, 0.800), } # Test where altitude argument is a single value: self.assertEqual(self.vs.mmo(00000), 0.850) self.assertEqual(self.vs.mmo(19999), 0.850) self.assertEqual(self.vs.mmo(20000), 0.800) self.assertEqual(self.vs.mmo(20001), 0.800) self.assertEqual(self.vs.mmo(40000), 0.800) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked mmo = np.ma.array([0.850] * 2 + [0.800] * 3) mmo[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.mmo(altitude), mmo) def test__mmo__interpolated(self): self.vs.tables['mmo'] = { 'altitude': ( 0, 20000, 40000), 'speed': (0.860, 0.830, 0.800), } # Test where altitude argument is a single value: self.assertEqual(self.vs.mmo(00000), 0.860) self.assertEqual(self.vs.mmo(10000), 0.845) self.assertEqual(self.vs.mmo(20000), 0.830) self.assertEqual(self.vs.mmo(30000), 0.815) self.assertEqual(self.vs.mmo(40000), 0.800) # Test where altitude argument is a masked array: altitude = np.ma.arange(0, 50, 10) * 1000 altitude[2] = np.ma.masked mmo = np.ma.arange(860, 785, -15) / 1000.0 mmo[2] = np.ma.masked ma_test.assert_masked_array_equal(self.vs.mmo(altitude), mmo)