Market3

ILCAgent/ilc/criteria_handler.py

@@ -135,7 +135,7 @@ def get_score_order(self, state):
             if state not in cluster.criteria_labels.keys() or state not in cluster.row_average.keys():
                 _log.debug("Criteria - Not configured for current state: {}".format(state))
                 continue
-
+            _log.debug("EVAL: {} - {}".format(evaluations.values(), cluster.criteria_labels[state]))
             input_arr = input_matrix(evaluations, cluster.criteria_labels[state])
             scores = build_score(input_arr, cluster.row_average[state], cluster.priority)
             all_scored.extend(scores)
@@ -154,7 +154,7 @@ def get_device(self, device_name):
     # this passes all data coming in to all device criteria
     # TODO:  rethink this approach.  Is there a better way to create the topic map to pass only data needed
     def ingest_data(self, time_stamp, data):
-        for device in self.devices.itervalues():
+        for device in self.devices.values():
             device.ingest_data(time_stamp, data)
 
 
@@ -235,7 +235,7 @@ def numeric_check(self, value):
         :param value:
         :return:
         """
-        if not isinstance(value, (int, float, long, numbers.Float, numbers.Integer)):
+        if not isinstance(value, (int, float, numbers.Float, numbers.Integer)):
             if isinstance(value, str):
                 try:
                     value = float(value)
@@ -353,7 +353,7 @@ def fixup_dict_args(self, operation_args):
 
         result = {"always": [], "nc": []}
 
-        for key, value in operation_args.iteritems():
+        for key, value in operation_args.items():
             if value != "nc":
                 result["always"].append(key)
             else:
@@ -367,11 +367,11 @@ def build_ingest_map(self, operation_args):
         self.update_points = {}
         self.operation_arg_count = 0
 
-        for arg_type, arg_list in operation_args.iteritems():
+        for arg_type, arg_list in operation_args.items():
             topic_map, topic_set = create_device_topic_map(arg_list, self.device_topic)
             self.device_topic_map.update(topic_map)
             self.device_topics |= topic_set
-            self.update_points[arg_type] = set(topic_map.itervalues())
+            self.update_points[arg_type] = set(topic_map.values())
             self.operation_arg_count += len(topic_map)
 
     def evaluate(self):
@@ -383,7 +383,7 @@ def evaluate(self):
         return value
 
     def ingest_data(self, time_stamp, data):
-        for topic, point in self.device_topic_map.iteritems():
+        for topic, point in self.device_topic_map.items():
             if topic in data:
                 if not self.status or point not in self.update_points.get("nc", set()):
                     value = data[topic]

ILCAgent/ilc/curtailment_handler.py

@@ -125,7 +125,7 @@ def get_devices_status(self, state):
         return all_on_devices
 
     def ingest_data(self, time_stamp, data):
-        for device in self.devices.itervalues():
+        for device in self.devices.values():
             device.ingest_data(time_stamp, data)
 
 
@@ -148,7 +148,7 @@ def __init__(self, logging_topic, parent, device_status_args=[], condition="", d
         self.logging_topic = logging_topic
 
     def ingest_data(self, time_stamp, data):
-        for topic, point in self.device_topic_map.iteritems():
+        for topic, point in self.device_topic_map.items():
             if topic in data:
                 self.current_device_values[point] = data[topic]
                 _log.debug("DEVICE_STATUS: {} - {} current device values: {}".format(topic,
@@ -251,7 +251,7 @@ def __init__(self, device_config, logging_topic, parent, default_device=""):
             self.device_topics |= controls.device_topics
 
     def ingest_data(self, time_stamp, data):
-        for control in self.controls.itervalues():
+        for control in self.controls.values():
             control.ingest_data(time_stamp, data)
 
     def get_control_info(self, device_id, state):
@@ -395,7 +395,7 @@ def check_condition(self):
         return value
 
     def ingest_data(self, time_stamp, data):
-        for topic, point in self.device_topic_map.iteritems():
+        for topic, point in self.device_topic_map.items():
             if topic in data:
                 self.current_device_values[point] = data[topic]
 

ILCAgent/ilc/ilc_agent.py

@@ -654,7 +654,7 @@ def calculate_average_power(self, current_power, current_time):
         power_sort.sort(reverse=True)
         exp_power = 0
 
-        for n in xrange(len(self.bldg_power)):
+        for n in range(len(self.bldg_power)):
             exp_power += power_sort[n][1] * smoothing_constant * (1.0 - smoothing_constant) ** n
 
         exp_power += power_sort[-1][1] * (1.0 - smoothing_constant) ** (len(self.bldg_power))
@@ -763,9 +763,6 @@ def load_message_handler(self, peer, sender, bus, topic, headers, message):
             # TODO: Refactor this code block.  Disparate code paths for simulation and real devices is undesireable
             if self.sim_running:
                 gevent.sleep(0.25)
-                while self.sim_time >= 15:
-                    _log.debug("HOLDING {}".format(self.sim_time))
-                    gevent.sleep(1)
                 self.vip.pubsub.publish("pubsub", "applications/ilc/advance", headers={}, message={})
 
     def check_load(self):
@@ -779,10 +776,10 @@ def check_load(self):
 
         if self.demand_limit is not None:
             if self.avg_power > self.demand_limit + self.demand_threshold:
-                result = "Current load of {} kW exceeds demand limit of {} kW.".format(self.avg_power, self.demand_limit)
+                result = "Current load of {} kW exceeds demand limit of {} kW.".format(self.avg_power, self.demand_limit+self.demand_threshold)
                 self.curtail_load()
-            if self.avg_power < self.demand_limit - self.demand_threshold:
-                result = "Current load of {} kW is below demand limit of {} kW.".format(self.avg_power, self.demand_limit)
+            elif self.avg_power < self.demand_limit - self.demand_threshold:
+                result = "Current load of {} kW is below demand limit of {} kW.".format(self.avg_power, self.demand_limit-self.demand_threshold)
                 self.augment_load()
             else:
                 result = "Current load of {} kW meets demand goal of {} kW.".format(self.avg_power, self.demand_limit)
@@ -952,10 +949,11 @@ def determine_curtail_parms(self, control, device_dict):
                     control_load = 0.0
                     break
                 load_point_values.append((load_arg[0], value))
-                try:
-                    control_load = float(load_equation.subs(load_point_values))
-                except:
-                    _log.debug("Could not convert expression for load estimation: ")
+                #try:
+                _log.debug("LOAD_EQUATION: {} - {} - {}".format(point_to_get, load_equation, load_point_values))
+                control_load = float(load_equation.subs(load_point_values))
+                #except:
+                #    _log.debug("Could not convert expression for load estimation: ")
 
         try:
             revert_value = self.vip.rpc.call(device_actuator, "get_point", control_pt).get(timeout=30)

ILCAgent/ilc/ilc_matrices.py

@@ -67,6 +67,7 @@
 import math
 from volttron.platform.agent import utils
 from collections import defaultdict
+from functools import reduce
 
 utils.setup_logging()
 _log = logging.getLogger(__name__)
@@ -238,7 +239,7 @@ def input_matrix(builder, criteria_labels):
     """
     sum_mat = defaultdict(float)
     inp_mat = {}
