def _gather_device_statistics(cls, area: Area, subdict: Dict,
flat_result_dict: Dict):
if not hasattr(area.parent, "past_markets") or len(
area.parent.past_markets) == 0:
return None
if area.strategy is not None:
cls._device_price_stats(area, subdict)
cls._device_energy_stats(area, subdict)
if isinstance(area.strategy, PVStrategy):
cls._pv_production_stats(area, subdict)
elif isinstance(area.strategy, StorageStrategy):
cls._soc_stats(area, subdict)
elif isinstance(area.strategy, LoadHoursStrategy):
cls._load_profile_stats(area, subdict)
elif type(area.strategy) == FinitePowerPlant:
market = list(area.parent.past_markets)[-1]
create_or_update_subdict(
subdict, "production_kWh",
{market.time_slot: area.strategy.energy_per_slot_kWh})
cls._calc_min_max_from_sim_dict(subdict, "production_kWh")
flat_result_dict[area.uuid] = subdict.copy()
def _calc_min_max_from_sim_dict(subdict: Dict, key: str):
min_trade_stats_daily = {}
max_trade_stats_daily = {}
indict = subdict[key]
trade_stats_daily = dict(
(k.format(TIME_FORMAT), []) for k, v in indict.items())
for time, value in indict.items():
value = [] if value is None else value
value = [value] if not isinstance(value, list) else value
trade_stats_daily[time.format(TIME_FORMAT)] += value
for time_str, value in trade_stats_daily.items():
min_trade_stats_daily[time_str] = limit_float_precision(min(value)) \
if len(value) > 0 else FILL_VALUE
max_trade_stats_daily[time_str] = limit_float_precision(max(value)) \
if len(value) > 0 else FILL_VALUE
min_trade_stats = dict(
(time, min_trade_stats_daily[time.format(TIME_FORMAT)])
for time in indict.keys())
max_trade_stats = dict(
(time, max_trade_stats_daily[time.format(TIME_FORMAT)])
for time in indict.keys())
create_or_update_subdict(subdict, f"min_{key}", min_trade_stats)
create_or_update_subdict(subdict, f"max_{key}", max_trade_stats)
def _soc_stats(cls, area: Area, subdict: Dict):
key_name = "soc_history_%"
market = list(area.parent.past_markets)[-1]
create_or_update_subdict(subdict, key_name, {
market.time_slot:
area.strategy.state.charge_history[market.time_slot]
})
cls._calc_min_max_from_sim_dict(subdict, key_name)
def calculate_stats_for_device(cls, area, market, subdict):
key_name = "trade_energy_kWh"
traded_energy = 0
for t in market.trades:
if t.seller == area.name:
traded_energy -= t.offer.energy
if t.buyer == area.name:
traded_energy += t.offer.energy
create_or_update_subdict(subdict, key_name,
{market.time_slot: traded_energy})
cls._calc_min_max_from_sim_dict(subdict, key_name)
def _pv_production_stats(cls, area: Area, subdict: Dict):
key_name = "pv_production_kWh"
market = list(area.parent.past_markets)[-1]
create_or_update_subdict(
subdict, key_name, {
market.time_slot:
area.strategy.energy_production_forecast_kWh.get(
market.time_slot, 0)
})
cls._calc_min_max_from_sim_dict(subdict, key_name)
def _load_profile_stats(cls, area: Area, subdict: Dict):
key_name = "load_profile_kWh"
market = list(area.parent.past_markets)[-1]
if market.time_slot in area.strategy.state.desired_energy_Wh:
create_or_update_subdict(
subdict, key_name, {
market.time_slot:
area.strategy.state.desired_energy_Wh.get(
market.time_slot, 0) / 1000.
})
else:
create_or_update_subdict(subdict, key_name, {market.time_slot: 0})
cls._calc_min_max_from_sim_dict(subdict, key_name)
def _device_price_stats(cls, area: Area, subdict: Dict):
key_name = "trade_price_eur"
market = list(area.parent.past_markets)[-1]
trade_price_list = []
for t in market.trades:
if t.seller == area.name or t.buyer == area.name:
trade_price_list.append(t.offer.energy_rate / 100.0)
if trade_price_list:
create_or_update_subdict(subdict, key_name,
{market.time_slot: trade_price_list})
else:
create_or_update_subdict(subdict, key_name,
{market.time_slot: FILL_VALUE})
cls._calc_min_max_from_sim_dict(subdict, key_name)
def calculate_stats_for_device(cls, area_dict, subdict, core_stats,
current_market_slot):
key_name = "trade_energy_kWh"
if core_stats[area_dict['uuid']] == {}:
return
area_core_trades = core_stats[area_dict['uuid']].get('trades', [])
traded_energy = 0
for t in area_core_trades:
if t['seller'] == area_dict['name']:
traded_energy -= t['energy']
if t['buyer'] == area_dict['name']:
traded_energy += t['energy']
create_or_update_subdict(subdict, key_name,
{current_market_slot: traded_energy})
cls._calc_min_max_from_sim_dict(subdict, key_name)
def calculate_stats_for_infinite_bus(cls, area, market, subdict):
sold_key_name = "sold_trade_energy_kWh"
bought_key_name = "bought_trade_energy_kWh"
sold_traded_energy = 0
bought_traded_energy = 0
for t in market.trades:
if t.seller == area.name:
sold_traded_energy += t.offer.energy
if t.buyer == area.name:
bought_traded_energy += t.offer.energy
create_or_update_subdict(subdict, sold_key_name,
{market.time_slot: sold_traded_energy})
cls._calc_min_max_from_sim_dict(subdict, sold_key_name)
create_or_update_subdict(subdict, bought_key_name,
{market.time_slot: bought_traded_energy})
cls._calc_min_max_from_sim_dict(subdict, bought_key_name)
def _device_price_stats(cls, area_dict: Dict, subdict: Dict, core_stats,
current_market_slot):
key_name = "trade_price_eur"
if core_stats[area_dict['uuid']] == {}:
return
area_core_trades = core_stats[area_dict['uuid']].get('trades', [])
trade_price_list = []
for t in area_core_trades:
if t['seller'] == area_dict['name'] or t['buyer'] == area_dict[
'name']:
trade_price_list.append(t['energy_rate'] / 100.0)
if trade_price_list:
create_or_update_subdict(subdict, key_name,
{current_market_slot: trade_price_list})
else:
create_or_update_subdict(subdict, key_name,
{current_market_slot: FILL_VALUE})
cls._calc_min_max_from_sim_dict(subdict, key_name)
def _populate_area_stats(cls,
area_dict: Dict,
subdict: Dict,
core_stats=None,
current_market_slot=None):
key_name = cls._compute_key_name_for_node(area_dict)
if not key_name:
return
if core_stats is None:
core_stats = {}
if core_stats[area_dict['uuid']] == {}:
return
create_or_update_subdict(
subdict, key_name,
{current_market_slot: core_stats[area_dict["uuid"]][key_name]})
cls._calc_min_max_from_sim_dict(subdict, key_name)
def calculate_stats_for_infinite_bus(cls, area_dict, subdict, core_stats,
current_market_slot):
sold_key_name = "sold_trade_energy_kWh"
bought_key_name = "bought_trade_energy_kWh"
sold_traded_energy = 0
bought_traded_energy = 0
if core_stats[area_dict['uuid']] == {}:
return
area_core_trades = core_stats[area_dict['uuid']].get('trades', [])
for t in area_core_trades:
if t['seller'] == area_dict['name']:
sold_traded_energy += t['energy']
if t['buyer'] == area_dict['name']:
bought_traded_energy += t['energy']
create_or_update_subdict(subdict, sold_key_name,
{current_market_slot: sold_traded_energy})
cls._calc_min_max_from_sim_dict(subdict, sold_key_name)
create_or_update_subdict(subdict, bought_key_name,
{current_market_slot: bought_traded_energy})
cls._calc_min_max_from_sim_dict(subdict, bought_key_name)
