def test_ref_creation_error():
"""Test errors creating reference objects."""
comb = CombustionEngine('combustion engine')
pipeline = Pipe('pipeline')
conn = Connection(comb, 'out1', pipeline, 'in1')
create_ref_TypeError([conn, 7, 'hi'])
create_ref_TypeError([conn, 'hi', 0])
create_ref_TypeError([comb, 1, 0])
def test_set_attr_errors():
"""Test errors of set_attr methods."""
nw = Network(['water', 'air'])
comb = CombustionEngine('combustion engine')
pipeline = Pipe('pipeline')
conn = Connection(comb, 'out1', pipeline, 'in1')
mybus = Bus('mybus')
# ValueErrors
set_attr_ValueError(comb, offdesign=['Q'])
set_attr_ValueError(conn, offdesign=['f'])
set_attr_ValueError(nw, m_unit='kg')
set_attr_ValueError(nw, h_unit='kg')
set_attr_ValueError(nw, p_unit='kg')
set_attr_ValueError(nw, T_unit='kg')
set_attr_ValueError(nw, v_unit='kg')
set_attr_ValueError(conn, state=5)
# TypeErrors
set_attr_TypeError(comb, P=[5])
set_attr_TypeError(comb, P=[5])
set_attr_TypeError(comb, tiP_char=7)
set_attr_TypeError(comb, design='f')
set_attr_TypeError(comb, lamb=dc_cc())
set_attr_TypeError(comb, design_path=7)
set_attr_TypeError(comb, local_design=5)
set_attr_TypeError(comb, local_offdesign=5)
set_attr_TypeError(pipeline, hydro_group=5)
set_attr_TypeError(comb, printout=5)
set_attr_TypeError(conn, design='h')
set_attr_TypeError(conn, fluid_balance=1)
set_attr_TypeError(conn, h0=[4])
set_attr_TypeError(conn, fluid=5)
set_attr_TypeError(conn, design_path=5)
set_attr_TypeError(conn, local_design=5)
set_attr_TypeError(conn, local_offdesign=5)
set_attr_TypeError(conn, printout=5)
set_attr_TypeError(conn, state='f')
set_attr_TypeError(nw, m_range=5)
set_attr_TypeError(nw, p_range=5)
set_attr_TypeError(nw, h_range=5)
set_attr_TypeError(nw, iterinfo=5)
set_attr_TypeError(mybus, P='some value')
set_attr_TypeError(mybus, printout=5)
# KeyErrors
set_attr_KeyError(dc_cc(), x=7)
set_attr_KeyError(comb, wow=5)
set_attr_KeyError(conn, jey=5)
set_attr_KeyError(mybus, power_output=100000)
# NotImplementedError
set_attr_NotImplementedError(conn, Td_bp=Ref(conn, 1, 0))
def test_Connection_creation_TypeError():
"""Test TypeErrors creating connections."""
comb = CombustionEngine('combustion engine')
pipeline = Pipe('pipeline')
with raises(TypeError):
Connection(comb, 'out1', 7, 'in1')
with raises(TypeError):
Connection(comb, 'out1', pipeline, 'in1', label=5)
def test_Connection_creation_ValueError():
"""Test ValueErrors creating connections."""
comb = CombustionEngine('combustion engine')
pipeline = Pipe('pipeline')
with raises(ValueError):
Connection(comb, 'out6', pipeline, 'in1')
with raises(ValueError):
Connection(comb, 'out1', pipeline, 'in5')
class TestCombustionEngineBusErrors:
def setup(self):
self.nw = Network(['water', 'air'])
self.instance = CombustionEngine('combustion engine')
self.bus = Bus('power')
self.bus.add_comps({'comp': self.instance, 'param': 'Param'})
def test_missing_Bus_param_func(self):
"""Test wrong/missing bus parameter in bus function."""
with raises(ValueError):
self.instance.bus_func(self.bus.comps.loc[self.instance])
def test_missing_Bus_param_deriv(self):
"""Test wrong/missing bus parameter in bus derivatives."""
# both values do not matter, but are required for the test
self.instance.num_nw_vars = 1
self.instance.num_vars = 1
self.instance.inl = [Connection(self.instance, 'out1',
Sink('sink'), 'in1')]
self.instance.inl[0].fluid = dc_flu(val={'water': 1})
with raises(ValueError):
self.instance.bus_deriv(self.bus)
def test_Bus_add_comps_errors():
"""Test errors adding components to busses."""
mybus = Bus('mybus')
comb = CombustionEngine('combustion engine')
pipeline = Pipe('pipeline')
conn = Connection(comb, 'out1', pipeline, 'in1')
bus_add_comps_TypeError(mybus, {'comp': conn})
bus_add_comps_TypeError(mybus, {'f': comb})
bus_add_comps_TypeError(mybus, {'comp': comb, 'char': 'Hi'})
bus_add_comps_TypeError(mybus, {'comp': comb, 'param': 5})
bus_add_comps_TypeError(mybus, {'comp': comb, 'P_ref': 'what'})
bus_add_comps_TypeError(mybus, comb)
with raises(ValueError):
mybus.add_comps({'comp': comb, 'base': 5})
def test_get_attr_errors():
"""Test errors of get_attr methods."""
nw = Network(['water', 'air'])
comb = CombustionEngine('combustion engine')
pipeline = Pipe('pipeline')
conn = Connection(comb, 'out1', pipeline, 'in1')
mybus = Bus('mybus')
sub = Subsystem('MySub')
get_attr_KeyError(comb, 'wow')
get_attr_KeyError(conn, 'key')
get_attr_KeyError(mybus, 'components')
get_attr_KeyError(nw, 'missing')
get_attr_KeyError(Ref(conn, 1, 0), 'comp')
get_attr_KeyError(sub, 'test')
get_attr_KeyError(CharLine(), 'test')
get_attr_KeyError(DataContainer(), 'somekey')
get_attr_KeyError(CharMap(), 'Stuff')
def setup(self):
self.nw = Network(['water', 'air'])
self.instance = CombustionEngine('combustion engine')
self.bus = Bus('power')
self.bus.add_comps({'comp': self.instance, 'param': 'Param'})
def test_Connection_creation_TESPyConnectionError():
comb = CombustionEngine('combustion engine')
with raises(TESPyConnectionError):
Connection(comb, 'out1', comb, 'in1')
def test_cmp_instanciation_ValueError():
"""Test bad label specification for component."""
labels = [5, 'Label,', 'Labe;l', 'Label.']
for label in labels:
with raises(ValueError):
CombustionEngine(label)
def test_CombustionEngine(self):
"""Test component properties of combustion engine."""
instance = CombustionEngine('combustion engine')
self.setup_CombustionEngine_network(instance)
air = {
'N2': 0.7556,
'O2': 0.2315,
'Ar': 0.0129,
'H2O': 0,
'CO2': 0,
'CH4': 0
}
fuel = {'N2': 0, 'O2': 0, 'Ar': 0, 'H2O': 0, 'CO2': 0.04, 'CH4': 0.96}
water1 = {'N2': 0, 'O2': 0, 'Ar': 0, 'H2O': 1, 'CO2': 0, 'CH4': 0}
water2 = {'N2': 0, 'O2': 0, 'Ar': 0, 'H2O': 1, 'CO2': 0, 'CH4': 0}
# connection parametrisation
instance.set_attr(pr1=0.99,
pr2=0.99,
lamb=1.0,
design=['pr1', 'pr2'],
offdesign=['zeta1', 'zeta2'])
self.c1.set_attr(p=5, T=30, fluid=air)
self.c2.set_attr(T=30, fluid=fuel)
self.c4.set_attr(p=3, T=60, m=50, fluid=water1)
self.c5.set_attr(p=3, T=80, m=50, fluid=water2)
# create busses
TI = Bus('thermal input')
Q1 = Bus('heat output 1')
Q2 = Bus('heat output 2')
Q = Bus('heat output')
Qloss = Bus('thermal heat loss')
TI.add_comps({'comp': instance, 'param': 'TI'})
Q1.add_comps({'comp': instance, 'param': 'Q1'})
Q2.add_comps({'comp': instance, 'param': 'Q2'})
Q.add_comps({'comp': instance, 'param': 'Q'})
Qloss.add_comps({'comp': instance, 'param': 'Qloss'})
self.nw.add_busses(TI, Q1, Q2, Q, Qloss)
# test specified thermal input bus value
ti = 1e6
TI.set_attr(P=ti)
self.nw.solve('design')
convergence_check(self.nw.lin_dep)
self.nw.save('tmp')
# calculate in offdesign mode
self.nw.solve('offdesign', init_path='tmp', design_path='tmp')
convergence_check(self.nw.lin_dep)
msg = ('Value of thermal input must be ' + str(TI.P.val) + ', is ' +
str(instance.ti.val) + '.')
assert round(TI.P.val, 1) == round(instance.ti.val, 1), msg
# test specified thermal input in component
TI.set_attr(P=np.nan)
instance.set_attr(ti=ti)
self.nw.solve('offdesign', init_path='tmp', design_path='tmp')
convergence_check(self.nw.lin_dep)
msg = ('Value of thermal input must be ' + str(ti) + ', is ' +
str(instance.ti.val) + '.')
assert round(ti, 1) == round(instance.ti.val, 1), msg
instance.set_attr(ti=None)
# test specified heat output 1 bus value
Q1.set_attr(P=instance.Q1.val)
self.nw.solve('offdesign', init_path='tmp', design_path='tmp')
convergence_check(self.nw.lin_dep)
# heat output is at design point value, thermal input must therefore
# not have changed
msg = ('Value of thermal input must be ' + str(ti) + ', is ' +
str(instance.ti.val) + '.')
assert round(ti, 1) == round(instance.ti.val, 1), msg
# calculate heat output over cooling loop
heat1 = self.c4.m.val_SI * (self.c6.h.val_SI - self.c4.h.val_SI)
msg = ('Value of heat output 1 must be ' + str(-heat1) + ', is ' +
str(instance.Q1.val) + '.')
assert round(heat1, 1) == -round(instance.Q1.val, 1), msg
Q1.set_attr(P=np.nan)
# test specified heat output 2 bus value
Q2.set_attr(P=1.2 * instance.Q2.val)
self.nw.solve('offdesign', init_path='tmp', design_path='tmp')
convergence_check(self.nw.lin_dep)
# calculate heat output over cooling loop
heat2 = self.c5.m.val_SI * (self.c7.h.val_SI - self.c5.h.val_SI)
msg = ('Value of heat output 2 must be ' + str(-heat2) + ', is ' +
str(instance.Q2.val) + '.')
assert round(heat2, 1) == -round(instance.Q2.val, 1), msg
# test specified heat output 2 in component
Q2.set_attr(P=np.nan)
instance.set_attr(Q2=-heat2)
self.nw.solve('offdesign', init_path='tmp', design_path='tmp')
convergence_check(self.nw.lin_dep)
heat2 = self.c5.m.val_SI * (self.c7.h.val_SI - self.c5.h.val_SI)
msg = ('Value of heat output 2 must be ' + str(-heat2) + ', is ' +
str(instance.Q2.val) + '.')
assert round(heat2, 1) == -round(instance.Q2.val, 1), msg
# test total heat output bus value
instance.set_attr(Q2=np.nan)
Q.set_attr(P=1.5 * instance.Q1.val)
self.nw.solve('offdesign', init_path='tmp', design_path='tmp')
convergence_check(self.nw.lin_dep)
heat = (self.c4.m.val_SI * (self.c6.h.val_SI - self.c4.h.val_SI) +
self.c5.m.val_SI * (self.c7.h.val_SI - self.c5.h.val_SI))
msg = ('Value of total heat output must be ' + str(Q.P.val) + ', is ' +
str(-heat) + '.')
assert round(Q.P.val, 1) == -round(heat, 1), msg
# test specified heat loss bus value
Q.set_attr(P=np.nan)
Qloss.set_attr(P=-1e5)
self.nw.solve('offdesign', init_path='tmp', design_path='tmp')
convergence_check(self.nw.lin_dep)
msg = ('Value of heat loss must be ' + str(Qloss.P.val) + ', is ' +
str(instance.Qloss.val) + '.')
assert round(Qloss.P.val, 1) == round(instance.Qloss.val, 1), msg
shutil.rmtree('./tmp', ignore_errors=True)
# %% components
# sinks & sources
amb = Source('ambient')
sf = Source('fuel')
fg = Sink('flue gas outlet')
cw_in1 = Source('cooling water inlet1')
cw_in2 = Source('cooling water inlet2')
cw_out1 = Sink('cooling water outlet1')
cw_out2 = Sink('cooling water outlet2')
split = Splitter('splitter')
merge = Merge('merge')
# combustion chamber
chp = CombustionEngine(label='combustion engine')
# %% connections
amb_comb = Connection(amb, 'out1', chp, 'in3')
sf_comb = Connection(sf, 'out1', chp, 'in4')
comb_fg = Connection(chp, 'out3', fg, 'in1')
nw.add_conns(sf_comb, amb_comb, comb_fg)
cw1_chp1 = Connection(cw_in1, 'out1', chp, 'in1')
cw2_chp2 = Connection(cw_in2, 'out1', chp, 'in2')
nw.add_conns(cw1_chp1, cw2_chp2)
chp1_cw = Connection(chp, 'out1', cw_out1, 'in1')
ch = Sink('chimney')
cw = Source('cooling water')
pump = Pump('cooling water pump')
cw_split = Splitter('cooling water splitter')
cw_merge = Merge('cooling water merge')
fg_split = Splitter('flue gas splitter')
fgc = HeatExchanger('flue gas cooler')
cons = HeatExchangerSimple('consumer')
cw_out = Sink('cooling water sink')
# combustion engine
ice = CombustionEngine(label='internal combustion engine')
# %% connections
amb_comb = Connection(amb, 'out1', ice, 'in3')
sf_comb = Connection(sf, 'out1', ice, 'in4')
comb_fg = Connection(ice, 'out3', fg_split, 'in1')
fg_fgc = Connection(fg_split, 'out1', fgc, 'in1')
fg_chbp = Connection(fg_split, 'out2', chbp, 'in1')
fgc_ch = Connection(fgc, 'out1', ch, 'in1')
nw.add_conns(sf_comb, amb_comb, comb_fg, fg_fgc, fg_chbp, fgc_ch)
cw_pu = Connection(cw, 'out1', pump, 'in1')