-    label_check = builder.values()[-1].keys()
+    label_check = list(list(builder.values())[-1].keys())
     if set(label_check) != set(criteria_labels):
         raise Exception('Input criteria and data criteria do not match.')
     for device_data in builder.values():

ILCAgent/ilc/utils.py

@@ -67,7 +67,7 @@
 
 
 def clean_text(text, rep={" ": ""}):
-    rep = dict((re.escape(k), v) for k, v in rep.iteritems())
+    rep = dict((re.escape(k), v) for k, v in rep.items())
     pattern = re.compile("|".join(rep.keys()))
     new_key = pattern.sub(lambda m: rep[re.escape(m.group(0))], text)
     return new_key

MarketAgents/AHUAgent/ahu/agent.py

@@ -63,7 +63,7 @@
 from volttron.platform.agent.base_market_agent.poly_line import PolyLine
 from volttron.platform.agent.base_market_agent.point import Point
 
-from volttron.pnnl.models.ahuchiller import AHUChiller
+from volttron.pnnl.models import Model
 
 # from pnnl.models.firstorderzone import FirstOrderZone
 
@@ -72,31 +72,43 @@
 __version__ = "0.2"
 
 
-class AHUAgent(Aggregator, AHUChiller):
+# https://stash.pnnl.gov/users/ngoh511/repos/transactivecontrol/raw/MarketAgents/AHUAgent/ahu/agent.py?at=refs%2Fheads%2Fahu_chiller_split
+
+
+class AHUAgent(Aggregator, Model):
     """
-    The SampleElectricMeterAgent serves as a sample of an electric meter that
-    sells electricity for a single building at a fixed price.
+    The AHUAgent participates in 3 markets:
+    1. Electricity Market: Consumer of electricity
+    2. Air Market: Supplier of air
+    3. Chilled Water Market: Consumer of chilled water
     """
 
     def __init__(self, config_path, **kwargs):
         try:
             config = utils.load_config(config_path)
-        except StandardError:
+        except Exception.StandardError:
             config = {}
         model_config = config.get("model_parameters")
         self.agent_name = config.get("agent_name", "ahu")
         Aggregator.__init__(self, config, **kwargs)
-        AHUChiller.__init__(self, model_config, **kwargs)
+        Model.__init__(self, model_config, **kwargs)
+
         self.init_markets()
 
     def translate_aggregate_demand(self, air_demand, index):
         electric_demand_curve = PolyLine()
+        coil_load_demand_curve = PolyLine()
         oat = self.oat_predictions[index] if self.oat_predictions else None
         for point in air_demand.points:
-            electric_demand_curve.add(Point(price=point.y, quantity=self.model.calculate_load(point.x, oat)))
-        _log.debug("{}: electric demand : {}".format(self.agent_name, electric_demand_curve.points))
+            #electric_demand_curve.add(Point(price=point.y, quantity=self.model.calculate_load(point.x, oat)))
+            self.model.input_zone_load(point.x)
+            electric_demand_curve.add(Point(price=point.y, quantity=self.model.calculate_electric_load()))
+            coil_load_demand_curve.add(Point(price=point.y, quantity=self.model.calculate_coil_load(oat)))
+
         # Hard-coding the market names is not ideal.  Need to come up with more robust solution
         self.consumer_demand_curve["electric"][index] = electric_demand_curve
+        self.consumer_demand_curve["chilled_water"][index] = coil_load_demand_curve
+
 
 
 def main():

MarketAgents/AHUAgent/setup.py

@@ -75,7 +75,7 @@
 
 # Find the version number from the main module
 agent_module = agent_package + '.' + MAIN_MODULE
-_temp = __import__(agent_module, globals(), locals(), ['__version__'], -1)
+_temp = __import__(agent_module, globals(), locals(), ['__version__'], 0)
 __version__ = _temp.__version__
 
 # Setup