def setup(self): sub_prob = om.Problem() sub_prob.model.add_subsystem('time_calc', om.ExecComp('norm_time=time/t_final', time={'units': 's'}, t_final={'units': 's'})) controls = sub_prob.model.add_subsystem('controls', om.MetaModelStructuredComp(method='scipy_cubic', training_data_gradients=True)) controls.add_input('norm_time', 0.0, training_data=time_cp) controls.add_output('theta', 0.0, training_data=theta_cp) controls.add_output('power', 0.0, training_data=power_cp) sub_prob.model.connect('time_calc.norm_time', 'controls.norm_time') sub_prob.model.add_subsystem('ode', Dynamics(input_dict=input_dict, num_nodes=1)) sub_prob.model.connect('controls.theta', 'ode.theta') sub_prob.model.connect('controls.power', 'ode.power') sub_prob.setup() self.sub_prob = sub_prob self.add_input('t_final', val=30., units='s') self.add_input('time', val=0., units='s') self.add_input('theta_cp', val=np.ones(num_cp), units='rad') self.add_input('power_cp', val=np.ones(num_cp), units='W') self.add_output('x', shape=num_steps, units='m') self.add_output('y', shape=num_steps, units='m') self.add_output('vx', shape=num_steps, units='m/s') self.add_output('vy', shape=num_steps, units='m/s') self.add_output('energy', shape=num_steps, units='J') self.add_output('times', shape=num_steps, units='s')
def setup(self): interp_method = self.options['interp_method'] spec = self.options['spec'] composition = self.options['composition'] if composition is None: composition = TAB_AIR_FUEL_COMPOSITION sorted_compo = sorted(composition.keys()) interp = om.MetaModelStructuredComp(method=interp_method, extrapolate=True) self.add_subsystem('tab', interp, promotes_inputs=['P', 'T'], promotes_outputs=['h', 'S', 'gamma', 'Cp', 'Cv', 'rho', 'R']) for i, param in enumerate(sorted_compo): interp.add_input(param, composition[param], training_data=spec[param]) self.promotes('tab', inputs=[(param, 'composition')], src_indices=[i,]) self.set_input_defaults('composition', src_shape=len(composition)) interp.add_input('P', 101325.0, units='Pa', training_data=spec['P']) interp.add_input('T', 273.0, units='degK', training_data=spec['T']) interp.add_output('h', 1.0, units='J/kg', training_data=spec['h']) interp.add_output('S', 1.0, units='J/kg/degK', training_data=spec['S']) interp.add_output('gamma', 1.4, units=None, training_data=spec['gamma']) interp.add_output('Cp', 1.0, units='J/kg/degK', training_data=spec['Cp']) interp.add_output('Cv', 1.0, units='J/kg/degK', training_data=spec['Cv']) interp.add_output('rho', 1.0, units='kg/m**3', training_data=spec['rho']) interp.add_output('R', 287.0, units='J/kg/degK', training_data=spec['R']) # required part of the SetTotalTP API for flow setup # use a sorted list of keys, so dictionary hash ordering doesn't bite us # loop over keys and create a vector of mass fractions self.composition = [composition[k] for k in sorted_compo]
def test_working_scipy_cubic(self): # create input param training data, of sizes 25, 5, and 10 points resp. p1 = np.linspace(0, 100, 25) p2 = np.linspace(-10, 10, 5) p3 = np.linspace(0, 1, 10) # can use meshgrid to create a 3D array of test data P1, P2, P3 = np.meshgrid(p1, p2, p3, indexing='ij') f = np.sqrt(P1) + P2 * P3 # Create regular grid interpolator instance interp = om.MetaModelStructuredComp(method='scipy_cubic') interp.add_input('p1', 0.5, training_data=p1) interp.add_input('p2', 0.0, training_data=p2) interp.add_input('p3', 3.14, training_data=p3) interp.add_output('f', 0.0, training_data=f) # Set up the OpenMDAO model model = om.Group() model.add_subsystem('comp', interp, promotes=["*"]) prob = om.Problem(model) prob.setup() MetaModelVisualization(interp)
def test_working_slinear(self): num_train = 10 x0_min, x0_max = -5.0, 10.0 x1_min, x1_max = 0.0, 15.0 train_x0 = np.linspace(x0_min, x0_max, num_train) train_x1 = np.linspace(x1_min, x1_max, num_train) t_data = self.grid_data prob = om.Problem() ivc = om.IndepVarComp() ivc.add_output('x0', 0.0) ivc.add_output('x1', 0.0) prob.model.add_subsystem('p', ivc, promotes=['*']) mm = prob.model.add_subsystem( 'mm', om.MetaModelStructuredComp(method='slinear'), promotes=['x0', 'x1']) mm.add_input('x0', 0.0, train_x0) mm.add_input('x1', 0.0, train_x1) mm.add_output('f', 0.0, t_data) prob.setup() prob.final_setup() MetaModelVisualization(mm)
def test_working_slinear(self): num_train = 10 x0_min, x0_max = -5.0, 10.0 x1_min, x1_max = 0.0, 15.0 train_x0 = np.linspace(x0_min, x0_max, num_train) train_x1 = np.linspace(x1_min, x1_max, num_train) t_data = np.array([[308.12909601, 253.61567418, 204.6578079, 161.25549718, 123.40874201, 91.1175424, 64.38189835, 43.20180985, 27.5772769, 17.50829952], [162.89542418, 123.20470795, 89.06954726, 60.48994214, 37.46589257, 19.99739855, 8.08446009, 1.72707719, 0.92524984, 5.67897804,], [ 90.2866907, 63.02637433, 41.32161352, 25.17240826, 14.57875856, 9.54066442, 10.05812583, 16.13114279, 27.75971531, 44.94384339,], [ 55.60211264, 38.37989042, 26.71322375, 20.60211264, 20.04655709, 25.04655709, 35.60211264, 51.71322375, 73.37989042, 100.60211264], [ 22.81724065, 13.24080685, 9.2199286, 10.75460591, 17.84483877, 30.49062719, 48.69197117, 72.4488707, 101.76132579, 136.62933643], [ 5.11168719, 0.78873608, 2.02134053, 8.80950054, 21.1532161, 39.05248721, 62.50731389, 91.51769611, 126.0836339, 166.20512723], [ 14.3413983, 12.87962416, 16.97340558, 26.62274256, 41.82763509, 62.58808317, 88.90408682, 120.77564601, 158.20276077, 201.18543108], [ 20.18431209, 19.1914092, 23.75406186, 33.87227009, 49.54603386, 70.77535319, 97.56022808, 129.90065853, 167.79664453, 211.24818608], [ 8.48953212, 5.57319475, 8.21241294, 16.40718668, 30.15751598, 49.46340083, 74.32484124, 104.74183721, 140.71438873, 182.2424958 ], [ 10.96088904, 3.72881146, 2.05228945, 5.93132298, 15.36591208, 30.35605673, 50.90175693, 77.00301269, 108.65982401, 145.87219088]]) prob = om.Problem() ivc = om.IndepVarComp() ivc.add_output('x0', 0.0) ivc.add_output('x1', 0.0) prob.model.add_subsystem('p', ivc, promotes=['*']) mm = prob.model.add_subsystem('mm', om.MetaModelStructuredComp(method='slinear'), promotes=['x0', 'x1']) mm.add_input('x0', 0.0, train_x0) mm.add_input('x1', 0.0, train_x1) mm.add_output('f', 0.0, t_data) prob.setup() prob.final_setup() MetaModelVisualization(mm)
def test_working_scipy_slinear(self): # Create regular grid interpolator instance xor_interp = om.MetaModelStructuredComp(method='scipy_slinear') # 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 = om.Group() ivc = om.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 = om.Problem(model) prob.setup() MetaModelVisualization(xor_interp)
def setup(self): nn = self.options['num_nodes'] self.add_subsystem('comp', om.ExecComp('I_peak= I*2**0.5', I={ 'value': np.ones(nn), 'units': 'A' }), promotes_inputs=['I'], promotes_outputs=['I_peak']) motor_interp = om.MetaModelStructuredComp(method='scipy_slinear', extrapolate=True) rpm_data = np.array( [200, 600, 1000, 1800, 2200, 3000, 3400, 4200, 5000, 5400]) # 1400, 2600, 3800, 4600 current_data = np.array( [10, 14.4, 18.9, 23.3, 27.8, 32.2, 36.7, 41.1, 45.6, 50]) motor_interp.add_input('rpm', 5400 * np.ones(nn), training_data=rpm_data, units='rpm') motor_interp.add_input('I_peak', 50, training_data=current_data, units='A') motor_interp.add_output('AC_power_factor', 0.5, training_data=motor_loss_data) self.add_subsystem('ac_power_factor_interp', motor_interp, promotes_inputs=['rpm', 'I_peak'], promotes_outputs=['AC_power_factor']) self.add_subsystem(name='copperloss', subsys=WindingLossComp(num_nodes=nn), promotes_inputs=[ 'resistivity_wire', 'stack_length', 'n_slots', 'n_turns', 'T_coeff_cu', 'I', 'T_windings', 'r_strand', 'n_m', 'mu_o', 'mu_r', 'n_strands', 'rpm', 'AC_power_factor' ], promotes_outputs=[ 'A_cu', 'f_e', 'r_litz', 'P_dc', 'P_ac', 'P_wire', 'L_wire', 'R_dc', 'skin_depth', 'temp_resistivity' ]) self.add_subsystem(name='steinmetzloss', subsys=SteinmetzLossComp(num_nodes=nn), promotes_inputs=[ 'alpha_stein', 'B_pk', 'f_e', 'beta_stein', 'k_stein', 'sta_mass' ], promotes_outputs=['P_steinmetz'])
def test_meta_model(self): import openmdao.api as om from openmdao.components.tests.test_meta_model_structured_comp import SampleMap filename = 'pyxdsm_meta_model' out_format = PYXDSM_OUT model = om.Group() ivc = om.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 = om.MetaModelStructuredComp(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=["*"]) prob = om.Problem(model) prob.setup() prob.final_setup() om.write_xdsm(prob, filename=filename, out_format=out_format, quiet=QUIET, show_browser=SHOW, show_parallel=True) # Check if file was created self.assertTrue(os.path.isfile('.'.join([filename, out_format])))
def setup(self): num_nodes = self.options['num_nodes'] num_radial = self.options['num_radial'] num_blades = self.options['num_blades'] af_filename = self.options['af_filename'] turbine = self.options['turbine'] installed_thrust_loss = self.options['installed_thrust_loss'] comp = om.ExecComp([ 'hub_radius = 0.5*hub_diameter', 'prop_radius = 0.5*prop_diameter' ], shape=num_nodes, has_diag_partials=True, hub_radius={'units': 'm'}, hub_diameter={'units': 'm'}, prop_radius={'units': 'm'}, prop_diameter={'units': 'm'}) self.add_subsystem('hub_prop_radius_comp', comp, promotes=['*']) # Stole this from John Hwang's OpenBEMT code. this_dir = os.path.split(__file__)[0] file_path = os.path.join(this_dir, 'airfoils', af_filename) af = af_from_files([file_path]) comp = make_component( CCBladeResidualComp(num_nodes=num_nodes, num_radial=num_radial, af=af, B=num_blades, turbine=turbine)) comp.linear_solver = om.DirectSolver(assemble_jac=True) self.add_subsystem('ccblade_comp', comp, promotes_inputs=[("r", "radii"), "chord", "theta", "Vx", "Vy", "rho", "mu", "asound", ("Rhub", "hub_radius"), ("Rtip", "prop_radius"), "precone", "pitch"], promotes_outputs=['Np', 'Tp']) comp = FunctionalsComp(num_nodes=num_nodes, num_radial=num_radial, num_blades=num_blades) if installed_thrust_loss: promotes_outputs = [('thrust', 'uninstalled_thrust'), 'torque', 'power', 'efficiency'] else: promotes_outputs = ['thrust', 'torque', 'power', 'efficiency'] self.add_subsystem('ccblade_torquethrust_comp', comp, promotes_inputs=[ 'hub_radius', 'prop_radius', 'radii', 'Np', 'Tp', 'v', 'omega' ], promotes_outputs=promotes_outputs) if installed_thrust_loss: comp = BertonInstalledThrustLossInputComp(num_nodes=num_nodes) self.add_subsystem('installed_thrust_loss_inputs_comp', comp, promotes_inputs=['omega', 'v', 'prop_diameter'], promotes_outputs=['sqa', 'zje']) comp = om.MetaModelStructuredComp(vec_size=num_nodes) comp.add_input('sqa', val=0.0, training_data=sqa_training, units=None) comp.add_input('zje', val=0.0, training_data=zje_training, units=None) comp.add_output('fb', val=1.0, training_data=fb_training, units=None) self.add_subsystem('installed_thrust_loss_mm_comp', comp, promotes_inputs=['sqa', 'zje'], promotes_outputs=['fb']) comp = om.ExecComp('thrust = fb*uninstalled_thrust', has_diag_partials=True, uninstalled_thrust={ 'units': 'N', 'shape': num_nodes }, fb={ 'units': None, 'shape': num_nodes }, thrust={ 'units': 'N', 'shape': num_nodes }) self.add_subsystem('installed_thrust_loss_comp', comp, promotes_inputs=['fb', 'uninstalled_thrust'], promotes_outputs=['thrust'])
if __name__ == "__main__": nn = 5 prob = om.Problem() ivc = om.IndepVarComp() ivc.add_output('omega', val=2700.0, shape=nn, units='rev/min') ivc.add_output('v', val=150.0, shape=nn, units='knot') ivc.add_output('prop_diameter', val=74.0, shape=nn, units='inch') prob.model.add_subsystem('ivc', ivc, promotes=['*']) comp = BertonInstalledThrustLossInputComp(num_nodes=nn) prob.model.add_subsystem('thrust_loss_inputs_comp', comp, promotes=['*']) comp = om.MetaModelStructuredComp(vec_size=nn) comp.add_input('sqa', val=0.0, training_data=sqa_training, units=None) comp.add_input('zje', val=0.0, training_data=zje_training, units=None) comp.add_output('fb', val=1.0, training_data=fb_training, units=None) prob.model.add_subsystem('installed_thrust_loss_mm_comp', comp, promotes_inputs=['sqa', 'zje'], promotes_outputs=['fb']) comp = om.ExecComp('installed_thrust = fb*bemt_thrust', has_diag_partials=True, bemt_thrust={ 'units': 'N', 'shape': nn }, fb={
def setup(self): map_data = self.options['map_data'] design = self.options['design'] method = self.options['interp_method'] extrap = self.options['extrap'] params = map_data.param_data outputs = map_data.output_data # Define map which will be used readmap = om.MetaModelStructuredComp(method=method, extrapolate=extrap) for p in params: readmap.add_input(p['name'], val=p['default'], units=p['units'], training_data=p['values']) for o in outputs: readmap.add_output(o['name'], val=o['default'], units=o['units'], training_data=o['values']) if design: # In design mode, operating point specified by default values for RlineMap, NcMap and alphaMap mapDesPt = om.IndepVarComp() mapDesPt.add_output('NpMap', val=map_data.defaults['NpMap'], units='rpm') mapDesPt.add_output('PRmap', val=map_data.defaults['PRmap'], units=None) self.add_subsystem('mapDesPt', subsys=mapDesPt, promotes=['*']) # Evaluate map using design point values self.add_subsystem('readMap', readmap, promotes_inputs=['alphaMap', 'NpMap', 'PRmap'], promotes_outputs=['effMap', 'WpMap']) # Compute map scalars based on input PR, eff, Np and Wp as well as unscaled map values self.add_subsystem( 'scalars', MapScalars(), promotes_inputs=[ 'PR', 'eff', 'Np', 'Wp', 'NpMap', 'effMap', 'PRmap', 'WpMap' ], promotes_outputs=['s_Np', 's_PR', 's_eff', 's_Wp']) else: # In off-design mode, PRmap, NpMap and alphaMap are input to map self.add_subsystem('readMap', readmap, promotes_inputs=['alphaMap', 'NpMap', 'PRmap'], promotes_outputs=['effMap', 'WpMap']) # Compute scaled map outputs base on input scalars and unscaled map values self.add_subsystem('scaledOutput', ScaledMapValues(), promotes_inputs=[ 's_PR', 's_eff', 's_Wp', 's_Np', 'NpMap', 'effMap', 'PRmap', 'WpMap' ], promotes_outputs=['PR', 'eff']) # Use balance component to vary NpMap and PRmap to match incoming corrected flow and speed map_bal = om.BalanceComp() map_bal.add_balance('NpMap', val=map_data.defaults['NpMap'], units='rpm', eq_units='rpm', lower=1., upper=200.) map_bal.add_balance('PRmap', val=map_data.defaults['PRmap'], units=None, eq_units='lbm/s', lower=1.01) self.add_subsystem(name='map_bal', subsys=map_bal, promotes_inputs=[('lhs:NpMap', 'Np'), ('lhs:PRmap', 'Wp')], promotes_outputs=['NpMap', 'PRmap']) self.connect('scaledOutput.Np', 'map_bal.rhs:NpMap') self.connect('scaledOutput.Wp', 'map_bal.rhs:PRmap')
x0_min, x0_max = -5.0, 10.0 x1_min, x1_max = 0.0, 15.0 train_x0 = np.linspace(x0_min, x0_max, num_train) train_x1 = np.linspace(x1_min, x1_max, num_train) t_data = np.array([[308.12909601, 253.61567418, 204.6578079, 161.25549718, 123.40874201, 91.1175424, 64.38189835, 43.20180985, 27.5772769, 17.50829952], [162.89542418, 123.20470795, 89.06954726, 60.48994214, 37.46589257, 19.99739855, 8.08446009, 1.72707719, 0.92524984, 5.67897804,], [ 90.2866907, 63.02637433, 41.32161352, 25.17240826, 14.57875856, 9.54066442, 10.05812583, 16.13114279, 27.75971531, 44.94384339,], [ 55.60211264, 38.37989042, 26.71322375, 20.60211264, 20.04655709, 25.04655709, 35.60211264, 51.71322375, 73.37989042, 100.60211264], [ 22.81724065, 13.24080685, 9.2199286, 10.75460591, 17.84483877, 30.49062719, 48.69197117, 72.4488707, 101.76132579, 136.62933643], [ 5.11168719, 0.78873608, 2.02134053, 8.80950054, 21.1532161, 39.05248721, 62.50731389, 91.51769611, 126.0836339, 166.20512723], [ 14.3413983, 12.87962416, 16.97340558, 26.62274256, 41.82763509, 62.58808317, 88.90408682, 120.77564601, 158.20276077, 201.18543108], [ 20.18431209, 19.1914092, 23.75406186, 33.87227009, 49.54603386, 70.77535319, 97.56022808, 129.90065853, 167.79664453, 211.24818608], [ 8.48953212, 5.57319475, 8.21241294, 16.40718668, 30.15751598, 49.46340083, 74.32484124, 104.74183721, 140.71438873, 182.2424958 ], [ 10.96088904, 3.72881146, 2.05228945, 5.93132298, 15.36591208, 30.35605673, 50.90175693, 77.00301269, 108.65982401, 145.87219088]]) prob = om.Problem() mm = prob.model.add_subsystem('mm1', om.MetaModelStructuredComp(method='slinear'), promotes=['x0', 'x1']) mm2 = prob.model.add_subsystem('mm2', om.MetaModelStructuredComp(method='slinear'), promotes=['x0', 'x1']) mm.add_input('x0', 0.0, train_x0) mm.add_input('x1', 0.0, train_x1) mm.add_output('f', 0.0, t_data) mm2.add_input('x0', 0.0, train_x0) mm2.add_input('x1', 0.0, train_x1) mm2.add_output('f', 0.0, t_data) prob.setup() prob.final_setup()
def setup(self): nn = self.options["num_nodes"] n_alpha = self.options["alpha_train"].size n_Mach = self.options["Mach_train"].size n_alt = self.options["alt_train"].size # Training data self.add_subsystem( "training_data", VLMDataGen( num_x=self.options["num_x"], num_y=self.options["num_y"], num_twist=self.options["num_twist"], alpha_train=self.options["alpha_train"], Mach_train=self.options["Mach_train"], alt_train=self.options["alt_train"], surf_options=self.options["surf_options"], ), promotes_inputs=[ "ac|geom|wing|S_ref", "ac|geom|wing|AR", "ac|geom|wing|taper", "ac|geom|wing|c4sweep", "ac|geom|wing|twist", "ac|aero|CD_nonwing", "fltcond|TempIncrement", ], ) # Surrogate model interp = om.MetaModelStructuredComp(method="scipy_cubic", training_data_gradients=True, vec_size=nn, extrapolate=True) interp.add_input("fltcond|M", 0.1, training_data=self.options["Mach_train"]) interp.add_input("alpha", 0.0, units="deg", training_data=self.options["alpha_train"]) interp.add_input("fltcond|h", 0.0, units="m", training_data=self.options["alt_train"]) interp.add_output("CL", training_data=np.zeros((n_Mach, n_alpha, n_alt))) interp.add_output("CD", training_data=np.zeros((n_Mach, n_alpha, n_alt))) self.add_subsystem("aero_surrogate", interp, promotes_inputs=["fltcond|M", "fltcond|h"]) self.connect("training_data.CL_train", "aero_surrogate.CL_train") self.connect("training_data.CD_train", "aero_surrogate.CD_train") # Solve for angle of attack that meets input lift coefficient self.add_subsystem( "alpha_bal", om.BalanceComp("alpha", eq_units=None, lhs_name="CL_VLM", rhs_name="fltcond|CL", val=np.ones(nn), units="deg"), promotes_inputs=["fltcond|CL"], ) self.connect("alpha_bal.alpha", "aero_surrogate.alpha") self.connect("aero_surrogate.CL", "alpha_bal.CL_VLM") # Compute drag force from drag coefficient self.add_subsystem( "drag_calc", om.ExecComp( "drag = q * S * CD", drag={ "units": "N", "shape": (nn, ) }, q={ "units": "Pa", "shape": (nn, ) }, S={"units": "m**2"}, CD={"shape": (nn, )}, ), promotes_inputs=[("q", "fltcond|q"), ("S", "ac|geom|wing|S_ref")], promotes_outputs=["drag"], ) self.connect("aero_surrogate.CD", "drag_calc.CD")
def setup(self): nn = self.options['num_nodes'] config = self.options['config'] temp2_interp = om.MetaModelStructuredComp(method='lagrange2', extrapolate=True) temp3_interp = om.MetaModelStructuredComp(method='lagrange2', extrapolate=True) if (config != 'honeycomb'): energy_bp = np.linspace(16., 32., 5) extra_bp = np.linspace(1., 2.0, 6) ratio_bp = np.linspace(0.2, 1.0, 5) else: energy_bp = np.linspace(16., 32., 5) extra_bp = np.linspace(1., 1.5, 6) #res_bp = np.linspace(0.006, 0.006, 1) temp2_interp.add_input('energy', val=16, training_data=energy_bp, units='kJ') temp2_interp.add_input('extra', val=1, training_data=extra_bp, units='mm') #temp2_interp.add_input('resistance', val=0.006, training_data=res_bp, units='degK*mm**2/W') #temp2_interp.add_input('time', val=0, training_data= time_bp, units='s') temp3_interp.add_input('energy', val=16, training_data=energy_bp, units='kJ') temp3_interp.add_input('extra', val=1, training_data=extra_bp, units='mm') #temp3_interp.add_input('resistance', val=0.006, training_data=res_bp, units='degK*mm**2/W') #temp3_interp.add_input('time', val=0, training_data= time_bp, units='s') if (config != 'honeycomb'): temp2_interp.add_input('ratio', val=1, training_data=ratio_bp) temp3_interp.add_input('ratio', val=1, training_data=ratio_bp) inpts = ['energy', 'extra', 'ratio'] else: inpts = ['energy', 'extra'] temp2_interp.add_output('temp2_data', val=300 * np.ones(nn), training_data=t_data2, units='degK') temp3_interp.add_output('temp3_data', val=300 * np.ones(nn), training_data=t_data3, units='degK') self.add_subsystem('meta_temp2_data', temp2_interp, promotes_inputs=inpts, promotes_outputs=['temp2_data']) self.add_subsystem( 'meta_temp3_data', temp3_interp, promotes_inputs=inpts, # comment out to view_mm promotes_outputs=['temp3_data']) if (config == 'honeycomb'): # if mass is computed by COMSOL mass_interp = om.MetaModelStructuredComp(method='lagrange2', extrapolate=True) mass_interp.add_input('energy', val=16, training_data=energy_bp, units='kJ') mass_interp.add_input('extra', val=1, training_data=extra_bp, units='mm') mass_interp.add_output('mass', val=0.5 * np.ones(nn), training_data=m_data, units='kg') self.add_subsystem('meta_mass_data', mass_interp, promotes_inputs=['energy', 'extra'], promotes_outputs=['mass'])
def setup(self): map_data = self.options['map_data'] design = self.options['design'] method = self.options['interp_method'] extrap = self.options['extrap'] params = map_data.param_data outputs = map_data.output_data # Define map which will be used readmap = om.MetaModelStructuredComp(method=method, extrapolate=extrap) for p in params: readmap.add_input(p['name'], val=p['default'], units=p['units'], training_data=p['values']) for o in outputs: readmap.add_output(o['name'], val=o['default'], units=o['units'], training_data=o['values']) # Create instance of map for evaluating actual operating point if design: # In design mode, operating point specified by default values for RlineMap, NcMap and alphaMap mapDesPt = om.IndepVarComp() mapDesPt.add_output('NcMap', val=map_data.defaults['NcMap'], units='rpm') mapDesPt.add_output('RlineMap', val=map_data.defaults['RlineMap'], units=None) self.add_subsystem('mapDesPt', subsys=mapDesPt, promotes=['*']) # Evaluate map using design point values self.add_subsystem('map', readmap, promotes_inputs=['RlineMap', 'NcMap', 'alphaMap'], promotes_outputs=['effMap', 'PRmap', 'WcMap']) # Compute map scalars based on input PR, eff, Nc and Wc as well as unscaled map values self.add_subsystem('scalars', MapScalars(), promotes_inputs=['PR', 'eff', 'Nc', 'Wc', 'NcMap', 'effMap', 'PRmap', 'WcMap'], promotes_outputs=['s_Nc', 's_PR', 's_eff', 's_Wc']) else: # In off-design mode, RlineMap, NcMap and alphaMap are input to map self.add_subsystem('map', readmap, promotes_inputs=['RlineMap', 'NcMap', 'alphaMap'], promotes_outputs=['effMap', 'PRmap', 'WcMap']) # Compute scaled map outputs base on input scalars and unscaled map values self.add_subsystem('scaledOutput', ScaledMapValues(), promotes_inputs=['s_PR', 's_eff', 's_Wc', 's_Nc', 'NcMap', 'effMap', 'PRmap', 'WcMap'], promotes_outputs=['PR', 'eff']) # Use balance component to vary NcMap and RlineMap to match incoming corrected flow and speed map_bal = om.BalanceComp() map_bal.add_balance('NcMap', val=map_data.defaults['NcMap'], units='rpm', eq_units='rpm') map_bal.add_balance('RlineMap', val=map_data.defaults['RlineMap'], units=None, eq_units='lbm/s', lower=map_data.RlineStall) self.add_subsystem(name='map_bal', subsys=map_bal, promotes_inputs=[('lhs:NcMap','Nc'),('lhs:RlineMap','Wc')], promotes_outputs=['NcMap', 'RlineMap']) self.connect('scaledOutput.Nc','map_bal.rhs:NcMap') self.connect('scaledOutput.Wc','map_bal.rhs:RlineMap') # Define the Rline corresponding to stall RlineStall = om.IndepVarComp() RlineStall.add_output('RlineStall', val=map_data.RlineStall, units=None) self.add_subsystem('stall_R', subsys=RlineStall) # Evaluate map for the constant speed stall margin (SMN) SMN_map = om.MetaModelStructuredComp(method=method, extrapolate=extrap) for p in params: SMN_map.add_input(p['name'], val=p['default'], units=p['units'], training_data=p['values']) for o in outputs: SMN_map.add_output(o['name'], val=o['default'], units=o['units'], training_data=o['values']) self.add_subsystem('SMN_map', SMN_map, promotes_inputs=['NcMap', 'alphaMap']) self.connect('stall_R.RlineStall', 'SMN_map.RlineMap') # Evaluate map for the constant speed stall margin (SMN) SMW_map = om.MetaModelStructuredComp(method=method, extrapolate=extrap) for p in params: SMW_map.add_input(p['name'], val=p['default'], units=p['units'], training_data=p['values']) for o in outputs: SMW_map.add_output(o['name'], val=o['default'], units=o['units'], training_data=o['values']) self.add_subsystem('SMW_map', SMW_map, promotes_inputs=['alphaMap']) self.connect('stall_R.RlineStall', 'SMW_map.RlineMap') # Use balance to vary NcMap on SMW map to hold corrected flow constant SMW_bal = om.BalanceComp() SMW_bal.add_balance('NcMap', val=map_data.defaults['NcMap'], units='rpm', eq_units='lbm/s') self.add_subsystem(name='SMW_bal', subsys=SMW_bal) self.connect('SMW_bal.NcMap', 'SMW_map.NcMap') self.connect('WcMap','SMW_bal.lhs:NcMap') self.connect('SMW_map.WcMap','SMW_bal.rhs:NcMap') # Compute the stall margins self.add_subsystem('stall_margins', StallCalcs(), promotes_inputs=[('PR_actual','PRmap'),('Wc_actual','WcMap')], promotes_outputs=['SMN','SMW']) self.connect('SMN_map.PRmap', 'stall_margins.PR_SMN') self.connect('SMW_map.PRmap', 'stall_margins.PR_SMW') self.connect('SMN_map.WcMap', 'stall_margins.Wc_SMN')
def setup(self): nn = self.options['num_nodes'] config = self.options['config'] temp2_interp = om.MetaModelStructuredComp(method='lagrange2', extrapolate=True) temp3_interp = om.MetaModelStructuredComp(method='lagrange2', extrapolate=True) energy_bp = np.linspace(16., 32., 5) #np.array([0.1, 8,16,24,32,40,48]) extra_bp = np.linspace(1.1, 1.5, 5) ratio_bp = np.linspace(0.1, 0.9, 5) # <-- #res_bp = np.linspace(0.006, 0.006, 1) temp2_interp.add_input('energy', val=16, training_data=energy_bp, units='kJ') temp2_interp.add_input('extra', val=1, training_data=extra_bp) temp2_interp.add_input('ratio', val=1, training_data=ratio_bp) # <-- #temp2_interp.add_input('resistance', val=0.006, training_data=res_bp, units='degK*mm**2/W') #temp2_interp.add_input('time', val=0, training_data= time_bp, units='s') temp3_interp.add_input('energy', val=16, training_data=energy_bp, units='kJ') temp3_interp.add_input('extra', val=1, training_data=extra_bp) temp3_interp.add_input('ratio', val=1, training_data=ratio_bp) # <-- #temp3_interp.add_input('resistance', val=0.006, training_data=res_bp, units='degK*mm**2/W') #temp3_interp.add_input('time', val=0, training_data= time_bp, units='s') temp2_interp.add_output('temp2_data', val=300 * np.ones(nn), training_data=t_data2, units='degK') temp3_interp.add_output('temp3_data', val=300 * np.ones(nn), training_data=t_data3, units='degK') inpts = ['energy', 'extra', 'ratio'] self.add_subsystem('meta_temp2_data', temp2_interp, promotes_inputs=inpts, promotes_outputs=['temp2_data']) self.add_subsystem('meta_temp3_data', temp3_interp, promotes_inputs=inpts, promotes_outputs=['temp3_data']) # if mass is computed by COMSOL mass_interp = om.MetaModelStructuredComp(method='lagrange2', extrapolate=True) mass_interp.add_input('energy', val=16, training_data=energy_bp, units='kJ') mass_interp.add_input('extra', val=1, training_data=extra_bp) mass_interp.add_input('ratio', val=1, training_data=ratio_bp) # <-- mass_interp.add_output('mass', val=0.5 * np.ones(nn), training_data=m_data, units='kg') self.add_subsystem('meta_mass_data', mass_interp, promotes_inputs=['energy', 'extra', 'ratio'], promotes_outputs=['mass'])