def wind_farm_info(self): myInputs = inputs.Inputs(self.name, self.subname) input_windturbine = myInputs.wind_farm() input_weather = myInputs.wind_farm_weather() myWindfarm = renewables.Windturbine( turbine_name=input_windturbine['turbine_name'], hub_height=input_windturbine['hub_height'], rotor_diameter=input_windturbine['rotor_diameter'], multiplier=input_windturbine['number_of_turbines'], wind_farm_efficiency=input_windturbine['efficiency'], weather_input=input_weather) power = myWindfarm.wind_farm_power()['wind_farm'] data = power.values sort = np.sort(data)[::-1] exceedence = np.arange(1., len(sort) + 1) / len(sort) exceedence_rounded = np.around(exceedence, decimals=2) lower_band_array = np.where( exceedence_rounded == self.lower_percent)[0] lower_band_array_median = np.median(lower_band_array) lower_band = sort[int(lower_band_array_median)] higher_band_array = np.where( exceedence_rounded == self.higher_percent)[0] higher_band_array_median = np.median(higher_band_array) higher_band = sort[int(higher_band_array_median)] dic = {'lower_band': lower_band, 'higher_band': higher_band, 'power': power} return dic
def wind_user_power(name, subname): """power of user-defined wind turbine takes inputs from the excel spreadsheet creates a wind turbine object calculates hourly power output over year Returns: pandas df -- power output 8760 steps """ myInputs = inputs.Inputs(name, subname) input_windturbine = myInputs.windturbine_user() input_weather = myInputs.weather() myWindturbine = Windturbine( turbine_name=input_windturbine['turbine_name'], hub_height=input_windturbine['hub_height'], rotor_diameter=input_windturbine['rotor_diameter'], multiplier=input_windturbine['multiplier'], nominal_power=input_windturbine['nominal_power'], power_curve=input_windturbine['power_curve'], weather_input=input_weather) power = myWindturbine.user_power()['wind_database'] return power
def __init__(self, name, subname): self.name = name self.subname = subname classes = initialise_classes.init(name, subname) self.myUserWindturbine = classes['myUserWindturbine'] self.myDatabaseWindturbine = classes['myDatabaseWindturbine'] self.myPV = classes['myPV'] self.myHotWaterTank = classes['myHotWaterTank'] self.myHeatPump = classes['myHeatPump'] self.myElectricalStorage = classes['myElectricalStorage'] self.myAux = classes['myAux'] myInputs = inputs.Inputs(name, subname) self.horizon = myInputs.controller()['horizon'] dem = myInputs.demands() self.source_temp = dem['source_temp'] self.flow_temp = dem['flow_temp_DH'] self.elec_demand = dem['elec_demand'] self.heat_demand = dem['heat_demand'] self.return_temp = dem['return_temp_DH'] self.source_delta_t = dem['source_delta_t'] self.myGrid = classes['myGrid'] self.import_cost = self.myGrid.import_cost_series() self.export_cost = self.myGrid.export
def PV_power(name, subname): """power output for PV takes inputs from excel sheet for weather and PV Returns: pandas df -- power output for year hourly for PV """ myInputs = inputs.Inputs(name, subname) input_PV_model = myInputs.PV_model() input_weather = myInputs.weather() myPV = PV(module_name=input_PV_model['module_name'], inverter_name=input_PV_model['inverter_name'], multiplier=input_PV_model['multiplier'], surface_tilt=input_PV_model['surface_tilt'], surface_azimuth=input_PV_model['surface_azimuth'], surface_type=input_PV_model['surface_type'], loc_name=input_PV_model['loc_name'], latitude=input_PV_model['latitude'], longitude=input_PV_model['longitude'], altitude=input_PV_model['altitude'], weather_input=input_weather) power = myPV.power_output() return power
def test(img): def show(state): print(measureConfidenceOfParameters(img, state)) def update(control, value, state): state[control.name] = value show(state) class var: def __init__(self, v, vmin, vmax, steps=1): self.v = v self.min = vmin self.max = vmax self.steps = steps state = {} parameters = { 'blur_kernel_size': var(v=3, vmin=1, vmax=15, steps=2), 'blur_diviation': var(v=1, vmin=1, vmax=9), 'close_size': var(v=6, vmin=1, vmax=50), 'harris_block_size': var(v=25, vmin=1, vmax=31, steps=2), 'harris_ksize': var(v=3, vmin=1, vmax=31, steps=2), 'harris_k': var(v=0.04, vmin=0, vmax=1, steps=0.001), 'harris_threashold': var(v=0.03, vmin=0, vmax=1, steps=0.001), 'canny_lower': var(v=50, vmin=1, vmax=255), 'canny_upper': var(v=200, vmin=1, vmax=255), 'hough_rho': var(v=1, vmin=1, vmax=32), 'hough_theta': var(v=1, vmin=1, vmax=360), 'hough_threshold': var(v=60, vmin=1, vmax=256), 'hough_srn': var(v=0, vmin=1, vmax=255), 'hough_stn': var(v=0, vmin=1, vmax=255), 'hough_group_threshold_rho': var(v=10, vmin=0, vmax=100), 'hough_group_threshold_theta': var(v=0.1, vmin=0, vmax=0.5, steps=0.01), 'perpective_threshold_theta': var(v=0.5, vmin=0, vmax=3.0, steps=0.01), } app = App() ins = inputs.Inputs(state=state) for name in parameters: properties = parameters[name] state[name] = properties.v slider = inputs.InputSlider(name, properties.v, onUpdate=update, sMin=properties.min, sMax=properties.max, sSteps=properties.steps) ins.addInput(slider) show(state) ins.getFrames() app.show()
def lambda_handler(event: dict, context: LambdaContext): ''' Lambda entry point function invoked by AWS ''' print("lambda_handler: started. event={}, context={}".format( event, vars(context))) result = { "isBase64Encoded": False, "statusCode": 200, "headers": {}, "multiValueHeaders": {}, "body": "" } try: params: inputs.Inputs = inputs.Inputs() if "body" in event: params.parse_http_body(event) else: params.parse_event(event) print("lambda_handler: params =", params) # setup cache cache_keys: CacheKeys = CacheKeys(params.cache_key_prefix()) print("cache keys", cache_keys) if params.cache_type() == inputs.Cachetype.FILE: print("Using FileCache") cache = FileCache("/tmp") else: key_expiry_secs = int(defaults.BACKING_JOB_LIFETIME_MS / 1000) # for as long as the backing jobs run print("Using MemCache:", params.cache_location, key_expiry_secs) memcache = MemCache(params.cache_location, key_expiry_secs) cache = ReliableCache(memcache, 3, 100, 1000) # run in backing job mode or api mode if params.is_daemon: print("lambda_handler: running as backing job") run_as_backing_job(params, context, cache) else: print("lambda_handler: returning cached results") cached_result = get_cached_result(params, context, cache) result["body"] = json.dumps(cached_result) except Exception as ex: print("lambda_handler: exception", ex, traceback.format_exc()) result["statusCode"] = 500 result["body"] = str(ex) + "\n" + get_usage() if not context.invoked_function_arn: print(result["statusCode"]) try: pprint.pprint(json.loads(result["body"])) except: print(result["body"]) return result
def __init__(self): self.box = Tk() self.frame1 = Frame(self.box) self.frame2 = Frame(self.box) self.toplabel = Label(self.box, text="Complex Calculator", font=("Century Gothic", 24)) self.toplabel.pack(side=TOP) self.inputs = inputs.Inputs(self.frame2) self.inputs.pack(side=LEFT, padx=50) self.evalbutton = Button(self.inputs, text="Evaluate", command=self.calculate) self.evalbutton.pack(side=TOP) self.resultslabels = Frame(self.frame2) self.sum = Label(self.resultslabels, text="Sum", font=("Century Gothic", 12), anchor="w", width=8) self.diff = Label(self.resultslabels, text="Difference", font=("Century Gothic", 12), anchor="w", width=8) self.product = Label(self.resultslabels, text="Product", font=("Century Gothic", 12), anchor="w", width=8) self.sum.pack(side=TOP) self.diff.pack(side=TOP) self.product.pack(side=TOP) self.resultslabels.pack(side=LEFT) self.results = results.Results(self.frame2) self.results.pack(side=LEFT) self.frame1.pack(side=TOP, pady=10) self.frame2.pack(side=TOP, pady=10) self.box.mainloop()
def standard_regression(): myInputs = inputs.Inputs('WWHC.xlsx', 'hp_1000_ts_50000') inputs_basics = myInputs.heatpump_basics() inputs_standard_regression = myInputs.heatpump_standard_regression() inputs_demands = myInputs.demands() weather = myInputs.weather() HeatPump = heatpump.HeatPump( inputs_basics['heat_pump_type'], inputs_basics['modelling_approach'], inputs_basics['capacity'], inputs_basics['ambient_delta_t'], inputs_basics['operation'], inputs_basics['minimum_output'], inputs_basics['data_input'], inputs_demands['source_temp'], inputs_demands['return_temp_DH'], weather, standard_test_regression_inputs=inputs_standard_regression) HeatPump.flow_temp_source = [70] * 8760 hp1 = HeatPump.performance() HeatPump.flow_temp_source = [60] * 8760 hp2 = HeatPump.performance() cop1 = [] duty1 = [] cop2 = [] duty2 = [] for time in range(8760): cop1.append(hp1[time]['cop']) duty1.append(hp1[time]['duty']) cop2.append(hp2[time]['cop']) duty2.append(hp2[time]['duty']) cop1 = pd.DataFrame(cop1) duty1 = pd.DataFrame(duty1) cop2 = pd.DataFrame(cop2) duty2 = pd.DataFrame(duty2) plt.plot(cop1) plt.plot(cop2) plt.show()
def __init__(self, level_name): self._collision_detector = kidgine.collision.CollisionDetector() self.drawable = renderer.SceneRenderer() self._inputs = inputs.Inputs() # separate game time from scene time. scene time pauses during blocking events self._scene_time = 0 self.updatables = set() self._triggers = dict() self._blocking_events = collections.deque() self._current_blocking_event = None self.player_character = None self.return_state = None if level_name: self.level = level.Level(level_name, self._collision_detector) self.add_updatable(self.level) self.add_updatable(updatable.HUD(self))
def wind_database_power(name, subname): """power output for a wind turbine from database takes inputs for weather and wind turbine from database from excel Returns: pandas df -- power output of databased wind turbine """ myInputs = inputs.Inputs(name, subname) input_windturbine = myInputs.windturbine_database() input_weather = myInputs.weather() myWindturbine = Windturbine( turbine_name=input_windturbine['turbine_name'], hub_height=input_windturbine['hub_height'], rotor_diameter=input_windturbine['rotor_diameter'], multiplier=input_windturbine['multiplier'], weather_input=input_weather) power = myWindturbine.database_power()['wind_user'] return power
def init(name, subname): myInputs = inputs.Inputs(name, subname) # initialise instance of classes input_windturbine = myInputs.windturbine_user() input_weather = myInputs.weather() myUserWindturbine = renewables.Windturbine( turbine_name=input_windturbine['turbine_name'], hub_height=input_windturbine['hub_height'], rotor_diameter=input_windturbine['rotor_diameter'], multiplier=input_windturbine['multiplier'], nominal_power=input_windturbine['nominal_power'], power_curve=input_windturbine['power_curve'], weather_input=input_weather) input_windturbine = myInputs.windturbine_database() myDatabaseWindturbine = renewables.Windturbine( turbine_name=input_windturbine['turbine_name'], hub_height=input_windturbine['hub_height'], rotor_diameter=input_windturbine['rotor_diameter'], multiplier=input_windturbine['multiplier'], weather_input=input_weather) input_PV_model = myInputs.PV_model() myPV = renewables.PV(module_name=input_PV_model['module_name'], inverter_name=input_PV_model['inverter_name'], multiplier=input_PV_model['multiplier'], surface_tilt=input_PV_model['surface_tilt'], surface_azimuth=input_PV_model['surface_azimuth'], surface_type=input_PV_model['surface_type'], loc_name=input_PV_model['loc_name'], latitude=input_PV_model['latitude'], longitude=input_PV_model['longitude'], altitude=input_PV_model['altitude'], weather_input=input_weather) ts_inputs = myInputs.hot_water_tank() myHotWaterTank = hot_water_tank.HotWaterTank( ts_inputs['capacity'], ts_inputs['insulation'], ts_inputs['location'], ts_inputs['number_nodes'], ts_inputs['dimensions'], ts_inputs['tank_openings'], ts_inputs['correction_factors'], air_temperature=input_weather) inputs_basics = myInputs.heatpump_basics() modelling_approach = inputs_basics['modelling_approach'] if modelling_approach == 'Simple': inputs_simple = myInputs.heatpump_simple() inputs_demands = myInputs.demands() myHeatPump = heatpump.HeatPump(inputs_basics['heat_pump_type'], inputs_basics['modelling_approach'], inputs_basics['capacity'], inputs_basics['ambient_delta_t'], inputs_basics['minimum_runtime'], inputs_basics['minimum_output'], inputs_basics['data_input'], inputs_demands['source_temp'], inputs_demands['return_temp_DH'], input_weather, simple_cop=inputs_simple) if modelling_approach == 'Lorentz': inputs_lorentz = myInputs.heatpump_lorentz() inputs_demands = myInputs.demands() myHeatPump = heatpump.HeatPump(inputs_basics['heat_pump_type'], inputs_basics['modelling_approach'], inputs_basics['capacity'], inputs_basics['ambient_delta_t'], inputs_basics['minimum_runtime'], inputs_basics['minimum_output'], inputs_basics['data_input'], inputs_demands['source_temp'], inputs_demands['return_temp_DH'], input_weather, lorentz_inputs=inputs_lorentz) elif modelling_approach == 'Generic regression': inputs_demands = myInputs.demands() myHeatPump = heatpump.HeatPump( inputs_basics['heat_pump_type'], inputs_basics['modelling_approach'], inputs_basics['capacity'], inputs_basics['ambient_delta_t'], inputs_basics['minimum_runtime'], inputs_basics['minimum_output'], inputs_basics['data_input'], inputs_demands['source_temp'], inputs_demands['return_temp_DH'], input_weather) elif modelling_approach == 'Standard test regression': inputs_standard_regression = myInputs.heatpump_standard_regression() inputs_demands = myInputs.demands() myHeatPump = heatpump.HeatPump( inputs_basics['heat_pump_type'], inputs_basics['modelling_approach'], inputs_basics['capacity'], inputs_basics['ambient_delta_t'], inputs_basics['minimum_runtime'], inputs_basics['minimum_output'], inputs_basics['data_input'], inputs_demands['source_temp'], inputs_demands['return_temp_DH'], input_weather, standard_test_regression_inputs=inputs_standard_regression) i = myInputs.electrical_storage() myElectricalStorage = electrical_storage.ElectricalStorage( i['capacity'], i['initial_state'], i['charge_max'], i['discharge_max'], i['charge_eff'], i['discharge_eff'], i['self_discharge']) aux_inputs = myInputs.aux() myAux = auxiliary.Aux(aux_inputs['fuel'], aux_inputs['efficiency'], aux_inputs['fuel_info']) grid_inputs = myInputs.grid() export = grid_inputs['export'] tariff_choice = grid_inputs['tariff_choice'] balancing_mechanism = grid_inputs['balancing_mechanism'] grid_services = grid_inputs['grid_services'] tariff_choice = grid_inputs['tariff_choice'] balancing_mechanism = grid_inputs['balancing_mechanism'] grid_services = grid_inputs['grid_services'] variable_periods_year = grid_inputs['variable_periods_year'] premium = grid_inputs['wm_info']['premium'] maximum = grid_inputs['wm_info']['maximum'] lower_percent = grid_inputs['ppa_info']['lower_percent'] higher_percent = grid_inputs['ppa_info']['higher_percent'] lower_penalty = grid_inputs['ppa_info']['lower_penalty'] higher_discount = grid_inputs['ppa_info']['higher_discount'] if tariff_choice == 'Flat rates': fr = grid_inputs['flat_rates'] myGrid = grid.Grid(name, subname, export, tariff_choice, balancing_mechanism, grid_services, flat_rate=fr) elif tariff_choice == 'Variable periods': vp = grid_inputs['variable_periods'] myGrid = grid.Grid(name, subname, export, tariff_choice, balancing_mechanism, grid_services, variable_periods=vp, variable_periods_year=variable_periods_year) elif tariff_choice == 'Time of use - WM': twm = grid_inputs['wholesale_market'] myGrid = grid.Grid(name, subname, export, tariff_choice, balancing_mechanism, grid_services, wholesale_market=twm, premium=premium, maximum=maximum) elif tariff_choice == 'Time of use - PPA + FR': fr = grid_inputs['flat_rates'] myGrid = grid.Grid(name, subname, export, tariff_choice, balancing_mechanism, grid_services, flat_rate=fr, lower_percent=lower_percent, higher_percent=higher_percent, higher_discount=higher_discount, lower_penalty=lower_penalty) elif tariff_choice == 'Time of use - PPA + WM': twm = grid_inputs['wholesale_market'] myGrid = grid.Grid(name, subname, export, tariff_choice, balancing_mechanism, grid_services, wholesale_market=twm, premium=premium, maximum=maximum, lower_percent=lower_percent, higher_percent=higher_percent, higher_discount=higher_discount, lower_penalty=lower_penalty) elif tariff_choice == 'Time of use - PPA + VP': vp = grid_inputs['variable_periods'] myGrid = grid.Grid(name, subname, export, tariff_choice, balancing_mechanism, grid_services, variable_periods=vp, variable_periods_year=variable_periods_year, lower_percent=lower_percent, higher_percent=higher_percent, higher_discount=higher_discount, lower_penalty=lower_penalty) dict = { 'myUserWindturbine': myUserWindturbine, 'myDatabaseWindturbine': myDatabaseWindturbine, 'myPV': myPV, 'myHotWaterTank': myHotWaterTank, 'myHeatPump': myHeatPump, 'myElectricalStorage': myElectricalStorage, 'myAux': myAux, 'myGrid': myGrid } return dict
import inputs, setup, push, knit from colour import * import concurrent.futures from pathlib import Path import sys from fnmatch import fnmatch from shutil import copy, copytree exit_code = 0 github_work_dir = Path("/github/workspace") print(cyan | "Starting org-knit") I = inputs.Inputs(*sys.argv[1:]) I.args["name"] = push.git_result(github_work_dir, "log", "-1", "--format=%an", "HEAD") I.args["email"] = push.git_result(github_work_dir, "log", "-1", "--format=%ae", "HEAD") print("::group::configuration") print(I.pretty_print()) print("::endgroup::") if I.config: print("::group::setup emacs config") setup.config(I.config) print("::endgroup::") else:
# -*- coding: utf-8 -*- """ Forces Processing based a lot on static forces.py from Kuba Created on Wed Feb 22 09:31:12 2017 @author: Roeland """ import inputs Inputs = inputs.Inputs() g = 9.81 m = 64000.0 L1 = 5.0 L2 = 14.6 L3 = 34 - 19.6 L = L1 + L2 + L3 dz = 3.1 dy = 6.4 dx = 7.6 Sx = 1.6 * 10**5 q = 3 * g * m / L #F - front, R - rear, R = R1+R2 #forces in x Fx = Sx * (1 - ((L - L1 + dz) / L2)) Rx = Sx * ((L - L1 + dz) / L2) #forces in y Fy = q * ((L1 + L2)**2 / (2 * L2)) - (q * L3**2) / (2 * L2) Ry = q * L - Fy def Vx(z):
# generate pickle inputs for parametric analysis print('Generating inputs for all simuation combinations...') myPara = parametric_analysis.Para(name) myPara.create_pickles() combinations = myPara.folder_name num_combos = len(combinations) t1 = time.time() tot_time = (t1 - t0) print('Input complete. Time taken: ', round(tot_time, 2), 'seconds.') # just take first subname as controller is same in all subname = myPara.folder_name[0] myInputs = inputs.Inputs(name, subname) # controller inputs controller_info = myInputs.controller()['controller_info'] controller = controller_info['controller'] timesteps = controller_info['total_timesteps'] first_hour = controller_info['first_hour'] # run controller and outputs for all combinations for i in range(num_combos): # combo to be run subname = combinations[i] if controller == 'Fixed order control': # run fixed order controller
def validation(): myInputs = inputs.Inputs('WWHC_FOC_WM.xlsx', 'hp_0_ts_0') ts_inputs = myInputs.hot_water_tank() weather = myInputs.weather() myHotWaterTank = hot_water_tank.HotWaterTank( ts_inputs['capacity'], ts_inputs['insulation'], ts_inputs['location'], ts_inputs['number_nodes'], ts_inputs['dimensions'], ts_inputs['tank_openings'], ts_inputs['correction_factors'], air_temperature=weather) myHotWaterTank.capacity = 50000 myHotWaterTank.number_nodes = 5 number_nodes = 5 timesteps = 24 source_delta_t = 20 return_temp = 65 source_temp = [85] * timesteps flow_temp = [85] * timesteps # charge_discharge = [ # 267.81, 151.35, 185.64, 141.9, 117.67, 122.93, 44.1, # -121.79, -177.77, -260.31, -282.73, -190.41, -258.12, # -247.19, -203.82, -269.62, -255.76, -261.3, 35.54, # 64.81, 348.66, 253.03, 256.98, 158.47, 94.23, 156.9, # 181.67, 36.04, 68.27, -3.03, 144.47, 160.95, -101.96, # 71.41, 94.55, 2.3, 137.41, 108.32, 32.63, 155.31, 37.2, # 98.36, 115.61, 59.4, 45, 30.85, 37.39, -129.72, 137.92, # 26.28, -343.13, -455.03, -371.29, -475.4, -493.92, -387.26, # -387.2, -443.62, -97.47, -191.56, -42.08, 52.89, -245.88, # 146.05, 8.76, -161.8, -38.9, -44.69, -163.02, -163.86, # -25.85, -143.38, -142.88, -112.56, -187.39, -78.68, -228.52, # -137.54, -162.03, -157.25, -116.14, -124.2, -135.9, -152.94, # -190.34, -43.93, -73.21, -31.84, 55.54, -21.25, -18.32, # 70.78, 105.5, 80.06, 114.23, 133.34] charge_discharge = [ 746.7, 162.91, -911.22, -978.75, -416.71, 1017.14, 468.84, 370.66, 66.3, 433.67, 310.57, -16.48, -633.96, -1727.87, -1119.85, -89.02, 236.63, 496.11, 1., 1., 1., -100.32, 86.75, 433.13 ] max_energy = np.zeros(timesteps) nodes_temp = [] nodes_temp.append([84.36, 83.23, 81.8, 81.6, 78.52]) for timestep in range(timesteps): if charge_discharge[timestep] > 0.: state = 'charging' max_energy[timestep] = myHotWaterTank.max_energy_in_out( state, nodes_temp[timestep], source_temp[timestep], flow_temp[timestep], return_temp, timestep) if abs(charge_discharge[timestep]) <= max_energy[timestep]: thermal_output = charge_discharge[timestep] demand = 0. else: thermal_output = max_energy[timestep] demand = 0. elif charge_discharge[timestep] < 0.: state = 'discharging' max_energy[timestep] = myHotWaterTank.max_energy_in_out( state, nodes_temp[timestep], source_temp[timestep], flow_temp[timestep], return_temp, timestep) if abs(charge_discharge[timestep]) <= max_energy[timestep]: demand = abs(charge_discharge[timestep]) thermal_output = 0. else: demand = max_energy[timestep] thermal_output = 0. # new temps after charging/discharging node_temp_list = myHotWaterTank.new_nodes_temp( state, nodes_temp[timestep], source_temp[timestep], source_delta_t, flow_temp[timestep], return_temp, thermal_output, demand, timestep) nodes_temp.append(node_temp_list[number_nodes - 1]) plt.style.use('ggplot') plt.rcParams.update({'font.size': 16}) plt.subplot(2, 1, 1) plt.plot(nodes_temp) plt.ylabel('Node temperature \n (degC)') plt.title('Modelled node temperatures') plt.xlabel('Hour timesteps') # read csv file data = pd.read_csv('wwhc_ts.csv') plt.subplot(2, 1, 2) plt.plot(data) plt.ylabel('Node temperature \n (degC)') plt.title('Monitored node temperatures') plt.xlabel('15-minute timesteps') # plt.tight_layout() plt.show()
import inputs myInputs = inputs.Inputs('WWHC_FOC_WM', 'subname')
def test(): myInputs = inputs.Inputs('WWHC_FOC_WM.xlsx', 'hp_1000_ts_400000') ts_inputs = myInputs.hot_water_tank() weather = myInputs.weather() demands = myInputs.demands() myHotWaterTank = hot_water_tank.HotWaterTank( ts_inputs['capacity'], ts_inputs['insulation'], ts_inputs['location'], ts_inputs['number_nodes'], ts_inputs['dimensions'], ts_inputs['tank_openings'], ts_inputs['correction_factors'], air_temperature=weather) myHotWaterTank.number_nodes = 5 number_nodes = myHotWaterTank.number_nodes t = 24 source_delta_t = demands['source_delta_t'] return_temp = demands['return_temp_DH'] source_temp = demands['source_temp'] flow_temp = demands['flow_temp_DH'] # charging, discharging, standby state = 'discharging' if state == 'charging': i_nodes_temp = [40] * number_nodes demand = 0 thermal_output = 4000 elif state == 'discharging': i_nodes_temp = [70] * number_nodes demand = 5000 thermal_output = 0 elif state == 'standby': i_nodes_temp = [90] * number_nodes demand = 0 thermal_output = 0 nodes_temp = [] nodes_temp.append(i_nodes_temp) for timestep in range(t): # available energy to discharge or charge energy_available = myHotWaterTank.max_energy_in_out( state, nodes_temp[timestep], source_temp[timestep], flow_temp[timestep], return_temp, timestep) if state == 'charging' and thermal_output >= energy_available: thermal_output = energy_available if state == 'discharging' and demand >= energy_available: demand = energy_available # new temps after charging/discharging node_temp_list = myHotWaterTank.new_nodes_temp( state, nodes_temp[timestep], source_temp[timestep], source_delta_t, flow_temp[timestep], return_temp, thermal_output, demand, timestep) nodes_temp.append(node_temp_list[-1]) plt.style.use('ggplot') plt.rcParams.update({'font.size': 16}) plt.plot(nodes_temp) plt.ylabel('Node temperature \n (degC)') plt.title('Modelled node temperatures') plt.xlabel('Hour timesteps') plt.show()
def perf(name, subname): myInputs = inputs.Inputs(name, subname) input_weather = myInputs.weather() inputs_basics = myInputs.heatpump_basics() modelling_approach = inputs_basics['modelling_approach'] if modelling_approach == 'Simple': inputs_simple = myInputs.heatpump_simple() inputs_demands = myInputs.demands() myHeatPump = HeatPump(inputs_basics['heat_pump_type'], inputs_basics['modelling_approach'], inputs_basics['capacity'], inputs_basics['ambient_delta_t'], inputs_basics['minimum_runtime'], inputs_basics['minimum_output'], inputs_basics['data_input'], inputs_demands['source_temp'], inputs_demands['return_temp_DH'], input_weather, simple_cop=inputs_simple) return myHeatPump.performance() elif modelling_approach == 'Lorentz': inputs_lorentz = myInputs.heatpump_lorentz() inputs_demands = myInputs.demands() myHeatPump = HeatPump(inputs_basics['heat_pump_type'], inputs_basics['modelling_approach'], inputs_basics['capacity'], inputs_basics['ambient_delta_t'], inputs_basics['minimum_runtime'], inputs_basics['minimum_output'], inputs_basics['data_input'], inputs_demands['source_temp'], inputs_demands['return_temp_DH'], input_weather, lorentz_inputs=inputs_lorentz) return myHeatPump.performance() elif modelling_approach == 'Generic regression': inputs_demands = myInputs.demands() myHeatPump = HeatPump( inputs_basics['heat_pump_type'], inputs_basics['modelling_approach'], inputs_basics['capacity'], inputs_basics['ambient_delta_t'], inputs_basics['minimum_runtime'], inputs_basics['minimum_output'], inputs_basics['data_input'], inputs_demands['source_temp'], inputs_demands['return_temp_DH'], input_weather) return myHeatPump.performance() elif modelling_approach == 'Standard test regression': inputs_standard_regression = myInputs.heatpump_standard_regression() inputs_demands = myInputs.demands() myHeatPump = HeatPump( inputs_basics['heat_pump_type'], inputs_basics['modelling_approach'], inputs_basics['capacity'], inputs_basics['ambient_delta_t'], inputs_basics['minimum_runtime'], inputs_basics['minimum_output'], inputs_basics['data_input'], inputs_demands['source_temp'], inputs_demands['return_temp_DH'], input_weather, standard_test_regression_inputs=inputs_standard_regression) return myHeatPump.performance()