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'])
