updated find_converter_techs and get_upstream_techs_for_commodity

Author: elenya-grant

h2integrate/control/control_strategies/system_level/system_level_control_base.py

@@ -658,9 +658,11 @@ def _feedstock_marginal_cost(self, inputs, marginal_cost_data):
 
         return np.full(self.n_timesteps, marginal_cost_scalar)
 
-    def get_upstream_techs_for_commodity(self, tech_name: str, commodity: str):
+    def get_upstream_techs_for_commodity(
+        self, tech_name: str, commodity: str, include_feedstock_sources=True
+    ):
         """Get the name of technologies that are upstream
-        of `tech_name` and that output `commodity`
+        of `tech_name` and that output `commodity`.
 
         Args:
             tech_name (str): name of technology
@@ -669,6 +671,11 @@ def get_upstream_techs_for_commodity(self, tech_name: str, commodity: str):
         Returns:
             list[str]: list of technologies upstream of the tech_name that produce a given commodity
         """
+        if include_feedstock_sources:
+            input_techs = self.input_techs | set(self.feedstock_comps)
+        else:
+            input_techs = self.input_techs.copy()
+
         # figure out where the upstream commodity is coming from
         upstream_components = nx.ancestors(self.technology_graph, tech_name)
         # iterates through a list of 3 length tuples (source, dest, commodity)
@@ -678,36 +685,38 @@ def get_upstream_techs_for_commodity(self, tech_name: str, commodity: str):
             if s[0] in upstream_components and s[2] == commodity
         ]
         # get the technologies that are available to the controller
-        upstream_techs = set(upstream_components_shared_commodity).intersection(
-            set(self.input_techs)
-        )
+        upstream_techs = set(upstream_components_shared_commodity).intersection(set(input_techs))
         return list(upstream_techs)
 
-    def find_converter_techs(self):
+    def find_converter_techs(self, include_feedstock_sources=True):
         """Get the name of the technology that transforms a commodity.
+        Does not include feedstocks.
 
         Returns:
             set(tuple): set of converter technologies formatted as
                 (input_commodity, converter tech name, output_commodity)
         """
+        if include_feedstock_sources:
+            input_techs = self.input_techs | set(self.feedstock_comps)
+        else:
+            input_techs = self.input_techs.copy()
         if not self.multi_commodity_system:
             return
 
         converter_techs = set()
 
         edges = list(self.technology_graph.edges(data="commodity"))
         upstream_converter = None
-        # for tech in self.input_techs:
         for edge in edges:
             tech, dest_tech, cmod = edge
-            if tech in self.input_techs:
+            if tech in input_techs:
                 tech_output_commodity = self._get_commodity_for_tech(tech)
 
                 # NOTE: unsure how this would work for systems with tiered converters
                 # aka - maybe have to eliminate a converter once we've discovered it
                 if upstream_converter is None:
                     upstream_techs = nx.ancestors(self.technology_graph, tech).intersection(
-                        set(self.input_techs)
+                        set(input_techs)
                     )
                 else:
                     idx_upstream_converter = [
@@ -721,7 +730,7 @@ def find_converter_techs(self):
                         if i > min(idx_upstream_converter)
                     ]
                     all_upstream_techs = nx.ancestors(self.technology_graph, tech).intersection(
-                        set(self.input_techs)
+                        set(input_techs)
                     )
                     upstream_techs = all_upstream_techs.intersection(
                         set(downstream_of_previous_converter)