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()
