first pass at migration to pyenergyplus

Author: TShapinsky

alfalfa_worker/jobs/modelica/step_run.py

@@ -99,31 +99,6 @@ def update_sim_status(self):
     def get_sim_time(self) -> datetime:
         return datetime(self.start_datetime.year, 1, 1, 0, 0, 0) + timedelta(seconds=float(self.tc.final_time))
 
-    def step(self):
-        # u represents simulation input values
-        u = self.default_input.copy()
-        # look in redis for current writearrays which has an array of controller
-        # input values, the first element in the array with a value
-        # is what should be applied to the simulation according to Project Haystack
-        # convention. If there is no value in the array, then it will not be passed to the
-        # simulation.
-        for point in self.run.input_points:
-            value = point.value
-            if value is not None:
-                u[point.name] = value
-                u[point.name.replace('_u', '_activate')] = 1
-
-        y_output = self.tc.advance(u)
-        self.logger.debug(f"FMU output is {y_output}")
-        self.update_sim_status()
-
-        # get each of the simulation output values and feed to the database
-        for point in self.run.output_points:
-            point.value = y_output[point.name]
-
-        if self.historian_enabled:
-            self.write_outputs_to_influx(y_output)
-
     def write_outputs_to_influx(self, outputs):
         """
         Write output data to influx
@@ -174,8 +149,26 @@ def setup_points(self):
     @message
     def advance(self):
         self.logger.info("advance called")
-        self.step()
+        # u represents simulation input values
+        u = self.default_input.copy()
+        # look in redis for current writearrays which has an array of controller
+        # input values, the first element in the array with a value
+        # is what should be applied to the simulation according to Project Haystack
+        # convention. If there is no value in the array, then it will not be passed to the
+        # simulation.
+        for point in self.run.input_points:
+            value = point.value
+            if value is not None:
+                u[point.name] = value
+                u[point.name.replace('_u', '_activate')] = 1
 
-    @message
-    def stop(self):
-        super().stop()
+        y_output = self.tc.advance(u)
+        self.logger.debug(f"FMU output is {y_output}")
+        self.update_sim_status()
+
+        # get each of the simulation output values and feed to the database
+        for point in self.run.output_points:
+            point.value = y_output[point.name]
+
+        if self.historian_enabled:
+            self.write_outputs_to_influx(y_output)

alfalfa_worker/jobs/openstudio/create_run.py

@@ -44,7 +44,7 @@ def exec(self):
         check_output(['openstudio', str(lib_dir / 'merge_osws.rb'), str(default_workflow_path), str(submitted_osw_path)])
 
         # run workflow
-        check_output(['openstudio', '-I', '/alfalfa/alfalfa_worker/jobs/openstudio/lib/alfalfa-lib-gem/lib', 'run', '-m', '-w', str(submitted_osw_path)])
+        check_output(['openstudio', '-I', '/alfalfa/alfalfa_worker/jobs/openstudio/lib/alfalfa-lib-gem/lib', '--verbose', 'run', '-m', '-w', str(submitted_osw_path)])
 
         self.logger.info('Loading Building Metadata')
         metadata_json_path = submitted_workflow_path / 'reports' / 'alfalfa_metadata_report_metadata.json'
@@ -56,37 +56,13 @@ def exec(self):
         self.logger.info('Generating variables from measure reports')
         self.variables = Variables(self.run)
         self.variables.load_reports()
-        self.variables.generate_points()
-
-        points_json_path = submitted_workflow_path / 'reports/haystack_report_haystack.json'
-        mapping_json_path = submitted_workflow_path / 'reports/haystack_report_mapping.json'
-
-        self.logger.info("Inserting OpenStudio tags")
-        self.insert_os_tags(points_json_path, mapping_json_path)
+        self.variables.write_files(simulation_dir)
 
         self.logger.info("Setting up symlinks")
         idf_src_path = submitted_workflow_path / 'run' / 'in.idf'
         idf_dest_path = simulation_dir / 'sim.idf'
         rel_symlink(idf_src_path, idf_dest_path)
 
-        haystack_src_path = submitted_workflow_path / 'reports' / 'haystack_report_mapping.json'
-        haystack_dest_path = simulation_dir / 'haystack_report_mapping.json'
-        rel_symlink(haystack_src_path, haystack_dest_path)
-
-        haystack_src_path = submitted_workflow_path / 'reports' / 'haystack_report_haystack.json'
-        haystack_dest_path = simulation_dir / 'haystack_report_haystack.json'
-        rel_symlink(haystack_src_path, haystack_dest_path)
-
-        variables_src_path = submitted_workflow_path / 'reports/export_bcvtb_report_variables.cfg'
-        variables_dest_path = simulation_dir / 'variables.cfg'
-        rel_symlink(variables_src_path, variables_dest_path)
-
-        # variables.cfg also needs to be located next to the idf to satisfy EnergyPlus conventions
-        idf_src_dir = idf_src_path.parents[0]
-        variables_ep_path = idf_src_dir / 'variables.cfg'
-        rel_symlink(variables_src_path, variables_ep_path)
-        self.variables.write_files(simulation_dir)
-
         # hack. need to find a more general approach to preserve osw resources that might be needed at simulation time
         for file in self.run.glob(submitted_workflow_path / 'python' / '*'):
             idfdir = idf_src_path.parents[0]
@@ -108,9 +84,6 @@ def exec(self):
     def validate(self) -> None:
         assert (self.dir / 'simulation' / 'sim.idf').exists(), "Idf was not created"
         assert (self.dir / 'simulation' / 'sim.epw').exists(), "Weather file was not created"
-        assert (self.dir / 'simulation' / 'haystack_report_mapping.json').exists(), "haystack report json was not created"
-        assert (self.dir / 'simulation' / 'variables.cfg').exists(), "variables file was not created"
-        assert (self.dir / 'simulation' / 'haystack_report_haystack.json').exists(), "haystack mapping json was not created"
 
     def cleanup(self) -> None:
         super().cleanup()

alfalfa_worker/jobs/openstudio/lib/alfalfa-lib-gem/lib/alfalfa.rb

@@ -1,9 +1,8 @@
 require 'alfalfa_mixin'
 require 'energy_plus_mixin'
-require 'input'
 require 'openstudio_mixin'
-require 'output'
 require 'point'
+require 'alfalfa_component'
 
 # Module which contains all OpenStudio code
 module OpenStudio

alfalfa_worker/jobs/openstudio/lib/alfalfa-lib-gem/lib/alfalfa_component.rb

@@ -0,0 +1,112 @@
+module OpenStudio
+  module Alfalfa
+    class Component
+      attr_reader :parameters
+
+      def initialize(**parameters)
+        @parameters = parameters
+      end
+
+      def is_input_capable
+        raise "is_input_capable not implemented"
+      end
+
+      def is_output_capable
+        raise "is_output_capable not implemented"
+      end
+
+      def to_dict
+        raise "to_dict not implemented"
+      end
+    end
+
+    class GlobalVariable < Component
+      def initialize(var_name)
+        super(var_name: var_name)
+      end
+      def is_input_capable
+        true
+      end
+
+      def is_output_capable
+        true
+      end
+
+      def to_dict
+        return {type: "GlobalVariable", parameters: @parameters}
+      end
+    end
+
+    class InternalVariable < Component
+      def initialize(variable_type, variable_key)
+        super(variable_type: variable_type, variable_key: variable_key)
+      end
+
+      def is_input_capable
+        false
+      end
+
+      def is_output_capable
+        true
+      end
+
+      def to_dict
+        return {type: "InternalVariable", parameters: @parameters}
+      end
+    end
+
+    class OutputVariable < Component
+      def initialize(variable_name, variable_key)
+        super(variable_name: variable_name, variable_key: variable_key)
+      end
+
+      def is_input_capable
+        false
+      end
+
+      def is_output_capable
+        true
+      end
+
+      def to_dict
+        return {type: "OutputVariable", parameters: @parameters}
+      end
+    end
+
+    class Meter < Component
+      def initialize(meter_name)
+        super(meter_name: meter_name)
+      end
+
+      def is_input_capable
+        false
+      end
+
+      def is_output_capable
+        true
+      end
+
+      def to_dict
+        return {type: "Meter", parameters: @parameters}
+      end
+    end
+
+    class Actuator < Component
+      def initialize(component_type, control_type, actuator_key)
+        super(component_type: component_type, control_type: control_type, actuator_key: actuator_key)
+      end
+
+      def is_input_capable
+        true
+      end
+
+      def is_output_capable
+        true
+      end
+
+      def to_dict
+        return {type: "Actuator", parameters: @parameters}
+      end
+    end
+  end
+end