def test_suphVap_10(self): # MECH2201 A8 Q1 State 1 statePropt = {'P': 8000, 'T': 500} testState = StatePure(**statePropt) testState = fullyDefine_StatePure(testState, water_mpDF) expected_h = 3398.3 expected_s = 6.7240 self.assertTrue(isWithin(testState.h, 3, '%', expected_h)) print('Expected: {0}'.format(expected_h)) print('Received: {0}'.format(testState.h)) self.assertTrue(isWithin(testState.s, 3, '%', expected_s)) print('Expected: {0}'.format(expected_s)) print('Received: {0}'.format(testState.s)) # state 2s statePropt = {'P': 30, 's': testState.s} testState = StatePure(**statePropt) testState = fullyDefine_StatePure(testState, water_mpDF) expected_h = 2276.8 expected_x = 0.847 self.assertTrue(isWithin(testState.h, 3, '%', expected_h)) print('Expected: {0}'.format(expected_h)) print('Received: {0}'.format(testState.h)) self.assertTrue(isWithin(testState.x, 3, '%', expected_x)) print('Expected: {0}'.format(expected_x)) print('Received: {0}'.format(testState.x))
def test_flows_water_15(self): # CENGEL P10-22 flow_a = Flow(water) flow_a.massFF = 1 flow_a.massFR = 20 flow_a.items = [ state_01 := StatePure(P=6000), boiler := Boiler(), state_02 := StatePure(T=450), turbine := Turbine(eta_isentropic=0.94), state_03 := StatePure(), condenser := Condenser(), state_04 := StatePure(P=50, T=water.define(StatePure(P=50, x=0)).T - 6.3), pump := Pump(), state_01 ] cycle = Cycle() cycle.flows = [flow_a] cycle.solve() self.CompareResults(state_04, {'h': 314.03, 'mu': 0.001026}, 2) self.CompareResults(state_01, {'h': 320.13}, 2) self.CompareResults(state_03, {'h': 2394.4}, 2) self.assertTrue(isWithin(cycle.Q_in, 1, '%', 59660)) self.assertTrue(isWithin(cycle.netPower, 1, '%', 18050)) self.assertTrue(isWithin(cycle.efficiency, 1, '%', 0.303)) pass
def defineState_ifDefinable(self, state: StatePure): if not state.isFullyDefined() and state.isFullyDefinable(): try: state.copy_fromState(self.define(state)) except NeedsExtrapolationError: print( 'Fluid.defineState_ifDefinable: Leaving state @ {0} not fully defined' .format(state)) return state
def test_flows_water_14(self): # CENGEL P10-47 flow_a = Flow(water) flow_a.massFF = 1 flow_a.massFR = 16 flow_a.items = [ ofwh2 := MixingChamber(), state_05 := StatePure(x=0), pump3 := Pump(), state_06 := StatePure(), boiler := Boiler(), state_07 := StatePure(P=8000, T=550), turbine := Turbine() ] flow_b = Flow(water) flow_b.items = [turbine, state_08 := StatePure(P=600), ofwh2] flow_c = Flow(water) flow_c.items = [ turbine, state_09 := StatePure(P=200), ofwh1 := MixingChamber() ] flow_d = Flow(water) flow_d.items = [ turbine, state_10 := StatePure(P=10), condenser := Condenser(), state_01 := StatePure(x=0), pump1 := Pump(), state_02 := StatePure(), ofwh1 ] flow_e = Flow(water) flow_e.items = [ ofwh1, state_03 := StatePure(x=0), pump2 := Pump(), state_04 := StatePure(), ofwh2 ] cycle = Cycle() cycle.flows = [flow_a, flow_b, flow_c, flow_d, flow_e] cycle.solve() for e in cycle._equations: e.update() cycle.solve() for e in cycle._equations: e.update() cycle.solve() self.CompareResults(state_02, {'h': 192}, 2) self.CompareResults(state_04, {'h': 505.13}, 2) self.CompareResults(state_06, {'h': 678.52}, 2) self.CompareResults(flow_b, {'massFF': 0.07171}, 2) self.CompareResults(flow_c, {'massFF': 0.1201}, 2) self.assertTrue(isWithin(cycle.netPower, 1, '%', 19800)) self.assertTrue(isWithin(cycle.efficiency, 1, '%', 0.435)) pass
def apply_isentropicEfficiency(state_in: StatePure, state_out_ideal: StatePure, eta_isentropic: float, fluid: 'Fluid'): """Returns a new state_out based on the provided one, with all fields filled out based on the isentropic efficiency of the process between the state_in and state_out.""" assert state_out_ideal.hasDefined('P') state_out_ideal.set_or_verify({'s': state_in.s}) try: state_out_ideal.copy_fromState(fluid.define(state_out_ideal)) except NeedsExtrapolationError: # For pumps dealing with subcooled liquids no data may be available. w = mu*dP relation can be used to get at least the h. if all(state.x <= 0 for state in [state_in, state_out_ideal]): apply_incompressibleWorkRelation(state_in=state_in, state_out=state_out_ideal) assert all(state.hasDefined('h') for state in [state_in, state_out_ideal]) # state_in & state_out should have *h* defined work_ideal = state_out_ideal.h - state_in.h state_out_actual = StatePure(P=state_out_ideal.P) if work_ideal >= 0: # work provided to flow from device -> eta_s = w_ideal / w_actual work_actual = work_ideal / eta_isentropic state_out_actual.h = work_actual + state_in.h elif work_ideal < 0: # work extracted from flow by device -> eta_s = w_actual / w_ideal work_ideal = abs(work_ideal) work_actual = eta_isentropic * work_ideal state_out_actual.h = state_in.h - work_actual return fluid.defineState_ifDefinable(state_out_actual)
def test_flows_water_06(self): # CENGEL P10-48 # diagram in book is not helpful - see solutions flow_a = Flow(water) flow_a.massFF = 1 flow_a.items = [ mixc := MixingChamber(), state_t := StatePure(), condenser := Condenser(), state_1 := StatePure(x=0), pump := Pump(), state_2 := StatePure(), cfwh := HeatExchanger(), state_3 := StatePure(T=water.define(StatePure(P=1000, x=0)).T), boiler := Boiler(), state_4 := StatePure(P=3000, T=350), turbine := Turbine() ] flow_b = Flow(water) flow_b.items = [ turbine, state_5 := StatePure(P=1000), cfwh, state_7 := StatePure(x=0), trap := Trap(), state_8 := StatePure(P=20), mixc ] flow_c = Flow(water) flow_c.items = [turbine, state_6 := StatePure(), mixc] cycle = Cycle() cycle.flows = [flow_a, flow_b, flow_c] cycle.solve() for e in cycle._equations: e.update() cycle.solve() for e in cycle._equations: e.update() cycle.solve() for f in cycle.flows: # TODO - Has to solve the flows manually again f.solve() for e in cycle._equations: e.update() cycle.solve() self.CompareResults(state_2, {'h': 254.45}, 2) self.CompareResults(state_4, {'h': 3116.1, 's': 6.7450}, 2) self.CompareResults(state_5, {'h': 2851.9}, 2) self.CompareResults(state_6, {'h': 2221.7, 'x': 0.8357}, 2) self.CompareResults(state_7, {'h': 762.51, 'T': 179.9}, 2) self.CompareResults(flow_b, {'massFF': 0.2437}, 2) self.assertTrue(isWithin(cycle.sHeat, 2, '%', 2353)) self.assertTrue(isWithin(cycle.net_sPower, 2, '%', 737.8)) self.assertTrue(isWithin(cycle.efficiency, 1, '%', 0.3136)) pass
def test_satMix_02(self): # From MECH2201 - A9 Q2 - state 4 statePropt = {'P': 5, 's': 7.7622, 'x': 0.92} testState = StatePure(**statePropt) self.assertTrue(testState.isFullyDefinable()) testState = fullyDefine_StatePure(testState, water_mpDF) expected = 2367.8 self.assertTrue(isWithin(testState.h, 3, '%', expected)) print('Expected: {0}'.format(expected)) print('Received: {0}'.format(testState.h))
def test_satMix_01(self): # From MECH2201 - A9 Q3 statePropt = {'P': 6, 's': 6.4855, 'x': 0.7638} testState = StatePure(**statePropt) self.assertTrue(testState.isFullyDefinable()) testState = fullyDefine_StatePure(testState, water_mpDF) expected = 1996.7 self.assertTrue(isWithin(testState.h, 3, '%', expected)) print('Expected: {0}'.format(expected)) print('Received: {0}'.format(testState.h))
def test_subcLiq_02(self): # From MECH2201 - A9 Q2 - state 6 state5 = StatePure(P=5, x=0) state5 = fullyDefine_StatePure(state5, water_mpDF) state6s = StatePure(P=200, s=state5.s) state6s = fullyDefine_StatePure(state6s, water_mpDF) h6_manual = state5.h + state5.mu * (state6s.P - state5.P) self.assertTrue(isWithin(h6_manual, 3, '%', 138))
def test_subcLiq_03(self): # From MECH2201 - A9 Q3 - state 4 s3 = fullyDefine_StatePure(StatePure(P=6, x=0), water_mpDF) s4 = fullyDefine_StatePure(StatePure(P=150, s=s3.s), water_mpDF) s4_h_alt = 151.67 # manua calculation with vdp self.assertTrue(isWithin(s4.h, 3, '%', s4_h_alt)) s5 = fullyDefine_StatePure(StatePure(P=150, x=0), water_mpDF) s6 = fullyDefine_StatePure(StatePure(P=12000, s=s5.s), water_mpDF) s6_h_alt = 479.59 self.assertTrue(isWithin(s6.h, 3, '%', s6_h_alt))
def test_suphVap_09(self): # MECH2201 A7 Q2 State 3 & 1 & 2 statePropt = { 'P': 50, 'T': 100 } # P & T above critical values - no saturated mixture exists testState = StatePure(**statePropt) testState = fullyDefine_StatePure(testState, water_mpDF) expected_h = 2682.5 expected_s = 7.6947 self.assertTrue(isWithin(testState.h, 3, '%', expected_h)) print('Expected: {0}'.format(expected_h)) print('Received: {0}'.format(testState.h)) self.assertTrue(isWithin(testState.s, 3, '%', expected_s)) print('Expected: {0}'.format(expected_s)) print('Received: {0}'.format(testState.s)) # below is state 1 statePropt2 = {'P': 3000, 's': testState.s} testState2 = StatePure(**statePropt2) testState2 = fullyDefine_StatePure(testState2, water_mpDF) expected_h = 3854.1 self.assertTrue(isWithin(testState2.h, 3, '%', expected_h)) print('Expected: {0}'.format(expected_h)) print('Received: {0}'.format(testState2.h)) self.assertTrue(testState2.x > 1) # below is state 2 statePropt3 = {'P': 500, 's': testState.s} testState3 = StatePure(**statePropt3) testState3 = fullyDefine_StatePure(testState3, water_mpDF) expected_h = 3207.7 self.assertTrue(isWithin(testState3.h, 3, '%', expected_h)) print('Expected: {0}'.format(expected_h)) print('Received: {0}'.format(testState3.h)) self.assertTrue(testState2.x > 1)
def test_subcLiq_01(self): # From MECH2201 - A9 Q1 - state 6 state5 = StatePure(P=10, x=0) state5 = fullyDefine_StatePure(state5, water_mpDF) state6s = StatePure(P=10000, s=state5.s) state6s = fullyDefine_StatePure(state6s, water_mpDF) eta_p = 0.95 W_is = state5.mu * (state6s.P - state5.P) W_ia = W_is / eta_p h6a = state5.h + W_ia self.assertTrue(isWithin(h6a, 3, '%', 202.45))
def test_satVap_01(self): # From MECH2201 - A7 Q3 - state 1 statePropt = {'P': 600, 'x': 1} testState = StatePure(**statePropt) testState = fullyDefine_StatePure(testState, water_mpDF) expected_mu = 0.3157 expected_s = 6.76 expected_T = 158.85 expected_u = 2567.4 self.assertTrue(isWithin(testState.u, 3, '%', expected_u)) print('Expected: {0}'.format(expected_u)) print('Received: {0}'.format(testState.u)) self.assertTrue(isWithin(testState.mu, 3, '%', expected_mu)) print('Expected: {0}'.format(expected_mu)) print('Received: {0}'.format(testState.mu)) self.assertTrue(isWithin(testState.s, 3, '%', expected_s)) print('Expected: {0}'.format(expected_s)) print('Received: {0}'.format(testState.s)) self.assertTrue(isWithin(testState.T, 3, '%', expected_T)) print('Expected: {0}'.format(expected_T)) print('Received: {0}'.format(testState.T))
def test_satLiq_03(self): # From MECH2201 - A9 Q1 - state 5 statePropt = {'P': 10, 'x': 0} testState = StatePure(**statePropt) testState = fullyDefine_StatePure(testState, water_mpDF) expected_h = 191.83 expected_mu = 0.001010 expected_s = 0.6493 expected_T = 45.81 self.assertTrue(isWithin(testState.h, 3, '%', expected_h)) print('Expected: {0}'.format(expected_h)) print('Received: {0}'.format(testState.h)) self.assertTrue(isWithin(testState.mu, 3, '%', expected_mu)) print('Expected: {0}'.format(expected_mu)) print('Received: {0}'.format(testState.mu)) self.assertTrue(isWithin(testState.s, 3, '%', expected_s)) print('Expected: {0}'.format(expected_s)) print('Received: {0}'.format(testState.s)) self.assertTrue(isWithin(testState.T, 3, '%', expected_T)) print('Expected: {0}'.format(expected_T)) print('Received: {0}'.format(testState.T))
def apply_isentropicEfficiency(constant_c: bool, state_in: StatePure, state_out_ideal: StatePure, eta_isentropic: float, fluid: 'Fluid'): """Returns a new state_out based on the provided one, with all fields filled out based on the isentropic efficiency of the process between the state_in and state_out.""" if not constant_c: # Variable c analysis - will use tabulated data for fluids other than ideal gases if state_out_ideal.hasDefined('P'): if fluid.stateClass is StatePure: # if not an IGas flow - ideally should check if fluid is IGas but cannot as ThprOps do not know fluids. state_out_ideal.set_or_verify({'s': state_in.s}) try: state_out_ideal.copy_fromState(fluid.define(state_out_ideal)) except NeedsExtrapolationError: # For pumps dealing with subcooled liquids no data may be available. w = mu*dP relation can be used to get at least the h. if all(state.x <= 0 for state in [state_in, state_out_ideal]): apply_incompressibleWorkRelation(state_in=state_in, state_out=state_out_ideal) assert all(state.hasDefined('h') for state in [state_in, state_out_ideal]) # state_in & state_out should have *h* defined work_ideal = state_out_ideal.h - state_in.h state_out_actual = fluid.stateClass(P=state_out_ideal.P) if work_ideal >= 0: # work provided to flow from device -> eta_s = w_ideal / w_actual work_actual = work_ideal / eta_isentropic state_out_actual.h = work_actual + state_in.h elif work_ideal < 0: # work extracted from flow by device -> eta_s = w_actual / w_ideal work_ideal = abs(work_ideal) work_actual = eta_isentropic * work_ideal state_out_actual.h = state_in.h - work_actual return fluid.defineState_ifDefinable(state_out_actual) else: # Constant c analysis if all(state.hasDefined('T') for state in [state_in, state_out_ideal]): work_ideal = fluid.cp*(state_out_ideal.T - state_in.T) state_out_actual = fluid.stateClass() state_out_actual.copy_fromState(state_out_ideal) # accessing __class__ like this, to use the same class as state_out - could be StatePure or StateIGas if work_ideal >= 0: work_actual = work_ideal / eta_isentropic state_out_actual.T = (work_actual/fluid.cp) + state_in.T state_out_actual.mu = float('nan') # mu of state_out_ideal no longer valid, needs to be recalculated with IGasLaw elif work_ideal <= 0: work_ideal = abs(work_ideal) work_actual = eta_isentropic * work_ideal state_out_actual.T = state_in.T - (work_actual/fluid.cp) state_out_actual.mu = float('nan') # mu of state_out_ideal no longer valid, needs to be recalculated with IGasLaw return state_out_actual
def test_flows_refr_01(self): # CENGEL P11-13 flow_a = Flow(R134a) flow_a.massFF = 1 flow_a.items = [ state_1 := StatePure(x=1), compressor := Compressor(), state_2 := StatePure(P=800), condenser := Condenser(), state_3 := StatePure(x=0), expValve := Trap(), state_4 := StatePure(T=-12), evaporator := Boiler(), state_1 ] cycle = Cycle() cycle.flows = [flow_a] cycle.solve() pass
def test_flows_water_12(self): # CENGEL P10-45 flow_a = Flow(water) flow_a.massFF = 1 flow_a.items = [ ofwh := MixingChamber(), state_3 := StatePure(x=0), pump2 := Pump(), state_4 := StatePure(), boiler := Boiler(), state_5 := StatePure(P=6000, T=450), turbine := Turbine() ] flow_b = Flow(water) flow_b.items = [turbine, state_6 := StatePure(P=400), ofwh] flow_c = Flow(water) flow_c.items = [ turbine, state_7 := StatePure(P=20), condenser := Condenser(), state_1 := StatePure(x=0), pump1 := Pump(), state_2 := StatePure(), ofwh ] cycle = Cycle() cycle.flows = [flow_a, flow_b, flow_c] cycle.solve() cycle.solve() for e in cycle._equations: e.update() cycle.solve() self.assertTrue(isWithin(cycle.net_sPower, 1, '%', 1017)) self.assertTrue(isWithin(cycle.efficiency, 1, '%', 0.378)) pass
def test_satMix_06(self): # From MECH2201 - A7 Q1 - state 2 state1Propt = {'T': 100, 'x': 1} state1 = StatePure(**state1Propt) state1 = fullyDefine_StatePure(state1, water_mpDF) expected_s = 7.3549 expected_P = 101.35 expected_mu = 1.6729 expected_u = 2506.5 self.assertTrue(isWithin(state1.s, 3, '%', expected_s)) print('Expected: {0}'.format(expected_s)) print('Received: {0}'.format(state1.s)) self.assertTrue(isWithin(state1.P, 3, '%', expected_P)) print('Expected: {0}'.format(expected_P)) print('Received: {0}'.format(state1.P)) self.assertTrue(isWithin(state1.mu, 3, '%', expected_mu)) print('Expected: {0}'.format(expected_mu)) print('Received: {0}'.format(state1.mu)) self.assertTrue(isWithin(state1.u, 3, '%', expected_u)) print('Expected: {0}'.format(expected_u)) print('Received: {0}'.format(state1.u)) state2Propt = {'T': 25, 'mu': state1.mu} state2 = StatePure(**state2Propt) state2 = fullyDefine_StatePure(state2, water_mpDF) expected_x = 0.03856 expected_s = 0.6832 expected_u = 193.76 self.assertTrue(isWithin(state2.s, 3, '%', expected_s)) print('Expected: {0}'.format(expected_s)) print('Received: {0}'.format(state2.s)) self.assertTrue(isWithin(state2.x, 3, '%', expected_x)) print('Expected: {0}'.format(expected_x)) print('Received: {0}'.format(state2.x)) self.assertTrue(isWithin(state2.u, 3, '%', expected_u)) print('Expected: {0}'.format(expected_u)) print('Received: {0}'.format(state2.u))
def test_satLiq_01(self): # From MECH2201 - A9 Q2 - state 11 statePropt = {'P': 600, 'x': 0} testState = StatePure(**statePropt) testState = fullyDefine_StatePure(testState, water_mpDF) expected = 670.56 self.assertTrue(isWithin(testState.h, 3, '%', expected)) print('Expected: {0}'.format(expected)) print('Received: {0}'.format(testState.h))
def test_suphVap_04(self): # From MECH2201 - A9 Q2 - state 2 statePropt = {'P': 1000, 's': 6.6776} testState = StatePure(**statePropt) testState = fullyDefine_StatePure(testState, water_mpDF) expected_h = 2820.3 self.assertTrue(isWithin(testState.h, 3, '%', expected_h)) print('Expected: {0}'.format(expected_h)) print('Received: {0}'.format(testState.h))
def interpolate_onSaturationCurve(mpDF: DataFrame, interpolate_by: str, interpolate_at: float, endpoint: str) -> StatePure: """Method to interpolate along the saturation curve. Interpolates to find the state identified by 'endpoint' (either f or g, for saturated liquid or vapor states) (i.e. identifier for left or right side of the saturation curve), and by value ('interpolate_at') of the property ('interpolate_by').""" endpoint_x = {'f': 0, 'g': 1} x = endpoint_x[endpoint] queryPropt, queryValue = interpolate_by, interpolate_at # rename for clarity in this method satStates_ordered_byPropt = mpDF.query('x == {0}'.format(x)).sort_values(queryPropt) # retrieve only saturated liquid states satStates_ProptVals = satStates_ordered_byPropt[queryPropt].to_list() proptVal_below, proptVal_above = get_surroundingValues(satStates_ProptVals, queryValue) # satStates_ProptVals[bisect_left(satStates_ProptVals, queryValue) - 1], satStates_ProptVals[bisect_right(satStates_ProptVals, queryValue)] satState_below, satState_above = mpDF.query('x == {0} and {1} == {2}'.format(x, queryPropt, proptVal_below)), mpDF.query('x == {0} and {1} == {2}'.format(x, queryPropt, proptVal_above)) assert all(not state_DFrow.empty for state_DFrow in [satState_below, satState_above]), 'More than one saturation state provided for the same value of query property "{0}" in supplied data file.'.format(queryPropt) satState_below, satState_above = StatePure().init_fromDFRow(satState_below), StatePure().init_fromDFRow(satState_above) satState_atProptVal = interpolate_betweenPureStates(satState_below, satState_above, interpolate_at={queryPropt: queryValue}) assert satState_atProptVal.isFullyDefined() return satState_atProptVal
def test_suphVap_08(self): # Superheated state requiring double interpolation statePropt = {'P': 20, 'T': 625} # P & T above critical values - no saturated mixture exists testState = StatePure(**statePropt) testState = fullyDefine_StatePure(testState, water_mpDF) expected_mu = 33.159 self.assertTrue(isWithin(testState.mu, 3, '%', expected_mu)) print('Expected: {0}'.format(expected_mu)) print('Received: {0}'.format(testState.mu))
def test_flows_water_17(self): # CENGEL P10-31 flow_a = Flow(water) flow_a.massFF = 1 flow_a.massFR = 1.74 flow_a.items = [ state_02 := StatePure(), rhboiler := ReheatBoiler(infer_fixed_exitT=True), state_03 := StatePure(T=400, P=6000), hpturbine := Turbine(), state_04 := StatePure(P=2000), rhboiler, state_05 := StatePure(), lpturbine := Turbine(), state_06 := StatePure(P=20), condenser := Condenser(), state_01 := StatePure(x=0), pump := Pump(), state_02 ] cycle = Cycle() cycle.flows = [flow_a] cycle.solve() self.CompareResults(state_02, {'h': 257.5}, 2) self.CompareResults(state_06, {'h': 2349.7}, 2) self.assertTrue(isWithin(cycle.sHeat, 1, '%', 3268)) self.assertTrue(isWithin(cycle.net_sPower, 1, '%', 1170)) self.assertTrue(isWithin(cycle.efficiency, 1, '%', 0.358)) pass
def test_flows_water_11(self): # CENGEL P10-38 flow_a = Flow(water) flow_a.massFF = 1 flow_a.items = [ state_1 := StatePure(x=0, P=10), pump := Pump(eta_isentropic=1), state_2 := StatePure(), rhboiler := ReheatBoiler(infer_fixed_exitT=True), state_3 := StatePure(P=10000, T=500), hpt := Turbine(eta_isentropic=1), state_4 := StatePure(), rhboiler, state_5 := StatePure(P=1000, T=500), lpt := Turbine(eta_isentropic=1), state_6 := StatePure(), condenser := Condenser(), state_1 ] cycle = Cycle() cycle.flows = [flow_a] cycle.netPower = 80000 cycle.solve() self.CompareResults(state_6, {'x': 0.949}, 2) self.assertTrue( isWithin( flow_a.get_net_sWorkExtracted() / flow_a.get_sHeatSupplied(), 2, '%', 0.413)) self.assertTrue(isWithin(flow_a.massFR, 2, '%', 50)) pass
def test_flows_water_10(self): # CENGEL P10-37 flow_a = Flow(water) flow_a.massFF = 1 flow_a.items = [ state_1 := StatePure(x=0, P=10), pump := Pump(eta_isentropic=0.95), state_2 := StatePure(), rhboiler := ReheatBoiler(infer_fixed_exitT=True), state_3 := StatePure(P=10000, T=500), hpt := Turbine(eta_isentropic=0.8), state_4 := StatePure(), rhboiler, state_5 := StatePure(P=1000, T=500), lpt := Turbine(eta_isentropic=0.8), state_6 := StatePure(), condenser := Condenser(), state_1 ] cycle = Cycle() cycle.flows = [flow_a] cycle.netPower = 80000 cycle.solve() self.CompareResults(state_2, {'h': 202.43}, 2) self.CompareResults(state_4, {'h': 2902}, 2) self.CompareResults(state_6, {'h': 2664.8, 'T': 88.1}, 2) self.assertTrue( isWithin(flow_a.get_net_sWorkExtracted(), 2, '%', 1276.8)) self.assertTrue(isWithin(flow_a.get_sHeatSupplied(), 2, '%', 3749.8)) self.assertTrue(isWithin(flow_a.massFR, 2, '%', 62.7)) pass
def test_flows_water_09(self): # CENGEL P10-35 flow_a = Flow(water) flow_a.massFF = 1 flow_a.massFR = 12 flow_a.items = [ state_1 := StatePure(x=0), pump := Pump(), state_2 := StatePure(P=15000), rhboiler := ReheatBoiler(infer_fixed_exitT=True), state_3 := StatePure(T=500), hpt := Turbine(), state_4 := StatePure(), rhboiler, state_5 := StatePure(), lpt := Turbine(), state_6 := StatePure(P=10, x=0.9), condenser := Condenser(), state_1 ] cycle = Cycle() cycle.flows = [flow_a] cycle.solve() self.CompareResults(state_2, {'h': 206.95}, 2) self.CompareResults(state_5, { 'P': 2160, 'h': 3466.61 }, 2) # not sure why answers say 2150 - did manually, ~2161 self.CompareResults(state_4, {'h': 2817.2}, 2) self.assertTrue(isWithin(cycle.Q_in, 2, '%', 45039)) self.assertTrue(isWithin(cycle.netPower / cycle.Q_in, 2, '%', 0.426)) pass
def test_flows_water_08(self): # CENGEL P10-34 flow_a = Flow(water) flow_a.massFF = 1 flow_a.items = [ state_1 := StatePure(x=0), pump := Pump(), state_2 := StatePure(P=5000), rhboiler := ReheatBoiler(infer_fixed_exitT=False), state_3 := StatePure(), hpt := Turbine(), state_4 := StatePure(P=1200, x=0.96), rhboiler, state_5 := StatePure(), lpt := Turbine(), state_6 := StatePure(P=20, x=0.96), condenser := Condenser(), state_1 ] cycle = Cycle() cycle.flows = [flow_a] cycle.solve() self.CompareResults(state_2, {'h': 256.49}, 2) self.CompareResults(state_3, {'h': 3006.9, 'T': 327.2}, 2) self.CompareResults(state_5, {'h': 3436, 'T': 481.1}, 2) self.assertTrue(isWithin(flow_a.get_sHeatSupplied(), 2, '%', 3482)) self.assertTrue( isWithin( flow_a.get_net_sWorkExtracted() / flow_a.get_sHeatSupplied(), 2, '%', 0.35)) pass
def test_flows_water_13(self): # CENGEL P10-46 flow_a = Flow(water) flow_a.massFF = 1 flow_a.items = [ mixc := MixingChamber(), state_4 := StatePure(), boiler := Boiler(), state_5 := StatePure(P=6000, T=450), turbine := Turbine() ] flow_b = Flow(water) flow_b.items = [ turbine, state_6 := StatePure(P=400), cfwh := HeatExchanger(), state_3 := StatePure(x=0), pump2 := Pump(), state_9 := StatePure(), mixc ] flow_c = Flow(water) flow_c.items = [ turbine, state_7 := StatePure(), condenser := Condenser(), state_1 := StatePure(x=0, P=20), pump1 := Pump(), state_2 := StatePure(), cfwh, state_8 := StatePure(), mixc ] # assuming h8 = h9 = h4 - 8 & 9 have same pressure. determine 8's h by vdp (determine out of nowhere) cycle = Cycle() cycle.flows = [flow_a, flow_b, flow_c] cycle.solve() wtot = 0 for f in cycle.flows: wtot += f.massFF * f.get_net_sWorkExtracted() qtot = 0 for f in cycle.flows: qtot += f.massFF * f.get_sHeatSupplied() self.assertTrue(isWithin(wtot, 1, '%', 1016.8)) self.assertTrue(isWithin(wtot / qtot, 1, '%', 0.378)) pass
def test_flows_water_07(self): # CENGEL P10-55 flow_a = Flow(water) flow_a.massFF = 1 flow_a.items = [ ofwh := MixingChamber(), state_03 := StatePure(x=0), pump2 := Pump(), state_04 := StatePure(), rhboiler := ReheatBoiler(), state_05 := StatePure(P=10000, T=550), turba := Turbine(), state_06 := StatePure(P=800) ] flow_b = Flow(water) flow_b.items = [ state_06, rhboiler, state_07 := StatePure(T=500), turbineb := Turbine(), state_08 := StatePure(P=10), condenser := Condenser(), state_01 := StatePure(x=0), pump1 := Pump(), state_02 := StatePure(), ofwh ] flow_c = Flow(water) flow_c.items = [state_06, ofwh] cycle = Cycle() cycle.flows = [flow_a, flow_b, flow_c] cycle.netPower = 80000 cycle.solve() for e in cycle._equations: e.update() cycle.solve() self.CompareResults(state_02, {'h': 192.61}, 2) self.CompareResults(state_03, {'h': 720.87, 'mu': 0.001115}, 2) self.CompareResults(state_04, {'h': 731.12}, 2) self.CompareResults(state_05, {'h': 3502, 's': 6.7585}, 2) self.CompareResults(state_06, {'h': 2812.1}, 2) self.CompareResults(state_07, {'h': 3481.3, 's': 7.8692}, 2) self.CompareResults(state_08, {'h': 2494.7, 'x': 0.9627}, 2) self.CompareResults(flow_c, {'massFF': 0.2017}, 2) self.assertTrue(isWithin(flow_a.massFR, 2, '%', 54.5)) self.assertTrue(isWithin(cycle.netPower / cycle.Q_in, 2, '%', 0.444)) pass
def test_satLiq_02(self): # From MECH2201 - A9 Q2 - state 7 statePropt = {'P': 200, 'x': 0} testState = StatePure(**statePropt) testState = fullyDefine_StatePure(testState, water_mpDF) expected_h = 504.7 expected_mu = 0.001061 self.assertTrue(isWithin(testState.h, 3, '%', expected_h)) print('Expected: {0}'.format(expected_h)) print('Received: {0}'.format(testState.h)) self.assertTrue(isWithin(testState.mu, 3, '%', expected_mu)) print('Expected: {0}'.format(expected_mu)) print('Received: {0}'.format(testState.mu))