def test_links_2(): with Simulation(MODEL_WEIR_SETTING_PATH) as sim: link_names = ["C1", "C1:C2", "C2", "C3"] for link in Links(sim): assert (link.linkid in link_names) link.flow_limit = 10 assert (link.flow_limit == 10)
def test_CoRemoval_load(): dict1 = {'Culvert': {'pollutant': 1, 'method': 'ConstantRemoval', 'parameters': {'R': 0.15}},\ 'Culvert': {'pollutant': 0, 'method': 'CoRemoval', 'parameters': {'R1': 0.75, 'R2': 0.15}}, } conc = [] conc1 = [] flow = [] flow1 = [] with Simulation("./tests/inps/LinkTest_variableinflow2.inp") as sim: CR = waterQuality(sim, dict1) culvert = Links(sim)["Culvert"] outlet = Nodes(sim)["Outlet"] for step in sim: CR.updateWQState() c = culvert.pollut_quality conc.append(c['P1']) c1 = outlet.pollut_quality conc1.append(c1['P1']) flow.append(sim._model.getLinkResult("Culvert", 0)) flow1.append(sim._model.getNodeResult("Outlet", 0)) load = [a * b for a, b in zip(conc, flow)] cum_load = np.cumsum(load) 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 updateWQState(self): """ Runs the selected water quality method (except CSTR) and updates the pollutant concentration during a SWMM simulation. """ nodes = Nodes(self.sim) links = Links(self.sim) for asset_ID, asset_info in self.config.items(): for node in nodes: attribute = self.config[asset_ID]['method'] if node.nodeid == asset_ID: self.flag = 0 self.method[attribute](asset_ID, \ self.config[asset_ID]['pollutant'], \ self.config[asset_ID]['parameters'], self.flag) for link in links: attribute = self.config[asset_ID]['method'] if link.linkid == asset_ID: self.flag = 1 self.method[attribute](asset_ID, \ self.config[asset_ID]['pollutant'], \ self.config[asset_ID]['parameters'], self.flag)
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_CSTR_load(): dict1 = { 'Tank': { 'pollutant': 0, 'method': 'CSTR', 'parameters': { 'k': -0.2, 'n': 1.0, 'c0': 10.0 } } } conc = [] conc1 = [] flow = [] flow1 = [] with Simulation("./tests/inps/tank_constantinflow_notreatment.inp") as sim: CS = waterQuality(sim, dict1) Tank = Nodes(sim)["Tank"] Valve = Links(sim)["Valve"] for index, step in enumerate(sim): CS.updateWQState_CSTR(index) c = Tank.pollut_quality conc.append(c['P1']) c1 = Valve.pollut_quality conc1.append(c1['P1']) flow.append(sim._model.getNodeResult("Tank", 0)) flow1.append(sim._model.getLinkResult("Valve", 0)) load = [a * b for a, b in zip(conc, flow)] cum_load = np.cumsum(load) 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): """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 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, 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 test_GravitySettling_load(): dict1 = { 'Culvert': { 'pollutant': 0, 'method': 'GravitySettling', 'parameters': { 'k': 0.01, 'C_s': 10.0 } } } conc = [] conc1 = [] flow = [] flow1 = [] with Simulation("./tests/inps/LinkTest_variableinflow.inp") as sim: GS = waterQuality(sim, dict1) culvert = Links(sim)["Culvert"] outlet = Nodes(sim)["Outlet"] for step in sim: GS.updateWQState() c = culvert.pollut_quality conc.append(c['P1']) c1 = outlet.pollut_quality conc1.append(c1['P1']) flow.append(sim._model.getLinkResult("Culvert", 0)) flow1.append(sim._model.getNodeResult("Outlet", 0)) load = [a * b for a, b in zip(conc, flow)] cum_load = np.cumsum(load) 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(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_CSTR_load(): dict1 = {'Tank': {0: [-0.2, 1.0, 0.0]}} conc = [] conc1 = [] flow = [] flow1 = [] with Simulation("./inps/tank_constantinflow_notreatment.inp") as sim: CS = Node_Quality(sim, dict1) Tank = Nodes(sim)["Tank"] Valve = Links(sim)["Valve"] for index, step in enumerate(sim): CS.CSTR_solver(index) c = Tank.pollut_quality conc.append(c['P1']) c1 = Valve.pollut_quality conc1.append(c1['P1']) flow.append(sim._model.getNodeResult("Tank", 0)) flow1.append(sim._model.getLinkResult("Valve", 0)) load = [a * b for a, b in zip(conc, flow)] cum_load = np.cumsum(load) 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_CoRemoval_load(): dict1 = {'Culvert': {0: [0.75, 0.15]}} dict2 = {'Culvert': {1: 0.15}} conc = [] conc1 = [] flow = [] flow1 = [] with Simulation("./inps/LinkTest_variableinflow2.inp") as sim: CR = Link_Quality(sim, dict1) culvert = Links(sim)["Culvert"] outlet = Nodes(sim)["Outlet"] for step in sim: CR.CoRemoval() c = culvert.pollut_quality conc.append(c['P1']) c1 = outlet.pollut_quality conc1.append(c1['P1']) flow.append(sim._model.getLinkResult("Culvert", 0)) flow1.append(sim._model.getNodeResult("Outlet", 0)) load = [a * b for a, b in zip(conc, flow)] cum_load = np.cumsum(load) 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_Erosion_load(): dict1 = {'Channel': {0: [10.0, 0.001, 2.68, 0.7]}} conc = [] conc1 = [] flow = [] flow1 = [] with Simulation("./inps/LinkTest_variableinflow.inp") as sim: ER = Link_Quality(sim, dict1) channel = Links(sim)["Channel"] tailwater = Nodes(sim)["TailWater"] for step in sim: ER.Erosion() c = channel.pollut_quality conc.append(c['P1']) c1 = tailwater.pollut_quality conc1.append(c1['P1']) flow.append(sim._model.getLinkResult("Channel", 0)) flow1.append(sim._model.getNodeResult("Tailwater", 0)) load = [a * b for a, b in zip(conc, flow)] cum_load = np.cumsum(load) 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.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_links_2(): with Simulation(MODEL_WEIR_SETTING_PATH) as sim: for link in Links(sim): print(link) print(link.linkid) print(link.flow_limit) link.flow_limit = 10 print(link.flow_limit)
def fit_func(nest, My_Current_step, CONTROL_RULES, Current_States): sim = Simulation(r"./test.inp") Linkname = ["C1", "C2", "O1", "O2"] Nodename = ["St1", "St2", "J1", "J2"] links = Links(sim) nodes = Nodes(sim) t = 0 for link in Linkname: a2 = links[link] a2.initial_flow = Current_States[t][0] t = t + 1 for node in Nodename: a1 = nodes[node] a1.initial_depth = Current_States[t][0] t = t + 1 flood1 = np.array([]) flood2 = np.array([]) flood3 = np.array([]) flood4 = np.array([]) o1 = Links(sim)["O1"] o2 = Links(sim)["O2"] j1 = Nodes(sim)["J1"] j2 = Nodes(sim)["J2"] j3 = Nodes(sim)["St1"] j4 = Nodes(sim)["St2"] sim.start_time = my_Start_time + datetime.timedelta( minutes=My_timestep * (My_Current_step)) sim.end_time = my_Start_time + datetime.timedelta( minutes=My_timestep * (My_Current_step + HorizonLength + 1)) sim.step_advance(My_timestep * 60) CONTROL_RULES[My_Current_step:My_Current_step + HorizonLength] = nest.reshape([4, -1]) i = 0 for step in sim: o1.target_setting = CONTROL_RULES[i + My_Current_step][0] o2.target_setting = CONTROL_RULES[i + My_Current_step][1] i = i + 1 flood1 = np.append(flood1, [j1.flooding]) flood2 = np.append(flood2, [j2.flooding]) flood3 = np.append(flood3, [j3.flooding]) flood4 = np.append(flood4, [j4.flooding]) sim.close() return mytrape(flood1, 60 * My_timestep) + mytrape( flood2, 60 * My_timestep) + mytrape( flood3, 60 * My_timestep) + mytrape(flood4, 60 * My_timestep)
def test_simulation_iter(): with Simulation(MODEL_WEIR_SETTING_PATH) as sim: c1c2 = Links(sim)["C1:C2"] sim.step_advance(300) for ind, step in enumerate(sim): print(c1c2.flow, c1c2.target_setting) if c1c2.flow > 9.19: c1c2.target_setting = 0.9
def test_links_6(): with Simulation(MODEL_STORAGE_PUMP) as sim: print("\n\n\nConduits\n") link = Links(sim)["C2"] sim.step_advance(300) for ind, step in enumerate(sim): if ind % 1000 == 0: print(link.conduit_statistics)
def test_links_7(): with Simulation(MODEL_STORAGE_PUMP) as sim: print("\n\n\nPUMPS\n") link = Links(sim)["P1"] sim.step_advance(300) for ind, step in enumerate(sim): if ind % 1000 == 0: print(link.pump_statistics)
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 step(self, action): self.current_step += 1 self.settings, self.depths, self.flooding = [], [], [] self.node_object = Nodes(self.sim) self.link_object = Links(self.sim) x = 0 for i in self.links: self.link_object[i].target_setting = action[x] self.eps_action[x].append(action[x]) x += 1 self.sim.__next__() for i in self.links: self.settings.append(self.link_object[i].current_setting) ii = 0 for i in self.nodes: self.depths.append(self.node_object[i].depth) self.flooding.append(self.node_object[i].flooding) self.eps_depths[ii].append(self.node_object[i].depth) ii += 1 self.floodings += sum(self.flooding) self.flood.append(sum(self.flooding)) self.reward = reward_function(self.depths, self.flooding) self.eps_reward += self.reward state = [] state = self.settings.copy() state.extend(self.depths) state.extend(self.flooding) time = str(self.sim.current_time).split(" ") time = time[1].split(":") cur = self.day[int(time[0])].split(" ")[3] if (int(time[0]) < 23): nxt = self.day[int(time[0]) + 1].split(" ")[3] else: nxt = 0 cur = int(float(cur) * random.uniform(.95, 1.05)) nxt = int(float(nxt) * random.uniform(.85, 1.15)) state.extend([cur, nxt]) xx = [] for x in state: xx.append(float(x) * random.uniform(0.9, 1.1)) return state, self.reward, self.done #, {} # {} is debugging information
def swmm_run(k=k, pctImperv_c=pctImperv_c, pctImperv_l=pctImperv_l, slope=slope, nPerv=nPerv, nImperv=nImperv, stoPerv=stoPerv, rain=rain, stoImperv=stoImperv, infi=infi,imd=imd): #def swmm_run(k=k, slope=slope): #sublist = [] lawn = ['s31', 's32', 's33', 's34', 's41', 's42', 's43', 's59', 's60', 's61', 's62', 's63', 's64'] simflow = [] i = 0 flow_temp = 0 with Simulation('tianheful_backup625.inp') as sim: #with Simulation('tianheful_backup1.inp') as sim: subcatchments = Subcatchments(sim) #for sub in subcatchments: # sublist.append(sub.subcatchmentid) for sub in subcatchments: sub.width = k / 100 * np.sqrt(sub.area * 10000) sub.percent_impervious = pctImperv_c / 100 sub.slope = slope / 100 sub.perv_n = nPerv / 100 sub.imperv_n = nImperv / 100 sub.perv_sto = stoPerv / 100 sub.imperv_sto = stoImperv / 100 sub.Ks = infi / 100 sub.IMD = imd / 100 sub.rainMulti = rain / 100 #for j in range(len(sublist)): # subcatchments[sublist[j]].width = k / 100 * np.sqrt(subcatchments[sublist[j]].area * 10000) # subcatchments[sublist[j]].slope = slope[j] / 100 # subcatchments[sublist[j]].Ks = infi / 100 # subcatchments[sublist[j]].IMD = imd / 100 for sublawn in lawn: subcatchments[sublawn].percent_impervious = pctImperv_l / 100 #print(sublawn) #print(subcatchments[sublawn].percent_impervious) links = Links(sim) #for link in links: # link.con_roughness = roughness / 100 l29 = links['l29'] #print(l29.con_roughness) for step in sim: flow_temp += l29.flow # integrate 30s data to 1min i += 1 if i > 1: #print(i) simflow.append(flow_temp / 2) i = 0 flow_temp = 0 #simflow.append(l29.flow) #print(sim.current_time) #print(sim.flow_routing_error) return simflow
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 run_no_control_sim(controlDict, upstreamDict, downstreamDict, dsKeys, swmmINP, performanceDict): with Simulation(swmmINP) as sim: freq = '12s' timesteps = pd.date_range(sim.start_time, sim.end_time, freq=freq) price = [] PDemand = [] nodes = Nodes(sim) links = Links(sim) for point in controlDict: controlDict[point]['pyswmmVar'] = links[point] for point in upstreamDict: upstreamDict[point]['pyswmmVar'] = links[point] for point in downstreamDict: downstreamDict[point]['pyswmmVar'] = links[point] for point in performanceDict: if performanceDict[point]['type'] == 'outfall' or performanceDict[ point] == 'junction' or performanceDict[point] == 'storage': performanceDict[point]['pyswmmVar'] = nodes[point] elif performanceDict[point]['type'] == 'link': performanceDict[point]['pyswmmVar'] = links[point] print('running simulation...') for step in sim: for point in controlDict: controlDict[point]['pyswmmVar'].target_setting = 1.0 for point in upstreamDict: upstreamDict[point]['ts'].append( upstreamDict[point]['pyswmmVar'].depth / upstreamDict[point]['max_depth']) for point in downstreamDict: downstreamDict[point]['ts_flow'].append( downstreamDict[point]['pyswmmVar'].flow / downstreamDict[point]['max_flow']) downstreamDict[point]['ts_depth'].append( downstreamDict[point]['pyswmmVar'].depth / downstreamDict[point]['max_depth']) for point in performanceDict: try: performanceDict[point]['ts_flow'].append( performanceDict[point]['pyswmmVar'].flow) except: pass try: performanceDict[point]['ts_flow'].append( performanceDict[point]['pyswmmVar'].total_inflow) except: pass print('done ...')
def main(): with Simulation(os.path.join(project_dir, "cmac_temp/temp_inp.inp")) as sim: sim.step_advance(control_time_step) node_object = Nodes(sim) # init node object St1 = node_object["St1"] St2 = node_object["St2"] J1 = node_object["J1"] J2 = node_object["J2"] Out1 = node_object["Out1"] St1.full_depth = 4.61 St2.full_depth = 4.61 link_object = Links(sim) # init link object C2 = link_object["C2"] C3 = link_object["C3"] R1 = link_object["R1"] R2 = link_object["R2"] # set initial conditions def init_conditions(): St1.initial_depth = init_df[0] St2.initial_depth = init_df[1] J1.initial_depth = init_df[2] J2.initial_depth = init_df[3] Out1.initial_depth = init_df[4] C2.initial_flow = init_df[5] C3.initial_flow = init_df[6] R1.target_setting = init_df[7] R2.target_setting = init_df[8] sim.initial_conditions(init_conditions) for step in sim: pass flood_dict = { "St1": (St1.statistics['flooding_volume'] ), # volume in ft^3, multiply by 7.481 for gallons "St2": (St2.statistics['flooding_volume']), "current_dt": str(sim.current_time) } flood_json = json.dumps(flood_dict) sim.close() # save results data # result_list = [St1_flooding, St2_flooding, current_dt] # results_df = pd.DataFrame(result_list).transpose() # results_df.to_csv("C:/swmm_opti_cmac/cmac_temp/temp_flood.csv", index=False) return flood_json
def test_links_3(): with Simulation(MODEL_WEIR_SETTING_PATH) as sim: print("\n\n\nLINKS\n") c1c2 = Links(sim)["C1:C2"] sim.step_advance(300) for ind, step in enumerate(sim): if ind > 15: c1c2.flow_limit = 1 if ind > 30: c1c2.flow_limit = 0 if ind > 16 and ind <= 30: assert (c1c2.flow == 1)
def test_links_1(): with Simulation(MODEL_WEIR_SETTING_PATH) as sim: print("\n\n\nLINKS\n") c1c2 = Links(sim)["C1:C2"] assert (c1c2.linkid == "C1:C2") assert (c1c2.is_conduit() == True) assert (c1c2.is_pump() == False) assert (c1c2.is_orifice() == False) assert (c1c2.is_weir() == False) assert (c1c2.is_outlet() == False) assert (c1c2.connections == ("J1", "J2")) assert (c1c2.inlet_node == "J1") assert (c1c2.outlet_node == "J2")
def State_Update(CONTROL_RULES, Current_States, My_Current_step): sim = Simulation(r"./test.inp") Linkname = ["C1", "C2", "O1", "O2"] Nodename = ["St1", "St2", "J1", "J2"] links = Links(sim) nodes = Nodes(sim) o1 = Links(sim)["O1"] o2 = Links(sim)["O2"] t = 0 sim.start_time = my_Start_time + datetime.timedelta(minutes=My_timestep * (My_Current_step)) sim.end_time = my_Start_time + datetime.timedelta( minutes=My_timestep * (My_Current_step + HorizonLength + 1)) sim.step_advance(My_timestep * 60) for link in Linkname: a2 = links[link] a2.initial_flow = Current_States[t][0] t = t + 1 for node in Nodename: a1 = nodes[node] a1.initial_depth = Current_States[t][0] t = t + 1 i = 0 for step in sim: o1.target_setting = CONTROL_RULES[i + My_Current_step][0] o2.target_setting = CONTROL_RULES[i + My_Current_step][1] i = i + 1 t = 0 for link in Linkname: a2 = links[link] Current_States[t][0] = a2.flow t = t + 1 for node in Nodename: a1 = nodes[node] Current_States[t][0] = a1.depth t = t + 1 return Current_States
def test_links_1(): with Simulation(MODEL_WEIR_SETTING_PATH) as sim: print("\n\n\nLINKS\n") c1c2 = Links(sim)["C1:C2"] print(c1c2.flow) print(c1c2.is_conduit()) print(c1c2.is_pump()) print(c1c2.is_orifice()) print(c1c2.is_weir()) print(c1c2.is_outlet()) print(c1c2.connections) print(c1c2.inlet_node) print(c1c2.outlet_node) print(c1c2.average_head_loss) sim.step_advance(300) for ind, step in enumerate(sim): if c1c2.flow > 9.19: c1c2.target_setting = 0.9
def create_network(inputfilename=FileSettings.settingsdict['inputfilename']): """ This function creates the system-wide NetworkX DiGraph that contains every node and connection. :param inputfilename: :return: """ global sim linklist = [] with Simulation(inputfilename) as sim: for sub in Subcatchments(sim): network.add_node(sub.subcatchmentid) for nodes in Nodes(sim): network.add_node(nodes.nodeid) for link in Links(sim): linklist.append(link.connections) network.add_edges_from(linklist) for sub in Subcatchments(sim): network.add_edge(sub.subcatchmentid, sub.connection[1]) return