def _init_price_update(self, fit_to_limit, energy_rate_increase_per_update,
update_interval, use_market_maker_rate,
initial_buying_rate, final_buying_rate):
# Instantiate instance variables that should not be shared with child classes
self.use_market_maker_rate = use_market_maker_rate
self.fit_to_limit = fit_to_limit
LoadValidator.validate_rate(
fit_to_limit=fit_to_limit,
energy_rate_increase_per_update=energy_rate_increase_per_update)
if update_interval is None:
update_interval = \
duration(minutes=ConstSettings.GeneralSettings.DEFAULT_UPDATE_INTERVAL)
if isinstance(update_interval, int):
update_interval = duration(minutes=update_interval)
BidEnabledStrategy.__init__(self)
self.bid_update = \
TemplateStrategyBidUpdater(
initial_rate=initial_buying_rate,
final_rate=final_buying_rate,
fit_to_limit=fit_to_limit,
energy_rate_change_per_update=energy_rate_increase_per_update,
update_interval=update_interval, rate_limit_object=min)
def _init_price_update(self, fit_to_limit, energy_rate_increase_per_update, update_interval,
use_market_maker_rate, initial_buying_rate, final_buying_rate):
validate_load_device_price(fit_to_limit=fit_to_limit,
energy_rate_increase_per_update=energy_rate_increase_per_update)
if update_interval is None:
update_interval = \
duration(minutes=ConstSettings.GeneralSettings.DEFAULT_UPDATE_INTERVAL)
self.use_market_maker_rate = use_market_maker_rate
if isinstance(update_interval, int):
update_interval = duration(minutes=update_interval)
BidEnabledStrategy.__init__(self)
self.bid_update = \
UpdateFrequencyMixin(initial_rate=initial_buying_rate,
final_rate=final_buying_rate,
fit_to_limit=fit_to_limit,
energy_rate_change_per_update=energy_rate_increase_per_update,
update_interval=update_interval, rate_limit_object=min)
self.fit_to_limit = fit_to_limit
def __init__(
self,
avg_power_W,
hrs_per_day=None,
hrs_of_day=None,
fit_to_limit=True,
energy_rate_increase_per_update=1,
update_interval=duration(
minutes=ConstSettings.GeneralSettings.DEFAULT_UPDATE_INTERVAL),
initial_buying_rate: Union[
float, dict,
str] = ConstSettings.LoadSettings.INITIAL_BUYING_RATE,
final_buying_rate: Union[
float, dict,
str] = ConstSettings.LoadSettings.FINAL_BUYING_RATE,
balancing_energy_ratio: tuple = (
ConstSettings.BalancingSettings.OFFER_DEMAND_RATIO,
ConstSettings.BalancingSettings.OFFER_SUPPLY_RATIO),
use_market_maker_rate: bool = False):
"""
Constructor of LoadHoursStrategy
:param avg_power_W: Power rating of load device
:param hrs_per_day: Daily energy usage
:param hrs_of_day: hours of day energy is needed
:param fit_to_limit: if set to True, it will make a linear curve
following following initial_buying_rate & final_buying_rate
:param energy_rate_increase_per_update: Slope of Load bids change per update
:param update_interval: Interval after which Load will update its offer
:param initial_buying_rate: Starting point of load's preferred buying rate
:param final_buying_rate: Ending point of load's preferred buying rate
:param use_market_maker_rate: If set to True, Load would track its final buying rate
as per utility's trading rate
"""
# If use_market_maker_rate is true, overwrite final_buying_rate to market maker rate
if use_market_maker_rate:
final_buying_rate = GlobalConfig.market_maker_rate
if isinstance(update_interval, int):
update_interval = duration(minutes=update_interval)
BidEnabledStrategy.__init__(self)
self.bid_update = \
UpdateFrequencyMixin(initial_rate=initial_buying_rate,
final_rate=final_buying_rate,
fit_to_limit=fit_to_limit,
energy_rate_change_per_update=energy_rate_increase_per_update,
update_interval=update_interval, rate_limit_object=min)
try:
validate_load_device(avg_power_W=avg_power_W,
hrs_per_day=hrs_per_day,
hrs_of_day=hrs_of_day)
except D3ADeviceException as e:
raise D3ADeviceException(str(e))
for time_slot in generate_market_slot_list():
rate_change = self.bid_update.energy_rate_change_per_update[
time_slot]
try:
validate_load_device(
initial_buying_rate=self.bid_update.
initial_rate[time_slot],
final_buying_rate=self.bid_update.final_rate[time_slot],
energy_rate_increase_per_update=rate_change)
except D3ADeviceException as e:
raise D3ADeviceException(str(e))
self.state = LoadState()
self.avg_power_W = avg_power_W
# consolidated_cycle is KWh energy consumed for the entire year
self.daily_energy_required = None
# Energy consumed during the day ideally should not exceed daily_energy_required
self.energy_per_slot_Wh = None
self.energy_requirement_Wh = {} # type: Dict[Time, float]
self.hrs_per_day = {} # type: Dict[int, int]
self.assign_hours_of_per_day(hrs_of_day, hrs_per_day)
self.balancing_energy_ratio = BalancingRatio(*balancing_energy_ratio)
def base():
base = BidEnabledStrategy()
base.owner = FakeOwner()
base.area = FakeArea()
return base
def __init__(
self,
initial_soc: float = StorageSettings.MIN_ALLOWED_SOC,
min_allowed_soc=StorageSettings.MIN_ALLOWED_SOC,
battery_capacity_kWh: float = StorageSettings.CAPACITY,
max_abs_battery_power_kW: float = StorageSettings.MAX_ABS_POWER,
cap_price_strategy: bool = False,
initial_selling_rate: Union[
float, dict] = StorageSettings.SELLING_RATE_RANGE.initial,
final_selling_rate: Union[
float, dict] = StorageSettings.SELLING_RATE_RANGE.final,
initial_buying_rate: Union[
float, dict] = StorageSettings.BUYING_RATE_RANGE.initial,
final_buying_rate: Union[
float, dict] = StorageSettings.BUYING_RATE_RANGE.final,
loss_per_hour=StorageSettings.LOSS_PER_HOUR,
loss_function=StorageSettings.LOSS_FUNCTION,
fit_to_limit=True,
energy_rate_increase_per_update=None,
energy_rate_decrease_per_update=None,
update_interval=None,
initial_energy_origin: Enum = ESSEnergyOrigin.EXTERNAL,
balancing_energy_ratio: tuple = (
BalancingSettings.OFFER_DEMAND_RATIO,
BalancingSettings.OFFER_SUPPLY_RATIO)):
if update_interval is None:
update_interval = \
duration(minutes=ConstSettings.GeneralSettings.DEFAULT_UPDATE_INTERVAL)
if min_allowed_soc is None:
min_allowed_soc = StorageSettings.MIN_ALLOWED_SOC
self.initial_soc = initial_soc
validate_storage_device(
initial_soc=initial_soc,
min_allowed_soc=min_allowed_soc,
battery_capacity_kWh=battery_capacity_kWh,
max_abs_battery_power_kW=max_abs_battery_power_kW,
loss_per_hour=loss_per_hour,
loss_function=loss_function,
fit_to_limit=fit_to_limit,
energy_rate_increase_per_update=energy_rate_increase_per_update,
energy_rate_decrease_per_update=energy_rate_decrease_per_update)
if isinstance(update_interval, int):
update_interval = duration(minutes=update_interval)
BidEnabledStrategy.__init__(self)
self.offer_update = \
UpdateFrequencyMixin(initial_rate=initial_selling_rate,
final_rate=final_selling_rate,
fit_to_limit=fit_to_limit,
energy_rate_change_per_update=energy_rate_decrease_per_update,
update_interval=update_interval)
for time_slot in generate_market_slot_list():
validate_storage_device(
initial_selling_rate=self.offer_update.initial_rate[time_slot],
final_selling_rate=self.offer_update.final_rate[time_slot])
self.bid_update = \
UpdateFrequencyMixin(
initial_rate=initial_buying_rate,
final_rate=final_buying_rate,
fit_to_limit=fit_to_limit,
energy_rate_change_per_update=energy_rate_increase_per_update,
update_interval=update_interval,
rate_limit_object=min
)
for time_slot in generate_market_slot_list():
validate_storage_device(
initial_buying_rate=self.bid_update.initial_rate[time_slot],
final_buying_rate=self.bid_update.final_rate[time_slot])
self.state = \
StorageState(initial_soc=initial_soc,
initial_energy_origin=initial_energy_origin,
capacity=battery_capacity_kWh,
max_abs_battery_power_kW=max_abs_battery_power_kW,
loss_per_hour=loss_per_hour,
loss_function=loss_function,
min_allowed_soc=min_allowed_soc)
self.cap_price_strategy = cap_price_strategy
self.balancing_energy_ratio = BalancingRatio(*balancing_energy_ratio)
def test_can_bid_be_posted(base):
base = BidEnabledStrategy()
base.owner = FakeOwner()
base.area = FakeArea()
market = FakeMarket(raises=True)
base.area._market = market
base.post_bid(market, 1, 23)
base.post_bid(market, 1, 27)
base.post_bid(market, 1, 10)
assert base.can_bid_be_posted(9.999, 70, market) is True
assert base.can_bid_be_posted(10.0, 70, market) is True
assert base.can_bid_be_posted(10.001, 70, market) is False