def create_deflex_slp_profile(year, outfile):
demand_deflex = prepare_ego_demand()
cal = Germany()
holidays = dict(cal.holidays(year))
deflex_profile = pd.DataFrame()
for region in demand_deflex.index:
annual_demand = demand_deflex.loc[region]
annual_electrical_demand_per_sector = {
'g0': annual_demand.sector_consumption_retail,
'h0': annual_demand.sector_consumption_residential,
'l0': annual_demand.sector_consumption_agricultural,
'i0': annual_demand.sector_consumption_industrial
}
e_slp = bdew.ElecSlp(year, holidays=holidays)
elec_demand = e_slp.get_profile(annual_electrical_demand_per_sector)
# Add the slp for the industrial group
ilp = profiles.IndustrialLoadProfile(e_slp.date_time_index,
holidays=holidays)
elec_demand['i0'] = ilp.simple_profile(
annual_electrical_demand_per_sector['i0'])
deflex_profile[region] = elec_demand.sum(1).resample('H').mean()
deflex_profile.to_csv(outfile)
def el_load_profiles(demand, ann_el_demand_per_sector, year, **kwargs):
"""
Generates an electrical load profile using the oemof demandlib.
"""
# read standard load profiles
e_slp = bdew.ElecSlp(year, holidays=kwargs.get('holidays', None))
# multiply given annual demand with timeseries
elec_demand = e_slp.get_profile(ann_el_demand_per_sector)
# Add the slp for the industrial group
ilp = profiles.IndustrialLoadProfile(e_slp.date_time_index,
holidays=kwargs.get('holidays', None))
# Beginning and end of workday, weekdays and weekend days, and scaling
# factors by default
elec_demand['i0'] = ilp.simple_profile(
ann_el_demand_per_sector['i0'],
am=kwargs.get('am'),
pm=kwargs.get('pm'),
profile_factors=kwargs.get('profile_factors'))
# Resample 15-minute values to hourly values.
elec_demand = elec_demand.resample('H').mean()
demand.val = elec_demand.sum(axis=1)
return demand
def call_ind_profile(time_index, annual_demand, **kwargs):
'''
Creates an industrial load profile as step load profile.
'''
ilp = profiles.IndustrialLoadProfile(time_index,
holidays=kwargs.get('holidays', None))
load_profile = ilp.simple_profile(annual_demand,
am=kwargs.get('am', None),
pm=kwargs.get('pm', None),
profile_factors=kwargs.get(
'profile_factors', None))
load_profile = load_profile.resample('H').mean()
return load_profile
def add_sectoral_peak_load(load_areas, **kwargs):
r"""Add peak load per sector based on given annual consumption
"""
# define data year
# TODO: in the future get this from somewhere else
year = 2011
# call demandlib
# TODO: change to use new demandlib
# read standard load profiles
e_slp = bdew.ElecSlp(year, holidays=holidays)
# multiply given annual demand with timeseries
# elec_demand = e_slp.get_profile(load_areas['h0', 'g0', 'l0', 'i0'].to_dict())
elec_demand = e_slp.get_profile(load_areas.to_dict())
# tmp_peak_load = dm.electrical_demand(method='calculate_profile',
# year=year,
# ann_el_demand_per_sector= {
# 'h0':
# load_areas['sector_consumption_residential'],
# 'g0':
# load_areas['sector_consumption_retail'],
# 'i0':
# load_areas['sector_consumption_industrial'],
# 'l0':
# load_areas['sector_consumption_agricultural']}
# ).elec_demand
# hack correct industrial profile into dataframe
# print(load_areas['sector_consumption_industrial'])
# if load_areas['sector_consumption_industrial'] == 0:
# load_areas['sector_consumption_industrial'] = 0.1
# Add the slp for the industrial group
ilp = profiles.IndustrialLoadProfile(e_slp.date_time_index,
holidays=holidays)
# Beginning and end of workday, weekdays and weekend days, and scaling factors
# by default
elec_demand['i0'] = ilp.simple_profile(load_areas['i0'],
am=settime(6, 0, 0),
pm=settime(22, 0, 0),
profile_factors={
'week': {
'day': 0.8,
'night': 0.6
},
'weekend': {
'day': 0.6,
'night': 0.6
}
})
# Resample 15-minute values to hourly values and sum across sectors
elec_demand = elec_demand.resample('H').mean().fillna(0).max().to_frame().T
# demand_industry = eb.IndustrialLoadProfile('simple_industrial_profile',
# **{'annual_demand': load_areas['sector_consumption_industrial'],
# 'year': year,
# 'am': settime(6, 0, 0),
# 'pm': settime(22, 0, 0),
# 'profile_factors':
# {'week': {'day': 0.8, 'night': 0.6},
# 'weekend': {'day': 0.6, 'night': 0.6}}
# })
# ind_demand = demand_industry.profile
# elec_demand['i0'] = ind_demand
peak_load = elec_demand.max(axis=0)
return peak_load
# empty table or create
try:
orm_peak_load.__table__.create(conn)
except:
session.query(orm_peak_load).delete()
session.commit()
# Use above function `add_sectoral_peak_load` via apply
# elec_demand = load_areas.fillna(0).apply(
# add_sectoral_peak_load, axis=1, args=())
# read standard load profiles
e_slp = bdew.ElecSlp(year, holidays=holidays)
# Add the slp for the industrial group
ilp = profiles.IndustrialLoadProfile(e_slp.date_time_index,
holidays=holidays)
# counter
ctr = 0
# iterate over substation retrieving sectoral demand at each of it
for it, row in load_areas.iterrows():
row = row.fillna(0)
# multiply given annual demand with timeseries
elec_demand = e_slp.get_profile(row.to_dict())
# Beginning and end of workday, weekdays and weekend days, and scaling factors
# by default
elec_demand['i0'] = ilp.simple_profile(row['i0'],
am=settime(6, 0, 0),
def power_example(ann_el_demand_per_sector=None, testmode=False):
if ann_el_demand_per_sector is None:
ann_el_demand_per_sector = {
'g0': 3000,
'h0': 3000,
'i0': 3000,
'i1': 5000,
'i2': 6000,
'g6': 5000
}
year = 2010
# read standard load profiles
e_slp = bdew.ElecSlp(year, holidays=holidays)
# multiply given annual demand with timeseries
elec_demand = e_slp.get_profile(ann_el_demand_per_sector,
dyn_function_h0=False)
# Add the slp for the industrial group
ilp = profiles.IndustrialLoadProfile(e_slp.date_time_index,
holidays=holidays)
# Beginning and end of workday, weekdays and weekend days, and scaling
# factors by default
if 'i0' in ann_el_demand_per_sector:
elec_demand['i0'] = ilp.simple_profile(ann_el_demand_per_sector['i0'])
# Set beginning of workday to 9 am
if 'i1' in ann_el_demand_per_sector:
elec_demand['i1'] = ilp.simple_profile(ann_el_demand_per_sector['i1'],
am=settime(9, 0, 0))
# Change scaling factors
if 'i2' in ann_el_demand_per_sector:
elec_demand['i2'] = ilp.simple_profile(ann_el_demand_per_sector['i2'],
profile_factors={
'week': {
'day': 1.0,
'night': 0.8
},
'weekend': {
'day': 0.8,
'night': 0.6
}
})
if not testmode:
print(
"Be aware that the values in the DataFrame are 15 minute values" +
"with a power unit. If you sum up a table with 15min values" +
"the result will be of the unit 'kW15minutes'.")
print(elec_demand.sum())
print("You will have to divide the result by 4 to get kWh.")
print(elec_demand.sum() / 4)
print("Or resample the DataFrame to hourly values using the mean() "
"method.")
# Resample 15-minute values to hourly values.
elec_demand = elec_demand.resample('H').mean()
print(elec_demand.sum())
if plt is not None:
# Plot demand
ax = elec_demand.plot()
ax.set_xlabel("Date")
ax.set_ylabel("Power demand")
plt.show()
return elec_demand
def demand_per_mv_grid_district():
year = 2011
schema = orm_demand.__table_args__['schema']
target_table = orm_demand.__tablename__
db_group = 'oeuser'
columns_names = {
'h0': 'residential',
'g0': 'retail',
'i0': 'industrial',
'l0': 'agricultural'
}
inv_columns_names = {v: k for k, v in columns_names.items()}
# The following dictionary is create by "workalendar"
# pip3 install workalendar
cal = Germany()
holidays = dict(cal.holidays(2011))
# retrieve sectoral demand from oedb
# get database connection
conn = io.oedb_session(section='oedb')
Session = sessionmaker(bind=conn)
session = Session()
query_demand = session.query(orm_loads.otg_id,
func.sum(orm_loads.sector_consumption_residential).\
label('residential'),
func.sum(orm_loads.sector_consumption_retail).label('retail'),
func.sum(orm_loads.sector_consumption_industrial).\
label('industrial'),
func.sum(orm_loads.sector_consumption_agricultural).\
label('agricultural')).\
group_by(orm_loads.otg_id)
annual_demand_df = pd.read_sql_query(query_demand.statement,
session.bind,
index_col='otg_id').fillna(0)
annual_demand_df = annual_demand_df.loc[~pd.isnull(annual_demand_df.index)]
write_scenario_log(conn=conn,
version='v0.4.5',
project='eGoDP',
io='input',
schema='model_draft',
table=orm_loads.__tablename__,
script='ego_dp_powerflow_griddistrict_demand.py',
entries=len(annual_demand_df))
large_scale_industrial = pd.read_sql_table(
'ego_demand_hv_largescaleconsumer',
conn,
schema,
index_col='polygon_id')
write_scenario_log(conn=conn,
version='v0.4.5',
project='eGoDP',
io='input',
schema='model_draft',
table='ego_demand_hv_largescaleconsumer',
script='ego_dp_powerflow_griddistrict_demand.py',
entries=len(large_scale_industrial))
# add extra industrial demand ontop of MV industrial demand
annual_demand_df = pd.concat([
annual_demand_df,
large_scale_industrial.groupby(by='otg_id').sum()['consumption']
],
axis=1)
annual_demand_df['industrial'] = annual_demand_df[[
'industrial', 'consumption'
]].sum(axis=1)
annual_demand_df.drop('consumption', axis=1, inplace=True)
# rename columns according to demandlib definitions
annual_demand_df.rename(columns=inv_columns_names, inplace=True)
# empty table or create
try:
orm_demand.__table__.create(conn)
except:
session.query(orm_demand).delete()
session.commit()
# iterate over substation retrieving sectoral demand at each of it
for it, row in annual_demand_df.iterrows():
# read standard load profiles
e_slp = bdew.ElecSlp(year, holidays=holidays)
# multiply given annual demand with timeseries
elec_demand = e_slp.get_profile(row.to_dict())
# Add the slp for the industrial group
ilp = profiles.IndustrialLoadProfile(e_slp.date_time_index,
holidays=holidays)
# Beginning and end of workday, weekdays and weekend days, and scaling factors
# by default
elec_demand['i0'] = ilp.simple_profile(row['i0'],
am=settime(6, 0, 0),
pm=settime(22, 0, 0),
profile_factors={
'week': {
'day': 0.8,
'night': 0.6
},
'weekend': {
'day': 0.6,
'night': 0.6
}
})
# Resample 15-minute values to hourly values and sum across sectors
elec_demand = elec_demand.resample('H').mean().sum(axis=1)
# Convert from GW to MW
active_power = elec_demand * 1e3
# derive reactive power from active power
reactive_power = ((active_power / 0.95)**2 -
active_power**2).apply(sqrt)
# Write to database
demand2db = orm_demand(id=it,
p_set=active_power.tolist(),
q_set=reactive_power.tolist())
session.add(demand2db)
session.commit()
# grant access to db_group
db.grant_db_access(conn, schema, target_table, db_group)
# change owner of table to db_group
db.change_owner_to(conn, schema, target_table, db_group)
# # add primary key constraint on id column
# db.add_primary_key(conn, schema, target_table, 'id')
# create metadata json str
json_str = metadata.create_metadata_json(
'Load time series at transition points', '', '2011',
time.strftime("%d.%m.%Y"),
'Open Energy Database, schema: {0}, table: {1}'.format(
schema, target_table), 'Germany',
'Active and reactive power demand time series per transition point',
[{
'Name': 'id',
'Description': 'Unique identifier',
'Unit': '-'
}, {
'Name': 'active_power',
'Description': 'Active power demand',
'Unit': 'MW'
}, {
'Name': 'reactive_power',
'Description': 'Reactive power demand',
'Unit': 'MW'
}], {
'Name': 'Guido Pleßmann',
'Mail': '*****@*****.**',
'Date': time.strftime("%d.%m.%Y"),
'Comment': 'Initial creation of dataset'
}, 'Be aware of applicability. Data bases on synthetic load profiles',
'', '')
metadata.submit_comment(conn, json_str, schema, target_table)
write_scenario_log(conn=conn,
version='v0.4.5',
project='eGoDP',
io='output',
schema=schema,
table=target_table,
script='ego_dp_powerflow_griddistrict_demand.py',
entries=len(annual_demand_df))
conn.close()
def heating_systems(esystem, dfull, add_elec, p):
power_plants = prepare_data.chp_berlin(p)
time_index = esystem.time_idx
temperature_path = '/home/uwe/rli-lokal/git_home/demandlib/examples'
temperature_file = temperature_path + '/example_data.csv'
temperature = pd.read_csv(temperature_file)['temperature']
sli = pd.Series(list(temperature.loc[:23]), index=list(range(8760, 8784)))
temperature = temperature.append(sli)
temperature = temperature.iloc[0:len(time_index)]
heatbus = dict()
hd = dict()
auxiliary_energy = 0
print(dfull)
for h in dfull.keys():
hd.setdefault(h, 0)
lsink = 'demand_{0}'.format(h)
lbus = 'bus_{0}'.format(h)
ltransf = '{0}'.format(h)
lres_bus = 'bus_{0}'.format(p.heating2resource[h])
for b in dfull[h].keys():
if b.upper() in p.bdew_types:
bc = 0
if b.upper() in ['EFH', 'MFH']:
bc = 1
hd[h] += bdew.HeatBuilding(time_index,
temperature=temperature,
shlp_type=b,
building_class=bc,
wind_class=1,
annual_heat_demand=dfull[h][b],
name=h).get_bdew_profile()
if b.upper() in ['EFH', 'MFH']:
print(h, 'in')
auxiliary_energy += bdew.HeatBuilding(
time_index,
temperature=temperature,
shlp_type=b,
building_class=bc,
wind_class=1,
annual_heat_demand=add_elec[h][b],
name=h).get_bdew_profile()
elif b in [
'i',
]:
hd[h] += pprofiles.IndustrialLoadProfile(
time_index).simple_profile(annual_demand=dfull[h][b])
else:
logging.error('Demandlib typ "{0}" not found.'.format(b))
heatbus[h] = solph.Bus(label=lbus)
solph.Sink(label=lsink,
inputs={
heatbus[h]:
solph.Flow(actual_value=hd[h].div(hd[h].max()),
fixed=True,
nominal_value=hd[h].max())
})
if 'district' not in h:
if lres_bus not in esystem.groups:
solph.Bus(label=lres_bus)
solph.LinearTransformer(
label=ltransf,
inputs={esystem.groups[lres_bus]: solph.Flow()},
outputs={
heatbus[h]:
solph.Flow(nominal_value=hd[h].max(), variable_costs=0)
},
conversion_factors={heatbus[h]: 1})
else:
for pp in power_plants[h].index:
lres_bus = 'bus_' + pp
if lres_bus not in esystem.groups:
solph.Bus(label=lres_bus)
solph.LinearTransformer(
label='pp_chp_{0}_{1}'.format(h, pp),
inputs={esystem.groups[lres_bus]: solph.Flow()},
outputs={
esystem.groups['bus_el']:
solph.Flow(
nominal_value=power_plants[h]['power_el'][pp]),
heatbus[h]:
solph.Flow(
nominal_value=power_plants[h]['power_th'][pp])
},
conversion_factors={
esystem.groups['bus_el']: 0.3,
heatbus[h]: 0.4
})
from matplotlib import pyplot as plt
hd_df = pd.DataFrame(hd)
print(hd_df.sum().sum())
print('z_max:', hd_df['district_z'].max())
print('dz_max:', hd_df['district_dz'].max())
print('z_sum:', hd_df['district_z'].sum())
print('dz_sum:', hd_df['district_dz'].sum())
hd_df.plot(colormap='Spectral')
hd_df.to_csv('/home/uwe/hd.csv')
plt.show()
solph.Sink(label='auxiliary_energy',
inputs={
esystem.groups['bus_el']:
solph.Flow(actual_value=auxiliary_energy.div(
auxiliary_energy.max()),
fixed=True,
nominal_value=auxiliary_energy.max())
})
# Create sinks
# Get normalise demand and maximum value of electricity usage
electricity_usage = electricity.DemandElec(time_index)
normalised_demand, max_demand = electricity_usage.solph_sink(
resample='H', reduce=auxiliary_energy)
sum_demand = normalised_demand.sum() * max_demand
print("delec:", "{:.2E}".format(sum_demand))
solph.Sink(label='elec_demand',
inputs={
esystem.groups['bus_el']:
solph.Flow(actual_value=normalised_demand,
fixed=True,
nominal_value=max_demand)
})
def get_open_ego_slp_profile_by_region(
region,
year,
name,
annual_demand=None,
filename=None,
dynamic_H0=True,
):
"""
Create standardised load profiles (slp) for each region.
Parameters
----------
region : geopandas.geoDataFrame
Regions set.
year : int
Year.
name : str
Name of the region set.
annual_demand : float
Annual demand for all regions.
filename : str (optional)
Filename of the output file.
dynamic_H0 : bool (optional)
Use the dynamic function of the H0. If you doubt, "True" might be the
tight choice (default: True)
Returns
-------
"""
ego_demand = openego.get_ego_demand_by_region(region,
name,
sectors=True,
dump=True)
# Add holidays
cal = Germany()
holidays = dict(cal.holidays(year))
# Drop geometry column and group by region
ego_demand.drop("geometry", inplace=True, axis=1)
ego_demand_grouped = ego_demand.groupby(name).sum()
if filename is None:
path = cfg.get("paths", "demand")
filename = os.path.join(path,
"open_ego_slp_profile_{0}.csv").format(name)
if not os.path.isfile(filename):
regions = ego_demand_grouped.index
else:
regions = []
# Create standardised load profiles (slp)
fs_profile = pd.DataFrame()
for region in regions:
logging.info("Create SLP for {0}".format(region))
annual_demand_type = ego_demand_grouped.loc[region]
annual_electrical_demand_per_sector = {
"g0":
annual_demand_type.sector_consumption_retail,
"h0":
annual_demand_type.sector_consumption_residential,
"l0":
annual_demand_type.sector_consumption_agricultural,
"i0":
annual_demand_type.sector_consumption_industrial +
annual_demand_type.sector_consumption_large_consumers,
}
e_slp = bdew.ElecSlp(year, holidays=holidays)
elec_demand = e_slp.get_profile(annual_electrical_demand_per_sector,
dyn_function_h0=dynamic_H0)
# Add the slp for the industrial group
ilp = particular_profiles.IndustrialLoadProfile(e_slp.date_time_index,
holidays=holidays)
elec_demand["i0"] = ilp.simple_profile(
annual_electrical_demand_per_sector["i0"])
elec_demand = elec_demand.resample("H").mean()
elec_demand.columns = pd.MultiIndex.from_product([[region],
elec_demand.columns])
fs_profile = pd.concat([fs_profile, elec_demand], axis=1)
if not os.path.isfile(filename):
fs_profile.set_index(fs_profile.index -
pd.DateOffset(hours=1)).to_csv(filename)
df = pd.read_csv(
filename,
index_col=[0],
header=[0, 1],
parse_dates=True,
date_parser=lambda col: pd.to_datetime(col, utc=True),
).tz_convert("Europe/Berlin")
if annual_demand is None:
return df
else:
return df.mul(annual_demand / df.sum().sum())
