From 5ff4f21da5a0cdbde711302a15625b325ae7bf1c Mon Sep 17 00:00:00 2001 From: jkirk5 Date: Thu, 15 Jan 2026 13:09:10 -0500 Subject: [PATCH 1/6] Updated a selection of unittests with subtests - performed by AI --- .../flops_based/test/test_mux_component.py | 44 +- .../gasp_based/flaps_model/test/test_Clmax.py | 20 +- .../test/test_basic_calculations.py | 52 +- .../flaps_model/test/test_flaps_group.py | 178 +++--- .../flaps_model/test/test_increments.py | 15 +- .../flaps_model/test/test_metamodel.py | 117 ++-- .../gasp_based/test/test_common.py | 12 +- .../gasp_based/test/test_interference.py | 44 +- .../gasp_based/test/test_size_group.py | 516 ++++++------------ .../mass/gasp_based/test/test_fixed.py | 116 ++-- .../gasp_based/test/test_mass_summation.py | 109 ++-- .../test/test_propeller_performance.py | 19 +- .../test/test_gasp_based_premission.py | 462 ++++++++-------- aviary/subsystems/test/test_premission.py | 106 ++-- .../benchmark_tests/test_bench_FwGm.py | 50 +- .../benchmark_tests/test_bench_GwGm.py | 86 +-- .../test_bench_multimission.py | 16 +- .../benchmark_tests/test_bench_off_design.py | 470 +++++++--------- 18 files changed, 1046 insertions(+), 1386 deletions(-) diff --git a/aviary/subsystems/aerodynamics/flops_based/test/test_mux_component.py b/aviary/subsystems/aerodynamics/flops_based/test/test_mux_component.py index 0a9fd2ca33..a1c6371823 100644 --- a/aviary/subsystems/aerodynamics/flops_based/test/test_mux_component.py +++ b/aviary/subsystems/aerodynamics/flops_based/test/test_mux_component.py @@ -74,11 +74,23 @@ def test_mux(self): laminar_fractions_lower_output = prob['mux.laminar_fractions_lower'] # Assert that the outputs are near the expected values - assert_near_equal(wetted_areas_output, wetted_areas_truth, 1e-7) - assert_near_equal(fineness_ratios_output, fineness_ratios_truth, 1e-7) - assert_near_equal(characteristic_lengths_output, characteristic_lengths_truth, 1e-7) - assert_near_equal(laminar_fractions_upper_output, laminar_fractions_upper_truth, 1e-7) - assert_near_equal(laminar_fractions_lower_output, laminar_fractions_lower_truth, 1e-7) + expected_values = { + 'wetted_areas': (wetted_areas_output, wetted_areas_truth), + 'fineness_ratios': (fineness_ratios_output, fineness_ratios_truth), + 'characteristic_lengths': (characteristic_lengths_output, characteristic_lengths_truth), + 'laminar_fractions_upper': ( + laminar_fractions_upper_output, + laminar_fractions_upper_truth, + ), + 'laminar_fractions_lower': ( + laminar_fractions_lower_output, + laminar_fractions_lower_truth, + ), + } + + for var_name, (output, truth) in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(output, truth, 1e-7) def test_mux_multiengine(self): prob = om.Problem() @@ -151,11 +163,23 @@ def test_mux_multiengine(self): laminar_fractions_lower_output = prob['mux.laminar_fractions_lower'] # Assert that the outputs are near the expected values - assert_near_equal(wetted_areas_output, wetted_areas_truth, 1e-7) - assert_near_equal(fineness_ratios_output, fineness_ratios_truth, 1e-7) - assert_near_equal(characteristic_lengths_output, characteristic_lengths_truth, 1e-7) - assert_near_equal(laminar_fractions_upper_output, laminar_fractions_upper_truth, 1e-7) - assert_near_equal(laminar_fractions_lower_output, laminar_fractions_lower_truth, 1e-7) + expected_values = { + 'wetted_areas': (wetted_areas_output, wetted_areas_truth), + 'fineness_ratios': (fineness_ratios_output, fineness_ratios_truth), + 'characteristic_lengths': (characteristic_lengths_output, characteristic_lengths_truth), + 'laminar_fractions_upper': ( + laminar_fractions_upper_output, + laminar_fractions_upper_truth, + ), + 'laminar_fractions_lower': ( + laminar_fractions_lower_output, + laminar_fractions_lower_truth, + ), + } + + for var_name, (output, truth) in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(output, truth, 1e-7) if __name__ == '__main__': diff --git a/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_Clmax.py b/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_Clmax.py index e1470a7353..53623cae45 100644 --- a/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_Clmax.py +++ b/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_Clmax.py @@ -49,19 +49,17 @@ def setUp(self): def test_case(self): self.prob.run_model() tol = 6e-4 - print() - reg_data = 2.8155 - ans = self.prob['CL_max'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'CL_max': 2.8155, + Dynamic.Atmosphere.MACH: 0.17522, + 'reynolds': 157.19864, + } - reg_data = 0.17522 - ans = self.prob[Dynamic.Atmosphere.MACH] - assert_near_equal(ans, reg_data, tol) - - reg_data = 157.19864 - ans = self.prob['reynolds'] - assert_near_equal(ans, reg_data, tol) + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(out_stream=None, method='fd') assert_check_partials( diff --git a/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_basic_calculations.py b/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_basic_calculations.py index 53e5634e6e..ab09f66cdc 100644 --- a/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_basic_calculations.py +++ b/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_basic_calculations.py @@ -43,43 +43,23 @@ def setUp(self): def test_case(self): self.prob.run_model() tol = 2.1e-4 - print() - reg_data = 0.74444 - ans = self.prob['VLAM8'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.93578 - ans = self.prob['VDEL4'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.90761 - ans = self.prob['VDEL5'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.9975 - ans = self.prob['VLAM9'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.5 - ans = self.prob['slat_defl_ratio'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.89761 - ans = self.prob[Aircraft.Wing.SLAT_SPAN_RATIO] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.09239 - ans = self.prob['body_to_span_ratio'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.12679 - ans = self.prob['chord_to_body_ratio'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.79208 - ans = self.prob['VLAM12'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'VLAM8': 0.74444, + 'VDEL4': 0.93578, + 'VDEL5': 0.90761, + 'VLAM9': 0.9975, + 'slat_defl_ratio': 0.5, + Aircraft.Wing.SLAT_SPAN_RATIO: 0.89761, + 'body_to_span_ratio': 0.09239, + 'chord_to_body_ratio': 0.12679, + 'VLAM12': 0.79208, + } + + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(out_stream=None, method='fd') assert_check_partials(data, atol=1e-6, rtol=4e-6) diff --git a/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_flaps_group.py b/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_flaps_group.py index 07e4428bf9..8bd5c81157 100644 --- a/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_flaps_group.py +++ b/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_flaps_group.py @@ -99,25 +99,18 @@ def test_case(self): self.prob.run_model() tol = 6e-4 # checked. high tol for lack of precision in GASP data. - reg_data = 2.8155 - ans = self.prob['CL_max'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.17522 - ans = self.prob[Dynamic.Atmosphere.MACH] - assert_near_equal(ans, reg_data, tol) - - reg_data = 157.1111 - ans = self.prob['reynolds'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.0406 - ans = self.prob['delta_CD'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 1.0293 - ans = self.prob['delta_CL'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'CL_max': 2.8155, + Dynamic.Atmosphere.MACH: 0.17522, + 'reynolds': 157.1111, + 'delta_CD': 0.0406, + 'delta_CL': 1.0293, + } + + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(method='fd', out_stream=None) assert_check_partials( @@ -207,25 +200,18 @@ def test_case(self): self.prob.run_model() tol = 9e-4 # checked. high tol for lack of precision in GASP data. - reg_data = 2.56197 - ans = self.prob['CL_max'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.18368 - ans = self.prob[Dynamic.Atmosphere.MACH] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'CL_max': 2.56197, + Dynamic.Atmosphere.MACH: 0.18368, + 'reynolds': 164.78406, + 'delta_CD': 0.0362, + 'delta_CL': 0.7816, + } - reg_data = 164.78406 - ans = self.prob['reynolds'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.0362 - ans = self.prob['delta_CD'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.7816 - ans = self.prob['delta_CL'] - assert_near_equal(ans, reg_data, tol) + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(method='fd', out_stream=None) assert_check_partials( @@ -316,25 +302,18 @@ def test_case(self): self.prob.run_model() tol = 6e-4 # checked. high tol for lack of precision in GASP data. - reg_data = 2.8155 - ans = self.prob['CL_max'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.17522 - ans = self.prob[Dynamic.Atmosphere.MACH] - assert_near_equal(ans, reg_data, tol) - - reg_data = 157.1111 - ans = self.prob['reynolds'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.0406 - ans = self.prob['delta_CD'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'CL_max': 2.8155, + Dynamic.Atmosphere.MACH: 0.17522, + 'reynolds': 157.1111, + 'delta_CD': 0.0406, + 'delta_CL': 1.0293, + } - reg_data = 1.0293 - ans = self.prob['delta_CL'] - assert_near_equal(ans, reg_data, tol) + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(method='fd', out_stream=None) assert_check_partials( @@ -424,25 +403,18 @@ def test_case(self): self.prob.run_model() tol = 9e-4 # checked. high tol for lack of precision in GASP data. - reg_data = 2.56197 - ans = self.prob['CL_max'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'CL_max': 2.56197, + Dynamic.Atmosphere.MACH: 0.18368, + 'reynolds': 164.78406, + 'delta_CD': 0.0362, + 'delta_CL': 0.7816, + } - reg_data = 0.18368 - ans = self.prob[Dynamic.Atmosphere.MACH] - assert_near_equal(ans, reg_data, tol) - - reg_data = 164.78406 - ans = self.prob['reynolds'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.0362 - ans = self.prob['delta_CD'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.7816 - ans = self.prob['delta_CL'] - assert_near_equal(ans, reg_data, tol) + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(method='fd', out_stream=None) assert_check_partials( @@ -532,25 +504,18 @@ def test_case(self): self.prob.run_model() tol = 6e-4 # checked. high tol for lack of precision in GASP data. - reg_data = 2.93271 - ans = self.prob['CL_max'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.17168 - ans = self.prob[Dynamic.Atmosphere.MACH] - assert_near_equal(ans, reg_data, tol) - - reg_data = 154.02686 - ans = self.prob['reynolds'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'CL_max': 2.93271, + Dynamic.Atmosphere.MACH: 0.17168, + 'reynolds': 154.02686, + 'delta_CD': 0.1070, + 'delta_CL': 1.1441, + } - reg_data = 0.1070 - ans = self.prob['delta_CD'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 1.1441 - ans = self.prob['delta_CL'] - assert_near_equal(ans, reg_data, tol) + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(method='fd', out_stream=None) assert_check_partials( @@ -642,25 +607,18 @@ def test_case(self): self.prob.run_model() tol = 6e-4 # checked. high tol for lack of precision in GASP data. - reg_data = 2.93271 - ans = self.prob['CL_max'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.17168 - ans = self.prob[Dynamic.Atmosphere.MACH] - assert_near_equal(ans, reg_data, tol) - - reg_data = 154.02686 - ans = self.prob['reynolds'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.1070 - ans = self.prob['delta_CD'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 1.1441 - ans = self.prob['delta_CL'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'CL_max': 2.93271, + Dynamic.Atmosphere.MACH: 0.17168, + 'reynolds': 154.02686, + 'delta_CD': 0.1070, + 'delta_CL': 1.1441, + } + + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(method='fd', out_stream=None) assert_check_partials( diff --git a/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_increments.py b/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_increments.py index 920add3b53..48803ca653 100644 --- a/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_increments.py +++ b/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_increments.py @@ -41,15 +41,16 @@ def setUp(self): def test_case(self): self.prob.run_model() tol = 5e-4 - print() - reg_data = 0.0650 - ans = self.prob['delta_CD'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'delta_CD': 0.0650, + 'delta_CL': 1.0293, + } - reg_data = 1.0293 - ans = self.prob['delta_CL'] - assert_near_equal(ans, reg_data, tol) + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(out_stream=None, method='fd') assert_check_partials(data, atol=1e-4, rtol=1e-4) diff --git a/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_metamodel.py b/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_metamodel.py index 488a766b09..f367d52762 100644 --- a/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_metamodel.py +++ b/aviary/subsystems/aerodynamics/gasp_based/flaps_model/test/test_metamodel.py @@ -40,65 +40,28 @@ def test_case(self): self.prob.run_model() tol = 1e-4 - reg_data = 1 - ans = self.prob['VDEL1'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.55667 - ans = self.prob['VDEL2'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.76500 - ans = self.prob['VDEL3'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.05498 - ans = self.prob['fus_lift'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.97217 - ans = self.prob['VLAM1'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 1.09948 - ans = self.prob['VLAM2'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.97217 - ans = self.prob['VLAM3'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 1.19742 - ans = self.prob['VLAM4'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 1 - ans = self.prob['VLAM5'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.80000 - ans = self.prob['VLAM6'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.73500 - ans = self.prob['VLAM7'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.74000 - ans = self.prob['VLAM10'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 0.84232 - ans = self.prob['VLAM11'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 1.03209 - ans = self.prob['VLAM13'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'VDEL1': 1, + 'VDEL2': 0.55667, + 'VDEL3': 0.76500, + 'fus_lift': 0.05498, + 'VLAM1': 0.97217, + 'VLAM2': 1.09948, + 'VLAM3': 0.97217, + 'VLAM4': 1.19742, + 'VLAM5': 1, + 'VLAM6': 0.80000, + 'VLAM7': 0.73500, + 'VLAM10': 0.74000, + 'VLAM11': 0.84232, + 'VLAM13': 1.03209, + 'VLAM14': 0.99082, + } - reg_data = 0.99082 - ans = self.prob['VLAM14'] - assert_near_equal(ans, reg_data, tol) + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(out_stream=None, method='fd') assert_check_partials(data, atol=1e-4, rtol=1e-4) @@ -121,21 +84,17 @@ def test_case(self): self.prob.run_model() tol = 1e-4 - reg_data = 1 - ans = self.prob['VDEL1'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 1.25725 - ans = self.prob['VLAM4'] - assert_near_equal(ans, reg_data, tol) - - reg_data = 1 - ans = self.prob['VLAM5'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'VDEL1': 1, + 'VLAM4': 1.25725, + 'VLAM5': 1, + 'VLAM6': 1.0, + } - reg_data = 1.0 - ans = self.prob['VLAM6'] - assert_near_equal(ans, reg_data, tol) + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(out_stream=None, method='fd') assert_check_partials(data, atol=1e-4, rtol=1e-4) @@ -157,13 +116,15 @@ def test_case(self): self.prob.run_model() tol = 1e-4 - reg_data = 1.0 - ans = self.prob['VLAM5'] - assert_near_equal(ans, reg_data, tol) + expected_values = { + 'VLAM5': 1.0, + 'VLAM6': 1.11, + } - reg_data = 1.11 - ans = self.prob['VLAM6'] - assert_near_equal(ans, reg_data, tol) + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + ans = self.prob[var_name] + assert_near_equal(ans, reg_data, tol) data = self.prob.check_partials(out_stream=None, method='fd') assert_check_partials(data, atol=1e-4, rtol=1e-4) diff --git a/aviary/subsystems/aerodynamics/gasp_based/test/test_common.py b/aviary/subsystems/aerodynamics/gasp_based/test/test_common.py index 608882a3d9..18b5d55d2d 100644 --- a/aviary/subsystems/aerodynamics/gasp_based/test/test_common.py +++ b/aviary/subsystems/aerodynamics/gasp_based/test/test_common.py @@ -30,10 +30,14 @@ def testAeroForces(self): prob.run_model() - lift = prob.get_val(Dynamic.Vehicle.LIFT) - drag = prob.get_val(Dynamic.Vehicle.DRAG) - assert_near_equal(lift, [1370.3, 1233.27, 1096.24]) - assert_near_equal(drag, [1370.3, 1301.785, 1164.755]) + expected_values = { + Dynamic.Vehicle.LIFT: [1370.3, 1233.27, 1096.24], + Dynamic.Vehicle.DRAG: [1370.3, 1301.785, 1164.755], + } + + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob.get_val(var_name), reg_data) partial_data = prob.check_partials(method='cs', out_stream=None) assert_check_partials(partial_data, atol=1e-12, rtol=1e-15) diff --git a/aviary/subsystems/aerodynamics/gasp_based/test/test_interference.py b/aviary/subsystems/aerodynamics/gasp_based/test/test_interference.py index 972d576bc0..2d3d659008 100644 --- a/aviary/subsystems/aerodynamics/gasp_based/test/test_interference.py +++ b/aviary/subsystems/aerodynamics/gasp_based/test/test_interference.py @@ -47,8 +47,14 @@ def test_common_vars(self): prob.run_model() - assert_near_equal(prob.get_val('ZW_RF'), [-0.8], tol) - assert_near_equal(prob.get_val('wtofd'), [0.144], tol) + expected_values = { + 'ZW_RF': [-0.8], + 'wtofd': [0.144], + } + + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob.get_val(var_name), reg_data, tol) partial_data = prob.check_partials(method='cs', out_stream=None) assert_check_partials(partial_data, atol=1e-12, rtol=1e-14) @@ -84,8 +90,14 @@ def test_body_ratios(self): prob.run_model() - assert_near_equal(prob.get_val('TCBODYWF'), [0.11957627], tol) - assert_near_equal(prob.get_val('CBODYWF'), [11.974576], tol) + expected_values = { + 'TCBODYWF': [0.11957627], + 'CBODYWF': [11.974576], + } + + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob.get_val(var_name), reg_data, tol) partial_data = prob.check_partials(method='cs', out_stream=None) assert_check_partials(partial_data, atol=1e-12, rtol=1e-14) @@ -105,10 +117,14 @@ def test_interference_drag(self): prob.run_model() - assert_near_equal( - prob.get_val('interference_independent_of_shielded_area'), [0.05654201], tol - ) - assert_near_equal(prob.get_val('drag_loss_due_to_shielded_wing_area'), [30], tol) + expected_values = { + 'interference_independent_of_shielded_area': [0.05654201], + 'drag_loss_due_to_shielded_wing_area': [30], + } + + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob.get_val(var_name), reg_data, tol) partial_data = prob.check_partials(method='cs', out_stream=None) assert_check_partials(partial_data, atol=1e-12, rtol=1e-14) @@ -139,10 +155,14 @@ def test_complete_group(self): prob.run_model() - assert_near_equal( - prob.get_val('interference_independent_of_shielded_area'), [0.35794891], tol - ) - assert_near_equal(prob.get_val('drag_loss_due_to_shielded_wing_area'), [83.53366], tol) + expected_values = { + 'interference_independent_of_shielded_area': [0.35794891], + 'drag_loss_due_to_shielded_wing_area': [83.53366], + } + + for var_name, reg_data in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob.get_val(var_name), reg_data, tol) partial_data = prob.check_partials(method='cs', out_stream=None) assert_check_partials(partial_data, atol=1e-12, rtol=1e-14) diff --git a/aviary/subsystems/geometry/gasp_based/test/test_size_group.py b/aviary/subsystems/geometry/gasp_based/test/test_size_group.py index 735e2ad46a..fcdc6de76f 100644 --- a/aviary/subsystems/geometry/gasp_based/test/test_size_group.py +++ b/aviary/subsystems/geometry/gasp_based/test/test_size_group.py @@ -89,43 +89,39 @@ def test_case1(self): self.prob.run_model() tol = 5e-4 - assert_near_equal(self.prob[Aircraft.Fuselage.AVG_DIAMETER], 157.2, tol) - assert_near_equal(self.prob['cabin_height'], 13.1, tol) - assert_near_equal(self.prob['cabin_len'], 72.1, tol) - assert_near_equal(self.prob['nose_height'], 8.6, tol) - - # note: this is the actual GASP value, but for version 3.5. Version 3 has 129.4 - assert_near_equal(self.prob[Aircraft.Fuselage.LENGTH], 129.5, tol) - assert_near_equal(self.prob[Aircraft.Fuselage.WETTED_AREA], 4639.57, tol) - # note: this is the actual GASP value, but for version 3.5. Version 3 has 129.4 - assert_near_equal(self.prob[Aircraft.TailBoom.LENGTH], 129.5, tol) - - assert_near_equal(self.prob[Aircraft.Wing.AREA], 1370.3, tol) - assert_near_equal(self.prob[Aircraft.Wing.SPAN], 117.8, tol) - - assert_near_equal(self.prob[Aircraft.Wing.CENTER_CHORD], 17.49, tol) - assert_near_equal(self.prob[Aircraft.Wing.AVERAGE_CHORD], 12.615, tol) - assert_near_equal(self.prob[Aircraft.Wing.ROOT_CHORD], 16.41, tol) - assert_near_equal( - self.prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.1397, tol - ) # not exact GASP value, likely due to rounding error - assert_near_equal(self.prob[Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX], 1114, tol) - - assert_near_equal(self.prob[Aircraft.HorizontalTail.AREA], 375.9, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.SPAN], 42.25, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.ROOT_CHORD], 13.16130387591471, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 9.57573, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.MOMENT_ARM], 54.7, tol) - - assert_near_equal(self.prob[Aircraft.VerticalTail.AREA], 469.3, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.SPAN], 28, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.ROOT_CHORD], 18.61267549773935, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.AVERAGE_CHORD], 16.83022, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.MOMENT_ARM], 49.9, tol) - - assert_near_equal(self.prob[Aircraft.Nacelle.AVG_DIAMETER], 7.35, tol) - assert_near_equal(self.prob[Aircraft.Nacelle.AVG_LENGTH], 14.7, tol) - assert_near_equal(self.prob[Aircraft.Nacelle.SURFACE_AREA], 339.58, tol) + expected_values = { + Aircraft.Fuselage.AVG_DIAMETER: 157.2, + 'cabin_height': 13.1, + 'cabin_len': 72.1, + 'nose_height': 8.6, + Aircraft.Fuselage.LENGTH: 129.5, # note: this is the actual GASP value, but for version 3.5. Version 3 has 129.4 + Aircraft.Fuselage.WETTED_AREA: 4639.57, + Aircraft.TailBoom.LENGTH: 129.5, # note: this is the actual GASP value, but for version 3.5. Version 3 has 129.4 + Aircraft.Wing.AREA: 1370.3, + Aircraft.Wing.SPAN: 117.8, + Aircraft.Wing.CENTER_CHORD: 17.49, + Aircraft.Wing.AVERAGE_CHORD: 12.615, + Aircraft.Wing.ROOT_CHORD: 16.41, + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.1397, # not exact GASP value, likely due to rounding error + Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX: 1114, + Aircraft.HorizontalTail.AREA: 375.9, + Aircraft.HorizontalTail.SPAN: 42.25, + Aircraft.HorizontalTail.ROOT_CHORD: 13.16130387591471, + Aircraft.HorizontalTail.AVERAGE_CHORD: 9.57573, + Aircraft.HorizontalTail.MOMENT_ARM: 54.7, + Aircraft.VerticalTail.AREA: 469.3, + Aircraft.VerticalTail.SPAN: 28, + Aircraft.VerticalTail.ROOT_CHORD: 18.61267549773935, + Aircraft.VerticalTail.AVERAGE_CHORD: 16.83022, + Aircraft.VerticalTail.MOMENT_ARM: 49.9, + Aircraft.Nacelle.AVG_DIAMETER: 7.35, + Aircraft.Nacelle.AVG_LENGTH: 14.7, + Aircraft.Nacelle.SURFACE_AREA: 339.58, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=2e-12, rtol=1e-12) @@ -222,99 +218,47 @@ def test_case1(self): self.prob.run_model() tol = 1e-4 - assert_near_equal( - self.prob[Aircraft.Fuselage.AVG_DIAMETER], 157.2, tol - ) # not actual GASP value - assert_near_equal(self.prob['cabin_height'], 13.1, tol) # not actual GASP value - assert_near_equal(self.prob['cabin_len'], 72.09722222, tol) # not actual GASP value - assert_near_equal(self.prob['nose_height'], 8.6, tol) # not actual GASP value - - assert_near_equal(self.prob[Aircraft.Fuselage.LENGTH], 129.5, tol) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Fuselage.WETTED_AREA], 4639.57, tol - ) # not actual GASP value - assert_near_equal(self.prob[Aircraft.TailBoom.LENGTH], 129.5, tol) # not actual GASP value - - assert_near_equal(self.prob[Aircraft.Wing.AREA], 1370.3125, tol) # not actual GASP value - assert_near_equal(self.prob[Aircraft.Wing.SPAN], 117.81878299, tol) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.Wing.CENTER_CHORD], 17.48974356, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Wing.AVERAGE_CHORD], 12.61453233, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Wing.ROOT_CHORD], 16.40711451, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.13965584, tol - ) # not actual GASP value - - assert_near_equal( - self.prob['nonfolded_taper_ratio'], 0.93175961, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Wing.FOLDING_AREA], 1167.5966191, tol - ) # not actual GASP value - assert_near_equal( - self.prob['nonfolded_wing_area'], 202.7158809, tol - ) # not actual GASP value - assert_near_equal( - self.prob['tc_ratio_mean_folded'], 0.14847223, tol - ) # not actual GASP value - assert_near_equal(self.prob['nonfolded_AR'], 0.71035382, tol) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX], 208.08091725, tol - ) # not actual GASP value - - assert_near_equal(self.prob['strut_y'], 6, tol) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Strut.LENGTH], 13.11154072, tol - ) # not actual GASP value - assert_near_equal(self.prob[Aircraft.Strut.CHORD], 1.14403031, tol) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.HorizontalTail.AREA], 375.87987047, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.SPAN], 42.25434161, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.ROOT_CHORD], 13.15924684, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 9.57681709, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.MOMENT_ARM], 54.67937726, tol - ) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.VerticalTail.AREA], 469.31832812, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.SPAN], 27.99574268, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.ROOT_CHORD], 18.61623295, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.AVERAGE_CHORD], 16.83214111, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.MOMENT_ARM], 49.88094115, tol - ) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.Nacelle.AVG_DIAMETER], 7.35163168, tol - ) # may not be actual GASP value - assert_near_equal( - self.prob[Aircraft.Nacelle.AVG_LENGTH], 14.70326336, tol - ) # may not be actual GASP value - assert_near_equal( - self.prob[Aircraft.Nacelle.SURFACE_AREA], 339.58410134, tol - ) # may not be actual GASP value + expected_values = { + Aircraft.Fuselage.AVG_DIAMETER: 157.2, # not actual GASP value + 'cabin_height': 13.1, # not actual GASP value + 'cabin_len': 72.09722222, # not actual GASP value + 'nose_height': 8.6, # not actual GASP value + Aircraft.Fuselage.LENGTH: 129.5, # not actual GASP value + Aircraft.Fuselage.WETTED_AREA: 4639.57, # not actual GASP value + Aircraft.TailBoom.LENGTH: 129.5, # not actual GASP value + Aircraft.Wing.AREA: 1370.3125, # not actual GASP value + Aircraft.Wing.SPAN: 117.81878299, # not actual GASP value + Aircraft.Wing.CENTER_CHORD: 17.48974356, # not actual GASP value + Aircraft.Wing.AVERAGE_CHORD: 12.61453233, # not actual GASP value + Aircraft.Wing.ROOT_CHORD: 16.40711451, # not actual GASP value + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.13965584, # not actual GASP value + 'nonfolded_taper_ratio': 0.93175961, # not actual GASP value + Aircraft.Wing.FOLDING_AREA: 1167.5966191, # not actual GASP value + 'nonfolded_wing_area': 202.7158809, # not actual GASP value + 'tc_ratio_mean_folded': 0.14847223, # not actual GASP value + 'nonfolded_AR': 0.71035382, # not actual GASP value + Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX: 208.08091725, # not actual GASP value + 'strut_y': 6, # not actual GASP value + Aircraft.Strut.LENGTH: 13.11154072, # not actual GASP value + Aircraft.Strut.CHORD: 1.14403031, # not actual GASP value + Aircraft.HorizontalTail.AREA: 375.87987047, # not actual GASP value + Aircraft.HorizontalTail.SPAN: 42.25434161, # not actual GASP value + Aircraft.HorizontalTail.ROOT_CHORD: 13.15924684, # not actual GASP value + Aircraft.HorizontalTail.AVERAGE_CHORD: 9.57681709, # not actual GASP value + Aircraft.HorizontalTail.MOMENT_ARM: 54.67937726, # not actual GASP value + Aircraft.VerticalTail.AREA: 469.31832812, # not actual GASP value + Aircraft.VerticalTail.SPAN: 27.99574268, # not actual GASP value + Aircraft.VerticalTail.ROOT_CHORD: 18.61623295, # not actual GASP value + Aircraft.VerticalTail.AVERAGE_CHORD: 16.83214111, # not actual GASP value + Aircraft.VerticalTail.MOMENT_ARM: 49.88094115, # not actual GASP value + Aircraft.Nacelle.AVG_DIAMETER: 7.35163168, # may not be actual GASP value + Aircraft.Nacelle.AVG_LENGTH: 14.70326336, # may not be actual GASP value + Aircraft.Nacelle.SURFACE_AREA: 339.58410134, # may not be actual GASP value + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=3e-10, rtol=1e-12) @@ -410,99 +354,45 @@ def test_case1(self): self.prob.run_model() tol = 1e-4 - assert_near_equal( - self.prob[Aircraft.Fuselage.AVG_DIAMETER], 56.2, tol - ) # not actual GASP value - assert_near_equal(self.prob['cabin_height'], 9.18333, tol) # not actual GASP value - assert_near_equal(self.prob['cabin_len'], 435, tol) # not actual GASP value - assert_near_equal(self.prob['nose_height'], 4.68333, tol) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.Fuselage.LENGTH], 476.7333, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Fuselage.WETTED_AREA], 13400.44, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.TailBoom.LENGTH], 476.7333, tol - ) # not actual GASP value - - assert_near_equal(self.prob[Aircraft.Wing.AREA], 1370.3125, tol) # not actual GASP value - assert_near_equal(self.prob[Aircraft.Wing.SPAN], 117.81878299, tol) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.Wing.CENTER_CHORD], 17.48974356, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Wing.AVERAGE_CHORD], 12.61453233, tol - ) # not actual GASP value - assert_near_equal(self.prob[Aircraft.Wing.ROOT_CHORD], 16.988, tol) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.14151, tol - ) # not actual GASP value - - assert_near_equal( - self.prob['nonfolded_taper_ratio'], 0.85783252, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Wing.FOLDING_AREA], 964.14982163, tol - ) # not actual GASP value - assert_near_equal( - self.prob['nonfolded_wing_area'], 406.16267837, tol - ) # not actual GASP value - assert_near_equal( - self.prob['tc_ratio_mean_folded'], 0.14681715, tol - ) # not actual GASP value - assert_near_equal(self.prob['nonfolded_AR'], 1.5387923, tol) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX], 406.53567274, tol - ) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.HorizontalTail.AREA], 298.484, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.SPAN], 37.654, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.ROOT_CHORD], 11.7265, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 8.5341, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.MOMENT_ARM], 54.67937726, tol - ) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.VerticalTail.AREA], 297.003, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.SPAN], 22.2709, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.ROOT_CHORD], 14.8094, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.AVERAGE_CHORD], 13.3902, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.MOMENT_ARM], 49.88094115, tol - ) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.Nacelle.AVG_DIAMETER], 7.35163168, tol - ) # may not be actual GASP value - assert_near_equal( - self.prob[Aircraft.Nacelle.AVG_LENGTH], 14.70326336, tol - ) # may not be actual GASP value - assert_near_equal( - self.prob[Aircraft.Nacelle.SURFACE_AREA], 339.58410134, tol - ) # may not be actual GASP value - - assert_near_equal( - self.prob[Aircraft.Electrical.HYBRID_CABLE_LENGTH], 50.6032, tol - ) # not actual GASP value + expected_values = { + Aircraft.Fuselage.AVG_DIAMETER: 56.2, # not actual GASP value + 'cabin_height': 9.18333, # not actual GASP value + 'cabin_len': 435, # not actual GASP value + 'nose_height': 4.68333, # not actual GASP value + Aircraft.Fuselage.LENGTH: 476.7333, # not actual GASP value + Aircraft.Fuselage.WETTED_AREA: 13400.44, # not actual GASP value + Aircraft.TailBoom.LENGTH: 476.7333, # not actual GASP value + Aircraft.Wing.AREA: 1370.3125, # not actual GASP value + Aircraft.Wing.SPAN: 117.81878299, # not actual GASP value + Aircraft.Wing.CENTER_CHORD: 17.48974356, # not actual GASP value + Aircraft.Wing.AVERAGE_CHORD: 12.61453233, # not actual GASP value + Aircraft.Wing.ROOT_CHORD: 16.988, # not actual GASP value + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.14151, # not actual GASP value + 'nonfolded_taper_ratio': 0.85783252, # not actual GASP value + Aircraft.Wing.FOLDING_AREA: 964.14982163, # not actual GASP value + 'nonfolded_wing_area': 406.16267837, # not actual GASP value + 'tc_ratio_mean_folded': 0.14681715, # not actual GASP value + 'nonfolded_AR': 1.5387923, # not actual GASP value + Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX: 406.53567274, # not actual GASP value + Aircraft.HorizontalTail.AREA: 298.484, # not actual GASP value + Aircraft.HorizontalTail.SPAN: 37.654, # not actual GASP value + Aircraft.HorizontalTail.ROOT_CHORD: 11.7265, # not actual GASP value + Aircraft.HorizontalTail.AVERAGE_CHORD: 8.5341, # not actual GASP value + Aircraft.HorizontalTail.MOMENT_ARM: 54.67937726, # not actual GASP value + Aircraft.VerticalTail.AREA: 297.003, # not actual GASP value + Aircraft.VerticalTail.SPAN: 22.2709, # not actual GASP value + Aircraft.VerticalTail.ROOT_CHORD: 14.8094, # not actual GASP value + Aircraft.VerticalTail.AVERAGE_CHORD: 13.3902, # not actual GASP value + Aircraft.VerticalTail.MOMENT_ARM: 49.88094115, # not actual GASP value + Aircraft.Nacelle.AVG_DIAMETER: 7.35163168, # may not be actual GASP value + Aircraft.Nacelle.AVG_LENGTH: 14.70326336, # may not be actual GASP value + Aircraft.Nacelle.SURFACE_AREA: 339.58410134, # may not be actual GASP value + Aircraft.Electrical.HYBRID_CABLE_LENGTH: 50.6032, # not actual GASP value + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-9, rtol=1e-12) @@ -598,82 +488,41 @@ def test_case1(self): self.prob.run_model() tol = 1e-4 - assert_near_equal( - self.prob[Aircraft.Fuselage.AVG_DIAMETER], 56.2, tol - ) # not actual GASP value - assert_near_equal(self.prob['cabin_height'], 9.18333, tol) # not actual GASP value - assert_near_equal(self.prob['cabin_len'], 435, tol) # not actual GASP value - assert_near_equal(self.prob['nose_height'], 4.68333, tol) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.Fuselage.LENGTH], 476.7333, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Fuselage.WETTED_AREA], 13400.44, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.TailBoom.LENGTH], 476.7333, tol - ) # not actual GASP value - - assert_near_equal(self.prob[Aircraft.Wing.AREA], 1370.3125, tol) # not actual GASP value - assert_near_equal(self.prob[Aircraft.Wing.SPAN], 117.81878299, tol) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.Wing.CENTER_CHORD], 17.48974356, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Wing.AVERAGE_CHORD], 12.61453233, tol - ) # not actual GASP value - assert_near_equal(self.prob[Aircraft.Wing.ROOT_CHORD], 16.988, tol) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.14151, tol - ) # not actual GASP value - - assert_near_equal(self.prob['strut_y'], 0, tol) # not actual GASP value - assert_near_equal(self.prob[Aircraft.Strut.LENGTH], 5.2361, tol) # not actual GASP value - assert_near_equal(self.prob[Aircraft.Strut.CHORD], 2.8647, tol) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.HorizontalTail.AREA], 298.484, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.SPAN], 37.654, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.ROOT_CHORD], 11.7265, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 8.5341, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.HorizontalTail.MOMENT_ARM], 54.67937726, tol - ) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.VerticalTail.AREA], 297.003, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.SPAN], 22.2709, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.ROOT_CHORD], 14.8094, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.AVERAGE_CHORD], 13.3902, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.VerticalTail.MOMENT_ARM], 49.88094115, tol - ) # not actual GASP value - - assert_near_equal( - self.prob[Aircraft.Nacelle.AVG_DIAMETER], 7.35163168, tol - ) # may not be actual GASP value - assert_near_equal( - self.prob[Aircraft.Nacelle.AVG_LENGTH], 14.70326336, tol - ) # may not be actual GASP value - assert_near_equal( - self.prob[Aircraft.Nacelle.SURFACE_AREA], 339.58410134, tol - ) # may not be actual GASP value + expected_values = { + Aircraft.Fuselage.AVG_DIAMETER: 56.2, # not actual GASP value + 'cabin_height': 9.18333, # not actual GASP value + 'cabin_len': 435, # not actual GASP value + 'nose_height': 4.68333, # not actual GASP value + Aircraft.Fuselage.LENGTH: 476.7333, # not actual GASP value + Aircraft.Fuselage.WETTED_AREA: 13400.44, # not actual GASP value + Aircraft.TailBoom.LENGTH: 476.7333, # not actual GASP value + Aircraft.Wing.AREA: 1370.3125, # not actual GASP value + Aircraft.Wing.SPAN: 117.81878299, # not actual GASP value + Aircraft.Wing.CENTER_CHORD: 17.48974356, # not actual GASP value + Aircraft.Wing.AVERAGE_CHORD: 12.61453233, # not actual GASP value + Aircraft.Wing.ROOT_CHORD: 16.988, # not actual GASP value + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.14151, # not actual GASP value + 'strut_y': 0, # not actual GASP value + Aircraft.Strut.LENGTH: 5.2361, # not actual GASP value + Aircraft.Strut.CHORD: 2.8647, # not actual GASP value + Aircraft.HorizontalTail.AREA: 298.484, # not actual GASP value + Aircraft.HorizontalTail.SPAN: 37.654, # not actual GASP value + Aircraft.HorizontalTail.ROOT_CHORD: 11.7265, # not actual GASP value + Aircraft.HorizontalTail.AVERAGE_CHORD: 8.5341, # not actual GASP value + Aircraft.HorizontalTail.MOMENT_ARM: 54.67937726, # not actual GASP value + Aircraft.VerticalTail.AREA: 297.003, # not actual GASP value + Aircraft.VerticalTail.SPAN: 22.2709, # not actual GASP value + Aircraft.VerticalTail.ROOT_CHORD: 14.8094, # not actual GASP value + Aircraft.VerticalTail.AVERAGE_CHORD: 13.3902, # not actual GASP value + Aircraft.VerticalTail.MOMENT_ARM: 49.88094115, # not actual GASP value + Aircraft.Nacelle.AVG_DIAMETER: 7.35163168, # may not be actual GASP value + Aircraft.Nacelle.AVG_LENGTH: 14.70326336, # may not be actual GASP value + Aircraft.Nacelle.SURFACE_AREA: 339.58410134, # may not be actual GASP value + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=2e-12, rtol=1e-12) @@ -821,41 +670,40 @@ def test_case1(self): tol = 1e-4 # BWBFuselageGroup - assert_near_equal(self.prob[Aircraft.Fuselage.AVG_DIAMETER], 38, tol) - assert_near_equal(self.prob['cabin_height'], 9.86859989, tol) - # assert_near_equal(self.prob['fuselage.cabin_len'], 43.83334, tol) - assert_near_equal(self.prob['nose_height'], 4.86859989, tol) - assert_near_equal(self.prob[Aircraft.Fuselage.LENGTH], 71.5245514, tol) - assert_near_equal(self.prob[Aircraft.Fuselage.WETTED_AREA], 4573.42578, tol) - assert_near_equal(self.prob[Aircraft.TailBoom.LENGTH], 71.5245514, tol) - - # BWBWingGroup - assert_near_equal(self.prob[Aircraft.Wing.AREA], 2142.85714286, tol) - assert_near_equal(self.prob[Aircraft.Wing.SPAN], 146.38501094, tol) - assert_near_equal(self.prob[Aircraft.Wing.CENTER_CHORD], 22.97244452, tol) - assert_near_equal(self.prob[Aircraft.Wing.AVERAGE_CHORD], 16.2200522, tol) - assert_near_equal(self.prob[Aircraft.Wing.ROOT_CHORD], 20.33371617, tol) - assert_near_equal(self.prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.13596576, tol) - assert_near_equal(self.prob['wing_volume_no_fold'], 783.62100035, tol) - assert_near_equal(self.prob[Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX], 605.90781747, tol) - assert_near_equal(self.prob[Aircraft.Wing.EXPOSED_AREA], 1352.1135998, tol) - - # EmpennageSize - assert_near_equal(self.prob[Aircraft.HorizontalTail.AREA], 0.00117064, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.SPAN], 0.04467601, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.ROOT_CHORD], 0.03836448, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 0.02808445, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.MOMENT_ARM], 29.69074172, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.AREA], 169.11964286, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.SPAN], 16.98084188, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.ROOT_CHORD], 14.58190052, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.AVERAGE_CHORD], 10.67457744, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.MOMENT_ARM], 27.82191598, tol) - - # BWBEngineSizeGroup - assert_near_equal(self.prob[Aircraft.Nacelle.AVG_DIAMETER], 5.33382144, tol) - assert_near_equal(self.prob[Aircraft.Nacelle.AVG_LENGTH], 7.24759657, tol) - assert_near_equal(self.prob[Aircraft.Nacelle.SURFACE_AREA], 121.44575974, tol) + expected_values = { + Aircraft.Fuselage.AVG_DIAMETER: 38, + 'cabin_height': 9.86859989, + 'nose_height': 4.86859989, + Aircraft.Fuselage.LENGTH: 71.5245514, + Aircraft.Fuselage.WETTED_AREA: 4573.42578, + Aircraft.TailBoom.LENGTH: 71.5245514, + Aircraft.Wing.AREA: 2142.85714286, + Aircraft.Wing.SPAN: 146.38501094, + Aircraft.Wing.CENTER_CHORD: 22.97244452, + Aircraft.Wing.AVERAGE_CHORD: 16.2200522, + Aircraft.Wing.ROOT_CHORD: 20.33371617, + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.13596576, + 'wing_volume_no_fold': 783.62100035, + Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX: 605.90781747, + Aircraft.Wing.EXPOSED_AREA: 1352.1135998, + Aircraft.HorizontalTail.AREA: 0.00117064, + Aircraft.HorizontalTail.SPAN: 0.04467601, + Aircraft.HorizontalTail.ROOT_CHORD: 0.03836448, + Aircraft.HorizontalTail.AVERAGE_CHORD: 0.02808445, + Aircraft.HorizontalTail.MOMENT_ARM: 29.69074172, + Aircraft.VerticalTail.AREA: 169.11964286, + Aircraft.VerticalTail.SPAN: 16.98084188, + Aircraft.VerticalTail.ROOT_CHORD: 14.58190052, + Aircraft.VerticalTail.AVERAGE_CHORD: 10.67457744, + Aircraft.VerticalTail.MOMENT_ARM: 27.82191598, + Aircraft.Nacelle.AVG_DIAMETER: 5.33382144, + Aircraft.Nacelle.AVG_LENGTH: 7.24759657, + Aircraft.Nacelle.SURFACE_AREA: 121.44575974, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=3e-9, rtol=3e-9) diff --git a/aviary/subsystems/mass/gasp_based/test/test_fixed.py b/aviary/subsystems/mass/gasp_based/test/test_fixed.py index e27601068b..9b2f3e07a3 100644 --- a/aviary/subsystems/mass/gasp_based/test/test_fixed.py +++ b/aviary/subsystems/mass/gasp_based/test/test_fixed.py @@ -64,14 +64,17 @@ def test_case1(self): self.prob.run_model() tol = 1e-4 - assert_near_equal( - self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.2203729275531838, tol - ) # bug fixed value - assert_near_equal(self.prob['c_strut_braced'], 1, tol) # bug fixed value - assert_near_equal(self.prob['c_gear_loc'], 1, tol) # bug fixed value - # bug fixed value - assert_near_equal(self.prob[Aircraft.Engine.POSITION_FACTOR], 0.95, tol) - assert_near_equal(self.prob['half_sweep'], 0.3947081519145335, tol) # bug fixed value + expected_values = { + Aircraft.Wing.MATERIAL_FACTOR: 1.2203729275531838, # bug fixed value + 'c_strut_braced': 1, # bug fixed value + 'c_gear_loc': 1, # bug fixed value + Aircraft.Engine.POSITION_FACTOR: 0.95, # bug fixed value + 'half_sweep': 0.3947081519145335, # bug fixed value + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) @@ -109,14 +112,17 @@ def test_case1(self): self.prob.run_model() tol = 1e-4 - assert_near_equal( - self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.2213063198183813, tol - ) # not actual bug fixed value - assert_near_equal(self.prob['c_strut_braced'], 1, tol) - assert_near_equal(self.prob['c_gear_loc'], 0.95, tol) # not actual bug fixed value - # not actual bug fixed value - assert_near_equal(self.prob[Aircraft.Engine.POSITION_FACTOR], 1, tol) - assert_near_equal(self.prob['half_sweep'], 0.3947081519145335, tol) + expected_values = { + Aircraft.Wing.MATERIAL_FACTOR: 1.2213063198183813, # not actual bug fixed value + 'c_strut_braced': 1, + 'c_gear_loc': 0.95, # not actual bug fixed value + Aircraft.Engine.POSITION_FACTOR: 1, # not actual bug fixed value + 'half_sweep': 0.3947081519145335, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) @@ -155,15 +161,17 @@ def test_case1(self): self.prob.run_model() tol = 1e-4 - assert_near_equal( - self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.2213063198183813, tol - ) # not actual bug fixed value - assert_near_equal(self.prob['c_strut_braced'], 1, tol) - assert_near_equal(self.prob['c_gear_loc'], 0.95, tol) # not actual bug fixed value - assert_near_equal( - self.prob[Aircraft.Engine.POSITION_FACTOR], 0.98, tol - ) # not actual bug fixed value - assert_near_equal(self.prob['half_sweep'], 0.3947081519145335, tol) + expected_values = { + Aircraft.Wing.MATERIAL_FACTOR: 1.2213063198183813, # not actual bug fixed value + 'c_strut_braced': 1, + 'c_gear_loc': 0.95, # not actual bug fixed value + Aircraft.Engine.POSITION_FACTOR: 0.98, # not actual bug fixed value + 'half_sweep': 0.3947081519145335, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) @@ -202,15 +210,17 @@ def test_case1(self): self.prob.run_model() tol = 1e-4 - assert_near_equal( - self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.2213063198183813, tol - ) # not actual bug fixed value - assert_near_equal(self.prob['c_strut_braced'], 1, tol) - assert_near_equal(self.prob['c_gear_loc'], 0.95, tol) # not actual bug fixed value - assert_near_equal( - self.prob[Aircraft.Engine.POSITION_FACTOR], 0.95, tol - ) # not actual bug fixed value - assert_near_equal(self.prob['half_sweep'], 0.3947081519145335, tol) + expected_values = { + Aircraft.Wing.MATERIAL_FACTOR: 1.2213063198183813, # not actual bug fixed value + 'c_strut_braced': 1, + 'c_gear_loc': 0.95, # not actual bug fixed value + Aircraft.Engine.POSITION_FACTOR: 0.95, # not actual bug fixed value + 'half_sweep': 0.3947081519145335, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) @@ -249,15 +259,17 @@ def test_case1(self): self.prob.run_model() tol = 1e-4 - assert_near_equal( - self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.2213063198183813, tol - ) # not actual bug fixed value - assert_near_equal(self.prob['c_strut_braced'], 1, tol) - assert_near_equal(self.prob['c_gear_loc'], 0.95, tol) # not actual bug fixed value - assert_near_equal( - self.prob[Aircraft.Engine.POSITION_FACTOR], 0.9, tol - ) # not actual bug fixed value - assert_near_equal(self.prob['half_sweep'], 0.3947081519145335, tol) + expected_values = { + Aircraft.Wing.MATERIAL_FACTOR: 1.2213063198183813, # not actual bug fixed value + 'c_strut_braced': 1, + 'c_gear_loc': 0.95, # not actual bug fixed value + Aircraft.Engine.POSITION_FACTOR: 0.9, # not actual bug fixed value + 'half_sweep': 0.3947081519145335, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) @@ -289,15 +301,15 @@ def test_case1(self): self.prob.run_model() tol = 1e-4 - assert_near_equal( - self.prob[Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS], 36000, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['payload_mass_des'], 36000, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['payload_mass_max'], 46040, tol - ) # bug fixed value and original value + expected_values = { + Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS: 36000, # bug fixed value and original value + 'payload_mass_des': 36000, # bug fixed value and original value + 'payload_mass_max': 46040, # bug fixed value and original value + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) diff --git a/aviary/subsystems/mass/gasp_based/test/test_mass_summation.py b/aviary/subsystems/mass/gasp_based/test/test_mass_summation.py index 6f635217ed..3fcd5b24bd 100644 --- a/aviary/subsystems/mass/gasp_based/test/test_mass_summation.py +++ b/aviary/subsystems/mass/gasp_based/test/test_mass_summation.py @@ -69,78 +69,43 @@ def test_case1(self): # print(f'wetted_area: {self.prob[Aircraft.Fuselage.WETTED_AREA]}') tol = 5e-4 - # size values: - assert_near_equal(self.prob['gasp_based_geom.cabin_height'], 13.1, tol) - assert_near_equal(self.prob['gasp_based_geom.cabin_len'], 72.09722222222223, tol) - assert_near_equal(self.prob['gasp_based_geom.nose_height'], 8.6, tol) - - assert_near_equal(self.prob[Aircraft.Wing.CENTER_CHORD], 17.63, tol) - assert_near_equal(self.prob[Aircraft.Wing.ROOT_CHORD], 16.54, tol) - assert_near_equal( - self.prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.1397, tol - ) # not exact GASP value from the output file, likely due to rounding error - - assert_near_equal(self.prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 9.6509873673743, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.AVERAGE_CHORD], 16.96457870166355, tol) - assert_near_equal(self.prob[Aircraft.Nacelle.AVG_LENGTH], 14.7, tol) - - # fixed mass values: - assert_near_equal(self.prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6384.35, tol) - assert_near_equal(self.prob['loc_MAC_vtail'], 0.44959578484694906, tol) - - # wing values: - assert_near_equal(self.prob['isolated_wing_mass'], 15758, tol) - assert_near_equal(self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 12606, tol) - assert_near_equal(self.prob[Aircraft.Engine.ADDITIONAL_MASS], 1765 / 2, tol) - - # fuel values: - # modified from GASP value to account for updated crew mass. GASP value is - # 78843.6 - assert_near_equal(self.prob['OEM_wingfuel_mass'], 79500.16001078, tol) - # modified from GASP value to account for updated crew mass. GASP value is - # 102408.05695930264 - assert_near_equal(self.prob['fus_mass_full'], 101735.01012115, tol) - # modified from GASP value to account for updated crew mass. GASP value is - # 1757 - assert_near_equal( - self.prob[Aircraft.Fuel.FUEL_SYSTEM_MASS], 1783.50656044, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 1757 - assert_near_equal(self.prob[Aircraft.Design.STRUCTURE_MASS], 50266.438, tol) - assert_near_equal( - self.prob[Aircraft.Fuselage.MASS], 18624.42144949, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 18814 - - # modified from GASP value to account for updated crew mass. GASP value is - # 42843.6 - assert_near_equal( - self.prob[Mission.Summary.FUEL_MASS_REQUIRED], 43500.16001078, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 42843.6 - assert_near_equal( - self.prob[Aircraft.Propulsion.MASS], 16161.21, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 16127 - assert_near_equal( - self.prob[Mission.Summary.FUEL_MASS], 43500.16001078, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 42844.0 - assert_near_equal( - self.prob['fuel_mass_min'], 33460.16001078, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 32803.6 - assert_near_equal( - self.prob[Aircraft.Fuel.WING_VOLUME_DESIGN], 869.61632311, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 856.4910800459031 - assert_near_equal( - self.prob['OEM_fuel_vol'], 1589.29615013, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 1576.1710061411081 - assert_near_equal( - self.prob[Mission.Summary.OPERATING_MASS], 95899.83998922, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 96556.0 - # extra_fuel_mass calculated differently in this version, so test for payload_mass_max_fuel not included - assert_near_equal(self.prob['volume_wingfuel_mass'], 57066.3, tol) - assert_near_equal(self.prob['max_wingfuel_mass'], 57066.3, tol) - assert_near_equal( - self.prob[Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY], 0, tol - ) # always zero when no body tank - assert_near_equal(self.prob['extra_fuel_volume'], 0, tol) # always zero when no body tank - assert_near_equal(self.prob['max_extra_fuel_mass'], 0, tol) # always zero when no body tank + expected_values = { + 'gasp_based_geom.cabin_height': 13.1, + 'gasp_based_geom.cabin_len': 72.09722222222223, + 'gasp_based_geom.nose_height': 8.6, + Aircraft.Wing.CENTER_CHORD: 17.63, + Aircraft.Wing.ROOT_CHORD: 16.54, + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.1397, # not exact GASP value from the output file, likely due to rounding error + Aircraft.HorizontalTail.AVERAGE_CHORD: 9.6509873673743, + Aircraft.VerticalTail.AVERAGE_CHORD: 16.96457870166355, + Aircraft.Nacelle.AVG_LENGTH: 14.7, + Aircraft.LandingGear.MAIN_GEAR_MASS: 6384.35, + 'loc_MAC_vtail': 0.44959578484694906, + 'isolated_wing_mass': 15758, + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 12606, + Aircraft.Engine.ADDITIONAL_MASS: 1765 / 2, + 'OEM_wingfuel_mass': 79500.16001078, # modified from GASP value to account for updated crew mass. GASP value is 78843.6 + 'fus_mass_full': 101735.01012115, # modified from GASP value to account for updated crew mass. GASP value is 102408.05695930264 + Aircraft.Fuel.FUEL_SYSTEM_MASS: 1783.50656044, # modified from GASP value to account for updated crew mass. GASP value is 1757 + Aircraft.Design.STRUCTURE_MASS: 50266.438, + Aircraft.Fuselage.MASS: 18624.42144949, # modified from GASP value to account for updated crew mass. GASP value is 18814 + Mission.Summary.FUEL_MASS_REQUIRED: 43500.16001078, # modified from GASP value to account for updated crew mass. GASP value is 42843.6 + Aircraft.Propulsion.MASS: 16161.21, # modified from GASP value to account for updated crew mass. GASP value is 16127 + Mission.Summary.FUEL_MASS: 43500.16001078, # modified from GASP value to account for updated crew mass. GASP value is 42844.0 + 'fuel_mass_min': 33460.16001078, # modified from GASP value to account for updated crew mass. GASP value is 32803.6 + Aircraft.Fuel.WING_VOLUME_DESIGN: 869.61632311, # modified from GASP value to account for updated crew mass. GASP value is 856.4910800459031 + 'OEM_fuel_vol': 1589.29615013, # modified from GASP value to account for updated crew mass. GASP value is 1576.1710061411081 + Mission.Summary.OPERATING_MASS: 95899.83998922, # modified from GASP value to account for updated crew mass. GASP value is 96556.0 + 'volume_wingfuel_mass': 57066.3, # extra_fuel_mass calculated differently in this version, so test for payload_mass_max_fuel not included + 'max_wingfuel_mass': 57066.3, + Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY: 0, # always zero when no body tank + 'extra_fuel_volume': 0, # always zero when no body tank + 'max_extra_fuel_mass': 0, # always zero when no body tank + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=3e-10, rtol=1e-12) diff --git a/aviary/subsystems/propulsion/propeller/test/test_propeller_performance.py b/aviary/subsystems/propulsion/propeller/test/test_propeller_performance.py index 82920c0d04..b0d9f69362 100644 --- a/aviary/subsystems/propulsion/propeller/test/test_propeller_performance.py +++ b/aviary/subsystems/propulsion/propeller/test/test_propeller_performance.py @@ -258,13 +258,18 @@ def compare_results(self, case_idx_begin, case_idx_end): for case_idx in range(case_idx_begin, case_idx_end): idx = case_idx - case_idx_begin - assert_near_equal(cthr[idx], CT[case_idx], tolerance=tol) - assert_near_equal(ctlf[idx], XFT[case_idx], tolerance=tol) - assert_near_equal(tccl[idx], CTX[case_idx], tolerance=tol) - assert_near_equal(thrt[idx], thrust[case_idx], tolerance=tol) - assert_near_equal(peff[idx], prop_eff[case_idx], tolerance=tol) - assert_near_equal(lfac[idx], install_loss[case_idx], tolerance=tol) - assert_near_equal(ieff[idx], install_eff[case_idx], tolerance=tol) + expected_values = { + 'thrust_coefficient': (cthr[idx], CT[case_idx]), + 'comp_tip_loss_factor': (ctlf[idx], XFT[case_idx]), + 'thrust_coefficient_comp_loss': (tccl[idx], CTX[case_idx]), + 'thrust': (thrt[idx], thrust[case_idx]), + 'propeller_efficiency': (peff[idx], prop_eff[case_idx]), + 'install_loss_factor': (lfac[idx], install_loss[case_idx]), + 'install_efficiency': (ieff[idx], install_eff[case_idx]), + } + for var_name, (actual, expected) in expected_values.items(): + with self.subTest(case_idx=case_idx, var=var_name): + assert_near_equal(actual, expected, tolerance=tol) def test_case_0_1_2(self): # Case 0, 1, 2, to test installation loss factor computation. diff --git a/aviary/subsystems/test/test_gasp_based_premission.py b/aviary/subsystems/test/test_gasp_based_premission.py index 860099b3d7..55069197ca 100644 --- a/aviary/subsystems/test/test_gasp_based_premission.py +++ b/aviary/subsystems/test/test_gasp_based_premission.py @@ -51,60 +51,62 @@ def test_case1(self): prob.run_model() tol = 1e-5 - # propulsion subsystem - # geometry subsystem - assert_near_equal(prob[Aircraft.Fuselage.AVG_DIAMETER], 157.2, tol) - assert_near_equal(prob[Aircraft.Fuselage.LENGTH], 129.497, tol) - assert_near_equal(prob[Aircraft.Fuselage.WETTED_AREA], 4000.0, tol) - assert_near_equal(prob[Aircraft.Wing.AREA], 1370.3125, tol) - assert_near_equal(prob[Aircraft.Wing.SPAN], 117.81878299, tol) - assert_near_equal(prob[Aircraft.Wing.CENTER_CHORD], 17.48974356, tol) - assert_near_equal(prob[Aircraft.Wing.AVERAGE_CHORD], 12.61453233, tol) - assert_near_equal(prob[Aircraft.Wing.ROOT_CHORD], 16.40711451, tol) - assert_near_equal(prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.139656, tol) - assert_near_equal(prob[Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX], 1114.0056, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.AREA], 375.8798, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.SPAN], 42.2543, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.ROOT_CHORD], 13.1592, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 9.5768, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.MOMENT_ARM], 54.6793, tol) - assert_near_equal(prob[Aircraft.VerticalTail.AREA], 469.3183, tol) - assert_near_equal(prob[Aircraft.VerticalTail.SPAN], 27.9957, tol) - assert_near_equal(prob[Aircraft.VerticalTail.ROOT_CHORD], 18.6162, tol) - assert_near_equal(prob[Aircraft.VerticalTail.AVERAGE_CHORD], 16.8321, tol) - assert_near_equal(prob[Aircraft.VerticalTail.MOMENT_ARM], 49.8809, tol) - assert_near_equal(prob[Aircraft.Nacelle.AVG_DIAMETER], 7.25, tol) - assert_near_equal(prob[Aircraft.Nacelle.AVG_LENGTH], 14.5, tol) - assert_near_equal(prob[Aircraft.Nacelle.SURFACE_AREA], 330.2599, tol) - # mass subsystem - assert_near_equal(self.prob[Aircraft.Design.LIFT_CURVE_SLOPE], 6.39471, tol) - assert_near_equal(self.prob[Aircraft.Wing.ULTIMATE_LOAD_FACTOR], 3.75, tol) - assert_near_equal(self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.22129, tol) - assert_near_equal(self.prob[Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS], 36000.0, tol) - assert_near_equal(self.prob[Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS], 36000.0, tol) - assert_near_equal(self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 12605.94, tol) - assert_near_equal(self.prob[Aircraft.Nacelle.MASS], 990.7798, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.MASS], 2276.1316, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.MASS], 2297.9697, tol) - assert_near_equal(self.prob[Aircraft.Wing.HIGH_LIFT_MASS], 4740.1241, tol) - assert_near_equal(self.prob[Aircraft.Controls.TOTAL_MASS], 3819.3564, tol) - assert_near_equal(self.prob[Aircraft.Wing.SURFACE_CONTROL_MASS], 3682.099, tol) - assert_near_equal(prob[Aircraft.LandingGear.TOTAL_MASS], 7489.8343, tol) - assert_near_equal(prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6366.3591, tol) - assert_near_equal(self.prob[Aircraft.Design.FIXED_EQUIPMENT_MASS], 21078.3911, tol) - assert_near_equal(self.prob[Aircraft.Design.FIXED_USEFUL_LOAD], 5341.4317956, tol) - - assert_near_equal(prob[Aircraft.Engine.ADDITIONAL_MASS], 850.90095, tol) - assert_near_equal(prob[Aircraft.Wing.MASS], 16206.8122, tol) - assert_near_equal(prob[Aircraft.Fuel.FUEL_SYSTEM_MASS], 1740.2606, tol) - assert_near_equal(prob[Aircraft.Design.STRUCTURE_MASS], 50667.4376, tol) - assert_near_equal(prob[Aircraft.Fuselage.MASS], 18673.0352, tol) - assert_near_equal(prob[Mission.Summary.FUEL_MASS_REQUIRED], 42445.3806, tol) - assert_near_equal(prob[Aircraft.Propulsion.MASS], 16048.0025, tol) - assert_near_equal(prob[Mission.Summary.FUEL_MASS], 42445.3806, tol) - assert_near_equal(prob[Aircraft.Fuel.WING_VOLUME_DESIGN], 848.5301, tol) - assert_near_equal(prob[Mission.Summary.OPERATING_MASS], 96954.6194, tol) - assert_near_equal(prob[Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY], 0, tol) + expected_values = { + Aircraft.Fuselage.AVG_DIAMETER: 157.2, + Aircraft.Fuselage.LENGTH: 129.497, + Aircraft.Fuselage.WETTED_AREA: 4000.0, + Aircraft.Wing.AREA: 1370.3125, + Aircraft.Wing.SPAN: 117.81878299, + Aircraft.Wing.CENTER_CHORD: 17.48974356, + Aircraft.Wing.AVERAGE_CHORD: 12.61453233, + Aircraft.Wing.ROOT_CHORD: 16.40711451, + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.139656, + Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX: 1114.0056, + Aircraft.HorizontalTail.AREA: 375.8798, + Aircraft.HorizontalTail.SPAN: 42.2543, + Aircraft.HorizontalTail.ROOT_CHORD: 13.1592, + Aircraft.HorizontalTail.AVERAGE_CHORD: 9.5768, + Aircraft.HorizontalTail.MOMENT_ARM: 54.6793, + Aircraft.VerticalTail.AREA: 469.3183, + Aircraft.VerticalTail.SPAN: 27.9957, + Aircraft.VerticalTail.ROOT_CHORD: 18.6162, + Aircraft.VerticalTail.AVERAGE_CHORD: 16.8321, + Aircraft.VerticalTail.MOMENT_ARM: 49.8809, + Aircraft.Nacelle.AVG_DIAMETER: 7.25, + Aircraft.Nacelle.AVG_LENGTH: 14.5, + Aircraft.Nacelle.SURFACE_AREA: 330.2599, + Aircraft.Design.LIFT_CURVE_SLOPE: 6.39471, + Aircraft.Wing.ULTIMATE_LOAD_FACTOR: 3.75, + Aircraft.Wing.MATERIAL_FACTOR: 1.22129, + Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS: 36000.0, + Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS: 36000.0, + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 12605.94, + Aircraft.Nacelle.MASS: 990.7798, + Aircraft.HorizontalTail.MASS: 2276.1316, + Aircraft.VerticalTail.MASS: 2297.9697, + Aircraft.Wing.HIGH_LIFT_MASS: 4740.1241, + Aircraft.Controls.TOTAL_MASS: 3819.3564, + Aircraft.Wing.SURFACE_CONTROL_MASS: 3682.099, + Aircraft.LandingGear.TOTAL_MASS: 7489.8343, + Aircraft.LandingGear.MAIN_GEAR_MASS: 6366.3591, + Aircraft.Design.FIXED_EQUIPMENT_MASS: 21078.3911, + Aircraft.Design.FIXED_USEFUL_LOAD: 5341.4317956, + Aircraft.Engine.ADDITIONAL_MASS: 850.90095, + Aircraft.Wing.MASS: 16206.8122, + Aircraft.Fuel.FUEL_SYSTEM_MASS: 1740.2606, + Aircraft.Design.STRUCTURE_MASS: 50667.4376, + Aircraft.Fuselage.MASS: 18673.0352, + Mission.Summary.FUEL_MASS_REQUIRED: 42445.3806, + Aircraft.Propulsion.MASS: 16048.0025, + Mission.Summary.FUEL_MASS: 42445.3806, + Aircraft.Fuel.WING_VOLUME_DESIGN: 848.5301, + Mission.Summary.OPERATING_MASS: 96954.6194, + Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY: 0, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob[var_name], expected_val, tol) def test_case2(self): """premission: propulsion + geometry + aerodynamics + mass""" @@ -130,62 +132,66 @@ def test_case2(self): prob.run_model() tol = 1e-5 - # propulsion subsystem - assert_near_equal(prob[Aircraft.Engine.SCALED_SLS_THRUST], 28690.0, tol) - # geometry subsystem - assert_near_equal(prob[Aircraft.Fuselage.AVG_DIAMETER], 157.2, tol) - assert_near_equal(prob[Aircraft.Fuselage.LENGTH], 129.497, tol) - assert_near_equal(prob[Aircraft.Fuselage.WETTED_AREA], 4000.0, tol) - assert_near_equal(prob[Aircraft.Wing.AREA], 1370.3125, tol) - assert_near_equal(prob[Aircraft.Wing.SPAN], 117.81878299, tol) - assert_near_equal(prob[Aircraft.Wing.CENTER_CHORD], 17.48974356, tol) - assert_near_equal(prob[Aircraft.Wing.AVERAGE_CHORD], 12.61453233, tol) - assert_near_equal(prob[Aircraft.Wing.ROOT_CHORD], 16.40711451, tol) - assert_near_equal(prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.139656, tol) - assert_near_equal(prob[Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX], 1114.0056, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.AREA], 375.8798, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.SPAN], 42.2543, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.ROOT_CHORD], 13.1592, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 9.5768, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.MOMENT_ARM], 54.6793, tol) - assert_near_equal(prob[Aircraft.VerticalTail.AREA], 469.3183, tol) - assert_near_equal(prob[Aircraft.VerticalTail.SPAN], 27.9957, tol) - assert_near_equal(prob[Aircraft.VerticalTail.ROOT_CHORD], 18.6162, tol) - assert_near_equal(prob[Aircraft.VerticalTail.AVERAGE_CHORD], 16.8321, tol) - assert_near_equal(prob[Aircraft.VerticalTail.MOMENT_ARM], 49.8809, tol) - assert_near_equal(prob[Aircraft.Nacelle.AVG_DIAMETER], 7.25, tol) - assert_near_equal(prob[Aircraft.Nacelle.AVG_LENGTH], 14.5, tol) - assert_near_equal(prob[Aircraft.Nacelle.SURFACE_AREA], 330.2599, tol) - # aerodynamics subsystem - assert_near_equal(prob[Mission.Landing.LIFT_COEFFICIENT_MAX], 2.8179491, tol) - # mass subsystem - assert_near_equal(self.prob[Aircraft.Design.LIFT_CURVE_SLOPE], 6.39471, tol) - assert_near_equal(self.prob[Aircraft.Wing.ULTIMATE_LOAD_FACTOR], 3.75, tol) - assert_near_equal(self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.22129, tol) - assert_near_equal(self.prob[Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS], 36000.0, tol) - assert_near_equal(self.prob[Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS], 36000.0, tol) - assert_near_equal(self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 12259.8108, tol) - assert_near_equal(self.prob[Aircraft.Nacelle.MASS], 990.7798, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.MASS], 2276.1316, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.MASS], 2297.9697, tol) - assert_near_equal(self.prob[Aircraft.Wing.HIGH_LIFT_MASS], 4161.22777613, tol) - assert_near_equal(self.prob[Aircraft.Controls.TOTAL_MASS], 3819.3564, tol) - assert_near_equal(self.prob[Aircraft.Wing.SURFACE_CONTROL_MASS], 3682.099, tol) - assert_near_equal(prob[Aircraft.LandingGear.TOTAL_MASS], 7489.8343, tol) - assert_near_equal(prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6366.3591, tol) - assert_near_equal(self.prob[Aircraft.Design.FIXED_EQUIPMENT_MASS], 21078.3911, tol) - assert_near_equal(self.prob[Aircraft.Design.FIXED_USEFUL_LOAD], 5332.684, tol) - assert_near_equal(prob[Aircraft.Engine.ADDITIONAL_MASS], 827.5372, tol) - assert_near_equal(prob[Aircraft.Wing.MASS], 15651.64198957, tol) - assert_near_equal(prob[Aircraft.Fuel.FUEL_SYSTEM_MASS], 1779.06667944, tol) - assert_near_equal(prob[Aircraft.Design.STRUCTURE_MASS], 50083.74652256, tol) - assert_near_equal(prob[Aircraft.Fuselage.MASS], 18675.0408, tol) - assert_near_equal(prob[Mission.Summary.FUEL_MASS_REQUIRED], 43391.87023036, tol) - assert_near_equal(prob[Aircraft.Propulsion.MASS], 15694.0515, tol) - assert_near_equal(prob[Mission.Summary.FUEL_MASS], 43391.87023036, tol) - assert_near_equal(prob[Aircraft.Fuel.WING_VOLUME_DESIGN], 867.4514906, tol) - assert_near_equal(prob[Mission.Summary.OPERATING_MASS], 96008.12976964, tol) - assert_near_equal(prob[Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY], 0, tol) + expected_values = { + Aircraft.Engine.SCALED_SLS_THRUST: 28690.0, + Aircraft.Fuselage.AVG_DIAMETER: 157.2, + Aircraft.Fuselage.LENGTH: 129.497, + Aircraft.Fuselage.WETTED_AREA: 4000.0, + Aircraft.Wing.AREA: 1370.3125, + Aircraft.Wing.SPAN: 117.81878299, + Aircraft.Wing.CENTER_CHORD: 17.48974356, + Aircraft.Wing.AVERAGE_CHORD: 12.61453233, + Aircraft.Wing.ROOT_CHORD: 16.40711451, + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.139656, + Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX: 1114.0056, + Aircraft.HorizontalTail.AREA: 375.8798, + Aircraft.HorizontalTail.SPAN: 42.2543, + Aircraft.HorizontalTail.ROOT_CHORD: 13.1592, + Aircraft.HorizontalTail.AVERAGE_CHORD: 9.5768, + Aircraft.HorizontalTail.MOMENT_ARM: 54.6793, + Aircraft.VerticalTail.AREA: 469.3183, + Aircraft.VerticalTail.SPAN: 27.9957, + Aircraft.VerticalTail.ROOT_CHORD: 18.6162, + Aircraft.VerticalTail.AVERAGE_CHORD: 16.8321, + Aircraft.VerticalTail.MOMENT_ARM: 49.8809, + Aircraft.Nacelle.AVG_DIAMETER: 7.25, + Aircraft.Nacelle.AVG_LENGTH: 14.5, + Aircraft.Nacelle.SURFACE_AREA: 330.2599, + Mission.Landing.LIFT_COEFFICIENT_MAX: 2.8179491, + Aircraft.Design.LIFT_CURVE_SLOPE: 6.39471, + Aircraft.Wing.ULTIMATE_LOAD_FACTOR: 3.75, + Aircraft.Wing.MATERIAL_FACTOR: 1.22129, + Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS: 36000.0, + Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS: 36000.0, + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 12259.8108, + Aircraft.Nacelle.MASS: 990.7798, + Aircraft.HorizontalTail.MASS: 2276.1316, + Aircraft.VerticalTail.MASS: 2297.9697, + Aircraft.Wing.HIGH_LIFT_MASS: 4161.22777613, + Aircraft.Controls.TOTAL_MASS: 3819.3564, + Aircraft.Wing.SURFACE_CONTROL_MASS: 3682.099, + Aircraft.LandingGear.TOTAL_MASS: 7489.8343, + Aircraft.LandingGear.MAIN_GEAR_MASS: 6366.3591, + Aircraft.Design.FIXED_EQUIPMENT_MASS: 21078.3911, + Aircraft.Design.FIXED_USEFUL_LOAD: 5332.684, + Aircraft.Engine.ADDITIONAL_MASS: 827.5372, + Aircraft.Wing.MASS: 15651.64198957, + Aircraft.Fuel.FUEL_SYSTEM_MASS: 1779.06667944, + Aircraft.Design.STRUCTURE_MASS: 50083.74652256, + Aircraft.Fuselage.MASS: 18675.0408, + Mission.Summary.FUEL_MASS_REQUIRED: 43391.87023036, + Aircraft.Propulsion.MASS: 15694.0515, + Mission.Summary.FUEL_MASS: 43391.87023036, + Aircraft.Fuel.WING_VOLUME_DESIGN: 867.4514906, + Mission.Summary.OPERATING_MASS: 96008.12976964, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob[var_name], expected_val, tol) + + with self.subTest(var=Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY): + assert_near_equal(prob[Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY], 0, tol) @use_tempdirs @@ -261,63 +267,67 @@ def test_case1(self): prob.run_model() tol = 1e-5 - # geometry subsystem - assert_near_equal(prob[Aircraft.Fuselage.AVG_DIAMETER], 38, tol) - assert_near_equal(prob[Aircraft.Fuselage.LENGTH], 71.52455, tol) - assert_near_equal(prob[Aircraft.Fuselage.WETTED_AREA], 4573.882, tol) - assert_near_equal(prob[Aircraft.Wing.AREA], 2142.857, tol) - assert_near_equal(prob[Aircraft.Wing.SPAN], 146.385, tol) - assert_near_equal(prob[Aircraft.Wing.CENTER_CHORD], 22.97244, tol) - assert_near_equal(prob[Aircraft.Wing.AVERAGE_CHORD], 16.22, tol) - assert_near_equal(prob[Aircraft.Wing.ROOT_CHORD], 20.3337, tol) - assert_near_equal(prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.135966, tol) - assert_near_equal(prob[Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX], 605.9078, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.AREA], 0.00117064, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.SPAN], 0.04467601, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.ROOT_CHORD], 0.0383645, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 0.0280845, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.MOMENT_ARM], 29.6907, tol) - assert_near_equal(prob[Aircraft.VerticalTail.AREA], 169.1196, tol) - assert_near_equal(prob[Aircraft.VerticalTail.SPAN], 16.98084, tol) - assert_near_equal(prob[Aircraft.VerticalTail.ROOT_CHORD], 14.5819, tol) - assert_near_equal(prob[Aircraft.VerticalTail.AVERAGE_CHORD], 10.6746, tol) - assert_near_equal(prob[Aircraft.VerticalTail.MOMENT_ARM], 27.8219, tol) - assert_near_equal(prob[Aircraft.Nacelle.AVG_DIAMETER], 5.33382, tol) - assert_near_equal(prob[Aircraft.Nacelle.AVG_LENGTH], 7.2476, tol) - assert_near_equal(prob[Aircraft.Nacelle.SURFACE_AREA], 121.4458, tol) - # mass subsystem - assert_near_equal(prob[Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS], 1686.6256, tol) - assert_near_equal(prob[Aircraft.Design.LIFT_CURVE_SLOPE], 5.948, tol) - assert_near_equal(prob[Aircraft.Wing.ULTIMATE_LOAD_FACTOR], 3.77336, tol) - assert_near_equal(prob[Aircraft.Wing.MATERIAL_FACTOR], 1.194612, tol) - assert_near_equal(prob[Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS], 33750.0, tol) - assert_near_equal(prob[Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS], 33750.0, tol) - assert_near_equal(prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 7005.15475, tol) - assert_near_equal(prob[Aircraft.Nacelle.MASS], 303.6144, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.MASS], 1.02402, tol) - assert_near_equal(prob[Aircraft.VerticalTail.MASS], 864.174, tol) - assert_near_equal(prob[Aircraft.Wing.HIGH_LIFT_MASS], 974.436, tol) - assert_near_equal(prob[Aircraft.Controls.TOTAL_MASS], 2114.982, tol) - assert_near_equal(prob[Aircraft.Wing.SURFACE_CONTROL_MASS], 1986.251, tol) - assert_near_equal(prob[Aircraft.LandingGear.TOTAL_MASS], 7800.0, tol) - assert_near_equal(prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6630.0, tol) - assert_near_equal(prob[Aircraft.Avionics.MASS], 3225.0, tol) - assert_near_equal(prob[Aircraft.AirConditioning.MASS], 1301.573, tol) - assert_near_equal(prob[Aircraft.Furnishings.MASS], 11269.876, tol) - assert_near_equal(prob[Aircraft.Design.FIXED_EQUIPMENT_MASS], 20876.453, tol) - assert_near_equal(prob[Aircraft.Design.FIXED_USEFUL_LOAD], 5971.7946, tol) - assert_near_equal(prob[Aircraft.Engine.ADDITIONAL_MASS], 153.1677, tol) - assert_near_equal(prob[Aircraft.Wing.FOLD_MASS], 107.8736151, tol) - assert_near_equal(prob[Aircraft.Wing.MASS], 6962.31442344, tol) - assert_near_equal(prob[Aircraft.Fuel.FUEL_SYSTEM_MASS], 1316.13400269, tol) - assert_near_equal(prob[Aircraft.Design.STRUCTURE_MASS], 44473.41356849, tol) - assert_near_equal(prob[Aircraft.Fuselage.MASS], 27159.693, tol) - assert_near_equal(prob[Mission.Summary.FUEL_MASS_REQUIRED], 34185.29877112, tol) - assert_near_equal(prob[Aircraft.Propulsion.MASS], 8627.6738, tol) - assert_near_equal(prob[Mission.Summary.FUEL_MASS], 34185.29877112, tol) - assert_near_equal(prob[Aircraft.Fuel.WING_VOLUME_DESIGN], 751.74213602, tol) - assert_near_equal(prob[Mission.Summary.OPERATING_MASS], 82064.29761786, tol) - assert_near_equal(prob[Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY], 3876.43000743, tol) + expected_values = { + Aircraft.Fuselage.AVG_DIAMETER: 38, + Aircraft.Fuselage.LENGTH: 71.52455, + Aircraft.Fuselage.WETTED_AREA: 4573.882, + Aircraft.Wing.AREA: 2142.857, + Aircraft.Wing.SPAN: 146.385, + Aircraft.Wing.CENTER_CHORD: 22.97244, + Aircraft.Wing.AVERAGE_CHORD: 16.22, + Aircraft.Wing.ROOT_CHORD: 20.3337, + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.135966, + Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX: 605.9078, + Aircraft.HorizontalTail.AREA: 0.00117064, + Aircraft.HorizontalTail.SPAN: 0.04467601, + Aircraft.HorizontalTail.ROOT_CHORD: 0.0383645, + Aircraft.HorizontalTail.AVERAGE_CHORD: 0.0280845, + Aircraft.HorizontalTail.MOMENT_ARM: 29.6907, + Aircraft.VerticalTail.AREA: 169.1196, + Aircraft.VerticalTail.SPAN: 16.98084, + Aircraft.VerticalTail.ROOT_CHORD: 14.5819, + Aircraft.VerticalTail.AVERAGE_CHORD: 10.6746, + Aircraft.VerticalTail.MOMENT_ARM: 27.8219, + Aircraft.Nacelle.AVG_DIAMETER: 5.33382, + Aircraft.Nacelle.AVG_LENGTH: 7.2476, + Aircraft.Nacelle.SURFACE_AREA: 121.4458, + Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS: 1686.6256, + Aircraft.Design.LIFT_CURVE_SLOPE: 5.948, + Aircraft.Wing.ULTIMATE_LOAD_FACTOR: 3.77336, + Aircraft.Wing.MATERIAL_FACTOR: 1.194612, + Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS: 33750.0, + Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS: 33750.0, + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 7005.15475, + Aircraft.Nacelle.MASS: 303.6144, + Aircraft.HorizontalTail.MASS: 1.02402, + Aircraft.VerticalTail.MASS: 864.174, + Aircraft.Wing.HIGH_LIFT_MASS: 974.436, + Aircraft.Controls.TOTAL_MASS: 2114.982, + Aircraft.Wing.SURFACE_CONTROL_MASS: 1986.251, + Aircraft.LandingGear.TOTAL_MASS: 7800.0, + Aircraft.LandingGear.MAIN_GEAR_MASS: 6630.0, + Aircraft.Avionics.MASS: 3225.0, + Aircraft.AirConditioning.MASS: 1301.573, + Aircraft.Furnishings.MASS: 11269.876, + Aircraft.Design.FIXED_EQUIPMENT_MASS: 20876.453, + Aircraft.Design.FIXED_USEFUL_LOAD: 5971.7946, + Aircraft.Engine.ADDITIONAL_MASS: 153.1677, + Aircraft.Wing.FOLD_MASS: 107.8736151, + Aircraft.Wing.MASS: 6962.31442344, + Aircraft.Fuel.FUEL_SYSTEM_MASS: 1316.13400269, + Aircraft.Design.STRUCTURE_MASS: 44473.41356849, + Aircraft.Fuselage.MASS: 27159.693, + Mission.Summary.FUEL_MASS_REQUIRED: 34185.29877112, + Aircraft.Propulsion.MASS: 8627.6738, + Mission.Summary.FUEL_MASS: 34185.29877112, + Aircraft.Fuel.WING_VOLUME_DESIGN: 751.74213602, + Mission.Summary.OPERATING_MASS: 82064.29761786, + Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY: 3876.43000743, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob[var_name], expected_val, tol) def test_case2(self): """ @@ -352,63 +362,67 @@ def test_case2(self): prob.run_model() tol = 1e-5 - # geometry subsystem - assert_near_equal(prob[Aircraft.Fuselage.AVG_DIAMETER], 38, tol) - assert_near_equal(prob[Aircraft.Fuselage.LENGTH], 71.52455, tol) - assert_near_equal(prob[Aircraft.Fuselage.WETTED_AREA], 4573.882, tol) - assert_near_equal(prob[Aircraft.Wing.AREA], 2142.857, tol) - assert_near_equal(prob[Aircraft.Wing.SPAN], 146.385, tol) - assert_near_equal(prob[Aircraft.Wing.CENTER_CHORD], 22.97244, tol) - assert_near_equal(prob[Aircraft.Wing.AVERAGE_CHORD], 16.22, tol) - assert_near_equal(prob[Aircraft.Wing.ROOT_CHORD], 20.3337, tol) - assert_near_equal(prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.135966, tol) - assert_near_equal(prob[Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX], 605.9078, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.AREA], 0.00117064, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.SPAN], 0.04467601, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.ROOT_CHORD], 0.0383645, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 0.0280845, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.MOMENT_ARM], 29.6907, tol) - assert_near_equal(prob[Aircraft.VerticalTail.AREA], 169.1196, tol) - assert_near_equal(prob[Aircraft.VerticalTail.SPAN], 16.98084, tol) - assert_near_equal(prob[Aircraft.VerticalTail.ROOT_CHORD], 14.5819, tol) - assert_near_equal(prob[Aircraft.VerticalTail.AVERAGE_CHORD], 10.6746, tol) - assert_near_equal(prob[Aircraft.VerticalTail.MOMENT_ARM], 27.8219, tol) - assert_near_equal(prob[Aircraft.Nacelle.AVG_DIAMETER], 5.33382, tol) - assert_near_equal(prob[Aircraft.Nacelle.AVG_LENGTH], 7.2476, tol) - assert_near_equal(prob[Aircraft.Nacelle.SURFACE_AREA], 121.4458, tol) - # mass subsystem - assert_near_equal(prob[Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS], 1686.6256, tol) - assert_near_equal(prob[Aircraft.Design.LIFT_CURVE_SLOPE], 5.948, tol) - assert_near_equal(prob[Aircraft.Wing.ULTIMATE_LOAD_FACTOR], 3.77336, tol) - assert_near_equal(prob[Aircraft.Wing.MATERIAL_FACTOR], 1.194612, tol) - assert_near_equal(prob[Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS], 33750.0, tol) - assert_near_equal(prob[Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS], 33750.0, tol) - assert_near_equal(prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 7005.155, tol) - assert_near_equal(prob[Aircraft.Nacelle.MASS], 303.6144, tol) - assert_near_equal(prob[Aircraft.HorizontalTail.MASS], 1.02402, tol) - assert_near_equal(prob[Aircraft.VerticalTail.MASS], 864.174, tol) - assert_near_equal(prob[Aircraft.Wing.HIGH_LIFT_MASS], 971.8248, tol) - assert_near_equal(prob[Aircraft.Controls.TOTAL_MASS], 2114.982, tol) - assert_near_equal(prob[Aircraft.Wing.SURFACE_CONTROL_MASS], 1986.251, tol) - assert_near_equal(prob[Aircraft.LandingGear.TOTAL_MASS], 7800.0, tol) - assert_near_equal(prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6630.0, tol) - assert_near_equal(prob[Aircraft.Avionics.MASS], 3225.0, tol) - assert_near_equal(prob[Aircraft.AirConditioning.MASS], 1301.573, tol) - assert_near_equal(prob[Aircraft.Furnishings.MASS], 11269.876, tol) - assert_near_equal(prob[Aircraft.Design.FIXED_EQUIPMENT_MASS], 20876.453, tol) - assert_near_equal(prob[Aircraft.Design.FIXED_USEFUL_LOAD], 5971.7946, tol) - assert_near_equal(prob[Aircraft.Engine.ADDITIONAL_MASS], 153.1677, tol) - assert_near_equal(prob[Aircraft.Wing.FOLD_MASS], 107.8335, tol) - assert_near_equal(prob[Aircraft.Wing.MASS], 6959.7262, tol) - assert_near_equal(prob[Aircraft.Fuel.FUEL_SYSTEM_MASS], 1316.2306, tol) - assert_near_equal(prob[Aircraft.Design.STRUCTURE_MASS], 44471.243, tol) - assert_near_equal(prob[Aircraft.Fuselage.MASS], 27159.693, tol) - assert_near_equal(prob[Mission.Summary.FUEL_MASS_REQUIRED], 34187.8, tol) - assert_near_equal(prob[Aircraft.Propulsion.MASS], 8627.72, tol) - assert_near_equal(prob[Mission.Summary.FUEL_MASS], 34187.807, tol) - assert_near_equal(prob[Aircraft.Fuel.WING_VOLUME_DESIGN], 751.7973, tol) - assert_near_equal(prob[Mission.Summary.OPERATING_MASS], 82062.193, tol) - assert_near_equal(prob[Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY], 3878.938, tol) + expected_values = { + Aircraft.Fuselage.AVG_DIAMETER: 38, + Aircraft.Fuselage.LENGTH: 71.52455, + Aircraft.Fuselage.WETTED_AREA: 4573.882, + Aircraft.Wing.AREA: 2142.857, + Aircraft.Wing.SPAN: 146.385, + Aircraft.Wing.CENTER_CHORD: 22.97244, + Aircraft.Wing.AVERAGE_CHORD: 16.22, + Aircraft.Wing.ROOT_CHORD: 20.3337, + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.135966, + Aircraft.Fuel.WING_VOLUME_GEOMETRIC_MAX: 605.9078, + Aircraft.HorizontalTail.AREA: 0.00117064, + Aircraft.HorizontalTail.SPAN: 0.04467601, + Aircraft.HorizontalTail.ROOT_CHORD: 0.0383645, + Aircraft.HorizontalTail.AVERAGE_CHORD: 0.0280845, + Aircraft.HorizontalTail.MOMENT_ARM: 29.6907, + Aircraft.VerticalTail.AREA: 169.1196, + Aircraft.VerticalTail.SPAN: 16.98084, + Aircraft.VerticalTail.ROOT_CHORD: 14.5819, + Aircraft.VerticalTail.AVERAGE_CHORD: 10.6746, + Aircraft.VerticalTail.MOMENT_ARM: 27.8219, + Aircraft.Nacelle.AVG_DIAMETER: 5.33382, + Aircraft.Nacelle.AVG_LENGTH: 7.2476, + Aircraft.Nacelle.SURFACE_AREA: 121.4458, + Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS: 1686.6256, + Aircraft.Design.LIFT_CURVE_SLOPE: 5.948, + Aircraft.Wing.ULTIMATE_LOAD_FACTOR: 3.77336, + Aircraft.Wing.MATERIAL_FACTOR: 1.194612, + Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS: 33750.0, + Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS: 33750.0, + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 7005.155, + Aircraft.Nacelle.MASS: 303.6144, + Aircraft.HorizontalTail.MASS: 1.02402, + Aircraft.VerticalTail.MASS: 864.174, + Aircraft.Wing.HIGH_LIFT_MASS: 971.8248, + Aircraft.Controls.TOTAL_MASS: 2114.982, + Aircraft.Wing.SURFACE_CONTROL_MASS: 1986.251, + Aircraft.LandingGear.TOTAL_MASS: 7800.0, + Aircraft.LandingGear.MAIN_GEAR_MASS: 6630.0, + Aircraft.Avionics.MASS: 3225.0, + Aircraft.AirConditioning.MASS: 1301.573, + Aircraft.Furnishings.MASS: 11269.876, + Aircraft.Design.FIXED_EQUIPMENT_MASS: 20876.453, + Aircraft.Design.FIXED_USEFUL_LOAD: 5971.7946, + Aircraft.Engine.ADDITIONAL_MASS: 153.1677, + Aircraft.Wing.FOLD_MASS: 107.8335, + Aircraft.Wing.MASS: 6959.7262, + Aircraft.Fuel.FUEL_SYSTEM_MASS: 1316.2306, + Aircraft.Design.STRUCTURE_MASS: 44471.243, + Aircraft.Fuselage.MASS: 27159.693, + Mission.Summary.FUEL_MASS_REQUIRED: 34187.8, + Aircraft.Propulsion.MASS: 8627.72, + Mission.Summary.FUEL_MASS: 34187.807, + Aircraft.Fuel.WING_VOLUME_DESIGN: 751.7973, + Mission.Summary.OPERATING_MASS: 82062.193, + Aircraft.Fuel.AUXILIARY_FUEL_CAPACITY: 3878.938, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob[var_name], expected_val, tol) if __name__ == '__main__': diff --git a/aviary/subsystems/test/test_premission.py b/aviary/subsystems/test/test_premission.py index 129fbc78d0..0c9262431b 100644 --- a/aviary/subsystems/test/test_premission.py +++ b/aviary/subsystems/test/test_premission.py @@ -135,76 +135,42 @@ def test_GASP_mass_FLOPS_everything_else(self): # Check the outputs from GASP mass and geometry (FLOPS outputs are not tested) tol = 5e-4 - # size values: - assert_near_equal(self.prob['gasp_based_geom.cabin_height'], 13.1, tol) - assert_near_equal(self.prob['gasp_based_geom.cabin_len'], 72.09722222222223, tol) - assert_near_equal(self.prob['gasp_based_geom.nose_height'], 8.6, tol) - - assert_near_equal(self.prob[Aircraft.Wing.CENTER_CHORD], 17.63, tol) - assert_near_equal(self.prob[Aircraft.Wing.ROOT_CHORD], 16.54, tol) - assert_near_equal( - self.prob[Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED], 0.1397, tol - ) # not exact GASP value from the output file, likely due to rounding error - - assert_near_equal(self.prob[Aircraft.HorizontalTail.AVERAGE_CHORD], 9.6509873673743, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.AVERAGE_CHORD], 16.96457870166355, tol) - assert_near_equal(self.prob[Aircraft.Nacelle.AVG_LENGTH], 14.7, tol) - - # fixed mass values: - assert_near_equal(self.prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6384.35, tol) - assert_near_equal(self.prob['loc_MAC_vtail'], 0.44959578484694906, tol) - - # wing values: - assert_near_equal(self.prob['isolated_wing_mass'], 16205, tol) - assert_near_equal(self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 12606, tol) - assert_near_equal(self.prob[Aircraft.Engine.ADDITIONAL_MASS], 1765 / 2, tol) - - # fuel values: - # modified from GASP value to account for updated crew mass. GASP value is - # 78843.6 - assert_near_equal(self.prob['OEM_wingfuel_mass'], 77977.7, tol) - # modified from GASP value to account for updated crew mass. GASP value is - # 102408.05695930264 - assert_near_equal(self.prob['fus_mass_full'], 102812.6654177, tol) - # modified from GASP value to account for updated crew mass. GASP value is - # 1757 - assert_near_equal( - self.prob[Aircraft.Fuel.FUEL_SYSTEM_MASS], 1721.08, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 1757 - assert_near_equal(self.prob[Aircraft.Design.STRUCTURE_MASS], 50931.4, tol) - assert_near_equal( - self.prob[Aircraft.Fuselage.MASS], 18833.76678366, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 18814 - - # modified from GASP value to account for updated crew mass. GASP value is - # 42843.6 - assert_near_equal( - self.prob[Mission.Summary.FUEL_MASS_REQUIRED], 41977.7, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 42843.6 - assert_near_equal( - self.prob[Aircraft.Propulsion.MASS], 16098.7, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 16127 - assert_near_equal( - self.prob[Mission.Summary.FUEL_MASS], 41977.68, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 42844.0 - assert_near_equal( - self.prob['fuel_mass_min'], 31937.68, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 32803.6 - assert_near_equal( - self.prob[Aircraft.Fuel.WING_VOLUME_DESIGN], 839.18, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 856.4910800459031 - assert_near_equal( - self.prob['OEM_fuel_vol'], 1558.86, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 1576.1710061411081 - assert_near_equal( - self.prob[Mission.Summary.OPERATING_MASS], 97422.32, tol - ) # modified from GASP value to account for updated crew mass. GASP value is 96556.0 - # extra_fuel_mass calculated differently in this version, so test for fuel_mass.fuel_and_oem.payload_mass_max_fuel not included - assert_near_equal(self.prob['volume_wingfuel_mass'], 57066.3, tol) - assert_near_equal(self.prob['max_wingfuel_mass'], 57066.3, tol) - - assert_near_equal(self.prob['extra_fuel_volume'], 0, tol) # always zero when no body tank - assert_near_equal(self.prob['max_extra_fuel_mass'], 0, tol) # always zero when no body tank + expected_values = { + 'gasp_based_geom.cabin_height': 13.1, + 'gasp_based_geom.cabin_len': 72.09722222222223, + 'gasp_based_geom.nose_height': 8.6, + Aircraft.Wing.CENTER_CHORD: 17.63, + Aircraft.Wing.ROOT_CHORD: 16.54, + Aircraft.Wing.THICKNESS_TO_CHORD_UNWEIGHTED: 0.1397, # not exact GASP value from the output file, likely due to rounding error + Aircraft.HorizontalTail.AVERAGE_CHORD: 9.6509873673743, + Aircraft.VerticalTail.AVERAGE_CHORD: 16.96457870166355, + Aircraft.Nacelle.AVG_LENGTH: 14.7, + Aircraft.LandingGear.MAIN_GEAR_MASS: 6384.35, + 'loc_MAC_vtail': 0.44959578484694906, + 'isolated_wing_mass': 16205, + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 12606, + Aircraft.Engine.ADDITIONAL_MASS: 1765 / 2, + 'OEM_wingfuel_mass': 77977.7, # modified from GASP value to account for updated crew mass. GASP value is 78843.6 + 'fus_mass_full': 102812.6654177, # modified from GASP value to account for updated crew mass. GASP value is 102408.05695930264 + Aircraft.Fuel.FUEL_SYSTEM_MASS: 1721.08, # modified from GASP value to account for updated crew mass. GASP value is 1757 + Aircraft.Design.STRUCTURE_MASS: 50931.4, + Aircraft.Fuselage.MASS: 18833.76678366, # modified from GASP value to account for updated crew mass. GASP value is 18814 + Mission.Summary.FUEL_MASS_REQUIRED: 41977.7, # modified from GASP value to account for updated crew mass. GASP value is 42843.6 + Aircraft.Propulsion.MASS: 16098.7, # modified from GASP value to account for updated crew mass. GASP value is 16127 + Mission.Summary.FUEL_MASS: 41977.68, # modified from GASP value to account for updated crew mass. GASP value is 42844.0 + 'fuel_mass_min': 31937.68, # modified from GASP value to account for updated crew mass. GASP value is 32803.6 + Aircraft.Fuel.WING_VOLUME_DESIGN: 839.18, # modified from GASP value to account for updated crew mass. GASP value is 856.4910800459031 + 'OEM_fuel_vol': 1558.86, # modified from GASP value to account for updated crew mass. GASP value is 1576.1710061411081 + Mission.Summary.OPERATING_MASS: 97422.32, # modified from GASP value to account for updated crew mass. GASP value is 96556.0 + 'volume_wingfuel_mass': 57066.3, # extra_fuel_mass calculated differently in this version, so test for fuel_mass.fuel_and_oem.payload_mass_max_fuel not included + 'max_wingfuel_mass': 57066.3, + 'extra_fuel_volume': 0, # always zero when no body tank + 'max_extra_fuel_mass': 0, # always zero when no body tank + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=3e-10, rtol=1e-12) diff --git a/aviary/validation_cases/benchmark_tests/test_bench_FwGm.py b/aviary/validation_cases/benchmark_tests/test_bench_FwGm.py index 4083292d54..d5ceb81fba 100644 --- a/aviary/validation_cases/benchmark_tests/test_bench_FwGm.py +++ b/aviary/validation_cases/benchmark_tests/test_bench_FwGm.py @@ -38,17 +38,20 @@ def bench_test_swap_3_FwGm_IPOPT(self): rtol = 1e-2 # There are no truth values for these. - assert_near_equal(prob.get_val(Mission.Design.GROSS_MASS), 177536.28, tolerance=rtol) - - assert_near_equal(prob.get_val(Mission.Summary.OPERATING_MASS), 101262.9, tolerance=rtol) - - assert_near_equal(prob.get_val(Mission.Summary.TOTAL_FUEL_MASS), 38417.3, tolerance=rtol) - - assert_near_equal(prob.get_val(Mission.Landing.GROUND_DISTANCE), 2613.4, tolerance=rtol) - - assert_near_equal( - prob.get_val('traj.desc2.timeseries.distance')[-1], 3675.0, tolerance=rtol - ) + expected_values = { + Mission.Design.GROSS_MASS: 177536.28, + Mission.Summary.OPERATING_MASS: 101262.9, + Mission.Summary.TOTAL_FUEL_MASS: 38417.3, + Mission.Landing.GROUND_DISTANCE: 2613.4, + 'traj.desc2.timeseries.distance': 3675.0, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + if var_name == 'traj.desc2.timeseries.distance': + assert_near_equal(prob.get_val(var_name)[-1], expected_val, tolerance=rtol) + else: + assert_near_equal(prob.get_val(var_name), expected_val, tolerance=rtol) @require_pyoptsparse(optimizer='SNOPT') def bench_test_swap_3_FwGm_SNOPT(self): @@ -66,17 +69,20 @@ def bench_test_swap_3_FwGm_SNOPT(self): rtol = 1e-2 # There are no truth values for these. - assert_near_equal(prob.get_val(Mission.Design.GROSS_MASS), 177536.28, tolerance=rtol) - - assert_near_equal(prob.get_val(Mission.Summary.OPERATING_MASS), 101262.9, tolerance=rtol) - - assert_near_equal(prob.get_val(Mission.Summary.TOTAL_FUEL_MASS), 38417.3, tolerance=rtol) - - assert_near_equal(prob.get_val(Mission.Landing.GROUND_DISTANCE), 2613.4, tolerance=rtol) - - assert_near_equal( - prob.get_val('traj.desc2.timeseries.distance')[-1], 3675.0, tolerance=rtol - ) + expected_values = { + Mission.Design.GROSS_MASS: 177536.28, + Mission.Summary.OPERATING_MASS: 101262.9, + Mission.Summary.TOTAL_FUEL_MASS: 38417.3, + Mission.Landing.GROUND_DISTANCE: 2613.4, + 'traj.desc2.timeseries.distance': 3675.0, + } + + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + if var_name == 'traj.desc2.timeseries.distance': + assert_near_equal(prob.get_val(var_name)[-1], expected_val, tolerance=rtol) + else: + assert_near_equal(prob.get_val(var_name), expected_val, tolerance=rtol) if __name__ == '__main__': diff --git a/aviary/validation_cases/benchmark_tests/test_bench_GwGm.py b/aviary/validation_cases/benchmark_tests/test_bench_GwGm.py index 206aa067b4..9c4b9e5e93 100644 --- a/aviary/validation_cases/benchmark_tests/test_bench_GwGm.py +++ b/aviary/validation_cases/benchmark_tests/test_bench_GwGm.py @@ -36,37 +36,18 @@ def test_bench_GwGm_IPOPT(self): rtol = 1e-3 # There are no truth values for these. - assert_near_equal( - prob.get_val(Mission.Design.GROSS_MASS, units='lbm'), - 171646.48312684, - tolerance=rtol, - ) - - assert_near_equal( - prob.get_val(Mission.Summary.OPERATING_MASS, units='lbm'), - 95100.07583783, - tolerance=rtol, - ) - - assert_near_equal( - prob.get_val(Mission.Summary.TOTAL_FUEL_MASS, units='lbm'), - 40546.40728901, - tolerance=rtol, - ) - - assert_near_equal( - prob.get_val(Mission.Landing.GROUND_DISTANCE, units='ft'), - 2655.5028412, - tolerance=rtol, - ) - - assert_near_equal(prob.get_val(Mission.Summary.RANGE, units='NM'), 3675.0, tolerance=rtol) - - assert_near_equal( - prob.get_val(Mission.Landing.TOUCHDOWN_MASS, units='lbm'), - 136098.07583783, - tolerance=rtol, - ) + expected_values = { + (Mission.Design.GROSS_MASS, 'lbm'): 171646.48312684, + (Mission.Summary.OPERATING_MASS, 'lbm'): 95100.07583783, + (Mission.Summary.TOTAL_FUEL_MASS, 'lbm'): 40546.40728901, + (Mission.Landing.GROUND_DISTANCE, 'ft'): 2655.5028412, + (Mission.Summary.RANGE, 'NM'): 3675.0, + (Mission.Landing.TOUCHDOWN_MASS, 'lbm'): 136098.07583783, + } + + for (var_name, units), expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob.get_val(var_name, units=units), expected_val, tolerance=rtol) @require_pyoptsparse(optimizer='SNOPT') def test_bench_GwGm_SNOPT(self): @@ -83,37 +64,18 @@ def test_bench_GwGm_SNOPT(self): rtol = 1e-3 # There are no truth values for these. - assert_near_equal( - prob.get_val(Mission.Design.GROSS_MASS, units='lbm'), - 171646.48312684, - tolerance=rtol, - ) - - assert_near_equal( - prob.get_val(Mission.Summary.OPERATING_MASS, units='lbm'), - 95100.07583783, - tolerance=rtol, - ) - - assert_near_equal( - prob.get_val(Mission.Summary.TOTAL_FUEL_MASS, units='lbm'), - 40546.40728901, - tolerance=rtol, - ) - - assert_near_equal( - prob.get_val(Mission.Landing.GROUND_DISTANCE, units='ft'), - 2655.5028412, - tolerance=rtol, - ) - - assert_near_equal(prob.get_val(Mission.Summary.RANGE, units='NM'), 3675.0, tolerance=rtol) - - assert_near_equal( - prob.get_val(Mission.Landing.TOUCHDOWN_MASS, units='lbm'), - 136098.07583783, - tolerance=rtol, - ) + expected_values = { + (Mission.Design.GROSS_MASS, 'lbm'): 171646.48312684, + (Mission.Summary.OPERATING_MASS, 'lbm'): 95100.07583783, + (Mission.Summary.TOTAL_FUEL_MASS, 'lbm'): 40546.40728901, + (Mission.Landing.GROUND_DISTANCE, 'ft'): 2655.5028412, + (Mission.Summary.RANGE, 'NM'): 3675.0, + (Mission.Landing.TOUCHDOWN_MASS, 'lbm'): 136098.07583783, + } + + for (var_name, units), expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(prob.get_val(var_name, units=units), expected_val, tolerance=rtol) if __name__ == '__main__': diff --git a/aviary/validation_cases/benchmark_tests/test_bench_multimission.py b/aviary/validation_cases/benchmark_tests/test_bench_multimission.py index 110e1317ab..2f74b3bed8 100644 --- a/aviary/validation_cases/benchmark_tests/test_bench_multimission.py +++ b/aviary/validation_cases/benchmark_tests/test_bench_multimission.py @@ -42,11 +42,17 @@ def test_multimission(self): self.assertTrue(prob.result.success) - assert_near_equal(objective_expected_value, objective, tolerance=1e-3) - assert_near_equal(mission1_fuel_expected_value, mission1_fuel, tolerance=1e-3) - assert_near_equal(mission2_fuel_expected_value, mission2_fuel, tolerance=1e-3) - assert_near_equal(mission1_cargo_expected_value, mission1_cargo, tolerance=1e-3) - assert_near_equal(mission2_cargo_expected_value, mission2_cargo, tolerance=1e-3) + expected_values = { + 'objective': (objective_expected_value, objective), + 'mission1_fuel': (mission1_fuel_expected_value, mission1_fuel), + 'mission2_fuel': (mission2_fuel_expected_value, mission2_fuel), + 'mission1_cargo': (mission1_cargo_expected_value, mission1_cargo), + 'mission2_cargo': (mission2_cargo_expected_value, mission2_cargo), + } + + for var_name, (expected, actual) in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(expected, actual, tolerance=1e-3) if __name__ == '__main__': diff --git a/aviary/validation_cases/benchmark_tests/test_bench_off_design.py b/aviary/validation_cases/benchmark_tests/test_bench_off_design.py index a5d358f31f..8d763d6891 100644 --- a/aviary/validation_cases/benchmark_tests/test_bench_off_design.py +++ b/aviary/validation_cases/benchmark_tests/test_bench_off_design.py @@ -72,14 +72,18 @@ def compare_results(self, comparison_prob): ] for var in prob_var_list: - assert_near_equal(comparison_prob.get_val(var), self.prob.get_val(var), tolerance=1e-6) + with self.subTest(var=var): + assert_near_equal( + comparison_prob.get_val(var), self.prob.get_val(var), tolerance=1e-6 + ) for var in inputs_var_list: - assert_near_equal( - comparison_prob.aviary_inputs.get_val(var), - self.prob.aviary_inputs.get_val(var), - tolerance=1e-12, - ) + with self.subTest(var=var): + assert_near_equal( + comparison_prob.aviary_inputs.get_val(var), + self.prob.aviary_inputs.get_val(var), + tolerance=1e-12, + ) @require_pyoptsparse(optimizer='SNOPT') def test_fallout_mission_match(self): @@ -99,77 +103,52 @@ def test_fallout_mission_changed(self): num_business=5, num_tourist=75, ) - assert_near_equal( - prob_fallout.get_val(Mission.Design.RANGE), - self.prob.get_val(Mission.Design.RANGE), - tolerance=1e-12, - ) - assert_near_equal(prob_fallout.get_val(Mission.Summary.RANGE), 2438.6, tolerance=1e-3) - assert_near_equal( - prob_fallout.get_val(Mission.Summary.FUEL_MASS, 'lbm'), - 46164.07769361, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Mission.Summary.TOTAL_FUEL_MASS, 'lbm'), - 29031.53317628, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Mission.Summary.OPERATING_MASS, 'lbm'), - 97743.46682372, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Aircraft.CrewPayload.CARGO_MASS, 'lbm'), - 5000, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS, 'lbm'), - 23225, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS, 'lbm'), - 18225, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Aircraft.Design.EMPTY_MASS, 'lbm'), - self.prob.get_val(Aircraft.Design.EMPTY_MASS, 'lbm'), - tolerance=1e-12, - ) - assert_near_equal( - prob_fallout.get_val(Mission.Design.GROSS_MASS, 'lbm'), - self.prob.get_val(Mission.Design.GROSS_MASS, 'lbm'), - tolerance=1e-12, - ) - assert_near_equal( - prob_fallout.get_val(Mission.Summary.GROSS_MASS, 'lbm'), - 150000, - tolerance=1e-12, - ) - assert_near_equal( - prob_fallout.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_FIRST_CLASS), - 1, - tolerance=1e-12, - ) - assert_near_equal( - prob_fallout.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_BUSINESS_CLASS), - 5, - tolerance=1e-12, - ) - assert_near_equal( - prob_fallout.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_TOURIST_CLASS), - 75, - tolerance=1e-12, - ) - assert_near_equal( - prob_fallout.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_PASSENGERS), - 81, - tolerance=1e-12, - ) + expected_values = [ + (Mission.Design.RANGE, None, self.prob.get_val(Mission.Design.RANGE), 1e-12), + (Mission.Summary.RANGE, None, 2438.6, 1e-3), + (Mission.Summary.FUEL_MASS, 'lbm', 46164.07769361, 1e-6), + (Mission.Summary.TOTAL_FUEL_MASS, 'lbm', 29031.53317628, 1e-6), + (Mission.Summary.OPERATING_MASS, 'lbm', 97743.46682372, 1e-6), + (Aircraft.CrewPayload.CARGO_MASS, 'lbm', 5000, 1e-6), + (Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS, 'lbm', 23225, 1e-6), + (Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS, 'lbm', 18225, 1e-6), + ( + Aircraft.Design.EMPTY_MASS, + 'lbm', + self.prob.get_val(Aircraft.Design.EMPTY_MASS, 'lbm'), + 1e-12, + ), + ( + Mission.Design.GROSS_MASS, + 'lbm', + self.prob.get_val(Mission.Design.GROSS_MASS, 'lbm'), + 1e-12, + ), + (Mission.Summary.GROSS_MASS, 'lbm', 150000, 1e-12), + ] + + for var_name, units, expected_val, tol in expected_values: + with self.subTest(var=var_name): + if units: + actual = prob_fallout.get_val(var_name, units) + else: + actual = prob_fallout.get_val(var_name) + assert_near_equal(actual, expected_val, tolerance=tol) + + expected_inputs = [ + (Aircraft.CrewPayload.NUM_FIRST_CLASS, 1), + (Aircraft.CrewPayload.NUM_BUSINESS_CLASS, 5), + (Aircraft.CrewPayload.NUM_TOURIST_CLASS, 75), + (Aircraft.CrewPayload.NUM_PASSENGERS, 81), + ] + + for var_name, expected_val in expected_inputs: + with self.subTest(var=var_name): + assert_near_equal( + prob_fallout.aviary_inputs.get_val(var_name), + expected_val, + tolerance=1e-12, + ) @require_pyoptsparse(optimizer='SNOPT') def test_alternate_mission_match(self): @@ -189,77 +168,52 @@ def test_alternate_mission_changed(self): num_business=5, num_tourist=144, ) - assert_near_equal( - prob_alternate.get_val(Mission.Design.RANGE), - self.prob.get_val(Mission.Design.RANGE), - tolerance=1e-12, - ) - assert_near_equal(prob_alternate.get_val(Mission.Summary.RANGE), 1800, tolerance=1e-6) - assert_near_equal( - prob_alternate.get_val(Mission.Summary.FUEL_MASS, 'lbm'), - 33139.01658754, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.get_val(Mission.Summary.TOTAL_FUEL_MASS, 'lbm'), - 23663.00633808, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.get_val(Mission.Summary.OPERATING_MASS, 'lbm'), - 97743.52792979, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.get_val(Aircraft.CrewPayload.CARGO_MASS, 'lbm'), - 2500, - tolerance=1e-12, - ) - assert_near_equal( - prob_alternate.get_val(Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS, 'lbm'), - 36250, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.get_val(Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS, 'lbm'), - 33750, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.get_val(Aircraft.Design.EMPTY_MASS, 'lbm'), - self.prob.get_val(Aircraft.Design.EMPTY_MASS, 'lbm'), - tolerance=1e-12, - ) - assert_near_equal( - prob_alternate.get_val(Mission.Design.GROSS_MASS, 'lbm'), - self.prob.get_val(Mission.Design.GROSS_MASS, 'lbm'), - tolerance=1e-12, - ) - assert_near_equal( - prob_alternate.get_val(Mission.Summary.GROSS_MASS, 'lbm'), - 157656.53426787, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_FIRST_CLASS), - 1, - tolerance=1e-12, - ) - assert_near_equal( - prob_alternate.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_BUSINESS_CLASS), - 5, - tolerance=1e-12, - ) - assert_near_equal( - prob_alternate.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_TOURIST_CLASS), - 144, - tolerance=1e-12, - ) - assert_near_equal( - prob_alternate.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_PASSENGERS), - 150, - tolerance=1e-12, - ) + expected_values = [ + (Mission.Design.RANGE, None, self.prob.get_val(Mission.Design.RANGE), 1e-12), + (Mission.Summary.RANGE, None, 1800, 1e-6), + (Mission.Summary.FUEL_MASS, 'lbm', 33139.01658754, 1e-6), + (Mission.Summary.TOTAL_FUEL_MASS, 'lbm', 23663.00633808, 1e-6), + (Mission.Summary.OPERATING_MASS, 'lbm', 97743.52792979, 1e-6), + (Aircraft.CrewPayload.CARGO_MASS, 'lbm', 2500, 1e-12), + (Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS, 'lbm', 36250, 1e-6), + (Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS, 'lbm', 33750, 1e-6), + ( + Aircraft.Design.EMPTY_MASS, + 'lbm', + self.prob.get_val(Aircraft.Design.EMPTY_MASS, 'lbm'), + 1e-12, + ), + ( + Mission.Design.GROSS_MASS, + 'lbm', + self.prob.get_val(Mission.Design.GROSS_MASS, 'lbm'), + 1e-12, + ), + (Mission.Summary.GROSS_MASS, 'lbm', 157656.53426787, 1e-6), + ] + + for var_name, units, expected_val, tol in expected_values: + with self.subTest(var=var_name): + if units: + actual = prob_alternate.get_val(var_name, units) + else: + actual = prob_alternate.get_val(var_name) + assert_near_equal(actual, expected_val, tolerance=tol) + + expected_inputs = [ + (Aircraft.CrewPayload.NUM_FIRST_CLASS, 1), + (Aircraft.CrewPayload.NUM_BUSINESS_CLASS, 5), + (Aircraft.CrewPayload.NUM_TOURIST_CLASS, 144), + (Aircraft.CrewPayload.NUM_PASSENGERS, 150), + ] + + for var_name, expected_val in expected_inputs: + with self.subTest(var=var_name): + assert_near_equal( + prob_alternate.aviary_inputs.get_val(var_name), + expected_val, + tolerance=1e-12, + ) @use_tempdirs @@ -318,14 +272,18 @@ def compare_results(self, comparison_prob): ] for var in prob_var_list: - assert_near_equal(comparison_prob.get_val(var), self.prob.get_val(var), tolerance=1e-6) + with self.subTest(var=var): + assert_near_equal( + comparison_prob.get_val(var), self.prob.get_val(var), tolerance=1e-6 + ) for var in inputs_var_list: - assert_near_equal( - comparison_prob.aviary_inputs.get_val(var[0], var[1]), - self.prob.aviary_inputs.get_val(var[0], var[1]), - tolerance=1e-12, - ) + with self.subTest(var=var[0]): + assert_near_equal( + comparison_prob.aviary_inputs.get_val(var[0], var[1]), + self.prob.aviary_inputs.get_val(var[0], var[1]), + tolerance=1e-12, + ) @require_pyoptsparse(optimizer='SNOPT') def test_fallout_mission_match(self): @@ -344,65 +302,53 @@ def test_fallout_mission_changed(self): mission_gross_mass=155000.0, num_pax=75, ) - assert_near_equal( - prob_fallout.aviary_inputs.get_val(Mission.Design.RANGE, 'nmi'), - prob.aviary_inputs.get_val(Mission.Design.RANGE, 'nmi'), - tolerance=1e-12, - ) - assert_near_equal( - prob_fallout.get_val(Mission.Summary.RANGE), 3990.50333708, tolerance=1e-4 - ) - assert_near_equal( - prob_fallout.get_val(Mission.Summary.FUEL_MASS, 'lbm'), - 40530.30547651, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Mission.Summary.TOTAL_FUEL_MASS, 'lbm'), - 39901.96542487, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Mission.Summary.OPERATING_MASS, 'lbm'), - 95098.03457513, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Aircraft.CrewPayload.CARGO_MASS, 'lbm'), - 5000, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS, 'lbm'), - 20000, - tolerance=1e-6, - ) - assert_near_equal( - prob_fallout.get_val(Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS, 'lbm'), - 15000, - tolerance=1e-6, - ) - # currently not a GASP variable - # assert_near_equal( - # prob_fallout.get_val(Aircraft.Design.EMPTY_MASS, 'lbm'), - # prob.get_val(Aircraft.Design.EMPTY_MASS, 'lbm'), - # tolerance=1e-12, - # ) - assert_near_equal( - prob_fallout.get_val(Mission.Design.GROSS_MASS, 'lbm'), - prob.get_val(Mission.Design.GROSS_MASS, 'lbm'), - tolerance=1e-12, - ) - assert_near_equal( - prob_fallout.get_val(Mission.Summary.GROSS_MASS, 'lbm'), - 155000, - tolerance=1e-12, - ) - assert_near_equal( - prob_fallout.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_PASSENGERS), - 75, - tolerance=1e-12, - ) + expected_values = [ + ( + Mission.Design.RANGE, + 'nmi', + prob.aviary_inputs.get_val(Mission.Design.RANGE, 'nmi'), + 1e-12, + 'aviary_inputs', + ), + (Mission.Summary.RANGE, None, 3990.50333708, 1e-4, None), + (Mission.Summary.FUEL_MASS, 'lbm', 40530.30547651, 1e-6, None), + (Mission.Summary.TOTAL_FUEL_MASS, 'lbm', 39901.96542487, 1e-6, None), + ] + + for var_name, units, expected_val, tol, source in expected_values: + with self.subTest(var=var_name): + if source == 'aviary_inputs': + actual = prob_fallout.aviary_inputs.get_val(var_name, units) + elif units: + actual = prob_fallout.get_val(var_name, units) + else: + actual = prob_fallout.get_val(var_name) + assert_near_equal(actual, expected_val, tolerance=tol) + expected_values = [ + (Mission.Summary.OPERATING_MASS, 'lbm', 95098.03457513, 1e-6), + (Aircraft.CrewPayload.CARGO_MASS, 'lbm', 5000, 1e-6), + (Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS, 'lbm', 20000, 1e-6), + (Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS, 'lbm', 15000, 1e-6), + ( + Mission.Design.GROSS_MASS, + 'lbm', + prob.get_val(Mission.Design.GROSS_MASS, 'lbm'), + 1e-12, + ), + (Mission.Summary.GROSS_MASS, 'lbm', 155000, 1e-12), + ] + + for var_name, units, expected_val, tol in expected_values: + with self.subTest(var=var_name): + actual = prob_fallout.get_val(var_name, units) + assert_near_equal(actual, expected_val, tolerance=tol) + + with self.subTest(var=Aircraft.CrewPayload.NUM_PASSENGERS): + assert_near_equal( + prob_fallout.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_PASSENGERS), + 75, + tolerance=1e-12, + ) @require_pyoptsparse(optimizer='SNOPT') def test_alternate_mission_match(self): @@ -424,63 +370,47 @@ def test_alternate_mission_changed(self): mission_range=1800, num_pax=150, ) - assert_near_equal( - prob_alternate.aviary_inputs.get_val(Mission.Design.RANGE, 'nmi'), - prob.aviary_inputs.get_val(Mission.Design.RANGE, 'nmi'), - tolerance=1e-12, - ) - assert_near_equal(prob_alternate.get_val(Mission.Summary.RANGE), 1800, tolerance=1e-6) - assert_near_equal( - prob_alternate.get_val(Mission.Summary.FUEL_MASS, 'lbm'), - 40530.30547651, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.get_val(Mission.Summary.TOTAL_FUEL_MASS, 'lbm'), - 21491.58497491, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.get_val(Mission.Summary.OPERATING_MASS, 'lbm'), - 95098.03432895, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.get_val(Aircraft.CrewPayload.CARGO_MASS, 'lbm'), - 2100, - tolerance=1e-12, - ) - assert_near_equal( - prob_alternate.get_val(Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS, 'lbm'), - 32100, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.get_val(Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS, 'lbm'), - 30000, - tolerance=1e-6, - ) - # currently not a GASP variable - # assert_near_equal( - # prob_alternate.get_val(Aircraft.Design.EMPTY_MASS, 'lbm'), - # prob.get_val(Aircraft.Design.EMPTY_MASS, 'lbm'), - # tolerance=1e-12, - # ) - assert_near_equal( - prob_alternate.get_val(Mission.Design.GROSS_MASS, 'lbm'), - prob.get_val(Mission.Design.GROSS_MASS, 'lbm'), - tolerance=1e-12, - ) - assert_near_equal( - prob_alternate.get_val(Mission.Summary.GROSS_MASS, 'lbm'), - 148689.61930389, - tolerance=1e-6, - ) - assert_near_equal( - prob_alternate.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_PASSENGERS), - 150, - tolerance=1e-12, - ) + expected_values = [ + ( + Mission.Design.RANGE, + 'nmi', + prob.aviary_inputs.get_val(Mission.Design.RANGE, 'nmi'), + 1e-12, + 'aviary_inputs', + ), + (Mission.Summary.RANGE, None, 1800, 1e-6, None), + (Mission.Summary.FUEL_MASS, 'lbm', 40530.30547651, 1e-6, None), + (Mission.Summary.TOTAL_FUEL_MASS, 'lbm', 21491.58497491, 1e-6, None), + (Mission.Summary.OPERATING_MASS, 'lbm', 95098.03432895, 1e-6, None), + (Aircraft.CrewPayload.CARGO_MASS, 'lbm', 2100, 1e-12, None), + (Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS, 'lbm', 32100, 1e-6, None), + (Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS, 'lbm', 30000, 1e-6, None), + ( + Mission.Design.GROSS_MASS, + 'lbm', + prob.get_val(Mission.Design.GROSS_MASS, 'lbm'), + 1e-12, + None, + ), + (Mission.Summary.GROSS_MASS, 'lbm', 148689.61930389, 1e-6, None), + ] + + for var_name, units, expected_val, tol, source in expected_values: + with self.subTest(var=var_name): + if source == 'aviary_inputs': + actual = prob_alternate.aviary_inputs.get_val(var_name, units) + elif units: + actual = prob_alternate.get_val(var_name, units) + else: + actual = prob_alternate.get_val(var_name) + assert_near_equal(actual, expected_val, tolerance=tol) + + with self.subTest(var=Aircraft.CrewPayload.NUM_PASSENGERS): + assert_near_equal( + prob_alternate.aviary_inputs.get_val(Aircraft.CrewPayload.NUM_PASSENGERS), + 150, + tolerance=1e-12, + ) @use_tempdirs From 6281ca29237ac7b7803e4d13a8b728baf9699836 Mon Sep 17 00:00:00 2001 From: jkirk5 Date: Fri, 23 Jan 2026 17:31:27 -0500 Subject: [PATCH 2/6] added subtests to FLOPS validation cases (manually coded) --- .../flops_based/test/test_prep_geom.py | 2 + .../flops_based/test/test_air_conditioning.py | 3 + .../mass/flops_based/test/test_anti_icing.py | 2 + .../mass/flops_based/test/test_apu.py | 2 + .../mass/flops_based/test/test_avionics.py | 2 + .../mass/flops_based/test/test_cargo.py | 1 + .../flops_based/test/test_cargo_containers.py | 2 + .../mass/flops_based/test/test_crew.py | 4 ++ .../mass/flops_based/test/test_electrical.py | 4 ++ .../flops_based/test/test_empty_margin.py | 2 + .../mass/flops_based/test/test_engine.py | 2 + .../flops_based/test/test_engine_controls.py | 2 + .../mass/flops_based/test/test_engine_oil.py | 3 + .../mass/flops_based/test/test_engine_pod.py | 2 + .../mass/flops_based/test/test_fin.py | 1 + .../flops_based/test/test_fuel_capacity.py | 1 + .../mass/flops_based/test/test_fuel_system.py | 3 + .../mass/flops_based/test/test_furnishings.py | 4 ++ .../mass/flops_based/test/test_fuselage.py | 4 ++ .../flops_based/test/test_horizontail_tail.py | 3 + .../mass/flops_based/test/test_hydraulics.py | 3 + .../mass/flops_based/test/test_instruments.py | 2 + .../flops_based/test/test_landing_gear.py | 4 ++ .../flops_based/test/test_landing_mass.py | 2 + .../flops_based/test/test_mass_summation.py | 6 ++ .../mass/flops_based/test/test_misc_engine.py | 2 + .../mass/flops_based/test/test_nacelle.py | 2 + .../mass/flops_based/test/test_paint.py | 2 + .../test/test_passenger_service.py | 3 + .../mass/flops_based/test/test_starter.py | 2 + .../flops_based/test/test_surface_controls.py | 3 + .../flops_based/test/test_thrust_reverser.py | 2 + .../flops_based/test/test_unusable_fuel.py | 3 + .../flops_based/test/test_vertical_tail.py | 3 + .../mass/flops_based/test/test_wing_common.py | 3 + .../flops_based/test/test_wing_detailed.py | 1 + .../mass/flops_based/test/test_wing_group.py | 1 + .../mass/flops_based/test/test_wing_simple.py | 1 + .../test/test_flops_based_premission.py | 5 ++ aviary/validation_cases/validation_tests.py | 71 +++++++++---------- 40 files changed, 131 insertions(+), 39 deletions(-) diff --git a/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py b/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py index 856a8d3064..be873fa2e0 100644 --- a/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py +++ b/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py @@ -152,6 +152,7 @@ def configure(self): ) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -463,6 +464,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_air_conditioning.py b/aviary/subsystems/mass/flops_based/test/test_air_conditioning.py index 7200c76417..23daef151c 100644 --- a/aviary/subsystems/mass/flops_based/test/test_air_conditioning.py +++ b/aviary/subsystems/mass/flops_based/test/test_air_conditioning.py @@ -40,6 +40,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -120,6 +121,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=Aircraft.AirConditioning.MASS_SCALER, @@ -190,6 +192,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_anti_icing.py b/aviary/subsystems/mass/flops_based/test/test_anti_icing.py index 7b7629c3e2..adf79dc983 100644 --- a/aviary/subsystems/mass/flops_based/test/test_anti_icing.py +++ b/aviary/subsystems/mass/flops_based/test/test_anti_icing.py @@ -41,6 +41,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -203,6 +204,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_apu.py b/aviary/subsystems/mass/flops_based/test/test_apu.py index 47d1e31d9a..45a4b43289 100644 --- a/aviary/subsystems/mass/flops_based/test/test_apu.py +++ b/aviary/subsystems/mass/flops_based/test/test_apu.py @@ -40,6 +40,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.APU.MASS_SCALER, Aircraft.Fuselage.PLANFORM_AREA], @@ -104,6 +105,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.APU.MASS_SCALER, Aircraft.Fuselage.PLANFORM_AREA], diff --git a/aviary/subsystems/mass/flops_based/test/test_avionics.py b/aviary/subsystems/mass/flops_based/test/test_avionics.py index d5e9d29078..9e693f609a 100644 --- a/aviary/subsystems/mass/flops_based/test/test_avionics.py +++ b/aviary/subsystems/mass/flops_based/test/test_avionics.py @@ -42,6 +42,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -113,6 +114,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_cargo.py b/aviary/subsystems/mass/flops_based/test/test_cargo.py index 4c035f2215..5dc7e1a99d 100644 --- a/aviary/subsystems/mass/flops_based/test/test_cargo.py +++ b/aviary/subsystems/mass/flops_based/test/test_cargo.py @@ -100,6 +100,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.CrewPayload.MISC_CARGO, Aircraft.CrewPayload.WING_CARGO], diff --git a/aviary/subsystems/mass/flops_based/test/test_cargo_containers.py b/aviary/subsystems/mass/flops_based/test/test_cargo_containers.py index 7161b566a6..c552f18e04 100644 --- a/aviary/subsystems/mass/flops_based/test/test_cargo_containers.py +++ b/aviary/subsystems/mass/flops_based/test/test_cargo_containers.py @@ -40,6 +40,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -111,6 +112,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_crew.py b/aviary/subsystems/mass/flops_based/test/test_crew.py index d12498a244..20b36f2478 100644 --- a/aviary/subsystems/mass/flops_based/test/test_crew.py +++ b/aviary/subsystems/mass/flops_based/test/test_crew.py @@ -39,6 +39,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=Aircraft.CrewPayload.NON_FLIGHT_CREW_MASS_SCALER, @@ -71,6 +72,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=Aircraft.CrewPayload.FLIGHT_CREW_MASS_SCALER, @@ -105,6 +107,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=Aircraft.CrewPayload.NON_FLIGHT_CREW_MASS_SCALER, @@ -137,6 +140,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=Aircraft.CrewPayload.FLIGHT_CREW_MASS_SCALER, diff --git a/aviary/subsystems/mass/flops_based/test/test_electrical.py b/aviary/subsystems/mass/flops_based/test/test_electrical.py index 5748dfebda..34ab2acded 100644 --- a/aviary/subsystems/mass/flops_based/test/test_electrical.py +++ b/aviary/subsystems/mass/flops_based/test/test_electrical.py @@ -46,6 +46,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, self.prob, case_name, input_keys=[ @@ -86,6 +87,7 @@ def test_case(self): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, self.prob, 'AdvancedSingleAisle', input_keys=[ @@ -160,6 +162,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, self.prob, case_name, input_keys=Aircraft.Electrical.MASS_SCALER, @@ -200,6 +203,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, self.prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_empty_margin.py b/aviary/subsystems/mass/flops_based/test/test_empty_margin.py index 65993f19b2..b49ae8d884 100644 --- a/aviary/subsystems/mass/flops_based/test/test_empty_margin.py +++ b/aviary/subsystems/mass/flops_based/test/test_empty_margin.py @@ -39,6 +39,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -79,6 +80,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_engine.py b/aviary/subsystems/mass/flops_based/test/test_engine.py index fc6278d200..322d318e2c 100644 --- a/aviary/subsystems/mass/flops_based/test/test_engine.py +++ b/aviary/subsystems/mass/flops_based/test/test_engine.py @@ -46,6 +46,7 @@ def test_case(self, case_name): prob.set_val(Aircraft.Engine.MASS_SCALER, val=np.zeros(1)) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -163,6 +164,7 @@ def test_case(self, case_name): prob.set_val(Aircraft.Engine.MASS_SCALER, val=np.ones(1)) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_engine_controls.py b/aviary/subsystems/mass/flops_based/test/test_engine_controls.py index ea705a065a..5ba06bee0e 100644 --- a/aviary/subsystems/mass/flops_based/test/test_engine_controls.py +++ b/aviary/subsystems/mass/flops_based/test/test_engine_controls.py @@ -43,6 +43,7 @@ def test_case(self, case_name): prob.setup(force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Propulsion.TOTAL_SCALED_SLS_THRUST], @@ -112,6 +113,7 @@ def test_case(self, case_name): prob.setup(force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Propulsion.TOTAL_SCALED_SLS_THRUST], diff --git a/aviary/subsystems/mass/flops_based/test/test_engine_oil.py b/aviary/subsystems/mass/flops_based/test/test_engine_oil.py index 961ac22623..9452556e70 100644 --- a/aviary/subsystems/mass/flops_based/test/test_engine_oil.py +++ b/aviary/subsystems/mass/flops_based/test/test_engine_oil.py @@ -46,6 +46,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -122,6 +123,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -194,6 +196,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_engine_pod.py b/aviary/subsystems/mass/flops_based/test/test_engine_pod.py index 07e3ac0530..f1579d68d8 100644 --- a/aviary/subsystems/mass/flops_based/test/test_engine_pod.py +++ b/aviary/subsystems/mass/flops_based/test/test_engine_pod.py @@ -55,6 +55,7 @@ def test_case(self, case_name): # Tol not that tight, but it is unclear where the pod mass values in files come from, # since they aren't printed in the FLOPS output. flops_validation_test( + self, prob, case_name, input_keys=[ @@ -136,6 +137,7 @@ def test_case(self, case_name): # Tol not that tight, but it is unclear where the pod mass values in files come from, # since they aren't printed in the FLOPS output. flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_fin.py b/aviary/subsystems/mass/flops_based/test/test_fin.py index 6fbf73c67a..00b0616765 100644 --- a/aviary/subsystems/mass/flops_based/test/test_fin.py +++ b/aviary/subsystems/mass/flops_based/test/test_fin.py @@ -134,6 +134,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py b/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py index abc098325b..2bf422b5e9 100644 --- a/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py +++ b/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py @@ -59,6 +59,7 @@ def configure(self): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_fuel_system.py b/aviary/subsystems/mass/flops_based/test/test_fuel_system.py index 12c3fb265e..c62db14961 100644 --- a/aviary/subsystems/mass/flops_based/test/test_fuel_system.py +++ b/aviary/subsystems/mass/flops_based/test/test_fuel_system.py @@ -45,6 +45,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Fuel.FUEL_SYSTEM_MASS_SCALER, Aircraft.Fuel.TOTAL_CAPACITY], @@ -122,6 +123,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Fuel.FUEL_SYSTEM_MASS_SCALER, Aircraft.Fuel.TOTAL_CAPACITY], @@ -202,6 +204,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Fuel.FUEL_SYSTEM_MASS_SCALER, Aircraft.Fuel.TOTAL_CAPACITY], diff --git a/aviary/subsystems/mass/flops_based/test/test_furnishings.py b/aviary/subsystems/mass/flops_based/test/test_furnishings.py index 10b09c0aad..8277d62c05 100644 --- a/aviary/subsystems/mass/flops_based/test/test_furnishings.py +++ b/aviary/subsystems/mass/flops_based/test/test_furnishings.py @@ -48,6 +48,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -86,6 +87,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -174,6 +176,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=Aircraft.Furnishings.MASS_SCALER, @@ -205,6 +208,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_fuselage.py b/aviary/subsystems/mass/flops_based/test/test_fuselage.py index 0d409f46f7..d31e38f04e 100644 --- a/aviary/subsystems/mass/flops_based/test/test_fuselage.py +++ b/aviary/subsystems/mass/flops_based/test/test_fuselage.py @@ -47,6 +47,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -114,6 +115,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -183,6 +185,7 @@ def test_case1(self, case_name): self.prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -221,6 +224,7 @@ def test_case1(self, case_name): self.prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_horizontail_tail.py b/aviary/subsystems/mass/flops_based/test/test_horizontail_tail.py index de43ab99e0..11dd9f5d5a 100644 --- a/aviary/subsystems/mass/flops_based/test/test_horizontail_tail.py +++ b/aviary/subsystems/mass/flops_based/test/test_horizontail_tail.py @@ -40,6 +40,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -105,6 +106,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.HorizontalTail.AREA, Aircraft.HorizontalTail.MASS_SCALER], @@ -165,6 +167,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_hydraulics.py b/aviary/subsystems/mass/flops_based/test/test_hydraulics.py index 9a31f34a31..ce356219ad 100644 --- a/aviary/subsystems/mass/flops_based/test/test_hydraulics.py +++ b/aviary/subsystems/mass/flops_based/test/test_hydraulics.py @@ -55,6 +55,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -134,6 +135,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -212,6 +214,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_instruments.py b/aviary/subsystems/mass/flops_based/test/test_instruments.py index 6e4efd43ec..42b1f5475c 100644 --- a/aviary/subsystems/mass/flops_based/test/test_instruments.py +++ b/aviary/subsystems/mass/flops_based/test/test_instruments.py @@ -54,6 +54,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Fuselage.PLANFORM_AREA, Aircraft.Instruments.MASS_SCALER], @@ -149,6 +150,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Fuselage.PLANFORM_AREA, Aircraft.Instruments.MASS_SCALER], diff --git a/aviary/subsystems/mass/flops_based/test/test_landing_gear.py b/aviary/subsystems/mass/flops_based/test/test_landing_gear.py index dd585de091..5633de5973 100644 --- a/aviary/subsystems/mass/flops_based/test/test_landing_gear.py +++ b/aviary/subsystems/mass/flops_based/test/test_landing_gear.py @@ -43,6 +43,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, self.prob, case_name, input_keys=[ @@ -108,6 +109,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, self.prob, case_name, input_keys=[ @@ -178,6 +180,7 @@ def test_derivs(self, case_name): prob.setup(force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -221,6 +224,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, self.prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_landing_mass.py b/aviary/subsystems/mass/flops_based/test/test_landing_mass.py index 50446cc73e..efbf572b1d 100644 --- a/aviary/subsystems/mass/flops_based/test/test_landing_mass.py +++ b/aviary/subsystems/mass/flops_based/test/test_landing_mass.py @@ -30,6 +30,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Mission.Design.GROSS_MASS, Aircraft.Design.LANDING_TO_TAKEOFF_MASS_RATIO], @@ -58,6 +59,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Mission.Design.GROSS_MASS, Aircraft.Design.LANDING_TO_TAKEOFF_MASS_RATIO], diff --git a/aviary/subsystems/mass/flops_based/test/test_mass_summation.py b/aviary/subsystems/mass/flops_based/test/test_mass_summation.py index 0ece0d573c..d6c1f2cd94 100644 --- a/aviary/subsystems/mass/flops_based/test/test_mass_summation.py +++ b/aviary/subsystems/mass/flops_based/test/test_mass_summation.py @@ -53,6 +53,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -138,6 +139,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -271,6 +273,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -305,6 +308,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -339,6 +343,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -383,6 +388,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_misc_engine.py b/aviary/subsystems/mass/flops_based/test/test_misc_engine.py index c9d727271b..9fc1b9e7b2 100644 --- a/aviary/subsystems/mass/flops_based/test/test_misc_engine.py +++ b/aviary/subsystems/mass/flops_based/test/test_misc_engine.py @@ -46,6 +46,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -129,6 +130,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_nacelle.py b/aviary/subsystems/mass/flops_based/test/test_nacelle.py index b9e940fb02..d4e3a0ad8b 100644 --- a/aviary/subsystems/mass/flops_based/test/test_nacelle.py +++ b/aviary/subsystems/mass/flops_based/test/test_nacelle.py @@ -49,6 +49,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, self.prob, case_name, input_keys=[ @@ -202,6 +203,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, self.prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_paint.py b/aviary/subsystems/mass/flops_based/test/test_paint.py index 93291f3d4d..3e3f94ab47 100644 --- a/aviary/subsystems/mass/flops_based/test/test_paint.py +++ b/aviary/subsystems/mass/flops_based/test/test_paint.py @@ -36,6 +36,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Design.TOTAL_WETTED_AREA, Aircraft.Paint.MASS_PER_UNIT_AREA], @@ -67,6 +68,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Design.TOTAL_WETTED_AREA, Aircraft.Paint.MASS_PER_UNIT_AREA], diff --git a/aviary/subsystems/mass/flops_based/test/test_passenger_service.py b/aviary/subsystems/mass/flops_based/test/test_passenger_service.py index c338106098..2a5b2687ba 100644 --- a/aviary/subsystems/mass/flops_based/test/test_passenger_service.py +++ b/aviary/subsystems/mass/flops_based/test/test_passenger_service.py @@ -43,6 +43,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.CrewPayload.PASSENGER_SERVICE_MASS_SCALER, Mission.Design.RANGE], @@ -107,6 +108,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=Aircraft.CrewPayload.PASSENGER_SERVICE_MASS_SCALER, @@ -172,6 +174,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.CrewPayload.PASSENGER_SERVICE_MASS_SCALER, Mission.Design.RANGE], diff --git a/aviary/subsystems/mass/flops_based/test/test_starter.py b/aviary/subsystems/mass/flops_based/test/test_starter.py index a7bd7f40f0..9280e80be3 100644 --- a/aviary/subsystems/mass/flops_based/test/test_starter.py +++ b/aviary/subsystems/mass/flops_based/test/test_starter.py @@ -45,6 +45,7 @@ def test_case_1(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Nacelle.AVG_DIAMETER, Aircraft.Engine.SCALE_FACTOR], @@ -159,6 +160,7 @@ def test_case_1(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Nacelle.AVG_DIAMETER, Aircraft.Engine.SCALE_FACTOR], diff --git a/aviary/subsystems/mass/flops_based/test/test_surface_controls.py b/aviary/subsystems/mass/flops_based/test/test_surface_controls.py index b941c054b7..a940d7daa2 100644 --- a/aviary/subsystems/mass/flops_based/test/test_surface_controls.py +++ b/aviary/subsystems/mass/flops_based/test/test_surface_controls.py @@ -38,6 +38,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -101,6 +102,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -167,6 +169,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_thrust_reverser.py b/aviary/subsystems/mass/flops_based/test/test_thrust_reverser.py index 5d81f3015e..1b54f63c55 100644 --- a/aviary/subsystems/mass/flops_based/test/test_thrust_reverser.py +++ b/aviary/subsystems/mass/flops_based/test/test_thrust_reverser.py @@ -44,6 +44,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -170,6 +171,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_unusable_fuel.py b/aviary/subsystems/mass/flops_based/test/test_unusable_fuel.py index 449f44e62b..c11dad885f 100644 --- a/aviary/subsystems/mass/flops_based/test/test_unusable_fuel.py +++ b/aviary/subsystems/mass/flops_based/test/test_unusable_fuel.py @@ -45,6 +45,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -118,6 +119,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.Fuel.UNUSABLE_FUEL_MASS_SCALER, Aircraft.Fuel.TOTAL_CAPACITY], @@ -179,6 +181,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_vertical_tail.py b/aviary/subsystems/mass/flops_based/test/test_vertical_tail.py index a1a13b3cd6..4ff9dd4ee5 100644 --- a/aviary/subsystems/mass/flops_based/test/test_vertical_tail.py +++ b/aviary/subsystems/mass/flops_based/test/test_vertical_tail.py @@ -40,6 +40,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ @@ -107,6 +108,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[Aircraft.VerticalTail.AREA, Aircraft.VerticalTail.MASS_SCALER], @@ -172,6 +174,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_wing_common.py b/aviary/subsystems/mass/flops_based/test/test_wing_common.py index 64b4e5dfd0..b627bab2c8 100644 --- a/aviary/subsystems/mass/flops_based/test/test_wing_common.py +++ b/aviary/subsystems/mass/flops_based/test/test_wing_common.py @@ -42,6 +42,7 @@ def test_case(self, case_name): prob = self.prob flops_validation_test( + self, prob, case_name, input_keys=[ @@ -107,6 +108,7 @@ def test_case(self, case_name): prob = self.prob flops_validation_test( + self, prob, case_name, input_keys=[ @@ -175,6 +177,7 @@ def test_case(self, case_name): prob = self.prob flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_wing_detailed.py b/aviary/subsystems/mass/flops_based/test/test_wing_detailed.py index ceed595dff..8042ed91fc 100644 --- a/aviary/subsystems/mass/flops_based/test/test_wing_detailed.py +++ b/aviary/subsystems/mass/flops_based/test/test_wing_detailed.py @@ -65,6 +65,7 @@ def test_case(self, case_name): self.prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_wing_group.py b/aviary/subsystems/mass/flops_based/test/test_wing_group.py index e6f86b73b5..50705d6fdd 100644 --- a/aviary/subsystems/mass/flops_based/test/test_wing_group.py +++ b/aviary/subsystems/mass/flops_based/test/test_wing_group.py @@ -56,6 +56,7 @@ def test_case(self): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, self.prob, case_name, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_wing_simple.py b/aviary/subsystems/mass/flops_based/test/test_wing_simple.py index 36d022a624..3aa0e56353 100644 --- a/aviary/subsystems/mass/flops_based/test/test_wing_simple.py +++ b/aviary/subsystems/mass/flops_based/test/test_wing_simple.py @@ -47,6 +47,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) flops_validation_test( + self, prob, case_name, input_keys=[ diff --git a/aviary/subsystems/test/test_flops_based_premission.py b/aviary/subsystems/test/test_flops_based_premission.py index 648e588854..c88b0bb24a 100644 --- a/aviary/subsystems/test/test_flops_based_premission.py +++ b/aviary/subsystems/test/test_flops_based_premission.py @@ -86,6 +86,7 @@ def test_case(self, case_name): ) flops_validation_test( + self, prob, case_name, input_keys=[], @@ -131,6 +132,7 @@ def test_diff_configuration_mass(self): set_aviary_initial_values(prob, flops_inputs) flops_validation_test( + self, prob, 'LargeSingleAisle2FLOPS', input_keys=[], @@ -176,6 +178,7 @@ def test_mass_aero_only(self): prob.run_model() flops_validation_test( + self, prob, 'LargeSingleAisle2FLOPS', input_keys=[], @@ -256,6 +259,7 @@ def test_case_all_subsystems(self, case_name): set_aviary_initial_values(prob, flops_inputs) flops_validation_test( + self, prob, case_name, input_keys=[], @@ -444,6 +448,7 @@ def test_case_geom(self): set_aviary_initial_values(prob, flops_inputs) flops_validation_test( + self, prob, case_name, input_keys=[], diff --git a/aviary/validation_cases/validation_tests.py b/aviary/validation_cases/validation_tests.py index 7a8e31c2c7..012555ad9c 100644 --- a/aviary/validation_cases/validation_tests.py +++ b/aviary/validation_cases/validation_tests.py @@ -1,4 +1,4 @@ -import warnings +import unittest from enum import Enum import openmdao.api as om @@ -20,8 +20,8 @@ def do_validation_test( + test: unittest.TestCase, prob: om.Problem, - case_name: str, input_validation_data: AviaryValues, output_validation_data: AviaryValues, input_keys: list, @@ -44,61 +44,53 @@ def do_validation_test( Parameters ---------- + test : unittest + The unittest housing this function call prob : om.Problem An instantiated and set-up Problem. case_name : str Name of the case being run. input_validation_data : AviaryValues - Input variables and their values to use when running the problem. - The object must contain at a minimum all the input variables listed - in input_keys. + Input variables and their values to use when running the problem. The object must contain at + a minimum all the input variables listed in input_keys. output_validation_data : AviaryValues - Output variables and their values to which output from the problem - will be compared. The object must contain at a minimum all the - output variables listed in output_keys. Note that input_validation_data - and output_validation_data may be the same object. + Output variables and their values to which output from the problem will be compared. The + object must contain at a minimum all the output variables listed in output_keys. Note that + input_validation_data and output_validation_data may be the same object. input_keys : str, or iter of str - List of input variables whose values will be transferred from - the input validation data in order to run the problem. + List of input variables whose values will be transferred from the input validation data in + order to run the problem. output_keys : str, or iter of str - List of output variables whose values will be looked up in - the output validation data and compared against the outputs from the - problem. + List of output variables whose values will be looked up in the output validation data and + compared against the outputs from the problem. aviary_option_keys: str, or iter of str - List of aviary_options keys whose values will be looked up and - listed in the options printout. If None, all items in aviary_options - will be listed. + List of aviary_options keys whose values will be looked up and listed in the options + printout. If None, all items in aviary_options will be listed. tol : float - Relative tolerance for comparing problem outputs against - validation data. The default is 1.0e-4. + Relative tolerance for comparing problem outputs against validation data. The default is + 1.0e-4. atol : float - Absolute tolerance for checking partial derivative calculations. The - default is 1.0e-12. + Absolute tolerance for checking partial derivative calculations. The default is 1.0e-12. rtol : float - Relative tolerance for checking partial derivative calculations. The - default is 1.0e-12. + Relative tolerance for checking partial derivative calculations. The default is 1.0e-12. method : str Type of differencing to use. The default is "cs". step : float - Step size for approximation. Default is None, which means 1e-6 for 'fd' and 1e-40 for - 'cs'. + Step size for approximation. Default is None, which means 1e-6 for 'fd' and 1e-40 for 'cs'. check_values : bool - If true, check output values against validation data. The default is - true. + If true, check output values against validation data. The default is true. check_partials : bool If true, check partial derivative calculations. The default is true. excludes : None or list_like - List of glob patterns for pathnames to exclude from the partial derivative check. - Default is None, which excludes nothing. + List of glob patterns for pathnames to exclude from the partial derivative check. Default is + None, which excludes nothing. list_options: bool - If True, values of options for all components in the model will be listed - on standard output. Default is False. + If True, values of options for all components in the model will be listed on standard + output. Default is False. list_inputs: bool - If True, prob.model.list_inputs() will be called after the model is run. - Default is False. + If True, prob.model.list_inputs() will be called after the model is run. Default is False. list_outputs: bool - If True, prob.model.list_outputs() will be called after the model is run. - Default is False. + If True, prob.model.list_outputs() will be called after the model is run. Default is False. """ input_key_list = _assure_is_list(input_keys) output_key_list = _assure_is_list(output_keys) @@ -127,10 +119,8 @@ def do_validation_test( for key in output_key_list: desired, units = output_validation_data.get_item(key) actual = prob.get_val(key, units) - try: + with test.subTest(key): assert_near_equal(actual, desired, tol) - except ValueError as err: - raise ValueError(f'ValueError for key = {key}') from err if check_partials: partial_data = prob.check_partials( @@ -140,6 +130,7 @@ def do_validation_test( def flops_validation_test( + test: unittest.TestCase, prob: om.Problem, case_name: str, input_keys: list, @@ -165,6 +156,8 @@ def flops_validation_test( Parameters ---------- + test : unittest + The unittest housing this function call prob : om.Problem An instantiated and set-up Problem. case_name : str @@ -239,8 +232,8 @@ def flops_validation_test( return do_validation_test( + test=test, prob=prob, - case_name=case_name, input_validation_data=flops_inputs, output_validation_data=flops_outputs, input_keys=input_keys, From 13ebe2fc3b2acf71da35cfaa457fddeedeb9ab4a Mon Sep 17 00:00:00 2001 From: jkirk5 Date: Fri, 23 Jan 2026 18:03:24 -0500 Subject: [PATCH 3/6] missed some find+replace for updating validation test calls --- aviary/mission/height_energy/ode/test/test_landing_eom.py | 1 + aviary/mission/height_energy/ode/test/test_landing_ode.py | 1 + aviary/mission/height_energy/ode/test/test_range_rate.py | 1 + aviary/mission/height_energy/ode/test/test_takeoff_eom.py | 2 ++ aviary/mission/height_energy/ode/test/test_takeoff_ode.py | 2 ++ aviary/mission/ode/test/test_altitude_rate.py | 1 + aviary/mission/ode/test/test_specific_energy_rate.py | 1 + .../subsystems/geometry/flops_based/test/test_prep_geom.py | 6 ++++++ aviary/subsystems/mass/flops_based/test/test_canard.py | 1 + aviary/subsystems/mass/flops_based/test/test_cargo.py | 1 + aviary/subsystems/mass/flops_based/test/test_fin.py | 2 ++ .../subsystems/mass/flops_based/test/test_fuel_capacity.py | 4 ++++ 12 files changed, 23 insertions(+) diff --git a/aviary/mission/height_energy/ode/test/test_landing_eom.py b/aviary/mission/height_energy/ode/test/test_landing_eom.py index d9230e83e6..a548a2ccb6 100644 --- a/aviary/mission/height_energy/ode/test/test_landing_eom.py +++ b/aviary/mission/height_energy/ode/test/test_landing_eom.py @@ -44,6 +44,7 @@ def setUp(self): def test_case(self): do_validation_test( + self, self.prob, 'landing_flare_eom', input_validation_data=detailed_landing_flare, diff --git a/aviary/mission/height_energy/ode/test/test_landing_ode.py b/aviary/mission/height_energy/ode/test/test_landing_ode.py index 38773750c4..867b60cea7 100644 --- a/aviary/mission/height_energy/ode/test/test_landing_ode.py +++ b/aviary/mission/height_energy/ode/test/test_landing_ode.py @@ -54,6 +54,7 @@ def test_case(self): set_aviary_initial_values(prob, aviary_options) do_validation_test( + self, prob, 'landing_flare_ode', input_validation_data=detailed_landing_flare, diff --git a/aviary/mission/height_energy/ode/test/test_range_rate.py b/aviary/mission/height_energy/ode/test/test_range_rate.py index 99d4af066e..e5af579027 100644 --- a/aviary/mission/height_energy/ode/test/test_range_rate.py +++ b/aviary/mission/height_energy/ode/test/test_range_rate.py @@ -27,6 +27,7 @@ def setUp(self): def test_case1(self): do_validation_test( + self, self.prob, 'full_mission_test_data', input_validation_data=data, diff --git a/aviary/mission/height_energy/ode/test/test_takeoff_eom.py b/aviary/mission/height_energy/ode/test/test_takeoff_eom.py index be994fe5de..8976976a4e 100644 --- a/aviary/mission/height_energy/ode/test/test_takeoff_eom.py +++ b/aviary/mission/height_energy/ode/test/test_takeoff_eom.py @@ -34,6 +34,7 @@ def test_case_ground(self): prob = self._make_prob(climbing=False) do_validation_test( + self, prob, 'takeoff_eom_ground', input_validation_data=detailed_takeoff_ground, @@ -59,6 +60,7 @@ def test_case_climbing(self): prob = self._make_prob(climbing=True) do_validation_test( + self, prob, 'takeoff_eom_climbing', input_validation_data=detailed_takeoff_climbing, diff --git a/aviary/mission/height_energy/ode/test/test_takeoff_ode.py b/aviary/mission/height_energy/ode/test/test_takeoff_ode.py index 3fa6112473..d16b8043c2 100644 --- a/aviary/mission/height_energy/ode/test/test_takeoff_ode.py +++ b/aviary/mission/height_energy/ode/test/test_takeoff_ode.py @@ -29,6 +29,7 @@ def test_case_ground(self): prob = self._make_prob(climbing=False) do_validation_test( + self, prob, 'takeoff_ode_ground', input_validation_data=detailed_takeoff_ground, @@ -59,6 +60,7 @@ def test_case_climbing(self): prob = self._make_prob(climbing=True) do_validation_test( + self, prob, 'takeoff_ode_climbing', input_validation_data=detailed_takeoff_climbing, diff --git a/aviary/mission/ode/test/test_altitude_rate.py b/aviary/mission/ode/test/test_altitude_rate.py index 1caa25f001..8dc098453d 100644 --- a/aviary/mission/ode/test/test_altitude_rate.py +++ b/aviary/mission/ode/test/test_altitude_rate.py @@ -26,6 +26,7 @@ def setUp(self): def test_case1(self): do_validation_test( + self, self.prob, 'full_mission_test_data', input_validation_data=data, diff --git a/aviary/mission/ode/test/test_specific_energy_rate.py b/aviary/mission/ode/test/test_specific_energy_rate.py index f1b9c600a4..10c01a9eb4 100644 --- a/aviary/mission/ode/test/test_specific_energy_rate.py +++ b/aviary/mission/ode/test/test_specific_energy_rate.py @@ -26,6 +26,7 @@ def setUp(self): def test_case1(self): do_validation_test( + self, self.prob, 'full_mission_test_data', input_validation_data=data, diff --git a/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py b/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py index be873fa2e0..bf7a044105 100644 --- a/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py +++ b/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py @@ -250,6 +250,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) do_validation_test( + self, prob, case_name, input_validation_data=get_flops_data(case_name), @@ -313,6 +314,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) do_validation_test( + self, prob, case_name, input_validation_data=_hybrid_input_data(case_name), @@ -359,6 +361,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) do_validation_test( + self, prob, case_name, input_validation_data=_hybrid_input_data(case_name), @@ -413,6 +416,7 @@ def test_case(self, case_name): outputs.extend(Aircraft.Fuselage.WETTED_AREA) do_validation_test( + self, prob, case_name, input_validation_data=_hybrid_input_data(case_name), @@ -495,6 +499,7 @@ def test_case(self): prob.setup(check=False, force_alloc_complex=True) do_validation_test( + self, prob, 'canard_test', input_validation_data=Canard_test_data, @@ -578,6 +583,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) do_validation_test( + self, prob, case_name, input_validation_data=_hybrid_input_data(case_name), diff --git a/aviary/subsystems/mass/flops_based/test/test_canard.py b/aviary/subsystems/mass/flops_based/test/test_canard.py index 649e3107e6..e40c25636f 100644 --- a/aviary/subsystems/mass/flops_based/test/test_canard.py +++ b/aviary/subsystems/mass/flops_based/test/test_canard.py @@ -46,6 +46,7 @@ def test_case1(self, case_name): prob.setup(check=False, force_alloc_complex=True) do_validation_test( + self, prob, case_name, input_validation_data=validation_data, diff --git a/aviary/subsystems/mass/flops_based/test/test_cargo.py b/aviary/subsystems/mass/flops_based/test/test_cargo.py index 5dc7e1a99d..4d85dbfd24 100644 --- a/aviary/subsystems/mass/flops_based/test/test_cargo.py +++ b/aviary/subsystems/mass/flops_based/test/test_cargo.py @@ -60,6 +60,7 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) do_validation_test( + self, prob, case_name, input_validation_data=validation_data, diff --git a/aviary/subsystems/mass/flops_based/test/test_fin.py b/aviary/subsystems/mass/flops_based/test/test_fin.py index 00b0616765..721cc9ae38 100644 --- a/aviary/subsystems/mass/flops_based/test/test_fin.py +++ b/aviary/subsystems/mass/flops_based/test/test_fin.py @@ -59,6 +59,8 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) do_validation_test( + self, + self, prob, case_name, input_validation_data=validation_data, diff --git a/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py b/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py index 2bf422b5e9..20ab1845b1 100644 --- a/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py +++ b/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py @@ -122,6 +122,7 @@ def test_derivs(self, case_name): prob.setup(force_alloc_complex=True) do_validation_test( + self, prob, case_name, input_validation_data=validation_data, @@ -168,6 +169,7 @@ def test_basic(self, case_name): prob.setup(force_alloc_complex=True) do_validation_test( + self, prob, case_name, input_validation_data=validation_data, @@ -207,6 +209,7 @@ def test_basic(self, case_name): prob.setup(force_alloc_complex=True) do_validation_test( + self, prob, case_name, input_validation_data=validation_data, @@ -252,6 +255,7 @@ def test_basic(self, case_name): prob.setup(force_alloc_complex=True) do_validation_test( + self, prob, case_name, input_validation_data=validation_data, From 0224a6d76d2de723c7401792d3b3a5529cb843b1 Mon Sep 17 00:00:00 2001 From: jkirk5 Date: Mon, 26 Jan 2026 15:40:44 -0500 Subject: [PATCH 4/6] fixed tests to use validation test api change --- aviary/mission/height_energy/ode/test/test_landing_eom.py | 1 - aviary/mission/height_energy/ode/test/test_landing_ode.py | 1 - aviary/mission/height_energy/ode/test/test_range_rate.py | 1 - aviary/mission/height_energy/ode/test/test_takeoff_eom.py | 2 -- aviary/mission/height_energy/ode/test/test_takeoff_ode.py | 2 -- aviary/mission/ode/test/test_altitude_rate.py | 1 - aviary/mission/ode/test/test_specific_energy_rate.py | 1 - .../subsystems/geometry/flops_based/test/test_prep_geom.py | 6 ------ aviary/subsystems/mass/flops_based/test/test_canard.py | 1 - aviary/subsystems/mass/flops_based/test/test_cargo.py | 1 - aviary/subsystems/mass/flops_based/test/test_fin.py | 2 -- .../subsystems/mass/flops_based/test/test_fuel_capacity.py | 4 ---- 12 files changed, 23 deletions(-) diff --git a/aviary/mission/height_energy/ode/test/test_landing_eom.py b/aviary/mission/height_energy/ode/test/test_landing_eom.py index a548a2ccb6..f8b61be63a 100644 --- a/aviary/mission/height_energy/ode/test/test_landing_eom.py +++ b/aviary/mission/height_energy/ode/test/test_landing_eom.py @@ -46,7 +46,6 @@ def test_case(self): do_validation_test( self, self.prob, - 'landing_flare_eom', input_validation_data=detailed_landing_flare, output_validation_data=detailed_landing_flare, input_keys=[ diff --git a/aviary/mission/height_energy/ode/test/test_landing_ode.py b/aviary/mission/height_energy/ode/test/test_landing_ode.py index 867b60cea7..44726345e0 100644 --- a/aviary/mission/height_energy/ode/test/test_landing_ode.py +++ b/aviary/mission/height_energy/ode/test/test_landing_ode.py @@ -56,7 +56,6 @@ def test_case(self): do_validation_test( self, prob, - 'landing_flare_ode', input_validation_data=detailed_landing_flare, output_validation_data=detailed_landing_flare, input_keys=[ diff --git a/aviary/mission/height_energy/ode/test/test_range_rate.py b/aviary/mission/height_energy/ode/test/test_range_rate.py index e5af579027..5d84e3d96a 100644 --- a/aviary/mission/height_energy/ode/test/test_range_rate.py +++ b/aviary/mission/height_energy/ode/test/test_range_rate.py @@ -29,7 +29,6 @@ def test_case1(self): do_validation_test( self, self.prob, - 'full_mission_test_data', input_validation_data=data, output_validation_data=data, input_keys=[Dynamic.Mission.ALTITUDE_RATE, Dynamic.Mission.VELOCITY], diff --git a/aviary/mission/height_energy/ode/test/test_takeoff_eom.py b/aviary/mission/height_energy/ode/test/test_takeoff_eom.py index 8976976a4e..05f57bcc8e 100644 --- a/aviary/mission/height_energy/ode/test/test_takeoff_eom.py +++ b/aviary/mission/height_energy/ode/test/test_takeoff_eom.py @@ -36,7 +36,6 @@ def test_case_ground(self): do_validation_test( self, prob, - 'takeoff_eom_ground', input_validation_data=detailed_takeoff_ground, output_validation_data=detailed_takeoff_ground, input_keys=[ @@ -62,7 +61,6 @@ def test_case_climbing(self): do_validation_test( self, prob, - 'takeoff_eom_climbing', input_validation_data=detailed_takeoff_climbing, output_validation_data=detailed_takeoff_climbing, input_keys=[ diff --git a/aviary/mission/height_energy/ode/test/test_takeoff_ode.py b/aviary/mission/height_energy/ode/test/test_takeoff_ode.py index d16b8043c2..67a76ac3a9 100644 --- a/aviary/mission/height_energy/ode/test/test_takeoff_ode.py +++ b/aviary/mission/height_energy/ode/test/test_takeoff_ode.py @@ -31,7 +31,6 @@ def test_case_ground(self): do_validation_test( self, prob, - 'takeoff_ode_ground', input_validation_data=detailed_takeoff_ground, output_validation_data=detailed_takeoff_ground, input_keys=[ @@ -62,7 +61,6 @@ def test_case_climbing(self): do_validation_test( self, prob, - 'takeoff_ode_climbing', input_validation_data=detailed_takeoff_climbing, output_validation_data=detailed_takeoff_climbing, input_keys=[ diff --git a/aviary/mission/ode/test/test_altitude_rate.py b/aviary/mission/ode/test/test_altitude_rate.py index 8dc098453d..06b70b86af 100644 --- a/aviary/mission/ode/test/test_altitude_rate.py +++ b/aviary/mission/ode/test/test_altitude_rate.py @@ -28,7 +28,6 @@ def test_case1(self): do_validation_test( self, self.prob, - 'full_mission_test_data', input_validation_data=data, output_validation_data=data, input_keys=[ diff --git a/aviary/mission/ode/test/test_specific_energy_rate.py b/aviary/mission/ode/test/test_specific_energy_rate.py index 10c01a9eb4..0d4e881022 100644 --- a/aviary/mission/ode/test/test_specific_energy_rate.py +++ b/aviary/mission/ode/test/test_specific_energy_rate.py @@ -28,7 +28,6 @@ def test_case1(self): do_validation_test( self, self.prob, - 'full_mission_test_data', input_validation_data=data, output_validation_data=data, input_keys=[ diff --git a/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py b/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py index bf7a044105..3146b2d455 100644 --- a/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py +++ b/aviary/subsystems/geometry/flops_based/test/test_prep_geom.py @@ -252,7 +252,6 @@ def test_case(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=get_flops_data(case_name), output_validation_data=local_variables[case_name], input_keys=[ @@ -316,7 +315,6 @@ def test_case(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=_hybrid_input_data(case_name), output_validation_data=get_flops_outputs(case_name), input_keys=[ @@ -363,7 +361,6 @@ def test_case(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=_hybrid_input_data(case_name), output_validation_data=get_flops_outputs(case_name), input_keys=[ @@ -418,7 +415,6 @@ def test_case(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=_hybrid_input_data(case_name), output_validation_data=get_flops_outputs(case_name), input_keys=[ @@ -501,7 +497,6 @@ def test_case(self): do_validation_test( self, prob, - 'canard_test', input_validation_data=Canard_test_data, output_validation_data=Canard_test_data, input_keys=[ @@ -585,7 +580,6 @@ def test_case(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=_hybrid_input_data(case_name), output_validation_data=get_flops_outputs(case_name), input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_canard.py b/aviary/subsystems/mass/flops_based/test/test_canard.py index e40c25636f..557f4bc6c7 100644 --- a/aviary/subsystems/mass/flops_based/test/test_canard.py +++ b/aviary/subsystems/mass/flops_based/test/test_canard.py @@ -48,7 +48,6 @@ def test_case1(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=validation_data, output_validation_data=validation_data, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_cargo.py b/aviary/subsystems/mass/flops_based/test/test_cargo.py index 4d85dbfd24..8f77347f48 100644 --- a/aviary/subsystems/mass/flops_based/test/test_cargo.py +++ b/aviary/subsystems/mass/flops_based/test/test_cargo.py @@ -62,7 +62,6 @@ def test_case(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=validation_data, output_validation_data=validation_data, input_keys=[Aircraft.CrewPayload.MISC_CARGO, Aircraft.CrewPayload.WING_CARGO], diff --git a/aviary/subsystems/mass/flops_based/test/test_fin.py b/aviary/subsystems/mass/flops_based/test/test_fin.py index 721cc9ae38..102d0d3ba4 100644 --- a/aviary/subsystems/mass/flops_based/test/test_fin.py +++ b/aviary/subsystems/mass/flops_based/test/test_fin.py @@ -59,10 +59,8 @@ def test_case(self, case_name): prob.setup(check=False, force_alloc_complex=True) do_validation_test( - self, self, prob, - case_name, input_validation_data=validation_data, output_validation_data=validation_data, input_keys=[ diff --git a/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py b/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py index 20ab1845b1..80e6975f8a 100644 --- a/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py +++ b/aviary/subsystems/mass/flops_based/test/test_fuel_capacity.py @@ -124,7 +124,6 @@ def test_derivs(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=validation_data, output_validation_data=validation_data, input_keys=[ @@ -171,7 +170,6 @@ def test_basic(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=validation_data, output_validation_data=validation_data, input_keys=[Aircraft.Fuel.TOTAL_CAPACITY, Aircraft.Fuel.WING_FUEL_CAPACITY], @@ -211,7 +209,6 @@ def test_basic(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=validation_data, output_validation_data=validation_data, input_keys=[ @@ -257,7 +254,6 @@ def test_basic(self, case_name): do_validation_test( self, prob, - case_name, input_validation_data=validation_data, output_validation_data=validation_data, input_keys=[ From 0d4943ef392554284a5a31df421f19d96d7a7f7b Mon Sep 17 00:00:00 2001 From: jkirk5 Date: Thu, 5 Feb 2026 14:21:54 -0500 Subject: [PATCH 5/6] missed variable rename --- aviary/subsystems/test/test_gasp_based_premission.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/aviary/subsystems/test/test_gasp_based_premission.py b/aviary/subsystems/test/test_gasp_based_premission.py index 04b893f60c..9c6688efb1 100644 --- a/aviary/subsystems/test/test_gasp_based_premission.py +++ b/aviary/subsystems/test/test_gasp_based_premission.py @@ -87,7 +87,7 @@ def test_case1(self): assert_near_equal(self.prob[Aircraft.HorizontalTail.MASS], 2276.1316, tol) assert_near_equal(self.prob[Aircraft.VerticalTail.MASS], 2297.9697, tol) assert_near_equal(self.prob[Aircraft.Wing.HIGH_LIFT_MASS], 4740.1241, tol) - assert_near_equal(self.prob[Aircraft.Controls.TOTAL_MASS], 3819.3564, tol) + assert_near_equal(self.prob[Aircraft.Controls.MASS], 3819.3564, tol) assert_near_equal(self.prob[Aircraft.Wing.SURFACE_CONTROL_MASS], 3682.099, tol) assert_near_equal(prob[Aircraft.LandingGear.TOTAL_MASS], 7489.8343, tol) assert_near_equal(prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6366.3591, tol) From 96cf6ad374a9cff41d9ceb5f37a5c4bce4b07115 Mon Sep 17 00:00:00 2001 From: jkirk5 Date: Fri, 6 Feb 2026 15:37:19 -0500 Subject: [PATCH 6/6] more test updates --- .../two_dof/ode/test/test_accel_eom.py | 22 +- .../two_dof/ode/test/test_ascent_eom.py | 18 +- .../two_dof/ode/test/test_flight_eom.py | 69 +-- .../two_dof/ode/test/test_flight_path_eom.py | 56 +- .../two_dof/ode/test/test_groundroll_eom.py | 25 +- .../two_dof/ode/test/test_landing_eom.py | 70 +-- .../two_dof/ode/test/test_rotation_eom.py | 24 +- .../atmosphere/test/test_atmosphere.py | 233 ++++---- .../mass/gasp_based/test/test_fixed.py | 544 +++++++++--------- 9 files changed, 501 insertions(+), 560 deletions(-) diff --git a/aviary/mission/two_dof/ode/test/test_accel_eom.py b/aviary/mission/two_dof/ode/test/test_accel_eom.py index 5fdaef91db..35ee80b9a3 100644 --- a/aviary/mission/two_dof/ode/test/test_accel_eom.py +++ b/aviary/mission/two_dof/ode/test/test_accel_eom.py @@ -40,18 +40,16 @@ def test_case1(self): tol = 1e-6 self.prob.run_model() - assert_near_equal( - self.prob[Dynamic.Mission.VELOCITY_RATE], - np.array([5.51533958, 5.51533958]), - tol, - # note: this was finite differenced from GASP. The fd value is: np.array([5.2353365, 5.2353365]) - ) - assert_near_equal( - self.prob[Dynamic.Mission.DISTANCE_RATE], - np.array([425.32808399, 425.32808399]), - tol, - # note: this was finite differenced from GASP. The fd value is: np.array([441.6439, 441.6439]) - ) + # note: values were finite differenced from GASP + # fd values are: VELOCITY_RATE=[5.2353365, 5.2353365], DISTANCE_RATE=[441.6439, 441.6439] + expected_values = { + Dynamic.Mission.VELOCITY_RATE: np.array([5.51533958, 5.51533958]), + Dynamic.Mission.DISTANCE_RATE: np.array([425.32808399, 425.32808399]), + } + + for var_name, expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) diff --git a/aviary/mission/two_dof/ode/test/test_ascent_eom.py b/aviary/mission/two_dof/ode/test/test_ascent_eom.py index 8a290f83c9..8356fd0c30 100644 --- a/aviary/mission/two_dof/ode/test/test_ascent_eom.py +++ b/aviary/mission/two_dof/ode/test/test_ascent_eom.py @@ -39,16 +39,14 @@ def test_case1(self): tol = 1e-6 self.prob.run_model() - assert_near_equal( - self.prob[Dynamic.Mission.VELOCITY_RATE], - np.array([2.202965, 2.202965]), - tol, - ) - assert_near_equal( - self.prob[Dynamic.Mission.FLIGHT_PATH_ANGLE_RATE], - np.array([-3.216328, -3.216328]), - tol, - ) + expected_values = { + Dynamic.Mission.VELOCITY_RATE: np.array([2.202965, 2.202965]), + Dynamic.Mission.FLIGHT_PATH_ANGLE_RATE: np.array([-3.216328, -3.216328]), + } + + for var_name, expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) diff --git a/aviary/mission/two_dof/ode/test/test_flight_eom.py b/aviary/mission/two_dof/ode/test/test_flight_eom.py index 27e224231c..ffefe84660 100644 --- a/aviary/mission/two_dof/ode/test/test_flight_eom.py +++ b/aviary/mission/two_dof/ode/test/test_flight_eom.py @@ -40,28 +40,19 @@ def test_case1(self): tol = 1e-6 self.prob.run_model() - assert_near_equal( - self.prob[Dynamic.Mission.ALTITUDE_RATE], - np.array([-39.42713005, -39.42713005]), - tol, - ) # note: values from GASP are: np.array([-39.75, -39.75]) - assert_near_equal( - self.prob[Dynamic.Mission.DISTANCE_RATE], - np.array([773.70078935, 773.70078935]), - tol, - # note: these values are finite differenced and lose accuracy. Fd values are:np.array([964.4634921, 964.4634921]) - ) - assert_near_equal( - self.prob['required_lift'], - np.array([147444.41570307, 147444.41570307]), - tol, - # note: values from GASP are: np.array([146288.8, 146288.8]) (estimated based on GASP values) - ) - assert_near_equal( - self.prob[Dynamic.Mission.FLIGHT_PATH_ANGLE], - np.array([-0.0509151, -0.0509151]), - tol, - ) # note: values from GASP are: np.array([-.0513127, -.0513127]) + # note: some values from GASP differ slightly due to calculation method differences + # GASP values: ALTITUDE_RATE=[-39.75, -39.75], DISTANCE_RATE=[964.4634921, 964.4634921] (fd), + # required_lift=[146288.8, 146288.8], FLIGHT_PATH_ANGLE=[-.0513127, -.0513127] + expected_values = { + Dynamic.Mission.ALTITUDE_RATE: np.array([-39.42713005, -39.42713005]), + Dynamic.Mission.DISTANCE_RATE: np.array([773.70078935, 773.70078935]), + 'required_lift': np.array([147444.41570307, 147444.41570307]), + Dynamic.Mission.FLIGHT_PATH_ANGLE: np.array([-0.0509151, -0.0509151]), + } + + for var_name, expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) @@ -131,27 +122,19 @@ def test_case1(self): tol = 1e-6 self.prob.run_model() - assert_near_equal( - self.prob[Dynamic.Mission.ALTITUDE_RATE], - np.array([6.24116612, 6.24116612]), - tol, - ) # note: values from GASP are: np.array([5.9667, 5.9667]) - assert_near_equal( - self.prob[Dynamic.Mission.DISTANCE_RATE], - np.array([774.679584, 774.679584]), - tol, - # note: these values are finite differenced and lose accuracy. Fd values are: np.array([799.489, 799.489]) - ) - assert_near_equal( - self.prob['required_lift'], - np.array([162662.70954313, 162662.70954313]), - tol, - ) # note: values from GASP are: np.array([170316.2, 170316.2]) - assert_near_equal( - self.prob[Dynamic.Mission.FLIGHT_PATH_ANGLE], - np.array([0.00805627, 0.00805627]), - tol, - ) # note: values from GASP are:np.array([.0076794487, .0076794487]) + # note: some values from GASP differ slightly due to calculation method differences + # GASP values: ALTITUDE_RATE=[5.9667, 5.9667], DISTANCE_RATE=[799.489, 799.489] (fd), + # required_lift=[170316.2, 170316.2], FLIGHT_PATH_ANGLE=[.0076794487, .0076794487] + expected_values = { + Dynamic.Mission.ALTITUDE_RATE: np.array([6.24116612, 6.24116612]), + Dynamic.Mission.DISTANCE_RATE: np.array([774.679584, 774.679584]), + 'required_lift': np.array([162662.70954313, 162662.70954313]), + Dynamic.Mission.FLIGHT_PATH_ANGLE: np.array([0.00805627, 0.00805627]), + } + + for var_name, expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) diff --git a/aviary/mission/two_dof/ode/test/test_flight_path_eom.py b/aviary/mission/two_dof/ode/test/test_flight_path_eom.py index beb68da3b3..b48bf8a912 100644 --- a/aviary/mission/two_dof/ode/test/test_flight_path_eom.py +++ b/aviary/mission/two_dof/ode/test/test_flight_path_eom.py @@ -23,27 +23,19 @@ def test_case1(self): tol = 1e-6 self.prob.run_model() - assert_near_equal( - self.prob[Dynamic.Mission.VELOCITY_RATE], - np.array([-27.10027, -27.10027]), - tol, - ) - assert_near_equal( - self.prob[Dynamic.Mission.DISTANCE_RATE], np.array([0.5403023, 0.5403023]), tol - ) - assert_near_equal(self.prob['normal_force'], np.array([-0.0174524, -0.0174524]), tol) - assert_near_equal(self.prob['fuselage_pitch'], np.array([58.2958, 58.2958]), tol) - assert_near_equal(self.prob['load_factor'], np.array([1.883117, 1.883117]), tol) - assert_near_equal( - self.prob[Dynamic.Mission.ALTITUDE_RATE], - np.array([0.841471, 0.841471]), - tol, - ) - assert_near_equal( - self.prob[Dynamic.Mission.FLIGHT_PATH_ANGLE_RATE], - np.array([15.36423, 15.36423]), - tol, - ) + expected_values = { + Dynamic.Mission.VELOCITY_RATE: np.array([-27.10027, -27.10027]), + Dynamic.Mission.DISTANCE_RATE: np.array([0.5403023, 0.5403023]), + 'normal_force': np.array([-0.0174524, -0.0174524]), + 'fuselage_pitch': np.array([58.2958, 58.2958]), + 'load_factor': np.array([1.883117, 1.883117]), + Dynamic.Mission.ALTITUDE_RATE: np.array([0.841471, 0.841471]), + Dynamic.Mission.FLIGHT_PATH_ANGLE_RATE: np.array([15.36423, 15.36423]), + } + + for var_name, expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) @@ -56,17 +48,17 @@ def test_case2(self): tol = 1e-6 self.prob.run_model() - assert_near_equal( - self.prob[Dynamic.Mission.VELOCITY_RATE], - np.array([-27.09537, -27.09537]), - tol, - ) - assert_near_equal( - self.prob[Dynamic.Mission.DISTANCE_RATE], np.array([0.5403023, 0.5403023]), tol - ) - assert_near_equal(self.prob['normal_force'], np.array([-0.0, -0.0]), tol) - assert_near_equal(self.prob['fuselage_pitch'], np.array([57.29578, 57.29578]), tol) - assert_near_equal(self.prob['load_factor'], np.array([1.850816, 1.850816]), tol) + expected_values = { + Dynamic.Mission.VELOCITY_RATE: np.array([-27.09537, -27.09537]), + Dynamic.Mission.DISTANCE_RATE: np.array([0.5403023, 0.5403023]), + 'normal_force': np.array([-0.0, -0.0]), + 'fuselage_pitch': np.array([57.29578, 57.29578]), + 'load_factor': np.array([1.850816, 1.850816]), + } + + for var_name, expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) diff --git a/aviary/mission/two_dof/ode/test/test_groundroll_eom.py b/aviary/mission/two_dof/ode/test/test_groundroll_eom.py index f182934483..ebb90d2182 100644 --- a/aviary/mission/two_dof/ode/test/test_groundroll_eom.py +++ b/aviary/mission/two_dof/ode/test/test_groundroll_eom.py @@ -39,18 +39,19 @@ def test_case1(self): tol = 1e-6 self.prob.run_model() - assert_near_equal( - self.prob[Dynamic.Mission.VELOCITY_RATE], - np.array([1.5597, 1.5597]), - tol, - ) - assert_near_equal( - self.prob[Dynamic.Mission.FLIGHT_PATH_ANGLE_RATE], np.array([0.0, 0.0]), tol - ) - assert_near_equal(self.prob[Dynamic.Mission.ALTITUDE_RATE], np.array([0.0, 0.0]), tol) - assert_near_equal(self.prob[Dynamic.Mission.DISTANCE_RATE], np.array([10.0, 10.0]), tol) - assert_near_equal(self.prob['normal_force'], np.array([175200.0, 175200.0]), tol) - assert_near_equal(self.prob['fuselage_pitch'], np.array([0.0, 0.0]), tol) + expected_values = { + Dynamic.Mission.VELOCITY_RATE: np.array([1.5597, 1.5597]), + Dynamic.Mission.FLIGHT_PATH_ANGLE_RATE: np.array([0.0, 0.0]), + Dynamic.Mission.ALTITUDE_RATE: np.array([0.0, 0.0]), + Dynamic.Mission.DISTANCE_RATE: np.array([10.0, 10.0]), + 'normal_force': np.array([175200.0, 175200.0]), + 'fuselage_pitch': np.array([0.0, 0.0]), + } + + for var_name, expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected, tol) + partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) diff --git a/aviary/mission/two_dof/ode/test/test_landing_eom.py b/aviary/mission/two_dof/ode/test/test_landing_eom.py index 68f28316b6..128db965ce 100644 --- a/aviary/mission/two_dof/ode/test/test_landing_eom.py +++ b/aviary/mission/two_dof/ode/test/test_landing_eom.py @@ -68,36 +68,26 @@ def test_case1(self): tol = 1e-6 self.prob.run_model() - assert_near_equal( - self.prob.get_val(Mission.Landing.INITIAL_VELOCITY, units='kn'), 142.783, tol - ) # note: actual GASP value is: 142.74 - assert_near_equal( - self.prob.get_val(Mission.Landing.STALL_VELOCITY, units='kn'), 109.8331, tol - ) # note: EAS in GASP, although at this altitude they are nearly identical. actual GASP value is 109.73 - assert_near_equal( - self.prob.get_val('TAS_touchdown', units='kn'), 126.3081, tol - ) # note: actual GASP value is: 126.27 - assert_near_equal( - self.prob.get_val('density_ratio', units='unitless'), 1.0, tol - ) # note: calculated from GASP glide speed values as: .998739 - assert_near_equal( - self.prob.get_val('wing_loading_land', units='lbf/ft**2'), 120.61519375, tol - ) # note: actual GASP value is: 120.61 - assert_near_equal( - self.prob.get_val('theta', units='deg'), 3.56857, tol - ) # note: actual GASP value is: 3.57 - assert_near_equal( - self.prob.get_val('glide_distance', units='ft'), 801.7444, tol - ) # note: actual GASP value is: 802 - assert_near_equal( - self.prob.get_val('tr_distance', units='ft'), 166.5303, tol - ) # note: actual GASP value is: 167 - assert_near_equal( - self.prob.get_val('delay_distance', units='ft'), 213.184, tol - ) # note: actual GASP value is: 213 - assert_near_equal( - self.prob.get_val('flare_alt', units='ft'), 20.73407, tol - ) # note: actual GASP value is: 20.8 + # note: actual GASP values differ slightly + # GASP values: INITIAL_VELOCITY=142.74, STALL_VELOCITY=109.73, TAS_touchdown=126.27, + # density_ratio=.998739, wing_loading_land=120.61, theta=3.57, + # glide_distance=802, tr_distance=167, delay_distance=213, flare_alt=20.8 + expected_values = { + (Mission.Landing.INITIAL_VELOCITY, 'kn'): 142.783, + (Mission.Landing.STALL_VELOCITY, 'kn'): 109.8331, + ('TAS_touchdown', 'kn'): 126.3081, + ('density_ratio', 'unitless'): 1.0, + ('wing_loading_land', 'lbf/ft**2'): 120.61519375, + ('theta', 'deg'): 3.56857, + ('glide_distance', 'ft'): 801.7444, + ('tr_distance', 'ft'): 166.5303, + ('delay_distance', 'ft'): 213.184, + ('flare_alt', 'ft'): 20.73407, + } + + for (var_name, units), expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob.get_val(var_name, units=units), expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-10, rtol=1e-12) @@ -172,15 +162,17 @@ def test_case1(self): tol = 1e-6 self.prob.run_model() - assert_near_equal( - self.prob['ground_roll_distance'], 2406.43116212, tol - ) # actual GASP value is: 1798 - assert_near_equal( - self.prob[Mission.Landing.GROUND_DISTANCE], 3588.43116212, tol - ) # actual GASP value is: 2980 - assert_near_equal( - self.prob['average_acceleration'], 0.29308129, tol - ) # actual GASP value is: 0.3932 + # note: actual GASP values differ: ground_roll_distance=1798, GROUND_DISTANCE=2980, + # average_acceleration=0.3932 + expected_values = { + 'ground_roll_distance': 2406.43116212, + Mission.Landing.GROUND_DISTANCE: 3588.43116212, + 'average_acceleration': 0.29308129, + } + + for var_name, expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=5e-12, rtol=1e-12) diff --git a/aviary/mission/two_dof/ode/test/test_rotation_eom.py b/aviary/mission/two_dof/ode/test/test_rotation_eom.py index a4d6ff36df..0d68b85ca1 100644 --- a/aviary/mission/two_dof/ode/test/test_rotation_eom.py +++ b/aviary/mission/two_dof/ode/test/test_rotation_eom.py @@ -39,18 +39,18 @@ def test_case1(self): tol = 1e-6 self.prob.run_model() - assert_near_equal( - self.prob[Dynamic.Mission.VELOCITY_RATE], - np.array([1.5597, 1.5597]), - tol, - ) - assert_near_equal( - self.prob[Dynamic.Mission.FLIGHT_PATH_ANGLE_RATE], np.array([0.0, 0.0]), tol - ) - assert_near_equal(self.prob[Dynamic.Mission.ALTITUDE_RATE], np.array([0.0, 0.0]), tol) - assert_near_equal(self.prob[Dynamic.Mission.DISTANCE_RATE], np.array([10.0, 10.0]), tol) - assert_near_equal(self.prob['normal_force'], np.array([175200.0, 175200.0]), tol) - assert_near_equal(self.prob['fuselage_pitch'], np.array([0.0, 0.0]), tol) + expected_values = { + Dynamic.Mission.VELOCITY_RATE: np.array([1.5597, 1.5597]), + Dynamic.Mission.FLIGHT_PATH_ANGLE_RATE: np.array([0.0, 0.0]), + Dynamic.Mission.ALTITUDE_RATE: np.array([0.0, 0.0]), + Dynamic.Mission.DISTANCE_RATE: np.array([10.0, 10.0]), + 'normal_force': np.array([175200.0, 175200.0]), + 'fuselage_pitch': np.array([0.0, 0.0]), + } + + for var_name, expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) diff --git a/aviary/subsystems/atmosphere/test/test_atmosphere.py b/aviary/subsystems/atmosphere/test/test_atmosphere.py index 1c13edfb80..9cd524a96c 100644 --- a/aviary/subsystems/atmosphere/test/test_atmosphere.py +++ b/aviary/subsystems/atmosphere/test/test_atmosphere.py @@ -79,25 +79,17 @@ def test_geocentric(self): tol = 1e-4 self.prob.run_model() - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.TEMPERATURE, units='K'), expected_temp, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='Pa'), - expected_pressure, - tol, - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DENSITY, units='kg/m**3'), expected_density, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.SPEED_OF_SOUND, units='m/s'), expected_sos, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DYNAMIC_VISCOSITY, units='Pa*s'), - expected_viscosity, - tol, - ) + expected_values = { + (Dynamic.Atmosphere.TEMPERATURE, 'K'): expected_temp, + (Dynamic.Atmosphere.STATIC_PRESSURE, 'Pa'): expected_pressure, + (Dynamic.Atmosphere.DENSITY, 'kg/m**3'): expected_density, + (Dynamic.Atmosphere.SPEED_OF_SOUND, 'm/s'): expected_sos, + (Dynamic.Atmosphere.DYNAMIC_VISCOSITY, 'Pa*s'): expected_viscosity, + } + + for (var_name, units), expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob.get_val(var_name, units=units), expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') @@ -169,25 +161,17 @@ def test_geocentric_delta_T(self): 1.58179488e-05, ] # (Pa*s) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.TEMPERATURE, units='K'), expected_temp, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='Pa'), - expected_pressure, - tol, - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DENSITY, units='kg/m**3'), expected_density, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.SPEED_OF_SOUND, units='m/s'), expected_sos, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DYNAMIC_VISCOSITY, units='Pa*s'), - expected_viscosity, - tol, - ) + expected_values = { + (Dynamic.Atmosphere.TEMPERATURE, 'K'): expected_temp, + (Dynamic.Atmosphere.STATIC_PRESSURE, 'Pa'): expected_pressure, + (Dynamic.Atmosphere.DENSITY, 'kg/m**3'): expected_density, + (Dynamic.Atmosphere.SPEED_OF_SOUND, 'm/s'): expected_sos, + (Dynamic.Atmosphere.DYNAMIC_VISCOSITY, 'Pa*s'): expected_viscosity, + } + + for (var_name, units), expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob.get_val(var_name, units=units), expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') @@ -219,25 +203,17 @@ def test_geodetic(self): tol = 1e-4 self.prob.run_model() - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.TEMPERATURE, units='K'), expected_temp, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='Pa'), - expected_pressure, - tol, - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DENSITY, units='kg/m**3'), expected_density, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.SPEED_OF_SOUND, units='m/s'), expected_sos, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DYNAMIC_VISCOSITY, units='Pa*s'), - expected_viscosity, - tol, - ) + expected_values = { + (Dynamic.Atmosphere.TEMPERATURE, 'K'): expected_temp, + (Dynamic.Atmosphere.STATIC_PRESSURE, 'Pa'): expected_pressure, + (Dynamic.Atmosphere.DENSITY, 'kg/m**3'): expected_density, + (Dynamic.Atmosphere.SPEED_OF_SOUND, 'm/s'): expected_sos, + (Dynamic.Atmosphere.DYNAMIC_VISCOSITY, 'Pa*s'): expected_viscosity, + } + + for (var_name, units), expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob.get_val(var_name, units=units), expected, tol) partial_data = self.prob.check_partials(out_stream=None, method='cs') @@ -331,28 +307,25 @@ def test_case1(self): 1.31516893e-05, ] # (Pa*s) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.TEMPERATURE, units='degF'), expected_temp, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DENSITY, units='lbm/ft**3'), expected_density, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.SPEED_OF_SOUND, units='m/s'), expected_sos, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DYNAMIC_VISCOSITY, units='Pa*s'), - expected_viscosity, - tol, - ) + expected_values = { + (Dynamic.Atmosphere.TEMPERATURE, 'degF'): expected_temp, + (Dynamic.Atmosphere.DENSITY, 'lbm/ft**3'): expected_density, + (Dynamic.Atmosphere.SPEED_OF_SOUND, 'm/s'): expected_sos, + (Dynamic.Atmosphere.DYNAMIC_VISCOSITY, 'Pa*s'): expected_viscosity, + } + + for (var_name, units), expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob.get_val(var_name, units=units), expected, tol) # inHg60 is a newer unit in OpenMDAO so we'll do this check only of that newer version is installed if Version(openmdao.__version__) >= Version('3.42.0'): - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='inHg60'), - expected_pressure, - tol, - ) + with self.subTest(var=Dynamic.Atmosphere.STATIC_PRESSURE): + assert_near_equal( + self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='inHg60'), + expected_pressure, + tol, + ) partial_data = self.prob.check_partials(out_stream=None, method='cs') @@ -416,26 +389,24 @@ def test_case1(self): 1.53000203e-05, ] # (Pa*s) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.TEMPERATURE, units='degF'), expected_temp, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DENSITY, units='lbm/ft**3'), expected_density, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.SPEED_OF_SOUND, units='m/s'), expected_sos, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DYNAMIC_VISCOSITY, units='Pa*s'), - expected_viscosity, - tol, - ) + expected_values = { + (Dynamic.Atmosphere.TEMPERATURE, 'degF'): expected_temp, + (Dynamic.Atmosphere.DENSITY, 'lbm/ft**3'): expected_density, + (Dynamic.Atmosphere.SPEED_OF_SOUND, 'm/s'): expected_sos, + (Dynamic.Atmosphere.DYNAMIC_VISCOSITY, 'Pa*s'): expected_viscosity, + } + + for (var_name, units), expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob.get_val(var_name, units=units), expected, tol) + if Version(openmdao.__version__) >= Version('3.42.0'): - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='inHg60'), - expected_pressure, - tol, - ) + with self.subTest(var=Dynamic.Atmosphere.STATIC_PRESSURE): + assert_near_equal( + self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='inHg60'), + expected_pressure, + tol, + ) partial_data = self.prob.check_partials(out_stream=None, method='cs') @@ -499,26 +470,24 @@ def test_case1(self): 1.59359066e-05, ] # (Pa*s) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.TEMPERATURE, units='degF'), expected_temp, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DENSITY, units='lbm/ft**3'), expected_density, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.SPEED_OF_SOUND, units='m/s'), expected_sos, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DYNAMIC_VISCOSITY, units='Pa*s'), - expected_viscosity, - tol, - ) + expected_values = { + (Dynamic.Atmosphere.TEMPERATURE, 'degF'): expected_temp, + (Dynamic.Atmosphere.DENSITY, 'lbm/ft**3'): expected_density, + (Dynamic.Atmosphere.SPEED_OF_SOUND, 'm/s'): expected_sos, + (Dynamic.Atmosphere.DYNAMIC_VISCOSITY, 'Pa*s'): expected_viscosity, + } + + for (var_name, units), expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob.get_val(var_name, units=units), expected, tol) + if Version(openmdao.__version__) >= Version('3.42.0'): - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='inHg60'), - expected_pressure, - tol, - ) + with self.subTest(var=Dynamic.Atmosphere.STATIC_PRESSURE): + assert_near_equal( + self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='inHg60'), + expected_pressure, + tol, + ) partial_data = self.prob.check_partials(out_stream=None, method='cs') @@ -582,26 +551,24 @@ def test_case1(self): 1.38565730e-05, ] # (Pa*s) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.TEMPERATURE, units='degF'), expected_temp, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DENSITY, units='lbm/ft**3'), expected_density, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.SPEED_OF_SOUND, units='m/s'), expected_sos, tol - ) - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.DYNAMIC_VISCOSITY, units='Pa*s'), - expected_viscosity, - tol, - ) + expected_values = { + (Dynamic.Atmosphere.TEMPERATURE, 'degF'): expected_temp, + (Dynamic.Atmosphere.DENSITY, 'lbm/ft**3'): expected_density, + (Dynamic.Atmosphere.SPEED_OF_SOUND, 'm/s'): expected_sos, + (Dynamic.Atmosphere.DYNAMIC_VISCOSITY, 'Pa*s'): expected_viscosity, + } + + for (var_name, units), expected in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob.get_val(var_name, units=units), expected, tol) + if Version(openmdao.__version__) >= Version('3.42.0'): - assert_near_equal( - self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='inHg60'), - expected_pressure, - tol, - ) + with self.subTest(var=Dynamic.Atmosphere.STATIC_PRESSURE): + assert_near_equal( + self.prob.get_val(Dynamic.Atmosphere.STATIC_PRESSURE, units='inHg60'), + expected_pressure, + tol, + ) partial_data = self.prob.check_partials(out_stream=None, method='cs') diff --git a/aviary/subsystems/mass/gasp_based/test/test_fixed.py b/aviary/subsystems/mass/gasp_based/test/test_fixed.py index 5888f8bb5a..03d9674904 100644 --- a/aviary/subsystems/mass/gasp_based/test/test_fixed.py +++ b/aviary/subsystems/mass/gasp_based/test/test_fixed.py @@ -379,12 +379,17 @@ def setUp(self): def test_case1(self): self.prob.run_model() - assert_near_equal( - self.prob['aug_mass'], 9394.3, 0.0017 - ) # electrified diff configuration value v3.6. Higher tol because num_wires is discrete in GASP and is not in Aviary + expected_values = { + 'aug_mass': 9394.3, # electrified diff configuration value v3.6. Higher tol because num_wires is discrete in GASP and is not in Aviary + } + tol = 0.0017 - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=4e-12, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=4e-12, rtol=1e-12) @use_tempdirs @@ -439,25 +444,21 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 12606.0, + Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS: 3785.0, + Aircraft.Engine.ADDITIONAL_MASS: 1765.0 / 2, + 'eng_comb_mass': 14370.8, + 'wing_mounted_mass': 24446.343040697346, + } tol = 5e-4 - assert_near_equal( - self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 12606.0, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob[Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS], 3785.0, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob[Aircraft.Engine.ADDITIONAL_MASS], 1765.0 / 2, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['eng_comb_mass'], 14370.8, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['wing_mounted_mass'], 24446.343040697346, tol - ) # bug fixed value and original value - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=2e-11, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=2e-11, rtol=1e-12) @use_tempdirs @@ -518,28 +519,22 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 12606.0, + Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS: 3785.0, + Aircraft.Engine.ADDITIONAL_MASS: 1765.0 / 2, + 'eng_comb_mass': 14370.8, + 'prop_mass_all': 0, + 'wing_mounted_mass': 24446.343040697346, + } tol = 5e-4 - assert_near_equal( - self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 12606.0, tol - ) # note: these are only the right values because this was given a prop mass of zero. This is not a large single aisle test case - assert_near_equal( - self.prob[Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS], 3785.0, tol - ) # note: these are only the right values because this was given a prop mass of zero. This is not a large single aisle test case - assert_near_equal( - self.prob[Aircraft.Engine.ADDITIONAL_MASS], 1765.0 / 2, tol - ) # note: these are only the right values because this was given a prop mass of zero. This is not a large single aisle test case - assert_near_equal( - self.prob['eng_comb_mass'], 14370.8, tol - ) # note: these are only the right values because this was given a prop mass of zero. This is not a large single aisle test case - assert_near_equal( - self.prob['prop_mass_all'], 0, tol - ) # note: these are only the right values because this was given a prop mass of zero. This is not a large single aisle test case - assert_near_equal( - self.prob['wing_mounted_mass'], 24446.343040697346, tol - ) # note: these are only the right values because this was given a prop mass of zero. This is not a large single aisle test case - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=2e-11, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=2e-11, rtol=1e-12) # arbitrary test case with multiple engine types @@ -598,24 +593,20 @@ def test_case_1(self): self.prob.run_model() tol = 5e-4 - assert_near_equal( - self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 23405.94, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob[Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS], 8074.09809932, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob[Aircraft.Engine.ADDITIONAL_MASS], [882.4158, 513.0], tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['eng_comb_mass'], 26142.7716, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['wing_mounted_mass'], 41417.49593562, tol - ) # bug fixed value and original value + expected_values = { + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 23405.94, + Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS: 8074.09809932, + Aircraft.Engine.ADDITIONAL_MASS: [882.4158, 513.0], + 'eng_comb_mass': 26142.7716, + 'wing_mounted_mass': 41417.49593562, + } - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=1e-8, rtol=1e-8) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=1e-8, rtol=1e-8) @use_tempdirs @@ -696,14 +687,19 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + 'loc_MAC_vtail': 0.44959578484694906, + Aircraft.HorizontalTail.MASS: 2285, + Aircraft.VerticalTail.MASS: 2312, + } tol = 5e-4 - assert_near_equal(self.prob['loc_MAC_vtail'], 0.44959578484694906, tol) # bug fixed value - # bug fixed value - assert_near_equal(self.prob[Aircraft.HorizontalTail.MASS], 2285, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.MASS], 2312, tol) # bug fixed value - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=1e-11, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=1e-11, rtol=1e-12) # this is a different configuration with turbofan_23k_1 test case @@ -752,14 +748,17 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.Wing.HIGH_LIFT_MASS: 4829.6, + } tol = 5e-4 - # bug fixed value - assert_near_equal(self.prob[Aircraft.Wing.HIGH_LIFT_MASS], 4829.6, tol) - partial_data = self.prob.check_partials( - out_stream=None, method='cs', show_only_incorrect=True - ) - assert_check_partials(partial_data, atol=5e-10, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs', show_only_incorrect=True) + assert_check_partials(data, atol=5e-10, rtol=1e-12) # this is the large single aisle 1 V3 test case @@ -808,12 +807,17 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.Controls.MASS: 3945, + } tol = 5e-4 - # bug fixed value - assert_near_equal(self.prob[Aircraft.Controls.MASS], 3945, tol) - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=1e-11, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=1e-11, rtol=1e-12) @use_tempdirs @@ -850,16 +854,18 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.LandingGear.TOTAL_MASS: 7511, + Aircraft.LandingGear.MAIN_GEAR_MASS: 6384.35, + } tol = 5e-4 - assert_near_equal( - self.prob[Aircraft.LandingGear.TOTAL_MASS], 7511, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6384.35, tol - ) # bug fixed value and original value - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=3e-11, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=3e-11, rtol=1e-12) @use_tempdirs @@ -889,16 +895,18 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.LandingGear.TOTAL_MASS: 7016, + Aircraft.LandingGear.MAIN_GEAR_MASS: 5963.6, + } tol = 5e-4 - assert_near_equal( - self.prob[Aircraft.LandingGear.TOTAL_MASS], 7016, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 5963.6, tol - ) # not actual GASP value - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=1e-12, rtol=1e-12) @use_tempdirs @@ -934,12 +942,16 @@ def test_case1(self): self.prob.run_model() tol = 5e-4 - assert_near_equal( - self.prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 5614.3311546, tol - ) # bug fixed value and original value + expected_values = { + Aircraft.LandingGear.MAIN_GEAR_MASS: 5614.3311546, + } - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=1e-10, rtol=1e-10) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=1e-10, rtol=1e-10) # this is the large single aisle 1 V3 test case @@ -1135,65 +1147,36 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.LandingGear.MAIN_GEAR_MASS: 6384.35, + Aircraft.Wing.MATERIAL_FACTOR: 1.2203729275531838, + 'c_strut_braced': 1, + 'c_gear_loc': 1, + Aircraft.Engine.POSITION_FACTOR: 0.95, + 'half_sweep': 0.3947081519145335, + Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS: 36000, + 'payload_mass_des': 36000, + 'payload_mass_max': 46040, + 'loc_MAC_vtail': 0.44959578484694906, + Aircraft.HorizontalTail.MASS: 2285, + Aircraft.VerticalTail.MASS: 2312, + Aircraft.Wing.HIGH_LIFT_MASS: 4082.1, + Aircraft.Controls.MASS: 3945, + Aircraft.LandingGear.TOTAL_MASS: 7511, + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 12606, + Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS: 3785, + Aircraft.Engine.ADDITIONAL_MASS: 1765 / 2, + 'eng_comb_mass': 14370.8, + 'wing_mounted_mass': 24446.343040697346, + } tol = 5e-4 - assert_near_equal( - self.prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6384.35, tol - ) # bug fixed value and original value - - assert_near_equal( - self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.2203729275531838, tol - ) # bug fixed value - assert_near_equal(self.prob['c_strut_braced'], 1, tol) # bug fixed value and original value - assert_near_equal(self.prob['c_gear_loc'], 1, tol) # bug fixed value and original value - assert_near_equal( - self.prob[Aircraft.Engine.POSITION_FACTOR], 0.95, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['half_sweep'], 0.3947081519145335, tol - ) # bug fixed value and original value - - assert_near_equal( - self.prob[Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS], 36000, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['payload_mass_des'], 36000, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['payload_mass_max'], 46040, tol - ) # bug fixed value and original value - assert_near_equal(self.prob['loc_MAC_vtail'], 0.44959578484694906, tol) # bug fixed value - # bug fixed value - assert_near_equal(self.prob[Aircraft.HorizontalTail.MASS], 2285, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.MASS], 2312, tol) # bug fixed value - # bug fixed value - assert_near_equal(self.prob[Aircraft.Wing.HIGH_LIFT_MASS], 4082.1, tol) - - # bug fixed value - assert_near_equal(self.prob[Aircraft.Controls.MASS], 3945, tol) - - assert_near_equal( - self.prob[Aircraft.LandingGear.TOTAL_MASS], 7511, tol - ) # bug fixed value and original value - - assert_near_equal( - self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 12606, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob[Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS], 3785, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob[Aircraft.Engine.ADDITIONAL_MASS], 1765 / 2, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['eng_comb_mass'], 14370.8, tol - ) # bug fixed value and original value - assert_near_equal( - self.prob['wing_mounted_mass'], 24446.343040697346, tol - ) # bug fixed value and original value + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=3e-11, rtol=1e-12) + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=3e-11, rtol=1e-12) @use_tempdirs @@ -1444,60 +1427,42 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.LandingGear.MAIN_GEAR_MASS: 5963.6, + 'aug_mass': 228.51036478, + Aircraft.Wing.MATERIAL_FACTOR: 1.2213063198183813, + 'c_strut_braced': 0.9928, + 'c_gear_loc': 1, + Aircraft.Engine.POSITION_FACTOR: 1, + 'half_sweep': 0.3947081519145335, + Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS: 36000, + 'payload_mass_des': 36000, + 'payload_mass_max': 46040, + 'loc_MAC_vtail': 1.799, + Aircraft.HorizontalTail.MASS: 2275, + Aircraft.VerticalTail.MASS: 2297, + Aircraft.Wing.HIGH_LIFT_MASS: 4162.1, + Aircraft.Controls.MASS: 3895, + Aircraft.LandingGear.TOTAL_MASS: 7016, + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 12606, + Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS: 3785, + Aircraft.Engine.ADDITIONAL_MASS: 1765 / 2, + 'eng_comb_mass': 14599.28196478, + 'wing_mounted_mass': 24027.6, + 'prop_mass_all': 0, + } tol = 5e-4 - assert_near_equal( - self.prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 5963.6, tol - ) # not actual GASP value - assert_near_equal(self.prob['aug_mass'], 228.51036478, tol) # not actual GASP value - - assert_near_equal(self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.2213063198183813, tol) - assert_near_equal(self.prob['c_strut_braced'], 0.9928, tol) # not actual GASP value - assert_near_equal(self.prob['c_gear_loc'], 1, tol) # not actual GASP value - # not actual GASP value - assert_near_equal(self.prob[Aircraft.Engine.POSITION_FACTOR], 1, tol) - assert_near_equal( - self.prob['half_sweep'], 0.3947081519145335, tol - ) # bug fixed and original value - - assert_near_equal( - self.prob[Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS], 36000, tol - ) # bug fixed and original value - assert_near_equal(self.prob['payload_mass_des'], 36000, tol) # bug fixed and original value - assert_near_equal(self.prob['payload_mass_max'], 46040, tol) # bug fixed and original value - - assert_near_equal(self.prob['loc_MAC_vtail'], 1.799, tol) # not actual GASP value - # original GASP value - assert_near_equal(self.prob[Aircraft.HorizontalTail.MASS], 2275, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.MASS], 2297, tol) # original GASP value - # original GASP value - assert_near_equal(self.prob[Aircraft.Wing.HIGH_LIFT_MASS], 4162.1, tol) - - # original GASP value - assert_near_equal(self.prob[Aircraft.Controls.MASS], 3895, tol) - - assert_near_equal( - self.prob[Aircraft.LandingGear.TOTAL_MASS], 7016, tol - ) # not actual GASP value - assert_near_equal( - self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 12606, tol - ) # bug fixed and original value - assert_near_equal( - self.prob[Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS], 3785, tol - ) # bug fixed and original value - assert_near_equal( - self.prob[Aircraft.Engine.ADDITIONAL_MASS], 1765 / 2, tol - ) # bug fixed and original value - assert_near_equal(self.prob['eng_comb_mass'], 14599.28196478, tol) # not actual GASP value - assert_near_equal(self.prob['wing_mounted_mass'], 24027.6, tol) # not actual GASP value - assert_near_equal(self.prob['prop_mass_all'], 0, tol) # bug fixed and original value - - partial_data = self.prob.check_partials( + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials( out_stream=None, method='cs', form='central', ) - assert_check_partials(partial_data, atol=3e-10, rtol=1e-12) + assert_check_partials(data, atol=3e-10, rtol=1e-12) @use_tempdirs @@ -1691,15 +1656,21 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.Wing.MATERIAL_FACTOR: 1.19461189, + 'c_strut_braced': 1, + 'c_gear_loc': 0.95, + Aircraft.Engine.POSITION_FACTOR: 1.05, + 'half_sweep': 0.47984874, + } tol = 1e-7 - assert_near_equal(self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.19461189, tol) - assert_near_equal(self.prob['c_strut_braced'], 1, tol) - assert_near_equal(self.prob['c_gear_loc'], 0.95, tol) - assert_near_equal(self.prob[Aircraft.Engine.POSITION_FACTOR], 1.05, tol) - assert_near_equal(self.prob['half_sweep'], 0.47984874, tol) - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=1e-12, rtol=1e-12) class BWBPayloadGroupTestCase(unittest.TestCase): @@ -1725,14 +1696,20 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS: 33750.0, + Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS: 33750.0, + 'payload_mass_des': 33750.0, + 'payload_mass_max': 48750.0, + } tol = 1e-7 - assert_near_equal(self.prob[Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS], 33750.0, tol) - assert_near_equal(self.prob[Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS], 33750.0, tol) - assert_near_equal(self.prob['payload_mass_des'], 33750.0, tol) - assert_near_equal(self.prob['payload_mass_max'], 48750.0, tol) - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=1e-12, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=1e-12, rtol=1e-12) class BWBEngineTestCase(unittest.TestCase): @@ -1770,17 +1747,23 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 7005.15475443, + Aircraft.Nacelle.MASS: 487.39296691, + 'pylon_mass': 558.757916785, + Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS: 2092.30176475, + Aircraft.Engine.ADDITIONAL_MASS: 153.16770871, + 'eng_comb_mass': 7311.49017184, + 'wing_mounted_mass': 0, + } tol = 1e-7 - assert_near_equal(self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 7005.15475443, tol) - assert_near_equal(self.prob[Aircraft.Nacelle.MASS], 487.39296691, tol) - assert_near_equal(self.prob['pylon_mass'], 558.757916785, tol) - assert_near_equal(self.prob[Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS], 2092.30176475, tol) - assert_near_equal(self.prob[Aircraft.Engine.ADDITIONAL_MASS], 153.16770871, tol) - assert_near_equal(self.prob['eng_comb_mass'], 7311.49017184, tol) - assert_near_equal(self.prob['wing_mounted_mass'], 0, tol) - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=2e-9, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=2e-9, rtol=1e-12) class BWBTailTestCase(unittest.TestCase): @@ -1830,13 +1813,19 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + 'loc_MAC_vtail': 0.97683077, + Aircraft.HorizontalTail.MASS: 1.02401953, + Aircraft.VerticalTail.MASS: 864.17404177, + } tol = 1e-7 - assert_near_equal(self.prob['loc_MAC_vtail'], 0.97683077, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.MASS], 1.02401953, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.MASS], 864.17404177, tol) - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=1e-11, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=1e-11, rtol=1e-12) class BWBHighLiftTestCase(unittest.TestCase): @@ -1876,16 +1865,19 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.Wing.HIGH_LIFT_MASS: 1068.88854499, + 'flap_mass': 1068.46572125, + 'slat_mass': 0.42282374, + } tol = 1e-7 - assert_near_equal(self.prob[Aircraft.Wing.HIGH_LIFT_MASS], 1068.88854499, tol) - assert_near_equal(self.prob['flap_mass'], 1068.46572125, tol) # WFLAP = 997.949249689 - assert_near_equal(self.prob['slat_mass'], 0.42282374, tol) # WLED + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) - partial_data = self.prob.check_partials( - out_stream=None, method='cs', show_only_incorrect=True - ) - assert_check_partials(partial_data, atol=5e-10, rtol=1e-12) + data = self.prob.check_partials(out_stream=None, method='cs', show_only_incorrect=True) + assert_check_partials(data, atol=5e-10, rtol=1e-12) @use_tempdirs @@ -1927,12 +1919,18 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.Wing.SURFACE_CONTROL_MASS: 2045.5556421, + Aircraft.Controls.MASS: 2174.28611375, + } tol = 1e-7 - assert_near_equal(self.prob[Aircraft.Wing.SURFACE_CONTROL_MASS], 2045.5556421, tol) - assert_near_equal(self.prob[Aircraft.Controls.MASS], 2174.28611375, tol) - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=1e-11, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=1e-11, rtol=1e-12) class BWBGearTestCase(unittest.TestCase): @@ -1964,12 +1962,18 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.LandingGear.TOTAL_MASS: 7800.0, + Aircraft.LandingGear.MAIN_GEAR_MASS: 6630.0, + } tol = 1e-7 - assert_near_equal(self.prob[Aircraft.LandingGear.TOTAL_MASS], 7800.0, tol) - assert_near_equal(self.prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6630.0, tol) - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=3e-11, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=3e-11, rtol=1e-12) class BWBFixedMassGroupTestCase1(unittest.TestCase): @@ -2098,33 +2102,39 @@ def setUp(self): def test_case1(self): self.prob.run_model() + expected_values = { + Aircraft.LandingGear.TOTAL_MASS: 7800.0, + Aircraft.LandingGear.MAIN_GEAR_MASS: 6630.0, + Aircraft.Wing.MATERIAL_FACTOR: 1.19461189, + 'c_strut_braced': 1, + 'c_gear_loc': 0.95, + Aircraft.Engine.POSITION_FACTOR: 0.95, + 'half_sweep': 0.47984874, + Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS: 33750.0, + 'payload_mass_des': 33750, + 'payload_mass_max': 48750, + 'loc_MAC_vtail': 0.97683077, + Aircraft.HorizontalTail.MASS: 1.02401953, + Aircraft.VerticalTail.MASS: 864.17404177, + Aircraft.Wing.HIGH_LIFT_MASS: 1068.88854499, + Aircraft.Controls.MASS: 2114.98158947, + Aircraft.Propulsion.TOTAL_ENGINE_MASS: 7005.15475443, + Aircraft.Nacelle.MASS: 549.8807447, + Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS: 2230.13208284, + Aircraft.Engine.ADDITIONAL_MASS: 153.16770871, + 'pylon_mass': 565.18529673, + 'eng_comb_mass': 7311.49017184, + 'wing_mounted_mass': 0.0, + Aircraft.Wing.SURFACE_CONTROL_MASS: 1986.25111783, + } tol = 1e-7 - assert_near_equal(self.prob[Aircraft.LandingGear.TOTAL_MASS], 7800.0, tol) - assert_near_equal(self.prob[Aircraft.LandingGear.MAIN_GEAR_MASS], 6630.0, tol) - assert_near_equal(self.prob[Aircraft.Wing.MATERIAL_FACTOR], 1.19461189, tol) - assert_near_equal(self.prob['c_strut_braced'], 1, tol) - assert_near_equal(self.prob['c_gear_loc'], 0.95, tol) - assert_near_equal(self.prob[Aircraft.Engine.POSITION_FACTOR], 0.95, tol) - assert_near_equal(self.prob['half_sweep'], 0.47984874, tol) - assert_near_equal(self.prob[Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS], 33750.0, tol) - assert_near_equal(self.prob['payload_mass_des'], 33750, tol) - assert_near_equal(self.prob['payload_mass_max'], 48750, tol) - assert_near_equal(self.prob['loc_MAC_vtail'], 0.97683077, tol) - assert_near_equal(self.prob[Aircraft.HorizontalTail.MASS], 1.02401953, tol) - assert_near_equal(self.prob[Aircraft.VerticalTail.MASS], 864.17404177, tol) - assert_near_equal(self.prob[Aircraft.Wing.HIGH_LIFT_MASS], 1068.88854499, tol) - assert_near_equal(self.prob[Aircraft.Controls.MASS], 2114.98158947, tol) - assert_near_equal(self.prob[Aircraft.Propulsion.TOTAL_ENGINE_MASS], 7005.15475443, tol) - assert_near_equal(self.prob[Aircraft.Nacelle.MASS], 549.8807447, tol) - assert_near_equal(self.prob[Aircraft.Propulsion.TOTAL_ENGINE_POD_MASS], 2230.13208284, tol) - assert_near_equal(self.prob[Aircraft.Engine.ADDITIONAL_MASS], 153.16770871, tol) - assert_near_equal(self.prob['pylon_mass'], 565.18529673, tol) - assert_near_equal(self.prob['eng_comb_mass'], 7311.49017184, tol) - assert_near_equal(self.prob['wing_mounted_mass'], 0.0, tol) - assert_near_equal(self.prob[Aircraft.Wing.SURFACE_CONTROL_MASS], 1986.25111783, tol) - partial_data = self.prob.check_partials(out_stream=None, method='cs') - assert_check_partials(partial_data, atol=2e-9, rtol=1e-12) + for var_name, expected_val in expected_values.items(): + with self.subTest(var=var_name): + assert_near_equal(self.prob[var_name], expected_val, tol) + + data = self.prob.check_partials(out_stream=None, method='cs') + assert_check_partials(data, atol=2e-9, rtol=1e-12) if __name__ == '__main__':