def test_case1(self):
# 6 cases to check against
for i, data in enumerate(ref_data):
# input torques
self.top['trq_0'] = data[h_map['trqLoad1']]
self.top['trq_1'] = data[h_map['trqLoad2']]
self.top['trq_2'] = data[h_map['trqLoad3']]
# shaft inputs
self.top['Nmech'] = data[h_map['Nmech']]
self.top['HPX'] = data[h_map['HPX']]
self.top['fracLoss'] = data[h_map['fracLoss']]
self.top.run_model()
# check outputs
trqIn, trqOut, trqNet = data[h_map['trqIn']], data[
h_map['trqOut']], data[h_map['trqNet']]
pwrIn, pwrOut, pwrNet = data[h_map['pwrIn']], data[
h_map['pwrOut']], data[h_map['pwrNet']]
trqIn_comp = self.top['trq_in']
trqOut_comp = self.top['trq_out']
trqNet_comp = self.top['trq_net']
pwrIn_comp = self.top['pwr_in']
pwrOut_comp = self.top['pwr_out']
pwrNet_comp = self.top['pwr_net']
tol = 1.0e-4
assert_near_equal(trqIn_comp, trqIn, tol)
assert_near_equal(trqOut_comp, trqOut, tol)
assert_near_equal(trqNet_comp, trqNet, tol)
assert_near_equal(pwrIn_comp, pwrIn, tol)
assert_near_equal(pwrOut_comp, pwrOut, tol)
assert_near_equal(pwrNet_comp, pwrNet, tol)
check_element_partials(self, self.top)
def test_case1(self):
# 4 cases to check against
for i, data in enumerate(ref_data):
self.prob['inlet.ram_recovery'] = data[h_map['eRamBase']]
# input flowstation
self.prob['flow_start.P'] = data[h_map['Fl_I.Pt']]
self.prob['flow_start.T'] = data[h_map['Fl_I.Tt']]
self.prob['inlet.MN'] = data[h_map['Fl_O.MN']]
self.prob['flow_start.W'] = data[h_map['Fl_I.W']]
self.prob['inlet.Fl_I:stat:V'] = data[h_map['Fl_I.V']]
self.prob.run_model()
# check outputs
pt, ht, Fram, ps, ts = data[h_map['Fl_O.Pt']], data[
h_map['Fl_O.ht']], data[h_map['Fram']], data[
h_map['Fl_O.Ps']], data[h_map['Fl_O.Ts']]
pt_computed = self.prob['inlet.Fl_O:tot:P']
ht_computed = self.prob['inlet.Fl_O:tot:h']
Fram_computed = self.prob['inlet.F_ram']
ps_computed = self.prob['inlet.Fl_O:stat:P']
ts_computed = self.prob['inlet.Fl_O:stat:T']
tol = 1e-4
assert_near_equal(pt_computed, pt, tol)
assert_near_equal(ht_computed, ht, tol)
assert_near_equal(Fram_computed, Fram, tol)
assert_near_equal(ps_computed, ps, tol)
assert_near_equal(ts_computed, ts, tol)
check_element_partials(self, self.prob)
def test_case1(self):
# 6 cases to check against
for i, data in enumerate(ref_data):
self.prob['fc.alt'] = data[h_map['alt']]
self.prob['fc.MN'] = data[h_map['MN']]
self.prob['fc.dTs'] = data[h_map['dTs']]
if self.prob['fc.MN'] < 1e-10:
self.prob['fc.MN'] += 1e-6
self.prob.run_model()
# check outputs
Pt = data[h_map['Pt']]
Pt_c = self.prob['fc.Fl_O:tot:P']
Ps = data[h_map['Ps']]
Ps_c = self.prob['fc.Fl_O:stat:P']
Tt = data[h_map['Tt']]
Tt_c = self.prob['fc.Fl_O:tot:T']
Ts = data[h_map['Ts']]
Ts_c = self.prob['fc.Fl_O:stat:T']
tol = 1e-4
assert_near_equal(Pt_c, Pt, tol)
assert_near_equal(Ps_c, Ps, tol)
assert_near_equal(Tt_c, Tt, tol)
assert_near_equal(Ps_c, Ps, tol)
check_element_partials(self, self.prob, depth=3)
def test_CDnozzle(self):
print('Testing CD Nozzle')
self.setup_helper(NozzType='CD', LossType='Cv')
self.ref_data = np.loadtxt(self.fpath + "/reg_data/nozzleCD.csv", delimiter=",", skiprows=1)
self.run_helper()
check_element_partials(self, self.prob)
def test_case1(self):
# 4 cases to check against
for i, data in enumerate(ref_data):
self.prob['inlet.ram_recovery'] = data[h_map['eRamBase']]
# input flowstation
self.prob['P'] = data[h_map['Fl_I.Pt']]
self.prob['T'] = data[h_map['Fl_I.Tt']]
self.prob['MN'] = data[h_map['Fl_O.MN']]
self.prob['W'] = data[h_map['Fl_I.W']]
self.prob['V'] = data[h_map['Fl_I.V']]
self.prob.run_model()
# check outputs
pt, ht, Fram, ps, ts = data[h_map['Fl_O.Pt']], data[h_map['Fl_O.ht']], data[
h_map['Fram']], data[h_map['Fl_O.Ps']], data[h_map['Fl_O.Ts']]
pt_computed = self.prob['inlet.Fl_O:tot:P']
ht_computed = self.prob['inlet.Fl_O:tot:h']
Fram_computed = self.prob['inlet.F_ram']
ps_computed = self.prob['inlet.Fl_O:stat:P']
ts_computed = self.prob['inlet.Fl_O:stat:T']
tol = 1e-4
# rel_err = abs(pt_computed - pt) / pt_computed
assert_rel_error(self, pt_computed, pt, tol)
assert_rel_error(self, ht_computed, ht, tol)
assert_rel_error(self, Fram_computed, Fram, tol)
assert_rel_error(self, ps_computed, ps, tol)
assert_rel_error(self, ts_computed, ts, tol)
check_element_partials(self, self.prob)
def test_case1(self):
np.seterr(divide='raise')
# 6 cases to check against
for i, data in enumerate(ref_data):
self.prob['des_vars.alt'] = data[h_map['alt']]
# self.prob['des_vars.MN'] = data[h_map['MN']]
self.prob['des_vars.dTs'] = data[h_map['dTs']]
self.prob.run_model()
# check outputs
tol = 1.0e-2 # seems a little generous
npss = data[h_map['Ps']]
pyc = self.prob['amb.Ps']
rel_err = abs(npss - pyc) / npss
# print( 'Ps:', npss, pyc, rel_err)
self.assertLessEqual(rel_err, tol)
npss = data[h_map['Ts']]
pyc = self.prob['amb.Ts']
rel_err = abs(npss - pyc) / npss
# print( 'Ts:', npss, pyc, rel_err)
self.assertLessEqual(rel_err, tol)
# print()
check_element_partials(self, self.prob)
def test_case1(self):
thermo = Thermo(janaf, constants.AIR_MIX)
self.prob = Problem()
self.prob.model = Group()
self.prob.model.add_subsystem('flow_start',
FlowStart(thermo_data=janaf,
elements=AIR_MIX),
promotes=['MN', 'P', 'T'])
self.prob.model.add_subsystem('duct',
Duct(elements=AIR_MIX),
promotes=['MN'])
connect_flow(self.prob.model, 'flow_start.Fl_O', 'duct.Fl_I')
self.prob.model.set_input_defaults('MN', 0.5)
self.prob.model.set_input_defaults('duct.dPqP', 0.0)
self.prob.model.set_input_defaults('P', 17., units='psi')
self.prob.model.set_input_defaults('T', 500., units='degR')
self.prob.model.set_input_defaults('flow_start.W', 500., units='lbm/s')
self.prob.setup(check=False)
self.prob.set_solver_print(level=-1)
# 6 cases to check against
for i, data in enumerate(ref_data):
self.prob['duct.dPqP'] = data[h_map['dPqP']]
# input flowstation
self.prob['P'] = data[h_map['Fl_I.Pt']]
self.prob['T'] = data[h_map['Fl_I.Tt']]
self.prob['MN'] = data[h_map['Fl_O.MN']]
self.prob['flow_start.W'] = data[h_map['Fl_I.W']]
self.prob['duct.Fl_I:stat:V'] = data[h_map['Fl_I.V']]
# give a decent initial guess for Ps
print(i, self.prob['P'], self.prob['T'], self.prob['MN'])
self.prob.run_model()
# check outputs
pt, ht, ps, ts = data[h_map['Fl_O.Pt']], data[h_map[
'Fl_O.ht']], data[h_map['Fl_O.Ps']], data[h_map['Fl_O.Ts']]
pt_computed = self.prob['duct.Fl_O:tot:P']
ht_computed = self.prob['duct.Fl_O:tot:h']
ps_computed = self.prob['duct.Fl_O:stat:P']
ts_computed = self.prob['duct.Fl_O:stat:T']
tol = 2.0e-2
assert_near_equal(pt_computed, pt, tol)
assert_near_equal(ht_computed, ht, tol)
assert_near_equal(ps_computed, ps, tol)
assert_near_equal(ts_computed, ts, tol)
check_element_partials(self, self.prob)
def test_CD_CVnozzle_Cfg(self):
print('Testing CD_CV Nozzle with Cfg')
self.setup_helper(NozzType='CD_CV', LossType='Cfg')
self.ref_data = np.loadtxt(self.fpath +
"/reg_data/nozzleCD_CV__Cfg.csv",
delimiter=",",
skiprows=1)
self.run_helper(LossType='Cfg')
check_element_partials(self, self.prob)
def test_case1(self):
# 6 cases to check against
for i, data in enumerate(ref_data):
self.prob['alt'] = data[h_map['alt']]
self.prob['MN'] = data[h_map['MN']]
self.prob['dTs'] = data[h_map['dTs']]
if self.prob['MN'] < 1e-10:
self.prob['MN'] += 1e-6
# print(data[h_map['alt']], data[h_map['MN']], data[h_map['dTs']])
# from openmdao.api import view_model
# view_model(self.prob)
# exit()
self.prob.run_model()
# check outputs
Pt = data[h_map['Pt']]
Pt_c = self.prob['fc.Fl_O:tot:P']
Ps = data[h_map['Ps']]
Ps_c = self.prob['fc.Fl_O:stat:P']
Tt = data[h_map['Tt']]
Tt_c = self.prob['fc.Fl_O:tot:T']
Ts = data[h_map['Ts']]
Ts_c = self.prob['fc.Fl_O:stat:T']
# print('alt, MN, dts: ', self.prob['alt'], self.prob['MN'], self.prob['dTs'])
# print('Pt:', Pt_c, Pt)
# print('Ps:', Ps_c, Ps)
# print('Tt:', Tt_c, Tt)
# print('Ts:', Ts_c, Ts)
# print()
tol = 1e-4
assert_rel_error(self, Pt_c, Pt, tol)
assert_rel_error(self, Ps_c, Ps, tol)
assert_rel_error(self, Tt_c, Tt, tol)
assert_rel_error(self, Ps_c, Ps, tol)
check_element_partials(self, self.prob, depth=3)
def test_case1(self):
# 4 cases to check against
for i, data in enumerate(ref_data):
self.prob['splitter.BPR'] = data[h_map['BPR']]
# input flowstation
self.prob['flow_start.P'] = data[h_map['Fl_I.Pt']]
self.prob['flow_start.T'] = data[h_map['Fl_I.Tt']]
self.prob['flow_start.W'] = data[h_map['Fl_I.W']]
self.prob['splitter.MN1'] = data[h_map['Fl_O1.MN']]
self.prob['splitter.MN2'] = data[h_map['Fl_O2.MN']]
self.prob['splitter.Fl_I:stat:V'] = data[h_map['Fl_I.V']]
self.prob.run_model()
# check flow1 outputs
pt1, ht1, ps1, ts1 = data[h_map['Fl_O2.Pt']], data[h_map[
'Fl_O1.ht']], data[h_map['Fl_O1.Ps']], data[h_map['Fl_O1.Ts']]
pt1_computed = self.prob['splitter.Fl_O1:tot:P']
ht1_computed = self.prob['splitter.Fl_O1:tot:h']
ps1_computed = self.prob['splitter.Fl_O1:stat:P']
ts1_computed = self.prob['splitter.Fl_O1:stat:T']
tol = 1e-4
assert_near_equal(pt1_computed, pt1, tol)
assert_near_equal(ht1_computed, ht1, tol)
assert_near_equal(ps1_computed, ps1, tol)
assert_near_equal(ts1_computed, ts1, tol)
# check flow2 outputs
pt2, ht2, ps2, ts2 = data[h_map['Fl_O2.Pt']], data[h_map[
'Fl_O2.ht']], data[h_map['Fl_O2.Ps']], data[h_map['Fl_O2.Ts']]
pt2_computed = self.prob['splitter.Fl_O2:tot:P']
ht2_computed = self.prob['splitter.Fl_O2:tot:h']
ps2_computed = self.prob['splitter.Fl_O2:stat:P']
ts2_computed = self.prob['splitter.Fl_O2:stat:T']
assert_near_equal(pt2_computed, pt2, tol)
assert_near_equal(ht2_computed, ht2, tol)
assert_near_equal(ps2_computed, ps2, tol)
assert_near_equal(ts2_computed, ts2, tol)
check_element_partials(self, self.prob)
def test_case1(self):
np.seterr(divide='raise')
# 6 cases to check against
for i, data in enumerate(ref_data):
self.prob['compressor.PR'] = data[h_map['comp.PRdes']]
self.prob['compressor.eff'] = data[h_map['comp.effDes']]
self.prob['compressor.MN'] = data[h_map['comp.Fl_O.MN']]
# input flowstation
self.prob['flow_start.P'] = data[h_map['start.Pt']]
self.prob['flow_start.T'] = data[h_map['start.Tt']]
self.prob['flow_start.W'] = data[h_map['start.W']]
self.prob.run_model()
tol = 1e-3
npss = data[h_map['comp.Fl_O.Pt']]
pyc = self.prob['compressor.Fl_O:tot:P'][0]
print('Pt out:', npss, pyc)
assert_near_equal(pyc, npss, tol)
npss = data[h_map['comp.Fl_O.Tt']]
pyc = self.prob['compressor.Fl_O:tot:T'][0]
print('Tt out:', npss, pyc)
assert_near_equal(pyc, npss, tol)
npss = data[h_map['comp.Fl_O.ht']] - data[h_map['start.Fl_O.ht']]
pyc = self.prob['compressor.Fl_O:tot:h'] - self.prob[
'flow_start.Fl_O:tot:h']
print('delta h:', npss, pyc)
assert_near_equal(pyc, npss, tol)
npss = data[h_map['start.Fl_O.s']]
pyc = self.prob['flow_start.Fl_O:tot:S'][0]
print('S in:', npss, pyc)
assert_near_equal(pyc, npss, tol)
npss = data[h_map['comp.Fl_O.s']]
pyc = self.prob['compressor.Fl_O:tot:S'][0]
print('S out:', npss, pyc)
assert_near_equal(pyc, npss, tol)
npss = data[h_map['comp.pwr']]
pyc = self.prob['compressor.power'][0]
print('Power:', npss, pyc)
assert_near_equal(pyc, npss, tol)
npss = data[h_map['Fl_O.Ps']]
pyc = self.prob['compressor.Fl_O:stat:P'][0]
print('Ps out:', npss, pyc)
assert_near_equal(pyc, npss, tol)
npss = data[h_map['Fl_O.Ts']]
pyc = self.prob['compressor.Fl_O:stat:T'][0]
print('Ts out:', npss, pyc)
assert_near_equal(pyc, npss, tol)
npss = data[h_map['comp.effPoly']]
pyc = self.prob['compressor.eff_poly'][0]
print('effPoly:', npss, pyc)
assert_near_equal(pyc, npss, tol)
print("")
check_element_partials(self, self.prob, tol=5e-5)
def test_case_with_dPqP_MN(self):
self.prob = Problem()
self.prob.model = Group()
self.prob.model.add_subsystem(
'flow_start', FlowStart(thermo_data=janaf, elements=AIR_MIX))
self.prob.model.add_subsystem(
'flow_start_OD', FlowStart(thermo_data=janaf, elements=AIR_MIX))
expMN = 1.0
self.prob.model.add_subsystem('duct_des',
Duct(elements=AIR_MIX, expMN=expMN))
self.prob.model.add_subsystem(
'duct_OD', Duct(elements=AIR_MIX, expMN=expMN, design=False))
connect_flow(self.prob.model, 'flow_start.Fl_O', 'duct_des.Fl_I')
connect_flow(self.prob.model, 'flow_start_OD.Fl_O', 'duct_OD.Fl_I')
des_vars = self.prob.model.add_subsystem('des_vars',
IndepVarComp(),
promotes=['*'])
des_vars.add_output('P', 17., units='psi')
des_vars.add_output('T', 500., units='degR')
des_vars.add_output('W', 500., units='lbm/s')
des_vars.add_output('MN', 0.5)
des_vars.add_output('MN_OD', 0.25)
des_vars.add_output('dPqP_des', 0.0)
self.prob.model.connect("P", ["flow_start.P", 'flow_start_OD.P'])
self.prob.model.connect("T", ["flow_start.T", 'flow_start_OD.T'])
self.prob.model.connect("W", ["flow_start.W", 'flow_start_OD.W'])
self.prob.model.connect("MN", ["duct_des.MN", "flow_start.MN"])
self.prob.model.connect("MN_OD", "flow_start_OD.MN")
self.prob.model.connect("duct_des.s_dPqP", "duct_OD.s_dPqP")
self.prob.model.connect("duct_des.Fl_O:stat:area", "duct_OD.area")
self.prob.model.connect("dPqP_des", "duct_des.dPqP")
self.prob.setup(check=False)
self.prob.set_solver_print(level=-1)
data = ref_data[0]
self.prob['dPqP_des'] = data[h_map['dPqP']]
# input flowstation
self.prob['P'] = data[h_map['Fl_I.Pt']]
self.prob['T'] = data[h_map['Fl_I.Tt']]
self.prob['MN'] = data[h_map['Fl_O.MN']]
self.prob['W'] = data[h_map['Fl_I.W']]
self.prob['duct_des.Fl_I:stat:V'] = data[h_map['Fl_I.V']]
# give a decent initial guess for Ps
print(self.prob['P'], self.prob['T'], self.prob['MN'])
self.prob.run_model()
# check outputs
pt, ht, ps, ts = data[h_map['Fl_O.Pt']], data[h_map['Fl_O.ht']], data[
h_map['Fl_O.Ps']], data[h_map['Fl_O.Ts']]
pt_computed = self.prob['duct_OD.Fl_O:tot:P']
ht_computed = self.prob['duct_OD.Fl_O:tot:h']
ps_computed = self.prob['duct_OD.Fl_O:stat:P']
ts_computed = self.prob['duct_OD.Fl_O:stat:T']
tol = 1.0e-4
assert_rel_error(self, pt_computed, 8.84073152, tol)
assert_rel_error(self, ht_computed, ht, tol)
assert_rel_error(self, ps_computed, 8.26348914, tol)
assert_rel_error(self, ts_computed, ts, tol)
check_element_partials(self, self.prob)
def test_case1(self):
self.prob = Problem()
self.prob.model = Group()
self.prob.model.add_subsystem(
'flow_start', FlowStart(thermo_data=janaf, elements=AIR_MIX))
self.prob.model.add_subsystem('duct', Duct(elements=AIR_MIX))
connect_flow(self.prob.model, 'flow_start.Fl_O', 'duct.Fl_I')
des_vars = self.prob.model.add_subsystem('des_vars',
IndepVarComp(),
promotes=['*'])
des_vars.add_output('P', 17., units='psi')
des_vars.add_output('T', 500., units='degR')
des_vars.add_output('W', 500., units='lbm/s')
des_vars.add_output('MN', 0.5)
des_vars.add_output('dPqP_des', 0.0)
self.prob.model.connect("P", "flow_start.P")
self.prob.model.connect("T", "flow_start.T")
self.prob.model.connect("W", "flow_start.W")
self.prob.model.connect("MN", ["duct.MN", "flow_start.MN"])
self.prob.model.connect("dPqP_des", "duct.dPqP")
self.prob.setup(check=False)
self.prob.set_solver_print(level=-1)
# 6 cases to check against
for i, data in enumerate(ref_data):
self.prob['dPqP_des'] = data[h_map['dPqP']]
# input flowstation
self.prob['P'] = data[h_map['Fl_I.Pt']]
self.prob['T'] = data[h_map['Fl_I.Tt']]
self.prob['MN'] = data[h_map['Fl_O.MN']]
self.prob['W'] = data[h_map['Fl_I.W']]
self.prob['duct.Fl_I:stat:V'] = data[h_map['Fl_I.V']]
# give a decent initial guess for Ps
print(i, self.prob['P'], self.prob['T'], self.prob['MN'])
self.prob.run_model()
# check outputs
pt, ht, ps, ts = data[h_map['Fl_O.Pt']], data[h_map[
'Fl_O.ht']], data[h_map['Fl_O.Ps']], data[h_map['Fl_O.Ts']]
pt_computed = self.prob['duct.Fl_O:tot:P']
ht_computed = self.prob['duct.Fl_O:tot:h']
ps_computed = self.prob['duct.Fl_O:stat:P']
ts_computed = self.prob['duct.Fl_O:stat:T']
tol = 2.0e-2
assert_rel_error(self, pt_computed, pt, tol)
assert_rel_error(self, ht_computed, ht, tol)
assert_rel_error(self, ps_computed, ps, tol)
assert_rel_error(self, ts_computed, ts, tol)
check_element_partials(self, self.prob)
def test_case1(self):
# 4 cases to check against
for i, data in enumerate(ref_data):
print()
print('---- Test Case,', i, '----')
self.prob['PR'] = data[h_map['PRdes']]
self.prob['Nmech'] = data[h_map['Nmech']]
self.prob['eff'] = data[h_map['EffDes']]
self.prob['MN'] = data[h_map['Fl_O.MN']]
# input flowstation
self.prob['P'] = data[h_map['Fl_I.Pt']]
self.prob['T'] = data[h_map['Fl_I.Tt']]
self.prob['W'] = data[h_map['Fl_I.W']]
self.prob['flow_start_MN'] = data[h_map['Fl_I.MN']]
self.prob.run_model()
# check outputs
tol = 5e-4
# print("effDes", self.prob['turbine.map.effDes'])
# print("S_eff", self.prob['turbine.s_effDes'])
# print("effMap", self.prob['turbine.map.desMap.effMap'])
npss = data[h_map['EffDes']]
pyc = self.prob['eff'][0]
print('EffDes:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_I.s']]
pyc = self.prob['flow_start.Fl_O:tot:S'][0]
print('Fl_I.s:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_I.Tt']]
pyc = self.prob['flow_start.Fl_O:tot:T'][0]
print('Fl_I.Tt:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_I.ht']]
pyc = self.prob['flow_start.Fl_O:tot:h'][0]
print('Fl_I.ht:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_I.W']]
pyc = self.prob['flow_start.Fl_O:stat:W'][0]
print('Fl_I.W:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_O.MN']]
pyc = self.prob['MN'][0]
print('Fl_O.MN:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_O.Pt']]
pyc = self.prob['turbine.Fl_O:tot:P'][0]
print('Fl_O.Pt:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_O.ht']]
pyc = self.prob['turbine.Fl_O:tot:h'][0]
print('Fl_O.ht:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_O.Tt']]
pyc = self.prob['turbine.Fl_O:tot:T'][0]
print('Fl_O.Tt:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_O.ht']] - data[h_map['Fl_I.ht']]
pyc = self.prob['turbine.Fl_O:tot:h'][0] - self.prob[
'flow_start.Fl_O:tot:h'][0]
print('Fl_O.ht - Fl_I.ht:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_O.s']]
pyc = self.prob['turbine.Fl_O:tot:S'][0]
print('Fl_O.s:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Power']]
pyc = self.prob['turbine.power'][0]
print('Power:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_O.Ps']]
pyc = self.prob['turbine.Fl_O:stat:P'][0]
print('Fl_O.Ps:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['Fl_O.Ts']]
pyc = self.prob['turbine.Fl_O:stat:T'][0]
print('Fl_O.Ts:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
npss = data[h_map['effPoly']]
pyc = self.prob['turbine.eff_poly'][0]
print('effPoly:', npss, pyc)
assert_rel_error(self, npss, pyc, tol)
check_element_partials(self, self.prob, tol=1e-4)
def test_case1(self):
self.prob = Problem()
self.prob.model = Group()
des_vars = self.prob.model.add_subsystem('des_vars',
IndepVarComp(),
promotes=['*'])
des_vars.add_output('P', 17.0, units='psi')
des_vars.add_output('T', 500.0, units='degR')
des_vars.add_output('W', 100.0, units='lbm/s')
des_vars.add_output('MN', 0.0)
des_vars.add_output('Ps_exhaust', 10.0, units='lbf/inch**2')
self.prob.model.add_subsystem(
'flow_start', FlowStart(thermo_data=janaf, elements=AIR_MIX))
self.prob.model.add_subsystem(
'nozzle',
Nozzle(elements=AIR_MIX, lossCoef='Cfg', internal_solver=True))
fl_src = "flow_start.Fl_O"
fl_target = "nozzle.Fl_I"
for v_name in ('h', 'T', 'P', 'S', 'rho', 'gamma', 'Cp', 'Cv', 'n'):
self.prob.model.connect('%s:tot:%s' % (fl_src, v_name),
'%s:tot:%s' % (fl_target, v_name))
# no prefix
for v_name in ('W', ): # ('Wc', 'W', 'FAR'):
self.prob.model.connect('%s:stat:%s' % (fl_src, v_name),
'%s:stat:%s' % (fl_target, v_name))
self.prob.model.connect('W', 'flow_start.W')
self.prob.model.connect('P', 'flow_start.P')
self.prob.model.connect('T', 'flow_start.T')
self.prob.model.connect('MN', 'flow_start.MN')
# self.prob.model.connect('MN', 'nozzle.Fl_I:stat:MN')
self.prob.model.connect('Ps_exhaust', 'nozzle.Ps_exhaust')
# self.prob.model.connect('set_tp.props.tp2props.flow_prods', 'compressor.Fl_I:flow_prods')
self.prob.setup(check=False)
# 4 cases to check against
for i, data in enumerate(ref_data):
self.prob['nozzle.Cfg'] = data[h_map['Cfg']]
self.prob['Ps_exhaust'] = data[h_map['PsExh']]
# input flowstation
self.prob['P'] = data[h_map['Fl_I.Pt']]
self.prob['T'] = data[h_map['Fl_I.Tt']]
self.prob['W'] = data[h_map['Fl_I.W']]
self.prob['MN'] = data[h_map['Fl_I.MN']]
# self.prob['nozzle.throat_static_choked.n2ls.P'] = data[h_map['Fl_O.Ps']]
# self.prob.root.list_connections()
self.prob.run_model()
# print self.prob['nozzle.throat_static_choked.flow:h']
# print self.prob['nozzle.throat_static_choked.flow:S']
# quit()
# check outputs
Fg, V, PR = data[h_map['Fg']], data[h_map['Vactual']], data[
h_map['PR']]
MN = data[h_map['Fl_O.MN']]
Ath = data[h_map['Ath']]
Pt = data[h_map['Fl_O.Pt']]
MN_computed = self.prob['nozzle.Fl_O:stat:MN']
Fg_computed = self.prob['nozzle.Fg']
V_computed = self.prob['nozzle.Fl_O:stat:V']
PR_computed = self.prob['nozzle.PR']
Ath_computed = self.prob['nozzle.Fl_O:stat:area']
Pt_computed = self.prob['nozzle.Fl_O:tot:P']
# print('Cfg: ', self.prob['nozzle.Cfg'])
# print('Ps_exh: ', self.prob['Ps_exhaust'], data[h_map['PsExh']])
# print('S_in: ', self.prob['nozzle.Fl_I:tot:S'])
# print('Pt_in: ', self.prob['nozzle.Fl_I:tot:P'])
# print('Tt_in: ', self.prob['nozzle.Fl_I:tot:T'])
# print('ht_in: ', self.prob['nozzle.Fl_I:tot:h'])
# print('rhot_in: ', self.prob['nozzle.Fl_I:tot:rho'])
# print('gamt_in: ', self.prob['nozzle.Fl_I:tot:gamma'])
# print('----------------------')
# print('MNth: ', self.prob['nozzle.Fl_O:stat:MN'])
# print('S_out: ', self.prob['nozzle.Fl_O:tot:S'])
# print('Pt_out: ', self.prob['nozzle.Fl_O:tot:P'])
# print('Tt_out: ', self.prob['nozzle.Fl_O:tot:T'])
# print('ht_out: ', self.prob['nozzle.Fl_O:tot:h'])
# # print('rhot_out: ', self.prob['nozzle.Fl_O.rhot'])
# # print('gamt_out: ', self.prob['nozzle.Fl_O.gamt'])
# print('Ps_out: ', self.prob['nozzle.Fl_O:stat:P'])
# print('----------------------')
# print('Fg: ', self.prob['nozzle.Fg'])
# print('Fg_ideal: ', self.prob['nozzle.perf_calcs.Fg_ideal'])
# print('MN: ', MN_computed, MN)
# # print('V_actual: ', self.prob['nozzle..Vactual'])
# # print('Aexit: ', self.prob['nozzle.Fl_O.area'])
# print('PR: ', PR_computed, PR)
# print('----------------------')
# Used for all
tol = 5.e-3
assert_rel_error(self, MN_computed, MN, tol)
# print "bar", Fg_computed, Fg
assert_rel_error(self, Fg_computed, Fg, tol)
assert_rel_error(self, V_computed, V, tol)
assert_rel_error(self, Pt_computed, Pt, tol)
# print "foo", PR_computed, PR
# print("Fg_comp ", Fg_computed)
# print("psE ", self.prob['nozzle.Ps_exhaust'])
# print("videal ", self.prob['nozzle.perf_calcs.V_ideal'])
# print("A ideal ", self.prob['nozzle.perf_calcs.A_ideal'])
# print("Ps ideal ",self.prob['nozzle.perf_calcs.Ps_ideal'])
# print("w ", self.prob['nozzle.Fl_I:stat:W'])
# print("S ", self.prob['nozzle.ideal_flow.S'])
# print("ht ", self.prob['nozzle.ideal_flow.ht'])
# print("nn ", self.prob['nozzle.ideal_flow.init_prod_amounts'])
# print("Ps ", self.prob['nozzle.ideal_flow.Ps'])
# print("W_in ", self.prob['nozzle.perf_calcs.W_in'])
# print("W ", self.prob['nozzle.Fl_O:stat:W'])
assert_rel_error(self, PR_computed, PR, tol)
assert_rel_error(self, Ath_computed, Ath, tol)
check_element_partials(self, self.prob)
def test_case1(self):
np.seterr(divide='raise')
fpath = os.path.dirname(os.path.realpath(__file__))
ref_data = np.loadtxt(fpath + "/reg_data/compressorOD1.csv",
delimiter=",",
skiprows=1)
header = [
'comp.PRdes', 'comp.effDes', 'shaft.Nmech', 'comp.Fl_I.W',
'comp.Fl_I.Pt', 'comp.Fl_I.Tt', 'comp.Fl_I.ht', 'comp.Fl_I.s',
'comp.Fl_I.MN', 'comp.Fl_I.V', 'comp.Fl_I.A', 'comp.Fl_I.Ps',
'comp.Fl_I.Ts', 'comp.Fl_I.hs', 'comp.Fl_O.W', 'comp.Fl_O.Pt',
'comp.Fl_O.Tt', 'comp.Fl_O.ht', 'comp.Fl_O.s', 'comp.Fl_O.MN',
'comp.Fl_O.V', 'comp.Fl_O.A', 'comp.Fl_O.Ps', 'comp.Fl_O.Ts',
'comp.Fl_O.hs', 'comp.PR', 'comp.eff', 'comp.Nc', 'comp.Wc',
'comp.pwr', 'comp.RlineMap', 'comp.PRmap', 'comp.effMap',
'comp.NcMap', 'comp.WcMap', 'comp.s_WcDes', 'comp.s_PRdes',
'comp.s_effDes', 'comp.s_NcDes', 'comp.SMW', 'comp.SMN'
]
h_map = dict(((v_name, i) for i, v_name in enumerate(header)))
# 6 cases to check against
for i, data in enumerate(ref_data):
# if i == 0:
# pass # skip design case
# else:
self.prob['s_PR'] = data[h_map['comp.s_PRdes']]
self.prob['s_Wc'] = data[h_map['comp.s_WcDes']]
self.prob['s_eff'] = data[h_map['comp.s_effDes']]
self.prob['s_Nc'] = data[h_map['comp.s_NcDes']]
self.prob['compressor.map.RlineMap'] = data[h_map['comp.RlineMap']]
self.prob['Nmech'] = data[h_map['shaft.Nmech']]
# input flowstation
self.prob['P'] = data[h_map['comp.Fl_I.Pt']]
self.prob['T'] = data[h_map['comp.Fl_I.Tt']]
self.prob['W'] = data[h_map['comp.Fl_I.W']]
# cu(data[h_map['comp.Fl_O.A']],"inch**2", "m**2")
self.prob['area_targ'] = data[h_map['comp.Fl_O.A']]
self.prob.run_model()
tol = 3.0e-3 # seems a little generous,
# FL_O.Ps is off by 4% or less, everything else is <1% tol
print('----- Test Case', i, '-----')
npss = data[h_map['comp.Fl_I.Pt']]
pyc = self.prob['flow_start.Fl_O:tot:P'][0]
print('Pt in:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.Fl_I.s']]
pyc = self.prob['flow_start.Fl_O:tot:S'][0]
print('S in:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.Fl_I.W']]
pyc = self.prob['compressor.Fl_O:stat:W'][0]
print('W in:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.Fl_I.s']]
pyc = self.prob['flow_start.Fl_O:tot:S'][0]
print('S in:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.RlineMap']]
pyc = self.prob['compressor.map.RlineMap'][0]
print('RlineMap:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.PR']]
pyc = self.prob['compressor.PR'][0]
print('PR:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.eff']]
pyc = self.prob['compressor.eff'][0]
print('eff:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.Fl_O.ht']] - data[h_map['comp.Fl_I.ht']]
pyc = self.prob['compressor.Fl_O:tot:h'][0] - self.prob[
'flow_start.Fl_O:tot:h'][0]
print('delta h:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.Fl_O.s']]
pyc = self.prob['compressor.Fl_O:tot:S'][0]
print('S out:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.pwr']]
pyc = self.prob['compressor.power'][0]
print('Power:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.Fl_O.Ps']]
pyc = self.prob['compressor.Fl_O:stat:P'][0]
print('Ps out:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.Fl_O.Ts']]
pyc = self.prob['compressor.Fl_O:stat:T'][0]
print('Ts out:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.SMW']]
pyc = self.prob['compressor.SMW'][0]
print('SMW:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.SMN']]
pyc = self.prob['compressor.SMN'][0]
print('SMN:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
print()
check_element_partials(self, self.prob, tol=5e-5)
def test_case1(self):
prob = Problem()
model = prob.model = Group()
n_init = np.array([
3.23319258e-04, 1.00000000e-10, 1.10131241e-05, 1.00000000e-10,
1.63212420e-10, 6.18813039e-09, 1.00000000e-10, 2.69578835e-02,
1.00000000e-10, 7.23198770e-03
])
model.add_subsystem('des_var1',
IndepVarComp('Fl_I:tot:P',
100.0,
units='lbf/inch**2'),
promotes=["*"])
model.add_subsystem('des_var2',
IndepVarComp('Fl_I:tot:h', 100.0, units='Btu/lbm'),
promotes=["*"])
model.add_subsystem('des_var3',
IndepVarComp('Fl_I:stat:W', 100.0, units='lbm/s'),
promotes=["*"])
model.add_subsystem('des_var4',
IndepVarComp('Fl_I:FAR', 0.0),
promotes=["*"])
model.add_subsystem('des_var5',
IndepVarComp('MN', 0.5),
promotes=["*"])
model.add_subsystem('des_var6',
IndepVarComp('Fl_I:tot:n', n_init),
promotes=["*"])
model.add_subsystem('combustor', Combustor(), promotes=["*"])
prob.set_solver_print(level=2)
prob.setup(check=False)
# 6 cases to check against
for i, data in enumerate(ref_data):
# input flowstation
prob['Fl_I:tot:P'] = data[h_map['Fl_I.Pt']]
prob['Fl_I:tot:h'] = data[h_map['Fl_I.ht']]
prob['Fl_I:stat:W'] = data[h_map['Fl_I.W']]
prob['Fl_I:FAR'] = data[h_map['FAR']]
prob['MN'] = data[h_map['Fl_O.MN']]
prob.run_model()
# check outputs
tol = 1.0e-2
npss = data[h_map['Fl_O.Pt']]
pyc = prob['Fl_O:tot:P']
rel_err = abs(npss - pyc) / npss
print('Pt out:', npss, pyc, rel_err)
self.assertLessEqual(rel_err, tol)
npss = data[h_map['Fl_O.Tt']]
pyc = prob['Fl_O:tot:T']
rel_err = abs(npss - pyc) / npss
print('Tt out:', npss, pyc, rel_err)
self.assertLessEqual(rel_err, tol)
npss = data[h_map['Fl_O.ht']]
pyc = prob['Fl_O:tot:h']
rel_err = abs(npss - pyc) / npss
print('ht out:', npss, pyc, rel_err)
self.assertLessEqual(rel_err, tol)
npss = data[h_map['Fl_O.Ps']]
pyc = prob['Fl_O:stat:P']
rel_err = abs(npss - pyc) / npss
print('Ps out:', npss, pyc, rel_err)
self.assertLessEqual(rel_err, tol)
npss = data[h_map['Fl_O.Ts']]
pyc = prob['Fl_O:stat:T']
rel_err = abs(npss - pyc) / npss
print('Ts out:', npss, pyc, rel_err)
self.assertLessEqual(rel_err, tol)
npss = data[h_map['Wfuel']]
pyc = prob['Fl_I:stat:W'] * (prob['Fl_I:FAR'])
rel_err = abs(npss - pyc) / npss
print('Wfuel:', npss, pyc, rel_err)
self.assertLessEqual(rel_err, tol)
print('')
check_element_partials(self, prob, tol=1e-4)
def test_case1(self):
thermo = Thermo(janaf, AIR_MIX)
self.prob = Problem()
self.prob.model = Group()
self.prob.model.add_subsystem(
'flow_start', FlowStart(thermo_data=janaf, elements=AIR_MIX))
self.prob.model.add_subsystem(
'nozzle',
Nozzle(elements=AIR_MIX, lossCoef='Cfg', internal_solver=True))
self.prob.model.set_input_defaults('nozzle.Ps_exhaust',
10.0,
units='lbf/inch**2')
self.prob.model.set_input_defaults('flow_start.MN', 0.0)
self.prob.model.set_input_defaults('flow_start.T', 500.0, units='degR')
self.prob.model.set_input_defaults('flow_start.P', 17.0, units='psi')
self.prob.model.set_input_defaults('flow_start.W',
100.0,
units='lbm/s')
fl_src = "flow_start.Fl_O"
fl_target = "nozzle.Fl_I"
for v_name in ('h', 'T', 'P', 'S', 'rho', 'gamma', 'Cp', 'Cv', 'n'):
self.prob.model.connect('%s:tot:%s' % (fl_src, v_name),
'%s:tot:%s' % (fl_target, v_name))
# no prefix
for v_name in ('W', ):
self.prob.model.connect('%s:stat:%s' % (fl_src, v_name),
'%s:stat:%s' % (fl_target, v_name))
self.prob.setup(check=False)
# 4 cases to check against
for i, data in enumerate(ref_data):
self.prob['nozzle.Cfg'] = data[h_map['Cfg']]
self.prob['nozzle.Ps_exhaust'] = data[h_map['PsExh']]
# input flowstation
self.prob['flow_start.P'] = data[h_map['Fl_I.Pt']]
self.prob['flow_start.T'] = data[h_map['Fl_I.Tt']]
self.prob['flow_start.W'] = data[h_map['Fl_I.W']]
self.prob['flow_start.MN'] = data[h_map['Fl_I.MN']]
self.prob.run_model()
# check outputs
Fg, V, PR = data[h_map['Fg']], data[h_map['Vactual']], data[
h_map['PR']]
MN = data[h_map['Fl_O.MN']]
Ath = data[h_map['Ath']]
Pt = data[h_map['Fl_O.Pt']]
MN_computed = self.prob['nozzle.Fl_O:stat:MN']
Fg_computed = self.prob['nozzle.Fg']
V_computed = self.prob['nozzle.Fl_O:stat:V']
PR_computed = self.prob['nozzle.PR']
Ath_computed = self.prob['nozzle.Fl_O:stat:area']
Pt_computed = self.prob['nozzle.Fl_O:tot:P']
# Used for all
tol = 5.e-3
assert_near_equal(MN_computed, MN, tol)
assert_near_equal(Fg_computed, Fg, tol)
assert_near_equal(V_computed, V, tol)
assert_near_equal(Pt_computed, Pt, tol)
assert_near_equal(PR_computed, PR, tol)
assert_near_equal(Ath_computed, Ath, tol)
check_element_partials(self, self.prob)
def test_case_with_dPqP_MN(self):
thermo = Thermo(janaf, constants.AIR_MIX)
self.prob = Problem()
self.prob.model = Group()
self.prob.model.add_subsystem('flow_start',
FlowStart(thermo_data=janaf,
elements=AIR_MIX),
promotes=['P', 'T', 'MN', 'W'])
self.prob.model.add_subsystem('flow_start_OD',
FlowStart(thermo_data=janaf,
elements=AIR_MIX),
promotes=['P', 'T', 'W'])
expMN = 1.0
self.prob.model.add_subsystem('duct_des',
Duct(elements=AIR_MIX, expMN=expMN),
promotes=['MN'])
self.prob.model.add_subsystem(
'duct_OD', Duct(elements=AIR_MIX, expMN=expMN, design=False))
connect_flow(self.prob.model, 'flow_start.Fl_O', 'duct_des.Fl_I')
connect_flow(self.prob.model, 'flow_start_OD.Fl_O', 'duct_OD.Fl_I')
self.prob.model.set_input_defaults('P', 17., units='psi')
self.prob.model.set_input_defaults('T', 500., units='degR')
self.prob.model.set_input_defaults('MN', 0.5)
self.prob.model.set_input_defaults('flow_start_OD.MN', 0.25)
self.prob.model.set_input_defaults('duct_des.dPqP', 0.0)
self.prob.model.set_input_defaults('W', 500., units='lbm/s')
self.prob.model.connect("duct_des.s_dPqP", "duct_OD.s_dPqP")
self.prob.model.connect("duct_des.Fl_O:stat:area", "duct_OD.area")
self.prob.setup(check=False)
self.prob.set_solver_print(level=-1)
data = ref_data[0]
self.prob['duct_des.dPqP'] = data[h_map['dPqP']]
# input flowstation
self.prob['P'] = data[h_map['Fl_I.Pt']]
self.prob['T'] = data[h_map['Fl_I.Tt']]
self.prob['MN'] = data[h_map['Fl_O.MN']]
self.prob['W'] = data[h_map['Fl_I.W']]
self.prob['duct_des.Fl_I:stat:V'] = data[h_map['Fl_I.V']]
# give a decent initial guess for Ps
print(self.prob['P'], self.prob['T'], self.prob['MN'])
self.prob.run_model()
# check outputs
pt, ht, ps, ts = data[h_map['Fl_O.Pt']], data[h_map['Fl_O.ht']], data[
h_map['Fl_O.Ps']], data[h_map['Fl_O.Ts']]
pt_computed = self.prob['duct_OD.Fl_O:tot:P']
ht_computed = self.prob['duct_OD.Fl_O:tot:h']
ps_computed = self.prob['duct_OD.Fl_O:stat:P']
ts_computed = self.prob['duct_OD.Fl_O:stat:T']
tol = 1.0e-4
assert_near_equal(pt_computed, 8.84073152, tol)
assert_near_equal(ht_computed, ht, tol)
assert_near_equal(ps_computed, 8.26348914, tol)
assert_near_equal(ts_computed, ts, tol)
check_element_partials(self, self.prob)
def test_case1(self):
np.seterr(divide='raise')
# 6 cases to check against
for i, data in enumerate(ref_data):
self.prob['PR'] = data[h_map['comp.PRdes']]
self.prob['eff'] = data[h_map['comp.effDes']]
self.prob['MN'] = data[h_map['comp.Fl_O.MN']]
# input flowstation
self.prob['P'] = data[h_map['start.Pt']]
self.prob['T'] = data[h_map['start.Tt']]
self.prob['W'] = data[h_map['start.W']]
self.prob.run_model()
# print(" mapPRdes : PRdes : PR : scalarsPRmapDes : scaledOutput.PR")
# print(self.prob['PR'], data[h_map['comp.PRdes']], self.prob[
# 'PR'], self.prob['compressor.map.PRmap'])
# print("s_PR", self.prob['compressor.s_PR'])
# print(" mapeffDes : effDes : eff : scalars_effMapDes : scaledOutput.eff")
# print(self.prob['compressor.map.effDes'], data[h_map['comp.effDes']], self.prob[
# 'compressor.eff'], self.prob['compressor.map.scalars.effMapDes'])
# print("Rline", self.prob['compressor.map.RlineMap'])
# print(self.prob.model.resids._dat.keys())
#print("errWc: ", self.prob.model.resids['compressor.map.RlineMap'])
# quit()
# check outputs
tol = 1e-3
npss = data[h_map['comp.Fl_O.Pt']]
pyc = self.prob['compressor.Fl_O:tot:P'][0]
print('Pt out:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.Fl_O.Tt']]
pyc = self.prob['compressor.Fl_O:tot:T'][0]
# print('foo test:', self.prob['compressor.enth_rise.ht_out'][0], data[h_map['start.Fl_O.ht']])
print('Tt out:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.Fl_O.ht']] - data[h_map['start.Fl_O.ht']]
pyc = self.prob['compressor.Fl_O:tot:h'] - self.prob['flow_start.Fl_O:tot:h']
print('delta h:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['start.Fl_O.s']]
pyc = self.prob['flow_start.Fl_O:tot:S'][0]
print('S in:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.Fl_O.s']]
pyc = self.prob['compressor.Fl_O:tot:S'][0]
print('S out:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.pwr']]
pyc = self.prob['compressor.power'][0]
print('Power:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['Fl_O.Ps']]
pyc = self.prob['compressor.Fl_O:stat:P'][0]
print('Ps out:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['Fl_O.Ts']]
pyc = self.prob['compressor.Fl_O:stat:T'][0]
print('Ts out:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
npss = data[h_map['comp.effPoly']]
pyc = self.prob['compressor.eff_poly'][0]
print('effPoly:', npss, pyc)
assert_rel_error(self, pyc, npss, tol)
print("")
check_element_partials(self, self.prob,tol = 5e-5)
def test_case0(self):
# captured inputs:
prob = Problem()
prob.model = Inlet()
prob.setup()
# view_model(p)
prob.run_model()
tol = 1e-7
prob['flow_in.Fl_I:tot:h'] = np.array([1.])
prob['flow_in.Fl_I:tot:T'] = np.array([518.])
prob['flow_in.Fl_I:tot:P'] = np.array([1.])
prob['flow_in.Fl_I:tot:rho'] = np.array([1.])
prob['flow_in.Fl_I:tot:gamma'] = np.array([1.3999999999999999])
prob['flow_in.Fl_I:tot:Cp'] = np.array([1.])
prob['flow_in.Fl_I:tot:Cv'] = np.array([1.])
prob['flow_in.Fl_I:tot:S'] = np.array([1.])
prob['flow_in.Fl_I:tot:n'] = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
prob['flow_in.Fl_I:stat:h'] = np.array([1.])
prob['flow_in.Fl_I:stat:T'] = np.array([518.])
prob['flow_in.Fl_I:stat:P'] = np.array([1.])
prob['flow_in.Fl_I:stat:rho'] = np.array([1.])
prob['flow_in.Fl_I:stat:gamma'] = np.array([1.3999999999999999])
prob['flow_in.Fl_I:stat:Cp'] = np.array([1.])
prob['flow_in.Fl_I:stat:Cv'] = np.array([1.])
prob['flow_in.Fl_I:stat:S'] = np.array([0.])
prob['flow_in.Fl_I:stat:n'] = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
prob['flow_in.Fl_I:stat:V'] = np.array([1.])
prob['flow_in.Fl_I:stat:Vsonic'] = np.array([1.])
prob['flow_in.Fl_I:stat:MN'] = np.array([1.])
prob['flow_in.Fl_I:stat:area'] = np.array([1.])
prob['flow_in.Fl_I:stat:Wc'] = np.array([1.])
prob['flow_in.Fl_I:stat:W'] = np.array([0.])
prob['flow_in.Fl_I:FAR'] = np.array([1.])
prob['calcs_inlet.Pt_in'] = np.array([5.])
prob['calcs_inlet.ram_recovery'] = np.array([1.])
prob['calcs_inlet.V_in'] = np.array([0.])
prob['calcs_inlet.W_in'] = np.array([100.])
prob['real_flow.flow.T'] = np.array([284.])
prob['real_flow.flow.P'] = np.array([5.])
prob['real_flow.flow.h'] = np.array([-7.9733188552527334])
prob['real_flow.flow.S'] = np.array([1.7017265964076564])
prob['real_flow.flow.gamma'] = np.array([1.4002877621616485])
prob['real_flow.flow.Cp'] = np.array([0.2398396648541221])
prob['real_flow.flow.Cv'] = np.array([0.1712788399253588])
prob['real_flow.flow.rho'] = np.array([0.0263992728679074])
prob['real_flow.flow.n'] = np.array([3.2331925838204755e-04, 1.0000000000000000e-10,
1.1013124070888753e-05, 1.0000000000000000e-10,
1.0000000000000000e-10, 1.0000000000000000e-10,
1.0000000000000000e-10, 2.6957886582171697e-02,
1.0000000000000000e-10, 7.2319938237413537e-03])
prob['real_flow.flow.n_moles'] = np.array([0.034524213388366])
prob['FAR_passthru.Fl_I:FAR'] = np.array([0.])
prob['out_stat.statics.ps_resid.Ts'] = np.array([270.4606098605202078])
prob['out_stat.statics.ps_resid.ht'] = np.array([-18545.9396573178637482])
prob['out_stat.statics.ps_resid.hs'] = np.array([-32137.5489635905178147])
prob['out_stat.statics.ps_resid.n_moles'] = np.array([0.034524213388366])
prob['out_stat.statics.ps_resid.gamma'] = np.array([1.4005512841014192])
prob['out_stat.statics.ps_resid.W'] = np.array([1.])
prob['out_stat.statics.ps_resid.rho'] = np.array([0.3743153852344497])
prob['out_stat.statics.ps_resid.guess:gamt'] = np.array([1.4002877621616485])
prob['out_stat.statics.ps_resid.guess:Pt'] = np.array([0.3447378650257302])
prob['out_stat.statics.ps_resid.MN'] = np.array([0.5])
prob['out_stat.flow.T'] = np.array([486.8290977489364195])
prob['out_stat.flow.P'] = np.array([4.2148347084158546])
prob['out_stat.flow.h'] = np.array([-13.8166590557138917])
prob['out_stat.flow.S'] = np.array([1.701726596407656])
prob['out_stat.flow.gamma'] = np.array([1.4005512841014192])
prob['out_stat.flow.Cp'] = np.array([0.2397269927781015])
prob['out_stat.flow.Cv'] = np.array([0.1711661644315738])
prob['out_stat.flow.rho'] = np.array([0.0233677461124606])
prob['out_stat.flow.n'] = np.array([3.2331925838204755e-04, 1.0000000000330098e-10,
1.1013124070888747e-05, 1.0000000000001391e-10,
1.0000000000147303e-10, 1.0000000000000000e-10,
1.0000000000053357e-10, 2.6957886582171697e-02,
1.0000000000021437e-10, 7.2319938237413537e-03])
prob['out_stat.flow.n_moles'] = np.array([0.034524213388366])
prob['out_stat.flow_static.area'] = np.array([25.1156515934009938])
prob['out_stat.flow_static.W'] = np.array([1.])
prob['out_stat.flow_static.V'] = np.array([540.9230351753141122])
prob['out_stat.flow_static.Vsonic'] = np.array([1081.8460703506282243])
prob['out_stat.flow_static.MN'] = np.array([0.5])
# captured outputs:
assert_rel_error(self, prob['flow_in.foo'], np.array([1.]), tol)
assert_rel_error(self, prob['calcs_inlet.Pt_out'], np.array([5.]), tol)
assert_rel_error(self, prob['calcs_inlet.F_ram'], np.array([0.]), tol)
assert_rel_error(self, prob['real_flow.flow.Fl_O:tot:T'], np.array([284.]), tol)
assert_rel_error(self, prob['real_flow.flow.Fl_O:tot:P'], np.array([5.]), tol)
assert_rel_error(self, prob['real_flow.flow.Fl_O:tot:h'],
np.array([-7.9733188552527361]), tol)
assert_rel_error(
self,
prob['real_flow.flow.Fl_O:tot:S'],
np.array(
[1.701726596407656]),
tol)
assert_rel_error(
self,
prob['real_flow.flow.Fl_O:tot:gamma'],
np.array(
[1.4002877621616485]),
tol)
assert_rel_error(self, prob['real_flow.flow.Fl_O:tot:Cp'],
np.array([0.2398396648541221]), tol)
assert_rel_error(self, prob['real_flow.flow.Fl_O:tot:Cv'],
np.array([0.1712788399253588]), tol)
assert_rel_error(self, prob['real_flow.flow.Fl_O:tot:rho'],
np.array([0.0263992728679074]), tol)
assert_rel_error(self,
prob['real_flow.flow.Fl_O:tot:n'],
np.array([3.2331925838204755e-04,
1.0000000000000000e-10,
1.1013124070888753e-05,
1.0000000000000000e-10,
1.0000000000000000e-10,
1.0000000000000000e-10,
1.0000000000000000e-10,
2.6957886582171697e-02,
1.0000000000000000e-10,
7.2319938237413537e-03]),
tol)
assert_rel_error(
self,
prob['real_flow.flow.Fl_O:tot:n_moles'],
np.array(
[0.034524213388366]),
tol)
assert_rel_error(self, prob['FAR_passthru.Fl_O:FAR'], np.array([0.]), tol)
assert_rel_error(
self,
prob['out_stat.statics.ps_resid.Ps'],
np.array(
[0.2906026237631253]),
tol)
assert_rel_error(self, prob['out_stat.statics.ps_resid.V'],
np.array([164.8733411214357432]), tol)
assert_rel_error(self, prob['out_stat.statics.ps_resid.Vsonic'],
np.array([329.7466822428714863]), tol)
assert_rel_error(
self,
prob['out_stat.statics.ps_resid.area'],
np.array(
[0.0162036137819986]),
tol)
assert_rel_error(self, prob['out_stat.flow.Fl_O:stat:T'],
np.array([486.8290977489363058]), tol)
assert_rel_error(self, prob['out_stat.flow.Fl_O:stat:P'],
np.array([4.2148347084158537]), tol)
assert_rel_error(self, prob['out_stat.flow.Fl_O:stat:h'],
np.array([-13.8166590557138935]), tol)
assert_rel_error(
self,
prob['out_stat.flow.Fl_O:stat:S'],
np.array(
[1.701726596407656]),
tol)
assert_rel_error(
self,
prob['out_stat.flow.Fl_O:stat:gamma'],
np.array(
[1.4005512841014192]),
tol)
assert_rel_error(self, prob['out_stat.flow.Fl_O:stat:Cp'],
np.array([0.2397269927781014]), tol)
assert_rel_error(self, prob['out_stat.flow.Fl_O:stat:Cv'],
np.array([0.1711661644315738]), tol)
assert_rel_error(self, prob['out_stat.flow.Fl_O:stat:rho'],
np.array([0.0233677461124606]), tol)
assert_rel_error(self,
prob['out_stat.flow.Fl_O:stat:n'],
np.array([3.2331925838204755e-04,
1.0000000000330098e-10,
1.1013124070888747e-05,
1.0000000000001391e-10,
1.0000000000147303e-10,
1.0000000000000000e-10,
1.0000000000053357e-10,
2.6957886582171697e-02,
1.0000000000021437e-10,
7.2319938237413537e-03]),
tol)
assert_rel_error(
self,
prob['out_stat.flow.Fl_O:stat:n_moles'],
np.array(
[0.034524213388366]),
tol)
assert_rel_error(
self,
prob['out_stat.flow_static.Fl_O:stat:area'],
np.array(
[25.1156515934009938]),
tol)
assert_rel_error(self, prob['out_stat.flow_static.Fl_O:stat:W'], np.array([1.]), tol)
assert_rel_error(self, prob['out_stat.flow_static.Fl_O:stat:V'],
np.array([540.9230351753141122]), tol)
assert_rel_error(
self,
prob['out_stat.flow_static.Fl_O:stat:Vsonic'],
np.array(
[1081.8460703506282243]),
tol)
assert_rel_error(self, prob['out_stat.flow_static.Fl_O:stat:MN'], np.array([0.5]), tol)
check_element_partials(self, prob, depth=1)
