def test_simple_integration(self):
p = Problem(model=Group())
p.model = Group()
time_options = TimeOptionsDictionary()
time_options['units'] = 's'
time_options['targets'] = 't'
state_options = {}
state_options['y'] = StateOptionsDictionary()
state_options['y']['units'] = 'm'
state_options['y']['targets'] = 'y'
state_options['y']['rate_source'] = 'ydot'
gd = GridData(num_segments=4, transcription='gauss-lobatto', transcription_order=3)
seg0_comp = SegmentSimulationComp(index=0, grid_data=gd, method='RK45',
atol=1.0E-9, rtol=1.0E-9,
ode_class=TestODE, time_options=time_options,
state_options=state_options)
p.model.add_subsystem('segment_0', subsys=seg0_comp)
p.setup(check=True)
p.set_val('segment_0.time', [0, 0.25, 0.5])
p.set_val('segment_0.initial_states:y', 0.5)
p.run_model()
assert_rel_error(self,
p.get_val('segment_0.states:y', units='m')[-1, ...],
1.425639364649936,
tolerance=1.0E-6)
def test_varying_bypass(self):
nn = 4
p = Problem()
p.model = HeatPumpWithIntegratedCoolantLoop(num_nodes=nn)
p.model.set_input_defaults('power_rating', val=1., units='kW')
p.model.linear_solver = DirectSolver()
p.model.nonlinear_solver = NewtonSolver()
p.model.nonlinear_solver.options['solve_subsystems'] = True
p.setup()
p.set_val('T_in_hot', 350., units='K')
p.set_val('T_in_cold', 300., units='K')
p.set_val('mdot_coolant', 1., units='kg/s')
p.set_val('control.bypass_start', 0.)
p.set_val('control.bypass_end', 1.)
p.run_model()
assert_near_equal(
p.get_val('T_out_hot', units='K'),
np.array([350.87503524, 333.91669016, 316.95834508, 300.]),
tolerance=1e-10)
assert_near_equal(
p.get_val('T_out_cold', units='K'),
np.array([299.38805342, 316.25870228, 333.12935114, 350.]),
tolerance=1e-10)
assert_near_equal(p.get_val('component_weight', units='kg'),
np.array([5.]),
tolerance=1e-10)
assert_near_equal(p.get_val('elec_load', units='W'),
np.array(
[1052.63157895, 701.75438596, 350.87719298, 0.]),
tolerance=1e-10)
def test_serial_multi_src_inds_units_setval_promoted(self):
p = Problem()
indep = p.model.add_subsystem('indep', IndepVarComp(), promotes=['x'])
indep.add_output('x', units='inch', val=np.ones(10))
p.model.add_subsystem('C1', ExecComp('y=x*2.',
x={'val': np.zeros(7),
'units': 'ft'},
y={'val': np.zeros(7), 'units': 'ft'}))
p.model.add_subsystem('C2', ExecComp('y=x*3.',
x={'val': np.zeros(3),
'units': 'inch'},
y={'val': np.zeros(3), 'units': 'inch'}))
p.model.promotes('C1', inputs=['x'], src_indices=list(range(7)))
p.model.promotes('C2', inputs=['x'], src_indices=list(range(7, 10)))
p.setup()
p.set_val('C1.x', np.ones(7) * 24., units='inch')
p.set_val('C2.x', np.ones(3) * 3., units='inch')
p.run_model()
np.testing.assert_allclose(p['indep.x'][:7], np.ones(7) * 24.)
np.testing.assert_allclose(p['indep.x'][7:10], np.ones(3) * 3.)
np.testing.assert_allclose(p['C1.x'], np.ones(7) * 2.)
np.testing.assert_allclose(p['C1.y'], np.ones(7) * 4.)
np.testing.assert_allclose(p['C2.x'], np.ones(3) * 3.)
np.testing.assert_allclose(p['C2.y'], np.ones(3) * 9.)
def test_no_bypass(self):
# Set up the heat pump problem with 11 evaluation points
nn = 4
p = Problem()
p.model = HeatPumpWithIntegratedCoolantLoop(num_nodes=nn)
p.model.set_input_defaults('power_rating', val=1., units='kW')
p.model.linear_solver = DirectSolver()
p.model.nonlinear_solver = NewtonSolver()
p.model.nonlinear_solver.options['solve_subsystems'] = True
p.setup()
p.set_val('T_in_hot', 350., units='K')
p.set_val('T_in_cold', 300., units='K')
p.set_val('mdot_coolant', 1., units='kg/s')
p.set_val('control.bypass_start', 0.)
p.set_val('control.bypass_end', 0.)
p.run_model()
assert_near_equal(p.get_val('T_out_hot', units='K'),
350.87503524 * np.ones(nn),
tolerance=1e-10)
assert_near_equal(p.get_val('T_out_cold', units='K'),
299.38805342 * np.ones(nn),
tolerance=1e-10)
assert_near_equal(p.get_val('component_weight', units='kg'),
np.array([5.]),
tolerance=1e-10)
assert_near_equal(p.get_val('elec_load', units='W'),
1052.63157895 * np.ones(nn),
tolerance=1e-10)
def make_problem(self,
transcription=GaussLobatto,
optimizer='SLSQP',
numseg=30):
p = Problem(model=Group())
p.driver = pyOptSparseDriver()
p.driver.declare_coloring()
p.driver.options['optimizer'] = optimizer
if optimizer == 'SNOPT':
p.driver.declare_coloring()
p.driver.opt_settings['Major iterations limit'] = 100
p.driver.opt_settings['Major feasibility tolerance'] = 1.0E-6
p.driver.opt_settings['Major optimality tolerance'] = 1.0E-6
elif optimizer == 'IPOPT':
p.driver.opt_settings['hessian_approximation'] = 'limited-memory'
# p.driver.opt_settings['nlp_scaling_method'] = 'user-scaling'
p.driver.opt_settings['print_level'] = 5
p.driver.opt_settings['linear_solver'] = 'mumps'
p.driver.declare_coloring()
else:
p.driver.declare_coloring()
traj = p.model.add_subsystem('traj', Trajectory())
phase0 = traj.add_phase(
'phase0',
Phase(ode_class=HyperSensitiveODE,
transcription=transcription(num_segments=numseg, order=3)))
phase0.set_time_options(fix_initial=True, fix_duration=True)
phase0.add_state('x',
fix_initial=True,
fix_final=False,
rate_source='x_dot',
targets=['x'])
phase0.add_state('xL',
fix_initial=True,
fix_final=False,
rate_source='L',
targets=['xL'])
phase0.add_control('u', opt=True, targets=['u'])
phase0.add_boundary_constraint('x', loc='final', equals=1)
phase0.add_objective('xL', loc='final')
phase0.set_refine_options(refine=True, tol=1e-6, max_order=14)
p.setup(check=True)
p.set_val('traj.phase0.states:x',
phase0.interpolate(ys=[1.5, 1], nodes='state_input'))
p.set_val('traj.phase0.states:xL',
phase0.interpolate(ys=[0, 1], nodes='state_input'))
p.set_val('traj.phase0.t_initial', 0)
p.set_val('traj.phase0.t_duration', tf)
p.set_val('traj.phase0.controls:u',
phase0.interpolate(ys=[-0.6, 2.4], nodes='control_input'))
return p
def test_one_input(self):
p = Problem()
p.model.add_subsystem('test', MinComp(), promotes=['*'])
p.setup(check=True, force_alloc_complex=True)
p.set_val('array', np.array([42.]))
p.run_model()
assert_near_equal(p['min'], 42.)
partials = p.check_partials(method='cs',compact_print=True)
assert_check_partials(partials)
def test_multiple_inputs(self):
nn = 5
p = Problem()
p.model.add_subsystem('test', MinComp(num_nodes=nn), promotes=['*'])
p.setup(check=True, force_alloc_complex=True)
p.set_val('array', np.array([42., 12., -3., 58., 7.]))
p.run_model()
assert_near_equal(p['min'], -3.)
partials = p.check_partials(method='cs',compact_print=True)
assert_check_partials(partials)
def test_units(self):
nn = 5
p = Problem()
p.model.add_subsystem('max_comp', MaxComp(num_nodes=nn, units='N'), promotes=['*'])
p.setup(check=True, force_alloc_complex=True)
p.set_val('array', np.array([42., 58., -3., 3., 7.]), units='N')
p.run_model()
assert_near_equal(p['max'], 58.)
partials = p.check_partials(method='cs',compact_print=True)
assert_check_partials(partials)
def test_multiple_very_close_max(self):
nn = 5
p = Problem()
p.model.add_subsystem('test', MaxComp(num_nodes=nn), promotes=['*'])
p.setup(check=True, force_alloc_complex=True)
p.set_val('array', np.array([-2., 2e-45, -3., 1e-45, -7.]))
p.run_model()
assert_near_equal(p['max'], 2e-45, tolerance=1e-50)
partials = p.check_partials(method='cs',compact_print=True)
assert_check_partials(partials)
def test_multiple_min(self):
nn = 5
p = Problem(MinComp(num_nodes=nn))
p.setup(check=True, force_alloc_complex=True)
p.set_val('array', np.array([42., 7., 30., 58., 7.]))
p.run_model()
assert_near_equal(p['min'], 7.)
# Need to use fd here because cs doesn't support backward and forward does
# not capture behavior of minimum
partials = p.check_partials(method='fd',form='backward',compact_print=True)
assert_check_partials(partials)
def test_single(self):
p = Problem()
p.model.linear_solver = DirectSolver()
p.model = COPExplicit()
p.setup()
p.set_val('T_c', 300. * np.ones(1), units='K')
p.set_val('T_h', 400. * np.ones(1), units='K')
p.set_val('eff_factor', 0.4)
p.run_model()
assert_near_equal(p.get_val('COP'),
np.array([1.20001629]),
tolerance=1e-8)
def test_single(self):
p = Problem()
p.model.linear_solver = DirectSolver()
p.model = HeatPumpWeight()
p.setup(force_alloc_complex=True)
p.set_val('power_rating', 1., units='kW')
p.set_val('specific_power', 200., units='W/kg')
p.run_model()
assert_near_equal(p.get_val('component_weight', units='kg'),
np.array([5.]))
partials = p.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def test_single(self):
p = Problem()
p.model.linear_solver = DirectSolver()
p.model = COPHeatPump()
p.setup(force_alloc_complex=True)
p.set_val('COP', np.ones(1))
p.set_val('power_rating', 1., units='kW')
p.run_model()
assert_near_equal(p.get_val('q_in_1', units='W'), np.array([-1000.]))
assert_near_equal(p.get_val('q_in_2', units='W'), np.array([2000.]))
partials = p.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def test(self):
prob = Problem()
prob.model.add_subsystem('mil_spec', MilSpecRecovery(), promotes=['*'])
prob.setup(check=False, force_alloc_complex=True)
prob.set_val('MN', 0.8)
prob.set_val('ram_recovery_base', 0.9)
prob.run_model()
tol = 1e-4
assert_near_equal(prob['ram_recovery'], 0.9, tol)
partial_data = prob.check_partials(out_stream=None, method='cs')
assert_check_partials(partial_data, atol=1e-8, rtol=1e-8)
prob.set_val('MN', 2.0)
prob.run_model()
assert_near_equal(prob['ram_recovery'], 0.8325, tol)
partial_data = prob.check_partials(out_stream=None, method='cs')
assert_check_partials(partial_data, atol=1e-8, rtol=1e-8)
prob.set_val('MN', 6.0)
prob.run_model()
assert_near_equal(prob['ram_recovery'], 0.35858, tol)
partial_data = prob.check_partials(out_stream=None, method='cs')
assert_check_partials(partial_data, atol=1e-8, rtol=1e-8)
def test_vectorized(self):
p = Problem()
p.model.linear_solver = DirectSolver()
p.model = COPExplicit(num_nodes=4)
p.setup()
p.set_val('T_c', np.array([100., 110., 120., 130.]), units='K')
p.set_val('T_h', np.array([200., 190., 180., 170.]), units='K')
p.set_val('eff_factor', 0.4)
p.run_model()
assert_near_equal(p.get_val('COP'),
np.array(
[0.40000535, 0.5500066, 0.80000934, 1.30001871]),
tolerance=1e-8)
def test_comp(self):
num_nodes = 3
prob = Problem()
prob.model.nonlinear_solver = NewtonSolver()
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver.options['solve_subsystems'] = True
prob.model.add_subsystem('test',
thermal.CoolantReservoir(num_nodes=num_nodes),
promotes=['*'])
prob.setup(check=True, force_alloc_complex=True)
# Set the values
prob.set_val('mdot_coolant', np.array([9., 14., 12.]), units='kg/s')
prob.set_val('T_in', np.array([300., 350., 290.]), units='K')
prob.set_val('mass', 10., units='kg')
prob.set_val('T_initial', 400., units='K')
prob.set_val('duration', 20., units='min')
prob.run_model()
assert_near_equal(prob.get_val('T_out', units='K'),
np.array([400., 317.9653263, 364.64246726]),
tolerance=1e-9)
partials = prob.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def test_vectorized(self):
nn = 5
p = Problem()
p.model = N3Hybrid(num_nodes=nn)
p.setup(force_alloc_complex=True)
p.set_val('throttle', np.linspace(0.0001, 1., nn))
p.set_val('fltcond|h', np.linspace(0, 40e3, nn), units='ft')
p.set_val('fltcond|M', np.linspace(0.1, 0.9, nn))
p.set_val('hybrid_power', np.linspace(1e3, 0, nn), units='kW')
p.run_model()
assert_near_equal(p.get_val('thrust', units='lbf'),
np.array([
2143.74837065, 4298.37044104, 5731.73572266,
5567.1704698, 6093.64182948
]),
tolerance=5e-3)
assert_near_equal(p.get_val('fuel_flow', units='kg/s'),
np.array([
0.12830921, 0.15107399, 0.24857052, 0.28013556,
0.24271405
]),
tolerance=5e-3)
assert_near_equal(p.get_val('surge_margin'),
np.array([
3.62385489, 5.13891739, 17.61488138, 29.65131358,
17.48630861
]),
tolerance=5e-3)
partials = p.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def test_defaults(self):
p = Problem()
p.model = N3Hybrid()
p.setup(force_alloc_complex=True)
p.set_val('throttle', 0.5)
p.set_val('fltcond|h', 10e3, units='ft')
p.set_val('fltcond|M', 0.5)
p.set_val('hybrid_power', 200., units='kW')
p.run_model()
assert_near_equal(p.get_val('thrust', units='lbf'),
6965.43674107 * np.ones(1),
tolerance=1e-6)
assert_near_equal(p.get_val('fuel_flow', units='kg/s'),
0.34333925 * np.ones(1),
tolerance=1e-6)
assert_near_equal(p.get_val('surge_margin'),
17.49872296 * np.ones(1),
tolerance=1e-6)
partials = p.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def test_no_bypass(self):
p = Problem()
p.model.linear_solver = DirectSolver()
p.model = LinearSelector()
p.setup(force_alloc_complex=True)
p.set_val('bypass', np.zeros(1))
p.run_model()
assert_near_equal(p.get_val('T_out_cold', units='K'),
p.get_val('T_out_refrig_cold', units='K'))
assert_near_equal(p.get_val('T_out_hot', units='K'),
p.get_val('T_out_refrig_hot', units='K'))
assert_near_equal(p.get_val('elec_load', units='W'),
p.get_val('elec_load', units='W'))
partials = p.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def make_problem(self,
transcription=GaussLobatto,
optimizer='SLSQP',
numseg=30):
p = Problem(model=Group())
p.driver = pyOptSparseDriver()
p.driver.declare_coloring()
OPT, OPTIMIZER = set_pyoptsparse_opt(optimizer, fallback=False)
p.driver.options['optimizer'] = OPTIMIZER
traj = p.model.add_subsystem('traj', Trajectory())
phase0 = traj.add_phase(
'phase0',
Phase(ode_class=HyperSensitiveODE,
transcription=transcription(num_segments=numseg, order=3)))
phase0.set_time_options(fix_initial=True, fix_duration=True)
phase0.add_state('x',
fix_initial=True,
fix_final=False,
rate_source='x_dot',
targets=['x'])
phase0.add_state('xL',
fix_initial=True,
fix_final=False,
rate_source='L',
targets=['xL'])
phase0.add_control('u', opt=True, targets=['u'])
phase0.add_boundary_constraint('x', loc='final', equals=1)
phase0.add_objective('xL', loc='final')
p.setup(check=True)
p.set_val('traj.phase0.states:x',
phase0.interpolate(ys=[1.5, 1], nodes='state_input'))
p.set_val('traj.phase0.states:xL',
phase0.interpolate(ys=[0, 1], nodes='state_input'))
p.set_val('traj.phase0.t_initial', 0)
p.set_val('traj.phase0.t_duration', tf)
p.set_val('traj.phase0.controls:u',
phase0.interpolate(ys=[-0.6, 2.4], nodes='control_input'))
return p
def test_vectorized(self):
# Set up the SimpleTMS problem with 11 evaluation points
nn = 11
prob = Problem()
prob.model = thermal.SimpleTMS(num_nodes=nn)
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver = NewtonSolver()
prob.model.nonlinear_solver.options['solve_subsystems'] = True
prob.setup()
prob.set_val('throttle', np.linspace(0.01, 0.99, nn), units=None)
prob.set_val('motor_elec_power_rating', 6., units='MW')
prob.run_model()
# Check that the solvers properly converged the BalanceComp so
# the heat taken by the cold plate equals the heat extracted
# by the refrigerator
q_fridge = prob['refrigerator.q_c']
q_plate = prob['refrigerator_cold_plate.q']
relative_error_met = (q_fridge - q_plate) / q_plate < 1e-9
self.assertTrue(relative_error_met.all())
def test_zero_work(self):
# Set up the SimpleTMS problem with throttle at zero
prob = Problem()
prob.model = thermal.SimpleTMS()
prob.model.linear_solver = DirectSolver()
prob.model.nonlinear_solver = NewtonSolver()
prob.model.nonlinear_solver.options['solve_subsystems'] = True
prob.setup()
prob.set_val('Wdot', 0.)
prob.set_val('motor_elec_power_rating', 10., units='kW')
prob.run_model()
# Check that the solvers properly converged the BalanceComp so
# the heat taken by the cold plate equals the heat extracted
# by the refrigerator
q_fridge = prob['refrigerator.q_c']
q_plate = prob['refrigerator_cold_plate.q']
fridge_abs_error_met = np.abs(q_fridge) < 1e-9
plate_abs_error_met = np.abs(q_plate) < 1e-9
self.assertTrue(fridge_abs_error_met.all())
self.assertTrue(plate_abs_error_met.all())
def test_fixed(self):
p = Problem()
p.model = PowerSplit(num_nodes=3,
rule='fixed',
efficiency=0.95,
weight_inc=0.01,
weight_base=1.,
cost_inc=0.02,
cost_base=2.)
p.setup(check=True)
p.set_val('power_in', np.array([1, 2, 3]), units='W')
p.set_val('power_rating', 10., units='W')
p.set_val('power_split_amount', np.array([0.95, 1., 1.]))
p.run_model()
assert_near_equal(p['power_out_A'], 0.95 * np.array([0.95, 1., 1.]))
assert_near_equal(
p['power_out_B'],
0.95 * (np.array([1., 2., 3.]) - np.array([0.95, 1., 1.])))
assert_near_equal(p['heat_out'], 0.05 * np.array([1., 2., 3.]))
assert_near_equal(p['component_cost'], 2.2)
assert_near_equal(p['component_weight'], 1.1)
assert_near_equal(p['component_sizing_margin'], np.array([.1, .2, .3]))
partials = p.check_partials(
method='fd', compact_print=True) # for some reason this one
# doesn't work with complex step
assert_check_partials(partials)
def test_fraction(self):
p = Problem()
p.model = PowerSplit(num_nodes=3,
efficiency=0.95,
weight_inc=0.01,
weight_base=1.,
cost_inc=0.02,
cost_base=2.)
p.setup(check=True, force_alloc_complex=True)
p.set_val('power_in', np.array([1, 2, 3]), units='W')
p.set_val('power_rating', 10., units='W')
p.set_val('power_split_fraction', np.array([0.2, 0.4, 0.3]))
p.run_model()
assert_near_equal(p['power_out_A'], 0.95 * np.array([0.2, 0.8, 0.9]))
assert_near_equal(p['power_out_B'], 0.95 * np.array([0.8, 1.2, 2.1]))
assert_near_equal(p['heat_out'], 0.05 * np.array([1., 2., 3.]))
assert_near_equal(p['component_cost'], 2.2)
assert_near_equal(p['component_weight'], 1.1)
assert_near_equal(p['component_sizing_margin'], np.array([.1, .2, .3]))
partials = p.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def test_vectorized(self):
nn = 5
p = Problem()
p.model = N3Hybrid(num_nodes=nn)
p.setup(force_alloc_complex=True)
p.set_val('throttle', np.linspace(0.0001, 1., nn))
p.set_val('fltcond|h', np.linspace(0, 40e3, nn), units='ft')
p.set_val('fltcond|M', np.linspace(0.1, 0.9, nn))
p.run_model()
assert_near_equal(p.get_val('thrust', units='lbf'),
np.array([
2116.01166807, 4298.21330183, 5731.73026453,
5567.1916333, 6093.64182948
]),
tolerance=5e-3)
assert_near_equal(p.get_val('fuel_flow', units='kg/s'),
np.array([
0.15443523, 0.18527426, 0.26886803, 0.29035632,
0.24271405
]),
tolerance=5e-3)
assert_near_equal(p.get_val('surge_margin'),
np.array([
9.63957356, 9.85223288, 21.01375818, 31.54415929,
17.48630861
]),
tolerance=5e-3)
partials = p.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def test_comp(self):
num_nodes = 3
prob = Problem()
prob.model.add_subsystem(
'test',
thermal.CoolantReservoirRate(num_nodes=num_nodes),
promotes=['*'])
prob.setup(check=True, force_alloc_complex=True)
# Set the values
prob.set_val('T_in', np.array([300., 350., 290.]), units='K')
prob.set_val('T_out', np.array([350., 340., 250.]), units='K')
prob.set_val('mdot_coolant', np.array([9., 14., 12.]), units='kg/s')
prob.set_val('mass', 7., units='kg')
prob.run_model()
assert_near_equal(prob.get_val('dTdt', units='K/s'),
np.array([-64.28571429, 20., 68.57142857]),
tolerance=1e-9)
partials = prob.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def test_one_input(self):
p = Problem()
p.model.add_subsystem('select',
SelectorComp(input_names=['A']),
promotes=['*'])
p.setup(check=True, force_alloc_complex=True)
p.set_val('A', np.array([5.7]))
p.set_val('selector', np.array([0]))
p.run_model()
assert_near_equal(p['result'], np.array([5.7]))
partials = p.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
p.set_val('selector', np.array([1]))
with self.assertRaises(RuntimeWarning):
p.run_model()
def test_defaults(self):
p = Problem()
p.model = CFM56()
p.setup(force_alloc_complex=True)
p.set_val('throttle', 0.5)
p.set_val('fltcond|h', 10e3, units='ft')
p.set_val('fltcond|M', 0.5)
p.run_model()
assert_near_equal(p.get_val('thrust', units='lbf'), 7050.73840869*np.ones(1), tolerance=1e-6)
assert_near_equal(p.get_val('fuel_flow', units='kg/s'), 0.50273824*np.ones(1), tolerance=1e-6)
assert_near_equal(p.get_val('T4', units='degK'), 1432.06813946*np.ones(1), tolerance=1e-6)
partials = p.check_partials(method='cs',compact_print=True)
assert_check_partials(partials)
def test_comp(self):
num_nodes = 3
prob = Problem()
prob.model.add_subsystem(
'test',
thermal.ThermalComponentWithMass(num_nodes=num_nodes),
promotes=['*'])
prob.setup(check=True, force_alloc_complex=True)
# Set the values
prob.set_val('q_in', np.array([10., 14., 4.]), units='kW')
prob.set_val('q_out', np.array([9., 14., 12.]), units='kW')
prob.set_val('mass', 7., units='kg')
prob.run_model()
assert_near_equal(prob.get_val('dTdt', units='K/s'),
np.array([.1551109043, 0., -1.2408872344]),
tolerance=1e-9)
partials = prob.check_partials(method='cs', compact_print=True)
assert_check_partials(partials)
def test_vectorized(self):
nn = 5
p = Problem()
p.model = CFM56(num_nodes=nn)
p.setup(force_alloc_complex=True)
p.set_val('throttle', np.linspace(0.0001, 1., nn))
p.set_val('fltcond|h', np.linspace(0, 40e3, nn), units='ft')
p.set_val('fltcond|M', np.linspace(0.1, 0.9, nn))
p.run_model()
assert_near_equal(p.get_val('thrust', units='lbf'), np.array([1445.41349482, 3961.46624224,
5278.43191982, 5441.44404298, 6479.00525867]), tolerance=5e-3)
assert_near_equal(p.get_val('fuel_flow', units='kg/s'), np.array([0.17032429, 0.25496437,
0.35745638, 0.40572545, 0.4924194]), tolerance=5e-3)
assert_near_equal(p.get_val('T4', units='degK'), np.array([1005.38911171, 1207.57548728,
1381.94820904, 1508.07901676, 1665.37063872]), tolerance=5e-3)
partials = p.check_partials(method='cs',compact_print=True)
assert_check_partials(partials)