def test_CSTR_steadystate(): dict1 = { 'Tank': { 'pollutant': 0, 'method': 'CSTR', 'parameters': { 'k': -0.2, 'n': 1.0, 'c0': 10.0 } } } conc2 = [] vol = [] flow = [] with Simulation("./tests/inps/tank_constantinflow_notreatment.inp") as sim: Tank = Nodes(sim)["Tank"] for index, step in enumerate(sim): v = Tank.volume vol.append(v) q = Tank.total_inflow flow.append(q) with Simulation("./tests/inps/tank_constantinflow_notreatment.inp") as sim: CS = waterQuality(sim, dict1) Tank = Nodes(sim)["Tank"] for index, step in enumerate(sim): CS.updateWQState_CSTR(index) c = Tank.pollut_quality conc2.append(c['P1']) C_steadystate = dict1['Tank']['parameters']['c0'] / ( (1 - (dict1['Tank']['parameters']['k'] * (np.mean(vol) / np.mean(flow))))**dict1['Tank']['parameters']['n']) error = (C_steadystate - conc2[-1]) / C_steadystate assert error <= 0.03
def reset(self): self.sim.close() self.sim = Simulation(self.input_file) # self.fcst = np.genfromtxt(self.fcst_file, delimiter=',') # read forecast file as array self.fcst = pd.read_csv(self.fcst_file, index_col="datetime", infer_datetime_format=True, parse_dates=True) self.sim.step_advance(self.control_time_step) # set control time step node_object = Nodes(self.sim) # init node object self.St1 = node_object["st1"] self.St2 = node_object["st2"] self.St3 = node_object["F134101"] link_object = Links(self.sim) # init link object self.R1 = link_object["R1"] self.R2 = link_object["R2"] self.R3 = link_object["R3"] self.sim.start() self.t = 1 if self.sim.current_time == self.sim.start_time: self.R1.target_setting = 0.5 self.R2.target_setting = 1 self.R3.target_setting = 0.5 # self.state = np.concatenate([np.asarray([self.St1.depth, self.St3.depth, self.St1.flooding, self.St3.flooding, # self.R1.current_setting, self.R3.current_setting]), self.fcst[self.t]]) current_fcst = self.fcst.iloc[self.fcst.index.get_loc(self.sim.current_time, method='nearest')] rain_fcst = sum(current_fcst[:int(len(current_fcst) / 2)]) # total rainfall in forecast tide_fcst = np.mean(current_fcst[int(len(current_fcst) / 2):]) # mean tide in forecast # self.state = np.asarray([self.St1.depth, self.St3.depth, self.St1.flooding, self.St3.flooding, # self.R1.current_setting, self.R3.current_setting, # rain_fcst, tide_fcst]) self.state = np.asarray([self.St1.depth, self.St3.depth, self.St1.flooding, self.St3.flooding, self.R1.current_setting, self.R3.current_setting, self.R1.pollut_quality['TSS'], self.R3.pollut_quality['TSS'], rain_fcst, tide_fcst]) return self.state
def test_ConstantRemoval_conc(): dict1 = { 'Tank': { 'pollutant': 0, 'method': 'ConstantRemoval', 'parameters': { 'R': 0.5 } } } conc = [] con = [] with Simulation("./tests/inps/tank_variableinflow_notreatment.inp") as sim: CR = waterQuality(sim, dict1) Tank = Nodes(sim)["Tank"] for step in sim: CR.updateWQState() c = Tank.pollut_quality conc.append(c['P1']) with Simulation( "./tests/inps/tank_variableinflow_constantremoval.inp") as sim: Tank = Nodes(sim)["Tank"] for step in sim: co = Tank.pollut_quality con.append(co['P1']) error = mse(con, conc[1:]) print(error) assert error <= 0.03
def test_NthOrderReaction_conc(): dict1 = { 'Tank': { 'pollutant': 0, 'method': 'NthOrderReaction', 'parameters': { 'k': 0.01, 'n': 2.0 } } } conc = [] con = [] with Simulation("./tests/inps/tank_variableinflow_notreatment.inp") as sim: NOR = waterQuality(sim, dict1) Tank = Nodes(sim)["Tank"] for step in sim: NOR.updateWQState() c = Tank.pollut_quality conc.append(c['P1']) with Simulation( "./tests/inps/tank_variableinflow_nthorderreaction.inp") as sim: Tank = Nodes(sim)["Tank"] for step in sim: co = Tank.pollut_quality con.append(co['P1']) error = mse(con, conc[1:]) print(error) assert error <= 0.03
def test_outfalls_8_mgd(): ''' pytest pyswmm/tests/test_nodes.py -k `test_outfalls_8_mgd` ''' sim = Simulation(MODEL_STORAGE_PUMP_MGD) print("\n\n\nOUTFALL\n") outfall = Nodes(sim)["J3"] storage = Nodes(sim)["SU1"] junction = Nodes(sim)["J2"] for ind, step in enumerate(sim): pass stats = outfall.outfall_statistics outfall_cuinflow = outfall.cumulative_inflow sim.close() assert (stats['total_periods'] == approx(208796, rel=UT_PRECISION)) assert (stats['pollutant_loading']['test'] == approx(1305.25, rel=UT_PRECISION)) assert (stats['pollutant_loading']['test'] == approx(1305.75, rel=UT_PRECISION)) assert (stats['average_flowrate'] == approx(4.3, rel=UT_PRECISION)) assert (stats['average_flowrate'] == approx(4.32, rel=UT_PRECISION)) assert (stats['peak_flowrate'] == approx(4.33, rel=UT_PRECISION)) assert (stats['peak_flowrate'] == approx(4.34, rel=UT_PRECISION)) assert (outfall_cuinflow == approx(1395293, rel=UT_PRECISION)) assert (outfall_cuinflow == approx(1395299, rel=UT_PRECISION) and outfall_cuinflow == approx(1395350, rel=UT_PRECISION))
def test_GravitySettling_conc(): dict1 = { 'Tank': { 'pollutant': 0, 'method': 'GravitySettling', 'parameters': { 'k': 0.01, 'C_s': 10.0 } } } conc = [] con = [] with Simulation("./tests/inps/tank_variableinflow_notreatment.inp") as sim: GS = waterQuality(sim, dict1) Tank = Nodes(sim)["Tank"] for step in sim: GS.updateWQState() c = Tank.pollut_quality conc.append(c['P1']) with Simulation( "./tests/inps/tank_variableinflow_gravsettling.inp") as sim: Tank = Nodes(sim)["Tank"] for step in sim: co = Tank.pollut_quality con.append(co['P1']) error = mse(con, conc[1:]) print(error) assert error <= 0.03
def test_CoRemoval_load(): dict1 = {'Tank': {'pollutant': 1, 'method': 'ConstantRemoval', 'parameters': {'R': 0.15}},\ 'Tank': {'pollutant': 0, 'method': 'CoRemoval', 'parameters': {'R1': 0.75, 'R2': 0.15}}} conc = [] conc1 = [] flow = [] flow1 = [] with Simulation("./tests/inps/tank_variableinflow_notreatment.inp") as sim: CO = waterQuality(sim, dict1) Outfall = Nodes(sim)["Outfall"] for step in sim: CO.updateWQState() c = Outfall.pollut_quality conc.append(c['P1']) flow.append(sim._model.getNodeResult("Outfall", 0)) load = [a * b for a, b in zip(conc, flow)] cum_load = np.cumsum(load) with Simulation("./tests/inps/tank_variableinflow_coremoval.inp") as sim: Outfall = Nodes(sim)["Outfall"] for step in sim: c = Outfall.pollut_quality conc1.append(c['P1']) flow1.append(sim._model.getNodeResult("Outfall", 0)) load1 = [a * b for a, b in zip(conc1, flow1)] cum_load1 = np.cumsum(load1) error = (cum_load1[-1] / cum_load[-1]) / cum_load1[-1] print(error) assert error <= 0.03
def test_EventMeanConc_conc(): dict1 = { 'Tank': { 'pollutant': 0, 'method': 'EventMeanConc', 'parameters': { 'C': 5.0 } } } conc = [] con = [] with Simulation("./tests/inps/tank_variableinflow_notreatment.inp") as sim: EMC = waterQuality(sim, dict1) Tank = Nodes(sim)["Tank"] for step in sim: EMC.updateWQState() c = Tank.pollut_quality conc.append(c['P1']) with Simulation("./tests/inps/tank_variableinflow_emc.inp") as sim: Tank = Nodes(sim)["Tank"] for step in sim: co = Tank.pollut_quality con.append(co['P1']) error = mse(con, conc) print(error) assert error <= 0.03
def __init__(self, inp_file, fcst_file, depth=4.61): # initialize simulation self.input_file = inp_file self.sim = Simulation(self.input_file) # read input file self.fcst_file = fcst_file self.fcst = np.genfromtxt(self.fcst_file, delimiter=',') # read forecast file as array self.control_time_step = 900 # control time step in seconds self.sim.step_advance(self.control_time_step) # set control time step node_object = Nodes(self.sim) # init node object self.St1 = node_object["St1"] self.St2 = node_object["St2"] self.J1 = node_object["J1"] self.depth = depth self.St1.full_depth = self.depth self.St2.full_depth = self.depth link_object = Links(self.sim) # init link object self.R1 = link_object["R1"] self.R2 = link_object["R2"] self.sim.start() if self.sim.current_time == self.sim.start_time: self.R1.target_setting = 0.5 self.R2.target_setting = 0.5 sim_len = self.sim.end_time - self.sim.start_time self.T = int(sim_len.total_seconds()/self.control_time_step) self.t = 1 self.state = np.concatenate([np.asarray([self.St1.depth, self.St2.depth, self.J1.depth, self.St1.flooding, self.St2.flooding, self.J1.flooding, self.R1.current_setting, self.R2.current_setting]), self.fcst[self.t]]) self.action_space = spaces.Box(low=np.array([0, 0]), high=np.array([1, 1]), dtype=np.float32) self.observation_space = spaces.Box(low=0, high=1000, shape=(len(self.state),), dtype=np.float32)
def reset(self): """Reset state. """ # state = np.random.random(size=(1,)) self.sim.close() self.sim = Simulation(self.modelfile) self.sim.step_advance(self.controlstep) node_object = Nodes(self.sim) self.P1 = node_object["P1"] self.P2 = node_object["P2"] self.P1.depth = self.depth self.P2.depth = self.depth link_object = Links(self.sim) self.L8 = link_object["8"] self.L8.flow = self.flow self.sim.start() if self.sim.current_time == self.sim.start_time: self.L8.target_setting = 0 self.state = np.concatenate([ np.asarray([ self.P1.depth, self.P2.depth, self.L8.flow, self.P1.flooding, self.P2.flooding, self.O1.current_setting, self.O2.current_setting ]) ]) return self.state
def simul_nodes(i,filename): ''' Function to be iterated using parallelisation Filename needs to be changed every time that the storm is changed Input ----- list of subcatchments where GI will be implemented Output ------ resilience index pandas dataframe ''' from pyswmm import Simulation area = 500 LIDsubcat_area(filename,i) fin=filename+str(hash(''.join(i)))+f'area_{area}' sim=Simulation('Res_files/'+fin+'.inp') sim.execute() res=resilienceindex_nodes_sys(fin) print('Resilience Index Calculated') os.remove('Res_files/'+fin+'.inp') os.remove('Res_files/'+fin+'.out') os.remove('Res_files/'+fin+'.rpt') print('Files removed!') return res
def test_nodes_6(): ''' pytest pyswmm/tests/test_nodes.py -k `test_nodes_6` ''' sim = Simulation(MODEL_WEIR_SETTING_PATH) print("\n\n\nNODES\n") J5 = Nodes(sim)["J5"] for ind, step in enumerate(sim): pass assert(J5.statistics['peak_total_inflow'] >= 0.478) assert(J5.statistics['average_depth'] >= 0.00018) assert(J5.statistics['surcharge_duration'] >= 0.0) assert(J5.statistics['max_ponded_volume'] >= 0.0) assert(J5.statistics['courant_crit_duration'] >= 0.0) assert(J5.statistics['peak_lateral_inflowrate'] >= 0.0) assert(J5.statistics['flooding_duration'] >= 0.0) assert(J5.statistics['peak_flooding_rate'] >= 0.0) assert(J5.statistics['lateral_infow_vol'] >= 0.0) assert(J5.statistics['max_flooding_date'] >= 42309) assert(J5.statistics['max_depth_date'] >= 42309) assert(J5.statistics['max_inflow_date'] >= 42309) assert(J5.statistics['max_depth'] >= 0.0292) assert(J5.statistics['flooding_volume'] >= 0.0) assert(J5.statistics['max_report_depth'] >= 0.0286) sim.close()
def reset(self): self.sim.close() self.sim = Simulation(swmm_inp) self.sim.step_advance(self.control_time_step) # set control time step node_object = Nodes(self.sim) # init node object self.St1 = node_object["St1"] self.St2 = node_object["St2"] self.J1 = node_object["J1"] link_object = Links(self.sim) # init link object self.R1 = link_object["R1"] self.R2 = link_object["R2"] self.St1.full_depth = self.depth self.St2.full_depth = self.depth self.sim.start() self.t = 1 if self.sim.current_time == self.sim.start_time: self.R1.target_setting = 0.5 self.R2.target_setting = 0.5 self.state = np.asarray([ self.St1.depth, self.St2.depth, self.J1.depth, self.St1.flooding, self.St2.flooding, self.J1.flooding ]) return self.state
def test_ConstantRemoval_load(): dict1 = {'Tank': {0: 0.5}} conc = [] conc1 = [] flow = [] flow1 = [] with Simulation("./inps/tank_variableinflow_notreatment.inp") as sim: CR = Node_Quality(sim, dict1) Outfall = Nodes(sim)["Outfall"] for step in sim: CR.ConstantRemoval() c = Outfall.pollut_quality conc.append(c['P1']) flow.append(sim._model.getNodeResult("Outfall", 0)) load = [a * b for a, b in zip(conc, flow)] cum_load = np.cumsum(load) with Simulation("./inps/tank_variableinflow_constantremoval.inp") as sim: Outfall = Nodes(sim)["Outfall"] for step in sim: c = Outfall.pollut_quality conc1.append(c['P1']) flow1.append(sim._model.getNodeResult("Outfall", 0)) load1 = [a * b for a, b in zip(conc1, flow1)] cum_load1 = np.cumsum(load1) error = (cum_load1[-1] / cum_load[-1]) / cum_load1[-1] print(error) assert error <= 0.03
def reset(self): self.sim.close() self.sim = Simulation(self.input_file) self.fcst = np.genfromtxt(self.fcst_file, delimiter=',') # read forecast file as array self.sim.step_advance(self.control_time_step) # set control time step node_object = Nodes(self.sim) # init node object self.St1 = node_object["St1"] self.St2 = node_object["St2"] self.J1 = node_object["J1"] link_object = Links(self.sim) # init link object self.R1 = link_object["R1"] self.R2 = link_object["R2"] self.St1.full_depth = self.depth self.St2.full_depth = self.depth self.sim.start() self.t = 1 if self.sim.current_time == self.sim.start_time: self.R1.target_setting = 0.5 self.R2.target_setting = 0.5 self.state = np.concatenate([ np.asarray([ self.St1.depth, self.St2.depth, self.J1.depth, self.St1.flooding, self.St2.flooding, self.J1.flooding, self.R1.current_setting, self.R2.current_setting ]), self.fcst[self.t] ]) return self.state
def __init__(self,depth=5): # initialize simulation self.sim = Simulation(swmm_inp) # read input file self.control_time_step = 900 # control time step in seconds self.sim.step_advance(self.control_time_step) # set control time step node_object = Nodes(self.sim) # init node object self.St1 = node_object["St1"] self.St2 = node_object["St2"] self.J3 = node_object["J3"] self.depth = depth self.St1.full_depth = self.depth self.St2.full_depth = self.depth link_object = Links(self.sim) # init link object self.R1 = link_object["R1"] self.R2 = link_object["R2"] self.sim.start() if self.sim.current_time == self.sim.start_time: self.R1.target_setting = 0.5 self.R2.target_setting = 0.5 sim_len = self.sim.end_time - self.sim.start_time self.T = int(sim_len.total_seconds()/self.control_time_step) self.t = 1 #print('T=', self.T) self.state = np.asarray([self.St1.depth, self.St2.depth, self.J3.depth, self.St1.flooding, self.St2.flooding, self.J3.flooding]) self.action_space = spaces.Box(low=np.array([0,0]),high=np.array([1,1]), dtype=np.float32) self.observation_space = spaces.Box(low=0, high = 1000, shape=(len(self.state),),dtype=np.float32)
def test_EventMeanConc_load(): dict1 = { 'Tank': { 'pollutant': 0, 'method': 'EventMeanConc', 'parameters': { 'C': 5.0 } } } conc = [] conc1 = [] flow = [] flow1 = [] with Simulation("./tests/inps/tank_variableinflow_notreatment.inp") as sim: EMC = waterQuality(sim, dict1) Outfall = Nodes(sim)["Outfall"] for step in sim: EMC.updateWQState() c = Outfall.pollut_quality conc.append(c['P1']) flow.append(sim._model.getNodeResult("Outfall", 0)) load = [a * b for a, b in zip(conc, flow)] cum_load = np.cumsum(load) with Simulation("./tests/inps/tank_variableinflow_emc.inp") as sim: Outfall = Nodes(sim)["Outfall"] for step in sim: c = Outfall.pollut_quality conc1.append(c['P1']) flow1.append(sim._model.getNodeResult("Outfall", 0)) load1 = [a * b for a, b in zip(conc1, flow1)] cum_load1 = np.cumsum(load1) error = (cum_load1[-1] / cum_load[-1]) / cum_load1[-1] print(error) assert error <= 0.03
def test_outfalls_8(): sim = Simulation(MODEL_STORAGE_PUMP) print("\n\n\nOUTFALL\n") outfall = Nodes(sim)["J3"] for ind, step in enumerate(sim): if ind % 1000 == 0: print(outfall.outfall_statistics) sim.close()
def test_nodes_6(): sim = Simulation(MODEL_WEIR_SETTING_PATH) print("\n\n\nNODES\n") J5 = Nodes(sim)["J5"] for ind, step in enumerate(sim): if ind % 1000 == 0: print(J5.statistics) sim.close()
def test_outfalls_7(): sim = Simulation(MODEL_STORAGE_PUMP) print("\n\n\nSTORAGE\n") STOR1 = Nodes(sim)["SU1"] for ind, step in enumerate(sim): if ind % 1000 == 0: print(STOR1.storage_statistics) sim.close()
def test_storage_7(): ''' pytest pyswmm/tests/test_nodes.py -k `test_storage_7` ''' sim = Simulation(MODEL_STORAGE_PUMP) print("\n\n\nSTORAGE\n") STOR1 = Nodes(sim)["SU1"] for ind, step in enumerate(sim): pass stats = STOR1.storage_statistics assert (stats['max_volume'] == approx(5000.0, rel=UT_PRECISION)) assert (stats['peak_flowrate'] == approx(0.0, rel=UT_PRECISION)) assert (stats['exfil_loss'] == approx(0.0, rel=UT_PRECISION)) assert (stats['evap_loss'] == approx(0.0, rel=UT_PRECISION)) assert (stats['average_volume'] == approx(4979.0, rel=UT_PRECISION)) assert (stats['average_volume'] == approx(4980.0, rel=UT_PRECISION)) assert (stats['max_vol_date'] == approx(42309.0, rel=UT_PRECISION)) assert (stats['max_vol_date'] == approx(42310.0, rel=UT_PRECISION)) assert (stats['initial_volume'] == approx(0.0, rel=UT_PRECISION)) stats = STOR1.statistics assert (stats['peak_total_inflow'] == approx(2.9, rel=UT_PRECISION)) assert (stats['peak_total_inflow'] == approx(3.1, rel=UT_PRECISION)) assert (stats['average_depth'] == approx(4.9, rel=UT_PRECISION)) assert (stats['average_depth'] == approx(5, rel=UT_PRECISION)) assert (stats['flooding_duration'] == approx(57, rel=UT_PRECISION)) assert (stats['flooding_duration'] == approx(58, rel=UT_PRECISION)) assert (stats['peak_flooding_rate'] == approx(2.9, rel=UT_PRECISION)) assert (stats['peak_flooding_rate'] == approx(3.1, rel=UT_PRECISION)) assert (stats['lateral_infow_vol'] == approx(0.0, rel=UT_PRECISION)) assert (stats['max_flooding_date'] == approx(42309, rel=UT_PRECISION)) assert (stats['max_flooding_date'] == approx(42310, rel=UT_PRECISION)) assert (stats['max_depth_date'] == approx(42309, rel=UT_PRECISION)) assert (stats['max_depth_date'] == approx(42310, rel=UT_PRECISION)) assert (stats['max_inflow_date'] == approx(42309, rel=UT_PRECISION)) assert (stats['max_inflow_date'] == approx(42310, rel=UT_PRECISION)) assert (stats['max_depth'] == approx(4.99, rel=UT_PRECISION)) assert (stats['max_depth'] == approx(5.01, rel=UT_PRECISION)) assert (stats['flooding_volume'] == approx(621390, rel=UT_PRECISION)) assert (stats['flooding_volume'] == approx(621393, rel=UT_PRECISION)) assert (stats['max_report_depth'] == approx(4.99, rel=UT_PRECISION)) assert (stats['max_report_depth'] == approx(5.01, rel=UT_PRECISION)) print(STOR1.statistics) sim.close()
def run_swmm(): #======================================= # setup all the nodes before starting #======================================= sim = Simulation('./pipe_test.inp') #======================================= # Start the simulation #======================================= print(sim._isStarted) sim.start() print(sim._isStarted) node_names = ['Inlet', 'Outlet'] link_names = ['Culvert'] nodes = [Nodes(sim)[names] for names in node_names] links = [Links(sim)[names] for names in link_names] # type, area, length, orifice_coeff, free_weir_coeff, submerged_weir_coeff opening0 = nodes[0].create_opening(4, 1.0, 1.0, 0.6, 1.6, 1.0) opening0 = nodes[1].create_opening(4, 1.0, 1.0, 0.6, 1.6, 1.0) print("\n") print("n0 is coupled? ", nodes[0].is_coupled) print("n1 is coupled? ", nodes[1].is_coupled) nodes[0].overland_depth = 1.0 nodes[0].coupling_area = 1.0 # This step_advance should be an integer multiple of the routing step # which is set in the ,inp file. Currently set to 1s. # Should be able to interrogate sim to find out what the # routing stepsize is. Maybe should issue a warning if # step_advance is set lower than the routing step size. # Indeed maybe step_advance should just allow advance n routing steps? for i in range(50): ids = dict() volumes = sim.coupling_step(1.0) print("Step:", i) print("Current time:", sim.current_time) #print("volumes:",volumes) #print(volumes) for flows in volumes: #print(flows) vols = flows[1] for key in vols: print("Volume total at node", key, "at time", flows[0], ":", vols[key])
def test_lib_5(): """Testing SWMM Path as argument to Simulation Object. On Windows for now.""" if os.name == 'nt': print(WIN_SWMM_LIB_PATH) sim = Simulation(MODEL_WEIR_SETTING_PATH, swmm_lib_path=WIN_SWMM_LIB_PATH) sim.execute() pyswmm.lib.use(WIN_SWMM_LIB_PATH)
def test_storage_7(): ''' pytest pyswmm/tests/test_nodes.py -k `test_storage_7` ''' sim = Simulation(MODEL_STORAGE_PUMP) print("\n\n\nSTORAGE\n") STOR1 = Nodes(sim)["SU1"] for ind, step in enumerate(sim): pass stats = STOR1.storage_statistics assert(stats['max_volume'] == 5000.0) assert(stats['peak_flowrate'] == 0.0) assert(stats['exfil_loss'] == 0.0) assert(stats['evap_loss'] == 0.0) assert(stats['average_volume'] >= 4979.0) assert(stats['average_volume'] <= 4980.0) assert(stats['max_vol_date'] >= 42309.0) assert(stats['max_vol_date'] <= 42310.0) assert(stats['initial_volume'] == 0.0) stats = STOR1.statistics assert(stats['peak_total_inflow'] >= 2.9) assert(stats['peak_total_inflow'] <= 3.1) assert(stats['average_depth'] >= 4.9) assert(stats['average_depth'] <= 5) assert(stats['flooding_duration'] >= 57) assert(stats['flooding_duration'] <= 58) assert(stats['peak_flooding_rate'] >= 2.9) assert(stats['peak_flooding_rate'] <= 3.1) assert(stats['lateral_infow_vol'] == 0.0) assert(stats['max_flooding_date'] >= 42309) assert(stats['max_flooding_date'] <= 42310) assert(stats['max_depth_date'] >= 42309) assert(stats['max_depth_date'] <= 42310) assert(stats['max_inflow_date'] >= 42309) assert(stats['max_inflow_date'] <= 42310) assert(stats['max_depth'] >= 4.99) assert(stats['max_depth'] <= 5.01) assert(stats['flooding_volume'] >= 621390) assert(stats['flooding_volume'] <= 621393) assert(stats['max_report_depth'] >= 4.99) assert(stats['max_report_depth'] <= 5.01) print(STOR1.statistics) sim.close()
class Env: def __init__(self, input_file): self.input_file = input_file self.sim = Simulation(self.input_file) self.sim.start() self.time = 1.0 def step(self): if self.time > 0: done = False self.time = self.sim._model.swmm_step() else: done = True print("Simulation Ended") return done def terminate(self): self.sim._model.swmm_end() self.sim._model.swmm_close() def depthN(self, node_id): return self.sim._model.getNodeResult(node_id, 5) def depthL(self, link_id): return self.sim._model.getLinkResult(link_id, 1) def flow(self, link_id): return self.sim._model.getLinkResult(link_id, 0) def get_precip(self, subcatchment_id): pass def set_precip(self, subcatchment_id): pass def get_gate(self, orifice): return self.sim._model.getLinkResult(orifice, 6) def set_gate(self, orifice, gate): self.sim._model.setLinkSetting(orifice, gate) def get_pollutant_node(self, node): return self.sim._model.getNodeResult(node, 100) def get_pollutant_link(self, link): return self.sim._model.getLinkResult(link, 100) def reset(self): self.sim._model.swmm_end() self.sim._model.swmm_close() # Start the next simulation self.sim._model.swmm_open() self.sim._model.swmm_start() self.time = 1.0
def reset(self): # make this dynamic later self.swmm_inp = "data/simple3.inp" self.sim = Simulation(self.swmm_inp) self.sim.step_advance(self.control_time_step) # set control time step self.node_object = Nodes(self.sim) self.link_object = Links(self.sim) self.total_rewards.append(self.eps_reward) self.eps_reward = 0 self.global_current_step += 1 self.current_step = 0 self.done = False self.sim.start() self.sim_len = self.sim.end_time - self.sim.start_time self.T = self.sim_len.total_seconds() // self.control_time_step for i in range(1, self.R + 1): self.link_object['R' + str(i)].target_setting = random.randrange(1) self.settings = [ self.link_object['R' + str(i)].current_setting for i in range(1, self.R + 1) ] # one for loop would be faster but less readable # making new lists all the time is probably bad self.depths = [ self.node_object['St' + str(i)].depth for i in range(1, self.R + 1) ] self.depths.extend([ self.node_object['J' + str(i)].depth for i in range(2, self.J + 1) ]) self.flooding = [ self.node_object['St' + str(i)].flooding for i in range(1, self.R + 1) ] self.flooding.extend([ self.node_object['J' + str(i)].flooding for i in range(2, self.J + 1) ]) self.reward = reward_function(self.depths, self.flooding) self.eps_reward += self.reward return np.asarray(self.settings + self.depths + self.flooding)
def test_nodes_5(): sim = Simulation(MODEL_WEIR_SETTING_PATH) print("\n\n\nNODES\n") J5 = Nodes(sim)["J5"] for ind, step in enumerate(sim): if ind == 7: J5.generated_inflow(544.0) if ind > 8: assert (J5.lateral_inflow >= 543.9) print(J5.lateral_inflow) sim.close()
def test_nodes_5(): sim = Simulation(MODEL_WEIR_SETTING_PATH) print("\n\n\nNODES\n") J5 = Nodes(sim)["J5"] for ind, step in enumerate(sim): if ind == 7: J5.generated_inflow(544.0) if ind > 8: assert (J5.lateral_inflow == approx(543.9, rel=UT_PRECISION)) if ind % 1000 == 0: print(J5.lateral_inflow) sim.close()
def test_nodes_11(): ''' pytest pyswmm/tests/test_nodes.py -k `test_outfalls_8_mgd` ''' sim = Simulation(MODEL_STORAGE_PUMP_MGD) print("\n\n\nOUTFALL\n") outfall = Nodes(sim)["J3"] for ind, step in enumerate(sim): pass stats = outfall.outfall_statistics outfall_cuinflow = outfall.cumulative_inflow sim.close() assert (outfall_cuinflow == approx(1395293, rel=UT_PRECISION)) assert (outfall_cuinflow == approx(1395299, rel=UT_PRECISION) and outfall_cuinflow == approx(1395350, rel=UT_PRECISION))
def test_simulation_1(): sim = Simulation(MODEL_WEIR_SETTING_PATH) for ind, step in enumerate(sim): print(step.getCurrentSimulationTime()) sim.step_advance(randint(300, 900)) sim.report() sim.close()