def __init__(self, params=None, modelPressureTransient=False, modelTemperatureDepletion=True, **kwargs): self.params = params if self.params == None: self.params = SimulationParameters(**kwargs) self.modelPressureTransient = modelPressureTransient self.modelTemperatureDepletion = modelTemperatureDepletion super().__init__()
def testFluidSystemWaterSolverMdot40(self): params = SimulationParameters(working_fluid = 'water', orc_fluid = 'R245fa', capacity_factor = 0.9) params.m_dot_IP = 40 output = FullSystemORC.getDefaultWaterSystem(params).solve() self.assertTrue(*testAssert(output.fluid_system_solver.pump.well.state.P_Pa, 7.9610e6, 'test_subsurface_solver2_pressure')) self.assertTrue(*testAssert(output.fluid_system_solver.pump.well.state.T_C, 100.3125, 'test_subsurface_solver2_temp')) self.assertTrue(*testAssert(output.energy_results.W_net, 1.4286e+05, 'test_subsurface_solver2_w_net')) self.assertTrue(*testAssert(output.capital_cost_model.C_brownfield, 2.3287e7, 'test_solver2_C_brownfield_N')) self.assertTrue(*testAssert(output.capital_cost_model.C_greenfield, 3.6399062e7, 'test_solver2_C_greenfield_N')) self.assertTrue(*testAssert(output.capital_cost_model.LCOE_brownfield.LCOE, 7.8465e-4, 'test_solver2_LCOE_brownfield'))
def testFluidSystemWaterSolverMdot1(self): params = SimulationParameters(working_fluid = 'water', orc_fluid = 'R245fa', capacity_factor = 0.9) params.m_dot_IP = 1 output = FullSystemORC.getDefaultWaterSystem(params).solve() self.assertTrue(*testAssert(output.fluid_system_solver.pump.well.state.P_Pa, 7.84791e5, 'test_subsurface_solver1_pressure')) self.assertTrue(*testAssert(output.fluid_system_solver.pump.well.state.T_C, 81.2595, 'test_subsurface_solver1_temp')) self.assertTrue(*testAssert(output.energy_results.W_net, 5.2775e3, 'test_subsurface_solver1_w_net')) self.assertTrue(*testAssert(output.capital_cost_model.C_brownfield, 9.1965e6, 'test_solver1_C_brownfield_N')) self.assertTrue(*testAssert(output.capital_cost_model.C_greenfield, 2.2308e7, 'test_solver1_C_greenfield_N')) self.assertTrue(*testAssert(output.capital_cost_model.LCOE_brownfield.LCOE, 0.0083879, 'test_solver1_LCOE_brownfield'))
def __init__(self, params=None, **kwargs): self.params = params if self.params == None: self.params = SimulationParameters(**kwargs) self.data = getTboilOptimum() self.orc_fluid = self.params.orc_fluid self.T_boil_max = maxSubcritORCBoilTemp(self.orc_fluid)
def testProductionWell(self): ### # Testing SemiAnalyticalWell for vertical production well settings ### # Water params = SimulationParameters(working_fluid = 'water', time_years = 10., m_dot_IP=136.) # initial state initial_state = FluidState.getStateFromPT(25.e6, 97., params.working_fluid) well = SemiAnalyticalWell(params, T_e_initial=102.5, dz_total=2500.) wellresult = well.solve(initial_state) self.assertMessages(well.params.working_fluid, (wellresult.state.P_Pa, 1.2372e6), (wellresult.state.T_C, 95.0133), (wellresult.state.h_Jkg, 3.9902e5)) # CO2 well.params.working_fluid = 'CO2' # initial state wellresult = well.solve(initial_state) self.assertMessages(well.params.working_fluid, (wellresult.state.P_Pa, 1.1674e7), (wellresult.state.T_C, 55.9783), (wellresult.state.h_Jkg, 3.7225e5))
def cO2MonitoringIdeal(params=None, **kwargs): if params == None: params = SimulationParameters(**kwargs) return cPermitting(params.cost_year) + dCPermittingCO2( params.N_5spot, params.cost_year) + dCMonitoringCO2Ideal( params.N_5spot, params.cost_year, params.depth, params.monitoring_well_radius)
def getDefaultCPGSystem(params = None, **kwargs): if params == None: params = SimulationParameters(**kwargs) fluid_system = FluidSystemCO2(params = params) injWell_m_dot_multiplier = params.wellFieldType.getInjWellMdotMultiplier() fluid_system.injection_well = SemiAnalyticalWell(params = params, dz_total = -params.depth, T_e_initial = params.T_ambient_C, m_dot_multiplier = injWell_m_dot_multiplier) fluid_system.reservoir = PorousReservoir(params = params) prodWell_m_dot_multiplier = params.wellFieldType.getProdWellMdotMultiplier() fluid_system.production_well = SemiAnalyticalWell(params = params, dz_total = params.depth, T_e_initial = params.T_ambient_C + params.dT_dz * params.depth, m_dot_multiplier = prodWell_m_dot_multiplier) capital_cost_system = CapitalCostSystem() capital_cost_system.CapitalCost_SurfacePlant = CapitalCostSurfacePlantCPG(params = params) capital_cost_system.CapitalCost_SurfacePipe = CapitalCostSurfacePipes.cost(params = params) capital_cost_system.CapitalCost_Production_Well = CapitalCostWell.cO2Baseline(params = params) capital_cost_system.CapitalCost_Injection_Well = CapitalCostWell.cO2Baseline(params = params) capital_cost_system.CapitalCost_Wellfield = CapitalCostWellField.cO2MonitoringBaseline(params = params) capital_cost_system.CapitalCost_Exploration = CapitalCostExploration.cO2Baseline(params = params) capital_cost_system.CapitalCost_Stimulation = CapitalCostWellStimulation.cost() capital_cost_system.lcoe_model = LCOESimple(params = params) return FullSystemCPG(params, fluid_system, capital_cost_system)
def __init__(self, params=None, **kwargs): self.params = params if self.params == None: self.params = SimulationParameters(**kwargs) self.ppi_T_G = readCostTable('PPI_T-G') self.ppi_pump = readCostTable('PPI_Pump') self.ppi_HX = readCostTable('PPI_HX')
def waterBaseline(params=None, **kwargs): if params == None: params = SimulationParameters(**kwargs) A = cModeling(params.cost_year) B = dCCharacterizationWellsBaseline(params.cost_year, params.depth, params.well_radius, params.success_rate) return A + B
def cO2Ideal(params=None, **kwargs): if params == None: params = SimulationParameters(**kwargs) A = cModeling(params.cost_year) B = dCCharacterizationWellsIdeal(params.cost_year, params.depth, params.well_radius, params.success_rate) C = dCModelingCO2(params.N_5spot, params.cost_year) return A + B + C
def testFluidSystemCO2Mdot10(self): params = SimulationParameters(working_fluid='co2', capacity_factor=0.9) params.m_dot_IP = 10 output = FullSystemCPG.getDefaultCPGSystem(params).solve() self.assertTrue(*testAssert(output.fluid_system_solver.pp.dP_surface, 5.9421e6, 'test_dP_surface')) self.assertTrue( *testAssert(output.fluid_system_solver.production_well.state.T_C, 59.2802, 'test_T_prod_surface_C')) self.assertTrue( *testAssert(output.energy_results.W_net, 9.7662e4, 'test_W_net')) self.assertTrue(*testAssert(output.capital_cost_model.C_brownfield, 1.3271e7, 'test_C_brownfield_N')) self.assertTrue(*testAssert(output.capital_cost_model.C_greenfield, 3.5901e7, 'test_C_greenfield_N')) self.assertTrue( *testAssert(output.capital_cost_model.LCOE_brownfield.LCOE, 6.5410e-4, 'test_LCOE_brownfield'))
def testFluidSystemCO2Mdot200(self): params = SimulationParameters(working_fluid='co2', capacity_factor=0.9) params.m_dot_IP = 200 output = FullSystemCPG.getDefaultCPGSystem(params).solve() self.assertTrue(*testAssert(output.fluid_system_solver.pp.dP_surface, 3.468765e+06, 'test_dP_surface')) self.assertTrue( *testAssert(output.fluid_system_solver.production_well.state.T_C, 47.6070, 'test_T_prod_surface_C')) self.assertTrue( *testAssert(output.energy_results.W_net, -1.3875e6, 'test_W_net')) self.assertTrue(*testAssert(output.capital_cost_model.C_brownfield, 5.0443e7, 'test_C_brownfield_N')) self.assertTrue(*testAssert(output.capital_cost_model.C_greenfield, 7.3073e7, 'test_C_greenfield_N')) self.assertTrue( np.isnan(output.capital_cost_model.LCOE_brownfield.LCOE), 'test_LCOE_brownfield')
def testFluidSystemCO2Mdot80(self): params = SimulationParameters(working_fluid='co2', capacity_factor=0.9) params.m_dot_IP = 80 output = FullSystemCPG.getDefaultCPGSystem(params).solve() self.assertTrue(*testAssert(output.fluid_system_solver.pp.dP_surface, 5.6501e6, 'test_dP_surface')) self.assertTrue( *testAssert(output.fluid_system_solver.production_well.state.T_C, 59.0540, 'test_T_prod_surface_C')) self.assertTrue( *testAssert(output.energy_results.W_net, 4.9940e+05, 'test_W_net')) self.assertTrue(*testAssert(output.capital_cost_model.C_brownfield, 2.7650e7, 'test_C_brownfield_N')) self.assertTrue(*testAssert(output.capital_cost_model.C_greenfield, 5.0280e7, 'test_C_greenfield_N')) self.assertTrue( *testAssert(output.capital_cost_model.LCOE_brownfield.LCOE, 2.6650e-4, 'test_LCOE_brownfield'))
def testFluidSystemWaterSolverOptMdot(self): params = SimulationParameters(working_fluid = 'water', orc_fluid = 'R245fa', capacity_factor = 0.9) full_system = FullSystemORC.getDefaultWaterSystem(params) full_system_solver = FullSystemSolver(full_system) output = full_system_solver.solve() self.assertTrue(*testAssert(output.optMdot, 21.9823, 'test_optMdot_solver_optMdot', 1e-3)) self.assertTrue(*testAssert(output.energy_results.W_net, 1.5212e5, 'test_optMdot_solver_w_net', 1e-3)) self.assertTrue(*testAssert(output.capital_cost_model.LCOE_brownfield.LCOE, 5.4633e-4, 'test_optMdot_solver_brownfield', 1e-3))
def cost(params=None, **kwargs): if params == None: params = SimulationParameters(**kwargs) X_PCs = 1.15 X_ICs = 1.12 if params.wellFieldType == WellFieldType.Doublet: L_surfacePipe = 707 D_surfacePipe = 0.41 elif params.wellFieldType == WellFieldType._5Spot: L_surfacePipe = 3000 D_surfacePipe = 0.41 elif params.wellFieldType == WellFieldType._5Spot_SharedNeighbor: L_surfacePipe = 707 D_surfacePipe = 0.41 elif params.wellFieldType == WellFieldType._5Spot_Many: L_surfacePipe_manyN = { 1: 3000, 2: 12000, 3: 25000, 4: 45000, 5: 69000, 6: 107000, 7: 153000, 8: 223000, 9: 309000, 10: 406000 } D_surfacePipe_manyN = { 1: 0.34, 2: 0.54, 3: 0.65, 4: 0.79, 5: 0.89, 6: 0.98, 7: 1.02, 8: 1.05, 9: 1.09, 10: 1.13 } L_surfacePipe = L_surfacePipe_manyN[params.N_5spot] D_surfacePipe = D_surfacePipe_manyN[params.N_5spot] else: L_surfacePipe = 707 D_surfacePipe = 0.41 c_surfacePipe = 2205. * D_surfacePipe**2 + 134. return X_PCs * X_ICs * readCostTable( 'PPI_Pipe', cost_year=params.cost_year) * c_surfacePipe * L_surfacePipe
def testFluidSystemCO2Mdot100(self): params = SimulationParameters(working_fluid='co2', capacity_factor=0.9) params.m_dot_IP = 100 params.depth = 2400. params.permeability = 1e-8 / 100. output = FullSystemCPG.getDefaultCPGSystem(params).solve() self.assertTrue(*testAssert(output.fluid_system_solver.pp.dP_surface, 5.0019e6, 'test_dP_surface')) self.assertTrue( *testAssert(output.fluid_system_solver.production_well.state.T_C, 55.3144, 'test_T_prod_surface_C')) self.assertTrue(*testAssert(output.fluid_system_solver.pp.dP_pump, -1.0756e6, 'test_dP_pump')) self.assertTrue( *testAssert(output.energy_results.W_net, 8.2656e5, 'test_W_net')) self.assertTrue(*testAssert(output.capital_cost_model.C_brownfield, 2.6182e7, 'test_C_brownfield_N')) self.assertTrue(*testAssert(output.capital_cost_model.C_greenfield, 4.8021e7, 'test_C_greenfield_N')) self.assertTrue( *testAssert(output.capital_cost_model.LCOE_brownfield.LCOE, 1.5247e-4, 'test_LCOE_brownfield'))
def testFluidSystemCO2SolverOptMdot(self): params = SimulationParameters(working_fluid='co2', capacity_factor=0.9) full_system = FullSystemCPG.getDefaultCPGSystem(params) full_system_solver = FullSystemSolver(full_system) output = full_system_solver.solve() self.assertTrue(*testAssert(output.optMdot, 54.8493, 'test_optMdot_solver_optMdot', 1e-3)) self.assertTrue(*testAssert(output.energy_results.W_net, 4.5411e5, 'test_optMdot_solver_w_net', 1e-3)) self.assertTrue(*testAssert( output.capital_cost_model.LCOE_brownfield.LCOE, 2.3915e-4, 'test_optMdot_solver_LCOE_brownfield', 1e-3))
def __init__(self, params = None, T_e_initial = 15., dz_total = 0., dr_total = 0., m_dot_multiplier = 1, **kwargs): self.params = params if self.params == None: self.params = SimulationParameters(**kwargs) # dimensions # dz_total is the change in elevation, negative if going into the earth self.dz_total = dz_total # dr_total is the deviation from vertical, always positive self.dr_total = dr_total # T_e_initial is the beginning rock temp # default is set to be 15 C self.T_e_initial = T_e_initial # m_dot_multiplier is the multiplier applied to the mass flowrate within the wells # default is 1 self.m_dot_multiplier = m_dot_multiplier
def getDefaultWaterSystem(params=None, **kwargs): if params == None: params = SimulationParameters(**kwargs) fluid_system = FluidSystemWater(params=params) injWell_m_dot_multiplier = params.wellFieldType.getInjWellMdotMultiplier( ) fluid_system.injection_well = SemiAnalyticalWell( params=params, dz_total=-params.depth, T_e_initial=params.T_ambient_C, m_dot_multiplier=injWell_m_dot_multiplier) fluid_system.reservoir = PorousReservoir(params=params) prodWell_m_dot_multiplier = params.wellFieldType.getProdWellMdotMultiplier( ) fluid_system.production_well1 = SemiAnalyticalWell( params=params, dz_total=params.depth - params.pump_depth, T_e_initial=params.T_ambient_C + params.dT_dz * params.depth, m_dot_multiplier=prodWell_m_dot_multiplier) prod_well2 = SemiAnalyticalWell( params=params, dz_total=params.pump_depth, T_e_initial=params.T_ambient_C + params.dT_dz * params.pump_depth, m_dot_multiplier=prodWell_m_dot_multiplier) fluid_system.pump = DownHolePump(well=prod_well2, params=params) fluid_system.pp = ORCCycleTboil(params=params) capital_cost_system = CapitalCostSystem() capital_cost_system.CapitalCost_SurfacePlant = CapitalCostSurfacePlantORC( params=params) capital_cost_system.CapitalCost_SurfacePipe = CapitalCostSurfacePipes.cost( params=params) capital_cost_system.CapitalCost_Production_Well = CapitalCostWell.waterBaseline( params=params) capital_cost_system.CapitalCost_Injection_Well = CapitalCostWell.waterBaseline( params=params) capital_cost_system.CapitalCost_Wellfield = CapitalCostWellField.water( params=params) capital_cost_system.CapitalCost_Exploration = CapitalCostExploration.waterBaseline( params=params) capital_cost_system.CapitalCost_Stimulation = CapitalCostWellStimulation.cost( ) capital_cost_system.lcoe_model = LCOESimple(params=params) solver = FluidSystemWaterSolver(fluid_system) return FullSystemORC(params, solver, capital_cost_system)
def testORCCycleSupercritPboil(self): params = SimulationParameters(orc_fluid = 'R245fa') cycle = ORCCycleSupercritPboil(params = params) initialState = FluidState.getStateFromPT(1.e6, 190., 'water') results = cycle.solve(initialState = initialState, P_boil_Pa = 5e6) self.assertTrue(*testAssert(results.dT_range_CT, 6.8948, 'test1_dT_range_CT')) self.assertTrue(*testAssert(results.w_pump, -1.9676e+03, 'test1_w_pump')) self.assertTrue(*testAssert(results.q_boiler, 1.2030e+05, 'test1_q_boiler')) self.assertTrue(*testAssert(results.w_turbine, 2.4353e+04, 'test1_w_turbine')) self.assertTrue(*testAssert(results.q_recuperator, 9.8023e+03, 'test1_q_recuperator')) self.assertTrue(*testAssert(results.q_desuperheater, -3.0484e+03, 'test1_q_desuperheater')) self.assertTrue(*testAssert(results.q_condenser, -9.4878e+04, 'test1_q_condenser')) self.assertTrue(*testAssert(results.w_cooler, -51.2720, 'test1_w_cooler')) self.assertTrue(*testAssert(results.w_condenser, -2.5484e+03, 'test1_w_condenser')) self.assertTrue(*testAssert(results.w_net, 1.9786e+04, 'test1_w_net')) self.assertTrue(*testAssert(results.state.T_C, 73.7974, 'test1_end_T_C')) self.assertTrue(*testAssert(results.dT_LMTD_boiler, 9.6698, 'test1_dT_LMTD_boiler')) self.assertTrue(*testAssert(results.dT_LMTD_recuperator, 7.4340, 'test1_dT_LMTD_recuperator'))
def testInjectionWellCO2SmallWellR(self): ### # Testing SemiAnalyticalWell for horizontal injection well settings ### # load global physical properties gpp = SimulationParameters(working_fluid = 'co2') gpp.time_years = 10. gpp.dT_dz = 0.06 gpp.well_radius = 0.02 gpp.m_dot_IP = 0.1 vertical_well = SemiAnalyticalWell(params = gpp, dz_total = -3500., T_e_initial = 15.) # initial state initial_state = FluidState.getStateFromPT(1.e6, 25., gpp.working_fluid) vertical_well_results = vertical_well.solve(initial_state) self.assertMessages(gpp.working_fluid, (vertical_well_results.state.P_Pa, 1.1431e6), (vertical_well_results.state.T_C, 222.2246), (vertical_well_results.state.h_Jkg, 6.8717e5))
def testInjectionWellWater(self): ### # Testing SemiAnalyticalWell for vertical and horizontal injection well settings ### # load parameters gpp = SimulationParameters(working_fluid = 'water') gpp.time_years = 10. gpp.dT_dz = 0.06 gpp.well_radius = 0.279 gpp.m_dot_IP = 5. vertical_well = SemiAnalyticalWell(params = gpp, dz_total = -3500., T_e_initial = 15.) # initial state initial_state = FluidState.getStateFromPT(1.e6, 25., gpp.working_fluid) vertical_well_results = vertical_well.solve(initial_state) self.assertMessages(gpp.working_fluid, (vertical_well_results.state.P_Pa, 3.533e7), (vertical_well_results.state.T_C, 67.03), (vertical_well_results.state.h_Jkg, 3.0963e5)) horizontal_well = SemiAnalyticalWell(params = gpp, dr_total = 3000., T_e_initial = vertical_well.T_e_initial + gpp.dT_dz * abs(vertical_well.dz_total)) # initial state initial_state = FluidState.getStateFromPT(vertical_well_results.state.P_Pa, vertical_well_results.state.T_C, gpp.working_fluid) horizontal_well_results = horizontal_well.solve(initial_state) self.assertMessages(gpp.working_fluid, (horizontal_well_results.state.P_Pa, 3.533e7), (horizontal_well_results.state.T_C, 121.99), (horizontal_well_results.state.h_Jkg, 5.3712e5))
def testInjectionWellCO2(self): ### # Testing SemiAnalyticalWell for horizontal injection well settings ### # load global physical properties gpp = SimulationParameters(working_fluid = 'co2') gpp.time_years = 10. gpp.dT_dz = 0.06 gpp.well_radius = 0.279 gpp.m_dot_IP = 5. vertical_well = SemiAnalyticalWell(params = gpp, dz_total = -3500., T_e_initial = 15.) # initial state initial_state = FluidState.getStateFromPT(1.e6, 25., gpp.working_fluid) vertical_well_results = vertical_well.solve(initial_state) self.assertMessages(gpp.working_fluid, (vertical_well_results.state.P_Pa, 1.7245e6), (vertical_well_results.state.T_C, 156.08), (vertical_well_results.state.h_Jkg, 6.1802e5)) horizontal_well = SemiAnalyticalWell(params = gpp, dr_total = 3000., T_e_initial = vertical_well.T_e_initial + gpp.dT_dz * abs(vertical_well.dz_total)) # initial state initial_state = FluidState.getStateFromPT(vertical_well_results.state.P_Pa, vertical_well_results.state.T_C, gpp.working_fluid) horizontal_well_results = horizontal_well.solve(initial_state) self.assertMessages(gpp.working_fluid, (horizontal_well_results.state.P_Pa, 1.7235e6), (horizontal_well_results.state.T_C, 212.746), (horizontal_well_results.state.h_Jkg, 6.755e5))
def __init__(self, well, params=None, **kwargs): self.well = well self.params = params if self.params == None: self.params = SimulationParameters(**kwargs) self.computeSurfacePipeFrictionFactor()
def cO2Baseline(params=None, **kwargs): if params == None: params = SimulationParameters(**kwargs) return wellCO2(params.depth, params.well_radius, baseLine(params.depth), params.success_rate, params.cost_year)
class DownHolePump(object): """DownHolePump.""" def __init__(self, well, params=None, **kwargs): self.well = well self.params = params if self.params == None: self.params = SimulationParameters(**kwargs) self.computeSurfacePipeFrictionFactor() def computeSurfacePipeFrictionFactor(self): self.ff_m_dot = self.params.m_dot_IP initial_P = 1e6 + self.params.P_system_min() initial_T = 60. initial_h = FluidState.getStateFromPT(initial_P, initial_T, self.params.working_fluid).h_Jkg self.friction_factor = frictionFactor(self.params.well_radius, initial_P, initial_h, \ self.params.m_dot_IP, self.params.working_fluid, self.params.epsilon) def solve(self, initial_state, P_inj_surface): if self.ff_m_dot != self.params.m_dot_IP: self.computeSurfacePipeFrictionFactor() # initilize object with well output results = DownHolePumpOutput() # Pumping and second well d_dP_pump = 1e5 dP_pump = 0 dP_surface = np.nan dP_loops = 1 dP_Solver = Solver() while np.isnan(dP_surface) or abs(dP_surface) > 100: try: if dP_pump > self.params.max_pump_dP: dP_pump = self.params.max_pump_dP P_prod_pump_out = initial_state.P_Pa + dP_pump T_prod_pump_out = initial_state.T_C temp_at_pump_depth = self.well.T_e_initial + self.params.dT_dz * self.params.pump_depth state_in = FluidState.getStateFromPT(P_prod_pump_out, T_prod_pump_out, self.params.working_fluid) results.well = self.well.solve(state_in) # calculate surface pipe friction loss if self.params.has_surface_gathering_system: dP_surface_pipes = self.friction_factor * self.params.well_spacing / \ (2 * self.params.well_radius)**5 * 8 * self.params.m_dot_IP**2 / results.well.state.rho_kgm3 / np.pi**2 else: dP_surface_pipes = 0. dP_surface = (results.well.state.P_Pa - P_inj_surface - dP_surface_pipes) if dP_pump == self.params.max_pump_dP: break # No pumping is needed in this system if dP_pump == 0 and dP_surface >= 0: break dP_pump = dP_Solver.addDataAndEstimate(dP_pump, dP_surface) if np.isnan(dP_pump): dP_pump = -1 * dP_surface # Pump can't be less than zero if dP_pump < 0: dP_pump = 0 # Warn against excessive loops if dP_loops > 10: print('Warning::DownHolePump:dP_loops is large: %s' % dP_loops) dP_loops += 1 except ValueError as error: # Only catch problems of flashing fluid if str(error).find( 'GenGeo::SemiAnalyticalWell:BelowSaturationPressure' ) > -1: dP_pump = dP_pump + d_dP_pump else: raise error # if pump pressure greater than allowable, throw error if dP_pump >= self.params.max_pump_dP: raise Exception( 'GenGeo::DownHolePump:ExceedsMaxProductionPumpPressure - ' 'Exceeds Max Pump Pressure of %.3f MPa!' % (self.params.max_pump_dP / 1e6)) results.w_pump = 0 results.dP_surface_pipes = dP_surface_pipes if dP_pump > 0: results.w_pump = (initial_state.h_Jkg - state_in.h_Jkg) / self.params.eta_pump return results
# Further changes are done by: # ############################ import unittest from src.oRCCycleTboil import ORCCycleTboil from src.coolingCondensingTower import CoolingCondensingTower from models.coolingCondensingTowerMode import CoolingCondensingTowerMode from utils.fluidState import FluidState from models.simulationParameters import SimulationParameters from tests.testAssertion import testAssert params = SimulationParameters(orc_fluid='R245fa') cycle = ORCCycleTboil(params=params) class ORCCycleTboilTest(unittest.TestCase): def testParasiticPowerFraction(self): parasiticPowerFraction = CoolingCondensingTower.parasiticPowerFraction( 15., 7., 25., CoolingCondensingTowerMode.Wet) self.assertTrue(*testAssert(parasiticPowerFraction('cooling'), 0.016025303571428565, 'Wet - cooling')) self.assertTrue(*testAssert(parasiticPowerFraction('condensing'), 0.02685987257142855, 'Wet - condensing')) self.assertRaises(Exception, parasiticPowerFraction, 'heating') parasiticPowerFraction = CoolingCondensingTower.parasiticPowerFraction( 15., 7., 25., CoolingCondensingTowerMode.Dry) self.assertTrue(*testAssert(parasiticPowerFraction('cooling'),
def waterIdeal(params=None, **kwargs): if params == None: params = SimulationParameters(**kwargs) return well(params.depth, params.well_radius, ideal(params.depth), params.success_rate, params.cost_year)
from models.simulationParameters import SimulationParameters logTrans = np.arange(2., 8., 1.) permeabilities = 1e-15 * 10.**logTrans depths = np.arange(1000, 8000, 1000) # create output folder output_folder = 'results' if not os.path.exists(output_folder): os.mkdir(output_folder) output_file = open(os.path.join(output_folder, 'data_CO2.csv'), 'w') # initialize parameters params = SimulationParameters(working_fluid='co2', capacity_factor=0.9) # generate the full system full_system = FullSystemCPG.getDefaultCPGSystem(params) full_system_solver = FullSystemSolver(full_system) # iterate over all depths and permeabilities and solve the system for depth in depths: for permeability in permeabilities: print('Depth: ', depth) print('Permeability: ', permeability) params.depth = depth params.permeability = permeability / 100. try: output = full_system_solver.solve()
def water(params=None, **kwargs): if params == None: params = SimulationParameters(**kwargs) return cPermitting(params.cost_year)