class TestPricingModel(unittest.TestCase):
def setUp(self):
self.sup = Supervisor()
batt = Battery("batt_1",
price_logic="hourly_preference",
capacity=5000.0,
max_charge_rate=2000.0,
max_discharge_rate=2000.0)
self.gc1 = GridController(device_id="gc_1",
supervisor=self.sup,
battery=batt,
price_logic='weighted_average')
self.gc2 = GridController(device_id="gc_2",
supervisor=self.sup,
battery=batt,
price_logic='weighted_average')
self.sup.register_device(self.gc1)
self.sup.register_device(self.gc2)
self.gc1._connected_devices["gc_2"] = self.gc2
self.gc2._connected_devices["gc_1"] = self.gc1
@unittest.skip("Exception: Device ID not found (gc_2)")
def test_weighted_price(self):
self.gc1.send_power_message("gc_2", -200) # sending it out
self.gc1.send_price_message("gc_2", 0.2)
self.gc2.process_events()
self.gc2.update_time(3000)
self.gc2.modulate_price()
print("current interval prices: {}".format(", ".join(
map(str, self.gc2._price_logic.get_interval_prices()))))
def setUp(self):
self.sup = Supervisor()
self.gc1 = GridController("gc1", self.sup)
self.gc2 = GridController("gc2", self.sup, [self.gc1])
self.sup.register_device(self.gc1)
self.sup.register_device(self.gc2)
self.gc1.register_device(self.gc2, self.gc2.get_id(), 1)
def setUp(self):
self.sup = Supervisor()
self.gc1 = GridController("gc1", self.sup)
self.gc2 = GridController("gc2", self.sup)
self.sup.register_device(self.gc1)
self.sup.register_device(self.gc2)
self.gc1._connected_devices["gc2"] = self.gc2
class TestDeviceRegister(unittest.TestCase):
def setUp(self):
self.sup = Supervisor()
self.gc1 = GridController("gc1", self.sup)
self.gc2 = GridController("gc2", self.sup, [self.gc1])
self.sup.register_device(self.gc1)
self.sup.register_device(self.gc2)
self.gc1.register_device(self.gc2, self.gc2.get_id(), 1)
def test_connections(self):
self.assertEqual(self.gc1._connected_devices["gc2"], self.gc2)
self.assertEqual(self.gc2._connected_devices["gc1"], self.gc1)
class TestGCMessaging(unittest.TestCase):
def setUp(self):
self.sup = Supervisor()
self.gc1 = GridController("gc1", self.sup)
self.gc2 = GridController("gc2", self.sup)
self.sup.register_device(self.gc1)
self.sup.register_device(self.gc2)
self.gc1._connected_devices["gc2"] = self.gc2
def test_GC_register_message(self):
self.gc1.send_register_message("gc2", 1)
while self.sup.has_next_event():
self.sup.occur_next_event()
self.assertEqual(self.gc2._connected_devices["gc1"], self.gc1)
def test_GC_power_message_unfulfilled(self):
# no battery. Can't provide, lists every as request.
self.gc2._connected_devices["gc1"] = self.gc1
self.gc1.send_power_message("gc2", 10)
while self.sup.has_next_event():
self.sup.occur_next_event()
self.assertEqual(self.gc2._requested["gc1"], -10)
def test_balance_power_below_max_battery_rate(self):
self.gc2._connected_devices["gc1"] = self.gc1
batt1 = Battery(None) # no price logic
batt2 = Battery(None) # no price logic.
self.gc1._battery = batt1
self.gc2._battery = batt2
self.gc1.send_power_message("gc2", 70)
while self.sup.has_next_event():
self.sup.occur_next_event()
self.assertEqual(self.gc2._loads["gc1"], -70)
self.assertEqual(self.gc2._battery.get_load(), -70)
def test_balance_power_above_max_battery_rate(self):
self.gc1.send_register_message("gc2", 1)
batt1 = Battery(None) # no price logic
batt2 = Battery(None) # no price logic.
self.gc1._battery = batt1
self.gc2._battery = batt2
self.gc1.send_power_message("gc2", 110)
while self.sup.has_next_event():
self.sup.occur_next_event()
self.assertEqual(self.gc2._loads["gc1"],
-100) # 100 is default max charge rate.
self.assertEqual(self.gc2._battery.get_load(), -100)
self.assertEqual(self.gc2._requested["gc1"],
-10) # 10 remaining to be sold to ya.
"""
def make_grid_controllers(self, config, runtime, override_args):
connections = [
] # a list of tuples of (gc, [connections]) to initialize later once all devices are set.
if 'grid_controllers' not in config['devices']:
return connections
for gc in config['devices']['grid_controllers']:
gc_id = gc['device_id']
price_logic = gc['price_logic']
price_logic = override_args.get(
'devices.{}.price_logic'.format(gc_id), price_logic)
msg_latency = gc.get('message_latency',
self.DEFAULT_MESSAGE_LATENCY)
msg_latency = int(
override_args.get('devices.{}.message_latency'.format(gc_id),
msg_latency))
min_alloc_response_threshold = gc.get('threshold_alloc', 1.0)
min_alloc_response_threshold = float(
override_args.get('devices.{}.threshold_alloc'.format(gc_id),
min_alloc_response_threshold))
price_announce_threshold = gc.get('price_announce_threshold', .01)
price_announce_threshold = float(
override_args.get(
'devices.{}.price_announce_threshold'.format(gc_id),
price_announce_threshold))
schedule = gc.get('schedule', None)
multiday = schedule.get('multiday',
self.DEFAULT_MULTIDAY) if schedule else 0
schedule_items = schedule.get('items', None) if schedule else None
connected_devices = gc.get('connected_devices', None)
if connected_devices:
connections.append((gc_id, connected_devices))
batt_info = gc.get('battery', None)
if batt_info:
battery = self.make_battery(battery_info=batt_info,
gc_id=gc_id,
override_args=override_args)
else:
battery = None
new_gc = GridController(
device_id=gc_id,
supervisor=self.supervisor,
battery=battery,
msg_latency=msg_latency,
price_logic=price_logic,
schedule=schedule_items,
min_alloc_response_threshold=min_alloc_response_threshold,
price_announce_threshold=price_announce_threshold,
total_runtime=runtime)
# make a new grid controller and register it with the supervisor
self.supervisor.register_device(new_gc)
return connections
def setUp(self):
self.sup = Supervisor()
batt = Battery("batt_1",
price_logic="hourly_preference",
capacity=5000.0,
max_charge_rate=2000.0,
max_discharge_rate=2000.0)
self.gc1 = GridController(device_id="gc_1",
supervisor=self.sup,
battery=batt,
price_logic='weighted_average')
self.gc2 = GridController(device_id="gc_2",
supervisor=self.sup,
battery=batt,
price_logic='weighted_average')
self.sup.register_device(self.gc1)
self.sup.register_device(self.gc2)
self.gc1._connected_devices["gc_2"] = self.gc2
self.gc2._connected_devices["gc_1"] = self.gc1
def test_simple_interation_with_grid_controller(self):
supervisor = Supervisor()
notebook_personal_computer_device_id = "notebook_personal_computer_1"
max_operating_power = 12 * 5
notebook_personal_computer = NotebookPersonalComputer(notebook_personal_computer_device_id, supervisor, max_operating_power = max_operating_power)
battery_id = "battery_1"
battery_price_logic = 'moving_average' # According to the constructor of Battery class, 'hourly_preference' or 'moving_average'
capacity = 1200.0 # in [Wh] though it is defined in [Ah] in related science and data sheet
max_charge_rate = 120 # in [W], assuming it's 12[V] battery with 100 [Ah] capacity, rouchly lasting 10 hours, 10[A] maximum.
# Note: Charge rate varies depending on state of charge.
max_discharge_rate = 120 # in [W], same value as above, simplifying for now.
battery = Battery(battery_id, battery_price_logic, capacity, max_charge_rate, max_discharge_rate)
grid_controller_device_id = "grid_controller_1"
grid_controller_price_logic = 'marginal_price' # According to the constructor of GridController,
# 'weighted_average', 'marginal_price', 'marginal_price_b', or 'static_price'
grid_controller = GridController(grid_controller_device_id, supervisor, battery = battery, price_logic = grid_controller_price_logic,
connected_devices = [notebook_personal_computer])
supervisor.register_device(notebook_personal_computer)
supervisor.register_device(grid_controller)
grid_controller.send_register_message("notebook_personal_computer_1", 1)
# grid_controller.build_device_list()
grid_controller.send_power_message("notebook_personal_computer_1", 10)
class TestEventModel(unittest.TestCase):
def setUp(self):
self.sup = Supervisor()
self.gc1 = GridController("gc1", self.sup)
self.gc2 = GridController("gc2", self.sup)
self.sup.register_device(self.gc1)
self.sup.register_device(self.gc2)
def test_event_queue(self):
pq = PriorityQueue()
pq.add(Event(self.gc1.set_power_in, 20), 1)
pq.add(Event(self.gc1.set_power_in, 20),
2) # to make sure they are treated as distinct entities.
event1, time_stamp = pq.pop()
event1.run_event()
self.assertEqual(self.gc1._power_in, 20)
event2, time_stamp = pq.pop()
event2.run_event()
self.assertEqual(self.gc1._power_in, 20)
def test_single_argument_event(self):
self.gc1.add_event(Event(self.gc1.set_power_in, 20), 1)
self.gc1.update_time(1)
self.gc1.process_events()
self.assertEqual(self.gc1._power_in, 20)
def test_multiple_argument_event(self):
self.gc1.add_event(Event(self.gc1.on_allocated, "gc2", 20), 1)
self.gc1.update_time(1)
self.gc1.process_events()
self.assertEqual(self.gc1._allocated["gc2"], 20)
def test_no_argument_event(self):
self.gc1.add_event(Event(self.gc1.add_power_in), 1)
self.gc1.update_time(1)
self.gc1.process_events()
self.assertEqual(self.gc1._power_in, 10)
"""More Tests Here are Highest Priority"""