def setUp(self): model = Group() ivc = IndepVarComp() mapdata = SampleMap() params = mapdata.param_data x, y, z = params outs = mapdata.output_data z = outs[0] ivc.add_output('x', x['default'], units=x['units']) ivc.add_output('y', y['default'], units=y['units']) ivc.add_output('z', z['default'], units=z['units']) model.add_subsystem('des_vars', ivc, promotes=["*"]) comp = MetaModelStructured(method='slinear', extrapolate=True) for param in params: comp.add_input(param['name'], param['default'], param['values']) for out in outs: comp.add_output(out['name'], out['default'], out['values']) model.add_subsystem('comp', comp, promotes=["*"]) self.prob = Problem(model) self.prob.setup() self.prob['x'] = 1.0 self.prob['y'] = 0.75 self.prob['z'] = -1.7
def get_cd_trim(cl): ivc = IndepVarComp() ivc.add_output( "data:aerodynamics:aircraft:cruise:CL", 150 * [cl] ) # needed because size of input array is fixed problem = run_system(CdTrim(), ivc) return problem["data:aerodynamics:aircraft:cruise:CD:trim"][0]
def test_compute_with_provided_path(): """ Test that option "use_exe_path" works """ ivc = IndepVarComp() ivc.add_output("xfoil:reynolds", 1e6) ivc.add_output("xfoil:mach", 0.20) # Clear saved polar results if pth.exists( pth.join(resources.__path__[0], _DEFAULT_AIRFOIL_FILE.replace('af', 'csv'))): os.remove( pth.join(resources.__path__[0], _DEFAULT_AIRFOIL_FILE.replace('af', 'csv'))) if pth.exists( pth.join(resources.__path__[0], _DEFAULT_AIRFOIL_FILE.replace('.af', '_sym.csv'))): os.remove( pth.join(resources.__path__[0], _DEFAULT_AIRFOIL_FILE.replace('.af', '_sym.csv'))) xfoil_comp = XfoilPolar(alpha_start=0.0, alpha_end=20.0, iter_limit=20) xfoil_comp.options["xfoil_exe_path"] = "Dummy" # bad name with pytest.raises(ValueError): _ = run_system(xfoil_comp, ivc) xfoil_comp.options["xfoil_exe_path"] = ( xfoil_path if xfoil_path else pth.join( pth.dirname(__file__), pth.pardir, "xfoil699", "xfoil.exe")) problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(1.48, 1e-2)
def get_cd_compressibility(mach, cl): ivc = IndepVarComp() ivc.add_output("data:aerodynamics:aircraft:cruise:CL", 150 * [cl]) # needed because size of input array is fixed ivc.add_output("data:TLAR:cruise_mach", mach) problem = run_system(CdCompressibility(), ivc) return problem["data:aerodynamics:aircraft:cruise:CD:compressibility"][ 0]
def get_cd_compressibility(mach, cl, sweep, thickness_ratio, delta_charac_mach=0.0): ivc = IndepVarComp() ivc.add_output( "data:aerodynamics:aircraft:cruise:CL", 150 * [cl] ) # needed because size of input array is fixed ivc.add_output("data:TLAR:cruise_mach", mach) ivc.add_output("data:geometry:wing:sweep_25", sweep, units="deg") ivc.add_output("data:geometry:wing:thickness_ratio", thickness_ratio) ivc.add_output( "tuning:aerodynamics:aircraft:cruise:CD:compressibility:characteristic_mach_increment", delta_charac_mach, ) problem = run_system(CdCompressibility(), ivc) return problem["data:aerodynamics:aircraft:cruise:CD:compressibility"][0]
def test_meta_model_structured_deprecated(self): # run same test as above, only with the deprecated component, # to ensure we get the warning and the correct answer. # self-contained, to be removed when class name goes away. import numpy as np from openmdao.api import Group, Problem, IndepVarComp from openmdao.components.meta_model_structured_comp import MetaModelStructured # deprecated import warnings with warnings.catch_warnings(record=True) as w: xor_interp = MetaModelStructured(method='slinear') self.assertEqual(len(w), 1) self.assertTrue(issubclass(w[0].category, DeprecationWarning)) self.assertEqual(str(w[0].message), "'MetaModelStructured' has been deprecated. Use " "'MetaModelStructuredComp' instead.") # set up inputs and outputs xor_interp.add_input('x', 0.0, training_data=np.array([0.0, 1.0]), units=None) xor_interp.add_input('y', 1.0, training_data=np.array([0.0, 1.0]), units=None) xor_interp.add_output('xor', 1.0, training_data=np.array([[0.0, 1.0], [1.0, 0.0]]), units=None) # Set up the OpenMDAO model model = Group() ivc = IndepVarComp() ivc.add_output('x', 0.0) ivc.add_output('y', 1.0) model.add_subsystem('ivc', ivc, promotes=["*"]) model.add_subsystem('comp', xor_interp, promotes=["*"]) prob = Problem(model) prob.setup() # Now test out a 'fuzzy' XOR prob['x'] = 0.9 prob['y'] = 0.001242 prob.run_model() computed = prob['xor'] actual = 0.8990064 assert_almost_equal(computed, actual) # we can verify all gradients by checking against finite-difference prob.check_partials(compact_print=True)
def test_compute(): """ Tests a simple XFOIL run""" if pth.exists(XFOIL_RESULTS): shutil.rmtree(XFOIL_RESULTS) ivc = IndepVarComp() ivc.add_output("xfoil:reynolds", 1e6, units="m**-1") ivc.add_output("xfoil:mach", 0.60) xfoil_comp = XfoilPolar(alpha_start=0.0, alpha_end=15.0, iter_limit=100, symmetrical=True, xfoil_exe_path=xfoil_path) problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(1.31, 1e-2) assert problem["xfoil:CL_min_2D"] == pytest.approx(-0.59, 1e-2) assert not pth.exists(XFOIL_RESULTS) # Deactivate warnings for wished crash of xfoil warnings.simplefilter("ignore") xfoil_comp = XfoilPolar(alpha_start=50.0, alpha_end=60.0, iter_limit=2, xfoil_exe_path=xfoil_path) # will not converge problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(DEFAULT_2D_CL_MAX, 1e-2) assert problem["xfoil:CL_min_2D"] == pytest.approx(DEFAULT_2D_CL_MIN, 1e-2) assert not pth.exists(XFOIL_RESULTS) # Reactivate warnings warnings.simplefilter("default") xfoil_comp = XfoilPolar(iter_limit=20, result_folder_path=XFOIL_RESULTS, xfoil_exe_path=xfoil_path) run_system(xfoil_comp, ivc) assert pth.exists(XFOIL_RESULTS) assert pth.exists(pth.join(XFOIL_RESULTS, "polar_result.txt")) # remove folder if pth.exists(XFOIL_RESULTS): shutil.rmtree(XFOIL_RESULTS)
def test_compute(): """ Tests a simple XFOIL run""" if pth.exists(XFOIL_RESULTS): shutil.rmtree(XFOIL_RESULTS) ivc = IndepVarComp() ivc.add_output("xfoil:unit_reynolds", 18000000) ivc.add_output("xfoil:mach", 0.80) ivc.add_output("data:geometry:wing:thickness_ratio", 0.1284) ivc.add_output("xfoil:length", 1.0, units="m") xfoil_comp = XfoilPolar(alpha_start=15.0, alpha_end=25.0, iter_limit=20, xfoil_exe_path=xfoil_path) problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(1.9, 1e-2) assert not pth.exists(XFOIL_RESULTS) # Deactivate warnings for wished crash of xfoil warnings.simplefilter("ignore") xfoil_comp = XfoilPolar( alpha_start=12.0, alpha_end=20.0, iter_limit=20, xfoil_exe_path=xfoil_path) # will stop before real max CL problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(1.9, 1e-2) assert not pth.exists(XFOIL_RESULTS) xfoil_comp = XfoilPolar(alpha_start=50.0, alpha_end=55.0, iter_limit=2, xfoil_exe_path=xfoil_path) # will not converge problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(DEFAULT_2D_CL_MAX, 1e-2) assert not pth.exists(XFOIL_RESULTS) # Reactivate warnings warnings.simplefilter("default") xfoil_comp = XfoilPolar(iter_limit=20, result_folder_path=XFOIL_RESULTS, xfoil_exe_path=xfoil_path) problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(1.9, 1e-2) assert pth.exists(XFOIL_RESULTS) assert pth.exists(pth.join(XFOIL_RESULTS, "polar_result.txt")) # remove folder if pth.exists(XFOIL_RESULTS): shutil.rmtree(XFOIL_RESULTS)
def test_raise_out_of_bounds_error(self): model = Group() ivc = IndepVarComp() mapdata = SampleMap() params = mapdata.param_data x, y, z = params outs = mapdata.output_data z = outs[0] ivc.add_output('x', x['default'], units=x['units']) ivc.add_output('y', y['default'], units=y['units']) ivc.add_output('z', z['default'], units=z['units']) model.add_subsystem('des_vars', ivc, promotes=["*"]) # Need to make sure extrapolate is False for bounds to be checked comp = MetaModelStructured(method='slinear', extrapolate=False) for param in params: comp.add_input(param['name'], param['default'], param['values']) for out in outs: comp.add_output(out['name'], out['default'], out['values']) model.add_subsystem('comp', comp, promotes=["*"]) self.prob = Problem(model) self.prob.setup() self.prob['x'] = 1.0 self.prob['y'] = 0.75 self.prob['z'] = 9.0 # intentionally set to be out of bounds # The interpolating output name is given as a regexp because the exception could # happen with f or g first. The order those are evaluated comes from the keys of # dict so no guarantee on the order except for Python 3.6 ! msg = "Error interpolating output '[f|g]' in 'comp' " + "because input 'comp.z' was " \ "out of bounds \('.*', '.*'\) with value '9.0'" with assertRaisesRegex(self, ValueError, msg): self.run_and_check_derivs(self.prob)
def test_xor(self): import numpy as np from openmdao.api import Group, Problem, IndepVarComp from openmdao.components.meta_model_structured import MetaModelStructured # Create regular grid interpolator instance xor_interp = MetaModelStructured(method='slinear') # set up inputs and outputs xor_interp.add_input('x', 0.0, np.array([0.0, 1.0]), units=None) xor_interp.add_input('y', 1.0, np.array([0.0, 1.0]), units=None) xor_interp.add_output('xor', 1.0, np.array([[0.0, 1.0], [1.0, 0.0]]), units=None) # Set up the OpenMDAO model model = Group() ivc = IndepVarComp() ivc.add_output('x', 0.0) ivc.add_output('y', 1.0) model.add_subsystem('ivc', ivc, promotes=["*"]) model.add_subsystem('comp', xor_interp, promotes=["*"]) prob = Problem(model) prob.setup() # Now test out a 'fuzzy' XOR prob['x'] = 0.9 prob['y'] = 0.001242 prob.run_model() computed = prob['xor'] actual = 0.8990064 assert_almost_equal(computed, actual) # we can verify all gradients by checking against finit-difference prob.check_partials(compact_print=True)
def test_compute_with_provided_path(): """ Test that option "use_exe_path" works """ ivc = IndepVarComp() ivc.add_output("xfoil:unit_reynolds", 18000000) ivc.add_output("xfoil:mach", 0.20) ivc.add_output("data:geometry:wing:thickness_ratio", 0.1284) ivc.add_output("xfoil:length", 1.0, units="m") xfoil_comp = XfoilPolar(alpha_start=18.0, alpha_end=21.0, iter_limit=20) xfoil_comp.options["xfoil_exe_path"] = "Dummy" # bad name with pytest.raises(ValueError): _ = run_system(xfoil_comp, ivc) xfoil_comp.options["xfoil_exe_path"] = ( xfoil_path if xfoil_path else pth.join( pth.dirname(__file__), pth.pardir, "xfoil699", "xfoil.exe")) problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(1.85, 1e-2)
def test_compute(): """ Tests a simple XFOIL run""" if pth.exists(XFOIL_RESULTS): shutil.rmtree(XFOIL_RESULTS) ivc = IndepVarComp() ivc.add_output("xfoil:reynolds", 18000000) ivc.add_output("xfoil:mach", 0.20) ivc.add_output("data:geometry:wing:thickness_ratio", 0.1284) # Base test ---------------------------------------------------------------- xfoil_comp = XfoilPolar(alpha_start=15.0, alpha_end=25.0, iter_limit=20, xfoil_exe_path=xfoil_path) problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(1.94, 1e-2) assert not pth.exists(XFOIL_RESULTS) # Test that will stop before real max CL ----------------------------------- xfoil_comp = XfoilPolar(alpha_start=12.0, alpha_end=20.0, iter_limit=20, xfoil_exe_path=xfoil_path) problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(1.92, 1e-2) assert not pth.exists(XFOIL_RESULTS) # Test that will not converge ---------------------------------------------- xfoil_comp = XfoilPolar(alpha_start=50.0, alpha_end=55.0, iter_limit=2, xfoil_exe_path=xfoil_path) problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(DEFAULT_2D_CL_MAX, 1e-2) assert not pth.exists(XFOIL_RESULTS) # Test that will output results in provided folder ------------------------- xfoil_comp = XfoilPolar(iter_limit=20, result_folder_path=XFOIL_RESULTS, xfoil_exe_path=xfoil_path) problem = run_system(xfoil_comp, ivc) assert problem["xfoil:CL_max_2D"] == pytest.approx(1.94, 1e-2) assert pth.exists(XFOIL_RESULTS) assert pth.exists(pth.join(XFOIL_RESULTS, "polar_result.txt"))
def test_training_gradient(self): model = Group() ivc = IndepVarComp() mapdata = SampleMap() params = mapdata.param_data outs = mapdata.output_data ivc.add_output('x', np.array([-0.3, 0.7, 1.2])) ivc.add_output('y', np.array([0.14, 0.313, 1.41])) ivc.add_output('z', np.array([-2.11, -1.2, 2.01])) ivc.add_output('f_train', outs[0]['values']) ivc.add_output('g_train', outs[1]['values']) comp = MetaModelStructured(training_data_gradients=True, method='cubic', num_nodes=3) for param in params: comp.add_input(param['name'], param['default'], param['values']) for out in outs: comp.add_output(out['name'], out['default'], out['values']) model.add_subsystem('ivc', ivc, promotes=["*"]) model.add_subsystem('comp', comp, promotes=["*"]) prob = Problem(model) prob.setup() prob.run_model() val0 = np.array([ 50.26787317, 49.76106232, 19.66117913]) val1 = np.array([-32.62094041, -31.67449135, -27.46959668]) tol = 1e-5 assert_rel_error(self, prob['f'], val0, tol) assert_rel_error(self, prob['g'], val1, tol) self.run_and_check_derivs(prob)
def test_training_gradient(self): model = Group() ivc = IndepVarComp() mapdata = SampleMap() params = mapdata.param_data outs = mapdata.output_data ivc.add_output('x', np.array([-0.3, 0.7, 1.2])) ivc.add_output('y', np.array([0.14, 0.313, 1.41])) ivc.add_output('z', np.array([-2.11, -1.2, 2.01])) ivc.add_output('f_train', outs[0]['values']) ivc.add_output('g_train', outs[1]['values']) comp = MetaModelStructuredComp(training_data_gradients=True, method='cubic', num_nodes=3) for param in params: comp.add_input(param['name'], param['default'], param['values']) for out in outs: comp.add_output(out['name'], out['default'], out['values']) model.add_subsystem('ivc', ivc, promotes=["*"]) model.add_subsystem('comp', comp, promotes=["*"]) prob = Problem(model) prob.setup() prob.run_model() val0 = np.array([ 50.26787317, 49.76106232, 19.66117913]) val1 = np.array([-32.62094041, -31.67449135, -27.46959668]) tol = 1e-5 assert_rel_error(self, prob['f'], val0, tol) assert_rel_error(self, prob['g'], val1, tol) self.run_and_check_derivs(prob)
""" x = inputs['x'] y = inputs['y'] partials['f_xy', 'x'] = 2.0 * x - 6.0 + y partials['f_xy', 'y'] = 2.0 * y + 8.0 + x if __name__ == "__main__": from openmdao.core.problem import Problem from openmdao.core.group import Group from openmdao.core.indepvarcomp import IndepVarComp model = Group() ivc = IndepVarComp() ivc.add_output('x', 3.0) ivc.add_output('y', -4.0) model.add_subsystem('des_vars', ivc) model.add_subsystem('parab_comp', Paraboloid()) model.connect('des_vars.x', 'parab_comp.x') model.connect('des_vars.y', 'parab_comp.y') prob = Problem(model) prob.setup() prob.run_model() print(prob['parab_comp.f_xy']) prob['des_vars.x'] = 5.0 prob['des_vars.y'] = -2.0 prob.run_model()
Optimal solution (minimum): x = 6.6667; y = -7.3333 """ x = inputs['x'] y = inputs['y'] outputs['f_xy'] = (x-3.0)**2 + x*y + (y+4.0)**2 - 3.0 if __name__ == "__main__": from openmdao.core.problem import Problem from openmdao.core.group import Group from openmdao.core.indepvarcomp import IndepVarComp model = Group() ivc = IndepVarComp() ivc.add_output('x', 3.0) ivc.add_output('y', -4.0) model.add_subsystem('des_vars', ivc) model.add_subsystem('parab_comp', Paraboloid()) model.connect('des_vars.x', 'parab_comp.x') model.connect('des_vars.y', 'parab_comp.y') prob = Problem(model) prob.setup() prob.run_model() print(prob['parab_comp.f_xy']) prob['des_vars.x'] = 5.0 prob['des_vars.y'] = -2.0 prob.run_model()
def __init__(self, ode_class, time_options, state_options, control_options, polynomial_control_options, design_parameter_options, input_parameter_options, traj_parameter_options, ode_init_kwargs=None): # Get the state vector. This isn't necessarily ordered # so just pick the default ordering and go with it. self.state_options = OrderedDict() self.time_options = time_options self.control_options = control_options self.polynomial_control_options = polynomial_control_options self.design_parameter_options = design_parameter_options self.input_parameter_options = input_parameter_options self.traj_parameter_options = traj_parameter_options self.control_interpolants = {} self.polynomial_control_interpolants = {} pos = 0 for state, options in iteritems(state_options): self.state_options[state] = { 'rate_source': options['rate_source'], 'pos': pos, 'shape': options['shape'], 'size': np.prod(options['shape']), 'units': options['units'], 'targets': options['targets'] } pos += self.state_options[state]['size'] self._state_vec = np.zeros(pos, dtype=float) self._state_rate_vec = np.zeros(pos, dtype=float) # # Build odeint problem interface # self.prob = Problem(model=Group()) model = self.prob.model # The time IVC ivc = IndepVarComp() time_units = self.time_options['units'] ivc.add_output('time', val=0.0, units=time_units) ivc.add_output('time_phase', val=-88.0, units=time_units) ivc.add_output('t_initial', val=-99.0, units=time_units) ivc.add_output('t_duration', val=-111.0, units=time_units) model.add_subsystem('time_input', ivc, promotes_outputs=['*']) model.connect( 'time', ['ode.{0}'.format(tgt) for tgt in self.time_options['targets']]) model.connect('time_phase', [ 'ode.{0}'.format(tgt) for tgt in self.time_options['time_phase_targets'] ]) model.connect('t_initial', [ 'ode.{0}'.format(tgt) for tgt in self.time_options['t_initial_targets'] ]) model.connect('t_duration', [ 'ode.{0}'.format(tgt) for tgt in self.time_options['t_duration_targets'] ]) # The States Comp for name, options in iteritems(self.state_options): ivc.add_output('states:{0}'.format(name), shape=(1, np.prod(options['shape'])), units=options['units']) rate_src = self._get_rate_source_path(name) model.connect( rate_src, 'state_rate_collector.state_rates_in:{0}_rate'.format(name)) if options['targets'] is not None: model.connect( 'states:{0}'.format(name), ['ode.{0}'.format(tgt) for tgt in options['targets']]) if self.control_options or self.polynomial_control_options: self._interp_comp = \ ODEIntControlInterpolationComp(time_units=time_units, control_options=self.control_options, polynomial_control_options=self.polynomial_control_options) self._interp_comp.control_interpolants = self.control_interpolants self._interp_comp.polynomial_control_interpolants = self.polynomial_control_interpolants model.add_subsystem('indep_controls', self._interp_comp, promotes_outputs=['*']) model.connect('time', ['indep_controls.time']) if self.control_options: for name, options in iteritems(self.control_options): if options['targets']: model.connect( 'controls:{0}'.format(name), ['ode.{0}'.format(tgt) for tgt in options['targets']]) if options['rate_targets']: model.connect('control_rates:{0}_rate'.format(name), [ 'ode.{0}'.format(tgt) for tgt in options['rate_targets'] ]) if options['rate2_targets']: model.connect('control_rates:{0}_rate2'.format(name), [ 'ode.{0}'.format(tgt) for tgt in options['rate2_targets'] ]) if self.polynomial_control_options: for name, options in iteritems(self.polynomial_control_options): tgts = options['targets'] rate_tgts = options['rate_targets'] rate2_tgts = options['rate2_targets'] if options['targets']: if isinstance(tgts, string_types): tgts = [tgts] model.connect('polynomial_controls:{0}'.format(name), ['ode.{0}'.format(tgt) for tgt in tgts]) if options['rate_targets']: if isinstance(rate_tgts, string_types): rate_tgts = [rate_tgts] model.connect( 'polynomial_control_rates:{0}_rate'.format(name), ['ode.{0}'.format(tgt) for tgt in rate_tgts]) if options['rate2_targets']: if isinstance(rate2_tgts, string_types): rate2_tgts = [rate2_tgts] model.connect( 'polynomial_control_rates:{0}_rate2'.format(name), ['ode.{0}'.format(tgt) for tgt in rate2_tgts]) if self.design_parameter_options: for name, options in iteritems(self.design_parameter_options): ivc.add_output('design_parameters:{0}'.format(name), shape=options['shape'], units=options['units']) if options['targets'] is not None: tgts = options['targets'] if isinstance(tgts, string_types): tgts = [tgts] model.connect('design_parameters:{0}'.format(name), ['ode.{0}'.format(tgt) for tgt in tgts]) if self.input_parameter_options: for name, options in iteritems(self.input_parameter_options): ivc.add_output('input_parameters:{0}'.format(name), shape=options['shape'], units=options['units']) if options['targets'] is not None: tgts = options['targets'] if isinstance(tgts, string_types): tgts = [tgts] model.connect('input_parameters:{0}'.format(name), ['ode.{0}'.format(tgt) for tgt in tgts]) if self.traj_parameter_options: for name, options in iteritems(self.traj_parameter_options): ivc.add_output('traj_parameters:{0}'.format(name), shape=options['shape'], units=options['units']) if options['targets'] is not None: tgts = options['targets'] if isinstance(tgts, string_types): tgts = [tgts] model.connect('traj_parameters:{0}'.format(name), ['ode.{0}'.format(tgt) for tgt in tgts]) # The ODE System if ode_class is not None: model.add_subsystem('ode', subsys=ode_class(num_nodes=1, **ode_init_kwargs)) # The state rate collector comp self.prob.model.add_subsystem( 'state_rate_collector', StateRateCollectorComp(state_options=self.state_options, time_units=time_options['units'])) # Flag that is set to true if has_controls is called self._has_dynamic_controls = False
def __init__(self, phase_name, ode_class, time_options, state_options, control_options, design_parameter_options, input_parameter_options, ode_init_kwargs=None): self.phase_name = phase_name self.prob = Problem(model=Group()) self.ode = ode # The ODE System self.prob.model.add_subsystem('ode', subsys=ode_class(num_nodes=1, **ode_init_kwargs)) self.ode_options = ode_class.ode_options # Get the state vector. This isn't necessarily ordered # so just pick the default ordering and go with it. self.state_options = OrderedDict() self.time_options = time_options self.control_options = control_options self.design_parameter_options = design_parameter_options self.input_parameter_options = input_parameter_options pos = 0 for state, options in iteritems(state_options): self.state_options[state] = { 'rate_source': options['rate_source'], 'pos': pos, 'shape': options['shape'], 'size': np.prod(options['shape']), 'units': options['units'], 'targets': options['targets'] } pos += self.state_options[state]['size'] self._state_vec = np.zeros(pos, dtype=float) self._state_rate_vec = np.zeros(pos, dtype=float) # The Time Comp self.prob.model.add_subsystem( 'time_input', IndepVarComp('time', val=0.0, units=self.ode_options._time_options['units']), promotes_outputs=['time']) if self.ode_options._time_options['targets'] is not None: self.prob.model.connect('time', [ 'ode.{0}'.format(tgt) for tgt in self.ode_options._time_options['targets'] ]) # The States Comp indep = IndepVarComp() for name, options in iteritems(self.state_options): indep.add_output('states:{0}'.format(name), shape=(1, np.prod(options['shape'])), units=options['units']) if options['targets'] is not None: self.prob.model.connect( 'states:{0}'.format(name), ['ode.{0}'.format(tgt) for tgt in options['targets']]) self.prob.model.connect( 'ode.{0}'.format(options['rate_source']), 'state_rate_collector.state_rates_in:{0}_rate'.format(name)) self.prob.model.add_subsystem('indep_states', subsys=indep, promotes_outputs=['*']) # The Control interpolation comp time_units = self.ode_options._time_options['units'] self._interp_comp = ControlInterpolationComp( time_units=time_units, control_options=control_options) # The state rate collector comp self.prob.model.add_subsystem( 'state_rate_collector', StateRateCollectorComp(state_options=self.state_options, time_units=time_options['units'])) # Flag that is set to true if has_controls is called self._has_dynamic_controls = False
Rhub = initial['planform']['hub_radius'] z = np.array( initial['planform']['Z'] ) # no x,y for now so not worrying about coordinate transformation. r = Rhub + z[1:-1] # chop off hub/tip (loads are zero) Rtip = Rhub + z[-1] # load other constraints Tfactor = initial['optimization']['Constraints']['Rotor_Thrust'][ 'Upper_Limit'] Bfwfactor = initial['optimization']['Constraints'][ 'Root_Flap_Wise_Bending_Moment']['Upper_Limit'] # create an input component ivc = IndepVarComp() ivc.add_output('r', r) ivc.add_output('Rhub', Rhub) ivc.add_output('Rtip', Rtip) ivc.add_output('hubHt', 0.0) # irrelevant if no shear ivc.add_output('precone', 0.0) ivc.add_output('tilt', 0.0) ivc.add_output('yaw', 0.0) ivc.add_output('B', 3) # never explicitly stated ivc.add_output('rho', initial['environment']['Air_Density']) ivc.add_output('mu', 0.0000181206) # irrelevant if no Re dependency ivc.add_output('shearExp', 0.0) ivc.add_output('nSector', 1) # ivc.add_output('blend', blendingweight) ivc.add_output('tmin', tmin) n -= 2 # removed hub/tip