def load_car_models(self):
"""
Loads all car models from car_models.csv.
Returns
-------
None.
"""
cast = Cast("Car Model")
self.car_models = dict()
csv_helper = CSVHelper("data", "car_models.csv")
for row in csv_helper.data:
uid = cast.to_positive_int(row[0], "Uid")
cast.uid = uid
car_model_name = str(row[1]).strip(" ").strip('"')
car_consumption = cast.to_positive_float(row[2], "Car consumption")
drag_coeff = cast.to_positive_float(row[3], "Drag coeff")
frontal_area = cast.to_positive_float(row[4], "Frontal area")
mass = cast.to_positive_float(row[5], "Mass")
battery_capacity \
= cast.to_positive_float(row[6], "Battery capacity")
charger_capacity \
= cast.to_positive_float(row[7], "Charger capacity")
cm = CarModel(uid, car_model_name, car_consumption, drag_coeff,
frontal_area, mass, battery_capacity,
charger_capacity)
self.car_models[uid] = cm
def load_charger_models(self):
"""
Reads information on individual charger models from charger_models.csv.
"""
cast = Cast("Charger Model")
self.charger_models = dict()
csv_helper = CSVHelper("data", "charger_models.csv")
for row in csv_helper.data:
uid = cast.to_positive_int(row[0], "Uid")
cast.uid = uid
classification = row[1]
ac_power = cast.to_positive_int(row[2], "AC Power")
dc_power = cast.to_positive_int(row[2], "DC Power")
cm = ChargerModel(uid, classification, ac_power, dc_power)
self.charger_models[uid] = cm
if cm.classification == "com":
self.commercial_model_uids.append(cm.uid)
else:
self.residential_model_uids.append(cm.uid)
def __init__(self, clock, row):
time_factor = 60 // clock.time_step
time_factor_sqrt = numpy.sqrt(time_factor)
if 60 % clock.time_step != 0:
raise RuntimeError("time_step do not add up to full hour!")
cast = Cast("Normed rooftop PV output fit parameters")
self.max_output \
= cast.to_positive_int(row[1], "Max output") / time_factor
# x_border seperates the part fitted by a constant and the part
# fitted by a gaussian
self.x_border = cast.to_positive_int(row[2], "x_border") / time_factor
self.A = cast.to_positive_float(row[3], "A")
self.mu = cast.to_positive_int(row[4], "mu") / time_factor
self.sig = cast.to_positive_float(row[5], "sig") / time_factor_sqrt
self.y0 = cast.to_positive_float(row[6], "y0")
self.A_po = cast.to_positive_float(row[7], "A_po")
self.mu_po = cast.to_positive_int(row[8], "mu_po") / time_factor
self.sig_po\
= cast.to_positive_float(row[9], "sig_po") / time_factor_sqrt
self.y_co = cast.to_positive_float(row[10], "y_co")
self.surf_po = cast.to_positive_float(row[11], "surf_po")
self.surf_co = cast.to_positive_float(row[12], "surf_co")
def load_locations(self):
"""
Reads information on individual suburbs from locations.csv.
"""
cast = Cast("Location")
self.locations = {}
csv_helper = CSVHelper("data", "locations.csv")
for row in csv_helper.data:
uid = cast.to_positive_int(row[0], "Uid")
cast.uid = uid
name = row[2]
longitude = cast.to_float(row[3], "Longitude")
latitude = cast.to_float(row[4], "Latitude")
population = cast.to_positive_int(row[5], "Population")
commute_mean = cast.to_positive_float(row[6], "Commute mean")
commute_std_dev = cast.to_positive_float(row[7], "Commute std dev")
occupant_distribution \
= cast.to_positive_int_list(row[8], "Occupant distribution")
occupant_values \
= cast.to_positive_int_list(row[9], "Occupant values")
pv_capacity_mean \
= cast.to_positive_float(row[10], "PV capacity mean")
pv_capacity_std_dev \
= cast.to_positive_float(row[11], "PV capacity std dev")
battery_capacity_mean \
= cast.to_positive_float(row[12], "Battery capacity mean")
battery_capacity_std_dev\
= cast.to_positive_float(row[13], "Battery capacity std dev")
loc = Location(uid, name, longitude, latitude, population,
commute_mean, commute_std_dev,
occupant_distribution, occupant_values,
pv_capacity_mean, pv_capacity_std_dev,
battery_capacity_mean, battery_capacity_std_dev)
# add public charger
self.cpm.add_company(loc)
self.locations[loc.uid] = loc
def get_parameter(self, parameter_name, parameter_type):
"""
Returns a parameter from self.parameter as a requested type.
Parameters
----------
parameter_name : string
Name of the parameter requested.
parameter_type : string
Type the parameter is requested in. Currently
supported: float, positive_float, int, positive_int, string,
boolean.
Returns
-------
<Type as requested in parameter_type>
Well the parameter request casted as the type requested
"""
if parameter_name not in self.parameters:
sys.exit("No parameter called " + parameter_name \
+ " is defined in parameters.csv")
value_str = self.parameters[parameter_name]
cast = Cast("Get Parameter")
if parameter_type == "float":
return cast.to_float(value_str, parameter_name)
elif parameter_type == "positive_float":
return cast.to_positive_float(value_str, parameter_name)
elif parameter_type == "int":
return cast.to_int(value_str, parameter_name)
elif parameter_type == "positive_int":
return cast.to_positive_int(value_str, parameter_name)
elif parameter_type == "string":
return value_str
elif parameter_type == "boolean":
return cast.to_boolean(value_str, parameter_name)
else:
sys.exit("Type '" + parameter_type + "' for parameter " \
+ parameter_name + " is not recognised")
def load_electricity_plans(self, parameters, clock):
"""
Loads all electricity plans from electricity_plans.csv.
Parameters
----------
clock : Clock
required for time_step parameter
Returns
-------
None.
"""
cast = Cast("Electricity Plan")
self.electricity_plans = dict()
csv_helper = CSVHelper("data", "electricity_plans.csv")
for row in csv_helper.data:
uid = cast.to_positive_int(row[0], "Uid")
cast.uid = uid
classification = row[1]
if not classification in ["res", "com"]:
sys.exit("Classification of electricity plan " + str(uid) \
+ " is ill-defined!")
is_commercial_plan = classification == "com"
base = cast.to_float(row[2], "Base")
feed_in_tariff = parameters.get_parameter("feed_in_tariff",
"float")
# create tariff structure
tariff_str = row[3]
tariff = self.extract_tariffs_from_string(tariff_str)
ep = ElectricityPlan(uid, is_commercial_plan, base, feed_in_tariff,
tariff, clock.time_step)
self.electricity_plans[uid] = ep
if ep.is_commercial_plan:
self.commercial_plan_uids.append(ep.uid)
else:
self.residential_plan_uids.append(ep.uid)
def __init__(self, clock):
self.clock = clock
# load hourly consumption data
cast = Cast("Hourly Consumption")
self.hourly_consumption = dict()
csv_helper = CSVHelper("data", "hourly_consumption.csv")
for row in csv_helper.data:
hour = cast.to_positive_int(row[0], "Hour")
season_it = self.clock.season * 3
hourly_cons = []
hourly_cons.append(
cast.to_positive_float(row[season_it + 1], "10%"))
hourly_cons.append(
cast.to_positive_float(row[season_it + 2], "50%"))
hourly_cons.append(
cast.to_positive_float(row[season_it + 3], "90%"))
self.hourly_consumption[hour] = hourly_cons
# load deviation data for consumption
cast = Cast("Consumption Deviation")
self.consumption_deviation = dict()
csv_helper = CSVHelper("data", "consumption_deviation.csv")
for row in csv_helper.data:
location_uid = cast.to_positive_int(row[0], "LocationUid")
season_it = self.clock.season * 5
cons_deviation = dict()
cons_deviation[1] = cast.to_positive_float(row[season_it + 1],
"1PHH")
cons_deviation[2] = cast.to_positive_float(row[season_it + 2],
"2PHH")
cons_deviation[3] = cast.to_positive_float(row[season_it + 3],
"3PHH")
cons_deviation[4] = cast.to_positive_float(row[season_it + 4],
"4PHH")
cons_deviation[5] = cast.to_positive_float(row[season_it + 5],
"5PHH")
self.consumption_deviation[location_uid] = cons_deviation
#
cast = Cast("Consumption Forecast Parameters")
self.forecast_parameters = dict()
hourly_forecast_parameters = dict()
csv_helper = CSVHelper("data", "hourly_consumption_fit.csv")
season_it = self.clock.season * 2 + 1
for row in csv_helper.data:
hour = cast.to_positive_int(row[0], "Hour")
mu = cast.to_positive_float(row[season_it], "mu")
sig = cast.to_positive_float(row[season_it + 1], "sig")
hourly_forecast_parameters[hour] = [mu, sig]
for time_step in range(0, 24 * 60, self.clock.time_step):
hour_begin = time_step // 60
hour_end = (time_step + self.clock.time_step) // 60
hour_end_remainder = (time_step + self.clock.time_step) % 60
same_hour = hour_begin == hour_end \
or (hour_begin == hour_end - 1 \
and hour_end_remainder == 0)
if same_hour:
mu_hour, sig_hour = hourly_forecast_parameters[hour_begin]
mu_time_step = mu_hour / (self.clock.time_step / 60)
sig_sqr_time_step = sig_hour**2 / (self.clock.time_step / 60)
self.forecast_parameters[time_step] = [
mu_time_step, sig_sqr_time_step
]
else:
raise RuntimeError("Demand forecast for 60 % time_step != 0" +
" not implemented")
cur_mu, cur_sig_sqr = 0, 0
for time in range(0, self.clock.forecast_horizon,
self.clock.time_step):
cur_mu += self.forecast_parameters[time][0]
cur_sig_sqr += self.forecast_parameters[time][0]**2
self.forecast_mu, self.forecast_sig = cur_mu, math.sqrt(cur_sig_sqr)
def __init__(self, parameters, clock, electricity_plan_manager,
car_model_manager):
self.parameters = parameters
self.clock = clock
self.epm = electricity_plan_manager
cast = Cast("Solar Irradation")
self.irradiances = []
file_name = "solar_irradiance_" \
+ self.clock.season_names[self.clock.season] + ".csv"
csv_helper = CSVHelper("data", file_name)
it = 0
resolution_irradiance = 0
for row in csv_helper.data:
if it == 0:
resolution_irradiance \
= - cast.to_positive_int(row[0], "Elapsed time")
if it == 1:
resolution_irradiance += \
+ cast.to_positive_int(row[0], "Elapsed time")
tmp_irradiances = []
for col in row[1:]:
value = cast.to_positive_float(col, "Solar irradiance")
tmp_irradiances.append(value)
self.irradiances.append(tmp_irradiances)
it += 1
cast = Cast("Temperatures")
self.temperatures = []
file_name = "temperatures_" \
+ self.clock.season_names[self.clock.season] + ".csv"
csv_helper = CSVHelper("data", file_name)
it = 0
resolution_temperatures = 0
for row in csv_helper.data:
if it == 0:
resolution_temperatures \
= - cast.to_positive_int(row[0], "Elapsed time")
if it == 1:
resolution_temperatures += \
+ cast.to_positive_int(row[0], "Elpased time")
tmp_temperatures = []
for col in row[1:]:
value = cast.to_positive_float(col, "Temperatures")
tmp_temperatures.append(value)
self.temperatures.append(tmp_temperatures)
it += 1
self.cur_irradiances = self.irradiances[0]
self.cur_temperatures = self.temperatures[0]
self.forecast_horizon = parameters.get_parameter(
"forecast_horizon", "int")
cast = Cast("Normed rooftop PV output fit parameters")
self.fit_data = []
file_name = "normed_rooftop_pv_output_fit_parameters.csv"
csv_helper = CSVHelper("data", file_name)
it = 0
resolution_fit = 0
for row in csv_helper.data:
if it == 0:
resolution_fit = -cast.to_positive_int(row[0], "Elapsed time")
if it == 1:
resolution_fit += cast.to_positive_int(row[0], "Elpased time")
self.fit_data.append(GenerationForecast(self.clock, row))
it += 1
self.resolution_irradiance = resolution_irradiance
self.resolution_temperatures = resolution_temperatures
self.resolution_fit = resolution_fit
self.forecast_mu, self.forecast_sig = 0.0, 0.0
self.forecast_mu_po, self.forecast_sig_po_sqr = 0.0, 0.0
self.max_output_co_sum, self.max_output_co_count = 0.0, 0
for it, fit_data_point in enumerate(self.fit_data):
if it * self.resolution_fit >= self.clock.forecast_horizon:
break
if fit_data_point.peak_dominates_constant():
self.forecast_mu_po += fit_data_point.mu_po
self.forecast_sig_po_sqr += fit_data_point.sig_po**2
else:
self.max_output_co_sum += fit_data_point.max_output
self.max_output_co_count += 1
avg_max_output_co = 0
if self.max_output_co_count != 0:
avg_max_output_co \
= self.max_output_co_sum / self.max_output_co_count
# we use Irwin-Hall to derive normal distribution from co parts
self.forecast_mu = self.forecast_mu_po + avg_max_output_co / 2
forecast_sig_co_sqr = (avg_max_output_co / 12)**2
self.forecast_sig \
= math.sqrt(self.forecast_sig_po_sqr + forecast_sig_co_sqr)
# more detailed processing
get_season = lambda month: ((month + 3) % 12) // 3
get_month_it_in_season = lambda month: month % 3
acc_days_season = [[0, 30, 61], [0, 31, 62], [0, 30, 61], [0, 30, 61]]
acc_days_year = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]
days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
irradiances = dict()
temperatures = dict()
normed_output = dict()
season_irradiances = [dict(), dict(), dict(), dict()]
season_temperatures = [dict(), dict(), dict(), dict()]
years = []
for data_point in data:
date = data_point[0]
year = cast.to_positive_int(date[0:4], "Year")
if year not in years:
years.append(year)
month = cast.to_positive_int(date[4:6], "Month")
season = ((month + 3) % 12) // 3
day = cast.to_positive_int(date[6:8], "Day")
# exclude leap days
if month == 2 and day == 29:
continue
hour = cast.to_positive_int(date[8:10], "Hour")
minute = cast.to_positive_int(date[10:12], "Minutes")
irrad = cast.to_positive_int(data_point[1], "Irradiance")
temp = cast.to_positive_float(data_point[2], "Temperature")
# Zulu time to Australian Eastern Standard Time // UTC -> AEDT
hour = (hour + 10) % 24