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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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__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(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__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(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)